@plurnk/plurnk-grammar 0.74.22 → 0.74.29

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (28) hide show
  1. package/dist/schema/TelemetryEvent.json +6 -2
  2. package/dist/src/AstBuilder.d.ts +2 -2
  3. package/dist/src/AstBuilder.d.ts.map +1 -1
  4. package/dist/src/AstBuilder.js +7 -3
  5. package/dist/src/AstBuilder.js.map +1 -1
  6. package/dist/src/PlurnkParseError.d.ts.map +1 -1
  7. package/dist/src/PlurnkParseError.js +1 -0
  8. package/dist/src/PlurnkParseError.js.map +1 -1
  9. package/dist/src/PlurnkParser.d.ts +1 -0
  10. package/dist/src/PlurnkParser.d.ts.map +1 -1
  11. package/dist/src/PlurnkParser.js +62 -35
  12. package/dist/src/PlurnkParser.js.map +1 -1
  13. package/dist/src/generated/plurnkLexer.d.ts +31 -18
  14. package/dist/src/generated/plurnkLexer.d.ts.map +1 -1
  15. package/dist/src/generated/plurnkLexer.js +360 -227
  16. package/dist/src/generated/plurnkLexer.js.map +1 -1
  17. package/dist/src/generated/plurnkParser.d.ts +104 -54
  18. package/dist/src/generated/plurnkParser.d.ts.map +1 -1
  19. package/dist/src/generated/plurnkParser.js +890 -428
  20. package/dist/src/generated/plurnkParser.js.map +1 -1
  21. package/dist/src/generated/plurnkParserVisitor.d.ts +28 -0
  22. package/dist/src/generated/plurnkParserVisitor.d.ts.map +1 -1
  23. package/dist/src/generated/plurnkParserVisitor.js +24 -0
  24. package/dist/src/generated/plurnkParserVisitor.js.map +1 -1
  25. package/dist/src/types.generated.d.ts +4 -0
  26. package/dist/src/types.generated.d.ts.map +1 -1
  27. package/package.json +1 -1
  28. package/plurnk.md +7 -4
package/dist/src/generated/plurnkParser.js CHANGED
@@ -14,67 +14,74 @@ export class plurnkParser extends antlr.Parser {
14
14
  static BODY_TEXT = 12;
15
15
  static CLOSE_TAG = 13;
16
16
  static TEXT = 14;
17
- static OPEN_FIND = 15;
18
- static OPEN_READ = 16;
19
- static OPEN_EDIT = 17;
20
- static OPEN_COPY = 18;
21
- static OPEN_MOVE = 19;
22
- static OPEN_OPEN = 20;
23
- static OPEN_FOLD = 21;
24
- static OPEN_SEND = 22;
25
- static OPEN_EXEC = 23;
26
- static OPEN_KILL = 24;
27
- static OPEN_PLAN = 25;
28
- static WS = 26;
29
- static SLOTS_WS = 27;
30
- static ST_WS = 28;
31
- static SI_WS = 29;
32
- static SD_WS = 30;
33
- static ST_COMMA = 31;
34
- static B_COLON = 32;
17
+ static OPEN_TURN = 15;
18
+ static CLOSE_TURN = 16;
19
+ static OPEN_FIND = 17;
20
+ static OPEN_READ = 18;
21
+ static OPEN_EDIT = 19;
22
+ static OPEN_COPY = 20;
23
+ static OPEN_MOVE = 21;
24
+ static OPEN_OPEN = 22;
25
+ static OPEN_FOLD = 23;
26
+ static OPEN_SEND = 24;
27
+ static OPEN_EXEC = 25;
28
+ static OPEN_KILL = 26;
29
+ static OPEN_PLAN = 27;
30
+ static WS = 28;
31
+ static SLOTS_WS = 29;
32
+ static ST_WS = 30;
33
+ static SI_WS = 31;
34
+ static SD_WS = 32;
35
+ static ST_COMMA = 33;
36
+ static B_COLON = 34;
35
37
  static RULE_document = 0;
36
- static RULE_statementSeq = 1;
37
- static RULE_statement = 2;
38
- static RULE_findStatement = 3;
39
- static RULE_readStatement = 4;
40
- static RULE_editStatement = 5;
41
- static RULE_copyStatement = 6;
42
- static RULE_moveStatement = 7;
43
- static RULE_openStatement = 8;
44
- static RULE_foldStatement = 9;
45
- static RULE_sendStatement = 10;
46
- static RULE_execStatement = 11;
47
- static RULE_killStatement = 12;
48
- static RULE_planStatement = 13;
49
- static RULE_tagOpModifiers = 14;
50
- static RULE_intOpModifiers = 15;
51
- static RULE_execModifiers = 16;
52
- static RULE_tagSignal = 17;
53
- static RULE_intSignal = 18;
54
- static RULE_identSignal = 19;
55
- static RULE_target = 20;
56
- static RULE_lineMarker = 21;
57
- static RULE_body = 22;
38
+ static RULE_log = 1;
39
+ static RULE_turnStatement = 2;
40
+ static RULE_turnContent = 3;
41
+ static RULE_statementSeq = 4;
42
+ static RULE_statement = 5;
43
+ static RULE_midStatement = 6;
44
+ static RULE_findStatement = 7;
45
+ static RULE_readStatement = 8;
46
+ static RULE_editStatement = 9;
47
+ static RULE_copyStatement = 10;
48
+ static RULE_moveStatement = 11;
49
+ static RULE_openStatement = 12;
50
+ static RULE_foldStatement = 13;
51
+ static RULE_sendStatement = 14;
52
+ static RULE_execStatement = 15;
53
+ static RULE_killStatement = 16;
54
+ static RULE_planStatement = 17;
55
+ static RULE_tagOpModifiers = 18;
56
+ static RULE_intOpModifiers = 19;
57
+ static RULE_execModifiers = 20;
58
+ static RULE_tagSignal = 21;
59
+ static RULE_intSignal = 22;
60
+ static RULE_identSignal = 23;
61
+ static RULE_target = 24;
62
+ static RULE_lineMarker = 25;
63
+ static RULE_body = 26;
58
64
  static literalNames = [
59
65
  null, null, null, null, null, null, null, null, null, null, null,
60
66
  null, null, null, null, null, null, null, null, null, null, null,
61
- null, null, null, null, null, null, null, null, null, "','", "':'"
67
+ null, null, null, null, null, null, null, null, null, null, null,
68
+ "','", "':'"
62
69
  ];
63
70
  static symbolicNames = [
64
71
  null, "LBRACKET", "RBRACKET", "LPAREN", "RPAREN", "L_MARKER", "COLON",
65
72
  "COMMA", "INT", "IDENT", "TAG", "TARGET_TEXT", "BODY_TEXT", "CLOSE_TAG",
66
- "TEXT", "OPEN_FIND", "OPEN_READ", "OPEN_EDIT", "OPEN_COPY", "OPEN_MOVE",
67
- "OPEN_OPEN", "OPEN_FOLD", "OPEN_SEND", "OPEN_EXEC", "OPEN_KILL",
68
- "OPEN_PLAN", "WS", "SLOTS_WS", "ST_WS", "SI_WS", "SD_WS", "ST_COMMA",
69
- "B_COLON"
73
+ "TEXT", "OPEN_TURN", "CLOSE_TURN", "OPEN_FIND", "OPEN_READ", "OPEN_EDIT",
74
+ "OPEN_COPY", "OPEN_MOVE", "OPEN_OPEN", "OPEN_FOLD", "OPEN_SEND",
75
+ "OPEN_EXEC", "OPEN_KILL", "OPEN_PLAN", "WS", "SLOTS_WS", "ST_WS",
76
+ "SI_WS", "SD_WS", "ST_COMMA", "B_COLON"
70
77
  ];
71
78
  static ruleNames = [
72
- "document", "statementSeq", "statement", "findStatement", "readStatement",
73
- "editStatement", "copyStatement", "moveStatement", "openStatement",
74
- "foldStatement", "sendStatement", "execStatement", "killStatement",
75
- "planStatement", "tagOpModifiers", "intOpModifiers", "execModifiers",
76
- "tagSignal", "intSignal", "identSignal", "target", "lineMarker",
77
- "body",
79
+ "document", "log", "turnStatement", "turnContent", "statementSeq",
80
+ "statement", "midStatement", "findStatement", "readStatement", "editStatement",
81
+ "copyStatement", "moveStatement", "openStatement", "foldStatement",
82
+ "sendStatement", "execStatement", "killStatement", "planStatement",
83
+ "tagOpModifiers", "intOpModifiers", "execModifiers", "tagSignal",
84
+ "intSignal", "identSignal", "target", "lineMarker", "body",
78
85
  ];
79
86
  get grammarFileName() { return "plurnkParser.g4"; }
80
87
  get literalNames() { return plurnkParser.literalNames; }
@@ -91,18 +98,139 @@ export class plurnkParser extends antlr.Parser {
91
98
  document() {
92
99
  let localContext = new DocumentContext(this.context, this.state);
93
100
  this.enterRule(localContext, 0, plurnkParser.RULE_document);
101
+ try {
102
+ this.enterOuterAlt(localContext, 1);
103
+ {
104
+ this.state = 54;
105
+ this.turnContent();
106
+ this.state = 55;
107
+ this.match(plurnkParser.EOF);
108
+ }
109
+ }
110
+ catch (re) {
111
+ if (re instanceof antlr.RecognitionException) {
112
+ this.errorHandler.reportError(this, re);
113
+ this.errorHandler.recover(this, re);
114
+ }
115
+ else {
116
+ throw re;
117
+ }
118
+ }
119
+ finally {
120
+ this.exitRule();
121
+ }
122
+ return localContext;
123
+ }
124
+ log() {
125
+ let localContext = new LogContext(this.context, this.state);
126
+ this.enterRule(localContext, 2, plurnkParser.RULE_log);
127
+ let _la;
128
+ try {
129
+ this.enterOuterAlt(localContext, 1);
130
+ {
131
+ this.state = 58;
132
+ this.errorHandler.sync(this);
133
+ _la = this.tokenStream.LA(1);
134
+ do {
135
+ {
136
+ {
137
+ this.state = 57;
138
+ this.turnStatement();
139
+ }
140
+ }
141
+ this.state = 60;
142
+ this.errorHandler.sync(this);
143
+ _la = this.tokenStream.LA(1);
144
+ } while (_la === 15);
145
+ this.state = 62;
146
+ this.match(plurnkParser.EOF);
147
+ }
148
+ }
149
+ catch (re) {
150
+ if (re instanceof antlr.RecognitionException) {
151
+ this.errorHandler.reportError(this, re);
152
+ this.errorHandler.recover(this, re);
153
+ }
154
+ else {
155
+ throw re;
156
+ }
157
+ }
158
+ finally {
159
+ this.exitRule();
160
+ }
161
+ return localContext;
162
+ }
163
+ turnStatement() {
164
+ let localContext = new TurnStatementContext(this.context, this.state);
165
+ this.enterRule(localContext, 4, plurnkParser.RULE_turnStatement);
166
+ let _la;
167
+ try {
168
+ this.enterOuterAlt(localContext, 1);
169
+ {
170
+ this.state = 64;
171
+ this.match(plurnkParser.OPEN_TURN);
172
+ this.state = 66;
173
+ this.errorHandler.sync(this);
174
+ _la = this.tokenStream.LA(1);
175
+ if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
176
+ {
177
+ this.state = 65;
178
+ this.tagOpModifiers();
179
+ }
180
+ }
181
+ this.state = 68;
182
+ this.match(plurnkParser.COLON);
183
+ this.state = 69;
184
+ this.turnContent();
185
+ this.state = 70;
186
+ this.match(plurnkParser.CLOSE_TURN);
187
+ }
188
+ }
189
+ catch (re) {
190
+ if (re instanceof antlr.RecognitionException) {
191
+ this.errorHandler.reportError(this, re);
192
+ this.errorHandler.recover(this, re);
193
+ }
194
+ else {
195
+ throw re;
196
+ }
197
+ }
198
+ finally {
199
+ this.exitRule();
200
+ }
201
+ return localContext;
202
+ }
203
+ turnContent() {
204
+ let localContext = new TurnContentContext(this.context, this.state);
205
+ this.enterRule(localContext, 6, plurnkParser.RULE_turnContent);
94
206
  let _la;
95
207
  try {
96
208
  let alternative;
97
209
  this.enterOuterAlt(localContext, 1);
98
210
  {
99
- this.state = 50;
211
+ this.state = 75;
212
+ this.errorHandler.sync(this);
213
+ _la = this.tokenStream.LA(1);
214
+ while (_la === 14) {
215
+ {
216
+ {
217
+ this.state = 72;
218
+ this.match(plurnkParser.TEXT);
219
+ }
220
+ }
221
+ this.state = 77;
222
+ this.errorHandler.sync(this);
223
+ _la = this.tokenStream.LA(1);
224
+ }
225
+ this.state = 78;
226
+ this.planStatement();
227
+ this.state = 83;
100
228
  this.errorHandler.sync(this);
101
- alternative = this.interpreter.adaptivePredict(this.tokenStream, 1, this.context);
229
+ alternative = this.interpreter.adaptivePredict(this.tokenStream, 4, this.context);
102
230
  while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
103
231
  if (alternative === 1) {
104
232
  {
105
- this.state = 48;
233
+ this.state = 81;
106
234
  this.errorHandler.sync(this);
107
235
  switch (this.tokenStream.LA(1)) {
108
236
  case plurnkParser.OPEN_FIND:
@@ -115,15 +243,14 @@ export class plurnkParser extends antlr.Parser {
115
243
  case plurnkParser.OPEN_SEND:
116
244
  case plurnkParser.OPEN_EXEC:
117
245
  case plurnkParser.OPEN_KILL:
118
- case plurnkParser.OPEN_PLAN:
119
246
  {
120
- this.state = 46;
121
- this.statement();
247
+ this.state = 79;
248
+ this.midStatement();
122
249
  }
123
250
  break;
124
251
  case plurnkParser.TEXT:
125
252
  {
126
- this.state = 47;
253
+ this.state = 80;
127
254
  this.match(plurnkParser.TEXT);
128
255
  }
129
256
  break;
@@ -132,28 +259,26 @@ export class plurnkParser extends antlr.Parser {
132
259
  }
133
260
  }
134
261
  }
135
- this.state = 52;
262
+ this.state = 85;
136
263
  this.errorHandler.sync(this);
137
- alternative = this.interpreter.adaptivePredict(this.tokenStream, 1, this.context);
264
+ alternative = this.interpreter.adaptivePredict(this.tokenStream, 4, this.context);
138
265
  }
139
- this.state = 53;
266
+ this.state = 86;
140
267
  this.sendStatement();
141
- this.state = 57;
268
+ this.state = 90;
142
269
  this.errorHandler.sync(this);
143
270
  _la = this.tokenStream.LA(1);
144
271
  while (_la === 14) {
145
272
  {
146
273
  {
147
- this.state = 54;
274
+ this.state = 87;
148
275
  this.match(plurnkParser.TEXT);
149
276
  }
150
277
  }
151
- this.state = 59;
278
+ this.state = 92;
152
279
  this.errorHandler.sync(this);
153
280
  _la = this.tokenStream.LA(1);
154
281
  }
155
- this.state = 60;
156
- this.match(plurnkParser.EOF);
157
282
  }
158
283
  }
159
284
  catch (re) {
@@ -172,26 +297,26 @@ export class plurnkParser extends antlr.Parser {
172
297
  }
173
298
  statementSeq() {
174
299
  let localContext = new StatementSeqContext(this.context, this.state);
175
- this.enterRule(localContext, 2, plurnkParser.RULE_statementSeq);
300
+ this.enterRule(localContext, 8, plurnkParser.RULE_statementSeq);
176
301
  let _la;
177
302
  try {
178
303
  this.enterOuterAlt(localContext, 1);
179
304
  {
180
- this.state = 65;
305
+ this.state = 96;
181
306
  this.errorHandler.sync(this);
182
307
  _la = this.tokenStream.LA(1);
183
- while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 67076096) !== 0)) {
308
+ while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 268304384) !== 0)) {
184
309
  {
185
310
  {
186
- this.state = 62;
311
+ this.state = 93;
187
312
  this.statement();
188
313
  }
189
314
  }
190
- this.state = 67;
315
+ this.state = 98;
191
316
  this.errorHandler.sync(this);
192
317
  _la = this.tokenStream.LA(1);
193
318
  }
194
- this.state = 68;
319
+ this.state = 99;
195
320
  this.match(plurnkParser.EOF);
196
321
  }
197
322
  }
