Line data Source code
1 : /* parser/listener/visitor header section */
2 :
3 : // Generated from accparser.g4 by ANTLR 4.7.2
4 :
5 : /* parser precinclude section */
6 :
7 : #include "accparserListener.h"
8 : #include "accparserVisitor.h"
9 :
10 : #include "accparser.h"
11 :
12 :
13 : /* parser postinclude section */
14 : #ifndef _WIN32
15 : #pragma GCC diagnostic ignored "-Wunused-parameter"
16 : #endif
17 :
18 :
19 : using namespace antlrcpp;
20 : using namespace antlr4;
21 :
22 0 : accparser::accparser(TokenStream *input) : Parser(input) {
23 0 : _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
24 0 : }
25 :
26 0 : accparser::~accparser() {
27 0 : delete _interpreter;
28 0 : }
29 :
30 0 : std::string accparser::getGrammarFileName() const {
31 0 : return "accparser.g4";
32 : }
33 :
34 0 : const std::vector<std::string>& accparser::getRuleNames() const {
35 0 : return _ruleNames;
36 : }
37 :
38 0 : dfa::Vocabulary& accparser::getVocabulary() const {
39 0 : return _vocabulary;
40 : }
41 :
42 : /* parser definitions section */
43 :
44 : //----------------- AccContext ------------------------------------------------------------------
45 :
46 0 : accparser::AccContext::AccContext(ParserRuleContext *parent, size_t invokingState)
47 0 : : ParserRuleContext(parent, invokingState) {
48 0 : }
49 :
50 0 : accparser::PrefixContext* accparser::AccContext::prefix() {
51 0 : return getRuleContext<accparser::PrefixContext>(0);
52 : }
53 :
54 0 : tree::TerminalNode* accparser::AccContext::ACC() {
55 0 : return getToken(accparser::ACC, 0);
56 : }
57 :
58 0 : accparser::Openacc_directiveContext* accparser::AccContext::openacc_directive() {
59 0 : return getRuleContext<accparser::Openacc_directiveContext>(0);
60 : }
61 :
62 0 : tree::TerminalNode* accparser::AccContext::EOF() {
63 0 : return getToken(accparser::EOF, 0);
64 : }
65 :
66 :
67 0 : size_t accparser::AccContext::getRuleIndex() const {
68 0 : return accparser::RuleAcc;
69 : }
70 :
71 0 : void accparser::AccContext::enterRule(tree::ParseTreeListener *listener) {
72 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
73 0 : if (parserListener != nullptr)
74 0 : parserListener->enterAcc(this);
75 0 : }
76 :
77 0 : void accparser::AccContext::exitRule(tree::ParseTreeListener *listener) {
78 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
79 0 : if (parserListener != nullptr)
80 0 : parserListener->exitAcc(this);
81 0 : }
82 :
83 :
84 0 : antlrcpp::Any accparser::AccContext::accept(tree::ParseTreeVisitor *visitor) {
85 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
86 0 : return parserVisitor->visitAcc(this);
87 : else
88 0 : return visitor->visitChildren(this);
89 : }
90 :
91 0 : accparser::AccContext* accparser::acc() {
92 0 : AccContext *_localctx = _tracker.createInstance<AccContext>(_ctx, getState());
93 0 : enterRule(_localctx, 0, accparser::RuleAcc);
94 :
95 0 : auto onExit = finally([=] {
96 0 : exitRule();
97 0 : });
98 0 : try {
99 0 : enterOuterAlt(_localctx, 1);
100 0 : setState(306);
101 0 : prefix();
102 0 : setState(307);
103 0 : match(accparser::ACC);
104 0 : setState(308);
105 0 : openacc_directive();
106 0 : setState(309);
107 0 : match(accparser::EOF);
108 :
109 : }
110 0 : catch (RecognitionException &e) {
111 0 : _errHandler->reportError(this, e);
112 0 : _localctx->exception = std::current_exception();
113 0 : _errHandler->recover(this, _localctx->exception);
114 : }
115 :
116 0 : return _localctx;
117 : }
118 :
119 : //----------------- PrefixContext ------------------------------------------------------------------
120 :
121 0 : accparser::PrefixContext::PrefixContext(ParserRuleContext *parent, size_t invokingState)
122 0 : : ParserRuleContext(parent, invokingState) {
123 0 : }
124 :
125 0 : accparser::C_prefixContext* accparser::PrefixContext::c_prefix() {
126 0 : return getRuleContext<accparser::C_prefixContext>(0);
127 : }
128 :
129 0 : accparser::Fortran_prefixContext* accparser::PrefixContext::fortran_prefix() {
130 0 : return getRuleContext<accparser::Fortran_prefixContext>(0);
131 : }
132 :
133 :
134 0 : size_t accparser::PrefixContext::getRuleIndex() const {
135 0 : return accparser::RulePrefix;
136 : }
137 :
138 0 : void accparser::PrefixContext::enterRule(tree::ParseTreeListener *listener) {
139 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
140 0 : if (parserListener != nullptr)
141 0 : parserListener->enterPrefix(this);
142 0 : }
143 :
144 0 : void accparser::PrefixContext::exitRule(tree::ParseTreeListener *listener) {
145 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
146 0 : if (parserListener != nullptr)
147 0 : parserListener->exitPrefix(this);
148 0 : }
149 :
150 :
151 0 : antlrcpp::Any accparser::PrefixContext::accept(tree::ParseTreeVisitor *visitor) {
152 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
153 0 : return parserVisitor->visitPrefix(this);
154 : else
155 0 : return visitor->visitChildren(this);
156 : }
157 :
158 0 : accparser::PrefixContext* accparser::prefix() {
159 0 : PrefixContext *_localctx = _tracker.createInstance<PrefixContext>(_ctx, getState());
160 0 : enterRule(_localctx, 2, accparser::RulePrefix);
161 :
162 0 : auto onExit = finally([=] {
163 0 : exitRule();
164 0 : });
165 0 : try {
166 0 : setState(313);
167 0 : _errHandler->sync(this);
168 0 : switch (_input->LA(1)) {
169 0 : case accparser::C_PREFIX: {
170 0 : enterOuterAlt(_localctx, 1);
171 0 : setState(311);
172 0 : c_prefix();
173 : break;
174 : }
175 :
176 0 : case accparser::FORTRAN_PREFIX: {
177 0 : enterOuterAlt(_localctx, 2);
178 0 : setState(312);
179 0 : fortran_prefix();
180 : break;
181 : }
182 :
183 0 : default:
184 0 : throw NoViableAltException(this);
185 : }
186 :
187 : }
188 0 : catch (RecognitionException &e) {
189 0 : _errHandler->reportError(this, e);
190 0 : _localctx->exception = std::current_exception();
191 0 : _errHandler->recover(this, _localctx->exception);
192 : }
193 :
194 0 : return _localctx;
195 : }
196 :
197 : //----------------- C_prefixContext ------------------------------------------------------------------
198 :
199 0 : accparser::C_prefixContext::C_prefixContext(ParserRuleContext *parent, size_t invokingState)
200 0 : : ParserRuleContext(parent, invokingState) {
201 0 : }
202 :
203 0 : tree::TerminalNode* accparser::C_prefixContext::C_PREFIX() {
204 0 : return getToken(accparser::C_PREFIX, 0);
205 : }
206 :
207 :
208 0 : size_t accparser::C_prefixContext::getRuleIndex() const {
209 0 : return accparser::RuleC_prefix;
210 : }
211 :
212 0 : void accparser::C_prefixContext::enterRule(tree::ParseTreeListener *listener) {
213 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
214 0 : if (parserListener != nullptr)
215 0 : parserListener->enterC_prefix(this);
216 0 : }
217 :
218 0 : void accparser::C_prefixContext::exitRule(tree::ParseTreeListener *listener) {
219 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
220 0 : if (parserListener != nullptr)
221 0 : parserListener->exitC_prefix(this);
222 0 : }
223 :
224 :
225 0 : antlrcpp::Any accparser::C_prefixContext::accept(tree::ParseTreeVisitor *visitor) {
226 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
227 0 : return parserVisitor->visitC_prefix(this);
228 : else
229 0 : return visitor->visitChildren(this);
230 : }
231 :
232 0 : accparser::C_prefixContext* accparser::c_prefix() {
233 0 : C_prefixContext *_localctx = _tracker.createInstance<C_prefixContext>(_ctx, getState());
234 0 : enterRule(_localctx, 4, accparser::RuleC_prefix);
235 :
236 0 : auto onExit = finally([=] {
237 0 : exitRule();
238 0 : });
239 0 : try {
240 0 : enterOuterAlt(_localctx, 1);
241 0 : setState(315);
242 0 : match(accparser::C_PREFIX);
243 :
244 : }
245 0 : catch (RecognitionException &e) {
246 0 : _errHandler->reportError(this, e);
247 0 : _localctx->exception = std::current_exception();
248 0 : _errHandler->recover(this, _localctx->exception);
249 : }
250 :
251 0 : return _localctx;
252 : }
253 :
254 : //----------------- Fortran_prefixContext ------------------------------------------------------------------
255 :
256 0 : accparser::Fortran_prefixContext::Fortran_prefixContext(ParserRuleContext *parent, size_t invokingState)
257 0 : : ParserRuleContext(parent, invokingState) {
258 0 : }
259 :
260 0 : tree::TerminalNode* accparser::Fortran_prefixContext::FORTRAN_PREFIX() {
261 0 : return getToken(accparser::FORTRAN_PREFIX, 0);
262 : }
263 :
264 :
265 0 : size_t accparser::Fortran_prefixContext::getRuleIndex() const {
266 0 : return accparser::RuleFortran_prefix;
267 : }
268 :
269 0 : void accparser::Fortran_prefixContext::enterRule(tree::ParseTreeListener *listener) {
270 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
271 0 : if (parserListener != nullptr)
272 0 : parserListener->enterFortran_prefix(this);
273 0 : }
274 :
275 0 : void accparser::Fortran_prefixContext::exitRule(tree::ParseTreeListener *listener) {
276 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
277 0 : if (parserListener != nullptr)
278 0 : parserListener->exitFortran_prefix(this);
279 0 : }
280 :
281 :
282 0 : antlrcpp::Any accparser::Fortran_prefixContext::accept(tree::ParseTreeVisitor *visitor) {
283 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
284 0 : return parserVisitor->visitFortran_prefix(this);
285 : else
286 0 : return visitor->visitChildren(this);
287 : }
288 :
289 0 : accparser::Fortran_prefixContext* accparser::fortran_prefix() {
290 0 : Fortran_prefixContext *_localctx = _tracker.createInstance<Fortran_prefixContext>(_ctx, getState());
291 0 : enterRule(_localctx, 6, accparser::RuleFortran_prefix);
292 :
293 0 : auto onExit = finally([=] {
294 0 : exitRule();
295 0 : });
296 0 : try {
297 0 : enterOuterAlt(_localctx, 1);
298 0 : setState(317);
299 0 : match(accparser::FORTRAN_PREFIX);
300 :
301 : }
302 0 : catch (RecognitionException &e) {
303 0 : _errHandler->reportError(this, e);
304 0 : _localctx->exception = std::current_exception();
305 0 : _errHandler->recover(this, _localctx->exception);
306 : }
307 :
308 0 : return _localctx;
309 : }
310 :
311 : //----------------- Openacc_directiveContext ------------------------------------------------------------------
312 :
313 0 : accparser::Openacc_directiveContext::Openacc_directiveContext(ParserRuleContext *parent, size_t invokingState)
314 0 : : ParserRuleContext(parent, invokingState) {
315 0 : }
316 :
317 0 : accparser::Atomic_directiveContext* accparser::Openacc_directiveContext::atomic_directive() {
318 0 : return getRuleContext<accparser::Atomic_directiveContext>(0);
319 : }
320 :
321 0 : accparser::Cache_directiveContext* accparser::Openacc_directiveContext::cache_directive() {
322 0 : return getRuleContext<accparser::Cache_directiveContext>(0);
323 : }
324 :
325 0 : accparser::Data_directiveContext* accparser::Openacc_directiveContext::data_directive() {
326 0 : return getRuleContext<accparser::Data_directiveContext>(0);
327 : }
328 :
329 0 : accparser::Declare_directiveContext* accparser::Openacc_directiveContext::declare_directive() {
330 0 : return getRuleContext<accparser::Declare_directiveContext>(0);
331 : }
332 :
333 0 : accparser::End_directiveContext* accparser::Openacc_directiveContext::end_directive() {
334 0 : return getRuleContext<accparser::End_directiveContext>(0);
335 : }
336 :
337 0 : accparser::Enter_data_directiveContext* accparser::Openacc_directiveContext::enter_data_directive() {
338 0 : return getRuleContext<accparser::Enter_data_directiveContext>(0);
339 : }
340 :
341 0 : accparser::Exit_data_directiveContext* accparser::Openacc_directiveContext::exit_data_directive() {
342 0 : return getRuleContext<accparser::Exit_data_directiveContext>(0);
343 : }
344 :
345 0 : accparser::Host_data_directiveContext* accparser::Openacc_directiveContext::host_data_directive() {
346 0 : return getRuleContext<accparser::Host_data_directiveContext>(0);
347 : }
348 :
349 0 : accparser::Init_directiveContext* accparser::Openacc_directiveContext::init_directive() {
350 0 : return getRuleContext<accparser::Init_directiveContext>(0);
351 : }
352 :
353 0 : accparser::Kernels_directiveContext* accparser::Openacc_directiveContext::kernels_directive() {
354 0 : return getRuleContext<accparser::Kernels_directiveContext>(0);
355 : }
356 :
357 0 : accparser::Kernels_loop_directiveContext* accparser::Openacc_directiveContext::kernels_loop_directive() {
358 0 : return getRuleContext<accparser::Kernels_loop_directiveContext>(0);
359 : }
360 :
361 0 : accparser::Loop_directiveContext* accparser::Openacc_directiveContext::loop_directive() {
362 0 : return getRuleContext<accparser::Loop_directiveContext>(0);
363 : }
364 :
365 0 : accparser::Parallel_directiveContext* accparser::Openacc_directiveContext::parallel_directive() {
366 0 : return getRuleContext<accparser::Parallel_directiveContext>(0);
367 : }
368 :
369 0 : accparser::Parallel_loop_directiveContext* accparser::Openacc_directiveContext::parallel_loop_directive() {
370 0 : return getRuleContext<accparser::Parallel_loop_directiveContext>(0);
371 : }
372 :
373 0 : accparser::Routine_directiveContext* accparser::Openacc_directiveContext::routine_directive() {
374 0 : return getRuleContext<accparser::Routine_directiveContext>(0);
375 : }
376 :
377 0 : accparser::Serial_directiveContext* accparser::Openacc_directiveContext::serial_directive() {
378 0 : return getRuleContext<accparser::Serial_directiveContext>(0);
379 : }
380 :
381 0 : accparser::Serial_loop_directiveContext* accparser::Openacc_directiveContext::serial_loop_directive() {
382 0 : return getRuleContext<accparser::Serial_loop_directiveContext>(0);
383 : }
384 :
385 0 : accparser::Set_directiveContext* accparser::Openacc_directiveContext::set_directive() {
386 0 : return getRuleContext<accparser::Set_directiveContext>(0);
387 : }
388 :
389 0 : accparser::Shutdown_directiveContext* accparser::Openacc_directiveContext::shutdown_directive() {
390 0 : return getRuleContext<accparser::Shutdown_directiveContext>(0);
391 : }
392 :
393 0 : accparser::Update_directiveContext* accparser::Openacc_directiveContext::update_directive() {
394 0 : return getRuleContext<accparser::Update_directiveContext>(0);
395 : }
396 :
397 0 : accparser::Wait_directiveContext* accparser::Openacc_directiveContext::wait_directive() {
398 0 : return getRuleContext<accparser::Wait_directiveContext>(0);
399 : }
400 :
401 :
402 0 : size_t accparser::Openacc_directiveContext::getRuleIndex() const {
403 0 : return accparser::RuleOpenacc_directive;
404 : }
405 :
406 0 : void accparser::Openacc_directiveContext::enterRule(tree::ParseTreeListener *listener) {
407 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
408 0 : if (parserListener != nullptr)
409 0 : parserListener->enterOpenacc_directive(this);
410 0 : }
411 :
412 0 : void accparser::Openacc_directiveContext::exitRule(tree::ParseTreeListener *listener) {
413 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
414 0 : if (parserListener != nullptr)
415 0 : parserListener->exitOpenacc_directive(this);
416 0 : }
417 :
418 :
419 0 : antlrcpp::Any accparser::Openacc_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
420 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
421 0 : return parserVisitor->visitOpenacc_directive(this);
422 : else
423 0 : return visitor->visitChildren(this);
424 : }
425 :
426 0 : accparser::Openacc_directiveContext* accparser::openacc_directive() {
427 0 : Openacc_directiveContext *_localctx = _tracker.createInstance<Openacc_directiveContext>(_ctx, getState());
428 0 : enterRule(_localctx, 8, accparser::RuleOpenacc_directive);
429 :
430 0 : auto onExit = finally([=] {
431 0 : exitRule();
432 0 : });
433 0 : try {
434 0 : setState(340);
435 0 : _errHandler->sync(this);
436 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx)) {
437 0 : case 1: {
438 0 : enterOuterAlt(_localctx, 1);
439 0 : setState(319);
440 0 : atomic_directive();
441 : break;
442 : }
443 :
444 0 : case 2: {
445 0 : enterOuterAlt(_localctx, 2);
446 0 : setState(320);
447 0 : cache_directive();
448 : break;
449 : }
450 :
451 0 : case 3: {
452 0 : enterOuterAlt(_localctx, 3);
453 0 : setState(321);
454 0 : data_directive();
455 : break;
456 : }
457 :
458 0 : case 4: {
459 0 : enterOuterAlt(_localctx, 4);
460 0 : setState(322);
461 0 : declare_directive();
462 : break;
463 : }
464 :
465 0 : case 5: {
466 0 : enterOuterAlt(_localctx, 5);
467 0 : setState(323);
468 0 : end_directive();
469 : break;
470 : }
471 :
472 0 : case 6: {
473 0 : enterOuterAlt(_localctx, 6);
474 0 : setState(324);
475 0 : enter_data_directive();
476 : break;
477 : }
478 :
479 0 : case 7: {
480 0 : enterOuterAlt(_localctx, 7);
481 0 : setState(325);
482 0 : exit_data_directive();
483 : break;
484 : }
485 :
486 0 : case 8: {
487 0 : enterOuterAlt(_localctx, 8);
488 0 : setState(326);
489 0 : host_data_directive();
490 : break;
491 : }
492 :
493 0 : case 9: {
494 0 : enterOuterAlt(_localctx, 9);
495 0 : setState(327);
496 0 : init_directive();
497 : break;
498 : }
499 :
500 0 : case 10: {
501 0 : enterOuterAlt(_localctx, 10);
502 0 : setState(328);
503 0 : kernels_directive();
504 : break;
505 : }
506 :
507 0 : case 11: {
508 0 : enterOuterAlt(_localctx, 11);
509 0 : setState(329);
510 0 : kernels_loop_directive();
511 : break;
512 : }
513 :
514 0 : case 12: {
515 0 : enterOuterAlt(_localctx, 12);
516 0 : setState(330);
517 0 : loop_directive();
518 : break;
519 : }
520 :
521 0 : case 13: {
522 0 : enterOuterAlt(_localctx, 13);
523 0 : setState(331);
524 0 : parallel_directive();
525 : break;
526 : }
527 :
528 0 : case 14: {
529 0 : enterOuterAlt(_localctx, 14);
530 0 : setState(332);
531 0 : parallel_loop_directive();
532 : break;
533 : }
534 :
535 0 : case 15: {
536 0 : enterOuterAlt(_localctx, 15);
537 0 : setState(333);
538 0 : routine_directive();
539 : break;
540 : }
541 :
542 0 : case 16: {
543 0 : enterOuterAlt(_localctx, 16);
544 0 : setState(334);
545 0 : serial_directive();
546 : break;
547 : }
548 :
549 0 : case 17: {
550 0 : enterOuterAlt(_localctx, 17);
551 0 : setState(335);
552 0 : serial_loop_directive();
553 : break;
554 : }
555 :
556 0 : case 18: {
557 0 : enterOuterAlt(_localctx, 18);
558 0 : setState(336);
559 0 : set_directive();
560 : break;
561 : }
562 :
563 0 : case 19: {
564 0 : enterOuterAlt(_localctx, 19);
565 0 : setState(337);
566 0 : shutdown_directive();
567 : break;
568 : }
569 :
570 0 : case 20: {
571 0 : enterOuterAlt(_localctx, 20);
572 0 : setState(338);
573 0 : update_directive();
574 : break;
575 : }
576 :
577 0 : case 21: {
578 0 : enterOuterAlt(_localctx, 21);
579 0 : setState(339);
580 0 : wait_directive();
581 : break;
582 : }
583 :
584 : }
585 :
586 : }
587 0 : catch (RecognitionException &e) {
588 0 : _errHandler->reportError(this, e);
589 0 : _localctx->exception = std::current_exception();
590 0 : _errHandler->recover(this, _localctx->exception);
591 : }
592 :
593 0 : return _localctx;
594 : }
595 :
596 : //----------------- Atomic_directiveContext ------------------------------------------------------------------
597 :
598 0 : accparser::Atomic_directiveContext::Atomic_directiveContext(ParserRuleContext *parent, size_t invokingState)
599 0 : : ParserRuleContext(parent, invokingState) {
600 0 : }
601 :
602 0 : tree::TerminalNode* accparser::Atomic_directiveContext::ATOMIC() {
603 0 : return getToken(accparser::ATOMIC, 0);
604 : }
605 :
606 0 : accparser::Atomic_clauseContext* accparser::Atomic_directiveContext::atomic_clause() {
607 0 : return getRuleContext<accparser::Atomic_clauseContext>(0);
608 : }
609 :
610 :
611 0 : size_t accparser::Atomic_directiveContext::getRuleIndex() const {
612 0 : return accparser::RuleAtomic_directive;
613 : }
614 :
615 0 : void accparser::Atomic_directiveContext::enterRule(tree::ParseTreeListener *listener) {
616 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
617 0 : if (parserListener != nullptr)
618 0 : parserListener->enterAtomic_directive(this);
619 0 : }
620 :
621 0 : void accparser::Atomic_directiveContext::exitRule(tree::ParseTreeListener *listener) {
622 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
623 0 : if (parserListener != nullptr)
624 0 : parserListener->exitAtomic_directive(this);
625 0 : }
626 :
627 :
628 0 : antlrcpp::Any accparser::Atomic_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
629 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
630 0 : return parserVisitor->visitAtomic_directive(this);
631 : else
632 0 : return visitor->visitChildren(this);
633 : }
634 :
635 0 : accparser::Atomic_directiveContext* accparser::atomic_directive() {
636 0 : Atomic_directiveContext *_localctx = _tracker.createInstance<Atomic_directiveContext>(_ctx, getState());
637 0 : enterRule(_localctx, 10, accparser::RuleAtomic_directive);
638 :
639 0 : auto onExit = finally([=] {
640 0 : exitRule();
641 0 : });
642 0 : try {
643 0 : setState(345);
644 0 : _errHandler->sync(this);
645 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx)) {
646 0 : case 1: {
647 0 : enterOuterAlt(_localctx, 1);
648 0 : setState(342);
649 0 : match(accparser::ATOMIC);
650 : break;
651 : }
652 :
653 0 : case 2: {
654 0 : enterOuterAlt(_localctx, 2);
655 0 : setState(343);
656 0 : match(accparser::ATOMIC);
657 0 : setState(344);
658 0 : atomic_clause();
659 : break;
660 : }
661 :
662 : }
663 :
664 : }
665 0 : catch (RecognitionException &e) {
666 0 : _errHandler->reportError(this, e);
667 0 : _localctx->exception = std::current_exception();
668 0 : _errHandler->recover(this, _localctx->exception);
669 : }
670 :
671 0 : return _localctx;
672 : }
673 :
674 : //----------------- Atomic_clauseContext ------------------------------------------------------------------
675 :
676 0 : accparser::Atomic_clauseContext::Atomic_clauseContext(ParserRuleContext *parent, size_t invokingState)
677 0 : : ParserRuleContext(parent, invokingState) {
678 0 : }
679 :
680 0 : accparser::Capture_clauseContext* accparser::Atomic_clauseContext::capture_clause() {
681 0 : return getRuleContext<accparser::Capture_clauseContext>(0);
682 : }
683 :
684 0 : accparser::Read_clauseContext* accparser::Atomic_clauseContext::read_clause() {
685 0 : return getRuleContext<accparser::Read_clauseContext>(0);
686 : }
687 :
688 0 : accparser::Update_clauseContext* accparser::Atomic_clauseContext::update_clause() {
689 0 : return getRuleContext<accparser::Update_clauseContext>(0);
690 : }
691 :
692 0 : accparser::Write_clauseContext* accparser::Atomic_clauseContext::write_clause() {
693 0 : return getRuleContext<accparser::Write_clauseContext>(0);
694 : }
695 :
696 :
697 0 : size_t accparser::Atomic_clauseContext::getRuleIndex() const {
698 0 : return accparser::RuleAtomic_clause;
699 : }
700 :
701 0 : void accparser::Atomic_clauseContext::enterRule(tree::ParseTreeListener *listener) {
702 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
703 0 : if (parserListener != nullptr)
704 0 : parserListener->enterAtomic_clause(this);
705 0 : }
706 :
707 0 : void accparser::Atomic_clauseContext::exitRule(tree::ParseTreeListener *listener) {
708 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
709 0 : if (parserListener != nullptr)
710 0 : parserListener->exitAtomic_clause(this);
711 0 : }
712 :
713 :
714 0 : antlrcpp::Any accparser::Atomic_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
715 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
716 0 : return parserVisitor->visitAtomic_clause(this);
717 : else
718 0 : return visitor->visitChildren(this);
719 : }
720 :
721 0 : accparser::Atomic_clauseContext* accparser::atomic_clause() {
722 0 : Atomic_clauseContext *_localctx = _tracker.createInstance<Atomic_clauseContext>(_ctx, getState());
723 0 : enterRule(_localctx, 12, accparser::RuleAtomic_clause);
724 :
725 0 : auto onExit = finally([=] {
726 0 : exitRule();
727 0 : });
728 0 : try {
729 0 : setState(351);
730 0 : _errHandler->sync(this);
731 0 : switch (_input->LA(1)) {
732 0 : case accparser::CAPTURE: {
733 0 : enterOuterAlt(_localctx, 1);
734 0 : setState(347);
735 0 : capture_clause();
736 : break;
737 : }
738 :
739 0 : case accparser::READ: {
740 0 : enterOuterAlt(_localctx, 2);
741 0 : setState(348);
742 0 : read_clause();
743 : break;
744 : }
745 :
746 0 : case accparser::UPDATE: {
747 0 : enterOuterAlt(_localctx, 3);
748 0 : setState(349);
749 0 : update_clause();
750 : break;
751 : }
752 :
753 0 : case accparser::WRITE: {
754 0 : enterOuterAlt(_localctx, 4);
755 0 : setState(350);
756 0 : write_clause();
757 : break;
758 : }
759 :
760 0 : default:
761 0 : throw NoViableAltException(this);
762 : }
763 :
764 : }
765 0 : catch (RecognitionException &e) {
766 0 : _errHandler->reportError(this, e);
767 0 : _localctx->exception = std::current_exception();
768 0 : _errHandler->recover(this, _localctx->exception);
769 : }
770 :
771 0 : return _localctx;
772 : }
773 :
774 : //----------------- Cache_directiveContext ------------------------------------------------------------------
775 :
776 0 : accparser::Cache_directiveContext::Cache_directiveContext(ParserRuleContext *parent, size_t invokingState)
777 0 : : ParserRuleContext(parent, invokingState) {
778 0 : }
779 :
780 0 : tree::TerminalNode* accparser::Cache_directiveContext::CACHE() {
781 0 : return getToken(accparser::CACHE, 0);
782 : }
783 :
784 0 : tree::TerminalNode* accparser::Cache_directiveContext::LEFT_PAREN() {
785 0 : return getToken(accparser::LEFT_PAREN, 0);
786 : }
787 :
788 0 : accparser::Var_listContext* accparser::Cache_directiveContext::var_list() {
789 0 : return getRuleContext<accparser::Var_listContext>(0);
790 : }
791 :
792 0 : tree::TerminalNode* accparser::Cache_directiveContext::RIGHT_PAREN() {
793 0 : return getToken(accparser::RIGHT_PAREN, 0);
794 : }
795 :
796 0 : accparser::Cache_directive_modifierContext* accparser::Cache_directiveContext::cache_directive_modifier() {
797 0 : return getRuleContext<accparser::Cache_directive_modifierContext>(0);
798 : }
799 :
800 0 : tree::TerminalNode* accparser::Cache_directiveContext::COLON() {
801 0 : return getToken(accparser::COLON, 0);
802 : }
803 :
804 :
805 0 : size_t accparser::Cache_directiveContext::getRuleIndex() const {
806 0 : return accparser::RuleCache_directive;
807 : }
808 :
809 0 : void accparser::Cache_directiveContext::enterRule(tree::ParseTreeListener *listener) {
810 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
811 0 : if (parserListener != nullptr)
812 0 : parserListener->enterCache_directive(this);
813 0 : }
814 :
815 0 : void accparser::Cache_directiveContext::exitRule(tree::ParseTreeListener *listener) {
816 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
817 0 : if (parserListener != nullptr)
818 0 : parserListener->exitCache_directive(this);
819 0 : }
820 :
821 :
822 0 : antlrcpp::Any accparser::Cache_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
823 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
824 0 : return parserVisitor->visitCache_directive(this);
825 : else
826 0 : return visitor->visitChildren(this);
827 : }
828 :
829 0 : accparser::Cache_directiveContext* accparser::cache_directive() {
830 0 : Cache_directiveContext *_localctx = _tracker.createInstance<Cache_directiveContext>(_ctx, getState());
831 0 : enterRule(_localctx, 14, accparser::RuleCache_directive);
832 :
833 0 : auto onExit = finally([=] {
834 0 : exitRule();
835 0 : });
836 0 : try {
837 0 : setState(365);
838 0 : _errHandler->sync(this);
839 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 4, _ctx)) {
840 0 : case 1: {
841 0 : enterOuterAlt(_localctx, 1);
842 0 : setState(353);
843 0 : match(accparser::CACHE);
844 0 : setState(354);
845 0 : match(accparser::LEFT_PAREN);
846 0 : setState(355);
847 0 : var_list();
848 0 : setState(356);
849 0 : match(accparser::RIGHT_PAREN);
850 : break;
851 : }
852 :
853 0 : case 2: {
854 0 : enterOuterAlt(_localctx, 2);
855 0 : setState(358);
856 0 : match(accparser::CACHE);
857 0 : setState(359);
858 0 : match(accparser::LEFT_PAREN);
859 0 : setState(360);
860 0 : cache_directive_modifier();
861 0 : setState(361);
862 0 : match(accparser::COLON);
863 0 : setState(362);
864 0 : var_list();
865 0 : setState(363);
866 0 : match(accparser::RIGHT_PAREN);
867 : break;
868 : }
869 :
870 : }
871 :
872 : }
873 0 : catch (RecognitionException &e) {
874 0 : _errHandler->reportError(this, e);
875 0 : _localctx->exception = std::current_exception();
876 0 : _errHandler->recover(this, _localctx->exception);
877 : }
878 :
879 0 : return _localctx;
880 : }
881 :
882 : //----------------- Cache_directive_modifierContext ------------------------------------------------------------------
883 :
884 0 : accparser::Cache_directive_modifierContext::Cache_directive_modifierContext(ParserRuleContext *parent, size_t invokingState)
885 0 : : ParserRuleContext(parent, invokingState) {
886 0 : }
887 :
888 0 : tree::TerminalNode* accparser::Cache_directive_modifierContext::READONLY() {
889 0 : return getToken(accparser::READONLY, 0);
890 : }
891 :
892 :
893 0 : size_t accparser::Cache_directive_modifierContext::getRuleIndex() const {
894 0 : return accparser::RuleCache_directive_modifier;
895 : }
896 :
897 0 : void accparser::Cache_directive_modifierContext::enterRule(tree::ParseTreeListener *listener) {
898 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
899 0 : if (parserListener != nullptr)
900 0 : parserListener->enterCache_directive_modifier(this);
901 0 : }
902 :
903 0 : void accparser::Cache_directive_modifierContext::exitRule(tree::ParseTreeListener *listener) {
904 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
905 0 : if (parserListener != nullptr)
906 0 : parserListener->exitCache_directive_modifier(this);
907 0 : }
908 :
909 :
910 0 : antlrcpp::Any accparser::Cache_directive_modifierContext::accept(tree::ParseTreeVisitor *visitor) {
911 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
912 0 : return parserVisitor->visitCache_directive_modifier(this);
913 : else
914 0 : return visitor->visitChildren(this);
915 : }
916 :
917 0 : accparser::Cache_directive_modifierContext* accparser::cache_directive_modifier() {
918 0 : Cache_directive_modifierContext *_localctx = _tracker.createInstance<Cache_directive_modifierContext>(_ctx, getState());
919 0 : enterRule(_localctx, 16, accparser::RuleCache_directive_modifier);
920 :
921 0 : auto onExit = finally([=] {
922 0 : exitRule();
923 0 : });
924 0 : try {
925 0 : enterOuterAlt(_localctx, 1);
926 0 : setState(367);
927 0 : match(accparser::READONLY);
928 :
929 : }
930 0 : catch (RecognitionException &e) {
931 0 : _errHandler->reportError(this, e);
932 0 : _localctx->exception = std::current_exception();
933 0 : _errHandler->recover(this, _localctx->exception);
934 : }
935 :
936 0 : return _localctx;
937 : }
938 :
939 : //----------------- Data_directiveContext ------------------------------------------------------------------
940 :
941 0 : accparser::Data_directiveContext::Data_directiveContext(ParserRuleContext *parent, size_t invokingState)
942 0 : : ParserRuleContext(parent, invokingState) {
943 0 : }
944 :
945 0 : tree::TerminalNode* accparser::Data_directiveContext::DATA() {
946 0 : return getToken(accparser::DATA, 0);
947 : }
948 :
949 0 : accparser::Data_clause_listContext* accparser::Data_directiveContext::data_clause_list() {
950 0 : return getRuleContext<accparser::Data_clause_listContext>(0);
951 : }
952 :
953 :
954 0 : size_t accparser::Data_directiveContext::getRuleIndex() const {
955 0 : return accparser::RuleData_directive;
956 : }
957 :
958 0 : void accparser::Data_directiveContext::enterRule(tree::ParseTreeListener *listener) {
959 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
960 0 : if (parserListener != nullptr)
961 0 : parserListener->enterData_directive(this);
962 0 : }
963 :
964 0 : void accparser::Data_directiveContext::exitRule(tree::ParseTreeListener *listener) {
965 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
966 0 : if (parserListener != nullptr)
967 0 : parserListener->exitData_directive(this);
968 0 : }
969 :
970 :
971 0 : antlrcpp::Any accparser::Data_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
972 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
973 0 : return parserVisitor->visitData_directive(this);
974 : else
975 0 : return visitor->visitChildren(this);
976 : }
977 :
978 0 : accparser::Data_directiveContext* accparser::data_directive() {
979 0 : Data_directiveContext *_localctx = _tracker.createInstance<Data_directiveContext>(_ctx, getState());
980 0 : enterRule(_localctx, 18, accparser::RuleData_directive);
981 :
982 0 : auto onExit = finally([=] {
983 0 : exitRule();
984 0 : });
985 0 : try {
986 0 : enterOuterAlt(_localctx, 1);
987 0 : setState(369);
988 0 : match(accparser::DATA);
989 0 : setState(370);
990 0 : data_clause_list();
991 :
992 : }
993 0 : catch (RecognitionException &e) {
994 0 : _errHandler->reportError(this, e);
995 0 : _localctx->exception = std::current_exception();
996 0 : _errHandler->recover(this, _localctx->exception);
997 : }
998 :
999 0 : return _localctx;
1000 : }
1001 :
1002 : //----------------- Data_clause_listContext ------------------------------------------------------------------
1003 :
1004 0 : accparser::Data_clause_listContext::Data_clause_listContext(ParserRuleContext *parent, size_t invokingState)
1005 0 : : ParserRuleContext(parent, invokingState) {
1006 0 : }
1007 :
1008 0 : std::vector<accparser::Data_clausesContext *> accparser::Data_clause_listContext::data_clauses() {
1009 0 : return getRuleContexts<accparser::Data_clausesContext>();
1010 : }
1011 :
1012 0 : accparser::Data_clausesContext* accparser::Data_clause_listContext::data_clauses(size_t i) {
1013 0 : return getRuleContext<accparser::Data_clausesContext>(i);
1014 : }
1015 :
1016 :
1017 0 : size_t accparser::Data_clause_listContext::getRuleIndex() const {
1018 0 : return accparser::RuleData_clause_list;
1019 : }
1020 :
1021 0 : void accparser::Data_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
1022 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1023 0 : if (parserListener != nullptr)
1024 0 : parserListener->enterData_clause_list(this);
1025 0 : }
1026 :
1027 0 : void accparser::Data_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
1028 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1029 0 : if (parserListener != nullptr)
1030 0 : parserListener->exitData_clause_list(this);
1031 0 : }
1032 :
1033 :
1034 0 : antlrcpp::Any accparser::Data_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
1035 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1036 0 : return parserVisitor->visitData_clause_list(this);
1037 : else
1038 0 : return visitor->visitChildren(this);
1039 : }
1040 :
1041 0 : accparser::Data_clause_listContext* accparser::data_clause_list() {
1042 0 : Data_clause_listContext *_localctx = _tracker.createInstance<Data_clause_listContext>(_ctx, getState());
1043 0 : enterRule(_localctx, 20, accparser::RuleData_clause_list);
1044 0 : size_t _la = 0;
1045 :
1046 0 : auto onExit = finally([=] {
1047 0 : exitRule();
1048 0 : });
1049 0 : try {
1050 0 : enterOuterAlt(_localctx, 1);
1051 0 : setState(375);
1052 0 : _errHandler->sync(this);
1053 0 : _la = _input->LA(1);
1054 0 : while ((((_la & ~ 0x3fULL) == 0) &&
1055 : ((1ULL << _la) & ((1ULL << accparser::ATTACH)
1056 : | (1ULL << accparser::COPY)
1057 : | (1ULL << accparser::COPYIN)
1058 : | (1ULL << accparser::COPYOUT)
1059 : | (1ULL << accparser::CREATE)
1060 : | (1ULL << accparser::DEFAULT)
1061 : | (1ULL << accparser::DEVICEPTR)
1062 : | (1ULL << accparser::IF)
1063 : | (1ULL << accparser::NO_CREATE)
1064 0 : | (1ULL << accparser::PRESENT))) != 0)) {
1065 0 : setState(372);
1066 0 : data_clauses();
1067 0 : setState(377);
1068 0 : _errHandler->sync(this);
1069 0 : _la = _input->LA(1);
1070 : }
1071 :
1072 : }
1073 0 : catch (RecognitionException &e) {
1074 0 : _errHandler->reportError(this, e);
1075 0 : _localctx->exception = std::current_exception();
1076 0 : _errHandler->recover(this, _localctx->exception);
1077 : }
1078 :
1079 0 : return _localctx;
1080 : }
1081 :
1082 : //----------------- Data_clausesContext ------------------------------------------------------------------
1083 :
1084 0 : accparser::Data_clausesContext::Data_clausesContext(ParserRuleContext *parent, size_t invokingState)
1085 0 : : ParserRuleContext(parent, invokingState) {
1086 0 : }
1087 :
1088 0 : accparser::Attach_clauseContext* accparser::Data_clausesContext::attach_clause() {
1089 0 : return getRuleContext<accparser::Attach_clauseContext>(0);
1090 : }
1091 :
1092 0 : accparser::Copy_clauseContext* accparser::Data_clausesContext::copy_clause() {
1093 0 : return getRuleContext<accparser::Copy_clauseContext>(0);
1094 : }
1095 :
1096 0 : accparser::Copyin_clauseContext* accparser::Data_clausesContext::copyin_clause() {
1097 0 : return getRuleContext<accparser::Copyin_clauseContext>(0);
1098 : }
1099 :
1100 0 : accparser::Copyout_clauseContext* accparser::Data_clausesContext::copyout_clause() {
1101 0 : return getRuleContext<accparser::Copyout_clauseContext>(0);
1102 : }
1103 :
1104 0 : accparser::Create_clauseContext* accparser::Data_clausesContext::create_clause() {
1105 0 : return getRuleContext<accparser::Create_clauseContext>(0);
1106 : }
1107 :
1108 0 : accparser::Default_clauseContext* accparser::Data_clausesContext::default_clause() {
1109 0 : return getRuleContext<accparser::Default_clauseContext>(0);
1110 : }
1111 :
1112 0 : accparser::Deviceptr_clauseContext* accparser::Data_clausesContext::deviceptr_clause() {
1113 0 : return getRuleContext<accparser::Deviceptr_clauseContext>(0);
1114 : }
1115 :
1116 0 : accparser::If_clauseContext* accparser::Data_clausesContext::if_clause() {
1117 0 : return getRuleContext<accparser::If_clauseContext>(0);
1118 : }
1119 :
1120 0 : accparser::No_create_clauseContext* accparser::Data_clausesContext::no_create_clause() {
1121 0 : return getRuleContext<accparser::No_create_clauseContext>(0);
1122 : }
1123 :
1124 0 : accparser::Present_clauseContext* accparser::Data_clausesContext::present_clause() {
1125 0 : return getRuleContext<accparser::Present_clauseContext>(0);
1126 : }
1127 :
1128 :
1129 0 : size_t accparser::Data_clausesContext::getRuleIndex() const {
1130 0 : return accparser::RuleData_clauses;
1131 : }
1132 :
1133 0 : void accparser::Data_clausesContext::enterRule(tree::ParseTreeListener *listener) {
1134 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1135 0 : if (parserListener != nullptr)
1136 0 : parserListener->enterData_clauses(this);
1137 0 : }
1138 :
1139 0 : void accparser::Data_clausesContext::exitRule(tree::ParseTreeListener *listener) {
1140 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1141 0 : if (parserListener != nullptr)
1142 0 : parserListener->exitData_clauses(this);
1143 0 : }
1144 :
1145 :
1146 0 : antlrcpp::Any accparser::Data_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
1147 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1148 0 : return parserVisitor->visitData_clauses(this);
1149 : else
1150 0 : return visitor->visitChildren(this);
1151 : }
1152 :
1153 0 : accparser::Data_clausesContext* accparser::data_clauses() {
1154 0 : Data_clausesContext *_localctx = _tracker.createInstance<Data_clausesContext>(_ctx, getState());
1155 0 : enterRule(_localctx, 22, accparser::RuleData_clauses);
1156 :
1157 0 : auto onExit = finally([=] {
1158 0 : exitRule();
1159 0 : });
1160 0 : try {
1161 0 : setState(388);
1162 0 : _errHandler->sync(this);
1163 0 : switch (_input->LA(1)) {
1164 0 : case accparser::ATTACH: {
1165 0 : enterOuterAlt(_localctx, 1);
1166 0 : setState(378);
1167 0 : attach_clause();
1168 : break;
1169 : }
1170 :
1171 0 : case accparser::COPY: {
1172 0 : enterOuterAlt(_localctx, 2);
1173 0 : setState(379);
1174 0 : copy_clause();
1175 : break;
1176 : }
1177 :
1178 0 : case accparser::COPYIN: {
1179 0 : enterOuterAlt(_localctx, 3);
1180 0 : setState(380);
1181 0 : copyin_clause();
1182 : break;
1183 : }
1184 :
1185 0 : case accparser::COPYOUT: {
1186 0 : enterOuterAlt(_localctx, 4);
1187 0 : setState(381);
1188 0 : copyout_clause();
1189 : break;
1190 : }
1191 :
1192 0 : case accparser::CREATE: {
1193 0 : enterOuterAlt(_localctx, 5);
1194 0 : setState(382);
1195 0 : create_clause();
1196 : break;
1197 : }
1198 :
1199 0 : case accparser::DEFAULT: {
1200 0 : enterOuterAlt(_localctx, 6);
1201 0 : setState(383);
1202 0 : default_clause();
1203 : break;
1204 : }
1205 :
1206 0 : case accparser::DEVICEPTR: {
1207 0 : enterOuterAlt(_localctx, 7);
1208 0 : setState(384);
1209 0 : deviceptr_clause();
1210 : break;
1211 : }
1212 :
1213 0 : case accparser::IF: {
1214 0 : enterOuterAlt(_localctx, 8);
1215 0 : setState(385);
1216 0 : if_clause();
1217 : break;
1218 : }
1219 :
1220 0 : case accparser::NO_CREATE: {
1221 0 : enterOuterAlt(_localctx, 9);
1222 0 : setState(386);
1223 0 : no_create_clause();
1224 : break;
1225 : }
1226 :
1227 0 : case accparser::PRESENT: {
1228 0 : enterOuterAlt(_localctx, 10);
1229 0 : setState(387);
1230 0 : present_clause();
1231 : break;
1232 : }
1233 :
1234 0 : default:
1235 0 : throw NoViableAltException(this);
1236 : }
1237 :
1238 : }
1239 0 : catch (RecognitionException &e) {
1240 0 : _errHandler->reportError(this, e);
1241 0 : _localctx->exception = std::current_exception();
1242 0 : _errHandler->recover(this, _localctx->exception);
1243 : }
1244 :
1245 0 : return _localctx;
1246 : }
1247 :
1248 : //----------------- Declare_directiveContext ------------------------------------------------------------------
1249 :
1250 0 : accparser::Declare_directiveContext::Declare_directiveContext(ParserRuleContext *parent, size_t invokingState)
1251 0 : : ParserRuleContext(parent, invokingState) {
1252 0 : }
1253 :
1254 0 : tree::TerminalNode* accparser::Declare_directiveContext::DECLARE() {
1255 0 : return getToken(accparser::DECLARE, 0);
1256 : }
1257 :
1258 0 : accparser::Declare_clause_listContext* accparser::Declare_directiveContext::declare_clause_list() {
1259 0 : return getRuleContext<accparser::Declare_clause_listContext>(0);
1260 : }
1261 :
1262 :
1263 0 : size_t accparser::Declare_directiveContext::getRuleIndex() const {
1264 0 : return accparser::RuleDeclare_directive;
1265 : }
1266 :
1267 0 : void accparser::Declare_directiveContext::enterRule(tree::ParseTreeListener *listener) {
1268 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1269 0 : if (parserListener != nullptr)
1270 0 : parserListener->enterDeclare_directive(this);
1271 0 : }
1272 :
1273 0 : void accparser::Declare_directiveContext::exitRule(tree::ParseTreeListener *listener) {
1274 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1275 0 : if (parserListener != nullptr)
1276 0 : parserListener->exitDeclare_directive(this);
1277 0 : }
1278 :
1279 :
1280 0 : antlrcpp::Any accparser::Declare_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
1281 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1282 0 : return parserVisitor->visitDeclare_directive(this);
1283 : else
1284 0 : return visitor->visitChildren(this);
1285 : }
1286 :
1287 0 : accparser::Declare_directiveContext* accparser::declare_directive() {
1288 0 : Declare_directiveContext *_localctx = _tracker.createInstance<Declare_directiveContext>(_ctx, getState());
1289 0 : enterRule(_localctx, 24, accparser::RuleDeclare_directive);
1290 :
1291 0 : auto onExit = finally([=] {
1292 0 : exitRule();
1293 0 : });
1294 0 : try {
1295 0 : enterOuterAlt(_localctx, 1);
1296 0 : setState(390);
1297 0 : match(accparser::DECLARE);
1298 0 : setState(391);
1299 0 : declare_clause_list();
1300 :
1301 : }
1302 0 : catch (RecognitionException &e) {
1303 0 : _errHandler->reportError(this, e);
1304 0 : _localctx->exception = std::current_exception();
1305 0 : _errHandler->recover(this, _localctx->exception);
1306 : }
1307 :
1308 0 : return _localctx;
1309 : }
1310 :
1311 : //----------------- Declare_clause_listContext ------------------------------------------------------------------
1312 :
1313 0 : accparser::Declare_clause_listContext::Declare_clause_listContext(ParserRuleContext *parent, size_t invokingState)
1314 0 : : ParserRuleContext(parent, invokingState) {
1315 0 : }
1316 :
1317 0 : std::vector<accparser::Declare_clausesContext *> accparser::Declare_clause_listContext::declare_clauses() {
1318 0 : return getRuleContexts<accparser::Declare_clausesContext>();
1319 : }
1320 :
1321 0 : accparser::Declare_clausesContext* accparser::Declare_clause_listContext::declare_clauses(size_t i) {
1322 0 : return getRuleContext<accparser::Declare_clausesContext>(i);
1323 : }
1324 :
1325 :
1326 0 : size_t accparser::Declare_clause_listContext::getRuleIndex() const {
1327 0 : return accparser::RuleDeclare_clause_list;
1328 : }
1329 :
1330 0 : void accparser::Declare_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
1331 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1332 0 : if (parserListener != nullptr)
1333 0 : parserListener->enterDeclare_clause_list(this);
1334 0 : }
1335 :
1336 0 : void accparser::Declare_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
1337 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1338 0 : if (parserListener != nullptr)
1339 0 : parserListener->exitDeclare_clause_list(this);
1340 0 : }
1341 :
1342 :
1343 0 : antlrcpp::Any accparser::Declare_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
1344 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1345 0 : return parserVisitor->visitDeclare_clause_list(this);
1346 : else
1347 0 : return visitor->visitChildren(this);
1348 : }
1349 :
1350 0 : accparser::Declare_clause_listContext* accparser::declare_clause_list() {
1351 0 : Declare_clause_listContext *_localctx = _tracker.createInstance<Declare_clause_listContext>(_ctx, getState());
1352 0 : enterRule(_localctx, 26, accparser::RuleDeclare_clause_list);
1353 0 : size_t _la = 0;
1354 :
1355 0 : auto onExit = finally([=] {
1356 0 : exitRule();
1357 0 : });
1358 0 : try {
1359 0 : enterOuterAlt(_localctx, 1);
1360 0 : setState(394);
1361 0 : _errHandler->sync(this);
1362 0 : _la = _input->LA(1);
1363 0 : do {
1364 0 : setState(393);
1365 0 : declare_clauses();
1366 0 : setState(396);
1367 0 : _errHandler->sync(this);
1368 0 : _la = _input->LA(1);
1369 0 : } while ((((_la & ~ 0x3fULL) == 0) &&
1370 : ((1ULL << _la) & ((1ULL << accparser::COPY)
1371 : | (1ULL << accparser::COPYIN)
1372 : | (1ULL << accparser::COPYOUT)
1373 : | (1ULL << accparser::CREATE)
1374 : | (1ULL << accparser::DEVICE_RESIDENT)
1375 : | (1ULL << accparser::DEVICEPTR)
1376 : | (1ULL << accparser::LINK)
1377 0 : | (1ULL << accparser::PRESENT))) != 0));
1378 :
1379 : }
1380 0 : catch (RecognitionException &e) {
1381 0 : _errHandler->reportError(this, e);
1382 0 : _localctx->exception = std::current_exception();
1383 0 : _errHandler->recover(this, _localctx->exception);
1384 : }
1385 :
1386 0 : return _localctx;
1387 : }
1388 :
1389 : //----------------- Declare_clausesContext ------------------------------------------------------------------
1390 :
1391 0 : accparser::Declare_clausesContext::Declare_clausesContext(ParserRuleContext *parent, size_t invokingState)
1392 0 : : ParserRuleContext(parent, invokingState) {
1393 0 : }
1394 :
1395 0 : accparser::Copy_clauseContext* accparser::Declare_clausesContext::copy_clause() {
1396 0 : return getRuleContext<accparser::Copy_clauseContext>(0);
1397 : }
1398 :
1399 0 : accparser::Copyin_clauseContext* accparser::Declare_clausesContext::copyin_clause() {
1400 0 : return getRuleContext<accparser::Copyin_clauseContext>(0);
1401 : }
1402 :
1403 0 : accparser::Copyout_no_modifier_clauseContext* accparser::Declare_clausesContext::copyout_no_modifier_clause() {
1404 0 : return getRuleContext<accparser::Copyout_no_modifier_clauseContext>(0);
1405 : }
1406 :
1407 0 : accparser::Create_no_modifier_clauseContext* accparser::Declare_clausesContext::create_no_modifier_clause() {
1408 0 : return getRuleContext<accparser::Create_no_modifier_clauseContext>(0);
1409 : }
1410 :
1411 0 : accparser::Device_resident_clauseContext* accparser::Declare_clausesContext::device_resident_clause() {
1412 0 : return getRuleContext<accparser::Device_resident_clauseContext>(0);
1413 : }
1414 :
1415 0 : accparser::Deviceptr_clauseContext* accparser::Declare_clausesContext::deviceptr_clause() {
1416 0 : return getRuleContext<accparser::Deviceptr_clauseContext>(0);
1417 : }
1418 :
1419 0 : accparser::Link_clauseContext* accparser::Declare_clausesContext::link_clause() {
1420 0 : return getRuleContext<accparser::Link_clauseContext>(0);
1421 : }
1422 :
1423 0 : accparser::Present_clauseContext* accparser::Declare_clausesContext::present_clause() {
1424 0 : return getRuleContext<accparser::Present_clauseContext>(0);
1425 : }
1426 :
1427 :
1428 0 : size_t accparser::Declare_clausesContext::getRuleIndex() const {
1429 0 : return accparser::RuleDeclare_clauses;
1430 : }
1431 :
1432 0 : void accparser::Declare_clausesContext::enterRule(tree::ParseTreeListener *listener) {
1433 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1434 0 : if (parserListener != nullptr)
1435 0 : parserListener->enterDeclare_clauses(this);
1436 0 : }
1437 :
1438 0 : void accparser::Declare_clausesContext::exitRule(tree::ParseTreeListener *listener) {
1439 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1440 0 : if (parserListener != nullptr)
1441 0 : parserListener->exitDeclare_clauses(this);
1442 0 : }
1443 :
1444 :
1445 0 : antlrcpp::Any accparser::Declare_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
1446 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1447 0 : return parserVisitor->visitDeclare_clauses(this);
1448 : else
1449 0 : return visitor->visitChildren(this);
1450 : }
1451 :
1452 0 : accparser::Declare_clausesContext* accparser::declare_clauses() {
1453 0 : Declare_clausesContext *_localctx = _tracker.createInstance<Declare_clausesContext>(_ctx, getState());
1454 0 : enterRule(_localctx, 28, accparser::RuleDeclare_clauses);
1455 :
1456 0 : auto onExit = finally([=] {
1457 0 : exitRule();
1458 0 : });
1459 0 : try {
1460 0 : setState(406);
1461 0 : _errHandler->sync(this);
1462 0 : switch (_input->LA(1)) {
1463 0 : case accparser::COPY: {
1464 0 : enterOuterAlt(_localctx, 1);
1465 0 : setState(398);
1466 0 : copy_clause();
1467 : break;
1468 : }
1469 :
1470 0 : case accparser::COPYIN: {
1471 0 : enterOuterAlt(_localctx, 2);
1472 0 : setState(399);
1473 0 : copyin_clause();
1474 : break;
1475 : }
1476 :
1477 0 : case accparser::COPYOUT: {
1478 0 : enterOuterAlt(_localctx, 3);
1479 0 : setState(400);
1480 0 : copyout_no_modifier_clause();
1481 : break;
1482 : }
1483 :
1484 0 : case accparser::CREATE: {
1485 0 : enterOuterAlt(_localctx, 4);
1486 0 : setState(401);
1487 0 : create_no_modifier_clause();
1488 : break;
1489 : }
1490 :
1491 0 : case accparser::DEVICE_RESIDENT: {
1492 0 : enterOuterAlt(_localctx, 5);
1493 0 : setState(402);
1494 0 : device_resident_clause();
1495 : break;
1496 : }
1497 :
1498 0 : case accparser::DEVICEPTR: {
1499 0 : enterOuterAlt(_localctx, 6);
1500 0 : setState(403);
1501 0 : deviceptr_clause();
1502 : break;
1503 : }
1504 :
1505 0 : case accparser::LINK: {
1506 0 : enterOuterAlt(_localctx, 7);
1507 0 : setState(404);
1508 0 : link_clause();
1509 : break;
1510 : }
1511 :
1512 0 : case accparser::PRESENT: {
1513 0 : enterOuterAlt(_localctx, 8);
1514 0 : setState(405);
1515 0 : present_clause();
1516 : break;
1517 : }
1518 :
1519 0 : default:
1520 0 : throw NoViableAltException(this);
1521 : }
1522 :
1523 : }
1524 0 : catch (RecognitionException &e) {
1525 0 : _errHandler->reportError(this, e);
1526 0 : _localctx->exception = std::current_exception();
1527 0 : _errHandler->recover(this, _localctx->exception);
1528 : }
1529 :
1530 0 : return _localctx;
1531 : }
1532 :
1533 : //----------------- End_directiveContext ------------------------------------------------------------------
1534 :
1535 0 : accparser::End_directiveContext::End_directiveContext(ParserRuleContext *parent, size_t invokingState)
1536 0 : : ParserRuleContext(parent, invokingState) {
1537 0 : }
1538 :
1539 0 : tree::TerminalNode* accparser::End_directiveContext::END() {
1540 0 : return getToken(accparser::END, 0);
1541 : }
1542 :
1543 0 : accparser::End_clause_seqContext* accparser::End_directiveContext::end_clause_seq() {
1544 0 : return getRuleContext<accparser::End_clause_seqContext>(0);
1545 : }
1546 :
1547 :
1548 0 : size_t accparser::End_directiveContext::getRuleIndex() const {
1549 0 : return accparser::RuleEnd_directive;
1550 : }
1551 :
1552 0 : void accparser::End_directiveContext::enterRule(tree::ParseTreeListener *listener) {
1553 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1554 0 : if (parserListener != nullptr)
1555 0 : parserListener->enterEnd_directive(this);
1556 0 : }
1557 :
1558 0 : void accparser::End_directiveContext::exitRule(tree::ParseTreeListener *listener) {
1559 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1560 0 : if (parserListener != nullptr)
1561 0 : parserListener->exitEnd_directive(this);
1562 0 : }
1563 :
1564 :
1565 0 : antlrcpp::Any accparser::End_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
1566 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1567 0 : return parserVisitor->visitEnd_directive(this);
1568 : else
1569 0 : return visitor->visitChildren(this);
1570 : }
1571 :
1572 0 : accparser::End_directiveContext* accparser::end_directive() {
1573 0 : End_directiveContext *_localctx = _tracker.createInstance<End_directiveContext>(_ctx, getState());
1574 0 : enterRule(_localctx, 30, accparser::RuleEnd_directive);
1575 :
1576 0 : auto onExit = finally([=] {
1577 0 : exitRule();
1578 0 : });
1579 0 : try {
1580 0 : enterOuterAlt(_localctx, 1);
1581 0 : setState(408);
1582 0 : match(accparser::END);
1583 0 : setState(409);
1584 0 : end_clause_seq();
1585 :
1586 : }
1587 0 : catch (RecognitionException &e) {
1588 0 : _errHandler->reportError(this, e);
1589 0 : _localctx->exception = std::current_exception();
1590 0 : _errHandler->recover(this, _localctx->exception);
1591 : }
1592 :
1593 0 : return _localctx;
1594 : }
1595 :
1596 : //----------------- End_clause_seqContext ------------------------------------------------------------------
1597 :
1598 0 : accparser::End_clause_seqContext::End_clause_seqContext(ParserRuleContext *parent, size_t invokingState)
1599 0 : : ParserRuleContext(parent, invokingState) {
1600 0 : }
1601 :
1602 0 : accparser::Fortran_paired_directiveContext* accparser::End_clause_seqContext::fortran_paired_directive() {
1603 0 : return getRuleContext<accparser::Fortran_paired_directiveContext>(0);
1604 : }
1605 :
1606 :
1607 0 : size_t accparser::End_clause_seqContext::getRuleIndex() const {
1608 0 : return accparser::RuleEnd_clause_seq;
1609 : }
1610 :
1611 0 : void accparser::End_clause_seqContext::enterRule(tree::ParseTreeListener *listener) {
1612 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1613 0 : if (parserListener != nullptr)
1614 0 : parserListener->enterEnd_clause_seq(this);
1615 0 : }
1616 :
1617 0 : void accparser::End_clause_seqContext::exitRule(tree::ParseTreeListener *listener) {
1618 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1619 0 : if (parserListener != nullptr)
1620 0 : parserListener->exitEnd_clause_seq(this);
1621 0 : }
1622 :
1623 :
1624 0 : antlrcpp::Any accparser::End_clause_seqContext::accept(tree::ParseTreeVisitor *visitor) {
1625 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1626 0 : return parserVisitor->visitEnd_clause_seq(this);
1627 : else
1628 0 : return visitor->visitChildren(this);
1629 : }
1630 :
1631 0 : accparser::End_clause_seqContext* accparser::end_clause_seq() {
1632 0 : End_clause_seqContext *_localctx = _tracker.createInstance<End_clause_seqContext>(_ctx, getState());
1633 0 : enterRule(_localctx, 32, accparser::RuleEnd_clause_seq);
1634 :
1635 0 : auto onExit = finally([=] {
1636 0 : exitRule();
1637 0 : });
1638 0 : try {
1639 0 : enterOuterAlt(_localctx, 1);
1640 0 : setState(411);
1641 0 : fortran_paired_directive();
1642 :
1643 : }
1644 0 : catch (RecognitionException &e) {
1645 0 : _errHandler->reportError(this, e);
1646 0 : _localctx->exception = std::current_exception();
1647 0 : _errHandler->recover(this, _localctx->exception);
1648 : }
1649 :
1650 0 : return _localctx;
1651 : }
1652 :
1653 : //----------------- Fortran_paired_directiveContext ------------------------------------------------------------------
1654 :
1655 0 : accparser::Fortran_paired_directiveContext::Fortran_paired_directiveContext(ParserRuleContext *parent, size_t invokingState)
1656 0 : : ParserRuleContext(parent, invokingState) {
1657 0 : }
1658 :
1659 0 : accparser::End_atomic_directiveContext* accparser::Fortran_paired_directiveContext::end_atomic_directive() {
1660 0 : return getRuleContext<accparser::End_atomic_directiveContext>(0);
1661 : }
1662 :
1663 0 : accparser::End_data_directiveContext* accparser::Fortran_paired_directiveContext::end_data_directive() {
1664 0 : return getRuleContext<accparser::End_data_directiveContext>(0);
1665 : }
1666 :
1667 0 : accparser::End_host_data_directiveContext* accparser::Fortran_paired_directiveContext::end_host_data_directive() {
1668 0 : return getRuleContext<accparser::End_host_data_directiveContext>(0);
1669 : }
1670 :
1671 0 : accparser::End_kernels_directiveContext* accparser::Fortran_paired_directiveContext::end_kernels_directive() {
1672 0 : return getRuleContext<accparser::End_kernels_directiveContext>(0);
1673 : }
1674 :
1675 0 : accparser::End_kernels_loop_directiveContext* accparser::Fortran_paired_directiveContext::end_kernels_loop_directive() {
1676 0 : return getRuleContext<accparser::End_kernels_loop_directiveContext>(0);
1677 : }
1678 :
1679 0 : accparser::End_parallel_directiveContext* accparser::Fortran_paired_directiveContext::end_parallel_directive() {
1680 0 : return getRuleContext<accparser::End_parallel_directiveContext>(0);
1681 : }
1682 :
1683 0 : accparser::End_parallel_loop_directiveContext* accparser::Fortran_paired_directiveContext::end_parallel_loop_directive() {
1684 0 : return getRuleContext<accparser::End_parallel_loop_directiveContext>(0);
1685 : }
1686 :
1687 0 : accparser::End_serial_directiveContext* accparser::Fortran_paired_directiveContext::end_serial_directive() {
1688 0 : return getRuleContext<accparser::End_serial_directiveContext>(0);
1689 : }
1690 :
1691 0 : accparser::End_serial_loop_directiveContext* accparser::Fortran_paired_directiveContext::end_serial_loop_directive() {
1692 0 : return getRuleContext<accparser::End_serial_loop_directiveContext>(0);
1693 : }
1694 :
1695 :
1696 0 : size_t accparser::Fortran_paired_directiveContext::getRuleIndex() const {
1697 0 : return accparser::RuleFortran_paired_directive;
1698 : }
1699 :
1700 0 : void accparser::Fortran_paired_directiveContext::enterRule(tree::ParseTreeListener *listener) {
1701 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1702 0 : if (parserListener != nullptr)
1703 0 : parserListener->enterFortran_paired_directive(this);
1704 0 : }
1705 :
1706 0 : void accparser::Fortran_paired_directiveContext::exitRule(tree::ParseTreeListener *listener) {
1707 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1708 0 : if (parserListener != nullptr)
1709 0 : parserListener->exitFortran_paired_directive(this);
1710 0 : }
1711 :
1712 :
1713 0 : antlrcpp::Any accparser::Fortran_paired_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
1714 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1715 0 : return parserVisitor->visitFortran_paired_directive(this);
1716 : else
1717 0 : return visitor->visitChildren(this);
1718 : }
1719 :
1720 0 : accparser::Fortran_paired_directiveContext* accparser::fortran_paired_directive() {
1721 0 : Fortran_paired_directiveContext *_localctx = _tracker.createInstance<Fortran_paired_directiveContext>(_ctx, getState());
1722 0 : enterRule(_localctx, 34, accparser::RuleFortran_paired_directive);
1723 :
1724 0 : auto onExit = finally([=] {
1725 0 : exitRule();
1726 0 : });
1727 0 : try {
1728 0 : setState(422);
1729 0 : _errHandler->sync(this);
1730 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
1731 0 : case 1: {
1732 0 : enterOuterAlt(_localctx, 1);
1733 0 : setState(413);
1734 0 : end_atomic_directive();
1735 : break;
1736 : }
1737 :
1738 0 : case 2: {
1739 0 : enterOuterAlt(_localctx, 2);
1740 0 : setState(414);
1741 0 : end_data_directive();
1742 : break;
1743 : }
1744 :
1745 0 : case 3: {
1746 0 : enterOuterAlt(_localctx, 3);
1747 0 : setState(415);
1748 0 : end_host_data_directive();
1749 : break;
1750 : }
1751 :
1752 0 : case 4: {
1753 0 : enterOuterAlt(_localctx, 4);
1754 0 : setState(416);
1755 0 : end_kernels_directive();
1756 : break;
1757 : }
1758 :
1759 0 : case 5: {
1760 0 : enterOuterAlt(_localctx, 5);
1761 0 : setState(417);
1762 0 : end_kernels_loop_directive();
1763 : break;
1764 : }
1765 :
1766 0 : case 6: {
1767 0 : enterOuterAlt(_localctx, 6);
1768 0 : setState(418);
1769 0 : end_parallel_directive();
1770 : break;
1771 : }
1772 :
1773 0 : case 7: {
1774 0 : enterOuterAlt(_localctx, 7);
1775 0 : setState(419);
1776 0 : end_parallel_loop_directive();
1777 : break;
1778 : }
1779 :
1780 0 : case 8: {
1781 0 : enterOuterAlt(_localctx, 8);
1782 0 : setState(420);
1783 0 : end_serial_directive();
1784 : break;
1785 : }
1786 :
1787 0 : case 9: {
1788 0 : enterOuterAlt(_localctx, 9);
1789 0 : setState(421);
1790 0 : end_serial_loop_directive();
1791 : break;
1792 : }
1793 :
1794 : }
1795 :
1796 : }
1797 0 : catch (RecognitionException &e) {
1798 0 : _errHandler->reportError(this, e);
1799 0 : _localctx->exception = std::current_exception();
1800 0 : _errHandler->recover(this, _localctx->exception);
1801 : }
1802 :
1803 0 : return _localctx;
1804 : }
1805 :
1806 : //----------------- End_atomic_directiveContext ------------------------------------------------------------------
1807 :
1808 0 : accparser::End_atomic_directiveContext::End_atomic_directiveContext(ParserRuleContext *parent, size_t invokingState)
1809 0 : : ParserRuleContext(parent, invokingState) {
1810 0 : }
1811 :
1812 0 : accparser::Atomic_directiveContext* accparser::End_atomic_directiveContext::atomic_directive() {
1813 0 : return getRuleContext<accparser::Atomic_directiveContext>(0);
1814 : }
1815 :
1816 :
1817 0 : size_t accparser::End_atomic_directiveContext::getRuleIndex() const {
1818 0 : return accparser::RuleEnd_atomic_directive;
1819 : }
1820 :
1821 0 : void accparser::End_atomic_directiveContext::enterRule(tree::ParseTreeListener *listener) {
1822 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1823 0 : if (parserListener != nullptr)
1824 0 : parserListener->enterEnd_atomic_directive(this);
1825 0 : }
1826 :
1827 0 : void accparser::End_atomic_directiveContext::exitRule(tree::ParseTreeListener *listener) {
1828 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1829 0 : if (parserListener != nullptr)
1830 0 : parserListener->exitEnd_atomic_directive(this);
1831 0 : }
1832 :
1833 :
1834 0 : antlrcpp::Any accparser::End_atomic_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
1835 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1836 0 : return parserVisitor->visitEnd_atomic_directive(this);
1837 : else
1838 0 : return visitor->visitChildren(this);
1839 : }
1840 :
1841 0 : accparser::End_atomic_directiveContext* accparser::end_atomic_directive() {
1842 0 : End_atomic_directiveContext *_localctx = _tracker.createInstance<End_atomic_directiveContext>(_ctx, getState());
1843 0 : enterRule(_localctx, 36, accparser::RuleEnd_atomic_directive);
1844 :
1845 0 : auto onExit = finally([=] {
1846 0 : exitRule();
1847 0 : });
1848 0 : try {
1849 0 : enterOuterAlt(_localctx, 1);
1850 0 : setState(424);
1851 0 : atomic_directive();
1852 :
1853 : }
1854 0 : catch (RecognitionException &e) {
1855 0 : _errHandler->reportError(this, e);
1856 0 : _localctx->exception = std::current_exception();
1857 0 : _errHandler->recover(this, _localctx->exception);
1858 : }
1859 :
1860 0 : return _localctx;
1861 : }
1862 :
1863 : //----------------- End_data_directiveContext ------------------------------------------------------------------
1864 :
1865 0 : accparser::End_data_directiveContext::End_data_directiveContext(ParserRuleContext *parent, size_t invokingState)
1866 0 : : ParserRuleContext(parent, invokingState) {
1867 0 : }
1868 :
1869 0 : accparser::Data_directiveContext* accparser::End_data_directiveContext::data_directive() {
1870 0 : return getRuleContext<accparser::Data_directiveContext>(0);
1871 : }
1872 :
1873 :
1874 0 : size_t accparser::End_data_directiveContext::getRuleIndex() const {
1875 0 : return accparser::RuleEnd_data_directive;
1876 : }
1877 :
1878 0 : void accparser::End_data_directiveContext::enterRule(tree::ParseTreeListener *listener) {
1879 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1880 0 : if (parserListener != nullptr)
1881 0 : parserListener->enterEnd_data_directive(this);
1882 0 : }
1883 :
1884 0 : void accparser::End_data_directiveContext::exitRule(tree::ParseTreeListener *listener) {
1885 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1886 0 : if (parserListener != nullptr)
1887 0 : parserListener->exitEnd_data_directive(this);
1888 0 : }
1889 :
1890 :
1891 0 : antlrcpp::Any accparser::End_data_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
1892 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1893 0 : return parserVisitor->visitEnd_data_directive(this);
1894 : else
1895 0 : return visitor->visitChildren(this);
1896 : }
1897 :
1898 0 : accparser::End_data_directiveContext* accparser::end_data_directive() {
1899 0 : End_data_directiveContext *_localctx = _tracker.createInstance<End_data_directiveContext>(_ctx, getState());
1900 0 : enterRule(_localctx, 38, accparser::RuleEnd_data_directive);
1901 :
1902 0 : auto onExit = finally([=] {
1903 0 : exitRule();
1904 0 : });
1905 0 : try {
1906 0 : enterOuterAlt(_localctx, 1);
1907 0 : setState(426);
1908 0 : data_directive();
1909 :
1910 : }
1911 0 : catch (RecognitionException &e) {
1912 0 : _errHandler->reportError(this, e);
1913 0 : _localctx->exception = std::current_exception();
1914 0 : _errHandler->recover(this, _localctx->exception);
1915 : }
1916 :
1917 0 : return _localctx;
1918 : }
1919 :
1920 : //----------------- End_host_data_directiveContext ------------------------------------------------------------------
1921 :
1922 0 : accparser::End_host_data_directiveContext::End_host_data_directiveContext(ParserRuleContext *parent, size_t invokingState)
1923 0 : : ParserRuleContext(parent, invokingState) {
1924 0 : }
1925 :
1926 0 : tree::TerminalNode* accparser::End_host_data_directiveContext::HOST_DATA() {
1927 0 : return getToken(accparser::HOST_DATA, 0);
1928 : }
1929 :
1930 :
1931 0 : size_t accparser::End_host_data_directiveContext::getRuleIndex() const {
1932 0 : return accparser::RuleEnd_host_data_directive;
1933 : }
1934 :
1935 0 : void accparser::End_host_data_directiveContext::enterRule(tree::ParseTreeListener *listener) {
1936 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1937 0 : if (parserListener != nullptr)
1938 0 : parserListener->enterEnd_host_data_directive(this);
1939 0 : }
1940 :
1941 0 : void accparser::End_host_data_directiveContext::exitRule(tree::ParseTreeListener *listener) {
1942 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1943 0 : if (parserListener != nullptr)
1944 0 : parserListener->exitEnd_host_data_directive(this);
1945 0 : }
1946 :
1947 :
1948 0 : antlrcpp::Any accparser::End_host_data_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
1949 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
1950 0 : return parserVisitor->visitEnd_host_data_directive(this);
1951 : else
1952 0 : return visitor->visitChildren(this);
1953 : }
1954 :
1955 0 : accparser::End_host_data_directiveContext* accparser::end_host_data_directive() {
1956 0 : End_host_data_directiveContext *_localctx = _tracker.createInstance<End_host_data_directiveContext>(_ctx, getState());
1957 0 : enterRule(_localctx, 40, accparser::RuleEnd_host_data_directive);
1958 :
1959 0 : auto onExit = finally([=] {
1960 0 : exitRule();
1961 0 : });
1962 0 : try {
1963 0 : enterOuterAlt(_localctx, 1);
1964 0 : setState(428);
1965 0 : match(accparser::HOST_DATA);
1966 :
1967 : }
1968 0 : catch (RecognitionException &e) {
1969 0 : _errHandler->reportError(this, e);
1970 0 : _localctx->exception = std::current_exception();
1971 0 : _errHandler->recover(this, _localctx->exception);
1972 : }
1973 :
1974 0 : return _localctx;
1975 : }
1976 :
1977 : //----------------- End_kernels_directiveContext ------------------------------------------------------------------
1978 :
1979 0 : accparser::End_kernels_directiveContext::End_kernels_directiveContext(ParserRuleContext *parent, size_t invokingState)
1980 0 : : ParserRuleContext(parent, invokingState) {
1981 0 : }
1982 :
1983 0 : accparser::Kernels_directiveContext* accparser::End_kernels_directiveContext::kernels_directive() {
1984 0 : return getRuleContext<accparser::Kernels_directiveContext>(0);
1985 : }
1986 :
1987 :
1988 0 : size_t accparser::End_kernels_directiveContext::getRuleIndex() const {
1989 0 : return accparser::RuleEnd_kernels_directive;
1990 : }
1991 :
1992 0 : void accparser::End_kernels_directiveContext::enterRule(tree::ParseTreeListener *listener) {
1993 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
1994 0 : if (parserListener != nullptr)
1995 0 : parserListener->enterEnd_kernels_directive(this);
1996 0 : }
1997 :
1998 0 : void accparser::End_kernels_directiveContext::exitRule(tree::ParseTreeListener *listener) {
1999 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2000 0 : if (parserListener != nullptr)
2001 0 : parserListener->exitEnd_kernels_directive(this);
2002 0 : }
2003 :
2004 :
2005 0 : antlrcpp::Any accparser::End_kernels_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
2006 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2007 0 : return parserVisitor->visitEnd_kernels_directive(this);
2008 : else
2009 0 : return visitor->visitChildren(this);
2010 : }
2011 :
2012 0 : accparser::End_kernels_directiveContext* accparser::end_kernels_directive() {
2013 0 : End_kernels_directiveContext *_localctx = _tracker.createInstance<End_kernels_directiveContext>(_ctx, getState());
2014 0 : enterRule(_localctx, 42, accparser::RuleEnd_kernels_directive);
2015 :
2016 0 : auto onExit = finally([=] {
2017 0 : exitRule();
2018 0 : });
2019 0 : try {
2020 0 : enterOuterAlt(_localctx, 1);
2021 0 : setState(430);
2022 0 : kernels_directive();
2023 :
2024 : }
2025 0 : catch (RecognitionException &e) {
2026 0 : _errHandler->reportError(this, e);
2027 0 : _localctx->exception = std::current_exception();
2028 0 : _errHandler->recover(this, _localctx->exception);
2029 : }
2030 :
2031 0 : return _localctx;
2032 : }
2033 :
2034 : //----------------- End_kernels_loop_directiveContext ------------------------------------------------------------------
2035 :
2036 0 : accparser::End_kernels_loop_directiveContext::End_kernels_loop_directiveContext(ParserRuleContext *parent, size_t invokingState)
2037 0 : : ParserRuleContext(parent, invokingState) {
2038 0 : }
2039 :
2040 0 : accparser::Kernels_loop_directiveContext* accparser::End_kernels_loop_directiveContext::kernels_loop_directive() {
2041 0 : return getRuleContext<accparser::Kernels_loop_directiveContext>(0);
2042 : }
2043 :
2044 :
2045 0 : size_t accparser::End_kernels_loop_directiveContext::getRuleIndex() const {
2046 0 : return accparser::RuleEnd_kernels_loop_directive;
2047 : }
2048 :
2049 0 : void accparser::End_kernels_loop_directiveContext::enterRule(tree::ParseTreeListener *listener) {
2050 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2051 0 : if (parserListener != nullptr)
2052 0 : parserListener->enterEnd_kernels_loop_directive(this);
2053 0 : }
2054 :
2055 0 : void accparser::End_kernels_loop_directiveContext::exitRule(tree::ParseTreeListener *listener) {
2056 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2057 0 : if (parserListener != nullptr)
2058 0 : parserListener->exitEnd_kernels_loop_directive(this);
2059 0 : }
2060 :
2061 :
2062 0 : antlrcpp::Any accparser::End_kernels_loop_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
2063 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2064 0 : return parserVisitor->visitEnd_kernels_loop_directive(this);
2065 : else
2066 0 : return visitor->visitChildren(this);
2067 : }
2068 :
2069 0 : accparser::End_kernels_loop_directiveContext* accparser::end_kernels_loop_directive() {
2070 0 : End_kernels_loop_directiveContext *_localctx = _tracker.createInstance<End_kernels_loop_directiveContext>(_ctx, getState());
2071 0 : enterRule(_localctx, 44, accparser::RuleEnd_kernels_loop_directive);
2072 :
2073 0 : auto onExit = finally([=] {
2074 0 : exitRule();
2075 0 : });
2076 0 : try {
2077 0 : enterOuterAlt(_localctx, 1);
2078 0 : setState(432);
2079 0 : kernels_loop_directive();
2080 :
2081 : }
2082 0 : catch (RecognitionException &e) {
2083 0 : _errHandler->reportError(this, e);
2084 0 : _localctx->exception = std::current_exception();
2085 0 : _errHandler->recover(this, _localctx->exception);
2086 : }
2087 :
2088 0 : return _localctx;
2089 : }
2090 :
2091 : //----------------- End_parallel_directiveContext ------------------------------------------------------------------
2092 :
2093 0 : accparser::End_parallel_directiveContext::End_parallel_directiveContext(ParserRuleContext *parent, size_t invokingState)
2094 0 : : ParserRuleContext(parent, invokingState) {
2095 0 : }
2096 :
2097 0 : accparser::Parallel_directiveContext* accparser::End_parallel_directiveContext::parallel_directive() {
2098 0 : return getRuleContext<accparser::Parallel_directiveContext>(0);
2099 : }
2100 :
2101 :
2102 0 : size_t accparser::End_parallel_directiveContext::getRuleIndex() const {
2103 0 : return accparser::RuleEnd_parallel_directive;
2104 : }
2105 :
2106 0 : void accparser::End_parallel_directiveContext::enterRule(tree::ParseTreeListener *listener) {
2107 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2108 0 : if (parserListener != nullptr)
2109 0 : parserListener->enterEnd_parallel_directive(this);
2110 0 : }
2111 :
2112 0 : void accparser::End_parallel_directiveContext::exitRule(tree::ParseTreeListener *listener) {
2113 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2114 0 : if (parserListener != nullptr)
2115 0 : parserListener->exitEnd_parallel_directive(this);
2116 0 : }
2117 :
2118 :
2119 0 : antlrcpp::Any accparser::End_parallel_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
2120 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2121 0 : return parserVisitor->visitEnd_parallel_directive(this);
2122 : else
2123 0 : return visitor->visitChildren(this);
2124 : }
2125 :
2126 0 : accparser::End_parallel_directiveContext* accparser::end_parallel_directive() {
2127 0 : End_parallel_directiveContext *_localctx = _tracker.createInstance<End_parallel_directiveContext>(_ctx, getState());
2128 0 : enterRule(_localctx, 46, accparser::RuleEnd_parallel_directive);
2129 :
2130 0 : auto onExit = finally([=] {
2131 0 : exitRule();
2132 0 : });
2133 0 : try {
2134 0 : enterOuterAlt(_localctx, 1);
2135 0 : setState(434);
2136 0 : parallel_directive();
2137 :
2138 : }
2139 0 : catch (RecognitionException &e) {
2140 0 : _errHandler->reportError(this, e);
2141 0 : _localctx->exception = std::current_exception();
2142 0 : _errHandler->recover(this, _localctx->exception);
2143 : }
2144 :
2145 0 : return _localctx;
2146 : }
2147 :
2148 : //----------------- End_parallel_loop_directiveContext ------------------------------------------------------------------
2149 :
2150 0 : accparser::End_parallel_loop_directiveContext::End_parallel_loop_directiveContext(ParserRuleContext *parent, size_t invokingState)
2151 0 : : ParserRuleContext(parent, invokingState) {
2152 0 : }
2153 :
2154 0 : accparser::Parallel_loop_directiveContext* accparser::End_parallel_loop_directiveContext::parallel_loop_directive() {
2155 0 : return getRuleContext<accparser::Parallel_loop_directiveContext>(0);
2156 : }
2157 :
2158 :
2159 0 : size_t accparser::End_parallel_loop_directiveContext::getRuleIndex() const {
2160 0 : return accparser::RuleEnd_parallel_loop_directive;
2161 : }
2162 :
2163 0 : void accparser::End_parallel_loop_directiveContext::enterRule(tree::ParseTreeListener *listener) {
2164 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2165 0 : if (parserListener != nullptr)
2166 0 : parserListener->enterEnd_parallel_loop_directive(this);
2167 0 : }
2168 :
2169 0 : void accparser::End_parallel_loop_directiveContext::exitRule(tree::ParseTreeListener *listener) {
2170 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2171 0 : if (parserListener != nullptr)
2172 0 : parserListener->exitEnd_parallel_loop_directive(this);
2173 0 : }
2174 :
2175 :
2176 0 : antlrcpp::Any accparser::End_parallel_loop_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
2177 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2178 0 : return parserVisitor->visitEnd_parallel_loop_directive(this);
2179 : else
2180 0 : return visitor->visitChildren(this);
2181 : }
2182 :
2183 0 : accparser::End_parallel_loop_directiveContext* accparser::end_parallel_loop_directive() {
2184 0 : End_parallel_loop_directiveContext *_localctx = _tracker.createInstance<End_parallel_loop_directiveContext>(_ctx, getState());
2185 0 : enterRule(_localctx, 48, accparser::RuleEnd_parallel_loop_directive);
2186 :
2187 0 : auto onExit = finally([=] {
2188 0 : exitRule();
2189 0 : });
2190 0 : try {
2191 0 : enterOuterAlt(_localctx, 1);
2192 0 : setState(436);
2193 0 : parallel_loop_directive();
2194 :
2195 : }
2196 0 : catch (RecognitionException &e) {
2197 0 : _errHandler->reportError(this, e);
2198 0 : _localctx->exception = std::current_exception();
2199 0 : _errHandler->recover(this, _localctx->exception);
2200 : }
2201 :
2202 0 : return _localctx;
2203 : }
2204 :
2205 : //----------------- End_serial_directiveContext ------------------------------------------------------------------
2206 :
2207 0 : accparser::End_serial_directiveContext::End_serial_directiveContext(ParserRuleContext *parent, size_t invokingState)
2208 0 : : ParserRuleContext(parent, invokingState) {
2209 0 : }
2210 :
2211 0 : accparser::Serial_directiveContext* accparser::End_serial_directiveContext::serial_directive() {
2212 0 : return getRuleContext<accparser::Serial_directiveContext>(0);
2213 : }
2214 :
2215 :
2216 0 : size_t accparser::End_serial_directiveContext::getRuleIndex() const {
2217 0 : return accparser::RuleEnd_serial_directive;
2218 : }
2219 :
2220 0 : void accparser::End_serial_directiveContext::enterRule(tree::ParseTreeListener *listener) {
2221 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2222 0 : if (parserListener != nullptr)
2223 0 : parserListener->enterEnd_serial_directive(this);
2224 0 : }
2225 :
2226 0 : void accparser::End_serial_directiveContext::exitRule(tree::ParseTreeListener *listener) {
2227 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2228 0 : if (parserListener != nullptr)
2229 0 : parserListener->exitEnd_serial_directive(this);
2230 0 : }
2231 :
2232 :
2233 0 : antlrcpp::Any accparser::End_serial_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
2234 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2235 0 : return parserVisitor->visitEnd_serial_directive(this);
2236 : else
2237 0 : return visitor->visitChildren(this);
2238 : }
2239 :
2240 0 : accparser::End_serial_directiveContext* accparser::end_serial_directive() {
2241 0 : End_serial_directiveContext *_localctx = _tracker.createInstance<End_serial_directiveContext>(_ctx, getState());
2242 0 : enterRule(_localctx, 50, accparser::RuleEnd_serial_directive);
2243 :
2244 0 : auto onExit = finally([=] {
2245 0 : exitRule();
2246 0 : });
2247 0 : try {
2248 0 : enterOuterAlt(_localctx, 1);
2249 0 : setState(438);
2250 0 : serial_directive();
2251 :
2252 : }
2253 0 : catch (RecognitionException &e) {
2254 0 : _errHandler->reportError(this, e);
2255 0 : _localctx->exception = std::current_exception();
2256 0 : _errHandler->recover(this, _localctx->exception);
2257 : }
2258 :
2259 0 : return _localctx;
2260 : }
2261 :
2262 : //----------------- End_serial_loop_directiveContext ------------------------------------------------------------------
2263 :
2264 0 : accparser::End_serial_loop_directiveContext::End_serial_loop_directiveContext(ParserRuleContext *parent, size_t invokingState)
2265 0 : : ParserRuleContext(parent, invokingState) {
2266 0 : }
2267 :
2268 0 : accparser::Serial_loop_directiveContext* accparser::End_serial_loop_directiveContext::serial_loop_directive() {
2269 0 : return getRuleContext<accparser::Serial_loop_directiveContext>(0);
2270 : }
2271 :
2272 :
2273 0 : size_t accparser::End_serial_loop_directiveContext::getRuleIndex() const {
2274 0 : return accparser::RuleEnd_serial_loop_directive;
2275 : }
2276 :
2277 0 : void accparser::End_serial_loop_directiveContext::enterRule(tree::ParseTreeListener *listener) {
2278 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2279 0 : if (parserListener != nullptr)
2280 0 : parserListener->enterEnd_serial_loop_directive(this);
2281 0 : }
2282 :
2283 0 : void accparser::End_serial_loop_directiveContext::exitRule(tree::ParseTreeListener *listener) {
2284 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2285 0 : if (parserListener != nullptr)
2286 0 : parserListener->exitEnd_serial_loop_directive(this);
2287 0 : }
2288 :
2289 :
2290 0 : antlrcpp::Any accparser::End_serial_loop_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
2291 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2292 0 : return parserVisitor->visitEnd_serial_loop_directive(this);
2293 : else
2294 0 : return visitor->visitChildren(this);
2295 : }
2296 :
2297 0 : accparser::End_serial_loop_directiveContext* accparser::end_serial_loop_directive() {
2298 0 : End_serial_loop_directiveContext *_localctx = _tracker.createInstance<End_serial_loop_directiveContext>(_ctx, getState());
2299 0 : enterRule(_localctx, 52, accparser::RuleEnd_serial_loop_directive);
2300 :
2301 0 : auto onExit = finally([=] {
2302 0 : exitRule();
2303 0 : });
2304 0 : try {
2305 0 : enterOuterAlt(_localctx, 1);
2306 0 : setState(440);
2307 0 : serial_loop_directive();
2308 :
2309 : }
2310 0 : catch (RecognitionException &e) {
2311 0 : _errHandler->reportError(this, e);
2312 0 : _localctx->exception = std::current_exception();
2313 0 : _errHandler->recover(this, _localctx->exception);
2314 : }
2315 :
2316 0 : return _localctx;
2317 : }
2318 :
2319 : //----------------- Enter_data_directiveContext ------------------------------------------------------------------
2320 :
2321 0 : accparser::Enter_data_directiveContext::Enter_data_directiveContext(ParserRuleContext *parent, size_t invokingState)
2322 0 : : ParserRuleContext(parent, invokingState) {
2323 0 : }
2324 :
2325 0 : tree::TerminalNode* accparser::Enter_data_directiveContext::ENTER() {
2326 0 : return getToken(accparser::ENTER, 0);
2327 : }
2328 :
2329 0 : tree::TerminalNode* accparser::Enter_data_directiveContext::DATA() {
2330 0 : return getToken(accparser::DATA, 0);
2331 : }
2332 :
2333 0 : accparser::Enter_data_clause_listContext* accparser::Enter_data_directiveContext::enter_data_clause_list() {
2334 0 : return getRuleContext<accparser::Enter_data_clause_listContext>(0);
2335 : }
2336 :
2337 :
2338 0 : size_t accparser::Enter_data_directiveContext::getRuleIndex() const {
2339 0 : return accparser::RuleEnter_data_directive;
2340 : }
2341 :
2342 0 : void accparser::Enter_data_directiveContext::enterRule(tree::ParseTreeListener *listener) {
2343 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2344 0 : if (parserListener != nullptr)
2345 0 : parserListener->enterEnter_data_directive(this);
2346 0 : }
2347 :
2348 0 : void accparser::Enter_data_directiveContext::exitRule(tree::ParseTreeListener *listener) {
2349 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2350 0 : if (parserListener != nullptr)
2351 0 : parserListener->exitEnter_data_directive(this);
2352 0 : }
2353 :
2354 :
2355 0 : antlrcpp::Any accparser::Enter_data_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
2356 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2357 0 : return parserVisitor->visitEnter_data_directive(this);
2358 : else
2359 0 : return visitor->visitChildren(this);
2360 : }
2361 :
2362 0 : accparser::Enter_data_directiveContext* accparser::enter_data_directive() {
2363 0 : Enter_data_directiveContext *_localctx = _tracker.createInstance<Enter_data_directiveContext>(_ctx, getState());
2364 0 : enterRule(_localctx, 54, accparser::RuleEnter_data_directive);
2365 :
2366 0 : auto onExit = finally([=] {
2367 0 : exitRule();
2368 0 : });
2369 0 : try {
2370 0 : enterOuterAlt(_localctx, 1);
2371 0 : setState(442);
2372 0 : match(accparser::ENTER);
2373 0 : setState(443);
2374 0 : match(accparser::DATA);
2375 0 : setState(444);
2376 0 : enter_data_clause_list();
2377 :
2378 : }
2379 0 : catch (RecognitionException &e) {
2380 0 : _errHandler->reportError(this, e);
2381 0 : _localctx->exception = std::current_exception();
2382 0 : _errHandler->recover(this, _localctx->exception);
2383 : }
2384 :
2385 0 : return _localctx;
2386 : }
2387 :
2388 : //----------------- Enter_data_clause_listContext ------------------------------------------------------------------
2389 :
2390 0 : accparser::Enter_data_clause_listContext::Enter_data_clause_listContext(ParserRuleContext *parent, size_t invokingState)
2391 0 : : ParserRuleContext(parent, invokingState) {
2392 0 : }
2393 :
2394 0 : std::vector<accparser::Enter_data_clausesContext *> accparser::Enter_data_clause_listContext::enter_data_clauses() {
2395 0 : return getRuleContexts<accparser::Enter_data_clausesContext>();
2396 : }
2397 :
2398 0 : accparser::Enter_data_clausesContext* accparser::Enter_data_clause_listContext::enter_data_clauses(size_t i) {
2399 0 : return getRuleContext<accparser::Enter_data_clausesContext>(i);
2400 : }
2401 :
2402 :
2403 0 : size_t accparser::Enter_data_clause_listContext::getRuleIndex() const {
2404 0 : return accparser::RuleEnter_data_clause_list;
2405 : }
2406 :
2407 0 : void accparser::Enter_data_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
2408 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2409 0 : if (parserListener != nullptr)
2410 0 : parserListener->enterEnter_data_clause_list(this);
2411 0 : }
2412 :
2413 0 : void accparser::Enter_data_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
2414 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2415 0 : if (parserListener != nullptr)
2416 0 : parserListener->exitEnter_data_clause_list(this);
2417 0 : }
2418 :
2419 :
2420 0 : antlrcpp::Any accparser::Enter_data_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
2421 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2422 0 : return parserVisitor->visitEnter_data_clause_list(this);
2423 : else
2424 0 : return visitor->visitChildren(this);
2425 : }
2426 :
2427 0 : accparser::Enter_data_clause_listContext* accparser::enter_data_clause_list() {
2428 0 : Enter_data_clause_listContext *_localctx = _tracker.createInstance<Enter_data_clause_listContext>(_ctx, getState());
2429 0 : enterRule(_localctx, 56, accparser::RuleEnter_data_clause_list);
2430 0 : size_t _la = 0;
2431 :
2432 0 : auto onExit = finally([=] {
2433 0 : exitRule();
2434 0 : });
2435 0 : try {
2436 0 : enterOuterAlt(_localctx, 1);
2437 0 : setState(447);
2438 0 : _errHandler->sync(this);
2439 0 : _la = _input->LA(1);
2440 0 : do {
2441 0 : setState(446);
2442 0 : enter_data_clauses();
2443 0 : setState(449);
2444 0 : _errHandler->sync(this);
2445 0 : _la = _input->LA(1);
2446 0 : } while (((((_la - 27) & ~ 0x3fULL) == 0) &&
2447 0 : ((1ULL << (_la - 27)) & ((1ULL << (accparser::ASYNC - 27))
2448 : | (1ULL << (accparser::ATTACH - 27))
2449 : | (1ULL << (accparser::COPYIN - 27))
2450 : | (1ULL << (accparser::CREATE - 27))
2451 : | (1ULL << (accparser::IF - 27))
2452 0 : | (1ULL << (accparser::WAIT - 27)))) != 0));
2453 :
2454 : }
2455 0 : catch (RecognitionException &e) {
2456 0 : _errHandler->reportError(this, e);
2457 0 : _localctx->exception = std::current_exception();
2458 0 : _errHandler->recover(this, _localctx->exception);
2459 : }
2460 :
2461 0 : return _localctx;
2462 : }
2463 :
2464 : //----------------- Enter_data_clausesContext ------------------------------------------------------------------
2465 :
2466 0 : accparser::Enter_data_clausesContext::Enter_data_clausesContext(ParserRuleContext *parent, size_t invokingState)
2467 0 : : ParserRuleContext(parent, invokingState) {
2468 0 : }
2469 :
2470 0 : accparser::Async_clauseContext* accparser::Enter_data_clausesContext::async_clause() {
2471 0 : return getRuleContext<accparser::Async_clauseContext>(0);
2472 : }
2473 :
2474 0 : accparser::Attach_clauseContext* accparser::Enter_data_clausesContext::attach_clause() {
2475 0 : return getRuleContext<accparser::Attach_clauseContext>(0);
2476 : }
2477 :
2478 0 : accparser::Copyin_no_modifier_clauseContext* accparser::Enter_data_clausesContext::copyin_no_modifier_clause() {
2479 0 : return getRuleContext<accparser::Copyin_no_modifier_clauseContext>(0);
2480 : }
2481 :
2482 0 : accparser::Create_clauseContext* accparser::Enter_data_clausesContext::create_clause() {
2483 0 : return getRuleContext<accparser::Create_clauseContext>(0);
2484 : }
2485 :
2486 0 : accparser::If_clauseContext* accparser::Enter_data_clausesContext::if_clause() {
2487 0 : return getRuleContext<accparser::If_clauseContext>(0);
2488 : }
2489 :
2490 0 : accparser::Wait_argument_clauseContext* accparser::Enter_data_clausesContext::wait_argument_clause() {
2491 0 : return getRuleContext<accparser::Wait_argument_clauseContext>(0);
2492 : }
2493 :
2494 :
2495 0 : size_t accparser::Enter_data_clausesContext::getRuleIndex() const {
2496 0 : return accparser::RuleEnter_data_clauses;
2497 : }
2498 :
2499 0 : void accparser::Enter_data_clausesContext::enterRule(tree::ParseTreeListener *listener) {
2500 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2501 0 : if (parserListener != nullptr)
2502 0 : parserListener->enterEnter_data_clauses(this);
2503 0 : }
2504 :
2505 0 : void accparser::Enter_data_clausesContext::exitRule(tree::ParseTreeListener *listener) {
2506 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2507 0 : if (parserListener != nullptr)
2508 0 : parserListener->exitEnter_data_clauses(this);
2509 0 : }
2510 :
2511 :
2512 0 : antlrcpp::Any accparser::Enter_data_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
2513 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2514 0 : return parserVisitor->visitEnter_data_clauses(this);
2515 : else
2516 0 : return visitor->visitChildren(this);
2517 : }
2518 :
2519 0 : accparser::Enter_data_clausesContext* accparser::enter_data_clauses() {
2520 0 : Enter_data_clausesContext *_localctx = _tracker.createInstance<Enter_data_clausesContext>(_ctx, getState());
2521 0 : enterRule(_localctx, 58, accparser::RuleEnter_data_clauses);
2522 :
2523 0 : auto onExit = finally([=] {
2524 0 : exitRule();
2525 0 : });
2526 0 : try {
2527 0 : setState(457);
2528 0 : _errHandler->sync(this);
2529 0 : switch (_input->LA(1)) {
2530 0 : case accparser::ASYNC: {
2531 0 : enterOuterAlt(_localctx, 1);
2532 0 : setState(451);
2533 0 : async_clause();
2534 : break;
2535 : }
2536 :
2537 0 : case accparser::ATTACH: {
2538 0 : enterOuterAlt(_localctx, 2);
2539 0 : setState(452);
2540 0 : attach_clause();
2541 : break;
2542 : }
2543 :
2544 0 : case accparser::COPYIN: {
2545 0 : enterOuterAlt(_localctx, 3);
2546 0 : setState(453);
2547 0 : copyin_no_modifier_clause();
2548 : break;
2549 : }
2550 :
2551 0 : case accparser::CREATE: {
2552 0 : enterOuterAlt(_localctx, 4);
2553 0 : setState(454);
2554 0 : create_clause();
2555 : break;
2556 : }
2557 :
2558 0 : case accparser::IF: {
2559 0 : enterOuterAlt(_localctx, 5);
2560 0 : setState(455);
2561 0 : if_clause();
2562 : break;
2563 : }
2564 :
2565 0 : case accparser::WAIT: {
2566 0 : enterOuterAlt(_localctx, 6);
2567 0 : setState(456);
2568 0 : wait_argument_clause();
2569 : break;
2570 : }
2571 :
2572 0 : default:
2573 0 : throw NoViableAltException(this);
2574 : }
2575 :
2576 : }
2577 0 : catch (RecognitionException &e) {
2578 0 : _errHandler->reportError(this, e);
2579 0 : _localctx->exception = std::current_exception();
2580 0 : _errHandler->recover(this, _localctx->exception);
2581 : }
2582 :
2583 0 : return _localctx;
2584 : }
2585 :
2586 : //----------------- Exit_data_directiveContext ------------------------------------------------------------------
2587 :
2588 0 : accparser::Exit_data_directiveContext::Exit_data_directiveContext(ParserRuleContext *parent, size_t invokingState)
2589 0 : : ParserRuleContext(parent, invokingState) {
2590 0 : }
2591 :
2592 0 : tree::TerminalNode* accparser::Exit_data_directiveContext::EXIT() {
2593 0 : return getToken(accparser::EXIT, 0);
2594 : }
2595 :
2596 0 : tree::TerminalNode* accparser::Exit_data_directiveContext::DATA() {
2597 0 : return getToken(accparser::DATA, 0);
2598 : }
2599 :
2600 0 : accparser::Exit_data_clause_listContext* accparser::Exit_data_directiveContext::exit_data_clause_list() {
2601 0 : return getRuleContext<accparser::Exit_data_clause_listContext>(0);
2602 : }
2603 :
2604 :
2605 0 : size_t accparser::Exit_data_directiveContext::getRuleIndex() const {
2606 0 : return accparser::RuleExit_data_directive;
2607 : }
2608 :
2609 0 : void accparser::Exit_data_directiveContext::enterRule(tree::ParseTreeListener *listener) {
2610 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2611 0 : if (parserListener != nullptr)
2612 0 : parserListener->enterExit_data_directive(this);
2613 0 : }
2614 :
2615 0 : void accparser::Exit_data_directiveContext::exitRule(tree::ParseTreeListener *listener) {
2616 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2617 0 : if (parserListener != nullptr)
2618 0 : parserListener->exitExit_data_directive(this);
2619 0 : }
2620 :
2621 :
2622 0 : antlrcpp::Any accparser::Exit_data_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
2623 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2624 0 : return parserVisitor->visitExit_data_directive(this);
2625 : else
2626 0 : return visitor->visitChildren(this);
2627 : }
2628 :
2629 0 : accparser::Exit_data_directiveContext* accparser::exit_data_directive() {
2630 0 : Exit_data_directiveContext *_localctx = _tracker.createInstance<Exit_data_directiveContext>(_ctx, getState());
2631 0 : enterRule(_localctx, 60, accparser::RuleExit_data_directive);
2632 :
2633 0 : auto onExit = finally([=] {
2634 0 : exitRule();
2635 0 : });
2636 0 : try {
2637 0 : enterOuterAlt(_localctx, 1);
2638 0 : setState(459);
2639 0 : match(accparser::EXIT);
2640 0 : setState(460);
2641 0 : match(accparser::DATA);
2642 0 : setState(461);
2643 0 : exit_data_clause_list();
2644 :
2645 : }
2646 0 : catch (RecognitionException &e) {
2647 0 : _errHandler->reportError(this, e);
2648 0 : _localctx->exception = std::current_exception();
2649 0 : _errHandler->recover(this, _localctx->exception);
2650 : }
2651 :
2652 0 : return _localctx;
2653 : }
2654 :
2655 : //----------------- Exit_data_clause_listContext ------------------------------------------------------------------
2656 :
2657 0 : accparser::Exit_data_clause_listContext::Exit_data_clause_listContext(ParserRuleContext *parent, size_t invokingState)
2658 0 : : ParserRuleContext(parent, invokingState) {
2659 0 : }
2660 :
2661 0 : std::vector<accparser::Exit_data_clausesContext *> accparser::Exit_data_clause_listContext::exit_data_clauses() {
2662 0 : return getRuleContexts<accparser::Exit_data_clausesContext>();
2663 : }
2664 :
2665 0 : accparser::Exit_data_clausesContext* accparser::Exit_data_clause_listContext::exit_data_clauses(size_t i) {
2666 0 : return getRuleContext<accparser::Exit_data_clausesContext>(i);
2667 : }
2668 :
2669 :
2670 0 : size_t accparser::Exit_data_clause_listContext::getRuleIndex() const {
2671 0 : return accparser::RuleExit_data_clause_list;
2672 : }
2673 :
2674 0 : void accparser::Exit_data_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
2675 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2676 0 : if (parserListener != nullptr)
2677 0 : parserListener->enterExit_data_clause_list(this);
2678 0 : }
2679 :
2680 0 : void accparser::Exit_data_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
2681 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2682 0 : if (parserListener != nullptr)
2683 0 : parserListener->exitExit_data_clause_list(this);
2684 0 : }
2685 :
2686 :
2687 0 : antlrcpp::Any accparser::Exit_data_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
2688 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2689 0 : return parserVisitor->visitExit_data_clause_list(this);
2690 : else
2691 0 : return visitor->visitChildren(this);
2692 : }
2693 :
2694 0 : accparser::Exit_data_clause_listContext* accparser::exit_data_clause_list() {
2695 0 : Exit_data_clause_listContext *_localctx = _tracker.createInstance<Exit_data_clause_listContext>(_ctx, getState());
2696 0 : enterRule(_localctx, 62, accparser::RuleExit_data_clause_list);
2697 0 : size_t _la = 0;
2698 :
2699 0 : auto onExit = finally([=] {
2700 0 : exitRule();
2701 0 : });
2702 0 : try {
2703 0 : enterOuterAlt(_localctx, 1);
2704 0 : setState(464);
2705 0 : _errHandler->sync(this);
2706 0 : _la = _input->LA(1);
2707 0 : do {
2708 0 : setState(463);
2709 0 : exit_data_clauses();
2710 0 : setState(466);
2711 0 : _errHandler->sync(this);
2712 0 : _la = _input->LA(1);
2713 0 : } while (((((_la - 27) & ~ 0x3fULL) == 0) &&
2714 0 : ((1ULL << (_la - 27)) & ((1ULL << (accparser::ASYNC - 27))
2715 : | (1ULL << (accparser::COPYOUT - 27))
2716 : | (1ULL << (accparser::DELETE - 27))
2717 : | (1ULL << (accparser::DETACH - 27))
2718 : | (1ULL << (accparser::FINALIZE - 27))
2719 : | (1ULL << (accparser::IF - 27))
2720 0 : | (1ULL << (accparser::WAIT - 27)))) != 0));
2721 :
2722 : }
2723 0 : catch (RecognitionException &e) {
2724 0 : _errHandler->reportError(this, e);
2725 0 : _localctx->exception = std::current_exception();
2726 0 : _errHandler->recover(this, _localctx->exception);
2727 : }
2728 :
2729 0 : return _localctx;
2730 : }
2731 :
2732 : //----------------- Exit_data_clausesContext ------------------------------------------------------------------
2733 :
2734 0 : accparser::Exit_data_clausesContext::Exit_data_clausesContext(ParserRuleContext *parent, size_t invokingState)
2735 0 : : ParserRuleContext(parent, invokingState) {
2736 0 : }
2737 :
2738 0 : accparser::Async_clauseContext* accparser::Exit_data_clausesContext::async_clause() {
2739 0 : return getRuleContext<accparser::Async_clauseContext>(0);
2740 : }
2741 :
2742 0 : accparser::Copyout_no_modifier_clauseContext* accparser::Exit_data_clausesContext::copyout_no_modifier_clause() {
2743 0 : return getRuleContext<accparser::Copyout_no_modifier_clauseContext>(0);
2744 : }
2745 :
2746 0 : accparser::Delete_clauseContext* accparser::Exit_data_clausesContext::delete_clause() {
2747 0 : return getRuleContext<accparser::Delete_clauseContext>(0);
2748 : }
2749 :
2750 0 : accparser::Detach_clauseContext* accparser::Exit_data_clausesContext::detach_clause() {
2751 0 : return getRuleContext<accparser::Detach_clauseContext>(0);
2752 : }
2753 :
2754 0 : accparser::Finalize_clauseContext* accparser::Exit_data_clausesContext::finalize_clause() {
2755 0 : return getRuleContext<accparser::Finalize_clauseContext>(0);
2756 : }
2757 :
2758 0 : accparser::If_clauseContext* accparser::Exit_data_clausesContext::if_clause() {
2759 0 : return getRuleContext<accparser::If_clauseContext>(0);
2760 : }
2761 :
2762 0 : accparser::Wait_argument_clauseContext* accparser::Exit_data_clausesContext::wait_argument_clause() {
2763 0 : return getRuleContext<accparser::Wait_argument_clauseContext>(0);
2764 : }
2765 :
2766 :
2767 0 : size_t accparser::Exit_data_clausesContext::getRuleIndex() const {
2768 0 : return accparser::RuleExit_data_clauses;
2769 : }
2770 :
2771 0 : void accparser::Exit_data_clausesContext::enterRule(tree::ParseTreeListener *listener) {
2772 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2773 0 : if (parserListener != nullptr)
2774 0 : parserListener->enterExit_data_clauses(this);
2775 0 : }
2776 :
2777 0 : void accparser::Exit_data_clausesContext::exitRule(tree::ParseTreeListener *listener) {
2778 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2779 0 : if (parserListener != nullptr)
2780 0 : parserListener->exitExit_data_clauses(this);
2781 0 : }
2782 :
2783 :
2784 0 : antlrcpp::Any accparser::Exit_data_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
2785 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2786 0 : return parserVisitor->visitExit_data_clauses(this);
2787 : else
2788 0 : return visitor->visitChildren(this);
2789 : }
2790 :
2791 0 : accparser::Exit_data_clausesContext* accparser::exit_data_clauses() {
2792 0 : Exit_data_clausesContext *_localctx = _tracker.createInstance<Exit_data_clausesContext>(_ctx, getState());
2793 0 : enterRule(_localctx, 64, accparser::RuleExit_data_clauses);
2794 :
2795 0 : auto onExit = finally([=] {
2796 0 : exitRule();
2797 0 : });
2798 0 : try {
2799 0 : setState(475);
2800 0 : _errHandler->sync(this);
2801 0 : switch (_input->LA(1)) {
2802 0 : case accparser::ASYNC: {
2803 0 : enterOuterAlt(_localctx, 1);
2804 0 : setState(468);
2805 0 : async_clause();
2806 : break;
2807 : }
2808 :
2809 0 : case accparser::COPYOUT: {
2810 0 : enterOuterAlt(_localctx, 2);
2811 0 : setState(469);
2812 0 : copyout_no_modifier_clause();
2813 : break;
2814 : }
2815 :
2816 0 : case accparser::DELETE: {
2817 0 : enterOuterAlt(_localctx, 3);
2818 0 : setState(470);
2819 0 : delete_clause();
2820 : break;
2821 : }
2822 :
2823 0 : case accparser::DETACH: {
2824 0 : enterOuterAlt(_localctx, 4);
2825 0 : setState(471);
2826 0 : detach_clause();
2827 : break;
2828 : }
2829 :
2830 0 : case accparser::FINALIZE: {
2831 0 : enterOuterAlt(_localctx, 5);
2832 0 : setState(472);
2833 0 : finalize_clause();
2834 : break;
2835 : }
2836 :
2837 0 : case accparser::IF: {
2838 0 : enterOuterAlt(_localctx, 6);
2839 0 : setState(473);
2840 0 : if_clause();
2841 : break;
2842 : }
2843 :
2844 0 : case accparser::WAIT: {
2845 0 : enterOuterAlt(_localctx, 7);
2846 0 : setState(474);
2847 0 : wait_argument_clause();
2848 : break;
2849 : }
2850 :
2851 0 : default:
2852 0 : throw NoViableAltException(this);
2853 : }
2854 :
2855 : }
2856 0 : catch (RecognitionException &e) {
2857 0 : _errHandler->reportError(this, e);
2858 0 : _localctx->exception = std::current_exception();
2859 0 : _errHandler->recover(this, _localctx->exception);
2860 : }
2861 :
2862 0 : return _localctx;
2863 : }
2864 :
2865 : //----------------- Host_data_directiveContext ------------------------------------------------------------------
2866 :
2867 0 : accparser::Host_data_directiveContext::Host_data_directiveContext(ParserRuleContext *parent, size_t invokingState)
2868 0 : : ParserRuleContext(parent, invokingState) {
2869 0 : }
2870 :
2871 0 : tree::TerminalNode* accparser::Host_data_directiveContext::HOST_DATA() {
2872 0 : return getToken(accparser::HOST_DATA, 0);
2873 : }
2874 :
2875 0 : accparser::Host_data_clause_listContext* accparser::Host_data_directiveContext::host_data_clause_list() {
2876 0 : return getRuleContext<accparser::Host_data_clause_listContext>(0);
2877 : }
2878 :
2879 :
2880 0 : size_t accparser::Host_data_directiveContext::getRuleIndex() const {
2881 0 : return accparser::RuleHost_data_directive;
2882 : }
2883 :
2884 0 : void accparser::Host_data_directiveContext::enterRule(tree::ParseTreeListener *listener) {
2885 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2886 0 : if (parserListener != nullptr)
2887 0 : parserListener->enterHost_data_directive(this);
2888 0 : }
2889 :
2890 0 : void accparser::Host_data_directiveContext::exitRule(tree::ParseTreeListener *listener) {
2891 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2892 0 : if (parserListener != nullptr)
2893 0 : parserListener->exitHost_data_directive(this);
2894 0 : }
2895 :
2896 :
2897 0 : antlrcpp::Any accparser::Host_data_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
2898 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2899 0 : return parserVisitor->visitHost_data_directive(this);
2900 : else
2901 0 : return visitor->visitChildren(this);
2902 : }
2903 :
2904 0 : accparser::Host_data_directiveContext* accparser::host_data_directive() {
2905 0 : Host_data_directiveContext *_localctx = _tracker.createInstance<Host_data_directiveContext>(_ctx, getState());
2906 0 : enterRule(_localctx, 66, accparser::RuleHost_data_directive);
2907 :
2908 0 : auto onExit = finally([=] {
2909 0 : exitRule();
2910 0 : });
2911 0 : try {
2912 0 : enterOuterAlt(_localctx, 1);
2913 0 : setState(477);
2914 0 : match(accparser::HOST_DATA);
2915 0 : setState(478);
2916 0 : host_data_clause_list();
2917 :
2918 : }
2919 0 : catch (RecognitionException &e) {
2920 0 : _errHandler->reportError(this, e);
2921 0 : _localctx->exception = std::current_exception();
2922 0 : _errHandler->recover(this, _localctx->exception);
2923 : }
2924 :
2925 0 : return _localctx;
2926 : }
2927 :
2928 : //----------------- Host_data_clause_listContext ------------------------------------------------------------------
2929 :
2930 0 : accparser::Host_data_clause_listContext::Host_data_clause_listContext(ParserRuleContext *parent, size_t invokingState)
2931 0 : : ParserRuleContext(parent, invokingState) {
2932 0 : }
2933 :
2934 0 : std::vector<accparser::Host_data_clausesContext *> accparser::Host_data_clause_listContext::host_data_clauses() {
2935 0 : return getRuleContexts<accparser::Host_data_clausesContext>();
2936 : }
2937 :
2938 0 : accparser::Host_data_clausesContext* accparser::Host_data_clause_listContext::host_data_clauses(size_t i) {
2939 0 : return getRuleContext<accparser::Host_data_clausesContext>(i);
2940 : }
2941 :
2942 :
2943 0 : size_t accparser::Host_data_clause_listContext::getRuleIndex() const {
2944 0 : return accparser::RuleHost_data_clause_list;
2945 : }
2946 :
2947 0 : void accparser::Host_data_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
2948 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2949 0 : if (parserListener != nullptr)
2950 0 : parserListener->enterHost_data_clause_list(this);
2951 0 : }
2952 :
2953 0 : void accparser::Host_data_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
2954 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
2955 0 : if (parserListener != nullptr)
2956 0 : parserListener->exitHost_data_clause_list(this);
2957 0 : }
2958 :
2959 :
2960 0 : antlrcpp::Any accparser::Host_data_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
2961 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
2962 0 : return parserVisitor->visitHost_data_clause_list(this);
2963 : else
2964 0 : return visitor->visitChildren(this);
2965 : }
2966 :
2967 0 : accparser::Host_data_clause_listContext* accparser::host_data_clause_list() {
2968 0 : Host_data_clause_listContext *_localctx = _tracker.createInstance<Host_data_clause_listContext>(_ctx, getState());
2969 0 : enterRule(_localctx, 68, accparser::RuleHost_data_clause_list);
2970 0 : size_t _la = 0;
2971 :
2972 0 : auto onExit = finally([=] {
2973 0 : exitRule();
2974 0 : });
2975 0 : try {
2976 0 : enterOuterAlt(_localctx, 1);
2977 0 : setState(481);
2978 0 : _errHandler->sync(this);
2979 0 : _la = _input->LA(1);
2980 0 : do {
2981 0 : setState(480);
2982 0 : host_data_clauses();
2983 0 : setState(483);
2984 0 : _errHandler->sync(this);
2985 0 : _la = _input->LA(1);
2986 0 : } while (((((_la - 50) & ~ 0x3fULL) == 0) &&
2987 0 : ((1ULL << (_la - 50)) & ((1ULL << (accparser::IF - 50))
2988 : | (1ULL << (accparser::IF_PRESENT - 50))
2989 0 : | (1ULL << (accparser::USE_DEVICE - 50)))) != 0));
2990 :
2991 : }
2992 0 : catch (RecognitionException &e) {
2993 0 : _errHandler->reportError(this, e);
2994 0 : _localctx->exception = std::current_exception();
2995 0 : _errHandler->recover(this, _localctx->exception);
2996 : }
2997 :
2998 0 : return _localctx;
2999 : }
3000 :
3001 : //----------------- Host_data_clausesContext ------------------------------------------------------------------
3002 :
3003 0 : accparser::Host_data_clausesContext::Host_data_clausesContext(ParserRuleContext *parent, size_t invokingState)
3004 0 : : ParserRuleContext(parent, invokingState) {
3005 0 : }
3006 :
3007 0 : accparser::If_clauseContext* accparser::Host_data_clausesContext::if_clause() {
3008 0 : return getRuleContext<accparser::If_clauseContext>(0);
3009 : }
3010 :
3011 0 : accparser::If_present_clauseContext* accparser::Host_data_clausesContext::if_present_clause() {
3012 0 : return getRuleContext<accparser::If_present_clauseContext>(0);
3013 : }
3014 :
3015 0 : accparser::Use_device_clauseContext* accparser::Host_data_clausesContext::use_device_clause() {
3016 0 : return getRuleContext<accparser::Use_device_clauseContext>(0);
3017 : }
3018 :
3019 :
3020 0 : size_t accparser::Host_data_clausesContext::getRuleIndex() const {
3021 0 : return accparser::RuleHost_data_clauses;
3022 : }
3023 :
3024 0 : void accparser::Host_data_clausesContext::enterRule(tree::ParseTreeListener *listener) {
3025 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3026 0 : if (parserListener != nullptr)
3027 0 : parserListener->enterHost_data_clauses(this);
3028 0 : }
3029 :
3030 0 : void accparser::Host_data_clausesContext::exitRule(tree::ParseTreeListener *listener) {
3031 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3032 0 : if (parserListener != nullptr)
3033 0 : parserListener->exitHost_data_clauses(this);
3034 0 : }
3035 :
3036 :
3037 0 : antlrcpp::Any accparser::Host_data_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
3038 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
3039 0 : return parserVisitor->visitHost_data_clauses(this);
3040 : else
3041 0 : return visitor->visitChildren(this);
3042 : }
3043 :
3044 0 : accparser::Host_data_clausesContext* accparser::host_data_clauses() {
3045 0 : Host_data_clausesContext *_localctx = _tracker.createInstance<Host_data_clausesContext>(_ctx, getState());
3046 0 : enterRule(_localctx, 70, accparser::RuleHost_data_clauses);
3047 :
3048 0 : auto onExit = finally([=] {
3049 0 : exitRule();
3050 0 : });
3051 0 : try {
3052 0 : setState(488);
3053 0 : _errHandler->sync(this);
3054 0 : switch (_input->LA(1)) {
3055 0 : case accparser::IF: {
3056 0 : enterOuterAlt(_localctx, 1);
3057 0 : setState(485);
3058 0 : if_clause();
3059 : break;
3060 : }
3061 :
3062 0 : case accparser::IF_PRESENT: {
3063 0 : enterOuterAlt(_localctx, 2);
3064 0 : setState(486);
3065 0 : if_present_clause();
3066 : break;
3067 : }
3068 :
3069 0 : case accparser::USE_DEVICE: {
3070 0 : enterOuterAlt(_localctx, 3);
3071 0 : setState(487);
3072 0 : use_device_clause();
3073 : break;
3074 : }
3075 :
3076 0 : default:
3077 0 : throw NoViableAltException(this);
3078 : }
3079 :
3080 : }
3081 0 : catch (RecognitionException &e) {
3082 0 : _errHandler->reportError(this, e);
3083 0 : _localctx->exception = std::current_exception();
3084 0 : _errHandler->recover(this, _localctx->exception);
3085 : }
3086 :
3087 0 : return _localctx;
3088 : }
3089 :
3090 : //----------------- Init_directiveContext ------------------------------------------------------------------
3091 :
3092 0 : accparser::Init_directiveContext::Init_directiveContext(ParserRuleContext *parent, size_t invokingState)
3093 0 : : ParserRuleContext(parent, invokingState) {
3094 0 : }
3095 :
3096 0 : tree::TerminalNode* accparser::Init_directiveContext::INIT() {
3097 0 : return getToken(accparser::INIT, 0);
3098 : }
3099 :
3100 0 : accparser::Init_clause_listContext* accparser::Init_directiveContext::init_clause_list() {
3101 0 : return getRuleContext<accparser::Init_clause_listContext>(0);
3102 : }
3103 :
3104 :
3105 0 : size_t accparser::Init_directiveContext::getRuleIndex() const {
3106 0 : return accparser::RuleInit_directive;
3107 : }
3108 :
3109 0 : void accparser::Init_directiveContext::enterRule(tree::ParseTreeListener *listener) {
3110 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3111 0 : if (parserListener != nullptr)
3112 0 : parserListener->enterInit_directive(this);
3113 0 : }
3114 :
3115 0 : void accparser::Init_directiveContext::exitRule(tree::ParseTreeListener *listener) {
3116 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3117 0 : if (parserListener != nullptr)
3118 0 : parserListener->exitInit_directive(this);
3119 0 : }
3120 :
3121 :
3122 0 : antlrcpp::Any accparser::Init_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
3123 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
3124 0 : return parserVisitor->visitInit_directive(this);
3125 : else
3126 0 : return visitor->visitChildren(this);
3127 : }
3128 :
3129 0 : accparser::Init_directiveContext* accparser::init_directive() {
3130 0 : Init_directiveContext *_localctx = _tracker.createInstance<Init_directiveContext>(_ctx, getState());
3131 0 : enterRule(_localctx, 72, accparser::RuleInit_directive);
3132 :
3133 0 : auto onExit = finally([=] {
3134 0 : exitRule();
3135 0 : });
3136 0 : try {
3137 0 : enterOuterAlt(_localctx, 1);
3138 0 : setState(490);
3139 0 : match(accparser::INIT);
3140 0 : setState(491);
3141 0 : init_clause_list();
3142 :
3143 : }
3144 0 : catch (RecognitionException &e) {
3145 0 : _errHandler->reportError(this, e);
3146 0 : _localctx->exception = std::current_exception();
3147 0 : _errHandler->recover(this, _localctx->exception);
3148 : }
3149 :
3150 0 : return _localctx;
3151 : }
3152 :
3153 : //----------------- Init_clause_listContext ------------------------------------------------------------------
3154 :
3155 0 : accparser::Init_clause_listContext::Init_clause_listContext(ParserRuleContext *parent, size_t invokingState)
3156 0 : : ParserRuleContext(parent, invokingState) {
3157 0 : }
3158 :
3159 0 : std::vector<accparser::Init_clausesContext *> accparser::Init_clause_listContext::init_clauses() {
3160 0 : return getRuleContexts<accparser::Init_clausesContext>();
3161 : }
3162 :
3163 0 : accparser::Init_clausesContext* accparser::Init_clause_listContext::init_clauses(size_t i) {
3164 0 : return getRuleContext<accparser::Init_clausesContext>(i);
3165 : }
3166 :
3167 :
3168 0 : size_t accparser::Init_clause_listContext::getRuleIndex() const {
3169 0 : return accparser::RuleInit_clause_list;
3170 : }
3171 :
3172 0 : void accparser::Init_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
3173 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3174 0 : if (parserListener != nullptr)
3175 0 : parserListener->enterInit_clause_list(this);
3176 0 : }
3177 :
3178 0 : void accparser::Init_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
3179 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3180 0 : if (parserListener != nullptr)
3181 0 : parserListener->exitInit_clause_list(this);
3182 0 : }
3183 :
3184 :
3185 0 : antlrcpp::Any accparser::Init_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
3186 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
3187 0 : return parserVisitor->visitInit_clause_list(this);
3188 : else
3189 0 : return visitor->visitChildren(this);
3190 : }
3191 :
3192 0 : accparser::Init_clause_listContext* accparser::init_clause_list() {
3193 0 : Init_clause_listContext *_localctx = _tracker.createInstance<Init_clause_listContext>(_ctx, getState());
3194 0 : enterRule(_localctx, 74, accparser::RuleInit_clause_list);
3195 0 : size_t _la = 0;
3196 :
3197 0 : auto onExit = finally([=] {
3198 0 : exitRule();
3199 0 : });
3200 0 : try {
3201 0 : enterOuterAlt(_localctx, 1);
3202 0 : setState(496);
3203 0 : _errHandler->sync(this);
3204 0 : _la = _input->LA(1);
3205 0 : while ((((_la & ~ 0x3fULL) == 0) &&
3206 : ((1ULL << _la) & ((1ULL << accparser::DEVICE_NUM)
3207 : | (1ULL << accparser::DEVICE_TYPE)
3208 0 : | (1ULL << accparser::IF))) != 0)) {
3209 0 : setState(493);
3210 0 : init_clauses();
3211 0 : setState(498);
3212 0 : _errHandler->sync(this);
3213 0 : _la = _input->LA(1);
3214 : }
3215 :
3216 : }
3217 0 : catch (RecognitionException &e) {
3218 0 : _errHandler->reportError(this, e);
3219 0 : _localctx->exception = std::current_exception();
3220 0 : _errHandler->recover(this, _localctx->exception);
3221 : }
3222 :
3223 0 : return _localctx;
3224 : }
3225 :
3226 : //----------------- Init_clausesContext ------------------------------------------------------------------
3227 :
3228 0 : accparser::Init_clausesContext::Init_clausesContext(ParserRuleContext *parent, size_t invokingState)
3229 0 : : ParserRuleContext(parent, invokingState) {
3230 0 : }
3231 :
3232 0 : accparser::Device_type_clauseContext* accparser::Init_clausesContext::device_type_clause() {
3233 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
3234 : }
3235 :
3236 0 : accparser::Device_num_clauseContext* accparser::Init_clausesContext::device_num_clause() {
3237 0 : return getRuleContext<accparser::Device_num_clauseContext>(0);
3238 : }
3239 :
3240 0 : accparser::If_clauseContext* accparser::Init_clausesContext::if_clause() {
3241 0 : return getRuleContext<accparser::If_clauseContext>(0);
3242 : }
3243 :
3244 :
3245 0 : size_t accparser::Init_clausesContext::getRuleIndex() const {
3246 0 : return accparser::RuleInit_clauses;
3247 : }
3248 :
3249 0 : void accparser::Init_clausesContext::enterRule(tree::ParseTreeListener *listener) {
3250 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3251 0 : if (parserListener != nullptr)
3252 0 : parserListener->enterInit_clauses(this);
3253 0 : }
3254 :
3255 0 : void accparser::Init_clausesContext::exitRule(tree::ParseTreeListener *listener) {
3256 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3257 0 : if (parserListener != nullptr)
3258 0 : parserListener->exitInit_clauses(this);
3259 0 : }
3260 :
3261 :
3262 0 : antlrcpp::Any accparser::Init_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
3263 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
3264 0 : return parserVisitor->visitInit_clauses(this);
3265 : else
3266 0 : return visitor->visitChildren(this);
3267 : }
3268 :
3269 0 : accparser::Init_clausesContext* accparser::init_clauses() {
3270 0 : Init_clausesContext *_localctx = _tracker.createInstance<Init_clausesContext>(_ctx, getState());
3271 0 : enterRule(_localctx, 76, accparser::RuleInit_clauses);
3272 :
3273 0 : auto onExit = finally([=] {
3274 0 : exitRule();
3275 0 : });
3276 0 : try {
3277 0 : setState(502);
3278 0 : _errHandler->sync(this);
3279 0 : switch (_input->LA(1)) {
3280 0 : case accparser::DEVICE_TYPE: {
3281 0 : enterOuterAlt(_localctx, 1);
3282 0 : setState(499);
3283 0 : device_type_clause();
3284 : break;
3285 : }
3286 :
3287 0 : case accparser::DEVICE_NUM: {
3288 0 : enterOuterAlt(_localctx, 2);
3289 0 : setState(500);
3290 0 : device_num_clause();
3291 : break;
3292 : }
3293 :
3294 0 : case accparser::IF: {
3295 0 : enterOuterAlt(_localctx, 3);
3296 0 : setState(501);
3297 0 : if_clause();
3298 : break;
3299 : }
3300 :
3301 0 : default:
3302 0 : throw NoViableAltException(this);
3303 : }
3304 :
3305 : }
3306 0 : catch (RecognitionException &e) {
3307 0 : _errHandler->reportError(this, e);
3308 0 : _localctx->exception = std::current_exception();
3309 0 : _errHandler->recover(this, _localctx->exception);
3310 : }
3311 :
3312 0 : return _localctx;
3313 : }
3314 :
3315 : //----------------- Kernels_directiveContext ------------------------------------------------------------------
3316 :
3317 0 : accparser::Kernels_directiveContext::Kernels_directiveContext(ParserRuleContext *parent, size_t invokingState)
3318 0 : : ParserRuleContext(parent, invokingState) {
3319 0 : }
3320 :
3321 0 : tree::TerminalNode* accparser::Kernels_directiveContext::KERNELS() {
3322 0 : return getToken(accparser::KERNELS, 0);
3323 : }
3324 :
3325 0 : accparser::Kernels_clause_listContext* accparser::Kernels_directiveContext::kernels_clause_list() {
3326 0 : return getRuleContext<accparser::Kernels_clause_listContext>(0);
3327 : }
3328 :
3329 :
3330 0 : size_t accparser::Kernels_directiveContext::getRuleIndex() const {
3331 0 : return accparser::RuleKernels_directive;
3332 : }
3333 :
3334 0 : void accparser::Kernels_directiveContext::enterRule(tree::ParseTreeListener *listener) {
3335 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3336 0 : if (parserListener != nullptr)
3337 0 : parserListener->enterKernels_directive(this);
3338 0 : }
3339 :
3340 0 : void accparser::Kernels_directiveContext::exitRule(tree::ParseTreeListener *listener) {
3341 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3342 0 : if (parserListener != nullptr)
3343 0 : parserListener->exitKernels_directive(this);
3344 0 : }
3345 :
3346 :
3347 0 : antlrcpp::Any accparser::Kernels_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
3348 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
3349 0 : return parserVisitor->visitKernels_directive(this);
3350 : else
3351 0 : return visitor->visitChildren(this);
3352 : }
3353 :
3354 0 : accparser::Kernels_directiveContext* accparser::kernels_directive() {
3355 0 : Kernels_directiveContext *_localctx = _tracker.createInstance<Kernels_directiveContext>(_ctx, getState());
3356 0 : enterRule(_localctx, 78, accparser::RuleKernels_directive);
3357 :
3358 0 : auto onExit = finally([=] {
3359 0 : exitRule();
3360 0 : });
3361 0 : try {
3362 0 : enterOuterAlt(_localctx, 1);
3363 0 : setState(504);
3364 0 : match(accparser::KERNELS);
3365 0 : setState(505);
3366 0 : kernels_clause_list();
3367 :
3368 : }
3369 0 : catch (RecognitionException &e) {
3370 0 : _errHandler->reportError(this, e);
3371 0 : _localctx->exception = std::current_exception();
3372 0 : _errHandler->recover(this, _localctx->exception);
3373 : }
3374 :
3375 0 : return _localctx;
3376 : }
3377 :
3378 : //----------------- Kernels_clause_listContext ------------------------------------------------------------------
3379 :
3380 0 : accparser::Kernels_clause_listContext::Kernels_clause_listContext(ParserRuleContext *parent, size_t invokingState)
3381 0 : : ParserRuleContext(parent, invokingState) {
3382 0 : }
3383 :
3384 0 : std::vector<accparser::Kernels_clausesContext *> accparser::Kernels_clause_listContext::kernels_clauses() {
3385 0 : return getRuleContexts<accparser::Kernels_clausesContext>();
3386 : }
3387 :
3388 0 : accparser::Kernels_clausesContext* accparser::Kernels_clause_listContext::kernels_clauses(size_t i) {
3389 0 : return getRuleContext<accparser::Kernels_clausesContext>(i);
3390 : }
3391 :
3392 :
3393 0 : size_t accparser::Kernels_clause_listContext::getRuleIndex() const {
3394 0 : return accparser::RuleKernels_clause_list;
3395 : }
3396 :
3397 0 : void accparser::Kernels_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
3398 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3399 0 : if (parserListener != nullptr)
3400 0 : parserListener->enterKernels_clause_list(this);
3401 0 : }
3402 :
3403 0 : void accparser::Kernels_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
3404 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3405 0 : if (parserListener != nullptr)
3406 0 : parserListener->exitKernels_clause_list(this);
3407 0 : }
3408 :
3409 :
3410 0 : antlrcpp::Any accparser::Kernels_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
3411 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
3412 0 : return parserVisitor->visitKernels_clause_list(this);
3413 : else
3414 0 : return visitor->visitChildren(this);
3415 : }
3416 :
3417 0 : accparser::Kernels_clause_listContext* accparser::kernels_clause_list() {
3418 0 : Kernels_clause_listContext *_localctx = _tracker.createInstance<Kernels_clause_listContext>(_ctx, getState());
3419 0 : enterRule(_localctx, 80, accparser::RuleKernels_clause_list);
3420 0 : size_t _la = 0;
3421 :
3422 0 : auto onExit = finally([=] {
3423 0 : exitRule();
3424 0 : });
3425 0 : try {
3426 0 : enterOuterAlt(_localctx, 1);
3427 0 : setState(510);
3428 0 : _errHandler->sync(this);
3429 0 : _la = _input->LA(1);
3430 0 : while (((((_la - 27) & ~ 0x3fULL) == 0) &&
3431 0 : ((1ULL << (_la - 27)) & ((1ULL << (accparser::ASYNC - 27))
3432 : | (1ULL << (accparser::ATTACH - 27))
3433 : | (1ULL << (accparser::COPY - 27))
3434 : | (1ULL << (accparser::COPYIN - 27))
3435 : | (1ULL << (accparser::COPYOUT - 27))
3436 : | (1ULL << (accparser::CREATE - 27))
3437 : | (1ULL << (accparser::DEFAULT - 27))
3438 : | (1ULL << (accparser::DEVICE_TYPE - 27))
3439 : | (1ULL << (accparser::DEVICEPTR - 27))
3440 : | (1ULL << (accparser::IF - 27))
3441 : | (1ULL << (accparser::NO_CREATE - 27))
3442 : | (1ULL << (accparser::NUM_GANGS - 27))
3443 : | (1ULL << (accparser::NUM_WORKERS - 27))
3444 : | (1ULL << (accparser::PRESENT - 27))
3445 : | (1ULL << (accparser::SELF - 27))
3446 : | (1ULL << (accparser::VECTOR_LENGTH - 27))
3447 0 : | (1ULL << (accparser::WAIT - 27)))) != 0)) {
3448 0 : setState(507);
3449 0 : kernels_clauses();
3450 0 : setState(512);
3451 0 : _errHandler->sync(this);
3452 0 : _la = _input->LA(1);
3453 : }
3454 :
3455 : }
3456 0 : catch (RecognitionException &e) {
3457 0 : _errHandler->reportError(this, e);
3458 0 : _localctx->exception = std::current_exception();
3459 0 : _errHandler->recover(this, _localctx->exception);
3460 : }
3461 :
3462 0 : return _localctx;
3463 : }
3464 :
3465 : //----------------- Kernels_clausesContext ------------------------------------------------------------------
3466 :
3467 0 : accparser::Kernels_clausesContext::Kernels_clausesContext(ParserRuleContext *parent, size_t invokingState)
3468 0 : : ParserRuleContext(parent, invokingState) {
3469 0 : }
3470 :
3471 0 : accparser::Async_clauseContext* accparser::Kernels_clausesContext::async_clause() {
3472 0 : return getRuleContext<accparser::Async_clauseContext>(0);
3473 : }
3474 :
3475 0 : accparser::Attach_clauseContext* accparser::Kernels_clausesContext::attach_clause() {
3476 0 : return getRuleContext<accparser::Attach_clauseContext>(0);
3477 : }
3478 :
3479 0 : accparser::Copy_clauseContext* accparser::Kernels_clausesContext::copy_clause() {
3480 0 : return getRuleContext<accparser::Copy_clauseContext>(0);
3481 : }
3482 :
3483 0 : accparser::Copyin_clauseContext* accparser::Kernels_clausesContext::copyin_clause() {
3484 0 : return getRuleContext<accparser::Copyin_clauseContext>(0);
3485 : }
3486 :
3487 0 : accparser::Copyout_clauseContext* accparser::Kernels_clausesContext::copyout_clause() {
3488 0 : return getRuleContext<accparser::Copyout_clauseContext>(0);
3489 : }
3490 :
3491 0 : accparser::Create_clauseContext* accparser::Kernels_clausesContext::create_clause() {
3492 0 : return getRuleContext<accparser::Create_clauseContext>(0);
3493 : }
3494 :
3495 0 : accparser::Default_clauseContext* accparser::Kernels_clausesContext::default_clause() {
3496 0 : return getRuleContext<accparser::Default_clauseContext>(0);
3497 : }
3498 :
3499 0 : accparser::Device_type_clauseContext* accparser::Kernels_clausesContext::device_type_clause() {
3500 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
3501 : }
3502 :
3503 0 : accparser::Deviceptr_clauseContext* accparser::Kernels_clausesContext::deviceptr_clause() {
3504 0 : return getRuleContext<accparser::Deviceptr_clauseContext>(0);
3505 : }
3506 :
3507 0 : accparser::If_clauseContext* accparser::Kernels_clausesContext::if_clause() {
3508 0 : return getRuleContext<accparser::If_clauseContext>(0);
3509 : }
3510 :
3511 0 : accparser::No_create_clauseContext* accparser::Kernels_clausesContext::no_create_clause() {
3512 0 : return getRuleContext<accparser::No_create_clauseContext>(0);
3513 : }
3514 :
3515 0 : accparser::Num_gangs_clauseContext* accparser::Kernels_clausesContext::num_gangs_clause() {
3516 0 : return getRuleContext<accparser::Num_gangs_clauseContext>(0);
3517 : }
3518 :
3519 0 : accparser::Num_workers_clauseContext* accparser::Kernels_clausesContext::num_workers_clause() {
3520 0 : return getRuleContext<accparser::Num_workers_clauseContext>(0);
3521 : }
3522 :
3523 0 : accparser::Present_clauseContext* accparser::Kernels_clausesContext::present_clause() {
3524 0 : return getRuleContext<accparser::Present_clauseContext>(0);
3525 : }
3526 :
3527 0 : accparser::Self_clauseContext* accparser::Kernels_clausesContext::self_clause() {
3528 0 : return getRuleContext<accparser::Self_clauseContext>(0);
3529 : }
3530 :
3531 0 : accparser::Vector_length_clauseContext* accparser::Kernels_clausesContext::vector_length_clause() {
3532 0 : return getRuleContext<accparser::Vector_length_clauseContext>(0);
3533 : }
3534 :
3535 0 : accparser::Wait_clauseContext* accparser::Kernels_clausesContext::wait_clause() {
3536 0 : return getRuleContext<accparser::Wait_clauseContext>(0);
3537 : }
3538 :
3539 :
3540 0 : size_t accparser::Kernels_clausesContext::getRuleIndex() const {
3541 0 : return accparser::RuleKernels_clauses;
3542 : }
3543 :
3544 0 : void accparser::Kernels_clausesContext::enterRule(tree::ParseTreeListener *listener) {
3545 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3546 0 : if (parserListener != nullptr)
3547 0 : parserListener->enterKernels_clauses(this);
3548 0 : }
3549 :
3550 0 : void accparser::Kernels_clausesContext::exitRule(tree::ParseTreeListener *listener) {
3551 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3552 0 : if (parserListener != nullptr)
3553 0 : parserListener->exitKernels_clauses(this);
3554 0 : }
3555 :
3556 :
3557 0 : antlrcpp::Any accparser::Kernels_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
3558 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
3559 0 : return parserVisitor->visitKernels_clauses(this);
3560 : else
3561 0 : return visitor->visitChildren(this);
3562 : }
3563 :
3564 0 : accparser::Kernels_clausesContext* accparser::kernels_clauses() {
3565 0 : Kernels_clausesContext *_localctx = _tracker.createInstance<Kernels_clausesContext>(_ctx, getState());
3566 0 : enterRule(_localctx, 82, accparser::RuleKernels_clauses);
3567 :
3568 0 : auto onExit = finally([=] {
3569 0 : exitRule();
3570 0 : });
3571 0 : try {
3572 0 : setState(530);
3573 0 : _errHandler->sync(this);
3574 0 : switch (_input->LA(1)) {
3575 0 : case accparser::ASYNC: {
3576 0 : enterOuterAlt(_localctx, 1);
3577 0 : setState(513);
3578 0 : async_clause();
3579 : break;
3580 : }
3581 :
3582 0 : case accparser::ATTACH: {
3583 0 : enterOuterAlt(_localctx, 2);
3584 0 : setState(514);
3585 0 : attach_clause();
3586 : break;
3587 : }
3588 :
3589 0 : case accparser::COPY: {
3590 0 : enterOuterAlt(_localctx, 3);
3591 0 : setState(515);
3592 0 : copy_clause();
3593 : break;
3594 : }
3595 :
3596 0 : case accparser::COPYIN: {
3597 0 : enterOuterAlt(_localctx, 4);
3598 0 : setState(516);
3599 0 : copyin_clause();
3600 : break;
3601 : }
3602 :
3603 0 : case accparser::COPYOUT: {
3604 0 : enterOuterAlt(_localctx, 5);
3605 0 : setState(517);
3606 0 : copyout_clause();
3607 : break;
3608 : }
3609 :
3610 0 : case accparser::CREATE: {
3611 0 : enterOuterAlt(_localctx, 6);
3612 0 : setState(518);
3613 0 : create_clause();
3614 : break;
3615 : }
3616 :
3617 0 : case accparser::DEFAULT: {
3618 0 : enterOuterAlt(_localctx, 7);
3619 0 : setState(519);
3620 0 : default_clause();
3621 : break;
3622 : }
3623 :
3624 0 : case accparser::DEVICE_TYPE: {
3625 0 : enterOuterAlt(_localctx, 8);
3626 0 : setState(520);
3627 0 : device_type_clause();
3628 : break;
3629 : }
3630 :
3631 0 : case accparser::DEVICEPTR: {
3632 0 : enterOuterAlt(_localctx, 9);
3633 0 : setState(521);
3634 0 : deviceptr_clause();
3635 : break;
3636 : }
3637 :
3638 0 : case accparser::IF: {
3639 0 : enterOuterAlt(_localctx, 10);
3640 0 : setState(522);
3641 0 : if_clause();
3642 : break;
3643 : }
3644 :
3645 0 : case accparser::NO_CREATE: {
3646 0 : enterOuterAlt(_localctx, 11);
3647 0 : setState(523);
3648 0 : no_create_clause();
3649 : break;
3650 : }
3651 :
3652 0 : case accparser::NUM_GANGS: {
3653 0 : enterOuterAlt(_localctx, 12);
3654 0 : setState(524);
3655 0 : num_gangs_clause();
3656 : break;
3657 : }
3658 :
3659 0 : case accparser::NUM_WORKERS: {
3660 0 : enterOuterAlt(_localctx, 13);
3661 0 : setState(525);
3662 0 : num_workers_clause();
3663 : break;
3664 : }
3665 :
3666 0 : case accparser::PRESENT: {
3667 0 : enterOuterAlt(_localctx, 14);
3668 0 : setState(526);
3669 0 : present_clause();
3670 : break;
3671 : }
3672 :
3673 0 : case accparser::SELF: {
3674 0 : enterOuterAlt(_localctx, 15);
3675 0 : setState(527);
3676 0 : self_clause();
3677 : break;
3678 : }
3679 :
3680 0 : case accparser::VECTOR_LENGTH: {
3681 0 : enterOuterAlt(_localctx, 16);
3682 0 : setState(528);
3683 0 : vector_length_clause();
3684 : break;
3685 : }
3686 :
3687 0 : case accparser::WAIT: {
3688 0 : enterOuterAlt(_localctx, 17);
3689 0 : setState(529);
3690 0 : wait_clause();
3691 : break;
3692 : }
3693 :
3694 0 : default:
3695 0 : throw NoViableAltException(this);
3696 : }
3697 :
3698 : }
3699 0 : catch (RecognitionException &e) {
3700 0 : _errHandler->reportError(this, e);
3701 0 : _localctx->exception = std::current_exception();
3702 0 : _errHandler->recover(this, _localctx->exception);
3703 : }
3704 :
3705 0 : return _localctx;
3706 : }
3707 :
3708 : //----------------- Kernels_loop_directiveContext ------------------------------------------------------------------
3709 :
3710 0 : accparser::Kernels_loop_directiveContext::Kernels_loop_directiveContext(ParserRuleContext *parent, size_t invokingState)
3711 0 : : ParserRuleContext(parent, invokingState) {
3712 0 : }
3713 :
3714 0 : tree::TerminalNode* accparser::Kernels_loop_directiveContext::KERNELS() {
3715 0 : return getToken(accparser::KERNELS, 0);
3716 : }
3717 :
3718 0 : tree::TerminalNode* accparser::Kernels_loop_directiveContext::LOOP() {
3719 0 : return getToken(accparser::LOOP, 0);
3720 : }
3721 :
3722 0 : accparser::Kernels_loop_clause_listContext* accparser::Kernels_loop_directiveContext::kernels_loop_clause_list() {
3723 0 : return getRuleContext<accparser::Kernels_loop_clause_listContext>(0);
3724 : }
3725 :
3726 :
3727 0 : size_t accparser::Kernels_loop_directiveContext::getRuleIndex() const {
3728 0 : return accparser::RuleKernels_loop_directive;
3729 : }
3730 :
3731 0 : void accparser::Kernels_loop_directiveContext::enterRule(tree::ParseTreeListener *listener) {
3732 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3733 0 : if (parserListener != nullptr)
3734 0 : parserListener->enterKernels_loop_directive(this);
3735 0 : }
3736 :
3737 0 : void accparser::Kernels_loop_directiveContext::exitRule(tree::ParseTreeListener *listener) {
3738 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3739 0 : if (parserListener != nullptr)
3740 0 : parserListener->exitKernels_loop_directive(this);
3741 0 : }
3742 :
3743 :
3744 0 : antlrcpp::Any accparser::Kernels_loop_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
3745 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
3746 0 : return parserVisitor->visitKernels_loop_directive(this);
3747 : else
3748 0 : return visitor->visitChildren(this);
3749 : }
3750 :
3751 0 : accparser::Kernels_loop_directiveContext* accparser::kernels_loop_directive() {
3752 0 : Kernels_loop_directiveContext *_localctx = _tracker.createInstance<Kernels_loop_directiveContext>(_ctx, getState());
3753 0 : enterRule(_localctx, 84, accparser::RuleKernels_loop_directive);
3754 :
3755 0 : auto onExit = finally([=] {
3756 0 : exitRule();
3757 0 : });
3758 0 : try {
3759 0 : enterOuterAlt(_localctx, 1);
3760 0 : setState(532);
3761 0 : match(accparser::KERNELS);
3762 0 : setState(533);
3763 0 : match(accparser::LOOP);
3764 0 : setState(534);
3765 0 : kernels_loop_clause_list();
3766 :
3767 : }
3768 0 : catch (RecognitionException &e) {
3769 0 : _errHandler->reportError(this, e);
3770 0 : _localctx->exception = std::current_exception();
3771 0 : _errHandler->recover(this, _localctx->exception);
3772 : }
3773 :
3774 0 : return _localctx;
3775 : }
3776 :
3777 : //----------------- Kernels_loop_clause_listContext ------------------------------------------------------------------
3778 :
3779 0 : accparser::Kernels_loop_clause_listContext::Kernels_loop_clause_listContext(ParserRuleContext *parent, size_t invokingState)
3780 0 : : ParserRuleContext(parent, invokingState) {
3781 0 : }
3782 :
3783 0 : std::vector<accparser::Kernels_loop_clausesContext *> accparser::Kernels_loop_clause_listContext::kernels_loop_clauses() {
3784 0 : return getRuleContexts<accparser::Kernels_loop_clausesContext>();
3785 : }
3786 :
3787 0 : accparser::Kernels_loop_clausesContext* accparser::Kernels_loop_clause_listContext::kernels_loop_clauses(size_t i) {
3788 0 : return getRuleContext<accparser::Kernels_loop_clausesContext>(i);
3789 : }
3790 :
3791 :
3792 0 : size_t accparser::Kernels_loop_clause_listContext::getRuleIndex() const {
3793 0 : return accparser::RuleKernels_loop_clause_list;
3794 : }
3795 :
3796 0 : void accparser::Kernels_loop_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
3797 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3798 0 : if (parserListener != nullptr)
3799 0 : parserListener->enterKernels_loop_clause_list(this);
3800 0 : }
3801 :
3802 0 : void accparser::Kernels_loop_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
3803 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3804 0 : if (parserListener != nullptr)
3805 0 : parserListener->exitKernels_loop_clause_list(this);
3806 0 : }
3807 :
3808 :
3809 0 : antlrcpp::Any accparser::Kernels_loop_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
3810 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
3811 0 : return parserVisitor->visitKernels_loop_clause_list(this);
3812 : else
3813 0 : return visitor->visitChildren(this);
3814 : }
3815 :
3816 0 : accparser::Kernels_loop_clause_listContext* accparser::kernels_loop_clause_list() {
3817 0 : Kernels_loop_clause_listContext *_localctx = _tracker.createInstance<Kernels_loop_clause_listContext>(_ctx, getState());
3818 0 : enterRule(_localctx, 86, accparser::RuleKernels_loop_clause_list);
3819 0 : size_t _la = 0;
3820 :
3821 0 : auto onExit = finally([=] {
3822 0 : exitRule();
3823 0 : });
3824 0 : try {
3825 0 : enterOuterAlt(_localctx, 1);
3826 0 : setState(539);
3827 0 : _errHandler->sync(this);
3828 0 : _la = _input->LA(1);
3829 0 : while (((((_la - 27) & ~ 0x3fULL) == 0) &&
3830 0 : ((1ULL << (_la - 27)) & ((1ULL << (accparser::ASYNC - 27))
3831 : | (1ULL << (accparser::ATTACH - 27))
3832 : | (1ULL << (accparser::AUTO - 27))
3833 : | (1ULL << (accparser::COLLAPSE - 27))
3834 : | (1ULL << (accparser::COPY - 27))
3835 : | (1ULL << (accparser::COPYIN - 27))
3836 : | (1ULL << (accparser::COPYOUT - 27))
3837 : | (1ULL << (accparser::CREATE - 27))
3838 : | (1ULL << (accparser::DEFAULT - 27))
3839 : | (1ULL << (accparser::DEVICE_TYPE - 27))
3840 : | (1ULL << (accparser::DEVICEPTR - 27))
3841 : | (1ULL << (accparser::GANG - 27))
3842 : | (1ULL << (accparser::IF - 27))
3843 : | (1ULL << (accparser::INDEPENDENT - 27))
3844 : | (1ULL << (accparser::NO_CREATE - 27))
3845 : | (1ULL << (accparser::NUM_GANGS - 27))
3846 : | (1ULL << (accparser::NUM_WORKERS - 27))
3847 : | (1ULL << (accparser::PRESENT - 27))
3848 : | (1ULL << (accparser::PRIVATE - 27))
3849 : | (1ULL << (accparser::REDUCTION - 27))
3850 : | (1ULL << (accparser::SELF - 27))
3851 : | (1ULL << (accparser::SEQ - 27))
3852 : | (1ULL << (accparser::TILE - 27))
3853 : | (1ULL << (accparser::VECTOR - 27))
3854 : | (1ULL << (accparser::VECTOR_LENGTH - 27))
3855 : | (1ULL << (accparser::WAIT - 27))
3856 0 : | (1ULL << (accparser::WORKER - 27)))) != 0)) {
3857 0 : setState(536);
3858 0 : kernels_loop_clauses();
3859 0 : setState(541);
3860 0 : _errHandler->sync(this);
3861 0 : _la = _input->LA(1);
3862 : }
3863 :
3864 : }
3865 0 : catch (RecognitionException &e) {
3866 0 : _errHandler->reportError(this, e);
3867 0 : _localctx->exception = std::current_exception();
3868 0 : _errHandler->recover(this, _localctx->exception);
3869 : }
3870 :
3871 0 : return _localctx;
3872 : }
3873 :
3874 : //----------------- Kernels_loop_clausesContext ------------------------------------------------------------------
3875 :
3876 0 : accparser::Kernels_loop_clausesContext::Kernels_loop_clausesContext(ParserRuleContext *parent, size_t invokingState)
3877 0 : : ParserRuleContext(parent, invokingState) {
3878 0 : }
3879 :
3880 0 : accparser::Async_clauseContext* accparser::Kernels_loop_clausesContext::async_clause() {
3881 0 : return getRuleContext<accparser::Async_clauseContext>(0);
3882 : }
3883 :
3884 0 : accparser::Attach_clauseContext* accparser::Kernels_loop_clausesContext::attach_clause() {
3885 0 : return getRuleContext<accparser::Attach_clauseContext>(0);
3886 : }
3887 :
3888 0 : accparser::Auto_clauseContext* accparser::Kernels_loop_clausesContext::auto_clause() {
3889 0 : return getRuleContext<accparser::Auto_clauseContext>(0);
3890 : }
3891 :
3892 0 : accparser::Collapse_clauseContext* accparser::Kernels_loop_clausesContext::collapse_clause() {
3893 0 : return getRuleContext<accparser::Collapse_clauseContext>(0);
3894 : }
3895 :
3896 0 : accparser::Copy_clauseContext* accparser::Kernels_loop_clausesContext::copy_clause() {
3897 0 : return getRuleContext<accparser::Copy_clauseContext>(0);
3898 : }
3899 :
3900 0 : accparser::Copyin_clauseContext* accparser::Kernels_loop_clausesContext::copyin_clause() {
3901 0 : return getRuleContext<accparser::Copyin_clauseContext>(0);
3902 : }
3903 :
3904 0 : accparser::Copyout_clauseContext* accparser::Kernels_loop_clausesContext::copyout_clause() {
3905 0 : return getRuleContext<accparser::Copyout_clauseContext>(0);
3906 : }
3907 :
3908 0 : accparser::Create_clauseContext* accparser::Kernels_loop_clausesContext::create_clause() {
3909 0 : return getRuleContext<accparser::Create_clauseContext>(0);
3910 : }
3911 :
3912 0 : accparser::Default_clauseContext* accparser::Kernels_loop_clausesContext::default_clause() {
3913 0 : return getRuleContext<accparser::Default_clauseContext>(0);
3914 : }
3915 :
3916 0 : accparser::Device_type_clauseContext* accparser::Kernels_loop_clausesContext::device_type_clause() {
3917 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
3918 : }
3919 :
3920 0 : accparser::Deviceptr_clauseContext* accparser::Kernels_loop_clausesContext::deviceptr_clause() {
3921 0 : return getRuleContext<accparser::Deviceptr_clauseContext>(0);
3922 : }
3923 :
3924 0 : accparser::Gang_clauseContext* accparser::Kernels_loop_clausesContext::gang_clause() {
3925 0 : return getRuleContext<accparser::Gang_clauseContext>(0);
3926 : }
3927 :
3928 0 : accparser::If_clauseContext* accparser::Kernels_loop_clausesContext::if_clause() {
3929 0 : return getRuleContext<accparser::If_clauseContext>(0);
3930 : }
3931 :
3932 0 : accparser::Independent_clauseContext* accparser::Kernels_loop_clausesContext::independent_clause() {
3933 0 : return getRuleContext<accparser::Independent_clauseContext>(0);
3934 : }
3935 :
3936 0 : accparser::No_create_clauseContext* accparser::Kernels_loop_clausesContext::no_create_clause() {
3937 0 : return getRuleContext<accparser::No_create_clauseContext>(0);
3938 : }
3939 :
3940 0 : accparser::Num_gangs_clauseContext* accparser::Kernels_loop_clausesContext::num_gangs_clause() {
3941 0 : return getRuleContext<accparser::Num_gangs_clauseContext>(0);
3942 : }
3943 :
3944 0 : accparser::Num_workers_clauseContext* accparser::Kernels_loop_clausesContext::num_workers_clause() {
3945 0 : return getRuleContext<accparser::Num_workers_clauseContext>(0);
3946 : }
3947 :
3948 0 : accparser::Present_clauseContext* accparser::Kernels_loop_clausesContext::present_clause() {
3949 0 : return getRuleContext<accparser::Present_clauseContext>(0);
3950 : }
3951 :
3952 0 : accparser::Private_clauseContext* accparser::Kernels_loop_clausesContext::private_clause() {
3953 0 : return getRuleContext<accparser::Private_clauseContext>(0);
3954 : }
3955 :
3956 0 : accparser::Reduction_clauseContext* accparser::Kernels_loop_clausesContext::reduction_clause() {
3957 0 : return getRuleContext<accparser::Reduction_clauseContext>(0);
3958 : }
3959 :
3960 0 : accparser::Self_clauseContext* accparser::Kernels_loop_clausesContext::self_clause() {
3961 0 : return getRuleContext<accparser::Self_clauseContext>(0);
3962 : }
3963 :
3964 0 : accparser::Seq_clauseContext* accparser::Kernels_loop_clausesContext::seq_clause() {
3965 0 : return getRuleContext<accparser::Seq_clauseContext>(0);
3966 : }
3967 :
3968 0 : accparser::Tile_clauseContext* accparser::Kernels_loop_clausesContext::tile_clause() {
3969 0 : return getRuleContext<accparser::Tile_clauseContext>(0);
3970 : }
3971 :
3972 0 : accparser::Vector_clauseContext* accparser::Kernels_loop_clausesContext::vector_clause() {
3973 0 : return getRuleContext<accparser::Vector_clauseContext>(0);
3974 : }
3975 :
3976 0 : accparser::Vector_length_clauseContext* accparser::Kernels_loop_clausesContext::vector_length_clause() {
3977 0 : return getRuleContext<accparser::Vector_length_clauseContext>(0);
3978 : }
3979 :
3980 0 : accparser::Wait_clauseContext* accparser::Kernels_loop_clausesContext::wait_clause() {
3981 0 : return getRuleContext<accparser::Wait_clauseContext>(0);
3982 : }
3983 :
3984 0 : accparser::Worker_clauseContext* accparser::Kernels_loop_clausesContext::worker_clause() {
3985 0 : return getRuleContext<accparser::Worker_clauseContext>(0);
3986 : }
3987 :
3988 :
3989 0 : size_t accparser::Kernels_loop_clausesContext::getRuleIndex() const {
3990 0 : return accparser::RuleKernels_loop_clauses;
3991 : }
3992 :
3993 0 : void accparser::Kernels_loop_clausesContext::enterRule(tree::ParseTreeListener *listener) {
3994 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
3995 0 : if (parserListener != nullptr)
3996 0 : parserListener->enterKernels_loop_clauses(this);
3997 0 : }
3998 :
3999 0 : void accparser::Kernels_loop_clausesContext::exitRule(tree::ParseTreeListener *listener) {
4000 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4001 0 : if (parserListener != nullptr)
4002 0 : parserListener->exitKernels_loop_clauses(this);
4003 0 : }
4004 :
4005 :
4006 0 : antlrcpp::Any accparser::Kernels_loop_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
4007 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
4008 0 : return parserVisitor->visitKernels_loop_clauses(this);
4009 : else
4010 0 : return visitor->visitChildren(this);
4011 : }
4012 :
4013 0 : accparser::Kernels_loop_clausesContext* accparser::kernels_loop_clauses() {
4014 0 : Kernels_loop_clausesContext *_localctx = _tracker.createInstance<Kernels_loop_clausesContext>(_ctx, getState());
4015 0 : enterRule(_localctx, 88, accparser::RuleKernels_loop_clauses);
4016 :
4017 0 : auto onExit = finally([=] {
4018 0 : exitRule();
4019 0 : });
4020 0 : try {
4021 0 : setState(569);
4022 0 : _errHandler->sync(this);
4023 0 : switch (_input->LA(1)) {
4024 0 : case accparser::ASYNC: {
4025 0 : enterOuterAlt(_localctx, 1);
4026 0 : setState(542);
4027 0 : async_clause();
4028 : break;
4029 : }
4030 :
4031 0 : case accparser::ATTACH: {
4032 0 : enterOuterAlt(_localctx, 2);
4033 0 : setState(543);
4034 0 : attach_clause();
4035 : break;
4036 : }
4037 :
4038 0 : case accparser::AUTO: {
4039 0 : enterOuterAlt(_localctx, 3);
4040 0 : setState(544);
4041 0 : auto_clause();
4042 : break;
4043 : }
4044 :
4045 0 : case accparser::COLLAPSE: {
4046 0 : enterOuterAlt(_localctx, 4);
4047 0 : setState(545);
4048 0 : collapse_clause();
4049 : break;
4050 : }
4051 :
4052 0 : case accparser::COPY: {
4053 0 : enterOuterAlt(_localctx, 5);
4054 0 : setState(546);
4055 0 : copy_clause();
4056 : break;
4057 : }
4058 :
4059 0 : case accparser::COPYIN: {
4060 0 : enterOuterAlt(_localctx, 6);
4061 0 : setState(547);
4062 0 : copyin_clause();
4063 : break;
4064 : }
4065 :
4066 0 : case accparser::COPYOUT: {
4067 0 : enterOuterAlt(_localctx, 7);
4068 0 : setState(548);
4069 0 : copyout_clause();
4070 : break;
4071 : }
4072 :
4073 0 : case accparser::CREATE: {
4074 0 : enterOuterAlt(_localctx, 8);
4075 0 : setState(549);
4076 0 : create_clause();
4077 : break;
4078 : }
4079 :
4080 0 : case accparser::DEFAULT: {
4081 0 : enterOuterAlt(_localctx, 9);
4082 0 : setState(550);
4083 0 : default_clause();
4084 : break;
4085 : }
4086 :
4087 0 : case accparser::DEVICE_TYPE: {
4088 0 : enterOuterAlt(_localctx, 10);
4089 0 : setState(551);
4090 0 : device_type_clause();
4091 : break;
4092 : }
4093 :
4094 0 : case accparser::DEVICEPTR: {
4095 0 : enterOuterAlt(_localctx, 11);
4096 0 : setState(552);
4097 0 : deviceptr_clause();
4098 : break;
4099 : }
4100 :
4101 0 : case accparser::GANG: {
4102 0 : enterOuterAlt(_localctx, 12);
4103 0 : setState(553);
4104 0 : gang_clause();
4105 : break;
4106 : }
4107 :
4108 0 : case accparser::IF: {
4109 0 : enterOuterAlt(_localctx, 13);
4110 0 : setState(554);
4111 0 : if_clause();
4112 : break;
4113 : }
4114 :
4115 0 : case accparser::INDEPENDENT: {
4116 0 : enterOuterAlt(_localctx, 14);
4117 0 : setState(555);
4118 0 : independent_clause();
4119 : break;
4120 : }
4121 :
4122 0 : case accparser::NO_CREATE: {
4123 0 : enterOuterAlt(_localctx, 15);
4124 0 : setState(556);
4125 0 : no_create_clause();
4126 : break;
4127 : }
4128 :
4129 0 : case accparser::NUM_GANGS: {
4130 0 : enterOuterAlt(_localctx, 16);
4131 0 : setState(557);
4132 0 : num_gangs_clause();
4133 : break;
4134 : }
4135 :
4136 0 : case accparser::NUM_WORKERS: {
4137 0 : enterOuterAlt(_localctx, 17);
4138 0 : setState(558);
4139 0 : num_workers_clause();
4140 : break;
4141 : }
4142 :
4143 0 : case accparser::PRESENT: {
4144 0 : enterOuterAlt(_localctx, 18);
4145 0 : setState(559);
4146 0 : present_clause();
4147 : break;
4148 : }
4149 :
4150 0 : case accparser::PRIVATE: {
4151 0 : enterOuterAlt(_localctx, 19);
4152 0 : setState(560);
4153 0 : private_clause();
4154 : break;
4155 : }
4156 :
4157 0 : case accparser::REDUCTION: {
4158 0 : enterOuterAlt(_localctx, 20);
4159 0 : setState(561);
4160 0 : reduction_clause();
4161 : break;
4162 : }
4163 :
4164 0 : case accparser::SELF: {
4165 0 : enterOuterAlt(_localctx, 21);
4166 0 : setState(562);
4167 0 : self_clause();
4168 : break;
4169 : }
4170 :
4171 0 : case accparser::SEQ: {
4172 0 : enterOuterAlt(_localctx, 22);
4173 0 : setState(563);
4174 0 : seq_clause();
4175 : break;
4176 : }
4177 :
4178 0 : case accparser::TILE: {
4179 0 : enterOuterAlt(_localctx, 23);
4180 0 : setState(564);
4181 0 : tile_clause();
4182 : break;
4183 : }
4184 :
4185 0 : case accparser::VECTOR: {
4186 0 : enterOuterAlt(_localctx, 24);
4187 0 : setState(565);
4188 0 : vector_clause();
4189 : break;
4190 : }
4191 :
4192 0 : case accparser::VECTOR_LENGTH: {
4193 0 : enterOuterAlt(_localctx, 25);
4194 0 : setState(566);
4195 0 : vector_length_clause();
4196 : break;
4197 : }
4198 :
4199 0 : case accparser::WAIT: {
4200 0 : enterOuterAlt(_localctx, 26);
4201 0 : setState(567);
4202 0 : wait_clause();
4203 : break;
4204 : }
4205 :
4206 0 : case accparser::WORKER: {
4207 0 : enterOuterAlt(_localctx, 27);
4208 0 : setState(568);
4209 0 : worker_clause();
4210 : break;
4211 : }
4212 :
4213 0 : default:
4214 0 : throw NoViableAltException(this);
4215 : }
4216 :
4217 : }
4218 0 : catch (RecognitionException &e) {
4219 0 : _errHandler->reportError(this, e);
4220 0 : _localctx->exception = std::current_exception();
4221 0 : _errHandler->recover(this, _localctx->exception);
4222 : }
4223 :
4224 0 : return _localctx;
4225 : }
4226 :
4227 : //----------------- Loop_directiveContext ------------------------------------------------------------------
4228 :
4229 0 : accparser::Loop_directiveContext::Loop_directiveContext(ParserRuleContext *parent, size_t invokingState)
4230 0 : : ParserRuleContext(parent, invokingState) {
4231 0 : }
4232 :
4233 0 : tree::TerminalNode* accparser::Loop_directiveContext::LOOP() {
4234 0 : return getToken(accparser::LOOP, 0);
4235 : }
4236 :
4237 0 : accparser::Loop_clause_listContext* accparser::Loop_directiveContext::loop_clause_list() {
4238 0 : return getRuleContext<accparser::Loop_clause_listContext>(0);
4239 : }
4240 :
4241 :
4242 0 : size_t accparser::Loop_directiveContext::getRuleIndex() const {
4243 0 : return accparser::RuleLoop_directive;
4244 : }
4245 :
4246 0 : void accparser::Loop_directiveContext::enterRule(tree::ParseTreeListener *listener) {
4247 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4248 0 : if (parserListener != nullptr)
4249 0 : parserListener->enterLoop_directive(this);
4250 0 : }
4251 :
4252 0 : void accparser::Loop_directiveContext::exitRule(tree::ParseTreeListener *listener) {
4253 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4254 0 : if (parserListener != nullptr)
4255 0 : parserListener->exitLoop_directive(this);
4256 0 : }
4257 :
4258 :
4259 0 : antlrcpp::Any accparser::Loop_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
4260 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
4261 0 : return parserVisitor->visitLoop_directive(this);
4262 : else
4263 0 : return visitor->visitChildren(this);
4264 : }
4265 :
4266 0 : accparser::Loop_directiveContext* accparser::loop_directive() {
4267 0 : Loop_directiveContext *_localctx = _tracker.createInstance<Loop_directiveContext>(_ctx, getState());
4268 0 : enterRule(_localctx, 90, accparser::RuleLoop_directive);
4269 :
4270 0 : auto onExit = finally([=] {
4271 0 : exitRule();
4272 0 : });
4273 0 : try {
4274 0 : enterOuterAlt(_localctx, 1);
4275 0 : setState(571);
4276 0 : match(accparser::LOOP);
4277 0 : setState(572);
4278 0 : loop_clause_list();
4279 :
4280 : }
4281 0 : catch (RecognitionException &e) {
4282 0 : _errHandler->reportError(this, e);
4283 0 : _localctx->exception = std::current_exception();
4284 0 : _errHandler->recover(this, _localctx->exception);
4285 : }
4286 :
4287 0 : return _localctx;
4288 : }
4289 :
4290 : //----------------- Loop_clause_listContext ------------------------------------------------------------------
4291 :
4292 0 : accparser::Loop_clause_listContext::Loop_clause_listContext(ParserRuleContext *parent, size_t invokingState)
4293 0 : : ParserRuleContext(parent, invokingState) {
4294 0 : }
4295 :
4296 0 : std::vector<accparser::Loop_clausesContext *> accparser::Loop_clause_listContext::loop_clauses() {
4297 0 : return getRuleContexts<accparser::Loop_clausesContext>();
4298 : }
4299 :
4300 0 : accparser::Loop_clausesContext* accparser::Loop_clause_listContext::loop_clauses(size_t i) {
4301 0 : return getRuleContext<accparser::Loop_clausesContext>(i);
4302 : }
4303 :
4304 :
4305 0 : size_t accparser::Loop_clause_listContext::getRuleIndex() const {
4306 0 : return accparser::RuleLoop_clause_list;
4307 : }
4308 :
4309 0 : void accparser::Loop_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
4310 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4311 0 : if (parserListener != nullptr)
4312 0 : parserListener->enterLoop_clause_list(this);
4313 0 : }
4314 :
4315 0 : void accparser::Loop_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
4316 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4317 0 : if (parserListener != nullptr)
4318 0 : parserListener->exitLoop_clause_list(this);
4319 0 : }
4320 :
4321 :
4322 0 : antlrcpp::Any accparser::Loop_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
4323 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
4324 0 : return parserVisitor->visitLoop_clause_list(this);
4325 : else
4326 0 : return visitor->visitChildren(this);
4327 : }
4328 :
4329 0 : accparser::Loop_clause_listContext* accparser::loop_clause_list() {
4330 0 : Loop_clause_listContext *_localctx = _tracker.createInstance<Loop_clause_listContext>(_ctx, getState());
4331 0 : enterRule(_localctx, 92, accparser::RuleLoop_clause_list);
4332 0 : size_t _la = 0;
4333 :
4334 0 : auto onExit = finally([=] {
4335 0 : exitRule();
4336 0 : });
4337 0 : try {
4338 0 : enterOuterAlt(_localctx, 1);
4339 0 : setState(577);
4340 0 : _errHandler->sync(this);
4341 0 : _la = _input->LA(1);
4342 0 : while (((((_la - 29) & ~ 0x3fULL) == 0) &&
4343 0 : ((1ULL << (_la - 29)) & ((1ULL << (accparser::AUTO - 29))
4344 : | (1ULL << (accparser::COLLAPSE - 29))
4345 : | (1ULL << (accparser::DEVICE_TYPE - 29))
4346 : | (1ULL << (accparser::GANG - 29))
4347 : | (1ULL << (accparser::INDEPENDENT - 29))
4348 : | (1ULL << (accparser::PRIVATE - 29))
4349 : | (1ULL << (accparser::REDUCTION - 29))
4350 : | (1ULL << (accparser::SEQ - 29))
4351 : | (1ULL << (accparser::TILE - 29))
4352 : | (1ULL << (accparser::VECTOR - 29))
4353 0 : | (1ULL << (accparser::WORKER - 29)))) != 0)) {
4354 0 : setState(574);
4355 0 : loop_clauses();
4356 0 : setState(579);
4357 0 : _errHandler->sync(this);
4358 0 : _la = _input->LA(1);
4359 : }
4360 :
4361 : }
4362 0 : catch (RecognitionException &e) {
4363 0 : _errHandler->reportError(this, e);
4364 0 : _localctx->exception = std::current_exception();
4365 0 : _errHandler->recover(this, _localctx->exception);
4366 : }
4367 :
4368 0 : return _localctx;
4369 : }
4370 :
4371 : //----------------- Loop_clausesContext ------------------------------------------------------------------
4372 :
4373 0 : accparser::Loop_clausesContext::Loop_clausesContext(ParserRuleContext *parent, size_t invokingState)
4374 0 : : ParserRuleContext(parent, invokingState) {
4375 0 : }
4376 :
4377 0 : accparser::Auto_clauseContext* accparser::Loop_clausesContext::auto_clause() {
4378 0 : return getRuleContext<accparser::Auto_clauseContext>(0);
4379 : }
4380 :
4381 0 : accparser::Collapse_clauseContext* accparser::Loop_clausesContext::collapse_clause() {
4382 0 : return getRuleContext<accparser::Collapse_clauseContext>(0);
4383 : }
4384 :
4385 0 : accparser::Device_type_clauseContext* accparser::Loop_clausesContext::device_type_clause() {
4386 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
4387 : }
4388 :
4389 0 : accparser::Gang_clauseContext* accparser::Loop_clausesContext::gang_clause() {
4390 0 : return getRuleContext<accparser::Gang_clauseContext>(0);
4391 : }
4392 :
4393 0 : accparser::Independent_clauseContext* accparser::Loop_clausesContext::independent_clause() {
4394 0 : return getRuleContext<accparser::Independent_clauseContext>(0);
4395 : }
4396 :
4397 0 : accparser::Private_clauseContext* accparser::Loop_clausesContext::private_clause() {
4398 0 : return getRuleContext<accparser::Private_clauseContext>(0);
4399 : }
4400 :
4401 0 : accparser::Reduction_clauseContext* accparser::Loop_clausesContext::reduction_clause() {
4402 0 : return getRuleContext<accparser::Reduction_clauseContext>(0);
4403 : }
4404 :
4405 0 : accparser::Seq_clauseContext* accparser::Loop_clausesContext::seq_clause() {
4406 0 : return getRuleContext<accparser::Seq_clauseContext>(0);
4407 : }
4408 :
4409 0 : accparser::Tile_clauseContext* accparser::Loop_clausesContext::tile_clause() {
4410 0 : return getRuleContext<accparser::Tile_clauseContext>(0);
4411 : }
4412 :
4413 0 : accparser::Vector_clauseContext* accparser::Loop_clausesContext::vector_clause() {
4414 0 : return getRuleContext<accparser::Vector_clauseContext>(0);
4415 : }
4416 :
4417 0 : accparser::Worker_clauseContext* accparser::Loop_clausesContext::worker_clause() {
4418 0 : return getRuleContext<accparser::Worker_clauseContext>(0);
4419 : }
4420 :
4421 :
4422 0 : size_t accparser::Loop_clausesContext::getRuleIndex() const {
4423 0 : return accparser::RuleLoop_clauses;
4424 : }
4425 :
4426 0 : void accparser::Loop_clausesContext::enterRule(tree::ParseTreeListener *listener) {
4427 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4428 0 : if (parserListener != nullptr)
4429 0 : parserListener->enterLoop_clauses(this);
4430 0 : }
4431 :
4432 0 : void accparser::Loop_clausesContext::exitRule(tree::ParseTreeListener *listener) {
4433 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4434 0 : if (parserListener != nullptr)
4435 0 : parserListener->exitLoop_clauses(this);
4436 0 : }
4437 :
4438 :
4439 0 : antlrcpp::Any accparser::Loop_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
4440 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
4441 0 : return parserVisitor->visitLoop_clauses(this);
4442 : else
4443 0 : return visitor->visitChildren(this);
4444 : }
4445 :
4446 0 : accparser::Loop_clausesContext* accparser::loop_clauses() {
4447 0 : Loop_clausesContext *_localctx = _tracker.createInstance<Loop_clausesContext>(_ctx, getState());
4448 0 : enterRule(_localctx, 94, accparser::RuleLoop_clauses);
4449 :
4450 0 : auto onExit = finally([=] {
4451 0 : exitRule();
4452 0 : });
4453 0 : try {
4454 0 : setState(591);
4455 0 : _errHandler->sync(this);
4456 0 : switch (_input->LA(1)) {
4457 0 : case accparser::AUTO: {
4458 0 : enterOuterAlt(_localctx, 1);
4459 0 : setState(580);
4460 0 : auto_clause();
4461 : break;
4462 : }
4463 :
4464 0 : case accparser::COLLAPSE: {
4465 0 : enterOuterAlt(_localctx, 2);
4466 0 : setState(581);
4467 0 : collapse_clause();
4468 : break;
4469 : }
4470 :
4471 0 : case accparser::DEVICE_TYPE: {
4472 0 : enterOuterAlt(_localctx, 3);
4473 0 : setState(582);
4474 0 : device_type_clause();
4475 : break;
4476 : }
4477 :
4478 0 : case accparser::GANG: {
4479 0 : enterOuterAlt(_localctx, 4);
4480 0 : setState(583);
4481 0 : gang_clause();
4482 : break;
4483 : }
4484 :
4485 0 : case accparser::INDEPENDENT: {
4486 0 : enterOuterAlt(_localctx, 5);
4487 0 : setState(584);
4488 0 : independent_clause();
4489 : break;
4490 : }
4491 :
4492 0 : case accparser::PRIVATE: {
4493 0 : enterOuterAlt(_localctx, 6);
4494 0 : setState(585);
4495 0 : private_clause();
4496 : break;
4497 : }
4498 :
4499 0 : case accparser::REDUCTION: {
4500 0 : enterOuterAlt(_localctx, 7);
4501 0 : setState(586);
4502 0 : reduction_clause();
4503 : break;
4504 : }
4505 :
4506 0 : case accparser::SEQ: {
4507 0 : enterOuterAlt(_localctx, 8);
4508 0 : setState(587);
4509 0 : seq_clause();
4510 : break;
4511 : }
4512 :
4513 0 : case accparser::TILE: {
4514 0 : enterOuterAlt(_localctx, 9);
4515 0 : setState(588);
4516 0 : tile_clause();
4517 : break;
4518 : }
4519 :
4520 0 : case accparser::VECTOR: {
4521 0 : enterOuterAlt(_localctx, 10);
4522 0 : setState(589);
4523 0 : vector_clause();
4524 : break;
4525 : }
4526 :
4527 0 : case accparser::WORKER: {
4528 0 : enterOuterAlt(_localctx, 11);
4529 0 : setState(590);
4530 0 : worker_clause();
4531 : break;
4532 : }
4533 :
4534 0 : default:
4535 0 : throw NoViableAltException(this);
4536 : }
4537 :
4538 : }
4539 0 : catch (RecognitionException &e) {
4540 0 : _errHandler->reportError(this, e);
4541 0 : _localctx->exception = std::current_exception();
4542 0 : _errHandler->recover(this, _localctx->exception);
4543 : }
4544 :
4545 0 : return _localctx;
4546 : }
4547 :
4548 : //----------------- Parallel_directiveContext ------------------------------------------------------------------
4549 :
4550 0 : accparser::Parallel_directiveContext::Parallel_directiveContext(ParserRuleContext *parent, size_t invokingState)
4551 0 : : ParserRuleContext(parent, invokingState) {
4552 0 : }
4553 :
4554 0 : tree::TerminalNode* accparser::Parallel_directiveContext::PARALLEL() {
4555 0 : return getToken(accparser::PARALLEL, 0);
4556 : }
4557 :
4558 0 : accparser::Parallel_clause_listContext* accparser::Parallel_directiveContext::parallel_clause_list() {
4559 0 : return getRuleContext<accparser::Parallel_clause_listContext>(0);
4560 : }
4561 :
4562 :
4563 0 : size_t accparser::Parallel_directiveContext::getRuleIndex() const {
4564 0 : return accparser::RuleParallel_directive;
4565 : }
4566 :
4567 0 : void accparser::Parallel_directiveContext::enterRule(tree::ParseTreeListener *listener) {
4568 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4569 0 : if (parserListener != nullptr)
4570 0 : parserListener->enterParallel_directive(this);
4571 0 : }
4572 :
4573 0 : void accparser::Parallel_directiveContext::exitRule(tree::ParseTreeListener *listener) {
4574 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4575 0 : if (parserListener != nullptr)
4576 0 : parserListener->exitParallel_directive(this);
4577 0 : }
4578 :
4579 :
4580 0 : antlrcpp::Any accparser::Parallel_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
4581 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
4582 0 : return parserVisitor->visitParallel_directive(this);
4583 : else
4584 0 : return visitor->visitChildren(this);
4585 : }
4586 :
4587 0 : accparser::Parallel_directiveContext* accparser::parallel_directive() {
4588 0 : Parallel_directiveContext *_localctx = _tracker.createInstance<Parallel_directiveContext>(_ctx, getState());
4589 0 : enterRule(_localctx, 96, accparser::RuleParallel_directive);
4590 :
4591 0 : auto onExit = finally([=] {
4592 0 : exitRule();
4593 0 : });
4594 0 : try {
4595 0 : enterOuterAlt(_localctx, 1);
4596 0 : setState(593);
4597 0 : match(accparser::PARALLEL);
4598 0 : setState(594);
4599 0 : parallel_clause_list();
4600 :
4601 : }
4602 0 : catch (RecognitionException &e) {
4603 0 : _errHandler->reportError(this, e);
4604 0 : _localctx->exception = std::current_exception();
4605 0 : _errHandler->recover(this, _localctx->exception);
4606 : }
4607 :
4608 0 : return _localctx;
4609 : }
4610 :
4611 : //----------------- Parallel_clause_listContext ------------------------------------------------------------------
4612 :
4613 0 : accparser::Parallel_clause_listContext::Parallel_clause_listContext(ParserRuleContext *parent, size_t invokingState)
4614 0 : : ParserRuleContext(parent, invokingState) {
4615 0 : }
4616 :
4617 0 : std::vector<accparser::Parallel_clausesContext *> accparser::Parallel_clause_listContext::parallel_clauses() {
4618 0 : return getRuleContexts<accparser::Parallel_clausesContext>();
4619 : }
4620 :
4621 0 : accparser::Parallel_clausesContext* accparser::Parallel_clause_listContext::parallel_clauses(size_t i) {
4622 0 : return getRuleContext<accparser::Parallel_clausesContext>(i);
4623 : }
4624 :
4625 :
4626 0 : size_t accparser::Parallel_clause_listContext::getRuleIndex() const {
4627 0 : return accparser::RuleParallel_clause_list;
4628 : }
4629 :
4630 0 : void accparser::Parallel_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
4631 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4632 0 : if (parserListener != nullptr)
4633 0 : parserListener->enterParallel_clause_list(this);
4634 0 : }
4635 :
4636 0 : void accparser::Parallel_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
4637 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4638 0 : if (parserListener != nullptr)
4639 0 : parserListener->exitParallel_clause_list(this);
4640 0 : }
4641 :
4642 :
4643 0 : antlrcpp::Any accparser::Parallel_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
4644 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
4645 0 : return parserVisitor->visitParallel_clause_list(this);
4646 : else
4647 0 : return visitor->visitChildren(this);
4648 : }
4649 :
4650 0 : accparser::Parallel_clause_listContext* accparser::parallel_clause_list() {
4651 0 : Parallel_clause_listContext *_localctx = _tracker.createInstance<Parallel_clause_listContext>(_ctx, getState());
4652 0 : enterRule(_localctx, 98, accparser::RuleParallel_clause_list);
4653 0 : size_t _la = 0;
4654 :
4655 0 : auto onExit = finally([=] {
4656 0 : exitRule();
4657 0 : });
4658 0 : try {
4659 0 : enterOuterAlt(_localctx, 1);
4660 0 : setState(599);
4661 0 : _errHandler->sync(this);
4662 0 : _la = _input->LA(1);
4663 0 : while (((((_la - 27) & ~ 0x3fULL) == 0) &&
4664 0 : ((1ULL << (_la - 27)) & ((1ULL << (accparser::ASYNC - 27))
4665 : | (1ULL << (accparser::ATTACH - 27))
4666 : | (1ULL << (accparser::COPY - 27))
4667 : | (1ULL << (accparser::COPYIN - 27))
4668 : | (1ULL << (accparser::COPYOUT - 27))
4669 : | (1ULL << (accparser::CREATE - 27))
4670 : | (1ULL << (accparser::DEFAULT - 27))
4671 : | (1ULL << (accparser::DEVICE_TYPE - 27))
4672 : | (1ULL << (accparser::DEVICEPTR - 27))
4673 : | (1ULL << (accparser::FIRSTPRIVATE - 27))
4674 : | (1ULL << (accparser::IF - 27))
4675 : | (1ULL << (accparser::NO_CREATE - 27))
4676 : | (1ULL << (accparser::NUM_GANGS - 27))
4677 : | (1ULL << (accparser::NUM_WORKERS - 27))
4678 : | (1ULL << (accparser::PRESENT - 27))
4679 : | (1ULL << (accparser::PRIVATE - 27))
4680 : | (1ULL << (accparser::REDUCTION - 27))
4681 : | (1ULL << (accparser::SELF - 27))
4682 : | (1ULL << (accparser::VECTOR_LENGTH - 27))
4683 0 : | (1ULL << (accparser::WAIT - 27)))) != 0)) {
4684 0 : setState(596);
4685 0 : parallel_clauses();
4686 0 : setState(601);
4687 0 : _errHandler->sync(this);
4688 0 : _la = _input->LA(1);
4689 : }
4690 :
4691 : }
4692 0 : catch (RecognitionException &e) {
4693 0 : _errHandler->reportError(this, e);
4694 0 : _localctx->exception = std::current_exception();
4695 0 : _errHandler->recover(this, _localctx->exception);
4696 : }
4697 :
4698 0 : return _localctx;
4699 : }
4700 :
4701 : //----------------- Parallel_clausesContext ------------------------------------------------------------------
4702 :
4703 0 : accparser::Parallel_clausesContext::Parallel_clausesContext(ParserRuleContext *parent, size_t invokingState)
4704 0 : : ParserRuleContext(parent, invokingState) {
4705 0 : }
4706 :
4707 0 : accparser::Async_clauseContext* accparser::Parallel_clausesContext::async_clause() {
4708 0 : return getRuleContext<accparser::Async_clauseContext>(0);
4709 : }
4710 :
4711 0 : accparser::Attach_clauseContext* accparser::Parallel_clausesContext::attach_clause() {
4712 0 : return getRuleContext<accparser::Attach_clauseContext>(0);
4713 : }
4714 :
4715 0 : accparser::Copy_clauseContext* accparser::Parallel_clausesContext::copy_clause() {
4716 0 : return getRuleContext<accparser::Copy_clauseContext>(0);
4717 : }
4718 :
4719 0 : accparser::Copyin_clauseContext* accparser::Parallel_clausesContext::copyin_clause() {
4720 0 : return getRuleContext<accparser::Copyin_clauseContext>(0);
4721 : }
4722 :
4723 0 : accparser::Copyout_clauseContext* accparser::Parallel_clausesContext::copyout_clause() {
4724 0 : return getRuleContext<accparser::Copyout_clauseContext>(0);
4725 : }
4726 :
4727 0 : accparser::Create_clauseContext* accparser::Parallel_clausesContext::create_clause() {
4728 0 : return getRuleContext<accparser::Create_clauseContext>(0);
4729 : }
4730 :
4731 0 : accparser::Default_clauseContext* accparser::Parallel_clausesContext::default_clause() {
4732 0 : return getRuleContext<accparser::Default_clauseContext>(0);
4733 : }
4734 :
4735 0 : accparser::Device_type_clauseContext* accparser::Parallel_clausesContext::device_type_clause() {
4736 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
4737 : }
4738 :
4739 0 : accparser::Deviceptr_clauseContext* accparser::Parallel_clausesContext::deviceptr_clause() {
4740 0 : return getRuleContext<accparser::Deviceptr_clauseContext>(0);
4741 : }
4742 :
4743 0 : accparser::Firstprivate_clauseContext* accparser::Parallel_clausesContext::firstprivate_clause() {
4744 0 : return getRuleContext<accparser::Firstprivate_clauseContext>(0);
4745 : }
4746 :
4747 0 : accparser::If_clauseContext* accparser::Parallel_clausesContext::if_clause() {
4748 0 : return getRuleContext<accparser::If_clauseContext>(0);
4749 : }
4750 :
4751 0 : accparser::No_create_clauseContext* accparser::Parallel_clausesContext::no_create_clause() {
4752 0 : return getRuleContext<accparser::No_create_clauseContext>(0);
4753 : }
4754 :
4755 0 : accparser::Num_gangs_clauseContext* accparser::Parallel_clausesContext::num_gangs_clause() {
4756 0 : return getRuleContext<accparser::Num_gangs_clauseContext>(0);
4757 : }
4758 :
4759 0 : accparser::Num_workers_clauseContext* accparser::Parallel_clausesContext::num_workers_clause() {
4760 0 : return getRuleContext<accparser::Num_workers_clauseContext>(0);
4761 : }
4762 :
4763 0 : accparser::Present_clauseContext* accparser::Parallel_clausesContext::present_clause() {
4764 0 : return getRuleContext<accparser::Present_clauseContext>(0);
4765 : }
4766 :
4767 0 : accparser::Private_clauseContext* accparser::Parallel_clausesContext::private_clause() {
4768 0 : return getRuleContext<accparser::Private_clauseContext>(0);
4769 : }
4770 :
4771 0 : accparser::Reduction_clauseContext* accparser::Parallel_clausesContext::reduction_clause() {
4772 0 : return getRuleContext<accparser::Reduction_clauseContext>(0);
4773 : }
4774 :
4775 0 : accparser::Self_clauseContext* accparser::Parallel_clausesContext::self_clause() {
4776 0 : return getRuleContext<accparser::Self_clauseContext>(0);
4777 : }
4778 :
4779 0 : accparser::Vector_length_clauseContext* accparser::Parallel_clausesContext::vector_length_clause() {
4780 0 : return getRuleContext<accparser::Vector_length_clauseContext>(0);
4781 : }
4782 :
4783 0 : accparser::Wait_clauseContext* accparser::Parallel_clausesContext::wait_clause() {
4784 0 : return getRuleContext<accparser::Wait_clauseContext>(0);
4785 : }
4786 :
4787 :
4788 0 : size_t accparser::Parallel_clausesContext::getRuleIndex() const {
4789 0 : return accparser::RuleParallel_clauses;
4790 : }
4791 :
4792 0 : void accparser::Parallel_clausesContext::enterRule(tree::ParseTreeListener *listener) {
4793 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4794 0 : if (parserListener != nullptr)
4795 0 : parserListener->enterParallel_clauses(this);
4796 0 : }
4797 :
4798 0 : void accparser::Parallel_clausesContext::exitRule(tree::ParseTreeListener *listener) {
4799 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
4800 0 : if (parserListener != nullptr)
4801 0 : parserListener->exitParallel_clauses(this);
4802 0 : }
4803 :
4804 :
4805 0 : antlrcpp::Any accparser::Parallel_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
4806 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
4807 0 : return parserVisitor->visitParallel_clauses(this);
4808 : else
4809 0 : return visitor->visitChildren(this);
4810 : }
4811 :
4812 0 : accparser::Parallel_clausesContext* accparser::parallel_clauses() {
4813 0 : Parallel_clausesContext *_localctx = _tracker.createInstance<Parallel_clausesContext>(_ctx, getState());
4814 0 : enterRule(_localctx, 100, accparser::RuleParallel_clauses);
4815 :
4816 0 : auto onExit = finally([=] {
4817 0 : exitRule();
4818 0 : });
4819 0 : try {
4820 0 : setState(622);
4821 0 : _errHandler->sync(this);
4822 0 : switch (_input->LA(1)) {
4823 0 : case accparser::ASYNC: {
4824 0 : enterOuterAlt(_localctx, 1);
4825 0 : setState(602);
4826 0 : async_clause();
4827 : break;
4828 : }
4829 :
4830 0 : case accparser::ATTACH: {
4831 0 : enterOuterAlt(_localctx, 2);
4832 0 : setState(603);
4833 0 : attach_clause();
4834 : break;
4835 : }
4836 :
4837 0 : case accparser::COPY: {
4838 0 : enterOuterAlt(_localctx, 3);
4839 0 : setState(604);
4840 0 : copy_clause();
4841 : break;
4842 : }
4843 :
4844 0 : case accparser::COPYIN: {
4845 0 : enterOuterAlt(_localctx, 4);
4846 0 : setState(605);
4847 0 : copyin_clause();
4848 : break;
4849 : }
4850 :
4851 0 : case accparser::COPYOUT: {
4852 0 : enterOuterAlt(_localctx, 5);
4853 0 : setState(606);
4854 0 : copyout_clause();
4855 : break;
4856 : }
4857 :
4858 0 : case accparser::CREATE: {
4859 0 : enterOuterAlt(_localctx, 6);
4860 0 : setState(607);
4861 0 : create_clause();
4862 : break;
4863 : }
4864 :
4865 0 : case accparser::DEFAULT: {
4866 0 : enterOuterAlt(_localctx, 7);
4867 0 : setState(608);
4868 0 : default_clause();
4869 : break;
4870 : }
4871 :
4872 0 : case accparser::DEVICE_TYPE: {
4873 0 : enterOuterAlt(_localctx, 8);
4874 0 : setState(609);
4875 0 : device_type_clause();
4876 : break;
4877 : }
4878 :
4879 0 : case accparser::DEVICEPTR: {
4880 0 : enterOuterAlt(_localctx, 9);
4881 0 : setState(610);
4882 0 : deviceptr_clause();
4883 : break;
4884 : }
4885 :
4886 0 : case accparser::FIRSTPRIVATE: {
4887 0 : enterOuterAlt(_localctx, 10);
4888 0 : setState(611);
4889 0 : firstprivate_clause();
4890 : break;
4891 : }
4892 :
4893 0 : case accparser::IF: {
4894 0 : enterOuterAlt(_localctx, 11);
4895 0 : setState(612);
4896 0 : if_clause();
4897 : break;
4898 : }
4899 :
4900 0 : case accparser::NO_CREATE: {
4901 0 : enterOuterAlt(_localctx, 12);
4902 0 : setState(613);
4903 0 : no_create_clause();
4904 : break;
4905 : }
4906 :
4907 0 : case accparser::NUM_GANGS: {
4908 0 : enterOuterAlt(_localctx, 13);
4909 0 : setState(614);
4910 0 : num_gangs_clause();
4911 : break;
4912 : }
4913 :
4914 0 : case accparser::NUM_WORKERS: {
4915 0 : enterOuterAlt(_localctx, 14);
4916 0 : setState(615);
4917 0 : num_workers_clause();
4918 : break;
4919 : }
4920 :
4921 0 : case accparser::PRESENT: {
4922 0 : enterOuterAlt(_localctx, 15);
4923 0 : setState(616);
4924 0 : present_clause();
4925 : break;
4926 : }
4927 :
4928 0 : case accparser::PRIVATE: {
4929 0 : enterOuterAlt(_localctx, 16);
4930 0 : setState(617);
4931 0 : private_clause();
4932 : break;
4933 : }
4934 :
4935 0 : case accparser::REDUCTION: {
4936 0 : enterOuterAlt(_localctx, 17);
4937 0 : setState(618);
4938 0 : reduction_clause();
4939 : break;
4940 : }
4941 :
4942 0 : case accparser::SELF: {
4943 0 : enterOuterAlt(_localctx, 18);
4944 0 : setState(619);
4945 0 : self_clause();
4946 : break;
4947 : }
4948 :
4949 0 : case accparser::VECTOR_LENGTH: {
4950 0 : enterOuterAlt(_localctx, 19);
4951 0 : setState(620);
4952 0 : vector_length_clause();
4953 : break;
4954 : }
4955 :
4956 0 : case accparser::WAIT: {
4957 0 : enterOuterAlt(_localctx, 20);
4958 0 : setState(621);
4959 0 : wait_clause();
4960 : break;
4961 : }
4962 :
4963 0 : default:
4964 0 : throw NoViableAltException(this);
4965 : }
4966 :
4967 : }
4968 0 : catch (RecognitionException &e) {
4969 0 : _errHandler->reportError(this, e);
4970 0 : _localctx->exception = std::current_exception();
4971 0 : _errHandler->recover(this, _localctx->exception);
4972 : }
4973 :
4974 0 : return _localctx;
4975 : }
4976 :
4977 : //----------------- Parallel_loop_directiveContext ------------------------------------------------------------------
4978 :
4979 0 : accparser::Parallel_loop_directiveContext::Parallel_loop_directiveContext(ParserRuleContext *parent, size_t invokingState)
4980 0 : : ParserRuleContext(parent, invokingState) {
4981 0 : }
4982 :
4983 0 : tree::TerminalNode* accparser::Parallel_loop_directiveContext::PARALLEL() {
4984 0 : return getToken(accparser::PARALLEL, 0);
4985 : }
4986 :
4987 0 : tree::TerminalNode* accparser::Parallel_loop_directiveContext::LOOP() {
4988 0 : return getToken(accparser::LOOP, 0);
4989 : }
4990 :
4991 0 : accparser::Parallel_loop_clause_listContext* accparser::Parallel_loop_directiveContext::parallel_loop_clause_list() {
4992 0 : return getRuleContext<accparser::Parallel_loop_clause_listContext>(0);
4993 : }
4994 :
4995 :
4996 0 : size_t accparser::Parallel_loop_directiveContext::getRuleIndex() const {
4997 0 : return accparser::RuleParallel_loop_directive;
4998 : }
4999 :
5000 0 : void accparser::Parallel_loop_directiveContext::enterRule(tree::ParseTreeListener *listener) {
5001 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5002 0 : if (parserListener != nullptr)
5003 0 : parserListener->enterParallel_loop_directive(this);
5004 0 : }
5005 :
5006 0 : void accparser::Parallel_loop_directiveContext::exitRule(tree::ParseTreeListener *listener) {
5007 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5008 0 : if (parserListener != nullptr)
5009 0 : parserListener->exitParallel_loop_directive(this);
5010 0 : }
5011 :
5012 :
5013 0 : antlrcpp::Any accparser::Parallel_loop_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
5014 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
5015 0 : return parserVisitor->visitParallel_loop_directive(this);
5016 : else
5017 0 : return visitor->visitChildren(this);
5018 : }
5019 :
5020 0 : accparser::Parallel_loop_directiveContext* accparser::parallel_loop_directive() {
5021 0 : Parallel_loop_directiveContext *_localctx = _tracker.createInstance<Parallel_loop_directiveContext>(_ctx, getState());
5022 0 : enterRule(_localctx, 102, accparser::RuleParallel_loop_directive);
5023 :
5024 0 : auto onExit = finally([=] {
5025 0 : exitRule();
5026 0 : });
5027 0 : try {
5028 0 : enterOuterAlt(_localctx, 1);
5029 0 : setState(624);
5030 0 : match(accparser::PARALLEL);
5031 0 : setState(625);
5032 0 : match(accparser::LOOP);
5033 0 : setState(626);
5034 0 : parallel_loop_clause_list();
5035 :
5036 : }
5037 0 : catch (RecognitionException &e) {
5038 0 : _errHandler->reportError(this, e);
5039 0 : _localctx->exception = std::current_exception();
5040 0 : _errHandler->recover(this, _localctx->exception);
5041 : }
5042 :
5043 0 : return _localctx;
5044 : }
5045 :
5046 : //----------------- Parallel_loop_clause_listContext ------------------------------------------------------------------
5047 :
5048 0 : accparser::Parallel_loop_clause_listContext::Parallel_loop_clause_listContext(ParserRuleContext *parent, size_t invokingState)
5049 0 : : ParserRuleContext(parent, invokingState) {
5050 0 : }
5051 :
5052 0 : std::vector<accparser::Parallel_loop_clausesContext *> accparser::Parallel_loop_clause_listContext::parallel_loop_clauses() {
5053 0 : return getRuleContexts<accparser::Parallel_loop_clausesContext>();
5054 : }
5055 :
5056 0 : accparser::Parallel_loop_clausesContext* accparser::Parallel_loop_clause_listContext::parallel_loop_clauses(size_t i) {
5057 0 : return getRuleContext<accparser::Parallel_loop_clausesContext>(i);
5058 : }
5059 :
5060 :
5061 0 : size_t accparser::Parallel_loop_clause_listContext::getRuleIndex() const {
5062 0 : return accparser::RuleParallel_loop_clause_list;
5063 : }
5064 :
5065 0 : void accparser::Parallel_loop_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
5066 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5067 0 : if (parserListener != nullptr)
5068 0 : parserListener->enterParallel_loop_clause_list(this);
5069 0 : }
5070 :
5071 0 : void accparser::Parallel_loop_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
5072 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5073 0 : if (parserListener != nullptr)
5074 0 : parserListener->exitParallel_loop_clause_list(this);
5075 0 : }
5076 :
5077 :
5078 0 : antlrcpp::Any accparser::Parallel_loop_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
5079 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
5080 0 : return parserVisitor->visitParallel_loop_clause_list(this);
5081 : else
5082 0 : return visitor->visitChildren(this);
5083 : }
5084 :
5085 0 : accparser::Parallel_loop_clause_listContext* accparser::parallel_loop_clause_list() {
5086 0 : Parallel_loop_clause_listContext *_localctx = _tracker.createInstance<Parallel_loop_clause_listContext>(_ctx, getState());
5087 0 : enterRule(_localctx, 104, accparser::RuleParallel_loop_clause_list);
5088 0 : size_t _la = 0;
5089 :
5090 0 : auto onExit = finally([=] {
5091 0 : exitRule();
5092 0 : });
5093 0 : try {
5094 0 : enterOuterAlt(_localctx, 1);
5095 0 : setState(631);
5096 0 : _errHandler->sync(this);
5097 0 : _la = _input->LA(1);
5098 0 : while (((((_la - 27) & ~ 0x3fULL) == 0) &&
5099 0 : ((1ULL << (_la - 27)) & ((1ULL << (accparser::ASYNC - 27))
5100 : | (1ULL << (accparser::ATTACH - 27))
5101 : | (1ULL << (accparser::AUTO - 27))
5102 : | (1ULL << (accparser::COLLAPSE - 27))
5103 : | (1ULL << (accparser::COPY - 27))
5104 : | (1ULL << (accparser::COPYIN - 27))
5105 : | (1ULL << (accparser::COPYOUT - 27))
5106 : | (1ULL << (accparser::CREATE - 27))
5107 : | (1ULL << (accparser::DEFAULT - 27))
5108 : | (1ULL << (accparser::DEVICE_TYPE - 27))
5109 : | (1ULL << (accparser::DEVICEPTR - 27))
5110 : | (1ULL << (accparser::FIRSTPRIVATE - 27))
5111 : | (1ULL << (accparser::GANG - 27))
5112 : | (1ULL << (accparser::IF - 27))
5113 : | (1ULL << (accparser::INDEPENDENT - 27))
5114 : | (1ULL << (accparser::NO_CREATE - 27))
5115 : | (1ULL << (accparser::NUM_GANGS - 27))
5116 : | (1ULL << (accparser::NUM_WORKERS - 27))
5117 : | (1ULL << (accparser::PRESENT - 27))
5118 : | (1ULL << (accparser::PRIVATE - 27))
5119 : | (1ULL << (accparser::REDUCTION - 27))
5120 : | (1ULL << (accparser::SELF - 27))
5121 : | (1ULL << (accparser::SEQ - 27))
5122 : | (1ULL << (accparser::TILE - 27))
5123 : | (1ULL << (accparser::VECTOR - 27))
5124 : | (1ULL << (accparser::VECTOR_LENGTH - 27))
5125 : | (1ULL << (accparser::WAIT - 27))
5126 0 : | (1ULL << (accparser::WORKER - 27)))) != 0)) {
5127 0 : setState(628);
5128 0 : parallel_loop_clauses();
5129 0 : setState(633);
5130 0 : _errHandler->sync(this);
5131 0 : _la = _input->LA(1);
5132 : }
5133 :
5134 : }
5135 0 : catch (RecognitionException &e) {
5136 0 : _errHandler->reportError(this, e);
5137 0 : _localctx->exception = std::current_exception();
5138 0 : _errHandler->recover(this, _localctx->exception);
5139 : }
5140 :
5141 0 : return _localctx;
5142 : }
5143 :
5144 : //----------------- Parallel_loop_clausesContext ------------------------------------------------------------------
5145 :
5146 0 : accparser::Parallel_loop_clausesContext::Parallel_loop_clausesContext(ParserRuleContext *parent, size_t invokingState)
5147 0 : : ParserRuleContext(parent, invokingState) {
5148 0 : }
5149 :
5150 0 : accparser::Async_clauseContext* accparser::Parallel_loop_clausesContext::async_clause() {
5151 0 : return getRuleContext<accparser::Async_clauseContext>(0);
5152 : }
5153 :
5154 0 : accparser::Attach_clauseContext* accparser::Parallel_loop_clausesContext::attach_clause() {
5155 0 : return getRuleContext<accparser::Attach_clauseContext>(0);
5156 : }
5157 :
5158 0 : accparser::Auto_clauseContext* accparser::Parallel_loop_clausesContext::auto_clause() {
5159 0 : return getRuleContext<accparser::Auto_clauseContext>(0);
5160 : }
5161 :
5162 0 : accparser::Collapse_clauseContext* accparser::Parallel_loop_clausesContext::collapse_clause() {
5163 0 : return getRuleContext<accparser::Collapse_clauseContext>(0);
5164 : }
5165 :
5166 0 : accparser::Copy_clauseContext* accparser::Parallel_loop_clausesContext::copy_clause() {
5167 0 : return getRuleContext<accparser::Copy_clauseContext>(0);
5168 : }
5169 :
5170 0 : accparser::Copyin_clauseContext* accparser::Parallel_loop_clausesContext::copyin_clause() {
5171 0 : return getRuleContext<accparser::Copyin_clauseContext>(0);
5172 : }
5173 :
5174 0 : accparser::Copyout_clauseContext* accparser::Parallel_loop_clausesContext::copyout_clause() {
5175 0 : return getRuleContext<accparser::Copyout_clauseContext>(0);
5176 : }
5177 :
5178 0 : accparser::Create_clauseContext* accparser::Parallel_loop_clausesContext::create_clause() {
5179 0 : return getRuleContext<accparser::Create_clauseContext>(0);
5180 : }
5181 :
5182 0 : accparser::Default_clauseContext* accparser::Parallel_loop_clausesContext::default_clause() {
5183 0 : return getRuleContext<accparser::Default_clauseContext>(0);
5184 : }
5185 :
5186 0 : accparser::Device_type_clauseContext* accparser::Parallel_loop_clausesContext::device_type_clause() {
5187 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
5188 : }
5189 :
5190 0 : accparser::Deviceptr_clauseContext* accparser::Parallel_loop_clausesContext::deviceptr_clause() {
5191 0 : return getRuleContext<accparser::Deviceptr_clauseContext>(0);
5192 : }
5193 :
5194 0 : accparser::Firstprivate_clauseContext* accparser::Parallel_loop_clausesContext::firstprivate_clause() {
5195 0 : return getRuleContext<accparser::Firstprivate_clauseContext>(0);
5196 : }
5197 :
5198 0 : accparser::Gang_clauseContext* accparser::Parallel_loop_clausesContext::gang_clause() {
5199 0 : return getRuleContext<accparser::Gang_clauseContext>(0);
5200 : }
5201 :
5202 0 : accparser::If_clauseContext* accparser::Parallel_loop_clausesContext::if_clause() {
5203 0 : return getRuleContext<accparser::If_clauseContext>(0);
5204 : }
5205 :
5206 0 : accparser::Independent_clauseContext* accparser::Parallel_loop_clausesContext::independent_clause() {
5207 0 : return getRuleContext<accparser::Independent_clauseContext>(0);
5208 : }
5209 :
5210 0 : accparser::No_create_clauseContext* accparser::Parallel_loop_clausesContext::no_create_clause() {
5211 0 : return getRuleContext<accparser::No_create_clauseContext>(0);
5212 : }
5213 :
5214 0 : accparser::Num_gangs_clauseContext* accparser::Parallel_loop_clausesContext::num_gangs_clause() {
5215 0 : return getRuleContext<accparser::Num_gangs_clauseContext>(0);
5216 : }
5217 :
5218 0 : accparser::Num_workers_clauseContext* accparser::Parallel_loop_clausesContext::num_workers_clause() {
5219 0 : return getRuleContext<accparser::Num_workers_clauseContext>(0);
5220 : }
5221 :
5222 0 : accparser::Present_clauseContext* accparser::Parallel_loop_clausesContext::present_clause() {
5223 0 : return getRuleContext<accparser::Present_clauseContext>(0);
5224 : }
5225 :
5226 0 : accparser::Private_clauseContext* accparser::Parallel_loop_clausesContext::private_clause() {
5227 0 : return getRuleContext<accparser::Private_clauseContext>(0);
5228 : }
5229 :
5230 0 : accparser::Reduction_clauseContext* accparser::Parallel_loop_clausesContext::reduction_clause() {
5231 0 : return getRuleContext<accparser::Reduction_clauseContext>(0);
5232 : }
5233 :
5234 0 : accparser::Self_clauseContext* accparser::Parallel_loop_clausesContext::self_clause() {
5235 0 : return getRuleContext<accparser::Self_clauseContext>(0);
5236 : }
5237 :
5238 0 : accparser::Seq_clauseContext* accparser::Parallel_loop_clausesContext::seq_clause() {
5239 0 : return getRuleContext<accparser::Seq_clauseContext>(0);
5240 : }
5241 :
5242 0 : accparser::Tile_clauseContext* accparser::Parallel_loop_clausesContext::tile_clause() {
5243 0 : return getRuleContext<accparser::Tile_clauseContext>(0);
5244 : }
5245 :
5246 0 : accparser::Vector_clauseContext* accparser::Parallel_loop_clausesContext::vector_clause() {
5247 0 : return getRuleContext<accparser::Vector_clauseContext>(0);
5248 : }
5249 :
5250 0 : accparser::Vector_length_clauseContext* accparser::Parallel_loop_clausesContext::vector_length_clause() {
5251 0 : return getRuleContext<accparser::Vector_length_clauseContext>(0);
5252 : }
5253 :
5254 0 : accparser::Wait_clauseContext* accparser::Parallel_loop_clausesContext::wait_clause() {
5255 0 : return getRuleContext<accparser::Wait_clauseContext>(0);
5256 : }
5257 :
5258 0 : accparser::Worker_clauseContext* accparser::Parallel_loop_clausesContext::worker_clause() {
5259 0 : return getRuleContext<accparser::Worker_clauseContext>(0);
5260 : }
5261 :
5262 :
5263 0 : size_t accparser::Parallel_loop_clausesContext::getRuleIndex() const {
5264 0 : return accparser::RuleParallel_loop_clauses;
5265 : }
5266 :
5267 0 : void accparser::Parallel_loop_clausesContext::enterRule(tree::ParseTreeListener *listener) {
5268 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5269 0 : if (parserListener != nullptr)
5270 0 : parserListener->enterParallel_loop_clauses(this);
5271 0 : }
5272 :
5273 0 : void accparser::Parallel_loop_clausesContext::exitRule(tree::ParseTreeListener *listener) {
5274 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5275 0 : if (parserListener != nullptr)
5276 0 : parserListener->exitParallel_loop_clauses(this);
5277 0 : }
5278 :
5279 :
5280 0 : antlrcpp::Any accparser::Parallel_loop_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
5281 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
5282 0 : return parserVisitor->visitParallel_loop_clauses(this);
5283 : else
5284 0 : return visitor->visitChildren(this);
5285 : }
5286 :
5287 0 : accparser::Parallel_loop_clausesContext* accparser::parallel_loop_clauses() {
5288 0 : Parallel_loop_clausesContext *_localctx = _tracker.createInstance<Parallel_loop_clausesContext>(_ctx, getState());
5289 0 : enterRule(_localctx, 106, accparser::RuleParallel_loop_clauses);
5290 :
5291 0 : auto onExit = finally([=] {
5292 0 : exitRule();
5293 0 : });
5294 0 : try {
5295 0 : setState(662);
5296 0 : _errHandler->sync(this);
5297 0 : switch (_input->LA(1)) {
5298 0 : case accparser::ASYNC: {
5299 0 : enterOuterAlt(_localctx, 1);
5300 0 : setState(634);
5301 0 : async_clause();
5302 : break;
5303 : }
5304 :
5305 0 : case accparser::ATTACH: {
5306 0 : enterOuterAlt(_localctx, 2);
5307 0 : setState(635);
5308 0 : attach_clause();
5309 : break;
5310 : }
5311 :
5312 0 : case accparser::AUTO: {
5313 0 : enterOuterAlt(_localctx, 3);
5314 0 : setState(636);
5315 0 : auto_clause();
5316 : break;
5317 : }
5318 :
5319 0 : case accparser::COLLAPSE: {
5320 0 : enterOuterAlt(_localctx, 4);
5321 0 : setState(637);
5322 0 : collapse_clause();
5323 : break;
5324 : }
5325 :
5326 0 : case accparser::COPY: {
5327 0 : enterOuterAlt(_localctx, 5);
5328 0 : setState(638);
5329 0 : copy_clause();
5330 : break;
5331 : }
5332 :
5333 0 : case accparser::COPYIN: {
5334 0 : enterOuterAlt(_localctx, 6);
5335 0 : setState(639);
5336 0 : copyin_clause();
5337 : break;
5338 : }
5339 :
5340 0 : case accparser::COPYOUT: {
5341 0 : enterOuterAlt(_localctx, 7);
5342 0 : setState(640);
5343 0 : copyout_clause();
5344 : break;
5345 : }
5346 :
5347 0 : case accparser::CREATE: {
5348 0 : enterOuterAlt(_localctx, 8);
5349 0 : setState(641);
5350 0 : create_clause();
5351 : break;
5352 : }
5353 :
5354 0 : case accparser::DEFAULT: {
5355 0 : enterOuterAlt(_localctx, 9);
5356 0 : setState(642);
5357 0 : default_clause();
5358 : break;
5359 : }
5360 :
5361 0 : case accparser::DEVICE_TYPE: {
5362 0 : enterOuterAlt(_localctx, 10);
5363 0 : setState(643);
5364 0 : device_type_clause();
5365 : break;
5366 : }
5367 :
5368 0 : case accparser::DEVICEPTR: {
5369 0 : enterOuterAlt(_localctx, 11);
5370 0 : setState(644);
5371 0 : deviceptr_clause();
5372 : break;
5373 : }
5374 :
5375 0 : case accparser::FIRSTPRIVATE: {
5376 0 : enterOuterAlt(_localctx, 12);
5377 0 : setState(645);
5378 0 : firstprivate_clause();
5379 : break;
5380 : }
5381 :
5382 0 : case accparser::GANG: {
5383 0 : enterOuterAlt(_localctx, 13);
5384 0 : setState(646);
5385 0 : gang_clause();
5386 : break;
5387 : }
5388 :
5389 0 : case accparser::IF: {
5390 0 : enterOuterAlt(_localctx, 14);
5391 0 : setState(647);
5392 0 : if_clause();
5393 : break;
5394 : }
5395 :
5396 0 : case accparser::INDEPENDENT: {
5397 0 : enterOuterAlt(_localctx, 15);
5398 0 : setState(648);
5399 0 : independent_clause();
5400 : break;
5401 : }
5402 :
5403 0 : case accparser::NO_CREATE: {
5404 0 : enterOuterAlt(_localctx, 16);
5405 0 : setState(649);
5406 0 : no_create_clause();
5407 : break;
5408 : }
5409 :
5410 0 : case accparser::NUM_GANGS: {
5411 0 : enterOuterAlt(_localctx, 17);
5412 0 : setState(650);
5413 0 : num_gangs_clause();
5414 : break;
5415 : }
5416 :
5417 0 : case accparser::NUM_WORKERS: {
5418 0 : enterOuterAlt(_localctx, 18);
5419 0 : setState(651);
5420 0 : num_workers_clause();
5421 : break;
5422 : }
5423 :
5424 0 : case accparser::PRESENT: {
5425 0 : enterOuterAlt(_localctx, 19);
5426 0 : setState(652);
5427 0 : present_clause();
5428 : break;
5429 : }
5430 :
5431 0 : case accparser::PRIVATE: {
5432 0 : enterOuterAlt(_localctx, 20);
5433 0 : setState(653);
5434 0 : private_clause();
5435 : break;
5436 : }
5437 :
5438 0 : case accparser::REDUCTION: {
5439 0 : enterOuterAlt(_localctx, 21);
5440 0 : setState(654);
5441 0 : reduction_clause();
5442 : break;
5443 : }
5444 :
5445 0 : case accparser::SELF: {
5446 0 : enterOuterAlt(_localctx, 22);
5447 0 : setState(655);
5448 0 : self_clause();
5449 : break;
5450 : }
5451 :
5452 0 : case accparser::SEQ: {
5453 0 : enterOuterAlt(_localctx, 23);
5454 0 : setState(656);
5455 0 : seq_clause();
5456 : break;
5457 : }
5458 :
5459 0 : case accparser::TILE: {
5460 0 : enterOuterAlt(_localctx, 24);
5461 0 : setState(657);
5462 0 : tile_clause();
5463 : break;
5464 : }
5465 :
5466 0 : case accparser::VECTOR: {
5467 0 : enterOuterAlt(_localctx, 25);
5468 0 : setState(658);
5469 0 : vector_clause();
5470 : break;
5471 : }
5472 :
5473 0 : case accparser::VECTOR_LENGTH: {
5474 0 : enterOuterAlt(_localctx, 26);
5475 0 : setState(659);
5476 0 : vector_length_clause();
5477 : break;
5478 : }
5479 :
5480 0 : case accparser::WAIT: {
5481 0 : enterOuterAlt(_localctx, 27);
5482 0 : setState(660);
5483 0 : wait_clause();
5484 : break;
5485 : }
5486 :
5487 0 : case accparser::WORKER: {
5488 0 : enterOuterAlt(_localctx, 28);
5489 0 : setState(661);
5490 0 : worker_clause();
5491 : break;
5492 : }
5493 :
5494 0 : default:
5495 0 : throw NoViableAltException(this);
5496 : }
5497 :
5498 : }
5499 0 : catch (RecognitionException &e) {
5500 0 : _errHandler->reportError(this, e);
5501 0 : _localctx->exception = std::current_exception();
5502 0 : _errHandler->recover(this, _localctx->exception);
5503 : }
5504 :
5505 0 : return _localctx;
5506 : }
5507 :
5508 : //----------------- Routine_directiveContext ------------------------------------------------------------------
5509 :
5510 0 : accparser::Routine_directiveContext::Routine_directiveContext(ParserRuleContext *parent, size_t invokingState)
5511 0 : : ParserRuleContext(parent, invokingState) {
5512 0 : }
5513 :
5514 0 : tree::TerminalNode* accparser::Routine_directiveContext::ROUTINE() {
5515 0 : return getToken(accparser::ROUTINE, 0);
5516 : }
5517 :
5518 0 : accparser::Routine_clause_listContext* accparser::Routine_directiveContext::routine_clause_list() {
5519 0 : return getRuleContext<accparser::Routine_clause_listContext>(0);
5520 : }
5521 :
5522 0 : tree::TerminalNode* accparser::Routine_directiveContext::LEFT_PAREN() {
5523 0 : return getToken(accparser::LEFT_PAREN, 0);
5524 : }
5525 :
5526 0 : accparser::NameContext* accparser::Routine_directiveContext::name() {
5527 0 : return getRuleContext<accparser::NameContext>(0);
5528 : }
5529 :
5530 0 : tree::TerminalNode* accparser::Routine_directiveContext::RIGHT_PAREN() {
5531 0 : return getToken(accparser::RIGHT_PAREN, 0);
5532 : }
5533 :
5534 :
5535 0 : size_t accparser::Routine_directiveContext::getRuleIndex() const {
5536 0 : return accparser::RuleRoutine_directive;
5537 : }
5538 :
5539 0 : void accparser::Routine_directiveContext::enterRule(tree::ParseTreeListener *listener) {
5540 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5541 0 : if (parserListener != nullptr)
5542 0 : parserListener->enterRoutine_directive(this);
5543 0 : }
5544 :
5545 0 : void accparser::Routine_directiveContext::exitRule(tree::ParseTreeListener *listener) {
5546 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5547 0 : if (parserListener != nullptr)
5548 0 : parserListener->exitRoutine_directive(this);
5549 0 : }
5550 :
5551 :
5552 0 : antlrcpp::Any accparser::Routine_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
5553 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
5554 0 : return parserVisitor->visitRoutine_directive(this);
5555 : else
5556 0 : return visitor->visitChildren(this);
5557 : }
5558 :
5559 0 : accparser::Routine_directiveContext* accparser::routine_directive() {
5560 0 : Routine_directiveContext *_localctx = _tracker.createInstance<Routine_directiveContext>(_ctx, getState());
5561 0 : enterRule(_localctx, 108, accparser::RuleRoutine_directive);
5562 :
5563 0 : auto onExit = finally([=] {
5564 0 : exitRule();
5565 0 : });
5566 0 : try {
5567 0 : setState(672);
5568 0 : _errHandler->sync(this);
5569 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx)) {
5570 0 : case 1: {
5571 0 : enterOuterAlt(_localctx, 1);
5572 0 : setState(664);
5573 0 : match(accparser::ROUTINE);
5574 0 : setState(665);
5575 0 : routine_clause_list();
5576 : break;
5577 : }
5578 :
5579 0 : case 2: {
5580 0 : enterOuterAlt(_localctx, 2);
5581 0 : setState(666);
5582 0 : match(accparser::ROUTINE);
5583 0 : setState(667);
5584 0 : match(accparser::LEFT_PAREN);
5585 0 : setState(668);
5586 0 : name();
5587 0 : setState(669);
5588 0 : match(accparser::RIGHT_PAREN);
5589 0 : setState(670);
5590 0 : routine_clause_list();
5591 : break;
5592 : }
5593 :
5594 : }
5595 :
5596 : }
5597 0 : catch (RecognitionException &e) {
5598 0 : _errHandler->reportError(this, e);
5599 0 : _localctx->exception = std::current_exception();
5600 0 : _errHandler->recover(this, _localctx->exception);
5601 : }
5602 :
5603 0 : return _localctx;
5604 : }
5605 :
5606 : //----------------- Routine_clause_listContext ------------------------------------------------------------------
5607 :
5608 0 : accparser::Routine_clause_listContext::Routine_clause_listContext(ParserRuleContext *parent, size_t invokingState)
5609 0 : : ParserRuleContext(parent, invokingState) {
5610 0 : }
5611 :
5612 0 : std::vector<accparser::Routine_clausesContext *> accparser::Routine_clause_listContext::routine_clauses() {
5613 0 : return getRuleContexts<accparser::Routine_clausesContext>();
5614 : }
5615 :
5616 0 : accparser::Routine_clausesContext* accparser::Routine_clause_listContext::routine_clauses(size_t i) {
5617 0 : return getRuleContext<accparser::Routine_clausesContext>(i);
5618 : }
5619 :
5620 :
5621 0 : size_t accparser::Routine_clause_listContext::getRuleIndex() const {
5622 0 : return accparser::RuleRoutine_clause_list;
5623 : }
5624 :
5625 0 : void accparser::Routine_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
5626 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5627 0 : if (parserListener != nullptr)
5628 0 : parserListener->enterRoutine_clause_list(this);
5629 0 : }
5630 :
5631 0 : void accparser::Routine_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
5632 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5633 0 : if (parserListener != nullptr)
5634 0 : parserListener->exitRoutine_clause_list(this);
5635 0 : }
5636 :
5637 :
5638 0 : antlrcpp::Any accparser::Routine_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
5639 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
5640 0 : return parserVisitor->visitRoutine_clause_list(this);
5641 : else
5642 0 : return visitor->visitChildren(this);
5643 : }
5644 :
5645 0 : accparser::Routine_clause_listContext* accparser::routine_clause_list() {
5646 0 : Routine_clause_listContext *_localctx = _tracker.createInstance<Routine_clause_listContext>(_ctx, getState());
5647 0 : enterRule(_localctx, 110, accparser::RuleRoutine_clause_list);
5648 0 : size_t _la = 0;
5649 :
5650 0 : auto onExit = finally([=] {
5651 0 : exitRule();
5652 0 : });
5653 0 : try {
5654 0 : enterOuterAlt(_localctx, 1);
5655 0 : setState(675);
5656 0 : _errHandler->sync(this);
5657 0 : _la = _input->LA(1);
5658 0 : do {
5659 0 : setState(674);
5660 0 : routine_clauses();
5661 0 : setState(677);
5662 0 : _errHandler->sync(this);
5663 0 : _la = _input->LA(1);
5664 0 : } while (((((_la - 30) & ~ 0x3fULL) == 0) &&
5665 0 : ((1ULL << (_la - 30)) & ((1ULL << (accparser::BIND - 30))
5666 : | (1ULL << (accparser::DEVICE_TYPE - 30))
5667 : | (1ULL << (accparser::GANG - 30))
5668 : | (1ULL << (accparser::NOHOST - 30))
5669 : | (1ULL << (accparser::SEQ - 30))
5670 : | (1ULL << (accparser::VECTOR - 30))
5671 0 : | (1ULL << (accparser::WORKER - 30)))) != 0));
5672 :
5673 : }
5674 0 : catch (RecognitionException &e) {
5675 0 : _errHandler->reportError(this, e);
5676 0 : _localctx->exception = std::current_exception();
5677 0 : _errHandler->recover(this, _localctx->exception);
5678 : }
5679 :
5680 0 : return _localctx;
5681 : }
5682 :
5683 : //----------------- Routine_clausesContext ------------------------------------------------------------------
5684 :
5685 0 : accparser::Routine_clausesContext::Routine_clausesContext(ParserRuleContext *parent, size_t invokingState)
5686 0 : : ParserRuleContext(parent, invokingState) {
5687 0 : }
5688 :
5689 0 : accparser::Bind_clauseContext* accparser::Routine_clausesContext::bind_clause() {
5690 0 : return getRuleContext<accparser::Bind_clauseContext>(0);
5691 : }
5692 :
5693 0 : accparser::Device_type_clauseContext* accparser::Routine_clausesContext::device_type_clause() {
5694 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
5695 : }
5696 :
5697 0 : accparser::Gang_no_list_clauseContext* accparser::Routine_clausesContext::gang_no_list_clause() {
5698 0 : return getRuleContext<accparser::Gang_no_list_clauseContext>(0);
5699 : }
5700 :
5701 0 : accparser::Nohost_clauseContext* accparser::Routine_clausesContext::nohost_clause() {
5702 0 : return getRuleContext<accparser::Nohost_clauseContext>(0);
5703 : }
5704 :
5705 0 : accparser::Seq_clauseContext* accparser::Routine_clausesContext::seq_clause() {
5706 0 : return getRuleContext<accparser::Seq_clauseContext>(0);
5707 : }
5708 :
5709 0 : accparser::Vector_no_modifier_clauseContext* accparser::Routine_clausesContext::vector_no_modifier_clause() {
5710 0 : return getRuleContext<accparser::Vector_no_modifier_clauseContext>(0);
5711 : }
5712 :
5713 0 : accparser::Worker_no_modifier_clauseContext* accparser::Routine_clausesContext::worker_no_modifier_clause() {
5714 0 : return getRuleContext<accparser::Worker_no_modifier_clauseContext>(0);
5715 : }
5716 :
5717 :
5718 0 : size_t accparser::Routine_clausesContext::getRuleIndex() const {
5719 0 : return accparser::RuleRoutine_clauses;
5720 : }
5721 :
5722 0 : void accparser::Routine_clausesContext::enterRule(tree::ParseTreeListener *listener) {
5723 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5724 0 : if (parserListener != nullptr)
5725 0 : parserListener->enterRoutine_clauses(this);
5726 0 : }
5727 :
5728 0 : void accparser::Routine_clausesContext::exitRule(tree::ParseTreeListener *listener) {
5729 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5730 0 : if (parserListener != nullptr)
5731 0 : parserListener->exitRoutine_clauses(this);
5732 0 : }
5733 :
5734 :
5735 0 : antlrcpp::Any accparser::Routine_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
5736 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
5737 0 : return parserVisitor->visitRoutine_clauses(this);
5738 : else
5739 0 : return visitor->visitChildren(this);
5740 : }
5741 :
5742 0 : accparser::Routine_clausesContext* accparser::routine_clauses() {
5743 0 : Routine_clausesContext *_localctx = _tracker.createInstance<Routine_clausesContext>(_ctx, getState());
5744 0 : enterRule(_localctx, 112, accparser::RuleRoutine_clauses);
5745 :
5746 0 : auto onExit = finally([=] {
5747 0 : exitRule();
5748 0 : });
5749 0 : try {
5750 0 : setState(686);
5751 0 : _errHandler->sync(this);
5752 0 : switch (_input->LA(1)) {
5753 0 : case accparser::BIND: {
5754 0 : enterOuterAlt(_localctx, 1);
5755 0 : setState(679);
5756 0 : bind_clause();
5757 : break;
5758 : }
5759 :
5760 0 : case accparser::DEVICE_TYPE: {
5761 0 : enterOuterAlt(_localctx, 2);
5762 0 : setState(680);
5763 0 : device_type_clause();
5764 : break;
5765 : }
5766 :
5767 0 : case accparser::GANG: {
5768 0 : enterOuterAlt(_localctx, 3);
5769 0 : setState(681);
5770 0 : gang_no_list_clause();
5771 : break;
5772 : }
5773 :
5774 0 : case accparser::NOHOST: {
5775 0 : enterOuterAlt(_localctx, 4);
5776 0 : setState(682);
5777 0 : nohost_clause();
5778 : break;
5779 : }
5780 :
5781 0 : case accparser::SEQ: {
5782 0 : enterOuterAlt(_localctx, 5);
5783 0 : setState(683);
5784 0 : seq_clause();
5785 : break;
5786 : }
5787 :
5788 0 : case accparser::VECTOR: {
5789 0 : enterOuterAlt(_localctx, 6);
5790 0 : setState(684);
5791 0 : vector_no_modifier_clause();
5792 : break;
5793 : }
5794 :
5795 0 : case accparser::WORKER: {
5796 0 : enterOuterAlt(_localctx, 7);
5797 0 : setState(685);
5798 0 : worker_no_modifier_clause();
5799 : break;
5800 : }
5801 :
5802 0 : default:
5803 0 : throw NoViableAltException(this);
5804 : }
5805 :
5806 : }
5807 0 : catch (RecognitionException &e) {
5808 0 : _errHandler->reportError(this, e);
5809 0 : _localctx->exception = std::current_exception();
5810 0 : _errHandler->recover(this, _localctx->exception);
5811 : }
5812 :
5813 0 : return _localctx;
5814 : }
5815 :
5816 : //----------------- NameContext ------------------------------------------------------------------
5817 :
5818 0 : accparser::NameContext::NameContext(ParserRuleContext *parent, size_t invokingState)
5819 0 : : ParserRuleContext(parent, invokingState) {
5820 0 : }
5821 :
5822 0 : tree::TerminalNode* accparser::NameContext::EXPR() {
5823 0 : return getToken(accparser::EXPR, 0);
5824 : }
5825 :
5826 :
5827 0 : size_t accparser::NameContext::getRuleIndex() const {
5828 0 : return accparser::RuleName;
5829 : }
5830 :
5831 0 : void accparser::NameContext::enterRule(tree::ParseTreeListener *listener) {
5832 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5833 0 : if (parserListener != nullptr)
5834 0 : parserListener->enterName(this);
5835 0 : }
5836 :
5837 0 : void accparser::NameContext::exitRule(tree::ParseTreeListener *listener) {
5838 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5839 0 : if (parserListener != nullptr)
5840 0 : parserListener->exitName(this);
5841 0 : }
5842 :
5843 :
5844 0 : antlrcpp::Any accparser::NameContext::accept(tree::ParseTreeVisitor *visitor) {
5845 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
5846 0 : return parserVisitor->visitName(this);
5847 : else
5848 0 : return visitor->visitChildren(this);
5849 : }
5850 :
5851 0 : accparser::NameContext* accparser::name() {
5852 0 : NameContext *_localctx = _tracker.createInstance<NameContext>(_ctx, getState());
5853 0 : enterRule(_localctx, 114, accparser::RuleName);
5854 :
5855 0 : auto onExit = finally([=] {
5856 0 : exitRule();
5857 0 : });
5858 0 : try {
5859 0 : enterOuterAlt(_localctx, 1);
5860 0 : setState(688);
5861 0 : match(accparser::EXPR);
5862 :
5863 : }
5864 0 : catch (RecognitionException &e) {
5865 0 : _errHandler->reportError(this, e);
5866 0 : _localctx->exception = std::current_exception();
5867 0 : _errHandler->recover(this, _localctx->exception);
5868 : }
5869 :
5870 0 : return _localctx;
5871 : }
5872 :
5873 : //----------------- Serial_directiveContext ------------------------------------------------------------------
5874 :
5875 0 : accparser::Serial_directiveContext::Serial_directiveContext(ParserRuleContext *parent, size_t invokingState)
5876 0 : : ParserRuleContext(parent, invokingState) {
5877 0 : }
5878 :
5879 0 : tree::TerminalNode* accparser::Serial_directiveContext::SERIAL() {
5880 0 : return getToken(accparser::SERIAL, 0);
5881 : }
5882 :
5883 0 : accparser::Serial_clause_listContext* accparser::Serial_directiveContext::serial_clause_list() {
5884 0 : return getRuleContext<accparser::Serial_clause_listContext>(0);
5885 : }
5886 :
5887 :
5888 0 : size_t accparser::Serial_directiveContext::getRuleIndex() const {
5889 0 : return accparser::RuleSerial_directive;
5890 : }
5891 :
5892 0 : void accparser::Serial_directiveContext::enterRule(tree::ParseTreeListener *listener) {
5893 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5894 0 : if (parserListener != nullptr)
5895 0 : parserListener->enterSerial_directive(this);
5896 0 : }
5897 :
5898 0 : void accparser::Serial_directiveContext::exitRule(tree::ParseTreeListener *listener) {
5899 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5900 0 : if (parserListener != nullptr)
5901 0 : parserListener->exitSerial_directive(this);
5902 0 : }
5903 :
5904 :
5905 0 : antlrcpp::Any accparser::Serial_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
5906 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
5907 0 : return parserVisitor->visitSerial_directive(this);
5908 : else
5909 0 : return visitor->visitChildren(this);
5910 : }
5911 :
5912 0 : accparser::Serial_directiveContext* accparser::serial_directive() {
5913 0 : Serial_directiveContext *_localctx = _tracker.createInstance<Serial_directiveContext>(_ctx, getState());
5914 0 : enterRule(_localctx, 116, accparser::RuleSerial_directive);
5915 :
5916 0 : auto onExit = finally([=] {
5917 0 : exitRule();
5918 0 : });
5919 0 : try {
5920 0 : enterOuterAlt(_localctx, 1);
5921 0 : setState(690);
5922 0 : match(accparser::SERIAL);
5923 0 : setState(691);
5924 0 : serial_clause_list();
5925 :
5926 : }
5927 0 : catch (RecognitionException &e) {
5928 0 : _errHandler->reportError(this, e);
5929 0 : _localctx->exception = std::current_exception();
5930 0 : _errHandler->recover(this, _localctx->exception);
5931 : }
5932 :
5933 0 : return _localctx;
5934 : }
5935 :
5936 : //----------------- Serial_clause_listContext ------------------------------------------------------------------
5937 :
5938 0 : accparser::Serial_clause_listContext::Serial_clause_listContext(ParserRuleContext *parent, size_t invokingState)
5939 0 : : ParserRuleContext(parent, invokingState) {
5940 0 : }
5941 :
5942 0 : std::vector<accparser::Serial_clausesContext *> accparser::Serial_clause_listContext::serial_clauses() {
5943 0 : return getRuleContexts<accparser::Serial_clausesContext>();
5944 : }
5945 :
5946 0 : accparser::Serial_clausesContext* accparser::Serial_clause_listContext::serial_clauses(size_t i) {
5947 0 : return getRuleContext<accparser::Serial_clausesContext>(i);
5948 : }
5949 :
5950 :
5951 0 : size_t accparser::Serial_clause_listContext::getRuleIndex() const {
5952 0 : return accparser::RuleSerial_clause_list;
5953 : }
5954 :
5955 0 : void accparser::Serial_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
5956 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5957 0 : if (parserListener != nullptr)
5958 0 : parserListener->enterSerial_clause_list(this);
5959 0 : }
5960 :
5961 0 : void accparser::Serial_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
5962 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
5963 0 : if (parserListener != nullptr)
5964 0 : parserListener->exitSerial_clause_list(this);
5965 0 : }
5966 :
5967 :
5968 0 : antlrcpp::Any accparser::Serial_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
5969 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
5970 0 : return parserVisitor->visitSerial_clause_list(this);
5971 : else
5972 0 : return visitor->visitChildren(this);
5973 : }
5974 :
5975 0 : accparser::Serial_clause_listContext* accparser::serial_clause_list() {
5976 0 : Serial_clause_listContext *_localctx = _tracker.createInstance<Serial_clause_listContext>(_ctx, getState());
5977 0 : enterRule(_localctx, 118, accparser::RuleSerial_clause_list);
5978 0 : size_t _la = 0;
5979 :
5980 0 : auto onExit = finally([=] {
5981 0 : exitRule();
5982 0 : });
5983 0 : try {
5984 0 : enterOuterAlt(_localctx, 1);
5985 0 : setState(696);
5986 0 : _errHandler->sync(this);
5987 0 : _la = _input->LA(1);
5988 0 : while (((((_la - 27) & ~ 0x3fULL) == 0) &&
5989 0 : ((1ULL << (_la - 27)) & ((1ULL << (accparser::ASYNC - 27))
5990 : | (1ULL << (accparser::ATTACH - 27))
5991 : | (1ULL << (accparser::COPY - 27))
5992 : | (1ULL << (accparser::COPYIN - 27))
5993 : | (1ULL << (accparser::COPYOUT - 27))
5994 : | (1ULL << (accparser::CREATE - 27))
5995 : | (1ULL << (accparser::DEFAULT - 27))
5996 : | (1ULL << (accparser::DEVICE_TYPE - 27))
5997 : | (1ULL << (accparser::DEVICEPTR - 27))
5998 : | (1ULL << (accparser::FIRSTPRIVATE - 27))
5999 : | (1ULL << (accparser::IF - 27))
6000 : | (1ULL << (accparser::NO_CREATE - 27))
6001 : | (1ULL << (accparser::PRESENT - 27))
6002 : | (1ULL << (accparser::PRIVATE - 27))
6003 : | (1ULL << (accparser::REDUCTION - 27))
6004 : | (1ULL << (accparser::SELF - 27))
6005 0 : | (1ULL << (accparser::WAIT - 27)))) != 0)) {
6006 0 : setState(693);
6007 0 : serial_clauses();
6008 0 : setState(698);
6009 0 : _errHandler->sync(this);
6010 0 : _la = _input->LA(1);
6011 : }
6012 :
6013 : }
6014 0 : catch (RecognitionException &e) {
6015 0 : _errHandler->reportError(this, e);
6016 0 : _localctx->exception = std::current_exception();
6017 0 : _errHandler->recover(this, _localctx->exception);
6018 : }
6019 :
6020 0 : return _localctx;
6021 : }
6022 :
6023 : //----------------- Serial_clausesContext ------------------------------------------------------------------
6024 :
6025 0 : accparser::Serial_clausesContext::Serial_clausesContext(ParserRuleContext *parent, size_t invokingState)
6026 0 : : ParserRuleContext(parent, invokingState) {
6027 0 : }
6028 :
6029 0 : accparser::Async_clauseContext* accparser::Serial_clausesContext::async_clause() {
6030 0 : return getRuleContext<accparser::Async_clauseContext>(0);
6031 : }
6032 :
6033 0 : accparser::Attach_clauseContext* accparser::Serial_clausesContext::attach_clause() {
6034 0 : return getRuleContext<accparser::Attach_clauseContext>(0);
6035 : }
6036 :
6037 0 : accparser::Copy_clauseContext* accparser::Serial_clausesContext::copy_clause() {
6038 0 : return getRuleContext<accparser::Copy_clauseContext>(0);
6039 : }
6040 :
6041 0 : accparser::Copyin_clauseContext* accparser::Serial_clausesContext::copyin_clause() {
6042 0 : return getRuleContext<accparser::Copyin_clauseContext>(0);
6043 : }
6044 :
6045 0 : accparser::Copyout_clauseContext* accparser::Serial_clausesContext::copyout_clause() {
6046 0 : return getRuleContext<accparser::Copyout_clauseContext>(0);
6047 : }
6048 :
6049 0 : accparser::Create_clauseContext* accparser::Serial_clausesContext::create_clause() {
6050 0 : return getRuleContext<accparser::Create_clauseContext>(0);
6051 : }
6052 :
6053 0 : accparser::Default_clauseContext* accparser::Serial_clausesContext::default_clause() {
6054 0 : return getRuleContext<accparser::Default_clauseContext>(0);
6055 : }
6056 :
6057 0 : accparser::Device_type_clauseContext* accparser::Serial_clausesContext::device_type_clause() {
6058 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
6059 : }
6060 :
6061 0 : accparser::Deviceptr_clauseContext* accparser::Serial_clausesContext::deviceptr_clause() {
6062 0 : return getRuleContext<accparser::Deviceptr_clauseContext>(0);
6063 : }
6064 :
6065 0 : accparser::Firstprivate_clauseContext* accparser::Serial_clausesContext::firstprivate_clause() {
6066 0 : return getRuleContext<accparser::Firstprivate_clauseContext>(0);
6067 : }
6068 :
6069 0 : accparser::If_clauseContext* accparser::Serial_clausesContext::if_clause() {
6070 0 : return getRuleContext<accparser::If_clauseContext>(0);
6071 : }
6072 :
6073 0 : accparser::No_create_clauseContext* accparser::Serial_clausesContext::no_create_clause() {
6074 0 : return getRuleContext<accparser::No_create_clauseContext>(0);
6075 : }
6076 :
6077 0 : accparser::Present_clauseContext* accparser::Serial_clausesContext::present_clause() {
6078 0 : return getRuleContext<accparser::Present_clauseContext>(0);
6079 : }
6080 :
6081 0 : accparser::Private_clauseContext* accparser::Serial_clausesContext::private_clause() {
6082 0 : return getRuleContext<accparser::Private_clauseContext>(0);
6083 : }
6084 :
6085 0 : accparser::Reduction_clauseContext* accparser::Serial_clausesContext::reduction_clause() {
6086 0 : return getRuleContext<accparser::Reduction_clauseContext>(0);
6087 : }
6088 :
6089 0 : accparser::Self_clauseContext* accparser::Serial_clausesContext::self_clause() {
6090 0 : return getRuleContext<accparser::Self_clauseContext>(0);
6091 : }
6092 :
6093 0 : accparser::Wait_clauseContext* accparser::Serial_clausesContext::wait_clause() {
6094 0 : return getRuleContext<accparser::Wait_clauseContext>(0);
6095 : }
6096 :
6097 :
6098 0 : size_t accparser::Serial_clausesContext::getRuleIndex() const {
6099 0 : return accparser::RuleSerial_clauses;
6100 : }
6101 :
6102 0 : void accparser::Serial_clausesContext::enterRule(tree::ParseTreeListener *listener) {
6103 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6104 0 : if (parserListener != nullptr)
6105 0 : parserListener->enterSerial_clauses(this);
6106 0 : }
6107 :
6108 0 : void accparser::Serial_clausesContext::exitRule(tree::ParseTreeListener *listener) {
6109 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6110 0 : if (parserListener != nullptr)
6111 0 : parserListener->exitSerial_clauses(this);
6112 0 : }
6113 :
6114 :
6115 0 : antlrcpp::Any accparser::Serial_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
6116 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
6117 0 : return parserVisitor->visitSerial_clauses(this);
6118 : else
6119 0 : return visitor->visitChildren(this);
6120 : }
6121 :
6122 0 : accparser::Serial_clausesContext* accparser::serial_clauses() {
6123 0 : Serial_clausesContext *_localctx = _tracker.createInstance<Serial_clausesContext>(_ctx, getState());
6124 0 : enterRule(_localctx, 120, accparser::RuleSerial_clauses);
6125 :
6126 0 : auto onExit = finally([=] {
6127 0 : exitRule();
6128 0 : });
6129 0 : try {
6130 0 : setState(716);
6131 0 : _errHandler->sync(this);
6132 0 : switch (_input->LA(1)) {
6133 0 : case accparser::ASYNC: {
6134 0 : enterOuterAlt(_localctx, 1);
6135 0 : setState(699);
6136 0 : async_clause();
6137 : break;
6138 : }
6139 :
6140 0 : case accparser::ATTACH: {
6141 0 : enterOuterAlt(_localctx, 2);
6142 0 : setState(700);
6143 0 : attach_clause();
6144 : break;
6145 : }
6146 :
6147 0 : case accparser::COPY: {
6148 0 : enterOuterAlt(_localctx, 3);
6149 0 : setState(701);
6150 0 : copy_clause();
6151 : break;
6152 : }
6153 :
6154 0 : case accparser::COPYIN: {
6155 0 : enterOuterAlt(_localctx, 4);
6156 0 : setState(702);
6157 0 : copyin_clause();
6158 : break;
6159 : }
6160 :
6161 0 : case accparser::COPYOUT: {
6162 0 : enterOuterAlt(_localctx, 5);
6163 0 : setState(703);
6164 0 : copyout_clause();
6165 : break;
6166 : }
6167 :
6168 0 : case accparser::CREATE: {
6169 0 : enterOuterAlt(_localctx, 6);
6170 0 : setState(704);
6171 0 : create_clause();
6172 : break;
6173 : }
6174 :
6175 0 : case accparser::DEFAULT: {
6176 0 : enterOuterAlt(_localctx, 7);
6177 0 : setState(705);
6178 0 : default_clause();
6179 : break;
6180 : }
6181 :
6182 0 : case accparser::DEVICE_TYPE: {
6183 0 : enterOuterAlt(_localctx, 8);
6184 0 : setState(706);
6185 0 : device_type_clause();
6186 : break;
6187 : }
6188 :
6189 0 : case accparser::DEVICEPTR: {
6190 0 : enterOuterAlt(_localctx, 9);
6191 0 : setState(707);
6192 0 : deviceptr_clause();
6193 : break;
6194 : }
6195 :
6196 0 : case accparser::FIRSTPRIVATE: {
6197 0 : enterOuterAlt(_localctx, 10);
6198 0 : setState(708);
6199 0 : firstprivate_clause();
6200 : break;
6201 : }
6202 :
6203 0 : case accparser::IF: {
6204 0 : enterOuterAlt(_localctx, 11);
6205 0 : setState(709);
6206 0 : if_clause();
6207 : break;
6208 : }
6209 :
6210 0 : case accparser::NO_CREATE: {
6211 0 : enterOuterAlt(_localctx, 12);
6212 0 : setState(710);
6213 0 : no_create_clause();
6214 : break;
6215 : }
6216 :
6217 0 : case accparser::PRESENT: {
6218 0 : enterOuterAlt(_localctx, 13);
6219 0 : setState(711);
6220 0 : present_clause();
6221 : break;
6222 : }
6223 :
6224 0 : case accparser::PRIVATE: {
6225 0 : enterOuterAlt(_localctx, 14);
6226 0 : setState(712);
6227 0 : private_clause();
6228 : break;
6229 : }
6230 :
6231 0 : case accparser::REDUCTION: {
6232 0 : enterOuterAlt(_localctx, 15);
6233 0 : setState(713);
6234 0 : reduction_clause();
6235 : break;
6236 : }
6237 :
6238 0 : case accparser::SELF: {
6239 0 : enterOuterAlt(_localctx, 16);
6240 0 : setState(714);
6241 0 : self_clause();
6242 : break;
6243 : }
6244 :
6245 0 : case accparser::WAIT: {
6246 0 : enterOuterAlt(_localctx, 17);
6247 0 : setState(715);
6248 0 : wait_clause();
6249 : break;
6250 : }
6251 :
6252 0 : default:
6253 0 : throw NoViableAltException(this);
6254 : }
6255 :
6256 : }
6257 0 : catch (RecognitionException &e) {
6258 0 : _errHandler->reportError(this, e);
6259 0 : _localctx->exception = std::current_exception();
6260 0 : _errHandler->recover(this, _localctx->exception);
6261 : }
6262 :
6263 0 : return _localctx;
6264 : }
6265 :
6266 : //----------------- Serial_loop_directiveContext ------------------------------------------------------------------
6267 :
6268 0 : accparser::Serial_loop_directiveContext::Serial_loop_directiveContext(ParserRuleContext *parent, size_t invokingState)
6269 0 : : ParserRuleContext(parent, invokingState) {
6270 0 : }
6271 :
6272 0 : tree::TerminalNode* accparser::Serial_loop_directiveContext::SERIAL() {
6273 0 : return getToken(accparser::SERIAL, 0);
6274 : }
6275 :
6276 0 : tree::TerminalNode* accparser::Serial_loop_directiveContext::LOOP() {
6277 0 : return getToken(accparser::LOOP, 0);
6278 : }
6279 :
6280 0 : accparser::Serial_loop_clause_listContext* accparser::Serial_loop_directiveContext::serial_loop_clause_list() {
6281 0 : return getRuleContext<accparser::Serial_loop_clause_listContext>(0);
6282 : }
6283 :
6284 :
6285 0 : size_t accparser::Serial_loop_directiveContext::getRuleIndex() const {
6286 0 : return accparser::RuleSerial_loop_directive;
6287 : }
6288 :
6289 0 : void accparser::Serial_loop_directiveContext::enterRule(tree::ParseTreeListener *listener) {
6290 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6291 0 : if (parserListener != nullptr)
6292 0 : parserListener->enterSerial_loop_directive(this);
6293 0 : }
6294 :
6295 0 : void accparser::Serial_loop_directiveContext::exitRule(tree::ParseTreeListener *listener) {
6296 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6297 0 : if (parserListener != nullptr)
6298 0 : parserListener->exitSerial_loop_directive(this);
6299 0 : }
6300 :
6301 :
6302 0 : antlrcpp::Any accparser::Serial_loop_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
6303 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
6304 0 : return parserVisitor->visitSerial_loop_directive(this);
6305 : else
6306 0 : return visitor->visitChildren(this);
6307 : }
6308 :
6309 0 : accparser::Serial_loop_directiveContext* accparser::serial_loop_directive() {
6310 0 : Serial_loop_directiveContext *_localctx = _tracker.createInstance<Serial_loop_directiveContext>(_ctx, getState());
6311 0 : enterRule(_localctx, 122, accparser::RuleSerial_loop_directive);
6312 :
6313 0 : auto onExit = finally([=] {
6314 0 : exitRule();
6315 0 : });
6316 0 : try {
6317 0 : enterOuterAlt(_localctx, 1);
6318 0 : setState(718);
6319 0 : match(accparser::SERIAL);
6320 0 : setState(719);
6321 0 : match(accparser::LOOP);
6322 0 : setState(720);
6323 0 : serial_loop_clause_list();
6324 :
6325 : }
6326 0 : catch (RecognitionException &e) {
6327 0 : _errHandler->reportError(this, e);
6328 0 : _localctx->exception = std::current_exception();
6329 0 : _errHandler->recover(this, _localctx->exception);
6330 : }
6331 :
6332 0 : return _localctx;
6333 : }
6334 :
6335 : //----------------- Serial_loop_clause_listContext ------------------------------------------------------------------
6336 :
6337 0 : accparser::Serial_loop_clause_listContext::Serial_loop_clause_listContext(ParserRuleContext *parent, size_t invokingState)
6338 0 : : ParserRuleContext(parent, invokingState) {
6339 0 : }
6340 :
6341 0 : std::vector<accparser::Serial_loop_clausesContext *> accparser::Serial_loop_clause_listContext::serial_loop_clauses() {
6342 0 : return getRuleContexts<accparser::Serial_loop_clausesContext>();
6343 : }
6344 :
6345 0 : accparser::Serial_loop_clausesContext* accparser::Serial_loop_clause_listContext::serial_loop_clauses(size_t i) {
6346 0 : return getRuleContext<accparser::Serial_loop_clausesContext>(i);
6347 : }
6348 :
6349 :
6350 0 : size_t accparser::Serial_loop_clause_listContext::getRuleIndex() const {
6351 0 : return accparser::RuleSerial_loop_clause_list;
6352 : }
6353 :
6354 0 : void accparser::Serial_loop_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
6355 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6356 0 : if (parserListener != nullptr)
6357 0 : parserListener->enterSerial_loop_clause_list(this);
6358 0 : }
6359 :
6360 0 : void accparser::Serial_loop_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
6361 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6362 0 : if (parserListener != nullptr)
6363 0 : parserListener->exitSerial_loop_clause_list(this);
6364 0 : }
6365 :
6366 :
6367 0 : antlrcpp::Any accparser::Serial_loop_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
6368 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
6369 0 : return parserVisitor->visitSerial_loop_clause_list(this);
6370 : else
6371 0 : return visitor->visitChildren(this);
6372 : }
6373 :
6374 0 : accparser::Serial_loop_clause_listContext* accparser::serial_loop_clause_list() {
6375 0 : Serial_loop_clause_listContext *_localctx = _tracker.createInstance<Serial_loop_clause_listContext>(_ctx, getState());
6376 0 : enterRule(_localctx, 124, accparser::RuleSerial_loop_clause_list);
6377 0 : size_t _la = 0;
6378 :
6379 0 : auto onExit = finally([=] {
6380 0 : exitRule();
6381 0 : });
6382 0 : try {
6383 0 : enterOuterAlt(_localctx, 1);
6384 0 : setState(725);
6385 0 : _errHandler->sync(this);
6386 0 : _la = _input->LA(1);
6387 0 : while (((((_la - 27) & ~ 0x3fULL) == 0) &&
6388 0 : ((1ULL << (_la - 27)) & ((1ULL << (accparser::ASYNC - 27))
6389 : | (1ULL << (accparser::ATTACH - 27))
6390 : | (1ULL << (accparser::AUTO - 27))
6391 : | (1ULL << (accparser::COLLAPSE - 27))
6392 : | (1ULL << (accparser::COPY - 27))
6393 : | (1ULL << (accparser::COPYIN - 27))
6394 : | (1ULL << (accparser::COPYOUT - 27))
6395 : | (1ULL << (accparser::CREATE - 27))
6396 : | (1ULL << (accparser::DEFAULT - 27))
6397 : | (1ULL << (accparser::DEVICE_TYPE - 27))
6398 : | (1ULL << (accparser::DEVICEPTR - 27))
6399 : | (1ULL << (accparser::FIRSTPRIVATE - 27))
6400 : | (1ULL << (accparser::GANG - 27))
6401 : | (1ULL << (accparser::IF - 27))
6402 : | (1ULL << (accparser::INDEPENDENT - 27))
6403 : | (1ULL << (accparser::NO_CREATE - 27))
6404 : | (1ULL << (accparser::PRESENT - 27))
6405 : | (1ULL << (accparser::PRIVATE - 27))
6406 : | (1ULL << (accparser::REDUCTION - 27))
6407 : | (1ULL << (accparser::SELF - 27))
6408 : | (1ULL << (accparser::SEQ - 27))
6409 : | (1ULL << (accparser::TILE - 27))
6410 : | (1ULL << (accparser::VECTOR - 27))
6411 : | (1ULL << (accparser::WAIT - 27))
6412 0 : | (1ULL << (accparser::WORKER - 27)))) != 0)) {
6413 0 : setState(722);
6414 0 : serial_loop_clauses();
6415 0 : setState(727);
6416 0 : _errHandler->sync(this);
6417 0 : _la = _input->LA(1);
6418 : }
6419 :
6420 : }
6421 0 : catch (RecognitionException &e) {
6422 0 : _errHandler->reportError(this, e);
6423 0 : _localctx->exception = std::current_exception();
6424 0 : _errHandler->recover(this, _localctx->exception);
6425 : }
6426 :
6427 0 : return _localctx;
6428 : }
6429 :
6430 : //----------------- Serial_loop_clausesContext ------------------------------------------------------------------
6431 :
6432 0 : accparser::Serial_loop_clausesContext::Serial_loop_clausesContext(ParserRuleContext *parent, size_t invokingState)
6433 0 : : ParserRuleContext(parent, invokingState) {
6434 0 : }
6435 :
6436 0 : accparser::Async_clauseContext* accparser::Serial_loop_clausesContext::async_clause() {
6437 0 : return getRuleContext<accparser::Async_clauseContext>(0);
6438 : }
6439 :
6440 0 : accparser::Attach_clauseContext* accparser::Serial_loop_clausesContext::attach_clause() {
6441 0 : return getRuleContext<accparser::Attach_clauseContext>(0);
6442 : }
6443 :
6444 0 : accparser::Auto_clauseContext* accparser::Serial_loop_clausesContext::auto_clause() {
6445 0 : return getRuleContext<accparser::Auto_clauseContext>(0);
6446 : }
6447 :
6448 0 : accparser::Collapse_clauseContext* accparser::Serial_loop_clausesContext::collapse_clause() {
6449 0 : return getRuleContext<accparser::Collapse_clauseContext>(0);
6450 : }
6451 :
6452 0 : accparser::Copy_clauseContext* accparser::Serial_loop_clausesContext::copy_clause() {
6453 0 : return getRuleContext<accparser::Copy_clauseContext>(0);
6454 : }
6455 :
6456 0 : accparser::Copyin_clauseContext* accparser::Serial_loop_clausesContext::copyin_clause() {
6457 0 : return getRuleContext<accparser::Copyin_clauseContext>(0);
6458 : }
6459 :
6460 0 : accparser::Copyout_clauseContext* accparser::Serial_loop_clausesContext::copyout_clause() {
6461 0 : return getRuleContext<accparser::Copyout_clauseContext>(0);
6462 : }
6463 :
6464 0 : accparser::Create_clauseContext* accparser::Serial_loop_clausesContext::create_clause() {
6465 0 : return getRuleContext<accparser::Create_clauseContext>(0);
6466 : }
6467 :
6468 0 : accparser::Default_clauseContext* accparser::Serial_loop_clausesContext::default_clause() {
6469 0 : return getRuleContext<accparser::Default_clauseContext>(0);
6470 : }
6471 :
6472 0 : accparser::Device_type_clauseContext* accparser::Serial_loop_clausesContext::device_type_clause() {
6473 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
6474 : }
6475 :
6476 0 : accparser::Deviceptr_clauseContext* accparser::Serial_loop_clausesContext::deviceptr_clause() {
6477 0 : return getRuleContext<accparser::Deviceptr_clauseContext>(0);
6478 : }
6479 :
6480 0 : accparser::Firstprivate_clauseContext* accparser::Serial_loop_clausesContext::firstprivate_clause() {
6481 0 : return getRuleContext<accparser::Firstprivate_clauseContext>(0);
6482 : }
6483 :
6484 0 : accparser::Gang_clauseContext* accparser::Serial_loop_clausesContext::gang_clause() {
6485 0 : return getRuleContext<accparser::Gang_clauseContext>(0);
6486 : }
6487 :
6488 0 : accparser::If_clauseContext* accparser::Serial_loop_clausesContext::if_clause() {
6489 0 : return getRuleContext<accparser::If_clauseContext>(0);
6490 : }
6491 :
6492 0 : accparser::Independent_clauseContext* accparser::Serial_loop_clausesContext::independent_clause() {
6493 0 : return getRuleContext<accparser::Independent_clauseContext>(0);
6494 : }
6495 :
6496 0 : accparser::No_create_clauseContext* accparser::Serial_loop_clausesContext::no_create_clause() {
6497 0 : return getRuleContext<accparser::No_create_clauseContext>(0);
6498 : }
6499 :
6500 0 : accparser::Present_clauseContext* accparser::Serial_loop_clausesContext::present_clause() {
6501 0 : return getRuleContext<accparser::Present_clauseContext>(0);
6502 : }
6503 :
6504 0 : accparser::Private_clauseContext* accparser::Serial_loop_clausesContext::private_clause() {
6505 0 : return getRuleContext<accparser::Private_clauseContext>(0);
6506 : }
6507 :
6508 0 : accparser::Reduction_clauseContext* accparser::Serial_loop_clausesContext::reduction_clause() {
6509 0 : return getRuleContext<accparser::Reduction_clauseContext>(0);
6510 : }
6511 :
6512 0 : accparser::Self_clauseContext* accparser::Serial_loop_clausesContext::self_clause() {
6513 0 : return getRuleContext<accparser::Self_clauseContext>(0);
6514 : }
6515 :
6516 0 : accparser::Seq_clauseContext* accparser::Serial_loop_clausesContext::seq_clause() {
6517 0 : return getRuleContext<accparser::Seq_clauseContext>(0);
6518 : }
6519 :
6520 0 : accparser::Tile_clauseContext* accparser::Serial_loop_clausesContext::tile_clause() {
6521 0 : return getRuleContext<accparser::Tile_clauseContext>(0);
6522 : }
6523 :
6524 0 : accparser::Vector_clauseContext* accparser::Serial_loop_clausesContext::vector_clause() {
6525 0 : return getRuleContext<accparser::Vector_clauseContext>(0);
6526 : }
6527 :
6528 0 : accparser::Wait_clauseContext* accparser::Serial_loop_clausesContext::wait_clause() {
6529 0 : return getRuleContext<accparser::Wait_clauseContext>(0);
6530 : }
6531 :
6532 0 : accparser::Worker_clauseContext* accparser::Serial_loop_clausesContext::worker_clause() {
6533 0 : return getRuleContext<accparser::Worker_clauseContext>(0);
6534 : }
6535 :
6536 :
6537 0 : size_t accparser::Serial_loop_clausesContext::getRuleIndex() const {
6538 0 : return accparser::RuleSerial_loop_clauses;
6539 : }
6540 :
6541 0 : void accparser::Serial_loop_clausesContext::enterRule(tree::ParseTreeListener *listener) {
6542 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6543 0 : if (parserListener != nullptr)
6544 0 : parserListener->enterSerial_loop_clauses(this);
6545 0 : }
6546 :
6547 0 : void accparser::Serial_loop_clausesContext::exitRule(tree::ParseTreeListener *listener) {
6548 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6549 0 : if (parserListener != nullptr)
6550 0 : parserListener->exitSerial_loop_clauses(this);
6551 0 : }
6552 :
6553 :
6554 0 : antlrcpp::Any accparser::Serial_loop_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
6555 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
6556 0 : return parserVisitor->visitSerial_loop_clauses(this);
6557 : else
6558 0 : return visitor->visitChildren(this);
6559 : }
6560 :
6561 0 : accparser::Serial_loop_clausesContext* accparser::serial_loop_clauses() {
6562 0 : Serial_loop_clausesContext *_localctx = _tracker.createInstance<Serial_loop_clausesContext>(_ctx, getState());
6563 0 : enterRule(_localctx, 126, accparser::RuleSerial_loop_clauses);
6564 :
6565 0 : auto onExit = finally([=] {
6566 0 : exitRule();
6567 0 : });
6568 0 : try {
6569 0 : setState(753);
6570 0 : _errHandler->sync(this);
6571 0 : switch (_input->LA(1)) {
6572 0 : case accparser::ASYNC: {
6573 0 : enterOuterAlt(_localctx, 1);
6574 0 : setState(728);
6575 0 : async_clause();
6576 : break;
6577 : }
6578 :
6579 0 : case accparser::ATTACH: {
6580 0 : enterOuterAlt(_localctx, 2);
6581 0 : setState(729);
6582 0 : attach_clause();
6583 : break;
6584 : }
6585 :
6586 0 : case accparser::AUTO: {
6587 0 : enterOuterAlt(_localctx, 3);
6588 0 : setState(730);
6589 0 : auto_clause();
6590 : break;
6591 : }
6592 :
6593 0 : case accparser::COLLAPSE: {
6594 0 : enterOuterAlt(_localctx, 4);
6595 0 : setState(731);
6596 0 : collapse_clause();
6597 : break;
6598 : }
6599 :
6600 0 : case accparser::COPY: {
6601 0 : enterOuterAlt(_localctx, 5);
6602 0 : setState(732);
6603 0 : copy_clause();
6604 : break;
6605 : }
6606 :
6607 0 : case accparser::COPYIN: {
6608 0 : enterOuterAlt(_localctx, 6);
6609 0 : setState(733);
6610 0 : copyin_clause();
6611 : break;
6612 : }
6613 :
6614 0 : case accparser::COPYOUT: {
6615 0 : enterOuterAlt(_localctx, 7);
6616 0 : setState(734);
6617 0 : copyout_clause();
6618 : break;
6619 : }
6620 :
6621 0 : case accparser::CREATE: {
6622 0 : enterOuterAlt(_localctx, 8);
6623 0 : setState(735);
6624 0 : create_clause();
6625 : break;
6626 : }
6627 :
6628 0 : case accparser::DEFAULT: {
6629 0 : enterOuterAlt(_localctx, 9);
6630 0 : setState(736);
6631 0 : default_clause();
6632 : break;
6633 : }
6634 :
6635 0 : case accparser::DEVICE_TYPE: {
6636 0 : enterOuterAlt(_localctx, 10);
6637 0 : setState(737);
6638 0 : device_type_clause();
6639 : break;
6640 : }
6641 :
6642 0 : case accparser::DEVICEPTR: {
6643 0 : enterOuterAlt(_localctx, 11);
6644 0 : setState(738);
6645 0 : deviceptr_clause();
6646 : break;
6647 : }
6648 :
6649 0 : case accparser::FIRSTPRIVATE: {
6650 0 : enterOuterAlt(_localctx, 12);
6651 0 : setState(739);
6652 0 : firstprivate_clause();
6653 : break;
6654 : }
6655 :
6656 0 : case accparser::GANG: {
6657 0 : enterOuterAlt(_localctx, 13);
6658 0 : setState(740);
6659 0 : gang_clause();
6660 : break;
6661 : }
6662 :
6663 0 : case accparser::IF: {
6664 0 : enterOuterAlt(_localctx, 14);
6665 0 : setState(741);
6666 0 : if_clause();
6667 : break;
6668 : }
6669 :
6670 0 : case accparser::INDEPENDENT: {
6671 0 : enterOuterAlt(_localctx, 15);
6672 0 : setState(742);
6673 0 : independent_clause();
6674 : break;
6675 : }
6676 :
6677 0 : case accparser::NO_CREATE: {
6678 0 : enterOuterAlt(_localctx, 16);
6679 0 : setState(743);
6680 0 : no_create_clause();
6681 : break;
6682 : }
6683 :
6684 0 : case accparser::PRESENT: {
6685 0 : enterOuterAlt(_localctx, 17);
6686 0 : setState(744);
6687 0 : present_clause();
6688 : break;
6689 : }
6690 :
6691 0 : case accparser::PRIVATE: {
6692 0 : enterOuterAlt(_localctx, 18);
6693 0 : setState(745);
6694 0 : private_clause();
6695 : break;
6696 : }
6697 :
6698 0 : case accparser::REDUCTION: {
6699 0 : enterOuterAlt(_localctx, 19);
6700 0 : setState(746);
6701 0 : reduction_clause();
6702 : break;
6703 : }
6704 :
6705 0 : case accparser::SELF: {
6706 0 : enterOuterAlt(_localctx, 20);
6707 0 : setState(747);
6708 0 : self_clause();
6709 : break;
6710 : }
6711 :
6712 0 : case accparser::SEQ: {
6713 0 : enterOuterAlt(_localctx, 21);
6714 0 : setState(748);
6715 0 : seq_clause();
6716 : break;
6717 : }
6718 :
6719 0 : case accparser::TILE: {
6720 0 : enterOuterAlt(_localctx, 22);
6721 0 : setState(749);
6722 0 : tile_clause();
6723 : break;
6724 : }
6725 :
6726 0 : case accparser::VECTOR: {
6727 0 : enterOuterAlt(_localctx, 23);
6728 0 : setState(750);
6729 0 : vector_clause();
6730 : break;
6731 : }
6732 :
6733 0 : case accparser::WAIT: {
6734 0 : enterOuterAlt(_localctx, 24);
6735 0 : setState(751);
6736 0 : wait_clause();
6737 : break;
6738 : }
6739 :
6740 0 : case accparser::WORKER: {
6741 0 : enterOuterAlt(_localctx, 25);
6742 0 : setState(752);
6743 0 : worker_clause();
6744 : break;
6745 : }
6746 :
6747 0 : default:
6748 0 : throw NoViableAltException(this);
6749 : }
6750 :
6751 : }
6752 0 : catch (RecognitionException &e) {
6753 0 : _errHandler->reportError(this, e);
6754 0 : _localctx->exception = std::current_exception();
6755 0 : _errHandler->recover(this, _localctx->exception);
6756 : }
6757 :
6758 0 : return _localctx;
6759 : }
6760 :
6761 : //----------------- Set_directiveContext ------------------------------------------------------------------
6762 :
6763 0 : accparser::Set_directiveContext::Set_directiveContext(ParserRuleContext *parent, size_t invokingState)
6764 0 : : ParserRuleContext(parent, invokingState) {
6765 0 : }
6766 :
6767 0 : tree::TerminalNode* accparser::Set_directiveContext::SET() {
6768 0 : return getToken(accparser::SET, 0);
6769 : }
6770 :
6771 0 : accparser::Set_clause_listContext* accparser::Set_directiveContext::set_clause_list() {
6772 0 : return getRuleContext<accparser::Set_clause_listContext>(0);
6773 : }
6774 :
6775 :
6776 0 : size_t accparser::Set_directiveContext::getRuleIndex() const {
6777 0 : return accparser::RuleSet_directive;
6778 : }
6779 :
6780 0 : void accparser::Set_directiveContext::enterRule(tree::ParseTreeListener *listener) {
6781 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6782 0 : if (parserListener != nullptr)
6783 0 : parserListener->enterSet_directive(this);
6784 0 : }
6785 :
6786 0 : void accparser::Set_directiveContext::exitRule(tree::ParseTreeListener *listener) {
6787 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6788 0 : if (parserListener != nullptr)
6789 0 : parserListener->exitSet_directive(this);
6790 0 : }
6791 :
6792 :
6793 0 : antlrcpp::Any accparser::Set_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
6794 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
6795 0 : return parserVisitor->visitSet_directive(this);
6796 : else
6797 0 : return visitor->visitChildren(this);
6798 : }
6799 :
6800 0 : accparser::Set_directiveContext* accparser::set_directive() {
6801 0 : Set_directiveContext *_localctx = _tracker.createInstance<Set_directiveContext>(_ctx, getState());
6802 0 : enterRule(_localctx, 128, accparser::RuleSet_directive);
6803 :
6804 0 : auto onExit = finally([=] {
6805 0 : exitRule();
6806 0 : });
6807 0 : try {
6808 0 : enterOuterAlt(_localctx, 1);
6809 0 : setState(755);
6810 0 : match(accparser::SET);
6811 0 : setState(756);
6812 0 : set_clause_list();
6813 :
6814 : }
6815 0 : catch (RecognitionException &e) {
6816 0 : _errHandler->reportError(this, e);
6817 0 : _localctx->exception = std::current_exception();
6818 0 : _errHandler->recover(this, _localctx->exception);
6819 : }
6820 :
6821 0 : return _localctx;
6822 : }
6823 :
6824 : //----------------- Set_clause_listContext ------------------------------------------------------------------
6825 :
6826 0 : accparser::Set_clause_listContext::Set_clause_listContext(ParserRuleContext *parent, size_t invokingState)
6827 0 : : ParserRuleContext(parent, invokingState) {
6828 0 : }
6829 :
6830 0 : std::vector<accparser::Set_clausesContext *> accparser::Set_clause_listContext::set_clauses() {
6831 0 : return getRuleContexts<accparser::Set_clausesContext>();
6832 : }
6833 :
6834 0 : accparser::Set_clausesContext* accparser::Set_clause_listContext::set_clauses(size_t i) {
6835 0 : return getRuleContext<accparser::Set_clausesContext>(i);
6836 : }
6837 :
6838 :
6839 0 : size_t accparser::Set_clause_listContext::getRuleIndex() const {
6840 0 : return accparser::RuleSet_clause_list;
6841 : }
6842 :
6843 0 : void accparser::Set_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
6844 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6845 0 : if (parserListener != nullptr)
6846 0 : parserListener->enterSet_clause_list(this);
6847 0 : }
6848 :
6849 0 : void accparser::Set_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
6850 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6851 0 : if (parserListener != nullptr)
6852 0 : parserListener->exitSet_clause_list(this);
6853 0 : }
6854 :
6855 :
6856 0 : antlrcpp::Any accparser::Set_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
6857 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
6858 0 : return parserVisitor->visitSet_clause_list(this);
6859 : else
6860 0 : return visitor->visitChildren(this);
6861 : }
6862 :
6863 0 : accparser::Set_clause_listContext* accparser::set_clause_list() {
6864 0 : Set_clause_listContext *_localctx = _tracker.createInstance<Set_clause_listContext>(_ctx, getState());
6865 0 : enterRule(_localctx, 130, accparser::RuleSet_clause_list);
6866 0 : size_t _la = 0;
6867 :
6868 0 : auto onExit = finally([=] {
6869 0 : exitRule();
6870 0 : });
6871 0 : try {
6872 0 : enterOuterAlt(_localctx, 1);
6873 0 : setState(761);
6874 0 : _errHandler->sync(this);
6875 0 : _la = _input->LA(1);
6876 0 : while ((((_la & ~ 0x3fULL) == 0) &&
6877 : ((1ULL << _la) & ((1ULL << accparser::DEFAULT_ASYNC)
6878 : | (1ULL << accparser::DEVICE_NUM)
6879 : | (1ULL << accparser::DEVICE_TYPE)
6880 0 : | (1ULL << accparser::IF))) != 0)) {
6881 0 : setState(758);
6882 0 : set_clauses();
6883 0 : setState(763);
6884 0 : _errHandler->sync(this);
6885 0 : _la = _input->LA(1);
6886 : }
6887 :
6888 : }
6889 0 : catch (RecognitionException &e) {
6890 0 : _errHandler->reportError(this, e);
6891 0 : _localctx->exception = std::current_exception();
6892 0 : _errHandler->recover(this, _localctx->exception);
6893 : }
6894 :
6895 0 : return _localctx;
6896 : }
6897 :
6898 : //----------------- Set_clausesContext ------------------------------------------------------------------
6899 :
6900 0 : accparser::Set_clausesContext::Set_clausesContext(ParserRuleContext *parent, size_t invokingState)
6901 0 : : ParserRuleContext(parent, invokingState) {
6902 0 : }
6903 :
6904 0 : accparser::Default_async_clauseContext* accparser::Set_clausesContext::default_async_clause() {
6905 0 : return getRuleContext<accparser::Default_async_clauseContext>(0);
6906 : }
6907 :
6908 0 : accparser::Device_type_clauseContext* accparser::Set_clausesContext::device_type_clause() {
6909 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
6910 : }
6911 :
6912 0 : accparser::Device_num_clauseContext* accparser::Set_clausesContext::device_num_clause() {
6913 0 : return getRuleContext<accparser::Device_num_clauseContext>(0);
6914 : }
6915 :
6916 0 : accparser::If_clauseContext* accparser::Set_clausesContext::if_clause() {
6917 0 : return getRuleContext<accparser::If_clauseContext>(0);
6918 : }
6919 :
6920 :
6921 0 : size_t accparser::Set_clausesContext::getRuleIndex() const {
6922 0 : return accparser::RuleSet_clauses;
6923 : }
6924 :
6925 0 : void accparser::Set_clausesContext::enterRule(tree::ParseTreeListener *listener) {
6926 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6927 0 : if (parserListener != nullptr)
6928 0 : parserListener->enterSet_clauses(this);
6929 0 : }
6930 :
6931 0 : void accparser::Set_clausesContext::exitRule(tree::ParseTreeListener *listener) {
6932 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
6933 0 : if (parserListener != nullptr)
6934 0 : parserListener->exitSet_clauses(this);
6935 0 : }
6936 :
6937 :
6938 0 : antlrcpp::Any accparser::Set_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
6939 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
6940 0 : return parserVisitor->visitSet_clauses(this);
6941 : else
6942 0 : return visitor->visitChildren(this);
6943 : }
6944 :
6945 0 : accparser::Set_clausesContext* accparser::set_clauses() {
6946 0 : Set_clausesContext *_localctx = _tracker.createInstance<Set_clausesContext>(_ctx, getState());
6947 0 : enterRule(_localctx, 132, accparser::RuleSet_clauses);
6948 :
6949 0 : auto onExit = finally([=] {
6950 0 : exitRule();
6951 0 : });
6952 0 : try {
6953 0 : setState(768);
6954 0 : _errHandler->sync(this);
6955 0 : switch (_input->LA(1)) {
6956 0 : case accparser::DEFAULT_ASYNC: {
6957 0 : enterOuterAlt(_localctx, 1);
6958 0 : setState(764);
6959 0 : default_async_clause();
6960 : break;
6961 : }
6962 :
6963 0 : case accparser::DEVICE_TYPE: {
6964 0 : enterOuterAlt(_localctx, 2);
6965 0 : setState(765);
6966 0 : device_type_clause();
6967 : break;
6968 : }
6969 :
6970 0 : case accparser::DEVICE_NUM: {
6971 0 : enterOuterAlt(_localctx, 3);
6972 0 : setState(766);
6973 0 : device_num_clause();
6974 : break;
6975 : }
6976 :
6977 0 : case accparser::IF: {
6978 0 : enterOuterAlt(_localctx, 4);
6979 0 : setState(767);
6980 0 : if_clause();
6981 : break;
6982 : }
6983 :
6984 0 : default:
6985 0 : throw NoViableAltException(this);
6986 : }
6987 :
6988 : }
6989 0 : catch (RecognitionException &e) {
6990 0 : _errHandler->reportError(this, e);
6991 0 : _localctx->exception = std::current_exception();
6992 0 : _errHandler->recover(this, _localctx->exception);
6993 : }
6994 :
6995 0 : return _localctx;
6996 : }
6997 :
6998 : //----------------- Shutdown_directiveContext ------------------------------------------------------------------
6999 :
7000 0 : accparser::Shutdown_directiveContext::Shutdown_directiveContext(ParserRuleContext *parent, size_t invokingState)
7001 0 : : ParserRuleContext(parent, invokingState) {
7002 0 : }
7003 :
7004 0 : tree::TerminalNode* accparser::Shutdown_directiveContext::SHUTDOWN() {
7005 0 : return getToken(accparser::SHUTDOWN, 0);
7006 : }
7007 :
7008 0 : accparser::Shutdown_clause_listContext* accparser::Shutdown_directiveContext::shutdown_clause_list() {
7009 0 : return getRuleContext<accparser::Shutdown_clause_listContext>(0);
7010 : }
7011 :
7012 :
7013 0 : size_t accparser::Shutdown_directiveContext::getRuleIndex() const {
7014 0 : return accparser::RuleShutdown_directive;
7015 : }
7016 :
7017 0 : void accparser::Shutdown_directiveContext::enterRule(tree::ParseTreeListener *listener) {
7018 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7019 0 : if (parserListener != nullptr)
7020 0 : parserListener->enterShutdown_directive(this);
7021 0 : }
7022 :
7023 0 : void accparser::Shutdown_directiveContext::exitRule(tree::ParseTreeListener *listener) {
7024 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7025 0 : if (parserListener != nullptr)
7026 0 : parserListener->exitShutdown_directive(this);
7027 0 : }
7028 :
7029 :
7030 0 : antlrcpp::Any accparser::Shutdown_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
7031 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7032 0 : return parserVisitor->visitShutdown_directive(this);
7033 : else
7034 0 : return visitor->visitChildren(this);
7035 : }
7036 :
7037 0 : accparser::Shutdown_directiveContext* accparser::shutdown_directive() {
7038 0 : Shutdown_directiveContext *_localctx = _tracker.createInstance<Shutdown_directiveContext>(_ctx, getState());
7039 0 : enterRule(_localctx, 134, accparser::RuleShutdown_directive);
7040 :
7041 0 : auto onExit = finally([=] {
7042 0 : exitRule();
7043 0 : });
7044 0 : try {
7045 0 : enterOuterAlt(_localctx, 1);
7046 0 : setState(770);
7047 0 : match(accparser::SHUTDOWN);
7048 0 : setState(771);
7049 0 : shutdown_clause_list();
7050 :
7051 : }
7052 0 : catch (RecognitionException &e) {
7053 0 : _errHandler->reportError(this, e);
7054 0 : _localctx->exception = std::current_exception();
7055 0 : _errHandler->recover(this, _localctx->exception);
7056 : }
7057 :
7058 0 : return _localctx;
7059 : }
7060 :
7061 : //----------------- Shutdown_clause_listContext ------------------------------------------------------------------
7062 :
7063 0 : accparser::Shutdown_clause_listContext::Shutdown_clause_listContext(ParserRuleContext *parent, size_t invokingState)
7064 0 : : ParserRuleContext(parent, invokingState) {
7065 0 : }
7066 :
7067 0 : std::vector<accparser::Shutdown_clausesContext *> accparser::Shutdown_clause_listContext::shutdown_clauses() {
7068 0 : return getRuleContexts<accparser::Shutdown_clausesContext>();
7069 : }
7070 :
7071 0 : accparser::Shutdown_clausesContext* accparser::Shutdown_clause_listContext::shutdown_clauses(size_t i) {
7072 0 : return getRuleContext<accparser::Shutdown_clausesContext>(i);
7073 : }
7074 :
7075 :
7076 0 : size_t accparser::Shutdown_clause_listContext::getRuleIndex() const {
7077 0 : return accparser::RuleShutdown_clause_list;
7078 : }
7079 :
7080 0 : void accparser::Shutdown_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
7081 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7082 0 : if (parserListener != nullptr)
7083 0 : parserListener->enterShutdown_clause_list(this);
7084 0 : }
7085 :
7086 0 : void accparser::Shutdown_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
7087 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7088 0 : if (parserListener != nullptr)
7089 0 : parserListener->exitShutdown_clause_list(this);
7090 0 : }
7091 :
7092 :
7093 0 : antlrcpp::Any accparser::Shutdown_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
7094 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7095 0 : return parserVisitor->visitShutdown_clause_list(this);
7096 : else
7097 0 : return visitor->visitChildren(this);
7098 : }
7099 :
7100 0 : accparser::Shutdown_clause_listContext* accparser::shutdown_clause_list() {
7101 0 : Shutdown_clause_listContext *_localctx = _tracker.createInstance<Shutdown_clause_listContext>(_ctx, getState());
7102 0 : enterRule(_localctx, 136, accparser::RuleShutdown_clause_list);
7103 0 : size_t _la = 0;
7104 :
7105 0 : auto onExit = finally([=] {
7106 0 : exitRule();
7107 0 : });
7108 0 : try {
7109 0 : enterOuterAlt(_localctx, 1);
7110 0 : setState(776);
7111 0 : _errHandler->sync(this);
7112 0 : _la = _input->LA(1);
7113 0 : while ((((_la & ~ 0x3fULL) == 0) &&
7114 : ((1ULL << _la) & ((1ULL << accparser::DEVICE_NUM)
7115 : | (1ULL << accparser::DEVICE_TYPE)
7116 0 : | (1ULL << accparser::IF))) != 0)) {
7117 0 : setState(773);
7118 0 : shutdown_clauses();
7119 0 : setState(778);
7120 0 : _errHandler->sync(this);
7121 0 : _la = _input->LA(1);
7122 : }
7123 :
7124 : }
7125 0 : catch (RecognitionException &e) {
7126 0 : _errHandler->reportError(this, e);
7127 0 : _localctx->exception = std::current_exception();
7128 0 : _errHandler->recover(this, _localctx->exception);
7129 : }
7130 :
7131 0 : return _localctx;
7132 : }
7133 :
7134 : //----------------- Shutdown_clausesContext ------------------------------------------------------------------
7135 :
7136 0 : accparser::Shutdown_clausesContext::Shutdown_clausesContext(ParserRuleContext *parent, size_t invokingState)
7137 0 : : ParserRuleContext(parent, invokingState) {
7138 0 : }
7139 :
7140 0 : accparser::Device_type_clauseContext* accparser::Shutdown_clausesContext::device_type_clause() {
7141 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
7142 : }
7143 :
7144 0 : accparser::Device_num_clauseContext* accparser::Shutdown_clausesContext::device_num_clause() {
7145 0 : return getRuleContext<accparser::Device_num_clauseContext>(0);
7146 : }
7147 :
7148 0 : accparser::If_clauseContext* accparser::Shutdown_clausesContext::if_clause() {
7149 0 : return getRuleContext<accparser::If_clauseContext>(0);
7150 : }
7151 :
7152 :
7153 0 : size_t accparser::Shutdown_clausesContext::getRuleIndex() const {
7154 0 : return accparser::RuleShutdown_clauses;
7155 : }
7156 :
7157 0 : void accparser::Shutdown_clausesContext::enterRule(tree::ParseTreeListener *listener) {
7158 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7159 0 : if (parserListener != nullptr)
7160 0 : parserListener->enterShutdown_clauses(this);
7161 0 : }
7162 :
7163 0 : void accparser::Shutdown_clausesContext::exitRule(tree::ParseTreeListener *listener) {
7164 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7165 0 : if (parserListener != nullptr)
7166 0 : parserListener->exitShutdown_clauses(this);
7167 0 : }
7168 :
7169 :
7170 0 : antlrcpp::Any accparser::Shutdown_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
7171 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7172 0 : return parserVisitor->visitShutdown_clauses(this);
7173 : else
7174 0 : return visitor->visitChildren(this);
7175 : }
7176 :
7177 0 : accparser::Shutdown_clausesContext* accparser::shutdown_clauses() {
7178 0 : Shutdown_clausesContext *_localctx = _tracker.createInstance<Shutdown_clausesContext>(_ctx, getState());
7179 0 : enterRule(_localctx, 138, accparser::RuleShutdown_clauses);
7180 :
7181 0 : auto onExit = finally([=] {
7182 0 : exitRule();
7183 0 : });
7184 0 : try {
7185 0 : setState(782);
7186 0 : _errHandler->sync(this);
7187 0 : switch (_input->LA(1)) {
7188 0 : case accparser::DEVICE_TYPE: {
7189 0 : enterOuterAlt(_localctx, 1);
7190 0 : setState(779);
7191 0 : device_type_clause();
7192 : break;
7193 : }
7194 :
7195 0 : case accparser::DEVICE_NUM: {
7196 0 : enterOuterAlt(_localctx, 2);
7197 0 : setState(780);
7198 0 : device_num_clause();
7199 : break;
7200 : }
7201 :
7202 0 : case accparser::IF: {
7203 0 : enterOuterAlt(_localctx, 3);
7204 0 : setState(781);
7205 0 : if_clause();
7206 : break;
7207 : }
7208 :
7209 0 : default:
7210 0 : throw NoViableAltException(this);
7211 : }
7212 :
7213 : }
7214 0 : catch (RecognitionException &e) {
7215 0 : _errHandler->reportError(this, e);
7216 0 : _localctx->exception = std::current_exception();
7217 0 : _errHandler->recover(this, _localctx->exception);
7218 : }
7219 :
7220 0 : return _localctx;
7221 : }
7222 :
7223 : //----------------- Update_directiveContext ------------------------------------------------------------------
7224 :
7225 0 : accparser::Update_directiveContext::Update_directiveContext(ParserRuleContext *parent, size_t invokingState)
7226 0 : : ParserRuleContext(parent, invokingState) {
7227 0 : }
7228 :
7229 0 : tree::TerminalNode* accparser::Update_directiveContext::UPDATE() {
7230 0 : return getToken(accparser::UPDATE, 0);
7231 : }
7232 :
7233 0 : accparser::Update_clause_listContext* accparser::Update_directiveContext::update_clause_list() {
7234 0 : return getRuleContext<accparser::Update_clause_listContext>(0);
7235 : }
7236 :
7237 :
7238 0 : size_t accparser::Update_directiveContext::getRuleIndex() const {
7239 0 : return accparser::RuleUpdate_directive;
7240 : }
7241 :
7242 0 : void accparser::Update_directiveContext::enterRule(tree::ParseTreeListener *listener) {
7243 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7244 0 : if (parserListener != nullptr)
7245 0 : parserListener->enterUpdate_directive(this);
7246 0 : }
7247 :
7248 0 : void accparser::Update_directiveContext::exitRule(tree::ParseTreeListener *listener) {
7249 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7250 0 : if (parserListener != nullptr)
7251 0 : parserListener->exitUpdate_directive(this);
7252 0 : }
7253 :
7254 :
7255 0 : antlrcpp::Any accparser::Update_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
7256 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7257 0 : return parserVisitor->visitUpdate_directive(this);
7258 : else
7259 0 : return visitor->visitChildren(this);
7260 : }
7261 :
7262 0 : accparser::Update_directiveContext* accparser::update_directive() {
7263 0 : Update_directiveContext *_localctx = _tracker.createInstance<Update_directiveContext>(_ctx, getState());
7264 0 : enterRule(_localctx, 140, accparser::RuleUpdate_directive);
7265 :
7266 0 : auto onExit = finally([=] {
7267 0 : exitRule();
7268 0 : });
7269 0 : try {
7270 0 : enterOuterAlt(_localctx, 1);
7271 0 : setState(784);
7272 0 : match(accparser::UPDATE);
7273 0 : setState(785);
7274 0 : update_clause_list();
7275 :
7276 : }
7277 0 : catch (RecognitionException &e) {
7278 0 : _errHandler->reportError(this, e);
7279 0 : _localctx->exception = std::current_exception();
7280 0 : _errHandler->recover(this, _localctx->exception);
7281 : }
7282 :
7283 0 : return _localctx;
7284 : }
7285 :
7286 : //----------------- Update_clause_listContext ------------------------------------------------------------------
7287 :
7288 0 : accparser::Update_clause_listContext::Update_clause_listContext(ParserRuleContext *parent, size_t invokingState)
7289 0 : : ParserRuleContext(parent, invokingState) {
7290 0 : }
7291 :
7292 0 : std::vector<accparser::Update_clausesContext *> accparser::Update_clause_listContext::update_clauses() {
7293 0 : return getRuleContexts<accparser::Update_clausesContext>();
7294 : }
7295 :
7296 0 : accparser::Update_clausesContext* accparser::Update_clause_listContext::update_clauses(size_t i) {
7297 0 : return getRuleContext<accparser::Update_clausesContext>(i);
7298 : }
7299 :
7300 :
7301 0 : size_t accparser::Update_clause_listContext::getRuleIndex() const {
7302 0 : return accparser::RuleUpdate_clause_list;
7303 : }
7304 :
7305 0 : void accparser::Update_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
7306 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7307 0 : if (parserListener != nullptr)
7308 0 : parserListener->enterUpdate_clause_list(this);
7309 0 : }
7310 :
7311 0 : void accparser::Update_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
7312 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7313 0 : if (parserListener != nullptr)
7314 0 : parserListener->exitUpdate_clause_list(this);
7315 0 : }
7316 :
7317 :
7318 0 : antlrcpp::Any accparser::Update_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
7319 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7320 0 : return parserVisitor->visitUpdate_clause_list(this);
7321 : else
7322 0 : return visitor->visitChildren(this);
7323 : }
7324 :
7325 0 : accparser::Update_clause_listContext* accparser::update_clause_list() {
7326 0 : Update_clause_listContext *_localctx = _tracker.createInstance<Update_clause_listContext>(_ctx, getState());
7327 0 : enterRule(_localctx, 142, accparser::RuleUpdate_clause_list);
7328 0 : size_t _la = 0;
7329 :
7330 0 : auto onExit = finally([=] {
7331 0 : exitRule();
7332 0 : });
7333 0 : try {
7334 0 : enterOuterAlt(_localctx, 1);
7335 0 : setState(788);
7336 0 : _errHandler->sync(this);
7337 0 : _la = _input->LA(1);
7338 0 : do {
7339 0 : setState(787);
7340 0 : update_clauses();
7341 0 : setState(790);
7342 0 : _errHandler->sync(this);
7343 0 : _la = _input->LA(1);
7344 0 : } while (((((_la - 27) & ~ 0x3fULL) == 0) &&
7345 0 : ((1ULL << (_la - 27)) & ((1ULL << (accparser::ASYNC - 27))
7346 : | (1ULL << (accparser::DEVICE - 27))
7347 : | (1ULL << (accparser::DEVICE_TYPE - 27))
7348 : | (1ULL << (accparser::HOST - 27))
7349 : | (1ULL << (accparser::IF - 27))
7350 : | (1ULL << (accparser::IF_PRESENT - 27))
7351 : | (1ULL << (accparser::SELF - 27))
7352 0 : | (1ULL << (accparser::WAIT - 27)))) != 0));
7353 :
7354 : }
7355 0 : catch (RecognitionException &e) {
7356 0 : _errHandler->reportError(this, e);
7357 0 : _localctx->exception = std::current_exception();
7358 0 : _errHandler->recover(this, _localctx->exception);
7359 : }
7360 :
7361 0 : return _localctx;
7362 : }
7363 :
7364 : //----------------- Update_clausesContext ------------------------------------------------------------------
7365 :
7366 0 : accparser::Update_clausesContext::Update_clausesContext(ParserRuleContext *parent, size_t invokingState)
7367 0 : : ParserRuleContext(parent, invokingState) {
7368 0 : }
7369 :
7370 0 : accparser::Async_clauseContext* accparser::Update_clausesContext::async_clause() {
7371 0 : return getRuleContext<accparser::Async_clauseContext>(0);
7372 : }
7373 :
7374 0 : accparser::Device_clauseContext* accparser::Update_clausesContext::device_clause() {
7375 0 : return getRuleContext<accparser::Device_clauseContext>(0);
7376 : }
7377 :
7378 0 : accparser::Device_type_clauseContext* accparser::Update_clausesContext::device_type_clause() {
7379 0 : return getRuleContext<accparser::Device_type_clauseContext>(0);
7380 : }
7381 :
7382 0 : accparser::Host_clauseContext* accparser::Update_clausesContext::host_clause() {
7383 0 : return getRuleContext<accparser::Host_clauseContext>(0);
7384 : }
7385 :
7386 0 : accparser::If_clauseContext* accparser::Update_clausesContext::if_clause() {
7387 0 : return getRuleContext<accparser::If_clauseContext>(0);
7388 : }
7389 :
7390 0 : accparser::If_present_clauseContext* accparser::Update_clausesContext::if_present_clause() {
7391 0 : return getRuleContext<accparser::If_present_clauseContext>(0);
7392 : }
7393 :
7394 0 : accparser::Self_list_clauseContext* accparser::Update_clausesContext::self_list_clause() {
7395 0 : return getRuleContext<accparser::Self_list_clauseContext>(0);
7396 : }
7397 :
7398 0 : accparser::Wait_argument_clauseContext* accparser::Update_clausesContext::wait_argument_clause() {
7399 0 : return getRuleContext<accparser::Wait_argument_clauseContext>(0);
7400 : }
7401 :
7402 :
7403 0 : size_t accparser::Update_clausesContext::getRuleIndex() const {
7404 0 : return accparser::RuleUpdate_clauses;
7405 : }
7406 :
7407 0 : void accparser::Update_clausesContext::enterRule(tree::ParseTreeListener *listener) {
7408 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7409 0 : if (parserListener != nullptr)
7410 0 : parserListener->enterUpdate_clauses(this);
7411 0 : }
7412 :
7413 0 : void accparser::Update_clausesContext::exitRule(tree::ParseTreeListener *listener) {
7414 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7415 0 : if (parserListener != nullptr)
7416 0 : parserListener->exitUpdate_clauses(this);
7417 0 : }
7418 :
7419 :
7420 0 : antlrcpp::Any accparser::Update_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
7421 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7422 0 : return parserVisitor->visitUpdate_clauses(this);
7423 : else
7424 0 : return visitor->visitChildren(this);
7425 : }
7426 :
7427 0 : accparser::Update_clausesContext* accparser::update_clauses() {
7428 0 : Update_clausesContext *_localctx = _tracker.createInstance<Update_clausesContext>(_ctx, getState());
7429 0 : enterRule(_localctx, 144, accparser::RuleUpdate_clauses);
7430 :
7431 0 : auto onExit = finally([=] {
7432 0 : exitRule();
7433 0 : });
7434 0 : try {
7435 0 : setState(800);
7436 0 : _errHandler->sync(this);
7437 0 : switch (_input->LA(1)) {
7438 0 : case accparser::ASYNC: {
7439 0 : enterOuterAlt(_localctx, 1);
7440 0 : setState(792);
7441 0 : async_clause();
7442 : break;
7443 : }
7444 :
7445 0 : case accparser::DEVICE: {
7446 0 : enterOuterAlt(_localctx, 2);
7447 0 : setState(793);
7448 0 : device_clause();
7449 : break;
7450 : }
7451 :
7452 0 : case accparser::DEVICE_TYPE: {
7453 0 : enterOuterAlt(_localctx, 3);
7454 0 : setState(794);
7455 0 : device_type_clause();
7456 : break;
7457 : }
7458 :
7459 0 : case accparser::HOST: {
7460 0 : enterOuterAlt(_localctx, 4);
7461 0 : setState(795);
7462 0 : host_clause();
7463 : break;
7464 : }
7465 :
7466 0 : case accparser::IF: {
7467 0 : enterOuterAlt(_localctx, 5);
7468 0 : setState(796);
7469 0 : if_clause();
7470 : break;
7471 : }
7472 :
7473 0 : case accparser::IF_PRESENT: {
7474 0 : enterOuterAlt(_localctx, 6);
7475 0 : setState(797);
7476 0 : if_present_clause();
7477 : break;
7478 : }
7479 :
7480 0 : case accparser::SELF: {
7481 0 : enterOuterAlt(_localctx, 7);
7482 0 : setState(798);
7483 0 : self_list_clause();
7484 : break;
7485 : }
7486 :
7487 0 : case accparser::WAIT: {
7488 0 : enterOuterAlt(_localctx, 8);
7489 0 : setState(799);
7490 0 : wait_argument_clause();
7491 : break;
7492 : }
7493 :
7494 0 : default:
7495 0 : throw NoViableAltException(this);
7496 : }
7497 :
7498 : }
7499 0 : catch (RecognitionException &e) {
7500 0 : _errHandler->reportError(this, e);
7501 0 : _localctx->exception = std::current_exception();
7502 0 : _errHandler->recover(this, _localctx->exception);
7503 : }
7504 :
7505 0 : return _localctx;
7506 : }
7507 :
7508 : //----------------- Wait_directiveContext ------------------------------------------------------------------
7509 :
7510 0 : accparser::Wait_directiveContext::Wait_directiveContext(ParserRuleContext *parent, size_t invokingState)
7511 0 : : ParserRuleContext(parent, invokingState) {
7512 0 : }
7513 :
7514 0 : tree::TerminalNode* accparser::Wait_directiveContext::WAIT() {
7515 0 : return getToken(accparser::WAIT, 0);
7516 : }
7517 :
7518 0 : accparser::Wait_clause_listContext* accparser::Wait_directiveContext::wait_clause_list() {
7519 0 : return getRuleContext<accparser::Wait_clause_listContext>(0);
7520 : }
7521 :
7522 0 : tree::TerminalNode* accparser::Wait_directiveContext::LEFT_PAREN() {
7523 0 : return getToken(accparser::LEFT_PAREN, 0);
7524 : }
7525 :
7526 0 : accparser::Wait_argumentContext* accparser::Wait_directiveContext::wait_argument() {
7527 0 : return getRuleContext<accparser::Wait_argumentContext>(0);
7528 : }
7529 :
7530 0 : tree::TerminalNode* accparser::Wait_directiveContext::RIGHT_PAREN() {
7531 0 : return getToken(accparser::RIGHT_PAREN, 0);
7532 : }
7533 :
7534 :
7535 0 : size_t accparser::Wait_directiveContext::getRuleIndex() const {
7536 0 : return accparser::RuleWait_directive;
7537 : }
7538 :
7539 0 : void accparser::Wait_directiveContext::enterRule(tree::ParseTreeListener *listener) {
7540 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7541 0 : if (parserListener != nullptr)
7542 0 : parserListener->enterWait_directive(this);
7543 0 : }
7544 :
7545 0 : void accparser::Wait_directiveContext::exitRule(tree::ParseTreeListener *listener) {
7546 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7547 0 : if (parserListener != nullptr)
7548 0 : parserListener->exitWait_directive(this);
7549 0 : }
7550 :
7551 :
7552 0 : antlrcpp::Any accparser::Wait_directiveContext::accept(tree::ParseTreeVisitor *visitor) {
7553 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7554 0 : return parserVisitor->visitWait_directive(this);
7555 : else
7556 0 : return visitor->visitChildren(this);
7557 : }
7558 :
7559 0 : accparser::Wait_directiveContext* accparser::wait_directive() {
7560 0 : Wait_directiveContext *_localctx = _tracker.createInstance<Wait_directiveContext>(_ctx, getState());
7561 0 : enterRule(_localctx, 146, accparser::RuleWait_directive);
7562 :
7563 0 : auto onExit = finally([=] {
7564 0 : exitRule();
7565 0 : });
7566 0 : try {
7567 0 : setState(810);
7568 0 : _errHandler->sync(this);
7569 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 41, _ctx)) {
7570 0 : case 1: {
7571 0 : enterOuterAlt(_localctx, 1);
7572 0 : setState(802);
7573 0 : match(accparser::WAIT);
7574 0 : setState(803);
7575 0 : wait_clause_list();
7576 : break;
7577 : }
7578 :
7579 0 : case 2: {
7580 0 : enterOuterAlt(_localctx, 2);
7581 0 : setState(804);
7582 0 : match(accparser::WAIT);
7583 0 : setState(805);
7584 0 : match(accparser::LEFT_PAREN);
7585 0 : setState(806);
7586 0 : wait_argument();
7587 0 : setState(807);
7588 0 : match(accparser::RIGHT_PAREN);
7589 0 : setState(808);
7590 0 : wait_clause_list();
7591 : break;
7592 : }
7593 :
7594 : }
7595 :
7596 : }
7597 0 : catch (RecognitionException &e) {
7598 0 : _errHandler->reportError(this, e);
7599 0 : _localctx->exception = std::current_exception();
7600 0 : _errHandler->recover(this, _localctx->exception);
7601 : }
7602 :
7603 0 : return _localctx;
7604 : }
7605 :
7606 : //----------------- Wait_clause_listContext ------------------------------------------------------------------
7607 :
7608 0 : accparser::Wait_clause_listContext::Wait_clause_listContext(ParserRuleContext *parent, size_t invokingState)
7609 0 : : ParserRuleContext(parent, invokingState) {
7610 0 : }
7611 :
7612 0 : std::vector<accparser::Wait_clausesContext *> accparser::Wait_clause_listContext::wait_clauses() {
7613 0 : return getRuleContexts<accparser::Wait_clausesContext>();
7614 : }
7615 :
7616 0 : accparser::Wait_clausesContext* accparser::Wait_clause_listContext::wait_clauses(size_t i) {
7617 0 : return getRuleContext<accparser::Wait_clausesContext>(i);
7618 : }
7619 :
7620 :
7621 0 : size_t accparser::Wait_clause_listContext::getRuleIndex() const {
7622 0 : return accparser::RuleWait_clause_list;
7623 : }
7624 :
7625 0 : void accparser::Wait_clause_listContext::enterRule(tree::ParseTreeListener *listener) {
7626 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7627 0 : if (parserListener != nullptr)
7628 0 : parserListener->enterWait_clause_list(this);
7629 0 : }
7630 :
7631 0 : void accparser::Wait_clause_listContext::exitRule(tree::ParseTreeListener *listener) {
7632 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7633 0 : if (parserListener != nullptr)
7634 0 : parserListener->exitWait_clause_list(this);
7635 0 : }
7636 :
7637 :
7638 0 : antlrcpp::Any accparser::Wait_clause_listContext::accept(tree::ParseTreeVisitor *visitor) {
7639 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7640 0 : return parserVisitor->visitWait_clause_list(this);
7641 : else
7642 0 : return visitor->visitChildren(this);
7643 : }
7644 :
7645 0 : accparser::Wait_clause_listContext* accparser::wait_clause_list() {
7646 0 : Wait_clause_listContext *_localctx = _tracker.createInstance<Wait_clause_listContext>(_ctx, getState());
7647 0 : enterRule(_localctx, 148, accparser::RuleWait_clause_list);
7648 0 : size_t _la = 0;
7649 :
7650 0 : auto onExit = finally([=] {
7651 0 : exitRule();
7652 0 : });
7653 0 : try {
7654 0 : enterOuterAlt(_localctx, 1);
7655 0 : setState(815);
7656 0 : _errHandler->sync(this);
7657 0 : _la = _input->LA(1);
7658 0 : while (_la == accparser::ASYNC
7659 :
7660 0 : || _la == accparser::IF) {
7661 0 : setState(812);
7662 0 : wait_clauses();
7663 0 : setState(817);
7664 0 : _errHandler->sync(this);
7665 0 : _la = _input->LA(1);
7666 : }
7667 :
7668 : }
7669 0 : catch (RecognitionException &e) {
7670 0 : _errHandler->reportError(this, e);
7671 0 : _localctx->exception = std::current_exception();
7672 0 : _errHandler->recover(this, _localctx->exception);
7673 : }
7674 :
7675 0 : return _localctx;
7676 : }
7677 :
7678 : //----------------- Wait_clausesContext ------------------------------------------------------------------
7679 :
7680 0 : accparser::Wait_clausesContext::Wait_clausesContext(ParserRuleContext *parent, size_t invokingState)
7681 0 : : ParserRuleContext(parent, invokingState) {
7682 0 : }
7683 :
7684 0 : accparser::Async_clauseContext* accparser::Wait_clausesContext::async_clause() {
7685 0 : return getRuleContext<accparser::Async_clauseContext>(0);
7686 : }
7687 :
7688 0 : accparser::If_clauseContext* accparser::Wait_clausesContext::if_clause() {
7689 0 : return getRuleContext<accparser::If_clauseContext>(0);
7690 : }
7691 :
7692 :
7693 0 : size_t accparser::Wait_clausesContext::getRuleIndex() const {
7694 0 : return accparser::RuleWait_clauses;
7695 : }
7696 :
7697 0 : void accparser::Wait_clausesContext::enterRule(tree::ParseTreeListener *listener) {
7698 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7699 0 : if (parserListener != nullptr)
7700 0 : parserListener->enterWait_clauses(this);
7701 0 : }
7702 :
7703 0 : void accparser::Wait_clausesContext::exitRule(tree::ParseTreeListener *listener) {
7704 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7705 0 : if (parserListener != nullptr)
7706 0 : parserListener->exitWait_clauses(this);
7707 0 : }
7708 :
7709 :
7710 0 : antlrcpp::Any accparser::Wait_clausesContext::accept(tree::ParseTreeVisitor *visitor) {
7711 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7712 0 : return parserVisitor->visitWait_clauses(this);
7713 : else
7714 0 : return visitor->visitChildren(this);
7715 : }
7716 :
7717 0 : accparser::Wait_clausesContext* accparser::wait_clauses() {
7718 0 : Wait_clausesContext *_localctx = _tracker.createInstance<Wait_clausesContext>(_ctx, getState());
7719 0 : enterRule(_localctx, 150, accparser::RuleWait_clauses);
7720 :
7721 0 : auto onExit = finally([=] {
7722 0 : exitRule();
7723 0 : });
7724 0 : try {
7725 0 : setState(820);
7726 0 : _errHandler->sync(this);
7727 0 : switch (_input->LA(1)) {
7728 0 : case accparser::ASYNC: {
7729 0 : enterOuterAlt(_localctx, 1);
7730 0 : setState(818);
7731 0 : async_clause();
7732 : break;
7733 : }
7734 :
7735 0 : case accparser::IF: {
7736 0 : enterOuterAlt(_localctx, 2);
7737 0 : setState(819);
7738 0 : if_clause();
7739 : break;
7740 : }
7741 :
7742 0 : default:
7743 0 : throw NoViableAltException(this);
7744 : }
7745 :
7746 : }
7747 0 : catch (RecognitionException &e) {
7748 0 : _errHandler->reportError(this, e);
7749 0 : _localctx->exception = std::current_exception();
7750 0 : _errHandler->recover(this, _localctx->exception);
7751 : }
7752 :
7753 0 : return _localctx;
7754 : }
7755 :
7756 : //----------------- Async_clauseContext ------------------------------------------------------------------
7757 :
7758 0 : accparser::Async_clauseContext::Async_clauseContext(ParserRuleContext *parent, size_t invokingState)
7759 0 : : ParserRuleContext(parent, invokingState) {
7760 0 : }
7761 :
7762 0 : tree::TerminalNode* accparser::Async_clauseContext::ASYNC() {
7763 0 : return getToken(accparser::ASYNC, 0);
7764 : }
7765 :
7766 0 : tree::TerminalNode* accparser::Async_clauseContext::LEFT_PAREN() {
7767 0 : return getToken(accparser::LEFT_PAREN, 0);
7768 : }
7769 :
7770 0 : accparser::Int_exprContext* accparser::Async_clauseContext::int_expr() {
7771 0 : return getRuleContext<accparser::Int_exprContext>(0);
7772 : }
7773 :
7774 0 : tree::TerminalNode* accparser::Async_clauseContext::RIGHT_PAREN() {
7775 0 : return getToken(accparser::RIGHT_PAREN, 0);
7776 : }
7777 :
7778 :
7779 0 : size_t accparser::Async_clauseContext::getRuleIndex() const {
7780 0 : return accparser::RuleAsync_clause;
7781 : }
7782 :
7783 0 : void accparser::Async_clauseContext::enterRule(tree::ParseTreeListener *listener) {
7784 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7785 0 : if (parserListener != nullptr)
7786 0 : parserListener->enterAsync_clause(this);
7787 0 : }
7788 :
7789 0 : void accparser::Async_clauseContext::exitRule(tree::ParseTreeListener *listener) {
7790 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7791 0 : if (parserListener != nullptr)
7792 0 : parserListener->exitAsync_clause(this);
7793 0 : }
7794 :
7795 :
7796 0 : antlrcpp::Any accparser::Async_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
7797 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7798 0 : return parserVisitor->visitAsync_clause(this);
7799 : else
7800 0 : return visitor->visitChildren(this);
7801 : }
7802 :
7803 0 : accparser::Async_clauseContext* accparser::async_clause() {
7804 0 : Async_clauseContext *_localctx = _tracker.createInstance<Async_clauseContext>(_ctx, getState());
7805 0 : enterRule(_localctx, 152, accparser::RuleAsync_clause);
7806 :
7807 0 : auto onExit = finally([=] {
7808 0 : exitRule();
7809 0 : });
7810 0 : try {
7811 0 : setState(828);
7812 0 : _errHandler->sync(this);
7813 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 44, _ctx)) {
7814 0 : case 1: {
7815 0 : enterOuterAlt(_localctx, 1);
7816 0 : setState(822);
7817 0 : match(accparser::ASYNC);
7818 : break;
7819 : }
7820 :
7821 0 : case 2: {
7822 0 : enterOuterAlt(_localctx, 2);
7823 0 : setState(823);
7824 0 : match(accparser::ASYNC);
7825 0 : setState(824);
7826 0 : match(accparser::LEFT_PAREN);
7827 0 : setState(825);
7828 0 : int_expr();
7829 0 : setState(826);
7830 0 : match(accparser::RIGHT_PAREN);
7831 : break;
7832 : }
7833 :
7834 : }
7835 :
7836 : }
7837 0 : catch (RecognitionException &e) {
7838 0 : _errHandler->reportError(this, e);
7839 0 : _localctx->exception = std::current_exception();
7840 0 : _errHandler->recover(this, _localctx->exception);
7841 : }
7842 :
7843 0 : return _localctx;
7844 : }
7845 :
7846 : //----------------- Attach_clauseContext ------------------------------------------------------------------
7847 :
7848 0 : accparser::Attach_clauseContext::Attach_clauseContext(ParserRuleContext *parent, size_t invokingState)
7849 0 : : ParserRuleContext(parent, invokingState) {
7850 0 : }
7851 :
7852 0 : tree::TerminalNode* accparser::Attach_clauseContext::ATTACH() {
7853 0 : return getToken(accparser::ATTACH, 0);
7854 : }
7855 :
7856 0 : tree::TerminalNode* accparser::Attach_clauseContext::LEFT_PAREN() {
7857 0 : return getToken(accparser::LEFT_PAREN, 0);
7858 : }
7859 :
7860 0 : accparser::Var_listContext* accparser::Attach_clauseContext::var_list() {
7861 0 : return getRuleContext<accparser::Var_listContext>(0);
7862 : }
7863 :
7864 0 : tree::TerminalNode* accparser::Attach_clauseContext::RIGHT_PAREN() {
7865 0 : return getToken(accparser::RIGHT_PAREN, 0);
7866 : }
7867 :
7868 :
7869 0 : size_t accparser::Attach_clauseContext::getRuleIndex() const {
7870 0 : return accparser::RuleAttach_clause;
7871 : }
7872 :
7873 0 : void accparser::Attach_clauseContext::enterRule(tree::ParseTreeListener *listener) {
7874 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7875 0 : if (parserListener != nullptr)
7876 0 : parserListener->enterAttach_clause(this);
7877 0 : }
7878 :
7879 0 : void accparser::Attach_clauseContext::exitRule(tree::ParseTreeListener *listener) {
7880 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7881 0 : if (parserListener != nullptr)
7882 0 : parserListener->exitAttach_clause(this);
7883 0 : }
7884 :
7885 :
7886 0 : antlrcpp::Any accparser::Attach_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
7887 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7888 0 : return parserVisitor->visitAttach_clause(this);
7889 : else
7890 0 : return visitor->visitChildren(this);
7891 : }
7892 :
7893 0 : accparser::Attach_clauseContext* accparser::attach_clause() {
7894 0 : Attach_clauseContext *_localctx = _tracker.createInstance<Attach_clauseContext>(_ctx, getState());
7895 0 : enterRule(_localctx, 154, accparser::RuleAttach_clause);
7896 :
7897 0 : auto onExit = finally([=] {
7898 0 : exitRule();
7899 0 : });
7900 0 : try {
7901 0 : enterOuterAlt(_localctx, 1);
7902 0 : setState(830);
7903 0 : match(accparser::ATTACH);
7904 0 : setState(831);
7905 0 : match(accparser::LEFT_PAREN);
7906 0 : setState(832);
7907 0 : var_list();
7908 0 : setState(833);
7909 0 : match(accparser::RIGHT_PAREN);
7910 :
7911 : }
7912 0 : catch (RecognitionException &e) {
7913 0 : _errHandler->reportError(this, e);
7914 0 : _localctx->exception = std::current_exception();
7915 0 : _errHandler->recover(this, _localctx->exception);
7916 : }
7917 :
7918 0 : return _localctx;
7919 : }
7920 :
7921 : //----------------- Auto_clauseContext ------------------------------------------------------------------
7922 :
7923 0 : accparser::Auto_clauseContext::Auto_clauseContext(ParserRuleContext *parent, size_t invokingState)
7924 0 : : ParserRuleContext(parent, invokingState) {
7925 0 : }
7926 :
7927 0 : tree::TerminalNode* accparser::Auto_clauseContext::AUTO() {
7928 0 : return getToken(accparser::AUTO, 0);
7929 : }
7930 :
7931 :
7932 0 : size_t accparser::Auto_clauseContext::getRuleIndex() const {
7933 0 : return accparser::RuleAuto_clause;
7934 : }
7935 :
7936 0 : void accparser::Auto_clauseContext::enterRule(tree::ParseTreeListener *listener) {
7937 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7938 0 : if (parserListener != nullptr)
7939 0 : parserListener->enterAuto_clause(this);
7940 0 : }
7941 :
7942 0 : void accparser::Auto_clauseContext::exitRule(tree::ParseTreeListener *listener) {
7943 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
7944 0 : if (parserListener != nullptr)
7945 0 : parserListener->exitAuto_clause(this);
7946 0 : }
7947 :
7948 :
7949 0 : antlrcpp::Any accparser::Auto_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
7950 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
7951 0 : return parserVisitor->visitAuto_clause(this);
7952 : else
7953 0 : return visitor->visitChildren(this);
7954 : }
7955 :
7956 0 : accparser::Auto_clauseContext* accparser::auto_clause() {
7957 0 : Auto_clauseContext *_localctx = _tracker.createInstance<Auto_clauseContext>(_ctx, getState());
7958 0 : enterRule(_localctx, 156, accparser::RuleAuto_clause);
7959 :
7960 0 : auto onExit = finally([=] {
7961 0 : exitRule();
7962 0 : });
7963 0 : try {
7964 0 : enterOuterAlt(_localctx, 1);
7965 0 : setState(835);
7966 0 : match(accparser::AUTO);
7967 :
7968 : }
7969 0 : catch (RecognitionException &e) {
7970 0 : _errHandler->reportError(this, e);
7971 0 : _localctx->exception = std::current_exception();
7972 0 : _errHandler->recover(this, _localctx->exception);
7973 : }
7974 :
7975 0 : return _localctx;
7976 : }
7977 :
7978 : //----------------- Bind_clauseContext ------------------------------------------------------------------
7979 :
7980 0 : accparser::Bind_clauseContext::Bind_clauseContext(ParserRuleContext *parent, size_t invokingState)
7981 0 : : ParserRuleContext(parent, invokingState) {
7982 0 : }
7983 :
7984 0 : tree::TerminalNode* accparser::Bind_clauseContext::BIND() {
7985 0 : return getToken(accparser::BIND, 0);
7986 : }
7987 :
7988 0 : tree::TerminalNode* accparser::Bind_clauseContext::LEFT_PAREN() {
7989 0 : return getToken(accparser::LEFT_PAREN, 0);
7990 : }
7991 :
7992 0 : accparser::Name_or_stringContext* accparser::Bind_clauseContext::name_or_string() {
7993 0 : return getRuleContext<accparser::Name_or_stringContext>(0);
7994 : }
7995 :
7996 0 : tree::TerminalNode* accparser::Bind_clauseContext::RIGHT_PAREN() {
7997 0 : return getToken(accparser::RIGHT_PAREN, 0);
7998 : }
7999 :
8000 :
8001 0 : size_t accparser::Bind_clauseContext::getRuleIndex() const {
8002 0 : return accparser::RuleBind_clause;
8003 : }
8004 :
8005 0 : void accparser::Bind_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8006 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8007 0 : if (parserListener != nullptr)
8008 0 : parserListener->enterBind_clause(this);
8009 0 : }
8010 :
8011 0 : void accparser::Bind_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8012 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8013 0 : if (parserListener != nullptr)
8014 0 : parserListener->exitBind_clause(this);
8015 0 : }
8016 :
8017 :
8018 0 : antlrcpp::Any accparser::Bind_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
8019 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8020 0 : return parserVisitor->visitBind_clause(this);
8021 : else
8022 0 : return visitor->visitChildren(this);
8023 : }
8024 :
8025 0 : accparser::Bind_clauseContext* accparser::bind_clause() {
8026 0 : Bind_clauseContext *_localctx = _tracker.createInstance<Bind_clauseContext>(_ctx, getState());
8027 0 : enterRule(_localctx, 158, accparser::RuleBind_clause);
8028 :
8029 0 : auto onExit = finally([=] {
8030 0 : exitRule();
8031 0 : });
8032 0 : try {
8033 0 : enterOuterAlt(_localctx, 1);
8034 0 : setState(837);
8035 0 : match(accparser::BIND);
8036 0 : setState(838);
8037 0 : match(accparser::LEFT_PAREN);
8038 0 : setState(839);
8039 0 : name_or_string();
8040 0 : setState(840);
8041 0 : match(accparser::RIGHT_PAREN);
8042 :
8043 : }
8044 0 : catch (RecognitionException &e) {
8045 0 : _errHandler->reportError(this, e);
8046 0 : _localctx->exception = std::current_exception();
8047 0 : _errHandler->recover(this, _localctx->exception);
8048 : }
8049 :
8050 0 : return _localctx;
8051 : }
8052 :
8053 : //----------------- Name_or_stringContext ------------------------------------------------------------------
8054 :
8055 0 : accparser::Name_or_stringContext::Name_or_stringContext(ParserRuleContext *parent, size_t invokingState)
8056 0 : : ParserRuleContext(parent, invokingState) {
8057 0 : }
8058 :
8059 0 : tree::TerminalNode* accparser::Name_or_stringContext::EXPR() {
8060 0 : return getToken(accparser::EXPR, 0);
8061 : }
8062 :
8063 :
8064 0 : size_t accparser::Name_or_stringContext::getRuleIndex() const {
8065 0 : return accparser::RuleName_or_string;
8066 : }
8067 :
8068 0 : void accparser::Name_or_stringContext::enterRule(tree::ParseTreeListener *listener) {
8069 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8070 0 : if (parserListener != nullptr)
8071 0 : parserListener->enterName_or_string(this);
8072 0 : }
8073 :
8074 0 : void accparser::Name_or_stringContext::exitRule(tree::ParseTreeListener *listener) {
8075 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8076 0 : if (parserListener != nullptr)
8077 0 : parserListener->exitName_or_string(this);
8078 0 : }
8079 :
8080 :
8081 0 : antlrcpp::Any accparser::Name_or_stringContext::accept(tree::ParseTreeVisitor *visitor) {
8082 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8083 0 : return parserVisitor->visitName_or_string(this);
8084 : else
8085 0 : return visitor->visitChildren(this);
8086 : }
8087 :
8088 0 : accparser::Name_or_stringContext* accparser::name_or_string() {
8089 0 : Name_or_stringContext *_localctx = _tracker.createInstance<Name_or_stringContext>(_ctx, getState());
8090 0 : enterRule(_localctx, 160, accparser::RuleName_or_string);
8091 :
8092 0 : auto onExit = finally([=] {
8093 0 : exitRule();
8094 0 : });
8095 0 : try {
8096 0 : enterOuterAlt(_localctx, 1);
8097 0 : setState(842);
8098 0 : match(accparser::EXPR);
8099 :
8100 : }
8101 0 : catch (RecognitionException &e) {
8102 0 : _errHandler->reportError(this, e);
8103 0 : _localctx->exception = std::current_exception();
8104 0 : _errHandler->recover(this, _localctx->exception);
8105 : }
8106 :
8107 0 : return _localctx;
8108 : }
8109 :
8110 : //----------------- Capture_clauseContext ------------------------------------------------------------------
8111 :
8112 0 : accparser::Capture_clauseContext::Capture_clauseContext(ParserRuleContext *parent, size_t invokingState)
8113 0 : : ParserRuleContext(parent, invokingState) {
8114 0 : }
8115 :
8116 0 : tree::TerminalNode* accparser::Capture_clauseContext::CAPTURE() {
8117 0 : return getToken(accparser::CAPTURE, 0);
8118 : }
8119 :
8120 :
8121 0 : size_t accparser::Capture_clauseContext::getRuleIndex() const {
8122 0 : return accparser::RuleCapture_clause;
8123 : }
8124 :
8125 0 : void accparser::Capture_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8126 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8127 0 : if (parserListener != nullptr)
8128 0 : parserListener->enterCapture_clause(this);
8129 0 : }
8130 :
8131 0 : void accparser::Capture_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8132 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8133 0 : if (parserListener != nullptr)
8134 0 : parserListener->exitCapture_clause(this);
8135 0 : }
8136 :
8137 :
8138 0 : antlrcpp::Any accparser::Capture_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
8139 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8140 0 : return parserVisitor->visitCapture_clause(this);
8141 : else
8142 0 : return visitor->visitChildren(this);
8143 : }
8144 :
8145 0 : accparser::Capture_clauseContext* accparser::capture_clause() {
8146 0 : Capture_clauseContext *_localctx = _tracker.createInstance<Capture_clauseContext>(_ctx, getState());
8147 0 : enterRule(_localctx, 162, accparser::RuleCapture_clause);
8148 :
8149 0 : auto onExit = finally([=] {
8150 0 : exitRule();
8151 0 : });
8152 0 : try {
8153 0 : enterOuterAlt(_localctx, 1);
8154 0 : setState(844);
8155 0 : match(accparser::CAPTURE);
8156 :
8157 : }
8158 0 : catch (RecognitionException &e) {
8159 0 : _errHandler->reportError(this, e);
8160 0 : _localctx->exception = std::current_exception();
8161 0 : _errHandler->recover(this, _localctx->exception);
8162 : }
8163 :
8164 0 : return _localctx;
8165 : }
8166 :
8167 : //----------------- Collapse_clauseContext ------------------------------------------------------------------
8168 :
8169 0 : accparser::Collapse_clauseContext::Collapse_clauseContext(ParserRuleContext *parent, size_t invokingState)
8170 0 : : ParserRuleContext(parent, invokingState) {
8171 0 : }
8172 :
8173 0 : tree::TerminalNode* accparser::Collapse_clauseContext::COLLAPSE() {
8174 0 : return getToken(accparser::COLLAPSE, 0);
8175 : }
8176 :
8177 0 : tree::TerminalNode* accparser::Collapse_clauseContext::LEFT_PAREN() {
8178 0 : return getToken(accparser::LEFT_PAREN, 0);
8179 : }
8180 :
8181 0 : accparser::Const_intContext* accparser::Collapse_clauseContext::const_int() {
8182 0 : return getRuleContext<accparser::Const_intContext>(0);
8183 : }
8184 :
8185 0 : tree::TerminalNode* accparser::Collapse_clauseContext::RIGHT_PAREN() {
8186 0 : return getToken(accparser::RIGHT_PAREN, 0);
8187 : }
8188 :
8189 :
8190 0 : size_t accparser::Collapse_clauseContext::getRuleIndex() const {
8191 0 : return accparser::RuleCollapse_clause;
8192 : }
8193 :
8194 0 : void accparser::Collapse_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8195 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8196 0 : if (parserListener != nullptr)
8197 0 : parserListener->enterCollapse_clause(this);
8198 0 : }
8199 :
8200 0 : void accparser::Collapse_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8201 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8202 0 : if (parserListener != nullptr)
8203 0 : parserListener->exitCollapse_clause(this);
8204 0 : }
8205 :
8206 :
8207 0 : antlrcpp::Any accparser::Collapse_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
8208 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8209 0 : return parserVisitor->visitCollapse_clause(this);
8210 : else
8211 0 : return visitor->visitChildren(this);
8212 : }
8213 :
8214 0 : accparser::Collapse_clauseContext* accparser::collapse_clause() {
8215 0 : Collapse_clauseContext *_localctx = _tracker.createInstance<Collapse_clauseContext>(_ctx, getState());
8216 0 : enterRule(_localctx, 164, accparser::RuleCollapse_clause);
8217 :
8218 0 : auto onExit = finally([=] {
8219 0 : exitRule();
8220 0 : });
8221 0 : try {
8222 0 : enterOuterAlt(_localctx, 1);
8223 0 : setState(846);
8224 0 : match(accparser::COLLAPSE);
8225 0 : setState(847);
8226 0 : match(accparser::LEFT_PAREN);
8227 0 : setState(848);
8228 0 : const_int();
8229 0 : setState(849);
8230 0 : match(accparser::RIGHT_PAREN);
8231 :
8232 : }
8233 0 : catch (RecognitionException &e) {
8234 0 : _errHandler->reportError(this, e);
8235 0 : _localctx->exception = std::current_exception();
8236 0 : _errHandler->recover(this, _localctx->exception);
8237 : }
8238 :
8239 0 : return _localctx;
8240 : }
8241 :
8242 : //----------------- Copy_clauseContext ------------------------------------------------------------------
8243 :
8244 0 : accparser::Copy_clauseContext::Copy_clauseContext(ParserRuleContext *parent, size_t invokingState)
8245 0 : : ParserRuleContext(parent, invokingState) {
8246 0 : }
8247 :
8248 0 : tree::TerminalNode* accparser::Copy_clauseContext::COPY() {
8249 0 : return getToken(accparser::COPY, 0);
8250 : }
8251 :
8252 0 : tree::TerminalNode* accparser::Copy_clauseContext::LEFT_PAREN() {
8253 0 : return getToken(accparser::LEFT_PAREN, 0);
8254 : }
8255 :
8256 0 : accparser::Var_listContext* accparser::Copy_clauseContext::var_list() {
8257 0 : return getRuleContext<accparser::Var_listContext>(0);
8258 : }
8259 :
8260 0 : tree::TerminalNode* accparser::Copy_clauseContext::RIGHT_PAREN() {
8261 0 : return getToken(accparser::RIGHT_PAREN, 0);
8262 : }
8263 :
8264 :
8265 0 : size_t accparser::Copy_clauseContext::getRuleIndex() const {
8266 0 : return accparser::RuleCopy_clause;
8267 : }
8268 :
8269 0 : void accparser::Copy_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8270 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8271 0 : if (parserListener != nullptr)
8272 0 : parserListener->enterCopy_clause(this);
8273 0 : }
8274 :
8275 0 : void accparser::Copy_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8276 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8277 0 : if (parserListener != nullptr)
8278 0 : parserListener->exitCopy_clause(this);
8279 0 : }
8280 :
8281 :
8282 0 : antlrcpp::Any accparser::Copy_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
8283 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8284 0 : return parserVisitor->visitCopy_clause(this);
8285 : else
8286 0 : return visitor->visitChildren(this);
8287 : }
8288 :
8289 0 : accparser::Copy_clauseContext* accparser::copy_clause() {
8290 0 : Copy_clauseContext *_localctx = _tracker.createInstance<Copy_clauseContext>(_ctx, getState());
8291 0 : enterRule(_localctx, 166, accparser::RuleCopy_clause);
8292 :
8293 0 : auto onExit = finally([=] {
8294 0 : exitRule();
8295 0 : });
8296 0 : try {
8297 0 : enterOuterAlt(_localctx, 1);
8298 0 : setState(851);
8299 0 : match(accparser::COPY);
8300 0 : setState(852);
8301 0 : match(accparser::LEFT_PAREN);
8302 0 : setState(853);
8303 0 : var_list();
8304 0 : setState(854);
8305 0 : match(accparser::RIGHT_PAREN);
8306 :
8307 : }
8308 0 : catch (RecognitionException &e) {
8309 0 : _errHandler->reportError(this, e);
8310 0 : _localctx->exception = std::current_exception();
8311 0 : _errHandler->recover(this, _localctx->exception);
8312 : }
8313 :
8314 0 : return _localctx;
8315 : }
8316 :
8317 : //----------------- Copyin_clauseContext ------------------------------------------------------------------
8318 :
8319 0 : accparser::Copyin_clauseContext::Copyin_clauseContext(ParserRuleContext *parent, size_t invokingState)
8320 0 : : ParserRuleContext(parent, invokingState) {
8321 0 : }
8322 :
8323 0 : tree::TerminalNode* accparser::Copyin_clauseContext::COPYIN() {
8324 0 : return getToken(accparser::COPYIN, 0);
8325 : }
8326 :
8327 0 : tree::TerminalNode* accparser::Copyin_clauseContext::LEFT_PAREN() {
8328 0 : return getToken(accparser::LEFT_PAREN, 0);
8329 : }
8330 :
8331 0 : accparser::Var_listContext* accparser::Copyin_clauseContext::var_list() {
8332 0 : return getRuleContext<accparser::Var_listContext>(0);
8333 : }
8334 :
8335 0 : tree::TerminalNode* accparser::Copyin_clauseContext::RIGHT_PAREN() {
8336 0 : return getToken(accparser::RIGHT_PAREN, 0);
8337 : }
8338 :
8339 0 : accparser::Copyin_clause_modifierContext* accparser::Copyin_clauseContext::copyin_clause_modifier() {
8340 0 : return getRuleContext<accparser::Copyin_clause_modifierContext>(0);
8341 : }
8342 :
8343 0 : tree::TerminalNode* accparser::Copyin_clauseContext::COLON() {
8344 0 : return getToken(accparser::COLON, 0);
8345 : }
8346 :
8347 :
8348 0 : size_t accparser::Copyin_clauseContext::getRuleIndex() const {
8349 0 : return accparser::RuleCopyin_clause;
8350 : }
8351 :
8352 0 : void accparser::Copyin_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8353 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8354 0 : if (parserListener != nullptr)
8355 0 : parserListener->enterCopyin_clause(this);
8356 0 : }
8357 :
8358 0 : void accparser::Copyin_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8359 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8360 0 : if (parserListener != nullptr)
8361 0 : parserListener->exitCopyin_clause(this);
8362 0 : }
8363 :
8364 :
8365 0 : antlrcpp::Any accparser::Copyin_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
8366 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8367 0 : return parserVisitor->visitCopyin_clause(this);
8368 : else
8369 0 : return visitor->visitChildren(this);
8370 : }
8371 :
8372 0 : accparser::Copyin_clauseContext* accparser::copyin_clause() {
8373 0 : Copyin_clauseContext *_localctx = _tracker.createInstance<Copyin_clauseContext>(_ctx, getState());
8374 0 : enterRule(_localctx, 168, accparser::RuleCopyin_clause);
8375 :
8376 0 : auto onExit = finally([=] {
8377 0 : exitRule();
8378 0 : });
8379 0 : try {
8380 0 : setState(868);
8381 0 : _errHandler->sync(this);
8382 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 45, _ctx)) {
8383 0 : case 1: {
8384 0 : enterOuterAlt(_localctx, 1);
8385 0 : setState(856);
8386 0 : match(accparser::COPYIN);
8387 0 : setState(857);
8388 0 : match(accparser::LEFT_PAREN);
8389 0 : setState(858);
8390 0 : var_list();
8391 0 : setState(859);
8392 0 : match(accparser::RIGHT_PAREN);
8393 : break;
8394 : }
8395 :
8396 0 : case 2: {
8397 0 : enterOuterAlt(_localctx, 2);
8398 0 : setState(861);
8399 0 : match(accparser::COPYIN);
8400 0 : setState(862);
8401 0 : match(accparser::LEFT_PAREN);
8402 0 : setState(863);
8403 0 : copyin_clause_modifier();
8404 0 : setState(864);
8405 0 : match(accparser::COLON);
8406 0 : setState(865);
8407 0 : var_list();
8408 0 : setState(866);
8409 0 : match(accparser::RIGHT_PAREN);
8410 : break;
8411 : }
8412 :
8413 : }
8414 :
8415 : }
8416 0 : catch (RecognitionException &e) {
8417 0 : _errHandler->reportError(this, e);
8418 0 : _localctx->exception = std::current_exception();
8419 0 : _errHandler->recover(this, _localctx->exception);
8420 : }
8421 :
8422 0 : return _localctx;
8423 : }
8424 :
8425 : //----------------- Copyin_clause_modifierContext ------------------------------------------------------------------
8426 :
8427 0 : accparser::Copyin_clause_modifierContext::Copyin_clause_modifierContext(ParserRuleContext *parent, size_t invokingState)
8428 0 : : ParserRuleContext(parent, invokingState) {
8429 0 : }
8430 :
8431 0 : tree::TerminalNode* accparser::Copyin_clause_modifierContext::READONLY() {
8432 0 : return getToken(accparser::READONLY, 0);
8433 : }
8434 :
8435 :
8436 0 : size_t accparser::Copyin_clause_modifierContext::getRuleIndex() const {
8437 0 : return accparser::RuleCopyin_clause_modifier;
8438 : }
8439 :
8440 0 : void accparser::Copyin_clause_modifierContext::enterRule(tree::ParseTreeListener *listener) {
8441 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8442 0 : if (parserListener != nullptr)
8443 0 : parserListener->enterCopyin_clause_modifier(this);
8444 0 : }
8445 :
8446 0 : void accparser::Copyin_clause_modifierContext::exitRule(tree::ParseTreeListener *listener) {
8447 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8448 0 : if (parserListener != nullptr)
8449 0 : parserListener->exitCopyin_clause_modifier(this);
8450 0 : }
8451 :
8452 :
8453 0 : antlrcpp::Any accparser::Copyin_clause_modifierContext::accept(tree::ParseTreeVisitor *visitor) {
8454 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8455 0 : return parserVisitor->visitCopyin_clause_modifier(this);
8456 : else
8457 0 : return visitor->visitChildren(this);
8458 : }
8459 :
8460 0 : accparser::Copyin_clause_modifierContext* accparser::copyin_clause_modifier() {
8461 0 : Copyin_clause_modifierContext *_localctx = _tracker.createInstance<Copyin_clause_modifierContext>(_ctx, getState());
8462 0 : enterRule(_localctx, 170, accparser::RuleCopyin_clause_modifier);
8463 :
8464 0 : auto onExit = finally([=] {
8465 0 : exitRule();
8466 0 : });
8467 0 : try {
8468 0 : enterOuterAlt(_localctx, 1);
8469 0 : setState(870);
8470 0 : match(accparser::READONLY);
8471 :
8472 : }
8473 0 : catch (RecognitionException &e) {
8474 0 : _errHandler->reportError(this, e);
8475 0 : _localctx->exception = std::current_exception();
8476 0 : _errHandler->recover(this, _localctx->exception);
8477 : }
8478 :
8479 0 : return _localctx;
8480 : }
8481 :
8482 : //----------------- Copyin_no_modifier_clauseContext ------------------------------------------------------------------
8483 :
8484 0 : accparser::Copyin_no_modifier_clauseContext::Copyin_no_modifier_clauseContext(ParserRuleContext *parent, size_t invokingState)
8485 0 : : ParserRuleContext(parent, invokingState) {
8486 0 : }
8487 :
8488 0 : tree::TerminalNode* accparser::Copyin_no_modifier_clauseContext::COPYIN() {
8489 0 : return getToken(accparser::COPYIN, 0);
8490 : }
8491 :
8492 0 : tree::TerminalNode* accparser::Copyin_no_modifier_clauseContext::LEFT_PAREN() {
8493 0 : return getToken(accparser::LEFT_PAREN, 0);
8494 : }
8495 :
8496 0 : accparser::Var_listContext* accparser::Copyin_no_modifier_clauseContext::var_list() {
8497 0 : return getRuleContext<accparser::Var_listContext>(0);
8498 : }
8499 :
8500 0 : tree::TerminalNode* accparser::Copyin_no_modifier_clauseContext::RIGHT_PAREN() {
8501 0 : return getToken(accparser::RIGHT_PAREN, 0);
8502 : }
8503 :
8504 :
8505 0 : size_t accparser::Copyin_no_modifier_clauseContext::getRuleIndex() const {
8506 0 : return accparser::RuleCopyin_no_modifier_clause;
8507 : }
8508 :
8509 0 : void accparser::Copyin_no_modifier_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8510 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8511 0 : if (parserListener != nullptr)
8512 0 : parserListener->enterCopyin_no_modifier_clause(this);
8513 0 : }
8514 :
8515 0 : void accparser::Copyin_no_modifier_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8516 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8517 0 : if (parserListener != nullptr)
8518 0 : parserListener->exitCopyin_no_modifier_clause(this);
8519 0 : }
8520 :
8521 :
8522 0 : antlrcpp::Any accparser::Copyin_no_modifier_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
8523 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8524 0 : return parserVisitor->visitCopyin_no_modifier_clause(this);
8525 : else
8526 0 : return visitor->visitChildren(this);
8527 : }
8528 :
8529 0 : accparser::Copyin_no_modifier_clauseContext* accparser::copyin_no_modifier_clause() {
8530 0 : Copyin_no_modifier_clauseContext *_localctx = _tracker.createInstance<Copyin_no_modifier_clauseContext>(_ctx, getState());
8531 0 : enterRule(_localctx, 172, accparser::RuleCopyin_no_modifier_clause);
8532 :
8533 0 : auto onExit = finally([=] {
8534 0 : exitRule();
8535 0 : });
8536 0 : try {
8537 0 : enterOuterAlt(_localctx, 1);
8538 0 : setState(872);
8539 0 : match(accparser::COPYIN);
8540 0 : setState(873);
8541 0 : match(accparser::LEFT_PAREN);
8542 0 : setState(874);
8543 0 : var_list();
8544 0 : setState(875);
8545 0 : match(accparser::RIGHT_PAREN);
8546 :
8547 : }
8548 0 : catch (RecognitionException &e) {
8549 0 : _errHandler->reportError(this, e);
8550 0 : _localctx->exception = std::current_exception();
8551 0 : _errHandler->recover(this, _localctx->exception);
8552 : }
8553 :
8554 0 : return _localctx;
8555 : }
8556 :
8557 : //----------------- Copyout_clauseContext ------------------------------------------------------------------
8558 :
8559 0 : accparser::Copyout_clauseContext::Copyout_clauseContext(ParserRuleContext *parent, size_t invokingState)
8560 0 : : ParserRuleContext(parent, invokingState) {
8561 0 : }
8562 :
8563 0 : tree::TerminalNode* accparser::Copyout_clauseContext::COPYOUT() {
8564 0 : return getToken(accparser::COPYOUT, 0);
8565 : }
8566 :
8567 0 : tree::TerminalNode* accparser::Copyout_clauseContext::LEFT_PAREN() {
8568 0 : return getToken(accparser::LEFT_PAREN, 0);
8569 : }
8570 :
8571 0 : accparser::Var_listContext* accparser::Copyout_clauseContext::var_list() {
8572 0 : return getRuleContext<accparser::Var_listContext>(0);
8573 : }
8574 :
8575 0 : tree::TerminalNode* accparser::Copyout_clauseContext::RIGHT_PAREN() {
8576 0 : return getToken(accparser::RIGHT_PAREN, 0);
8577 : }
8578 :
8579 0 : accparser::Copyout_clause_modifierContext* accparser::Copyout_clauseContext::copyout_clause_modifier() {
8580 0 : return getRuleContext<accparser::Copyout_clause_modifierContext>(0);
8581 : }
8582 :
8583 0 : tree::TerminalNode* accparser::Copyout_clauseContext::COLON() {
8584 0 : return getToken(accparser::COLON, 0);
8585 : }
8586 :
8587 :
8588 0 : size_t accparser::Copyout_clauseContext::getRuleIndex() const {
8589 0 : return accparser::RuleCopyout_clause;
8590 : }
8591 :
8592 0 : void accparser::Copyout_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8593 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8594 0 : if (parserListener != nullptr)
8595 0 : parserListener->enterCopyout_clause(this);
8596 0 : }
8597 :
8598 0 : void accparser::Copyout_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8599 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8600 0 : if (parserListener != nullptr)
8601 0 : parserListener->exitCopyout_clause(this);
8602 0 : }
8603 :
8604 :
8605 0 : antlrcpp::Any accparser::Copyout_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
8606 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8607 0 : return parserVisitor->visitCopyout_clause(this);
8608 : else
8609 0 : return visitor->visitChildren(this);
8610 : }
8611 :
8612 0 : accparser::Copyout_clauseContext* accparser::copyout_clause() {
8613 0 : Copyout_clauseContext *_localctx = _tracker.createInstance<Copyout_clauseContext>(_ctx, getState());
8614 0 : enterRule(_localctx, 174, accparser::RuleCopyout_clause);
8615 :
8616 0 : auto onExit = finally([=] {
8617 0 : exitRule();
8618 0 : });
8619 0 : try {
8620 0 : setState(889);
8621 0 : _errHandler->sync(this);
8622 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 46, _ctx)) {
8623 0 : case 1: {
8624 0 : enterOuterAlt(_localctx, 1);
8625 0 : setState(877);
8626 0 : match(accparser::COPYOUT);
8627 0 : setState(878);
8628 0 : match(accparser::LEFT_PAREN);
8629 0 : setState(879);
8630 0 : var_list();
8631 0 : setState(880);
8632 0 : match(accparser::RIGHT_PAREN);
8633 : break;
8634 : }
8635 :
8636 0 : case 2: {
8637 0 : enterOuterAlt(_localctx, 2);
8638 0 : setState(882);
8639 0 : match(accparser::COPYOUT);
8640 0 : setState(883);
8641 0 : match(accparser::LEFT_PAREN);
8642 0 : setState(884);
8643 0 : copyout_clause_modifier();
8644 0 : setState(885);
8645 0 : match(accparser::COLON);
8646 0 : setState(886);
8647 0 : var_list();
8648 0 : setState(887);
8649 0 : match(accparser::RIGHT_PAREN);
8650 : break;
8651 : }
8652 :
8653 : }
8654 :
8655 : }
8656 0 : catch (RecognitionException &e) {
8657 0 : _errHandler->reportError(this, e);
8658 0 : _localctx->exception = std::current_exception();
8659 0 : _errHandler->recover(this, _localctx->exception);
8660 : }
8661 :
8662 0 : return _localctx;
8663 : }
8664 :
8665 : //----------------- Copyout_clause_modifierContext ------------------------------------------------------------------
8666 :
8667 0 : accparser::Copyout_clause_modifierContext::Copyout_clause_modifierContext(ParserRuleContext *parent, size_t invokingState)
8668 0 : : ParserRuleContext(parent, invokingState) {
8669 0 : }
8670 :
8671 0 : tree::TerminalNode* accparser::Copyout_clause_modifierContext::ZERO() {
8672 0 : return getToken(accparser::ZERO, 0);
8673 : }
8674 :
8675 :
8676 0 : size_t accparser::Copyout_clause_modifierContext::getRuleIndex() const {
8677 0 : return accparser::RuleCopyout_clause_modifier;
8678 : }
8679 :
8680 0 : void accparser::Copyout_clause_modifierContext::enterRule(tree::ParseTreeListener *listener) {
8681 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8682 0 : if (parserListener != nullptr)
8683 0 : parserListener->enterCopyout_clause_modifier(this);
8684 0 : }
8685 :
8686 0 : void accparser::Copyout_clause_modifierContext::exitRule(tree::ParseTreeListener *listener) {
8687 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8688 0 : if (parserListener != nullptr)
8689 0 : parserListener->exitCopyout_clause_modifier(this);
8690 0 : }
8691 :
8692 :
8693 0 : antlrcpp::Any accparser::Copyout_clause_modifierContext::accept(tree::ParseTreeVisitor *visitor) {
8694 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8695 0 : return parserVisitor->visitCopyout_clause_modifier(this);
8696 : else
8697 0 : return visitor->visitChildren(this);
8698 : }
8699 :
8700 0 : accparser::Copyout_clause_modifierContext* accparser::copyout_clause_modifier() {
8701 0 : Copyout_clause_modifierContext *_localctx = _tracker.createInstance<Copyout_clause_modifierContext>(_ctx, getState());
8702 0 : enterRule(_localctx, 176, accparser::RuleCopyout_clause_modifier);
8703 :
8704 0 : auto onExit = finally([=] {
8705 0 : exitRule();
8706 0 : });
8707 0 : try {
8708 0 : enterOuterAlt(_localctx, 1);
8709 0 : setState(891);
8710 0 : match(accparser::ZERO);
8711 :
8712 : }
8713 0 : catch (RecognitionException &e) {
8714 0 : _errHandler->reportError(this, e);
8715 0 : _localctx->exception = std::current_exception();
8716 0 : _errHandler->recover(this, _localctx->exception);
8717 : }
8718 :
8719 0 : return _localctx;
8720 : }
8721 :
8722 : //----------------- Copyout_no_modifier_clauseContext ------------------------------------------------------------------
8723 :
8724 0 : accparser::Copyout_no_modifier_clauseContext::Copyout_no_modifier_clauseContext(ParserRuleContext *parent, size_t invokingState)
8725 0 : : ParserRuleContext(parent, invokingState) {
8726 0 : }
8727 :
8728 0 : tree::TerminalNode* accparser::Copyout_no_modifier_clauseContext::COPYOUT() {
8729 0 : return getToken(accparser::COPYOUT, 0);
8730 : }
8731 :
8732 0 : tree::TerminalNode* accparser::Copyout_no_modifier_clauseContext::LEFT_PAREN() {
8733 0 : return getToken(accparser::LEFT_PAREN, 0);
8734 : }
8735 :
8736 0 : accparser::Var_listContext* accparser::Copyout_no_modifier_clauseContext::var_list() {
8737 0 : return getRuleContext<accparser::Var_listContext>(0);
8738 : }
8739 :
8740 0 : tree::TerminalNode* accparser::Copyout_no_modifier_clauseContext::RIGHT_PAREN() {
8741 0 : return getToken(accparser::RIGHT_PAREN, 0);
8742 : }
8743 :
8744 :
8745 0 : size_t accparser::Copyout_no_modifier_clauseContext::getRuleIndex() const {
8746 0 : return accparser::RuleCopyout_no_modifier_clause;
8747 : }
8748 :
8749 0 : void accparser::Copyout_no_modifier_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8750 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8751 0 : if (parserListener != nullptr)
8752 0 : parserListener->enterCopyout_no_modifier_clause(this);
8753 0 : }
8754 :
8755 0 : void accparser::Copyout_no_modifier_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8756 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8757 0 : if (parserListener != nullptr)
8758 0 : parserListener->exitCopyout_no_modifier_clause(this);
8759 0 : }
8760 :
8761 :
8762 0 : antlrcpp::Any accparser::Copyout_no_modifier_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
8763 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8764 0 : return parserVisitor->visitCopyout_no_modifier_clause(this);
8765 : else
8766 0 : return visitor->visitChildren(this);
8767 : }
8768 :
8769 0 : accparser::Copyout_no_modifier_clauseContext* accparser::copyout_no_modifier_clause() {
8770 0 : Copyout_no_modifier_clauseContext *_localctx = _tracker.createInstance<Copyout_no_modifier_clauseContext>(_ctx, getState());
8771 0 : enterRule(_localctx, 178, accparser::RuleCopyout_no_modifier_clause);
8772 :
8773 0 : auto onExit = finally([=] {
8774 0 : exitRule();
8775 0 : });
8776 0 : try {
8777 0 : enterOuterAlt(_localctx, 1);
8778 0 : setState(893);
8779 0 : match(accparser::COPYOUT);
8780 0 : setState(894);
8781 0 : match(accparser::LEFT_PAREN);
8782 0 : setState(895);
8783 0 : var_list();
8784 0 : setState(896);
8785 0 : match(accparser::RIGHT_PAREN);
8786 :
8787 : }
8788 0 : catch (RecognitionException &e) {
8789 0 : _errHandler->reportError(this, e);
8790 0 : _localctx->exception = std::current_exception();
8791 0 : _errHandler->recover(this, _localctx->exception);
8792 : }
8793 :
8794 0 : return _localctx;
8795 : }
8796 :
8797 : //----------------- Create_clauseContext ------------------------------------------------------------------
8798 :
8799 0 : accparser::Create_clauseContext::Create_clauseContext(ParserRuleContext *parent, size_t invokingState)
8800 0 : : ParserRuleContext(parent, invokingState) {
8801 0 : }
8802 :
8803 0 : tree::TerminalNode* accparser::Create_clauseContext::CREATE() {
8804 0 : return getToken(accparser::CREATE, 0);
8805 : }
8806 :
8807 0 : tree::TerminalNode* accparser::Create_clauseContext::LEFT_PAREN() {
8808 0 : return getToken(accparser::LEFT_PAREN, 0);
8809 : }
8810 :
8811 0 : accparser::Var_listContext* accparser::Create_clauseContext::var_list() {
8812 0 : return getRuleContext<accparser::Var_listContext>(0);
8813 : }
8814 :
8815 0 : tree::TerminalNode* accparser::Create_clauseContext::RIGHT_PAREN() {
8816 0 : return getToken(accparser::RIGHT_PAREN, 0);
8817 : }
8818 :
8819 0 : accparser::Create_clause_modifierContext* accparser::Create_clauseContext::create_clause_modifier() {
8820 0 : return getRuleContext<accparser::Create_clause_modifierContext>(0);
8821 : }
8822 :
8823 0 : tree::TerminalNode* accparser::Create_clauseContext::COLON() {
8824 0 : return getToken(accparser::COLON, 0);
8825 : }
8826 :
8827 :
8828 0 : size_t accparser::Create_clauseContext::getRuleIndex() const {
8829 0 : return accparser::RuleCreate_clause;
8830 : }
8831 :
8832 0 : void accparser::Create_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8833 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8834 0 : if (parserListener != nullptr)
8835 0 : parserListener->enterCreate_clause(this);
8836 0 : }
8837 :
8838 0 : void accparser::Create_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8839 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8840 0 : if (parserListener != nullptr)
8841 0 : parserListener->exitCreate_clause(this);
8842 0 : }
8843 :
8844 :
8845 0 : antlrcpp::Any accparser::Create_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
8846 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8847 0 : return parserVisitor->visitCreate_clause(this);
8848 : else
8849 0 : return visitor->visitChildren(this);
8850 : }
8851 :
8852 0 : accparser::Create_clauseContext* accparser::create_clause() {
8853 0 : Create_clauseContext *_localctx = _tracker.createInstance<Create_clauseContext>(_ctx, getState());
8854 0 : enterRule(_localctx, 180, accparser::RuleCreate_clause);
8855 :
8856 0 : auto onExit = finally([=] {
8857 0 : exitRule();
8858 0 : });
8859 0 : try {
8860 0 : setState(910);
8861 0 : _errHandler->sync(this);
8862 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
8863 0 : case 1: {
8864 0 : enterOuterAlt(_localctx, 1);
8865 0 : setState(898);
8866 0 : match(accparser::CREATE);
8867 0 : setState(899);
8868 0 : match(accparser::LEFT_PAREN);
8869 0 : setState(900);
8870 0 : var_list();
8871 0 : setState(901);
8872 0 : match(accparser::RIGHT_PAREN);
8873 : break;
8874 : }
8875 :
8876 0 : case 2: {
8877 0 : enterOuterAlt(_localctx, 2);
8878 0 : setState(903);
8879 0 : match(accparser::CREATE);
8880 0 : setState(904);
8881 0 : match(accparser::LEFT_PAREN);
8882 0 : setState(905);
8883 0 : create_clause_modifier();
8884 0 : setState(906);
8885 0 : match(accparser::COLON);
8886 0 : setState(907);
8887 0 : var_list();
8888 0 : setState(908);
8889 0 : match(accparser::RIGHT_PAREN);
8890 : break;
8891 : }
8892 :
8893 : }
8894 :
8895 : }
8896 0 : catch (RecognitionException &e) {
8897 0 : _errHandler->reportError(this, e);
8898 0 : _localctx->exception = std::current_exception();
8899 0 : _errHandler->recover(this, _localctx->exception);
8900 : }
8901 :
8902 0 : return _localctx;
8903 : }
8904 :
8905 : //----------------- Create_clause_modifierContext ------------------------------------------------------------------
8906 :
8907 0 : accparser::Create_clause_modifierContext::Create_clause_modifierContext(ParserRuleContext *parent, size_t invokingState)
8908 0 : : ParserRuleContext(parent, invokingState) {
8909 0 : }
8910 :
8911 0 : tree::TerminalNode* accparser::Create_clause_modifierContext::ZERO() {
8912 0 : return getToken(accparser::ZERO, 0);
8913 : }
8914 :
8915 :
8916 0 : size_t accparser::Create_clause_modifierContext::getRuleIndex() const {
8917 0 : return accparser::RuleCreate_clause_modifier;
8918 : }
8919 :
8920 0 : void accparser::Create_clause_modifierContext::enterRule(tree::ParseTreeListener *listener) {
8921 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8922 0 : if (parserListener != nullptr)
8923 0 : parserListener->enterCreate_clause_modifier(this);
8924 0 : }
8925 :
8926 0 : void accparser::Create_clause_modifierContext::exitRule(tree::ParseTreeListener *listener) {
8927 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8928 0 : if (parserListener != nullptr)
8929 0 : parserListener->exitCreate_clause_modifier(this);
8930 0 : }
8931 :
8932 :
8933 0 : antlrcpp::Any accparser::Create_clause_modifierContext::accept(tree::ParseTreeVisitor *visitor) {
8934 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
8935 0 : return parserVisitor->visitCreate_clause_modifier(this);
8936 : else
8937 0 : return visitor->visitChildren(this);
8938 : }
8939 :
8940 0 : accparser::Create_clause_modifierContext* accparser::create_clause_modifier() {
8941 0 : Create_clause_modifierContext *_localctx = _tracker.createInstance<Create_clause_modifierContext>(_ctx, getState());
8942 0 : enterRule(_localctx, 182, accparser::RuleCreate_clause_modifier);
8943 :
8944 0 : auto onExit = finally([=] {
8945 0 : exitRule();
8946 0 : });
8947 0 : try {
8948 0 : enterOuterAlt(_localctx, 1);
8949 0 : setState(912);
8950 0 : match(accparser::ZERO);
8951 :
8952 : }
8953 0 : catch (RecognitionException &e) {
8954 0 : _errHandler->reportError(this, e);
8955 0 : _localctx->exception = std::current_exception();
8956 0 : _errHandler->recover(this, _localctx->exception);
8957 : }
8958 :
8959 0 : return _localctx;
8960 : }
8961 :
8962 : //----------------- Create_no_modifier_clauseContext ------------------------------------------------------------------
8963 :
8964 0 : accparser::Create_no_modifier_clauseContext::Create_no_modifier_clauseContext(ParserRuleContext *parent, size_t invokingState)
8965 0 : : ParserRuleContext(parent, invokingState) {
8966 0 : }
8967 :
8968 0 : tree::TerminalNode* accparser::Create_no_modifier_clauseContext::CREATE() {
8969 0 : return getToken(accparser::CREATE, 0);
8970 : }
8971 :
8972 0 : tree::TerminalNode* accparser::Create_no_modifier_clauseContext::LEFT_PAREN() {
8973 0 : return getToken(accparser::LEFT_PAREN, 0);
8974 : }
8975 :
8976 0 : accparser::Var_listContext* accparser::Create_no_modifier_clauseContext::var_list() {
8977 0 : return getRuleContext<accparser::Var_listContext>(0);
8978 : }
8979 :
8980 0 : tree::TerminalNode* accparser::Create_no_modifier_clauseContext::RIGHT_PAREN() {
8981 0 : return getToken(accparser::RIGHT_PAREN, 0);
8982 : }
8983 :
8984 :
8985 0 : size_t accparser::Create_no_modifier_clauseContext::getRuleIndex() const {
8986 0 : return accparser::RuleCreate_no_modifier_clause;
8987 : }
8988 :
8989 0 : void accparser::Create_no_modifier_clauseContext::enterRule(tree::ParseTreeListener *listener) {
8990 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8991 0 : if (parserListener != nullptr)
8992 0 : parserListener->enterCreate_no_modifier_clause(this);
8993 0 : }
8994 :
8995 0 : void accparser::Create_no_modifier_clauseContext::exitRule(tree::ParseTreeListener *listener) {
8996 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
8997 0 : if (parserListener != nullptr)
8998 0 : parserListener->exitCreate_no_modifier_clause(this);
8999 0 : }
9000 :
9001 :
9002 0 : antlrcpp::Any accparser::Create_no_modifier_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9003 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9004 0 : return parserVisitor->visitCreate_no_modifier_clause(this);
9005 : else
9006 0 : return visitor->visitChildren(this);
9007 : }
9008 :
9009 0 : accparser::Create_no_modifier_clauseContext* accparser::create_no_modifier_clause() {
9010 0 : Create_no_modifier_clauseContext *_localctx = _tracker.createInstance<Create_no_modifier_clauseContext>(_ctx, getState());
9011 0 : enterRule(_localctx, 184, accparser::RuleCreate_no_modifier_clause);
9012 :
9013 0 : auto onExit = finally([=] {
9014 0 : exitRule();
9015 0 : });
9016 0 : try {
9017 0 : enterOuterAlt(_localctx, 1);
9018 0 : setState(914);
9019 0 : match(accparser::CREATE);
9020 0 : setState(915);
9021 0 : match(accparser::LEFT_PAREN);
9022 0 : setState(916);
9023 0 : var_list();
9024 0 : setState(917);
9025 0 : match(accparser::RIGHT_PAREN);
9026 :
9027 : }
9028 0 : catch (RecognitionException &e) {
9029 0 : _errHandler->reportError(this, e);
9030 0 : _localctx->exception = std::current_exception();
9031 0 : _errHandler->recover(this, _localctx->exception);
9032 : }
9033 :
9034 0 : return _localctx;
9035 : }
9036 :
9037 : //----------------- Default_clauseContext ------------------------------------------------------------------
9038 :
9039 0 : accparser::Default_clauseContext::Default_clauseContext(ParserRuleContext *parent, size_t invokingState)
9040 0 : : ParserRuleContext(parent, invokingState) {
9041 0 : }
9042 :
9043 0 : tree::TerminalNode* accparser::Default_clauseContext::DEFAULT() {
9044 0 : return getToken(accparser::DEFAULT, 0);
9045 : }
9046 :
9047 0 : tree::TerminalNode* accparser::Default_clauseContext::LEFT_PAREN() {
9048 0 : return getToken(accparser::LEFT_PAREN, 0);
9049 : }
9050 :
9051 0 : accparser::Default_kindContext* accparser::Default_clauseContext::default_kind() {
9052 0 : return getRuleContext<accparser::Default_kindContext>(0);
9053 : }
9054 :
9055 0 : tree::TerminalNode* accparser::Default_clauseContext::RIGHT_PAREN() {
9056 0 : return getToken(accparser::RIGHT_PAREN, 0);
9057 : }
9058 :
9059 :
9060 0 : size_t accparser::Default_clauseContext::getRuleIndex() const {
9061 0 : return accparser::RuleDefault_clause;
9062 : }
9063 :
9064 0 : void accparser::Default_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9065 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9066 0 : if (parserListener != nullptr)
9067 0 : parserListener->enterDefault_clause(this);
9068 0 : }
9069 :
9070 0 : void accparser::Default_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9071 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9072 0 : if (parserListener != nullptr)
9073 0 : parserListener->exitDefault_clause(this);
9074 0 : }
9075 :
9076 :
9077 0 : antlrcpp::Any accparser::Default_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9078 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9079 0 : return parserVisitor->visitDefault_clause(this);
9080 : else
9081 0 : return visitor->visitChildren(this);
9082 : }
9083 :
9084 0 : accparser::Default_clauseContext* accparser::default_clause() {
9085 0 : Default_clauseContext *_localctx = _tracker.createInstance<Default_clauseContext>(_ctx, getState());
9086 0 : enterRule(_localctx, 186, accparser::RuleDefault_clause);
9087 :
9088 0 : auto onExit = finally([=] {
9089 0 : exitRule();
9090 0 : });
9091 0 : try {
9092 0 : enterOuterAlt(_localctx, 1);
9093 0 : setState(919);
9094 0 : match(accparser::DEFAULT);
9095 0 : setState(920);
9096 0 : match(accparser::LEFT_PAREN);
9097 0 : setState(921);
9098 0 : default_kind();
9099 0 : setState(922);
9100 0 : match(accparser::RIGHT_PAREN);
9101 :
9102 : }
9103 0 : catch (RecognitionException &e) {
9104 0 : _errHandler->reportError(this, e);
9105 0 : _localctx->exception = std::current_exception();
9106 0 : _errHandler->recover(this, _localctx->exception);
9107 : }
9108 :
9109 0 : return _localctx;
9110 : }
9111 :
9112 : //----------------- Default_kindContext ------------------------------------------------------------------
9113 :
9114 0 : accparser::Default_kindContext::Default_kindContext(ParserRuleContext *parent, size_t invokingState)
9115 0 : : ParserRuleContext(parent, invokingState) {
9116 0 : }
9117 :
9118 0 : tree::TerminalNode* accparser::Default_kindContext::NONE() {
9119 0 : return getToken(accparser::NONE, 0);
9120 : }
9121 :
9122 0 : tree::TerminalNode* accparser::Default_kindContext::PRESENT() {
9123 0 : return getToken(accparser::PRESENT, 0);
9124 : }
9125 :
9126 :
9127 0 : size_t accparser::Default_kindContext::getRuleIndex() const {
9128 0 : return accparser::RuleDefault_kind;
9129 : }
9130 :
9131 0 : void accparser::Default_kindContext::enterRule(tree::ParseTreeListener *listener) {
9132 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9133 0 : if (parserListener != nullptr)
9134 0 : parserListener->enterDefault_kind(this);
9135 0 : }
9136 :
9137 0 : void accparser::Default_kindContext::exitRule(tree::ParseTreeListener *listener) {
9138 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9139 0 : if (parserListener != nullptr)
9140 0 : parserListener->exitDefault_kind(this);
9141 0 : }
9142 :
9143 :
9144 0 : antlrcpp::Any accparser::Default_kindContext::accept(tree::ParseTreeVisitor *visitor) {
9145 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9146 0 : return parserVisitor->visitDefault_kind(this);
9147 : else
9148 0 : return visitor->visitChildren(this);
9149 : }
9150 :
9151 0 : accparser::Default_kindContext* accparser::default_kind() {
9152 0 : Default_kindContext *_localctx = _tracker.createInstance<Default_kindContext>(_ctx, getState());
9153 0 : enterRule(_localctx, 188, accparser::RuleDefault_kind);
9154 0 : size_t _la = 0;
9155 :
9156 0 : auto onExit = finally([=] {
9157 0 : exitRule();
9158 0 : });
9159 0 : try {
9160 0 : enterOuterAlt(_localctx, 1);
9161 0 : setState(924);
9162 0 : _la = _input->LA(1);
9163 0 : if (!(_la == accparser::PRESENT
9164 :
9165 0 : || _la == accparser::NONE)) {
9166 0 : _errHandler->recoverInline(this);
9167 : }
9168 : else {
9169 0 : _errHandler->reportMatch(this);
9170 0 : consume();
9171 : }
9172 :
9173 : }
9174 0 : catch (RecognitionException &e) {
9175 0 : _errHandler->reportError(this, e);
9176 0 : _localctx->exception = std::current_exception();
9177 0 : _errHandler->recover(this, _localctx->exception);
9178 : }
9179 :
9180 0 : return _localctx;
9181 : }
9182 :
9183 : //----------------- Default_async_clauseContext ------------------------------------------------------------------
9184 :
9185 0 : accparser::Default_async_clauseContext::Default_async_clauseContext(ParserRuleContext *parent, size_t invokingState)
9186 0 : : ParserRuleContext(parent, invokingState) {
9187 0 : }
9188 :
9189 0 : tree::TerminalNode* accparser::Default_async_clauseContext::DEFAULT_ASYNC() {
9190 0 : return getToken(accparser::DEFAULT_ASYNC, 0);
9191 : }
9192 :
9193 0 : tree::TerminalNode* accparser::Default_async_clauseContext::LEFT_PAREN() {
9194 0 : return getToken(accparser::LEFT_PAREN, 0);
9195 : }
9196 :
9197 0 : accparser::Int_exprContext* accparser::Default_async_clauseContext::int_expr() {
9198 0 : return getRuleContext<accparser::Int_exprContext>(0);
9199 : }
9200 :
9201 0 : tree::TerminalNode* accparser::Default_async_clauseContext::RIGHT_PAREN() {
9202 0 : return getToken(accparser::RIGHT_PAREN, 0);
9203 : }
9204 :
9205 :
9206 0 : size_t accparser::Default_async_clauseContext::getRuleIndex() const {
9207 0 : return accparser::RuleDefault_async_clause;
9208 : }
9209 :
9210 0 : void accparser::Default_async_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9211 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9212 0 : if (parserListener != nullptr)
9213 0 : parserListener->enterDefault_async_clause(this);
9214 0 : }
9215 :
9216 0 : void accparser::Default_async_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9217 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9218 0 : if (parserListener != nullptr)
9219 0 : parserListener->exitDefault_async_clause(this);
9220 0 : }
9221 :
9222 :
9223 0 : antlrcpp::Any accparser::Default_async_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9224 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9225 0 : return parserVisitor->visitDefault_async_clause(this);
9226 : else
9227 0 : return visitor->visitChildren(this);
9228 : }
9229 :
9230 0 : accparser::Default_async_clauseContext* accparser::default_async_clause() {
9231 0 : Default_async_clauseContext *_localctx = _tracker.createInstance<Default_async_clauseContext>(_ctx, getState());
9232 0 : enterRule(_localctx, 190, accparser::RuleDefault_async_clause);
9233 :
9234 0 : auto onExit = finally([=] {
9235 0 : exitRule();
9236 0 : });
9237 0 : try {
9238 0 : enterOuterAlt(_localctx, 1);
9239 0 : setState(926);
9240 0 : match(accparser::DEFAULT_ASYNC);
9241 0 : setState(927);
9242 0 : match(accparser::LEFT_PAREN);
9243 0 : setState(928);
9244 0 : int_expr();
9245 0 : setState(929);
9246 0 : match(accparser::RIGHT_PAREN);
9247 :
9248 : }
9249 0 : catch (RecognitionException &e) {
9250 0 : _errHandler->reportError(this, e);
9251 0 : _localctx->exception = std::current_exception();
9252 0 : _errHandler->recover(this, _localctx->exception);
9253 : }
9254 :
9255 0 : return _localctx;
9256 : }
9257 :
9258 : //----------------- Delete_clauseContext ------------------------------------------------------------------
9259 :
9260 0 : accparser::Delete_clauseContext::Delete_clauseContext(ParserRuleContext *parent, size_t invokingState)
9261 0 : : ParserRuleContext(parent, invokingState) {
9262 0 : }
9263 :
9264 0 : tree::TerminalNode* accparser::Delete_clauseContext::DELETE() {
9265 0 : return getToken(accparser::DELETE, 0);
9266 : }
9267 :
9268 0 : tree::TerminalNode* accparser::Delete_clauseContext::LEFT_PAREN() {
9269 0 : return getToken(accparser::LEFT_PAREN, 0);
9270 : }
9271 :
9272 0 : accparser::Var_listContext* accparser::Delete_clauseContext::var_list() {
9273 0 : return getRuleContext<accparser::Var_listContext>(0);
9274 : }
9275 :
9276 0 : tree::TerminalNode* accparser::Delete_clauseContext::RIGHT_PAREN() {
9277 0 : return getToken(accparser::RIGHT_PAREN, 0);
9278 : }
9279 :
9280 :
9281 0 : size_t accparser::Delete_clauseContext::getRuleIndex() const {
9282 0 : return accparser::RuleDelete_clause;
9283 : }
9284 :
9285 0 : void accparser::Delete_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9286 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9287 0 : if (parserListener != nullptr)
9288 0 : parserListener->enterDelete_clause(this);
9289 0 : }
9290 :
9291 0 : void accparser::Delete_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9292 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9293 0 : if (parserListener != nullptr)
9294 0 : parserListener->exitDelete_clause(this);
9295 0 : }
9296 :
9297 :
9298 0 : antlrcpp::Any accparser::Delete_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9299 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9300 0 : return parserVisitor->visitDelete_clause(this);
9301 : else
9302 0 : return visitor->visitChildren(this);
9303 : }
9304 :
9305 0 : accparser::Delete_clauseContext* accparser::delete_clause() {
9306 0 : Delete_clauseContext *_localctx = _tracker.createInstance<Delete_clauseContext>(_ctx, getState());
9307 0 : enterRule(_localctx, 192, accparser::RuleDelete_clause);
9308 :
9309 0 : auto onExit = finally([=] {
9310 0 : exitRule();
9311 0 : });
9312 0 : try {
9313 0 : enterOuterAlt(_localctx, 1);
9314 0 : setState(931);
9315 0 : match(accparser::DELETE);
9316 0 : setState(932);
9317 0 : match(accparser::LEFT_PAREN);
9318 0 : setState(933);
9319 0 : var_list();
9320 0 : setState(934);
9321 0 : match(accparser::RIGHT_PAREN);
9322 :
9323 : }
9324 0 : catch (RecognitionException &e) {
9325 0 : _errHandler->reportError(this, e);
9326 0 : _localctx->exception = std::current_exception();
9327 0 : _errHandler->recover(this, _localctx->exception);
9328 : }
9329 :
9330 0 : return _localctx;
9331 : }
9332 :
9333 : //----------------- Detach_clauseContext ------------------------------------------------------------------
9334 :
9335 0 : accparser::Detach_clauseContext::Detach_clauseContext(ParserRuleContext *parent, size_t invokingState)
9336 0 : : ParserRuleContext(parent, invokingState) {
9337 0 : }
9338 :
9339 0 : tree::TerminalNode* accparser::Detach_clauseContext::DETACH() {
9340 0 : return getToken(accparser::DETACH, 0);
9341 : }
9342 :
9343 0 : tree::TerminalNode* accparser::Detach_clauseContext::LEFT_PAREN() {
9344 0 : return getToken(accparser::LEFT_PAREN, 0);
9345 : }
9346 :
9347 0 : accparser::Var_listContext* accparser::Detach_clauseContext::var_list() {
9348 0 : return getRuleContext<accparser::Var_listContext>(0);
9349 : }
9350 :
9351 0 : tree::TerminalNode* accparser::Detach_clauseContext::RIGHT_PAREN() {
9352 0 : return getToken(accparser::RIGHT_PAREN, 0);
9353 : }
9354 :
9355 :
9356 0 : size_t accparser::Detach_clauseContext::getRuleIndex() const {
9357 0 : return accparser::RuleDetach_clause;
9358 : }
9359 :
9360 0 : void accparser::Detach_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9361 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9362 0 : if (parserListener != nullptr)
9363 0 : parserListener->enterDetach_clause(this);
9364 0 : }
9365 :
9366 0 : void accparser::Detach_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9367 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9368 0 : if (parserListener != nullptr)
9369 0 : parserListener->exitDetach_clause(this);
9370 0 : }
9371 :
9372 :
9373 0 : antlrcpp::Any accparser::Detach_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9374 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9375 0 : return parserVisitor->visitDetach_clause(this);
9376 : else
9377 0 : return visitor->visitChildren(this);
9378 : }
9379 :
9380 0 : accparser::Detach_clauseContext* accparser::detach_clause() {
9381 0 : Detach_clauseContext *_localctx = _tracker.createInstance<Detach_clauseContext>(_ctx, getState());
9382 0 : enterRule(_localctx, 194, accparser::RuleDetach_clause);
9383 :
9384 0 : auto onExit = finally([=] {
9385 0 : exitRule();
9386 0 : });
9387 0 : try {
9388 0 : enterOuterAlt(_localctx, 1);
9389 0 : setState(936);
9390 0 : match(accparser::DETACH);
9391 0 : setState(937);
9392 0 : match(accparser::LEFT_PAREN);
9393 0 : setState(938);
9394 0 : var_list();
9395 0 : setState(939);
9396 0 : match(accparser::RIGHT_PAREN);
9397 :
9398 : }
9399 0 : catch (RecognitionException &e) {
9400 0 : _errHandler->reportError(this, e);
9401 0 : _localctx->exception = std::current_exception();
9402 0 : _errHandler->recover(this, _localctx->exception);
9403 : }
9404 :
9405 0 : return _localctx;
9406 : }
9407 :
9408 : //----------------- Device_clauseContext ------------------------------------------------------------------
9409 :
9410 0 : accparser::Device_clauseContext::Device_clauseContext(ParserRuleContext *parent, size_t invokingState)
9411 0 : : ParserRuleContext(parent, invokingState) {
9412 0 : }
9413 :
9414 0 : tree::TerminalNode* accparser::Device_clauseContext::DEVICE() {
9415 0 : return getToken(accparser::DEVICE, 0);
9416 : }
9417 :
9418 0 : tree::TerminalNode* accparser::Device_clauseContext::LEFT_PAREN() {
9419 0 : return getToken(accparser::LEFT_PAREN, 0);
9420 : }
9421 :
9422 0 : accparser::Var_listContext* accparser::Device_clauseContext::var_list() {
9423 0 : return getRuleContext<accparser::Var_listContext>(0);
9424 : }
9425 :
9426 0 : tree::TerminalNode* accparser::Device_clauseContext::RIGHT_PAREN() {
9427 0 : return getToken(accparser::RIGHT_PAREN, 0);
9428 : }
9429 :
9430 :
9431 0 : size_t accparser::Device_clauseContext::getRuleIndex() const {
9432 0 : return accparser::RuleDevice_clause;
9433 : }
9434 :
9435 0 : void accparser::Device_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9436 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9437 0 : if (parserListener != nullptr)
9438 0 : parserListener->enterDevice_clause(this);
9439 0 : }
9440 :
9441 0 : void accparser::Device_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9442 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9443 0 : if (parserListener != nullptr)
9444 0 : parserListener->exitDevice_clause(this);
9445 0 : }
9446 :
9447 :
9448 0 : antlrcpp::Any accparser::Device_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9449 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9450 0 : return parserVisitor->visitDevice_clause(this);
9451 : else
9452 0 : return visitor->visitChildren(this);
9453 : }
9454 :
9455 0 : accparser::Device_clauseContext* accparser::device_clause() {
9456 0 : Device_clauseContext *_localctx = _tracker.createInstance<Device_clauseContext>(_ctx, getState());
9457 0 : enterRule(_localctx, 196, accparser::RuleDevice_clause);
9458 :
9459 0 : auto onExit = finally([=] {
9460 0 : exitRule();
9461 0 : });
9462 0 : try {
9463 0 : enterOuterAlt(_localctx, 1);
9464 0 : setState(941);
9465 0 : match(accparser::DEVICE);
9466 0 : setState(942);
9467 0 : match(accparser::LEFT_PAREN);
9468 0 : setState(943);
9469 0 : var_list();
9470 0 : setState(944);
9471 0 : match(accparser::RIGHT_PAREN);
9472 :
9473 : }
9474 0 : catch (RecognitionException &e) {
9475 0 : _errHandler->reportError(this, e);
9476 0 : _localctx->exception = std::current_exception();
9477 0 : _errHandler->recover(this, _localctx->exception);
9478 : }
9479 :
9480 0 : return _localctx;
9481 : }
9482 :
9483 : //----------------- Device_num_clauseContext ------------------------------------------------------------------
9484 :
9485 0 : accparser::Device_num_clauseContext::Device_num_clauseContext(ParserRuleContext *parent, size_t invokingState)
9486 0 : : ParserRuleContext(parent, invokingState) {
9487 0 : }
9488 :
9489 0 : tree::TerminalNode* accparser::Device_num_clauseContext::DEVICE_NUM() {
9490 0 : return getToken(accparser::DEVICE_NUM, 0);
9491 : }
9492 :
9493 0 : tree::TerminalNode* accparser::Device_num_clauseContext::LEFT_PAREN() {
9494 0 : return getToken(accparser::LEFT_PAREN, 0);
9495 : }
9496 :
9497 0 : accparser::Int_exprContext* accparser::Device_num_clauseContext::int_expr() {
9498 0 : return getRuleContext<accparser::Int_exprContext>(0);
9499 : }
9500 :
9501 0 : tree::TerminalNode* accparser::Device_num_clauseContext::RIGHT_PAREN() {
9502 0 : return getToken(accparser::RIGHT_PAREN, 0);
9503 : }
9504 :
9505 :
9506 0 : size_t accparser::Device_num_clauseContext::getRuleIndex() const {
9507 0 : return accparser::RuleDevice_num_clause;
9508 : }
9509 :
9510 0 : void accparser::Device_num_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9511 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9512 0 : if (parserListener != nullptr)
9513 0 : parserListener->enterDevice_num_clause(this);
9514 0 : }
9515 :
9516 0 : void accparser::Device_num_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9517 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9518 0 : if (parserListener != nullptr)
9519 0 : parserListener->exitDevice_num_clause(this);
9520 0 : }
9521 :
9522 :
9523 0 : antlrcpp::Any accparser::Device_num_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9524 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9525 0 : return parserVisitor->visitDevice_num_clause(this);
9526 : else
9527 0 : return visitor->visitChildren(this);
9528 : }
9529 :
9530 0 : accparser::Device_num_clauseContext* accparser::device_num_clause() {
9531 0 : Device_num_clauseContext *_localctx = _tracker.createInstance<Device_num_clauseContext>(_ctx, getState());
9532 0 : enterRule(_localctx, 198, accparser::RuleDevice_num_clause);
9533 :
9534 0 : auto onExit = finally([=] {
9535 0 : exitRule();
9536 0 : });
9537 0 : try {
9538 0 : enterOuterAlt(_localctx, 1);
9539 0 : setState(946);
9540 0 : match(accparser::DEVICE_NUM);
9541 0 : setState(947);
9542 0 : match(accparser::LEFT_PAREN);
9543 0 : setState(948);
9544 0 : int_expr();
9545 0 : setState(949);
9546 0 : match(accparser::RIGHT_PAREN);
9547 :
9548 : }
9549 0 : catch (RecognitionException &e) {
9550 0 : _errHandler->reportError(this, e);
9551 0 : _localctx->exception = std::current_exception();
9552 0 : _errHandler->recover(this, _localctx->exception);
9553 : }
9554 :
9555 0 : return _localctx;
9556 : }
9557 :
9558 : //----------------- Device_resident_clauseContext ------------------------------------------------------------------
9559 :
9560 0 : accparser::Device_resident_clauseContext::Device_resident_clauseContext(ParserRuleContext *parent, size_t invokingState)
9561 0 : : ParserRuleContext(parent, invokingState) {
9562 0 : }
9563 :
9564 0 : tree::TerminalNode* accparser::Device_resident_clauseContext::DEVICE_RESIDENT() {
9565 0 : return getToken(accparser::DEVICE_RESIDENT, 0);
9566 : }
9567 :
9568 0 : tree::TerminalNode* accparser::Device_resident_clauseContext::LEFT_PAREN() {
9569 0 : return getToken(accparser::LEFT_PAREN, 0);
9570 : }
9571 :
9572 0 : accparser::Var_listContext* accparser::Device_resident_clauseContext::var_list() {
9573 0 : return getRuleContext<accparser::Var_listContext>(0);
9574 : }
9575 :
9576 0 : tree::TerminalNode* accparser::Device_resident_clauseContext::RIGHT_PAREN() {
9577 0 : return getToken(accparser::RIGHT_PAREN, 0);
9578 : }
9579 :
9580 :
9581 0 : size_t accparser::Device_resident_clauseContext::getRuleIndex() const {
9582 0 : return accparser::RuleDevice_resident_clause;
9583 : }
9584 :
9585 0 : void accparser::Device_resident_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9586 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9587 0 : if (parserListener != nullptr)
9588 0 : parserListener->enterDevice_resident_clause(this);
9589 0 : }
9590 :
9591 0 : void accparser::Device_resident_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9592 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9593 0 : if (parserListener != nullptr)
9594 0 : parserListener->exitDevice_resident_clause(this);
9595 0 : }
9596 :
9597 :
9598 0 : antlrcpp::Any accparser::Device_resident_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9599 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9600 0 : return parserVisitor->visitDevice_resident_clause(this);
9601 : else
9602 0 : return visitor->visitChildren(this);
9603 : }
9604 :
9605 0 : accparser::Device_resident_clauseContext* accparser::device_resident_clause() {
9606 0 : Device_resident_clauseContext *_localctx = _tracker.createInstance<Device_resident_clauseContext>(_ctx, getState());
9607 0 : enterRule(_localctx, 200, accparser::RuleDevice_resident_clause);
9608 :
9609 0 : auto onExit = finally([=] {
9610 0 : exitRule();
9611 0 : });
9612 0 : try {
9613 0 : enterOuterAlt(_localctx, 1);
9614 0 : setState(951);
9615 0 : match(accparser::DEVICE_RESIDENT);
9616 0 : setState(952);
9617 0 : match(accparser::LEFT_PAREN);
9618 0 : setState(953);
9619 0 : var_list();
9620 0 : setState(954);
9621 0 : match(accparser::RIGHT_PAREN);
9622 :
9623 : }
9624 0 : catch (RecognitionException &e) {
9625 0 : _errHandler->reportError(this, e);
9626 0 : _localctx->exception = std::current_exception();
9627 0 : _errHandler->recover(this, _localctx->exception);
9628 : }
9629 :
9630 0 : return _localctx;
9631 : }
9632 :
9633 : //----------------- Device_type_clauseContext ------------------------------------------------------------------
9634 :
9635 0 : accparser::Device_type_clauseContext::Device_type_clauseContext(ParserRuleContext *parent, size_t invokingState)
9636 0 : : ParserRuleContext(parent, invokingState) {
9637 0 : }
9638 :
9639 0 : tree::TerminalNode* accparser::Device_type_clauseContext::DEVICE_TYPE() {
9640 0 : return getToken(accparser::DEVICE_TYPE, 0);
9641 : }
9642 :
9643 0 : tree::TerminalNode* accparser::Device_type_clauseContext::LEFT_PAREN() {
9644 0 : return getToken(accparser::LEFT_PAREN, 0);
9645 : }
9646 :
9647 0 : accparser::Device_type_listContext* accparser::Device_type_clauseContext::device_type_list() {
9648 0 : return getRuleContext<accparser::Device_type_listContext>(0);
9649 : }
9650 :
9651 0 : tree::TerminalNode* accparser::Device_type_clauseContext::RIGHT_PAREN() {
9652 0 : return getToken(accparser::RIGHT_PAREN, 0);
9653 : }
9654 :
9655 :
9656 0 : size_t accparser::Device_type_clauseContext::getRuleIndex() const {
9657 0 : return accparser::RuleDevice_type_clause;
9658 : }
9659 :
9660 0 : void accparser::Device_type_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9661 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9662 0 : if (parserListener != nullptr)
9663 0 : parserListener->enterDevice_type_clause(this);
9664 0 : }
9665 :
9666 0 : void accparser::Device_type_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9667 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9668 0 : if (parserListener != nullptr)
9669 0 : parserListener->exitDevice_type_clause(this);
9670 0 : }
9671 :
9672 :
9673 0 : antlrcpp::Any accparser::Device_type_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9674 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9675 0 : return parserVisitor->visitDevice_type_clause(this);
9676 : else
9677 0 : return visitor->visitChildren(this);
9678 : }
9679 :
9680 0 : accparser::Device_type_clauseContext* accparser::device_type_clause() {
9681 0 : Device_type_clauseContext *_localctx = _tracker.createInstance<Device_type_clauseContext>(_ctx, getState());
9682 0 : enterRule(_localctx, 202, accparser::RuleDevice_type_clause);
9683 :
9684 0 : auto onExit = finally([=] {
9685 0 : exitRule();
9686 0 : });
9687 0 : try {
9688 0 : enterOuterAlt(_localctx, 1);
9689 0 : setState(956);
9690 0 : match(accparser::DEVICE_TYPE);
9691 0 : setState(957);
9692 0 : match(accparser::LEFT_PAREN);
9693 0 : setState(958);
9694 0 : device_type_list();
9695 0 : setState(959);
9696 0 : match(accparser::RIGHT_PAREN);
9697 :
9698 : }
9699 0 : catch (RecognitionException &e) {
9700 0 : _errHandler->reportError(this, e);
9701 0 : _localctx->exception = std::current_exception();
9702 0 : _errHandler->recover(this, _localctx->exception);
9703 : }
9704 :
9705 0 : return _localctx;
9706 : }
9707 :
9708 : //----------------- Device_type_listContext ------------------------------------------------------------------
9709 :
9710 0 : accparser::Device_type_listContext::Device_type_listContext(ParserRuleContext *parent, size_t invokingState)
9711 0 : : ParserRuleContext(parent, invokingState) {
9712 0 : }
9713 :
9714 0 : std::vector<accparser::VarContext *> accparser::Device_type_listContext::var() {
9715 0 : return getRuleContexts<accparser::VarContext>();
9716 : }
9717 :
9718 0 : accparser::VarContext* accparser::Device_type_listContext::var(size_t i) {
9719 0 : return getRuleContext<accparser::VarContext>(i);
9720 : }
9721 :
9722 0 : std::vector<tree::TerminalNode *> accparser::Device_type_listContext::COMMA() {
9723 0 : return getTokens(accparser::COMMA);
9724 : }
9725 :
9726 0 : tree::TerminalNode* accparser::Device_type_listContext::COMMA(size_t i) {
9727 0 : return getToken(accparser::COMMA, i);
9728 : }
9729 :
9730 :
9731 0 : size_t accparser::Device_type_listContext::getRuleIndex() const {
9732 0 : return accparser::RuleDevice_type_list;
9733 : }
9734 :
9735 0 : void accparser::Device_type_listContext::enterRule(tree::ParseTreeListener *listener) {
9736 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9737 0 : if (parserListener != nullptr)
9738 0 : parserListener->enterDevice_type_list(this);
9739 0 : }
9740 :
9741 0 : void accparser::Device_type_listContext::exitRule(tree::ParseTreeListener *listener) {
9742 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9743 0 : if (parserListener != nullptr)
9744 0 : parserListener->exitDevice_type_list(this);
9745 0 : }
9746 :
9747 :
9748 0 : antlrcpp::Any accparser::Device_type_listContext::accept(tree::ParseTreeVisitor *visitor) {
9749 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9750 0 : return parserVisitor->visitDevice_type_list(this);
9751 : else
9752 0 : return visitor->visitChildren(this);
9753 : }
9754 :
9755 0 : accparser::Device_type_listContext* accparser::device_type_list() {
9756 0 : Device_type_listContext *_localctx = _tracker.createInstance<Device_type_listContext>(_ctx, getState());
9757 0 : enterRule(_localctx, 204, accparser::RuleDevice_type_list);
9758 0 : size_t _la = 0;
9759 :
9760 0 : auto onExit = finally([=] {
9761 0 : exitRule();
9762 0 : });
9763 0 : try {
9764 0 : enterOuterAlt(_localctx, 1);
9765 0 : setState(965);
9766 0 : _errHandler->sync(this);
9767 0 : _la = _input->LA(1);
9768 0 : do {
9769 0 : setState(965);
9770 0 : _errHandler->sync(this);
9771 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
9772 0 : case 1: {
9773 0 : setState(961);
9774 0 : var();
9775 0 : setState(962);
9776 0 : match(accparser::COMMA);
9777 : break;
9778 : }
9779 :
9780 0 : case 2: {
9781 0 : setState(964);
9782 0 : var();
9783 : break;
9784 : }
9785 :
9786 : }
9787 0 : setState(967);
9788 0 : _errHandler->sync(this);
9789 0 : _la = _input->LA(1);
9790 0 : } while (_la == accparser::EXPR);
9791 :
9792 : }
9793 0 : catch (RecognitionException &e) {
9794 0 : _errHandler->reportError(this, e);
9795 0 : _localctx->exception = std::current_exception();
9796 0 : _errHandler->recover(this, _localctx->exception);
9797 : }
9798 :
9799 0 : return _localctx;
9800 : }
9801 :
9802 : //----------------- Deviceptr_clauseContext ------------------------------------------------------------------
9803 :
9804 0 : accparser::Deviceptr_clauseContext::Deviceptr_clauseContext(ParserRuleContext *parent, size_t invokingState)
9805 0 : : ParserRuleContext(parent, invokingState) {
9806 0 : }
9807 :
9808 0 : tree::TerminalNode* accparser::Deviceptr_clauseContext::DEVICEPTR() {
9809 0 : return getToken(accparser::DEVICEPTR, 0);
9810 : }
9811 :
9812 0 : tree::TerminalNode* accparser::Deviceptr_clauseContext::LEFT_PAREN() {
9813 0 : return getToken(accparser::LEFT_PAREN, 0);
9814 : }
9815 :
9816 0 : accparser::Var_listContext* accparser::Deviceptr_clauseContext::var_list() {
9817 0 : return getRuleContext<accparser::Var_listContext>(0);
9818 : }
9819 :
9820 0 : tree::TerminalNode* accparser::Deviceptr_clauseContext::RIGHT_PAREN() {
9821 0 : return getToken(accparser::RIGHT_PAREN, 0);
9822 : }
9823 :
9824 :
9825 0 : size_t accparser::Deviceptr_clauseContext::getRuleIndex() const {
9826 0 : return accparser::RuleDeviceptr_clause;
9827 : }
9828 :
9829 0 : void accparser::Deviceptr_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9830 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9831 0 : if (parserListener != nullptr)
9832 0 : parserListener->enterDeviceptr_clause(this);
9833 0 : }
9834 :
9835 0 : void accparser::Deviceptr_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9836 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9837 0 : if (parserListener != nullptr)
9838 0 : parserListener->exitDeviceptr_clause(this);
9839 0 : }
9840 :
9841 :
9842 0 : antlrcpp::Any accparser::Deviceptr_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9843 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9844 0 : return parserVisitor->visitDeviceptr_clause(this);
9845 : else
9846 0 : return visitor->visitChildren(this);
9847 : }
9848 :
9849 0 : accparser::Deviceptr_clauseContext* accparser::deviceptr_clause() {
9850 0 : Deviceptr_clauseContext *_localctx = _tracker.createInstance<Deviceptr_clauseContext>(_ctx, getState());
9851 0 : enterRule(_localctx, 206, accparser::RuleDeviceptr_clause);
9852 :
9853 0 : auto onExit = finally([=] {
9854 0 : exitRule();
9855 0 : });
9856 0 : try {
9857 0 : enterOuterAlt(_localctx, 1);
9858 0 : setState(969);
9859 0 : match(accparser::DEVICEPTR);
9860 0 : setState(970);
9861 0 : match(accparser::LEFT_PAREN);
9862 0 : setState(971);
9863 0 : var_list();
9864 0 : setState(972);
9865 0 : match(accparser::RIGHT_PAREN);
9866 :
9867 : }
9868 0 : catch (RecognitionException &e) {
9869 0 : _errHandler->reportError(this, e);
9870 0 : _localctx->exception = std::current_exception();
9871 0 : _errHandler->recover(this, _localctx->exception);
9872 : }
9873 :
9874 0 : return _localctx;
9875 : }
9876 :
9877 : //----------------- Finalize_clauseContext ------------------------------------------------------------------
9878 :
9879 0 : accparser::Finalize_clauseContext::Finalize_clauseContext(ParserRuleContext *parent, size_t invokingState)
9880 0 : : ParserRuleContext(parent, invokingState) {
9881 0 : }
9882 :
9883 0 : tree::TerminalNode* accparser::Finalize_clauseContext::FINALIZE() {
9884 0 : return getToken(accparser::FINALIZE, 0);
9885 : }
9886 :
9887 :
9888 0 : size_t accparser::Finalize_clauseContext::getRuleIndex() const {
9889 0 : return accparser::RuleFinalize_clause;
9890 : }
9891 :
9892 0 : void accparser::Finalize_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9893 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9894 0 : if (parserListener != nullptr)
9895 0 : parserListener->enterFinalize_clause(this);
9896 0 : }
9897 :
9898 0 : void accparser::Finalize_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9899 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9900 0 : if (parserListener != nullptr)
9901 0 : parserListener->exitFinalize_clause(this);
9902 0 : }
9903 :
9904 :
9905 0 : antlrcpp::Any accparser::Finalize_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9906 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9907 0 : return parserVisitor->visitFinalize_clause(this);
9908 : else
9909 0 : return visitor->visitChildren(this);
9910 : }
9911 :
9912 0 : accparser::Finalize_clauseContext* accparser::finalize_clause() {
9913 0 : Finalize_clauseContext *_localctx = _tracker.createInstance<Finalize_clauseContext>(_ctx, getState());
9914 0 : enterRule(_localctx, 208, accparser::RuleFinalize_clause);
9915 :
9916 0 : auto onExit = finally([=] {
9917 0 : exitRule();
9918 0 : });
9919 0 : try {
9920 0 : enterOuterAlt(_localctx, 1);
9921 0 : setState(974);
9922 0 : match(accparser::FINALIZE);
9923 :
9924 : }
9925 0 : catch (RecognitionException &e) {
9926 0 : _errHandler->reportError(this, e);
9927 0 : _localctx->exception = std::current_exception();
9928 0 : _errHandler->recover(this, _localctx->exception);
9929 : }
9930 :
9931 0 : return _localctx;
9932 : }
9933 :
9934 : //----------------- Firstprivate_clauseContext ------------------------------------------------------------------
9935 :
9936 0 : accparser::Firstprivate_clauseContext::Firstprivate_clauseContext(ParserRuleContext *parent, size_t invokingState)
9937 0 : : ParserRuleContext(parent, invokingState) {
9938 0 : }
9939 :
9940 0 : tree::TerminalNode* accparser::Firstprivate_clauseContext::FIRSTPRIVATE() {
9941 0 : return getToken(accparser::FIRSTPRIVATE, 0);
9942 : }
9943 :
9944 0 : tree::TerminalNode* accparser::Firstprivate_clauseContext::LEFT_PAREN() {
9945 0 : return getToken(accparser::LEFT_PAREN, 0);
9946 : }
9947 :
9948 0 : accparser::Var_listContext* accparser::Firstprivate_clauseContext::var_list() {
9949 0 : return getRuleContext<accparser::Var_listContext>(0);
9950 : }
9951 :
9952 0 : tree::TerminalNode* accparser::Firstprivate_clauseContext::RIGHT_PAREN() {
9953 0 : return getToken(accparser::RIGHT_PAREN, 0);
9954 : }
9955 :
9956 :
9957 0 : size_t accparser::Firstprivate_clauseContext::getRuleIndex() const {
9958 0 : return accparser::RuleFirstprivate_clause;
9959 : }
9960 :
9961 0 : void accparser::Firstprivate_clauseContext::enterRule(tree::ParseTreeListener *listener) {
9962 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9963 0 : if (parserListener != nullptr)
9964 0 : parserListener->enterFirstprivate_clause(this);
9965 0 : }
9966 :
9967 0 : void accparser::Firstprivate_clauseContext::exitRule(tree::ParseTreeListener *listener) {
9968 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
9969 0 : if (parserListener != nullptr)
9970 0 : parserListener->exitFirstprivate_clause(this);
9971 0 : }
9972 :
9973 :
9974 0 : antlrcpp::Any accparser::Firstprivate_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
9975 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
9976 0 : return parserVisitor->visitFirstprivate_clause(this);
9977 : else
9978 0 : return visitor->visitChildren(this);
9979 : }
9980 :
9981 0 : accparser::Firstprivate_clauseContext* accparser::firstprivate_clause() {
9982 0 : Firstprivate_clauseContext *_localctx = _tracker.createInstance<Firstprivate_clauseContext>(_ctx, getState());
9983 0 : enterRule(_localctx, 210, accparser::RuleFirstprivate_clause);
9984 :
9985 0 : auto onExit = finally([=] {
9986 0 : exitRule();
9987 0 : });
9988 0 : try {
9989 0 : enterOuterAlt(_localctx, 1);
9990 0 : setState(976);
9991 0 : match(accparser::FIRSTPRIVATE);
9992 0 : setState(977);
9993 0 : match(accparser::LEFT_PAREN);
9994 0 : setState(978);
9995 0 : var_list();
9996 0 : setState(979);
9997 0 : match(accparser::RIGHT_PAREN);
9998 :
9999 : }
10000 0 : catch (RecognitionException &e) {
10001 0 : _errHandler->reportError(this, e);
10002 0 : _localctx->exception = std::current_exception();
10003 0 : _errHandler->recover(this, _localctx->exception);
10004 : }
10005 :
10006 0 : return _localctx;
10007 : }
10008 :
10009 : //----------------- Gang_clauseContext ------------------------------------------------------------------
10010 :
10011 0 : accparser::Gang_clauseContext::Gang_clauseContext(ParserRuleContext *parent, size_t invokingState)
10012 0 : : ParserRuleContext(parent, invokingState) {
10013 0 : }
10014 :
10015 0 : tree::TerminalNode* accparser::Gang_clauseContext::GANG() {
10016 0 : return getToken(accparser::GANG, 0);
10017 : }
10018 :
10019 0 : tree::TerminalNode* accparser::Gang_clauseContext::LEFT_PAREN() {
10020 0 : return getToken(accparser::LEFT_PAREN, 0);
10021 : }
10022 :
10023 0 : accparser::Gang_arg_listContext* accparser::Gang_clauseContext::gang_arg_list() {
10024 0 : return getRuleContext<accparser::Gang_arg_listContext>(0);
10025 : }
10026 :
10027 0 : tree::TerminalNode* accparser::Gang_clauseContext::RIGHT_PAREN() {
10028 0 : return getToken(accparser::RIGHT_PAREN, 0);
10029 : }
10030 :
10031 :
10032 0 : size_t accparser::Gang_clauseContext::getRuleIndex() const {
10033 0 : return accparser::RuleGang_clause;
10034 : }
10035 :
10036 0 : void accparser::Gang_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10037 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10038 0 : if (parserListener != nullptr)
10039 0 : parserListener->enterGang_clause(this);
10040 0 : }
10041 :
10042 0 : void accparser::Gang_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10043 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10044 0 : if (parserListener != nullptr)
10045 0 : parserListener->exitGang_clause(this);
10046 0 : }
10047 :
10048 :
10049 0 : antlrcpp::Any accparser::Gang_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10050 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10051 0 : return parserVisitor->visitGang_clause(this);
10052 : else
10053 0 : return visitor->visitChildren(this);
10054 : }
10055 :
10056 0 : accparser::Gang_clauseContext* accparser::gang_clause() {
10057 0 : Gang_clauseContext *_localctx = _tracker.createInstance<Gang_clauseContext>(_ctx, getState());
10058 0 : enterRule(_localctx, 212, accparser::RuleGang_clause);
10059 :
10060 0 : auto onExit = finally([=] {
10061 0 : exitRule();
10062 0 : });
10063 0 : try {
10064 0 : setState(987);
10065 0 : _errHandler->sync(this);
10066 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 50, _ctx)) {
10067 0 : case 1: {
10068 0 : enterOuterAlt(_localctx, 1);
10069 0 : setState(981);
10070 0 : match(accparser::GANG);
10071 : break;
10072 : }
10073 :
10074 0 : case 2: {
10075 0 : enterOuterAlt(_localctx, 2);
10076 0 : setState(982);
10077 0 : match(accparser::GANG);
10078 0 : setState(983);
10079 0 : match(accparser::LEFT_PAREN);
10080 0 : setState(984);
10081 0 : gang_arg_list();
10082 0 : setState(985);
10083 0 : match(accparser::RIGHT_PAREN);
10084 : break;
10085 : }
10086 :
10087 : }
10088 :
10089 : }
10090 0 : catch (RecognitionException &e) {
10091 0 : _errHandler->reportError(this, e);
10092 0 : _localctx->exception = std::current_exception();
10093 0 : _errHandler->recover(this, _localctx->exception);
10094 : }
10095 :
10096 0 : return _localctx;
10097 : }
10098 :
10099 : //----------------- Gang_arg_listContext ------------------------------------------------------------------
10100 :
10101 0 : accparser::Gang_arg_listContext::Gang_arg_listContext(ParserRuleContext *parent, size_t invokingState)
10102 0 : : ParserRuleContext(parent, invokingState) {
10103 0 : }
10104 :
10105 0 : std::vector<accparser::VarContext *> accparser::Gang_arg_listContext::var() {
10106 0 : return getRuleContexts<accparser::VarContext>();
10107 : }
10108 :
10109 0 : accparser::VarContext* accparser::Gang_arg_listContext::var(size_t i) {
10110 0 : return getRuleContext<accparser::VarContext>(i);
10111 : }
10112 :
10113 0 : std::vector<tree::TerminalNode *> accparser::Gang_arg_listContext::COMMA() {
10114 0 : return getTokens(accparser::COMMA);
10115 : }
10116 :
10117 0 : tree::TerminalNode* accparser::Gang_arg_listContext::COMMA(size_t i) {
10118 0 : return getToken(accparser::COMMA, i);
10119 : }
10120 :
10121 :
10122 0 : size_t accparser::Gang_arg_listContext::getRuleIndex() const {
10123 0 : return accparser::RuleGang_arg_list;
10124 : }
10125 :
10126 0 : void accparser::Gang_arg_listContext::enterRule(tree::ParseTreeListener *listener) {
10127 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10128 0 : if (parserListener != nullptr)
10129 0 : parserListener->enterGang_arg_list(this);
10130 0 : }
10131 :
10132 0 : void accparser::Gang_arg_listContext::exitRule(tree::ParseTreeListener *listener) {
10133 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10134 0 : if (parserListener != nullptr)
10135 0 : parserListener->exitGang_arg_list(this);
10136 0 : }
10137 :
10138 :
10139 0 : antlrcpp::Any accparser::Gang_arg_listContext::accept(tree::ParseTreeVisitor *visitor) {
10140 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10141 0 : return parserVisitor->visitGang_arg_list(this);
10142 : else
10143 0 : return visitor->visitChildren(this);
10144 : }
10145 :
10146 0 : accparser::Gang_arg_listContext* accparser::gang_arg_list() {
10147 0 : Gang_arg_listContext *_localctx = _tracker.createInstance<Gang_arg_listContext>(_ctx, getState());
10148 0 : enterRule(_localctx, 214, accparser::RuleGang_arg_list);
10149 0 : size_t _la = 0;
10150 :
10151 0 : auto onExit = finally([=] {
10152 0 : exitRule();
10153 0 : });
10154 0 : try {
10155 0 : enterOuterAlt(_localctx, 1);
10156 0 : setState(993);
10157 0 : _errHandler->sync(this);
10158 0 : _la = _input->LA(1);
10159 0 : do {
10160 0 : setState(993);
10161 0 : _errHandler->sync(this);
10162 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx)) {
10163 0 : case 1: {
10164 0 : setState(989);
10165 0 : var();
10166 0 : setState(990);
10167 0 : match(accparser::COMMA);
10168 : break;
10169 : }
10170 :
10171 0 : case 2: {
10172 0 : setState(992);
10173 0 : var();
10174 : break;
10175 : }
10176 :
10177 : }
10178 0 : setState(995);
10179 0 : _errHandler->sync(this);
10180 0 : _la = _input->LA(1);
10181 0 : } while (_la == accparser::EXPR);
10182 :
10183 : }
10184 0 : catch (RecognitionException &e) {
10185 0 : _errHandler->reportError(this, e);
10186 0 : _localctx->exception = std::current_exception();
10187 0 : _errHandler->recover(this, _localctx->exception);
10188 : }
10189 :
10190 0 : return _localctx;
10191 : }
10192 :
10193 : //----------------- Gang_no_list_clauseContext ------------------------------------------------------------------
10194 :
10195 0 : accparser::Gang_no_list_clauseContext::Gang_no_list_clauseContext(ParserRuleContext *parent, size_t invokingState)
10196 0 : : ParserRuleContext(parent, invokingState) {
10197 0 : }
10198 :
10199 0 : tree::TerminalNode* accparser::Gang_no_list_clauseContext::GANG() {
10200 0 : return getToken(accparser::GANG, 0);
10201 : }
10202 :
10203 :
10204 0 : size_t accparser::Gang_no_list_clauseContext::getRuleIndex() const {
10205 0 : return accparser::RuleGang_no_list_clause;
10206 : }
10207 :
10208 0 : void accparser::Gang_no_list_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10209 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10210 0 : if (parserListener != nullptr)
10211 0 : parserListener->enterGang_no_list_clause(this);
10212 0 : }
10213 :
10214 0 : void accparser::Gang_no_list_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10215 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10216 0 : if (parserListener != nullptr)
10217 0 : parserListener->exitGang_no_list_clause(this);
10218 0 : }
10219 :
10220 :
10221 0 : antlrcpp::Any accparser::Gang_no_list_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10222 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10223 0 : return parserVisitor->visitGang_no_list_clause(this);
10224 : else
10225 0 : return visitor->visitChildren(this);
10226 : }
10227 :
10228 0 : accparser::Gang_no_list_clauseContext* accparser::gang_no_list_clause() {
10229 0 : Gang_no_list_clauseContext *_localctx = _tracker.createInstance<Gang_no_list_clauseContext>(_ctx, getState());
10230 0 : enterRule(_localctx, 216, accparser::RuleGang_no_list_clause);
10231 :
10232 0 : auto onExit = finally([=] {
10233 0 : exitRule();
10234 0 : });
10235 0 : try {
10236 0 : enterOuterAlt(_localctx, 1);
10237 0 : setState(997);
10238 0 : match(accparser::GANG);
10239 :
10240 : }
10241 0 : catch (RecognitionException &e) {
10242 0 : _errHandler->reportError(this, e);
10243 0 : _localctx->exception = std::current_exception();
10244 0 : _errHandler->recover(this, _localctx->exception);
10245 : }
10246 :
10247 0 : return _localctx;
10248 : }
10249 :
10250 : //----------------- Host_clauseContext ------------------------------------------------------------------
10251 :
10252 0 : accparser::Host_clauseContext::Host_clauseContext(ParserRuleContext *parent, size_t invokingState)
10253 0 : : ParserRuleContext(parent, invokingState) {
10254 0 : }
10255 :
10256 0 : tree::TerminalNode* accparser::Host_clauseContext::HOST() {
10257 0 : return getToken(accparser::HOST, 0);
10258 : }
10259 :
10260 0 : tree::TerminalNode* accparser::Host_clauseContext::LEFT_PAREN() {
10261 0 : return getToken(accparser::LEFT_PAREN, 0);
10262 : }
10263 :
10264 0 : accparser::Var_listContext* accparser::Host_clauseContext::var_list() {
10265 0 : return getRuleContext<accparser::Var_listContext>(0);
10266 : }
10267 :
10268 0 : tree::TerminalNode* accparser::Host_clauseContext::RIGHT_PAREN() {
10269 0 : return getToken(accparser::RIGHT_PAREN, 0);
10270 : }
10271 :
10272 :
10273 0 : size_t accparser::Host_clauseContext::getRuleIndex() const {
10274 0 : return accparser::RuleHost_clause;
10275 : }
10276 :
10277 0 : void accparser::Host_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10278 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10279 0 : if (parserListener != nullptr)
10280 0 : parserListener->enterHost_clause(this);
10281 0 : }
10282 :
10283 0 : void accparser::Host_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10284 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10285 0 : if (parserListener != nullptr)
10286 0 : parserListener->exitHost_clause(this);
10287 0 : }
10288 :
10289 :
10290 0 : antlrcpp::Any accparser::Host_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10291 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10292 0 : return parserVisitor->visitHost_clause(this);
10293 : else
10294 0 : return visitor->visitChildren(this);
10295 : }
10296 :
10297 0 : accparser::Host_clauseContext* accparser::host_clause() {
10298 0 : Host_clauseContext *_localctx = _tracker.createInstance<Host_clauseContext>(_ctx, getState());
10299 0 : enterRule(_localctx, 218, accparser::RuleHost_clause);
10300 :
10301 0 : auto onExit = finally([=] {
10302 0 : exitRule();
10303 0 : });
10304 0 : try {
10305 0 : enterOuterAlt(_localctx, 1);
10306 0 : setState(999);
10307 0 : match(accparser::HOST);
10308 0 : setState(1000);
10309 0 : match(accparser::LEFT_PAREN);
10310 0 : setState(1001);
10311 0 : var_list();
10312 0 : setState(1002);
10313 0 : match(accparser::RIGHT_PAREN);
10314 :
10315 : }
10316 0 : catch (RecognitionException &e) {
10317 0 : _errHandler->reportError(this, e);
10318 0 : _localctx->exception = std::current_exception();
10319 0 : _errHandler->recover(this, _localctx->exception);
10320 : }
10321 :
10322 0 : return _localctx;
10323 : }
10324 :
10325 : //----------------- If_clauseContext ------------------------------------------------------------------
10326 :
10327 0 : accparser::If_clauseContext::If_clauseContext(ParserRuleContext *parent, size_t invokingState)
10328 0 : : ParserRuleContext(parent, invokingState) {
10329 0 : }
10330 :
10331 0 : tree::TerminalNode* accparser::If_clauseContext::IF() {
10332 0 : return getToken(accparser::IF, 0);
10333 : }
10334 :
10335 0 : tree::TerminalNode* accparser::If_clauseContext::LEFT_PAREN() {
10336 0 : return getToken(accparser::LEFT_PAREN, 0);
10337 : }
10338 :
10339 0 : accparser::ConditionContext* accparser::If_clauseContext::condition() {
10340 0 : return getRuleContext<accparser::ConditionContext>(0);
10341 : }
10342 :
10343 0 : tree::TerminalNode* accparser::If_clauseContext::RIGHT_PAREN() {
10344 0 : return getToken(accparser::RIGHT_PAREN, 0);
10345 : }
10346 :
10347 :
10348 0 : size_t accparser::If_clauseContext::getRuleIndex() const {
10349 0 : return accparser::RuleIf_clause;
10350 : }
10351 :
10352 0 : void accparser::If_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10353 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10354 0 : if (parserListener != nullptr)
10355 0 : parserListener->enterIf_clause(this);
10356 0 : }
10357 :
10358 0 : void accparser::If_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10359 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10360 0 : if (parserListener != nullptr)
10361 0 : parserListener->exitIf_clause(this);
10362 0 : }
10363 :
10364 :
10365 0 : antlrcpp::Any accparser::If_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10366 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10367 0 : return parserVisitor->visitIf_clause(this);
10368 : else
10369 0 : return visitor->visitChildren(this);
10370 : }
10371 :
10372 0 : accparser::If_clauseContext* accparser::if_clause() {
10373 0 : If_clauseContext *_localctx = _tracker.createInstance<If_clauseContext>(_ctx, getState());
10374 0 : enterRule(_localctx, 220, accparser::RuleIf_clause);
10375 :
10376 0 : auto onExit = finally([=] {
10377 0 : exitRule();
10378 0 : });
10379 0 : try {
10380 0 : enterOuterAlt(_localctx, 1);
10381 0 : setState(1004);
10382 0 : match(accparser::IF);
10383 0 : setState(1005);
10384 0 : match(accparser::LEFT_PAREN);
10385 0 : setState(1006);
10386 0 : condition();
10387 0 : setState(1007);
10388 0 : match(accparser::RIGHT_PAREN);
10389 :
10390 : }
10391 0 : catch (RecognitionException &e) {
10392 0 : _errHandler->reportError(this, e);
10393 0 : _localctx->exception = std::current_exception();
10394 0 : _errHandler->recover(this, _localctx->exception);
10395 : }
10396 :
10397 0 : return _localctx;
10398 : }
10399 :
10400 : //----------------- If_present_clauseContext ------------------------------------------------------------------
10401 :
10402 0 : accparser::If_present_clauseContext::If_present_clauseContext(ParserRuleContext *parent, size_t invokingState)
10403 0 : : ParserRuleContext(parent, invokingState) {
10404 0 : }
10405 :
10406 0 : tree::TerminalNode* accparser::If_present_clauseContext::IF_PRESENT() {
10407 0 : return getToken(accparser::IF_PRESENT, 0);
10408 : }
10409 :
10410 :
10411 0 : size_t accparser::If_present_clauseContext::getRuleIndex() const {
10412 0 : return accparser::RuleIf_present_clause;
10413 : }
10414 :
10415 0 : void accparser::If_present_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10416 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10417 0 : if (parserListener != nullptr)
10418 0 : parserListener->enterIf_present_clause(this);
10419 0 : }
10420 :
10421 0 : void accparser::If_present_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10422 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10423 0 : if (parserListener != nullptr)
10424 0 : parserListener->exitIf_present_clause(this);
10425 0 : }
10426 :
10427 :
10428 0 : antlrcpp::Any accparser::If_present_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10429 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10430 0 : return parserVisitor->visitIf_present_clause(this);
10431 : else
10432 0 : return visitor->visitChildren(this);
10433 : }
10434 :
10435 0 : accparser::If_present_clauseContext* accparser::if_present_clause() {
10436 0 : If_present_clauseContext *_localctx = _tracker.createInstance<If_present_clauseContext>(_ctx, getState());
10437 0 : enterRule(_localctx, 222, accparser::RuleIf_present_clause);
10438 :
10439 0 : auto onExit = finally([=] {
10440 0 : exitRule();
10441 0 : });
10442 0 : try {
10443 0 : enterOuterAlt(_localctx, 1);
10444 0 : setState(1009);
10445 0 : match(accparser::IF_PRESENT);
10446 :
10447 : }
10448 0 : catch (RecognitionException &e) {
10449 0 : _errHandler->reportError(this, e);
10450 0 : _localctx->exception = std::current_exception();
10451 0 : _errHandler->recover(this, _localctx->exception);
10452 : }
10453 :
10454 0 : return _localctx;
10455 : }
10456 :
10457 : //----------------- Independent_clauseContext ------------------------------------------------------------------
10458 :
10459 0 : accparser::Independent_clauseContext::Independent_clauseContext(ParserRuleContext *parent, size_t invokingState)
10460 0 : : ParserRuleContext(parent, invokingState) {
10461 0 : }
10462 :
10463 0 : tree::TerminalNode* accparser::Independent_clauseContext::INDEPENDENT() {
10464 0 : return getToken(accparser::INDEPENDENT, 0);
10465 : }
10466 :
10467 :
10468 0 : size_t accparser::Independent_clauseContext::getRuleIndex() const {
10469 0 : return accparser::RuleIndependent_clause;
10470 : }
10471 :
10472 0 : void accparser::Independent_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10473 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10474 0 : if (parserListener != nullptr)
10475 0 : parserListener->enterIndependent_clause(this);
10476 0 : }
10477 :
10478 0 : void accparser::Independent_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10479 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10480 0 : if (parserListener != nullptr)
10481 0 : parserListener->exitIndependent_clause(this);
10482 0 : }
10483 :
10484 :
10485 0 : antlrcpp::Any accparser::Independent_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10486 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10487 0 : return parserVisitor->visitIndependent_clause(this);
10488 : else
10489 0 : return visitor->visitChildren(this);
10490 : }
10491 :
10492 0 : accparser::Independent_clauseContext* accparser::independent_clause() {
10493 0 : Independent_clauseContext *_localctx = _tracker.createInstance<Independent_clauseContext>(_ctx, getState());
10494 0 : enterRule(_localctx, 224, accparser::RuleIndependent_clause);
10495 :
10496 0 : auto onExit = finally([=] {
10497 0 : exitRule();
10498 0 : });
10499 0 : try {
10500 0 : enterOuterAlt(_localctx, 1);
10501 0 : setState(1011);
10502 0 : match(accparser::INDEPENDENT);
10503 :
10504 : }
10505 0 : catch (RecognitionException &e) {
10506 0 : _errHandler->reportError(this, e);
10507 0 : _localctx->exception = std::current_exception();
10508 0 : _errHandler->recover(this, _localctx->exception);
10509 : }
10510 :
10511 0 : return _localctx;
10512 : }
10513 :
10514 : //----------------- Link_clauseContext ------------------------------------------------------------------
10515 :
10516 0 : accparser::Link_clauseContext::Link_clauseContext(ParserRuleContext *parent, size_t invokingState)
10517 0 : : ParserRuleContext(parent, invokingState) {
10518 0 : }
10519 :
10520 0 : tree::TerminalNode* accparser::Link_clauseContext::LINK() {
10521 0 : return getToken(accparser::LINK, 0);
10522 : }
10523 :
10524 0 : tree::TerminalNode* accparser::Link_clauseContext::LEFT_PAREN() {
10525 0 : return getToken(accparser::LEFT_PAREN, 0);
10526 : }
10527 :
10528 0 : accparser::Var_listContext* accparser::Link_clauseContext::var_list() {
10529 0 : return getRuleContext<accparser::Var_listContext>(0);
10530 : }
10531 :
10532 0 : tree::TerminalNode* accparser::Link_clauseContext::RIGHT_PAREN() {
10533 0 : return getToken(accparser::RIGHT_PAREN, 0);
10534 : }
10535 :
10536 :
10537 0 : size_t accparser::Link_clauseContext::getRuleIndex() const {
10538 0 : return accparser::RuleLink_clause;
10539 : }
10540 :
10541 0 : void accparser::Link_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10542 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10543 0 : if (parserListener != nullptr)
10544 0 : parserListener->enterLink_clause(this);
10545 0 : }
10546 :
10547 0 : void accparser::Link_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10548 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10549 0 : if (parserListener != nullptr)
10550 0 : parserListener->exitLink_clause(this);
10551 0 : }
10552 :
10553 :
10554 0 : antlrcpp::Any accparser::Link_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10555 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10556 0 : return parserVisitor->visitLink_clause(this);
10557 : else
10558 0 : return visitor->visitChildren(this);
10559 : }
10560 :
10561 0 : accparser::Link_clauseContext* accparser::link_clause() {
10562 0 : Link_clauseContext *_localctx = _tracker.createInstance<Link_clauseContext>(_ctx, getState());
10563 0 : enterRule(_localctx, 226, accparser::RuleLink_clause);
10564 :
10565 0 : auto onExit = finally([=] {
10566 0 : exitRule();
10567 0 : });
10568 0 : try {
10569 0 : enterOuterAlt(_localctx, 1);
10570 0 : setState(1013);
10571 0 : match(accparser::LINK);
10572 0 : setState(1014);
10573 0 : match(accparser::LEFT_PAREN);
10574 0 : setState(1015);
10575 0 : var_list();
10576 0 : setState(1016);
10577 0 : match(accparser::RIGHT_PAREN);
10578 :
10579 : }
10580 0 : catch (RecognitionException &e) {
10581 0 : _errHandler->reportError(this, e);
10582 0 : _localctx->exception = std::current_exception();
10583 0 : _errHandler->recover(this, _localctx->exception);
10584 : }
10585 :
10586 0 : return _localctx;
10587 : }
10588 :
10589 : //----------------- Nohost_clauseContext ------------------------------------------------------------------
10590 :
10591 0 : accparser::Nohost_clauseContext::Nohost_clauseContext(ParserRuleContext *parent, size_t invokingState)
10592 0 : : ParserRuleContext(parent, invokingState) {
10593 0 : }
10594 :
10595 0 : tree::TerminalNode* accparser::Nohost_clauseContext::NOHOST() {
10596 0 : return getToken(accparser::NOHOST, 0);
10597 : }
10598 :
10599 :
10600 0 : size_t accparser::Nohost_clauseContext::getRuleIndex() const {
10601 0 : return accparser::RuleNohost_clause;
10602 : }
10603 :
10604 0 : void accparser::Nohost_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10605 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10606 0 : if (parserListener != nullptr)
10607 0 : parserListener->enterNohost_clause(this);
10608 0 : }
10609 :
10610 0 : void accparser::Nohost_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10611 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10612 0 : if (parserListener != nullptr)
10613 0 : parserListener->exitNohost_clause(this);
10614 0 : }
10615 :
10616 :
10617 0 : antlrcpp::Any accparser::Nohost_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10618 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10619 0 : return parserVisitor->visitNohost_clause(this);
10620 : else
10621 0 : return visitor->visitChildren(this);
10622 : }
10623 :
10624 0 : accparser::Nohost_clauseContext* accparser::nohost_clause() {
10625 0 : Nohost_clauseContext *_localctx = _tracker.createInstance<Nohost_clauseContext>(_ctx, getState());
10626 0 : enterRule(_localctx, 228, accparser::RuleNohost_clause);
10627 :
10628 0 : auto onExit = finally([=] {
10629 0 : exitRule();
10630 0 : });
10631 0 : try {
10632 0 : enterOuterAlt(_localctx, 1);
10633 0 : setState(1018);
10634 0 : match(accparser::NOHOST);
10635 :
10636 : }
10637 0 : catch (RecognitionException &e) {
10638 0 : _errHandler->reportError(this, e);
10639 0 : _localctx->exception = std::current_exception();
10640 0 : _errHandler->recover(this, _localctx->exception);
10641 : }
10642 :
10643 0 : return _localctx;
10644 : }
10645 :
10646 : //----------------- No_create_clauseContext ------------------------------------------------------------------
10647 :
10648 0 : accparser::No_create_clauseContext::No_create_clauseContext(ParserRuleContext *parent, size_t invokingState)
10649 0 : : ParserRuleContext(parent, invokingState) {
10650 0 : }
10651 :
10652 0 : tree::TerminalNode* accparser::No_create_clauseContext::NO_CREATE() {
10653 0 : return getToken(accparser::NO_CREATE, 0);
10654 : }
10655 :
10656 0 : tree::TerminalNode* accparser::No_create_clauseContext::LEFT_PAREN() {
10657 0 : return getToken(accparser::LEFT_PAREN, 0);
10658 : }
10659 :
10660 0 : accparser::Var_listContext* accparser::No_create_clauseContext::var_list() {
10661 0 : return getRuleContext<accparser::Var_listContext>(0);
10662 : }
10663 :
10664 0 : tree::TerminalNode* accparser::No_create_clauseContext::RIGHT_PAREN() {
10665 0 : return getToken(accparser::RIGHT_PAREN, 0);
10666 : }
10667 :
10668 :
10669 0 : size_t accparser::No_create_clauseContext::getRuleIndex() const {
10670 0 : return accparser::RuleNo_create_clause;
10671 : }
10672 :
10673 0 : void accparser::No_create_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10674 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10675 0 : if (parserListener != nullptr)
10676 0 : parserListener->enterNo_create_clause(this);
10677 0 : }
10678 :
10679 0 : void accparser::No_create_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10680 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10681 0 : if (parserListener != nullptr)
10682 0 : parserListener->exitNo_create_clause(this);
10683 0 : }
10684 :
10685 :
10686 0 : antlrcpp::Any accparser::No_create_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10687 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10688 0 : return parserVisitor->visitNo_create_clause(this);
10689 : else
10690 0 : return visitor->visitChildren(this);
10691 : }
10692 :
10693 0 : accparser::No_create_clauseContext* accparser::no_create_clause() {
10694 0 : No_create_clauseContext *_localctx = _tracker.createInstance<No_create_clauseContext>(_ctx, getState());
10695 0 : enterRule(_localctx, 230, accparser::RuleNo_create_clause);
10696 :
10697 0 : auto onExit = finally([=] {
10698 0 : exitRule();
10699 0 : });
10700 0 : try {
10701 0 : enterOuterAlt(_localctx, 1);
10702 0 : setState(1020);
10703 0 : match(accparser::NO_CREATE);
10704 0 : setState(1021);
10705 0 : match(accparser::LEFT_PAREN);
10706 0 : setState(1022);
10707 0 : var_list();
10708 0 : setState(1023);
10709 0 : match(accparser::RIGHT_PAREN);
10710 :
10711 : }
10712 0 : catch (RecognitionException &e) {
10713 0 : _errHandler->reportError(this, e);
10714 0 : _localctx->exception = std::current_exception();
10715 0 : _errHandler->recover(this, _localctx->exception);
10716 : }
10717 :
10718 0 : return _localctx;
10719 : }
10720 :
10721 : //----------------- Num_gangs_clauseContext ------------------------------------------------------------------
10722 :
10723 0 : accparser::Num_gangs_clauseContext::Num_gangs_clauseContext(ParserRuleContext *parent, size_t invokingState)
10724 0 : : ParserRuleContext(parent, invokingState) {
10725 0 : }
10726 :
10727 0 : tree::TerminalNode* accparser::Num_gangs_clauseContext::NUM_GANGS() {
10728 0 : return getToken(accparser::NUM_GANGS, 0);
10729 : }
10730 :
10731 0 : tree::TerminalNode* accparser::Num_gangs_clauseContext::LEFT_PAREN() {
10732 0 : return getToken(accparser::LEFT_PAREN, 0);
10733 : }
10734 :
10735 0 : accparser::Int_exprContext* accparser::Num_gangs_clauseContext::int_expr() {
10736 0 : return getRuleContext<accparser::Int_exprContext>(0);
10737 : }
10738 :
10739 0 : tree::TerminalNode* accparser::Num_gangs_clauseContext::RIGHT_PAREN() {
10740 0 : return getToken(accparser::RIGHT_PAREN, 0);
10741 : }
10742 :
10743 :
10744 0 : size_t accparser::Num_gangs_clauseContext::getRuleIndex() const {
10745 0 : return accparser::RuleNum_gangs_clause;
10746 : }
10747 :
10748 0 : void accparser::Num_gangs_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10749 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10750 0 : if (parserListener != nullptr)
10751 0 : parserListener->enterNum_gangs_clause(this);
10752 0 : }
10753 :
10754 0 : void accparser::Num_gangs_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10755 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10756 0 : if (parserListener != nullptr)
10757 0 : parserListener->exitNum_gangs_clause(this);
10758 0 : }
10759 :
10760 :
10761 0 : antlrcpp::Any accparser::Num_gangs_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10762 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10763 0 : return parserVisitor->visitNum_gangs_clause(this);
10764 : else
10765 0 : return visitor->visitChildren(this);
10766 : }
10767 :
10768 0 : accparser::Num_gangs_clauseContext* accparser::num_gangs_clause() {
10769 0 : Num_gangs_clauseContext *_localctx = _tracker.createInstance<Num_gangs_clauseContext>(_ctx, getState());
10770 0 : enterRule(_localctx, 232, accparser::RuleNum_gangs_clause);
10771 :
10772 0 : auto onExit = finally([=] {
10773 0 : exitRule();
10774 0 : });
10775 0 : try {
10776 0 : enterOuterAlt(_localctx, 1);
10777 0 : setState(1025);
10778 0 : match(accparser::NUM_GANGS);
10779 0 : setState(1026);
10780 0 : match(accparser::LEFT_PAREN);
10781 0 : setState(1027);
10782 0 : int_expr();
10783 0 : setState(1028);
10784 0 : match(accparser::RIGHT_PAREN);
10785 :
10786 : }
10787 0 : catch (RecognitionException &e) {
10788 0 : _errHandler->reportError(this, e);
10789 0 : _localctx->exception = std::current_exception();
10790 0 : _errHandler->recover(this, _localctx->exception);
10791 : }
10792 :
10793 0 : return _localctx;
10794 : }
10795 :
10796 : //----------------- Num_workers_clauseContext ------------------------------------------------------------------
10797 :
10798 0 : accparser::Num_workers_clauseContext::Num_workers_clauseContext(ParserRuleContext *parent, size_t invokingState)
10799 0 : : ParserRuleContext(parent, invokingState) {
10800 0 : }
10801 :
10802 0 : tree::TerminalNode* accparser::Num_workers_clauseContext::NUM_WORKERS() {
10803 0 : return getToken(accparser::NUM_WORKERS, 0);
10804 : }
10805 :
10806 0 : tree::TerminalNode* accparser::Num_workers_clauseContext::LEFT_PAREN() {
10807 0 : return getToken(accparser::LEFT_PAREN, 0);
10808 : }
10809 :
10810 0 : accparser::Int_exprContext* accparser::Num_workers_clauseContext::int_expr() {
10811 0 : return getRuleContext<accparser::Int_exprContext>(0);
10812 : }
10813 :
10814 0 : tree::TerminalNode* accparser::Num_workers_clauseContext::RIGHT_PAREN() {
10815 0 : return getToken(accparser::RIGHT_PAREN, 0);
10816 : }
10817 :
10818 :
10819 0 : size_t accparser::Num_workers_clauseContext::getRuleIndex() const {
10820 0 : return accparser::RuleNum_workers_clause;
10821 : }
10822 :
10823 0 : void accparser::Num_workers_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10824 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10825 0 : if (parserListener != nullptr)
10826 0 : parserListener->enterNum_workers_clause(this);
10827 0 : }
10828 :
10829 0 : void accparser::Num_workers_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10830 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10831 0 : if (parserListener != nullptr)
10832 0 : parserListener->exitNum_workers_clause(this);
10833 0 : }
10834 :
10835 :
10836 0 : antlrcpp::Any accparser::Num_workers_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10837 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10838 0 : return parserVisitor->visitNum_workers_clause(this);
10839 : else
10840 0 : return visitor->visitChildren(this);
10841 : }
10842 :
10843 0 : accparser::Num_workers_clauseContext* accparser::num_workers_clause() {
10844 0 : Num_workers_clauseContext *_localctx = _tracker.createInstance<Num_workers_clauseContext>(_ctx, getState());
10845 0 : enterRule(_localctx, 234, accparser::RuleNum_workers_clause);
10846 :
10847 0 : auto onExit = finally([=] {
10848 0 : exitRule();
10849 0 : });
10850 0 : try {
10851 0 : enterOuterAlt(_localctx, 1);
10852 0 : setState(1030);
10853 0 : match(accparser::NUM_WORKERS);
10854 0 : setState(1031);
10855 0 : match(accparser::LEFT_PAREN);
10856 0 : setState(1032);
10857 0 : int_expr();
10858 0 : setState(1033);
10859 0 : match(accparser::RIGHT_PAREN);
10860 :
10861 : }
10862 0 : catch (RecognitionException &e) {
10863 0 : _errHandler->reportError(this, e);
10864 0 : _localctx->exception = std::current_exception();
10865 0 : _errHandler->recover(this, _localctx->exception);
10866 : }
10867 :
10868 0 : return _localctx;
10869 : }
10870 :
10871 : //----------------- Present_clauseContext ------------------------------------------------------------------
10872 :
10873 0 : accparser::Present_clauseContext::Present_clauseContext(ParserRuleContext *parent, size_t invokingState)
10874 0 : : ParserRuleContext(parent, invokingState) {
10875 0 : }
10876 :
10877 0 : tree::TerminalNode* accparser::Present_clauseContext::PRESENT() {
10878 0 : return getToken(accparser::PRESENT, 0);
10879 : }
10880 :
10881 0 : tree::TerminalNode* accparser::Present_clauseContext::LEFT_PAREN() {
10882 0 : return getToken(accparser::LEFT_PAREN, 0);
10883 : }
10884 :
10885 0 : accparser::Var_listContext* accparser::Present_clauseContext::var_list() {
10886 0 : return getRuleContext<accparser::Var_listContext>(0);
10887 : }
10888 :
10889 0 : tree::TerminalNode* accparser::Present_clauseContext::RIGHT_PAREN() {
10890 0 : return getToken(accparser::RIGHT_PAREN, 0);
10891 : }
10892 :
10893 :
10894 0 : size_t accparser::Present_clauseContext::getRuleIndex() const {
10895 0 : return accparser::RulePresent_clause;
10896 : }
10897 :
10898 0 : void accparser::Present_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10899 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10900 0 : if (parserListener != nullptr)
10901 0 : parserListener->enterPresent_clause(this);
10902 0 : }
10903 :
10904 0 : void accparser::Present_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10905 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10906 0 : if (parserListener != nullptr)
10907 0 : parserListener->exitPresent_clause(this);
10908 0 : }
10909 :
10910 :
10911 0 : antlrcpp::Any accparser::Present_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10912 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10913 0 : return parserVisitor->visitPresent_clause(this);
10914 : else
10915 0 : return visitor->visitChildren(this);
10916 : }
10917 :
10918 0 : accparser::Present_clauseContext* accparser::present_clause() {
10919 0 : Present_clauseContext *_localctx = _tracker.createInstance<Present_clauseContext>(_ctx, getState());
10920 0 : enterRule(_localctx, 236, accparser::RulePresent_clause);
10921 :
10922 0 : auto onExit = finally([=] {
10923 0 : exitRule();
10924 0 : });
10925 0 : try {
10926 0 : enterOuterAlt(_localctx, 1);
10927 0 : setState(1035);
10928 0 : match(accparser::PRESENT);
10929 0 : setState(1036);
10930 0 : match(accparser::LEFT_PAREN);
10931 0 : setState(1037);
10932 0 : var_list();
10933 0 : setState(1038);
10934 0 : match(accparser::RIGHT_PAREN);
10935 :
10936 : }
10937 0 : catch (RecognitionException &e) {
10938 0 : _errHandler->reportError(this, e);
10939 0 : _localctx->exception = std::current_exception();
10940 0 : _errHandler->recover(this, _localctx->exception);
10941 : }
10942 :
10943 0 : return _localctx;
10944 : }
10945 :
10946 : //----------------- Private_clauseContext ------------------------------------------------------------------
10947 :
10948 0 : accparser::Private_clauseContext::Private_clauseContext(ParserRuleContext *parent, size_t invokingState)
10949 0 : : ParserRuleContext(parent, invokingState) {
10950 0 : }
10951 :
10952 0 : tree::TerminalNode* accparser::Private_clauseContext::PRIVATE() {
10953 0 : return getToken(accparser::PRIVATE, 0);
10954 : }
10955 :
10956 0 : tree::TerminalNode* accparser::Private_clauseContext::LEFT_PAREN() {
10957 0 : return getToken(accparser::LEFT_PAREN, 0);
10958 : }
10959 :
10960 0 : accparser::Var_listContext* accparser::Private_clauseContext::var_list() {
10961 0 : return getRuleContext<accparser::Var_listContext>(0);
10962 : }
10963 :
10964 0 : tree::TerminalNode* accparser::Private_clauseContext::RIGHT_PAREN() {
10965 0 : return getToken(accparser::RIGHT_PAREN, 0);
10966 : }
10967 :
10968 :
10969 0 : size_t accparser::Private_clauseContext::getRuleIndex() const {
10970 0 : return accparser::RulePrivate_clause;
10971 : }
10972 :
10973 0 : void accparser::Private_clauseContext::enterRule(tree::ParseTreeListener *listener) {
10974 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10975 0 : if (parserListener != nullptr)
10976 0 : parserListener->enterPrivate_clause(this);
10977 0 : }
10978 :
10979 0 : void accparser::Private_clauseContext::exitRule(tree::ParseTreeListener *listener) {
10980 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
10981 0 : if (parserListener != nullptr)
10982 0 : parserListener->exitPrivate_clause(this);
10983 0 : }
10984 :
10985 :
10986 0 : antlrcpp::Any accparser::Private_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
10987 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
10988 0 : return parserVisitor->visitPrivate_clause(this);
10989 : else
10990 0 : return visitor->visitChildren(this);
10991 : }
10992 :
10993 0 : accparser::Private_clauseContext* accparser::private_clause() {
10994 0 : Private_clauseContext *_localctx = _tracker.createInstance<Private_clauseContext>(_ctx, getState());
10995 0 : enterRule(_localctx, 238, accparser::RulePrivate_clause);
10996 :
10997 0 : auto onExit = finally([=] {
10998 0 : exitRule();
10999 0 : });
11000 0 : try {
11001 0 : enterOuterAlt(_localctx, 1);
11002 0 : setState(1040);
11003 0 : match(accparser::PRIVATE);
11004 0 : setState(1041);
11005 0 : match(accparser::LEFT_PAREN);
11006 0 : setState(1042);
11007 0 : var_list();
11008 0 : setState(1043);
11009 0 : match(accparser::RIGHT_PAREN);
11010 :
11011 : }
11012 0 : catch (RecognitionException &e) {
11013 0 : _errHandler->reportError(this, e);
11014 0 : _localctx->exception = std::current_exception();
11015 0 : _errHandler->recover(this, _localctx->exception);
11016 : }
11017 :
11018 0 : return _localctx;
11019 : }
11020 :
11021 : //----------------- Read_clauseContext ------------------------------------------------------------------
11022 :
11023 0 : accparser::Read_clauseContext::Read_clauseContext(ParserRuleContext *parent, size_t invokingState)
11024 0 : : ParserRuleContext(parent, invokingState) {
11025 0 : }
11026 :
11027 0 : tree::TerminalNode* accparser::Read_clauseContext::READ() {
11028 0 : return getToken(accparser::READ, 0);
11029 : }
11030 :
11031 :
11032 0 : size_t accparser::Read_clauseContext::getRuleIndex() const {
11033 0 : return accparser::RuleRead_clause;
11034 : }
11035 :
11036 0 : void accparser::Read_clauseContext::enterRule(tree::ParseTreeListener *listener) {
11037 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11038 0 : if (parserListener != nullptr)
11039 0 : parserListener->enterRead_clause(this);
11040 0 : }
11041 :
11042 0 : void accparser::Read_clauseContext::exitRule(tree::ParseTreeListener *listener) {
11043 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11044 0 : if (parserListener != nullptr)
11045 0 : parserListener->exitRead_clause(this);
11046 0 : }
11047 :
11048 :
11049 0 : antlrcpp::Any accparser::Read_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
11050 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11051 0 : return parserVisitor->visitRead_clause(this);
11052 : else
11053 0 : return visitor->visitChildren(this);
11054 : }
11055 :
11056 0 : accparser::Read_clauseContext* accparser::read_clause() {
11057 0 : Read_clauseContext *_localctx = _tracker.createInstance<Read_clauseContext>(_ctx, getState());
11058 0 : enterRule(_localctx, 240, accparser::RuleRead_clause);
11059 :
11060 0 : auto onExit = finally([=] {
11061 0 : exitRule();
11062 0 : });
11063 0 : try {
11064 0 : enterOuterAlt(_localctx, 1);
11065 0 : setState(1045);
11066 0 : match(accparser::READ);
11067 :
11068 : }
11069 0 : catch (RecognitionException &e) {
11070 0 : _errHandler->reportError(this, e);
11071 0 : _localctx->exception = std::current_exception();
11072 0 : _errHandler->recover(this, _localctx->exception);
11073 : }
11074 :
11075 0 : return _localctx;
11076 : }
11077 :
11078 : //----------------- Reduction_clauseContext ------------------------------------------------------------------
11079 :
11080 0 : accparser::Reduction_clauseContext::Reduction_clauseContext(ParserRuleContext *parent, size_t invokingState)
11081 0 : : ParserRuleContext(parent, invokingState) {
11082 0 : }
11083 :
11084 0 : tree::TerminalNode* accparser::Reduction_clauseContext::REDUCTION() {
11085 0 : return getToken(accparser::REDUCTION, 0);
11086 : }
11087 :
11088 0 : tree::TerminalNode* accparser::Reduction_clauseContext::LEFT_PAREN() {
11089 0 : return getToken(accparser::LEFT_PAREN, 0);
11090 : }
11091 :
11092 0 : accparser::Reduction_operatorContext* accparser::Reduction_clauseContext::reduction_operator() {
11093 0 : return getRuleContext<accparser::Reduction_operatorContext>(0);
11094 : }
11095 :
11096 0 : tree::TerminalNode* accparser::Reduction_clauseContext::COLON() {
11097 0 : return getToken(accparser::COLON, 0);
11098 : }
11099 :
11100 0 : accparser::Var_listContext* accparser::Reduction_clauseContext::var_list() {
11101 0 : return getRuleContext<accparser::Var_listContext>(0);
11102 : }
11103 :
11104 0 : tree::TerminalNode* accparser::Reduction_clauseContext::RIGHT_PAREN() {
11105 0 : return getToken(accparser::RIGHT_PAREN, 0);
11106 : }
11107 :
11108 :
11109 0 : size_t accparser::Reduction_clauseContext::getRuleIndex() const {
11110 0 : return accparser::RuleReduction_clause;
11111 : }
11112 :
11113 0 : void accparser::Reduction_clauseContext::enterRule(tree::ParseTreeListener *listener) {
11114 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11115 0 : if (parserListener != nullptr)
11116 0 : parserListener->enterReduction_clause(this);
11117 0 : }
11118 :
11119 0 : void accparser::Reduction_clauseContext::exitRule(tree::ParseTreeListener *listener) {
11120 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11121 0 : if (parserListener != nullptr)
11122 0 : parserListener->exitReduction_clause(this);
11123 0 : }
11124 :
11125 :
11126 0 : antlrcpp::Any accparser::Reduction_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
11127 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11128 0 : return parserVisitor->visitReduction_clause(this);
11129 : else
11130 0 : return visitor->visitChildren(this);
11131 : }
11132 :
11133 0 : accparser::Reduction_clauseContext* accparser::reduction_clause() {
11134 0 : Reduction_clauseContext *_localctx = _tracker.createInstance<Reduction_clauseContext>(_ctx, getState());
11135 0 : enterRule(_localctx, 242, accparser::RuleReduction_clause);
11136 :
11137 0 : auto onExit = finally([=] {
11138 0 : exitRule();
11139 0 : });
11140 0 : try {
11141 0 : enterOuterAlt(_localctx, 1);
11142 0 : setState(1047);
11143 0 : match(accparser::REDUCTION);
11144 0 : setState(1048);
11145 0 : match(accparser::LEFT_PAREN);
11146 0 : setState(1049);
11147 0 : reduction_operator();
11148 0 : setState(1050);
11149 0 : match(accparser::COLON);
11150 0 : setState(1051);
11151 0 : var_list();
11152 0 : setState(1052);
11153 0 : match(accparser::RIGHT_PAREN);
11154 :
11155 : }
11156 0 : catch (RecognitionException &e) {
11157 0 : _errHandler->reportError(this, e);
11158 0 : _localctx->exception = std::current_exception();
11159 0 : _errHandler->recover(this, _localctx->exception);
11160 : }
11161 :
11162 0 : return _localctx;
11163 : }
11164 :
11165 : //----------------- Reduction_operatorContext ------------------------------------------------------------------
11166 :
11167 0 : accparser::Reduction_operatorContext::Reduction_operatorContext(ParserRuleContext *parent, size_t invokingState)
11168 0 : : ParserRuleContext(parent, invokingState) {
11169 0 : }
11170 :
11171 0 : tree::TerminalNode* accparser::Reduction_operatorContext::ADD() {
11172 0 : return getToken(accparser::ADD, 0);
11173 : }
11174 :
11175 0 : tree::TerminalNode* accparser::Reduction_operatorContext::MUL() {
11176 0 : return getToken(accparser::MUL, 0);
11177 : }
11178 :
11179 0 : tree::TerminalNode* accparser::Reduction_operatorContext::MAX() {
11180 0 : return getToken(accparser::MAX, 0);
11181 : }
11182 :
11183 0 : tree::TerminalNode* accparser::Reduction_operatorContext::MIN() {
11184 0 : return getToken(accparser::MIN, 0);
11185 : }
11186 :
11187 0 : tree::TerminalNode* accparser::Reduction_operatorContext::BITAND() {
11188 0 : return getToken(accparser::BITAND, 0);
11189 : }
11190 :
11191 0 : tree::TerminalNode* accparser::Reduction_operatorContext::BITOR() {
11192 0 : return getToken(accparser::BITOR, 0);
11193 : }
11194 :
11195 0 : tree::TerminalNode* accparser::Reduction_operatorContext::BITXOR() {
11196 0 : return getToken(accparser::BITXOR, 0);
11197 : }
11198 :
11199 0 : tree::TerminalNode* accparser::Reduction_operatorContext::LOGAND() {
11200 0 : return getToken(accparser::LOGAND, 0);
11201 : }
11202 :
11203 0 : tree::TerminalNode* accparser::Reduction_operatorContext::LOGOR() {
11204 0 : return getToken(accparser::LOGOR, 0);
11205 : }
11206 :
11207 :
11208 0 : size_t accparser::Reduction_operatorContext::getRuleIndex() const {
11209 0 : return accparser::RuleReduction_operator;
11210 : }
11211 :
11212 0 : void accparser::Reduction_operatorContext::enterRule(tree::ParseTreeListener *listener) {
11213 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11214 0 : if (parserListener != nullptr)
11215 0 : parserListener->enterReduction_operator(this);
11216 0 : }
11217 :
11218 0 : void accparser::Reduction_operatorContext::exitRule(tree::ParseTreeListener *listener) {
11219 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11220 0 : if (parserListener != nullptr)
11221 0 : parserListener->exitReduction_operator(this);
11222 0 : }
11223 :
11224 :
11225 0 : antlrcpp::Any accparser::Reduction_operatorContext::accept(tree::ParseTreeVisitor *visitor) {
11226 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11227 0 : return parserVisitor->visitReduction_operator(this);
11228 : else
11229 0 : return visitor->visitChildren(this);
11230 : }
11231 :
11232 0 : accparser::Reduction_operatorContext* accparser::reduction_operator() {
11233 0 : Reduction_operatorContext *_localctx = _tracker.createInstance<Reduction_operatorContext>(_ctx, getState());
11234 0 : enterRule(_localctx, 244, accparser::RuleReduction_operator);
11235 0 : size_t _la = 0;
11236 :
11237 0 : auto onExit = finally([=] {
11238 0 : exitRule();
11239 0 : });
11240 0 : try {
11241 0 : enterOuterAlt(_localctx, 1);
11242 0 : setState(1054);
11243 0 : _la = _input->LA(1);
11244 0 : if (!(((((_la - 109) & ~ 0x3fULL) == 0) &&
11245 0 : ((1ULL << (_la - 109)) & ((1ULL << (accparser::ADD - 109))
11246 : | (1ULL << (accparser::MUL - 109))
11247 : | (1ULL << (accparser::MAX - 109))
11248 : | (1ULL << (accparser::MIN - 109))
11249 : | (1ULL << (accparser::BITAND - 109))
11250 : | (1ULL << (accparser::BITOR - 109))
11251 : | (1ULL << (accparser::BITXOR - 109))
11252 : | (1ULL << (accparser::LOGAND - 109))
11253 0 : | (1ULL << (accparser::LOGOR - 109)))) != 0))) {
11254 0 : _errHandler->recoverInline(this);
11255 : }
11256 : else {
11257 0 : _errHandler->reportMatch(this);
11258 0 : consume();
11259 : }
11260 :
11261 : }
11262 0 : catch (RecognitionException &e) {
11263 0 : _errHandler->reportError(this, e);
11264 0 : _localctx->exception = std::current_exception();
11265 0 : _errHandler->recover(this, _localctx->exception);
11266 : }
11267 :
11268 0 : return _localctx;
11269 : }
11270 :
11271 : //----------------- Self_clauseContext ------------------------------------------------------------------
11272 :
11273 0 : accparser::Self_clauseContext::Self_clauseContext(ParserRuleContext *parent, size_t invokingState)
11274 0 : : ParserRuleContext(parent, invokingState) {
11275 0 : }
11276 :
11277 0 : tree::TerminalNode* accparser::Self_clauseContext::SELF() {
11278 0 : return getToken(accparser::SELF, 0);
11279 : }
11280 :
11281 0 : tree::TerminalNode* accparser::Self_clauseContext::LEFT_PAREN() {
11282 0 : return getToken(accparser::LEFT_PAREN, 0);
11283 : }
11284 :
11285 0 : accparser::ConditionContext* accparser::Self_clauseContext::condition() {
11286 0 : return getRuleContext<accparser::ConditionContext>(0);
11287 : }
11288 :
11289 0 : tree::TerminalNode* accparser::Self_clauseContext::RIGHT_PAREN() {
11290 0 : return getToken(accparser::RIGHT_PAREN, 0);
11291 : }
11292 :
11293 :
11294 0 : size_t accparser::Self_clauseContext::getRuleIndex() const {
11295 0 : return accparser::RuleSelf_clause;
11296 : }
11297 :
11298 0 : void accparser::Self_clauseContext::enterRule(tree::ParseTreeListener *listener) {
11299 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11300 0 : if (parserListener != nullptr)
11301 0 : parserListener->enterSelf_clause(this);
11302 0 : }
11303 :
11304 0 : void accparser::Self_clauseContext::exitRule(tree::ParseTreeListener *listener) {
11305 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11306 0 : if (parserListener != nullptr)
11307 0 : parserListener->exitSelf_clause(this);
11308 0 : }
11309 :
11310 :
11311 0 : antlrcpp::Any accparser::Self_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
11312 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11313 0 : return parserVisitor->visitSelf_clause(this);
11314 : else
11315 0 : return visitor->visitChildren(this);
11316 : }
11317 :
11318 0 : accparser::Self_clauseContext* accparser::self_clause() {
11319 0 : Self_clauseContext *_localctx = _tracker.createInstance<Self_clauseContext>(_ctx, getState());
11320 0 : enterRule(_localctx, 246, accparser::RuleSelf_clause);
11321 :
11322 0 : auto onExit = finally([=] {
11323 0 : exitRule();
11324 0 : });
11325 0 : try {
11326 0 : setState(1062);
11327 0 : _errHandler->sync(this);
11328 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 53, _ctx)) {
11329 0 : case 1: {
11330 0 : enterOuterAlt(_localctx, 1);
11331 0 : setState(1056);
11332 0 : match(accparser::SELF);
11333 : break;
11334 : }
11335 :
11336 0 : case 2: {
11337 0 : enterOuterAlt(_localctx, 2);
11338 0 : setState(1057);
11339 0 : match(accparser::SELF);
11340 0 : setState(1058);
11341 0 : match(accparser::LEFT_PAREN);
11342 0 : setState(1059);
11343 0 : condition();
11344 0 : setState(1060);
11345 0 : match(accparser::RIGHT_PAREN);
11346 : break;
11347 : }
11348 :
11349 : }
11350 :
11351 : }
11352 0 : catch (RecognitionException &e) {
11353 0 : _errHandler->reportError(this, e);
11354 0 : _localctx->exception = std::current_exception();
11355 0 : _errHandler->recover(this, _localctx->exception);
11356 : }
11357 :
11358 0 : return _localctx;
11359 : }
11360 :
11361 : //----------------- Self_list_clauseContext ------------------------------------------------------------------
11362 :
11363 0 : accparser::Self_list_clauseContext::Self_list_clauseContext(ParserRuleContext *parent, size_t invokingState)
11364 0 : : ParserRuleContext(parent, invokingState) {
11365 0 : }
11366 :
11367 0 : tree::TerminalNode* accparser::Self_list_clauseContext::SELF() {
11368 0 : return getToken(accparser::SELF, 0);
11369 : }
11370 :
11371 0 : tree::TerminalNode* accparser::Self_list_clauseContext::LEFT_PAREN() {
11372 0 : return getToken(accparser::LEFT_PAREN, 0);
11373 : }
11374 :
11375 0 : accparser::Var_listContext* accparser::Self_list_clauseContext::var_list() {
11376 0 : return getRuleContext<accparser::Var_listContext>(0);
11377 : }
11378 :
11379 0 : tree::TerminalNode* accparser::Self_list_clauseContext::RIGHT_PAREN() {
11380 0 : return getToken(accparser::RIGHT_PAREN, 0);
11381 : }
11382 :
11383 :
11384 0 : size_t accparser::Self_list_clauseContext::getRuleIndex() const {
11385 0 : return accparser::RuleSelf_list_clause;
11386 : }
11387 :
11388 0 : void accparser::Self_list_clauseContext::enterRule(tree::ParseTreeListener *listener) {
11389 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11390 0 : if (parserListener != nullptr)
11391 0 : parserListener->enterSelf_list_clause(this);
11392 0 : }
11393 :
11394 0 : void accparser::Self_list_clauseContext::exitRule(tree::ParseTreeListener *listener) {
11395 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11396 0 : if (parserListener != nullptr)
11397 0 : parserListener->exitSelf_list_clause(this);
11398 0 : }
11399 :
11400 :
11401 0 : antlrcpp::Any accparser::Self_list_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
11402 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11403 0 : return parserVisitor->visitSelf_list_clause(this);
11404 : else
11405 0 : return visitor->visitChildren(this);
11406 : }
11407 :
11408 0 : accparser::Self_list_clauseContext* accparser::self_list_clause() {
11409 0 : Self_list_clauseContext *_localctx = _tracker.createInstance<Self_list_clauseContext>(_ctx, getState());
11410 0 : enterRule(_localctx, 248, accparser::RuleSelf_list_clause);
11411 :
11412 0 : auto onExit = finally([=] {
11413 0 : exitRule();
11414 0 : });
11415 0 : try {
11416 0 : enterOuterAlt(_localctx, 1);
11417 0 : setState(1064);
11418 0 : match(accparser::SELF);
11419 0 : setState(1065);
11420 0 : match(accparser::LEFT_PAREN);
11421 0 : setState(1066);
11422 0 : var_list();
11423 0 : setState(1067);
11424 0 : match(accparser::RIGHT_PAREN);
11425 :
11426 : }
11427 0 : catch (RecognitionException &e) {
11428 0 : _errHandler->reportError(this, e);
11429 0 : _localctx->exception = std::current_exception();
11430 0 : _errHandler->recover(this, _localctx->exception);
11431 : }
11432 :
11433 0 : return _localctx;
11434 : }
11435 :
11436 : //----------------- ConditionContext ------------------------------------------------------------------
11437 :
11438 0 : accparser::ConditionContext::ConditionContext(ParserRuleContext *parent, size_t invokingState)
11439 0 : : ParserRuleContext(parent, invokingState) {
11440 0 : }
11441 :
11442 0 : tree::TerminalNode* accparser::ConditionContext::EXPR() {
11443 0 : return getToken(accparser::EXPR, 0);
11444 : }
11445 :
11446 :
11447 0 : size_t accparser::ConditionContext::getRuleIndex() const {
11448 0 : return accparser::RuleCondition;
11449 : }
11450 :
11451 0 : void accparser::ConditionContext::enterRule(tree::ParseTreeListener *listener) {
11452 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11453 0 : if (parserListener != nullptr)
11454 0 : parserListener->enterCondition(this);
11455 0 : }
11456 :
11457 0 : void accparser::ConditionContext::exitRule(tree::ParseTreeListener *listener) {
11458 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11459 0 : if (parserListener != nullptr)
11460 0 : parserListener->exitCondition(this);
11461 0 : }
11462 :
11463 :
11464 0 : antlrcpp::Any accparser::ConditionContext::accept(tree::ParseTreeVisitor *visitor) {
11465 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11466 0 : return parserVisitor->visitCondition(this);
11467 : else
11468 0 : return visitor->visitChildren(this);
11469 : }
11470 :
11471 0 : accparser::ConditionContext* accparser::condition() {
11472 0 : ConditionContext *_localctx = _tracker.createInstance<ConditionContext>(_ctx, getState());
11473 0 : enterRule(_localctx, 250, accparser::RuleCondition);
11474 :
11475 0 : auto onExit = finally([=] {
11476 0 : exitRule();
11477 0 : });
11478 0 : try {
11479 0 : enterOuterAlt(_localctx, 1);
11480 0 : setState(1069);
11481 0 : match(accparser::EXPR);
11482 :
11483 : }
11484 0 : catch (RecognitionException &e) {
11485 0 : _errHandler->reportError(this, e);
11486 0 : _localctx->exception = std::current_exception();
11487 0 : _errHandler->recover(this, _localctx->exception);
11488 : }
11489 :
11490 0 : return _localctx;
11491 : }
11492 :
11493 : //----------------- Seq_clauseContext ------------------------------------------------------------------
11494 :
11495 0 : accparser::Seq_clauseContext::Seq_clauseContext(ParserRuleContext *parent, size_t invokingState)
11496 0 : : ParserRuleContext(parent, invokingState) {
11497 0 : }
11498 :
11499 0 : tree::TerminalNode* accparser::Seq_clauseContext::SEQ() {
11500 0 : return getToken(accparser::SEQ, 0);
11501 : }
11502 :
11503 :
11504 0 : size_t accparser::Seq_clauseContext::getRuleIndex() const {
11505 0 : return accparser::RuleSeq_clause;
11506 : }
11507 :
11508 0 : void accparser::Seq_clauseContext::enterRule(tree::ParseTreeListener *listener) {
11509 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11510 0 : if (parserListener != nullptr)
11511 0 : parserListener->enterSeq_clause(this);
11512 0 : }
11513 :
11514 0 : void accparser::Seq_clauseContext::exitRule(tree::ParseTreeListener *listener) {
11515 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11516 0 : if (parserListener != nullptr)
11517 0 : parserListener->exitSeq_clause(this);
11518 0 : }
11519 :
11520 :
11521 0 : antlrcpp::Any accparser::Seq_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
11522 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11523 0 : return parserVisitor->visitSeq_clause(this);
11524 : else
11525 0 : return visitor->visitChildren(this);
11526 : }
11527 :
11528 0 : accparser::Seq_clauseContext* accparser::seq_clause() {
11529 0 : Seq_clauseContext *_localctx = _tracker.createInstance<Seq_clauseContext>(_ctx, getState());
11530 0 : enterRule(_localctx, 252, accparser::RuleSeq_clause);
11531 :
11532 0 : auto onExit = finally([=] {
11533 0 : exitRule();
11534 0 : });
11535 0 : try {
11536 0 : enterOuterAlt(_localctx, 1);
11537 0 : setState(1071);
11538 0 : match(accparser::SEQ);
11539 :
11540 : }
11541 0 : catch (RecognitionException &e) {
11542 0 : _errHandler->reportError(this, e);
11543 0 : _localctx->exception = std::current_exception();
11544 0 : _errHandler->recover(this, _localctx->exception);
11545 : }
11546 :
11547 0 : return _localctx;
11548 : }
11549 :
11550 : //----------------- Tile_clauseContext ------------------------------------------------------------------
11551 :
11552 0 : accparser::Tile_clauseContext::Tile_clauseContext(ParserRuleContext *parent, size_t invokingState)
11553 0 : : ParserRuleContext(parent, invokingState) {
11554 0 : }
11555 :
11556 0 : tree::TerminalNode* accparser::Tile_clauseContext::TILE() {
11557 0 : return getToken(accparser::TILE, 0);
11558 : }
11559 :
11560 0 : tree::TerminalNode* accparser::Tile_clauseContext::LEFT_PAREN() {
11561 0 : return getToken(accparser::LEFT_PAREN, 0);
11562 : }
11563 :
11564 0 : accparser::Size_expr_listContext* accparser::Tile_clauseContext::size_expr_list() {
11565 0 : return getRuleContext<accparser::Size_expr_listContext>(0);
11566 : }
11567 :
11568 0 : tree::TerminalNode* accparser::Tile_clauseContext::RIGHT_PAREN() {
11569 0 : return getToken(accparser::RIGHT_PAREN, 0);
11570 : }
11571 :
11572 :
11573 0 : size_t accparser::Tile_clauseContext::getRuleIndex() const {
11574 0 : return accparser::RuleTile_clause;
11575 : }
11576 :
11577 0 : void accparser::Tile_clauseContext::enterRule(tree::ParseTreeListener *listener) {
11578 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11579 0 : if (parserListener != nullptr)
11580 0 : parserListener->enterTile_clause(this);
11581 0 : }
11582 :
11583 0 : void accparser::Tile_clauseContext::exitRule(tree::ParseTreeListener *listener) {
11584 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11585 0 : if (parserListener != nullptr)
11586 0 : parserListener->exitTile_clause(this);
11587 0 : }
11588 :
11589 :
11590 0 : antlrcpp::Any accparser::Tile_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
11591 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11592 0 : return parserVisitor->visitTile_clause(this);
11593 : else
11594 0 : return visitor->visitChildren(this);
11595 : }
11596 :
11597 0 : accparser::Tile_clauseContext* accparser::tile_clause() {
11598 0 : Tile_clauseContext *_localctx = _tracker.createInstance<Tile_clauseContext>(_ctx, getState());
11599 0 : enterRule(_localctx, 254, accparser::RuleTile_clause);
11600 :
11601 0 : auto onExit = finally([=] {
11602 0 : exitRule();
11603 0 : });
11604 0 : try {
11605 0 : enterOuterAlt(_localctx, 1);
11606 0 : setState(1073);
11607 0 : match(accparser::TILE);
11608 0 : setState(1074);
11609 0 : match(accparser::LEFT_PAREN);
11610 0 : setState(1075);
11611 0 : size_expr_list();
11612 0 : setState(1076);
11613 0 : match(accparser::RIGHT_PAREN);
11614 :
11615 : }
11616 0 : catch (RecognitionException &e) {
11617 0 : _errHandler->reportError(this, e);
11618 0 : _localctx->exception = std::current_exception();
11619 0 : _errHandler->recover(this, _localctx->exception);
11620 : }
11621 :
11622 0 : return _localctx;
11623 : }
11624 :
11625 : //----------------- Update_clauseContext ------------------------------------------------------------------
11626 :
11627 0 : accparser::Update_clauseContext::Update_clauseContext(ParserRuleContext *parent, size_t invokingState)
11628 0 : : ParserRuleContext(parent, invokingState) {
11629 0 : }
11630 :
11631 0 : tree::TerminalNode* accparser::Update_clauseContext::UPDATE() {
11632 0 : return getToken(accparser::UPDATE, 0);
11633 : }
11634 :
11635 :
11636 0 : size_t accparser::Update_clauseContext::getRuleIndex() const {
11637 0 : return accparser::RuleUpdate_clause;
11638 : }
11639 :
11640 0 : void accparser::Update_clauseContext::enterRule(tree::ParseTreeListener *listener) {
11641 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11642 0 : if (parserListener != nullptr)
11643 0 : parserListener->enterUpdate_clause(this);
11644 0 : }
11645 :
11646 0 : void accparser::Update_clauseContext::exitRule(tree::ParseTreeListener *listener) {
11647 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11648 0 : if (parserListener != nullptr)
11649 0 : parserListener->exitUpdate_clause(this);
11650 0 : }
11651 :
11652 :
11653 0 : antlrcpp::Any accparser::Update_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
11654 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11655 0 : return parserVisitor->visitUpdate_clause(this);
11656 : else
11657 0 : return visitor->visitChildren(this);
11658 : }
11659 :
11660 0 : accparser::Update_clauseContext* accparser::update_clause() {
11661 0 : Update_clauseContext *_localctx = _tracker.createInstance<Update_clauseContext>(_ctx, getState());
11662 0 : enterRule(_localctx, 256, accparser::RuleUpdate_clause);
11663 :
11664 0 : auto onExit = finally([=] {
11665 0 : exitRule();
11666 0 : });
11667 0 : try {
11668 0 : enterOuterAlt(_localctx, 1);
11669 0 : setState(1078);
11670 0 : match(accparser::UPDATE);
11671 :
11672 : }
11673 0 : catch (RecognitionException &e) {
11674 0 : _errHandler->reportError(this, e);
11675 0 : _localctx->exception = std::current_exception();
11676 0 : _errHandler->recover(this, _localctx->exception);
11677 : }
11678 :
11679 0 : return _localctx;
11680 : }
11681 :
11682 : //----------------- Size_expr_listContext ------------------------------------------------------------------
11683 :
11684 0 : accparser::Size_expr_listContext::Size_expr_listContext(ParserRuleContext *parent, size_t invokingState)
11685 0 : : ParserRuleContext(parent, invokingState) {
11686 0 : }
11687 :
11688 0 : std::vector<accparser::VarContext *> accparser::Size_expr_listContext::var() {
11689 0 : return getRuleContexts<accparser::VarContext>();
11690 : }
11691 :
11692 0 : accparser::VarContext* accparser::Size_expr_listContext::var(size_t i) {
11693 0 : return getRuleContext<accparser::VarContext>(i);
11694 : }
11695 :
11696 0 : std::vector<tree::TerminalNode *> accparser::Size_expr_listContext::COMMA() {
11697 0 : return getTokens(accparser::COMMA);
11698 : }
11699 :
11700 0 : tree::TerminalNode* accparser::Size_expr_listContext::COMMA(size_t i) {
11701 0 : return getToken(accparser::COMMA, i);
11702 : }
11703 :
11704 :
11705 0 : size_t accparser::Size_expr_listContext::getRuleIndex() const {
11706 0 : return accparser::RuleSize_expr_list;
11707 : }
11708 :
11709 0 : void accparser::Size_expr_listContext::enterRule(tree::ParseTreeListener *listener) {
11710 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11711 0 : if (parserListener != nullptr)
11712 0 : parserListener->enterSize_expr_list(this);
11713 0 : }
11714 :
11715 0 : void accparser::Size_expr_listContext::exitRule(tree::ParseTreeListener *listener) {
11716 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11717 0 : if (parserListener != nullptr)
11718 0 : parserListener->exitSize_expr_list(this);
11719 0 : }
11720 :
11721 :
11722 0 : antlrcpp::Any accparser::Size_expr_listContext::accept(tree::ParseTreeVisitor *visitor) {
11723 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11724 0 : return parserVisitor->visitSize_expr_list(this);
11725 : else
11726 0 : return visitor->visitChildren(this);
11727 : }
11728 :
11729 0 : accparser::Size_expr_listContext* accparser::size_expr_list() {
11730 0 : Size_expr_listContext *_localctx = _tracker.createInstance<Size_expr_listContext>(_ctx, getState());
11731 0 : enterRule(_localctx, 258, accparser::RuleSize_expr_list);
11732 0 : size_t _la = 0;
11733 :
11734 0 : auto onExit = finally([=] {
11735 0 : exitRule();
11736 0 : });
11737 0 : try {
11738 0 : enterOuterAlt(_localctx, 1);
11739 0 : setState(1084);
11740 0 : _errHandler->sync(this);
11741 0 : _la = _input->LA(1);
11742 0 : do {
11743 0 : setState(1084);
11744 0 : _errHandler->sync(this);
11745 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx)) {
11746 0 : case 1: {
11747 0 : setState(1080);
11748 0 : var();
11749 0 : setState(1081);
11750 0 : match(accparser::COMMA);
11751 : break;
11752 : }
11753 :
11754 0 : case 2: {
11755 0 : setState(1083);
11756 0 : var();
11757 : break;
11758 : }
11759 :
11760 : }
11761 0 : setState(1086);
11762 0 : _errHandler->sync(this);
11763 0 : _la = _input->LA(1);
11764 0 : } while (_la == accparser::EXPR);
11765 :
11766 : }
11767 0 : catch (RecognitionException &e) {
11768 0 : _errHandler->reportError(this, e);
11769 0 : _localctx->exception = std::current_exception();
11770 0 : _errHandler->recover(this, _localctx->exception);
11771 : }
11772 :
11773 0 : return _localctx;
11774 : }
11775 :
11776 : //----------------- Use_device_clauseContext ------------------------------------------------------------------
11777 :
11778 0 : accparser::Use_device_clauseContext::Use_device_clauseContext(ParserRuleContext *parent, size_t invokingState)
11779 0 : : ParserRuleContext(parent, invokingState) {
11780 0 : }
11781 :
11782 0 : tree::TerminalNode* accparser::Use_device_clauseContext::USE_DEVICE() {
11783 0 : return getToken(accparser::USE_DEVICE, 0);
11784 : }
11785 :
11786 0 : tree::TerminalNode* accparser::Use_device_clauseContext::LEFT_PAREN() {
11787 0 : return getToken(accparser::LEFT_PAREN, 0);
11788 : }
11789 :
11790 0 : accparser::Var_listContext* accparser::Use_device_clauseContext::var_list() {
11791 0 : return getRuleContext<accparser::Var_listContext>(0);
11792 : }
11793 :
11794 0 : tree::TerminalNode* accparser::Use_device_clauseContext::RIGHT_PAREN() {
11795 0 : return getToken(accparser::RIGHT_PAREN, 0);
11796 : }
11797 :
11798 :
11799 0 : size_t accparser::Use_device_clauseContext::getRuleIndex() const {
11800 0 : return accparser::RuleUse_device_clause;
11801 : }
11802 :
11803 0 : void accparser::Use_device_clauseContext::enterRule(tree::ParseTreeListener *listener) {
11804 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11805 0 : if (parserListener != nullptr)
11806 0 : parserListener->enterUse_device_clause(this);
11807 0 : }
11808 :
11809 0 : void accparser::Use_device_clauseContext::exitRule(tree::ParseTreeListener *listener) {
11810 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11811 0 : if (parserListener != nullptr)
11812 0 : parserListener->exitUse_device_clause(this);
11813 0 : }
11814 :
11815 :
11816 0 : antlrcpp::Any accparser::Use_device_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
11817 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11818 0 : return parserVisitor->visitUse_device_clause(this);
11819 : else
11820 0 : return visitor->visitChildren(this);
11821 : }
11822 :
11823 0 : accparser::Use_device_clauseContext* accparser::use_device_clause() {
11824 0 : Use_device_clauseContext *_localctx = _tracker.createInstance<Use_device_clauseContext>(_ctx, getState());
11825 0 : enterRule(_localctx, 260, accparser::RuleUse_device_clause);
11826 :
11827 0 : auto onExit = finally([=] {
11828 0 : exitRule();
11829 0 : });
11830 0 : try {
11831 0 : enterOuterAlt(_localctx, 1);
11832 0 : setState(1088);
11833 0 : match(accparser::USE_DEVICE);
11834 0 : setState(1089);
11835 0 : match(accparser::LEFT_PAREN);
11836 0 : setState(1090);
11837 0 : var_list();
11838 0 : setState(1091);
11839 0 : match(accparser::RIGHT_PAREN);
11840 :
11841 : }
11842 0 : catch (RecognitionException &e) {
11843 0 : _errHandler->reportError(this, e);
11844 0 : _localctx->exception = std::current_exception();
11845 0 : _errHandler->recover(this, _localctx->exception);
11846 : }
11847 :
11848 0 : return _localctx;
11849 : }
11850 :
11851 : //----------------- Vector_clauseContext ------------------------------------------------------------------
11852 :
11853 0 : accparser::Vector_clauseContext::Vector_clauseContext(ParserRuleContext *parent, size_t invokingState)
11854 0 : : ParserRuleContext(parent, invokingState) {
11855 0 : }
11856 :
11857 0 : tree::TerminalNode* accparser::Vector_clauseContext::VECTOR() {
11858 0 : return getToken(accparser::VECTOR, 0);
11859 : }
11860 :
11861 0 : accparser::Vector_clause_argsContext* accparser::Vector_clauseContext::vector_clause_args() {
11862 0 : return getRuleContext<accparser::Vector_clause_argsContext>(0);
11863 : }
11864 :
11865 :
11866 0 : size_t accparser::Vector_clauseContext::getRuleIndex() const {
11867 0 : return accparser::RuleVector_clause;
11868 : }
11869 :
11870 0 : void accparser::Vector_clauseContext::enterRule(tree::ParseTreeListener *listener) {
11871 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11872 0 : if (parserListener != nullptr)
11873 0 : parserListener->enterVector_clause(this);
11874 0 : }
11875 :
11876 0 : void accparser::Vector_clauseContext::exitRule(tree::ParseTreeListener *listener) {
11877 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11878 0 : if (parserListener != nullptr)
11879 0 : parserListener->exitVector_clause(this);
11880 0 : }
11881 :
11882 :
11883 0 : antlrcpp::Any accparser::Vector_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
11884 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11885 0 : return parserVisitor->visitVector_clause(this);
11886 : else
11887 0 : return visitor->visitChildren(this);
11888 : }
11889 :
11890 0 : accparser::Vector_clauseContext* accparser::vector_clause() {
11891 0 : Vector_clauseContext *_localctx = _tracker.createInstance<Vector_clauseContext>(_ctx, getState());
11892 0 : enterRule(_localctx, 262, accparser::RuleVector_clause);
11893 :
11894 0 : auto onExit = finally([=] {
11895 0 : exitRule();
11896 0 : });
11897 0 : try {
11898 0 : setState(1096);
11899 0 : _errHandler->sync(this);
11900 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 56, _ctx)) {
11901 0 : case 1: {
11902 0 : enterOuterAlt(_localctx, 1);
11903 0 : setState(1093);
11904 0 : match(accparser::VECTOR);
11905 : break;
11906 : }
11907 :
11908 0 : case 2: {
11909 0 : enterOuterAlt(_localctx, 2);
11910 0 : setState(1094);
11911 0 : match(accparser::VECTOR);
11912 0 : setState(1095);
11913 0 : vector_clause_args();
11914 : break;
11915 : }
11916 :
11917 : }
11918 :
11919 : }
11920 0 : catch (RecognitionException &e) {
11921 0 : _errHandler->reportError(this, e);
11922 0 : _localctx->exception = std::current_exception();
11923 0 : _errHandler->recover(this, _localctx->exception);
11924 : }
11925 :
11926 0 : return _localctx;
11927 : }
11928 :
11929 : //----------------- Vector_clause_argsContext ------------------------------------------------------------------
11930 :
11931 0 : accparser::Vector_clause_argsContext::Vector_clause_argsContext(ParserRuleContext *parent, size_t invokingState)
11932 0 : : ParserRuleContext(parent, invokingState) {
11933 0 : }
11934 :
11935 0 : tree::TerminalNode* accparser::Vector_clause_argsContext::LEFT_PAREN() {
11936 0 : return getToken(accparser::LEFT_PAREN, 0);
11937 : }
11938 :
11939 0 : accparser::Vector_clause_modifierContext* accparser::Vector_clause_argsContext::vector_clause_modifier() {
11940 0 : return getRuleContext<accparser::Vector_clause_modifierContext>(0);
11941 : }
11942 :
11943 0 : tree::TerminalNode* accparser::Vector_clause_argsContext::COLON() {
11944 0 : return getToken(accparser::COLON, 0);
11945 : }
11946 :
11947 0 : accparser::Int_exprContext* accparser::Vector_clause_argsContext::int_expr() {
11948 0 : return getRuleContext<accparser::Int_exprContext>(0);
11949 : }
11950 :
11951 0 : tree::TerminalNode* accparser::Vector_clause_argsContext::RIGHT_PAREN() {
11952 0 : return getToken(accparser::RIGHT_PAREN, 0);
11953 : }
11954 :
11955 :
11956 0 : size_t accparser::Vector_clause_argsContext::getRuleIndex() const {
11957 0 : return accparser::RuleVector_clause_args;
11958 : }
11959 :
11960 0 : void accparser::Vector_clause_argsContext::enterRule(tree::ParseTreeListener *listener) {
11961 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11962 0 : if (parserListener != nullptr)
11963 0 : parserListener->enterVector_clause_args(this);
11964 0 : }
11965 :
11966 0 : void accparser::Vector_clause_argsContext::exitRule(tree::ParseTreeListener *listener) {
11967 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
11968 0 : if (parserListener != nullptr)
11969 0 : parserListener->exitVector_clause_args(this);
11970 0 : }
11971 :
11972 :
11973 0 : antlrcpp::Any accparser::Vector_clause_argsContext::accept(tree::ParseTreeVisitor *visitor) {
11974 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
11975 0 : return parserVisitor->visitVector_clause_args(this);
11976 : else
11977 0 : return visitor->visitChildren(this);
11978 : }
11979 :
11980 0 : accparser::Vector_clause_argsContext* accparser::vector_clause_args() {
11981 0 : Vector_clause_argsContext *_localctx = _tracker.createInstance<Vector_clause_argsContext>(_ctx, getState());
11982 0 : enterRule(_localctx, 264, accparser::RuleVector_clause_args);
11983 :
11984 0 : auto onExit = finally([=] {
11985 0 : exitRule();
11986 0 : });
11987 0 : try {
11988 0 : setState(1108);
11989 0 : _errHandler->sync(this);
11990 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 57, _ctx)) {
11991 0 : case 1: {
11992 0 : enterOuterAlt(_localctx, 1);
11993 0 : setState(1098);
11994 0 : match(accparser::LEFT_PAREN);
11995 0 : setState(1099);
11996 0 : vector_clause_modifier();
11997 0 : setState(1100);
11998 0 : match(accparser::COLON);
11999 0 : setState(1101);
12000 0 : int_expr();
12001 0 : setState(1102);
12002 0 : match(accparser::RIGHT_PAREN);
12003 : break;
12004 : }
12005 :
12006 0 : case 2: {
12007 0 : enterOuterAlt(_localctx, 2);
12008 0 : setState(1104);
12009 0 : match(accparser::LEFT_PAREN);
12010 0 : setState(1105);
12011 0 : int_expr();
12012 0 : setState(1106);
12013 0 : match(accparser::RIGHT_PAREN);
12014 : break;
12015 : }
12016 :
12017 : }
12018 :
12019 : }
12020 0 : catch (RecognitionException &e) {
12021 0 : _errHandler->reportError(this, e);
12022 0 : _localctx->exception = std::current_exception();
12023 0 : _errHandler->recover(this, _localctx->exception);
12024 : }
12025 :
12026 0 : return _localctx;
12027 : }
12028 :
12029 : //----------------- Vector_clause_modifierContext ------------------------------------------------------------------
12030 :
12031 0 : accparser::Vector_clause_modifierContext::Vector_clause_modifierContext(ParserRuleContext *parent, size_t invokingState)
12032 0 : : ParserRuleContext(parent, invokingState) {
12033 0 : }
12034 :
12035 0 : tree::TerminalNode* accparser::Vector_clause_modifierContext::LENGTH() {
12036 0 : return getToken(accparser::LENGTH, 0);
12037 : }
12038 :
12039 :
12040 0 : size_t accparser::Vector_clause_modifierContext::getRuleIndex() const {
12041 0 : return accparser::RuleVector_clause_modifier;
12042 : }
12043 :
12044 0 : void accparser::Vector_clause_modifierContext::enterRule(tree::ParseTreeListener *listener) {
12045 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12046 0 : if (parserListener != nullptr)
12047 0 : parserListener->enterVector_clause_modifier(this);
12048 0 : }
12049 :
12050 0 : void accparser::Vector_clause_modifierContext::exitRule(tree::ParseTreeListener *listener) {
12051 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12052 0 : if (parserListener != nullptr)
12053 0 : parserListener->exitVector_clause_modifier(this);
12054 0 : }
12055 :
12056 :
12057 0 : antlrcpp::Any accparser::Vector_clause_modifierContext::accept(tree::ParseTreeVisitor *visitor) {
12058 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12059 0 : return parserVisitor->visitVector_clause_modifier(this);
12060 : else
12061 0 : return visitor->visitChildren(this);
12062 : }
12063 :
12064 0 : accparser::Vector_clause_modifierContext* accparser::vector_clause_modifier() {
12065 0 : Vector_clause_modifierContext *_localctx = _tracker.createInstance<Vector_clause_modifierContext>(_ctx, getState());
12066 0 : enterRule(_localctx, 266, accparser::RuleVector_clause_modifier);
12067 :
12068 0 : auto onExit = finally([=] {
12069 0 : exitRule();
12070 0 : });
12071 0 : try {
12072 0 : enterOuterAlt(_localctx, 1);
12073 0 : setState(1110);
12074 0 : match(accparser::LENGTH);
12075 :
12076 : }
12077 0 : catch (RecognitionException &e) {
12078 0 : _errHandler->reportError(this, e);
12079 0 : _localctx->exception = std::current_exception();
12080 0 : _errHandler->recover(this, _localctx->exception);
12081 : }
12082 :
12083 0 : return _localctx;
12084 : }
12085 :
12086 : //----------------- Vector_no_modifier_clauseContext ------------------------------------------------------------------
12087 :
12088 0 : accparser::Vector_no_modifier_clauseContext::Vector_no_modifier_clauseContext(ParserRuleContext *parent, size_t invokingState)
12089 0 : : ParserRuleContext(parent, invokingState) {
12090 0 : }
12091 :
12092 0 : tree::TerminalNode* accparser::Vector_no_modifier_clauseContext::VECTOR() {
12093 0 : return getToken(accparser::VECTOR, 0);
12094 : }
12095 :
12096 :
12097 0 : size_t accparser::Vector_no_modifier_clauseContext::getRuleIndex() const {
12098 0 : return accparser::RuleVector_no_modifier_clause;
12099 : }
12100 :
12101 0 : void accparser::Vector_no_modifier_clauseContext::enterRule(tree::ParseTreeListener *listener) {
12102 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12103 0 : if (parserListener != nullptr)
12104 0 : parserListener->enterVector_no_modifier_clause(this);
12105 0 : }
12106 :
12107 0 : void accparser::Vector_no_modifier_clauseContext::exitRule(tree::ParseTreeListener *listener) {
12108 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12109 0 : if (parserListener != nullptr)
12110 0 : parserListener->exitVector_no_modifier_clause(this);
12111 0 : }
12112 :
12113 :
12114 0 : antlrcpp::Any accparser::Vector_no_modifier_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
12115 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12116 0 : return parserVisitor->visitVector_no_modifier_clause(this);
12117 : else
12118 0 : return visitor->visitChildren(this);
12119 : }
12120 :
12121 0 : accparser::Vector_no_modifier_clauseContext* accparser::vector_no_modifier_clause() {
12122 0 : Vector_no_modifier_clauseContext *_localctx = _tracker.createInstance<Vector_no_modifier_clauseContext>(_ctx, getState());
12123 0 : enterRule(_localctx, 268, accparser::RuleVector_no_modifier_clause);
12124 :
12125 0 : auto onExit = finally([=] {
12126 0 : exitRule();
12127 0 : });
12128 0 : try {
12129 0 : enterOuterAlt(_localctx, 1);
12130 0 : setState(1112);
12131 0 : match(accparser::VECTOR);
12132 :
12133 : }
12134 0 : catch (RecognitionException &e) {
12135 0 : _errHandler->reportError(this, e);
12136 0 : _localctx->exception = std::current_exception();
12137 0 : _errHandler->recover(this, _localctx->exception);
12138 : }
12139 :
12140 0 : return _localctx;
12141 : }
12142 :
12143 : //----------------- Vector_length_clauseContext ------------------------------------------------------------------
12144 :
12145 0 : accparser::Vector_length_clauseContext::Vector_length_clauseContext(ParserRuleContext *parent, size_t invokingState)
12146 0 : : ParserRuleContext(parent, invokingState) {
12147 0 : }
12148 :
12149 0 : tree::TerminalNode* accparser::Vector_length_clauseContext::VECTOR_LENGTH() {
12150 0 : return getToken(accparser::VECTOR_LENGTH, 0);
12151 : }
12152 :
12153 0 : tree::TerminalNode* accparser::Vector_length_clauseContext::LEFT_PAREN() {
12154 0 : return getToken(accparser::LEFT_PAREN, 0);
12155 : }
12156 :
12157 0 : accparser::Int_exprContext* accparser::Vector_length_clauseContext::int_expr() {
12158 0 : return getRuleContext<accparser::Int_exprContext>(0);
12159 : }
12160 :
12161 0 : tree::TerminalNode* accparser::Vector_length_clauseContext::RIGHT_PAREN() {
12162 0 : return getToken(accparser::RIGHT_PAREN, 0);
12163 : }
12164 :
12165 :
12166 0 : size_t accparser::Vector_length_clauseContext::getRuleIndex() const {
12167 0 : return accparser::RuleVector_length_clause;
12168 : }
12169 :
12170 0 : void accparser::Vector_length_clauseContext::enterRule(tree::ParseTreeListener *listener) {
12171 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12172 0 : if (parserListener != nullptr)
12173 0 : parserListener->enterVector_length_clause(this);
12174 0 : }
12175 :
12176 0 : void accparser::Vector_length_clauseContext::exitRule(tree::ParseTreeListener *listener) {
12177 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12178 0 : if (parserListener != nullptr)
12179 0 : parserListener->exitVector_length_clause(this);
12180 0 : }
12181 :
12182 :
12183 0 : antlrcpp::Any accparser::Vector_length_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
12184 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12185 0 : return parserVisitor->visitVector_length_clause(this);
12186 : else
12187 0 : return visitor->visitChildren(this);
12188 : }
12189 :
12190 0 : accparser::Vector_length_clauseContext* accparser::vector_length_clause() {
12191 0 : Vector_length_clauseContext *_localctx = _tracker.createInstance<Vector_length_clauseContext>(_ctx, getState());
12192 0 : enterRule(_localctx, 270, accparser::RuleVector_length_clause);
12193 :
12194 0 : auto onExit = finally([=] {
12195 0 : exitRule();
12196 0 : });
12197 0 : try {
12198 0 : enterOuterAlt(_localctx, 1);
12199 0 : setState(1114);
12200 0 : match(accparser::VECTOR_LENGTH);
12201 0 : setState(1115);
12202 0 : match(accparser::LEFT_PAREN);
12203 0 : setState(1116);
12204 0 : int_expr();
12205 0 : setState(1117);
12206 0 : match(accparser::RIGHT_PAREN);
12207 :
12208 : }
12209 0 : catch (RecognitionException &e) {
12210 0 : _errHandler->reportError(this, e);
12211 0 : _localctx->exception = std::current_exception();
12212 0 : _errHandler->recover(this, _localctx->exception);
12213 : }
12214 :
12215 0 : return _localctx;
12216 : }
12217 :
12218 : //----------------- Wait_clauseContext ------------------------------------------------------------------
12219 :
12220 0 : accparser::Wait_clauseContext::Wait_clauseContext(ParserRuleContext *parent, size_t invokingState)
12221 0 : : ParserRuleContext(parent, invokingState) {
12222 0 : }
12223 :
12224 0 : tree::TerminalNode* accparser::Wait_clauseContext::WAIT() {
12225 0 : return getToken(accparser::WAIT, 0);
12226 : }
12227 :
12228 0 : tree::TerminalNode* accparser::Wait_clauseContext::LEFT_PAREN() {
12229 0 : return getToken(accparser::LEFT_PAREN, 0);
12230 : }
12231 :
12232 0 : accparser::Int_expr_listContext* accparser::Wait_clauseContext::int_expr_list() {
12233 0 : return getRuleContext<accparser::Int_expr_listContext>(0);
12234 : }
12235 :
12236 0 : tree::TerminalNode* accparser::Wait_clauseContext::RIGHT_PAREN() {
12237 0 : return getToken(accparser::RIGHT_PAREN, 0);
12238 : }
12239 :
12240 :
12241 0 : size_t accparser::Wait_clauseContext::getRuleIndex() const {
12242 0 : return accparser::RuleWait_clause;
12243 : }
12244 :
12245 0 : void accparser::Wait_clauseContext::enterRule(tree::ParseTreeListener *listener) {
12246 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12247 0 : if (parserListener != nullptr)
12248 0 : parserListener->enterWait_clause(this);
12249 0 : }
12250 :
12251 0 : void accparser::Wait_clauseContext::exitRule(tree::ParseTreeListener *listener) {
12252 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12253 0 : if (parserListener != nullptr)
12254 0 : parserListener->exitWait_clause(this);
12255 0 : }
12256 :
12257 :
12258 0 : antlrcpp::Any accparser::Wait_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
12259 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12260 0 : return parserVisitor->visitWait_clause(this);
12261 : else
12262 0 : return visitor->visitChildren(this);
12263 : }
12264 :
12265 0 : accparser::Wait_clauseContext* accparser::wait_clause() {
12266 0 : Wait_clauseContext *_localctx = _tracker.createInstance<Wait_clauseContext>(_ctx, getState());
12267 0 : enterRule(_localctx, 272, accparser::RuleWait_clause);
12268 :
12269 0 : auto onExit = finally([=] {
12270 0 : exitRule();
12271 0 : });
12272 0 : try {
12273 0 : setState(1125);
12274 0 : _errHandler->sync(this);
12275 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx)) {
12276 0 : case 1: {
12277 0 : enterOuterAlt(_localctx, 1);
12278 0 : setState(1119);
12279 0 : match(accparser::WAIT);
12280 : break;
12281 : }
12282 :
12283 0 : case 2: {
12284 0 : enterOuterAlt(_localctx, 2);
12285 0 : setState(1120);
12286 0 : match(accparser::WAIT);
12287 0 : setState(1121);
12288 0 : match(accparser::LEFT_PAREN);
12289 0 : setState(1122);
12290 0 : int_expr_list();
12291 0 : setState(1123);
12292 0 : match(accparser::RIGHT_PAREN);
12293 : break;
12294 : }
12295 :
12296 : }
12297 :
12298 : }
12299 0 : catch (RecognitionException &e) {
12300 0 : _errHandler->reportError(this, e);
12301 0 : _localctx->exception = std::current_exception();
12302 0 : _errHandler->recover(this, _localctx->exception);
12303 : }
12304 :
12305 0 : return _localctx;
12306 : }
12307 :
12308 : //----------------- Wait_argument_clauseContext ------------------------------------------------------------------
12309 :
12310 0 : accparser::Wait_argument_clauseContext::Wait_argument_clauseContext(ParserRuleContext *parent, size_t invokingState)
12311 0 : : ParserRuleContext(parent, invokingState) {
12312 0 : }
12313 :
12314 0 : tree::TerminalNode* accparser::Wait_argument_clauseContext::WAIT() {
12315 0 : return getToken(accparser::WAIT, 0);
12316 : }
12317 :
12318 0 : tree::TerminalNode* accparser::Wait_argument_clauseContext::LEFT_PAREN() {
12319 0 : return getToken(accparser::LEFT_PAREN, 0);
12320 : }
12321 :
12322 0 : accparser::Wait_argumentContext* accparser::Wait_argument_clauseContext::wait_argument() {
12323 0 : return getRuleContext<accparser::Wait_argumentContext>(0);
12324 : }
12325 :
12326 0 : tree::TerminalNode* accparser::Wait_argument_clauseContext::RIGHT_PAREN() {
12327 0 : return getToken(accparser::RIGHT_PAREN, 0);
12328 : }
12329 :
12330 :
12331 0 : size_t accparser::Wait_argument_clauseContext::getRuleIndex() const {
12332 0 : return accparser::RuleWait_argument_clause;
12333 : }
12334 :
12335 0 : void accparser::Wait_argument_clauseContext::enterRule(tree::ParseTreeListener *listener) {
12336 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12337 0 : if (parserListener != nullptr)
12338 0 : parserListener->enterWait_argument_clause(this);
12339 0 : }
12340 :
12341 0 : void accparser::Wait_argument_clauseContext::exitRule(tree::ParseTreeListener *listener) {
12342 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12343 0 : if (parserListener != nullptr)
12344 0 : parserListener->exitWait_argument_clause(this);
12345 0 : }
12346 :
12347 :
12348 0 : antlrcpp::Any accparser::Wait_argument_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
12349 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12350 0 : return parserVisitor->visitWait_argument_clause(this);
12351 : else
12352 0 : return visitor->visitChildren(this);
12353 : }
12354 :
12355 0 : accparser::Wait_argument_clauseContext* accparser::wait_argument_clause() {
12356 0 : Wait_argument_clauseContext *_localctx = _tracker.createInstance<Wait_argument_clauseContext>(_ctx, getState());
12357 0 : enterRule(_localctx, 274, accparser::RuleWait_argument_clause);
12358 :
12359 0 : auto onExit = finally([=] {
12360 0 : exitRule();
12361 0 : });
12362 0 : try {
12363 0 : setState(1133);
12364 0 : _errHandler->sync(this);
12365 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 59, _ctx)) {
12366 0 : case 1: {
12367 0 : enterOuterAlt(_localctx, 1);
12368 0 : setState(1127);
12369 0 : match(accparser::WAIT);
12370 : break;
12371 : }
12372 :
12373 0 : case 2: {
12374 0 : enterOuterAlt(_localctx, 2);
12375 0 : setState(1128);
12376 0 : match(accparser::WAIT);
12377 0 : setState(1129);
12378 0 : match(accparser::LEFT_PAREN);
12379 0 : setState(1130);
12380 0 : wait_argument();
12381 0 : setState(1131);
12382 0 : match(accparser::RIGHT_PAREN);
12383 : break;
12384 : }
12385 :
12386 : }
12387 :
12388 : }
12389 0 : catch (RecognitionException &e) {
12390 0 : _errHandler->reportError(this, e);
12391 0 : _localctx->exception = std::current_exception();
12392 0 : _errHandler->recover(this, _localctx->exception);
12393 : }
12394 :
12395 0 : return _localctx;
12396 : }
12397 :
12398 : //----------------- Wait_argumentContext ------------------------------------------------------------------
12399 :
12400 0 : accparser::Wait_argumentContext::Wait_argumentContext(ParserRuleContext *parent, size_t invokingState)
12401 0 : : ParserRuleContext(parent, invokingState) {
12402 0 : }
12403 :
12404 0 : tree::TerminalNode* accparser::Wait_argumentContext::DEVNUM() {
12405 0 : return getToken(accparser::DEVNUM, 0);
12406 : }
12407 :
12408 0 : std::vector<tree::TerminalNode *> accparser::Wait_argumentContext::COLON() {
12409 0 : return getTokens(accparser::COLON);
12410 : }
12411 :
12412 0 : tree::TerminalNode* accparser::Wait_argumentContext::COLON(size_t i) {
12413 0 : return getToken(accparser::COLON, i);
12414 : }
12415 :
12416 0 : accparser::Wait_argument_int_exprContext* accparser::Wait_argumentContext::wait_argument_int_expr() {
12417 0 : return getRuleContext<accparser::Wait_argument_int_exprContext>(0);
12418 : }
12419 :
12420 0 : accparser::Wait_argument_queuesContext* accparser::Wait_argumentContext::wait_argument_queues() {
12421 0 : return getRuleContext<accparser::Wait_argument_queuesContext>(0);
12422 : }
12423 :
12424 0 : accparser::Wait_int_expr_listContext* accparser::Wait_argumentContext::wait_int_expr_list() {
12425 0 : return getRuleContext<accparser::Wait_int_expr_listContext>(0);
12426 : }
12427 :
12428 :
12429 0 : size_t accparser::Wait_argumentContext::getRuleIndex() const {
12430 0 : return accparser::RuleWait_argument;
12431 : }
12432 :
12433 0 : void accparser::Wait_argumentContext::enterRule(tree::ParseTreeListener *listener) {
12434 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12435 0 : if (parserListener != nullptr)
12436 0 : parserListener->enterWait_argument(this);
12437 0 : }
12438 :
12439 0 : void accparser::Wait_argumentContext::exitRule(tree::ParseTreeListener *listener) {
12440 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12441 0 : if (parserListener != nullptr)
12442 0 : parserListener->exitWait_argument(this);
12443 0 : }
12444 :
12445 :
12446 0 : antlrcpp::Any accparser::Wait_argumentContext::accept(tree::ParseTreeVisitor *visitor) {
12447 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12448 0 : return parserVisitor->visitWait_argument(this);
12449 : else
12450 0 : return visitor->visitChildren(this);
12451 : }
12452 :
12453 0 : accparser::Wait_argumentContext* accparser::wait_argument() {
12454 0 : Wait_argumentContext *_localctx = _tracker.createInstance<Wait_argumentContext>(_ctx, getState());
12455 0 : enterRule(_localctx, 276, accparser::RuleWait_argument);
12456 :
12457 0 : auto onExit = finally([=] {
12458 0 : exitRule();
12459 0 : });
12460 0 : try {
12461 0 : setState(1154);
12462 0 : _errHandler->sync(this);
12463 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _ctx)) {
12464 0 : case 1: {
12465 0 : enterOuterAlt(_localctx, 1);
12466 0 : setState(1135);
12467 0 : match(accparser::DEVNUM);
12468 0 : setState(1136);
12469 0 : match(accparser::COLON);
12470 0 : setState(1137);
12471 0 : wait_argument_int_expr();
12472 0 : setState(1138);
12473 0 : match(accparser::COLON);
12474 0 : setState(1139);
12475 0 : wait_argument_queues();
12476 0 : setState(1140);
12477 0 : match(accparser::COLON);
12478 0 : setState(1141);
12479 0 : wait_int_expr_list();
12480 : break;
12481 : }
12482 :
12483 0 : case 2: {
12484 0 : enterOuterAlt(_localctx, 2);
12485 0 : setState(1143);
12486 0 : match(accparser::DEVNUM);
12487 0 : setState(1144);
12488 0 : match(accparser::COLON);
12489 0 : setState(1145);
12490 0 : wait_argument_int_expr();
12491 0 : setState(1146);
12492 0 : match(accparser::COLON);
12493 0 : setState(1147);
12494 0 : wait_int_expr_list();
12495 : break;
12496 : }
12497 :
12498 0 : case 3: {
12499 0 : enterOuterAlt(_localctx, 3);
12500 0 : setState(1149);
12501 0 : wait_argument_queues();
12502 0 : setState(1150);
12503 0 : match(accparser::COLON);
12504 0 : setState(1151);
12505 0 : wait_int_expr_list();
12506 : break;
12507 : }
12508 :
12509 0 : case 4: {
12510 0 : enterOuterAlt(_localctx, 4);
12511 0 : setState(1153);
12512 0 : wait_int_expr_list();
12513 : break;
12514 : }
12515 :
12516 : }
12517 :
12518 : }
12519 0 : catch (RecognitionException &e) {
12520 0 : _errHandler->reportError(this, e);
12521 0 : _localctx->exception = std::current_exception();
12522 0 : _errHandler->recover(this, _localctx->exception);
12523 : }
12524 :
12525 0 : return _localctx;
12526 : }
12527 :
12528 : //----------------- Wait_int_expr_listContext ------------------------------------------------------------------
12529 :
12530 0 : accparser::Wait_int_expr_listContext::Wait_int_expr_listContext(ParserRuleContext *parent, size_t invokingState)
12531 0 : : ParserRuleContext(parent, invokingState) {
12532 0 : }
12533 :
12534 0 : std::vector<accparser::Wait_int_exprContext *> accparser::Wait_int_expr_listContext::wait_int_expr() {
12535 0 : return getRuleContexts<accparser::Wait_int_exprContext>();
12536 : }
12537 :
12538 0 : accparser::Wait_int_exprContext* accparser::Wait_int_expr_listContext::wait_int_expr(size_t i) {
12539 0 : return getRuleContext<accparser::Wait_int_exprContext>(i);
12540 : }
12541 :
12542 0 : std::vector<tree::TerminalNode *> accparser::Wait_int_expr_listContext::COMMA() {
12543 0 : return getTokens(accparser::COMMA);
12544 : }
12545 :
12546 0 : tree::TerminalNode* accparser::Wait_int_expr_listContext::COMMA(size_t i) {
12547 0 : return getToken(accparser::COMMA, i);
12548 : }
12549 :
12550 :
12551 0 : size_t accparser::Wait_int_expr_listContext::getRuleIndex() const {
12552 0 : return accparser::RuleWait_int_expr_list;
12553 : }
12554 :
12555 0 : void accparser::Wait_int_expr_listContext::enterRule(tree::ParseTreeListener *listener) {
12556 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12557 0 : if (parserListener != nullptr)
12558 0 : parserListener->enterWait_int_expr_list(this);
12559 0 : }
12560 :
12561 0 : void accparser::Wait_int_expr_listContext::exitRule(tree::ParseTreeListener *listener) {
12562 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12563 0 : if (parserListener != nullptr)
12564 0 : parserListener->exitWait_int_expr_list(this);
12565 0 : }
12566 :
12567 :
12568 0 : antlrcpp::Any accparser::Wait_int_expr_listContext::accept(tree::ParseTreeVisitor *visitor) {
12569 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12570 0 : return parserVisitor->visitWait_int_expr_list(this);
12571 : else
12572 0 : return visitor->visitChildren(this);
12573 : }
12574 :
12575 0 : accparser::Wait_int_expr_listContext* accparser::wait_int_expr_list() {
12576 0 : Wait_int_expr_listContext *_localctx = _tracker.createInstance<Wait_int_expr_listContext>(_ctx, getState());
12577 0 : enterRule(_localctx, 278, accparser::RuleWait_int_expr_list);
12578 0 : size_t _la = 0;
12579 :
12580 0 : auto onExit = finally([=] {
12581 0 : exitRule();
12582 0 : });
12583 0 : try {
12584 0 : enterOuterAlt(_localctx, 1);
12585 0 : setState(1160);
12586 0 : _errHandler->sync(this);
12587 0 : _la = _input->LA(1);
12588 0 : do {
12589 0 : setState(1160);
12590 0 : _errHandler->sync(this);
12591 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx)) {
12592 0 : case 1: {
12593 0 : setState(1156);
12594 0 : wait_int_expr();
12595 0 : setState(1157);
12596 0 : match(accparser::COMMA);
12597 : break;
12598 : }
12599 :
12600 0 : case 2: {
12601 0 : setState(1159);
12602 0 : wait_int_expr();
12603 : break;
12604 : }
12605 :
12606 : }
12607 0 : setState(1162);
12608 0 : _errHandler->sync(this);
12609 0 : _la = _input->LA(1);
12610 0 : } while (_la == accparser::EXPR);
12611 :
12612 : }
12613 0 : catch (RecognitionException &e) {
12614 0 : _errHandler->reportError(this, e);
12615 0 : _localctx->exception = std::current_exception();
12616 0 : _errHandler->recover(this, _localctx->exception);
12617 : }
12618 :
12619 0 : return _localctx;
12620 : }
12621 :
12622 : //----------------- Wait_int_exprContext ------------------------------------------------------------------
12623 :
12624 0 : accparser::Wait_int_exprContext::Wait_int_exprContext(ParserRuleContext *parent, size_t invokingState)
12625 0 : : ParserRuleContext(parent, invokingState) {
12626 0 : }
12627 :
12628 0 : tree::TerminalNode* accparser::Wait_int_exprContext::EXPR() {
12629 0 : return getToken(accparser::EXPR, 0);
12630 : }
12631 :
12632 :
12633 0 : size_t accparser::Wait_int_exprContext::getRuleIndex() const {
12634 0 : return accparser::RuleWait_int_expr;
12635 : }
12636 :
12637 0 : void accparser::Wait_int_exprContext::enterRule(tree::ParseTreeListener *listener) {
12638 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12639 0 : if (parserListener != nullptr)
12640 0 : parserListener->enterWait_int_expr(this);
12641 0 : }
12642 :
12643 0 : void accparser::Wait_int_exprContext::exitRule(tree::ParseTreeListener *listener) {
12644 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12645 0 : if (parserListener != nullptr)
12646 0 : parserListener->exitWait_int_expr(this);
12647 0 : }
12648 :
12649 :
12650 0 : antlrcpp::Any accparser::Wait_int_exprContext::accept(tree::ParseTreeVisitor *visitor) {
12651 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12652 0 : return parserVisitor->visitWait_int_expr(this);
12653 : else
12654 0 : return visitor->visitChildren(this);
12655 : }
12656 :
12657 0 : accparser::Wait_int_exprContext* accparser::wait_int_expr() {
12658 0 : Wait_int_exprContext *_localctx = _tracker.createInstance<Wait_int_exprContext>(_ctx, getState());
12659 0 : enterRule(_localctx, 280, accparser::RuleWait_int_expr);
12660 :
12661 0 : auto onExit = finally([=] {
12662 0 : exitRule();
12663 0 : });
12664 0 : try {
12665 0 : enterOuterAlt(_localctx, 1);
12666 0 : setState(1164);
12667 0 : match(accparser::EXPR);
12668 :
12669 : }
12670 0 : catch (RecognitionException &e) {
12671 0 : _errHandler->reportError(this, e);
12672 0 : _localctx->exception = std::current_exception();
12673 0 : _errHandler->recover(this, _localctx->exception);
12674 : }
12675 :
12676 0 : return _localctx;
12677 : }
12678 :
12679 : //----------------- Wait_argument_queuesContext ------------------------------------------------------------------
12680 :
12681 0 : accparser::Wait_argument_queuesContext::Wait_argument_queuesContext(ParserRuleContext *parent, size_t invokingState)
12682 0 : : ParserRuleContext(parent, invokingState) {
12683 0 : }
12684 :
12685 0 : tree::TerminalNode* accparser::Wait_argument_queuesContext::QUEUES() {
12686 0 : return getToken(accparser::QUEUES, 0);
12687 : }
12688 :
12689 :
12690 0 : size_t accparser::Wait_argument_queuesContext::getRuleIndex() const {
12691 0 : return accparser::RuleWait_argument_queues;
12692 : }
12693 :
12694 0 : void accparser::Wait_argument_queuesContext::enterRule(tree::ParseTreeListener *listener) {
12695 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12696 0 : if (parserListener != nullptr)
12697 0 : parserListener->enterWait_argument_queues(this);
12698 0 : }
12699 :
12700 0 : void accparser::Wait_argument_queuesContext::exitRule(tree::ParseTreeListener *listener) {
12701 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12702 0 : if (parserListener != nullptr)
12703 0 : parserListener->exitWait_argument_queues(this);
12704 0 : }
12705 :
12706 :
12707 0 : antlrcpp::Any accparser::Wait_argument_queuesContext::accept(tree::ParseTreeVisitor *visitor) {
12708 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12709 0 : return parserVisitor->visitWait_argument_queues(this);
12710 : else
12711 0 : return visitor->visitChildren(this);
12712 : }
12713 :
12714 0 : accparser::Wait_argument_queuesContext* accparser::wait_argument_queues() {
12715 0 : Wait_argument_queuesContext *_localctx = _tracker.createInstance<Wait_argument_queuesContext>(_ctx, getState());
12716 0 : enterRule(_localctx, 282, accparser::RuleWait_argument_queues);
12717 :
12718 0 : auto onExit = finally([=] {
12719 0 : exitRule();
12720 0 : });
12721 0 : try {
12722 0 : enterOuterAlt(_localctx, 1);
12723 0 : setState(1166);
12724 0 : match(accparser::QUEUES);
12725 :
12726 : }
12727 0 : catch (RecognitionException &e) {
12728 0 : _errHandler->reportError(this, e);
12729 0 : _localctx->exception = std::current_exception();
12730 0 : _errHandler->recover(this, _localctx->exception);
12731 : }
12732 :
12733 0 : return _localctx;
12734 : }
12735 :
12736 : //----------------- Wait_argument_int_exprContext ------------------------------------------------------------------
12737 :
12738 0 : accparser::Wait_argument_int_exprContext::Wait_argument_int_exprContext(ParserRuleContext *parent, size_t invokingState)
12739 0 : : ParserRuleContext(parent, invokingState) {
12740 0 : }
12741 :
12742 0 : tree::TerminalNode* accparser::Wait_argument_int_exprContext::EXPR() {
12743 0 : return getToken(accparser::EXPR, 0);
12744 : }
12745 :
12746 :
12747 0 : size_t accparser::Wait_argument_int_exprContext::getRuleIndex() const {
12748 0 : return accparser::RuleWait_argument_int_expr;
12749 : }
12750 :
12751 0 : void accparser::Wait_argument_int_exprContext::enterRule(tree::ParseTreeListener *listener) {
12752 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12753 0 : if (parserListener != nullptr)
12754 0 : parserListener->enterWait_argument_int_expr(this);
12755 0 : }
12756 :
12757 0 : void accparser::Wait_argument_int_exprContext::exitRule(tree::ParseTreeListener *listener) {
12758 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12759 0 : if (parserListener != nullptr)
12760 0 : parserListener->exitWait_argument_int_expr(this);
12761 0 : }
12762 :
12763 :
12764 0 : antlrcpp::Any accparser::Wait_argument_int_exprContext::accept(tree::ParseTreeVisitor *visitor) {
12765 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12766 0 : return parserVisitor->visitWait_argument_int_expr(this);
12767 : else
12768 0 : return visitor->visitChildren(this);
12769 : }
12770 :
12771 0 : accparser::Wait_argument_int_exprContext* accparser::wait_argument_int_expr() {
12772 0 : Wait_argument_int_exprContext *_localctx = _tracker.createInstance<Wait_argument_int_exprContext>(_ctx, getState());
12773 0 : enterRule(_localctx, 284, accparser::RuleWait_argument_int_expr);
12774 :
12775 0 : auto onExit = finally([=] {
12776 0 : exitRule();
12777 0 : });
12778 0 : try {
12779 0 : enterOuterAlt(_localctx, 1);
12780 0 : setState(1168);
12781 0 : match(accparser::EXPR);
12782 :
12783 : }
12784 0 : catch (RecognitionException &e) {
12785 0 : _errHandler->reportError(this, e);
12786 0 : _localctx->exception = std::current_exception();
12787 0 : _errHandler->recover(this, _localctx->exception);
12788 : }
12789 :
12790 0 : return _localctx;
12791 : }
12792 :
12793 : //----------------- Worker_clauseContext ------------------------------------------------------------------
12794 :
12795 0 : accparser::Worker_clauseContext::Worker_clauseContext(ParserRuleContext *parent, size_t invokingState)
12796 0 : : ParserRuleContext(parent, invokingState) {
12797 0 : }
12798 :
12799 0 : tree::TerminalNode* accparser::Worker_clauseContext::WORKER() {
12800 0 : return getToken(accparser::WORKER, 0);
12801 : }
12802 :
12803 0 : accparser::Worker_clause_argsContext* accparser::Worker_clauseContext::worker_clause_args() {
12804 0 : return getRuleContext<accparser::Worker_clause_argsContext>(0);
12805 : }
12806 :
12807 :
12808 0 : size_t accparser::Worker_clauseContext::getRuleIndex() const {
12809 0 : return accparser::RuleWorker_clause;
12810 : }
12811 :
12812 0 : void accparser::Worker_clauseContext::enterRule(tree::ParseTreeListener *listener) {
12813 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12814 0 : if (parserListener != nullptr)
12815 0 : parserListener->enterWorker_clause(this);
12816 0 : }
12817 :
12818 0 : void accparser::Worker_clauseContext::exitRule(tree::ParseTreeListener *listener) {
12819 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12820 0 : if (parserListener != nullptr)
12821 0 : parserListener->exitWorker_clause(this);
12822 0 : }
12823 :
12824 :
12825 0 : antlrcpp::Any accparser::Worker_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
12826 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12827 0 : return parserVisitor->visitWorker_clause(this);
12828 : else
12829 0 : return visitor->visitChildren(this);
12830 : }
12831 :
12832 0 : accparser::Worker_clauseContext* accparser::worker_clause() {
12833 0 : Worker_clauseContext *_localctx = _tracker.createInstance<Worker_clauseContext>(_ctx, getState());
12834 0 : enterRule(_localctx, 286, accparser::RuleWorker_clause);
12835 :
12836 0 : auto onExit = finally([=] {
12837 0 : exitRule();
12838 0 : });
12839 0 : try {
12840 0 : setState(1173);
12841 0 : _errHandler->sync(this);
12842 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx)) {
12843 0 : case 1: {
12844 0 : enterOuterAlt(_localctx, 1);
12845 0 : setState(1170);
12846 0 : match(accparser::WORKER);
12847 : break;
12848 : }
12849 :
12850 0 : case 2: {
12851 0 : enterOuterAlt(_localctx, 2);
12852 0 : setState(1171);
12853 0 : match(accparser::WORKER);
12854 0 : setState(1172);
12855 0 : worker_clause_args();
12856 : break;
12857 : }
12858 :
12859 : }
12860 :
12861 : }
12862 0 : catch (RecognitionException &e) {
12863 0 : _errHandler->reportError(this, e);
12864 0 : _localctx->exception = std::current_exception();
12865 0 : _errHandler->recover(this, _localctx->exception);
12866 : }
12867 :
12868 0 : return _localctx;
12869 : }
12870 :
12871 : //----------------- Worker_clause_argsContext ------------------------------------------------------------------
12872 :
12873 0 : accparser::Worker_clause_argsContext::Worker_clause_argsContext(ParserRuleContext *parent, size_t invokingState)
12874 0 : : ParserRuleContext(parent, invokingState) {
12875 0 : }
12876 :
12877 0 : tree::TerminalNode* accparser::Worker_clause_argsContext::LEFT_PAREN() {
12878 0 : return getToken(accparser::LEFT_PAREN, 0);
12879 : }
12880 :
12881 0 : accparser::Worker_clause_modifierContext* accparser::Worker_clause_argsContext::worker_clause_modifier() {
12882 0 : return getRuleContext<accparser::Worker_clause_modifierContext>(0);
12883 : }
12884 :
12885 0 : tree::TerminalNode* accparser::Worker_clause_argsContext::COLON() {
12886 0 : return getToken(accparser::COLON, 0);
12887 : }
12888 :
12889 0 : accparser::Int_exprContext* accparser::Worker_clause_argsContext::int_expr() {
12890 0 : return getRuleContext<accparser::Int_exprContext>(0);
12891 : }
12892 :
12893 0 : tree::TerminalNode* accparser::Worker_clause_argsContext::RIGHT_PAREN() {
12894 0 : return getToken(accparser::RIGHT_PAREN, 0);
12895 : }
12896 :
12897 :
12898 0 : size_t accparser::Worker_clause_argsContext::getRuleIndex() const {
12899 0 : return accparser::RuleWorker_clause_args;
12900 : }
12901 :
12902 0 : void accparser::Worker_clause_argsContext::enterRule(tree::ParseTreeListener *listener) {
12903 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12904 0 : if (parserListener != nullptr)
12905 0 : parserListener->enterWorker_clause_args(this);
12906 0 : }
12907 :
12908 0 : void accparser::Worker_clause_argsContext::exitRule(tree::ParseTreeListener *listener) {
12909 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12910 0 : if (parserListener != nullptr)
12911 0 : parserListener->exitWorker_clause_args(this);
12912 0 : }
12913 :
12914 :
12915 0 : antlrcpp::Any accparser::Worker_clause_argsContext::accept(tree::ParseTreeVisitor *visitor) {
12916 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
12917 0 : return parserVisitor->visitWorker_clause_args(this);
12918 : else
12919 0 : return visitor->visitChildren(this);
12920 : }
12921 :
12922 0 : accparser::Worker_clause_argsContext* accparser::worker_clause_args() {
12923 0 : Worker_clause_argsContext *_localctx = _tracker.createInstance<Worker_clause_argsContext>(_ctx, getState());
12924 0 : enterRule(_localctx, 288, accparser::RuleWorker_clause_args);
12925 :
12926 0 : auto onExit = finally([=] {
12927 0 : exitRule();
12928 0 : });
12929 0 : try {
12930 0 : setState(1185);
12931 0 : _errHandler->sync(this);
12932 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 64, _ctx)) {
12933 0 : case 1: {
12934 0 : enterOuterAlt(_localctx, 1);
12935 0 : setState(1175);
12936 0 : match(accparser::LEFT_PAREN);
12937 0 : setState(1176);
12938 0 : worker_clause_modifier();
12939 0 : setState(1177);
12940 0 : match(accparser::COLON);
12941 0 : setState(1178);
12942 0 : int_expr();
12943 0 : setState(1179);
12944 0 : match(accparser::RIGHT_PAREN);
12945 : break;
12946 : }
12947 :
12948 0 : case 2: {
12949 0 : enterOuterAlt(_localctx, 2);
12950 0 : setState(1181);
12951 0 : match(accparser::LEFT_PAREN);
12952 0 : setState(1182);
12953 0 : int_expr();
12954 0 : setState(1183);
12955 0 : match(accparser::RIGHT_PAREN);
12956 : break;
12957 : }
12958 :
12959 : }
12960 :
12961 : }
12962 0 : catch (RecognitionException &e) {
12963 0 : _errHandler->reportError(this, e);
12964 0 : _localctx->exception = std::current_exception();
12965 0 : _errHandler->recover(this, _localctx->exception);
12966 : }
12967 :
12968 0 : return _localctx;
12969 : }
12970 :
12971 : //----------------- Worker_clause_modifierContext ------------------------------------------------------------------
12972 :
12973 0 : accparser::Worker_clause_modifierContext::Worker_clause_modifierContext(ParserRuleContext *parent, size_t invokingState)
12974 0 : : ParserRuleContext(parent, invokingState) {
12975 0 : }
12976 :
12977 0 : tree::TerminalNode* accparser::Worker_clause_modifierContext::NUM() {
12978 0 : return getToken(accparser::NUM, 0);
12979 : }
12980 :
12981 :
12982 0 : size_t accparser::Worker_clause_modifierContext::getRuleIndex() const {
12983 0 : return accparser::RuleWorker_clause_modifier;
12984 : }
12985 :
12986 0 : void accparser::Worker_clause_modifierContext::enterRule(tree::ParseTreeListener *listener) {
12987 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12988 0 : if (parserListener != nullptr)
12989 0 : parserListener->enterWorker_clause_modifier(this);
12990 0 : }
12991 :
12992 0 : void accparser::Worker_clause_modifierContext::exitRule(tree::ParseTreeListener *listener) {
12993 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
12994 0 : if (parserListener != nullptr)
12995 0 : parserListener->exitWorker_clause_modifier(this);
12996 0 : }
12997 :
12998 :
12999 0 : antlrcpp::Any accparser::Worker_clause_modifierContext::accept(tree::ParseTreeVisitor *visitor) {
13000 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
13001 0 : return parserVisitor->visitWorker_clause_modifier(this);
13002 : else
13003 0 : return visitor->visitChildren(this);
13004 : }
13005 :
13006 0 : accparser::Worker_clause_modifierContext* accparser::worker_clause_modifier() {
13007 0 : Worker_clause_modifierContext *_localctx = _tracker.createInstance<Worker_clause_modifierContext>(_ctx, getState());
13008 0 : enterRule(_localctx, 290, accparser::RuleWorker_clause_modifier);
13009 :
13010 0 : auto onExit = finally([=] {
13011 0 : exitRule();
13012 0 : });
13013 0 : try {
13014 0 : enterOuterAlt(_localctx, 1);
13015 0 : setState(1187);
13016 0 : match(accparser::NUM);
13017 :
13018 : }
13019 0 : catch (RecognitionException &e) {
13020 0 : _errHandler->reportError(this, e);
13021 0 : _localctx->exception = std::current_exception();
13022 0 : _errHandler->recover(this, _localctx->exception);
13023 : }
13024 :
13025 0 : return _localctx;
13026 : }
13027 :
13028 : //----------------- Worker_no_modifier_clauseContext ------------------------------------------------------------------
13029 :
13030 0 : accparser::Worker_no_modifier_clauseContext::Worker_no_modifier_clauseContext(ParserRuleContext *parent, size_t invokingState)
13031 0 : : ParserRuleContext(parent, invokingState) {
13032 0 : }
13033 :
13034 0 : tree::TerminalNode* accparser::Worker_no_modifier_clauseContext::WORKER() {
13035 0 : return getToken(accparser::WORKER, 0);
13036 : }
13037 :
13038 :
13039 0 : size_t accparser::Worker_no_modifier_clauseContext::getRuleIndex() const {
13040 0 : return accparser::RuleWorker_no_modifier_clause;
13041 : }
13042 :
13043 0 : void accparser::Worker_no_modifier_clauseContext::enterRule(tree::ParseTreeListener *listener) {
13044 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13045 0 : if (parserListener != nullptr)
13046 0 : parserListener->enterWorker_no_modifier_clause(this);
13047 0 : }
13048 :
13049 0 : void accparser::Worker_no_modifier_clauseContext::exitRule(tree::ParseTreeListener *listener) {
13050 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13051 0 : if (parserListener != nullptr)
13052 0 : parserListener->exitWorker_no_modifier_clause(this);
13053 0 : }
13054 :
13055 :
13056 0 : antlrcpp::Any accparser::Worker_no_modifier_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
13057 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
13058 0 : return parserVisitor->visitWorker_no_modifier_clause(this);
13059 : else
13060 0 : return visitor->visitChildren(this);
13061 : }
13062 :
13063 0 : accparser::Worker_no_modifier_clauseContext* accparser::worker_no_modifier_clause() {
13064 0 : Worker_no_modifier_clauseContext *_localctx = _tracker.createInstance<Worker_no_modifier_clauseContext>(_ctx, getState());
13065 0 : enterRule(_localctx, 292, accparser::RuleWorker_no_modifier_clause);
13066 :
13067 0 : auto onExit = finally([=] {
13068 0 : exitRule();
13069 0 : });
13070 0 : try {
13071 0 : enterOuterAlt(_localctx, 1);
13072 0 : setState(1189);
13073 0 : match(accparser::WORKER);
13074 :
13075 : }
13076 0 : catch (RecognitionException &e) {
13077 0 : _errHandler->reportError(this, e);
13078 0 : _localctx->exception = std::current_exception();
13079 0 : _errHandler->recover(this, _localctx->exception);
13080 : }
13081 :
13082 0 : return _localctx;
13083 : }
13084 :
13085 : //----------------- Write_clauseContext ------------------------------------------------------------------
13086 :
13087 0 : accparser::Write_clauseContext::Write_clauseContext(ParserRuleContext *parent, size_t invokingState)
13088 0 : : ParserRuleContext(parent, invokingState) {
13089 0 : }
13090 :
13091 0 : tree::TerminalNode* accparser::Write_clauseContext::WRITE() {
13092 0 : return getToken(accparser::WRITE, 0);
13093 : }
13094 :
13095 :
13096 0 : size_t accparser::Write_clauseContext::getRuleIndex() const {
13097 0 : return accparser::RuleWrite_clause;
13098 : }
13099 :
13100 0 : void accparser::Write_clauseContext::enterRule(tree::ParseTreeListener *listener) {
13101 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13102 0 : if (parserListener != nullptr)
13103 0 : parserListener->enterWrite_clause(this);
13104 0 : }
13105 :
13106 0 : void accparser::Write_clauseContext::exitRule(tree::ParseTreeListener *listener) {
13107 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13108 0 : if (parserListener != nullptr)
13109 0 : parserListener->exitWrite_clause(this);
13110 0 : }
13111 :
13112 :
13113 0 : antlrcpp::Any accparser::Write_clauseContext::accept(tree::ParseTreeVisitor *visitor) {
13114 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
13115 0 : return parserVisitor->visitWrite_clause(this);
13116 : else
13117 0 : return visitor->visitChildren(this);
13118 : }
13119 :
13120 0 : accparser::Write_clauseContext* accparser::write_clause() {
13121 0 : Write_clauseContext *_localctx = _tracker.createInstance<Write_clauseContext>(_ctx, getState());
13122 0 : enterRule(_localctx, 294, accparser::RuleWrite_clause);
13123 :
13124 0 : auto onExit = finally([=] {
13125 0 : exitRule();
13126 0 : });
13127 0 : try {
13128 0 : enterOuterAlt(_localctx, 1);
13129 0 : setState(1191);
13130 0 : match(accparser::WRITE);
13131 :
13132 : }
13133 0 : catch (RecognitionException &e) {
13134 0 : _errHandler->reportError(this, e);
13135 0 : _localctx->exception = std::current_exception();
13136 0 : _errHandler->recover(this, _localctx->exception);
13137 : }
13138 :
13139 0 : return _localctx;
13140 : }
13141 :
13142 : //----------------- Const_intContext ------------------------------------------------------------------
13143 :
13144 0 : accparser::Const_intContext::Const_intContext(ParserRuleContext *parent, size_t invokingState)
13145 0 : : ParserRuleContext(parent, invokingState) {
13146 0 : }
13147 :
13148 0 : tree::TerminalNode* accparser::Const_intContext::EXPR() {
13149 0 : return getToken(accparser::EXPR, 0);
13150 : }
13151 :
13152 :
13153 0 : size_t accparser::Const_intContext::getRuleIndex() const {
13154 0 : return accparser::RuleConst_int;
13155 : }
13156 :
13157 0 : void accparser::Const_intContext::enterRule(tree::ParseTreeListener *listener) {
13158 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13159 0 : if (parserListener != nullptr)
13160 0 : parserListener->enterConst_int(this);
13161 0 : }
13162 :
13163 0 : void accparser::Const_intContext::exitRule(tree::ParseTreeListener *listener) {
13164 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13165 0 : if (parserListener != nullptr)
13166 0 : parserListener->exitConst_int(this);
13167 0 : }
13168 :
13169 :
13170 0 : antlrcpp::Any accparser::Const_intContext::accept(tree::ParseTreeVisitor *visitor) {
13171 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
13172 0 : return parserVisitor->visitConst_int(this);
13173 : else
13174 0 : return visitor->visitChildren(this);
13175 : }
13176 :
13177 0 : accparser::Const_intContext* accparser::const_int() {
13178 0 : Const_intContext *_localctx = _tracker.createInstance<Const_intContext>(_ctx, getState());
13179 0 : enterRule(_localctx, 296, accparser::RuleConst_int);
13180 :
13181 0 : auto onExit = finally([=] {
13182 0 : exitRule();
13183 0 : });
13184 0 : try {
13185 0 : enterOuterAlt(_localctx, 1);
13186 0 : setState(1193);
13187 0 : match(accparser::EXPR);
13188 :
13189 : }
13190 0 : catch (RecognitionException &e) {
13191 0 : _errHandler->reportError(this, e);
13192 0 : _localctx->exception = std::current_exception();
13193 0 : _errHandler->recover(this, _localctx->exception);
13194 : }
13195 :
13196 0 : return _localctx;
13197 : }
13198 :
13199 : //----------------- Int_expr_listContext ------------------------------------------------------------------
13200 :
13201 0 : accparser::Int_expr_listContext::Int_expr_listContext(ParserRuleContext *parent, size_t invokingState)
13202 0 : : ParserRuleContext(parent, invokingState) {
13203 0 : }
13204 :
13205 0 : std::vector<accparser::Int_exprContext *> accparser::Int_expr_listContext::int_expr() {
13206 0 : return getRuleContexts<accparser::Int_exprContext>();
13207 : }
13208 :
13209 0 : accparser::Int_exprContext* accparser::Int_expr_listContext::int_expr(size_t i) {
13210 0 : return getRuleContext<accparser::Int_exprContext>(i);
13211 : }
13212 :
13213 0 : std::vector<tree::TerminalNode *> accparser::Int_expr_listContext::COMMA() {
13214 0 : return getTokens(accparser::COMMA);
13215 : }
13216 :
13217 0 : tree::TerminalNode* accparser::Int_expr_listContext::COMMA(size_t i) {
13218 0 : return getToken(accparser::COMMA, i);
13219 : }
13220 :
13221 :
13222 0 : size_t accparser::Int_expr_listContext::getRuleIndex() const {
13223 0 : return accparser::RuleInt_expr_list;
13224 : }
13225 :
13226 0 : void accparser::Int_expr_listContext::enterRule(tree::ParseTreeListener *listener) {
13227 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13228 0 : if (parserListener != nullptr)
13229 0 : parserListener->enterInt_expr_list(this);
13230 0 : }
13231 :
13232 0 : void accparser::Int_expr_listContext::exitRule(tree::ParseTreeListener *listener) {
13233 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13234 0 : if (parserListener != nullptr)
13235 0 : parserListener->exitInt_expr_list(this);
13236 0 : }
13237 :
13238 :
13239 0 : antlrcpp::Any accparser::Int_expr_listContext::accept(tree::ParseTreeVisitor *visitor) {
13240 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
13241 0 : return parserVisitor->visitInt_expr_list(this);
13242 : else
13243 0 : return visitor->visitChildren(this);
13244 : }
13245 :
13246 0 : accparser::Int_expr_listContext* accparser::int_expr_list() {
13247 0 : Int_expr_listContext *_localctx = _tracker.createInstance<Int_expr_listContext>(_ctx, getState());
13248 0 : enterRule(_localctx, 298, accparser::RuleInt_expr_list);
13249 0 : size_t _la = 0;
13250 :
13251 0 : auto onExit = finally([=] {
13252 0 : exitRule();
13253 0 : });
13254 0 : try {
13255 0 : enterOuterAlt(_localctx, 1);
13256 0 : setState(1199);
13257 0 : _errHandler->sync(this);
13258 0 : _la = _input->LA(1);
13259 0 : do {
13260 0 : setState(1199);
13261 0 : _errHandler->sync(this);
13262 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx)) {
13263 0 : case 1: {
13264 0 : setState(1195);
13265 0 : int_expr();
13266 0 : setState(1196);
13267 0 : match(accparser::COMMA);
13268 : break;
13269 : }
13270 :
13271 0 : case 2: {
13272 0 : setState(1198);
13273 0 : int_expr();
13274 : break;
13275 : }
13276 :
13277 : }
13278 0 : setState(1201);
13279 0 : _errHandler->sync(this);
13280 0 : _la = _input->LA(1);
13281 0 : } while (_la == accparser::EXPR);
13282 :
13283 : }
13284 0 : catch (RecognitionException &e) {
13285 0 : _errHandler->reportError(this, e);
13286 0 : _localctx->exception = std::current_exception();
13287 0 : _errHandler->recover(this, _localctx->exception);
13288 : }
13289 :
13290 0 : return _localctx;
13291 : }
13292 :
13293 : //----------------- Int_exprContext ------------------------------------------------------------------
13294 :
13295 0 : accparser::Int_exprContext::Int_exprContext(ParserRuleContext *parent, size_t invokingState)
13296 0 : : ParserRuleContext(parent, invokingState) {
13297 0 : }
13298 :
13299 0 : tree::TerminalNode* accparser::Int_exprContext::EXPR() {
13300 0 : return getToken(accparser::EXPR, 0);
13301 : }
13302 :
13303 :
13304 0 : size_t accparser::Int_exprContext::getRuleIndex() const {
13305 0 : return accparser::RuleInt_expr;
13306 : }
13307 :
13308 0 : void accparser::Int_exprContext::enterRule(tree::ParseTreeListener *listener) {
13309 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13310 0 : if (parserListener != nullptr)
13311 0 : parserListener->enterInt_expr(this);
13312 0 : }
13313 :
13314 0 : void accparser::Int_exprContext::exitRule(tree::ParseTreeListener *listener) {
13315 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13316 0 : if (parserListener != nullptr)
13317 0 : parserListener->exitInt_expr(this);
13318 0 : }
13319 :
13320 :
13321 0 : antlrcpp::Any accparser::Int_exprContext::accept(tree::ParseTreeVisitor *visitor) {
13322 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
13323 0 : return parserVisitor->visitInt_expr(this);
13324 : else
13325 0 : return visitor->visitChildren(this);
13326 : }
13327 :
13328 0 : accparser::Int_exprContext* accparser::int_expr() {
13329 0 : Int_exprContext *_localctx = _tracker.createInstance<Int_exprContext>(_ctx, getState());
13330 0 : enterRule(_localctx, 300, accparser::RuleInt_expr);
13331 :
13332 0 : auto onExit = finally([=] {
13333 0 : exitRule();
13334 0 : });
13335 0 : try {
13336 0 : enterOuterAlt(_localctx, 1);
13337 0 : setState(1203);
13338 0 : match(accparser::EXPR);
13339 :
13340 : }
13341 0 : catch (RecognitionException &e) {
13342 0 : _errHandler->reportError(this, e);
13343 0 : _localctx->exception = std::current_exception();
13344 0 : _errHandler->recover(this, _localctx->exception);
13345 : }
13346 :
13347 0 : return _localctx;
13348 : }
13349 :
13350 : //----------------- Var_listContext ------------------------------------------------------------------
13351 :
13352 0 : accparser::Var_listContext::Var_listContext(ParserRuleContext *parent, size_t invokingState)
13353 0 : : ParserRuleContext(parent, invokingState) {
13354 0 : }
13355 :
13356 0 : std::vector<accparser::VarContext *> accparser::Var_listContext::var() {
13357 0 : return getRuleContexts<accparser::VarContext>();
13358 : }
13359 :
13360 0 : accparser::VarContext* accparser::Var_listContext::var(size_t i) {
13361 0 : return getRuleContext<accparser::VarContext>(i);
13362 : }
13363 :
13364 0 : std::vector<tree::TerminalNode *> accparser::Var_listContext::COMMA() {
13365 0 : return getTokens(accparser::COMMA);
13366 : }
13367 :
13368 0 : tree::TerminalNode* accparser::Var_listContext::COMMA(size_t i) {
13369 0 : return getToken(accparser::COMMA, i);
13370 : }
13371 :
13372 :
13373 0 : size_t accparser::Var_listContext::getRuleIndex() const {
13374 0 : return accparser::RuleVar_list;
13375 : }
13376 :
13377 0 : void accparser::Var_listContext::enterRule(tree::ParseTreeListener *listener) {
13378 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13379 0 : if (parserListener != nullptr)
13380 0 : parserListener->enterVar_list(this);
13381 0 : }
13382 :
13383 0 : void accparser::Var_listContext::exitRule(tree::ParseTreeListener *listener) {
13384 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13385 0 : if (parserListener != nullptr)
13386 0 : parserListener->exitVar_list(this);
13387 0 : }
13388 :
13389 :
13390 0 : antlrcpp::Any accparser::Var_listContext::accept(tree::ParseTreeVisitor *visitor) {
13391 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
13392 0 : return parserVisitor->visitVar_list(this);
13393 : else
13394 0 : return visitor->visitChildren(this);
13395 : }
13396 :
13397 0 : accparser::Var_listContext* accparser::var_list() {
13398 0 : Var_listContext *_localctx = _tracker.createInstance<Var_listContext>(_ctx, getState());
13399 0 : enterRule(_localctx, 302, accparser::RuleVar_list);
13400 0 : size_t _la = 0;
13401 :
13402 0 : auto onExit = finally([=] {
13403 0 : exitRule();
13404 0 : });
13405 0 : try {
13406 0 : enterOuterAlt(_localctx, 1);
13407 0 : setState(1209);
13408 0 : _errHandler->sync(this);
13409 0 : _la = _input->LA(1);
13410 0 : do {
13411 0 : setState(1209);
13412 0 : _errHandler->sync(this);
13413 0 : switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 67, _ctx)) {
13414 0 : case 1: {
13415 0 : setState(1205);
13416 0 : var();
13417 0 : setState(1206);
13418 0 : match(accparser::COMMA);
13419 : break;
13420 : }
13421 :
13422 0 : case 2: {
13423 0 : setState(1208);
13424 0 : var();
13425 : break;
13426 : }
13427 :
13428 : }
13429 0 : setState(1211);
13430 0 : _errHandler->sync(this);
13431 0 : _la = _input->LA(1);
13432 0 : } while (_la == accparser::EXPR);
13433 :
13434 : }
13435 0 : catch (RecognitionException &e) {
13436 0 : _errHandler->reportError(this, e);
13437 0 : _localctx->exception = std::current_exception();
13438 0 : _errHandler->recover(this, _localctx->exception);
13439 : }
13440 :
13441 0 : return _localctx;
13442 : }
13443 :
13444 : //----------------- VarContext ------------------------------------------------------------------
13445 :
13446 0 : accparser::VarContext::VarContext(ParserRuleContext *parent, size_t invokingState)
13447 0 : : ParserRuleContext(parent, invokingState) {
13448 0 : }
13449 :
13450 0 : tree::TerminalNode* accparser::VarContext::EXPR() {
13451 0 : return getToken(accparser::EXPR, 0);
13452 : }
13453 :
13454 :
13455 0 : size_t accparser::VarContext::getRuleIndex() const {
13456 0 : return accparser::RuleVar;
13457 : }
13458 :
13459 0 : void accparser::VarContext::enterRule(tree::ParseTreeListener *listener) {
13460 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13461 0 : if (parserListener != nullptr)
13462 0 : parserListener->enterVar(this);
13463 0 : }
13464 :
13465 0 : void accparser::VarContext::exitRule(tree::ParseTreeListener *listener) {
13466 0 : auto parserListener = dynamic_cast<accparserListener *>(listener);
13467 0 : if (parserListener != nullptr)
13468 0 : parserListener->exitVar(this);
13469 0 : }
13470 :
13471 :
13472 0 : antlrcpp::Any accparser::VarContext::accept(tree::ParseTreeVisitor *visitor) {
13473 0 : if (auto parserVisitor = dynamic_cast<accparserVisitor*>(visitor))
13474 0 : return parserVisitor->visitVar(this);
13475 : else
13476 0 : return visitor->visitChildren(this);
13477 : }
13478 :
13479 0 : accparser::VarContext* accparser::var() {
13480 0 : VarContext *_localctx = _tracker.createInstance<VarContext>(_ctx, getState());
13481 0 : enterRule(_localctx, 304, accparser::RuleVar);
13482 :
13483 0 : auto onExit = finally([=] {
13484 :
13485 0 : cleanUp();
13486 :
13487 0 : exitRule();
13488 0 : });
13489 0 : try {
13490 0 : enterOuterAlt(_localctx, 1);
13491 0 : setState(1213);
13492 0 : match(accparser::EXPR);
13493 :
13494 : }
13495 0 : catch (RecognitionException &e) {
13496 0 : _errHandler->reportError(this, e);
13497 0 : _localctx->exception = std::current_exception();
13498 0 : _errHandler->recover(this, _localctx->exception);
13499 : }
13500 :
13501 0 : return _localctx;
13502 : }
13503 :
13504 : // Static vars and initialization.
13505 : std::vector<dfa::DFA> accparser::_decisionToDFA;
13506 : atn::PredictionContextCache accparser::_sharedContextCache;
13507 :
13508 : // We own the ATN which in turn owns the ATN states.
13509 : atn::ATN accparser::_atn;
13510 : std::vector<uint16_t> accparser::_serializedATN;
13511 :
13512 : std::vector<std::string> accparser::_ruleNames = {
13513 : "acc", "prefix", "c_prefix", "fortran_prefix", "openacc_directive", "atomic_directive",
13514 : "atomic_clause", "cache_directive", "cache_directive_modifier", "data_directive",
13515 : "data_clause_list", "data_clauses", "declare_directive", "declare_clause_list",
13516 : "declare_clauses", "end_directive", "end_clause_seq", "fortran_paired_directive",
13517 : "end_atomic_directive", "end_data_directive", "end_host_data_directive",
13518 : "end_kernels_directive", "end_kernels_loop_directive", "end_parallel_directive",
13519 : "end_parallel_loop_directive", "end_serial_directive", "end_serial_loop_directive",
13520 : "enter_data_directive", "enter_data_clause_list", "enter_data_clauses",
13521 : "exit_data_directive", "exit_data_clause_list", "exit_data_clauses", "host_data_directive",
13522 : "host_data_clause_list", "host_data_clauses", "init_directive", "init_clause_list",
13523 : "init_clauses", "kernels_directive", "kernels_clause_list", "kernels_clauses",
13524 : "kernels_loop_directive", "kernels_loop_clause_list", "kernels_loop_clauses",
13525 : "loop_directive", "loop_clause_list", "loop_clauses", "parallel_directive",
13526 : "parallel_clause_list", "parallel_clauses", "parallel_loop_directive",
13527 : "parallel_loop_clause_list", "parallel_loop_clauses", "routine_directive",
13528 : "routine_clause_list", "routine_clauses", "name", "serial_directive",
13529 : "serial_clause_list", "serial_clauses", "serial_loop_directive", "serial_loop_clause_list",
13530 : "serial_loop_clauses", "set_directive", "set_clause_list", "set_clauses",
13531 : "shutdown_directive", "shutdown_clause_list", "shutdown_clauses", "update_directive",
13532 : "update_clause_list", "update_clauses", "wait_directive", "wait_clause_list",
13533 : "wait_clauses", "async_clause", "attach_clause", "auto_clause", "bind_clause",
13534 : "name_or_string", "capture_clause", "collapse_clause", "copy_clause",
13535 : "copyin_clause", "copyin_clause_modifier", "copyin_no_modifier_clause",
13536 : "copyout_clause", "copyout_clause_modifier", "copyout_no_modifier_clause",
13537 : "create_clause", "create_clause_modifier", "create_no_modifier_clause",
13538 : "default_clause", "default_kind", "default_async_clause", "delete_clause",
13539 : "detach_clause", "device_clause", "device_num_clause", "device_resident_clause",
13540 : "device_type_clause", "device_type_list", "deviceptr_clause", "finalize_clause",
13541 : "firstprivate_clause", "gang_clause", "gang_arg_list", "gang_no_list_clause",
13542 : "host_clause", "if_clause", "if_present_clause", "independent_clause",
13543 : "link_clause", "nohost_clause", "no_create_clause", "num_gangs_clause",
13544 : "num_workers_clause", "present_clause", "private_clause", "read_clause",
13545 : "reduction_clause", "reduction_operator", "self_clause", "self_list_clause",
13546 : "condition", "seq_clause", "tile_clause", "update_clause", "size_expr_list",
13547 : "use_device_clause", "vector_clause", "vector_clause_args", "vector_clause_modifier",
13548 : "vector_no_modifier_clause", "vector_length_clause", "wait_clause", "wait_argument_clause",
13549 : "wait_argument", "wait_int_expr_list", "wait_int_expr", "wait_argument_queues",
13550 : "wait_argument_int_expr", "worker_clause", "worker_clause_args", "worker_clause_modifier",
13551 : "worker_no_modifier_clause", "write_clause", "const_int", "int_expr_list",
13552 : "int_expr", "var_list", "var"
13553 : };
13554 :
13555 : std::vector<std::string> accparser::_literalNames = {
13556 : "", "", "", "", "'acc'", "'atomic'", "'cache'", "'data'", "'end'", "'declare'",
13557 : "'enter'", "'exit'", "'host_data'", "'init'", "'kernels'", "'loop'", "'parallel'",
13558 : "", "'serial'", "'set'", "'shutdown'", "'update'", "", "", "", "':'",
13559 : "", "", "'attach'", "'auto'", "", "'capture'", "'collapse'", "'copy'",
13560 : "'copyin'", "'copyout'", "'create'", "'default'", "'default_async'", "'delete'",
13561 : "'detach'", "'device'", "'device_num'", "'device_resident'", "'device_type'",
13562 : "'deviceptr'", "'finalize'", "'firstprivate'", "", "'host'", "", "'if_present'",
13563 : "'independent'", "'link'", "'nohost'", "'no_create'", "'num'", "'num_gangs'",
13564 : "'num_workers'", "", "'private'", "'read'", "'reduction'", "", "'seq'",
13565 : "'tile'", "'use_device'", "", "'vector_length'", "", "", "'write'", "",
13566 : "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
13567 : "", "", "", "", "", "", "", "", "", "'none'"
13568 : };
13569 :
13570 : std::vector<std::string> accparser::_symbolicNames = {
13571 : "", "EXPR", "C_PREFIX", "FORTRAN_PREFIX", "ACC", "ATOMIC", "CACHE", "DATA",
13572 : "END", "DECLARE", "ENTER", "EXIT", "HOST_DATA", "INIT", "KERNELS", "LOOP",
13573 : "PARALLEL", "ROUTINE", "SERIAL", "SET", "SHUTDOWN", "UPDATE", "LEFT_PAREN",
13574 : "RIGHT_PAREN", "D_BLANK", "COLON", "LINE_END", "ASYNC", "ATTACH", "AUTO",
13575 : "BIND", "CAPTURE", "COLLAPSE", "COPY", "COPYIN", "COPYOUT", "CREATE",
13576 : "DEFAULT", "DEFAULT_ASYNC", "DELETE", "DETACH", "DEVICE", "DEVICE_NUM",
13577 : "DEVICE_RESIDENT", "DEVICE_TYPE", "DEVICEPTR", "FINALIZE", "FIRSTPRIVATE",
13578 : "GANG", "HOST", "IF", "IF_PRESENT", "INDEPENDENT", "LINK", "NOHOST", "NO_CREATE",
13579 : "NUM", "NUM_GANGS", "NUM_WORKERS", "PRESENT", "PRIVATE", "READ", "REDUCTION",
13580 : "SELF", "SEQ", "TILE", "USE_DEVICE", "VECTOR", "VECTOR_LENGTH", "WAIT",
13581 : "WORKER", "WRITE", "COMMENT", "CACHE_LEFT_PAREN", "CACHE_READONLY", "CACHE_COLON",
13582 : "CACHE_COMMA", "CACHE_BLANK", "CACHE_LINE_END", "ROUTINE_LEFT_PAREN",
13583 : "ROUTINE_BLANK", "ROUTINE_LINE_END", "COPYIN_LEFT_PAREN", "READONLY",
13584 : "COPYIN_COLON", "COPYIN_COMMA", "COPYIN_BLANK", "COPYIN_LINE_END", "COPYOUT_LEFT_PAREN",
13585 : "ZERO", "COPYOUT_COLON", "COPYOUT_COMMA", "COPYOUT_BLANK", "COPYOUT_LINE_END",
13586 : "CREATE_LEFT_PAREN", "CREATE_ZERO", "CREATE_COLON", "CREATE_COMMA", "CREATE_BLANK",
13587 : "CREATE_LINE_END", "NONE", "BLANK", "EXPR_LINE_END", "VECTOR_LEFT_PAREN",
13588 : "LENGTH", "VECTOR_COLON", "VECTOR_BLANK", "VECTOR_LINE_END", "REDUCTION_LEFT_PAREN",
13589 : "ADD", "MUL", "MAX", "MIN", "BITAND", "BITOR", "BITXOR", "LOGAND", "LOGOR",
13590 : "REDUCTION_COLON", "REDUCTION_COMMA", "REDUCTION_BLANK", "REDUCTION_LINE_END",
13591 : "WAIT_LEFT_PAREN", "DEVNUM", "QUEUES", "WAIT_COLON", "WAIT_COMMA", "WAIT_BLANK",
13592 : "WAIT_LINE_END", "WORKER_LEFT_PAREN", "WORKER_NUM", "WORKER_COLON", "WORKER_BLANK",
13593 : "WORKER_LINE_END", "EXPR_LEFT_PAREN", "COMMA", "EXPRESSION_LEFT_PAREN",
13594 : "EXPRESSION_RIGHT_PAREN", "EXPRESSION_CHAR"
13595 : };
13596 :
13597 : dfa::Vocabulary accparser::_vocabulary(_literalNames, _symbolicNames);
13598 :
13599 : std::vector<std::string> accparser::_tokenNames;
13600 :
13601 356 : accparser::Initializer::Initializer() {
13602 49840 : for (size_t i = 0; i < _symbolicNames.size(); ++i) {
13603 98968 : std::string name = _vocabulary.getLiteralName(i);
13604 49484 : if (name.empty()) {
13605 29904 : name = _vocabulary.getSymbolicName(i);
13606 : }
13607 :
13608 49484 : if (name.empty()) {
13609 712 : _tokenNames.push_back("<INVALID>");
13610 : } else {
13611 49128 : _tokenNames.push_back(name);
13612 : }
13613 : }
13614 :
13615 356 : _serializedATN = {
13616 : 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964,
13617 : 0x3, 0x8c, 0x4c2, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4,
13618 : 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7,
13619 : 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb,
13620 : 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe,
13621 : 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4,
13622 : 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15,
13623 : 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9,
13624 : 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b,
13625 : 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4,
13626 : 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22,
13627 : 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9,
13628 : 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28,
13629 : 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4,
13630 : 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f,
13631 : 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9,
13632 : 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35,
13633 : 0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4,
13634 : 0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c,
13635 : 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9,
13636 : 0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42,
13637 : 0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4,
13638 : 0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x4, 0x49,
13639 : 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4, 0x4c, 0x9,
13640 : 0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f,
13641 : 0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x4, 0x52, 0x9, 0x52, 0x4,
13642 : 0x53, 0x9, 0x53, 0x4, 0x54, 0x9, 0x54, 0x4, 0x55, 0x9, 0x55, 0x4, 0x56,
13643 : 0x9, 0x56, 0x4, 0x57, 0x9, 0x57, 0x4, 0x58, 0x9, 0x58, 0x4, 0x59, 0x9,
13644 : 0x59, 0x4, 0x5a, 0x9, 0x5a, 0x4, 0x5b, 0x9, 0x5b, 0x4, 0x5c, 0x9, 0x5c,
13645 : 0x4, 0x5d, 0x9, 0x5d, 0x4, 0x5e, 0x9, 0x5e, 0x4, 0x5f, 0x9, 0x5f, 0x4,
13646 : 0x60, 0x9, 0x60, 0x4, 0x61, 0x9, 0x61, 0x4, 0x62, 0x9, 0x62, 0x4, 0x63,
13647 : 0x9, 0x63, 0x4, 0x64, 0x9, 0x64, 0x4, 0x65, 0x9, 0x65, 0x4, 0x66, 0x9,
13648 : 0x66, 0x4, 0x67, 0x9, 0x67, 0x4, 0x68, 0x9, 0x68, 0x4, 0x69, 0x9, 0x69,
13649 : 0x4, 0x6a, 0x9, 0x6a, 0x4, 0x6b, 0x9, 0x6b, 0x4, 0x6c, 0x9, 0x6c, 0x4,
13650 : 0x6d, 0x9, 0x6d, 0x4, 0x6e, 0x9, 0x6e, 0x4, 0x6f, 0x9, 0x6f, 0x4, 0x70,
13651 : 0x9, 0x70, 0x4, 0x71, 0x9, 0x71, 0x4, 0x72, 0x9, 0x72, 0x4, 0x73, 0x9,
13652 : 0x73, 0x4, 0x74, 0x9, 0x74, 0x4, 0x75, 0x9, 0x75, 0x4, 0x76, 0x9, 0x76,
13653 : 0x4, 0x77, 0x9, 0x77, 0x4, 0x78, 0x9, 0x78, 0x4, 0x79, 0x9, 0x79, 0x4,
13654 : 0x7a, 0x9, 0x7a, 0x4, 0x7b, 0x9, 0x7b, 0x4, 0x7c, 0x9, 0x7c, 0x4, 0x7d,
13655 : 0x9, 0x7d, 0x4, 0x7e, 0x9, 0x7e, 0x4, 0x7f, 0x9, 0x7f, 0x4, 0x80, 0x9,
13656 : 0x80, 0x4, 0x81, 0x9, 0x81, 0x4, 0x82, 0x9, 0x82, 0x4, 0x83, 0x9, 0x83,
13657 : 0x4, 0x84, 0x9, 0x84, 0x4, 0x85, 0x9, 0x85, 0x4, 0x86, 0x9, 0x86, 0x4,
13658 : 0x87, 0x9, 0x87, 0x4, 0x88, 0x9, 0x88, 0x4, 0x89, 0x9, 0x89, 0x4, 0x8a,
13659 : 0x9, 0x8a, 0x4, 0x8b, 0x9, 0x8b, 0x4, 0x8c, 0x9, 0x8c, 0x4, 0x8d, 0x9,
13660 : 0x8d, 0x4, 0x8e, 0x9, 0x8e, 0x4, 0x8f, 0x9, 0x8f, 0x4, 0x90, 0x9, 0x90,
13661 : 0x4, 0x91, 0x9, 0x91, 0x4, 0x92, 0x9, 0x92, 0x4, 0x93, 0x9, 0x93, 0x4,
13662 : 0x94, 0x9, 0x94, 0x4, 0x95, 0x9, 0x95, 0x4, 0x96, 0x9, 0x96, 0x4, 0x97,
13663 : 0x9, 0x97, 0x4, 0x98, 0x9, 0x98, 0x4, 0x99, 0x9, 0x99, 0x4, 0x9a, 0x9,
13664 : 0x9a, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3,
13665 : 0x3, 0x5, 0x3, 0x13c, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5,
13666 : 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6,
13667 : 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6,
13668 : 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6,
13669 : 0x5, 0x6, 0x157, 0xa, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x5, 0x7, 0x15c,
13670 : 0xa, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x5, 0x8, 0x162, 0xa,
13671 : 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3,
13672 : 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x5, 0x9, 0x170,
13673 : 0xa, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc,
13674 : 0x7, 0xc, 0x178, 0xa, 0xc, 0xc, 0xc, 0xe, 0xc, 0x17b, 0xb, 0xc, 0x3,
13675 : 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3,
13676 : 0xd, 0x3, 0xd, 0x3, 0xd, 0x5, 0xd, 0x187, 0xa, 0xd, 0x3, 0xe, 0x3, 0xe,
13677 : 0x3, 0xe, 0x3, 0xf, 0x6, 0xf, 0x18d, 0xa, 0xf, 0xd, 0xf, 0xe, 0xf, 0x18e,
13678 : 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3,
13679 : 0x10, 0x3, 0x10, 0x5, 0x10, 0x199, 0xa, 0x10, 0x3, 0x11, 0x3, 0x11,
13680 : 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3,
13681 : 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x5, 0x13,
13682 : 0x1a9, 0xa, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16,
13683 : 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3,
13684 : 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c,
13685 : 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x6, 0x1e, 0x1c2,
13686 : 0xa, 0x1e, 0xd, 0x1e, 0xe, 0x1e, 0x1c3, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f,
13687 : 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x5, 0x1f, 0x1cc, 0xa, 0x1f, 0x3, 0x20,
13688 : 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x6, 0x21, 0x1d3, 0xa, 0x21,
13689 : 0xd, 0x21, 0xe, 0x21, 0x1d4, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22,
13690 : 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x5, 0x22, 0x1de, 0xa, 0x22, 0x3, 0x23,
13691 : 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 0x6, 0x24, 0x1e4, 0xa, 0x24, 0xd, 0x24,
13692 : 0xe, 0x24, 0x1e5, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x5, 0x25, 0x1eb,
13693 : 0xa, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 0x3, 0x27, 0x7, 0x27, 0x1f1,
13694 : 0xa, 0x27, 0xc, 0x27, 0xe, 0x27, 0x1f4, 0xb, 0x27, 0x3, 0x28, 0x3, 0x28,
13695 : 0x3, 0x28, 0x5, 0x28, 0x1f9, 0xa, 0x28, 0x3, 0x29, 0x3, 0x29, 0x3, 0x29,
13696 : 0x3, 0x2a, 0x7, 0x2a, 0x1ff, 0xa, 0x2a, 0xc, 0x2a, 0xe, 0x2a, 0x202,
13697 : 0xb, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3,
13698 : 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b,
13699 : 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x5, 0x2b, 0x215,
13700 : 0xa, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2d, 0x7,
13701 : 0x2d, 0x21c, 0xa, 0x2d, 0xc, 0x2d, 0xe, 0x2d, 0x21f, 0xb, 0x2d, 0x3,
13702 : 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e,
13703 : 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3,
13704 : 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e,
13705 : 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3,
13706 : 0x2e, 0x5, 0x2e, 0x23c, 0xa, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f,
13707 : 0x3, 0x30, 0x7, 0x30, 0x242, 0xa, 0x30, 0xc, 0x30, 0xe, 0x30, 0x245,
13708 : 0xb, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3,
13709 : 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x5, 0x31,
13710 : 0x252, 0xa, 0x31, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x33, 0x7, 0x33,
13711 : 0x258, 0xa, 0x33, 0xc, 0x33, 0xe, 0x33, 0x25b, 0xb, 0x33, 0x3, 0x34,
13712 : 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3,
13713 : 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34,
13714 : 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x5,
13715 : 0x34, 0x271, 0xa, 0x34, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35,
13716 : 0x3, 0x36, 0x7, 0x36, 0x278, 0xa, 0x36, 0xc, 0x36, 0xe, 0x36, 0x27b,
13717 : 0xb, 0x36, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3,
13718 : 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37,
13719 : 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3,
13720 : 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37,
13721 : 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 0x299, 0xa, 0x37, 0x3, 0x38,
13722 : 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3,
13723 : 0x38, 0x5, 0x38, 0x2a3, 0xa, 0x38, 0x3, 0x39, 0x6, 0x39, 0x2a6, 0xa,
13724 : 0x39, 0xd, 0x39, 0xe, 0x39, 0x2a7, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3a,
13725 : 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3a, 0x5, 0x3a, 0x2b1, 0xa, 0x3a,
13726 : 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3d, 0x7,
13727 : 0x3d, 0x2b9, 0xa, 0x3d, 0xc, 0x3d, 0xe, 0x3d, 0x2bc, 0xb, 0x3d, 0x3,
13728 : 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e,
13729 : 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3,
13730 : 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x5, 0x3e, 0x2cf, 0xa, 0x3e,
13731 : 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x40, 0x7, 0x40, 0x2d6,
13732 : 0xa, 0x40, 0xc, 0x40, 0xe, 0x40, 0x2d9, 0xb, 0x40, 0x3, 0x41, 0x3, 0x41,
13733 : 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3,
13734 : 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41,
13735 : 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3,
13736 : 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x2f4, 0xa, 0x41,
13737 : 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, 0x7, 0x43, 0x2fa, 0xa, 0x43,
13738 : 0xc, 0x43, 0xe, 0x43, 0x2fd, 0xb, 0x43, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44,
13739 : 0x3, 0x44, 0x5, 0x44, 0x303, 0xa, 0x44, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45,
13740 : 0x3, 0x46, 0x7, 0x46, 0x309, 0xa, 0x46, 0xc, 0x46, 0xe, 0x46, 0x30c,
13741 : 0xb, 0x46, 0x3, 0x47, 0x3, 0x47, 0x3, 0x47, 0x5, 0x47, 0x311, 0xa, 0x47,
13742 : 0x3, 0x48, 0x3, 0x48, 0x3, 0x48, 0x3, 0x49, 0x6, 0x49, 0x317, 0xa, 0x49,
13743 : 0xd, 0x49, 0xe, 0x49, 0x318, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a,
13744 : 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x5, 0x4a, 0x323, 0xa, 0x4a,
13745 : 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3,
13746 : 0x4b, 0x3, 0x4b, 0x5, 0x4b, 0x32d, 0xa, 0x4b, 0x3, 0x4c, 0x7, 0x4c,
13747 : 0x330, 0xa, 0x4c, 0xc, 0x4c, 0xe, 0x4c, 0x333, 0xb, 0x4c, 0x3, 0x4d,
13748 : 0x3, 0x4d, 0x5, 0x4d, 0x337, 0xa, 0x4d, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e,
13749 : 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x5, 0x4e, 0x33f, 0xa, 0x4e, 0x3, 0x4f,
13750 : 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3,
13751 : 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x52, 0x3, 0x52,
13752 : 0x3, 0x53, 0x3, 0x53, 0x3, 0x54, 0x3, 0x54, 0x3, 0x54, 0x3, 0x54, 0x3,
13753 : 0x54, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x56,
13754 : 0x3, 0x56, 0x3, 0x56, 0x3, 0x56, 0x3, 0x56, 0x3, 0x56, 0x3, 0x56, 0x3,
13755 : 0x56, 0x3, 0x56, 0x3, 0x56, 0x3, 0x56, 0x3, 0x56, 0x5, 0x56, 0x367,
13756 : 0xa, 0x56, 0x3, 0x57, 0x3, 0x57, 0x3, 0x58, 0x3, 0x58, 0x3, 0x58, 0x3,
13757 : 0x58, 0x3, 0x58, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59,
13758 : 0x3, 0x59, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59, 0x3,
13759 : 0x59, 0x5, 0x59, 0x37c, 0xa, 0x59, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5b,
13760 : 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5c, 0x3, 0x5c, 0x3,
13761 : 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c,
13762 : 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x5, 0x5c, 0x391, 0xa, 0x5c, 0x3, 0x5d,
13763 : 0x3, 0x5d, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3,
13764 : 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x60, 0x3, 0x60,
13765 : 0x3, 0x61, 0x3, 0x61, 0x3, 0x61, 0x3, 0x61, 0x3, 0x61, 0x3, 0x62, 0x3,
13766 : 0x62, 0x3, 0x62, 0x3, 0x62, 0x3, 0x62, 0x3, 0x63, 0x3, 0x63, 0x3, 0x63,
13767 : 0x3, 0x63, 0x3, 0x63, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3,
13768 : 0x64, 0x3, 0x65, 0x3, 0x65, 0x3, 0x65, 0x3, 0x65, 0x3, 0x65, 0x3, 0x66,
13769 : 0x3, 0x66, 0x3, 0x66, 0x3, 0x66, 0x3, 0x66, 0x3, 0x67, 0x3, 0x67, 0x3,
13770 : 0x67, 0x3, 0x67, 0x3, 0x67, 0x3, 0x68, 0x3, 0x68, 0x3, 0x68, 0x3, 0x68,
13771 : 0x6, 0x68, 0x3c8, 0xa, 0x68, 0xd, 0x68, 0xe, 0x68, 0x3c9, 0x3, 0x69,
13772 : 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x6a, 0x3, 0x6a, 0x3,
13773 : 0x6b, 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6c, 0x3, 0x6c,
13774 : 0x3, 0x6c, 0x3, 0x6c, 0x3, 0x6c, 0x3, 0x6c, 0x5, 0x6c, 0x3de, 0xa, 0x6c,
13775 : 0x3, 0x6d, 0x3, 0x6d, 0x3, 0x6d, 0x3, 0x6d, 0x6, 0x6d, 0x3e4, 0xa, 0x6d,
13776 : 0xd, 0x6d, 0xe, 0x6d, 0x3e5, 0x3, 0x6e, 0x3, 0x6e, 0x3, 0x6f, 0x3, 0x6f,
13777 : 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3,
13778 : 0x70, 0x3, 0x70, 0x3, 0x71, 0x3, 0x71, 0x3, 0x72, 0x3, 0x72, 0x3, 0x73,
13779 : 0x3, 0x73, 0x3, 0x73, 0x3, 0x73, 0x3, 0x73, 0x3, 0x74, 0x3, 0x74, 0x3,
13780 : 0x75, 0x3, 0x75, 0x3, 0x75, 0x3, 0x75, 0x3, 0x75, 0x3, 0x76, 0x3, 0x76,
13781 : 0x3, 0x76, 0x3, 0x76, 0x3, 0x76, 0x3, 0x77, 0x3, 0x77, 0x3, 0x77, 0x3,
13782 : 0x77, 0x3, 0x77, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78, 0x3, 0x78,
13783 : 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x3, 0x7a, 0x3,
13784 : 0x7a, 0x3, 0x7b, 0x3, 0x7b, 0x3, 0x7b, 0x3, 0x7b, 0x3, 0x7b, 0x3, 0x7b,
13785 : 0x3, 0x7b, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x3,
13786 : 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x5, 0x7d, 0x429, 0xa, 0x7d, 0x3, 0x7e,
13787 : 0x3, 0x7e, 0x3, 0x7e, 0x3, 0x7e, 0x3, 0x7e, 0x3, 0x7f, 0x3, 0x7f, 0x3,
13788 : 0x80, 0x3, 0x80, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81,
13789 : 0x3, 0x82, 0x3, 0x82, 0x3, 0x83, 0x3, 0x83, 0x3, 0x83, 0x3, 0x83, 0x6,
13790 : 0x83, 0x43f, 0xa, 0x83, 0xd, 0x83, 0xe, 0x83, 0x440, 0x3, 0x84, 0x3,
13791 : 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85,
13792 : 0x5, 0x85, 0x44b, 0xa, 0x85, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86,
13793 : 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x5,
13794 : 0x86, 0x457, 0xa, 0x86, 0x3, 0x87, 0x3, 0x87, 0x3, 0x88, 0x3, 0x88,
13795 : 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x8a, 0x3,
13796 : 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x5, 0x8a, 0x468,
13797 : 0xa, 0x8a, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3,
13798 : 0x8b, 0x5, 0x8b, 0x470, 0xa, 0x8b, 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c,
13799 : 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c, 0x3,
13800 : 0x8c, 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c,
13801 : 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8c, 0x5, 0x8c, 0x485, 0xa, 0x8c, 0x3, 0x8d,
13802 : 0x3, 0x8d, 0x3, 0x8d, 0x3, 0x8d, 0x6, 0x8d, 0x48b, 0xa, 0x8d, 0xd, 0x8d,
13803 : 0xe, 0x8d, 0x48c, 0x3, 0x8e, 0x3, 0x8e, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x90,
13804 : 0x3, 0x90, 0x3, 0x91, 0x3, 0x91, 0x3, 0x91, 0x5, 0x91, 0x498, 0xa, 0x91,
13805 : 0x3, 0x92, 0x3, 0x92, 0x3, 0x92, 0x3, 0x92, 0x3, 0x92, 0x3, 0x92, 0x3,
13806 : 0x92, 0x3, 0x92, 0x3, 0x92, 0x3, 0x92, 0x5, 0x92, 0x4a4, 0xa, 0x92,
13807 : 0x3, 0x93, 0x3, 0x93, 0x3, 0x94, 0x3, 0x94, 0x3, 0x95, 0x3, 0x95, 0x3,
13808 : 0x96, 0x3, 0x96, 0x3, 0x97, 0x3, 0x97, 0x3, 0x97, 0x3, 0x97, 0x6, 0x97,
13809 : 0x4b2, 0xa, 0x97, 0xd, 0x97, 0xe, 0x97, 0x4b3, 0x3, 0x98, 0x3, 0x98,
13810 : 0x3, 0x99, 0x3, 0x99, 0x3, 0x99, 0x3, 0x99, 0x6, 0x99, 0x4bc, 0xa, 0x99,
13811 : 0xd, 0x99, 0xe, 0x99, 0x4bd, 0x3, 0x9a, 0x3, 0x9a, 0x3, 0x9a, 0x2, 0x2,
13812 : 0x9b, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18,
13813 : 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30,
13814 : 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48,
13815 : 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60,
13816 : 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78,
13817 : 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90,
13818 : 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6, 0xa8,
13819 : 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, 0xc0,
13820 : 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8,
13821 : 0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0,
13822 : 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x100, 0x102, 0x104, 0x106,
13823 : 0x108, 0x10a, 0x10c, 0x10e, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11a,
13824 : 0x11c, 0x11e, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12a, 0x12c, 0x12e,
13825 : 0x130, 0x132, 0x2, 0x4, 0x4, 0x2, 0x3d, 0x3d, 0x66, 0x66, 0x3, 0x2,
13826 : 0x6f, 0x77, 0x2, 0x535, 0x2, 0x134, 0x3, 0x2, 0x2, 0x2, 0x4, 0x13b,
13827 : 0x3, 0x2, 0x2, 0x2, 0x6, 0x13d, 0x3, 0x2, 0x2, 0x2, 0x8, 0x13f, 0x3,
13828 : 0x2, 0x2, 0x2, 0xa, 0x156, 0x3, 0x2, 0x2, 0x2, 0xc, 0x15b, 0x3, 0x2,
13829 : 0x2, 0x2, 0xe, 0x161, 0x3, 0x2, 0x2, 0x2, 0x10, 0x16f, 0x3, 0x2, 0x2,
13830 : 0x2, 0x12, 0x171, 0x3, 0x2, 0x2, 0x2, 0x14, 0x173, 0x3, 0x2, 0x2, 0x2,
13831 : 0x16, 0x179, 0x3, 0x2, 0x2, 0x2, 0x18, 0x186, 0x3, 0x2, 0x2, 0x2, 0x1a,
13832 : 0x188, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x18c, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x198,
13833 : 0x3, 0x2, 0x2, 0x2, 0x20, 0x19a, 0x3, 0x2, 0x2, 0x2, 0x22, 0x19d, 0x3,
13834 : 0x2, 0x2, 0x2, 0x24, 0x1a8, 0x3, 0x2, 0x2, 0x2, 0x26, 0x1aa, 0x3, 0x2,
13835 : 0x2, 0x2, 0x28, 0x1ac, 0x3, 0x2, 0x2, 0x2, 0x2a, 0x1ae, 0x3, 0x2, 0x2,
13836 : 0x2, 0x2c, 0x1b0, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x1b2, 0x3, 0x2, 0x2, 0x2,
13837 : 0x30, 0x1b4, 0x3, 0x2, 0x2, 0x2, 0x32, 0x1b6, 0x3, 0x2, 0x2, 0x2, 0x34,
13838 : 0x1b8, 0x3, 0x2, 0x2, 0x2, 0x36, 0x1ba, 0x3, 0x2, 0x2, 0x2, 0x38, 0x1bc,
13839 : 0x3, 0x2, 0x2, 0x2, 0x3a, 0x1c1, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x1cb, 0x3,
13840 : 0x2, 0x2, 0x2, 0x3e, 0x1cd, 0x3, 0x2, 0x2, 0x2, 0x40, 0x1d2, 0x3, 0x2,
13841 : 0x2, 0x2, 0x42, 0x1dd, 0x3, 0x2, 0x2, 0x2, 0x44, 0x1df, 0x3, 0x2, 0x2,
13842 : 0x2, 0x46, 0x1e3, 0x3, 0x2, 0x2, 0x2, 0x48, 0x1ea, 0x3, 0x2, 0x2, 0x2,
13843 : 0x4a, 0x1ec, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x1f2, 0x3, 0x2, 0x2, 0x2, 0x4e,
13844 : 0x1f8, 0x3, 0x2, 0x2, 0x2, 0x50, 0x1fa, 0x3, 0x2, 0x2, 0x2, 0x52, 0x200,
13845 : 0x3, 0x2, 0x2, 0x2, 0x54, 0x214, 0x3, 0x2, 0x2, 0x2, 0x56, 0x216, 0x3,
13846 : 0x2, 0x2, 0x2, 0x58, 0x21d, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x23b, 0x3, 0x2,
13847 : 0x2, 0x2, 0x5c, 0x23d, 0x3, 0x2, 0x2, 0x2, 0x5e, 0x243, 0x3, 0x2, 0x2,
13848 : 0x2, 0x60, 0x251, 0x3, 0x2, 0x2, 0x2, 0x62, 0x253, 0x3, 0x2, 0x2, 0x2,
13849 : 0x64, 0x259, 0x3, 0x2, 0x2, 0x2, 0x66, 0x270, 0x3, 0x2, 0x2, 0x2, 0x68,
13850 : 0x272, 0x3, 0x2, 0x2, 0x2, 0x6a, 0x279, 0x3, 0x2, 0x2, 0x2, 0x6c, 0x298,
13851 : 0x3, 0x2, 0x2, 0x2, 0x6e, 0x2a2, 0x3, 0x2, 0x2, 0x2, 0x70, 0x2a5, 0x3,
13852 : 0x2, 0x2, 0x2, 0x72, 0x2b0, 0x3, 0x2, 0x2, 0x2, 0x74, 0x2b2, 0x3, 0x2,
13853 : 0x2, 0x2, 0x76, 0x2b4, 0x3, 0x2, 0x2, 0x2, 0x78, 0x2ba, 0x3, 0x2, 0x2,
13854 : 0x2, 0x7a, 0x2ce, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x2d0, 0x3, 0x2, 0x2, 0x2,
13855 : 0x7e, 0x2d7, 0x3, 0x2, 0x2, 0x2, 0x80, 0x2f3, 0x3, 0x2, 0x2, 0x2, 0x82,
13856 : 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x84, 0x2fb, 0x3, 0x2, 0x2, 0x2, 0x86, 0x302,
13857 : 0x3, 0x2, 0x2, 0x2, 0x88, 0x304, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x30a, 0x3,
13858 : 0x2, 0x2, 0x2, 0x8c, 0x310, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x312, 0x3, 0x2,
13859 : 0x2, 0x2, 0x90, 0x316, 0x3, 0x2, 0x2, 0x2, 0x92, 0x322, 0x3, 0x2, 0x2,
13860 : 0x2, 0x94, 0x32c, 0x3, 0x2, 0x2, 0x2, 0x96, 0x331, 0x3, 0x2, 0x2, 0x2,
13861 : 0x98, 0x336, 0x3, 0x2, 0x2, 0x2, 0x9a, 0x33e, 0x3, 0x2, 0x2, 0x2, 0x9c,
13862 : 0x340, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x345, 0x3, 0x2, 0x2, 0x2, 0xa0, 0x347,
13863 : 0x3, 0x2, 0x2, 0x2, 0xa2, 0x34c, 0x3, 0x2, 0x2, 0x2, 0xa4, 0x34e, 0x3,
13864 : 0x2, 0x2, 0x2, 0xa6, 0x350, 0x3, 0x2, 0x2, 0x2, 0xa8, 0x355, 0x3, 0x2,
13865 : 0x2, 0x2, 0xaa, 0x366, 0x3, 0x2, 0x2, 0x2, 0xac, 0x368, 0x3, 0x2, 0x2,
13866 : 0x2, 0xae, 0x36a, 0x3, 0x2, 0x2, 0x2, 0xb0, 0x37b, 0x3, 0x2, 0x2, 0x2,
13867 : 0xb2, 0x37d, 0x3, 0x2, 0x2, 0x2, 0xb4, 0x37f, 0x3, 0x2, 0x2, 0x2, 0xb6,
13868 : 0x390, 0x3, 0x2, 0x2, 0x2, 0xb8, 0x392, 0x3, 0x2, 0x2, 0x2, 0xba, 0x394,
13869 : 0x3, 0x2, 0x2, 0x2, 0xbc, 0x399, 0x3, 0x2, 0x2, 0x2, 0xbe, 0x39e, 0x3,
13870 : 0x2, 0x2, 0x2, 0xc0, 0x3a0, 0x3, 0x2, 0x2, 0x2, 0xc2, 0x3a5, 0x3, 0x2,
13871 : 0x2, 0x2, 0xc4, 0x3aa, 0x3, 0x2, 0x2, 0x2, 0xc6, 0x3af, 0x3, 0x2, 0x2,
13872 : 0x2, 0xc8, 0x3b4, 0x3, 0x2, 0x2, 0x2, 0xca, 0x3b9, 0x3, 0x2, 0x2, 0x2,
13873 : 0xcc, 0x3be, 0x3, 0x2, 0x2, 0x2, 0xce, 0x3c7, 0x3, 0x2, 0x2, 0x2, 0xd0,
13874 : 0x3cb, 0x3, 0x2, 0x2, 0x2, 0xd2, 0x3d0, 0x3, 0x2, 0x2, 0x2, 0xd4, 0x3d2,
13875 : 0x3, 0x2, 0x2, 0x2, 0xd6, 0x3dd, 0x3, 0x2, 0x2, 0x2, 0xd8, 0x3e3, 0x3,
13876 : 0x2, 0x2, 0x2, 0xda, 0x3e7, 0x3, 0x2, 0x2, 0x2, 0xdc, 0x3e9, 0x3, 0x2,
13877 : 0x2, 0x2, 0xde, 0x3ee, 0x3, 0x2, 0x2, 0x2, 0xe0, 0x3f3, 0x3, 0x2, 0x2,
13878 : 0x2, 0xe2, 0x3f5, 0x3, 0x2, 0x2, 0x2, 0xe4, 0x3f7, 0x3, 0x2, 0x2, 0x2,
13879 : 0xe6, 0x3fc, 0x3, 0x2, 0x2, 0x2, 0xe8, 0x3fe, 0x3, 0x2, 0x2, 0x2, 0xea,
13880 : 0x403, 0x3, 0x2, 0x2, 0x2, 0xec, 0x408, 0x3, 0x2, 0x2, 0x2, 0xee, 0x40d,
13881 : 0x3, 0x2, 0x2, 0x2, 0xf0, 0x412, 0x3, 0x2, 0x2, 0x2, 0xf2, 0x417, 0x3,
13882 : 0x2, 0x2, 0x2, 0xf4, 0x419, 0x3, 0x2, 0x2, 0x2, 0xf6, 0x420, 0x3, 0x2,
13883 : 0x2, 0x2, 0xf8, 0x428, 0x3, 0x2, 0x2, 0x2, 0xfa, 0x42a, 0x3, 0x2, 0x2,
13884 : 0x2, 0xfc, 0x42f, 0x3, 0x2, 0x2, 0x2, 0xfe, 0x431, 0x3, 0x2, 0x2, 0x2,
13885 : 0x100, 0x433, 0x3, 0x2, 0x2, 0x2, 0x102, 0x438, 0x3, 0x2, 0x2, 0x2,
13886 : 0x104, 0x43e, 0x3, 0x2, 0x2, 0x2, 0x106, 0x442, 0x3, 0x2, 0x2, 0x2,
13887 : 0x108, 0x44a, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x456, 0x3, 0x2, 0x2, 0x2,
13888 : 0x10c, 0x458, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x45a, 0x3, 0x2, 0x2, 0x2,
13889 : 0x110, 0x45c, 0x3, 0x2, 0x2, 0x2, 0x112, 0x467, 0x3, 0x2, 0x2, 0x2,
13890 : 0x114, 0x46f, 0x3, 0x2, 0x2, 0x2, 0x116, 0x484, 0x3, 0x2, 0x2, 0x2,
13891 : 0x118, 0x48a, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x48e, 0x3, 0x2, 0x2, 0x2,
13892 : 0x11c, 0x490, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x492, 0x3, 0x2, 0x2, 0x2,
13893 : 0x120, 0x497, 0x3, 0x2, 0x2, 0x2, 0x122, 0x4a3, 0x3, 0x2, 0x2, 0x2,
13894 : 0x124, 0x4a5, 0x3, 0x2, 0x2, 0x2, 0x126, 0x4a7, 0x3, 0x2, 0x2, 0x2,
13895 : 0x128, 0x4a9, 0x3, 0x2, 0x2, 0x2, 0x12a, 0x4ab, 0x3, 0x2, 0x2, 0x2,
13896 : 0x12c, 0x4b1, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x4b5, 0x3, 0x2, 0x2, 0x2,
13897 : 0x130, 0x4bb, 0x3, 0x2, 0x2, 0x2, 0x132, 0x4bf, 0x3, 0x2, 0x2, 0x2,
13898 : 0x134, 0x135, 0x5, 0x4, 0x3, 0x2, 0x135, 0x136, 0x7, 0x6, 0x2, 0x2,
13899 : 0x136, 0x137, 0x5, 0xa, 0x6, 0x2, 0x137, 0x138, 0x7, 0x2, 0x2, 0x3,
13900 : 0x138, 0x3, 0x3, 0x2, 0x2, 0x2, 0x139, 0x13c, 0x5, 0x6, 0x4, 0x2, 0x13a,
13901 : 0x13c, 0x5, 0x8, 0x5, 0x2, 0x13b, 0x139, 0x3, 0x2, 0x2, 0x2, 0x13b,
13902 : 0x13a, 0x3, 0x2, 0x2, 0x2, 0x13c, 0x5, 0x3, 0x2, 0x2, 0x2, 0x13d, 0x13e,
13903 : 0x7, 0x4, 0x2, 0x2, 0x13e, 0x7, 0x3, 0x2, 0x2, 0x2, 0x13f, 0x140, 0x7,
13904 : 0x5, 0x2, 0x2, 0x140, 0x9, 0x3, 0x2, 0x2, 0x2, 0x141, 0x157, 0x5, 0xc,
13905 : 0x7, 0x2, 0x142, 0x157, 0x5, 0x10, 0x9, 0x2, 0x143, 0x157, 0x5, 0x14,
13906 : 0xb, 0x2, 0x144, 0x157, 0x5, 0x1a, 0xe, 0x2, 0x145, 0x157, 0x5, 0x20,
13907 : 0x11, 0x2, 0x146, 0x157, 0x5, 0x38, 0x1d, 0x2, 0x147, 0x157, 0x5, 0x3e,
13908 : 0x20, 0x2, 0x148, 0x157, 0x5, 0x44, 0x23, 0x2, 0x149, 0x157, 0x5, 0x4a,
13909 : 0x26, 0x2, 0x14a, 0x157, 0x5, 0x50, 0x29, 0x2, 0x14b, 0x157, 0x5, 0x56,
13910 : 0x2c, 0x2, 0x14c, 0x157, 0x5, 0x5c, 0x2f, 0x2, 0x14d, 0x157, 0x5, 0x62,
13911 : 0x32, 0x2, 0x14e, 0x157, 0x5, 0x68, 0x35, 0x2, 0x14f, 0x157, 0x5, 0x6e,
13912 : 0x38, 0x2, 0x150, 0x157, 0x5, 0x76, 0x3c, 0x2, 0x151, 0x157, 0x5, 0x7c,
13913 : 0x3f, 0x2, 0x152, 0x157, 0x5, 0x82, 0x42, 0x2, 0x153, 0x157, 0x5, 0x88,
13914 : 0x45, 0x2, 0x154, 0x157, 0x5, 0x8e, 0x48, 0x2, 0x155, 0x157, 0x5, 0x94,
13915 : 0x4b, 0x2, 0x156, 0x141, 0x3, 0x2, 0x2, 0x2, 0x156, 0x142, 0x3, 0x2,
13916 : 0x2, 0x2, 0x156, 0x143, 0x3, 0x2, 0x2, 0x2, 0x156, 0x144, 0x3, 0x2,
13917 : 0x2, 0x2, 0x156, 0x145, 0x3, 0x2, 0x2, 0x2, 0x156, 0x146, 0x3, 0x2,
13918 : 0x2, 0x2, 0x156, 0x147, 0x3, 0x2, 0x2, 0x2, 0x156, 0x148, 0x3, 0x2,
13919 : 0x2, 0x2, 0x156, 0x149, 0x3, 0x2, 0x2, 0x2, 0x156, 0x14a, 0x3, 0x2,
13920 : 0x2, 0x2, 0x156, 0x14b, 0x3, 0x2, 0x2, 0x2, 0x156, 0x14c, 0x3, 0x2,
13921 : 0x2, 0x2, 0x156, 0x14d, 0x3, 0x2, 0x2, 0x2, 0x156, 0x14e, 0x3, 0x2,
13922 : 0x2, 0x2, 0x156, 0x14f, 0x3, 0x2, 0x2, 0x2, 0x156, 0x150, 0x3, 0x2,
13923 : 0x2, 0x2, 0x156, 0x151, 0x3, 0x2, 0x2, 0x2, 0x156, 0x152, 0x3, 0x2,
13924 : 0x2, 0x2, 0x156, 0x153, 0x3, 0x2, 0x2, 0x2, 0x156, 0x154, 0x3, 0x2,
13925 : 0x2, 0x2, 0x156, 0x155, 0x3, 0x2, 0x2, 0x2, 0x157, 0xb, 0x3, 0x2, 0x2,
13926 : 0x2, 0x158, 0x15c, 0x7, 0x7, 0x2, 0x2, 0x159, 0x15a, 0x7, 0x7, 0x2,
13927 : 0x2, 0x15a, 0x15c, 0x5, 0xe, 0x8, 0x2, 0x15b, 0x158, 0x3, 0x2, 0x2,
13928 : 0x2, 0x15b, 0x159, 0x3, 0x2, 0x2, 0x2, 0x15c, 0xd, 0x3, 0x2, 0x2, 0x2,
13929 : 0x15d, 0x162, 0x5, 0xa4, 0x53, 0x2, 0x15e, 0x162, 0x5, 0xf2, 0x7a, 0x2,
13930 : 0x15f, 0x162, 0x5, 0x102, 0x82, 0x2, 0x160, 0x162, 0x5, 0x128, 0x95,
13931 : 0x2, 0x161, 0x15d, 0x3, 0x2, 0x2, 0x2, 0x161, 0x15e, 0x3, 0x2, 0x2,
13932 : 0x2, 0x161, 0x15f, 0x3, 0x2, 0x2, 0x2, 0x161, 0x160, 0x3, 0x2, 0x2,
13933 : 0x2, 0x162, 0xf, 0x3, 0x2, 0x2, 0x2, 0x163, 0x164, 0x7, 0x8, 0x2, 0x2,
13934 : 0x164, 0x165, 0x7, 0x18, 0x2, 0x2, 0x165, 0x166, 0x5, 0x130, 0x99, 0x2,
13935 : 0x166, 0x167, 0x7, 0x19, 0x2, 0x2, 0x167, 0x170, 0x3, 0x2, 0x2, 0x2,
13936 : 0x168, 0x169, 0x7, 0x8, 0x2, 0x2, 0x169, 0x16a, 0x7, 0x18, 0x2, 0x2,
13937 : 0x16a, 0x16b, 0x5, 0x12, 0xa, 0x2, 0x16b, 0x16c, 0x7, 0x1b, 0x2, 0x2,
13938 : 0x16c, 0x16d, 0x5, 0x130, 0x99, 0x2, 0x16d, 0x16e, 0x7, 0x19, 0x2, 0x2,
13939 : 0x16e, 0x170, 0x3, 0x2, 0x2, 0x2, 0x16f, 0x163, 0x3, 0x2, 0x2, 0x2,
13940 : 0x16f, 0x168, 0x3, 0x2, 0x2, 0x2, 0x170, 0x11, 0x3, 0x2, 0x2, 0x2, 0x171,
13941 : 0x172, 0x7, 0x55, 0x2, 0x2, 0x172, 0x13, 0x3, 0x2, 0x2, 0x2, 0x173,
13942 : 0x174, 0x7, 0x9, 0x2, 0x2, 0x174, 0x175, 0x5, 0x16, 0xc, 0x2, 0x175,
13943 : 0x15, 0x3, 0x2, 0x2, 0x2, 0x176, 0x178, 0x5, 0x18, 0xd, 0x2, 0x177,
13944 : 0x176, 0x3, 0x2, 0x2, 0x2, 0x178, 0x17b, 0x3, 0x2, 0x2, 0x2, 0x179,
13945 : 0x177, 0x3, 0x2, 0x2, 0x2, 0x179, 0x17a, 0x3, 0x2, 0x2, 0x2, 0x17a,
13946 : 0x17, 0x3, 0x2, 0x2, 0x2, 0x17b, 0x179, 0x3, 0x2, 0x2, 0x2, 0x17c, 0x187,
13947 : 0x5, 0x9c, 0x4f, 0x2, 0x17d, 0x187, 0x5, 0xa8, 0x55, 0x2, 0x17e, 0x187,
13948 : 0x5, 0xaa, 0x56, 0x2, 0x17f, 0x187, 0x5, 0xb0, 0x59, 0x2, 0x180, 0x187,
13949 : 0x5, 0xb6, 0x5c, 0x2, 0x181, 0x187, 0x5, 0xbc, 0x5f, 0x2, 0x182, 0x187,
13950 : 0x5, 0xd0, 0x69, 0x2, 0x183, 0x187, 0x5, 0xde, 0x70, 0x2, 0x184, 0x187,
13951 : 0x5, 0xe8, 0x75, 0x2, 0x185, 0x187, 0x5, 0xee, 0x78, 0x2, 0x186, 0x17c,
13952 : 0x3, 0x2, 0x2, 0x2, 0x186, 0x17d, 0x3, 0x2, 0x2, 0x2, 0x186, 0x17e,
13953 : 0x3, 0x2, 0x2, 0x2, 0x186, 0x17f, 0x3, 0x2, 0x2, 0x2, 0x186, 0x180,
13954 : 0x3, 0x2, 0x2, 0x2, 0x186, 0x181, 0x3, 0x2, 0x2, 0x2, 0x186, 0x182,
13955 : 0x3, 0x2, 0x2, 0x2, 0x186, 0x183, 0x3, 0x2, 0x2, 0x2, 0x186, 0x184,
13956 : 0x3, 0x2, 0x2, 0x2, 0x186, 0x185, 0x3, 0x2, 0x2, 0x2, 0x187, 0x19, 0x3,
13957 : 0x2, 0x2, 0x2, 0x188, 0x189, 0x7, 0xb, 0x2, 0x2, 0x189, 0x18a, 0x5,
13958 : 0x1c, 0xf, 0x2, 0x18a, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x18b, 0x18d, 0x5,
13959 : 0x1e, 0x10, 0x2, 0x18c, 0x18b, 0x3, 0x2, 0x2, 0x2, 0x18d, 0x18e, 0x3,
13960 : 0x2, 0x2, 0x2, 0x18e, 0x18c, 0x3, 0x2, 0x2, 0x2, 0x18e, 0x18f, 0x3,
13961 : 0x2, 0x2, 0x2, 0x18f, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x190, 0x199, 0x5, 0xa8,
13962 : 0x55, 0x2, 0x191, 0x199, 0x5, 0xaa, 0x56, 0x2, 0x192, 0x199, 0x5, 0xb4,
13963 : 0x5b, 0x2, 0x193, 0x199, 0x5, 0xba, 0x5e, 0x2, 0x194, 0x199, 0x5, 0xca,
13964 : 0x66, 0x2, 0x195, 0x199, 0x5, 0xd0, 0x69, 0x2, 0x196, 0x199, 0x5, 0xe4,
13965 : 0x73, 0x2, 0x197, 0x199, 0x5, 0xee, 0x78, 0x2, 0x198, 0x190, 0x3, 0x2,
13966 : 0x2, 0x2, 0x198, 0x191, 0x3, 0x2, 0x2, 0x2, 0x198, 0x192, 0x3, 0x2,
13967 : 0x2, 0x2, 0x198, 0x193, 0x3, 0x2, 0x2, 0x2, 0x198, 0x194, 0x3, 0x2,
13968 : 0x2, 0x2, 0x198, 0x195, 0x3, 0x2, 0x2, 0x2, 0x198, 0x196, 0x3, 0x2,
13969 : 0x2, 0x2, 0x198, 0x197, 0x3, 0x2, 0x2, 0x2, 0x199, 0x1f, 0x3, 0x2, 0x2,
13970 : 0x2, 0x19a, 0x19b, 0x7, 0xa, 0x2, 0x2, 0x19b, 0x19c, 0x5, 0x22, 0x12,
13971 : 0x2, 0x19c, 0x21, 0x3, 0x2, 0x2, 0x2, 0x19d, 0x19e, 0x5, 0x24, 0x13,
13972 : 0x2, 0x19e, 0x23, 0x3, 0x2, 0x2, 0x2, 0x19f, 0x1a9, 0x5, 0x26, 0x14,
13973 : 0x2, 0x1a0, 0x1a9, 0x5, 0x28, 0x15, 0x2, 0x1a1, 0x1a9, 0x5, 0x2a, 0x16,
13974 : 0x2, 0x1a2, 0x1a9, 0x5, 0x2c, 0x17, 0x2, 0x1a3, 0x1a9, 0x5, 0x2e, 0x18,
13975 : 0x2, 0x1a4, 0x1a9, 0x5, 0x30, 0x19, 0x2, 0x1a5, 0x1a9, 0x5, 0x32, 0x1a,
13976 : 0x2, 0x1a6, 0x1a9, 0x5, 0x34, 0x1b, 0x2, 0x1a7, 0x1a9, 0x5, 0x36, 0x1c,
13977 : 0x2, 0x1a8, 0x19f, 0x3, 0x2, 0x2, 0x2, 0x1a8, 0x1a0, 0x3, 0x2, 0x2,
13978 : 0x2, 0x1a8, 0x1a1, 0x3, 0x2, 0x2, 0x2, 0x1a8, 0x1a2, 0x3, 0x2, 0x2,
13979 : 0x2, 0x1a8, 0x1a3, 0x3, 0x2, 0x2, 0x2, 0x1a8, 0x1a4, 0x3, 0x2, 0x2,
13980 : 0x2, 0x1a8, 0x1a5, 0x3, 0x2, 0x2, 0x2, 0x1a8, 0x1a6, 0x3, 0x2, 0x2,
13981 : 0x2, 0x1a8, 0x1a7, 0x3, 0x2, 0x2, 0x2, 0x1a9, 0x25, 0x3, 0x2, 0x2, 0x2,
13982 : 0x1aa, 0x1ab, 0x5, 0xc, 0x7, 0x2, 0x1ab, 0x27, 0x3, 0x2, 0x2, 0x2, 0x1ac,
13983 : 0x1ad, 0x5, 0x14, 0xb, 0x2, 0x1ad, 0x29, 0x3, 0x2, 0x2, 0x2, 0x1ae,
13984 : 0x1af, 0x7, 0xe, 0x2, 0x2, 0x1af, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x1b0, 0x1b1,
13985 : 0x5, 0x50, 0x29, 0x2, 0x1b1, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x1b2, 0x1b3,
13986 : 0x5, 0x56, 0x2c, 0x2, 0x1b3, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x1b4, 0x1b5,
13987 : 0x5, 0x62, 0x32, 0x2, 0x1b5, 0x31, 0x3, 0x2, 0x2, 0x2, 0x1b6, 0x1b7,
13988 : 0x5, 0x68, 0x35, 0x2, 0x1b7, 0x33, 0x3, 0x2, 0x2, 0x2, 0x1b8, 0x1b9,
13989 : 0x5, 0x76, 0x3c, 0x2, 0x1b9, 0x35, 0x3, 0x2, 0x2, 0x2, 0x1ba, 0x1bb,
13990 : 0x5, 0x7c, 0x3f, 0x2, 0x1bb, 0x37, 0x3, 0x2, 0x2, 0x2, 0x1bc, 0x1bd,
13991 : 0x7, 0xc, 0x2, 0x2, 0x1bd, 0x1be, 0x7, 0x9, 0x2, 0x2, 0x1be, 0x1bf,
13992 : 0x5, 0x3a, 0x1e, 0x2, 0x1bf, 0x39, 0x3, 0x2, 0x2, 0x2, 0x1c0, 0x1c2,
13993 : 0x5, 0x3c, 0x1f, 0x2, 0x1c1, 0x1c0, 0x3, 0x2, 0x2, 0x2, 0x1c2, 0x1c3,
13994 : 0x3, 0x2, 0x2, 0x2, 0x1c3, 0x1c1, 0x3, 0x2, 0x2, 0x2, 0x1c3, 0x1c4,
13995 : 0x3, 0x2, 0x2, 0x2, 0x1c4, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x1c5, 0x1cc, 0x5,
13996 : 0x9a, 0x4e, 0x2, 0x1c6, 0x1cc, 0x5, 0x9c, 0x4f, 0x2, 0x1c7, 0x1cc, 0x5,
13997 : 0xae, 0x58, 0x2, 0x1c8, 0x1cc, 0x5, 0xb6, 0x5c, 0x2, 0x1c9, 0x1cc, 0x5,
13998 : 0xde, 0x70, 0x2, 0x1ca, 0x1cc, 0x5, 0x114, 0x8b, 0x2, 0x1cb, 0x1c5,
13999 : 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x1c6, 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x1c7,
14000 : 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x1c8, 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x1c9,
14001 : 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x1ca, 0x3, 0x2, 0x2, 0x2, 0x1cc, 0x3d, 0x3,
14002 : 0x2, 0x2, 0x2, 0x1cd, 0x1ce, 0x7, 0xd, 0x2, 0x2, 0x1ce, 0x1cf, 0x7,
14003 : 0x9, 0x2, 0x2, 0x1cf, 0x1d0, 0x5, 0x40, 0x21, 0x2, 0x1d0, 0x3f, 0x3,
14004 : 0x2, 0x2, 0x2, 0x1d1, 0x1d3, 0x5, 0x42, 0x22, 0x2, 0x1d2, 0x1d1, 0x3,
14005 : 0x2, 0x2, 0x2, 0x1d3, 0x1d4, 0x3, 0x2, 0x2, 0x2, 0x1d4, 0x1d2, 0x3,
14006 : 0x2, 0x2, 0x2, 0x1d4, 0x1d5, 0x3, 0x2, 0x2, 0x2, 0x1d5, 0x41, 0x3, 0x2,
14007 : 0x2, 0x2, 0x1d6, 0x1de, 0x5, 0x9a, 0x4e, 0x2, 0x1d7, 0x1de, 0x5, 0xb4,
14008 : 0x5b, 0x2, 0x1d8, 0x1de, 0x5, 0xc2, 0x62, 0x2, 0x1d9, 0x1de, 0x5, 0xc4,
14009 : 0x63, 0x2, 0x1da, 0x1de, 0x5, 0xd2, 0x6a, 0x2, 0x1db, 0x1de, 0x5, 0xde,
14010 : 0x70, 0x2, 0x1dc, 0x1de, 0x5, 0x114, 0x8b, 0x2, 0x1dd, 0x1d6, 0x3, 0x2,
14011 : 0x2, 0x2, 0x1dd, 0x1d7, 0x3, 0x2, 0x2, 0x2, 0x1dd, 0x1d8, 0x3, 0x2,
14012 : 0x2, 0x2, 0x1dd, 0x1d9, 0x3, 0x2, 0x2, 0x2, 0x1dd, 0x1da, 0x3, 0x2,
14013 : 0x2, 0x2, 0x1dd, 0x1db, 0x3, 0x2, 0x2, 0x2, 0x1dd, 0x1dc, 0x3, 0x2,
14014 : 0x2, 0x2, 0x1de, 0x43, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x1e0, 0x7, 0xe, 0x2,
14015 : 0x2, 0x1e0, 0x1e1, 0x5, 0x46, 0x24, 0x2, 0x1e1, 0x45, 0x3, 0x2, 0x2,
14016 : 0x2, 0x1e2, 0x1e4, 0x5, 0x48, 0x25, 0x2, 0x1e3, 0x1e2, 0x3, 0x2, 0x2,
14017 : 0x2, 0x1e4, 0x1e5, 0x3, 0x2, 0x2, 0x2, 0x1e5, 0x1e3, 0x3, 0x2, 0x2,
14018 : 0x2, 0x1e5, 0x1e6, 0x3, 0x2, 0x2, 0x2, 0x1e6, 0x47, 0x3, 0x2, 0x2, 0x2,
14019 : 0x1e7, 0x1eb, 0x5, 0xde, 0x70, 0x2, 0x1e8, 0x1eb, 0x5, 0xe0, 0x71, 0x2,
14020 : 0x1e9, 0x1eb, 0x5, 0x106, 0x84, 0x2, 0x1ea, 0x1e7, 0x3, 0x2, 0x2, 0x2,
14021 : 0x1ea, 0x1e8, 0x3, 0x2, 0x2, 0x2, 0x1ea, 0x1e9, 0x3, 0x2, 0x2, 0x2,
14022 : 0x1eb, 0x49, 0x3, 0x2, 0x2, 0x2, 0x1ec, 0x1ed, 0x7, 0xf, 0x2, 0x2, 0x1ed,
14023 : 0x1ee, 0x5, 0x4c, 0x27, 0x2, 0x1ee, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x1ef,
14024 : 0x1f1, 0x5, 0x4e, 0x28, 0x2, 0x1f0, 0x1ef, 0x3, 0x2, 0x2, 0x2, 0x1f1,
14025 : 0x1f4, 0x3, 0x2, 0x2, 0x2, 0x1f2, 0x1f0, 0x3, 0x2, 0x2, 0x2, 0x1f2,
14026 : 0x1f3, 0x3, 0x2, 0x2, 0x2, 0x1f3, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x1f4, 0x1f2,
14027 : 0x3, 0x2, 0x2, 0x2, 0x1f5, 0x1f9, 0x5, 0xcc, 0x67, 0x2, 0x1f6, 0x1f9,
14028 : 0x5, 0xc8, 0x65, 0x2, 0x1f7, 0x1f9, 0x5, 0xde, 0x70, 0x2, 0x1f8, 0x1f5,
14029 : 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1f6, 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1f7,
14030 : 0x3, 0x2, 0x2, 0x2, 0x1f9, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x1fa, 0x1fb, 0x7,
14031 : 0x10, 0x2, 0x2, 0x1fb, 0x1fc, 0x5, 0x52, 0x2a, 0x2, 0x1fc, 0x51, 0x3,
14032 : 0x2, 0x2, 0x2, 0x1fd, 0x1ff, 0x5, 0x54, 0x2b, 0x2, 0x1fe, 0x1fd, 0x3,
14033 : 0x2, 0x2, 0x2, 0x1ff, 0x202, 0x3, 0x2, 0x2, 0x2, 0x200, 0x1fe, 0x3,
14034 : 0x2, 0x2, 0x2, 0x200, 0x201, 0x3, 0x2, 0x2, 0x2, 0x201, 0x53, 0x3, 0x2,
14035 : 0x2, 0x2, 0x202, 0x200, 0x3, 0x2, 0x2, 0x2, 0x203, 0x215, 0x5, 0x9a,
14036 : 0x4e, 0x2, 0x204, 0x215, 0x5, 0x9c, 0x4f, 0x2, 0x205, 0x215, 0x5, 0xa8,
14037 : 0x55, 0x2, 0x206, 0x215, 0x5, 0xaa, 0x56, 0x2, 0x207, 0x215, 0x5, 0xb0,
14038 : 0x59, 0x2, 0x208, 0x215, 0x5, 0xb6, 0x5c, 0x2, 0x209, 0x215, 0x5, 0xbc,
14039 : 0x5f, 0x2, 0x20a, 0x215, 0x5, 0xcc, 0x67, 0x2, 0x20b, 0x215, 0x5, 0xd0,
14040 : 0x69, 0x2, 0x20c, 0x215, 0x5, 0xde, 0x70, 0x2, 0x20d, 0x215, 0x5, 0xe8,
14041 : 0x75, 0x2, 0x20e, 0x215, 0x5, 0xea, 0x76, 0x2, 0x20f, 0x215, 0x5, 0xec,
14042 : 0x77, 0x2, 0x210, 0x215, 0x5, 0xee, 0x78, 0x2, 0x211, 0x215, 0x5, 0xf8,
14043 : 0x7d, 0x2, 0x212, 0x215, 0x5, 0x110, 0x89, 0x2, 0x213, 0x215, 0x5, 0x112,
14044 : 0x8a, 0x2, 0x214, 0x203, 0x3, 0x2, 0x2, 0x2, 0x214, 0x204, 0x3, 0x2,
14045 : 0x2, 0x2, 0x214, 0x205, 0x3, 0x2, 0x2, 0x2, 0x214, 0x206, 0x3, 0x2,
14046 : 0x2, 0x2, 0x214, 0x207, 0x3, 0x2, 0x2, 0x2, 0x214, 0x208, 0x3, 0x2,
14047 : 0x2, 0x2, 0x214, 0x209, 0x3, 0x2, 0x2, 0x2, 0x214, 0x20a, 0x3, 0x2,
14048 : 0x2, 0x2, 0x214, 0x20b, 0x3, 0x2, 0x2, 0x2, 0x214, 0x20c, 0x3, 0x2,
14049 : 0x2, 0x2, 0x214, 0x20d, 0x3, 0x2, 0x2, 0x2, 0x214, 0x20e, 0x3, 0x2,
14050 : 0x2, 0x2, 0x214, 0x20f, 0x3, 0x2, 0x2, 0x2, 0x214, 0x210, 0x3, 0x2,
14051 : 0x2, 0x2, 0x214, 0x211, 0x3, 0x2, 0x2, 0x2, 0x214, 0x212, 0x3, 0x2,
14052 : 0x2, 0x2, 0x214, 0x213, 0x3, 0x2, 0x2, 0x2, 0x215, 0x55, 0x3, 0x2, 0x2,
14053 : 0x2, 0x216, 0x217, 0x7, 0x10, 0x2, 0x2, 0x217, 0x218, 0x7, 0x11, 0x2,
14054 : 0x2, 0x218, 0x219, 0x5, 0x58, 0x2d, 0x2, 0x219, 0x57, 0x3, 0x2, 0x2,
14055 : 0x2, 0x21a, 0x21c, 0x5, 0x5a, 0x2e, 0x2, 0x21b, 0x21a, 0x3, 0x2, 0x2,
14056 : 0x2, 0x21c, 0x21f, 0x3, 0x2, 0x2, 0x2, 0x21d, 0x21b, 0x3, 0x2, 0x2,
14057 : 0x2, 0x21d, 0x21e, 0x3, 0x2, 0x2, 0x2, 0x21e, 0x59, 0x3, 0x2, 0x2, 0x2,
14058 : 0x21f, 0x21d, 0x3, 0x2, 0x2, 0x2, 0x220, 0x23c, 0x5, 0x9a, 0x4e, 0x2,
14059 : 0x221, 0x23c, 0x5, 0x9c, 0x4f, 0x2, 0x222, 0x23c, 0x5, 0x9e, 0x50, 0x2,
14060 : 0x223, 0x23c, 0x5, 0xa6, 0x54, 0x2, 0x224, 0x23c, 0x5, 0xa8, 0x55, 0x2,
14061 : 0x225, 0x23c, 0x5, 0xaa, 0x56, 0x2, 0x226, 0x23c, 0x5, 0xb0, 0x59, 0x2,
14062 : 0x227, 0x23c, 0x5, 0xb6, 0x5c, 0x2, 0x228, 0x23c, 0x5, 0xbc, 0x5f, 0x2,
14063 : 0x229, 0x23c, 0x5, 0xcc, 0x67, 0x2, 0x22a, 0x23c, 0x5, 0xd0, 0x69, 0x2,
14064 : 0x22b, 0x23c, 0x5, 0xd6, 0x6c, 0x2, 0x22c, 0x23c, 0x5, 0xde, 0x70, 0x2,
14065 : 0x22d, 0x23c, 0x5, 0xe2, 0x72, 0x2, 0x22e, 0x23c, 0x5, 0xe8, 0x75, 0x2,
14066 : 0x22f, 0x23c, 0x5, 0xea, 0x76, 0x2, 0x230, 0x23c, 0x5, 0xec, 0x77, 0x2,
14067 : 0x231, 0x23c, 0x5, 0xee, 0x78, 0x2, 0x232, 0x23c, 0x5, 0xf0, 0x79, 0x2,
14068 : 0x233, 0x23c, 0x5, 0xf4, 0x7b, 0x2, 0x234, 0x23c, 0x5, 0xf8, 0x7d, 0x2,
14069 : 0x235, 0x23c, 0x5, 0xfe, 0x80, 0x2, 0x236, 0x23c, 0x5, 0x100, 0x81,
14070 : 0x2, 0x237, 0x23c, 0x5, 0x108, 0x85, 0x2, 0x238, 0x23c, 0x5, 0x110,
14071 : 0x89, 0x2, 0x239, 0x23c, 0x5, 0x112, 0x8a, 0x2, 0x23a, 0x23c, 0x5, 0x120,
14072 : 0x91, 0x2, 0x23b, 0x220, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x221, 0x3, 0x2,
14073 : 0x2, 0x2, 0x23b, 0x222, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x223, 0x3, 0x2,
14074 : 0x2, 0x2, 0x23b, 0x224, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x225, 0x3, 0x2,
14075 : 0x2, 0x2, 0x23b, 0x226, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x227, 0x3, 0x2,
14076 : 0x2, 0x2, 0x23b, 0x228, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x229, 0x3, 0x2,
14077 : 0x2, 0x2, 0x23b, 0x22a, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x22b, 0x3, 0x2,
14078 : 0x2, 0x2, 0x23b, 0x22c, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x22d, 0x3, 0x2,
14079 : 0x2, 0x2, 0x23b, 0x22e, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x22f, 0x3, 0x2,
14080 : 0x2, 0x2, 0x23b, 0x230, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x231, 0x3, 0x2,
14081 : 0x2, 0x2, 0x23b, 0x232, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x233, 0x3, 0x2,
14082 : 0x2, 0x2, 0x23b, 0x234, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x235, 0x3, 0x2,
14083 : 0x2, 0x2, 0x23b, 0x236, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x237, 0x3, 0x2,
14084 : 0x2, 0x2, 0x23b, 0x238, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x239, 0x3, 0x2,
14085 : 0x2, 0x2, 0x23b, 0x23a, 0x3, 0x2, 0x2, 0x2, 0x23c, 0x5b, 0x3, 0x2, 0x2,
14086 : 0x2, 0x23d, 0x23e, 0x7, 0x11, 0x2, 0x2, 0x23e, 0x23f, 0x5, 0x5e, 0x30,
14087 : 0x2, 0x23f, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x240, 0x242, 0x5, 0x60, 0x31,
14088 : 0x2, 0x241, 0x240, 0x3, 0x2, 0x2, 0x2, 0x242, 0x245, 0x3, 0x2, 0x2,
14089 : 0x2, 0x243, 0x241, 0x3, 0x2, 0x2, 0x2, 0x243, 0x244, 0x3, 0x2, 0x2,
14090 : 0x2, 0x244, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x245, 0x243, 0x3, 0x2, 0x2, 0x2,
14091 : 0x246, 0x252, 0x5, 0x9e, 0x50, 0x2, 0x247, 0x252, 0x5, 0xa6, 0x54, 0x2,
14092 : 0x248, 0x252, 0x5, 0xcc, 0x67, 0x2, 0x249, 0x252, 0x5, 0xd6, 0x6c, 0x2,
14093 : 0x24a, 0x252, 0x5, 0xe2, 0x72, 0x2, 0x24b, 0x252, 0x5, 0xf0, 0x79, 0x2,
14094 : 0x24c, 0x252, 0x5, 0xf4, 0x7b, 0x2, 0x24d, 0x252, 0x5, 0xfe, 0x80, 0x2,
14095 : 0x24e, 0x252, 0x5, 0x100, 0x81, 0x2, 0x24f, 0x252, 0x5, 0x108, 0x85,
14096 : 0x2, 0x250, 0x252, 0x5, 0x120, 0x91, 0x2, 0x251, 0x246, 0x3, 0x2, 0x2,
14097 : 0x2, 0x251, 0x247, 0x3, 0x2, 0x2, 0x2, 0x251, 0x248, 0x3, 0x2, 0x2,
14098 : 0x2, 0x251, 0x249, 0x3, 0x2, 0x2, 0x2, 0x251, 0x24a, 0x3, 0x2, 0x2,
14099 : 0x2, 0x251, 0x24b, 0x3, 0x2, 0x2, 0x2, 0x251, 0x24c, 0x3, 0x2, 0x2,
14100 : 0x2, 0x251, 0x24d, 0x3, 0x2, 0x2, 0x2, 0x251, 0x24e, 0x3, 0x2, 0x2,
14101 : 0x2, 0x251, 0x24f, 0x3, 0x2, 0x2, 0x2, 0x251, 0x250, 0x3, 0x2, 0x2,
14102 : 0x2, 0x252, 0x61, 0x3, 0x2, 0x2, 0x2, 0x253, 0x254, 0x7, 0x12, 0x2,
14103 : 0x2, 0x254, 0x255, 0x5, 0x64, 0x33, 0x2, 0x255, 0x63, 0x3, 0x2, 0x2,
14104 : 0x2, 0x256, 0x258, 0x5, 0x66, 0x34, 0x2, 0x257, 0x256, 0x3, 0x2, 0x2,
14105 : 0x2, 0x258, 0x25b, 0x3, 0x2, 0x2, 0x2, 0x259, 0x257, 0x3, 0x2, 0x2,
14106 : 0x2, 0x259, 0x25a, 0x3, 0x2, 0x2, 0x2, 0x25a, 0x65, 0x3, 0x2, 0x2, 0x2,
14107 : 0x25b, 0x259, 0x3, 0x2, 0x2, 0x2, 0x25c, 0x271, 0x5, 0x9a, 0x4e, 0x2,
14108 : 0x25d, 0x271, 0x5, 0x9c, 0x4f, 0x2, 0x25e, 0x271, 0x5, 0xa8, 0x55, 0x2,
14109 : 0x25f, 0x271, 0x5, 0xaa, 0x56, 0x2, 0x260, 0x271, 0x5, 0xb0, 0x59, 0x2,
14110 : 0x261, 0x271, 0x5, 0xb6, 0x5c, 0x2, 0x262, 0x271, 0x5, 0xbc, 0x5f, 0x2,
14111 : 0x263, 0x271, 0x5, 0xcc, 0x67, 0x2, 0x264, 0x271, 0x5, 0xd0, 0x69, 0x2,
14112 : 0x265, 0x271, 0x5, 0xd4, 0x6b, 0x2, 0x266, 0x271, 0x5, 0xde, 0x70, 0x2,
14113 : 0x267, 0x271, 0x5, 0xe8, 0x75, 0x2, 0x268, 0x271, 0x5, 0xea, 0x76, 0x2,
14114 : 0x269, 0x271, 0x5, 0xec, 0x77, 0x2, 0x26a, 0x271, 0x5, 0xee, 0x78, 0x2,
14115 : 0x26b, 0x271, 0x5, 0xf0, 0x79, 0x2, 0x26c, 0x271, 0x5, 0xf4, 0x7b, 0x2,
14116 : 0x26d, 0x271, 0x5, 0xf8, 0x7d, 0x2, 0x26e, 0x271, 0x5, 0x110, 0x89,
14117 : 0x2, 0x26f, 0x271, 0x5, 0x112, 0x8a, 0x2, 0x270, 0x25c, 0x3, 0x2, 0x2,
14118 : 0x2, 0x270, 0x25d, 0x3, 0x2, 0x2, 0x2, 0x270, 0x25e, 0x3, 0x2, 0x2,
14119 : 0x2, 0x270, 0x25f, 0x3, 0x2, 0x2, 0x2, 0x270, 0x260, 0x3, 0x2, 0x2,
14120 : 0x2, 0x270, 0x261, 0x3, 0x2, 0x2, 0x2, 0x270, 0x262, 0x3, 0x2, 0x2,
14121 : 0x2, 0x270, 0x263, 0x3, 0x2, 0x2, 0x2, 0x270, 0x264, 0x3, 0x2, 0x2,
14122 : 0x2, 0x270, 0x265, 0x3, 0x2, 0x2, 0x2, 0x270, 0x266, 0x3, 0x2, 0x2,
14123 : 0x2, 0x270, 0x267, 0x3, 0x2, 0x2, 0x2, 0x270, 0x268, 0x3, 0x2, 0x2,
14124 : 0x2, 0x270, 0x269, 0x3, 0x2, 0x2, 0x2, 0x270, 0x26a, 0x3, 0x2, 0x2,
14125 : 0x2, 0x270, 0x26b, 0x3, 0x2, 0x2, 0x2, 0x270, 0x26c, 0x3, 0x2, 0x2,
14126 : 0x2, 0x270, 0x26d, 0x3, 0x2, 0x2, 0x2, 0x270, 0x26e, 0x3, 0x2, 0x2,
14127 : 0x2, 0x270, 0x26f, 0x3, 0x2, 0x2, 0x2, 0x271, 0x67, 0x3, 0x2, 0x2, 0x2,
14128 : 0x272, 0x273, 0x7, 0x12, 0x2, 0x2, 0x273, 0x274, 0x7, 0x11, 0x2, 0x2,
14129 : 0x274, 0x275, 0x5, 0x6a, 0x36, 0x2, 0x275, 0x69, 0x3, 0x2, 0x2, 0x2,
14130 : 0x276, 0x278, 0x5, 0x6c, 0x37, 0x2, 0x277, 0x276, 0x3, 0x2, 0x2, 0x2,
14131 : 0x278, 0x27b, 0x3, 0x2, 0x2, 0x2, 0x279, 0x277, 0x3, 0x2, 0x2, 0x2,
14132 : 0x279, 0x27a, 0x3, 0x2, 0x2, 0x2, 0x27a, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x27b,
14133 : 0x279, 0x3, 0x2, 0x2, 0x2, 0x27c, 0x299, 0x5, 0x9a, 0x4e, 0x2, 0x27d,
14134 : 0x299, 0x5, 0x9c, 0x4f, 0x2, 0x27e, 0x299, 0x5, 0x9e, 0x50, 0x2, 0x27f,
14135 : 0x299, 0x5, 0xa6, 0x54, 0x2, 0x280, 0x299, 0x5, 0xa8, 0x55, 0x2, 0x281,
14136 : 0x299, 0x5, 0xaa, 0x56, 0x2, 0x282, 0x299, 0x5, 0xb0, 0x59, 0x2, 0x283,
14137 : 0x299, 0x5, 0xb6, 0x5c, 0x2, 0x284, 0x299, 0x5, 0xbc, 0x5f, 0x2, 0x285,
14138 : 0x299, 0x5, 0xcc, 0x67, 0x2, 0x286, 0x299, 0x5, 0xd0, 0x69, 0x2, 0x287,
14139 : 0x299, 0x5, 0xd4, 0x6b, 0x2, 0x288, 0x299, 0x5, 0xd6, 0x6c, 0x2, 0x289,
14140 : 0x299, 0x5, 0xde, 0x70, 0x2, 0x28a, 0x299, 0x5, 0xe2, 0x72, 0x2, 0x28b,
14141 : 0x299, 0x5, 0xe8, 0x75, 0x2, 0x28c, 0x299, 0x5, 0xea, 0x76, 0x2, 0x28d,
14142 : 0x299, 0x5, 0xec, 0x77, 0x2, 0x28e, 0x299, 0x5, 0xee, 0x78, 0x2, 0x28f,
14143 : 0x299, 0x5, 0xf0, 0x79, 0x2, 0x290, 0x299, 0x5, 0xf4, 0x7b, 0x2, 0x291,
14144 : 0x299, 0x5, 0xf8, 0x7d, 0x2, 0x292, 0x299, 0x5, 0xfe, 0x80, 0x2, 0x293,
14145 : 0x299, 0x5, 0x100, 0x81, 0x2, 0x294, 0x299, 0x5, 0x108, 0x85, 0x2, 0x295,
14146 : 0x299, 0x5, 0x110, 0x89, 0x2, 0x296, 0x299, 0x5, 0x112, 0x8a, 0x2, 0x297,
14147 : 0x299, 0x5, 0x120, 0x91, 0x2, 0x298, 0x27c, 0x3, 0x2, 0x2, 0x2, 0x298,
14148 : 0x27d, 0x3, 0x2, 0x2, 0x2, 0x298, 0x27e, 0x3, 0x2, 0x2, 0x2, 0x298,
14149 : 0x27f, 0x3, 0x2, 0x2, 0x2, 0x298, 0x280, 0x3, 0x2, 0x2, 0x2, 0x298,
14150 : 0x281, 0x3, 0x2, 0x2, 0x2, 0x298, 0x282, 0x3, 0x2, 0x2, 0x2, 0x298,
14151 : 0x283, 0x3, 0x2, 0x2, 0x2, 0x298, 0x284, 0x3, 0x2, 0x2, 0x2, 0x298,
14152 : 0x285, 0x3, 0x2, 0x2, 0x2, 0x298, 0x286, 0x3, 0x2, 0x2, 0x2, 0x298,
14153 : 0x287, 0x3, 0x2, 0x2, 0x2, 0x298, 0x288, 0x3, 0x2, 0x2, 0x2, 0x298,
14154 : 0x289, 0x3, 0x2, 0x2, 0x2, 0x298, 0x28a, 0x3, 0x2, 0x2, 0x2, 0x298,
14155 : 0x28b, 0x3, 0x2, 0x2, 0x2, 0x298, 0x28c, 0x3, 0x2, 0x2, 0x2, 0x298,
14156 : 0x28d, 0x3, 0x2, 0x2, 0x2, 0x298, 0x28e, 0x3, 0x2, 0x2, 0x2, 0x298,
14157 : 0x28f, 0x3, 0x2, 0x2, 0x2, 0x298, 0x290, 0x3, 0x2, 0x2, 0x2, 0x298,
14158 : 0x291, 0x3, 0x2, 0x2, 0x2, 0x298, 0x292, 0x3, 0x2, 0x2, 0x2, 0x298,
14159 : 0x293, 0x3, 0x2, 0x2, 0x2, 0x298, 0x294, 0x3, 0x2, 0x2, 0x2, 0x298,
14160 : 0x295, 0x3, 0x2, 0x2, 0x2, 0x298, 0x296, 0x3, 0x2, 0x2, 0x2, 0x298,
14161 : 0x297, 0x3, 0x2, 0x2, 0x2, 0x299, 0x6d, 0x3, 0x2, 0x2, 0x2, 0x29a, 0x29b,
14162 : 0x7, 0x13, 0x2, 0x2, 0x29b, 0x2a3, 0x5, 0x70, 0x39, 0x2, 0x29c, 0x29d,
14163 : 0x7, 0x13, 0x2, 0x2, 0x29d, 0x29e, 0x7, 0x18, 0x2, 0x2, 0x29e, 0x29f,
14164 : 0x5, 0x74, 0x3b, 0x2, 0x29f, 0x2a0, 0x7, 0x19, 0x2, 0x2, 0x2a0, 0x2a1,
14165 : 0x5, 0x70, 0x39, 0x2, 0x2a1, 0x2a3, 0x3, 0x2, 0x2, 0x2, 0x2a2, 0x29a,
14166 : 0x3, 0x2, 0x2, 0x2, 0x2a2, 0x29c, 0x3, 0x2, 0x2, 0x2, 0x2a3, 0x6f, 0x3,
14167 : 0x2, 0x2, 0x2, 0x2a4, 0x2a6, 0x5, 0x72, 0x3a, 0x2, 0x2a5, 0x2a4, 0x3,
14168 : 0x2, 0x2, 0x2, 0x2a6, 0x2a7, 0x3, 0x2, 0x2, 0x2, 0x2a7, 0x2a5, 0x3,
14169 : 0x2, 0x2, 0x2, 0x2a7, 0x2a8, 0x3, 0x2, 0x2, 0x2, 0x2a8, 0x71, 0x3, 0x2,
14170 : 0x2, 0x2, 0x2a9, 0x2b1, 0x5, 0xa0, 0x51, 0x2, 0x2aa, 0x2b1, 0x5, 0xcc,
14171 : 0x67, 0x2, 0x2ab, 0x2b1, 0x5, 0xda, 0x6e, 0x2, 0x2ac, 0x2b1, 0x5, 0xe6,
14172 : 0x74, 0x2, 0x2ad, 0x2b1, 0x5, 0xfe, 0x80, 0x2, 0x2ae, 0x2b1, 0x5, 0x10e,
14173 : 0x88, 0x2, 0x2af, 0x2b1, 0x5, 0x126, 0x94, 0x2, 0x2b0, 0x2a9, 0x3, 0x2,
14174 : 0x2, 0x2, 0x2b0, 0x2aa, 0x3, 0x2, 0x2, 0x2, 0x2b0, 0x2ab, 0x3, 0x2,
14175 : 0x2, 0x2, 0x2b0, 0x2ac, 0x3, 0x2, 0x2, 0x2, 0x2b0, 0x2ad, 0x3, 0x2,
14176 : 0x2, 0x2, 0x2b0, 0x2ae, 0x3, 0x2, 0x2, 0x2, 0x2b0, 0x2af, 0x3, 0x2,
14177 : 0x2, 0x2, 0x2b1, 0x73, 0x3, 0x2, 0x2, 0x2, 0x2b2, 0x2b3, 0x7, 0x3, 0x2,
14178 : 0x2, 0x2b3, 0x75, 0x3, 0x2, 0x2, 0x2, 0x2b4, 0x2b5, 0x7, 0x14, 0x2,
14179 : 0x2, 0x2b5, 0x2b6, 0x5, 0x78, 0x3d, 0x2, 0x2b6, 0x77, 0x3, 0x2, 0x2,
14180 : 0x2, 0x2b7, 0x2b9, 0x5, 0x7a, 0x3e, 0x2, 0x2b8, 0x2b7, 0x3, 0x2, 0x2,
14181 : 0x2, 0x2b9, 0x2bc, 0x3, 0x2, 0x2, 0x2, 0x2ba, 0x2b8, 0x3, 0x2, 0x2,
14182 : 0x2, 0x2ba, 0x2bb, 0x3, 0x2, 0x2, 0x2, 0x2bb, 0x79, 0x3, 0x2, 0x2, 0x2,
14183 : 0x2bc, 0x2ba, 0x3, 0x2, 0x2, 0x2, 0x2bd, 0x2cf, 0x5, 0x9a, 0x4e, 0x2,
14184 : 0x2be, 0x2cf, 0x5, 0x9c, 0x4f, 0x2, 0x2bf, 0x2cf, 0x5, 0xa8, 0x55, 0x2,
14185 : 0x2c0, 0x2cf, 0x5, 0xaa, 0x56, 0x2, 0x2c1, 0x2cf, 0x5, 0xb0, 0x59, 0x2,
14186 : 0x2c2, 0x2cf, 0x5, 0xb6, 0x5c, 0x2, 0x2c3, 0x2cf, 0x5, 0xbc, 0x5f, 0x2,
14187 : 0x2c4, 0x2cf, 0x5, 0xcc, 0x67, 0x2, 0x2c5, 0x2cf, 0x5, 0xd0, 0x69, 0x2,
14188 : 0x2c6, 0x2cf, 0x5, 0xd4, 0x6b, 0x2, 0x2c7, 0x2cf, 0x5, 0xde, 0x70, 0x2,
14189 : 0x2c8, 0x2cf, 0x5, 0xe8, 0x75, 0x2, 0x2c9, 0x2cf, 0x5, 0xee, 0x78, 0x2,
14190 : 0x2ca, 0x2cf, 0x5, 0xf0, 0x79, 0x2, 0x2cb, 0x2cf, 0x5, 0xf4, 0x7b, 0x2,
14191 : 0x2cc, 0x2cf, 0x5, 0xf8, 0x7d, 0x2, 0x2cd, 0x2cf, 0x5, 0x112, 0x8a,
14192 : 0x2, 0x2ce, 0x2bd, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2be, 0x3, 0x2, 0x2,
14193 : 0x2, 0x2ce, 0x2bf, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2c0, 0x3, 0x2, 0x2,
14194 : 0x2, 0x2ce, 0x2c1, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2c2, 0x3, 0x2, 0x2,
14195 : 0x2, 0x2ce, 0x2c3, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2c4, 0x3, 0x2, 0x2,
14196 : 0x2, 0x2ce, 0x2c5, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2c6, 0x3, 0x2, 0x2,
14197 : 0x2, 0x2ce, 0x2c7, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2c8, 0x3, 0x2, 0x2,
14198 : 0x2, 0x2ce, 0x2c9, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2ca, 0x3, 0x2, 0x2,
14199 : 0x2, 0x2ce, 0x2cb, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2cc, 0x3, 0x2, 0x2,
14200 : 0x2, 0x2ce, 0x2cd, 0x3, 0x2, 0x2, 0x2, 0x2cf, 0x7b, 0x3, 0x2, 0x2, 0x2,
14201 : 0x2d0, 0x2d1, 0x7, 0x14, 0x2, 0x2, 0x2d1, 0x2d2, 0x7, 0x11, 0x2, 0x2,
14202 : 0x2d2, 0x2d3, 0x5, 0x7e, 0x40, 0x2, 0x2d3, 0x7d, 0x3, 0x2, 0x2, 0x2,
14203 : 0x2d4, 0x2d6, 0x5, 0x80, 0x41, 0x2, 0x2d5, 0x2d4, 0x3, 0x2, 0x2, 0x2,
14204 : 0x2d6, 0x2d9, 0x3, 0x2, 0x2, 0x2, 0x2d7, 0x2d5, 0x3, 0x2, 0x2, 0x2,
14205 : 0x2d7, 0x2d8, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x2d9,
14206 : 0x2d7, 0x3, 0x2, 0x2, 0x2, 0x2da, 0x2f4, 0x5, 0x9a, 0x4e, 0x2, 0x2db,
14207 : 0x2f4, 0x5, 0x9c, 0x4f, 0x2, 0x2dc, 0x2f4, 0x5, 0x9e, 0x50, 0x2, 0x2dd,
14208 : 0x2f4, 0x5, 0xa6, 0x54, 0x2, 0x2de, 0x2f4, 0x5, 0xa8, 0x55, 0x2, 0x2df,
14209 : 0x2f4, 0x5, 0xaa, 0x56, 0x2, 0x2e0, 0x2f4, 0x5, 0xb0, 0x59, 0x2, 0x2e1,
14210 : 0x2f4, 0x5, 0xb6, 0x5c, 0x2, 0x2e2, 0x2f4, 0x5, 0xbc, 0x5f, 0x2, 0x2e3,
14211 : 0x2f4, 0x5, 0xcc, 0x67, 0x2, 0x2e4, 0x2f4, 0x5, 0xd0, 0x69, 0x2, 0x2e5,
14212 : 0x2f4, 0x5, 0xd4, 0x6b, 0x2, 0x2e6, 0x2f4, 0x5, 0xd6, 0x6c, 0x2, 0x2e7,
14213 : 0x2f4, 0x5, 0xde, 0x70, 0x2, 0x2e8, 0x2f4, 0x5, 0xe2, 0x72, 0x2, 0x2e9,
14214 : 0x2f4, 0x5, 0xe8, 0x75, 0x2, 0x2ea, 0x2f4, 0x5, 0xee, 0x78, 0x2, 0x2eb,
14215 : 0x2f4, 0x5, 0xf0, 0x79, 0x2, 0x2ec, 0x2f4, 0x5, 0xf4, 0x7b, 0x2, 0x2ed,
14216 : 0x2f4, 0x5, 0xf8, 0x7d, 0x2, 0x2ee, 0x2f4, 0x5, 0xfe, 0x80, 0x2, 0x2ef,
14217 : 0x2f4, 0x5, 0x100, 0x81, 0x2, 0x2f0, 0x2f4, 0x5, 0x108, 0x85, 0x2, 0x2f1,
14218 : 0x2f4, 0x5, 0x112, 0x8a, 0x2, 0x2f2, 0x2f4, 0x5, 0x120, 0x91, 0x2, 0x2f3,
14219 : 0x2da, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2db, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14220 : 0x2dc, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2dd, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14221 : 0x2de, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2df, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14222 : 0x2e0, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2e1, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14223 : 0x2e2, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2e3, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14224 : 0x2e4, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2e5, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14225 : 0x2e6, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2e7, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14226 : 0x2e8, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2e9, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14227 : 0x2ea, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2eb, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14228 : 0x2ec, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2ed, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14229 : 0x2ee, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2ef, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14230 : 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2f1, 0x3, 0x2, 0x2, 0x2, 0x2f3,
14231 : 0x2f2, 0x3, 0x2, 0x2, 0x2, 0x2f4, 0x81, 0x3, 0x2, 0x2, 0x2, 0x2f5, 0x2f6,
14232 : 0x7, 0x15, 0x2, 0x2, 0x2f6, 0x2f7, 0x5, 0x84, 0x43, 0x2, 0x2f7, 0x83,
14233 : 0x3, 0x2, 0x2, 0x2, 0x2f8, 0x2fa, 0x5, 0x86, 0x44, 0x2, 0x2f9, 0x2f8,
14234 : 0x3, 0x2, 0x2, 0x2, 0x2fa, 0x2fd, 0x3, 0x2, 0x2, 0x2, 0x2fb, 0x2f9,
14235 : 0x3, 0x2, 0x2, 0x2, 0x2fb, 0x2fc, 0x3, 0x2, 0x2, 0x2, 0x2fc, 0x85, 0x3,
14236 : 0x2, 0x2, 0x2, 0x2fd, 0x2fb, 0x3, 0x2, 0x2, 0x2, 0x2fe, 0x303, 0x5,
14237 : 0xc0, 0x61, 0x2, 0x2ff, 0x303, 0x5, 0xcc, 0x67, 0x2, 0x300, 0x303, 0x5,
14238 : 0xc8, 0x65, 0x2, 0x301, 0x303, 0x5, 0xde, 0x70, 0x2, 0x302, 0x2fe, 0x3,
14239 : 0x2, 0x2, 0x2, 0x302, 0x2ff, 0x3, 0x2, 0x2, 0x2, 0x302, 0x300, 0x3,
14240 : 0x2, 0x2, 0x2, 0x302, 0x301, 0x3, 0x2, 0x2, 0x2, 0x303, 0x87, 0x3, 0x2,
14241 : 0x2, 0x2, 0x304, 0x305, 0x7, 0x16, 0x2, 0x2, 0x305, 0x306, 0x5, 0x8a,
14242 : 0x46, 0x2, 0x306, 0x89, 0x3, 0x2, 0x2, 0x2, 0x307, 0x309, 0x5, 0x8c,
14243 : 0x47, 0x2, 0x308, 0x307, 0x3, 0x2, 0x2, 0x2, 0x309, 0x30c, 0x3, 0x2,
14244 : 0x2, 0x2, 0x30a, 0x308, 0x3, 0x2, 0x2, 0x2, 0x30a, 0x30b, 0x3, 0x2,
14245 : 0x2, 0x2, 0x30b, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x30c, 0x30a, 0x3, 0x2, 0x2,
14246 : 0x2, 0x30d, 0x311, 0x5, 0xcc, 0x67, 0x2, 0x30e, 0x311, 0x5, 0xc8, 0x65,
14247 : 0x2, 0x30f, 0x311, 0x5, 0xde, 0x70, 0x2, 0x310, 0x30d, 0x3, 0x2, 0x2,
14248 : 0x2, 0x310, 0x30e, 0x3, 0x2, 0x2, 0x2, 0x310, 0x30f, 0x3, 0x2, 0x2,
14249 : 0x2, 0x311, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x312, 0x313, 0x7, 0x17, 0x2,
14250 : 0x2, 0x313, 0x314, 0x5, 0x90, 0x49, 0x2, 0x314, 0x8f, 0x3, 0x2, 0x2,
14251 : 0x2, 0x315, 0x317, 0x5, 0x92, 0x4a, 0x2, 0x316, 0x315, 0x3, 0x2, 0x2,
14252 : 0x2, 0x317, 0x318, 0x3, 0x2, 0x2, 0x2, 0x318, 0x316, 0x3, 0x2, 0x2,
14253 : 0x2, 0x318, 0x319, 0x3, 0x2, 0x2, 0x2, 0x319, 0x91, 0x3, 0x2, 0x2, 0x2,
14254 : 0x31a, 0x323, 0x5, 0x9a, 0x4e, 0x2, 0x31b, 0x323, 0x5, 0xc6, 0x64, 0x2,
14255 : 0x31c, 0x323, 0x5, 0xcc, 0x67, 0x2, 0x31d, 0x323, 0x5, 0xdc, 0x6f, 0x2,
14256 : 0x31e, 0x323, 0x5, 0xde, 0x70, 0x2, 0x31f, 0x323, 0x5, 0xe0, 0x71, 0x2,
14257 : 0x320, 0x323, 0x5, 0xfa, 0x7e, 0x2, 0x321, 0x323, 0x5, 0x114, 0x8b,
14258 : 0x2, 0x322, 0x31a, 0x3, 0x2, 0x2, 0x2, 0x322, 0x31b, 0x3, 0x2, 0x2,
14259 : 0x2, 0x322, 0x31c, 0x3, 0x2, 0x2, 0x2, 0x322, 0x31d, 0x3, 0x2, 0x2,
14260 : 0x2, 0x322, 0x31e, 0x3, 0x2, 0x2, 0x2, 0x322, 0x31f, 0x3, 0x2, 0x2,
14261 : 0x2, 0x322, 0x320, 0x3, 0x2, 0x2, 0x2, 0x322, 0x321, 0x3, 0x2, 0x2,
14262 : 0x2, 0x323, 0x93, 0x3, 0x2, 0x2, 0x2, 0x324, 0x325, 0x7, 0x47, 0x2,
14263 : 0x2, 0x325, 0x32d, 0x5, 0x96, 0x4c, 0x2, 0x326, 0x327, 0x7, 0x47, 0x2,
14264 : 0x2, 0x327, 0x328, 0x7, 0x18, 0x2, 0x2, 0x328, 0x329, 0x5, 0x116, 0x8c,
14265 : 0x2, 0x329, 0x32a, 0x7, 0x19, 0x2, 0x2, 0x32a, 0x32b, 0x5, 0x96, 0x4c,
14266 : 0x2, 0x32b, 0x32d, 0x3, 0x2, 0x2, 0x2, 0x32c, 0x324, 0x3, 0x2, 0x2,
14267 : 0x2, 0x32c, 0x326, 0x3, 0x2, 0x2, 0x2, 0x32d, 0x95, 0x3, 0x2, 0x2, 0x2,
14268 : 0x32e, 0x330, 0x5, 0x98, 0x4d, 0x2, 0x32f, 0x32e, 0x3, 0x2, 0x2, 0x2,
14269 : 0x330, 0x333, 0x3, 0x2, 0x2, 0x2, 0x331, 0x32f, 0x3, 0x2, 0x2, 0x2,
14270 : 0x331, 0x332, 0x3, 0x2, 0x2, 0x2, 0x332, 0x97, 0x3, 0x2, 0x2, 0x2, 0x333,
14271 : 0x331, 0x3, 0x2, 0x2, 0x2, 0x334, 0x337, 0x5, 0x9a, 0x4e, 0x2, 0x335,
14272 : 0x337, 0x5, 0xde, 0x70, 0x2, 0x336, 0x334, 0x3, 0x2, 0x2, 0x2, 0x336,
14273 : 0x335, 0x3, 0x2, 0x2, 0x2, 0x337, 0x99, 0x3, 0x2, 0x2, 0x2, 0x338, 0x33f,
14274 : 0x7, 0x1d, 0x2, 0x2, 0x339, 0x33a, 0x7, 0x1d, 0x2, 0x2, 0x33a, 0x33b,
14275 : 0x7, 0x18, 0x2, 0x2, 0x33b, 0x33c, 0x5, 0x12e, 0x98, 0x2, 0x33c, 0x33d,
14276 : 0x7, 0x19, 0x2, 0x2, 0x33d, 0x33f, 0x3, 0x2, 0x2, 0x2, 0x33e, 0x338,
14277 : 0x3, 0x2, 0x2, 0x2, 0x33e, 0x339, 0x3, 0x2, 0x2, 0x2, 0x33f, 0x9b, 0x3,
14278 : 0x2, 0x2, 0x2, 0x340, 0x341, 0x7, 0x1e, 0x2, 0x2, 0x341, 0x342, 0x7,
14279 : 0x18, 0x2, 0x2, 0x342, 0x343, 0x5, 0x130, 0x99, 0x2, 0x343, 0x344, 0x7,
14280 : 0x19, 0x2, 0x2, 0x344, 0x9d, 0x3, 0x2, 0x2, 0x2, 0x345, 0x346, 0x7,
14281 : 0x1f, 0x2, 0x2, 0x346, 0x9f, 0x3, 0x2, 0x2, 0x2, 0x347, 0x348, 0x7,
14282 : 0x20, 0x2, 0x2, 0x348, 0x349, 0x7, 0x18, 0x2, 0x2, 0x349, 0x34a, 0x5,
14283 : 0xa2, 0x52, 0x2, 0x34a, 0x34b, 0x7, 0x19, 0x2, 0x2, 0x34b, 0xa1, 0x3,
14284 : 0x2, 0x2, 0x2, 0x34c, 0x34d, 0x7, 0x3, 0x2, 0x2, 0x34d, 0xa3, 0x3, 0x2,
14285 : 0x2, 0x2, 0x34e, 0x34f, 0x7, 0x21, 0x2, 0x2, 0x34f, 0xa5, 0x3, 0x2,
14286 : 0x2, 0x2, 0x350, 0x351, 0x7, 0x22, 0x2, 0x2, 0x351, 0x352, 0x7, 0x18,
14287 : 0x2, 0x2, 0x352, 0x353, 0x5, 0x12a, 0x96, 0x2, 0x353, 0x354, 0x7, 0x19,
14288 : 0x2, 0x2, 0x354, 0xa7, 0x3, 0x2, 0x2, 0x2, 0x355, 0x356, 0x7, 0x23,
14289 : 0x2, 0x2, 0x356, 0x357, 0x7, 0x18, 0x2, 0x2, 0x357, 0x358, 0x5, 0x130,
14290 : 0x99, 0x2, 0x358, 0x359, 0x7, 0x19, 0x2, 0x2, 0x359, 0xa9, 0x3, 0x2,
14291 : 0x2, 0x2, 0x35a, 0x35b, 0x7, 0x24, 0x2, 0x2, 0x35b, 0x35c, 0x7, 0x18,
14292 : 0x2, 0x2, 0x35c, 0x35d, 0x5, 0x130, 0x99, 0x2, 0x35d, 0x35e, 0x7, 0x19,
14293 : 0x2, 0x2, 0x35e, 0x367, 0x3, 0x2, 0x2, 0x2, 0x35f, 0x360, 0x7, 0x24,
14294 : 0x2, 0x2, 0x360, 0x361, 0x7, 0x18, 0x2, 0x2, 0x361, 0x362, 0x5, 0xac,
14295 : 0x57, 0x2, 0x362, 0x363, 0x7, 0x1b, 0x2, 0x2, 0x363, 0x364, 0x5, 0x130,
14296 : 0x99, 0x2, 0x364, 0x365, 0x7, 0x19, 0x2, 0x2, 0x365, 0x367, 0x3, 0x2,
14297 : 0x2, 0x2, 0x366, 0x35a, 0x3, 0x2, 0x2, 0x2, 0x366, 0x35f, 0x3, 0x2,
14298 : 0x2, 0x2, 0x367, 0xab, 0x3, 0x2, 0x2, 0x2, 0x368, 0x369, 0x7, 0x55,
14299 : 0x2, 0x2, 0x369, 0xad, 0x3, 0x2, 0x2, 0x2, 0x36a, 0x36b, 0x7, 0x24,
14300 : 0x2, 0x2, 0x36b, 0x36c, 0x7, 0x18, 0x2, 0x2, 0x36c, 0x36d, 0x5, 0x130,
14301 : 0x99, 0x2, 0x36d, 0x36e, 0x7, 0x19, 0x2, 0x2, 0x36e, 0xaf, 0x3, 0x2,
14302 : 0x2, 0x2, 0x36f, 0x370, 0x7, 0x25, 0x2, 0x2, 0x370, 0x371, 0x7, 0x18,
14303 : 0x2, 0x2, 0x371, 0x372, 0x5, 0x130, 0x99, 0x2, 0x372, 0x373, 0x7, 0x19,
14304 : 0x2, 0x2, 0x373, 0x37c, 0x3, 0x2, 0x2, 0x2, 0x374, 0x375, 0x7, 0x25,
14305 : 0x2, 0x2, 0x375, 0x376, 0x7, 0x18, 0x2, 0x2, 0x376, 0x377, 0x5, 0xb2,
14306 : 0x5a, 0x2, 0x377, 0x378, 0x7, 0x1b, 0x2, 0x2, 0x378, 0x379, 0x5, 0x130,
14307 : 0x99, 0x2, 0x379, 0x37a, 0x7, 0x19, 0x2, 0x2, 0x37a, 0x37c, 0x3, 0x2,
14308 : 0x2, 0x2, 0x37b, 0x36f, 0x3, 0x2, 0x2, 0x2, 0x37b, 0x374, 0x3, 0x2,
14309 : 0x2, 0x2, 0x37c, 0xb1, 0x3, 0x2, 0x2, 0x2, 0x37d, 0x37e, 0x7, 0x5b,
14310 : 0x2, 0x2, 0x37e, 0xb3, 0x3, 0x2, 0x2, 0x2, 0x37f, 0x380, 0x7, 0x25,
14311 : 0x2, 0x2, 0x380, 0x381, 0x7, 0x18, 0x2, 0x2, 0x381, 0x382, 0x5, 0x130,
14312 : 0x99, 0x2, 0x382, 0x383, 0x7, 0x19, 0x2, 0x2, 0x383, 0xb5, 0x3, 0x2,
14313 : 0x2, 0x2, 0x384, 0x385, 0x7, 0x26, 0x2, 0x2, 0x385, 0x386, 0x7, 0x18,
14314 : 0x2, 0x2, 0x386, 0x387, 0x5, 0x130, 0x99, 0x2, 0x387, 0x388, 0x7, 0x19,
14315 : 0x2, 0x2, 0x388, 0x391, 0x3, 0x2, 0x2, 0x2, 0x389, 0x38a, 0x7, 0x26,
14316 : 0x2, 0x2, 0x38a, 0x38b, 0x7, 0x18, 0x2, 0x2, 0x38b, 0x38c, 0x5, 0xb8,
14317 : 0x5d, 0x2, 0x38c, 0x38d, 0x7, 0x1b, 0x2, 0x2, 0x38d, 0x38e, 0x5, 0x130,
14318 : 0x99, 0x2, 0x38e, 0x38f, 0x7, 0x19, 0x2, 0x2, 0x38f, 0x391, 0x3, 0x2,
14319 : 0x2, 0x2, 0x390, 0x384, 0x3, 0x2, 0x2, 0x2, 0x390, 0x389, 0x3, 0x2,
14320 : 0x2, 0x2, 0x391, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x392, 0x393, 0x7, 0x5b,
14321 : 0x2, 0x2, 0x393, 0xb9, 0x3, 0x2, 0x2, 0x2, 0x394, 0x395, 0x7, 0x26,
14322 : 0x2, 0x2, 0x395, 0x396, 0x7, 0x18, 0x2, 0x2, 0x396, 0x397, 0x5, 0x130,
14323 : 0x99, 0x2, 0x397, 0x398, 0x7, 0x19, 0x2, 0x2, 0x398, 0xbb, 0x3, 0x2,
14324 : 0x2, 0x2, 0x399, 0x39a, 0x7, 0x27, 0x2, 0x2, 0x39a, 0x39b, 0x7, 0x18,
14325 : 0x2, 0x2, 0x39b, 0x39c, 0x5, 0xbe, 0x60, 0x2, 0x39c, 0x39d, 0x7, 0x19,
14326 : 0x2, 0x2, 0x39d, 0xbd, 0x3, 0x2, 0x2, 0x2, 0x39e, 0x39f, 0x9, 0x2, 0x2,
14327 : 0x2, 0x39f, 0xbf, 0x3, 0x2, 0x2, 0x2, 0x3a0, 0x3a1, 0x7, 0x28, 0x2,
14328 : 0x2, 0x3a1, 0x3a2, 0x7, 0x18, 0x2, 0x2, 0x3a2, 0x3a3, 0x5, 0x12e, 0x98,
14329 : 0x2, 0x3a3, 0x3a4, 0x7, 0x19, 0x2, 0x2, 0x3a4, 0xc1, 0x3, 0x2, 0x2,
14330 : 0x2, 0x3a5, 0x3a6, 0x7, 0x29, 0x2, 0x2, 0x3a6, 0x3a7, 0x7, 0x18, 0x2,
14331 : 0x2, 0x3a7, 0x3a8, 0x5, 0x130, 0x99, 0x2, 0x3a8, 0x3a9, 0x7, 0x19, 0x2,
14332 : 0x2, 0x3a9, 0xc3, 0x3, 0x2, 0x2, 0x2, 0x3aa, 0x3ab, 0x7, 0x2a, 0x2,
14333 : 0x2, 0x3ab, 0x3ac, 0x7, 0x18, 0x2, 0x2, 0x3ac, 0x3ad, 0x5, 0x130, 0x99,
14334 : 0x2, 0x3ad, 0x3ae, 0x7, 0x19, 0x2, 0x2, 0x3ae, 0xc5, 0x3, 0x2, 0x2,
14335 : 0x2, 0x3af, 0x3b0, 0x7, 0x2b, 0x2, 0x2, 0x3b0, 0x3b1, 0x7, 0x18, 0x2,
14336 : 0x2, 0x3b1, 0x3b2, 0x5, 0x130, 0x99, 0x2, 0x3b2, 0x3b3, 0x7, 0x19, 0x2,
14337 : 0x2, 0x3b3, 0xc7, 0x3, 0x2, 0x2, 0x2, 0x3b4, 0x3b5, 0x7, 0x2c, 0x2,
14338 : 0x2, 0x3b5, 0x3b6, 0x7, 0x18, 0x2, 0x2, 0x3b6, 0x3b7, 0x5, 0x12e, 0x98,
14339 : 0x2, 0x3b7, 0x3b8, 0x7, 0x19, 0x2, 0x2, 0x3b8, 0xc9, 0x3, 0x2, 0x2,
14340 : 0x2, 0x3b9, 0x3ba, 0x7, 0x2d, 0x2, 0x2, 0x3ba, 0x3bb, 0x7, 0x18, 0x2,
14341 : 0x2, 0x3bb, 0x3bc, 0x5, 0x130, 0x99, 0x2, 0x3bc, 0x3bd, 0x7, 0x19, 0x2,
14342 : 0x2, 0x3bd, 0xcb, 0x3, 0x2, 0x2, 0x2, 0x3be, 0x3bf, 0x7, 0x2e, 0x2,
14343 : 0x2, 0x3bf, 0x3c0, 0x7, 0x18, 0x2, 0x2, 0x3c0, 0x3c1, 0x5, 0xce, 0x68,
14344 : 0x2, 0x3c1, 0x3c2, 0x7, 0x19, 0x2, 0x2, 0x3c2, 0xcd, 0x3, 0x2, 0x2,
14345 : 0x2, 0x3c3, 0x3c4, 0x5, 0x132, 0x9a, 0x2, 0x3c4, 0x3c5, 0x7, 0x89, 0x2,
14346 : 0x2, 0x3c5, 0x3c8, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x3c8, 0x5, 0x132, 0x9a,
14347 : 0x2, 0x3c7, 0x3c3, 0x3, 0x2, 0x2, 0x2, 0x3c7, 0x3c6, 0x3, 0x2, 0x2,
14348 : 0x2, 0x3c8, 0x3c9, 0x3, 0x2, 0x2, 0x2, 0x3c9, 0x3c7, 0x3, 0x2, 0x2,
14349 : 0x2, 0x3c9, 0x3ca, 0x3, 0x2, 0x2, 0x2, 0x3ca, 0xcf, 0x3, 0x2, 0x2, 0x2,
14350 : 0x3cb, 0x3cc, 0x7, 0x2f, 0x2, 0x2, 0x3cc, 0x3cd, 0x7, 0x18, 0x2, 0x2,
14351 : 0x3cd, 0x3ce, 0x5, 0x130, 0x99, 0x2, 0x3ce, 0x3cf, 0x7, 0x19, 0x2, 0x2,
14352 : 0x3cf, 0xd1, 0x3, 0x2, 0x2, 0x2, 0x3d0, 0x3d1, 0x7, 0x30, 0x2, 0x2,
14353 : 0x3d1, 0xd3, 0x3, 0x2, 0x2, 0x2, 0x3d2, 0x3d3, 0x7, 0x31, 0x2, 0x2,
14354 : 0x3d3, 0x3d4, 0x7, 0x18, 0x2, 0x2, 0x3d4, 0x3d5, 0x5, 0x130, 0x99, 0x2,
14355 : 0x3d5, 0x3d6, 0x7, 0x19, 0x2, 0x2, 0x3d6, 0xd5, 0x3, 0x2, 0x2, 0x2,
14356 : 0x3d7, 0x3de, 0x7, 0x32, 0x2, 0x2, 0x3d8, 0x3d9, 0x7, 0x32, 0x2, 0x2,
14357 : 0x3d9, 0x3da, 0x7, 0x18, 0x2, 0x2, 0x3da, 0x3db, 0x5, 0xd8, 0x6d, 0x2,
14358 : 0x3db, 0x3dc, 0x7, 0x19, 0x2, 0x2, 0x3dc, 0x3de, 0x3, 0x2, 0x2, 0x2,
14359 : 0x3dd, 0x3d7, 0x3, 0x2, 0x2, 0x2, 0x3dd, 0x3d8, 0x3, 0x2, 0x2, 0x2,
14360 : 0x3de, 0xd7, 0x3, 0x2, 0x2, 0x2, 0x3df, 0x3e0, 0x5, 0x132, 0x9a, 0x2,
14361 : 0x3e0, 0x3e1, 0x7, 0x89, 0x2, 0x2, 0x3e1, 0x3e4, 0x3, 0x2, 0x2, 0x2,
14362 : 0x3e2, 0x3e4, 0x5, 0x132, 0x9a, 0x2, 0x3e3, 0x3df, 0x3, 0x2, 0x2, 0x2,
14363 : 0x3e3, 0x3e2, 0x3, 0x2, 0x2, 0x2, 0x3e4, 0x3e5, 0x3, 0x2, 0x2, 0x2,
14364 : 0x3e5, 0x3e3, 0x3, 0x2, 0x2, 0x2, 0x3e5, 0x3e6, 0x3, 0x2, 0x2, 0x2,
14365 : 0x3e6, 0xd9, 0x3, 0x2, 0x2, 0x2, 0x3e7, 0x3e8, 0x7, 0x32, 0x2, 0x2,
14366 : 0x3e8, 0xdb, 0x3, 0x2, 0x2, 0x2, 0x3e9, 0x3ea, 0x7, 0x33, 0x2, 0x2,
14367 : 0x3ea, 0x3eb, 0x7, 0x18, 0x2, 0x2, 0x3eb, 0x3ec, 0x5, 0x130, 0x99, 0x2,
14368 : 0x3ec, 0x3ed, 0x7, 0x19, 0x2, 0x2, 0x3ed, 0xdd, 0x3, 0x2, 0x2, 0x2,
14369 : 0x3ee, 0x3ef, 0x7, 0x34, 0x2, 0x2, 0x3ef, 0x3f0, 0x7, 0x18, 0x2, 0x2,
14370 : 0x3f0, 0x3f1, 0x5, 0xfc, 0x7f, 0x2, 0x3f1, 0x3f2, 0x7, 0x19, 0x2, 0x2,
14371 : 0x3f2, 0xdf, 0x3, 0x2, 0x2, 0x2, 0x3f3, 0x3f4, 0x7, 0x35, 0x2, 0x2,
14372 : 0x3f4, 0xe1, 0x3, 0x2, 0x2, 0x2, 0x3f5, 0x3f6, 0x7, 0x36, 0x2, 0x2,
14373 : 0x3f6, 0xe3, 0x3, 0x2, 0x2, 0x2, 0x3f7, 0x3f8, 0x7, 0x37, 0x2, 0x2,
14374 : 0x3f8, 0x3f9, 0x7, 0x18, 0x2, 0x2, 0x3f9, 0x3fa, 0x5, 0x130, 0x99, 0x2,
14375 : 0x3fa, 0x3fb, 0x7, 0x19, 0x2, 0x2, 0x3fb, 0xe5, 0x3, 0x2, 0x2, 0x2,
14376 : 0x3fc, 0x3fd, 0x7, 0x38, 0x2, 0x2, 0x3fd, 0xe7, 0x3, 0x2, 0x2, 0x2,
14377 : 0x3fe, 0x3ff, 0x7, 0x39, 0x2, 0x2, 0x3ff, 0x400, 0x7, 0x18, 0x2, 0x2,
14378 : 0x400, 0x401, 0x5, 0x130, 0x99, 0x2, 0x401, 0x402, 0x7, 0x19, 0x2, 0x2,
14379 : 0x402, 0xe9, 0x3, 0x2, 0x2, 0x2, 0x403, 0x404, 0x7, 0x3b, 0x2, 0x2,
14380 : 0x404, 0x405, 0x7, 0x18, 0x2, 0x2, 0x405, 0x406, 0x5, 0x12e, 0x98, 0x2,
14381 : 0x406, 0x407, 0x7, 0x19, 0x2, 0x2, 0x407, 0xeb, 0x3, 0x2, 0x2, 0x2,
14382 : 0x408, 0x409, 0x7, 0x3c, 0x2, 0x2, 0x409, 0x40a, 0x7, 0x18, 0x2, 0x2,
14383 : 0x40a, 0x40b, 0x5, 0x12e, 0x98, 0x2, 0x40b, 0x40c, 0x7, 0x19, 0x2, 0x2,
14384 : 0x40c, 0xed, 0x3, 0x2, 0x2, 0x2, 0x40d, 0x40e, 0x7, 0x3d, 0x2, 0x2,
14385 : 0x40e, 0x40f, 0x7, 0x18, 0x2, 0x2, 0x40f, 0x410, 0x5, 0x130, 0x99, 0x2,
14386 : 0x410, 0x411, 0x7, 0x19, 0x2, 0x2, 0x411, 0xef, 0x3, 0x2, 0x2, 0x2,
14387 : 0x412, 0x413, 0x7, 0x3e, 0x2, 0x2, 0x413, 0x414, 0x7, 0x18, 0x2, 0x2,
14388 : 0x414, 0x415, 0x5, 0x130, 0x99, 0x2, 0x415, 0x416, 0x7, 0x19, 0x2, 0x2,
14389 : 0x416, 0xf1, 0x3, 0x2, 0x2, 0x2, 0x417, 0x418, 0x7, 0x3f, 0x2, 0x2,
14390 : 0x418, 0xf3, 0x3, 0x2, 0x2, 0x2, 0x419, 0x41a, 0x7, 0x40, 0x2, 0x2,
14391 : 0x41a, 0x41b, 0x7, 0x18, 0x2, 0x2, 0x41b, 0x41c, 0x5, 0xf6, 0x7c, 0x2,
14392 : 0x41c, 0x41d, 0x7, 0x1b, 0x2, 0x2, 0x41d, 0x41e, 0x5, 0x130, 0x99, 0x2,
14393 : 0x41e, 0x41f, 0x7, 0x19, 0x2, 0x2, 0x41f, 0xf5, 0x3, 0x2, 0x2, 0x2,
14394 : 0x420, 0x421, 0x9, 0x3, 0x2, 0x2, 0x421, 0xf7, 0x3, 0x2, 0x2, 0x2, 0x422,
14395 : 0x429, 0x7, 0x41, 0x2, 0x2, 0x423, 0x424, 0x7, 0x41, 0x2, 0x2, 0x424,
14396 : 0x425, 0x7, 0x18, 0x2, 0x2, 0x425, 0x426, 0x5, 0xfc, 0x7f, 0x2, 0x426,
14397 : 0x427, 0x7, 0x19, 0x2, 0x2, 0x427, 0x429, 0x3, 0x2, 0x2, 0x2, 0x428,
14398 : 0x422, 0x3, 0x2, 0x2, 0x2, 0x428, 0x423, 0x3, 0x2, 0x2, 0x2, 0x429,
14399 : 0xf9, 0x3, 0x2, 0x2, 0x2, 0x42a, 0x42b, 0x7, 0x41, 0x2, 0x2, 0x42b,
14400 : 0x42c, 0x7, 0x18, 0x2, 0x2, 0x42c, 0x42d, 0x5, 0x130, 0x99, 0x2, 0x42d,
14401 : 0x42e, 0x7, 0x19, 0x2, 0x2, 0x42e, 0xfb, 0x3, 0x2, 0x2, 0x2, 0x42f,
14402 : 0x430, 0x7, 0x3, 0x2, 0x2, 0x430, 0xfd, 0x3, 0x2, 0x2, 0x2, 0x431, 0x432,
14403 : 0x7, 0x42, 0x2, 0x2, 0x432, 0xff, 0x3, 0x2, 0x2, 0x2, 0x433, 0x434,
14404 : 0x7, 0x43, 0x2, 0x2, 0x434, 0x435, 0x7, 0x18, 0x2, 0x2, 0x435, 0x436,
14405 : 0x5, 0x104, 0x83, 0x2, 0x436, 0x437, 0x7, 0x19, 0x2, 0x2, 0x437, 0x101,
14406 : 0x3, 0x2, 0x2, 0x2, 0x438, 0x439, 0x7, 0x17, 0x2, 0x2, 0x439, 0x103,
14407 : 0x3, 0x2, 0x2, 0x2, 0x43a, 0x43b, 0x5, 0x132, 0x9a, 0x2, 0x43b, 0x43c,
14408 : 0x7, 0x89, 0x2, 0x2, 0x43c, 0x43f, 0x3, 0x2, 0x2, 0x2, 0x43d, 0x43f,
14409 : 0x5, 0x132, 0x9a, 0x2, 0x43e, 0x43a, 0x3, 0x2, 0x2, 0x2, 0x43e, 0x43d,
14410 : 0x3, 0x2, 0x2, 0x2, 0x43f, 0x440, 0x3, 0x2, 0x2, 0x2, 0x440, 0x43e,
14411 : 0x3, 0x2, 0x2, 0x2, 0x440, 0x441, 0x3, 0x2, 0x2, 0x2, 0x441, 0x105,
14412 : 0x3, 0x2, 0x2, 0x2, 0x442, 0x443, 0x7, 0x44, 0x2, 0x2, 0x443, 0x444,
14413 : 0x7, 0x18, 0x2, 0x2, 0x444, 0x445, 0x5, 0x130, 0x99, 0x2, 0x445, 0x446,
14414 : 0x7, 0x19, 0x2, 0x2, 0x446, 0x107, 0x3, 0x2, 0x2, 0x2, 0x447, 0x44b,
14415 : 0x7, 0x45, 0x2, 0x2, 0x448, 0x449, 0x7, 0x45, 0x2, 0x2, 0x449, 0x44b,
14416 : 0x5, 0x10a, 0x86, 0x2, 0x44a, 0x447, 0x3, 0x2, 0x2, 0x2, 0x44a, 0x448,
14417 : 0x3, 0x2, 0x2, 0x2, 0x44b, 0x109, 0x3, 0x2, 0x2, 0x2, 0x44c, 0x44d,
14418 : 0x7, 0x18, 0x2, 0x2, 0x44d, 0x44e, 0x5, 0x10c, 0x87, 0x2, 0x44e, 0x44f,
14419 : 0x7, 0x1b, 0x2, 0x2, 0x44f, 0x450, 0x5, 0x12e, 0x98, 0x2, 0x450, 0x451,
14420 : 0x7, 0x19, 0x2, 0x2, 0x451, 0x457, 0x3, 0x2, 0x2, 0x2, 0x452, 0x453,
14421 : 0x7, 0x18, 0x2, 0x2, 0x453, 0x454, 0x5, 0x12e, 0x98, 0x2, 0x454, 0x455,
14422 : 0x7, 0x19, 0x2, 0x2, 0x455, 0x457, 0x3, 0x2, 0x2, 0x2, 0x456, 0x44c,
14423 : 0x3, 0x2, 0x2, 0x2, 0x456, 0x452, 0x3, 0x2, 0x2, 0x2, 0x457, 0x10b,
14424 : 0x3, 0x2, 0x2, 0x2, 0x458, 0x459, 0x7, 0x6a, 0x2, 0x2, 0x459, 0x10d,
14425 : 0x3, 0x2, 0x2, 0x2, 0x45a, 0x45b, 0x7, 0x45, 0x2, 0x2, 0x45b, 0x10f,
14426 : 0x3, 0x2, 0x2, 0x2, 0x45c, 0x45d, 0x7, 0x46, 0x2, 0x2, 0x45d, 0x45e,
14427 : 0x7, 0x18, 0x2, 0x2, 0x45e, 0x45f, 0x5, 0x12e, 0x98, 0x2, 0x45f, 0x460,
14428 : 0x7, 0x19, 0x2, 0x2, 0x460, 0x111, 0x3, 0x2, 0x2, 0x2, 0x461, 0x468,
14429 : 0x7, 0x47, 0x2, 0x2, 0x462, 0x463, 0x7, 0x47, 0x2, 0x2, 0x463, 0x464,
14430 : 0x7, 0x18, 0x2, 0x2, 0x464, 0x465, 0x5, 0x12c, 0x97, 0x2, 0x465, 0x466,
14431 : 0x7, 0x19, 0x2, 0x2, 0x466, 0x468, 0x3, 0x2, 0x2, 0x2, 0x467, 0x461,
14432 : 0x3, 0x2, 0x2, 0x2, 0x467, 0x462, 0x3, 0x2, 0x2, 0x2, 0x468, 0x113,
14433 : 0x3, 0x2, 0x2, 0x2, 0x469, 0x470, 0x7, 0x47, 0x2, 0x2, 0x46a, 0x46b,
14434 : 0x7, 0x47, 0x2, 0x2, 0x46b, 0x46c, 0x7, 0x18, 0x2, 0x2, 0x46c, 0x46d,
14435 : 0x5, 0x116, 0x8c, 0x2, 0x46d, 0x46e, 0x7, 0x19, 0x2, 0x2, 0x46e, 0x470,
14436 : 0x3, 0x2, 0x2, 0x2, 0x46f, 0x469, 0x3, 0x2, 0x2, 0x2, 0x46f, 0x46a,
14437 : 0x3, 0x2, 0x2, 0x2, 0x470, 0x115, 0x3, 0x2, 0x2, 0x2, 0x471, 0x472,
14438 : 0x7, 0x7d, 0x2, 0x2, 0x472, 0x473, 0x7, 0x1b, 0x2, 0x2, 0x473, 0x474,
14439 : 0x5, 0x11e, 0x90, 0x2, 0x474, 0x475, 0x7, 0x1b, 0x2, 0x2, 0x475, 0x476,
14440 : 0x5, 0x11c, 0x8f, 0x2, 0x476, 0x477, 0x7, 0x1b, 0x2, 0x2, 0x477, 0x478,
14441 : 0x5, 0x118, 0x8d, 0x2, 0x478, 0x485, 0x3, 0x2, 0x2, 0x2, 0x479, 0x47a,
14442 : 0x7, 0x7d, 0x2, 0x2, 0x47a, 0x47b, 0x7, 0x1b, 0x2, 0x2, 0x47b, 0x47c,
14443 : 0x5, 0x11e, 0x90, 0x2, 0x47c, 0x47d, 0x7, 0x1b, 0x2, 0x2, 0x47d, 0x47e,
14444 : 0x5, 0x118, 0x8d, 0x2, 0x47e, 0x485, 0x3, 0x2, 0x2, 0x2, 0x47f, 0x480,
14445 : 0x5, 0x11c, 0x8f, 0x2, 0x480, 0x481, 0x7, 0x1b, 0x2, 0x2, 0x481, 0x482,
14446 : 0x5, 0x118, 0x8d, 0x2, 0x482, 0x485, 0x3, 0x2, 0x2, 0x2, 0x483, 0x485,
14447 : 0x5, 0x118, 0x8d, 0x2, 0x484, 0x471, 0x3, 0x2, 0x2, 0x2, 0x484, 0x479,
14448 : 0x3, 0x2, 0x2, 0x2, 0x484, 0x47f, 0x3, 0x2, 0x2, 0x2, 0x484, 0x483,
14449 : 0x3, 0x2, 0x2, 0x2, 0x485, 0x117, 0x3, 0x2, 0x2, 0x2, 0x486, 0x487,
14450 : 0x5, 0x11a, 0x8e, 0x2, 0x487, 0x488, 0x7, 0x89, 0x2, 0x2, 0x488, 0x48b,
14451 : 0x3, 0x2, 0x2, 0x2, 0x489, 0x48b, 0x5, 0x11a, 0x8e, 0x2, 0x48a, 0x486,
14452 : 0x3, 0x2, 0x2, 0x2, 0x48a, 0x489, 0x3, 0x2, 0x2, 0x2, 0x48b, 0x48c,
14453 : 0x3, 0x2, 0x2, 0x2, 0x48c, 0x48a, 0x3, 0x2, 0x2, 0x2, 0x48c, 0x48d,
14454 : 0x3, 0x2, 0x2, 0x2, 0x48d, 0x119, 0x3, 0x2, 0x2, 0x2, 0x48e, 0x48f,
14455 : 0x7, 0x3, 0x2, 0x2, 0x48f, 0x11b, 0x3, 0x2, 0x2, 0x2, 0x490, 0x491,
14456 : 0x7, 0x7e, 0x2, 0x2, 0x491, 0x11d, 0x3, 0x2, 0x2, 0x2, 0x492, 0x493,
14457 : 0x7, 0x3, 0x2, 0x2, 0x493, 0x11f, 0x3, 0x2, 0x2, 0x2, 0x494, 0x498,
14458 : 0x7, 0x48, 0x2, 0x2, 0x495, 0x496, 0x7, 0x48, 0x2, 0x2, 0x496, 0x498,
14459 : 0x5, 0x122, 0x92, 0x2, 0x497, 0x494, 0x3, 0x2, 0x2, 0x2, 0x497, 0x495,
14460 : 0x3, 0x2, 0x2, 0x2, 0x498, 0x121, 0x3, 0x2, 0x2, 0x2, 0x499, 0x49a,
14461 : 0x7, 0x18, 0x2, 0x2, 0x49a, 0x49b, 0x5, 0x124, 0x93, 0x2, 0x49b, 0x49c,
14462 : 0x7, 0x1b, 0x2, 0x2, 0x49c, 0x49d, 0x5, 0x12e, 0x98, 0x2, 0x49d, 0x49e,
14463 : 0x7, 0x19, 0x2, 0x2, 0x49e, 0x4a4, 0x3, 0x2, 0x2, 0x2, 0x49f, 0x4a0,
14464 : 0x7, 0x18, 0x2, 0x2, 0x4a0, 0x4a1, 0x5, 0x12e, 0x98, 0x2, 0x4a1, 0x4a2,
14465 : 0x7, 0x19, 0x2, 0x2, 0x4a2, 0x4a4, 0x3, 0x2, 0x2, 0x2, 0x4a3, 0x499,
14466 : 0x3, 0x2, 0x2, 0x2, 0x4a3, 0x49f, 0x3, 0x2, 0x2, 0x2, 0x4a4, 0x123,
14467 : 0x3, 0x2, 0x2, 0x2, 0x4a5, 0x4a6, 0x7, 0x3a, 0x2, 0x2, 0x4a6, 0x125,
14468 : 0x3, 0x2, 0x2, 0x2, 0x4a7, 0x4a8, 0x7, 0x48, 0x2, 0x2, 0x4a8, 0x127,
14469 : 0x3, 0x2, 0x2, 0x2, 0x4a9, 0x4aa, 0x7, 0x49, 0x2, 0x2, 0x4aa, 0x129,
14470 : 0x3, 0x2, 0x2, 0x2, 0x4ab, 0x4ac, 0x7, 0x3, 0x2, 0x2, 0x4ac, 0x12b,
14471 : 0x3, 0x2, 0x2, 0x2, 0x4ad, 0x4ae, 0x5, 0x12e, 0x98, 0x2, 0x4ae, 0x4af,
14472 : 0x7, 0x89, 0x2, 0x2, 0x4af, 0x4b2, 0x3, 0x2, 0x2, 0x2, 0x4b0, 0x4b2,
14473 : 0x5, 0x12e, 0x98, 0x2, 0x4b1, 0x4ad, 0x3, 0x2, 0x2, 0x2, 0x4b1, 0x4b0,
14474 : 0x3, 0x2, 0x2, 0x2, 0x4b2, 0x4b3, 0x3, 0x2, 0x2, 0x2, 0x4b3, 0x4b1,
14475 : 0x3, 0x2, 0x2, 0x2, 0x4b3, 0x4b4, 0x3, 0x2, 0x2, 0x2, 0x4b4, 0x12d,
14476 : 0x3, 0x2, 0x2, 0x2, 0x4b5, 0x4b6, 0x7, 0x3, 0x2, 0x2, 0x4b6, 0x12f,
14477 : 0x3, 0x2, 0x2, 0x2, 0x4b7, 0x4b8, 0x5, 0x132, 0x9a, 0x2, 0x4b8, 0x4b9,
14478 : 0x7, 0x89, 0x2, 0x2, 0x4b9, 0x4bc, 0x3, 0x2, 0x2, 0x2, 0x4ba, 0x4bc,
14479 : 0x5, 0x132, 0x9a, 0x2, 0x4bb, 0x4b7, 0x3, 0x2, 0x2, 0x2, 0x4bb, 0x4ba,
14480 : 0x3, 0x2, 0x2, 0x2, 0x4bc, 0x4bd, 0x3, 0x2, 0x2, 0x2, 0x4bd, 0x4bb,
14481 : 0x3, 0x2, 0x2, 0x2, 0x4bd, 0x4be, 0x3, 0x2, 0x2, 0x2, 0x4be, 0x131,
14482 : 0x3, 0x2, 0x2, 0x2, 0x4bf, 0x4c0, 0x7, 0x3, 0x2, 0x2, 0x4c0, 0x133,
14483 : 0x3, 0x2, 0x2, 0x2, 0x47, 0x13b, 0x156, 0x15b, 0x161, 0x16f, 0x179,
14484 : 0x186, 0x18e, 0x198, 0x1a8, 0x1c3, 0x1cb, 0x1d4, 0x1dd, 0x1e5, 0x1ea,
14485 : 0x1f2, 0x1f8, 0x200, 0x214, 0x21d, 0x23b, 0x243, 0x251, 0x259, 0x270,
14486 : 0x279, 0x298, 0x2a2, 0x2a7, 0x2b0, 0x2ba, 0x2ce, 0x2d7, 0x2f3, 0x2fb,
14487 : 0x302, 0x30a, 0x310, 0x318, 0x322, 0x32c, 0x331, 0x336, 0x33e, 0x366,
14488 : 0x37b, 0x390, 0x3c7, 0x3c9, 0x3dd, 0x3e3, 0x3e5, 0x428, 0x43e, 0x440,
14489 : 0x44a, 0x456, 0x467, 0x46f, 0x484, 0x48a, 0x48c, 0x497, 0x4a3, 0x4b1,
14490 : 0x4b3, 0x4bb, 0x4bd,
14491 356 : };
14492 :
14493 712 : atn::ATNDeserializer deserializer;
14494 356 : _atn = deserializer.deserialize(_serializedATN);
14495 :
14496 356 : size_t count = _atn.getNumberOfDecisions();
14497 356 : _decisionToDFA.reserve(count);
14498 24920 : for (size_t i = 0; i < count; i++) {
14499 24564 : _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
14500 : }
14501 356 : }
14502 :
14503 : accparser::Initializer accparser::_init;
|
