1
2 package org.openswift.interpreter;
3
4 import org.antlr.runtime.*;
5 import java.util.Stack;
6 import java.util.List;
7 import java.util.ArrayList;
8
9
10 import org.antlr.runtime.tree.*;
11
12 public class SwiftParser extends Parser {
13 public static final String[] tokenNames = new String[] {
14 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "START_BASIC_HEADER_BLOCK", "START_APPLICATION_HEADER_BLOCK", "START_USER_HEADER_BLOCK", "START_TEXT_BLOCK", "START_TRAILER_BLOCK", "START_BANKING_PRIORITY_CODE", "START_MESSAGE_USER_REFERENCE", "START_MAC_TRAILER", "START_CHK_TRAILER", "START_PDE_TRAILER", "START_DLM_TRAILER", "END_ALL_BLOCK", "END_TEXT_BLOCK", "CODE_SEPARATOR", "PLUS", "MINUS", "AMOUNT_SEPARATOR", "TAG_20", "TAG_13C", "TAG_23B", "TAG_23E", "TAG_26T", "TAG_32A", "TAG_33B", "TAG_36", "TAG_50A", "TAG_50K", "TAG_50F", "UPPERCASE_LETTER", "LOWERCASE_LETTER", "NUMBER", "CRLF", "START_BLOCK", "INPUT_MESSAGE", "OUTPUT_MESSAGE", "TAG_NAME", "SPECIAL_LETTER"
15 };
16 public static final int OUTPUT_MESSAGE=38;
17 public static final int TAG_50A=29;
18 public static final int TAG_50F=31;
19 public static final int END_ALL_BLOCK=15;
20 public static final int START_MAC_TRAILER=11;
21 public static final int CRLF=35;
22 public static final int TAG_50K=30;
23 public static final int START_DLM_TRAILER=14;
24 public static final int START_BASIC_HEADER_BLOCK=4;
25 public static final int START_BANKING_PRIORITY_CODE=9;
26 public static final int NUMBER=34;
27 public static final int TAG_26T=25;
28 public static final int START_MESSAGE_USER_REFERENCE=10;
29 public static final int INPUT_MESSAGE=37;
30 public static final int TAG_32A=26;
31 public static final int MINUS=19;
32 public static final int EOF=-1;
33 public static final int START_USER_HEADER_BLOCK=6;
34 public static final int TAG_20=21;
35 public static final int TAG_13C=22;
36 public static final int TAG_NAME=39;
37 public static final int START_TEXT_BLOCK=7;
38 public static final int AMOUNT_SEPARATOR=20;
39 public static final int LOWERCASE_LETTER=33;
40 public static final int TAG_23B=23;
41 public static final int UPPERCASE_LETTER=32;
42 public static final int CODE_SEPARATOR=17;
43 public static final int TAG_23E=24;
44 public static final int START_PDE_TRAILER=13;
45 public static final int START_BLOCK=36;
46 public static final int END_TEXT_BLOCK=16;
47 public static final int START_CHK_TRAILER=12;
48 public static final int TAG_36=28;
49 public static final int START_TRAILER_BLOCK=8;
50 public static final int SPECIAL_LETTER=40;
51 public static final int PLUS=18;
52 public static final int TAG_33B=27;
53 public static final int START_APPLICATION_HEADER_BLOCK=5;
54
55
56
57
58
59 public SwiftParser(TokenStream input) {
60 this(input, new RecognizerSharedState());
61 }
62 public SwiftParser(TokenStream input, RecognizerSharedState state) {
63 super(input, state);
64
65 }
66
67 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
68
69 public void setTreeAdaptor(TreeAdaptor adaptor) {
70 this.adaptor = adaptor;
71 }
72 public TreeAdaptor getTreeAdaptor() {
73 return adaptor;
74 }
75
76 public String[] getTokenNames() { return SwiftParser.tokenNames; }
77 public String getGrammarFileName() { return "org/openswift/interpreter/SwiftParser.g"; }
78
79
80 protected void mismatch(IntStream input, int ttype, BitSet follow)
81 throws RecognitionException {
82 throw new MismatchedTokenException(ttype, input);
83 }
84
85 public Object recoverFromMismatchedSet(IntStream input, RecognitionException e, BitSet follow)
86 throws RecognitionException {
87 throw e;
88 }
89
90 protected Object recoverFromMismatchedToken(IntStream input, int ttype, BitSet follow)
91 throws RecognitionException {
92 throw new MismatchedTokenException(ttype, input);
93 }
94
95 public String getErrorMessage(RecognitionException e, String[] tokenNames) {
96 List stack = getRuleInvocationStack(e, this.getClass().getName());
97 String msg = null;
98 if (e instanceof NoViableAltException) {
99 NoViableAltException nvae = (NoViableAltException) e;
100 msg = " no viable alt; token=" + e.token + " (decision="
101 + nvae.decisionNumber + " state " + nvae.stateNumber + ")"
102 + " decision=<<" + nvae.grammarDecisionDescription + ">>";
103 } else {
104 msg = super.getErrorMessage(e, tokenNames);
105 }
106 return stack.subList(0, stack.size()-1) + " " + msg;
107 }
108
109 public String getTokenErrorDisplay(Token t) {
110 return t.getText();
111 }
112
113
114
115 public static class messages_return extends ParserRuleReturnScope {
116 Object tree;
117 public Object getTree() { return tree; }
118 };
119
120
121
122 public final SwiftParser.messages_return messages() throws RecognitionException {
123 SwiftParser.messages_return retval = new SwiftParser.messages_return();
124 retval.start = input.LT(1);
125
126 Object root_0 = null;
127
128 Token EOF2=null;
129 SwiftParser.message_return message1 = null;
130
131
132 Object EOF2_tree=null;
133 RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
134 RewriteRuleSubtreeStream stream_message=new RewriteRuleSubtreeStream(adaptor,"rule message");
135 try {
136
137
138 {
139
140 loop1:
141 do {
142 int alt1=2;
143 int LA1_0 = input.LA(1);
144
145 if ( (LA1_0==START_BASIC_HEADER_BLOCK) ) {
146 alt1=1;
147 }
148
149
150 switch (alt1) {
151 case 1 :
152
153 {
154 pushFollow(FOLLOW_message_in_messages84);
155 message1=message();
156
157 state._fsp--;
158
159 stream_message.add(message1.getTree());
160
161 }
162 break;
163
164 default :
165 break loop1;
166 }
167 } while (true);
168
169 EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_messages87);
170 stream_EOF.add(EOF2);
171
172
173
174
175
176
177
178
179
180
181 retval.tree = root_0;
182 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
183
184 root_0 = (Object)adaptor.nil();
185
186 {
187 adaptor.addChild(root_0, stream_message.nextTree());
188
189 }
190
191 retval.tree = root_0;
192 }
193
194 retval.stop = input.LT(-1);
195
196 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
197 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
198
199 }
200
201 catch (RecognitionException re) {
202 throw re;
203 }
204 finally {
205 }
206 return retval;
207 }
208
209
210 public static class message_return extends ParserRuleReturnScope {
211 Object tree;
212 public Object getTree() { return tree; }
213 };
214
215
216
217 public final SwiftParser.message_return message() throws RecognitionException {
218 SwiftParser.message_return retval = new SwiftParser.message_return();
219 retval.start = input.LT(1);
220
221 Object root_0 = null;
222
223 SwiftParser.blocks_return blocks3 = null;
224
225
226
227 try {
228
229
230 {
231 root_0 = (Object)adaptor.nil();
232
233 pushFollow(FOLLOW_blocks_in_message99);
234 blocks3=blocks();
235
236 state._fsp--;
237
238 adaptor.addChild(root_0, blocks3.getTree());
239
240 }
241
242 retval.stop = input.LT(-1);
243
244 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
245 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
246
247 }
248
249 catch (RecognitionException re) {
250 throw re;
251 }
252 finally {
253 }
254 return retval;
255 }
256
257
258 public static class blocks_return extends ParserRuleReturnScope {
259 Object tree;
260 public Object getTree() { return tree; }
261 };
262
263
264
265 public final SwiftParser.blocks_return blocks() throws RecognitionException {
266 SwiftParser.blocks_return retval = new SwiftParser.blocks_return();
267 retval.start = input.LT(1);
268
269 Object root_0 = null;
270
271 SwiftParser.basicHeaderBlock_return basicHeaderBlock4 = null;
272
273 SwiftParser.applicationHeaderBlock_return applicationHeaderBlock5 = null;
274
275 SwiftParser.userHeaderBlock_return userHeaderBlock6 = null;
276
277 SwiftParser.textBlock_return textBlock7 = null;
278
279 SwiftParser.trailerBlock_return trailerBlock8 = null;
280
281
282
283 try {
284
285
286 {
287 root_0 = (Object)adaptor.nil();
288
289 pushFollow(FOLLOW_basicHeaderBlock_in_blocks107);
290 basicHeaderBlock4=basicHeaderBlock();
291
292 state._fsp--;
293
294 adaptor.addChild(root_0, basicHeaderBlock4.getTree());
295 pushFollow(FOLLOW_applicationHeaderBlock_in_blocks120);
296 applicationHeaderBlock5=applicationHeaderBlock();
297
298 state._fsp--;
299
300 adaptor.addChild(root_0, applicationHeaderBlock5.getTree());
301
302 int alt2=2;
303 int LA2_0 = input.LA(1);
304
305 if ( (LA2_0==START_USER_HEADER_BLOCK) ) {
306 alt2=1;
307 }
308 switch (alt2) {
309 case 1 :
310
311 {
312 pushFollow(FOLLOW_userHeaderBlock_in_blocks132);
313 userHeaderBlock6=userHeaderBlock();
314
315 state._fsp--;
316
317 adaptor.addChild(root_0, userHeaderBlock6.getTree());
318
319 }
320 break;
321
322 }
323
324 pushFollow(FOLLOW_textBlock_in_blocks144);
325 textBlock7=textBlock();
326
327 state._fsp--;
328
329 adaptor.addChild(root_0, textBlock7.getTree());
330 pushFollow(FOLLOW_trailerBlock_in_blocks155);
331 trailerBlock8=trailerBlock();
332
333 state._fsp--;
334
335 adaptor.addChild(root_0, trailerBlock8.getTree());
336
337 }
338
339 retval.stop = input.LT(-1);
340
341 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
342 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
343
344 }
345
346 catch (RecognitionException re) {
347 throw re;
348 }
349 finally {
350 }
351 return retval;
352 }
353
354
355 public static class basicHeaderBlock_return extends ParserRuleReturnScope {
356 Object tree;
357 public Object getTree() { return tree; }
358 };
359
360
361
362 public final SwiftParser.basicHeaderBlock_return basicHeaderBlock() throws RecognitionException {
363 SwiftParser.basicHeaderBlock_return retval = new SwiftParser.basicHeaderBlock_return();
364 retval.start = input.LT(1);
365
366 Object root_0 = null;
367
368 Token START_BASIC_HEADER_BLOCK9=null;
369 Token END_ALL_BLOCK15=null;
370 SwiftParser.applicationId_return applicationId10 = null;
371
372 SwiftParser.serviceId_return serviceId11 = null;
373
374 SwiftParser.logicalTerminalAddress_return logicalTerminalAddress12 = null;
375
376 SwiftParser.sessionNumber_return sessionNumber13 = null;
377
378 SwiftParser.sequenceNumber_return sequenceNumber14 = null;
379
380
381 Object START_BASIC_HEADER_BLOCK9_tree=null;
382 Object END_ALL_BLOCK15_tree=null;
383 RewriteRuleTokenStream stream_END_ALL_BLOCK=new RewriteRuleTokenStream(adaptor,"token END_ALL_BLOCK");
384 RewriteRuleTokenStream stream_START_BASIC_HEADER_BLOCK=new RewriteRuleTokenStream(adaptor,"token START_BASIC_HEADER_BLOCK");
385 RewriteRuleSubtreeStream stream_serviceId=new RewriteRuleSubtreeStream(adaptor,"rule serviceId");
386 RewriteRuleSubtreeStream stream_logicalTerminalAddress=new RewriteRuleSubtreeStream(adaptor,"rule logicalTerminalAddress");
387 RewriteRuleSubtreeStream stream_applicationId=new RewriteRuleSubtreeStream(adaptor,"rule applicationId");
388 RewriteRuleSubtreeStream stream_sessionNumber=new RewriteRuleSubtreeStream(adaptor,"rule sessionNumber");
389 RewriteRuleSubtreeStream stream_sequenceNumber=new RewriteRuleSubtreeStream(adaptor,"rule sequenceNumber");
390 try {
391
392
393 {
394
395
396 {
397 START_BASIC_HEADER_BLOCK9=(Token)match(input,START_BASIC_HEADER_BLOCK,FOLLOW_START_BASIC_HEADER_BLOCK_in_basicHeaderBlock172);
398 stream_START_BASIC_HEADER_BLOCK.add(START_BASIC_HEADER_BLOCK9);
399
400 pushFollow(FOLLOW_applicationId_in_basicHeaderBlock174);
401 applicationId10=applicationId();
402
403 state._fsp--;
404
405 stream_applicationId.add(applicationId10.getTree());
406 pushFollow(FOLLOW_serviceId_in_basicHeaderBlock176);
407 serviceId11=serviceId();
408
409 state._fsp--;
410
411 stream_serviceId.add(serviceId11.getTree());
412 pushFollow(FOLLOW_logicalTerminalAddress_in_basicHeaderBlock178);
413 logicalTerminalAddress12=logicalTerminalAddress();
414
415 state._fsp--;
416
417 stream_logicalTerminalAddress.add(logicalTerminalAddress12.getTree());
418 pushFollow(FOLLOW_sessionNumber_in_basicHeaderBlock180);
419 sessionNumber13=sessionNumber();
420
421 state._fsp--;
422
423 stream_sessionNumber.add(sessionNumber13.getTree());
424 pushFollow(FOLLOW_sequenceNumber_in_basicHeaderBlock182);
425 sequenceNumber14=sequenceNumber();
426
427 state._fsp--;
428
429 stream_sequenceNumber.add(sequenceNumber14.getTree());
430 END_ALL_BLOCK15=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_basicHeaderBlock184);
431 stream_END_ALL_BLOCK.add(END_ALL_BLOCK15);
432
433
434 }
435
436
437
438
439
440
441
442
443
444
445 retval.tree = root_0;
446 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
447
448 root_0 = (Object)adaptor.nil();
449
450 {
451
452 {
453 Object root_1 = (Object)adaptor.nil();
454 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(START_BLOCK, "START_BLOCK"), root_1);
455
456 adaptor.addChild(root_1, stream_applicationId.nextTree());
457 adaptor.addChild(root_1, stream_serviceId.nextTree());
458 adaptor.addChild(root_1, stream_logicalTerminalAddress.nextTree());
459 adaptor.addChild(root_1, stream_sessionNumber.nextTree());
460 adaptor.addChild(root_1, stream_sequenceNumber.nextTree());
461
462 adaptor.addChild(root_0, root_1);
463 }
464
465 }
466
467 retval.tree = root_0;
468 }
469
470 retval.stop = input.LT(-1);
471
472 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
473 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
474
475 }
476 catch (RecognitionException e) {
477 throw e;
478 }
479 finally {
480 }
481 return retval;
482 }
483
484
485 public static class applicationHeaderBlock_return extends ParserRuleReturnScope {
486 Object tree;
487 public Object getTree() { return tree; }
488 };
489
490
491
492 public final SwiftParser.applicationHeaderBlock_return applicationHeaderBlock() throws RecognitionException {
493 SwiftParser.applicationHeaderBlock_return retval = new SwiftParser.applicationHeaderBlock_return();
494 retval.start = input.LT(1);
495
496 Object root_0 = null;
497
498 Token START_APPLICATION_HEADER_BLOCK16=null;
499 Token END_ALL_BLOCK18=null;
500 SwiftParser.inputMessageOrOutputMessage_return inputMessageOrOutputMessage17 = null;
501
502
503 Object START_APPLICATION_HEADER_BLOCK16_tree=null;
504 Object END_ALL_BLOCK18_tree=null;
505 RewriteRuleTokenStream stream_END_ALL_BLOCK=new RewriteRuleTokenStream(adaptor,"token END_ALL_BLOCK");
506 RewriteRuleTokenStream stream_START_APPLICATION_HEADER_BLOCK=new RewriteRuleTokenStream(adaptor,"token START_APPLICATION_HEADER_BLOCK");
507 RewriteRuleSubtreeStream stream_inputMessageOrOutputMessage=new RewriteRuleSubtreeStream(adaptor,"rule inputMessageOrOutputMessage");
508 try {
509
510
511 {
512
513
514 {
515 START_APPLICATION_HEADER_BLOCK16=(Token)match(input,START_APPLICATION_HEADER_BLOCK,FOLLOW_START_APPLICATION_HEADER_BLOCK_in_applicationHeaderBlock225);
516 stream_START_APPLICATION_HEADER_BLOCK.add(START_APPLICATION_HEADER_BLOCK16);
517
518 pushFollow(FOLLOW_inputMessageOrOutputMessage_in_applicationHeaderBlock227);
519 inputMessageOrOutputMessage17=inputMessageOrOutputMessage();
520
521 state._fsp--;
522
523 stream_inputMessageOrOutputMessage.add(inputMessageOrOutputMessage17.getTree());
524 END_ALL_BLOCK18=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_applicationHeaderBlock229);
525 stream_END_ALL_BLOCK.add(END_ALL_BLOCK18);
526
527
528 }
529
530
531
532
533
534
535
536
537
538
539 retval.tree = root_0;
540 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
541
542 root_0 = (Object)adaptor.nil();
543
544 {
545
546 {
547 Object root_1 = (Object)adaptor.nil();
548 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(START_BLOCK, "START_BLOCK"), root_1);
549
550 adaptor.addChild(root_1, stream_inputMessageOrOutputMessage.nextTree());
551
552 adaptor.addChild(root_0, root_1);
553 }
554
555 }
556
557 retval.tree = root_0;
558 }
559
560 retval.stop = input.LT(-1);
561
562 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
563 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
564
565 }
566
567 catch (RecognitionException re) {
568 throw re;
569 }
570 finally {
571 }
572 return retval;
573 }
574
575
576 public static class inputMessageOrOutputMessage_return extends ParserRuleReturnScope {
577 Object tree;
578 public Object getTree() { return tree; }
579 };
580
581
582
583 public final SwiftParser.inputMessageOrOutputMessage_return inputMessageOrOutputMessage() throws RecognitionException {
584 SwiftParser.inputMessageOrOutputMessage_return retval = new SwiftParser.inputMessageOrOutputMessage_return();
585 retval.start = input.LT(1);
586
587 Object root_0 = null;
588
589 SwiftParser.inputMessage_return inputMessage19 = null;
590
591 SwiftParser.outputMessage_return outputMessage20 = null;
592
593
594
595 try {
596
597
598 {
599 root_0 = (Object)adaptor.nil();
600
601
602 int alt3=2;
603 int LA3_0 = input.LA(1);
604
605 if ( (LA3_0==UPPERCASE_LETTER) ) {
606 int LA3_1 = input.LA(2);
607
608 if ( (LA3_1==NUMBER) ) {
609 int LA3_2 = input.LA(3);
610
611 if ( (LA3_2==NUMBER) ) {
612 int LA3_3 = input.LA(4);
613
614 if ( (LA3_3==NUMBER) ) {
615 int LA3_4 = input.LA(5);
616
617 if ( (LA3_4==NUMBER) ) {
618 alt3=2;
619 }
620 else if ( (LA3_4==UPPERCASE_LETTER) ) {
621 alt3=1;
622 }
623 else {
624 NoViableAltException nvae =
625 new NoViableAltException("", 3, 4, input);
626
627 throw nvae;
628 }
629 }
630 else {
631 NoViableAltException nvae =
632 new NoViableAltException("", 3, 3, input);
633
634 throw nvae;
635 }
636 }
637 else {
638 NoViableAltException nvae =
639 new NoViableAltException("", 3, 2, input);
640
641 throw nvae;
642 }
643 }
644 else {
645 NoViableAltException nvae =
646 new NoViableAltException("", 3, 1, input);
647
648 throw nvae;
649 }
650 }
651 else {
652 NoViableAltException nvae =
653 new NoViableAltException("", 3, 0, input);
654
655 throw nvae;
656 }
657 switch (alt3) {
658 case 1 :
659
660 {
661 pushFollow(FOLLOW_inputMessage_in_inputMessageOrOutputMessage257);
662 inputMessage19=inputMessage();
663
664 state._fsp--;
665
666 adaptor.addChild(root_0, inputMessage19.getTree());
667
668 }
669 break;
670 case 2 :
671
672 {
673 pushFollow(FOLLOW_outputMessage_in_inputMessageOrOutputMessage261);
674 outputMessage20=outputMessage();
675
676 state._fsp--;
677
678 adaptor.addChild(root_0, outputMessage20.getTree());
679
680 }
681 break;
682
683 }
684
685
686 }
687
688 retval.stop = input.LT(-1);
689
690 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
691 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
692
693 }
694
695 catch (RecognitionException re) {
696 throw re;
697 }
698 finally {
699 }
700 return retval;
701 }
702
703
704 public static class inputMessage_return extends ParserRuleReturnScope {
705 Object tree;
706 public Object getTree() { return tree; }
707 };
708
709
710
711 public final SwiftParser.inputMessage_return inputMessage() throws RecognitionException {
712 SwiftParser.inputMessage_return retval = new SwiftParser.inputMessage_return();
713 retval.start = input.LT(1);
714
715 Object root_0 = null;
716
717 Token UPPERCASE_LETTER21=null;
718 SwiftParser.type_return type22 = null;
719
720 SwiftParser.receiverAddress_return receiverAddress23 = null;
721
722 SwiftParser.priority_return priority24 = null;
723
724 SwiftParser.deliveryMonitor_return deliveryMonitor25 = null;
725
726 SwiftParser.obsolescencePeriod_return obsolescencePeriod26 = null;
727
728
729 Object UPPERCASE_LETTER21_tree=null;
730 RewriteRuleTokenStream stream_UPPERCASE_LETTER=new RewriteRuleTokenStream(adaptor,"token UPPERCASE_LETTER");
731 RewriteRuleSubtreeStream stream_obsolescencePeriod=new RewriteRuleSubtreeStream(adaptor,"rule obsolescencePeriod");
732 RewriteRuleSubtreeStream stream_priority=new RewriteRuleSubtreeStream(adaptor,"rule priority");
733 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
734 RewriteRuleSubtreeStream stream_receiverAddress=new RewriteRuleSubtreeStream(adaptor,"rule receiverAddress");
735 RewriteRuleSubtreeStream stream_deliveryMonitor=new RewriteRuleSubtreeStream(adaptor,"rule deliveryMonitor");
736 try {
737
738
739 {
740
741
742 {
743 UPPERCASE_LETTER21=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_inputMessage274);
744 stream_UPPERCASE_LETTER.add(UPPERCASE_LETTER21);
745
746 pushFollow(FOLLOW_type_in_inputMessage276);
747 type22=type();
748
749 state._fsp--;
750
751 stream_type.add(type22.getTree());
752 pushFollow(FOLLOW_receiverAddress_in_inputMessage278);
753 receiverAddress23=receiverAddress();
754
755 state._fsp--;
756
757 stream_receiverAddress.add(receiverAddress23.getTree());
758 pushFollow(FOLLOW_priority_in_inputMessage280);
759 priority24=priority();
760
761 state._fsp--;
762
763 stream_priority.add(priority24.getTree());
764 pushFollow(FOLLOW_deliveryMonitor_in_inputMessage282);
765 deliveryMonitor25=deliveryMonitor();
766
767 state._fsp--;
768
769 stream_deliveryMonitor.add(deliveryMonitor25.getTree());
770 pushFollow(FOLLOW_obsolescencePeriod_in_inputMessage284);
771 obsolescencePeriod26=obsolescencePeriod();
772
773 state._fsp--;
774
775 stream_obsolescencePeriod.add(obsolescencePeriod26.getTree());
776
777 }
778
779
780
781
782
783
784
785
786
787
788 retval.tree = root_0;
789 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
790
791 root_0 = (Object)adaptor.nil();
792
793 {
794
795 {
796 Object root_1 = (Object)adaptor.nil();
797 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(INPUT_MESSAGE, "INPUT_MESSAGE"), root_1);
798
799 adaptor.addChild(root_1, stream_type.nextTree());
800 adaptor.addChild(root_1, stream_receiverAddress.nextTree());
801 adaptor.addChild(root_1, stream_priority.nextTree());
802 adaptor.addChild(root_1, stream_deliveryMonitor.nextTree());
803 adaptor.addChild(root_1, stream_obsolescencePeriod.nextTree());
804
805 adaptor.addChild(root_0, root_1);
806 }
807
808 }
809
810 retval.tree = root_0;
811 }
812
813 retval.stop = input.LT(-1);
814
815 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
816 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
817
818 }
819
820 catch (RecognitionException re) {
821 throw re;
822 }
823 finally {
824 }
825 return retval;
826 }
827
828
829 public static class outputMessage_return extends ParserRuleReturnScope {
830 Object tree;
831 public Object getTree() { return tree; }
832 };
833
834
835
836 public final SwiftParser.outputMessage_return outputMessage() throws RecognitionException {
837 SwiftParser.outputMessage_return retval = new SwiftParser.outputMessage_return();
838 retval.start = input.LT(1);
839
840 Object root_0 = null;
841
842 Token UPPERCASE_LETTER27=null;
843 SwiftParser.type_return type28 = null;
844
845 SwiftParser.inputTime_return inputTime29 = null;
846
847 SwiftParser.messageInputReference_return messageInputReference30 = null;
848
849 SwiftParser.outputDate_return outputDate31 = null;
850
851 SwiftParser.outputTime_return outputTime32 = null;
852
853 SwiftParser.priority_return priority33 = null;
854
855
856 Object UPPERCASE_LETTER27_tree=null;
857 RewriteRuleTokenStream stream_UPPERCASE_LETTER=new RewriteRuleTokenStream(adaptor,"token UPPERCASE_LETTER");
858 RewriteRuleSubtreeStream stream_messageInputReference=new RewriteRuleSubtreeStream(adaptor,"rule messageInputReference");
859 RewriteRuleSubtreeStream stream_outputTime=new RewriteRuleSubtreeStream(adaptor,"rule outputTime");
860 RewriteRuleSubtreeStream stream_inputTime=new RewriteRuleSubtreeStream(adaptor,"rule inputTime");
861 RewriteRuleSubtreeStream stream_priority=new RewriteRuleSubtreeStream(adaptor,"rule priority");
862 RewriteRuleSubtreeStream stream_outputDate=new RewriteRuleSubtreeStream(adaptor,"rule outputDate");
863 RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
864 try {
865
866
867 {
868
869
870 {
871 UPPERCASE_LETTER27=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_outputMessage316);
872 stream_UPPERCASE_LETTER.add(UPPERCASE_LETTER27);
873
874 pushFollow(FOLLOW_type_in_outputMessage318);
875 type28=type();
876
877 state._fsp--;
878
879 stream_type.add(type28.getTree());
880 pushFollow(FOLLOW_inputTime_in_outputMessage320);
881 inputTime29=inputTime();
882
883 state._fsp--;
884
885 stream_inputTime.add(inputTime29.getTree());
886 pushFollow(FOLLOW_messageInputReference_in_outputMessage322);
887 messageInputReference30=messageInputReference();
888
889 state._fsp--;
890
891 stream_messageInputReference.add(messageInputReference30.getTree());
892 pushFollow(FOLLOW_outputDate_in_outputMessage324);
893 outputDate31=outputDate();
894
895 state._fsp--;
896
897 stream_outputDate.add(outputDate31.getTree());
898 pushFollow(FOLLOW_outputTime_in_outputMessage326);
899 outputTime32=outputTime();
900
901 state._fsp--;
902
903 stream_outputTime.add(outputTime32.getTree());
904 pushFollow(FOLLOW_priority_in_outputMessage328);
905 priority33=priority();
906
907 state._fsp--;
908
909 stream_priority.add(priority33.getTree());
910
911 }
912
913
914
915
916
917
918
919
920
921
922 retval.tree = root_0;
923 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
924
925 root_0 = (Object)adaptor.nil();
926
927 {
928
929 {
930 Object root_1 = (Object)adaptor.nil();
931 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(OUTPUT_MESSAGE, "OUTPUT_MESSAGE"), root_1);
932
933 adaptor.addChild(root_1, stream_type.nextTree());
934 adaptor.addChild(root_1, stream_inputTime.nextTree());
935 adaptor.addChild(root_1, stream_messageInputReference.nextTree());
936 adaptor.addChild(root_1, stream_outputDate.nextTree());
937 adaptor.addChild(root_1, stream_outputTime.nextTree());
938 adaptor.addChild(root_1, stream_priority.nextTree());
939
940 adaptor.addChild(root_0, root_1);
941 }
942
943 }
944
945 retval.tree = root_0;
946 }
947
948 retval.stop = input.LT(-1);
949
950 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
951 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
952
953 }
954
955 catch (RecognitionException re) {
956 throw re;
957 }
958 finally {
959 }
960 return retval;
961 }
962
963
964 public static class userHeaderBlock_return extends ParserRuleReturnScope {
965 Object tree;
966 public Object getTree() { return tree; }
967 };
968
969
970
971 public final SwiftParser.userHeaderBlock_return userHeaderBlock() throws RecognitionException {
972 SwiftParser.userHeaderBlock_return retval = new SwiftParser.userHeaderBlock_return();
973 retval.start = input.LT(1);
974
975 Object root_0 = null;
976
977 Token START_USER_HEADER_BLOCK34=null;
978 Token START_BANKING_PRIORITY_CODE35=null;
979 Token END_ALL_BLOCK37=null;
980 Token START_MESSAGE_USER_REFERENCE38=null;
981 Token END_ALL_BLOCK40=null;
982 Token END_ALL_BLOCK41=null;
983 SwiftParser.bankPriorityCode_return bankPriorityCode36 = null;
984
985 SwiftParser.messageUserReference_return messageUserReference39 = null;
986
987
988 Object START_USER_HEADER_BLOCK34_tree=null;
989 Object START_BANKING_PRIORITY_CODE35_tree=null;
990 Object END_ALL_BLOCK37_tree=null;
991 Object START_MESSAGE_USER_REFERENCE38_tree=null;
992 Object END_ALL_BLOCK40_tree=null;
993 Object END_ALL_BLOCK41_tree=null;
994 RewriteRuleTokenStream stream_START_MESSAGE_USER_REFERENCE=new RewriteRuleTokenStream(adaptor,"token START_MESSAGE_USER_REFERENCE");
995 RewriteRuleTokenStream stream_END_ALL_BLOCK=new RewriteRuleTokenStream(adaptor,"token END_ALL_BLOCK");
996 RewriteRuleTokenStream stream_START_USER_HEADER_BLOCK=new RewriteRuleTokenStream(adaptor,"token START_USER_HEADER_BLOCK");
997 RewriteRuleTokenStream stream_START_BANKING_PRIORITY_CODE=new RewriteRuleTokenStream(adaptor,"token START_BANKING_PRIORITY_CODE");
998 RewriteRuleSubtreeStream stream_bankPriorityCode=new RewriteRuleSubtreeStream(adaptor,"rule bankPriorityCode");
999 RewriteRuleSubtreeStream stream_messageUserReference=new RewriteRuleSubtreeStream(adaptor,"rule messageUserReference");
1000 try {
1001
1002
1003 {
1004
1005
1006 {
1007 START_USER_HEADER_BLOCK34=(Token)match(input,START_USER_HEADER_BLOCK,FOLLOW_START_USER_HEADER_BLOCK_in_userHeaderBlock362);
1008 stream_START_USER_HEADER_BLOCK.add(START_USER_HEADER_BLOCK34);
1009
1010
1011 int alt4=2;
1012 int LA4_0 = input.LA(1);
1013
1014 if ( (LA4_0==START_BANKING_PRIORITY_CODE) ) {
1015 alt4=1;
1016 }
1017 switch (alt4) {
1018 case 1 :
1019
1020 {
1021 START_BANKING_PRIORITY_CODE35=(Token)match(input,START_BANKING_PRIORITY_CODE,FOLLOW_START_BANKING_PRIORITY_CODE_in_userHeaderBlock372);
1022 stream_START_BANKING_PRIORITY_CODE.add(START_BANKING_PRIORITY_CODE35);
1023
1024 pushFollow(FOLLOW_bankPriorityCode_in_userHeaderBlock374);
1025 bankPriorityCode36=bankPriorityCode();
1026
1027 state._fsp--;
1028
1029 stream_bankPriorityCode.add(bankPriorityCode36.getTree());
1030 END_ALL_BLOCK37=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_userHeaderBlock376);
1031 stream_END_ALL_BLOCK.add(END_ALL_BLOCK37);
1032
1033
1034 }
1035 break;
1036
1037 }
1038
1039 START_MESSAGE_USER_REFERENCE38=(Token)match(input,START_MESSAGE_USER_REFERENCE,FOLLOW_START_MESSAGE_USER_REFERENCE_in_userHeaderBlock387);
1040 stream_START_MESSAGE_USER_REFERENCE.add(START_MESSAGE_USER_REFERENCE38);
1041
1042 pushFollow(FOLLOW_messageUserReference_in_userHeaderBlock389);
1043 messageUserReference39=messageUserReference();
1044
1045 state._fsp--;
1046
1047 stream_messageUserReference.add(messageUserReference39.getTree());
1048 END_ALL_BLOCK40=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_userHeaderBlock391);
1049 stream_END_ALL_BLOCK.add(END_ALL_BLOCK40);
1050
1051 END_ALL_BLOCK41=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_userHeaderBlock396);
1052 stream_END_ALL_BLOCK.add(END_ALL_BLOCK41);
1053
1054
1055 }
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066 retval.tree = root_0;
1067 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1068
1069 root_0 = (Object)adaptor.nil();
1070
1071 {
1072
1073 {
1074 Object root_1 = (Object)adaptor.nil();
1075 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(START_BLOCK, "START_BLOCK"), root_1);
1076
1077
1078 if ( stream_bankPriorityCode.hasNext() ) {
1079 adaptor.addChild(root_1, stream_bankPriorityCode.nextTree());
1080
1081 }
1082 stream_bankPriorityCode.reset();
1083 adaptor.addChild(root_1, stream_messageUserReference.nextTree());
1084
1085 adaptor.addChild(root_0, root_1);
1086 }
1087
1088 }
1089
1090 retval.tree = root_0;
1091 }
1092
1093 retval.stop = input.LT(-1);
1094
1095 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1096 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1097
1098 }
1099
1100 catch (RecognitionException re) {
1101 throw re;
1102 }
1103 finally {
1104 }
1105 return retval;
1106 }
1107
1108
1109 public static class textBlock_return extends ParserRuleReturnScope {
1110 Object tree;
1111 public Object getTree() { return tree; }
1112 };
1113
1114
1115
1116 public final SwiftParser.textBlock_return textBlock() throws RecognitionException {
1117 SwiftParser.textBlock_return retval = new SwiftParser.textBlock_return();
1118 retval.start = input.LT(1);
1119
1120 Object root_0 = null;
1121
1122 Token START_TEXT_BLOCK42=null;
1123 Token CRLF43=null;
1124 Token END_TEXT_BLOCK45=null;
1125 SwiftParser.textBlockMessage_return textBlockMessage44 = null;
1126
1127
1128 Object START_TEXT_BLOCK42_tree=null;
1129 Object CRLF43_tree=null;
1130 Object END_TEXT_BLOCK45_tree=null;
1131 RewriteRuleTokenStream stream_START_TEXT_BLOCK=new RewriteRuleTokenStream(adaptor,"token START_TEXT_BLOCK");
1132 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
1133 RewriteRuleTokenStream stream_END_TEXT_BLOCK=new RewriteRuleTokenStream(adaptor,"token END_TEXT_BLOCK");
1134 RewriteRuleSubtreeStream stream_textBlockMessage=new RewriteRuleSubtreeStream(adaptor,"rule textBlockMessage");
1135 try {
1136
1137
1138 {
1139
1140
1141 {
1142 START_TEXT_BLOCK42=(Token)match(input,START_TEXT_BLOCK,FOLLOW_START_TEXT_BLOCK_in_textBlock423);
1143 stream_START_TEXT_BLOCK.add(START_TEXT_BLOCK42);
1144
1145 CRLF43=(Token)match(input,CRLF,FOLLOW_CRLF_in_textBlock425);
1146 stream_CRLF.add(CRLF43);
1147
1148 pushFollow(FOLLOW_textBlockMessage_in_textBlock427);
1149 textBlockMessage44=textBlockMessage();
1150
1151 state._fsp--;
1152
1153 stream_textBlockMessage.add(textBlockMessage44.getTree());
1154 END_TEXT_BLOCK45=(Token)match(input,END_TEXT_BLOCK,FOLLOW_END_TEXT_BLOCK_in_textBlock429);
1155 stream_END_TEXT_BLOCK.add(END_TEXT_BLOCK45);
1156
1157
1158 }
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169 retval.tree = root_0;
1170 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1171
1172 root_0 = (Object)adaptor.nil();
1173
1174 {
1175
1176 {
1177 Object root_1 = (Object)adaptor.nil();
1178 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(START_BLOCK, "START_BLOCK"), root_1);
1179
1180 adaptor.addChild(root_1, stream_textBlockMessage.nextTree());
1181
1182 adaptor.addChild(root_0, root_1);
1183 }
1184
1185 }
1186
1187 retval.tree = root_0;
1188 }
1189
1190 retval.stop = input.LT(-1);
1191
1192 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1193 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1194
1195 }
1196
1197 catch (RecognitionException re) {
1198 throw re;
1199 }
1200 finally {
1201 }
1202 return retval;
1203 }
1204
1205
1206 public static class textBlockMessage_return extends ParserRuleReturnScope {
1207 Object tree;
1208 public Object getTree() { return tree; }
1209 };
1210
1211
1212
1213 public final SwiftParser.textBlockMessage_return textBlockMessage() throws RecognitionException {
1214 SwiftParser.textBlockMessage_return retval = new SwiftParser.textBlockMessage_return();
1215 retval.start = input.LT(1);
1216
1217 Object root_0 = null;
1218
1219 SwiftParser.message1xx_return message1xx46 = null;
1220
1221 SwiftParser.message2xx_return message2xx47 = null;
1222
1223
1224
1225 try {
1226
1227
1228 {
1229 root_0 = (Object)adaptor.nil();
1230
1231
1232 int alt5=2;
1233 int LA5_0 = input.LA(1);
1234
1235 if ( (LA5_0==TAG_20) ) {
1236 alt5=1;
1237 }
1238 else if ( (LA5_0==END_TEXT_BLOCK||LA5_0==UPPERCASE_LETTER) ) {
1239 alt5=2;
1240 }
1241 else {
1242 NoViableAltException nvae =
1243 new NoViableAltException("", 5, 0, input);
1244
1245 throw nvae;
1246 }
1247 switch (alt5) {
1248 case 1 :
1249
1250 {
1251 pushFollow(FOLLOW_message1xx_in_textBlockMessage452);
1252 message1xx46=message1xx();
1253
1254 state._fsp--;
1255
1256 adaptor.addChild(root_0, message1xx46.getTree());
1257
1258 }
1259 break;
1260 case 2 :
1261
1262 {
1263 pushFollow(FOLLOW_message2xx_in_textBlockMessage456);
1264 message2xx47=message2xx();
1265
1266 state._fsp--;
1267
1268 adaptor.addChild(root_0, message2xx47.getTree());
1269
1270 }
1271 break;
1272
1273 }
1274
1275
1276 }
1277
1278 retval.stop = input.LT(-1);
1279
1280 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1281 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1282
1283 }
1284
1285 catch (RecognitionException re) {
1286 throw re;
1287 }
1288 finally {
1289 }
1290 return retval;
1291 }
1292
1293
1294 public static class trailerBlock_return extends ParserRuleReturnScope {
1295 Object tree;
1296 public Object getTree() { return tree; }
1297 };
1298
1299
1300
1301 public final SwiftParser.trailerBlock_return trailerBlock() throws RecognitionException {
1302 SwiftParser.trailerBlock_return retval = new SwiftParser.trailerBlock_return();
1303 retval.start = input.LT(1);
1304
1305 Object root_0 = null;
1306
1307 Token START_TRAILER_BLOCK48=null;
1308 Token START_MAC_TRAILER49=null;
1309 Token END_ALL_BLOCK51=null;
1310 Token START_CHK_TRAILER52=null;
1311 Token END_ALL_BLOCK54=null;
1312 Token START_PDE_TRAILER55=null;
1313 Token END_ALL_BLOCK57=null;
1314 Token START_DLM_TRAILER58=null;
1315 Token END_ALL_BLOCK60=null;
1316 Token END_ALL_BLOCK61=null;
1317 SwiftParser.messageAuthenticationCode_return messageAuthenticationCode50 = null;
1318
1319 SwiftParser.checksum_return checksum53 = null;
1320
1321 SwiftParser.possibleDuplicateEmission_return possibleDuplicateEmission56 = null;
1322
1323 SwiftParser.delayedMessage_return delayedMessage59 = null;
1324
1325
1326 Object START_TRAILER_BLOCK48_tree=null;
1327 Object START_MAC_TRAILER49_tree=null;
1328 Object END_ALL_BLOCK51_tree=null;
1329 Object START_CHK_TRAILER52_tree=null;
1330 Object END_ALL_BLOCK54_tree=null;
1331 Object START_PDE_TRAILER55_tree=null;
1332 Object END_ALL_BLOCK57_tree=null;
1333 Object START_DLM_TRAILER58_tree=null;
1334 Object END_ALL_BLOCK60_tree=null;
1335 Object END_ALL_BLOCK61_tree=null;
1336 RewriteRuleTokenStream stream_START_TRAILER_BLOCK=new RewriteRuleTokenStream(adaptor,"token START_TRAILER_BLOCK");
1337 RewriteRuleTokenStream stream_END_ALL_BLOCK=new RewriteRuleTokenStream(adaptor,"token END_ALL_BLOCK");
1338 RewriteRuleTokenStream stream_START_MAC_TRAILER=new RewriteRuleTokenStream(adaptor,"token START_MAC_TRAILER");
1339 RewriteRuleTokenStream stream_START_PDE_TRAILER=new RewriteRuleTokenStream(adaptor,"token START_PDE_TRAILER");
1340 RewriteRuleTokenStream stream_START_DLM_TRAILER=new RewriteRuleTokenStream(adaptor,"token START_DLM_TRAILER");
1341 RewriteRuleTokenStream stream_START_CHK_TRAILER=new RewriteRuleTokenStream(adaptor,"token START_CHK_TRAILER");
1342 RewriteRuleSubtreeStream stream_messageAuthenticationCode=new RewriteRuleSubtreeStream(adaptor,"rule messageAuthenticationCode");
1343 RewriteRuleSubtreeStream stream_checksum=new RewriteRuleSubtreeStream(adaptor,"rule checksum");
1344 RewriteRuleSubtreeStream stream_delayedMessage=new RewriteRuleSubtreeStream(adaptor,"rule delayedMessage");
1345 RewriteRuleSubtreeStream stream_possibleDuplicateEmission=new RewriteRuleSubtreeStream(adaptor,"rule possibleDuplicateEmission");
1346 try {
1347
1348
1349 {
1350
1351
1352 {
1353 START_TRAILER_BLOCK48=(Token)match(input,START_TRAILER_BLOCK,FOLLOW_START_TRAILER_BLOCK_in_trailerBlock471);
1354 stream_START_TRAILER_BLOCK.add(START_TRAILER_BLOCK48);
1355
1356
1357 int alt6=2;
1358 int LA6_0 = input.LA(1);
1359
1360 if ( (LA6_0==START_MAC_TRAILER) ) {
1361 alt6=1;
1362 }
1363 switch (alt6) {
1364 case 1 :
1365
1366 {
1367 START_MAC_TRAILER49=(Token)match(input,START_MAC_TRAILER,FOLLOW_START_MAC_TRAILER_in_trailerBlock481);
1368 stream_START_MAC_TRAILER.add(START_MAC_TRAILER49);
1369
1370 pushFollow(FOLLOW_messageAuthenticationCode_in_trailerBlock483);
1371 messageAuthenticationCode50=messageAuthenticationCode();
1372
1373 state._fsp--;
1374
1375 stream_messageAuthenticationCode.add(messageAuthenticationCode50.getTree());
1376 END_ALL_BLOCK51=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_trailerBlock485);
1377 stream_END_ALL_BLOCK.add(END_ALL_BLOCK51);
1378
1379
1380 }
1381 break;
1382
1383 }
1384
1385 START_CHK_TRAILER52=(Token)match(input,START_CHK_TRAILER,FOLLOW_START_CHK_TRAILER_in_trailerBlock496);
1386 stream_START_CHK_TRAILER.add(START_CHK_TRAILER52);
1387
1388 pushFollow(FOLLOW_checksum_in_trailerBlock498);
1389 checksum53=checksum();
1390
1391 state._fsp--;
1392
1393 stream_checksum.add(checksum53.getTree());
1394 END_ALL_BLOCK54=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_trailerBlock500);
1395 stream_END_ALL_BLOCK.add(END_ALL_BLOCK54);
1396
1397
1398 int alt7=2;
1399 int LA7_0 = input.LA(1);
1400
1401 if ( (LA7_0==START_PDE_TRAILER) ) {
1402 alt7=1;
1403 }
1404 switch (alt7) {
1405 case 1 :
1406
1407 {
1408 START_PDE_TRAILER55=(Token)match(input,START_PDE_TRAILER,FOLLOW_START_PDE_TRAILER_in_trailerBlock510);
1409 stream_START_PDE_TRAILER.add(START_PDE_TRAILER55);
1410
1411 pushFollow(FOLLOW_possibleDuplicateEmission_in_trailerBlock512);
1412 possibleDuplicateEmission56=possibleDuplicateEmission();
1413
1414 state._fsp--;
1415
1416 stream_possibleDuplicateEmission.add(possibleDuplicateEmission56.getTree());
1417 END_ALL_BLOCK57=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_trailerBlock514);
1418 stream_END_ALL_BLOCK.add(END_ALL_BLOCK57);
1419
1420
1421 }
1422 break;
1423
1424 }
1425
1426
1427 int alt8=2;
1428 int LA8_0 = input.LA(1);
1429
1430 if ( (LA8_0==START_DLM_TRAILER) ) {
1431 alt8=1;
1432 }
1433 switch (alt8) {
1434 case 1 :
1435
1436 {
1437 START_DLM_TRAILER58=(Token)match(input,START_DLM_TRAILER,FOLLOW_START_DLM_TRAILER_in_trailerBlock526);
1438 stream_START_DLM_TRAILER.add(START_DLM_TRAILER58);
1439
1440 pushFollow(FOLLOW_delayedMessage_in_trailerBlock528);
1441 delayedMessage59=delayedMessage();
1442
1443 state._fsp--;
1444
1445 stream_delayedMessage.add(delayedMessage59.getTree());
1446 END_ALL_BLOCK60=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_trailerBlock530);
1447 stream_END_ALL_BLOCK.add(END_ALL_BLOCK60);
1448
1449
1450 }
1451 break;
1452
1453 }
1454
1455 END_ALL_BLOCK61=(Token)match(input,END_ALL_BLOCK,FOLLOW_END_ALL_BLOCK_in_trailerBlock538);
1456 stream_END_ALL_BLOCK.add(END_ALL_BLOCK61);
1457
1458
1459 }
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470 retval.tree = root_0;
1471 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1472
1473 root_0 = (Object)adaptor.nil();
1474
1475 {
1476
1477 {
1478 Object root_1 = (Object)adaptor.nil();
1479 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(START_BLOCK, "START_BLOCK"), root_1);
1480
1481
1482 if ( stream_messageAuthenticationCode.hasNext() ) {
1483 adaptor.addChild(root_1, stream_messageAuthenticationCode.nextTree());
1484
1485 }
1486 stream_messageAuthenticationCode.reset();
1487 adaptor.addChild(root_1, stream_checksum.nextTree());
1488
1489 if ( stream_possibleDuplicateEmission.hasNext() ) {
1490 adaptor.addChild(root_1, stream_possibleDuplicateEmission.nextTree());
1491
1492 }
1493 stream_possibleDuplicateEmission.reset();
1494
1495 if ( stream_delayedMessage.hasNext() ) {
1496 adaptor.addChild(root_1, stream_delayedMessage.nextTree());
1497
1498 }
1499 stream_delayedMessage.reset();
1500
1501 adaptor.addChild(root_0, root_1);
1502 }
1503
1504 }
1505
1506 retval.tree = root_0;
1507 }
1508
1509 retval.stop = input.LT(-1);
1510
1511 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1512 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1513
1514 }
1515
1516 catch (RecognitionException re) {
1517 throw re;
1518 }
1519 finally {
1520 }
1521 return retval;
1522 }
1523
1524
1525 public static class message1xx_return extends ParserRuleReturnScope {
1526 Object tree;
1527 public Object getTree() { return tree; }
1528 };
1529
1530
1531
1532 public final SwiftParser.message1xx_return message1xx() throws RecognitionException {
1533 SwiftParser.message1xx_return retval = new SwiftParser.message1xx_return();
1534 retval.start = input.LT(1);
1535
1536 Object root_0 = null;
1537
1538 SwiftParser.message103_return message10362 = null;
1539
1540
1541
1542 try {
1543
1544
1545 {
1546 root_0 = (Object)adaptor.nil();
1547
1548 pushFollow(FOLLOW_message103_in_message1xx573);
1549 message10362=message103();
1550
1551 state._fsp--;
1552
1553 adaptor.addChild(root_0, message10362.getTree());
1554
1555 }
1556
1557 retval.stop = input.LT(-1);
1558
1559 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1560 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1561
1562 }
1563
1564 catch (RecognitionException re) {
1565 throw re;
1566 }
1567 finally {
1568 }
1569 return retval;
1570 }
1571
1572
1573 public static class message2xx_return extends ParserRuleReturnScope {
1574 Object tree;
1575 public Object getTree() { return tree; }
1576 };
1577
1578
1579
1580 public final SwiftParser.message2xx_return message2xx() throws RecognitionException {
1581 SwiftParser.message2xx_return retval = new SwiftParser.message2xx_return();
1582 retval.start = input.LT(1);
1583
1584 Object root_0 = null;
1585
1586 SwiftParser.message201_return message20163 = null;
1587
1588
1589
1590 try {
1591
1592
1593 {
1594 root_0 = (Object)adaptor.nil();
1595
1596 pushFollow(FOLLOW_message201_in_message2xx584);
1597 message20163=message201();
1598
1599 state._fsp--;
1600
1601 adaptor.addChild(root_0, message20163.getTree());
1602
1603 }
1604
1605 retval.stop = input.LT(-1);
1606
1607 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1608 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1609
1610 }
1611
1612 catch (RecognitionException re) {
1613 throw re;
1614 }
1615 finally {
1616 }
1617 return retval;
1618 }
1619
1620
1621 public static class message103_return extends ParserRuleReturnScope {
1622 Object tree;
1623 public Object getTree() { return tree; }
1624 };
1625
1626
1627
1628 public final SwiftParser.message103_return message103() throws RecognitionException {
1629 SwiftParser.message103_return retval = new SwiftParser.message103_return();
1630 retval.start = input.LT(1);
1631
1632 Object root_0 = null;
1633
1634 SwiftParser.tag20_return tag2064 = null;
1635
1636 SwiftParser.tag13C_return tag13C65 = null;
1637
1638 SwiftParser.tag23B_return tag23B66 = null;
1639
1640 SwiftParser.tag23E_return tag23E67 = null;
1641
1642 SwiftParser.tag26T_return tag26T68 = null;
1643
1644 SwiftParser.tag32A_return tag32A69 = null;
1645
1646 SwiftParser.tag33B_return tag33B70 = null;
1647
1648 SwiftParser.tag36_return tag3671 = null;
1649
1650 SwiftParser.tag50_a_return tag50_a72 = null;
1651
1652
1653
1654 try {
1655
1656
1657 {
1658 root_0 = (Object)adaptor.nil();
1659
1660 pushFollow(FOLLOW_tag20_in_message103596);
1661 tag2064=tag20();
1662
1663 state._fsp--;
1664
1665 adaptor.addChild(root_0, tag2064.getTree());
1666
1667 loop9:
1668 do {
1669 int alt9=2;
1670 int LA9_0 = input.LA(1);
1671
1672 if ( (LA9_0==TAG_13C) ) {
1673 alt9=1;
1674 }
1675
1676
1677 switch (alt9) {
1678 case 1 :
1679
1680 {
1681 pushFollow(FOLLOW_tag13C_in_message103599);
1682 tag13C65=tag13C();
1683
1684 state._fsp--;
1685
1686 adaptor.addChild(root_0, tag13C65.getTree());
1687
1688 }
1689 break;
1690
1691 default :
1692 break loop9;
1693 }
1694 } while (true);
1695
1696 pushFollow(FOLLOW_tag23B_in_message103603);
1697 tag23B66=tag23B();
1698
1699 state._fsp--;
1700
1701 adaptor.addChild(root_0, tag23B66.getTree());
1702
1703 int cnt10=0;
1704 loop10:
1705 do {
1706 int alt10=2;
1707 int LA10_0 = input.LA(1);
1708
1709 if ( (LA10_0==TAG_23E) ) {
1710 alt10=1;
1711 }
1712
1713
1714 switch (alt10) {
1715 case 1 :
1716
1717 {
1718 pushFollow(FOLLOW_tag23E_in_message103606);
1719 tag23E67=tag23E();
1720
1721 state._fsp--;
1722
1723 adaptor.addChild(root_0, tag23E67.getTree());
1724
1725 }
1726 break;
1727
1728 default :
1729 if ( cnt10 >= 1 ) break loop10;
1730 EarlyExitException eee =
1731 new EarlyExitException(10, input);
1732 throw eee;
1733 }
1734 cnt10++;
1735 } while (true);
1736
1737
1738 int alt11=2;
1739 int LA11_0 = input.LA(1);
1740
1741 if ( (LA11_0==TAG_26T) ) {
1742 alt11=1;
1743 }
1744 switch (alt11) {
1745 case 1 :
1746
1747 {
1748 pushFollow(FOLLOW_tag26T_in_message103611);
1749 tag26T68=tag26T();
1750
1751 state._fsp--;
1752
1753 adaptor.addChild(root_0, tag26T68.getTree());
1754
1755 }
1756 break;
1757
1758 }
1759
1760 pushFollow(FOLLOW_tag32A_in_message103615);
1761 tag32A69=tag32A();
1762
1763 state._fsp--;
1764
1765 adaptor.addChild(root_0, tag32A69.getTree());
1766
1767 int alt12=2;
1768 int LA12_0 = input.LA(1);
1769
1770 if ( (LA12_0==TAG_33B) ) {
1771 alt12=1;
1772 }
1773 switch (alt12) {
1774 case 1 :
1775
1776 {
1777 pushFollow(FOLLOW_tag33B_in_message103618);
1778 tag33B70=tag33B();
1779
1780 state._fsp--;
1781
1782 adaptor.addChild(root_0, tag33B70.getTree());
1783
1784 }
1785 break;
1786
1787 }
1788
1789
1790 int alt13=2;
1791 int LA13_0 = input.LA(1);
1792
1793 if ( (LA13_0==TAG_36) ) {
1794 alt13=1;
1795 }
1796 switch (alt13) {
1797 case 1 :
1798
1799 {
1800 pushFollow(FOLLOW_tag36_in_message103623);
1801 tag3671=tag36();
1802
1803 state._fsp--;
1804
1805 adaptor.addChild(root_0, tag3671.getTree());
1806
1807 }
1808 break;
1809
1810 }
1811
1812 pushFollow(FOLLOW_tag50_a_in_message103627);
1813 tag50_a72=tag50_a();
1814
1815 state._fsp--;
1816
1817 adaptor.addChild(root_0, tag50_a72.getTree());
1818
1819 }
1820
1821 retval.stop = input.LT(-1);
1822
1823 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1824 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1825
1826 }
1827
1828 catch (RecognitionException re) {
1829 throw re;
1830 }
1831 finally {
1832 }
1833 return retval;
1834 }
1835
1836
1837 public static class message201_return extends ParserRuleReturnScope {
1838 Object tree;
1839 public Object getTree() { return tree; }
1840 };
1841
1842
1843
1844 public final SwiftParser.message201_return message201() throws RecognitionException {
1845 SwiftParser.message201_return retval = new SwiftParser.message201_return();
1846 retval.start = input.LT(1);
1847
1848 Object root_0 = null;
1849
1850 Token UPPERCASE_LETTER73=null;
1851
1852 Object UPPERCASE_LETTER73_tree=null;
1853
1854 try {
1855
1856
1857 {
1858 root_0 = (Object)adaptor.nil();
1859
1860
1861 loop14:
1862 do {
1863 int alt14=2;
1864 int LA14_0 = input.LA(1);
1865
1866 if ( (LA14_0==UPPERCASE_LETTER) ) {
1867 alt14=1;
1868 }
1869
1870
1871 switch (alt14) {
1872 case 1 :
1873
1874 {
1875 UPPERCASE_LETTER73=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_message201647);
1876 UPPERCASE_LETTER73_tree = (Object)adaptor.create(UPPERCASE_LETTER73);
1877 adaptor.addChild(root_0, UPPERCASE_LETTER73_tree);
1878
1879
1880 }
1881 break;
1882
1883 default :
1884 break loop14;
1885 }
1886 } while (true);
1887
1888
1889 }
1890
1891 retval.stop = input.LT(-1);
1892
1893 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1894 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1895
1896 }
1897
1898 catch (RecognitionException re) {
1899 throw re;
1900 }
1901 finally {
1902 }
1903 return retval;
1904 }
1905
1906
1907 public static class dummyText_return extends ParserRuleReturnScope {
1908 Object tree;
1909 public Object getTree() { return tree; }
1910 };
1911
1912
1913
1914 public final SwiftParser.dummyText_return dummyText() throws RecognitionException {
1915 SwiftParser.dummyText_return retval = new SwiftParser.dummyText_return();
1916 retval.start = input.LT(1);
1917
1918 Object root_0 = null;
1919
1920 Token UPPERCASE_LETTER74=null;
1921
1922 Object UPPERCASE_LETTER74_tree=null;
1923
1924 try {
1925
1926
1927 {
1928 root_0 = (Object)adaptor.nil();
1929
1930
1931 loop15:
1932 do {
1933 int alt15=2;
1934 int LA15_0 = input.LA(1);
1935
1936 if ( (LA15_0==UPPERCASE_LETTER) ) {
1937 alt15=1;
1938 }
1939
1940
1941 switch (alt15) {
1942 case 1 :
1943
1944 {
1945 UPPERCASE_LETTER74=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_dummyText663);
1946 UPPERCASE_LETTER74_tree = (Object)adaptor.create(UPPERCASE_LETTER74);
1947 adaptor.addChild(root_0, UPPERCASE_LETTER74_tree);
1948
1949
1950 }
1951 break;
1952
1953 default :
1954 break loop15;
1955 }
1956 } while (true);
1957
1958
1959 }
1960
1961 retval.stop = input.LT(-1);
1962
1963 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
1964 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1965
1966 }
1967
1968 catch (RecognitionException re) {
1969 throw re;
1970 }
1971 finally {
1972 }
1973 return retval;
1974 }
1975
1976
1977 public static class tag13C_return extends ParserRuleReturnScope {
1978 Object tree;
1979 public Object getTree() { return tree; }
1980 };
1981
1982
1983
1984 public final SwiftParser.tag13C_return tag13C() throws RecognitionException {
1985 SwiftParser.tag13C_return retval = new SwiftParser.tag13C_return();
1986 retval.start = input.LT(1);
1987
1988 Object root_0 = null;
1989
1990 Token TAG_13C75=null;
1991 Token CODE_SEPARATOR76=null;
1992 Token CODE_SEPARATOR78=null;
1993 Token CRLF82=null;
1994 SwiftParser.code_return code77 = null;
1995
1996 SwiftParser.timeIndication_return timeIndication79 = null;
1997
1998 SwiftParser.sign_return sign80 = null;
1999
2000 SwiftParser.timeOffset_return timeOffset81 = null;
2001
2002
2003 Object TAG_13C75_tree=null;
2004 Object CODE_SEPARATOR76_tree=null;
2005 Object CODE_SEPARATOR78_tree=null;
2006 Object CRLF82_tree=null;
2007 RewriteRuleTokenStream stream_CODE_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token CODE_SEPARATOR");
2008 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2009 RewriteRuleTokenStream stream_TAG_13C=new RewriteRuleTokenStream(adaptor,"token TAG_13C");
2010 RewriteRuleSubtreeStream stream_sign=new RewriteRuleSubtreeStream(adaptor,"rule sign");
2011 RewriteRuleSubtreeStream stream_timeOffset=new RewriteRuleSubtreeStream(adaptor,"rule timeOffset");
2012 RewriteRuleSubtreeStream stream_timeIndication=new RewriteRuleSubtreeStream(adaptor,"rule timeIndication");
2013 RewriteRuleSubtreeStream stream_code=new RewriteRuleSubtreeStream(adaptor,"rule code");
2014 try {
2015
2016
2017 {
2018 TAG_13C75=(Token)match(input,TAG_13C,FOLLOW_TAG_13C_in_tag13C678);
2019 stream_TAG_13C.add(TAG_13C75);
2020
2021 CODE_SEPARATOR76=(Token)match(input,CODE_SEPARATOR,FOLLOW_CODE_SEPARATOR_in_tag13C680);
2022 stream_CODE_SEPARATOR.add(CODE_SEPARATOR76);
2023
2024 pushFollow(FOLLOW_code_in_tag13C682);
2025 code77=code();
2026
2027 state._fsp--;
2028
2029 stream_code.add(code77.getTree());
2030 CODE_SEPARATOR78=(Token)match(input,CODE_SEPARATOR,FOLLOW_CODE_SEPARATOR_in_tag13C684);
2031 stream_CODE_SEPARATOR.add(CODE_SEPARATOR78);
2032
2033 pushFollow(FOLLOW_timeIndication_in_tag13C686);
2034 timeIndication79=timeIndication();
2035
2036 state._fsp--;
2037
2038 stream_timeIndication.add(timeIndication79.getTree());
2039 pushFollow(FOLLOW_sign_in_tag13C688);
2040 sign80=sign();
2041
2042 state._fsp--;
2043
2044 stream_sign.add(sign80.getTree());
2045 pushFollow(FOLLOW_timeOffset_in_tag13C690);
2046 timeOffset81=timeOffset();
2047
2048 state._fsp--;
2049
2050 stream_timeOffset.add(timeOffset81.getTree());
2051 CRLF82=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag13C692);
2052 stream_CRLF.add(CRLF82);
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063 retval.tree = root_0;
2064 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2065
2066 root_0 = (Object)adaptor.nil();
2067
2068 {
2069
2070 {
2071 Object root_1 = (Object)adaptor.nil();
2072 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2073
2074 adaptor.addChild(root_1, stream_code.nextTree());
2075 adaptor.addChild(root_1, stream_timeIndication.nextTree());
2076 adaptor.addChild(root_1, stream_sign.nextTree());
2077 adaptor.addChild(root_1, stream_timeOffset.nextTree());
2078
2079 adaptor.addChild(root_0, root_1);
2080 }
2081
2082 }
2083
2084 retval.tree = root_0;
2085 }
2086
2087 retval.stop = input.LT(-1);
2088
2089 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2090 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2091
2092 }
2093
2094 catch (RecognitionException re) {
2095 throw re;
2096 }
2097 finally {
2098 }
2099 return retval;
2100 }
2101
2102
2103 public static class tag20_return extends ParserRuleReturnScope {
2104 Object tree;
2105 public Object getTree() { return tree; }
2106 };
2107
2108
2109
2110 public final SwiftParser.tag20_return tag20() throws RecognitionException {
2111 SwiftParser.tag20_return retval = new SwiftParser.tag20_return();
2112 retval.start = input.LT(1);
2113
2114 Object root_0 = null;
2115
2116 Token TAG_2083=null;
2117 Token CRLF85=null;
2118 SwiftParser.senderReference_return senderReference84 = null;
2119
2120
2121 Object TAG_2083_tree=null;
2122 Object CRLF85_tree=null;
2123 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2124 RewriteRuleTokenStream stream_TAG_20=new RewriteRuleTokenStream(adaptor,"token TAG_20");
2125 RewriteRuleSubtreeStream stream_senderReference=new RewriteRuleSubtreeStream(adaptor,"rule senderReference");
2126 try {
2127
2128
2129 {
2130 TAG_2083=(Token)match(input,TAG_20,FOLLOW_TAG_20_in_tag20716);
2131 stream_TAG_20.add(TAG_2083);
2132
2133 pushFollow(FOLLOW_senderReference_in_tag20718);
2134 senderReference84=senderReference();
2135
2136 state._fsp--;
2137
2138 stream_senderReference.add(senderReference84.getTree());
2139 CRLF85=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag20720);
2140 stream_CRLF.add(CRLF85);
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151 retval.tree = root_0;
2152 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2153
2154 root_0 = (Object)adaptor.nil();
2155
2156 {
2157
2158 {
2159 Object root_1 = (Object)adaptor.nil();
2160 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2161
2162 adaptor.addChild(root_1, stream_senderReference.nextTree());
2163
2164 adaptor.addChild(root_0, root_1);
2165 }
2166
2167 }
2168
2169 retval.tree = root_0;
2170 }
2171
2172 retval.stop = input.LT(-1);
2173
2174 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2175 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2176
2177 }
2178
2179 catch (RecognitionException re) {
2180 throw re;
2181 }
2182 finally {
2183 }
2184 return retval;
2185 }
2186
2187
2188 public static class tag23B_return extends ParserRuleReturnScope {
2189 Object tree;
2190 public Object getTree() { return tree; }
2191 };
2192
2193
2194
2195 public final SwiftParser.tag23B_return tag23B() throws RecognitionException {
2196 SwiftParser.tag23B_return retval = new SwiftParser.tag23B_return();
2197 retval.start = input.LT(1);
2198
2199 Object root_0 = null;
2200
2201 Token TAG_23B86=null;
2202 Token CRLF88=null;
2203 SwiftParser.bankOperationCode_return bankOperationCode87 = null;
2204
2205
2206 Object TAG_23B86_tree=null;
2207 Object CRLF88_tree=null;
2208 RewriteRuleTokenStream stream_TAG_23B=new RewriteRuleTokenStream(adaptor,"token TAG_23B");
2209 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2210 RewriteRuleSubtreeStream stream_bankOperationCode=new RewriteRuleSubtreeStream(adaptor,"rule bankOperationCode");
2211 try {
2212
2213
2214 {
2215 TAG_23B86=(Token)match(input,TAG_23B,FOLLOW_TAG_23B_in_tag23B738);
2216 stream_TAG_23B.add(TAG_23B86);
2217
2218 pushFollow(FOLLOW_bankOperationCode_in_tag23B740);
2219 bankOperationCode87=bankOperationCode();
2220
2221 state._fsp--;
2222
2223 stream_bankOperationCode.add(bankOperationCode87.getTree());
2224 CRLF88=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag23B742);
2225 stream_CRLF.add(CRLF88);
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236 retval.tree = root_0;
2237 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2238
2239 root_0 = (Object)adaptor.nil();
2240
2241 {
2242
2243 {
2244 Object root_1 = (Object)adaptor.nil();
2245 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2246
2247 adaptor.addChild(root_1, stream_bankOperationCode.nextTree());
2248
2249 adaptor.addChild(root_0, root_1);
2250 }
2251
2252 }
2253
2254 retval.tree = root_0;
2255 }
2256
2257 retval.stop = input.LT(-1);
2258
2259 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2260 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2261
2262 }
2263
2264 catch (RecognitionException re) {
2265 throw re;
2266 }
2267 finally {
2268 }
2269 return retval;
2270 }
2271
2272
2273 public static class tag23E_return extends ParserRuleReturnScope {
2274 Object tree;
2275 public Object getTree() { return tree; }
2276 };
2277
2278
2279
2280 public final SwiftParser.tag23E_return tag23E() throws RecognitionException {
2281 SwiftParser.tag23E_return retval = new SwiftParser.tag23E_return();
2282 retval.start = input.LT(1);
2283
2284 Object root_0 = null;
2285
2286 Token TAG_23E89=null;
2287 Token CODE_SEPARATOR91=null;
2288 Token CRLF93=null;
2289 SwiftParser.instruction_return instruction90 = null;
2290
2291 SwiftParser.additionalInformation_return additionalInformation92 = null;
2292
2293
2294 Object TAG_23E89_tree=null;
2295 Object CODE_SEPARATOR91_tree=null;
2296 Object CRLF93_tree=null;
2297 RewriteRuleTokenStream stream_TAG_23E=new RewriteRuleTokenStream(adaptor,"token TAG_23E");
2298 RewriteRuleTokenStream stream_CODE_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token CODE_SEPARATOR");
2299 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2300 RewriteRuleSubtreeStream stream_instruction=new RewriteRuleSubtreeStream(adaptor,"rule instruction");
2301 RewriteRuleSubtreeStream stream_additionalInformation=new RewriteRuleSubtreeStream(adaptor,"rule additionalInformation");
2302 try {
2303
2304
2305 {
2306 TAG_23E89=(Token)match(input,TAG_23E,FOLLOW_TAG_23E_in_tag23E761);
2307 stream_TAG_23E.add(TAG_23E89);
2308
2309 pushFollow(FOLLOW_instruction_in_tag23E763);
2310 instruction90=instruction();
2311
2312 state._fsp--;
2313
2314 stream_instruction.add(instruction90.getTree());
2315
2316 int alt16=2;
2317 int LA16_0 = input.LA(1);
2318
2319 if ( (LA16_0==CODE_SEPARATOR) ) {
2320 alt16=1;
2321 }
2322 switch (alt16) {
2323 case 1 :
2324
2325 {
2326 CODE_SEPARATOR91=(Token)match(input,CODE_SEPARATOR,FOLLOW_CODE_SEPARATOR_in_tag23E766);
2327 stream_CODE_SEPARATOR.add(CODE_SEPARATOR91);
2328
2329 pushFollow(FOLLOW_additionalInformation_in_tag23E768);
2330 additionalInformation92=additionalInformation();
2331
2332 state._fsp--;
2333
2334 stream_additionalInformation.add(additionalInformation92.getTree());
2335
2336 }
2337 break;
2338
2339 }
2340
2341 CRLF93=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag23E772);
2342 stream_CRLF.add(CRLF93);
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353 retval.tree = root_0;
2354 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2355
2356 root_0 = (Object)adaptor.nil();
2357
2358 {
2359
2360 {
2361 Object root_1 = (Object)adaptor.nil();
2362 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2363
2364 adaptor.addChild(root_1, stream_instruction.nextTree());
2365 adaptor.addChild(root_1, stream_additionalInformation.nextTree());
2366
2367 adaptor.addChild(root_0, root_1);
2368 }
2369
2370 }
2371
2372 retval.tree = root_0;
2373 }
2374
2375 retval.stop = input.LT(-1);
2376
2377 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2378 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2379
2380 }
2381
2382 catch (RecognitionException re) {
2383 throw re;
2384 }
2385 finally {
2386 }
2387 return retval;
2388 }
2389
2390
2391 public static class tag26T_return extends ParserRuleReturnScope {
2392 Object tree;
2393 public Object getTree() { return tree; }
2394 };
2395
2396
2397
2398 public final SwiftParser.tag26T_return tag26T() throws RecognitionException {
2399 SwiftParser.tag26T_return retval = new SwiftParser.tag26T_return();
2400 retval.start = input.LT(1);
2401
2402 Object root_0 = null;
2403
2404 Token TAG_26T94=null;
2405 Token CRLF96=null;
2406 SwiftParser.transactionTypeCode_return transactionTypeCode95 = null;
2407
2408
2409 Object TAG_26T94_tree=null;
2410 Object CRLF96_tree=null;
2411 RewriteRuleTokenStream stream_TAG_26T=new RewriteRuleTokenStream(adaptor,"token TAG_26T");
2412 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2413 RewriteRuleSubtreeStream stream_transactionTypeCode=new RewriteRuleSubtreeStream(adaptor,"rule transactionTypeCode");
2414 try {
2415
2416
2417 {
2418 TAG_26T94=(Token)match(input,TAG_26T,FOLLOW_TAG_26T_in_tag26T792);
2419 stream_TAG_26T.add(TAG_26T94);
2420
2421 pushFollow(FOLLOW_transactionTypeCode_in_tag26T794);
2422 transactionTypeCode95=transactionTypeCode();
2423
2424 state._fsp--;
2425
2426 stream_transactionTypeCode.add(transactionTypeCode95.getTree());
2427 CRLF96=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag26T796);
2428 stream_CRLF.add(CRLF96);
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439 retval.tree = root_0;
2440 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2441
2442 root_0 = (Object)adaptor.nil();
2443
2444 {
2445
2446 {
2447 Object root_1 = (Object)adaptor.nil();
2448 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2449
2450 adaptor.addChild(root_1, stream_transactionTypeCode.nextTree());
2451
2452 adaptor.addChild(root_0, root_1);
2453 }
2454
2455 }
2456
2457 retval.tree = root_0;
2458 }
2459
2460 retval.stop = input.LT(-1);
2461
2462 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2463 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2464
2465 }
2466
2467 catch (RecognitionException re) {
2468 throw re;
2469 }
2470 finally {
2471 }
2472 return retval;
2473 }
2474
2475
2476 public static class tag32A_return extends ParserRuleReturnScope {
2477 Object tree;
2478 public Object getTree() { return tree; }
2479 };
2480
2481
2482
2483 public final SwiftParser.tag32A_return tag32A() throws RecognitionException {
2484 SwiftParser.tag32A_return retval = new SwiftParser.tag32A_return();
2485 retval.start = input.LT(1);
2486
2487 Object root_0 = null;
2488
2489 Token TAG_32A97=null;
2490 Token CRLF101=null;
2491 SwiftParser.valueDate_return valueDate98 = null;
2492
2493 SwiftParser.currency_return currency99 = null;
2494
2495 SwiftParser.amount_return amount100 = null;
2496
2497
2498 Object TAG_32A97_tree=null;
2499 Object CRLF101_tree=null;
2500 RewriteRuleTokenStream stream_TAG_32A=new RewriteRuleTokenStream(adaptor,"token TAG_32A");
2501 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2502 RewriteRuleSubtreeStream stream_amount=new RewriteRuleSubtreeStream(adaptor,"rule amount");
2503 RewriteRuleSubtreeStream stream_valueDate=new RewriteRuleSubtreeStream(adaptor,"rule valueDate");
2504 RewriteRuleSubtreeStream stream_currency=new RewriteRuleSubtreeStream(adaptor,"rule currency");
2505 try {
2506
2507
2508 {
2509 TAG_32A97=(Token)match(input,TAG_32A,FOLLOW_TAG_32A_in_tag32A815);
2510 stream_TAG_32A.add(TAG_32A97);
2511
2512 pushFollow(FOLLOW_valueDate_in_tag32A817);
2513 valueDate98=valueDate();
2514
2515 state._fsp--;
2516
2517 stream_valueDate.add(valueDate98.getTree());
2518 pushFollow(FOLLOW_currency_in_tag32A819);
2519 currency99=currency();
2520
2521 state._fsp--;
2522
2523 stream_currency.add(currency99.getTree());
2524 pushFollow(FOLLOW_amount_in_tag32A821);
2525 amount100=amount();
2526
2527 state._fsp--;
2528
2529 stream_amount.add(amount100.getTree());
2530 CRLF101=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag32A823);
2531 stream_CRLF.add(CRLF101);
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542 retval.tree = root_0;
2543 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2544
2545 root_0 = (Object)adaptor.nil();
2546
2547 {
2548
2549 {
2550 Object root_1 = (Object)adaptor.nil();
2551 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2552
2553 adaptor.addChild(root_1, stream_valueDate.nextTree());
2554 adaptor.addChild(root_1, stream_currency.nextTree());
2555 adaptor.addChild(root_1, stream_amount.nextTree());
2556
2557 adaptor.addChild(root_0, root_1);
2558 }
2559
2560 }
2561
2562 retval.tree = root_0;
2563 }
2564
2565 retval.stop = input.LT(-1);
2566
2567 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2568 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2569
2570 }
2571
2572 catch (RecognitionException re) {
2573 throw re;
2574 }
2575 finally {
2576 }
2577 return retval;
2578 }
2579
2580
2581 public static class tag33B_return extends ParserRuleReturnScope {
2582 Object tree;
2583 public Object getTree() { return tree; }
2584 };
2585
2586
2587
2588 public final SwiftParser.tag33B_return tag33B() throws RecognitionException {
2589 SwiftParser.tag33B_return retval = new SwiftParser.tag33B_return();
2590 retval.start = input.LT(1);
2591
2592 Object root_0 = null;
2593
2594 Token TAG_33B102=null;
2595 Token CRLF105=null;
2596 SwiftParser.currency_return currency103 = null;
2597
2598 SwiftParser.amount_return amount104 = null;
2599
2600
2601 Object TAG_33B102_tree=null;
2602 Object CRLF105_tree=null;
2603 RewriteRuleTokenStream stream_TAG_33B=new RewriteRuleTokenStream(adaptor,"token TAG_33B");
2604 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2605 RewriteRuleSubtreeStream stream_amount=new RewriteRuleSubtreeStream(adaptor,"rule amount");
2606 RewriteRuleSubtreeStream stream_currency=new RewriteRuleSubtreeStream(adaptor,"rule currency");
2607 try {
2608
2609
2610 {
2611 TAG_33B102=(Token)match(input,TAG_33B,FOLLOW_TAG_33B_in_tag33B846);
2612 stream_TAG_33B.add(TAG_33B102);
2613
2614 pushFollow(FOLLOW_currency_in_tag33B848);
2615 currency103=currency();
2616
2617 state._fsp--;
2618
2619 stream_currency.add(currency103.getTree());
2620 pushFollow(FOLLOW_amount_in_tag33B850);
2621 amount104=amount();
2622
2623 state._fsp--;
2624
2625 stream_amount.add(amount104.getTree());
2626 CRLF105=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag33B852);
2627 stream_CRLF.add(CRLF105);
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638 retval.tree = root_0;
2639 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2640
2641 root_0 = (Object)adaptor.nil();
2642
2643 {
2644
2645 {
2646 Object root_1 = (Object)adaptor.nil();
2647 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2648
2649 adaptor.addChild(root_1, stream_currency.nextTree());
2650 adaptor.addChild(root_1, stream_amount.nextTree());
2651
2652 adaptor.addChild(root_0, root_1);
2653 }
2654
2655 }
2656
2657 retval.tree = root_0;
2658 }
2659
2660 retval.stop = input.LT(-1);
2661
2662 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2663 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2664
2665 }
2666
2667 catch (RecognitionException re) {
2668 throw re;
2669 }
2670 finally {
2671 }
2672 return retval;
2673 }
2674
2675
2676 public static class tag36_return extends ParserRuleReturnScope {
2677 Object tree;
2678 public Object getTree() { return tree; }
2679 };
2680
2681
2682
2683 public final SwiftParser.tag36_return tag36() throws RecognitionException {
2684 SwiftParser.tag36_return retval = new SwiftParser.tag36_return();
2685 retval.start = input.LT(1);
2686
2687 Object root_0 = null;
2688
2689 Token TAG_36106=null;
2690 Token CRLF108=null;
2691 SwiftParser.exchangeRate_return exchangeRate107 = null;
2692
2693
2694 Object TAG_36106_tree=null;
2695 Object CRLF108_tree=null;
2696 RewriteRuleTokenStream stream_TAG_36=new RewriteRuleTokenStream(adaptor,"token TAG_36");
2697 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2698 RewriteRuleSubtreeStream stream_exchangeRate=new RewriteRuleSubtreeStream(adaptor,"rule exchangeRate");
2699 try {
2700
2701
2702 {
2703 TAG_36106=(Token)match(input,TAG_36,FOLLOW_TAG_36_in_tag36874);
2704 stream_TAG_36.add(TAG_36106);
2705
2706 pushFollow(FOLLOW_exchangeRate_in_tag36876);
2707 exchangeRate107=exchangeRate();
2708
2709 state._fsp--;
2710
2711 stream_exchangeRate.add(exchangeRate107.getTree());
2712 CRLF108=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag36878);
2713 stream_CRLF.add(CRLF108);
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724 retval.tree = root_0;
2725 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2726
2727 root_0 = (Object)adaptor.nil();
2728
2729 {
2730
2731 {
2732 Object root_1 = (Object)adaptor.nil();
2733 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2734
2735 adaptor.addChild(root_1, stream_exchangeRate.nextTree());
2736
2737 adaptor.addChild(root_0, root_1);
2738 }
2739
2740 }
2741
2742 retval.tree = root_0;
2743 }
2744
2745 retval.stop = input.LT(-1);
2746
2747 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2748 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2749
2750 }
2751
2752 catch (RecognitionException re) {
2753 throw re;
2754 }
2755 finally {
2756 }
2757 return retval;
2758 }
2759
2760
2761 public static class tag50A_return extends ParserRuleReturnScope {
2762 Object tree;
2763 public Object getTree() { return tree; }
2764 };
2765
2766
2767
2768 public final SwiftParser.tag50A_return tag50A() throws RecognitionException {
2769 SwiftParser.tag50A_return retval = new SwiftParser.tag50A_return();
2770 retval.start = input.LT(1);
2771
2772 Object root_0 = null;
2773
2774 Token TAG_50A109=null;
2775 Token CODE_SEPARATOR110=null;
2776 Token CRLF112=null;
2777 Token CRLF114=null;
2778 SwiftParser.account_return account111 = null;
2779
2780 SwiftParser.bicBai_return bicBai113 = null;
2781
2782
2783 Object TAG_50A109_tree=null;
2784 Object CODE_SEPARATOR110_tree=null;
2785 Object CRLF112_tree=null;
2786 Object CRLF114_tree=null;
2787 RewriteRuleTokenStream stream_TAG_50A=new RewriteRuleTokenStream(adaptor,"token TAG_50A");
2788 RewriteRuleTokenStream stream_CODE_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token CODE_SEPARATOR");
2789 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2790 RewriteRuleSubtreeStream stream_bicBai=new RewriteRuleSubtreeStream(adaptor,"rule bicBai");
2791 RewriteRuleSubtreeStream stream_account=new RewriteRuleSubtreeStream(adaptor,"rule account");
2792 try {
2793
2794
2795 {
2796 TAG_50A109=(Token)match(input,TAG_50A,FOLLOW_TAG_50A_in_tag50A897);
2797 stream_TAG_50A.add(TAG_50A109);
2798
2799 CODE_SEPARATOR110=(Token)match(input,CODE_SEPARATOR,FOLLOW_CODE_SEPARATOR_in_tag50A899);
2800 stream_CODE_SEPARATOR.add(CODE_SEPARATOR110);
2801
2802 pushFollow(FOLLOW_account_in_tag50A901);
2803 account111=account();
2804
2805 state._fsp--;
2806
2807 stream_account.add(account111.getTree());
2808 CRLF112=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag50A903);
2809 stream_CRLF.add(CRLF112);
2810
2811 pushFollow(FOLLOW_bicBai_in_tag50A905);
2812 bicBai113=bicBai();
2813
2814 state._fsp--;
2815
2816 stream_bicBai.add(bicBai113.getTree());
2817 CRLF114=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag50A907);
2818 stream_CRLF.add(CRLF114);
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829 retval.tree = root_0;
2830 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2831
2832 root_0 = (Object)adaptor.nil();
2833
2834 {
2835
2836 {
2837 Object root_1 = (Object)adaptor.nil();
2838 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2839
2840 adaptor.addChild(root_1, stream_account.nextTree());
2841 adaptor.addChild(root_1, stream_bicBai.nextTree());
2842
2843 adaptor.addChild(root_0, root_1);
2844 }
2845
2846 }
2847
2848 retval.tree = root_0;
2849 }
2850
2851 retval.stop = input.LT(-1);
2852
2853 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2854 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2855
2856 }
2857
2858 catch (RecognitionException re) {
2859 throw re;
2860 }
2861 finally {
2862 }
2863 return retval;
2864 }
2865
2866
2867 public static class tag50K_return extends ParserRuleReturnScope {
2868 Object tree;
2869 public Object getTree() { return tree; }
2870 };
2871
2872
2873
2874 public final SwiftParser.tag50K_return tag50K() throws RecognitionException {
2875 SwiftParser.tag50K_return retval = new SwiftParser.tag50K_return();
2876 retval.start = input.LT(1);
2877
2878 Object root_0 = null;
2879
2880 Token TAG_50K115=null;
2881 Token CODE_SEPARATOR116=null;
2882 Token CRLF118=null;
2883 Token CRLF120=null;
2884 SwiftParser.account_return account117 = null;
2885
2886 SwiftParser.nameAndAddress_return nameAndAddress119 = null;
2887
2888
2889 Object TAG_50K115_tree=null;
2890 Object CODE_SEPARATOR116_tree=null;
2891 Object CRLF118_tree=null;
2892 Object CRLF120_tree=null;
2893 RewriteRuleTokenStream stream_CODE_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token CODE_SEPARATOR");
2894 RewriteRuleTokenStream stream_TAG_50K=new RewriteRuleTokenStream(adaptor,"token TAG_50K");
2895 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
2896 RewriteRuleSubtreeStream stream_nameAndAddress=new RewriteRuleSubtreeStream(adaptor,"rule nameAndAddress");
2897 RewriteRuleSubtreeStream stream_account=new RewriteRuleSubtreeStream(adaptor,"rule account");
2898 try {
2899
2900
2901 {
2902 TAG_50K115=(Token)match(input,TAG_50K,FOLLOW_TAG_50K_in_tag50K929);
2903 stream_TAG_50K.add(TAG_50K115);
2904
2905 CODE_SEPARATOR116=(Token)match(input,CODE_SEPARATOR,FOLLOW_CODE_SEPARATOR_in_tag50K931);
2906 stream_CODE_SEPARATOR.add(CODE_SEPARATOR116);
2907
2908 pushFollow(FOLLOW_account_in_tag50K933);
2909 account117=account();
2910
2911 state._fsp--;
2912
2913 stream_account.add(account117.getTree());
2914 CRLF118=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag50K935);
2915 stream_CRLF.add(CRLF118);
2916
2917 pushFollow(FOLLOW_nameAndAddress_in_tag50K937);
2918 nameAndAddress119=nameAndAddress();
2919
2920 state._fsp--;
2921
2922 stream_nameAndAddress.add(nameAndAddress119.getTree());
2923
2924 int alt17=2;
2925 int LA17_0 = input.LA(1);
2926
2927 if ( (LA17_0==CRLF) ) {
2928 alt17=1;
2929 }
2930 switch (alt17) {
2931 case 1 :
2932
2933 {
2934 CRLF120=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag50K940);
2935 stream_CRLF.add(CRLF120);
2936
2937
2938 }
2939 break;
2940
2941 }
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952 retval.tree = root_0;
2953 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
2954
2955 root_0 = (Object)adaptor.nil();
2956
2957 {
2958
2959 {
2960 Object root_1 = (Object)adaptor.nil();
2961 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
2962
2963 adaptor.addChild(root_1, stream_account.nextTree());
2964 adaptor.addChild(root_1, stream_nameAndAddress.nextTree());
2965
2966 adaptor.addChild(root_0, root_1);
2967 }
2968
2969 }
2970
2971 retval.tree = root_0;
2972 }
2973
2974 retval.stop = input.LT(-1);
2975
2976 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
2977 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2978
2979 }
2980
2981 catch (RecognitionException re) {
2982 throw re;
2983 }
2984 finally {
2985 }
2986 return retval;
2987 }
2988
2989
2990 public static class tag50F_return extends ParserRuleReturnScope {
2991 Object tree;
2992 public Object getTree() { return tree; }
2993 };
2994
2995
2996
2997 public final SwiftParser.tag50F_return tag50F() throws RecognitionException {
2998 SwiftParser.tag50F_return retval = new SwiftParser.tag50F_return();
2999 retval.start = input.LT(1);
3000
3001 Object root_0 = null;
3002
3003 Token TAG_50F121=null;
3004 Token CRLF123=null;
3005 Token CRLF125=null;
3006 SwiftParser.partyIdentifier_return partyIdentifier122 = null;
3007
3008 SwiftParser.nameAndAddress_return nameAndAddress124 = null;
3009
3010
3011 Object TAG_50F121_tree=null;
3012 Object CRLF123_tree=null;
3013 Object CRLF125_tree=null;
3014 RewriteRuleTokenStream stream_TAG_50F=new RewriteRuleTokenStream(adaptor,"token TAG_50F");
3015 RewriteRuleTokenStream stream_CRLF=new RewriteRuleTokenStream(adaptor,"token CRLF");
3016 RewriteRuleSubtreeStream stream_nameAndAddress=new RewriteRuleSubtreeStream(adaptor,"rule nameAndAddress");
3017 RewriteRuleSubtreeStream stream_partyIdentifier=new RewriteRuleSubtreeStream(adaptor,"rule partyIdentifier");
3018 try {
3019
3020
3021 {
3022 TAG_50F121=(Token)match(input,TAG_50F,FOLLOW_TAG_50F_in_tag50F965);
3023 stream_TAG_50F.add(TAG_50F121);
3024
3025 pushFollow(FOLLOW_partyIdentifier_in_tag50F967);
3026 partyIdentifier122=partyIdentifier();
3027
3028 state._fsp--;
3029
3030 stream_partyIdentifier.add(partyIdentifier122.getTree());
3031 CRLF123=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag50F969);
3032 stream_CRLF.add(CRLF123);
3033
3034 pushFollow(FOLLOW_nameAndAddress_in_tag50F971);
3035 nameAndAddress124=nameAndAddress();
3036
3037 state._fsp--;
3038
3039 stream_nameAndAddress.add(nameAndAddress124.getTree());
3040
3041 int alt18=2;
3042 int LA18_0 = input.LA(1);
3043
3044 if ( (LA18_0==CRLF) ) {
3045 alt18=1;
3046 }
3047 switch (alt18) {
3048 case 1 :
3049
3050 {
3051 CRLF125=(Token)match(input,CRLF,FOLLOW_CRLF_in_tag50F974);
3052 stream_CRLF.add(CRLF125);
3053
3054
3055 }
3056 break;
3057
3058 }
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069 retval.tree = root_0;
3070 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
3071
3072 root_0 = (Object)adaptor.nil();
3073
3074 {
3075
3076 {
3077 Object root_1 = (Object)adaptor.nil();
3078 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TAG_NAME, "TAG_NAME"), root_1);
3079
3080 adaptor.addChild(root_1, stream_partyIdentifier.nextTree());
3081 adaptor.addChild(root_1, stream_nameAndAddress.nextTree());
3082
3083 adaptor.addChild(root_0, root_1);
3084 }
3085
3086 }
3087
3088 retval.tree = root_0;
3089 }
3090
3091 retval.stop = input.LT(-1);
3092
3093 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3094 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3095
3096 }
3097
3098 catch (RecognitionException re) {
3099 throw re;
3100 }
3101 finally {
3102 }
3103 return retval;
3104 }
3105
3106
3107 public static class tag51A_return extends ParserRuleReturnScope {
3108 Object tree;
3109 public Object getTree() { return tree; }
3110 };
3111
3112
3113
3114 public final SwiftParser.tag51A_return tag51A() throws RecognitionException {
3115 SwiftParser.tag51A_return retval = new SwiftParser.tag51A_return();
3116 retval.start = input.LT(1);
3117
3118 Object root_0 = null;
3119
3120 try {
3121
3122
3123 {
3124 root_0 = (Object)adaptor.nil();
3125
3126 }
3127
3128 retval.stop = input.LT(-1);
3129
3130 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3131 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3132
3133 }
3134 finally {
3135 }
3136 return retval;
3137 }
3138
3139
3140 public static class tag52A_return extends ParserRuleReturnScope {
3141 Object tree;
3142 public Object getTree() { return tree; }
3143 };
3144
3145
3146
3147 public final SwiftParser.tag52A_return tag52A() throws RecognitionException {
3148 SwiftParser.tag52A_return retval = new SwiftParser.tag52A_return();
3149 retval.start = input.LT(1);
3150
3151 Object root_0 = null;
3152
3153 try {
3154
3155
3156 {
3157 root_0 = (Object)adaptor.nil();
3158
3159 }
3160
3161 retval.stop = input.LT(-1);
3162
3163 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3164 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3165
3166 }
3167 finally {
3168 }
3169 return retval;
3170 }
3171
3172
3173 public static class tag70_return extends ParserRuleReturnScope {
3174 Object tree;
3175 public Object getTree() { return tree; }
3176 };
3177
3178
3179
3180 public final SwiftParser.tag70_return tag70() throws RecognitionException {
3181 SwiftParser.tag70_return retval = new SwiftParser.tag70_return();
3182 retval.start = input.LT(1);
3183
3184 Object root_0 = null;
3185
3186 try {
3187
3188
3189 {
3190 root_0 = (Object)adaptor.nil();
3191
3192 }
3193
3194 retval.stop = input.LT(-1);
3195
3196 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3197 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3198
3199 }
3200 finally {
3201 }
3202 return retval;
3203 }
3204
3205
3206 public static class tag71A_return extends ParserRuleReturnScope {
3207 Object tree;
3208 public Object getTree() { return tree; }
3209 };
3210
3211
3212
3213 public final SwiftParser.tag71A_return tag71A() throws RecognitionException {
3214 SwiftParser.tag71A_return retval = new SwiftParser.tag71A_return();
3215 retval.start = input.LT(1);
3216
3217 Object root_0 = null;
3218
3219 try {
3220
3221
3222 {
3223 root_0 = (Object)adaptor.nil();
3224
3225 }
3226
3227 retval.stop = input.LT(-1);
3228
3229 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3230 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3231
3232 }
3233 finally {
3234 }
3235 return retval;
3236 }
3237
3238
3239 public static class tag71F_return extends ParserRuleReturnScope {
3240 Object tree;
3241 public Object getTree() { return tree; }
3242 };
3243
3244
3245
3246 public final SwiftParser.tag71F_return tag71F() throws RecognitionException {
3247 SwiftParser.tag71F_return retval = new SwiftParser.tag71F_return();
3248 retval.start = input.LT(1);
3249
3250 Object root_0 = null;
3251
3252 try {
3253
3254
3255 {
3256 root_0 = (Object)adaptor.nil();
3257
3258 }
3259
3260 retval.stop = input.LT(-1);
3261
3262 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3263 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3264
3265 }
3266 finally {
3267 }
3268 return retval;
3269 }
3270
3271
3272 public static class tag71G_return extends ParserRuleReturnScope {
3273 Object tree;
3274 public Object getTree() { return tree; }
3275 };
3276
3277
3278
3279 public final SwiftParser.tag71G_return tag71G() throws RecognitionException {
3280 SwiftParser.tag71G_return retval = new SwiftParser.tag71G_return();
3281 retval.start = input.LT(1);
3282
3283 Object root_0 = null;
3284
3285 try {
3286
3287
3288 {
3289 root_0 = (Object)adaptor.nil();
3290
3291 }
3292
3293 retval.stop = input.LT(-1);
3294
3295 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3296 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3297
3298 }
3299 finally {
3300 }
3301 return retval;
3302 }
3303
3304
3305 public static class tag72_return extends ParserRuleReturnScope {
3306 Object tree;
3307 public Object getTree() { return tree; }
3308 };
3309
3310
3311
3312 public final SwiftParser.tag72_return tag72() throws RecognitionException {
3313 SwiftParser.tag72_return retval = new SwiftParser.tag72_return();
3314 retval.start = input.LT(1);
3315
3316 Object root_0 = null;
3317
3318 try {
3319
3320
3321 {
3322 root_0 = (Object)adaptor.nil();
3323
3324 }
3325
3326 retval.stop = input.LT(-1);
3327
3328 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3329 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3330
3331 }
3332 finally {
3333 }
3334 return retval;
3335 }
3336
3337
3338 public static class tag77B_return extends ParserRuleReturnScope {
3339 Object tree;
3340 public Object getTree() { return tree; }
3341 };
3342
3343
3344
3345 public final SwiftParser.tag77B_return tag77B() throws RecognitionException {
3346 SwiftParser.tag77B_return retval = new SwiftParser.tag77B_return();
3347 retval.start = input.LT(1);
3348
3349 Object root_0 = null;
3350
3351 try {
3352
3353
3354 {
3355 root_0 = (Object)adaptor.nil();
3356
3357 }
3358
3359 retval.stop = input.LT(-1);
3360
3361 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3362 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3363
3364 }
3365 finally {
3366 }
3367 return retval;
3368 }
3369
3370
3371 public static class tag77T_return extends ParserRuleReturnScope {
3372 Object tree;
3373 public Object getTree() { return tree; }
3374 };
3375
3376
3377
3378 public final SwiftParser.tag77T_return tag77T() throws RecognitionException {
3379 SwiftParser.tag77T_return retval = new SwiftParser.tag77T_return();
3380 retval.start = input.LT(1);
3381
3382 Object root_0 = null;
3383
3384 try {
3385
3386
3387 {
3388 root_0 = (Object)adaptor.nil();
3389
3390 }
3391
3392 retval.stop = input.LT(-1);
3393
3394 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3395 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3396
3397 }
3398 finally {
3399 }
3400 return retval;
3401 }
3402
3403
3404 public static class tag50_a_return extends ParserRuleReturnScope {
3405 Object tree;
3406 public Object getTree() { return tree; }
3407 };
3408
3409
3410
3411 public final SwiftParser.tag50_a_return tag50_a() throws RecognitionException {
3412 SwiftParser.tag50_a_return retval = new SwiftParser.tag50_a_return();
3413 retval.start = input.LT(1);
3414
3415 Object root_0 = null;
3416
3417 SwiftParser.tag50A_return tag50A126 = null;
3418
3419 SwiftParser.tag50K_return tag50K127 = null;
3420
3421 SwiftParser.tag50F_return tag50F128 = null;
3422
3423
3424
3425 try {
3426
3427 int alt19=3;
3428 switch ( input.LA(1) ) {
3429 case TAG_50A:
3430 {
3431 alt19=1;
3432 }
3433 break;
3434 case TAG_50K:
3435 {
3436 alt19=2;
3437 }
3438 break;
3439 case TAG_50F:
3440 {
3441 alt19=3;
3442 }
3443 break;
3444 default:
3445 NoViableAltException nvae =
3446 new NoViableAltException("", 19, 0, input);
3447
3448 throw nvae;
3449 }
3450
3451 switch (alt19) {
3452 case 1 :
3453
3454 {
3455 root_0 = (Object)adaptor.nil();
3456
3457 pushFollow(FOLLOW_tag50A_in_tag50_a1058);
3458 tag50A126=tag50A();
3459
3460 state._fsp--;
3461
3462 adaptor.addChild(root_0, tag50A126.getTree());
3463
3464 }
3465 break;
3466 case 2 :
3467
3468 {
3469 root_0 = (Object)adaptor.nil();
3470
3471 pushFollow(FOLLOW_tag50K_in_tag50_a1065);
3472 tag50K127=tag50K();
3473
3474 state._fsp--;
3475
3476 adaptor.addChild(root_0, tag50K127.getTree());
3477
3478 }
3479 break;
3480 case 3 :
3481
3482 {
3483 root_0 = (Object)adaptor.nil();
3484
3485 pushFollow(FOLLOW_tag50F_in_tag50_a1070);
3486 tag50F128=tag50F();
3487
3488 state._fsp--;
3489
3490 adaptor.addChild(root_0, tag50F128.getTree());
3491
3492 }
3493 break;
3494
3495 }
3496 retval.stop = input.LT(-1);
3497
3498 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3499 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3500
3501 }
3502
3503 catch (RecognitionException re) {
3504 throw re;
3505 }
3506 finally {
3507 }
3508 return retval;
3509 }
3510
3511
3512 public static class tag52_a_return extends ParserRuleReturnScope {
3513 Object tree;
3514 public Object getTree() { return tree; }
3515 };
3516
3517
3518
3519 public final SwiftParser.tag52_a_return tag52_a() throws RecognitionException {
3520 SwiftParser.tag52_a_return retval = new SwiftParser.tag52_a_return();
3521 retval.start = input.LT(1);
3522
3523 Object root_0 = null;
3524
3525 try {
3526
3527
3528 {
3529 root_0 = (Object)adaptor.nil();
3530
3531 }
3532
3533 retval.stop = input.LT(-1);
3534
3535 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3536 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3537
3538 }
3539 finally {
3540 }
3541 return retval;
3542 }
3543
3544
3545 public static class tag53_a_return extends ParserRuleReturnScope {
3546 Object tree;
3547 public Object getTree() { return tree; }
3548 };
3549
3550
3551
3552 public final SwiftParser.tag53_a_return tag53_a() throws RecognitionException {
3553 SwiftParser.tag53_a_return retval = new SwiftParser.tag53_a_return();
3554 retval.start = input.LT(1);
3555
3556 Object root_0 = null;
3557
3558 try {
3559
3560
3561 {
3562 root_0 = (Object)adaptor.nil();
3563
3564 }
3565
3566 retval.stop = input.LT(-1);
3567
3568 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3569 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3570
3571 }
3572 finally {
3573 }
3574 return retval;
3575 }
3576
3577
3578 public static class tag54_a_return extends ParserRuleReturnScope {
3579 Object tree;
3580 public Object getTree() { return tree; }
3581 };
3582
3583
3584
3585 public final SwiftParser.tag54_a_return tag54_a() throws RecognitionException {
3586 SwiftParser.tag54_a_return retval = new SwiftParser.tag54_a_return();
3587 retval.start = input.LT(1);
3588
3589 Object root_0 = null;
3590
3591 try {
3592
3593
3594 {
3595 root_0 = (Object)adaptor.nil();
3596
3597 }
3598
3599 retval.stop = input.LT(-1);
3600
3601 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3602 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3603
3604 }
3605 finally {
3606 }
3607 return retval;
3608 }
3609
3610
3611 public static class tag55_a_return extends ParserRuleReturnScope {
3612 Object tree;
3613 public Object getTree() { return tree; }
3614 };
3615
3616
3617
3618 public final SwiftParser.tag55_a_return tag55_a() throws RecognitionException {
3619 SwiftParser.tag55_a_return retval = new SwiftParser.tag55_a_return();
3620 retval.start = input.LT(1);
3621
3622 Object root_0 = null;
3623
3624 try {
3625
3626
3627 {
3628 root_0 = (Object)adaptor.nil();
3629
3630 }
3631
3632 retval.stop = input.LT(-1);
3633
3634 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3635 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3636
3637 }
3638 finally {
3639 }
3640 return retval;
3641 }
3642
3643
3644 public static class tag56_a_return extends ParserRuleReturnScope {
3645 Object tree;
3646 public Object getTree() { return tree; }
3647 };
3648
3649
3650
3651 public final SwiftParser.tag56_a_return tag56_a() throws RecognitionException {
3652 SwiftParser.tag56_a_return retval = new SwiftParser.tag56_a_return();
3653 retval.start = input.LT(1);
3654
3655 Object root_0 = null;
3656
3657 try {
3658
3659
3660 {
3661 root_0 = (Object)adaptor.nil();
3662
3663 }
3664
3665 retval.stop = input.LT(-1);
3666
3667 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3668 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3669
3670 }
3671 finally {
3672 }
3673 return retval;
3674 }
3675
3676
3677 public static class tag57_a_return extends ParserRuleReturnScope {
3678 Object tree;
3679 public Object getTree() { return tree; }
3680 };
3681
3682
3683
3684 public final SwiftParser.tag57_a_return tag57_a() throws RecognitionException {
3685 SwiftParser.tag57_a_return retval = new SwiftParser.tag57_a_return();
3686 retval.start = input.LT(1);
3687
3688 Object root_0 = null;
3689
3690 try {
3691
3692
3693 {
3694 root_0 = (Object)adaptor.nil();
3695
3696 }
3697
3698 retval.stop = input.LT(-1);
3699
3700 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3701 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3702
3703 }
3704 finally {
3705 }
3706 return retval;
3707 }
3708
3709
3710 public static class tag59_a_return extends ParserRuleReturnScope {
3711 Object tree;
3712 public Object getTree() { return tree; }
3713 };
3714
3715
3716
3717 public final SwiftParser.tag59_a_return tag59_a() throws RecognitionException {
3718 SwiftParser.tag59_a_return retval = new SwiftParser.tag59_a_return();
3719 retval.start = input.LT(1);
3720
3721 Object root_0 = null;
3722
3723 try {
3724
3725
3726 {
3727 root_0 = (Object)adaptor.nil();
3728
3729 }
3730
3731 retval.stop = input.LT(-1);
3732
3733 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3734 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3735
3736 }
3737 finally {
3738 }
3739 return retval;
3740 }
3741
3742
3743 public static class direction_return extends ParserRuleReturnScope {
3744 Object tree;
3745 public Object getTree() { return tree; }
3746 };
3747
3748
3749
3750 public final SwiftParser.direction_return direction() throws RecognitionException {
3751 SwiftParser.direction_return retval = new SwiftParser.direction_return();
3752 retval.start = input.LT(1);
3753
3754 Object root_0 = null;
3755
3756 Token UPPERCASE_LETTER129=null;
3757
3758 Object UPPERCASE_LETTER129_tree=null;
3759
3760 try {
3761
3762
3763 {
3764 root_0 = (Object)adaptor.nil();
3765
3766 UPPERCASE_LETTER129=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_direction1129);
3767 UPPERCASE_LETTER129_tree = (Object)adaptor.create(UPPERCASE_LETTER129);
3768 adaptor.addChild(root_0, UPPERCASE_LETTER129_tree);
3769
3770
3771 }
3772
3773 retval.stop = input.LT(-1);
3774
3775 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3776 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3777
3778 }
3779
3780 catch (RecognitionException re) {
3781 throw re;
3782 }
3783 finally {
3784 }
3785 return retval;
3786 }
3787
3788
3789 public static class type_return extends ParserRuleReturnScope {
3790 Object tree;
3791 public Object getTree() { return tree; }
3792 };
3793
3794
3795
3796 public final SwiftParser.type_return type() throws RecognitionException {
3797 SwiftParser.type_return retval = new SwiftParser.type_return();
3798 retval.start = input.LT(1);
3799
3800 Object root_0 = null;
3801
3802 Token NUMBER130=null;
3803 Token NUMBER131=null;
3804 Token NUMBER132=null;
3805
3806 Object NUMBER130_tree=null;
3807 Object NUMBER131_tree=null;
3808 Object NUMBER132_tree=null;
3809
3810 try {
3811
3812
3813 {
3814 root_0 = (Object)adaptor.nil();
3815
3816 NUMBER130=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_type1139);
3817 NUMBER130_tree = (Object)adaptor.create(NUMBER130);
3818 adaptor.addChild(root_0, NUMBER130_tree);
3819
3820 NUMBER131=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_type1141);
3821 NUMBER131_tree = (Object)adaptor.create(NUMBER131);
3822 adaptor.addChild(root_0, NUMBER131_tree);
3823
3824 NUMBER132=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_type1143);
3825 NUMBER132_tree = (Object)adaptor.create(NUMBER132);
3826 adaptor.addChild(root_0, NUMBER132_tree);
3827
3828
3829 }
3830
3831 retval.stop = input.LT(-1);
3832
3833 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3834 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3835
3836 }
3837
3838 catch (RecognitionException re) {
3839 throw re;
3840 }
3841 finally {
3842 }
3843 return retval;
3844 }
3845
3846
3847 public static class receiverAddress_return extends ParserRuleReturnScope {
3848 Object tree;
3849 public Object getTree() { return tree; }
3850 };
3851
3852
3853
3854 public final SwiftParser.receiverAddress_return receiverAddress() throws RecognitionException {
3855 SwiftParser.receiverAddress_return retval = new SwiftParser.receiverAddress_return();
3856 retval.start = input.LT(1);
3857
3858 Object root_0 = null;
3859
3860 Token UPPERCASE_LETTER133=null;
3861 Token UPPERCASE_LETTER134=null;
3862 Token UPPERCASE_LETTER135=null;
3863 Token UPPERCASE_LETTER136=null;
3864 Token UPPERCASE_LETTER137=null;
3865 Token UPPERCASE_LETTER138=null;
3866 Token UPPERCASE_LETTER139=null;
3867 Token UPPERCASE_LETTER140=null;
3868 Token UPPERCASE_LETTER141=null;
3869 Token UPPERCASE_LETTER142=null;
3870 Token UPPERCASE_LETTER143=null;
3871 Token UPPERCASE_LETTER144=null;
3872
3873 Object UPPERCASE_LETTER133_tree=null;
3874 Object UPPERCASE_LETTER134_tree=null;
3875 Object UPPERCASE_LETTER135_tree=null;
3876 Object UPPERCASE_LETTER136_tree=null;
3877 Object UPPERCASE_LETTER137_tree=null;
3878 Object UPPERCASE_LETTER138_tree=null;
3879 Object UPPERCASE_LETTER139_tree=null;
3880 Object UPPERCASE_LETTER140_tree=null;
3881 Object UPPERCASE_LETTER141_tree=null;
3882 Object UPPERCASE_LETTER142_tree=null;
3883 Object UPPERCASE_LETTER143_tree=null;
3884 Object UPPERCASE_LETTER144_tree=null;
3885
3886 try {
3887
3888
3889 {
3890 root_0 = (Object)adaptor.nil();
3891
3892 UPPERCASE_LETTER133=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1155);
3893 UPPERCASE_LETTER133_tree = (Object)adaptor.create(UPPERCASE_LETTER133);
3894 adaptor.addChild(root_0, UPPERCASE_LETTER133_tree);
3895
3896 UPPERCASE_LETTER134=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1157);
3897 UPPERCASE_LETTER134_tree = (Object)adaptor.create(UPPERCASE_LETTER134);
3898 adaptor.addChild(root_0, UPPERCASE_LETTER134_tree);
3899
3900 UPPERCASE_LETTER135=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1159);
3901 UPPERCASE_LETTER135_tree = (Object)adaptor.create(UPPERCASE_LETTER135);
3902 adaptor.addChild(root_0, UPPERCASE_LETTER135_tree);
3903
3904 UPPERCASE_LETTER136=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1164);
3905 UPPERCASE_LETTER136_tree = (Object)adaptor.create(UPPERCASE_LETTER136);
3906 adaptor.addChild(root_0, UPPERCASE_LETTER136_tree);
3907
3908 UPPERCASE_LETTER137=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1166);
3909 UPPERCASE_LETTER137_tree = (Object)adaptor.create(UPPERCASE_LETTER137);
3910 adaptor.addChild(root_0, UPPERCASE_LETTER137_tree);
3911
3912 UPPERCASE_LETTER138=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1168);
3913 UPPERCASE_LETTER138_tree = (Object)adaptor.create(UPPERCASE_LETTER138);
3914 adaptor.addChild(root_0, UPPERCASE_LETTER138_tree);
3915
3916 UPPERCASE_LETTER139=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1173);
3917 UPPERCASE_LETTER139_tree = (Object)adaptor.create(UPPERCASE_LETTER139);
3918 adaptor.addChild(root_0, UPPERCASE_LETTER139_tree);
3919
3920 UPPERCASE_LETTER140=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1175);
3921 UPPERCASE_LETTER140_tree = (Object)adaptor.create(UPPERCASE_LETTER140);
3922 adaptor.addChild(root_0, UPPERCASE_LETTER140_tree);
3923
3924 UPPERCASE_LETTER141=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1177);
3925 UPPERCASE_LETTER141_tree = (Object)adaptor.create(UPPERCASE_LETTER141);
3926 adaptor.addChild(root_0, UPPERCASE_LETTER141_tree);
3927
3928 UPPERCASE_LETTER142=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1182);
3929 UPPERCASE_LETTER142_tree = (Object)adaptor.create(UPPERCASE_LETTER142);
3930 adaptor.addChild(root_0, UPPERCASE_LETTER142_tree);
3931
3932 UPPERCASE_LETTER143=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1184);
3933 UPPERCASE_LETTER143_tree = (Object)adaptor.create(UPPERCASE_LETTER143);
3934 adaptor.addChild(root_0, UPPERCASE_LETTER143_tree);
3935
3936 UPPERCASE_LETTER144=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_receiverAddress1186);
3937 UPPERCASE_LETTER144_tree = (Object)adaptor.create(UPPERCASE_LETTER144);
3938 adaptor.addChild(root_0, UPPERCASE_LETTER144_tree);
3939
3940
3941 }
3942
3943 retval.stop = input.LT(-1);
3944
3945 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3946 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3947
3948 }
3949
3950 catch (RecognitionException re) {
3951 throw re;
3952 }
3953 finally {
3954 }
3955 return retval;
3956 }
3957
3958
3959 public static class priority_return extends ParserRuleReturnScope {
3960 Object tree;
3961 public Object getTree() { return tree; }
3962 };
3963
3964
3965
3966 public final SwiftParser.priority_return priority() throws RecognitionException {
3967 SwiftParser.priority_return retval = new SwiftParser.priority_return();
3968 retval.start = input.LT(1);
3969
3970 Object root_0 = null;
3971
3972 Token UPPERCASE_LETTER145=null;
3973
3974 Object UPPERCASE_LETTER145_tree=null;
3975
3976 try {
3977
3978
3979 {
3980 root_0 = (Object)adaptor.nil();
3981
3982 UPPERCASE_LETTER145=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_priority1196);
3983 UPPERCASE_LETTER145_tree = (Object)adaptor.create(UPPERCASE_LETTER145);
3984 adaptor.addChild(root_0, UPPERCASE_LETTER145_tree);
3985
3986
3987 }
3988
3989 retval.stop = input.LT(-1);
3990
3991 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
3992 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3993
3994 }
3995
3996 catch (RecognitionException re) {
3997 throw re;
3998 }
3999 finally {
4000 }
4001 return retval;
4002 }
4003
4004
4005 public static class deliveryMonitor_return extends ParserRuleReturnScope {
4006 Object tree;
4007 public Object getTree() { return tree; }
4008 };
4009
4010
4011
4012 public final SwiftParser.deliveryMonitor_return deliveryMonitor() throws RecognitionException {
4013 SwiftParser.deliveryMonitor_return retval = new SwiftParser.deliveryMonitor_return();
4014 retval.start = input.LT(1);
4015
4016 Object root_0 = null;
4017
4018 Token NUMBER146=null;
4019
4020 Object NUMBER146_tree=null;
4021
4022 try {
4023
4024
4025 {
4026 root_0 = (Object)adaptor.nil();
4027
4028 NUMBER146=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_deliveryMonitor1205);
4029 NUMBER146_tree = (Object)adaptor.create(NUMBER146);
4030 adaptor.addChild(root_0, NUMBER146_tree);
4031
4032
4033 }
4034
4035 retval.stop = input.LT(-1);
4036
4037 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4038 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4039
4040 }
4041
4042 catch (RecognitionException re) {
4043 throw re;
4044 }
4045 finally {
4046 }
4047 return retval;
4048 }
4049
4050
4051 public static class obsolescencePeriod_return extends ParserRuleReturnScope {
4052 Object tree;
4053 public Object getTree() { return tree; }
4054 };
4055
4056
4057
4058 public final SwiftParser.obsolescencePeriod_return obsolescencePeriod() throws RecognitionException {
4059 SwiftParser.obsolescencePeriod_return retval = new SwiftParser.obsolescencePeriod_return();
4060 retval.start = input.LT(1);
4061
4062 Object root_0 = null;
4063
4064 Token NUMBER147=null;
4065 Token NUMBER148=null;
4066 Token NUMBER149=null;
4067
4068 Object NUMBER147_tree=null;
4069 Object NUMBER148_tree=null;
4070 Object NUMBER149_tree=null;
4071
4072 try {
4073
4074
4075 {
4076 root_0 = (Object)adaptor.nil();
4077
4078 NUMBER147=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_obsolescencePeriod1216);
4079 NUMBER147_tree = (Object)adaptor.create(NUMBER147);
4080 adaptor.addChild(root_0, NUMBER147_tree);
4081
4082 NUMBER148=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_obsolescencePeriod1218);
4083 NUMBER148_tree = (Object)adaptor.create(NUMBER148);
4084 adaptor.addChild(root_0, NUMBER148_tree);
4085
4086 NUMBER149=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_obsolescencePeriod1220);
4087 NUMBER149_tree = (Object)adaptor.create(NUMBER149);
4088 adaptor.addChild(root_0, NUMBER149_tree);
4089
4090
4091 }
4092
4093 retval.stop = input.LT(-1);
4094
4095 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4096 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4097
4098 }
4099
4100 catch (RecognitionException re) {
4101 throw re;
4102 }
4103 finally {
4104 }
4105 return retval;
4106 }
4107
4108
4109 public static class inputTime_return extends ParserRuleReturnScope {
4110 Object tree;
4111 public Object getTree() { return tree; }
4112 };
4113
4114
4115
4116 public final SwiftParser.inputTime_return inputTime() throws RecognitionException {
4117 SwiftParser.inputTime_return retval = new SwiftParser.inputTime_return();
4118 retval.start = input.LT(1);
4119
4120 Object root_0 = null;
4121
4122 Token NUMBER150=null;
4123 Token NUMBER151=null;
4124 Token NUMBER152=null;
4125 Token NUMBER153=null;
4126
4127 Object NUMBER150_tree=null;
4128 Object NUMBER151_tree=null;
4129 Object NUMBER152_tree=null;
4130 Object NUMBER153_tree=null;
4131
4132 try {
4133
4134
4135 {
4136 root_0 = (Object)adaptor.nil();
4137
4138 NUMBER150=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_inputTime1231);
4139 NUMBER150_tree = (Object)adaptor.create(NUMBER150);
4140 adaptor.addChild(root_0, NUMBER150_tree);
4141
4142 NUMBER151=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_inputTime1233);
4143 NUMBER151_tree = (Object)adaptor.create(NUMBER151);
4144 adaptor.addChild(root_0, NUMBER151_tree);
4145
4146 NUMBER152=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_inputTime1235);
4147 NUMBER152_tree = (Object)adaptor.create(NUMBER152);
4148 adaptor.addChild(root_0, NUMBER152_tree);
4149
4150 NUMBER153=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_inputTime1237);
4151 NUMBER153_tree = (Object)adaptor.create(NUMBER153);
4152 adaptor.addChild(root_0, NUMBER153_tree);
4153
4154
4155 }
4156
4157 retval.stop = input.LT(-1);
4158
4159 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4160 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4161
4162 }
4163
4164 catch (RecognitionException re) {
4165 throw re;
4166 }
4167 finally {
4168 }
4169 return retval;
4170 }
4171
4172
4173 public static class messageInputReference_return extends ParserRuleReturnScope {
4174 Object tree;
4175 public Object getTree() { return tree; }
4176 };
4177
4178
4179
4180 public final SwiftParser.messageInputReference_return messageInputReference() throws RecognitionException {
4181 SwiftParser.messageInputReference_return retval = new SwiftParser.messageInputReference_return();
4182 retval.start = input.LT(1);
4183
4184 Object root_0 = null;
4185
4186 Token NUMBER154=null;
4187 Token NUMBER155=null;
4188 Token NUMBER156=null;
4189 Token NUMBER157=null;
4190 Token NUMBER158=null;
4191 Token NUMBER159=null;
4192 Token UPPERCASE_LETTER160=null;
4193 Token UPPERCASE_LETTER161=null;
4194 Token UPPERCASE_LETTER162=null;
4195 Token UPPERCASE_LETTER163=null;
4196 Token UPPERCASE_LETTER164=null;
4197 Token UPPERCASE_LETTER165=null;
4198 Token UPPERCASE_LETTER166=null;
4199 Token UPPERCASE_LETTER167=null;
4200 Token UPPERCASE_LETTER168=null;
4201 Token UPPERCASE_LETTER169=null;
4202 Token UPPERCASE_LETTER170=null;
4203 Token UPPERCASE_LETTER171=null;
4204 Token NUMBER172=null;
4205 Token NUMBER173=null;
4206 Token NUMBER174=null;
4207 Token NUMBER175=null;
4208 Token NUMBER176=null;
4209 Token NUMBER177=null;
4210 Token NUMBER178=null;
4211 Token NUMBER179=null;
4212 Token NUMBER180=null;
4213 Token NUMBER181=null;
4214
4215 Object NUMBER154_tree=null;
4216 Object NUMBER155_tree=null;
4217 Object NUMBER156_tree=null;
4218 Object NUMBER157_tree=null;
4219 Object NUMBER158_tree=null;
4220 Object NUMBER159_tree=null;
4221 Object UPPERCASE_LETTER160_tree=null;
4222 Object UPPERCASE_LETTER161_tree=null;
4223 Object UPPERCASE_LETTER162_tree=null;
4224 Object UPPERCASE_LETTER163_tree=null;
4225 Object UPPERCASE_LETTER164_tree=null;
4226 Object UPPERCASE_LETTER165_tree=null;
4227 Object UPPERCASE_LETTER166_tree=null;
4228 Object UPPERCASE_LETTER167_tree=null;
4229 Object UPPERCASE_LETTER168_tree=null;
4230 Object UPPERCASE_LETTER169_tree=null;
4231 Object UPPERCASE_LETTER170_tree=null;
4232 Object UPPERCASE_LETTER171_tree=null;
4233 Object NUMBER172_tree=null;
4234 Object NUMBER173_tree=null;
4235 Object NUMBER174_tree=null;
4236 Object NUMBER175_tree=null;
4237 Object NUMBER176_tree=null;
4238 Object NUMBER177_tree=null;
4239 Object NUMBER178_tree=null;
4240 Object NUMBER179_tree=null;
4241 Object NUMBER180_tree=null;
4242 Object NUMBER181_tree=null;
4243
4244 try {
4245
4246
4247 {
4248 root_0 = (Object)adaptor.nil();
4249
4250 NUMBER154=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1247);
4251 NUMBER154_tree = (Object)adaptor.create(NUMBER154);
4252 adaptor.addChild(root_0, NUMBER154_tree);
4253
4254 NUMBER155=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1249);
4255 NUMBER155_tree = (Object)adaptor.create(NUMBER155);
4256 adaptor.addChild(root_0, NUMBER155_tree);
4257
4258 NUMBER156=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1251);
4259 NUMBER156_tree = (Object)adaptor.create(NUMBER156);
4260 adaptor.addChild(root_0, NUMBER156_tree);
4261
4262 NUMBER157=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1253);
4263 NUMBER157_tree = (Object)adaptor.create(NUMBER157);
4264 adaptor.addChild(root_0, NUMBER157_tree);
4265
4266 NUMBER158=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1255);
4267 NUMBER158_tree = (Object)adaptor.create(NUMBER158);
4268 adaptor.addChild(root_0, NUMBER158_tree);
4269
4270 NUMBER159=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1257);
4271 NUMBER159_tree = (Object)adaptor.create(NUMBER159);
4272 adaptor.addChild(root_0, NUMBER159_tree);
4273
4274 UPPERCASE_LETTER160=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1262);
4275 UPPERCASE_LETTER160_tree = (Object)adaptor.create(UPPERCASE_LETTER160);
4276 adaptor.addChild(root_0, UPPERCASE_LETTER160_tree);
4277
4278 UPPERCASE_LETTER161=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1264);
4279 UPPERCASE_LETTER161_tree = (Object)adaptor.create(UPPERCASE_LETTER161);
4280 adaptor.addChild(root_0, UPPERCASE_LETTER161_tree);
4281
4282 UPPERCASE_LETTER162=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1266);
4283 UPPERCASE_LETTER162_tree = (Object)adaptor.create(UPPERCASE_LETTER162);
4284 adaptor.addChild(root_0, UPPERCASE_LETTER162_tree);
4285
4286 UPPERCASE_LETTER163=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1271);
4287 UPPERCASE_LETTER163_tree = (Object)adaptor.create(UPPERCASE_LETTER163);
4288 adaptor.addChild(root_0, UPPERCASE_LETTER163_tree);
4289
4290 UPPERCASE_LETTER164=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1273);
4291 UPPERCASE_LETTER164_tree = (Object)adaptor.create(UPPERCASE_LETTER164);
4292 adaptor.addChild(root_0, UPPERCASE_LETTER164_tree);
4293
4294 UPPERCASE_LETTER165=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1275);
4295 UPPERCASE_LETTER165_tree = (Object)adaptor.create(UPPERCASE_LETTER165);
4296 adaptor.addChild(root_0, UPPERCASE_LETTER165_tree);
4297
4298 UPPERCASE_LETTER166=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1280);
4299 UPPERCASE_LETTER166_tree = (Object)adaptor.create(UPPERCASE_LETTER166);
4300 adaptor.addChild(root_0, UPPERCASE_LETTER166_tree);
4301
4302 UPPERCASE_LETTER167=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1282);
4303 UPPERCASE_LETTER167_tree = (Object)adaptor.create(UPPERCASE_LETTER167);
4304 adaptor.addChild(root_0, UPPERCASE_LETTER167_tree);
4305
4306 UPPERCASE_LETTER168=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1284);
4307 UPPERCASE_LETTER168_tree = (Object)adaptor.create(UPPERCASE_LETTER168);
4308 adaptor.addChild(root_0, UPPERCASE_LETTER168_tree);
4309
4310 UPPERCASE_LETTER169=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1289);
4311 UPPERCASE_LETTER169_tree = (Object)adaptor.create(UPPERCASE_LETTER169);
4312 adaptor.addChild(root_0, UPPERCASE_LETTER169_tree);
4313
4314 UPPERCASE_LETTER170=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1291);
4315 UPPERCASE_LETTER170_tree = (Object)adaptor.create(UPPERCASE_LETTER170);
4316 adaptor.addChild(root_0, UPPERCASE_LETTER170_tree);
4317
4318 UPPERCASE_LETTER171=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_messageInputReference1293);
4319 UPPERCASE_LETTER171_tree = (Object)adaptor.create(UPPERCASE_LETTER171);
4320 adaptor.addChild(root_0, UPPERCASE_LETTER171_tree);
4321
4322 NUMBER172=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1297);
4323 NUMBER172_tree = (Object)adaptor.create(NUMBER172);
4324 adaptor.addChild(root_0, NUMBER172_tree);
4325
4326 NUMBER173=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1299);
4327 NUMBER173_tree = (Object)adaptor.create(NUMBER173);
4328 adaptor.addChild(root_0, NUMBER173_tree);
4329
4330 NUMBER174=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1301);
4331 NUMBER174_tree = (Object)adaptor.create(NUMBER174);
4332 adaptor.addChild(root_0, NUMBER174_tree);
4333
4334 NUMBER175=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1303);
4335 NUMBER175_tree = (Object)adaptor.create(NUMBER175);
4336 adaptor.addChild(root_0, NUMBER175_tree);
4337
4338 NUMBER176=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1307);
4339 NUMBER176_tree = (Object)adaptor.create(NUMBER176);
4340 adaptor.addChild(root_0, NUMBER176_tree);
4341
4342 NUMBER177=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1309);
4343 NUMBER177_tree = (Object)adaptor.create(NUMBER177);
4344 adaptor.addChild(root_0, NUMBER177_tree);
4345
4346 NUMBER178=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1311);
4347 NUMBER178_tree = (Object)adaptor.create(NUMBER178);
4348 adaptor.addChild(root_0, NUMBER178_tree);
4349
4350 NUMBER179=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1315);
4351 NUMBER179_tree = (Object)adaptor.create(NUMBER179);
4352 adaptor.addChild(root_0, NUMBER179_tree);
4353
4354 NUMBER180=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1317);
4355 NUMBER180_tree = (Object)adaptor.create(NUMBER180);
4356 adaptor.addChild(root_0, NUMBER180_tree);
4357
4358 NUMBER181=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_messageInputReference1319);
4359 NUMBER181_tree = (Object)adaptor.create(NUMBER181);
4360 adaptor.addChild(root_0, NUMBER181_tree);
4361
4362
4363 }
4364
4365 retval.stop = input.LT(-1);
4366
4367 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4368 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4369
4370 }
4371
4372 catch (RecognitionException re) {
4373 throw re;
4374 }
4375 finally {
4376 }
4377 return retval;
4378 }
4379
4380
4381 public static class outputDate_return extends ParserRuleReturnScope {
4382 Object tree;
4383 public Object getTree() { return tree; }
4384 };
4385
4386
4387
4388 public final SwiftParser.outputDate_return outputDate() throws RecognitionException {
4389 SwiftParser.outputDate_return retval = new SwiftParser.outputDate_return();
4390 retval.start = input.LT(1);
4391
4392 Object root_0 = null;
4393
4394 Token NUMBER182=null;
4395 Token NUMBER183=null;
4396 Token NUMBER184=null;
4397 Token NUMBER185=null;
4398 Token NUMBER186=null;
4399 Token NUMBER187=null;
4400
4401 Object NUMBER182_tree=null;
4402 Object NUMBER183_tree=null;
4403 Object NUMBER184_tree=null;
4404 Object NUMBER185_tree=null;
4405 Object NUMBER186_tree=null;
4406 Object NUMBER187_tree=null;
4407
4408 try {
4409
4410
4411 {
4412 root_0 = (Object)adaptor.nil();
4413
4414 NUMBER182=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputDate1332);
4415 NUMBER182_tree = (Object)adaptor.create(NUMBER182);
4416 adaptor.addChild(root_0, NUMBER182_tree);
4417
4418 NUMBER183=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputDate1334);
4419 NUMBER183_tree = (Object)adaptor.create(NUMBER183);
4420 adaptor.addChild(root_0, NUMBER183_tree);
4421
4422 NUMBER184=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputDate1336);
4423 NUMBER184_tree = (Object)adaptor.create(NUMBER184);
4424 adaptor.addChild(root_0, NUMBER184_tree);
4425
4426 NUMBER185=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputDate1338);
4427 NUMBER185_tree = (Object)adaptor.create(NUMBER185);
4428 adaptor.addChild(root_0, NUMBER185_tree);
4429
4430 NUMBER186=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputDate1340);
4431 NUMBER186_tree = (Object)adaptor.create(NUMBER186);
4432 adaptor.addChild(root_0, NUMBER186_tree);
4433
4434 NUMBER187=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputDate1342);
4435 NUMBER187_tree = (Object)adaptor.create(NUMBER187);
4436 adaptor.addChild(root_0, NUMBER187_tree);
4437
4438
4439 }
4440
4441 retval.stop = input.LT(-1);
4442
4443 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4444 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4445
4446 }
4447
4448 catch (RecognitionException re) {
4449 throw re;
4450 }
4451 finally {
4452 }
4453 return retval;
4454 }
4455
4456
4457 public static class outputTime_return extends ParserRuleReturnScope {
4458 Object tree;
4459 public Object getTree() { return tree; }
4460 };
4461
4462
4463
4464 public final SwiftParser.outputTime_return outputTime() throws RecognitionException {
4465 SwiftParser.outputTime_return retval = new SwiftParser.outputTime_return();
4466 retval.start = input.LT(1);
4467
4468 Object root_0 = null;
4469
4470 Token NUMBER188=null;
4471 Token NUMBER189=null;
4472 Token NUMBER190=null;
4473 Token NUMBER191=null;
4474
4475 Object NUMBER188_tree=null;
4476 Object NUMBER189_tree=null;
4477 Object NUMBER190_tree=null;
4478 Object NUMBER191_tree=null;
4479
4480 try {
4481
4482
4483 {
4484 root_0 = (Object)adaptor.nil();
4485
4486 NUMBER188=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputTime1354);
4487 NUMBER188_tree = (Object)adaptor.create(NUMBER188);
4488 adaptor.addChild(root_0, NUMBER188_tree);
4489
4490 NUMBER189=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputTime1356);
4491 NUMBER189_tree = (Object)adaptor.create(NUMBER189);
4492 adaptor.addChild(root_0, NUMBER189_tree);
4493
4494 NUMBER190=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputTime1358);
4495 NUMBER190_tree = (Object)adaptor.create(NUMBER190);
4496 adaptor.addChild(root_0, NUMBER190_tree);
4497
4498 NUMBER191=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_outputTime1360);
4499 NUMBER191_tree = (Object)adaptor.create(NUMBER191);
4500 adaptor.addChild(root_0, NUMBER191_tree);
4501
4502
4503 }
4504
4505 retval.stop = input.LT(-1);
4506
4507 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4508 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4509
4510 }
4511
4512 catch (RecognitionException re) {
4513 throw re;
4514 }
4515 finally {
4516 }
4517 return retval;
4518 }
4519
4520
4521 public static class applicationId_return extends ParserRuleReturnScope {
4522 Object tree;
4523 public Object getTree() { return tree; }
4524 };
4525
4526
4527
4528 public final SwiftParser.applicationId_return applicationId() throws RecognitionException {
4529 SwiftParser.applicationId_return retval = new SwiftParser.applicationId_return();
4530 retval.start = input.LT(1);
4531
4532 Object root_0 = null;
4533
4534 Token UPPERCASE_LETTER192=null;
4535
4536 Object UPPERCASE_LETTER192_tree=null;
4537
4538 try {
4539
4540
4541 {
4542 root_0 = (Object)adaptor.nil();
4543
4544 UPPERCASE_LETTER192=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_applicationId1372);
4545 UPPERCASE_LETTER192_tree = (Object)adaptor.create(UPPERCASE_LETTER192);
4546 adaptor.addChild(root_0, UPPERCASE_LETTER192_tree);
4547
4548
4549 }
4550
4551 retval.stop = input.LT(-1);
4552
4553 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4554 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4555
4556 }
4557
4558 catch (RecognitionException re) {
4559 throw re;
4560 }
4561 finally {
4562 }
4563 return retval;
4564 }
4565
4566
4567 public static class serviceId_return extends ParserRuleReturnScope {
4568 Object tree;
4569 public Object getTree() { return tree; }
4570 };
4571
4572
4573
4574 public final SwiftParser.serviceId_return serviceId() throws RecognitionException {
4575 SwiftParser.serviceId_return retval = new SwiftParser.serviceId_return();
4576 retval.start = input.LT(1);
4577
4578 Object root_0 = null;
4579
4580 Token NUMBER193=null;
4581 Token NUMBER194=null;
4582
4583 Object NUMBER193_tree=null;
4584 Object NUMBER194_tree=null;
4585
4586 try {
4587
4588
4589 {
4590 root_0 = (Object)adaptor.nil();
4591
4592 NUMBER193=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_serviceId1382);
4593 NUMBER193_tree = (Object)adaptor.create(NUMBER193);
4594 adaptor.addChild(root_0, NUMBER193_tree);
4595
4596 NUMBER194=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_serviceId1384);
4597 NUMBER194_tree = (Object)adaptor.create(NUMBER194);
4598 adaptor.addChild(root_0, NUMBER194_tree);
4599
4600
4601 }
4602
4603 retval.stop = input.LT(-1);
4604
4605 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4606 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4607
4608 }
4609
4610 catch (RecognitionException re) {
4611 throw re;
4612 }
4613 finally {
4614 }
4615 return retval;
4616 }
4617
4618
4619 public static class logicalTerminalAddress_return extends ParserRuleReturnScope {
4620 Object tree;
4621 public Object getTree() { return tree; }
4622 };
4623
4624
4625
4626 public final SwiftParser.logicalTerminalAddress_return logicalTerminalAddress() throws RecognitionException {
4627 SwiftParser.logicalTerminalAddress_return retval = new SwiftParser.logicalTerminalAddress_return();
4628 retval.start = input.LT(1);
4629
4630 Object root_0 = null;
4631
4632 Token UPPERCASE_LETTER195=null;
4633 Token UPPERCASE_LETTER196=null;
4634 Token UPPERCASE_LETTER197=null;
4635 Token UPPERCASE_LETTER198=null;
4636 Token UPPERCASE_LETTER199=null;
4637 Token UPPERCASE_LETTER200=null;
4638 Token UPPERCASE_LETTER201=null;
4639 Token UPPERCASE_LETTER202=null;
4640 Token UPPERCASE_LETTER203=null;
4641 Token UPPERCASE_LETTER204=null;
4642 Token UPPERCASE_LETTER205=null;
4643 Token UPPERCASE_LETTER206=null;
4644
4645 Object UPPERCASE_LETTER195_tree=null;
4646 Object UPPERCASE_LETTER196_tree=null;
4647 Object UPPERCASE_LETTER197_tree=null;
4648 Object UPPERCASE_LETTER198_tree=null;
4649 Object UPPERCASE_LETTER199_tree=null;
4650 Object UPPERCASE_LETTER200_tree=null;
4651 Object UPPERCASE_LETTER201_tree=null;
4652 Object UPPERCASE_LETTER202_tree=null;
4653 Object UPPERCASE_LETTER203_tree=null;
4654 Object UPPERCASE_LETTER204_tree=null;
4655 Object UPPERCASE_LETTER205_tree=null;
4656 Object UPPERCASE_LETTER206_tree=null;
4657
4658 try {
4659
4660
4661 {
4662 root_0 = (Object)adaptor.nil();
4663
4664 UPPERCASE_LETTER195=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1395);
4665 UPPERCASE_LETTER195_tree = (Object)adaptor.create(UPPERCASE_LETTER195);
4666 adaptor.addChild(root_0, UPPERCASE_LETTER195_tree);
4667
4668 UPPERCASE_LETTER196=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1397);
4669 UPPERCASE_LETTER196_tree = (Object)adaptor.create(UPPERCASE_LETTER196);
4670 adaptor.addChild(root_0, UPPERCASE_LETTER196_tree);
4671
4672 UPPERCASE_LETTER197=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1399);
4673 UPPERCASE_LETTER197_tree = (Object)adaptor.create(UPPERCASE_LETTER197);
4674 adaptor.addChild(root_0, UPPERCASE_LETTER197_tree);
4675
4676 UPPERCASE_LETTER198=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1404);
4677 UPPERCASE_LETTER198_tree = (Object)adaptor.create(UPPERCASE_LETTER198);
4678 adaptor.addChild(root_0, UPPERCASE_LETTER198_tree);
4679
4680 UPPERCASE_LETTER199=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1406);
4681 UPPERCASE_LETTER199_tree = (Object)adaptor.create(UPPERCASE_LETTER199);
4682 adaptor.addChild(root_0, UPPERCASE_LETTER199_tree);
4683
4684 UPPERCASE_LETTER200=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1408);
4685 UPPERCASE_LETTER200_tree = (Object)adaptor.create(UPPERCASE_LETTER200);
4686 adaptor.addChild(root_0, UPPERCASE_LETTER200_tree);
4687
4688 UPPERCASE_LETTER201=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1413);
4689 UPPERCASE_LETTER201_tree = (Object)adaptor.create(UPPERCASE_LETTER201);
4690 adaptor.addChild(root_0, UPPERCASE_LETTER201_tree);
4691
4692 UPPERCASE_LETTER202=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1415);
4693 UPPERCASE_LETTER202_tree = (Object)adaptor.create(UPPERCASE_LETTER202);
4694 adaptor.addChild(root_0, UPPERCASE_LETTER202_tree);
4695
4696 UPPERCASE_LETTER203=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1417);
4697 UPPERCASE_LETTER203_tree = (Object)adaptor.create(UPPERCASE_LETTER203);
4698 adaptor.addChild(root_0, UPPERCASE_LETTER203_tree);
4699
4700 UPPERCASE_LETTER204=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1422);
4701 UPPERCASE_LETTER204_tree = (Object)adaptor.create(UPPERCASE_LETTER204);
4702 adaptor.addChild(root_0, UPPERCASE_LETTER204_tree);
4703
4704 UPPERCASE_LETTER205=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1424);
4705 UPPERCASE_LETTER205_tree = (Object)adaptor.create(UPPERCASE_LETTER205);
4706 adaptor.addChild(root_0, UPPERCASE_LETTER205_tree);
4707
4708 UPPERCASE_LETTER206=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1426);
4709 UPPERCASE_LETTER206_tree = (Object)adaptor.create(UPPERCASE_LETTER206);
4710 adaptor.addChild(root_0, UPPERCASE_LETTER206_tree);
4711
4712
4713 }
4714
4715 retval.stop = input.LT(-1);
4716
4717 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4718 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4719
4720 }
4721
4722 catch (RecognitionException re) {
4723 throw re;
4724 }
4725 finally {
4726 }
4727 return retval;
4728 }
4729
4730
4731 public static class sessionNumber_return extends ParserRuleReturnScope {
4732 Object tree;
4733 public Object getTree() { return tree; }
4734 };
4735
4736
4737
4738 public final SwiftParser.sessionNumber_return sessionNumber() throws RecognitionException {
4739 SwiftParser.sessionNumber_return retval = new SwiftParser.sessionNumber_return();
4740 retval.start = input.LT(1);
4741
4742 Object root_0 = null;
4743
4744 Token NUMBER207=null;
4745 Token NUMBER208=null;
4746 Token NUMBER209=null;
4747 Token NUMBER210=null;
4748
4749 Object NUMBER207_tree=null;
4750 Object NUMBER208_tree=null;
4751 Object NUMBER209_tree=null;
4752 Object NUMBER210_tree=null;
4753
4754 try {
4755
4756
4757 {
4758 root_0 = (Object)adaptor.nil();
4759
4760 NUMBER207=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sessionNumber1439);
4761 NUMBER207_tree = (Object)adaptor.create(NUMBER207);
4762 adaptor.addChild(root_0, NUMBER207_tree);
4763
4764 NUMBER208=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sessionNumber1441);
4765 NUMBER208_tree = (Object)adaptor.create(NUMBER208);
4766 adaptor.addChild(root_0, NUMBER208_tree);
4767
4768 NUMBER209=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sessionNumber1443);
4769 NUMBER209_tree = (Object)adaptor.create(NUMBER209);
4770 adaptor.addChild(root_0, NUMBER209_tree);
4771
4772 NUMBER210=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sessionNumber1445);
4773 NUMBER210_tree = (Object)adaptor.create(NUMBER210);
4774 adaptor.addChild(root_0, NUMBER210_tree);
4775
4776
4777 }
4778
4779 retval.stop = input.LT(-1);
4780
4781 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4782 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4783
4784 }
4785
4786 catch (RecognitionException re) {
4787 throw re;
4788 }
4789 finally {
4790 }
4791 return retval;
4792 }
4793
4794
4795 public static class sequenceNumber_return extends ParserRuleReturnScope {
4796 Object tree;
4797 public Object getTree() { return tree; }
4798 };
4799
4800
4801
4802 public final SwiftParser.sequenceNumber_return sequenceNumber() throws RecognitionException {
4803 SwiftParser.sequenceNumber_return retval = new SwiftParser.sequenceNumber_return();
4804 retval.start = input.LT(1);
4805
4806 Object root_0 = null;
4807
4808 Token NUMBER211=null;
4809 Token NUMBER212=null;
4810 Token NUMBER213=null;
4811 Token NUMBER214=null;
4812 Token NUMBER215=null;
4813 Token NUMBER216=null;
4814
4815 Object NUMBER211_tree=null;
4816 Object NUMBER212_tree=null;
4817 Object NUMBER213_tree=null;
4818 Object NUMBER214_tree=null;
4819 Object NUMBER215_tree=null;
4820 Object NUMBER216_tree=null;
4821
4822 try {
4823
4824
4825 {
4826 root_0 = (Object)adaptor.nil();
4827
4828 NUMBER211=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sequenceNumber1456);
4829 NUMBER211_tree = (Object)adaptor.create(NUMBER211);
4830 adaptor.addChild(root_0, NUMBER211_tree);
4831
4832 NUMBER212=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sequenceNumber1458);
4833 NUMBER212_tree = (Object)adaptor.create(NUMBER212);
4834 adaptor.addChild(root_0, NUMBER212_tree);
4835
4836 NUMBER213=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sequenceNumber1460);
4837 NUMBER213_tree = (Object)adaptor.create(NUMBER213);
4838 adaptor.addChild(root_0, NUMBER213_tree);
4839
4840 NUMBER214=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sequenceNumber1464);
4841 NUMBER214_tree = (Object)adaptor.create(NUMBER214);
4842 adaptor.addChild(root_0, NUMBER214_tree);
4843
4844 NUMBER215=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sequenceNumber1466);
4845 NUMBER215_tree = (Object)adaptor.create(NUMBER215);
4846 adaptor.addChild(root_0, NUMBER215_tree);
4847
4848 NUMBER216=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_sequenceNumber1468);
4849 NUMBER216_tree = (Object)adaptor.create(NUMBER216);
4850 adaptor.addChild(root_0, NUMBER216_tree);
4851
4852
4853 }
4854
4855 retval.stop = input.LT(-1);
4856
4857 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4858 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4859
4860 }
4861
4862 catch (RecognitionException re) {
4863 throw re;
4864 }
4865 finally {
4866 }
4867 return retval;
4868 }
4869
4870
4871 public static class code_return extends ParserRuleReturnScope {
4872 Object tree;
4873 public Object getTree() { return tree; }
4874 };
4875
4876
4877
4878 public final SwiftParser.code_return code() throws RecognitionException {
4879 SwiftParser.code_return retval = new SwiftParser.code_return();
4880 retval.start = input.LT(1);
4881
4882 Object root_0 = null;
4883
4884 Token UPPERCASE_LETTER217=null;
4885
4886 Object UPPERCASE_LETTER217_tree=null;
4887
4888 try {
4889
4890
4891 {
4892 root_0 = (Object)adaptor.nil();
4893
4894
4895 int cnt20=0;
4896 loop20:
4897 do {
4898 int alt20=2;
4899 int LA20_0 = input.LA(1);
4900
4901 if ( (LA20_0==UPPERCASE_LETTER) ) {
4902 alt20=1;
4903 }
4904
4905
4906 switch (alt20) {
4907 case 1 :
4908
4909 {
4910 UPPERCASE_LETTER217=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_code1480);
4911 UPPERCASE_LETTER217_tree = (Object)adaptor.create(UPPERCASE_LETTER217);
4912 adaptor.addChild(root_0, UPPERCASE_LETTER217_tree);
4913
4914
4915 }
4916 break;
4917
4918 default :
4919 if ( cnt20 >= 1 ) break loop20;
4920 EarlyExitException eee =
4921 new EarlyExitException(20, input);
4922 throw eee;
4923 }
4924 cnt20++;
4925 } while (true);
4926
4927
4928 }
4929
4930 retval.stop = input.LT(-1);
4931
4932 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4933 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4934
4935 }
4936
4937 catch (RecognitionException re) {
4938 throw re;
4939 }
4940 finally {
4941 }
4942 return retval;
4943 }
4944
4945
4946 public static class timeIndication_return extends ParserRuleReturnScope {
4947 Object tree;
4948 public Object getTree() { return tree; }
4949 };
4950
4951
4952
4953 public final SwiftParser.timeIndication_return timeIndication() throws RecognitionException {
4954 SwiftParser.timeIndication_return retval = new SwiftParser.timeIndication_return();
4955 retval.start = input.LT(1);
4956
4957 Object root_0 = null;
4958
4959 Token NUMBER218=null;
4960 Token NUMBER219=null;
4961 Token NUMBER220=null;
4962 Token NUMBER221=null;
4963
4964 Object NUMBER218_tree=null;
4965 Object NUMBER219_tree=null;
4966 Object NUMBER220_tree=null;
4967 Object NUMBER221_tree=null;
4968
4969 try {
4970
4971
4972 {
4973 root_0 = (Object)adaptor.nil();
4974
4975 NUMBER218=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_timeIndication1492);
4976 NUMBER218_tree = (Object)adaptor.create(NUMBER218);
4977 adaptor.addChild(root_0, NUMBER218_tree);
4978
4979 NUMBER219=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_timeIndication1494);
4980 NUMBER219_tree = (Object)adaptor.create(NUMBER219);
4981 adaptor.addChild(root_0, NUMBER219_tree);
4982
4983 NUMBER220=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_timeIndication1496);
4984 NUMBER220_tree = (Object)adaptor.create(NUMBER220);
4985 adaptor.addChild(root_0, NUMBER220_tree);
4986
4987 NUMBER221=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_timeIndication1498);
4988 NUMBER221_tree = (Object)adaptor.create(NUMBER221);
4989 adaptor.addChild(root_0, NUMBER221_tree);
4990
4991
4992 }
4993
4994 retval.stop = input.LT(-1);
4995
4996 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
4997 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4998
4999 }
5000
5001 catch (RecognitionException re) {
5002 throw re;
5003 }
5004 finally {
5005 }
5006 return retval;
5007 }
5008
5009
5010 public static class sign_return extends ParserRuleReturnScope {
5011 Object tree;
5012 public Object getTree() { return tree; }
5013 };
5014
5015
5016
5017 public final SwiftParser.sign_return sign() throws RecognitionException {
5018 SwiftParser.sign_return retval = new SwiftParser.sign_return();
5019 retval.start = input.LT(1);
5020
5021 Object root_0 = null;
5022
5023 Token set222=null;
5024
5025 Object set222_tree=null;
5026
5027 try {
5028
5029
5030 {
5031 root_0 = (Object)adaptor.nil();
5032
5033 set222=(Token)input.LT(1);
5034 if ( (input.LA(1)>=PLUS && input.LA(1)<=MINUS) ) {
5035 input.consume();
5036 adaptor.addChild(root_0, (Object)adaptor.create(set222));
5037 state.errorRecovery=false;
5038 }
5039 else {
5040 MismatchedSetException mse = new MismatchedSetException(null,input);
5041 throw mse;
5042 }
5043
5044
5045 }
5046
5047 retval.stop = input.LT(-1);
5048
5049 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5050 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5051
5052 }
5053
5054 catch (RecognitionException re) {
5055 throw re;
5056 }
5057 finally {
5058 }
5059 return retval;
5060 }
5061
5062
5063 public static class timeOffset_return extends ParserRuleReturnScope {
5064 Object tree;
5065 public Object getTree() { return tree; }
5066 };
5067
5068
5069
5070 public final SwiftParser.timeOffset_return timeOffset() throws RecognitionException {
5071 SwiftParser.timeOffset_return retval = new SwiftParser.timeOffset_return();
5072 retval.start = input.LT(1);
5073
5074 Object root_0 = null;
5075
5076 Token NUMBER223=null;
5077 Token NUMBER224=null;
5078 Token NUMBER225=null;
5079 Token NUMBER226=null;
5080
5081 Object NUMBER223_tree=null;
5082 Object NUMBER224_tree=null;
5083 Object NUMBER225_tree=null;
5084 Object NUMBER226_tree=null;
5085
5086 try {
5087
5088
5089 {
5090 root_0 = (Object)adaptor.nil();
5091
5092 NUMBER223=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_timeOffset1524);
5093 NUMBER223_tree = (Object)adaptor.create(NUMBER223);
5094 adaptor.addChild(root_0, NUMBER223_tree);
5095
5096 NUMBER224=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_timeOffset1526);
5097 NUMBER224_tree = (Object)adaptor.create(NUMBER224);
5098 adaptor.addChild(root_0, NUMBER224_tree);
5099
5100 NUMBER225=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_timeOffset1528);
5101 NUMBER225_tree = (Object)adaptor.create(NUMBER225);
5102 adaptor.addChild(root_0, NUMBER225_tree);
5103
5104 NUMBER226=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_timeOffset1530);
5105 NUMBER226_tree = (Object)adaptor.create(NUMBER226);
5106 adaptor.addChild(root_0, NUMBER226_tree);
5107
5108
5109 }
5110
5111 retval.stop = input.LT(-1);
5112
5113 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5114 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5115
5116 }
5117
5118 catch (RecognitionException re) {
5119 throw re;
5120 }
5121 finally {
5122 }
5123 return retval;
5124 }
5125
5126
5127 public static class senderReference_return extends ParserRuleReturnScope {
5128 Object tree;
5129 public Object getTree() { return tree; }
5130 };
5131
5132
5133
5134 public final SwiftParser.senderReference_return senderReference() throws RecognitionException {
5135 SwiftParser.senderReference_return retval = new SwiftParser.senderReference_return();
5136 retval.start = input.LT(1);
5137
5138 Object root_0 = null;
5139
5140 Token set227=null;
5141
5142 Object set227_tree=null;
5143
5144 try {
5145
5146
5147 {
5148 root_0 = (Object)adaptor.nil();
5149
5150
5151 int cnt21=0;
5152 loop21:
5153 do {
5154 int alt21=2;
5155 int LA21_0 = input.LA(1);
5156
5157 if ( ((LA21_0>=UPPERCASE_LETTER && LA21_0<=NUMBER)||LA21_0==SPECIAL_LETTER) ) {
5158 alt21=1;
5159 }
5160
5161
5162 switch (alt21) {
5163 case 1 :
5164
5165 {
5166 set227=(Token)input.LT(1);
5167 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER)||input.LA(1)==SPECIAL_LETTER ) {
5168 input.consume();
5169 adaptor.addChild(root_0, (Object)adaptor.create(set227));
5170 state.errorRecovery=false;
5171 }
5172 else {
5173 MismatchedSetException mse = new MismatchedSetException(null,input);
5174 throw mse;
5175 }
5176
5177
5178 }
5179 break;
5180
5181 default :
5182 if ( cnt21 >= 1 ) break loop21;
5183 EarlyExitException eee =
5184 new EarlyExitException(21, input);
5185 throw eee;
5186 }
5187 cnt21++;
5188 } while (true);
5189
5190
5191 }
5192
5193 retval.stop = input.LT(-1);
5194
5195 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5196 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5197
5198 }
5199
5200 catch (RecognitionException re) {
5201 throw re;
5202 }
5203 finally {
5204 }
5205 return retval;
5206 }
5207
5208
5209 public static class bankOperationCode_return extends ParserRuleReturnScope {
5210 Object tree;
5211 public Object getTree() { return tree; }
5212 };
5213
5214
5215
5216 public final SwiftParser.bankOperationCode_return bankOperationCode() throws RecognitionException {
5217 SwiftParser.bankOperationCode_return retval = new SwiftParser.bankOperationCode_return();
5218 retval.start = input.LT(1);
5219
5220 Object root_0 = null;
5221
5222 Token UPPERCASE_LETTER228=null;
5223 Token UPPERCASE_LETTER229=null;
5224 Token UPPERCASE_LETTER230=null;
5225 Token UPPERCASE_LETTER231=null;
5226
5227 Object UPPERCASE_LETTER228_tree=null;
5228 Object UPPERCASE_LETTER229_tree=null;
5229 Object UPPERCASE_LETTER230_tree=null;
5230 Object UPPERCASE_LETTER231_tree=null;
5231
5232 try {
5233
5234
5235 {
5236 root_0 = (Object)adaptor.nil();
5237
5238 UPPERCASE_LETTER228=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bankOperationCode1568);
5239 UPPERCASE_LETTER228_tree = (Object)adaptor.create(UPPERCASE_LETTER228);
5240 adaptor.addChild(root_0, UPPERCASE_LETTER228_tree);
5241
5242 UPPERCASE_LETTER229=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bankOperationCode1570);
5243 UPPERCASE_LETTER229_tree = (Object)adaptor.create(UPPERCASE_LETTER229);
5244 adaptor.addChild(root_0, UPPERCASE_LETTER229_tree);
5245
5246 UPPERCASE_LETTER230=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bankOperationCode1572);
5247 UPPERCASE_LETTER230_tree = (Object)adaptor.create(UPPERCASE_LETTER230);
5248 adaptor.addChild(root_0, UPPERCASE_LETTER230_tree);
5249
5250 UPPERCASE_LETTER231=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bankOperationCode1574);
5251 UPPERCASE_LETTER231_tree = (Object)adaptor.create(UPPERCASE_LETTER231);
5252 adaptor.addChild(root_0, UPPERCASE_LETTER231_tree);
5253
5254
5255 }
5256
5257 retval.stop = input.LT(-1);
5258
5259 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5260 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5261
5262 }
5263
5264 catch (RecognitionException re) {
5265 throw re;
5266 }
5267 finally {
5268 }
5269 return retval;
5270 }
5271
5272
5273 public static class instruction_return extends ParserRuleReturnScope {
5274 Object tree;
5275 public Object getTree() { return tree; }
5276 };
5277
5278
5279
5280 public final SwiftParser.instruction_return instruction() throws RecognitionException {
5281 SwiftParser.instruction_return retval = new SwiftParser.instruction_return();
5282 retval.start = input.LT(1);
5283
5284 Object root_0 = null;
5285
5286 Token UPPERCASE_LETTER232=null;
5287 Token UPPERCASE_LETTER233=null;
5288 Token UPPERCASE_LETTER234=null;
5289 Token UPPERCASE_LETTER235=null;
5290
5291 Object UPPERCASE_LETTER232_tree=null;
5292 Object UPPERCASE_LETTER233_tree=null;
5293 Object UPPERCASE_LETTER234_tree=null;
5294 Object UPPERCASE_LETTER235_tree=null;
5295
5296 try {
5297
5298
5299 {
5300 root_0 = (Object)adaptor.nil();
5301
5302 UPPERCASE_LETTER232=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_instruction1586);
5303 UPPERCASE_LETTER232_tree = (Object)adaptor.create(UPPERCASE_LETTER232);
5304 adaptor.addChild(root_0, UPPERCASE_LETTER232_tree);
5305
5306 UPPERCASE_LETTER233=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_instruction1588);
5307 UPPERCASE_LETTER233_tree = (Object)adaptor.create(UPPERCASE_LETTER233);
5308 adaptor.addChild(root_0, UPPERCASE_LETTER233_tree);
5309
5310 UPPERCASE_LETTER234=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_instruction1590);
5311 UPPERCASE_LETTER234_tree = (Object)adaptor.create(UPPERCASE_LETTER234);
5312 adaptor.addChild(root_0, UPPERCASE_LETTER234_tree);
5313
5314 UPPERCASE_LETTER235=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_instruction1592);
5315 UPPERCASE_LETTER235_tree = (Object)adaptor.create(UPPERCASE_LETTER235);
5316 adaptor.addChild(root_0, UPPERCASE_LETTER235_tree);
5317
5318
5319 }
5320
5321 retval.stop = input.LT(-1);
5322
5323 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5324 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5325
5326 }
5327
5328 catch (RecognitionException re) {
5329 throw re;
5330 }
5331 finally {
5332 }
5333 return retval;
5334 }
5335
5336
5337 public static class additionalInformation_return extends ParserRuleReturnScope {
5338 Object tree;
5339 public Object getTree() { return tree; }
5340 };
5341
5342
5343
5344 public final SwiftParser.additionalInformation_return additionalInformation() throws RecognitionException {
5345 SwiftParser.additionalInformation_return retval = new SwiftParser.additionalInformation_return();
5346 retval.start = input.LT(1);
5347
5348 Object root_0 = null;
5349
5350 Token set236=null;
5351
5352 Object set236_tree=null;
5353
5354 try {
5355
5356
5357 {
5358 root_0 = (Object)adaptor.nil();
5359
5360
5361 int cnt22=0;
5362 loop22:
5363 do {
5364 int alt22=2;
5365 int LA22_0 = input.LA(1);
5366
5367 if ( ((LA22_0>=UPPERCASE_LETTER && LA22_0<=NUMBER)) ) {
5368 alt22=1;
5369 }
5370
5371
5372 switch (alt22) {
5373 case 1 :
5374
5375 {
5376 set236=(Token)input.LT(1);
5377 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER) ) {
5378 input.consume();
5379 adaptor.addChild(root_0, (Object)adaptor.create(set236));
5380 state.errorRecovery=false;
5381 }
5382 else {
5383 MismatchedSetException mse = new MismatchedSetException(null,input);
5384 throw mse;
5385 }
5386
5387
5388 }
5389 break;
5390
5391 default :
5392 if ( cnt22 >= 1 ) break loop22;
5393 EarlyExitException eee =
5394 new EarlyExitException(22, input);
5395 throw eee;
5396 }
5397 cnt22++;
5398 } while (true);
5399
5400
5401 }
5402
5403 retval.stop = input.LT(-1);
5404
5405 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5406 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5407
5408 }
5409
5410 catch (RecognitionException re) {
5411 throw re;
5412 }
5413 finally {
5414 }
5415 return retval;
5416 }
5417
5418
5419 public static class transactionTypeCode_return extends ParserRuleReturnScope {
5420 Object tree;
5421 public Object getTree() { return tree; }
5422 };
5423
5424
5425
5426 public final SwiftParser.transactionTypeCode_return transactionTypeCode() throws RecognitionException {
5427 SwiftParser.transactionTypeCode_return retval = new SwiftParser.transactionTypeCode_return();
5428 retval.start = input.LT(1);
5429
5430 Object root_0 = null;
5431
5432 Token set237=null;
5433 Token set238=null;
5434 Token set239=null;
5435
5436 Object set237_tree=null;
5437 Object set238_tree=null;
5438 Object set239_tree=null;
5439
5440 try {
5441
5442
5443 {
5444 root_0 = (Object)adaptor.nil();
5445
5446 set237=(Token)input.LT(1);
5447 if ( input.LA(1)==UPPERCASE_LETTER||input.LA(1)==NUMBER ) {
5448 input.consume();
5449 adaptor.addChild(root_0, (Object)adaptor.create(set237));
5450 state.errorRecovery=false;
5451 }
5452 else {
5453 MismatchedSetException mse = new MismatchedSetException(null,input);
5454 throw mse;
5455 }
5456
5457 set238=(Token)input.LT(1);
5458 if ( input.LA(1)==UPPERCASE_LETTER||input.LA(1)==NUMBER ) {
5459 input.consume();
5460 adaptor.addChild(root_0, (Object)adaptor.create(set238));
5461 state.errorRecovery=false;
5462 }
5463 else {
5464 MismatchedSetException mse = new MismatchedSetException(null,input);
5465 throw mse;
5466 }
5467
5468 set239=(Token)input.LT(1);
5469 if ( input.LA(1)==UPPERCASE_LETTER||input.LA(1)==NUMBER ) {
5470 input.consume();
5471 adaptor.addChild(root_0, (Object)adaptor.create(set239));
5472 state.errorRecovery=false;
5473 }
5474 else {
5475 MismatchedSetException mse = new MismatchedSetException(null,input);
5476 throw mse;
5477 }
5478
5479
5480 }
5481
5482 retval.stop = input.LT(-1);
5483
5484 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5485 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5486
5487 }
5488
5489 catch (RecognitionException re) {
5490 throw re;
5491 }
5492 finally {
5493 }
5494 return retval;
5495 }
5496
5497
5498 public static class valueDate_return extends ParserRuleReturnScope {
5499 Object tree;
5500 public Object getTree() { return tree; }
5501 };
5502
5503
5504
5505 public final SwiftParser.valueDate_return valueDate() throws RecognitionException {
5506 SwiftParser.valueDate_return retval = new SwiftParser.valueDate_return();
5507 retval.start = input.LT(1);
5508
5509 Object root_0 = null;
5510
5511 Token NUMBER240=null;
5512 Token NUMBER241=null;
5513 Token NUMBER242=null;
5514 Token NUMBER243=null;
5515 Token NUMBER244=null;
5516 Token NUMBER245=null;
5517
5518 Object NUMBER240_tree=null;
5519 Object NUMBER241_tree=null;
5520 Object NUMBER242_tree=null;
5521 Object NUMBER243_tree=null;
5522 Object NUMBER244_tree=null;
5523 Object NUMBER245_tree=null;
5524
5525 try {
5526
5527
5528 {
5529 root_0 = (Object)adaptor.nil();
5530
5531 NUMBER240=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_valueDate1664);
5532 NUMBER240_tree = (Object)adaptor.create(NUMBER240);
5533 adaptor.addChild(root_0, NUMBER240_tree);
5534
5535 NUMBER241=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_valueDate1666);
5536 NUMBER241_tree = (Object)adaptor.create(NUMBER241);
5537 adaptor.addChild(root_0, NUMBER241_tree);
5538
5539 NUMBER242=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_valueDate1668);
5540 NUMBER242_tree = (Object)adaptor.create(NUMBER242);
5541 adaptor.addChild(root_0, NUMBER242_tree);
5542
5543 NUMBER243=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_valueDate1672);
5544 NUMBER243_tree = (Object)adaptor.create(NUMBER243);
5545 adaptor.addChild(root_0, NUMBER243_tree);
5546
5547 NUMBER244=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_valueDate1674);
5548 NUMBER244_tree = (Object)adaptor.create(NUMBER244);
5549 adaptor.addChild(root_0, NUMBER244_tree);
5550
5551 NUMBER245=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_valueDate1676);
5552 NUMBER245_tree = (Object)adaptor.create(NUMBER245);
5553 adaptor.addChild(root_0, NUMBER245_tree);
5554
5555
5556 }
5557
5558 retval.stop = input.LT(-1);
5559
5560 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5561 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5562
5563 }
5564
5565 catch (RecognitionException re) {
5566 throw re;
5567 }
5568 finally {
5569 }
5570 return retval;
5571 }
5572
5573
5574 public static class currency_return extends ParserRuleReturnScope {
5575 Object tree;
5576 public Object getTree() { return tree; }
5577 };
5578
5579
5580
5581 public final SwiftParser.currency_return currency() throws RecognitionException {
5582 SwiftParser.currency_return retval = new SwiftParser.currency_return();
5583 retval.start = input.LT(1);
5584
5585 Object root_0 = null;
5586
5587 Token UPPERCASE_LETTER246=null;
5588 Token UPPERCASE_LETTER247=null;
5589 Token UPPERCASE_LETTER248=null;
5590
5591 Object UPPERCASE_LETTER246_tree=null;
5592 Object UPPERCASE_LETTER247_tree=null;
5593 Object UPPERCASE_LETTER248_tree=null;
5594
5595 try {
5596
5597
5598 {
5599 root_0 = (Object)adaptor.nil();
5600
5601 UPPERCASE_LETTER246=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_currency1687);
5602 UPPERCASE_LETTER246_tree = (Object)adaptor.create(UPPERCASE_LETTER246);
5603 adaptor.addChild(root_0, UPPERCASE_LETTER246_tree);
5604
5605 UPPERCASE_LETTER247=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_currency1689);
5606 UPPERCASE_LETTER247_tree = (Object)adaptor.create(UPPERCASE_LETTER247);
5607 adaptor.addChild(root_0, UPPERCASE_LETTER247_tree);
5608
5609 UPPERCASE_LETTER248=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_currency1691);
5610 UPPERCASE_LETTER248_tree = (Object)adaptor.create(UPPERCASE_LETTER248);
5611 adaptor.addChild(root_0, UPPERCASE_LETTER248_tree);
5612
5613
5614 }
5615
5616 retval.stop = input.LT(-1);
5617
5618 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5619 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5620
5621 }
5622
5623 catch (RecognitionException re) {
5624 throw re;
5625 }
5626 finally {
5627 }
5628 return retval;
5629 }
5630
5631
5632 public static class amount_return extends ParserRuleReturnScope {
5633 Object tree;
5634 public Object getTree() { return tree; }
5635 };
5636
5637
5638
5639 public final SwiftParser.amount_return amount() throws RecognitionException {
5640 SwiftParser.amount_return retval = new SwiftParser.amount_return();
5641 retval.start = input.LT(1);
5642
5643 Object root_0 = null;
5644
5645 Token NUMBER249=null;
5646 Token AMOUNT_SEPARATOR250=null;
5647 Token NUMBER251=null;
5648
5649 Object NUMBER249_tree=null;
5650 Object AMOUNT_SEPARATOR250_tree=null;
5651 Object NUMBER251_tree=null;
5652
5653 try {
5654
5655
5656 {
5657 root_0 = (Object)adaptor.nil();
5658
5659
5660 loop23:
5661 do {
5662 int alt23=2;
5663 int LA23_0 = input.LA(1);
5664
5665 if ( (LA23_0==NUMBER) ) {
5666 alt23=1;
5667 }
5668
5669
5670 switch (alt23) {
5671 case 1 :
5672
5673 {
5674 NUMBER249=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_amount1703);
5675 NUMBER249_tree = (Object)adaptor.create(NUMBER249);
5676 adaptor.addChild(root_0, NUMBER249_tree);
5677
5678
5679 }
5680 break;
5681
5682 default :
5683 break loop23;
5684 }
5685 } while (true);
5686
5687 AMOUNT_SEPARATOR250=(Token)match(input,AMOUNT_SEPARATOR,FOLLOW_AMOUNT_SEPARATOR_in_amount1707);
5688 AMOUNT_SEPARATOR250_tree = (Object)adaptor.create(AMOUNT_SEPARATOR250);
5689 adaptor.addChild(root_0, AMOUNT_SEPARATOR250_tree);
5690
5691
5692 loop24:
5693 do {
5694 int alt24=2;
5695 int LA24_0 = input.LA(1);
5696
5697 if ( (LA24_0==NUMBER) ) {
5698 alt24=1;
5699 }
5700
5701
5702 switch (alt24) {
5703 case 1 :
5704
5705 {
5706 NUMBER251=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_amount1710);
5707 NUMBER251_tree = (Object)adaptor.create(NUMBER251);
5708 adaptor.addChild(root_0, NUMBER251_tree);
5709
5710
5711 }
5712 break;
5713
5714 default :
5715 break loop24;
5716 }
5717 } while (true);
5718
5719
5720 }
5721
5722 retval.stop = input.LT(-1);
5723
5724 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5725 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5726
5727 }
5728
5729 catch (RecognitionException re) {
5730 throw re;
5731 }
5732 finally {
5733 }
5734 return retval;
5735 }
5736
5737
5738 public static class exchangeRate_return extends ParserRuleReturnScope {
5739 Object tree;
5740 public Object getTree() { return tree; }
5741 };
5742
5743
5744
5745 public final SwiftParser.exchangeRate_return exchangeRate() throws RecognitionException {
5746 SwiftParser.exchangeRate_return retval = new SwiftParser.exchangeRate_return();
5747 retval.start = input.LT(1);
5748
5749 Object root_0 = null;
5750
5751 Token NUMBER252=null;
5752 Token AMOUNT_SEPARATOR253=null;
5753 Token NUMBER254=null;
5754
5755 Object NUMBER252_tree=null;
5756 Object AMOUNT_SEPARATOR253_tree=null;
5757 Object NUMBER254_tree=null;
5758
5759 try {
5760
5761
5762 {
5763 root_0 = (Object)adaptor.nil();
5764
5765
5766 int alt25=2;
5767 int LA25_0 = input.LA(1);
5768
5769 if ( (LA25_0==NUMBER) ) {
5770 alt25=1;
5771 }
5772 switch (alt25) {
5773 case 1 :
5774
5775 {
5776 NUMBER252=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_exchangeRate1725);
5777 NUMBER252_tree = (Object)adaptor.create(NUMBER252);
5778 adaptor.addChild(root_0, NUMBER252_tree);
5779
5780
5781 }
5782 break;
5783
5784 }
5785
5786 AMOUNT_SEPARATOR253=(Token)match(input,AMOUNT_SEPARATOR,FOLLOW_AMOUNT_SEPARATOR_in_exchangeRate1729);
5787 AMOUNT_SEPARATOR253_tree = (Object)adaptor.create(AMOUNT_SEPARATOR253);
5788 adaptor.addChild(root_0, AMOUNT_SEPARATOR253_tree);
5789
5790
5791 int cnt26=0;
5792 loop26:
5793 do {
5794 int alt26=2;
5795 int LA26_0 = input.LA(1);
5796
5797 if ( (LA26_0==NUMBER) ) {
5798 alt26=1;
5799 }
5800
5801
5802 switch (alt26) {
5803 case 1 :
5804
5805 {
5806 NUMBER254=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_exchangeRate1732);
5807 NUMBER254_tree = (Object)adaptor.create(NUMBER254);
5808 adaptor.addChild(root_0, NUMBER254_tree);
5809
5810
5811 }
5812 break;
5813
5814 default :
5815 if ( cnt26 >= 1 ) break loop26;
5816 EarlyExitException eee =
5817 new EarlyExitException(26, input);
5818 throw eee;
5819 }
5820 cnt26++;
5821 } while (true);
5822
5823
5824 }
5825
5826 retval.stop = input.LT(-1);
5827
5828 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5829 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5830
5831 }
5832
5833 catch (RecognitionException re) {
5834 throw re;
5835 }
5836 finally {
5837 }
5838 return retval;
5839 }
5840
5841
5842 public static class account_return extends ParserRuleReturnScope {
5843 Object tree;
5844 public Object getTree() { return tree; }
5845 };
5846
5847
5848
5849 public final SwiftParser.account_return account() throws RecognitionException {
5850 SwiftParser.account_return retval = new SwiftParser.account_return();
5851 retval.start = input.LT(1);
5852
5853 Object root_0 = null;
5854
5855 Token set255=null;
5856
5857 Object set255_tree=null;
5858
5859 try {
5860
5861
5862 {
5863 root_0 = (Object)adaptor.nil();
5864
5865
5866 int cnt27=0;
5867 loop27:
5868 do {
5869 int alt27=2;
5870 int LA27_0 = input.LA(1);
5871
5872 if ( ((LA27_0>=UPPERCASE_LETTER && LA27_0<=NUMBER)) ) {
5873 alt27=1;
5874 }
5875
5876
5877 switch (alt27) {
5878 case 1 :
5879
5880 {
5881 set255=(Token)input.LT(1);
5882 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER) ) {
5883 input.consume();
5884 adaptor.addChild(root_0, (Object)adaptor.create(set255));
5885 state.errorRecovery=false;
5886 }
5887 else {
5888 MismatchedSetException mse = new MismatchedSetException(null,input);
5889 throw mse;
5890 }
5891
5892
5893 }
5894 break;
5895
5896 default :
5897 if ( cnt27 >= 1 ) break loop27;
5898 EarlyExitException eee =
5899 new EarlyExitException(27, input);
5900 throw eee;
5901 }
5902 cnt27++;
5903 } while (true);
5904
5905
5906 }
5907
5908 retval.stop = input.LT(-1);
5909
5910 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
5911 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5912
5913 }
5914
5915 catch (RecognitionException re) {
5916 throw re;
5917 }
5918 finally {
5919 }
5920 return retval;
5921 }
5922
5923
5924 public static class bicBai_return extends ParserRuleReturnScope {
5925 Object tree;
5926 public Object getTree() { return tree; }
5927 };
5928
5929
5930
5931 public final SwiftParser.bicBai_return bicBai() throws RecognitionException {
5932 SwiftParser.bicBai_return retval = new SwiftParser.bicBai_return();
5933 retval.start = input.LT(1);
5934
5935 Object root_0 = null;
5936
5937 Token UPPERCASE_LETTER256=null;
5938 Token UPPERCASE_LETTER257=null;
5939 Token UPPERCASE_LETTER258=null;
5940 Token UPPERCASE_LETTER259=null;
5941 Token UPPERCASE_LETTER260=null;
5942 Token UPPERCASE_LETTER261=null;
5943 Token set262=null;
5944 Token set263=null;
5945 Token set264=null;
5946 Token set265=null;
5947 Token set266=null;
5948
5949 Object UPPERCASE_LETTER256_tree=null;
5950 Object UPPERCASE_LETTER257_tree=null;
5951 Object UPPERCASE_LETTER258_tree=null;
5952 Object UPPERCASE_LETTER259_tree=null;
5953 Object UPPERCASE_LETTER260_tree=null;
5954 Object UPPERCASE_LETTER261_tree=null;
5955 Object set262_tree=null;
5956 Object set263_tree=null;
5957 Object set264_tree=null;
5958 Object set265_tree=null;
5959 Object set266_tree=null;
5960
5961 try {
5962
5963
5964 {
5965 root_0 = (Object)adaptor.nil();
5966
5967
5968
5969 {
5970 UPPERCASE_LETTER256=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bicBai1769);
5971 UPPERCASE_LETTER256_tree = (Object)adaptor.create(UPPERCASE_LETTER256);
5972 adaptor.addChild(root_0, UPPERCASE_LETTER256_tree);
5973
5974 UPPERCASE_LETTER257=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bicBai1771);
5975 UPPERCASE_LETTER257_tree = (Object)adaptor.create(UPPERCASE_LETTER257);
5976 adaptor.addChild(root_0, UPPERCASE_LETTER257_tree);
5977
5978 UPPERCASE_LETTER258=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bicBai1773);
5979 UPPERCASE_LETTER258_tree = (Object)adaptor.create(UPPERCASE_LETTER258);
5980 adaptor.addChild(root_0, UPPERCASE_LETTER258_tree);
5981
5982 UPPERCASE_LETTER259=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bicBai1778);
5983 UPPERCASE_LETTER259_tree = (Object)adaptor.create(UPPERCASE_LETTER259);
5984 adaptor.addChild(root_0, UPPERCASE_LETTER259_tree);
5985
5986 UPPERCASE_LETTER260=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bicBai1780);
5987 UPPERCASE_LETTER260_tree = (Object)adaptor.create(UPPERCASE_LETTER260);
5988 adaptor.addChild(root_0, UPPERCASE_LETTER260_tree);
5989
5990 UPPERCASE_LETTER261=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_bicBai1782);
5991 UPPERCASE_LETTER261_tree = (Object)adaptor.create(UPPERCASE_LETTER261);
5992 adaptor.addChild(root_0, UPPERCASE_LETTER261_tree);
5993
5994
5995 }
5996
5997
5998
5999 {
6000 set262=(Token)input.LT(1);
6001 if ( input.LA(1)==UPPERCASE_LETTER||input.LA(1)==NUMBER ) {
6002 input.consume();
6003 adaptor.addChild(root_0, (Object)adaptor.create(set262));
6004 state.errorRecovery=false;
6005 }
6006 else {
6007 MismatchedSetException mse = new MismatchedSetException(null,input);
6008 throw mse;
6009 }
6010
6011 set263=(Token)input.LT(1);
6012 if ( input.LA(1)==UPPERCASE_LETTER||input.LA(1)==NUMBER ) {
6013 input.consume();
6014 adaptor.addChild(root_0, (Object)adaptor.create(set263));
6015 state.errorRecovery=false;
6016 }
6017 else {
6018 MismatchedSetException mse = new MismatchedSetException(null,input);
6019 throw mse;
6020 }
6021
6022
6023 }
6024
6025
6026 int alt28=2;
6027 int LA28_0 = input.LA(1);
6028
6029 if ( (LA28_0==UPPERCASE_LETTER||LA28_0==NUMBER) ) {
6030 alt28=1;
6031 }
6032 switch (alt28) {
6033 case 1 :
6034
6035 {
6036 set264=(Token)input.LT(1);
6037 if ( input.LA(1)==UPPERCASE_LETTER||input.LA(1)==NUMBER ) {
6038 input.consume();
6039 adaptor.addChild(root_0, (Object)adaptor.create(set264));
6040 state.errorRecovery=false;
6041 }
6042 else {
6043 MismatchedSetException mse = new MismatchedSetException(null,input);
6044 throw mse;
6045 }
6046
6047 set265=(Token)input.LT(1);
6048 if ( input.LA(1)==UPPERCASE_LETTER||input.LA(1)==NUMBER ) {
6049 input.consume();
6050 adaptor.addChild(root_0, (Object)adaptor.create(set265));
6051 state.errorRecovery=false;
6052 }
6053 else {
6054 MismatchedSetException mse = new MismatchedSetException(null,input);
6055 throw mse;
6056 }
6057
6058 set266=(Token)input.LT(1);
6059 if ( input.LA(1)==UPPERCASE_LETTER||input.LA(1)==NUMBER ) {
6060 input.consume();
6061 adaptor.addChild(root_0, (Object)adaptor.create(set266));
6062 state.errorRecovery=false;
6063 }
6064 else {
6065 MismatchedSetException mse = new MismatchedSetException(null,input);
6066 throw mse;
6067 }
6068
6069
6070 }
6071 break;
6072
6073 }
6074
6075
6076 }
6077
6078 retval.stop = input.LT(-1);
6079
6080 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6081 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6082
6083 }
6084
6085 catch (RecognitionException re) {
6086 throw re;
6087 }
6088 finally {
6089 }
6090 return retval;
6091 }
6092
6093
6094 public static class nameAndAddress_return extends ParserRuleReturnScope {
6095 Object tree;
6096 public Object getTree() { return tree; }
6097 };
6098
6099
6100
6101 public final SwiftParser.nameAndAddress_return nameAndAddress() throws RecognitionException {
6102 SwiftParser.nameAndAddress_return retval = new SwiftParser.nameAndAddress_return();
6103 retval.start = input.LT(1);
6104
6105 Object root_0 = null;
6106
6107 SwiftParser.line_return line267 = null;
6108
6109 SwiftParser.line_return line268 = null;
6110
6111 SwiftParser.line_return line269 = null;
6112
6113 SwiftParser.line_return line270 = null;
6114
6115 SwiftParser.line_return line271 = null;
6116
6117 SwiftParser.line_return line272 = null;
6118
6119 SwiftParser.line_return line273 = null;
6120
6121 SwiftParser.line_return line274 = null;
6122
6123 SwiftParser.line_return line275 = null;
6124
6125 SwiftParser.line_return line276 = null;
6126
6127
6128
6129 try {
6130
6131 int alt29=4;
6132 alt29 = dfa29.predict(input);
6133 switch (alt29) {
6134 case 1 :
6135
6136 {
6137 root_0 = (Object)adaptor.nil();
6138
6139 pushFollow(FOLLOW_line_in_nameAndAddress1849);
6140 line267=line();
6141
6142 state._fsp--;
6143
6144 adaptor.addChild(root_0, line267.getTree());
6145
6146 }
6147 break;
6148 case 2 :
6149
6150 {
6151 root_0 = (Object)adaptor.nil();
6152
6153 pushFollow(FOLLOW_line_in_nameAndAddress1855);
6154 line268=line();
6155
6156 state._fsp--;
6157
6158 adaptor.addChild(root_0, line268.getTree());
6159 pushFollow(FOLLOW_line_in_nameAndAddress1857);
6160 line269=line();
6161
6162 state._fsp--;
6163
6164 adaptor.addChild(root_0, line269.getTree());
6165
6166 }
6167 break;
6168 case 3 :
6169
6170 {
6171 root_0 = (Object)adaptor.nil();
6172
6173 pushFollow(FOLLOW_line_in_nameAndAddress1862);
6174 line270=line();
6175
6176 state._fsp--;
6177
6178 adaptor.addChild(root_0, line270.getTree());
6179 pushFollow(FOLLOW_line_in_nameAndAddress1864);
6180 line271=line();
6181
6182 state._fsp--;
6183
6184 adaptor.addChild(root_0, line271.getTree());
6185 pushFollow(FOLLOW_line_in_nameAndAddress1866);
6186 line272=line();
6187
6188 state._fsp--;
6189
6190 adaptor.addChild(root_0, line272.getTree());
6191
6192 }
6193 break;
6194 case 4 :
6195
6196 {
6197 root_0 = (Object)adaptor.nil();
6198
6199 pushFollow(FOLLOW_line_in_nameAndAddress1871);
6200 line273=line();
6201
6202 state._fsp--;
6203
6204 adaptor.addChild(root_0, line273.getTree());
6205 pushFollow(FOLLOW_line_in_nameAndAddress1873);
6206 line274=line();
6207
6208 state._fsp--;
6209
6210 adaptor.addChild(root_0, line274.getTree());
6211 pushFollow(FOLLOW_line_in_nameAndAddress1875);
6212 line275=line();
6213
6214 state._fsp--;
6215
6216 adaptor.addChild(root_0, line275.getTree());
6217 pushFollow(FOLLOW_line_in_nameAndAddress1877);
6218 line276=line();
6219
6220 state._fsp--;
6221
6222 adaptor.addChild(root_0, line276.getTree());
6223
6224 }
6225 break;
6226
6227 }
6228 retval.stop = input.LT(-1);
6229
6230 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6231 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6232
6233 }
6234
6235 catch (RecognitionException re) {
6236 throw re;
6237 }
6238 finally {
6239 }
6240 return retval;
6241 }
6242
6243
6244 public static class partyIdentifier_return extends ParserRuleReturnScope {
6245 Object tree;
6246 public Object getTree() { return tree; }
6247 };
6248
6249
6250
6251 public final SwiftParser.partyIdentifier_return partyIdentifier() throws RecognitionException {
6252 SwiftParser.partyIdentifier_return retval = new SwiftParser.partyIdentifier_return();
6253 retval.start = input.LT(1);
6254
6255 Object root_0 = null;
6256
6257 Token CODE_SEPARATOR277=null;
6258 Token CODE_SEPARATOR280=null;
6259 SwiftParser.genericLine_return genericLine278 = null;
6260
6261 SwiftParser.partyIdentifierCode_return partyIdentifierCode279 = null;
6262
6263 SwiftParser.genericLine_return genericLine281 = null;
6264
6265
6266 Object CODE_SEPARATOR277_tree=null;
6267 Object CODE_SEPARATOR280_tree=null;
6268 RewriteRuleTokenStream stream_CODE_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token CODE_SEPARATOR");
6269 RewriteRuleSubtreeStream stream_partyIdentifierCode=new RewriteRuleSubtreeStream(adaptor,"rule partyIdentifierCode");
6270 RewriteRuleSubtreeStream stream_genericLine=new RewriteRuleSubtreeStream(adaptor,"rule genericLine");
6271 try {
6272
6273 int alt30=2;
6274 int LA30_0 = input.LA(1);
6275
6276 if ( (LA30_0==CODE_SEPARATOR) ) {
6277 alt30=1;
6278 }
6279 else if ( (LA30_0==UPPERCASE_LETTER) ) {
6280 alt30=2;
6281 }
6282 else {
6283 NoViableAltException nvae =
6284 new NoViableAltException("", 30, 0, input);
6285
6286 throw nvae;
6287 }
6288 switch (alt30) {
6289 case 1 :
6290
6291 {
6292
6293
6294 {
6295 CODE_SEPARATOR277=(Token)match(input,CODE_SEPARATOR,FOLLOW_CODE_SEPARATOR_in_partyIdentifier1890);
6296 stream_CODE_SEPARATOR.add(CODE_SEPARATOR277);
6297
6298 pushFollow(FOLLOW_genericLine_in_partyIdentifier1892);
6299 genericLine278=genericLine();
6300
6301 state._fsp--;
6302
6303 stream_genericLine.add(genericLine278.getTree());
6304
6305 }
6306
6307
6308
6309
6310
6311
6312
6313
6314
6315
6316 retval.tree = root_0;
6317 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
6318
6319 root_0 = (Object)adaptor.nil();
6320
6321 {
6322
6323 {
6324 Object root_1 = (Object)adaptor.nil();
6325 root_1 = (Object)adaptor.becomeRoot(stream_CODE_SEPARATOR.nextNode(), root_1);
6326
6327 adaptor.addChild(root_1, stream_genericLine.nextTree());
6328
6329 adaptor.addChild(root_0, root_1);
6330 }
6331
6332 }
6333
6334 retval.tree = root_0;
6335 }
6336 break;
6337 case 2 :
6338
6339 {
6340
6341
6342 {
6343 pushFollow(FOLLOW_partyIdentifierCode_in_partyIdentifier1907);
6344 partyIdentifierCode279=partyIdentifierCode();
6345
6346 state._fsp--;
6347
6348 stream_partyIdentifierCode.add(partyIdentifierCode279.getTree());
6349 CODE_SEPARATOR280=(Token)match(input,CODE_SEPARATOR,FOLLOW_CODE_SEPARATOR_in_partyIdentifier1909);
6350 stream_CODE_SEPARATOR.add(CODE_SEPARATOR280);
6351
6352 pushFollow(FOLLOW_genericLine_in_partyIdentifier1911);
6353 genericLine281=genericLine();
6354
6355 state._fsp--;
6356
6357 stream_genericLine.add(genericLine281.getTree());
6358
6359 }
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370 retval.tree = root_0;
6371 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
6372
6373 root_0 = (Object)adaptor.nil();
6374
6375 {
6376
6377 {
6378 Object root_1 = (Object)adaptor.nil();
6379 root_1 = (Object)adaptor.becomeRoot(stream_CODE_SEPARATOR.nextNode(), root_1);
6380
6381 adaptor.addChild(root_1, stream_partyIdentifierCode.nextTree());
6382 adaptor.addChild(root_1, stream_genericLine.nextTree());
6383
6384 adaptor.addChild(root_0, root_1);
6385 }
6386
6387 }
6388
6389 retval.tree = root_0;
6390 }
6391 break;
6392
6393 }
6394 retval.stop = input.LT(-1);
6395
6396 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6397 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6398
6399 }
6400
6401 catch (RecognitionException re) {
6402 throw re;
6403 }
6404 finally {
6405 }
6406 return retval;
6407 }
6408
6409
6410 public static class line_return extends ParserRuleReturnScope {
6411 Object tree;
6412 public Object getTree() { return tree; }
6413 };
6414
6415
6416
6417 public final SwiftParser.line_return line() throws RecognitionException {
6418 SwiftParser.line_return retval = new SwiftParser.line_return();
6419 retval.start = input.LT(1);
6420
6421 Object root_0 = null;
6422
6423 Token CODE_SEPARATOR283=null;
6424 SwiftParser.nameAndAddressNumberCode_return nameAndAddressNumberCode282 = null;
6425
6426 SwiftParser.genericLine_return genericLine284 = null;
6427
6428
6429 Object CODE_SEPARATOR283_tree=null;
6430
6431 try {
6432
6433
6434 {
6435 root_0 = (Object)adaptor.nil();
6436
6437
6438 int alt31=2;
6439 int LA31_0 = input.LA(1);
6440
6441 if ( (LA31_0==NUMBER) ) {
6442 int LA31_1 = input.LA(2);
6443
6444 if ( (LA31_1==CODE_SEPARATOR) ) {
6445 alt31=1;
6446 }
6447 }
6448 switch (alt31) {
6449 case 1 :
6450
6451 {
6452 pushFollow(FOLLOW_nameAndAddressNumberCode_in_line1934);
6453 nameAndAddressNumberCode282=nameAndAddressNumberCode();
6454
6455 state._fsp--;
6456
6457 adaptor.addChild(root_0, nameAndAddressNumberCode282.getTree());
6458 CODE_SEPARATOR283=(Token)match(input,CODE_SEPARATOR,FOLLOW_CODE_SEPARATOR_in_line1936);
6459 CODE_SEPARATOR283_tree = (Object)adaptor.create(CODE_SEPARATOR283);
6460 adaptor.addChild(root_0, CODE_SEPARATOR283_tree);
6461
6462
6463 }
6464 break;
6465
6466 }
6467
6468 pushFollow(FOLLOW_genericLine_in_line1940);
6469 genericLine284=genericLine();
6470
6471 state._fsp--;
6472
6473 adaptor.addChild(root_0, genericLine284.getTree());
6474
6475 }
6476
6477 retval.stop = input.LT(-1);
6478
6479 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6480 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6481
6482 }
6483
6484 catch (RecognitionException re) {
6485 throw re;
6486 }
6487 finally {
6488 }
6489 return retval;
6490 }
6491
6492
6493 public static class genericLine_return extends ParserRuleReturnScope {
6494 Object tree;
6495 public Object getTree() { return tree; }
6496 };
6497
6498
6499
6500 public final SwiftParser.genericLine_return genericLine() throws RecognitionException {
6501 SwiftParser.genericLine_return retval = new SwiftParser.genericLine_return();
6502 retval.start = input.LT(1);
6503
6504 Object root_0 = null;
6505
6506 Token set285=null;
6507 Token CRLF286=null;
6508
6509 Object set285_tree=null;
6510 Object CRLF286_tree=null;
6511
6512 try {
6513
6514
6515 {
6516 root_0 = (Object)adaptor.nil();
6517
6518
6519 int cnt32=0;
6520 loop32:
6521 do {
6522 int alt32=2;
6523 int LA32_0 = input.LA(1);
6524
6525 if ( ((LA32_0>=UPPERCASE_LETTER && LA32_0<=NUMBER)||LA32_0==SPECIAL_LETTER) ) {
6526 alt32=1;
6527 }
6528
6529
6530 switch (alt32) {
6531 case 1 :
6532
6533 {
6534 set285=(Token)input.LT(1);
6535 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER)||input.LA(1)==SPECIAL_LETTER ) {
6536 input.consume();
6537 adaptor.addChild(root_0, (Object)adaptor.create(set285));
6538 state.errorRecovery=false;
6539 }
6540 else {
6541 MismatchedSetException mse = new MismatchedSetException(null,input);
6542 throw mse;
6543 }
6544
6545
6546 }
6547 break;
6548
6549 default :
6550 if ( cnt32 >= 1 ) break loop32;
6551 EarlyExitException eee =
6552 new EarlyExitException(32, input);
6553 throw eee;
6554 }
6555 cnt32++;
6556 } while (true);
6557
6558 CRLF286=(Token)match(input,CRLF,FOLLOW_CRLF_in_genericLine1969);
6559 CRLF286_tree = (Object)adaptor.create(CRLF286);
6560 adaptor.addChild(root_0, CRLF286_tree);
6561
6562
6563 }
6564
6565 retval.stop = input.LT(-1);
6566
6567 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6568 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6569
6570 }
6571
6572 catch (RecognitionException re) {
6573 throw re;
6574 }
6575 finally {
6576 }
6577 return retval;
6578 }
6579
6580
6581 public static class partyIdentifierCode_return extends ParserRuleReturnScope {
6582 Object tree;
6583 public Object getTree() { return tree; }
6584 };
6585
6586
6587
6588 public final SwiftParser.partyIdentifierCode_return partyIdentifierCode() throws RecognitionException {
6589 SwiftParser.partyIdentifierCode_return retval = new SwiftParser.partyIdentifierCode_return();
6590 retval.start = input.LT(1);
6591
6592 Object root_0 = null;
6593
6594 Token UPPERCASE_LETTER287=null;
6595 Token UPPERCASE_LETTER288=null;
6596 Token UPPERCASE_LETTER289=null;
6597 Token UPPERCASE_LETTER290=null;
6598
6599 Object UPPERCASE_LETTER287_tree=null;
6600 Object UPPERCASE_LETTER288_tree=null;
6601 Object UPPERCASE_LETTER289_tree=null;
6602 Object UPPERCASE_LETTER290_tree=null;
6603
6604 try {
6605
6606
6607 {
6608 root_0 = (Object)adaptor.nil();
6609
6610 UPPERCASE_LETTER287=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_partyIdentifierCode1981);
6611 UPPERCASE_LETTER287_tree = (Object)adaptor.create(UPPERCASE_LETTER287);
6612 adaptor.addChild(root_0, UPPERCASE_LETTER287_tree);
6613
6614 UPPERCASE_LETTER288=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_partyIdentifierCode1983);
6615 UPPERCASE_LETTER288_tree = (Object)adaptor.create(UPPERCASE_LETTER288);
6616 adaptor.addChild(root_0, UPPERCASE_LETTER288_tree);
6617
6618 UPPERCASE_LETTER289=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_partyIdentifierCode1985);
6619 UPPERCASE_LETTER289_tree = (Object)adaptor.create(UPPERCASE_LETTER289);
6620 adaptor.addChild(root_0, UPPERCASE_LETTER289_tree);
6621
6622 UPPERCASE_LETTER290=(Token)match(input,UPPERCASE_LETTER,FOLLOW_UPPERCASE_LETTER_in_partyIdentifierCode1987);
6623 UPPERCASE_LETTER290_tree = (Object)adaptor.create(UPPERCASE_LETTER290);
6624 adaptor.addChild(root_0, UPPERCASE_LETTER290_tree);
6625
6626
6627 }
6628
6629 retval.stop = input.LT(-1);
6630
6631 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6632 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6633
6634 }
6635
6636 catch (RecognitionException re) {
6637 throw re;
6638 }
6639 finally {
6640 }
6641 return retval;
6642 }
6643
6644
6645 public static class nameAndAddressNumberCode_return extends ParserRuleReturnScope {
6646 Object tree;
6647 public Object getTree() { return tree; }
6648 };
6649
6650
6651
6652 public final SwiftParser.nameAndAddressNumberCode_return nameAndAddressNumberCode() throws RecognitionException {
6653 SwiftParser.nameAndAddressNumberCode_return retval = new SwiftParser.nameAndAddressNumberCode_return();
6654 retval.start = input.LT(1);
6655
6656 Object root_0 = null;
6657
6658 Token NUMBER291=null;
6659
6660 Object NUMBER291_tree=null;
6661
6662 try {
6663
6664
6665 {
6666 root_0 = (Object)adaptor.nil();
6667
6668 NUMBER291=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_nameAndAddressNumberCode1998);
6669 NUMBER291_tree = (Object)adaptor.create(NUMBER291);
6670 adaptor.addChild(root_0, NUMBER291_tree);
6671
6672
6673 }
6674
6675 retval.stop = input.LT(-1);
6676
6677 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6678 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6679
6680 }
6681
6682 catch (RecognitionException re) {
6683 throw re;
6684 }
6685 finally {
6686 }
6687 return retval;
6688 }
6689
6690
6691 public static class bankPriorityCode_return extends ParserRuleReturnScope {
6692 Object tree;
6693 public Object getTree() { return tree; }
6694 };
6695
6696
6697
6698 public final SwiftParser.bankPriorityCode_return bankPriorityCode() throws RecognitionException {
6699 SwiftParser.bankPriorityCode_return retval = new SwiftParser.bankPriorityCode_return();
6700 retval.start = input.LT(1);
6701
6702 Object root_0 = null;
6703
6704 Token set292=null;
6705
6706 Object set292_tree=null;
6707
6708 try {
6709
6710
6711 {
6712 root_0 = (Object)adaptor.nil();
6713
6714
6715 int cnt33=0;
6716 loop33:
6717 do {
6718 int alt33=2;
6719 int LA33_0 = input.LA(1);
6720
6721 if ( ((LA33_0>=UPPERCASE_LETTER && LA33_0<=NUMBER)) ) {
6722 alt33=1;
6723 }
6724
6725
6726 switch (alt33) {
6727 case 1 :
6728
6729 {
6730 set292=(Token)input.LT(1);
6731 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER) ) {
6732 input.consume();
6733 adaptor.addChild(root_0, (Object)adaptor.create(set292));
6734 state.errorRecovery=false;
6735 }
6736 else {
6737 MismatchedSetException mse = new MismatchedSetException(null,input);
6738 throw mse;
6739 }
6740
6741
6742 }
6743 break;
6744
6745 default :
6746 if ( cnt33 >= 1 ) break loop33;
6747 EarlyExitException eee =
6748 new EarlyExitException(33, input);
6749 throw eee;
6750 }
6751 cnt33++;
6752 } while (true);
6753
6754
6755 }
6756
6757 retval.stop = input.LT(-1);
6758
6759 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6760 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6761
6762 }
6763
6764 catch (RecognitionException re) {
6765 throw re;
6766 }
6767 finally {
6768 }
6769 return retval;
6770 }
6771
6772
6773 public static class messageUserReference_return extends ParserRuleReturnScope {
6774 Object tree;
6775 public Object getTree() { return tree; }
6776 };
6777
6778
6779
6780 public final SwiftParser.messageUserReference_return messageUserReference() throws RecognitionException {
6781 SwiftParser.messageUserReference_return retval = new SwiftParser.messageUserReference_return();
6782 retval.start = input.LT(1);
6783
6784 Object root_0 = null;
6785
6786 Token set293=null;
6787
6788 Object set293_tree=null;
6789
6790 try {
6791
6792
6793 {
6794 root_0 = (Object)adaptor.nil();
6795
6796
6797 int cnt34=0;
6798 loop34:
6799 do {
6800 int alt34=2;
6801 int LA34_0 = input.LA(1);
6802
6803 if ( ((LA34_0>=UPPERCASE_LETTER && LA34_0<=NUMBER)) ) {
6804 alt34=1;
6805 }
6806
6807
6808 switch (alt34) {
6809 case 1 :
6810
6811 {
6812 set293=(Token)input.LT(1);
6813 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER) ) {
6814 input.consume();
6815 adaptor.addChild(root_0, (Object)adaptor.create(set293));
6816 state.errorRecovery=false;
6817 }
6818 else {
6819 MismatchedSetException mse = new MismatchedSetException(null,input);
6820 throw mse;
6821 }
6822
6823
6824 }
6825 break;
6826
6827 default :
6828 if ( cnt34 >= 1 ) break loop34;
6829 EarlyExitException eee =
6830 new EarlyExitException(34, input);
6831 throw eee;
6832 }
6833 cnt34++;
6834 } while (true);
6835
6836
6837 }
6838
6839 retval.stop = input.LT(-1);
6840
6841 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6842 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6843
6844 }
6845
6846 catch (RecognitionException re) {
6847 throw re;
6848 }
6849 finally {
6850 }
6851 return retval;
6852 }
6853
6854
6855 public static class messageAuthenticationCode_return extends ParserRuleReturnScope {
6856 Object tree;
6857 public Object getTree() { return tree; }
6858 };
6859
6860
6861
6862 public final SwiftParser.messageAuthenticationCode_return messageAuthenticationCode() throws RecognitionException {
6863 SwiftParser.messageAuthenticationCode_return retval = new SwiftParser.messageAuthenticationCode_return();
6864 retval.start = input.LT(1);
6865
6866 Object root_0 = null;
6867
6868 Token set294=null;
6869
6870 Object set294_tree=null;
6871
6872 try {
6873
6874
6875 {
6876 root_0 = (Object)adaptor.nil();
6877
6878
6879 int cnt35=0;
6880 loop35:
6881 do {
6882 int alt35=2;
6883 int LA35_0 = input.LA(1);
6884
6885 if ( ((LA35_0>=UPPERCASE_LETTER && LA35_0<=NUMBER)) ) {
6886 alt35=1;
6887 }
6888
6889
6890 switch (alt35) {
6891 case 1 :
6892
6893 {
6894 set294=(Token)input.LT(1);
6895 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER) ) {
6896 input.consume();
6897 adaptor.addChild(root_0, (Object)adaptor.create(set294));
6898 state.errorRecovery=false;
6899 }
6900 else {
6901 MismatchedSetException mse = new MismatchedSetException(null,input);
6902 throw mse;
6903 }
6904
6905
6906 }
6907 break;
6908
6909 default :
6910 if ( cnt35 >= 1 ) break loop35;
6911 EarlyExitException eee =
6912 new EarlyExitException(35, input);
6913 throw eee;
6914 }
6915 cnt35++;
6916 } while (true);
6917
6918
6919 }
6920
6921 retval.stop = input.LT(-1);
6922
6923 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
6924 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6925
6926 }
6927
6928 catch (RecognitionException re) {
6929 throw re;
6930 }
6931 finally {
6932 }
6933 return retval;
6934 }
6935
6936
6937 public static class checksum_return extends ParserRuleReturnScope {
6938 Object tree;
6939 public Object getTree() { return tree; }
6940 };
6941
6942
6943
6944 public final SwiftParser.checksum_return checksum() throws RecognitionException {
6945 SwiftParser.checksum_return retval = new SwiftParser.checksum_return();
6946 retval.start = input.LT(1);
6947
6948 Object root_0 = null;
6949
6950 Token set295=null;
6951
6952 Object set295_tree=null;
6953
6954 try {
6955
6956
6957 {
6958 root_0 = (Object)adaptor.nil();
6959
6960
6961 int cnt36=0;
6962 loop36:
6963 do {
6964 int alt36=2;
6965 int LA36_0 = input.LA(1);
6966
6967 if ( ((LA36_0>=UPPERCASE_LETTER && LA36_0<=NUMBER)) ) {
6968 alt36=1;
6969 }
6970
6971
6972 switch (alt36) {
6973 case 1 :
6974
6975 {
6976 set295=(Token)input.LT(1);
6977 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER) ) {
6978 input.consume();
6979 adaptor.addChild(root_0, (Object)adaptor.create(set295));
6980 state.errorRecovery=false;
6981 }
6982 else {
6983 MismatchedSetException mse = new MismatchedSetException(null,input);
6984 throw mse;
6985 }
6986
6987
6988 }
6989 break;
6990
6991 default :
6992 if ( cnt36 >= 1 ) break loop36;
6993 EarlyExitException eee =
6994 new EarlyExitException(36, input);
6995 throw eee;
6996 }
6997 cnt36++;
6998 } while (true);
6999
7000
7001 }
7002
7003 retval.stop = input.LT(-1);
7004
7005 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
7006 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
7007
7008 }
7009
7010 catch (RecognitionException re) {
7011 throw re;
7012 }
7013 finally {
7014 }
7015 return retval;
7016 }
7017
7018
7019 public static class possibleDuplicateEmission_return extends ParserRuleReturnScope {
7020 Object tree;
7021 public Object getTree() { return tree; }
7022 };
7023
7024
7025
7026 public final SwiftParser.possibleDuplicateEmission_return possibleDuplicateEmission() throws RecognitionException {
7027 SwiftParser.possibleDuplicateEmission_return retval = new SwiftParser.possibleDuplicateEmission_return();
7028 retval.start = input.LT(1);
7029
7030 Object root_0 = null;
7031
7032 Token set296=null;
7033
7034 Object set296_tree=null;
7035
7036 try {
7037
7038
7039 {
7040 root_0 = (Object)adaptor.nil();
7041
7042
7043 int cnt37=0;
7044 loop37:
7045 do {
7046 int alt37=2;
7047 int LA37_0 = input.LA(1);
7048
7049 if ( ((LA37_0>=UPPERCASE_LETTER && LA37_0<=NUMBER)) ) {
7050 alt37=1;
7051 }
7052
7053
7054 switch (alt37) {
7055 case 1 :
7056
7057 {
7058 set296=(Token)input.LT(1);
7059 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER) ) {
7060 input.consume();
7061 adaptor.addChild(root_0, (Object)adaptor.create(set296));
7062 state.errorRecovery=false;
7063 }
7064 else {
7065 MismatchedSetException mse = new MismatchedSetException(null,input);
7066 throw mse;
7067 }
7068
7069
7070 }
7071 break;
7072
7073 default :
7074 if ( cnt37 >= 1 ) break loop37;
7075 EarlyExitException eee =
7076 new EarlyExitException(37, input);
7077 throw eee;
7078 }
7079 cnt37++;
7080 } while (true);
7081
7082
7083 }
7084
7085 retval.stop = input.LT(-1);
7086
7087 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
7088 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
7089
7090 }
7091
7092 catch (RecognitionException re) {
7093 throw re;
7094 }
7095 finally {
7096 }
7097 return retval;
7098 }
7099
7100
7101 public static class delayedMessage_return extends ParserRuleReturnScope {
7102 Object tree;
7103 public Object getTree() { return tree; }
7104 };
7105
7106
7107
7108 public final SwiftParser.delayedMessage_return delayedMessage() throws RecognitionException {
7109 SwiftParser.delayedMessage_return retval = new SwiftParser.delayedMessage_return();
7110 retval.start = input.LT(1);
7111
7112 Object root_0 = null;
7113
7114 Token set297=null;
7115
7116 Object set297_tree=null;
7117
7118 try {
7119
7120
7121 {
7122 root_0 = (Object)adaptor.nil();
7123
7124
7125 int cnt38=0;
7126 loop38:
7127 do {
7128 int alt38=2;
7129 int LA38_0 = input.LA(1);
7130
7131 if ( ((LA38_0>=UPPERCASE_LETTER && LA38_0<=NUMBER)) ) {
7132 alt38=1;
7133 }
7134
7135
7136 switch (alt38) {
7137 case 1 :
7138
7139 {
7140 set297=(Token)input.LT(1);
7141 if ( (input.LA(1)>=UPPERCASE_LETTER && input.LA(1)<=NUMBER) ) {
7142 input.consume();
7143 adaptor.addChild(root_0, (Object)adaptor.create(set297));
7144 state.errorRecovery=false;
7145 }
7146 else {
7147 MismatchedSetException mse = new MismatchedSetException(null,input);
7148 throw mse;
7149 }
7150
7151
7152 }
7153 break;
7154
7155 default :
7156 if ( cnt38 >= 1 ) break loop38;
7157 EarlyExitException eee =
7158 new EarlyExitException(38, input);
7159 throw eee;
7160 }
7161 cnt38++;
7162 } while (true);
7163
7164
7165 }
7166
7167 retval.stop = input.LT(-1);
7168
7169 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
7170 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
7171
7172 }
7173
7174 catch (RecognitionException re) {
7175 throw re;
7176 }
7177 finally {
7178 }
7179 return retval;
7180 }
7181
7182
7183
7184
7185
7186 protected DFA29 dfa29 = new DFA29(this);
7187 static final String DFA29_eotS =
7188 "\21\uffff";
7189 static final String DFA29_eofS =
7190 "\21\uffff";
7191 static final String DFA29_minS =
7192 "\1\40\1\21\1\40\1\20\1\40\1\21\1\40\1\uffff\1\20\1\40\1\21\1\40"+
7193 "\1\uffff\1\40\1\20\2\uffff";
7194 static final String DFA29_maxS =
7195 "\7\50\1\uffff\4\50\1\uffff\2\50\2\uffff";
7196 static final String DFA29_acceptS =
7197 "\7\uffff\1\1\4\uffff\1\2\2\uffff\1\4\1\3";
7198 static final String DFA29_specialS =
7199 "\21\uffff}>";
7200 static final String[] DFA29_transitionS = {
7201 "\2\2\1\1\5\uffff\1\2",
7202 "\1\4\16\uffff\3\2\1\3\4\uffff\1\2",
7203 "\3\2\1\3\4\uffff\1\2",
7204 "\1\7\17\uffff\2\6\1\5\1\7\4\uffff\1\6",
7205 "\3\2\5\uffff\1\2",
7206 "\1\11\16\uffff\3\6\1\10\4\uffff\1\6",
7207 "\3\6\1\10\4\uffff\1\6",
7208 "",
7209 "\1\14\17\uffff\2\13\1\12\1\14\4\uffff\1\13",
7210 "\3\6\5\uffff\1\6",
7211 "\1\15\16\uffff\3\13\1\16\4\uffff\1\13",
7212 "\3\13\1\16\4\uffff\1\13",
7213 "",
7214 "\3\13\5\uffff\1\13",
7215 "\1\20\17\uffff\3\17\1\20\4\uffff\1\17",
7216 "",
7217 ""
7218 };
7219
7220 static final short[] DFA29_eot = DFA.unpackEncodedString(DFA29_eotS);
7221 static final short[] DFA29_eof = DFA.unpackEncodedString(DFA29_eofS);
7222 static final char[] DFA29_min = DFA.unpackEncodedStringToUnsignedChars(DFA29_minS);
7223 static final char[] DFA29_max = DFA.unpackEncodedStringToUnsignedChars(DFA29_maxS);
7224 static final short[] DFA29_accept = DFA.unpackEncodedString(DFA29_acceptS);
7225 static final short[] DFA29_special = DFA.unpackEncodedString(DFA29_specialS);
7226 static final short[][] DFA29_transition;
7227
7228 static {
7229 int numStates = DFA29_transitionS.length;
7230 DFA29_transition = new short[numStates][];
7231 for (int i=0; i<numStates; i++) {
7232 DFA29_transition[i] = DFA.unpackEncodedString(DFA29_transitionS[i]);
7233 }
7234 }
7235
7236 class DFA29 extends DFA {
7237
7238 public DFA29(BaseRecognizer recognizer) {
7239 this.recognizer = recognizer;
7240 this.decisionNumber = 29;
7241 this.eot = DFA29_eot;
7242 this.eof = DFA29_eof;
7243 this.min = DFA29_min;
7244 this.max = DFA29_max;
7245 this.accept = DFA29_accept;
7246 this.special = DFA29_special;
7247 this.transition = DFA29_transition;
7248 }
7249 public String getDescription() {
7250 return "355:1: nameAndAddress : ( line | line line | line line line | line line line line );";
7251 }
7252 }
7253
7254
7255 public static final BitSet FOLLOW_message_in_messages84 = new BitSet(new long[]{0x0000000000000010L});
7256 public static final BitSet FOLLOW_EOF_in_messages87 = new BitSet(new long[]{0x0000000000000002L});
7257 public static final BitSet FOLLOW_blocks_in_message99 = new BitSet(new long[]{0x0000000000000002L});
7258 public static final BitSet FOLLOW_basicHeaderBlock_in_blocks107 = new BitSet(new long[]{0x0000000000000020L});
7259 public static final BitSet FOLLOW_applicationHeaderBlock_in_blocks120 = new BitSet(new long[]{0x00000000000000C0L});
7260 public static final BitSet FOLLOW_userHeaderBlock_in_blocks132 = new BitSet(new long[]{0x00000000000000C0L});
7261 public static final BitSet FOLLOW_textBlock_in_blocks144 = new BitSet(new long[]{0x0000000000000100L});
7262 public static final BitSet FOLLOW_trailerBlock_in_blocks155 = new BitSet(new long[]{0x0000000000000002L});
7263 public static final BitSet FOLLOW_START_BASIC_HEADER_BLOCK_in_basicHeaderBlock172 = new BitSet(new long[]{0x0000000100000000L});
7264 public static final BitSet FOLLOW_applicationId_in_basicHeaderBlock174 = new BitSet(new long[]{0x0000000400000000L});
7265 public static final BitSet FOLLOW_serviceId_in_basicHeaderBlock176 = new BitSet(new long[]{0x0000000100000000L});
7266 public static final BitSet FOLLOW_logicalTerminalAddress_in_basicHeaderBlock178 = new BitSet(new long[]{0x0000000400000000L});
7267 public static final BitSet FOLLOW_sessionNumber_in_basicHeaderBlock180 = new BitSet(new long[]{0x0000000400000000L});
7268 public static final BitSet FOLLOW_sequenceNumber_in_basicHeaderBlock182 = new BitSet(new long[]{0x0000000000008000L});
7269 public static final BitSet FOLLOW_END_ALL_BLOCK_in_basicHeaderBlock184 = new BitSet(new long[]{0x0000000000000002L});
7270 public static final BitSet FOLLOW_START_APPLICATION_HEADER_BLOCK_in_applicationHeaderBlock225 = new BitSet(new long[]{0x0000000100000000L});
7271 public static final BitSet FOLLOW_inputMessageOrOutputMessage_in_applicationHeaderBlock227 = new BitSet(new long[]{0x0000000000008000L});
7272 public static final BitSet FOLLOW_END_ALL_BLOCK_in_applicationHeaderBlock229 = new BitSet(new long[]{0x0000000000000002L});
7273 public static final BitSet FOLLOW_inputMessage_in_inputMessageOrOutputMessage257 = new BitSet(new long[]{0x0000000000000002L});
7274 public static final BitSet FOLLOW_outputMessage_in_inputMessageOrOutputMessage261 = new BitSet(new long[]{0x0000000000000002L});
7275 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_inputMessage274 = new BitSet(new long[]{0x0000000400000000L});
7276 public static final BitSet FOLLOW_type_in_inputMessage276 = new BitSet(new long[]{0x0000000100000000L});
7277 public static final BitSet FOLLOW_receiverAddress_in_inputMessage278 = new BitSet(new long[]{0x0000000100000000L});
7278 public static final BitSet FOLLOW_priority_in_inputMessage280 = new BitSet(new long[]{0x0000000400000000L});
7279 public static final BitSet FOLLOW_deliveryMonitor_in_inputMessage282 = new BitSet(new long[]{0x0000000400000000L});
7280 public static final BitSet FOLLOW_obsolescencePeriod_in_inputMessage284 = new BitSet(new long[]{0x0000000000000002L});
7281 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_outputMessage316 = new BitSet(new long[]{0x0000000400000000L});
7282 public static final BitSet FOLLOW_type_in_outputMessage318 = new BitSet(new long[]{0x0000000400000000L});
7283 public static final BitSet FOLLOW_inputTime_in_outputMessage320 = new BitSet(new long[]{0x0000000400000000L});
7284 public static final BitSet FOLLOW_messageInputReference_in_outputMessage322 = new BitSet(new long[]{0x0000000400000000L});
7285 public static final BitSet FOLLOW_outputDate_in_outputMessage324 = new BitSet(new long[]{0x0000000400000000L});
7286 public static final BitSet FOLLOW_outputTime_in_outputMessage326 = new BitSet(new long[]{0x0000000100000000L});
7287 public static final BitSet FOLLOW_priority_in_outputMessage328 = new BitSet(new long[]{0x0000000000000002L});
7288 public static final BitSet FOLLOW_START_USER_HEADER_BLOCK_in_userHeaderBlock362 = new BitSet(new long[]{0x0000000000000600L});
7289 public static final BitSet FOLLOW_START_BANKING_PRIORITY_CODE_in_userHeaderBlock372 = new BitSet(new long[]{0x0000000700000000L});
7290 public static final BitSet FOLLOW_bankPriorityCode_in_userHeaderBlock374 = new BitSet(new long[]{0x0000000000008000L});
7291 public static final BitSet FOLLOW_END_ALL_BLOCK_in_userHeaderBlock376 = new BitSet(new long[]{0x0000000000000400L});
7292 public static final BitSet FOLLOW_START_MESSAGE_USER_REFERENCE_in_userHeaderBlock387 = new BitSet(new long[]{0x0000000700000000L});
7293 public static final BitSet FOLLOW_messageUserReference_in_userHeaderBlock389 = new BitSet(new long[]{0x0000000000008000L});
7294 public static final BitSet FOLLOW_END_ALL_BLOCK_in_userHeaderBlock391 = new BitSet(new long[]{0x0000000000008000L});
7295 public static final BitSet FOLLOW_END_ALL_BLOCK_in_userHeaderBlock396 = new BitSet(new long[]{0x0000000000000002L});
7296 public static final BitSet FOLLOW_START_TEXT_BLOCK_in_textBlock423 = new BitSet(new long[]{0x0000000800000000L});
7297 public static final BitSet FOLLOW_CRLF_in_textBlock425 = new BitSet(new long[]{0x0000000100200000L});
7298 public static final BitSet FOLLOW_textBlockMessage_in_textBlock427 = new BitSet(new long[]{0x0000000000010000L});
7299 public static final BitSet FOLLOW_END_TEXT_BLOCK_in_textBlock429 = new BitSet(new long[]{0x0000000000000002L});
7300 public static final BitSet FOLLOW_message1xx_in_textBlockMessage452 = new BitSet(new long[]{0x0000000000000002L});
7301 public static final BitSet FOLLOW_message2xx_in_textBlockMessage456 = new BitSet(new long[]{0x0000000000000002L});
7302 public static final BitSet FOLLOW_START_TRAILER_BLOCK_in_trailerBlock471 = new BitSet(new long[]{0x0000000000001800L});
7303 public static final BitSet FOLLOW_START_MAC_TRAILER_in_trailerBlock481 = new BitSet(new long[]{0x0000000700000000L});
7304 public static final BitSet FOLLOW_messageAuthenticationCode_in_trailerBlock483 = new BitSet(new long[]{0x0000000000008000L});
7305 public static final BitSet FOLLOW_END_ALL_BLOCK_in_trailerBlock485 = new BitSet(new long[]{0x0000000000001000L});
7306 public static final BitSet FOLLOW_START_CHK_TRAILER_in_trailerBlock496 = new BitSet(new long[]{0x0000000700000000L});
7307 public static final BitSet FOLLOW_checksum_in_trailerBlock498 = new BitSet(new long[]{0x0000000000008000L});
7308 public static final BitSet FOLLOW_END_ALL_BLOCK_in_trailerBlock500 = new BitSet(new long[]{0x000000000000E000L});
7309 public static final BitSet FOLLOW_START_PDE_TRAILER_in_trailerBlock510 = new BitSet(new long[]{0x0000000700000000L});
7310 public static final BitSet FOLLOW_possibleDuplicateEmission_in_trailerBlock512 = new BitSet(new long[]{0x0000000000008000L});
7311 public static final BitSet FOLLOW_END_ALL_BLOCK_in_trailerBlock514 = new BitSet(new long[]{0x000000000000C000L});
7312 public static final BitSet FOLLOW_START_DLM_TRAILER_in_trailerBlock526 = new BitSet(new long[]{0x0000000700000000L});
7313 public static final BitSet FOLLOW_delayedMessage_in_trailerBlock528 = new BitSet(new long[]{0x0000000000008000L});
7314 public static final BitSet FOLLOW_END_ALL_BLOCK_in_trailerBlock530 = new BitSet(new long[]{0x0000000000008000L});
7315 public static final BitSet FOLLOW_END_ALL_BLOCK_in_trailerBlock538 = new BitSet(new long[]{0x0000000000000002L});
7316 public static final BitSet FOLLOW_message103_in_message1xx573 = new BitSet(new long[]{0x0000000000000002L});
7317 public static final BitSet FOLLOW_message201_in_message2xx584 = new BitSet(new long[]{0x0000000000000002L});
7318 public static final BitSet FOLLOW_tag20_in_message103596 = new BitSet(new long[]{0x0000000000C00000L});
7319 public static final BitSet FOLLOW_tag13C_in_message103599 = new BitSet(new long[]{0x0000000000C00000L});
7320 public static final BitSet FOLLOW_tag23B_in_message103603 = new BitSet(new long[]{0x0000000001000000L});
7321 public static final BitSet FOLLOW_tag23E_in_message103606 = new BitSet(new long[]{0x0000000007000000L});
7322 public static final BitSet FOLLOW_tag26T_in_message103611 = new BitSet(new long[]{0x0000000006000000L});
7323 public static final BitSet FOLLOW_tag32A_in_message103615 = new BitSet(new long[]{0x00000000F8000000L});
7324 public static final BitSet FOLLOW_tag33B_in_message103618 = new BitSet(new long[]{0x00000000F8000000L});
7325 public static final BitSet FOLLOW_tag36_in_message103623 = new BitSet(new long[]{0x00000000F8000000L});
7326 public static final BitSet FOLLOW_tag50_a_in_message103627 = new BitSet(new long[]{0x0000000000000002L});
7327 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_message201647 = new BitSet(new long[]{0x0000000100000002L});
7328 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_dummyText663 = new BitSet(new long[]{0x0000000100000002L});
7329 public static final BitSet FOLLOW_TAG_13C_in_tag13C678 = new BitSet(new long[]{0x0000000000020000L});
7330 public static final BitSet FOLLOW_CODE_SEPARATOR_in_tag13C680 = new BitSet(new long[]{0x0000000100000000L});
7331 public static final BitSet FOLLOW_code_in_tag13C682 = new BitSet(new long[]{0x0000000000020000L});
7332 public static final BitSet FOLLOW_CODE_SEPARATOR_in_tag13C684 = new BitSet(new long[]{0x0000000400000000L});
7333 public static final BitSet FOLLOW_timeIndication_in_tag13C686 = new BitSet(new long[]{0x00000000000C0000L});
7334 public static final BitSet FOLLOW_sign_in_tag13C688 = new BitSet(new long[]{0x0000000400000000L});
7335 public static final BitSet FOLLOW_timeOffset_in_tag13C690 = new BitSet(new long[]{0x0000000800000000L});
7336 public static final BitSet FOLLOW_CRLF_in_tag13C692 = new BitSet(new long[]{0x0000000000000002L});
7337 public static final BitSet FOLLOW_TAG_20_in_tag20716 = new BitSet(new long[]{0x0000010700000000L});
7338 public static final BitSet FOLLOW_senderReference_in_tag20718 = new BitSet(new long[]{0x0000000800000000L});
7339 public static final BitSet FOLLOW_CRLF_in_tag20720 = new BitSet(new long[]{0x0000000000000002L});
7340 public static final BitSet FOLLOW_TAG_23B_in_tag23B738 = new BitSet(new long[]{0x0000000100000000L});
7341 public static final BitSet FOLLOW_bankOperationCode_in_tag23B740 = new BitSet(new long[]{0x0000000800000000L});
7342 public static final BitSet FOLLOW_CRLF_in_tag23B742 = new BitSet(new long[]{0x0000000000000002L});
7343 public static final BitSet FOLLOW_TAG_23E_in_tag23E761 = new BitSet(new long[]{0x0000000100000000L});
7344 public static final BitSet FOLLOW_instruction_in_tag23E763 = new BitSet(new long[]{0x0000000800020000L});
7345 public static final BitSet FOLLOW_CODE_SEPARATOR_in_tag23E766 = new BitSet(new long[]{0x0000000700000000L});
7346 public static final BitSet FOLLOW_additionalInformation_in_tag23E768 = new BitSet(new long[]{0x0000000800000000L});
7347 public static final BitSet FOLLOW_CRLF_in_tag23E772 = new BitSet(new long[]{0x0000000000000002L});
7348 public static final BitSet FOLLOW_TAG_26T_in_tag26T792 = new BitSet(new long[]{0x0000000500000000L});
7349 public static final BitSet FOLLOW_transactionTypeCode_in_tag26T794 = new BitSet(new long[]{0x0000000800000000L});
7350 public static final BitSet FOLLOW_CRLF_in_tag26T796 = new BitSet(new long[]{0x0000000000000002L});
7351 public static final BitSet FOLLOW_TAG_32A_in_tag32A815 = new BitSet(new long[]{0x0000000400000000L});
7352 public static final BitSet FOLLOW_valueDate_in_tag32A817 = new BitSet(new long[]{0x0000000100000000L});
7353 public static final BitSet FOLLOW_currency_in_tag32A819 = new BitSet(new long[]{0x0000000400100000L});
7354 public static final BitSet FOLLOW_amount_in_tag32A821 = new BitSet(new long[]{0x0000000800000000L});
7355 public static final BitSet FOLLOW_CRLF_in_tag32A823 = new BitSet(new long[]{0x0000000000000002L});
7356 public static final BitSet FOLLOW_TAG_33B_in_tag33B846 = new BitSet(new long[]{0x0000000100000000L});
7357 public static final BitSet FOLLOW_currency_in_tag33B848 = new BitSet(new long[]{0x0000000400100000L});
7358 public static final BitSet FOLLOW_amount_in_tag33B850 = new BitSet(new long[]{0x0000000800000000L});
7359 public static final BitSet FOLLOW_CRLF_in_tag33B852 = new BitSet(new long[]{0x0000000000000002L});
7360 public static final BitSet FOLLOW_TAG_36_in_tag36874 = new BitSet(new long[]{0x0000000400100000L});
7361 public static final BitSet FOLLOW_exchangeRate_in_tag36876 = new BitSet(new long[]{0x0000000800000000L});
7362 public static final BitSet FOLLOW_CRLF_in_tag36878 = new BitSet(new long[]{0x0000000000000002L});
7363 public static final BitSet FOLLOW_TAG_50A_in_tag50A897 = new BitSet(new long[]{0x0000000000020000L});
7364 public static final BitSet FOLLOW_CODE_SEPARATOR_in_tag50A899 = new BitSet(new long[]{0x0000000700000000L});
7365 public static final BitSet FOLLOW_account_in_tag50A901 = new BitSet(new long[]{0x0000000800000000L});
7366 public static final BitSet FOLLOW_CRLF_in_tag50A903 = new BitSet(new long[]{0x0000000100000000L});
7367 public static final BitSet FOLLOW_bicBai_in_tag50A905 = new BitSet(new long[]{0x0000000800000000L});
7368 public static final BitSet FOLLOW_CRLF_in_tag50A907 = new BitSet(new long[]{0x0000000000000002L});
7369 public static final BitSet FOLLOW_TAG_50K_in_tag50K929 = new BitSet(new long[]{0x0000000000020000L});
7370 public static final BitSet FOLLOW_CODE_SEPARATOR_in_tag50K931 = new BitSet(new long[]{0x0000000700000000L});
7371 public static final BitSet FOLLOW_account_in_tag50K933 = new BitSet(new long[]{0x0000000800000000L});
7372 public static final BitSet FOLLOW_CRLF_in_tag50K935 = new BitSet(new long[]{0x0000010700000000L});
7373 public static final BitSet FOLLOW_nameAndAddress_in_tag50K937 = new BitSet(new long[]{0x0000000800000002L});
7374 public static final BitSet FOLLOW_CRLF_in_tag50K940 = new BitSet(new long[]{0x0000000000000002L});
7375 public static final BitSet FOLLOW_TAG_50F_in_tag50F965 = new BitSet(new long[]{0x0000000100020000L});
7376 public static final BitSet FOLLOW_partyIdentifier_in_tag50F967 = new BitSet(new long[]{0x0000000800000000L});
7377 public static final BitSet FOLLOW_CRLF_in_tag50F969 = new BitSet(new long[]{0x0000010700000000L});
7378 public static final BitSet FOLLOW_nameAndAddress_in_tag50F971 = new BitSet(new long[]{0x0000000800000002L});
7379 public static final BitSet FOLLOW_CRLF_in_tag50F974 = new BitSet(new long[]{0x0000000000000002L});
7380 public static final BitSet FOLLOW_tag50A_in_tag50_a1058 = new BitSet(new long[]{0x0000000000000002L});
7381 public static final BitSet FOLLOW_tag50K_in_tag50_a1065 = new BitSet(new long[]{0x0000000000000002L});
7382 public static final BitSet FOLLOW_tag50F_in_tag50_a1070 = new BitSet(new long[]{0x0000000000000002L});
7383 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_direction1129 = new BitSet(new long[]{0x0000000000000002L});
7384 public static final BitSet FOLLOW_NUMBER_in_type1139 = new BitSet(new long[]{0x0000000400000000L});
7385 public static final BitSet FOLLOW_NUMBER_in_type1141 = new BitSet(new long[]{0x0000000400000000L});
7386 public static final BitSet FOLLOW_NUMBER_in_type1143 = new BitSet(new long[]{0x0000000000000002L});
7387 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1155 = new BitSet(new long[]{0x0000000100000000L});
7388 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1157 = new BitSet(new long[]{0x0000000100000000L});
7389 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1159 = new BitSet(new long[]{0x0000000100000000L});
7390 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1164 = new BitSet(new long[]{0x0000000100000000L});
7391 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1166 = new BitSet(new long[]{0x0000000100000000L});
7392 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1168 = new BitSet(new long[]{0x0000000100000000L});
7393 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1173 = new BitSet(new long[]{0x0000000100000000L});
7394 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1175 = new BitSet(new long[]{0x0000000100000000L});
7395 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1177 = new BitSet(new long[]{0x0000000100000000L});
7396 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1182 = new BitSet(new long[]{0x0000000100000000L});
7397 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1184 = new BitSet(new long[]{0x0000000100000000L});
7398 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_receiverAddress1186 = new BitSet(new long[]{0x0000000000000002L});
7399 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_priority1196 = new BitSet(new long[]{0x0000000000000002L});
7400 public static final BitSet FOLLOW_NUMBER_in_deliveryMonitor1205 = new BitSet(new long[]{0x0000000000000002L});
7401 public static final BitSet FOLLOW_NUMBER_in_obsolescencePeriod1216 = new BitSet(new long[]{0x0000000400000000L});
7402 public static final BitSet FOLLOW_NUMBER_in_obsolescencePeriod1218 = new BitSet(new long[]{0x0000000400000000L});
7403 public static final BitSet FOLLOW_NUMBER_in_obsolescencePeriod1220 = new BitSet(new long[]{0x0000000000000002L});
7404 public static final BitSet FOLLOW_NUMBER_in_inputTime1231 = new BitSet(new long[]{0x0000000400000000L});
7405 public static final BitSet FOLLOW_NUMBER_in_inputTime1233 = new BitSet(new long[]{0x0000000400000000L});
7406 public static final BitSet FOLLOW_NUMBER_in_inputTime1235 = new BitSet(new long[]{0x0000000400000000L});
7407 public static final BitSet FOLLOW_NUMBER_in_inputTime1237 = new BitSet(new long[]{0x0000000000000002L});
7408 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1247 = new BitSet(new long[]{0x0000000400000000L});
7409 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1249 = new BitSet(new long[]{0x0000000400000000L});
7410 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1251 = new BitSet(new long[]{0x0000000400000000L});
7411 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1253 = new BitSet(new long[]{0x0000000400000000L});
7412 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1255 = new BitSet(new long[]{0x0000000400000000L});
7413 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1257 = new BitSet(new long[]{0x0000000100000000L});
7414 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1262 = new BitSet(new long[]{0x0000000100000000L});
7415 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1264 = new BitSet(new long[]{0x0000000100000000L});
7416 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1266 = new BitSet(new long[]{0x0000000100000000L});
7417 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1271 = new BitSet(new long[]{0x0000000100000000L});
7418 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1273 = new BitSet(new long[]{0x0000000100000000L});
7419 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1275 = new BitSet(new long[]{0x0000000100000000L});
7420 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1280 = new BitSet(new long[]{0x0000000100000000L});
7421 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1282 = new BitSet(new long[]{0x0000000100000000L});
7422 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1284 = new BitSet(new long[]{0x0000000100000000L});
7423 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1289 = new BitSet(new long[]{0x0000000100000000L});
7424 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1291 = new BitSet(new long[]{0x0000000100000000L});
7425 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_messageInputReference1293 = new BitSet(new long[]{0x0000000400000000L});
7426 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1297 = new BitSet(new long[]{0x0000000400000000L});
7427 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1299 = new BitSet(new long[]{0x0000000400000000L});
7428 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1301 = new BitSet(new long[]{0x0000000400000000L});
7429 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1303 = new BitSet(new long[]{0x0000000400000000L});
7430 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1307 = new BitSet(new long[]{0x0000000400000000L});
7431 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1309 = new BitSet(new long[]{0x0000000400000000L});
7432 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1311 = new BitSet(new long[]{0x0000000400000000L});
7433 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1315 = new BitSet(new long[]{0x0000000400000000L});
7434 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1317 = new BitSet(new long[]{0x0000000400000000L});
7435 public static final BitSet FOLLOW_NUMBER_in_messageInputReference1319 = new BitSet(new long[]{0x0000000000000002L});
7436 public static final BitSet FOLLOW_NUMBER_in_outputDate1332 = new BitSet(new long[]{0x0000000400000000L});
7437 public static final BitSet FOLLOW_NUMBER_in_outputDate1334 = new BitSet(new long[]{0x0000000400000000L});
7438 public static final BitSet FOLLOW_NUMBER_in_outputDate1336 = new BitSet(new long[]{0x0000000400000000L});
7439 public static final BitSet FOLLOW_NUMBER_in_outputDate1338 = new BitSet(new long[]{0x0000000400000000L});
7440 public static final BitSet FOLLOW_NUMBER_in_outputDate1340 = new BitSet(new long[]{0x0000000400000000L});
7441 public static final BitSet FOLLOW_NUMBER_in_outputDate1342 = new BitSet(new long[]{0x0000000000000002L});
7442 public static final BitSet FOLLOW_NUMBER_in_outputTime1354 = new BitSet(new long[]{0x0000000400000000L});
7443 public static final BitSet FOLLOW_NUMBER_in_outputTime1356 = new BitSet(new long[]{0x0000000400000000L});
7444 public static final BitSet FOLLOW_NUMBER_in_outputTime1358 = new BitSet(new long[]{0x0000000400000000L});
7445 public static final BitSet FOLLOW_NUMBER_in_outputTime1360 = new BitSet(new long[]{0x0000000000000002L});
7446 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_applicationId1372 = new BitSet(new long[]{0x0000000000000002L});
7447 public static final BitSet FOLLOW_NUMBER_in_serviceId1382 = new BitSet(new long[]{0x0000000400000000L});
7448 public static final BitSet FOLLOW_NUMBER_in_serviceId1384 = new BitSet(new long[]{0x0000000000000002L});
7449 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1395 = new BitSet(new long[]{0x0000000100000000L});
7450 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1397 = new BitSet(new long[]{0x0000000100000000L});
7451 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1399 = new BitSet(new long[]{0x0000000100000000L});
7452 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1404 = new BitSet(new long[]{0x0000000100000000L});
7453 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1406 = new BitSet(new long[]{0x0000000100000000L});
7454 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1408 = new BitSet(new long[]{0x0000000100000000L});
7455 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1413 = new BitSet(new long[]{0x0000000100000000L});
7456 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1415 = new BitSet(new long[]{0x0000000100000000L});
7457 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1417 = new BitSet(new long[]{0x0000000100000000L});
7458 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1422 = new BitSet(new long[]{0x0000000100000000L});
7459 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1424 = new BitSet(new long[]{0x0000000100000000L});
7460 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_logicalTerminalAddress1426 = new BitSet(new long[]{0x0000000000000002L});
7461 public static final BitSet FOLLOW_NUMBER_in_sessionNumber1439 = new BitSet(new long[]{0x0000000400000000L});
7462 public static final BitSet FOLLOW_NUMBER_in_sessionNumber1441 = new BitSet(new long[]{0x0000000400000000L});
7463 public static final BitSet FOLLOW_NUMBER_in_sessionNumber1443 = new BitSet(new long[]{0x0000000400000000L});
7464 public static final BitSet FOLLOW_NUMBER_in_sessionNumber1445 = new BitSet(new long[]{0x0000000000000002L});
7465 public static final BitSet FOLLOW_NUMBER_in_sequenceNumber1456 = new BitSet(new long[]{0x0000000400000000L});
7466 public static final BitSet FOLLOW_NUMBER_in_sequenceNumber1458 = new BitSet(new long[]{0x0000000400000000L});
7467 public static final BitSet FOLLOW_NUMBER_in_sequenceNumber1460 = new BitSet(new long[]{0x0000000400000000L});
7468 public static final BitSet FOLLOW_NUMBER_in_sequenceNumber1464 = new BitSet(new long[]{0x0000000400000000L});
7469 public static final BitSet FOLLOW_NUMBER_in_sequenceNumber1466 = new BitSet(new long[]{0x0000000400000000L});
7470 public static final BitSet FOLLOW_NUMBER_in_sequenceNumber1468 = new BitSet(new long[]{0x0000000000000002L});
7471 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_code1480 = new BitSet(new long[]{0x0000000100000002L});
7472 public static final BitSet FOLLOW_NUMBER_in_timeIndication1492 = new BitSet(new long[]{0x0000000400000000L});
7473 public static final BitSet FOLLOW_NUMBER_in_timeIndication1494 = new BitSet(new long[]{0x0000000400000000L});
7474 public static final BitSet FOLLOW_NUMBER_in_timeIndication1496 = new BitSet(new long[]{0x0000000400000000L});
7475 public static final BitSet FOLLOW_NUMBER_in_timeIndication1498 = new BitSet(new long[]{0x0000000000000002L});
7476 public static final BitSet FOLLOW_set_in_sign0 = new BitSet(new long[]{0x0000000000000002L});
7477 public static final BitSet FOLLOW_NUMBER_in_timeOffset1524 = new BitSet(new long[]{0x0000000400000000L});
7478 public static final BitSet FOLLOW_NUMBER_in_timeOffset1526 = new BitSet(new long[]{0x0000000400000000L});
7479 public static final BitSet FOLLOW_NUMBER_in_timeOffset1528 = new BitSet(new long[]{0x0000000400000000L});
7480 public static final BitSet FOLLOW_NUMBER_in_timeOffset1530 = new BitSet(new long[]{0x0000000000000002L});
7481 public static final BitSet FOLLOW_set_in_senderReference1541 = new BitSet(new long[]{0x0000010700000002L});
7482 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bankOperationCode1568 = new BitSet(new long[]{0x0000000100000000L});
7483 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bankOperationCode1570 = new BitSet(new long[]{0x0000000100000000L});
7484 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bankOperationCode1572 = new BitSet(new long[]{0x0000000100000000L});
7485 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bankOperationCode1574 = new BitSet(new long[]{0x0000000000000002L});
7486 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_instruction1586 = new BitSet(new long[]{0x0000000100000000L});
7487 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_instruction1588 = new BitSet(new long[]{0x0000000100000000L});
7488 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_instruction1590 = new BitSet(new long[]{0x0000000100000000L});
7489 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_instruction1592 = new BitSet(new long[]{0x0000000000000002L});
7490 public static final BitSet FOLLOW_set_in_additionalInformation1606 = new BitSet(new long[]{0x0000000700000002L});
7491 public static final BitSet FOLLOW_set_in_transactionTypeCode1629 = new BitSet(new long[]{0x0000000500000000L});
7492 public static final BitSet FOLLOW_set_in_transactionTypeCode1637 = new BitSet(new long[]{0x0000000500000000L});
7493 public static final BitSet FOLLOW_set_in_transactionTypeCode1645 = new BitSet(new long[]{0x0000000000000002L});
7494 public static final BitSet FOLLOW_NUMBER_in_valueDate1664 = new BitSet(new long[]{0x0000000400000000L});
7495 public static final BitSet FOLLOW_NUMBER_in_valueDate1666 = new BitSet(new long[]{0x0000000400000000L});
7496 public static final BitSet FOLLOW_NUMBER_in_valueDate1668 = new BitSet(new long[]{0x0000000400000000L});
7497 public static final BitSet FOLLOW_NUMBER_in_valueDate1672 = new BitSet(new long[]{0x0000000400000000L});
7498 public static final BitSet FOLLOW_NUMBER_in_valueDate1674 = new BitSet(new long[]{0x0000000400000000L});
7499 public static final BitSet FOLLOW_NUMBER_in_valueDate1676 = new BitSet(new long[]{0x0000000000000002L});
7500 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_currency1687 = new BitSet(new long[]{0x0000000100000000L});
7501 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_currency1689 = new BitSet(new long[]{0x0000000100000000L});
7502 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_currency1691 = new BitSet(new long[]{0x0000000000000002L});
7503 public static final BitSet FOLLOW_NUMBER_in_amount1703 = new BitSet(new long[]{0x0000000400100000L});
7504 public static final BitSet FOLLOW_AMOUNT_SEPARATOR_in_amount1707 = new BitSet(new long[]{0x0000000400000002L});
7505 public static final BitSet FOLLOW_NUMBER_in_amount1710 = new BitSet(new long[]{0x0000000400000002L});
7506 public static final BitSet FOLLOW_NUMBER_in_exchangeRate1725 = new BitSet(new long[]{0x0000000000100000L});
7507 public static final BitSet FOLLOW_AMOUNT_SEPARATOR_in_exchangeRate1729 = new BitSet(new long[]{0x0000000400000000L});
7508 public static final BitSet FOLLOW_NUMBER_in_exchangeRate1732 = new BitSet(new long[]{0x0000000400000002L});
7509 public static final BitSet FOLLOW_set_in_account1745 = new BitSet(new long[]{0x0000000700000002L});
7510 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bicBai1769 = new BitSet(new long[]{0x0000000100000000L});
7511 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bicBai1771 = new BitSet(new long[]{0x0000000100000000L});
7512 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bicBai1773 = new BitSet(new long[]{0x0000000100000000L});
7513 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bicBai1778 = new BitSet(new long[]{0x0000000100000000L});
7514 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bicBai1780 = new BitSet(new long[]{0x0000000100000000L});
7515 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_bicBai1782 = new BitSet(new long[]{0x0000000500000000L});
7516 public static final BitSet FOLLOW_set_in_bicBai1789 = new BitSet(new long[]{0x0000000500000000L});
7517 public static final BitSet FOLLOW_set_in_bicBai1797 = new BitSet(new long[]{0x0000000500000002L});
7518 public static final BitSet FOLLOW_set_in_bicBai1810 = new BitSet(new long[]{0x0000000500000000L});
7519 public static final BitSet FOLLOW_set_in_bicBai1818 = new BitSet(new long[]{0x0000000500000000L});
7520 public static final BitSet FOLLOW_set_in_bicBai1826 = new BitSet(new long[]{0x0000000000000002L});
7521 public static final BitSet FOLLOW_line_in_nameAndAddress1849 = new BitSet(new long[]{0x0000000000000002L});
7522 public static final BitSet FOLLOW_line_in_nameAndAddress1855 = new BitSet(new long[]{0x0000010700000000L});
7523 public static final BitSet FOLLOW_line_in_nameAndAddress1857 = new BitSet(new long[]{0x0000000000000002L});
7524 public static final BitSet FOLLOW_line_in_nameAndAddress1862 = new BitSet(new long[]{0x0000010700000000L});
7525 public static final BitSet FOLLOW_line_in_nameAndAddress1864 = new BitSet(new long[]{0x0000010700000000L});
7526 public static final BitSet FOLLOW_line_in_nameAndAddress1866 = new BitSet(new long[]{0x0000000000000002L});
7527 public static final BitSet FOLLOW_line_in_nameAndAddress1871 = new BitSet(new long[]{0x0000010700000000L});
7528 public static final BitSet FOLLOW_line_in_nameAndAddress1873 = new BitSet(new long[]{0x0000010700000000L});
7529 public static final BitSet FOLLOW_line_in_nameAndAddress1875 = new BitSet(new long[]{0x0000010700000000L});
7530 public static final BitSet FOLLOW_line_in_nameAndAddress1877 = new BitSet(new long[]{0x0000000000000002L});
7531 public static final BitSet FOLLOW_CODE_SEPARATOR_in_partyIdentifier1890 = new BitSet(new long[]{0x0000010700000000L});
7532 public static final BitSet FOLLOW_genericLine_in_partyIdentifier1892 = new BitSet(new long[]{0x0000000000000002L});
7533 public static final BitSet FOLLOW_partyIdentifierCode_in_partyIdentifier1907 = new BitSet(new long[]{0x0000000000020000L});
7534 public static final BitSet FOLLOW_CODE_SEPARATOR_in_partyIdentifier1909 = new BitSet(new long[]{0x0000010700000000L});
7535 public static final BitSet FOLLOW_genericLine_in_partyIdentifier1911 = new BitSet(new long[]{0x0000000000000002L});
7536 public static final BitSet FOLLOW_nameAndAddressNumberCode_in_line1934 = new BitSet(new long[]{0x0000000000020000L});
7537 public static final BitSet FOLLOW_CODE_SEPARATOR_in_line1936 = new BitSet(new long[]{0x0000010700000000L});
7538 public static final BitSet FOLLOW_genericLine_in_line1940 = new BitSet(new long[]{0x0000000000000002L});
7539 public static final BitSet FOLLOW_set_in_genericLine1952 = new BitSet(new long[]{0x0000010F00000000L});
7540 public static final BitSet FOLLOW_CRLF_in_genericLine1969 = new BitSet(new long[]{0x0000000000000002L});
7541 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_partyIdentifierCode1981 = new BitSet(new long[]{0x0000000100000000L});
7542 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_partyIdentifierCode1983 = new BitSet(new long[]{0x0000000100000000L});
7543 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_partyIdentifierCode1985 = new BitSet(new long[]{0x0000000100000000L});
7544 public static final BitSet FOLLOW_UPPERCASE_LETTER_in_partyIdentifierCode1987 = new BitSet(new long[]{0x0000000000000002L});
7545 public static final BitSet FOLLOW_NUMBER_in_nameAndAddressNumberCode1998 = new BitSet(new long[]{0x0000000000000002L});
7546 public static final BitSet FOLLOW_set_in_bankPriorityCode2011 = new BitSet(new long[]{0x0000000700000002L});
7547 public static final BitSet FOLLOW_set_in_messageUserReference2037 = new BitSet(new long[]{0x0000000700000002L});
7548 public static final BitSet FOLLOW_set_in_messageAuthenticationCode2062 = new BitSet(new long[]{0x0000000700000002L});
7549 public static final BitSet FOLLOW_set_in_checksum2088 = new BitSet(new long[]{0x0000000700000002L});
7550 public static final BitSet FOLLOW_set_in_possibleDuplicateEmission2112 = new BitSet(new long[]{0x0000000700000002L});
7551 public static final BitSet FOLLOW_set_in_delayedMessage2136 = new BitSet(new long[]{0x0000000700000002L});
7552
7553 }