@@ -211,85 +336,85 @@ export class plurnkParser extends antlr.Parser {
211
336
  }
212
337
  statement() {
213
338
  let localContext = new StatementContext(this.context, this.state);
214
- this.enterRule(localContext, 4, plurnkParser.RULE_statement);
339
+ this.enterRule(localContext, 10, plurnkParser.RULE_statement);
215
340
  try {
216
- this.state = 81;
341
+ this.state = 112;
217
342
  this.errorHandler.sync(this);
218
343
  switch (this.tokenStream.LA(1)) {
219
344
  case plurnkParser.OPEN_FIND:
220
345
  this.enterOuterAlt(localContext, 1);
221
346
  {
222
- this.state = 70;
347
+ this.state = 101;
223
348
  this.findStatement();
224
349
  }
225
350
  break;
226
351
  case plurnkParser.OPEN_READ:
227
352
  this.enterOuterAlt(localContext, 2);
228
353
  {
229
- this.state = 71;
354
+ this.state = 102;
230
355
  this.readStatement();
231
356
  }
232
357
  break;
233
358
  case plurnkParser.OPEN_EDIT:
234
359
  this.enterOuterAlt(localContext, 3);
235
360
  {
236
- this.state = 72;
361
+ this.state = 103;
237
362
  this.editStatement();
238
363
  }
239
364
  break;
240
365
  case plurnkParser.OPEN_COPY:
241
366
  this.enterOuterAlt(localContext, 4);
242
367
  {
243
- this.state = 73;
368
+ this.state = 104;
244
369
  this.copyStatement();
245
370
  }
246
371
  break;
247
372
  case plurnkParser.OPEN_MOVE:
248
373
  this.enterOuterAlt(localContext, 5);
249
374
  {
250
- this.state = 74;
375
+ this.state = 105;
251
376
  this.moveStatement();
252
377
  }
253
378
  break;
254
379
  case plurnkParser.OPEN_OPEN:
255
380
  this.enterOuterAlt(localContext, 6);
256
381
  {
257
- this.state = 75;
382
+ this.state = 106;
258
383
  this.openStatement();
259
384
  }
260
385
  break;
261
386
  case plurnkParser.OPEN_FOLD:
262
387
  this.enterOuterAlt(localContext, 7);
263
388
  {
264
- this.state = 76;
389
+ this.state = 107;
265
390
  this.foldStatement();
266
391
  }
267
392
  break;
268
393
  case plurnkParser.OPEN_SEND:
269
394
  this.enterOuterAlt(localContext, 8);
270
395
  {
271
- this.state = 77;
396
+ this.state = 108;
272
397
  this.sendStatement();
273
398
  }
274
399
  break;
275
400
  case plurnkParser.OPEN_EXEC:
276
401
  this.enterOuterAlt(localContext, 9);
277
402
  {
278
- this.state = 78;
403
+ this.state = 109;
279
404
  this.execStatement();
280
405
  }
281
406
  break;
282
407
  case plurnkParser.OPEN_KILL:
283
408
  this.enterOuterAlt(localContext, 10);
284
409
  {
285
- this.state = 79;
410
+ this.state = 110;
286
411
  this.killStatement();
287
412
  }
288
413
  break;
289
414
  case plurnkParser.OPEN_PLAN:
290
415
  this.enterOuterAlt(localContext, 11);
291
416
  {
292
- this.state = 80;
417
+ this.state = 111;
293
418
  this.planStatement();
294
419
  }
295
420
  break;
@@ -311,36 +436,138 @@ export class plurnkParser extends antlr.Parser {
311
436
  }
312
437
  return localContext;
313
438
  }
439
+ midStatement() {
440
+ let localContext = new MidStatementContext(this.context, this.state);
441
+ this.enterRule(localContext, 12, plurnkParser.RULE_midStatement);
442
+ try {
443
+ this.state = 124;
444
+ this.errorHandler.sync(this);
445
+ switch (this.tokenStream.LA(1)) {
446
+ case plurnkParser.OPEN_FIND:
447
+ this.enterOuterAlt(localContext, 1);
448
+ {
449
+ this.state = 114;
450
+ this.findStatement();
451
+ }
452
+ break;
453
+ case plurnkParser.OPEN_READ:
454
+ this.enterOuterAlt(localContext, 2);
455
+ {
456
+ this.state = 115;
457
+ this.readStatement();
458
+ }
459
+ break;
460
+ case plurnkParser.OPEN_EDIT:
461
+ this.enterOuterAlt(localContext, 3);
462
+ {
463
+ this.state = 116;
464
+ this.editStatement();
465
+ }
466
+ break;
467
+ case plurnkParser.OPEN_COPY:
468
+ this.enterOuterAlt(localContext, 4);
469
+ {
470
+ this.state = 117;
471
+ this.copyStatement();
472
+ }
473
+ break;
474
+ case plurnkParser.OPEN_MOVE:
475
+ this.enterOuterAlt(localContext, 5);
476
+ {
477
+ this.state = 118;
478
+ this.moveStatement();
479
+ }
480
+ break;
481
+ case plurnkParser.OPEN_OPEN:
482
+ this.enterOuterAlt(localContext, 6);
483
+ {
484
+ this.state = 119;
485
+ this.openStatement();
486
+ }
487
+ break;
488
+ case plurnkParser.OPEN_FOLD:
489
+ this.enterOuterAlt(localContext, 7);
490
+ {
491
+ this.state = 120;
492
+ this.foldStatement();
493
+ }
494
+ break;
495
+ case plurnkParser.OPEN_SEND:
496
+ this.enterOuterAlt(localContext, 8);
497
+ {
498
+ this.state = 121;
499
+ this.sendStatement();
500
+ }
501
+ break;
502
+ case plurnkParser.OPEN_EXEC:
503
+ this.enterOuterAlt(localContext, 9);
504
+ {
505
+ this.state = 122;
506
+ this.execStatement();
507
+ }
508
+ break;
509
+ case plurnkParser.OPEN_KILL:
510
+ this.enterOuterAlt(localContext, 10);
511
+ {
512
+ this.state = 123;
513
+ this.killStatement();
514
+ }
515
+ break;
516
+ default:
517
+ throw new antlr.NoViableAltException(this);
518
+ }
519
+ }
520
+ catch (re) {
521
+ if (re instanceof antlr.RecognitionException) {
522
+ this.errorHandler.reportError(this, re);
523
+ this.errorHandler.recover(this, re);
524
+ }
525
+ else {
526
+ throw re;
527
+ }
528
+ }
529
+ finally {
530
+ this.exitRule();
531
+ }
532
+ return localContext;
533
+ }
314
534
  findStatement() {
315
535
  let localContext = new FindStatementContext(this.context, this.state);
316
- this.enterRule(localContext, 6, plurnkParser.RULE_findStatement);
536
+ this.enterRule(localContext, 14, plurnkParser.RULE_findStatement);
317
537
  let _la;
318
538
  try {
319
539
  this.enterOuterAlt(localContext, 1);
320
540
  {
321
- this.state = 83;
541
+ this.state = 126;
322
542
  this.match(plurnkParser.OPEN_FIND);
323
- this.state = 85;
543
+ this.state = 128;
324
544
  this.errorHandler.sync(this);
325
545
  _la = this.tokenStream.LA(1);
326
546
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
327
547
  {
328
- this.state = 84;
548
+ this.state = 127;
329
549
  this.tagOpModifiers();
330
550
  }
331
551
  }
332
- this.state = 87;
333
- this.match(plurnkParser.COLON);
334
- this.state = 89;
552
+ this.state = 131;
553
+ this.errorHandler.sync(this);
554
+ _la = this.tokenStream.LA(1);
555
+ if (_la === 6) {
556
+ {
557
+ this.state = 130;
558
+ this.match(plurnkParser.COLON);
559
+ }
560
+ }
561
+ this.state = 134;
335
562
  this.errorHandler.sync(this);
336
563
  _la = this.tokenStream.LA(1);
337
564
  if (_la === 12) {
338
565
  {
339
- this.state = 88;
566
+ this.state = 133;
340
567
  this.body();
341
568
  }
342
569
  }
343
- this.state = 91;
570
+ this.state = 136;
344
571
  this.match(plurnkParser.CLOSE_TAG);
345
572
  }
346
573
  }
@@ -360,34 +587,41 @@ export class plurnkParser extends antlr.Parser {
360
587
  }
361
588
  readStatement() {
362
589
  let localContext = new ReadStatementContext(this.context, this.state);
363
- this.enterRule(localContext, 8, plurnkParser.RULE_readStatement);
590
+ this.enterRule(localContext, 16, plurnkParser.RULE_readStatement);
364
591
  let _la;
365
592
  try {
366
593
  this.enterOuterAlt(localContext, 1);
367
594
  {
368
- this.state = 93;
595
+ this.state = 138;
369
596
  this.match(plurnkParser.OPEN_READ);
370
- this.state = 95;
597
+ this.state = 140;
371
598
  this.errorHandler.sync(this);
372
599
  _la = this.tokenStream.LA(1);
373
600
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
374
601
  {
375
- this.state = 94;
602
+ this.state = 139;
376
603
  this.tagOpModifiers();
377
604
  }
378
605
  }
379
- this.state = 97;
380
- this.match(plurnkParser.COLON);
381
- this.state = 99;
606
+ this.state = 143;
607
+ this.errorHandler.sync(this);
608
+ _la = this.tokenStream.LA(1);
609
+ if (_la === 6) {
610
+ {
611
+ this.state = 142;
612
+ this.match(plurnkParser.COLON);
613
+ }
614
+ }
615
+ this.state = 146;
382
616
  this.errorHandler.sync(this);
383
617
  _la = this.tokenStream.LA(1);
384
618
  if (_la === 12) {
385
619
  {
386
- this.state = 98;
620
+ this.state = 145;
387
621
  this.body();
388
622
  }
389
623
  }
390
- this.state = 101;
624
+ this.state = 148;
391
625
  this.match(plurnkParser.CLOSE_TAG);
392
626
  }
393
627
  }
@@ -407,34 +641,41 @@ export class plurnkParser extends antlr.Parser {
407
641
  }
408
642
  editStatement() {
409
643
  let localContext = new EditStatementContext(this.context, this.state);
410
- this.enterRule(localContext, 10, plurnkParser.RULE_editStatement);
644
+ this.enterRule(localContext, 18, plurnkParser.RULE_editStatement);
411
645
  let _la;
412
646
  try {
413
647
  this.enterOuterAlt(localContext, 1);
414
648
  {
415
- this.state = 103;
649
+ this.state = 150;
416
650
  this.match(plurnkParser.OPEN_EDIT);
417
- this.state = 105;
651
+ this.state = 152;
418
652
  this.errorHandler.sync(this);
419
653
  _la = this.tokenStream.LA(1);
420
654
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
421
655
  {
422
- this.state = 104;
656
+ this.state = 151;
423
657
  this.tagOpModifiers();
424
658
  }
425
659
  }
426
- this.state = 107;
427
- this.match(plurnkParser.COLON);
428
- this.state = 109;
660
+ this.state = 155;
661
+ this.errorHandler.sync(this);
662
+ _la = this.tokenStream.LA(1);
663
+ if (_la === 6) {
664
+ {
665
+ this.state = 154;
666
+ this.match(plurnkParser.COLON);
667
+ }
668
+ }
669
+ this.state = 158;
429
670
  this.errorHandler.sync(this);
430
671
  _la = this.tokenStream.LA(1);
431
672
  if (_la === 12) {
432
673
  {
433
- this.state = 108;
674
+ this.state = 157;
434
675
  this.body();
435
676
  }
436
677
  }
437
- this.state = 111;
678
+ this.state = 160;
438
679
  this.match(plurnkParser.CLOSE_TAG);
439
680
  }
440
681
  }
@@ -454,34 +695,41 @@ export class plurnkParser extends antlr.Parser {
454
695
  }
455
696
  copyStatement() {
456
697
  let localContext = new CopyStatementContext(this.context, this.state);
457
- this.enterRule(localContext, 12, plurnkParser.RULE_copyStatement);
698
+ this.enterRule(localContext, 20, plurnkParser.RULE_copyStatement);
458
699
  let _la;
459
700
  try {
460
701
  this.enterOuterAlt(localContext, 1);
461
702
  {
462
- this.state = 113;
703
+ this.state = 162;
463
704
  this.match(plurnkParser.OPEN_COPY);
464
- this.state = 115;
705
+ this.state = 164;
465
706
  this.errorHandler.sync(this);
466
707
  _la = this.tokenStream.LA(1);
467
708
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
468
709
  {
469
- this.state = 114;
710
+ this.state = 163;
470
711
  this.tagOpModifiers();
471
712
  }
472
713
  }
473
- this.state = 117;
474
- this.match(plurnkParser.COLON);
475
- this.state = 119;
714
+ this.state = 167;
715
+ this.errorHandler.sync(this);
716
+ _la = this.tokenStream.LA(1);
717
+ if (_la === 6) {
718
+ {
719
+ this.state = 166;
720
+ this.match(plurnkParser.COLON);
721
+ }
722
+ }
723
+ this.state = 170;
476
724
  this.errorHandler.sync(this);
477
725
  _la = this.tokenStream.LA(1);
478
726
  if (_la === 12) {
479
727
  {
480
- this.state = 118;
728
+ this.state = 169;
481
729
  this.body();
482
730
  }
483
731
  }
484
- this.state = 121;
732
+ this.state = 172;
485
733
  this.match(plurnkParser.CLOSE_TAG);
486
734
  }
487
735
  }
@@ -501,34 +749,41 @@ export class plurnkParser extends antlr.Parser {
501
749
  }
502
750
  moveStatement() {
503
751
  let localContext = new MoveStatementContext(this.context, this.state);
504
- this.enterRule(localContext, 14, plurnkParser.RULE_moveStatement);
752
+ this.enterRule(localContext, 22, plurnkParser.RULE_moveStatement);
505
753
  let _la;
506
754
  try {
507
755
  this.enterOuterAlt(localContext, 1);
508
756
  {
509
- this.state = 123;
757
+ this.state = 174;
510
758
  this.match(plurnkParser.OPEN_MOVE);
511
- this.state = 125;
759
+ this.state = 176;
512
760
  this.errorHandler.sync(this);
513
761
  _la = this.tokenStream.LA(1);
514
762
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
515
763
  {
516
- this.state = 124;
764
+ this.state = 175;
517
765
  this.tagOpModifiers();
518
766
  }
519
767
  }
520
- this.state = 127;
521
- this.match(plurnkParser.COLON);
522
- this.state = 129;
768
+ this.state = 179;
769
+ this.errorHandler.sync(this);
770
+ _la = this.tokenStream.LA(1);
771
+ if (_la === 6) {
772
+ {
773
+ this.state = 178;
774
+ this.match(plurnkParser.COLON);
775
+ }
776
+ }
777
+ this.state = 182;
523
778
  this.errorHandler.sync(this);
524
779
  _la = this.tokenStream.LA(1);
525
780
  if (_la === 12) {
526
781
  {
527
- this.state = 128;
782
+ this.state = 181;
528
783
  this.body();
529
784
  }
530
785
  }
531
- this.state = 131;
786
+ this.state = 184;
532
787
  this.match(plurnkParser.CLOSE_TAG);
533
788
  }
534
789
  }
@@ -548,34 +803,41 @@ export class plurnkParser extends antlr.Parser {
548
803
  }
549
804
  openStatement() {
550
805
  let localContext = new OpenStatementContext(this.context, this.state);
551
- this.enterRule(localContext, 16, plurnkParser.RULE_openStatement);
806
+ this.enterRule(localContext, 24, plurnkParser.RULE_openStatement);
552
807
  let _la;
553
808
  try {
554
809
  this.enterOuterAlt(localContext, 1);
555
810
  {
556
- this.state = 133;
811
+ this.state = 186;
557
812
  this.match(plurnkParser.OPEN_OPEN);
558
- this.state = 135;
813
+ this.state = 188;
559
814
  this.errorHandler.sync(this);
560
815
  _la = this.tokenStream.LA(1);
561
816
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
562
817
  {
563
- this.state = 134;
818
+ this.state = 187;
564
819
  this.tagOpModifiers();
565
820
  }
566
821
  }
567
- this.state = 137;
568
- this.match(plurnkParser.COLON);
569
- this.state = 139;
822
+ this.state = 191;
823
+ this.errorHandler.sync(this);
824
+ _la = this.tokenStream.LA(1);
825
+ if (_la === 6) {
826
+ {
827
+ this.state = 190;
828
+ this.match(plurnkParser.COLON);
829
+ }
830
+ }
831
+ this.state = 194;
570
832
  this.errorHandler.sync(this);
571
833
  _la = this.tokenStream.LA(1);
572
834
  if (_la === 12) {
573
835
  {
574
- this.state = 138;
836
+ this.state = 193;
575
837
  this.body();
576
838
  }
577
839
  }
578
- this.state = 141;
840
+ this.state = 196;
579
841
  this.match(plurnkParser.CLOSE_TAG);
580
842
  }
581
843
  }
@@ -595,34 +857,41 @@ export class plurnkParser extends antlr.Parser {
595
857
  }
596
858
  foldStatement() {
597
859
  let localContext = new FoldStatementContext(this.context, this.state);
598
- this.enterRule(localContext, 18, plurnkParser.RULE_foldStatement);
860
+ this.enterRule(localContext, 26, plurnkParser.RULE_foldStatement);
599
861
  let _la;
600
862
  try {
601
863
  this.enterOuterAlt(localContext, 1);
602
864
  {
603
- this.state = 143;
865
+ this.state = 198;
604
866
  this.match(plurnkParser.OPEN_FOLD);
605
- this.state = 145;
867
+ this.state = 200;
606
868
  this.errorHandler.sync(this);
607
869
  _la = this.tokenStream.LA(1);
608
870
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
609
871
  {
610
- this.state = 144;
872
+ this.state = 199;
611
873
  this.tagOpModifiers();
612
874
  }
613
875
  }
614
- this.state = 147;
615
- this.match(plurnkParser.COLON);
616
- this.state = 149;
876
+ this.state = 203;
877
+ this.errorHandler.sync(this);
878
+ _la = this.tokenStream.LA(1);
879
+ if (_la === 6) {
880
+ {
881
+ this.state = 202;
882
+ this.match(plurnkParser.COLON);
883
+ }
884
+ }
885
+ this.state = 206;
617
886
  this.errorHandler.sync(this);
618
887
  _la = this.tokenStream.LA(1);
619
888
  if (_la === 12) {
620
889
  {
621
- this.state = 148;
890
+ this.state = 205;
622
891
  this.body();
623
892
  }
624
893
  }
625
- this.state = 151;
894
+ this.state = 208;
626
895
  this.match(plurnkParser.CLOSE_TAG);
627
896
  }
628
897
  }
@@ -642,34 +911,41 @@ export class plurnkParser extends antlr.Parser {
642
911
  }
643
912
  sendStatement() {
644
913
  let localContext = new SendStatementContext(this.context, this.state);
645
- this.enterRule(localContext, 20, plurnkParser.RULE_sendStatement);
914
+ this.enterRule(localContext, 28, plurnkParser.RULE_sendStatement);
646
915
  let _la;
647
916
  try {
648
917
  this.enterOuterAlt(localContext, 1);
649
918
  {
650
- this.state = 153;
919
+ this.state = 210;
651
920
  this.match(plurnkParser.OPEN_SEND);
652
- this.state = 155;
921
+ this.state = 212;
653
922
  this.errorHandler.sync(this);
654
923
  _la = this.tokenStream.LA(1);
655
924
  if (_la === 1 || _la === 3) {
656
925
  {
657
- this.state = 154;
926
+ this.state = 211;
658
927
  this.intOpModifiers();
659
928
  }
660
929
  }
661
- this.state = 157;
662
- this.match(plurnkParser.COLON);
663
- this.state = 159;
930
+ this.state = 215;
931
+ this.errorHandler.sync(this);
932
+ _la = this.tokenStream.LA(1);
933
+ if (_la === 6) {
934
+ {
935
+ this.state = 214;
936
+ this.match(plurnkParser.COLON);
937
+ }
938
+ }
939
+ this.state = 218;
664
940
  this.errorHandler.sync(this);
665
941
  _la = this.tokenStream.LA(1);
666
942
  if (_la === 12) {
667
943
  {
668
- this.state = 158;
944
+ this.state = 217;
669
945
  this.body();
670
946
  }
671
947
  }
672
- this.state = 161;
948
+ this.state = 220;
673
949
  this.match(plurnkParser.CLOSE_TAG);
674
950
  }
675
951
  }
@@ -689,34 +965,41 @@ export class plurnkParser extends antlr.Parser {
689
965
  }
690
966
  execStatement() {
691
967
  let localContext = new ExecStatementContext(this.context, this.state);
692
- this.enterRule(localContext, 22, plurnkParser.RULE_execStatement);
968
+ this.enterRule(localContext, 30, plurnkParser.RULE_execStatement);
693
969
  let _la;
694
970
  try {
695
971
  this.enterOuterAlt(localContext, 1);
696
972
  {
697
- this.state = 163;
973
+ this.state = 222;
698
974
  this.match(plurnkParser.OPEN_EXEC);
699
- this.state = 165;
975
+ this.state = 224;
700
976
  this.errorHandler.sync(this);
701
977
  _la = this.tokenStream.LA(1);
702
978
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
703
979
  {
704
- this.state = 164;
980
+ this.state = 223;
705
981
  this.execModifiers();
706
982
  }
707
983
  }
708
- this.state = 167;
709
- this.match(plurnkParser.COLON);
710
- this.state = 169;
984
+ this.state = 227;
985
+ this.errorHandler.sync(this);
986
+ _la = this.tokenStream.LA(1);
987
+ if (_la === 6) {
988
+ {
989
+ this.state = 226;
990
+ this.match(plurnkParser.COLON);
991
+ }
992
+ }
993
+ this.state = 230;
711
994
  this.errorHandler.sync(this);
712
995
  _la = this.tokenStream.LA(1);
713
996
  if (_la === 12) {
714
997
  {
715
- this.state = 168;
998
+ this.state = 229;
716
999
  this.body();
717
1000
  }
718
1001
  }
719
- this.state = 171;
1002
+ this.state = 232;
720
1003
  this.match(plurnkParser.CLOSE_TAG);
721
1004
  }
722
1005
  }
@@ -736,34 +1019,41 @@ export class plurnkParser extends antlr.Parser {
736
1019
  }
737
1020
  killStatement() {
738
1021
  let localContext = new KillStatementContext(this.context, this.state);
739
- this.enterRule(localContext, 24, plurnkParser.RULE_killStatement);
1022
+ this.enterRule(localContext, 32, plurnkParser.RULE_killStatement);
740
1023
  let _la;
741
1024
  try {
742
1025
  this.enterOuterAlt(localContext, 1);
743
1026
  {
744
- this.state = 173;
1027
+ this.state = 234;
745
1028
  this.match(plurnkParser.OPEN_KILL);
746
- this.state = 175;
1029
+ this.state = 236;
747
1030
  this.errorHandler.sync(this);
748
1031
  _la = this.tokenStream.LA(1);
749
1032
  if (_la === 1 || _la === 3) {
750
1033
  {
751
- this.state = 174;
1034
+ this.state = 235;
752
1035
  this.intOpModifiers();
753
1036
  }
754
1037
  }
755
- this.state = 177;
756
- this.match(plurnkParser.COLON);
757
- this.state = 179;
1038
+ this.state = 239;
1039
+ this.errorHandler.sync(this);
1040
+ _la = this.tokenStream.LA(1);
1041
+ if (_la === 6) {
1042
+ {
1043
+ this.state = 238;
1044
+ this.match(plurnkParser.COLON);
1045
+ }
1046
+ }
1047
+ this.state = 242;
758
1048
  this.errorHandler.sync(this);
759
1049
  _la = this.tokenStream.LA(1);
760
1050
  if (_la === 12) {
761
1051
  {
762
- this.state = 178;
1052
+ this.state = 241;
763
1053
  this.body();
764
1054
  }
765
1055
  }
766
- this.state = 181;
1056
+ this.state = 244;
767
1057
  this.match(plurnkParser.CLOSE_TAG);
768
1058
  }
769
1059
  }
@@ -783,34 +1073,41 @@ export class plurnkParser extends antlr.Parser {
783
1073
  }
784
1074
  planStatement() {
785
1075
  let localContext = new PlanStatementContext(this.context, this.state);
786
- this.enterRule(localContext, 26, plurnkParser.RULE_planStatement);
1076
+ this.enterRule(localContext, 34, plurnkParser.RULE_planStatement);
787
1077
  let _la;
788
1078
  try {
789
1079
  this.enterOuterAlt(localContext, 1);
790
1080
  {
791
- this.state = 183;
1081
+ this.state = 246;
792
1082
  this.match(plurnkParser.OPEN_PLAN);
793
- this.state = 185;
1083
+ this.state = 248;
794
1084
  this.errorHandler.sync(this);
795
1085
  _la = this.tokenStream.LA(1);
796
1086
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
797
1087
  {
798
- this.state = 184;
1088
+ this.state = 247;
799
1089
  this.tagOpModifiers();
800
1090
  }
801
1091
  }
802
- this.state = 187;
803
- this.match(plurnkParser.COLON);
804
- this.state = 189;
1092
+ this.state = 251;
1093
+ this.errorHandler.sync(this);
1094
+ _la = this.tokenStream.LA(1);
1095
+ if (_la === 6) {
1096
+ {
1097
+ this.state = 250;
1098
+ this.match(plurnkParser.COLON);
1099
+ }
1100
+ }
1101
+ this.state = 254;
805
1102
  this.errorHandler.sync(this);
806
1103
  _la = this.tokenStream.LA(1);
807
1104
  if (_la === 12) {
808
1105
  {
809
- this.state = 188;
1106
+ this.state = 253;
810
1107
  this.body();
811
1108
  }
812
1109
  }
813
- this.state = 191;
1110
+ this.state = 256;
814
1111
  this.match(plurnkParser.CLOSE_TAG);
815
1112
  }
816
1113
  }
@@ -830,30 +1127,30 @@ export class plurnkParser extends antlr.Parser {
830
1127
  }
831
1128
  tagOpModifiers() {
832
1129
  let localContext = new TagOpModifiersContext(this.context, this.state);
833
- this.enterRule(localContext, 28, plurnkParser.RULE_tagOpModifiers);
1130
+ this.enterRule(localContext, 36, plurnkParser.RULE_tagOpModifiers);
834
1131
  let _la;
835
1132
  try {
836
- this.state = 226;
1133
+ this.state = 291;
837
1134
  this.errorHandler.sync(this);
838
1135
  switch (this.tokenStream.LA(1)) {
839
1136
  case plurnkParser.LBRACKET:
840
1137
  this.enterOuterAlt(localContext, 1);
841
1138
  {
842
- this.state = 193;
1139
+ this.state = 258;
843
1140
  this.tagSignal();
844
- this.state = 202;
1141
+ this.state = 267;
845
1142
  this.errorHandler.sync(this);
846
1143
  switch (this.tokenStream.LA(1)) {
847
1144
  case plurnkParser.LPAREN:
848
1145
  {
849
- this.state = 194;
1146
+ this.state = 259;
850
1147
  this.target();
851
- this.state = 196;
1148
+ this.state = 261;
852
1149
  this.errorHandler.sync(this);
853
1150
  _la = this.tokenStream.LA(1);
854
1151
  if (_la === 5) {
855
1152
  {
856
- this.state = 195;
1153
+ this.state = 260;
857
1154
  this.lineMarker();
858
1155
  }
859
1156
  }
@@ -861,20 +1158,22 @@ export class plurnkParser extends antlr.Parser {
861
1158
  break;
862
1159
  case plurnkParser.L_MARKER:
863
1160
  {
864
- this.state = 198;
1161
+ this.state = 263;
865
1162
  this.lineMarker();
866
- this.state = 200;
1163
+ this.state = 265;
867
1164
  this.errorHandler.sync(this);
868
1165
  _la = this.tokenStream.LA(1);
869
1166
  if (_la === 3) {
870
1167
  {
871
- this.state = 199;
1168
+ this.state = 264;
872
1169
  this.target();
873
1170
  }
874
1171
  }
875
1172
  }
876
1173
  break;
877
1174
  case plurnkParser.COLON:
1175
+ case plurnkParser.BODY_TEXT:
1176
+ case plurnkParser.CLOSE_TAG:
878
1177
  break;
879
1178
  default:
880
1179
  break;
@@ -884,21 +1183,21 @@ export class plurnkParser extends antlr.Parser {
884
1183
  case plurnkParser.LPAREN:
885
1184
  this.enterOuterAlt(localContext, 2);
886
1185
  {
887
- this.state = 204;
1186
+ this.state = 269;
888
1187
  this.target();
889
- this.state = 213;
1188
+ this.state = 278;
890
1189
  this.errorHandler.sync(this);
891
1190
  switch (this.tokenStream.LA(1)) {
892
1191
  case plurnkParser.LBRACKET:
893
1192
  {
894
- this.state = 205;
1193
+ this.state = 270;
895
1194
  this.tagSignal();
896
- this.state = 207;
1195
+ this.state = 272;
897
1196
  this.errorHandler.sync(this);
898
1197
  _la = this.tokenStream.LA(1);
899
1198
  if (_la === 5) {
900
1199
  {
901
- this.state = 206;
1200
+ this.state = 271;
902
1201
  this.lineMarker();
903
1202
  }
904
1203
  }
@@ -906,20 +1205,22 @@ export class plurnkParser extends antlr.Parser {
906
1205
  break;
907
1206
  case plurnkParser.L_MARKER:
908
1207
  {
909
- this.state = 209;
1208
+ this.state = 274;
910
1209
  this.lineMarker();
911
- this.state = 211;
1210
+ this.state = 276;
912
1211
  this.errorHandler.sync(this);
913
1212
  _la = this.tokenStream.LA(1);
914
1213
  if (_la === 1) {
915
1214
  {
916
- this.state = 210;
1215
+ this.state = 275;
917
1216
  this.tagSignal();
918
1217
  }
919
1218
  }
920
1219
  }
921
1220
  break;
922
1221
  case plurnkParser.COLON:
1222
+ case plurnkParser.BODY_TEXT:
1223
+ case plurnkParser.CLOSE_TAG:
923
1224
  break;
924
1225
  default:
925
1226
  break;
@@ -929,21 +1230,21 @@ export class plurnkParser extends antlr.Parser {
929
1230
  case plurnkParser.L_MARKER:
930
1231
  this.enterOuterAlt(localContext, 3);
931
1232
  {
932
- this.state = 215;
1233
+ this.state = 280;
933
1234
  this.lineMarker();
934
- this.state = 224;
1235
+ this.state = 289;
935
1236
  this.errorHandler.sync(this);
936
1237
  switch (this.tokenStream.LA(1)) {
937
1238
  case plurnkParser.LBRACKET:
938
1239
  {
939
- this.state = 216;
1240
+ this.state = 281;
940
1241
  this.tagSignal();
941
- this.state = 218;
1242
+ this.state = 283;
942
1243
  this.errorHandler.sync(this);
943
1244
  _la = this.tokenStream.LA(1);
944
1245
  if (_la === 3) {
945
1246
  {
946
- this.state = 217;
1247
+ this.state = 282;
947
1248
  this.target();
948
1249
  }
949
1250
  }
@@ -951,20 +1252,22 @@ export class plurnkParser extends antlr.Parser {
951
1252
  break;
952
1253
  case plurnkParser.LPAREN:
953
1254
  {
954
- this.state = 220;
1255
+ this.state = 285;
955
1256
  this.target();
956
- this.state = 222;
1257
+ this.state = 287;
957
1258
  this.errorHandler.sync(this);
958
1259
  _la = this.tokenStream.LA(1);
959
1260
  if (_la === 1) {
960
1261
  {
961
- this.state = 221;
1262
+ this.state = 286;
962
1263
  this.tagSignal();
963
1264
  }
964
1265
  }
965
1266
  }
966
1267
  break;
967
1268
  case plurnkParser.COLON:
1269
+ case plurnkParser.BODY_TEXT:
1270
+ case plurnkParser.CLOSE_TAG:
968
1271
  break;
969
1272
  default:
970
1273
  break;
@@ -991,23 +1294,23 @@ export class plurnkParser extends antlr.Parser {
991
1294
  }
992
1295
  intOpModifiers() {
993
1296
  let localContext = new IntOpModifiersContext(this.context, this.state);
994
- this.enterRule(localContext, 30, plurnkParser.RULE_intOpModifiers);
1297
+ this.enterRule(localContext, 38, plurnkParser.RULE_intOpModifiers);
995
1298
  let _la;
996
1299
  try {
997
- this.state = 236;
1300
+ this.state = 301;
998
1301
  this.errorHandler.sync(this);
999
1302
  switch (this.tokenStream.LA(1)) {
1000
1303
  case plurnkParser.LBRACKET:
1001
1304
  this.enterOuterAlt(localContext, 1);
1002
1305
  {
1003
- this.state = 228;
1306
+ this.state = 293;
1004
1307
  this.intSignal();
1005
- this.state = 230;
1308
+ this.state = 295;
1006
1309
  this.errorHandler.sync(this);
1007
1310
  _la = this.tokenStream.LA(1);
1008
1311
  if (_la === 3) {
1009
1312
  {
1010
- this.state = 229;
1313
+ this.state = 294;
1011
1314
  this.target();
1012
1315
  }
1013
1316
  }
@@ -1016,14 +1319,14 @@ export class plurnkParser extends antlr.Parser {
1016
1319
  case plurnkParser.LPAREN:
1017
1320
  this.enterOuterAlt(localContext, 2);
1018
1321
  {
1019
- this.state = 232;
1322
+ this.state = 297;
1020
1323
  this.target();
1021
- this.state = 234;
1324
+ this.state = 299;
1022
1325
  this.errorHandler.sync(this);
1023
1326
  _la = this.tokenStream.LA(1);
1024
1327
  if (_la === 1) {
1025
1328
  {
1026
- this.state = 233;
1329
+ this.state = 298;
1027
1330
  this.intSignal();
1028
1331
  }
1029
1332
  }
@@ -1049,30 +1352,30 @@ export class plurnkParser extends antlr.Parser {
1049
1352
  }
1050
1353
  execModifiers() {
1051
1354
  let localContext = new ExecModifiersContext(this.context, this.state);
1052
- this.enterRule(localContext, 32, plurnkParser.RULE_execModifiers);
1355
+ this.enterRule(localContext, 40, plurnkParser.RULE_execModifiers);
1053
1356
  let _la;
1054
1357
  try {
1055
- this.state = 271;
1358
+ this.state = 336;
1056
1359
  this.errorHandler.sync(this);
1057
1360
  switch (this.tokenStream.LA(1)) {
1058
1361
  case plurnkParser.LBRACKET:
1059
1362
  this.enterOuterAlt(localContext, 1);
1060
1363
  {
1061
- this.state = 238;
1364
+ this.state = 303;
1062
1365
  this.identSignal();
1063
- this.state = 247;
1366
+ this.state = 312;
1064
1367
  this.errorHandler.sync(this);
1065
1368
  switch (this.tokenStream.LA(1)) {
1066
1369
  case plurnkParser.LPAREN:
1067
1370
  {
1068
- this.state = 239;
1371
+ this.state = 304;
1069
1372
  this.target();
1070
- this.state = 241;
1373
+ this.state = 306;
1071
1374
  this.errorHandler.sync(this);
1072
1375
  _la = this.tokenStream.LA(1);
1073
1376
  if (_la === 5) {
1074
1377
  {
1075
- this.state = 240;
1378
+ this.state = 305;
1076
1379
  this.lineMarker();
1077
1380
  }
1078
1381
  }
@@ -1080,20 +1383,22 @@ export class plurnkParser extends antlr.Parser {
1080
1383
  break;
1081
1384
  case plurnkParser.L_MARKER:
1082
1385
  {
1083
- this.state = 243;
1386
+ this.state = 308;
1084
1387
  this.lineMarker();
1085
- this.state = 245;
1388
+ this.state = 310;
1086
1389
  this.errorHandler.sync(this);
1087
1390
  _la = this.tokenStream.LA(1);
1088
1391
  if (_la === 3) {
1089
1392
  {
1090
- this.state = 244;
1393
+ this.state = 309;
1091
1394
  this.target();
1092
1395
  }
1093
1396
  }
1094
1397
  }
1095
1398
  break;
1096
1399
  case plurnkParser.COLON:
1400
+ case plurnkParser.BODY_TEXT:
1401
+ case plurnkParser.CLOSE_TAG:
1097
1402
  break;
1098
1403
  default:
1099
1404
  break;
@@ -1103,21 +1408,21 @@ export class plurnkParser extends antlr.Parser {
1103
1408
  case plurnkParser.LPAREN:
1104
1409
  this.enterOuterAlt(localContext, 2);
1105
1410
  {
1106
- this.state = 249;
1411
+ this.state = 314;
1107
1412
  this.target();
1108
- this.state = 258;
1413
+ this.state = 323;
1109
1414
  this.errorHandler.sync(this);
1110
1415
  switch (this.tokenStream.LA(1)) {
1111
1416
  case plurnkParser.LBRACKET:
1112
1417
  {
1113
- this.state = 250;
1418
+ this.state = 315;
1114
1419
  this.identSignal();
1115
- this.state = 252;
1420
+ this.state = 317;
1116
1421
  this.errorHandler.sync(this);
1117
1422
  _la = this.tokenStream.LA(1);
1118
1423
  if (_la === 5) {
1119
1424
  {
1120
- this.state = 251;
1425
+ this.state = 316;
1121
1426
  this.lineMarker();
1122
1427
  }
1123
1428
  }
@@ -1125,20 +1430,22 @@ export class plurnkParser extends antlr.Parser {
1125
1430
  break;
1126
1431
  case plurnkParser.L_MARKER:
1127
1432
  {
1128
- this.state = 254;
1433
+ this.state = 319;
1129
1434
  this.lineMarker();
1130
- this.state = 256;
1435
+ this.state = 321;
1131
1436
  this.errorHandler.sync(this);
1132
1437
  _la = this.tokenStream.LA(1);
1133
1438
  if (_la === 1) {
1134
1439
  {
1135
- this.state = 255;
1440
+ this.state = 320;
1136
1441
  this.identSignal();
1137
1442
  }
1138
1443
  }
1139
1444
  }
1140
1445
  break;
1141
1446
  case plurnkParser.COLON:
1447
+ case plurnkParser.BODY_TEXT:
1448
+ case plurnkParser.CLOSE_TAG:
1142
1449
  break;
1143
1450
  default:
1144
1451
  break;
@@ -1148,21 +1455,21 @@ export class plurnkParser extends antlr.Parser {
1148
1455
  case plurnkParser.L_MARKER:
1149
1456
  this.enterOuterAlt(localContext, 3);
1150
1457
  {
1151
- this.state = 260;
1458
+ this.state = 325;
1152
1459
  this.lineMarker();
1153
- this.state = 269;
1460
+ this.state = 334;
1154
1461
  this.errorHandler.sync(this);
1155
1462
  switch (this.tokenStream.LA(1)) {
1156
1463
  case plurnkParser.LBRACKET:
1157
1464
  {
1158
- this.state = 261;
1465
+ this.state = 326;
1159
1466
  this.identSignal();
1160
- this.state = 263;
1467
+ this.state = 328;
1161
1468
  this.errorHandler.sync(this);
1162
1469
  _la = this.tokenStream.LA(1);
1163
1470
  if (_la === 3) {
1164
1471
  {
1165
- this.state = 262;
1472
+ this.state = 327;
1166
1473
  this.target();
1167
1474
  }
1168
1475
  }
@@ -1170,20 +1477,22 @@ export class plurnkParser extends antlr.Parser {
1170
1477
  break;
1171
1478
  case plurnkParser.LPAREN:
1172
1479
  {
1173
- this.state = 265;
1480
+ this.state = 330;
1174
1481
  this.target();
1175
- this.state = 267;
1482
+ this.state = 332;
1176
1483
  this.errorHandler.sync(this);
1177
1484
  _la = this.tokenStream.LA(1);
1178
1485
  if (_la === 1) {
1179
1486
  {
1180
- this.state = 266;
1487
+ this.state = 331;
1181
1488
  this.identSignal();
1182
1489
  }
1183
1490
  }
1184
1491
  }
1185
1492
  break;
1186
1493
  case plurnkParser.COLON:
1494
+ case plurnkParser.BODY_TEXT:
1495
+ case plurnkParser.CLOSE_TAG:
1187
1496
  break;
1188
1497
  default:
1189
1498
  break;
@@ -1210,20 +1519,20 @@ export class plurnkParser extends antlr.Parser {
1210
1519
  }
1211
1520
  tagSignal() {
1212
1521
  let localContext = new TagSignalContext(this.context, this.state);
1213
- this.enterRule(localContext, 34, plurnkParser.RULE_tagSignal);
1522
+ this.enterRule(localContext, 42, plurnkParser.RULE_tagSignal);
1214
1523
  let _la;
1215
1524
  try {
1216
1525
  this.enterOuterAlt(localContext, 1);
1217
1526
  {
1218
- this.state = 273;
1527
+ this.state = 338;
1219
1528
  this.match(plurnkParser.LBRACKET);
1220
- this.state = 277;
1529
+ this.state = 342;
1221
1530
  this.errorHandler.sync(this);
1222
1531
  _la = this.tokenStream.LA(1);
1223
1532
  while (_la === 7 || _la === 10) {
1224
1533
  {
1225
1534
  {
1226
- this.state = 274;
1535
+ this.state = 339;
1227
1536
  _la = this.tokenStream.LA(1);
1228
1537
  if (!(_la === 7 || _la === 10)) {
1229
1538
  this.errorHandler.recoverInline(this);
@@ -1234,11 +1543,11 @@ export class plurnkParser extends antlr.Parser {
1234
1543
  }
1235
1544
  }
1236
1545
  }
1237
- this.state = 279;
1546
+ this.state = 344;
1238
1547
  this.errorHandler.sync(this);
1239
1548
  _la = this.tokenStream.LA(1);
1240
1549
  }
1241
- this.state = 280;
1550
+ this.state = 345;
1242
1551
  this.match(plurnkParser.RBRACKET);
1243
1552
  }
1244
1553
  }
@@ -1258,23 +1567,23 @@ export class plurnkParser extends antlr.Parser {
1258
1567
  }
1259
1568
  intSignal() {
1260
1569
  let localContext = new IntSignalContext(this.context, this.state);
1261
- this.enterRule(localContext, 36, plurnkParser.RULE_intSignal);
1570
+ this.enterRule(localContext, 44, plurnkParser.RULE_intSignal);
1262
1571
  let _la;
1263
1572
  try {
1264
1573
  this.enterOuterAlt(localContext, 1);
1265
1574
  {
1266
- this.state = 282;
1575
+ this.state = 347;
1267
1576
  this.match(plurnkParser.LBRACKET);
1268
- this.state = 284;
1577
+ this.state = 349;
1269
1578
  this.errorHandler.sync(this);
1270
1579
  _la = this.tokenStream.LA(1);
1271
1580
  if (_la === 8) {
1272
1581
  {
1273
- this.state = 283;
1582
+ this.state = 348;
1274
1583
  this.match(plurnkParser.INT);
1275
1584
  }
1276
1585
  }
1277
- this.state = 286;
1586
+ this.state = 351;
1278
1587
  this.match(plurnkParser.RBRACKET);
1279
1588
  }
1280
1589
  }
@@ -1294,23 +1603,23 @@ export class plurnkParser extends antlr.Parser {
1294
1603
  }
1295
1604
  identSignal() {
1296
1605
  let localContext = new IdentSignalContext(this.context, this.state);
1297
- this.enterRule(localContext, 38, plurnkParser.RULE_identSignal);
1606
+ this.enterRule(localContext, 46, plurnkParser.RULE_identSignal);
1298
1607
  let _la;
1299
1608
  try {
1300
1609
  this.enterOuterAlt(localContext, 1);
1301
1610
  {
1302
- this.state = 288;
1611
+ this.state = 353;
1303
1612
  this.match(plurnkParser.LBRACKET);
1304
- this.state = 290;
1613
+ this.state = 355;
1305
1614
  this.errorHandler.sync(this);
1306
1615
  _la = this.tokenStream.LA(1);
1307
1616
  if (_la === 9) {
1308
1617
  {
1309
- this.state = 289;
1618
+ this.state = 354;
1310
1619
  this.match(plurnkParser.IDENT);
1311
1620
  }
1312
1621
  }
1313
- this.state = 292;
1622
+ this.state = 357;
1314
1623
  this.match(plurnkParser.RBRACKET);
1315
1624
  }
1316
1625
  }
@@ -1330,23 +1639,23 @@ export class plurnkParser extends antlr.Parser {
1330
1639
  }
1331
1640
  target() {
1332
1641
  let localContext = new TargetContext(this.context, this.state);
1333
- this.enterRule(localContext, 40, plurnkParser.RULE_target);
1642
+ this.enterRule(localContext, 48, plurnkParser.RULE_target);
1334
1643
  let _la;
1335
1644
  try {
1336
1645
  this.enterOuterAlt(localContext, 1);
1337
1646
  {
1338
- this.state = 294;
1647
+ this.state = 359;
1339
1648
  this.match(plurnkParser.LPAREN);
1340
- this.state = 296;
1649
+ this.state = 361;
1341
1650
  this.errorHandler.sync(this);
1342
1651
  _la = this.tokenStream.LA(1);
1343
1652
  if (_la === 11) {
1344
1653
  {
1345
- this.state = 295;
1654
+ this.state = 360;
1346
1655
  this.match(plurnkParser.TARGET_TEXT);
1347
1656
  }
1348
1657
  }
1349
- this.state = 298;
1658
+ this.state = 363;
1350
1659
  this.match(plurnkParser.RPAREN);
1351
1660
  }
1352
1661
  }
@@ -1366,11 +1675,11 @@ export class plurnkParser extends antlr.Parser {
1366
1675
  }
1367
1676
  lineMarker() {
1368
1677
  let localContext = new LineMarkerContext(this.context, this.state);
1369
- this.enterRule(localContext, 42, plurnkParser.RULE_lineMarker);
1678
+ this.enterRule(localContext, 50, plurnkParser.RULE_lineMarker);
1370
1679
  try {
1371
1680
  this.enterOuterAlt(localContext, 1);
1372
1681
  {
1373
- this.state = 300;
1682
+ this.state = 365;
1374
1683
  this.match(plurnkParser.L_MARKER);
1375
1684
  }
1376
1685
  }
@@ -1390,22 +1699,22 @@ export class plurnkParser extends antlr.Parser {
1390
1699
  }
1391
1700
  body() {
1392
1701
  let localContext = new BodyContext(this.context, this.state);
1393
- this.enterRule(localContext, 44, plurnkParser.RULE_body);
1702
+ this.enterRule(localContext, 52, plurnkParser.RULE_body);
1394
1703
  let _la;
1395
1704
  try {
1396
1705
  this.enterOuterAlt(localContext, 1);
1397
1706
  {
1398
- this.state = 303;
1707
+ this.state = 368;
1399
1708
  this.errorHandler.sync(this);
1400
1709
  _la = this.tokenStream.LA(1);
1401
1710
  do {
1402
1711
  {
1403
1712
  {
1404
- this.state = 302;
1713
+ this.state = 367;
1405
1714
  this.match(plurnkParser.BODY_TEXT);
1406
1715
  }
1407
1716
  }
1408
- this.state = 305;
1717
+ this.state = 370;
1409
1718
  this.errorHandler.sync(this);
1410
1719
  _la = this.tokenStream.LA(1);
1411
1720
  } while (_la === 12);
@@ -1426,124 +1735,153 @@ export class plurnkParser extends antlr.Parser {
1426
1735
  return localContext;
1427
1736
  }
1428
1737
  static _serializedATN = [
1429
- 4, 1, 32, 308, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7,
1738
+ 4, 1, 34, 373, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7,
1430
1739
  6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13,
1431
1740
  2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20,
1432
- 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 1, 0, 1, 0, 5, 0, 49, 8, 0, 10, 0, 12, 0, 52, 9, 0, 1, 0,
1433
- 1, 0, 5, 0, 56, 8, 0, 10, 0, 12, 0, 59, 9, 0, 1, 0, 1, 0, 1, 1, 5, 1, 64, 8, 1, 10, 1, 12, 1,
1434
- 67, 9, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 82,
1435
- 8, 2, 1, 3, 1, 3, 3, 3, 86, 8, 3, 1, 3, 1, 3, 3, 3, 90, 8, 3, 1, 3, 1, 3, 1, 4, 1, 4, 3, 4, 96,
1436
- 8, 4, 1, 4, 1, 4, 3, 4, 100, 8, 4, 1, 4, 1, 4, 1, 5, 1, 5, 3, 5, 106, 8, 5, 1, 5, 1, 5, 3, 5,
1437
- 110, 8, 5, 1, 5, 1, 5, 1, 6, 1, 6, 3, 6, 116, 8, 6, 1, 6, 1, 6, 3, 6, 120, 8, 6, 1, 6, 1, 6,
1438
- 1, 7, 1, 7, 3, 7, 126, 8, 7, 1, 7, 1, 7, 3, 7, 130, 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 3, 8, 136,
1439
- 8, 8, 1, 8, 1, 8, 3, 8, 140, 8, 8, 1, 8, 1, 8, 1, 9, 1, 9, 3, 9, 146, 8, 9, 1, 9, 1, 9, 3, 9,
1440
- 150, 8, 9, 1, 9, 1, 9, 1, 10, 1, 10, 3, 10, 156, 8, 10, 1, 10, 1, 10, 3, 10, 160, 8, 10,
1441
- 1, 10, 1, 10, 1, 11, 1, 11, 3, 11, 166, 8, 11, 1, 11, 1, 11, 3, 11, 170, 8, 11, 1, 11, 1,
1442
- 11, 1, 12, 1, 12, 3, 12, 176, 8, 12, 1, 12, 1, 12, 3, 12, 180, 8, 12, 1, 12, 1, 12, 1, 13,
1443
- 1, 13, 3, 13, 186, 8, 13, 1, 13, 1, 13, 3, 13, 190, 8, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1,
1444
- 14, 3, 14, 197, 8, 14, 1, 14, 1, 14, 3, 14, 201, 8, 14, 3, 14, 203, 8, 14, 1, 14, 1, 14,
1445
- 1, 14, 3, 14, 208, 8, 14, 1, 14, 1, 14, 3, 14, 212, 8, 14, 3, 14, 214, 8, 14, 1, 14, 1,
1446
- 14, 1, 14, 3, 14, 219, 8, 14, 1, 14, 1, 14, 3, 14, 223, 8, 14, 3, 14, 225, 8, 14, 3, 14,
1447
- 227, 8, 14, 1, 15, 1, 15, 3, 15, 231, 8, 15, 1, 15, 1, 15, 3, 15, 235, 8, 15, 3, 15, 237,
1448
- 8, 15, 1, 16, 1, 16, 1, 16, 3, 16, 242, 8, 16, 1, 16, 1, 16, 3, 16, 246, 8, 16, 3, 16, 248,
1449
- 8, 16, 1, 16, 1, 16, 1, 16, 3, 16, 253, 8, 16, 1, 16, 1, 16, 3, 16, 257, 8, 16, 3, 16, 259,
1450
- 8, 16, 1, 16, 1, 16, 1, 16, 3, 16, 264, 8, 16, 1, 16, 1, 16, 3, 16, 268, 8, 16, 3, 16, 270,
1451
- 8, 16, 3, 16, 272, 8, 16, 1, 17, 1, 17, 5, 17, 276, 8, 17, 10, 17, 12, 17, 279, 9, 17,
1452
- 1, 17, 1, 17, 1, 18, 1, 18, 3, 18, 285, 8, 18, 1, 18, 1, 18, 1, 19, 1, 19, 3, 19, 291, 8,
1453
- 19, 1, 19, 1, 19, 1, 20, 1, 20, 3, 20, 297, 8, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 4,
1454
- 22, 304, 8, 22, 11, 22, 12, 22, 305, 1, 22, 0, 0, 23, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
1455
- 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 0, 1, 2, 0, 7, 7, 10, 10, 356, 0, 50,
1456
- 1, 0, 0, 0, 2, 65, 1, 0, 0, 0, 4, 81, 1, 0, 0, 0, 6, 83, 1, 0, 0, 0, 8, 93, 1, 0, 0, 0, 10, 103,
1457
- 1, 0, 0, 0, 12, 113, 1, 0, 0, 0, 14, 123, 1, 0, 0, 0, 16, 133, 1, 0, 0, 0, 18, 143, 1, 0,
1458
- 0, 0, 20, 153, 1, 0, 0, 0, 22, 163, 1, 0, 0, 0, 24, 173, 1, 0, 0, 0, 26, 183, 1, 0, 0, 0,
1459
- 28, 226, 1, 0, 0, 0, 30, 236, 1, 0, 0, 0, 32, 271, 1, 0, 0, 0, 34, 273, 1, 0, 0, 0, 36, 282,
1460
- 1, 0, 0, 0, 38, 288, 1, 0, 0, 0, 40, 294, 1, 0, 0, 0, 42, 300, 1, 0, 0, 0, 44, 303, 1, 0,
1461
- 0, 0, 46, 49, 3, 4, 2, 0, 47, 49, 5, 14, 0, 0, 48, 46, 1, 0, 0, 0, 48, 47, 1, 0, 0, 0, 49,
1462
- 52, 1, 0, 0, 0, 50, 48, 1, 0, 0, 0, 50, 51, 1, 0, 0, 0, 51, 53, 1, 0, 0, 0, 52, 50, 1, 0, 0,
1463
- 0, 53, 57, 3, 20, 10, 0, 54, 56, 5, 14, 0, 0, 55, 54, 1, 0, 0, 0, 56, 59, 1, 0, 0, 0, 57,
1464
- 55, 1, 0, 0, 0, 57, 58, 1, 0, 0, 0, 58, 60, 1, 0, 0, 0, 59, 57, 1, 0, 0, 0, 60, 61, 5, 0, 0,
1465
- 1, 61, 1, 1, 0, 0, 0, 62, 64, 3, 4, 2, 0, 63, 62, 1, 0, 0, 0, 64, 67, 1, 0, 0, 0, 65, 63, 1,
1466
- 0, 0, 0, 65, 66, 1, 0, 0, 0, 66, 68, 1, 0, 0, 0, 67, 65, 1, 0, 0, 0, 68, 69, 5, 0, 0, 1, 69,
1467
- 3, 1, 0, 0, 0, 70, 82, 3, 6, 3, 0, 71, 82, 3, 8, 4, 0, 72, 82, 3, 10, 5, 0, 73, 82, 3, 12,
1468
- 6, 0, 74, 82, 3, 14, 7, 0, 75, 82, 3, 16, 8, 0, 76, 82, 3, 18, 9, 0, 77, 82, 3, 20, 10, 0,
1469
- 78, 82, 3, 22, 11, 0, 79, 82, 3, 24, 12, 0, 80, 82, 3, 26, 13, 0, 81, 70, 1, 0, 0, 0, 81,
1470
- 71, 1, 0, 0, 0, 81, 72, 1, 0, 0, 0, 81, 73, 1, 0, 0, 0, 81, 74, 1, 0, 0, 0, 81, 75, 1, 0, 0,
1471
- 0, 81, 76, 1, 0, 0, 0, 81, 77, 1, 0, 0, 0, 81, 78, 1, 0, 0, 0, 81, 79, 1, 0, 0, 0, 81, 80,
1472
- 1, 0, 0, 0, 82, 5, 1, 0, 0, 0, 83, 85, 5, 15, 0, 0, 84, 86, 3, 28, 14, 0, 85, 84, 1, 0, 0,
1473
- 0, 85, 86, 1, 0, 0, 0, 86, 87, 1, 0, 0, 0, 87, 89, 5, 6, 0, 0, 88, 90, 3, 44, 22, 0, 89, 88,
1474
- 1, 0, 0, 0, 89, 90, 1, 0, 0, 0, 90, 91, 1, 0, 0, 0, 91, 92, 5, 13, 0, 0, 92, 7, 1, 0, 0, 0,
1475
- 93, 95, 5, 16, 0, 0, 94, 96, 3, 28, 14, 0, 95, 94, 1, 0, 0, 0, 95, 96, 1, 0, 0, 0, 96, 97,
1476
- 1, 0, 0, 0, 97, 99, 5, 6, 0, 0, 98, 100, 3, 44, 22, 0, 99, 98, 1, 0, 0, 0, 99, 100, 1, 0,
1477
- 0, 0, 100, 101, 1, 0, 0, 0, 101, 102, 5, 13, 0, 0, 102, 9, 1, 0, 0, 0, 103, 105, 5, 17,
1478
- 0, 0, 104, 106, 3, 28, 14, 0, 105, 104, 1, 0, 0, 0, 105, 106, 1, 0, 0, 0, 106, 107, 1,
1479
- 0, 0, 0, 107, 109, 5, 6, 0, 0, 108, 110, 3, 44, 22, 0, 109, 108, 1, 0, 0, 0, 109, 110,
1480
- 1, 0, 0, 0, 110, 111, 1, 0, 0, 0, 111, 112, 5, 13, 0, 0, 112, 11, 1, 0, 0, 0, 113, 115,
1481
- 5, 18, 0, 0, 114, 116, 3, 28, 14, 0, 115, 114, 1, 0, 0, 0, 115, 116, 1, 0, 0, 0, 116, 117,
1482
- 1, 0, 0, 0, 117, 119, 5, 6, 0, 0, 118, 120, 3, 44, 22, 0, 119, 118, 1, 0, 0, 0, 119, 120,
1483
- 1, 0, 0, 0, 120, 121, 1, 0, 0, 0, 121, 122, 5, 13, 0, 0, 122, 13, 1, 0, 0, 0, 123, 125,
1484
- 5, 19, 0, 0, 124, 126, 3, 28, 14, 0, 125, 124, 1, 0, 0, 0, 125, 126, 1, 0, 0, 0, 126, 127,
1485
- 1, 0, 0, 0, 127, 129, 5, 6, 0, 0, 128, 130, 3, 44, 22, 0, 129, 128, 1, 0, 0, 0, 129, 130,
1486
- 1, 0, 0, 0, 130, 131, 1, 0, 0, 0, 131, 132, 5, 13, 0, 0, 132, 15, 1, 0, 0, 0, 133, 135,
1487
- 5, 20, 0, 0, 134, 136, 3, 28, 14, 0, 135, 134, 1, 0, 0, 0, 135, 136, 1, 0, 0, 0, 136, 137,
1488
- 1, 0, 0, 0, 137, 139, 5, 6, 0, 0, 138, 140, 3, 44, 22, 0, 139, 138, 1, 0, 0, 0, 139, 140,
1489
- 1, 0, 0, 0, 140, 141, 1, 0, 0, 0, 141, 142, 5, 13, 0, 0, 142, 17, 1, 0, 0, 0, 143, 145,
1490
- 5, 21, 0, 0, 144, 146, 3, 28, 14, 0, 145, 144, 1, 0, 0, 0, 145, 146, 1, 0, 0, 0, 146, 147,
1491
- 1, 0, 0, 0, 147, 149, 5, 6, 0, 0, 148, 150, 3, 44, 22, 0, 149, 148, 1, 0, 0, 0, 149, 150,
1492
- 1, 0, 0, 0, 150, 151, 1, 0, 0, 0, 151, 152, 5, 13, 0, 0, 152, 19, 1, 0, 0, 0, 153, 155,
1493
- 5, 22, 0, 0, 154, 156, 3, 30, 15, 0, 155, 154, 1, 0, 0, 0, 155, 156, 1, 0, 0, 0, 156, 157,
1494
- 1, 0, 0, 0, 157, 159, 5, 6, 0, 0, 158, 160, 3, 44, 22, 0, 159, 158, 1, 0, 0, 0, 159, 160,
1495
- 1, 0, 0, 0, 160, 161, 1, 0, 0, 0, 161, 162, 5, 13, 0, 0, 162, 21, 1, 0, 0, 0, 163, 165,
1496
- 5, 23, 0, 0, 164, 166, 3, 32, 16, 0, 165, 164, 1, 0, 0, 0, 165, 166, 1, 0, 0, 0, 166, 167,
1497
- 1, 0, 0, 0, 167, 169, 5, 6, 0, 0, 168, 170, 3, 44, 22, 0, 169, 168, 1, 0, 0, 0, 169, 170,
1498
- 1, 0, 0, 0, 170, 171, 1, 0, 0, 0, 171, 172, 5, 13, 0, 0, 172, 23, 1, 0, 0, 0, 173, 175,
1499
- 5, 24, 0, 0, 174, 176, 3, 30, 15, 0, 175, 174, 1, 0, 0, 0, 175, 176, 1, 0, 0, 0, 176, 177,
1500
- 1, 0, 0, 0, 177, 179, 5, 6, 0, 0, 178, 180, 3, 44, 22, 0, 179, 178, 1, 0, 0, 0, 179, 180,
1501
- 1, 0, 0, 0, 180, 181, 1, 0, 0, 0, 181, 182, 5, 13, 0, 0, 182, 25, 1, 0, 0, 0, 183, 185,
1502
- 5, 25, 0, 0, 184, 186, 3, 28, 14, 0, 185, 184, 1, 0, 0, 0, 185, 186, 1, 0, 0, 0, 186, 187,
1503
- 1, 0, 0, 0, 187, 189, 5, 6, 0, 0, 188, 190, 3, 44, 22, 0, 189, 188, 1, 0, 0, 0, 189, 190,
1504
- 1, 0, 0, 0, 190, 191, 1, 0, 0, 0, 191, 192, 5, 13, 0, 0, 192, 27, 1, 0, 0, 0, 193, 202,
1505
- 3, 34, 17, 0, 194, 196, 3, 40, 20, 0, 195, 197, 3, 42, 21, 0, 196, 195, 1, 0, 0, 0, 196,
1506
- 197, 1, 0, 0, 0, 197, 203, 1, 0, 0, 0, 198, 200, 3, 42, 21, 0, 199, 201, 3, 40, 20, 0,
1507
- 200, 199, 1, 0, 0, 0, 200, 201, 1, 0, 0, 0, 201, 203, 1, 0, 0, 0, 202, 194, 1, 0, 0, 0,
1508
- 202, 198, 1, 0, 0, 0, 202, 203, 1, 0, 0, 0, 203, 227, 1, 0, 0, 0, 204, 213, 3, 40, 20,
1509
- 0, 205, 207, 3, 34, 17, 0, 206, 208, 3, 42, 21, 0, 207, 206, 1, 0, 0, 0, 207, 208, 1,
1510
- 0, 0, 0, 208, 214, 1, 0, 0, 0, 209, 211, 3, 42, 21, 0, 210, 212, 3, 34, 17, 0, 211, 210,
1511
- 1, 0, 0, 0, 211, 212, 1, 0, 0, 0, 212, 214, 1, 0, 0, 0, 213, 205, 1, 0, 0, 0, 213, 209,
1512
- 1, 0, 0, 0, 213, 214, 1, 0, 0, 0, 214, 227, 1, 0, 0, 0, 215, 224, 3, 42, 21, 0, 216, 218,
1513
- 3, 34, 17, 0, 217, 219, 3, 40, 20, 0, 218, 217, 1, 0, 0, 0, 218, 219, 1, 0, 0, 0, 219,
1514
- 225, 1, 0, 0, 0, 220, 222, 3, 40, 20, 0, 221, 223, 3, 34, 17, 0, 222, 221, 1, 0, 0, 0,
1515
- 222, 223, 1, 0, 0, 0, 223, 225, 1, 0, 0, 0, 224, 216, 1, 0, 0, 0, 224, 220, 1, 0, 0, 0,
1516
- 224, 225, 1, 0, 0, 0, 225, 227, 1, 0, 0, 0, 226, 193, 1, 0, 0, 0, 226, 204, 1, 0, 0, 0,
1517
- 226, 215, 1, 0, 0, 0, 227, 29, 1, 0, 0, 0, 228, 230, 3, 36, 18, 0, 229, 231, 3, 40, 20,
1518
- 0, 230, 229, 1, 0, 0, 0, 230, 231, 1, 0, 0, 0, 231, 237, 1, 0, 0, 0, 232, 234, 3, 40, 20,
1519
- 0, 233, 235, 3, 36, 18, 0, 234, 233, 1, 0, 0, 0, 234, 235, 1, 0, 0, 0, 235, 237, 1, 0,
1520
- 0, 0, 236, 228, 1, 0, 0, 0, 236, 232, 1, 0, 0, 0, 237, 31, 1, 0, 0, 0, 238, 247, 3, 38,
1521
- 19, 0, 239, 241, 3, 40, 20, 0, 240, 242, 3, 42, 21, 0, 241, 240, 1, 0, 0, 0, 241, 242,
1522
- 1, 0, 0, 0, 242, 248, 1, 0, 0, 0, 243, 245, 3, 42, 21, 0, 244, 246, 3, 40, 20, 0, 245,
1523
- 244, 1, 0, 0, 0, 245, 246, 1, 0, 0, 0, 246, 248, 1, 0, 0, 0, 247, 239, 1, 0, 0, 0, 247,
1524
- 243, 1, 0, 0, 0, 247, 248, 1, 0, 0, 0, 248, 272, 1, 0, 0, 0, 249, 258, 3, 40, 20, 0, 250,
1525
- 252, 3, 38, 19, 0, 251, 253, 3, 42, 21, 0, 252, 251, 1, 0, 0, 0, 252, 253, 1, 0, 0, 0,
1526
- 253, 259, 1, 0, 0, 0, 254, 256, 3, 42, 21, 0, 255, 257, 3, 38, 19, 0, 256, 255, 1, 0,
1527
- 0, 0, 256, 257, 1, 0, 0, 0, 257, 259, 1, 0, 0, 0, 258, 250, 1, 0, 0, 0, 258, 254, 1, 0,
1528
- 0, 0, 258, 259, 1, 0, 0, 0, 259, 272, 1, 0, 0, 0, 260, 269, 3, 42, 21, 0, 261, 263, 3,
1529
- 38, 19, 0, 262, 264, 3, 40, 20, 0, 263, 262, 1, 0, 0, 0, 263, 264, 1, 0, 0, 0, 264, 270,
1530
- 1, 0, 0, 0, 265, 267, 3, 40, 20, 0, 266, 268, 3, 38, 19, 0, 267, 266, 1, 0, 0, 0, 267,
1531
- 268, 1, 0, 0, 0, 268, 270, 1, 0, 0, 0, 269, 261, 1, 0, 0, 0, 269, 265, 1, 0, 0, 0, 269,
1532
- 270, 1, 0, 0, 0, 270, 272, 1, 0, 0, 0, 271, 238, 1, 0, 0, 0, 271, 249, 1, 0, 0, 0, 271,
1533
- 260, 1, 0, 0, 0, 272, 33, 1, 0, 0, 0, 273, 277, 5, 1, 0, 0, 274, 276, 7, 0, 0, 0, 275, 274,
1534
- 1, 0, 0, 0, 276, 279, 1, 0, 0, 0, 277, 275, 1, 0, 0, 0, 277, 278, 1, 0, 0, 0, 278, 280,
1535
- 1, 0, 0, 0, 279, 277, 1, 0, 0, 0, 280, 281, 5, 2, 0, 0, 281, 35, 1, 0, 0, 0, 282, 284, 5,
1536
- 1, 0, 0, 283, 285, 5, 8, 0, 0, 284, 283, 1, 0, 0, 0, 284, 285, 1, 0, 0, 0, 285, 286, 1,
1537
- 0, 0, 0, 286, 287, 5, 2, 0, 0, 287, 37, 1, 0, 0, 0, 288, 290, 5, 1, 0, 0, 289, 291, 5, 9,
1538
- 0, 0, 290, 289, 1, 0, 0, 0, 290, 291, 1, 0, 0, 0, 291, 292, 1, 0, 0, 0, 292, 293, 5, 2,
1539
- 0, 0, 293, 39, 1, 0, 0, 0, 294, 296, 5, 3, 0, 0, 295, 297, 5, 11, 0, 0, 296, 295, 1, 0,
1540
- 0, 0, 296, 297, 1, 0, 0, 0, 297, 298, 1, 0, 0, 0, 298, 299, 5, 4, 0, 0, 299, 41, 1, 0, 0,
1541
- 0, 300, 301, 5, 5, 0, 0, 301, 43, 1, 0, 0, 0, 302, 304, 5, 12, 0, 0, 303, 302, 1, 0, 0,
1542
- 0, 304, 305, 1, 0, 0, 0, 305, 303, 1, 0, 0, 0, 305, 306, 1, 0, 0, 0, 306, 45, 1, 0, 0, 0,
1543
- 55, 48, 50, 57, 65, 81, 85, 89, 95, 99, 105, 109, 115, 119, 125, 129, 135, 139, 145,
1544
- 149, 155, 159, 165, 169, 175, 179, 185, 189, 196, 200, 202, 207, 211, 213, 218,
1545
- 222, 224, 226, 230, 234, 236, 241, 245, 247, 252, 256, 258, 263, 267, 269, 271,
1546
- 277, 284, 290, 296, 305
1741
+ 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26,
1742
+ 1, 0, 1, 0, 1, 0, 1, 1, 4, 1, 59, 8, 1, 11, 1, 12, 1, 60, 1, 1, 1, 1, 1, 2, 1, 2, 3, 2, 67, 8,
1743
+ 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 5, 3, 74, 8, 3, 10, 3, 12, 3, 77, 9, 3, 1, 3, 1, 3, 1, 3, 5,
1744
+ 3, 82, 8, 3, 10, 3, 12, 3, 85, 9, 3, 1, 3, 1, 3, 5, 3, 89, 8, 3, 10, 3, 12, 3, 92, 9, 3, 1,
1745
+ 4, 5, 4, 95, 8, 4, 10, 4, 12, 4, 98, 9, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1,
1746
+ 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 113, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1,
1747
+ 6, 1, 6, 3, 6, 125, 8, 6, 1, 7, 1, 7, 3, 7, 129, 8, 7, 1, 7, 3, 7, 132, 8, 7, 1, 7, 3, 7, 135,
1748
+ 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 3, 8, 141, 8, 8, 1, 8, 3, 8, 144, 8, 8, 1, 8, 3, 8, 147, 8, 8,
1749
+ 1, 8, 1, 8, 1, 9, 1, 9, 3, 9, 153, 8, 9, 1, 9, 3, 9, 156, 8, 9, 1, 9, 3, 9, 159, 8, 9, 1, 9,
1750
+ 1, 9, 1, 10, 1, 10, 3, 10, 165, 8, 10, 1, 10, 3, 10, 168, 8, 10, 1, 10, 3, 10, 171, 8, 10,
1751
+ 1, 10, 1, 10, 1, 11, 1, 11, 3, 11, 177, 8, 11, 1, 11, 3, 11, 180, 8, 11, 1, 11, 3, 11, 183,
1752
+ 8, 11, 1, 11, 1, 11, 1, 12, 1, 12, 3, 12, 189, 8, 12, 1, 12, 3, 12, 192, 8, 12, 1, 12, 3,
1753
+ 12, 195, 8, 12, 1, 12, 1, 12, 1, 13, 1, 13, 3, 13, 201, 8, 13, 1, 13, 3, 13, 204, 8, 13,
1754
+ 1, 13, 3, 13, 207, 8, 13, 1, 13, 1, 13, 1, 14, 1, 14, 3, 14, 213, 8, 14, 1, 14, 3, 14, 216,
1755
+ 8, 14, 1, 14, 3, 14, 219, 8, 14, 1, 14, 1, 14, 1, 15, 1, 15, 3, 15, 225, 8, 15, 1, 15, 3,
1756
+ 15, 228, 8, 15, 1, 15, 3, 15, 231, 8, 15, 1, 15, 1, 15, 1, 16, 1, 16, 3, 16, 237, 8, 16,
1757
+ 1, 16, 3, 16, 240, 8, 16, 1, 16, 3, 16, 243, 8, 16, 1, 16, 1, 16, 1, 17, 1, 17, 3, 17, 249,
1758
+ 8, 17, 1, 17, 3, 17, 252, 8, 17, 1, 17, 3, 17, 255, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1,
1759
+ 18, 3, 18, 262, 8, 18, 1, 18, 1, 18, 3, 18, 266, 8, 18, 3, 18, 268, 8, 18, 1, 18, 1, 18,
1760
+ 1, 18, 3, 18, 273, 8, 18, 1, 18, 1, 18, 3, 18, 277, 8, 18, 3, 18, 279, 8, 18, 1, 18, 1,
1761
+ 18, 1, 18, 3, 18, 284, 8, 18, 1, 18, 1, 18, 3, 18, 288, 8, 18, 3, 18, 290, 8, 18, 3, 18,
1762
+ 292, 8, 18, 1, 19, 1, 19, 3, 19, 296, 8, 19, 1, 19, 1, 19, 3, 19, 300, 8, 19, 3, 19, 302,
1763
+ 8, 19, 1, 20, 1, 20, 1, 20, 3, 20, 307, 8, 20, 1, 20, 1, 20, 3, 20, 311, 8, 20, 3, 20, 313,
1764
+ 8, 20, 1, 20, 1, 20, 1, 20, 3, 20, 318, 8, 20, 1, 20, 1, 20, 3, 20, 322, 8, 20, 3, 20, 324,
1765
+ 8, 20, 1, 20, 1, 20, 1, 20, 3, 20, 329, 8, 20, 1, 20, 1, 20, 3, 20, 333, 8, 20, 3, 20, 335,
1766
+ 8, 20, 3, 20, 337, 8, 20, 1, 21, 1, 21, 5, 21, 341, 8, 21, 10, 21, 12, 21, 344, 9, 21,
1767
+ 1, 21, 1, 21, 1, 22, 1, 22, 3, 22, 350, 8, 22, 1, 22, 1, 22, 1, 23, 1, 23, 3, 23, 356, 8,
1768
+ 23, 1, 23, 1, 23, 1, 24, 1, 24, 3, 24, 362, 8, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 4,
1769
+ 26, 369, 8, 26, 11, 26, 12, 26, 370, 1, 26, 0, 0, 27, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
1770
+ 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 0, 1, 2, 0, 7, 7, 10,
1771
+ 10, 440, 0, 54, 1, 0, 0, 0, 2, 58, 1, 0, 0, 0, 4, 64, 1, 0, 0, 0, 6, 75, 1, 0, 0, 0, 8, 96,
1772
+ 1, 0, 0, 0, 10, 112, 1, 0, 0, 0, 12, 124, 1, 0, 0, 0, 14, 126, 1, 0, 0, 0, 16, 138, 1, 0,
1773
+ 0, 0, 18, 150, 1, 0, 0, 0, 20, 162, 1, 0, 0, 0, 22, 174, 1, 0, 0, 0, 24, 186, 1, 0, 0, 0,
1774
+ 26, 198, 1, 0, 0, 0, 28, 210, 1, 0, 0, 0, 30, 222, 1, 0, 0, 0, 32, 234, 1, 0, 0, 0, 34, 246,
1775
+ 1, 0, 0, 0, 36, 291, 1, 0, 0, 0, 38, 301, 1, 0, 0, 0, 40, 336, 1, 0, 0, 0, 42, 338, 1, 0,
1776
+ 0, 0, 44, 347, 1, 0, 0, 0, 46, 353, 1, 0, 0, 0, 48, 359, 1, 0, 0, 0, 50, 365, 1, 0, 0, 0,
1777
+ 52, 368, 1, 0, 0, 0, 54, 55, 3, 6, 3, 0, 55, 56, 5, 0, 0, 1, 56, 1, 1, 0, 0, 0, 57, 59, 3,
1778
+ 4, 2, 0, 58, 57, 1, 0, 0, 0, 59, 60, 1, 0, 0, 0, 60, 58, 1, 0, 0, 0, 60, 61, 1, 0, 0, 0, 61,
1779
+ 62, 1, 0, 0, 0, 62, 63, 5, 0, 0, 1, 63, 3, 1, 0, 0, 0, 64, 66, 5, 15, 0, 0, 65, 67, 3, 36,
1780
+ 18, 0, 66, 65, 1, 0, 0, 0, 66, 67, 1, 0, 0, 0, 67, 68, 1, 0, 0, 0, 68, 69, 5, 6, 0, 0, 69,
1781
+ 70, 3, 6, 3, 0, 70, 71, 5, 16, 0, 0, 71, 5, 1, 0, 0, 0, 72, 74, 5, 14, 0, 0, 73, 72, 1, 0,
1782
+ 0, 0, 74, 77, 1, 0, 0, 0, 75, 73, 1, 0, 0, 0, 75, 76, 1, 0, 0, 0, 76, 78, 1, 0, 0, 0, 77, 75,
1783
+ 1, 0, 0, 0, 78, 83, 3, 34, 17, 0, 79, 82, 3, 12, 6, 0, 80, 82, 5, 14, 0, 0, 81, 79, 1, 0,
1784
+ 0, 0, 81, 80, 1, 0, 0, 0, 82, 85, 1, 0, 0, 0, 83, 81, 1, 0, 0, 0, 83, 84, 1, 0, 0, 0, 84, 86,
1785
+ 1, 0, 0, 0, 85, 83, 1, 0, 0, 0, 86, 90, 3, 28, 14, 0, 87, 89, 5, 14, 0, 0, 88, 87, 1, 0, 0,
1786
+ 0, 89, 92, 1, 0, 0, 0, 90, 88, 1, 0, 0, 0, 90, 91, 1, 0, 0, 0, 91, 7, 1, 0, 0, 0, 92, 90, 1,
1787
+ 0, 0, 0, 93, 95, 3, 10, 5, 0, 94, 93, 1, 0, 0, 0, 95, 98, 1, 0, 0, 0, 96, 94, 1, 0, 0, 0, 96,
1788
+ 97, 1, 0, 0, 0, 97, 99, 1, 0, 0, 0, 98, 96, 1, 0, 0, 0, 99, 100, 5, 0, 0, 1, 100, 9, 1, 0,
1789
+ 0, 0, 101, 113, 3, 14, 7, 0, 102, 113, 3, 16, 8, 0, 103, 113, 3, 18, 9, 0, 104, 113, 3,
1790
+ 20, 10, 0, 105, 113, 3, 22, 11, 0, 106, 113, 3, 24, 12, 0, 107, 113, 3, 26, 13, 0, 108,
1791
+ 113, 3, 28, 14, 0, 109, 113, 3, 30, 15, 0, 110, 113, 3, 32, 16, 0, 111, 113, 3, 34, 17,
1792
+ 0, 112, 101, 1, 0, 0, 0, 112, 102, 1, 0, 0, 0, 112, 103, 1, 0, 0, 0, 112, 104, 1, 0, 0,
1793
+ 0, 112, 105, 1, 0, 0, 0, 112, 106, 1, 0, 0, 0, 112, 107, 1, 0, 0, 0, 112, 108, 1, 0, 0,
1794
+ 0, 112, 109, 1, 0, 0, 0, 112, 110, 1, 0, 0, 0, 112, 111, 1, 0, 0, 0, 113, 11, 1, 0, 0, 0,
1795
+ 114, 125, 3, 14, 7, 0, 115, 125, 3, 16, 8, 0, 116, 125, 3, 18, 9, 0, 117, 125, 3, 20,
1796
+ 10, 0, 118, 125, 3, 22, 11, 0, 119, 125, 3, 24, 12, 0, 120, 125, 3, 26, 13, 0, 121, 125,
1797
+ 3, 28, 14, 0, 122, 125, 3, 30, 15, 0, 123, 125, 3, 32, 16, 0, 124, 114, 1, 0, 0, 0, 124,
1798
+ 115, 1, 0, 0, 0, 124, 116, 1, 0, 0, 0, 124, 117, 1, 0, 0, 0, 124, 118, 1, 0, 0, 0, 124,
1799
+ 119, 1, 0, 0, 0, 124, 120, 1, 0, 0, 0, 124, 121, 1, 0, 0, 0, 124, 122, 1, 0, 0, 0, 124,
1800
+ 123, 1, 0, 0, 0, 125, 13, 1, 0, 0, 0, 126, 128, 5, 17, 0, 0, 127, 129, 3, 36, 18, 0, 128,
1801
+ 127, 1, 0, 0, 0, 128, 129, 1, 0, 0, 0, 129, 131, 1, 0, 0, 0, 130, 132, 5, 6, 0, 0, 131,
1802
+ 130, 1, 0, 0, 0, 131, 132, 1, 0, 0, 0, 132, 134, 1, 0, 0, 0, 133, 135, 3, 52, 26, 0, 134,
1803
+ 133, 1, 0, 0, 0, 134, 135, 1, 0, 0, 0, 135, 136, 1, 0, 0, 0, 136, 137, 5, 13, 0, 0, 137,
1804
+ 15, 1, 0, 0, 0, 138, 140, 5, 18, 0, 0, 139, 141, 3, 36, 18, 0, 140, 139, 1, 0, 0, 0, 140,
1805
+ 141, 1, 0, 0, 0, 141, 143, 1, 0, 0, 0, 142, 144, 5, 6, 0, 0, 143, 142, 1, 0, 0, 0, 143,
1806
+ 144, 1, 0, 0, 0, 144, 146, 1, 0, 0, 0, 145, 147, 3, 52, 26, 0, 146, 145, 1, 0, 0, 0, 146,
1807
+ 147, 1, 0, 0, 0, 147, 148, 1, 0, 0, 0, 148, 149, 5, 13, 0, 0, 149, 17, 1, 0, 0, 0, 150,
1808
+ 152, 5, 19, 0, 0, 151, 153, 3, 36, 18, 0, 152, 151, 1, 0, 0, 0, 152, 153, 1, 0, 0, 0, 153,
1809
+ 155, 1, 0, 0, 0, 154, 156, 5, 6, 0, 0, 155, 154, 1, 0, 0, 0, 155, 156, 1, 0, 0, 0, 156,
1810
+ 158, 1, 0, 0, 0, 157, 159, 3, 52, 26, 0, 158, 157, 1, 0, 0, 0, 158, 159, 1, 0, 0, 0, 159,
1811
+ 160, 1, 0, 0, 0, 160, 161, 5, 13, 0, 0, 161, 19, 1, 0, 0, 0, 162, 164, 5, 20, 0, 0, 163,
1812
+ 165, 3, 36, 18, 0, 164, 163, 1, 0, 0, 0, 164, 165, 1, 0, 0, 0, 165, 167, 1, 0, 0, 0, 166,
1813
+ 168, 5, 6, 0, 0, 167, 166, 1, 0, 0, 0, 167, 168, 1, 0, 0, 0, 168, 170, 1, 0, 0, 0, 169,
1814
+ 171, 3, 52, 26, 0, 170, 169, 1, 0, 0, 0, 170, 171, 1, 0, 0, 0, 171, 172, 1, 0, 0, 0, 172,
1815
+ 173, 5, 13, 0, 0, 173, 21, 1, 0, 0, 0, 174, 176, 5, 21, 0, 0, 175, 177, 3, 36, 18, 0, 176,
1816
+ 175, 1, 0, 0, 0, 176, 177, 1, 0, 0, 0, 177, 179, 1, 0, 0, 0, 178, 180, 5, 6, 0, 0, 179,
1817
+ 178, 1, 0, 0, 0, 179, 180, 1, 0, 0, 0, 180, 182, 1, 0, 0, 0, 181, 183, 3, 52, 26, 0, 182,
1818
+ 181, 1, 0, 0, 0, 182, 183, 1, 0, 0, 0, 183, 184, 1, 0, 0, 0, 184, 185, 5, 13, 0, 0, 185,
1819
+ 23, 1, 0, 0, 0, 186, 188, 5, 22, 0, 0, 187, 189, 3, 36, 18, 0, 188, 187, 1, 0, 0, 0, 188,
1820
+ 189, 1, 0, 0, 0, 189, 191, 1, 0, 0, 0, 190, 192, 5, 6, 0, 0, 191, 190, 1, 0, 0, 0, 191,
1821
+ 192, 1, 0, 0, 0, 192, 194, 1, 0, 0, 0, 193, 195, 3, 52, 26, 0, 194, 193, 1, 0, 0, 0, 194,
1822
+ 195, 1, 0, 0, 0, 195, 196, 1, 0, 0, 0, 196, 197, 5, 13, 0, 0, 197, 25, 1, 0, 0, 0, 198,
1823
+ 200, 5, 23, 0, 0, 199, 201, 3, 36, 18, 0, 200, 199, 1, 0, 0, 0, 200, 201, 1, 0, 0, 0, 201,
1824
+ 203, 1, 0, 0, 0, 202, 204, 5, 6, 0, 0, 203, 202, 1, 0, 0, 0, 203, 204, 1, 0, 0, 0, 204,
1825
+ 206, 1, 0, 0, 0, 205, 207, 3, 52, 26, 0, 206, 205, 1, 0, 0, 0, 206, 207, 1, 0, 0, 0, 207,
1826
+ 208, 1, 0, 0, 0, 208, 209, 5, 13, 0, 0, 209, 27, 1, 0, 0, 0, 210, 212, 5, 24, 0, 0, 211,
1827
+ 213, 3, 38, 19, 0, 212, 211, 1, 0, 0, 0, 212, 213, 1, 0, 0, 0, 213, 215, 1, 0, 0, 0, 214,
1828
+ 216, 5, 6, 0, 0, 215, 214, 1, 0, 0, 0, 215, 216, 1, 0, 0, 0, 216, 218, 1, 0, 0, 0, 217,
1829
+ 219, 3, 52, 26, 0, 218, 217, 1, 0, 0, 0, 218, 219, 1, 0, 0, 0, 219, 220, 1, 0, 0, 0, 220,
1830
+ 221, 5, 13, 0, 0, 221, 29, 1, 0, 0, 0, 222, 224, 5, 25, 0, 0, 223, 225, 3, 40, 20, 0, 224,
1831
+ 223, 1, 0, 0, 0, 224, 225, 1, 0, 0, 0, 225, 227, 1, 0, 0, 0, 226, 228, 5, 6, 0, 0, 227,
1832
+ 226, 1, 0, 0, 0, 227, 228, 1, 0, 0, 0, 228, 230, 1, 0, 0, 0, 229, 231, 3, 52, 26, 0, 230,
1833
+ 229, 1, 0, 0, 0, 230, 231, 1, 0, 0, 0, 231, 232, 1, 0, 0, 0, 232, 233, 5, 13, 0, 0, 233,
1834
+ 31, 1, 0, 0, 0, 234, 236, 5, 26, 0, 0, 235, 237, 3, 38, 19, 0, 236, 235, 1, 0, 0, 0, 236,
1835
+ 237, 1, 0, 0, 0, 237, 239, 1, 0, 0, 0, 238, 240, 5, 6, 0, 0, 239, 238, 1, 0, 0, 0, 239,
1836
+ 240, 1, 0, 0, 0, 240, 242, 1, 0, 0, 0, 241, 243, 3, 52, 26, 0, 242, 241, 1, 0, 0, 0, 242,
1837
+ 243, 1, 0, 0, 0, 243, 244, 1, 0, 0, 0, 244, 245, 5, 13, 0, 0, 245, 33, 1, 0, 0, 0, 246,
1838
+ 248, 5, 27, 0, 0, 247, 249, 3, 36, 18, 0, 248, 247, 1, 0, 0, 0, 248, 249, 1, 0, 0, 0, 249,
1839
+ 251, 1, 0, 0, 0, 250, 252, 5, 6, 0, 0, 251, 250, 1, 0, 0, 0, 251, 252, 1, 0, 0, 0, 252,
1840
+ 254, 1, 0, 0, 0, 253, 255, 3, 52, 26, 0, 254, 253, 1, 0, 0, 0, 254, 255, 1, 0, 0, 0, 255,
1841
+ 256, 1, 0, 0, 0, 256, 257, 5, 13, 0, 0, 257, 35, 1, 0, 0, 0, 258, 267, 3, 42, 21, 0, 259,
1842
+ 261, 3, 48, 24, 0, 260, 262, 3, 50, 25, 0, 261, 260, 1, 0, 0, 0, 261, 262, 1, 0, 0, 0,
1843
+ 262, 268, 1, 0, 0, 0, 263, 265, 3, 50, 25, 0, 264, 266, 3, 48, 24, 0, 265, 264, 1, 0,
1844
+ 0, 0, 265, 266, 1, 0, 0, 0, 266, 268, 1, 0, 0, 0, 267, 259, 1, 0, 0, 0, 267, 263, 1, 0,
1845
+ 0, 0, 267, 268, 1, 0, 0, 0, 268, 292, 1, 0, 0, 0, 269, 278, 3, 48, 24, 0, 270, 272, 3,
1846
+ 42, 21, 0, 271, 273, 3, 50, 25, 0, 272, 271, 1, 0, 0, 0, 272, 273, 1, 0, 0, 0, 273, 279,
1847
+ 1, 0, 0, 0, 274, 276, 3, 50, 25, 0, 275, 277, 3, 42, 21, 0, 276, 275, 1, 0, 0, 0, 276,
1848
+ 277, 1, 0, 0, 0, 277, 279, 1, 0, 0, 0, 278, 270, 1, 0, 0, 0, 278, 274, 1, 0, 0, 0, 278,
1849
+ 279, 1, 0, 0, 0, 279, 292, 1, 0, 0, 0, 280, 289, 3, 50, 25, 0, 281, 283, 3, 42, 21, 0,
1850
+ 282, 284, 3, 48, 24, 0, 283, 282, 1, 0, 0, 0, 283, 284, 1, 0, 0, 0, 284, 290, 1, 0, 0,
1851
+ 0, 285, 287, 3, 48, 24, 0, 286, 288, 3, 42, 21, 0, 287, 286, 1, 0, 0, 0, 287, 288, 1,
1852
+ 0, 0, 0, 288, 290, 1, 0, 0, 0, 289, 281, 1, 0, 0, 0, 289, 285, 1, 0, 0, 0, 289, 290, 1,
1853
+ 0, 0, 0, 290, 292, 1, 0, 0, 0, 291, 258, 1, 0, 0, 0, 291, 269, 1, 0, 0, 0, 291, 280, 1,
1854
+ 0, 0, 0, 292, 37, 1, 0, 0, 0, 293, 295, 3, 44, 22, 0, 294, 296, 3, 48, 24, 0, 295, 294,
1855
+ 1, 0, 0, 0, 295, 296, 1, 0, 0, 0, 296, 302, 1, 0, 0, 0, 297, 299, 3, 48, 24, 0, 298, 300,
1856
+ 3, 44, 22, 0, 299, 298, 1, 0, 0, 0, 299, 300, 1, 0, 0, 0, 300, 302, 1, 0, 0, 0, 301, 293,
1857
+ 1, 0, 0, 0, 301, 297, 1, 0, 0, 0, 302, 39, 1, 0, 0, 0, 303, 312, 3, 46, 23, 0, 304, 306,
1858
+ 3, 48, 24, 0, 305, 307, 3, 50, 25, 0, 306, 305, 1, 0, 0, 0, 306, 307, 1, 0, 0, 0, 307,
1859
+ 313, 1, 0, 0, 0, 308, 310, 3, 50, 25, 0, 309, 311, 3, 48, 24, 0, 310, 309, 1, 0, 0, 0,
1860
+ 310, 311, 1, 0, 0, 0, 311, 313, 1, 0, 0, 0, 312, 304, 1, 0, 0, 0, 312, 308, 1, 0, 0, 0,
1861
+ 312, 313, 1, 0, 0, 0, 313, 337, 1, 0, 0, 0, 314, 323, 3, 48, 24, 0, 315, 317, 3, 46, 23,
1862
+ 0, 316, 318, 3, 50, 25, 0, 317, 316, 1, 0, 0, 0, 317, 318, 1, 0, 0, 0, 318, 324, 1, 0,
1863
+ 0, 0, 319, 321, 3, 50, 25, 0, 320, 322, 3, 46, 23, 0, 321, 320, 1, 0, 0, 0, 321, 322,
1864
+ 1, 0, 0, 0, 322, 324, 1, 0, 0, 0, 323, 315, 1, 0, 0, 0, 323, 319, 1, 0, 0, 0, 323, 324,
1865
+ 1, 0, 0, 0, 324, 337, 1, 0, 0, 0, 325, 334, 3, 50, 25, 0, 326, 328, 3, 46, 23, 0, 327,
1866
+ 329, 3, 48, 24, 0, 328, 327, 1, 0, 0, 0, 328, 329, 1, 0, 0, 0, 329, 335, 1, 0, 0, 0, 330,
1867
+ 332, 3, 48, 24, 0, 331, 333, 3, 46, 23, 0, 332, 331, 1, 0, 0, 0, 332, 333, 1, 0, 0, 0,
1868
+ 333, 335, 1, 0, 0, 0, 334, 326, 1, 0, 0, 0, 334, 330, 1, 0, 0, 0, 334, 335, 1, 0, 0, 0,
1869
+ 335, 337, 1, 0, 0, 0, 336, 303, 1, 0, 0, 0, 336, 314, 1, 0, 0, 0, 336, 325, 1, 0, 0, 0,
1870
+ 337, 41, 1, 0, 0, 0, 338, 342, 5, 1, 0, 0, 339, 341, 7, 0, 0, 0, 340, 339, 1, 0, 0, 0, 341,
1871
+ 344, 1, 0, 0, 0, 342, 340, 1, 0, 0, 0, 342, 343, 1, 0, 0, 0, 343, 345, 1, 0, 0, 0, 344,
1872
+ 342, 1, 0, 0, 0, 345, 346, 5, 2, 0, 0, 346, 43, 1, 0, 0, 0, 347, 349, 5, 1, 0, 0, 348, 350,
1873
+ 5, 8, 0, 0, 349, 348, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 351, 1, 0, 0, 0, 351, 352,
1874
+ 5, 2, 0, 0, 352, 45, 1, 0, 0, 0, 353, 355, 5, 1, 0, 0, 354, 356, 5, 9, 0, 0, 355, 354, 1,
1875
+ 0, 0, 0, 355, 356, 1, 0, 0, 0, 356, 357, 1, 0, 0, 0, 357, 358, 5, 2, 0, 0, 358, 47, 1, 0,
1876
+ 0, 0, 359, 361, 5, 3, 0, 0, 360, 362, 5, 11, 0, 0, 361, 360, 1, 0, 0, 0, 361, 362, 1, 0,
1877
+ 0, 0, 362, 363, 1, 0, 0, 0, 363, 364, 5, 4, 0, 0, 364, 49, 1, 0, 0, 0, 365, 366, 5, 5, 0,
1878
+ 0, 366, 51, 1, 0, 0, 0, 367, 369, 5, 12, 0, 0, 368, 367, 1, 0, 0, 0, 369, 370, 1, 0, 0,
1879
+ 0, 370, 368, 1, 0, 0, 0, 370, 371, 1, 0, 0, 0, 371, 53, 1, 0, 0, 0, 70, 60, 66, 75, 81,
1880
+ 83, 90, 96, 112, 124, 128, 131, 134, 140, 143, 146, 152, 155, 158, 164, 167, 170,
1881
+ 176, 179, 182, 188, 191, 194, 200, 203, 206, 212, 215, 218, 224, 227, 230, 236,
1882
+ 239, 242, 248, 251, 254, 261, 265, 267, 272, 276, 278, 283, 287, 289, 291, 295,
1883
+ 299, 301, 306, 310, 312, 317, 321, 323, 328, 332, 334, 336, 342, 349, 355, 361,
1884
+ 370
1547
1885
  ];
1548
1886
  static __ATN;
1549
1887
  static get _ATN() {
@@ -1562,17 +1900,89 @@ export class DocumentContext extends antlr.ParserRuleContext {
1562
1900
  constructor(parent, invokingState) {
1563
1901
  super(parent, invokingState);
1564
1902
  }
1565
- sendStatement() {
1566
- return this.getRuleContext(0, SendStatementContext);
1903
+ turnContent() {
1904
+ return this.getRuleContext(0, TurnContentContext);
1567
1905
  }
1568
1906
  EOF() {
1569
1907
  return this.getToken(plurnkParser.EOF, 0);
1570
1908
  }
1571
- statement(i) {
1909
+ get ruleIndex() {
1910
+ return plurnkParser.RULE_document;
1911
+ }
1912
+ accept(visitor) {
1913
+ if (visitor.visitDocument) {
1914
+ return visitor.visitDocument(this);
1915
+ }
1916
+ else {
1917
+ return visitor.visitChildren(this);
1918
+ }
1919
+ }
1920
+ }
1921
+ export class LogContext extends antlr.ParserRuleContext {
1922
+ constructor(parent, invokingState) {
1923
+ super(parent, invokingState);
1924
+ }
1925
+ EOF() {
1926
+ return this.getToken(plurnkParser.EOF, 0);
1927
+ }
1928
+ turnStatement(i) {
1572
1929
  if (i === undefined) {
1573
- return this.getRuleContexts(StatementContext);
1930
+ return this.getRuleContexts(TurnStatementContext);
1931
+ }
1932
+ return this.getRuleContext(i, TurnStatementContext);
1933
+ }
1934
+ get ruleIndex() {
1935
+ return plurnkParser.RULE_log;
1936
+ }
1937
+ accept(visitor) {
1938
+ if (visitor.visitLog) {
1939
+ return visitor.visitLog(this);
1940
+ }
1941
+ else {
1942
+ return visitor.visitChildren(this);
1574
1943
  }
1575
- return this.getRuleContext(i, StatementContext);
1944
+ }
1945
+ }
1946
+ export class TurnStatementContext extends antlr.ParserRuleContext {
1947
+ constructor(parent, invokingState) {
1948
+ super(parent, invokingState);
1949
+ }
1950
+ OPEN_TURN() {
1951
+ return this.getToken(plurnkParser.OPEN_TURN, 0);
1952
+ }
1953
+ COLON() {
1954
+ return this.getToken(plurnkParser.COLON, 0);
1955
+ }
1956
+ turnContent() {
1957
+ return this.getRuleContext(0, TurnContentContext);
1958
+ }
1959
+ CLOSE_TURN() {
1960
+ return this.getToken(plurnkParser.CLOSE_TURN, 0);
1961
+ }
1962
+ tagOpModifiers() {
1963
+ return this.getRuleContext(0, TagOpModifiersContext);
1964
+ }
1965
+ get ruleIndex() {
1966
+ return plurnkParser.RULE_turnStatement;
1967
+ }
1968
+ accept(visitor) {
1969
+ if (visitor.visitTurnStatement) {
1970
+ return visitor.visitTurnStatement(this);
1971
+ }
1972
+ else {
1973
+ return visitor.visitChildren(this);
1974
+ }
1975
+ }
1976
+ }
1977
+ export class TurnContentContext extends antlr.ParserRuleContext {
1978
+ constructor(parent, invokingState) {
1979
+ super(parent, invokingState);
1980
+ }
1981
+ planStatement() {
1982
+ return this.getRuleContext(0, PlanStatementContext);
1983
+ }
1984
+ sendStatement() {
1985
+ return this.getRuleContext(0, SendStatementContext);
1576
1986
  }
1577
1987
  TEXT(i) {
1578
1988
  if (i === undefined) {
@@ -1582,12 +1992,18 @@ export class DocumentContext extends antlr.ParserRuleContext {
1582
1992
  return this.getToken(plurnkParser.TEXT, i);
1583
1993
  }
1584
1994
  }
1995
+ midStatement(i) {
1996
+ if (i === undefined) {
1997
+ return this.getRuleContexts(MidStatementContext);
1998
+ }
1999
+ return this.getRuleContext(i, MidStatementContext);
2000
+ }
1585
2001
  get ruleIndex() {
1586
- return plurnkParser.RULE_document;
2002
+ return plurnkParser.RULE_turnContent;
1587
2003
  }
1588
2004
  accept(visitor) {
1589
- if (visitor.visitDocument) {
1590
- return visitor.visitDocument(this);
2005
+ if (visitor.visitTurnContent) {
2006
+ return visitor.visitTurnContent(this);
1591
2007
  }
1592
2008
  else {
1593
2009
  return visitor.visitChildren(this);
@@ -1668,6 +2084,52 @@ export class StatementContext extends antlr.ParserRuleContext {
1668
2084
  }
1669
2085
  }
1670
2086
  }
2087
+ export class MidStatementContext extends antlr.ParserRuleContext {
2088
+ constructor(parent, invokingState) {
2089
+ super(parent, invokingState);
2090
+ }
2091
+ findStatement() {
2092
+ return this.getRuleContext(0, FindStatementContext);
2093
+ }
2094
+ readStatement() {
2095
+ return this.getRuleContext(0, ReadStatementContext);
2096
+ }
2097
+ editStatement() {
2098
+ return this.getRuleContext(0, EditStatementContext);
2099
+ }
2100
+ copyStatement() {
2101
+ return this.getRuleContext(0, CopyStatementContext);
2102
+ }
2103
+ moveStatement() {
2104
+ return this.getRuleContext(0, MoveStatementContext);
2105
+ }
2106
+ openStatement() {
2107
+ return this.getRuleContext(0, OpenStatementContext);
2108
+ }
2109
+ foldStatement() {
2110
+ return this.getRuleContext(0, FoldStatementContext);
2111
+ }
2112
+ sendStatement() {
2113
+ return this.getRuleContext(0, SendStatementContext);
2114
+ }
2115
+ execStatement() {
2116
+ return this.getRuleContext(0, ExecStatementContext);
2117
+ }
2118
+ killStatement() {
2119
+ return this.getRuleContext(0, KillStatementContext);
2120
+ }
2121
+ get ruleIndex() {
2122
+ return plurnkParser.RULE_midStatement;
2123
+ }
2124
+ accept(visitor) {
2125
+ if (visitor.visitMidStatement) {
2126
+ return visitor.visitMidStatement(this);
2127
+ }
2128
+ else {
2129
+ return visitor.visitChildren(this);
2130
+ }
2131
+ }
2132
+ }
1671
2133
  export class FindStatementContext extends antlr.ParserRuleContext {
1672
2134
  constructor(parent, invokingState) {
1673
2135
  super(parent, invokingState);
@@ -1675,15 +2137,15 @@ export class FindStatementContext extends antlr.ParserRuleContext {
1675
2137
  OPEN_FIND() {
1676
2138
  return this.getToken(plurnkParser.OPEN_FIND, 0);
1677
2139
  }
1678
- COLON() {
1679
- return this.getToken(plurnkParser.COLON, 0);
1680
- }
1681
2140
  CLOSE_TAG() {
1682
2141
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1683
2142
  }
1684
2143
  tagOpModifiers() {
1685
2144
  return this.getRuleContext(0, TagOpModifiersContext);
1686
2145
  }
2146
+ COLON() {
2147
+ return this.getToken(plurnkParser.COLON, 0);
2148
+ }
1687
2149
  body() {
1688
2150
  return this.getRuleContext(0, BodyContext);
1689
2151
  }
@@ -1706,15 +2168,15 @@ export class ReadStatementContext extends antlr.ParserRuleContext {
1706
2168
  OPEN_READ() {
1707
2169
  return this.getToken(plurnkParser.OPEN_READ, 0);
1708
2170
  }
1709
- COLON() {
1710
- return this.getToken(plurnkParser.COLON, 0);
1711
- }
1712
2171
  CLOSE_TAG() {
1713
2172
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1714
2173
  }
1715
2174
  tagOpModifiers() {
1716
2175
  return this.getRuleContext(0, TagOpModifiersContext);
1717
2176
  }
2177
+ COLON() {
2178
+ return this.getToken(plurnkParser.COLON, 0);
2179
+ }
1718
2180
  body() {
1719
2181
  return this.getRuleContext(0, BodyContext);
1720
2182
  }
@@ -1737,15 +2199,15 @@ export class EditStatementContext extends antlr.ParserRuleContext {
1737
2199
  OPEN_EDIT() {
1738
2200
  return this.getToken(plurnkParser.OPEN_EDIT, 0);
1739
2201
  }
1740
- COLON() {
1741
- return this.getToken(plurnkParser.COLON, 0);
1742
- }
1743
2202
  CLOSE_TAG() {
1744
2203
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1745
2204
  }
1746
2205
  tagOpModifiers() {
1747
2206
  return this.getRuleContext(0, TagOpModifiersContext);
1748
2207
  }
2208
+ COLON() {
2209
+ return this.getToken(plurnkParser.COLON, 0);
2210
+ }
1749
2211
  body() {
1750
2212
  return this.getRuleContext(0, BodyContext);
1751
2213
  }
@@ -1768,15 +2230,15 @@ export class CopyStatementContext extends antlr.ParserRuleContext {
1768
2230
  OPEN_COPY() {
1769
2231
  return this.getToken(plurnkParser.OPEN_COPY, 0);
1770
2232
  }
1771
- COLON() {
1772
- return this.getToken(plurnkParser.COLON, 0);
1773
- }
1774
2233
  CLOSE_TAG() {
1775
2234
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1776
2235
  }
1777
2236
  tagOpModifiers() {
1778
2237
  return this.getRuleContext(0, TagOpModifiersContext);
1779
2238
  }
2239
+ COLON() {
2240
+ return this.getToken(plurnkParser.COLON, 0);
2241
+ }
1780
2242
  body() {
1781
2243
  return this.getRuleContext(0, BodyContext);
1782
2244
  }
@@ -1799,15 +2261,15 @@ export class MoveStatementContext extends antlr.ParserRuleContext {
1799
2261
  OPEN_MOVE() {
1800
2262
  return this.getToken(plurnkParser.OPEN_MOVE, 0);
1801
2263
  }
1802
- COLON() {
1803
- return this.getToken(plurnkParser.COLON, 0);
1804
- }
1805
2264
  CLOSE_TAG() {
1806
2265
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1807
2266
  }
1808
2267
  tagOpModifiers() {
1809
2268
  return this.getRuleContext(0, TagOpModifiersContext);
1810
2269
  }
2270
+ COLON() {
2271
+ return this.getToken(plurnkParser.COLON, 0);
2272
+ }
1811
2273
  body() {
1812
2274
  return this.getRuleContext(0, BodyContext);
1813
2275
  }
@@ -1830,15 +2292,15 @@ export class OpenStatementContext extends antlr.ParserRuleContext {
1830
2292
  OPEN_OPEN() {
1831
2293
  return this.getToken(plurnkParser.OPEN_OPEN, 0);
1832
2294
  }
1833
- COLON() {
1834
- return this.getToken(plurnkParser.COLON, 0);
1835
- }
1836
2295
  CLOSE_TAG() {
1837
2296
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1838
2297
  }
1839
2298
  tagOpModifiers() {
1840
2299
  return this.getRuleContext(0, TagOpModifiersContext);
1841
2300
  }
2301
+ COLON() {
2302
+ return this.getToken(plurnkParser.COLON, 0);
2303
+ }
1842
2304
  body() {
1843
2305
  return this.getRuleContext(0, BodyContext);
1844
2306
  }
@@ -1861,15 +2323,15 @@ export class FoldStatementContext extends antlr.ParserRuleContext {
1861
2323
  OPEN_FOLD() {
1862
2324
  return this.getToken(plurnkParser.OPEN_FOLD, 0);
1863
2325
  }
1864
- COLON() {
1865
- return this.getToken(plurnkParser.COLON, 0);
1866
- }
1867
2326
  CLOSE_TAG() {
1868
2327
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1869
2328
  }
1870
2329
  tagOpModifiers() {
1871
2330
  return this.getRuleContext(0, TagOpModifiersContext);
1872
2331
  }
2332
+ COLON() {
2333
+ return this.getToken(plurnkParser.COLON, 0);
2334
+ }
1873
2335
  body() {
1874
2336
  return this.getRuleContext(0, BodyContext);
1875
2337
  }
@@ -1892,15 +2354,15 @@ export class SendStatementContext extends antlr.ParserRuleContext {
1892
2354
  OPEN_SEND() {
1893
2355
  return this.getToken(plurnkParser.OPEN_SEND, 0);
1894
2356
  }
1895
- COLON() {
1896
- return this.getToken(plurnkParser.COLON, 0);
1897
- }
1898
2357
  CLOSE_TAG() {
1899
2358
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1900
2359
  }
1901
2360
  intOpModifiers() {
1902
2361
  return this.getRuleContext(0, IntOpModifiersContext);
1903
2362
  }
2363
+ COLON() {
2364
+ return this.getToken(plurnkParser.COLON, 0);
2365
+ }
1904
2366
  body() {
1905
2367
  return this.getRuleContext(0, BodyContext);
1906
2368
  }
@@ -1923,15 +2385,15 @@ export class ExecStatementContext extends antlr.ParserRuleContext {
1923
2385
  OPEN_EXEC() {
1924
2386
  return this.getToken(plurnkParser.OPEN_EXEC, 0);
1925
2387
  }
1926
- COLON() {
1927
- return this.getToken(plurnkParser.COLON, 0);
1928
- }
1929
2388
  CLOSE_TAG() {
1930
2389
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1931
2390
  }
1932
2391
  execModifiers() {
1933
2392
  return this.getRuleContext(0, ExecModifiersContext);
1934
2393
  }
2394
+ COLON() {
2395
+ return this.getToken(plurnkParser.COLON, 0);
2396
+ }
1935
2397
  body() {
1936
2398
  return this.getRuleContext(0, BodyContext);
1937
2399
  }
@@ -1954,15 +2416,15 @@ export class KillStatementContext extends antlr.ParserRuleContext {
1954
2416
  OPEN_KILL() {
1955
2417
  return this.getToken(plurnkParser.OPEN_KILL, 0);
1956
2418
  }
1957
- COLON() {
1958
- return this.getToken(plurnkParser.COLON, 0);
1959
- }
1960
2419
  CLOSE_TAG() {
1961
2420
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1962
2421
  }
1963
2422
  intOpModifiers() {
1964
2423
  return this.getRuleContext(0, IntOpModifiersContext);
1965
2424
  }
2425
+ COLON() {
2426
+ return this.getToken(plurnkParser.COLON, 0);
2427
+ }
1966
2428
  body() {
1967
2429
  return this.getRuleContext(0, BodyContext);
1968
2430
  }
@@ -1985,15 +2447,15 @@ export class PlanStatementContext extends antlr.ParserRuleContext {
1985
2447
  OPEN_PLAN() {
1986
2448
  return this.getToken(plurnkParser.OPEN_PLAN, 0);
1987
2449
  }
1988
- COLON() {
1989
- return this.getToken(plurnkParser.COLON, 0);
1990
- }
1991
2450
  CLOSE_TAG() {
1992
2451
  return this.getToken(plurnkParser.CLOSE_TAG, 0);
1993
2452
  }
1994
2453
  tagOpModifiers() {
1995
2454
  return this.getRuleContext(0, TagOpModifiersContext);
1996
2455
  }
2456
+ COLON() {
2457
+ return this.getToken(plurnkParser.COLON, 0);
2458
+ }
1997
2459
  body() {
1998
2460
  return this.getRuleContext(0, BodyContext);
1999
2461
  }