@plurnk/plurnk-contracts 1.4.0 → 1.6.0

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 (64) hide show
  1. package/README.md +10 -6
  2. package/SPEC.md +368 -231
  3. package/dist/plurnk.gemma.gbnf +160 -0
  4. package/dist/plurnk.qwen.gbnf +149 -0
  5. package/dist/schema/ClientStatement.json +7 -1
  6. package/dist/schema/EntryReadResult.json +1 -9
  7. package/dist/schema/MatcherBody.json +1 -1
  8. package/dist/schema/OperationResult.json +3 -0
  9. package/dist/schema/PlurnkStatement.json +57 -12
  10. package/dist/schema/ProposalProjection.json +1 -1
  11. package/dist/schema/ProviderAccounting.json +30 -0
  12. package/dist/schema/ProviderCost.json +6 -15
  13. package/dist/schema/ProviderRequestAccounting.json +17 -0
  14. package/dist/schema/ProviderUsage.json +40 -0
  15. package/dist/schema/RangeExtent.json +47 -0
  16. package/dist/schema/ResourceSelection.json +1 -1
  17. package/dist/schema/TextLineMarker.json +21 -0
  18. package/dist/src/AstBuilder.d.ts.map +1 -1
  19. package/dist/src/AstBuilder.js +123 -22
  20. package/dist/src/AstBuilder.js.map +1 -1
  21. package/dist/src/JsonResult.d.ts +3 -0
  22. package/dist/src/JsonResult.d.ts.map +1 -0
  23. package/dist/src/JsonResult.js +37 -0
  24. package/dist/src/JsonResult.js.map +1 -0
  25. package/dist/src/PlurnkErrorStrategy.d.ts +1 -0
  26. package/dist/src/PlurnkErrorStrategy.d.ts.map +1 -1
  27. package/dist/src/PlurnkErrorStrategy.js +42 -19
  28. package/dist/src/PlurnkErrorStrategy.js.map +1 -1
  29. package/dist/src/PlurnkParser.d.ts.map +1 -1
  30. package/dist/src/PlurnkParser.js +22 -139
  31. package/dist/src/PlurnkParser.js.map +1 -1
  32. package/dist/src/TagSignal.d.ts +15 -0
  33. package/dist/src/TagSignal.d.ts.map +1 -0
  34. package/dist/src/TagSignal.js +48 -0
  35. package/dist/src/TagSignal.js.map +1 -0
  36. package/dist/src/Validator.d.ts +6 -1
  37. package/dist/src/Validator.d.ts.map +1 -1
  38. package/dist/src/Validator.js +36 -1
  39. package/dist/src/Validator.js.map +1 -1
  40. package/dist/src/generated/plurnkLexer.d.ts +99 -54
  41. package/dist/src/generated/plurnkLexer.d.ts.map +1 -1
  42. package/dist/src/generated/plurnkLexer.js +889 -498
  43. package/dist/src/generated/plurnkLexer.js.map +1 -1
  44. package/dist/src/generated/plurnkParser.d.ts +99 -108
  45. package/dist/src/generated/plurnkParser.d.ts.map +1 -1
  46. package/dist/src/generated/plurnkParser.js +943 -1068
  47. package/dist/src/generated/plurnkParser.js.map +1 -1
  48. package/dist/src/generated/plurnkParserVisitor.d.ts +19 -5
  49. package/dist/src/generated/plurnkParserVisitor.d.ts.map +1 -1
  50. package/dist/src/generated/plurnkParserVisitor.js +16 -4
  51. package/dist/src/generated/plurnkParserVisitor.js.map +1 -1
  52. package/dist/src/index.d.ts +6 -2
  53. package/dist/src/index.d.ts.map +1 -1
  54. package/dist/src/index.js +4 -2
  55. package/dist/src/index.js.map +1 -1
  56. package/dist/src/types.d.ts +2 -1
  57. package/dist/src/types.d.ts.map +1 -1
  58. package/dist/src/types.generated.d.ts +98 -24
  59. package/dist/src/types.generated.d.ts.map +1 -1
  60. package/dist/src/types.js +4 -1
  61. package/dist/src/types.js.map +1 -1
  62. package/package.json +8 -8
  63. package/plurnk.md +143 -133
  64. package/dist/plurnk.gbnf +0 -394
package/dist/src/generated/plurnkParser.js CHANGED
@@ -5,18 +5,18 @@ export class plurnkParser extends antlr.Parser {
5
5
  static LPAREN = 3;
6
6
  static RPAREN = 4;
7
7
  static L_MARKER = 5;
8
- static COLON = 6;
9
- static COMMA = 7;
10
- static INT = 8;
11
- static DISPOSITION = 9;
12
- static IDENT = 10;
13
- static TAG = 11;
14
- static TARGET_TEXT = 12;
15
- static BODY_TEXT = 13;
16
- static CLOSE_TAG = 14;
17
- static TEXT = 15;
18
- static OPEN_TURN = 16;
19
- static CLOSE_TURN = 17;
8
+ static COMBINED_L_MARKER = 6;
9
+ static BODY_OPEN = 7;
10
+ static SECTION_END = 8;
11
+ static COMMA = 9;
12
+ static INT = 10;
13
+ static DISPOSITION = 11;
14
+ static IDENT = 12;
15
+ static TAG = 13;
16
+ static TARGET_TEXT = 14;
17
+ static BODY_TEXT = 15;
18
+ static TEXT = 16;
19
+ static OPEN_PLAN = 17;
20
20
  static OPEN_FIND = 18;
21
21
  static OPEN_READ = 19;
22
22
  static OPEN_EDIT = 20;
@@ -26,24 +26,26 @@ export class plurnkParser extends antlr.Parser {
26
26
  static OPEN_FOLD = 24;
27
27
  static OPEN_SEND = 25;
28
28
  static OPEN_EXEC = 26;
29
- static OPEN_WORK = 27;
30
- static OPEN_FORK = 28;
31
- static OPEN_KILL = 29;
32
- static OPEN_PLAN = 30;
29
+ static OPEN_BARE = 27;
30
+ static OPEN_WORK = 28;
31
+ static OPEN_FORK = 29;
32
+ static OPEN_KILL = 30;
33
33
  static OPEN_LOOK = 31;
34
34
  static OPEN_BUFF = 32;
35
- static WS = 33;
36
- static SLOTS_WS = 34;
37
- static ST_WS = 35;
38
- static SI_WS = 36;
39
- static SD_WS = 37;
40
- static ST_COMMA = 38;
41
- static TARGET_BACKSLASH = 39;
42
- static B_COLON = 40;
35
+ static FENCE_OPEN = 33;
36
+ static FENCE_CLOSE = 34;
37
+ static WS = 35;
38
+ static SLOTS_WS = 36;
39
+ static ST_WS = 37;
40
+ static SI_WS = 38;
41
+ static SD_WS = 39;
42
+ static TEXT_HASH = 40;
43
+ static ST_COMMA = 41;
44
+ static TARGET_BACKSLASH = 42;
43
45
  static RULE_document = 0;
44
46
  static RULE_log = 1;
45
- static RULE_turnStatement = 2;
46
- static RULE_turnContent = 3;
47
+ static RULE_turnContent = 2;
48
+ static RULE_turn = 3;
47
49
  static RULE_statementSeq = 4;
48
50
  static RULE_clientStatementSeq = 5;
49
51
  static RULE_clientStatement = 6;
@@ -59,54 +61,57 @@ export class plurnkParser extends antlr.Parser {
59
61
  static RULE_sendStatement = 16;
60
62
  static RULE_midSend = 17;
61
63
  static RULE_execStatement = 18;
62
- static RULE_workStatement = 19;
63
- static RULE_forkStatement = 20;
64
- static RULE_killStatement = 21;
65
- static RULE_planStatement = 22;
66
- static RULE_lookStatement = 23;
67
- static RULE_buffStatement = 24;
68
- static RULE_tagOpModifiers = 25;
69
- static RULE_curationModifiers = 26;
70
- static RULE_intOpModifiers = 27;
71
- static RULE_branchModifiers = 28;
72
- static RULE_termModifiers = 29;
73
- static RULE_midModifiers = 30;
74
- static RULE_execModifiers = 31;
75
- static RULE_tagSignal = 32;
76
- static RULE_branchSignal = 33;
77
- static RULE_intSignal = 34;
78
- static RULE_midSignal = 35;
79
- static RULE_dispSignal = 36;
80
- static RULE_identSignal = 37;
81
- static RULE_target = 38;
82
- static RULE_lineMarker = 39;
83
- static RULE_body = 40;
64
+ static RULE_bareStatement = 19;
65
+ static RULE_workStatement = 20;
66
+ static RULE_forkStatement = 21;
67
+ static RULE_killStatement = 22;
68
+ static RULE_planStatement = 23;
69
+ static RULE_lookStatement = 24;
70
+ static RULE_buffStatement = 25;
71
+ static RULE_statementEnd = 26;
72
+ static RULE_tagOpModifiers = 27;
73
+ static RULE_curationModifiers = 28;
74
+ static RULE_intOpModifiers = 29;
75
+ static RULE_branchModifiers = 30;
76
+ static RULE_termModifiers = 31;
77
+ static RULE_midModifiers = 32;
78
+ static RULE_execModifiers = 33;
79
+ static RULE_tagSignal = 34;
80
+ static RULE_branchSignal = 35;
81
+ static RULE_intSignal = 36;
82
+ static RULE_midSignal = 37;
83
+ static RULE_dispSignal = 38;
84
+ static RULE_identSignal = 39;
85
+ static RULE_target = 40;
86
+ static RULE_lineMarker = 41;
87
+ static RULE_body = 42;
84
88
  static literalNames = [
85
89
  null, null, null, null, null, null, null, null, null, null, null,
86
90
  null, null, null, null, null, null, null, null, null, null, null,
87
91
  null, null, null, null, null, null, null, null, null, null, null,
88
- null, null, null, null, null, "','", "'\\'", "':'"
92
+ null, null, null, null, null, null, null, "'#'", "','", "'\\'"
89
93
  ];
90
94
  static symbolicNames = [
91
- null, "LBRACKET", "RBRACKET", "LPAREN", "RPAREN", "L_MARKER", "COLON",
92
- "COMMA", "INT", "DISPOSITION", "IDENT", "TAG", "TARGET_TEXT", "BODY_TEXT",
93
- "CLOSE_TAG", "TEXT", "OPEN_TURN", "CLOSE_TURN", "OPEN_FIND", "OPEN_READ",
94
- "OPEN_EDIT", "OPEN_COPY", "OPEN_MOVE", "OPEN_OPEN", "OPEN_FOLD",
95
- "OPEN_SEND", "OPEN_EXEC", "OPEN_WORK", "OPEN_FORK", "OPEN_KILL",
96
- "OPEN_PLAN", "OPEN_LOOK", "OPEN_BUFF", "WS", "SLOTS_WS", "ST_WS",
97
- "SI_WS", "SD_WS", "ST_COMMA", "TARGET_BACKSLASH", "B_COLON"
95
+ null, "LBRACKET", "RBRACKET", "LPAREN", "RPAREN", "L_MARKER", "COMBINED_L_MARKER",
96
+ "BODY_OPEN", "SECTION_END", "COMMA", "INT", "DISPOSITION", "IDENT",
97
+ "TAG", "TARGET_TEXT", "BODY_TEXT", "TEXT", "OPEN_PLAN", "OPEN_FIND",
98
+ "OPEN_READ", "OPEN_EDIT", "OPEN_COPY", "OPEN_MOVE", "OPEN_OPEN",
99
+ "OPEN_FOLD", "OPEN_SEND", "OPEN_EXEC", "OPEN_BARE", "OPEN_WORK",
100
+ "OPEN_FORK", "OPEN_KILL", "OPEN_LOOK", "OPEN_BUFF", "FENCE_OPEN",
101
+ "FENCE_CLOSE", "WS", "SLOTS_WS", "ST_WS", "SI_WS", "SD_WS", "TEXT_HASH",
102
+ "ST_COMMA", "TARGET_BACKSLASH"
98
103
  ];
99
104
  static ruleNames = [
100
- "document", "log", "turnStatement", "turnContent", "statementSeq",
101
- "clientStatementSeq", "clientStatement", "statement", "midStatement",
102
- "findStatement", "readStatement", "editStatement", "copyStatement",
103
- "moveStatement", "openStatement", "foldStatement", "sendStatement",
104
- "midSend", "execStatement", "workStatement", "forkStatement", "killStatement",
105
- "planStatement", "lookStatement", "buffStatement", "tagOpModifiers",
106
- "curationModifiers", "intOpModifiers", "branchModifiers", "termModifiers",
107
- "midModifiers", "execModifiers", "tagSignal", "branchSignal", "intSignal",
108
- "midSignal", "dispSignal", "identSignal", "target", "lineMarker",
109
- "body",
105
+ "document", "log", "turnContent", "turn", "statementSeq", "clientStatementSeq",
106
+ "clientStatement", "statement", "midStatement", "findStatement",
107
+ "readStatement", "editStatement", "copyStatement", "moveStatement",
108
+ "openStatement", "foldStatement", "sendStatement", "midSend", "execStatement",
109
+ "bareStatement", "workStatement", "forkStatement", "killStatement",
110
+ "planStatement", "lookStatement", "buffStatement", "statementEnd",
111
+ "tagOpModifiers", "curationModifiers", "intOpModifiers", "branchModifiers",
112
+ "termModifiers", "midModifiers", "execModifiers", "tagSignal", "branchSignal",
113
+ "intSignal", "midSignal", "dispSignal", "identSignal", "target",
114
+ "lineMarker", "body",
110
115
  ];
111
116
  get grammarFileName() { return "plurnkParser.g4"; }
112
117
  get literalNames() { return plurnkParser.literalNames; }
@@ -123,13 +128,43 @@ export class plurnkParser extends antlr.Parser {
123
128
  document() {
124
129
  let localContext = new DocumentContext(this.context, this.state);
125
130
  this.enterRule(localContext, 0, plurnkParser.RULE_document);
131
+ let _la;
126
132
  try {
127
- this.enterOuterAlt(localContext, 1);
128
- {
129
- this.state = 82;
130
- this.turnContent();
131
- this.state = 83;
132
- this.match(plurnkParser.EOF);
133
+ this.state = 96;
134
+ this.errorHandler.sync(this);
135
+ switch (this.tokenStream.LA(1)) {
136
+ case plurnkParser.TEXT:
137
+ case plurnkParser.OPEN_PLAN:
138
+ this.enterOuterAlt(localContext, 1);
139
+ {
140
+ this.state = 86;
141
+ this.turnContent();
142
+ this.state = 87;
143
+ this.match(plurnkParser.EOF);
144
+ }
145
+ break;
146
+ case plurnkParser.FENCE_OPEN:
147
+ this.enterOuterAlt(localContext, 2);
148
+ {
149
+ this.state = 89;
150
+ this.match(plurnkParser.FENCE_OPEN);
151
+ this.state = 90;
152
+ this.turn();
153
+ this.state = 92;
154
+ this.errorHandler.sync(this);
155
+ _la = this.tokenStream.LA(1);
156
+ if (_la === 34) {
157
+ {
158
+ this.state = 91;
159
+ this.match(plurnkParser.FENCE_CLOSE);
160
+ }
161
+ }
162
+ this.state = 94;
163
+ this.match(plurnkParser.EOF);
164
+ }
165
+ break;
166
+ default:
167
+ throw new antlr.NoViableAltException(this);
133
168
  }
134
169
  }
135
170
  catch (re) {
@@ -153,21 +188,21 @@ export class plurnkParser extends antlr.Parser {
153
188
  try {
154
189
  this.enterOuterAlt(localContext, 1);
155
190
  {
156
- this.state = 86;
191
+ this.state = 99;
157
192
  this.errorHandler.sync(this);
158
193
  _la = this.tokenStream.LA(1);
159
194
  do {
160
195
  {
161
196
  {
162
- this.state = 85;
163
- this.turnStatement();
197
+ this.state = 98;
198
+ this.turnContent();
164
199
  }
165
200
  }
166
- this.state = 88;
201
+ this.state = 101;
167
202
  this.errorHandler.sync(this);
168
203
  _la = this.tokenStream.LA(1);
169
- } while (_la === 16);
170
- this.state = 90;
204
+ } while (_la === 16 || _la === 17);
205
+ this.state = 103;
171
206
  this.match(plurnkParser.EOF);
172
207
  }
173
208
  }
@@ -185,30 +220,29 @@ export class plurnkParser extends antlr.Parser {
185
220
  }
186
221
  return localContext;
187
222
  }
188
- turnStatement() {
189
- let localContext = new TurnStatementContext(this.context, this.state);
190
- this.enterRule(localContext, 4, plurnkParser.RULE_turnStatement);
223
+ turnContent() {
224
+ let localContext = new TurnContentContext(this.context, this.state);
225
+ this.enterRule(localContext, 4, plurnkParser.RULE_turnContent);
191
226
  let _la;
192
227
  try {
193
228
  this.enterOuterAlt(localContext, 1);
194
229
  {
195
- this.state = 92;
196
- this.match(plurnkParser.OPEN_TURN);
197
- this.state = 94;
230
+ this.state = 108;
198
231
  this.errorHandler.sync(this);
199
232
  _la = this.tokenStream.LA(1);
200
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
233
+ while (_la === 16) {
201
234
  {
202
- this.state = 93;
203
- this.tagOpModifiers();
235
+ {
236
+ this.state = 105;
237
+ this.match(plurnkParser.TEXT);
238
+ }
204
239
  }
240
+ this.state = 110;
241
+ this.errorHandler.sync(this);
242
+ _la = this.tokenStream.LA(1);
205
243
  }
206
- this.state = 96;
207
- this.match(plurnkParser.COLON);
208
- this.state = 97;
209
- this.turnContent();
210
- this.state = 98;
211
- this.match(plurnkParser.CLOSE_TURN);
244
+ this.state = 111;
245
+ this.turn();
212
246
  }
213
247
  }
214
248
  catch (re) {
@@ -225,87 +259,33 @@ export class plurnkParser extends antlr.Parser {
225
259
  }
226
260
  return localContext;
227
261
  }
228
- turnContent() {
229
- let localContext = new TurnContentContext(this.context, this.state);
230
- this.enterRule(localContext, 6, plurnkParser.RULE_turnContent);
231
- let _la;
262
+ turn() {
263
+ let localContext = new TurnContext(this.context, this.state);
264
+ this.enterRule(localContext, 6, plurnkParser.RULE_turn);
232
265
  try {
233
266
  let alternative;
234
267
  this.enterOuterAlt(localContext, 1);
235
268
  {
236
- this.state = 103;
237
- this.errorHandler.sync(this);
238
- _la = this.tokenStream.LA(1);
239
- while (_la === 15) {
240
- {
241
- {
242
- this.state = 100;
243
- this.match(plurnkParser.TEXT);
244
- }
245
- }
246
- this.state = 105;
247
- this.errorHandler.sync(this);
248
- _la = this.tokenStream.LA(1);
249
- }
250
- this.state = 106;
269
+ this.state = 113;
251
270
  this.planStatement();
252
- this.state = 111;
271
+ this.state = 117;
253
272
  this.errorHandler.sync(this);
254
273
  alternative = this.interpreter.adaptivePredict(this.tokenStream, 4, this.context);
255
274
  while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
256
275
  if (alternative === 1) {
257
276
  {
258
- this.state = 109;
259
- this.errorHandler.sync(this);
260
- switch (this.tokenStream.LA(1)) {
261
- case plurnkParser.OPEN_FIND:
262
- case plurnkParser.OPEN_READ:
263
- case plurnkParser.OPEN_EDIT:
264
- case plurnkParser.OPEN_COPY:
265
- case plurnkParser.OPEN_MOVE:
266
- case plurnkParser.OPEN_OPEN:
267
- case plurnkParser.OPEN_FOLD:
268
- case plurnkParser.OPEN_SEND:
269
- case plurnkParser.OPEN_EXEC:
270
- case plurnkParser.OPEN_WORK:
271
- case plurnkParser.OPEN_FORK:
272
- case plurnkParser.OPEN_KILL:
273
- {
274
- this.state = 107;
275
- this.midStatement();
276
- }
277
- break;
278
- case plurnkParser.TEXT:
279
- {
280
- this.state = 108;
281
- this.match(plurnkParser.TEXT);
282
- }
283
- break;
284
- default:
285
- throw new antlr.NoViableAltException(this);
277
+ {
278
+ this.state = 114;
279
+ this.midStatement();
286
280
  }
287
281
  }
288
282
  }
289
- this.state = 113;
283
+ this.state = 119;
290
284
  this.errorHandler.sync(this);
291
285
  alternative = this.interpreter.adaptivePredict(this.tokenStream, 4, this.context);
292
286
  }
293
- this.state = 114;
287
+ this.state = 120;
294
288
  this.sendStatement();
295
- this.state = 118;
296
- this.errorHandler.sync(this);
297
- _la = this.tokenStream.LA(1);
298
- while (_la === 15) {
299
- {
300
- {
301
- this.state = 115;
302
- this.match(plurnkParser.TEXT);
303
- }
304
- }
305
- this.state = 120;
306
- this.errorHandler.sync(this);
307
- _la = this.tokenStream.LA(1);
308
- }
309
289
  }
310
290
  }
311
291
  catch (re) {
@@ -329,21 +309,21 @@ export class plurnkParser extends antlr.Parser {
329
309
  try {
330
310
  this.enterOuterAlt(localContext, 1);
331
311
  {
332
- this.state = 124;
312
+ this.state = 125;
333
313
  this.errorHandler.sync(this);
334
314
  _la = this.tokenStream.LA(1);
335
- while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2147221504) !== 0)) {
315
+ while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2147352576) !== 0)) {
336
316
  {
337
317
  {
338
- this.state = 121;
318
+ this.state = 122;
339
319
  this.statement();
340
320
  }
341
321
  }
342
- this.state = 126;
322
+ this.state = 127;
343
323
  this.errorHandler.sync(this);
344
324
  _la = this.tokenStream.LA(1);
345
325
  }
346
- this.state = 127;
326
+ this.state = 128;
347
327
  this.match(plurnkParser.EOF);
348
328
  }
349
329
  }
@@ -368,21 +348,21 @@ export class plurnkParser extends antlr.Parser {
368
348
  try {
369
349
  this.enterOuterAlt(localContext, 1);
370
350
  {
371
- this.state = 132;
351
+ this.state = 133;
372
352
  this.errorHandler.sync(this);
373
353
  _la = this.tokenStream.LA(1);
374
- while (((((_la - 18)) & ~0x1F) === 0 && ((1 << (_la - 18)) & 32767) !== 0)) {
354
+ while (((((_la - 17)) & ~0x1F) === 0 && ((1 << (_la - 17)) & 65535) !== 0)) {
375
355
  {
376
356
  {
377
- this.state = 129;
357
+ this.state = 130;
378
358
  this.clientStatement();
379
359
  }
380
360
  }
381
- this.state = 134;
361
+ this.state = 135;
382
362
  this.errorHandler.sync(this);
383
363
  _la = this.tokenStream.LA(1);
384
364
  }
385
- this.state = 135;
365
+ this.state = 136;
386
366
  this.match(plurnkParser.EOF);
387
367
  }
388
368
  }
@@ -404,9 +384,10 @@ export class plurnkParser extends antlr.Parser {
404
384
  let localContext = new ClientStatementContext(this.context, this.state);
405
385
  this.enterRule(localContext, 12, plurnkParser.RULE_clientStatement);
406
386
  try {
407
- this.state = 140;
387
+ this.state = 141;
408
388
  this.errorHandler.sync(this);
409
389
  switch (this.tokenStream.LA(1)) {
390
+ case plurnkParser.OPEN_PLAN:
410
391
  case plurnkParser.OPEN_FIND:
411
392
  case plurnkParser.OPEN_READ:
412
393
  case plurnkParser.OPEN_EDIT:
@@ -416,27 +397,27 @@ export class plurnkParser extends antlr.Parser {
416
397
  case plurnkParser.OPEN_FOLD:
417
398
  case plurnkParser.OPEN_SEND:
418
399
  case plurnkParser.OPEN_EXEC:
400
+ case plurnkParser.OPEN_BARE:
419
401
  case plurnkParser.OPEN_WORK:
420
402
  case plurnkParser.OPEN_FORK:
421
403
  case plurnkParser.OPEN_KILL:
422
- case plurnkParser.OPEN_PLAN:
423
404
  this.enterOuterAlt(localContext, 1);
424
405
  {
425
- this.state = 137;
406
+ this.state = 138;
426
407
  this.statement();
427
408
  }
428
409
  break;
429
410
  case plurnkParser.OPEN_LOOK:
430
411
  this.enterOuterAlt(localContext, 2);
431
412
  {
432
- this.state = 138;
413
+ this.state = 139;
433
414
  this.lookStatement();
434
415
  }
435
416
  break;
436
417
  case plurnkParser.OPEN_BUFF:
437
418
  this.enterOuterAlt(localContext, 3);
438
419
  {
439
- this.state = 139;
420
+ this.state = 140;
440
421
  this.buffStatement();
441
422
  }
442
423
  break;
@@ -462,104 +443,111 @@ export class plurnkParser extends antlr.Parser {
462
443
  let localContext = new StatementContext(this.context, this.state);
463
444
  this.enterRule(localContext, 14, plurnkParser.RULE_statement);
464
445
  try {
465
- this.state = 156;
446
+ this.state = 158;
466
447
  this.errorHandler.sync(this);
467
- switch (this.interpreter.adaptivePredict(this.tokenStream, 9, this.context)) {
448
+ switch (this.interpreter.adaptivePredict(this.tokenStream, 8, this.context)) {
468
449
  case 1:
469
450
  this.enterOuterAlt(localContext, 1);
470
451
  {
471
- this.state = 142;
452
+ this.state = 143;
472
453
  this.findStatement();
473
454
  }
474
455
  break;
475
456
  case 2:
476
457
  this.enterOuterAlt(localContext, 2);
477
458
  {
478
- this.state = 143;
459
+ this.state = 144;
479
460
  this.readStatement();
480
461
  }
481
462
  break;
482
463
  case 3:
483
464
  this.enterOuterAlt(localContext, 3);
484
465
  {
485
- this.state = 144;
466
+ this.state = 145;
486
467
  this.editStatement();
487
468
  }
488
469
  break;
489
470
  case 4:
490
471
  this.enterOuterAlt(localContext, 4);
491
472
  {
492
- this.state = 145;
473
+ this.state = 146;
493
474
  this.copyStatement();
494
475
  }
495
476
  break;
496
477
  case 5:
497
478
  this.enterOuterAlt(localContext, 5);
498
479
  {
499
- this.state = 146;
480
+ this.state = 147;
500
481
  this.moveStatement();
501
482
  }
502
483
  break;
503
484
  case 6:
504
485
  this.enterOuterAlt(localContext, 6);
505
486
  {
506
- this.state = 147;
487
+ this.state = 148;
507
488
  this.openStatement();
508
489
  }
509
490
  break;
510
491
  case 7:
511
492
  this.enterOuterAlt(localContext, 7);
512
493
  {
513
- this.state = 148;
494
+ this.state = 149;
514
495
  this.foldStatement();
515
496
  }
516
497
  break;
517
498
  case 8:
518
499
  this.enterOuterAlt(localContext, 8);
519
500
  {
520
- this.state = 149;
501
+ this.state = 150;
521
502
  this.sendStatement();
522
503
  }
523
504
  break;
524
505
  case 9:
525
506
  this.enterOuterAlt(localContext, 9);
526
507
  {
527
- this.state = 150;
508
+ this.state = 151;
528
509
  this.midSend();
529
510
  }
530
511
  break;
531
512
  case 10:
532
513
  this.enterOuterAlt(localContext, 10);
533
514
  {
534
- this.state = 151;
515
+ this.state = 152;
535
516
  this.execStatement();
536
517
  }
537
518
  break;
538
519
  case 11:
539
520
  this.enterOuterAlt(localContext, 11);
540
521
  {
541
- this.state = 152;
542
- this.workStatement();
522
+ this.state = 153;
523
+ this.bareStatement();
543
524
  }
544
525
  break;
545
526
  case 12:
546
527
  this.enterOuterAlt(localContext, 12);
547
528
  {
548
- this.state = 153;
549
- this.forkStatement();
529
+ this.state = 154;
530
+ this.workStatement();
550
531
  }
551
532
  break;
552
533
  case 13:
553
534
  this.enterOuterAlt(localContext, 13);
554
535
  {
555
- this.state = 154;
556
- this.killStatement();
536
+ this.state = 155;
537
+ this.forkStatement();
557
538
  }
558
539
  break;
559
540
  case 14:
560
541
  this.enterOuterAlt(localContext, 14);
561
542
  {
562
- this.state = 155;
543
+ this.state = 156;
544
+ this.killStatement();
545
+ }
546
+ break;
547
+ case 15:
548
+ this.enterOuterAlt(localContext, 15);
549
+ {
550
+ this.state = 157;
563
551
  this.planStatement();
564
552
  }
565
553
  break;
@@ -583,90 +571,97 @@ export class plurnkParser extends antlr.Parser {
583
571
  let localContext = new MidStatementContext(this.context, this.state);
584
572
  this.enterRule(localContext, 16, plurnkParser.RULE_midStatement);
585
573
  try {
586
- this.state = 170;
574
+ this.state = 173;
587
575
  this.errorHandler.sync(this);
588
576
  switch (this.tokenStream.LA(1)) {
589
577
  case plurnkParser.OPEN_FIND:
590
578
  this.enterOuterAlt(localContext, 1);
591
579
  {
592
- this.state = 158;
580
+ this.state = 160;
593
581
  this.findStatement();
594
582
  }
595
583
  break;
596
584
  case plurnkParser.OPEN_READ:
597
585
  this.enterOuterAlt(localContext, 2);
598
586
  {
599
- this.state = 159;
587
+ this.state = 161;
600
588
  this.readStatement();
601
589
  }
602
590
  break;
603
591
  case plurnkParser.OPEN_EDIT:
604
592
  this.enterOuterAlt(localContext, 3);
605
593
  {
606
- this.state = 160;
594
+ this.state = 162;
607
595
  this.editStatement();
608
596
  }
609
597
  break;
610
598
  case plurnkParser.OPEN_COPY:
611
599
  this.enterOuterAlt(localContext, 4);
612
600
  {
613
- this.state = 161;
601
+ this.state = 163;
614
602
  this.copyStatement();
615
603
  }
616
604
  break;
617
605
  case plurnkParser.OPEN_MOVE:
618
606
  this.enterOuterAlt(localContext, 5);
619
607
  {
620
- this.state = 162;
608
+ this.state = 164;
621
609
  this.moveStatement();
622
610
  }
623
611
  break;
624
612
  case plurnkParser.OPEN_OPEN:
625
613
  this.enterOuterAlt(localContext, 6);
626
614
  {
627
- this.state = 163;
615
+ this.state = 165;
628
616
  this.openStatement();
629
617
  }
630
618
  break;
631
619
  case plurnkParser.OPEN_FOLD:
632
620
  this.enterOuterAlt(localContext, 7);
633
621
  {
634
- this.state = 164;
622
+ this.state = 166;
635
623
  this.foldStatement();
636
624
  }
637
625
  break;
638
626
  case plurnkParser.OPEN_SEND:
639
627
  this.enterOuterAlt(localContext, 8);
640
628
  {
641
- this.state = 165;
629
+ this.state = 167;
642
630
  this.midSend();
643
631
  }
644
632
  break;
645
633
  case plurnkParser.OPEN_EXEC:
646
634
  this.enterOuterAlt(localContext, 9);
647
635
  {
648
- this.state = 166;
636
+ this.state = 168;
649
637
  this.execStatement();
650
638
  }
651
639
  break;
652
- case plurnkParser.OPEN_WORK:
640
+ case plurnkParser.OPEN_BARE:
653
641
  this.enterOuterAlt(localContext, 10);
654
642
  {
655
- this.state = 167;
643
+ this.state = 169;
644
+ this.bareStatement();
645
+ }
646
+ break;
647
+ case plurnkParser.OPEN_WORK:
648
+ this.enterOuterAlt(localContext, 11);
649
+ {
650
+ this.state = 170;
656
651
  this.workStatement();
657
652
  }
658
653
  break;
659
654
  case plurnkParser.OPEN_FORK:
660
- this.enterOuterAlt(localContext, 11);
655
+ this.enterOuterAlt(localContext, 12);
661
656
  {
662
- this.state = 168;
657
+ this.state = 171;
663
658
  this.forkStatement();
664
659
  }
665
660
  break;
666
661
  case plurnkParser.OPEN_KILL:
667
- this.enterOuterAlt(localContext, 12);
662
+ this.enterOuterAlt(localContext, 13);
668
663
  {
669
- this.state = 169;
664
+ this.state = 172;
670
665
  this.killStatement();
671
666
  }
672
667
  break;
@@ -695,37 +690,19 @@ export class plurnkParser extends antlr.Parser {
695
690
  try {
696
691
  this.enterOuterAlt(localContext, 1);
697
692
  {
698
- this.state = 172;
693
+ this.state = 175;
699
694
  this.match(plurnkParser.OPEN_FIND);
700
- this.state = 174;
701
- this.errorHandler.sync(this);
702
- _la = this.tokenStream.LA(1);
703
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
704
- {
705
- this.state = 173;
706
- this.tagOpModifiers();
707
- }
708
- }
709
695
  this.state = 177;
710
696
  this.errorHandler.sync(this);
711
697
  _la = this.tokenStream.LA(1);
712
- if (_la === 6) {
698
+ if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
713
699
  {
714
700
  this.state = 176;
715
- this.match(plurnkParser.COLON);
716
- }
717
- }
718
- this.state = 180;
719
- this.errorHandler.sync(this);
720
- _la = this.tokenStream.LA(1);
721
- if (_la === 13) {
722
- {
723
- this.state = 179;
724
- this.body();
701
+ this.tagOpModifiers();
725
702
  }
726
703
  }
727
- this.state = 182;
728
- this.match(plurnkParser.CLOSE_TAG);
704
+ this.state = 179;
705
+ this.statementEnd();
729
706
  }
730
707
  }
731
708
  catch (re) {
@@ -749,37 +726,19 @@ export class plurnkParser extends antlr.Parser {
749
726
  try {
750
727
  this.enterOuterAlt(localContext, 1);
751
728
  {
752
- this.state = 184;
729
+ this.state = 181;
753
730
  this.match(plurnkParser.OPEN_READ);
754
- this.state = 186;
731
+ this.state = 183;
755
732
  this.errorHandler.sync(this);
756
733
  _la = this.tokenStream.LA(1);
757
734
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
758
735
  {
759
- this.state = 185;
736
+ this.state = 182;
760
737
  this.tagOpModifiers();
761
738
  }
762
739
  }
763
- this.state = 189;
764
- this.errorHandler.sync(this);
765
- _la = this.tokenStream.LA(1);
766
- if (_la === 6) {
767
- {
768
- this.state = 188;
769
- this.match(plurnkParser.COLON);
770
- }
771
- }
772
- this.state = 192;
773
- this.errorHandler.sync(this);
774
- _la = this.tokenStream.LA(1);
775
- if (_la === 13) {
776
- {
777
- this.state = 191;
778
- this.body();
779
- }
780
- }
781
- this.state = 194;
782
- this.match(plurnkParser.CLOSE_TAG);
740
+ this.state = 185;
741
+ this.statementEnd();
783
742
  }
784
743
  }
785
744
  catch (re) {
@@ -803,37 +762,19 @@ export class plurnkParser extends antlr.Parser {
803
762
  try {
804
763
  this.enterOuterAlt(localContext, 1);
805
764
  {
806
- this.state = 196;
765
+ this.state = 187;
807
766
  this.match(plurnkParser.OPEN_EDIT);
808
- this.state = 198;
767
+ this.state = 189;
809
768
  this.errorHandler.sync(this);
810
769
  _la = this.tokenStream.LA(1);
811
770
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
812
771
  {
813
- this.state = 197;
772
+ this.state = 188;
814
773
  this.tagOpModifiers();
815
774
  }
816
775
  }
817
- this.state = 201;
818
- this.errorHandler.sync(this);
819
- _la = this.tokenStream.LA(1);
820
- if (_la === 6) {
821
- {
822
- this.state = 200;
823
- this.match(plurnkParser.COLON);
824
- }
825
- }
826
- this.state = 204;
827
- this.errorHandler.sync(this);
828
- _la = this.tokenStream.LA(1);
829
- if (_la === 13) {
830
- {
831
- this.state = 203;
832
- this.body();
833
- }
834
- }
835
- this.state = 206;
836
- this.match(plurnkParser.CLOSE_TAG);
776
+ this.state = 191;
777
+ this.statementEnd();
837
778
  }
838
779
  }
839
780
  catch (re) {
@@ -857,37 +798,19 @@ export class plurnkParser extends antlr.Parser {
857
798
  try {
858
799
  this.enterOuterAlt(localContext, 1);
859
800
  {
860
- this.state = 208;
801
+ this.state = 193;
861
802
  this.match(plurnkParser.OPEN_COPY);
862
- this.state = 210;
803
+ this.state = 195;
863
804
  this.errorHandler.sync(this);
864
805
  _la = this.tokenStream.LA(1);
865
806
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
866
807
  {
867
- this.state = 209;
808
+ this.state = 194;
868
809
  this.tagOpModifiers();
869
810
  }
870
811
  }
871
- this.state = 213;
872
- this.errorHandler.sync(this);
873
- _la = this.tokenStream.LA(1);
874
- if (_la === 6) {
875
- {
876
- this.state = 212;
877
- this.match(plurnkParser.COLON);
878
- }
879
- }
880
- this.state = 216;
881
- this.errorHandler.sync(this);
882
- _la = this.tokenStream.LA(1);
883
- if (_la === 13) {
884
- {
885
- this.state = 215;
886
- this.body();
887
- }
888
- }
889
- this.state = 218;
890
- this.match(plurnkParser.CLOSE_TAG);
812
+ this.state = 197;
813
+ this.statementEnd();
891
814
  }
892
815
  }
893
816
  catch (re) {
@@ -911,37 +834,19 @@ export class plurnkParser extends antlr.Parser {
911
834
  try {
912
835
  this.enterOuterAlt(localContext, 1);
913
836
  {
914
- this.state = 220;
837
+ this.state = 199;
915
838
  this.match(plurnkParser.OPEN_MOVE);
916
- this.state = 222;
839
+ this.state = 201;
917
840
  this.errorHandler.sync(this);
918
841
  _la = this.tokenStream.LA(1);
919
842
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
920
843
  {
921
- this.state = 221;
844
+ this.state = 200;
922
845
  this.tagOpModifiers();
923
846
  }
924
847
  }
925
- this.state = 225;
926
- this.errorHandler.sync(this);
927
- _la = this.tokenStream.LA(1);
928
- if (_la === 6) {
929
- {
930
- this.state = 224;
931
- this.match(plurnkParser.COLON);
932
- }
933
- }
934
- this.state = 228;
935
- this.errorHandler.sync(this);
936
- _la = this.tokenStream.LA(1);
937
- if (_la === 13) {
938
- {
939
- this.state = 227;
940
- this.body();
941
- }
942
- }
943
- this.state = 230;
944
- this.match(plurnkParser.CLOSE_TAG);
848
+ this.state = 203;
849
+ this.statementEnd();
945
850
  }
946
851
  }
947
852
  catch (re) {
@@ -965,37 +870,19 @@ export class plurnkParser extends antlr.Parser {
965
870
  try {
966
871
  this.enterOuterAlt(localContext, 1);
967
872
  {
968
- this.state = 232;
873
+ this.state = 205;
969
874
  this.match(plurnkParser.OPEN_OPEN);
970
- this.state = 234;
875
+ this.state = 207;
971
876
  this.errorHandler.sync(this);
972
877
  _la = this.tokenStream.LA(1);
973
878
  if (_la === 1 || _la === 3) {
974
879
  {
975
- this.state = 233;
880
+ this.state = 206;
976
881
  this.curationModifiers();
977
882
  }
978
883
  }
979
- this.state = 237;
980
- this.errorHandler.sync(this);
981
- _la = this.tokenStream.LA(1);
982
- if (_la === 6) {
983
- {
984
- this.state = 236;
985
- this.match(plurnkParser.COLON);
986
- }
987
- }
988
- this.state = 240;
989
- this.errorHandler.sync(this);
990
- _la = this.tokenStream.LA(1);
991
- if (_la === 13) {
992
- {
993
- this.state = 239;
994
- this.body();
995
- }
996
- }
997
- this.state = 242;
998
- this.match(plurnkParser.CLOSE_TAG);
884
+ this.state = 209;
885
+ this.statementEnd();
999
886
  }
1000
887
  }
1001
888
  catch (re) {
@@ -1019,37 +906,19 @@ export class plurnkParser extends antlr.Parser {
1019
906
  try {
1020
907
  this.enterOuterAlt(localContext, 1);
1021
908
  {
1022
- this.state = 244;
909
+ this.state = 211;
1023
910
  this.match(plurnkParser.OPEN_FOLD);
1024
- this.state = 246;
911
+ this.state = 213;
1025
912
  this.errorHandler.sync(this);
1026
913
  _la = this.tokenStream.LA(1);
1027
914
  if (_la === 1 || _la === 3) {
1028
915
  {
1029
- this.state = 245;
916
+ this.state = 212;
1030
917
  this.curationModifiers();
1031
918
  }
1032
919
  }
1033
- this.state = 249;
1034
- this.errorHandler.sync(this);
1035
- _la = this.tokenStream.LA(1);
1036
- if (_la === 6) {
1037
- {
1038
- this.state = 248;
1039
- this.match(plurnkParser.COLON);
1040
- }
1041
- }
1042
- this.state = 252;
1043
- this.errorHandler.sync(this);
1044
- _la = this.tokenStream.LA(1);
1045
- if (_la === 13) {
1046
- {
1047
- this.state = 251;
1048
- this.body();
1049
- }
1050
- }
1051
- this.state = 254;
1052
- this.match(plurnkParser.CLOSE_TAG);
920
+ this.state = 215;
921
+ this.statementEnd();
1053
922
  }
1054
923
  }
1055
924
  catch (re) {
@@ -1069,34 +938,15 @@ export class plurnkParser extends antlr.Parser {
1069
938
  sendStatement() {
1070
939
  let localContext = new SendStatementContext(this.context, this.state);
1071
940
  this.enterRule(localContext, 32, plurnkParser.RULE_sendStatement);
1072
- let _la;
1073
941
  try {
1074
942
  this.enterOuterAlt(localContext, 1);
1075
943
  {
1076
- this.state = 256;
944
+ this.state = 217;
1077
945
  this.match(plurnkParser.OPEN_SEND);
1078
- this.state = 257;
946
+ this.state = 218;
1079
947
  this.termModifiers();
1080
- this.state = 259;
1081
- this.errorHandler.sync(this);
1082
- _la = this.tokenStream.LA(1);
1083
- if (_la === 6) {
1084
- {
1085
- this.state = 258;
1086
- this.match(plurnkParser.COLON);
1087
- }
1088
- }
1089
- this.state = 262;
1090
- this.errorHandler.sync(this);
1091
- _la = this.tokenStream.LA(1);
1092
- if (_la === 13) {
1093
- {
1094
- this.state = 261;
1095
- this.body();
1096
- }
1097
- }
1098
- this.state = 264;
1099
- this.match(plurnkParser.CLOSE_TAG);
948
+ this.state = 219;
949
+ this.statementEnd();
1100
950
  }
1101
951
  }
1102
952
  catch (re) {
@@ -1120,37 +970,19 @@ export class plurnkParser extends antlr.Parser {
1120
970
  try {
1121
971
  this.enterOuterAlt(localContext, 1);
1122
972
  {
1123
- this.state = 266;
973
+ this.state = 221;
1124
974
  this.match(plurnkParser.OPEN_SEND);
1125
- this.state = 268;
975
+ this.state = 223;
1126
976
  this.errorHandler.sync(this);
1127
977
  _la = this.tokenStream.LA(1);
1128
978
  if (_la === 1 || _la === 3) {
1129
979
  {
1130
- this.state = 267;
980
+ this.state = 222;
1131
981
  this.midModifiers();
1132
982
  }
1133
983
  }
1134
- this.state = 271;
1135
- this.errorHandler.sync(this);
1136
- _la = this.tokenStream.LA(1);
1137
- if (_la === 6) {
1138
- {
1139
- this.state = 270;
1140
- this.match(plurnkParser.COLON);
1141
- }
1142
- }
1143
- this.state = 274;
1144
- this.errorHandler.sync(this);
1145
- _la = this.tokenStream.LA(1);
1146
- if (_la === 13) {
1147
- {
1148
- this.state = 273;
1149
- this.body();
1150
- }
1151
- }
1152
- this.state = 276;
1153
- this.match(plurnkParser.CLOSE_TAG);
984
+ this.state = 225;
985
+ this.statementEnd();
1154
986
  }
1155
987
  }
1156
988
  catch (re) {
@@ -1174,37 +1006,55 @@ export class plurnkParser extends antlr.Parser {
1174
1006
  try {
1175
1007
  this.enterOuterAlt(localContext, 1);
1176
1008
  {
1177
- this.state = 278;
1009
+ this.state = 227;
1178
1010
  this.match(plurnkParser.OPEN_EXEC);
1179
- this.state = 280;
1011
+ this.state = 229;
1180
1012
  this.errorHandler.sync(this);
1181
1013
  _la = this.tokenStream.LA(1);
1182
1014
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
1183
1015
  {
1184
- this.state = 279;
1016
+ this.state = 228;
1185
1017
  this.execModifiers();
1186
1018
  }
1187
1019
  }
1188
- this.state = 283;
1189
- this.errorHandler.sync(this);
1190
- _la = this.tokenStream.LA(1);
1191
- if (_la === 6) {
1192
- {
1193
- this.state = 282;
1194
- this.match(plurnkParser.COLON);
1195
- }
1196
- }
1197
- this.state = 286;
1020
+ this.state = 231;
1021
+ this.statementEnd();
1022
+ }
1023
+ }
1024
+ catch (re) {
1025
+ if (re instanceof antlr.RecognitionException) {
1026
+ this.errorHandler.reportError(this, re);
1027
+ this.errorHandler.recover(this, re);
1028
+ }
1029
+ else {
1030
+ throw re;
1031
+ }
1032
+ }
1033
+ finally {
1034
+ this.exitRule();
1035
+ }
1036
+ return localContext;
1037
+ }
1038
+ bareStatement() {
1039
+ let localContext = new BareStatementContext(this.context, this.state);
1040
+ this.enterRule(localContext, 38, plurnkParser.RULE_bareStatement);
1041
+ let _la;
1042
+ try {
1043
+ this.enterOuterAlt(localContext, 1);
1044
+ {
1045
+ this.state = 233;
1046
+ this.match(plurnkParser.OPEN_BARE);
1047
+ this.state = 235;
1198
1048
  this.errorHandler.sync(this);
1199
1049
  _la = this.tokenStream.LA(1);
1200
- if (_la === 13) {
1050
+ if (_la === 1) {
1201
1051
  {
1202
- this.state = 285;
1203
- this.body();
1052
+ this.state = 234;
1053
+ this.tagSignal();
1204
1054
  }
1205
1055
  }
1206
- this.state = 288;
1207
- this.match(plurnkParser.CLOSE_TAG);
1056
+ this.state = 237;
1057
+ this.statementEnd();
1208
1058
  }
1209
1059
  }
1210
1060
  catch (re) {
@@ -1223,28 +1073,24 @@ export class plurnkParser extends antlr.Parser {
1223
1073
  }
1224
1074
  workStatement() {
1225
1075
  let localContext = new WorkStatementContext(this.context, this.state);
1226
- this.enterRule(localContext, 38, plurnkParser.RULE_workStatement);
1076
+ this.enterRule(localContext, 40, plurnkParser.RULE_workStatement);
1227
1077
  let _la;
1228
1078
  try {
1229
1079
  this.enterOuterAlt(localContext, 1);
1230
1080
  {
1231
- this.state = 290;
1081
+ this.state = 239;
1232
1082
  this.match(plurnkParser.OPEN_WORK);
1233
- this.state = 292;
1083
+ this.state = 241;
1234
1084
  this.errorHandler.sync(this);
1235
1085
  _la = this.tokenStream.LA(1);
1236
1086
  if (_la === 1 || _la === 3) {
1237
1087
  {
1238
- this.state = 291;
1088
+ this.state = 240;
1239
1089
  this.branchModifiers();
1240
1090
  }
1241
1091
  }
1242
- this.state = 294;
1243
- this.match(plurnkParser.COLON);
1244
- this.state = 295;
1245
- this.body();
1246
- this.state = 296;
1247
- this.match(plurnkParser.CLOSE_TAG);
1092
+ this.state = 243;
1093
+ this.statementEnd();
1248
1094
  }
1249
1095
  }
1250
1096
  catch (re) {
@@ -1263,28 +1109,24 @@ export class plurnkParser extends antlr.Parser {
1263
1109
  }
1264
1110
  forkStatement() {
1265
1111
  let localContext = new ForkStatementContext(this.context, this.state);
1266
- this.enterRule(localContext, 40, plurnkParser.RULE_forkStatement);
1112
+ this.enterRule(localContext, 42, plurnkParser.RULE_forkStatement);
1267
1113
  let _la;
1268
1114
  try {
1269
1115
  this.enterOuterAlt(localContext, 1);
1270
1116
  {
1271
- this.state = 298;
1117
+ this.state = 245;
1272
1118
  this.match(plurnkParser.OPEN_FORK);
1273
- this.state = 300;
1119
+ this.state = 247;
1274
1120
  this.errorHandler.sync(this);
1275
1121
  _la = this.tokenStream.LA(1);
1276
1122
  if (_la === 1 || _la === 3) {
1277
1123
  {
1278
- this.state = 299;
1124
+ this.state = 246;
1279
1125
  this.branchModifiers();
1280
1126
  }
1281
1127
  }
1282
- this.state = 302;
1283
- this.match(plurnkParser.COLON);
1284
- this.state = 303;
1285
- this.body();
1286
- this.state = 304;
1287
- this.match(plurnkParser.CLOSE_TAG);
1128
+ this.state = 249;
1129
+ this.statementEnd();
1288
1130
  }
1289
1131
  }
1290
1132
  catch (re) {
@@ -1303,42 +1145,24 @@ export class plurnkParser extends antlr.Parser {
1303
1145
  }
1304
1146
  killStatement() {
1305
1147
  let localContext = new KillStatementContext(this.context, this.state);
1306
- this.enterRule(localContext, 42, plurnkParser.RULE_killStatement);
1148
+ this.enterRule(localContext, 44, plurnkParser.RULE_killStatement);
1307
1149
  let _la;
1308
1150
  try {
1309
1151
  this.enterOuterAlt(localContext, 1);
1310
1152
  {
1311
- this.state = 306;
1153
+ this.state = 251;
1312
1154
  this.match(plurnkParser.OPEN_KILL);
1313
- this.state = 308;
1155
+ this.state = 253;
1314
1156
  this.errorHandler.sync(this);
1315
1157
  _la = this.tokenStream.LA(1);
1316
1158
  if (_la === 1 || _la === 3) {
1317
1159
  {
1318
- this.state = 307;
1160
+ this.state = 252;
1319
1161
  this.intOpModifiers();
1320
1162
  }
1321
1163
  }
1322
- this.state = 311;
1323
- this.errorHandler.sync(this);
1324
- _la = this.tokenStream.LA(1);
1325
- if (_la === 6) {
1326
- {
1327
- this.state = 310;
1328
- this.match(plurnkParser.COLON);
1329
- }
1330
- }
1331
- this.state = 314;
1332
- this.errorHandler.sync(this);
1333
- _la = this.tokenStream.LA(1);
1334
- if (_la === 13) {
1335
- {
1336
- this.state = 313;
1337
- this.body();
1338
- }
1339
- }
1340
- this.state = 316;
1341
- this.match(plurnkParser.CLOSE_TAG);
1164
+ this.state = 255;
1165
+ this.statementEnd();
1342
1166
  }
1343
1167
  }
1344
1168
  catch (re) {
@@ -1357,42 +1181,24 @@ export class plurnkParser extends antlr.Parser {
1357
1181
  }
1358
1182
  planStatement() {
1359
1183
  let localContext = new PlanStatementContext(this.context, this.state);
1360
- this.enterRule(localContext, 44, plurnkParser.RULE_planStatement);
1184
+ this.enterRule(localContext, 46, plurnkParser.RULE_planStatement);
1361
1185
  let _la;
1362
1186
  try {
1363
1187
  this.enterOuterAlt(localContext, 1);
1364
1188
  {
1365
- this.state = 318;
1189
+ this.state = 257;
1366
1190
  this.match(plurnkParser.OPEN_PLAN);
1367
- this.state = 320;
1191
+ this.state = 259;
1368
1192
  this.errorHandler.sync(this);
1369
1193
  _la = this.tokenStream.LA(1);
1370
1194
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
1371
1195
  {
1372
- this.state = 319;
1196
+ this.state = 258;
1373
1197
  this.tagOpModifiers();
1374
1198
  }
1375
1199
  }
1376
- this.state = 323;
1377
- this.errorHandler.sync(this);
1378
- _la = this.tokenStream.LA(1);
1379
- if (_la === 6) {
1380
- {
1381
- this.state = 322;
1382
- this.match(plurnkParser.COLON);
1383
- }
1384
- }
1385
- this.state = 326;
1386
- this.errorHandler.sync(this);
1387
- _la = this.tokenStream.LA(1);
1388
- if (_la === 13) {
1389
- {
1390
- this.state = 325;
1391
- this.body();
1392
- }
1393
- }
1394
- this.state = 328;
1395
- this.match(plurnkParser.CLOSE_TAG);
1200
+ this.state = 261;
1201
+ this.statementEnd();
1396
1202
  }
1397
1203
  }
1398
1204
  catch (re) {
@@ -1411,42 +1217,24 @@ export class plurnkParser extends antlr.Parser {
1411
1217
  }
1412
1218
  lookStatement() {
1413
1219
  let localContext = new LookStatementContext(this.context, this.state);
1414
- this.enterRule(localContext, 46, plurnkParser.RULE_lookStatement);
1220
+ this.enterRule(localContext, 48, plurnkParser.RULE_lookStatement);
1415
1221
  let _la;
1416
1222
  try {
1417
1223
  this.enterOuterAlt(localContext, 1);
1418
1224
  {
1419
- this.state = 330;
1225
+ this.state = 263;
1420
1226
  this.match(plurnkParser.OPEN_LOOK);
1421
- this.state = 332;
1227
+ this.state = 265;
1422
1228
  this.errorHandler.sync(this);
1423
1229
  _la = this.tokenStream.LA(1);
1424
1230
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
1425
1231
  {
1426
- this.state = 331;
1232
+ this.state = 264;
1427
1233
  this.tagOpModifiers();
1428
1234
  }
1429
1235
  }
1430
- this.state = 335;
1431
- this.errorHandler.sync(this);
1432
- _la = this.tokenStream.LA(1);
1433
- if (_la === 6) {
1434
- {
1435
- this.state = 334;
1436
- this.match(plurnkParser.COLON);
1437
- }
1438
- }
1439
- this.state = 338;
1440
- this.errorHandler.sync(this);
1441
- _la = this.tokenStream.LA(1);
1442
- if (_la === 13) {
1443
- {
1444
- this.state = 337;
1445
- this.body();
1446
- }
1447
- }
1448
- this.state = 340;
1449
- this.match(plurnkParser.CLOSE_TAG);
1236
+ this.state = 267;
1237
+ this.statementEnd();
1450
1238
  }
1451
1239
  }
1452
1240
  catch (re) {
@@ -1465,42 +1253,106 @@ export class plurnkParser extends antlr.Parser {
1465
1253
  }
1466
1254
  buffStatement() {
1467
1255
  let localContext = new BuffStatementContext(this.context, this.state);
1468
- this.enterRule(localContext, 48, plurnkParser.RULE_buffStatement);
1256
+ this.enterRule(localContext, 50, plurnkParser.RULE_buffStatement);
1469
1257
  let _la;
1470
1258
  try {
1471
1259
  this.enterOuterAlt(localContext, 1);
1472
1260
  {
1473
- this.state = 342;
1261
+ this.state = 269;
1474
1262
  this.match(plurnkParser.OPEN_BUFF);
1475
- this.state = 344;
1263
+ this.state = 271;
1476
1264
  this.errorHandler.sync(this);
1477
1265
  _la = this.tokenStream.LA(1);
1478
1266
  if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
1479
1267
  {
1480
- this.state = 343;
1268
+ this.state = 270;
1481
1269
  this.tagOpModifiers();
1482
1270
  }
1483
1271
  }
1484
- this.state = 347;
1485
- this.errorHandler.sync(this);
1486
- _la = this.tokenStream.LA(1);
1487
- if (_la === 6) {
1272
+ this.state = 273;
1273
+ this.statementEnd();
1274
+ }
1275
+ }
1276
+ catch (re) {
1277
+ if (re instanceof antlr.RecognitionException) {
1278
+ this.errorHandler.reportError(this, re);
1279
+ this.errorHandler.recover(this, re);
1280
+ }
1281
+ else {
1282
+ throw re;
1283
+ }
1284
+ }
1285
+ finally {
1286
+ this.exitRule();
1287
+ }
1288
+ return localContext;
1289
+ }
1290
+ statementEnd() {
1291
+ let localContext = new StatementEndContext(this.context, this.state);
1292
+ this.enterRule(localContext, 52, plurnkParser.RULE_statementEnd);
1293
+ let _la;
1294
+ try {
1295
+ this.state = 284;
1296
+ this.errorHandler.sync(this);
1297
+ switch (this.tokenStream.LA(1)) {
1298
+ case plurnkParser.SECTION_END:
1299
+ this.enterOuterAlt(localContext, 1);
1488
1300
  {
1489
- this.state = 346;
1490
- this.match(plurnkParser.COLON);
1301
+ this.state = 275;
1302
+ this.match(plurnkParser.SECTION_END);
1491
1303
  }
1492
- }
1493
- this.state = 350;
1494
- this.errorHandler.sync(this);
1495
- _la = this.tokenStream.LA(1);
1496
- if (_la === 13) {
1304
+ break;
1305
+ case plurnkParser.BODY_OPEN:
1306
+ this.enterOuterAlt(localContext, 2);
1497
1307
  {
1498
- this.state = 349;
1499
- this.body();
1308
+ this.state = 276;
1309
+ this.match(plurnkParser.BODY_OPEN);
1310
+ this.state = 278;
1311
+ this.errorHandler.sync(this);
1312
+ _la = this.tokenStream.LA(1);
1313
+ if (_la === 15) {
1314
+ {
1315
+ this.state = 277;
1316
+ this.body();
1317
+ }
1318
+ }
1319
+ this.state = 281;
1320
+ this.errorHandler.sync(this);
1321
+ _la = this.tokenStream.LA(1);
1322
+ if (_la === 8) {
1323
+ {
1324
+ this.state = 280;
1325
+ this.match(plurnkParser.SECTION_END);
1326
+ }
1327
+ }
1500
1328
  }
1501
- }
1502
- this.state = 352;
1503
- this.match(plurnkParser.CLOSE_TAG);
1329
+ break;
1330
+ case plurnkParser.EOF:
1331
+ case plurnkParser.TEXT:
1332
+ case plurnkParser.OPEN_PLAN:
1333
+ case plurnkParser.OPEN_FIND:
1334
+ case plurnkParser.OPEN_READ:
1335
+ case plurnkParser.OPEN_EDIT:
1336
+ case plurnkParser.OPEN_COPY:
1337
+ case plurnkParser.OPEN_MOVE:
1338
+ case plurnkParser.OPEN_OPEN:
1339
+ case plurnkParser.OPEN_FOLD:
1340
+ case plurnkParser.OPEN_SEND:
1341
+ case plurnkParser.OPEN_EXEC:
1342
+ case plurnkParser.OPEN_BARE:
1343
+ case plurnkParser.OPEN_WORK:
1344
+ case plurnkParser.OPEN_FORK:
1345
+ case plurnkParser.OPEN_KILL:
1346
+ case plurnkParser.OPEN_LOOK:
1347
+ case plurnkParser.OPEN_BUFF:
1348
+ case plurnkParser.FENCE_CLOSE:
1349
+ this.enterOuterAlt(localContext, 3);
1350
+ // tslint:disable-next-line:no-empty
1351
+ {
1352
+ }
1353
+ break;
1354
+ default:
1355
+ throw new antlr.NoViableAltException(this);
1504
1356
  }
1505
1357
  }
1506
1358
  catch (re) {
@@ -1519,30 +1371,30 @@ export class plurnkParser extends antlr.Parser {
1519
1371
  }
1520
1372
  tagOpModifiers() {
1521
1373
  let localContext = new TagOpModifiersContext(this.context, this.state);
1522
- this.enterRule(localContext, 50, plurnkParser.RULE_tagOpModifiers);
1374
+ this.enterRule(localContext, 54, plurnkParser.RULE_tagOpModifiers);
1523
1375
  let _la;
1524
1376
  try {
1525
- this.state = 387;
1377
+ this.state = 319;
1526
1378
  this.errorHandler.sync(this);
1527
1379
  switch (this.tokenStream.LA(1)) {
1528
1380
  case plurnkParser.LBRACKET:
1529
1381
  this.enterOuterAlt(localContext, 1);
1530
1382
  {
1531
- this.state = 354;
1383
+ this.state = 286;
1532
1384
  this.tagSignal();
1533
- this.state = 363;
1385
+ this.state = 295;
1534
1386
  this.errorHandler.sync(this);
1535
1387
  switch (this.tokenStream.LA(1)) {
1536
1388
  case plurnkParser.LPAREN:
1537
1389
  {
1538
- this.state = 355;
1390
+ this.state = 287;
1539
1391
  this.target();
1540
- this.state = 357;
1392
+ this.state = 289;
1541
1393
  this.errorHandler.sync(this);
1542
1394
  _la = this.tokenStream.LA(1);
1543
1395
  if (_la === 5) {
1544
1396
  {
1545
- this.state = 356;
1397
+ this.state = 288;
1546
1398
  this.lineMarker();
1547
1399
  }
1548
1400
  }
@@ -1550,22 +1402,38 @@ export class plurnkParser extends antlr.Parser {
1550
1402
  break;
1551
1403
  case plurnkParser.L_MARKER:
1552
1404
  {
1553
- this.state = 359;
1405
+ this.state = 291;
1554
1406
  this.lineMarker();
1555
- this.state = 361;
1407
+ this.state = 293;
1556
1408
  this.errorHandler.sync(this);
1557
1409
  _la = this.tokenStream.LA(1);
1558
1410
  if (_la === 3) {
1559
1411
  {
1560
- this.state = 360;
1412
+ this.state = 292;
1561
1413
  this.target();
1562
1414
  }
1563
1415
  }
1564
1416
  }
1565
1417
  break;
1566
- case plurnkParser.COLON:
1567
- case plurnkParser.BODY_TEXT:
1568
- case plurnkParser.CLOSE_TAG:
1418
+ case plurnkParser.EOF:
1419
+ case plurnkParser.BODY_OPEN:
1420
+ case plurnkParser.SECTION_END:
1421
+ case plurnkParser.OPEN_PLAN:
1422
+ case plurnkParser.OPEN_FIND:
1423
+ case plurnkParser.OPEN_READ:
1424
+ case plurnkParser.OPEN_EDIT:
1425
+ case plurnkParser.OPEN_COPY:
1426
+ case plurnkParser.OPEN_MOVE:
1427
+ case plurnkParser.OPEN_OPEN:
1428
+ case plurnkParser.OPEN_FOLD:
1429
+ case plurnkParser.OPEN_SEND:
1430
+ case plurnkParser.OPEN_EXEC:
1431
+ case plurnkParser.OPEN_BARE:
1432
+ case plurnkParser.OPEN_WORK:
1433
+ case plurnkParser.OPEN_FORK:
1434
+ case plurnkParser.OPEN_KILL:
1435
+ case plurnkParser.OPEN_LOOK:
1436
+ case plurnkParser.OPEN_BUFF:
1569
1437
  break;
1570
1438
  default:
1571
1439
  break;
@@ -1575,21 +1443,21 @@ export class plurnkParser extends antlr.Parser {
1575
1443
  case plurnkParser.LPAREN:
1576
1444
  this.enterOuterAlt(localContext, 2);
1577
1445
  {
1578
- this.state = 365;
1446
+ this.state = 297;
1579
1447
  this.target();
1580
- this.state = 374;
1448
+ this.state = 306;
1581
1449
  this.errorHandler.sync(this);
1582
1450
  switch (this.tokenStream.LA(1)) {
1583
1451
  case plurnkParser.LBRACKET:
1584
1452
  {
1585
- this.state = 366;
1453
+ this.state = 298;
1586
1454
  this.tagSignal();
1587
- this.state = 368;
1455
+ this.state = 300;
1588
1456
  this.errorHandler.sync(this);
1589
1457
  _la = this.tokenStream.LA(1);
1590
1458
  if (_la === 5) {
1591
1459
  {
1592
- this.state = 367;
1460
+ this.state = 299;
1593
1461
  this.lineMarker();
1594
1462
  }
1595
1463
  }
@@ -1597,22 +1465,38 @@ export class plurnkParser extends antlr.Parser {
1597
1465
  break;
1598
1466
  case plurnkParser.L_MARKER:
1599
1467
  {
1600
- this.state = 370;
1468
+ this.state = 302;
1601
1469
  this.lineMarker();
1602
- this.state = 372;
1470
+ this.state = 304;
1603
1471
  this.errorHandler.sync(this);
1604
1472
  _la = this.tokenStream.LA(1);
1605
1473
  if (_la === 1) {
1606
1474
  {
1607
- this.state = 371;
1475
+ this.state = 303;
1608
1476
  this.tagSignal();
1609
1477
  }
1610
1478
  }
1611
1479
  }
1612
1480
  break;
1613
- case plurnkParser.COLON:
1614
- case plurnkParser.BODY_TEXT:
1615
- case plurnkParser.CLOSE_TAG:
1481
+ case plurnkParser.EOF:
1482
+ case plurnkParser.BODY_OPEN:
1483
+ case plurnkParser.SECTION_END:
1484
+ case plurnkParser.OPEN_PLAN:
1485
+ case plurnkParser.OPEN_FIND:
1486
+ case plurnkParser.OPEN_READ:
1487
+ case plurnkParser.OPEN_EDIT:
1488
+ case plurnkParser.OPEN_COPY:
1489
+ case plurnkParser.OPEN_MOVE:
1490
+ case plurnkParser.OPEN_OPEN:
1491
+ case plurnkParser.OPEN_FOLD:
1492
+ case plurnkParser.OPEN_SEND:
1493
+ case plurnkParser.OPEN_EXEC:
1494
+ case plurnkParser.OPEN_BARE:
1495
+ case plurnkParser.OPEN_WORK:
1496
+ case plurnkParser.OPEN_FORK:
1497
+ case plurnkParser.OPEN_KILL:
1498
+ case plurnkParser.OPEN_LOOK:
1499
+ case plurnkParser.OPEN_BUFF:
1616
1500
  break;
1617
1501
  default:
1618
1502
  break;
@@ -1622,21 +1506,21 @@ export class plurnkParser extends antlr.Parser {
1622
1506
  case plurnkParser.L_MARKER:
1623
1507
  this.enterOuterAlt(localContext, 3);
1624
1508
  {
1625
- this.state = 376;
1509
+ this.state = 308;
1626
1510
  this.lineMarker();
1627
- this.state = 385;
1511
+ this.state = 317;
1628
1512
  this.errorHandler.sync(this);
1629
1513
  switch (this.tokenStream.LA(1)) {
1630
1514
  case plurnkParser.LBRACKET:
1631
1515
  {
1632
- this.state = 377;
1516
+ this.state = 309;
1633
1517
  this.tagSignal();
1634
- this.state = 379;
1518
+ this.state = 311;
1635
1519
  this.errorHandler.sync(this);
1636
1520
  _la = this.tokenStream.LA(1);
1637
1521
  if (_la === 3) {
1638
1522
  {
1639
- this.state = 378;
1523
+ this.state = 310;
1640
1524
  this.target();
1641
1525
  }
1642
1526
  }
@@ -1644,22 +1528,38 @@ export class plurnkParser extends antlr.Parser {
1644
1528
  break;
1645
1529
  case plurnkParser.LPAREN:
1646
1530
  {
1647
- this.state = 381;
1531
+ this.state = 313;
1648
1532
  this.target();
1649
- this.state = 383;
1533
+ this.state = 315;
1650
1534
  this.errorHandler.sync(this);
1651
1535
  _la = this.tokenStream.LA(1);
1652
1536
  if (_la === 1) {
1653
1537
  {
1654
- this.state = 382;
1538
+ this.state = 314;
1655
1539
  this.tagSignal();
1656
1540
  }
1657
1541
  }
1658
1542
  }
1659
1543
  break;
1660
- case plurnkParser.COLON:
1661
- case plurnkParser.BODY_TEXT:
1662
- case plurnkParser.CLOSE_TAG:
1544
+ case plurnkParser.EOF:
1545
+ case plurnkParser.BODY_OPEN:
1546
+ case plurnkParser.SECTION_END:
1547
+ case plurnkParser.OPEN_PLAN:
1548
+ case plurnkParser.OPEN_FIND:
1549
+ case plurnkParser.OPEN_READ:
1550
+ case plurnkParser.OPEN_EDIT:
1551
+ case plurnkParser.OPEN_COPY:
1552
+ case plurnkParser.OPEN_MOVE:
1553
+ case plurnkParser.OPEN_OPEN:
1554
+ case plurnkParser.OPEN_FOLD:
1555
+ case plurnkParser.OPEN_SEND:
1556
+ case plurnkParser.OPEN_EXEC:
1557
+ case plurnkParser.OPEN_BARE:
1558
+ case plurnkParser.OPEN_WORK:
1559
+ case plurnkParser.OPEN_FORK:
1560
+ case plurnkParser.OPEN_KILL:
1561
+ case plurnkParser.OPEN_LOOK:
1562
+ case plurnkParser.OPEN_BUFF:
1663
1563
  break;
1664
1564
  default:
1665
1565
  break;
@@ -1686,23 +1586,23 @@ export class plurnkParser extends antlr.Parser {
1686
1586
  }
1687
1587
  curationModifiers() {
1688
1588
  let localContext = new CurationModifiersContext(this.context, this.state);
1689
- this.enterRule(localContext, 52, plurnkParser.RULE_curationModifiers);
1589
+ this.enterRule(localContext, 56, plurnkParser.RULE_curationModifiers);
1690
1590
  let _la;
1691
1591
  try {
1692
- this.state = 397;
1592
+ this.state = 329;
1693
1593
  this.errorHandler.sync(this);
1694
1594
  switch (this.tokenStream.LA(1)) {
1695
1595
  case plurnkParser.LBRACKET:
1696
1596
  this.enterOuterAlt(localContext, 1);
1697
1597
  {
1698
- this.state = 389;
1598
+ this.state = 321;
1699
1599
  this.tagSignal();
1700
- this.state = 391;
1600
+ this.state = 323;
1701
1601
  this.errorHandler.sync(this);
1702
1602
  _la = this.tokenStream.LA(1);
1703
1603
  if (_la === 3) {
1704
1604
  {
1705
- this.state = 390;
1605
+ this.state = 322;
1706
1606
  this.target();
1707
1607
  }
1708
1608
  }
@@ -1711,14 +1611,14 @@ export class plurnkParser extends antlr.Parser {
1711
1611
  case plurnkParser.LPAREN:
1712
1612
  this.enterOuterAlt(localContext, 2);
1713
1613
  {
1714
- this.state = 393;
1614
+ this.state = 325;
1715
1615
  this.target();
1716
- this.state = 395;
1616
+ this.state = 327;
1717
1617
  this.errorHandler.sync(this);
1718
1618
  _la = this.tokenStream.LA(1);
1719
1619
  if (_la === 1) {
1720
1620
  {
1721
- this.state = 394;
1621
+ this.state = 326;
1722
1622
  this.tagSignal();
1723
1623
  }
1724
1624
  }
@@ -1744,23 +1644,23 @@ export class plurnkParser extends antlr.Parser {
1744
1644
  }
1745
1645
  intOpModifiers() {
1746
1646
  let localContext = new IntOpModifiersContext(this.context, this.state);
1747
- this.enterRule(localContext, 54, plurnkParser.RULE_intOpModifiers);
1647
+ this.enterRule(localContext, 58, plurnkParser.RULE_intOpModifiers);
1748
1648
  let _la;
1749
1649
  try {
1750
- this.state = 407;
1650
+ this.state = 339;
1751
1651
  this.errorHandler.sync(this);
1752
1652
  switch (this.tokenStream.LA(1)) {
1753
1653
  case plurnkParser.LBRACKET:
1754
1654
  this.enterOuterAlt(localContext, 1);
1755
1655
  {
1756
- this.state = 399;
1656
+ this.state = 331;
1757
1657
  this.intSignal();
1758
- this.state = 401;
1658
+ this.state = 333;
1759
1659
  this.errorHandler.sync(this);
1760
1660
  _la = this.tokenStream.LA(1);
1761
1661
  if (_la === 3) {
1762
1662
  {
1763
- this.state = 400;
1663
+ this.state = 332;
1764
1664
  this.target();
1765
1665
  }
1766
1666
  }
@@ -1769,14 +1669,14 @@ export class plurnkParser extends antlr.Parser {
1769
1669
  case plurnkParser.LPAREN:
1770
1670
  this.enterOuterAlt(localContext, 2);
1771
1671
  {
1772
- this.state = 403;
1672
+ this.state = 335;
1773
1673
  this.target();
1774
- this.state = 405;
1674
+ this.state = 337;
1775
1675
  this.errorHandler.sync(this);
1776
1676
  _la = this.tokenStream.LA(1);
1777
1677
  if (_la === 1) {
1778
1678
  {
1779
- this.state = 404;
1679
+ this.state = 336;
1780
1680
  this.intSignal();
1781
1681
  }
1782
1682
  }
@@ -1802,23 +1702,23 @@ export class plurnkParser extends antlr.Parser {
1802
1702
  }
1803
1703
  branchModifiers() {
1804
1704
  let localContext = new BranchModifiersContext(this.context, this.state);
1805
- this.enterRule(localContext, 56, plurnkParser.RULE_branchModifiers);
1705
+ this.enterRule(localContext, 60, plurnkParser.RULE_branchModifiers);
1806
1706
  let _la;
1807
1707
  try {
1808
- this.state = 417;
1708
+ this.state = 349;
1809
1709
  this.errorHandler.sync(this);
1810
1710
  switch (this.tokenStream.LA(1)) {
1811
1711
  case plurnkParser.LBRACKET:
1812
1712
  this.enterOuterAlt(localContext, 1);
1813
1713
  {
1814
- this.state = 409;
1714
+ this.state = 341;
1815
1715
  this.branchSignal();
1816
- this.state = 411;
1716
+ this.state = 343;
1817
1717
  this.errorHandler.sync(this);
1818
1718
  _la = this.tokenStream.LA(1);
1819
1719
  if (_la === 3) {
1820
1720
  {
1821
- this.state = 410;
1721
+ this.state = 342;
1822
1722
  this.target();
1823
1723
  }
1824
1724
  }
@@ -1827,14 +1727,14 @@ export class plurnkParser extends antlr.Parser {
1827
1727
  case plurnkParser.LPAREN:
1828
1728
  this.enterOuterAlt(localContext, 2);
1829
1729
  {
1830
- this.state = 413;
1730
+ this.state = 345;
1831
1731
  this.target();
1832
- this.state = 415;
1732
+ this.state = 347;
1833
1733
  this.errorHandler.sync(this);
1834
1734
  _la = this.tokenStream.LA(1);
1835
1735
  if (_la === 1) {
1836
1736
  {
1837
- this.state = 414;
1737
+ this.state = 346;
1838
1738
  this.branchSignal();
1839
1739
  }
1840
1740
  }
@@ -1860,32 +1760,32 @@ export class plurnkParser extends antlr.Parser {
1860
1760
  }
1861
1761
  termModifiers() {
1862
1762
  let localContext = new TermModifiersContext(this.context, this.state);
1863
- this.enterRule(localContext, 58, plurnkParser.RULE_termModifiers);
1763
+ this.enterRule(localContext, 62, plurnkParser.RULE_termModifiers);
1864
1764
  let _la;
1865
1765
  try {
1866
- this.state = 431;
1766
+ this.state = 363;
1867
1767
  this.errorHandler.sync(this);
1868
1768
  switch (this.tokenStream.LA(1)) {
1869
1769
  case plurnkParser.LBRACKET:
1870
1770
  this.enterOuterAlt(localContext, 1);
1871
1771
  {
1872
- this.state = 419;
1772
+ this.state = 351;
1873
1773
  this.dispSignal();
1874
- this.state = 421;
1774
+ this.state = 353;
1875
1775
  this.errorHandler.sync(this);
1876
1776
  _la = this.tokenStream.LA(1);
1877
1777
  if (_la === 3) {
1878
1778
  {
1879
- this.state = 420;
1779
+ this.state = 352;
1880
1780
  this.target();
1881
1781
  }
1882
1782
  }
1883
- this.state = 424;
1783
+ this.state = 356;
1884
1784
  this.errorHandler.sync(this);
1885
1785
  _la = this.tokenStream.LA(1);
1886
1786
  if (_la === 5) {
1887
1787
  {
1888
- this.state = 423;
1788
+ this.state = 355;
1889
1789
  this.lineMarker();
1890
1790
  }
1891
1791
  }
@@ -1894,16 +1794,16 @@ export class plurnkParser extends antlr.Parser {
1894
1794
  case plurnkParser.LPAREN:
1895
1795
  this.enterOuterAlt(localContext, 2);
1896
1796
  {
1897
- this.state = 426;
1797
+ this.state = 358;
1898
1798
  this.target();
1899
- this.state = 427;
1799
+ this.state = 359;
1900
1800
  this.dispSignal();
1901
- this.state = 429;
1801
+ this.state = 361;
1902
1802
  this.errorHandler.sync(this);
1903
1803
  _la = this.tokenStream.LA(1);
1904
1804
  if (_la === 5) {
1905
1805
  {
1906
- this.state = 428;
1806
+ this.state = 360;
1907
1807
  this.lineMarker();
1908
1808
  }
1909
1809
  }
@@ -1929,23 +1829,23 @@ export class plurnkParser extends antlr.Parser {
1929
1829
  }
1930
1830
  midModifiers() {
1931
1831
  let localContext = new MidModifiersContext(this.context, this.state);
1932
- this.enterRule(localContext, 60, plurnkParser.RULE_midModifiers);
1832
+ this.enterRule(localContext, 64, plurnkParser.RULE_midModifiers);
1933
1833
  let _la;
1934
1834
  try {
1935
- this.state = 441;
1835
+ this.state = 373;
1936
1836
  this.errorHandler.sync(this);
1937
1837
  switch (this.tokenStream.LA(1)) {
1938
1838
  case plurnkParser.LBRACKET:
1939
1839
  this.enterOuterAlt(localContext, 1);
1940
1840
  {
1941
- this.state = 433;
1841
+ this.state = 365;
1942
1842
  this.midSignal();
1943
- this.state = 435;
1843
+ this.state = 367;
1944
1844
  this.errorHandler.sync(this);
1945
1845
  _la = this.tokenStream.LA(1);
1946
1846
  if (_la === 3) {
1947
1847
  {
1948
- this.state = 434;
1848
+ this.state = 366;
1949
1849
  this.target();
1950
1850
  }
1951
1851
  }
@@ -1954,14 +1854,14 @@ export class plurnkParser extends antlr.Parser {
1954
1854
  case plurnkParser.LPAREN:
1955
1855
  this.enterOuterAlt(localContext, 2);
1956
1856
  {
1957
- this.state = 437;
1857
+ this.state = 369;
1958
1858
  this.target();
1959
- this.state = 439;
1859
+ this.state = 371;
1960
1860
  this.errorHandler.sync(this);
1961
1861
  _la = this.tokenStream.LA(1);
1962
1862
  if (_la === 1) {
1963
1863
  {
1964
- this.state = 438;
1864
+ this.state = 370;
1965
1865
  this.midSignal();
1966
1866
  }
1967
1867
  }
@@ -1987,30 +1887,30 @@ export class plurnkParser extends antlr.Parser {
1987
1887
  }
1988
1888
  execModifiers() {
1989
1889
  let localContext = new ExecModifiersContext(this.context, this.state);
1990
- this.enterRule(localContext, 62, plurnkParser.RULE_execModifiers);
1890
+ this.enterRule(localContext, 66, plurnkParser.RULE_execModifiers);
1991
1891
  let _la;
1992
1892
  try {
1993
- this.state = 476;
1893
+ this.state = 408;
1994
1894
  this.errorHandler.sync(this);
1995
1895
  switch (this.tokenStream.LA(1)) {
1996
1896
  case plurnkParser.LBRACKET:
1997
1897
  this.enterOuterAlt(localContext, 1);
1998
1898
  {
1999
- this.state = 443;
1899
+ this.state = 375;
2000
1900
  this.identSignal();
2001
- this.state = 452;
1901
+ this.state = 384;
2002
1902
  this.errorHandler.sync(this);
2003
1903
  switch (this.tokenStream.LA(1)) {
2004
1904
  case plurnkParser.LPAREN:
2005
1905
  {
2006
- this.state = 444;
1906
+ this.state = 376;
2007
1907
  this.target();
2008
- this.state = 446;
1908
+ this.state = 378;
2009
1909
  this.errorHandler.sync(this);
2010
1910
  _la = this.tokenStream.LA(1);
2011
1911
  if (_la === 5) {
2012
1912
  {
2013
- this.state = 445;
1913
+ this.state = 377;
2014
1914
  this.lineMarker();
2015
1915
  }
2016
1916
  }
@@ -2018,22 +1918,38 @@ export class plurnkParser extends antlr.Parser {
2018
1918
  break;
2019
1919
  case plurnkParser.L_MARKER:
2020
1920
  {
2021
- this.state = 448;
1921
+ this.state = 380;
2022
1922
  this.lineMarker();
2023
- this.state = 450;
1923
+ this.state = 382;
2024
1924
  this.errorHandler.sync(this);
2025
1925
  _la = this.tokenStream.LA(1);
2026
1926
  if (_la === 3) {
2027
1927
  {
2028
- this.state = 449;
1928
+ this.state = 381;
2029
1929
  this.target();
2030
1930
  }
2031
1931
  }
2032
1932
  }
2033
1933
  break;
2034
- case plurnkParser.COLON:
2035
- case plurnkParser.BODY_TEXT:
2036
- case plurnkParser.CLOSE_TAG:
1934
+ case plurnkParser.EOF:
1935
+ case plurnkParser.BODY_OPEN:
1936
+ case plurnkParser.SECTION_END:
1937
+ case plurnkParser.OPEN_PLAN:
1938
+ case plurnkParser.OPEN_FIND:
1939
+ case plurnkParser.OPEN_READ:
1940
+ case plurnkParser.OPEN_EDIT:
1941
+ case plurnkParser.OPEN_COPY:
1942
+ case plurnkParser.OPEN_MOVE:
1943
+ case plurnkParser.OPEN_OPEN:
1944
+ case plurnkParser.OPEN_FOLD:
1945
+ case plurnkParser.OPEN_SEND:
1946
+ case plurnkParser.OPEN_EXEC:
1947
+ case plurnkParser.OPEN_BARE:
1948
+ case plurnkParser.OPEN_WORK:
1949
+ case plurnkParser.OPEN_FORK:
1950
+ case plurnkParser.OPEN_KILL:
1951
+ case plurnkParser.OPEN_LOOK:
1952
+ case plurnkParser.OPEN_BUFF:
2037
1953
  break;
2038
1954
  default:
2039
1955
  break;
@@ -2043,21 +1959,21 @@ export class plurnkParser extends antlr.Parser {
2043
1959
  case plurnkParser.LPAREN:
2044
1960
  this.enterOuterAlt(localContext, 2);
2045
1961
  {
2046
- this.state = 454;
1962
+ this.state = 386;
2047
1963
  this.target();
2048
- this.state = 463;
1964
+ this.state = 395;
2049
1965
  this.errorHandler.sync(this);
2050
1966
  switch (this.tokenStream.LA(1)) {
2051
1967
  case plurnkParser.LBRACKET:
2052
1968
  {
2053
- this.state = 455;
1969
+ this.state = 387;
2054
1970
  this.identSignal();
2055
- this.state = 457;
1971
+ this.state = 389;
2056
1972
  this.errorHandler.sync(this);
2057
1973
  _la = this.tokenStream.LA(1);
2058
1974
  if (_la === 5) {
2059
1975
  {
2060
- this.state = 456;
1976
+ this.state = 388;
2061
1977
  this.lineMarker();
2062
1978
  }
2063
1979
  }
@@ -2065,22 +1981,38 @@ export class plurnkParser extends antlr.Parser {
2065
1981
  break;
2066
1982
  case plurnkParser.L_MARKER:
2067
1983
  {
2068
- this.state = 459;
1984
+ this.state = 391;
2069
1985
  this.lineMarker();
2070
- this.state = 461;
1986
+ this.state = 393;
2071
1987
  this.errorHandler.sync(this);
2072
1988
  _la = this.tokenStream.LA(1);
2073
1989
  if (_la === 1) {
2074
1990
  {
2075
- this.state = 460;
1991
+ this.state = 392;
2076
1992
  this.identSignal();
2077
1993
  }
2078
1994
  }
2079
1995
  }
2080
1996
  break;
2081
- case plurnkParser.COLON:
2082
- case plurnkParser.BODY_TEXT:
2083
- case plurnkParser.CLOSE_TAG:
1997
+ case plurnkParser.EOF:
1998
+ case plurnkParser.BODY_OPEN:
1999
+ case plurnkParser.SECTION_END:
2000
+ case plurnkParser.OPEN_PLAN:
2001
+ case plurnkParser.OPEN_FIND:
2002
+ case plurnkParser.OPEN_READ:
2003
+ case plurnkParser.OPEN_EDIT:
2004
+ case plurnkParser.OPEN_COPY:
2005
+ case plurnkParser.OPEN_MOVE:
2006
+ case plurnkParser.OPEN_OPEN:
2007
+ case plurnkParser.OPEN_FOLD:
2008
+ case plurnkParser.OPEN_SEND:
2009
+ case plurnkParser.OPEN_EXEC:
2010
+ case plurnkParser.OPEN_BARE:
2011
+ case plurnkParser.OPEN_WORK:
2012
+ case plurnkParser.OPEN_FORK:
2013
+ case plurnkParser.OPEN_KILL:
2014
+ case plurnkParser.OPEN_LOOK:
2015
+ case plurnkParser.OPEN_BUFF:
2084
2016
  break;
2085
2017
  default:
2086
2018
  break;
@@ -2090,21 +2022,21 @@ export class plurnkParser extends antlr.Parser {
2090
2022
  case plurnkParser.L_MARKER:
2091
2023
  this.enterOuterAlt(localContext, 3);
2092
2024
  {
2093
- this.state = 465;
2025
+ this.state = 397;
2094
2026
  this.lineMarker();
2095
- this.state = 474;
2027
+ this.state = 406;
2096
2028
  this.errorHandler.sync(this);
2097
2029
  switch (this.tokenStream.LA(1)) {
2098
2030
  case plurnkParser.LBRACKET:
2099
2031
  {
2100
- this.state = 466;
2032
+ this.state = 398;
2101
2033
  this.identSignal();
2102
- this.state = 468;
2034
+ this.state = 400;
2103
2035
  this.errorHandler.sync(this);
2104
2036
  _la = this.tokenStream.LA(1);
2105
2037
  if (_la === 3) {
2106
2038
  {
2107
- this.state = 467;
2039
+ this.state = 399;
2108
2040
  this.target();
2109
2041
  }
2110
2042
  }
@@ -2112,22 +2044,38 @@ export class plurnkParser extends antlr.Parser {
2112
2044
  break;
2113
2045
  case plurnkParser.LPAREN:
2114
2046
  {
2115
- this.state = 470;
2047
+ this.state = 402;
2116
2048
  this.target();
2117
- this.state = 472;
2049
+ this.state = 404;
2118
2050
  this.errorHandler.sync(this);
2119
2051
  _la = this.tokenStream.LA(1);
2120
2052
  if (_la === 1) {
2121
2053
  {
2122
- this.state = 471;
2054
+ this.state = 403;
2123
2055
  this.identSignal();
2124
2056
  }
2125
2057
  }
2126
2058
  }
2127
2059
  break;
2128
- case plurnkParser.COLON:
2129
- case plurnkParser.BODY_TEXT:
2130
- case plurnkParser.CLOSE_TAG:
2060
+ case plurnkParser.EOF:
2061
+ case plurnkParser.BODY_OPEN:
2062
+ case plurnkParser.SECTION_END:
2063
+ case plurnkParser.OPEN_PLAN:
2064
+ case plurnkParser.OPEN_FIND:
2065
+ case plurnkParser.OPEN_READ:
2066
+ case plurnkParser.OPEN_EDIT:
2067
+ case plurnkParser.OPEN_COPY:
2068
+ case plurnkParser.OPEN_MOVE:
2069
+ case plurnkParser.OPEN_OPEN:
2070
+ case plurnkParser.OPEN_FOLD:
2071
+ case plurnkParser.OPEN_SEND:
2072
+ case plurnkParser.OPEN_EXEC:
2073
+ case plurnkParser.OPEN_BARE:
2074
+ case plurnkParser.OPEN_WORK:
2075
+ case plurnkParser.OPEN_FORK:
2076
+ case plurnkParser.OPEN_KILL:
2077
+ case plurnkParser.OPEN_LOOK:
2078
+ case plurnkParser.OPEN_BUFF:
2131
2079
  break;
2132
2080
  default:
2133
2081
  break;
@@ -2154,22 +2102,22 @@ export class plurnkParser extends antlr.Parser {
2154
2102
  }
2155
2103
  tagSignal() {
2156
2104
  let localContext = new TagSignalContext(this.context, this.state);
2157
- this.enterRule(localContext, 64, plurnkParser.RULE_tagSignal);
2105
+ this.enterRule(localContext, 68, plurnkParser.RULE_tagSignal);
2158
2106
  let _la;
2159
2107
  try {
2160
2108
  this.enterOuterAlt(localContext, 1);
2161
2109
  {
2162
- this.state = 478;
2110
+ this.state = 410;
2163
2111
  this.match(plurnkParser.LBRACKET);
2164
- this.state = 482;
2112
+ this.state = 414;
2165
2113
  this.errorHandler.sync(this);
2166
2114
  _la = this.tokenStream.LA(1);
2167
- while (_la === 7 || _la === 11) {
2115
+ while (_la === 9 || _la === 13) {
2168
2116
  {
2169
2117
  {
2170
- this.state = 479;
2118
+ this.state = 411;
2171
2119
  _la = this.tokenStream.LA(1);
2172
- if (!(_la === 7 || _la === 11)) {
2120
+ if (!(_la === 9 || _la === 13)) {
2173
2121
  this.errorHandler.recoverInline(this);
2174
2122
  }
2175
2123
  else {
@@ -2178,11 +2126,11 @@ export class plurnkParser extends antlr.Parser {
2178
2126
  }
2179
2127
  }
2180
2128
  }
2181
- this.state = 484;
2129
+ this.state = 416;
2182
2130
  this.errorHandler.sync(this);
2183
2131
  _la = this.tokenStream.LA(1);
2184
2132
  }
2185
- this.state = 485;
2133
+ this.state = 417;
2186
2134
  this.match(plurnkParser.RBRACKET);
2187
2135
  }
2188
2136
  }
@@ -2202,15 +2150,15 @@ export class plurnkParser extends antlr.Parser {
2202
2150
  }
2203
2151
  branchSignal() {
2204
2152
  let localContext = new BranchSignalContext(this.context, this.state);
2205
- this.enterRule(localContext, 66, plurnkParser.RULE_branchSignal);
2153
+ this.enterRule(localContext, 70, plurnkParser.RULE_branchSignal);
2206
2154
  try {
2207
2155
  this.enterOuterAlt(localContext, 1);
2208
2156
  {
2209
- this.state = 487;
2157
+ this.state = 419;
2210
2158
  this.match(plurnkParser.LBRACKET);
2211
- this.state = 488;
2159
+ this.state = 420;
2212
2160
  this.match(plurnkParser.TAG);
2213
- this.state = 489;
2161
+ this.state = 421;
2214
2162
  this.match(plurnkParser.RBRACKET);
2215
2163
  }
2216
2164
  }
@@ -2230,21 +2178,21 @@ export class plurnkParser extends antlr.Parser {
2230
2178
  }
2231
2179
  intSignal() {
2232
2180
  let localContext = new IntSignalContext(this.context, this.state);
2233
- this.enterRule(localContext, 68, plurnkParser.RULE_intSignal);
2181
+ this.enterRule(localContext, 72, plurnkParser.RULE_intSignal);
2234
2182
  let _la;
2235
2183
  try {
2236
2184
  this.enterOuterAlt(localContext, 1);
2237
2185
  {
2238
- this.state = 491;
2186
+ this.state = 423;
2239
2187
  this.match(plurnkParser.LBRACKET);
2240
- this.state = 493;
2188
+ this.state = 425;
2241
2189
  this.errorHandler.sync(this);
2242
2190
  _la = this.tokenStream.LA(1);
2243
- if (_la === 8 || _la === 9) {
2191
+ if (_la === 10 || _la === 11) {
2244
2192
  {
2245
- this.state = 492;
2193
+ this.state = 424;
2246
2194
  _la = this.tokenStream.LA(1);
2247
- if (!(_la === 8 || _la === 9)) {
2195
+ if (!(_la === 10 || _la === 11)) {
2248
2196
  this.errorHandler.recoverInline(this);
2249
2197
  }
2250
2198
  else {
@@ -2253,7 +2201,7 @@ export class plurnkParser extends antlr.Parser {
2253
2201
  }
2254
2202
  }
2255
2203
  }
2256
- this.state = 495;
2204
+ this.state = 427;
2257
2205
  this.match(plurnkParser.RBRACKET);
2258
2206
  }
2259
2207
  }
@@ -2273,23 +2221,23 @@ export class plurnkParser extends antlr.Parser {
2273
2221
  }
2274
2222
  midSignal() {
2275
2223
  let localContext = new MidSignalContext(this.context, this.state);
2276
- this.enterRule(localContext, 70, plurnkParser.RULE_midSignal);
2224
+ this.enterRule(localContext, 74, plurnkParser.RULE_midSignal);
2277
2225
  let _la;
2278
2226
  try {
2279
2227
  this.enterOuterAlt(localContext, 1);
2280
2228
  {
2281
- this.state = 497;
2229
+ this.state = 429;
2282
2230
  this.match(plurnkParser.LBRACKET);
2283
- this.state = 499;
2231
+ this.state = 431;
2284
2232
  this.errorHandler.sync(this);
2285
2233
  _la = this.tokenStream.LA(1);
2286
- if (_la === 8) {
2234
+ if (_la === 10) {
2287
2235
  {
2288
- this.state = 498;
2236
+ this.state = 430;
2289
2237
  this.match(plurnkParser.INT);
2290
2238
  }
2291
2239
  }
2292
- this.state = 501;
2240
+ this.state = 433;
2293
2241
  this.match(plurnkParser.RBRACKET);
2294
2242
  }
2295
2243
  }
@@ -2309,15 +2257,15 @@ export class plurnkParser extends antlr.Parser {
2309
2257
  }
2310
2258
  dispSignal() {
2311
2259
  let localContext = new DispSignalContext(this.context, this.state);
2312
- this.enterRule(localContext, 72, plurnkParser.RULE_dispSignal);
2260
+ this.enterRule(localContext, 76, plurnkParser.RULE_dispSignal);
2313
2261
  try {
2314
2262
  this.enterOuterAlt(localContext, 1);
2315
2263
  {
2316
- this.state = 503;
2264
+ this.state = 435;
2317
2265
  this.match(plurnkParser.LBRACKET);
2318
- this.state = 504;
2266
+ this.state = 436;
2319
2267
  this.match(plurnkParser.DISPOSITION);
2320
- this.state = 505;
2268
+ this.state = 437;
2321
2269
  this.match(plurnkParser.RBRACKET);
2322
2270
  }
2323
2271
  }
@@ -2337,23 +2285,23 @@ export class plurnkParser extends antlr.Parser {
2337
2285
  }
2338
2286
  identSignal() {
2339
2287
  let localContext = new IdentSignalContext(this.context, this.state);
2340
- this.enterRule(localContext, 74, plurnkParser.RULE_identSignal);
2288
+ this.enterRule(localContext, 78, plurnkParser.RULE_identSignal);
2341
2289
  let _la;
2342
2290
  try {
2343
2291
  this.enterOuterAlt(localContext, 1);
2344
2292
  {
2345
- this.state = 507;
2293
+ this.state = 439;
2346
2294
  this.match(plurnkParser.LBRACKET);
2347
- this.state = 509;
2295
+ this.state = 441;
2348
2296
  this.errorHandler.sync(this);
2349
2297
  _la = this.tokenStream.LA(1);
2350
- if (_la === 10) {
2298
+ if (_la === 12) {
2351
2299
  {
2352
- this.state = 508;
2300
+ this.state = 440;
2353
2301
  this.match(plurnkParser.IDENT);
2354
2302
  }
2355
2303
  }
2356
- this.state = 511;
2304
+ this.state = 443;
2357
2305
  this.match(plurnkParser.RBRACKET);
2358
2306
  }
2359
2307
  }
@@ -2373,28 +2321,28 @@ export class plurnkParser extends antlr.Parser {
2373
2321
  }
2374
2322
  target() {
2375
2323
  let localContext = new TargetContext(this.context, this.state);
2376
- this.enterRule(localContext, 76, plurnkParser.RULE_target);
2324
+ this.enterRule(localContext, 80, plurnkParser.RULE_target);
2377
2325
  let _la;
2378
2326
  try {
2379
2327
  this.enterOuterAlt(localContext, 1);
2380
2328
  {
2381
- this.state = 513;
2329
+ this.state = 445;
2382
2330
  this.match(plurnkParser.LPAREN);
2383
- this.state = 517;
2331
+ this.state = 449;
2384
2332
  this.errorHandler.sync(this);
2385
2333
  _la = this.tokenStream.LA(1);
2386
- while (_la === 12) {
2334
+ while (_la === 14) {
2387
2335
  {
2388
2336
  {
2389
- this.state = 514;
2337
+ this.state = 446;
2390
2338
  this.match(plurnkParser.TARGET_TEXT);
2391
2339
  }
2392
2340
  }
2393
- this.state = 519;
2341
+ this.state = 451;
2394
2342
  this.errorHandler.sync(this);
2395
2343
  _la = this.tokenStream.LA(1);
2396
2344
  }
2397
- this.state = 520;
2345
+ this.state = 452;
2398
2346
  this.match(plurnkParser.RPAREN);
2399
2347
  }
2400
2348
  }
@@ -2414,11 +2362,11 @@ export class plurnkParser extends antlr.Parser {
2414
2362
  }
2415
2363
  lineMarker() {
2416
2364
  let localContext = new LineMarkerContext(this.context, this.state);
2417
- this.enterRule(localContext, 78, plurnkParser.RULE_lineMarker);
2365
+ this.enterRule(localContext, 82, plurnkParser.RULE_lineMarker);
2418
2366
  try {
2419
2367
  this.enterOuterAlt(localContext, 1);
2420
2368
  {
2421
- this.state = 522;
2369
+ this.state = 454;
2422
2370
  this.match(plurnkParser.L_MARKER);
2423
2371
  }
2424
2372
  }
@@ -2438,25 +2386,25 @@ export class plurnkParser extends antlr.Parser {
2438
2386
  }
2439
2387
  body() {
2440
2388
  let localContext = new BodyContext(this.context, this.state);
2441
- this.enterRule(localContext, 80, plurnkParser.RULE_body);
2389
+ this.enterRule(localContext, 84, plurnkParser.RULE_body);
2442
2390
  let _la;
2443
2391
  try {
2444
2392
  this.enterOuterAlt(localContext, 1);
2445
2393
  {
2446
- this.state = 525;
2394
+ this.state = 457;
2447
2395
  this.errorHandler.sync(this);
2448
2396
  _la = this.tokenStream.LA(1);
2449
2397
  do {
2450
2398
  {
2451
2399
  {
2452
- this.state = 524;
2400
+ this.state = 456;
2453
2401
  this.match(plurnkParser.BODY_TEXT);
2454
2402
  }
2455
2403
  }
2456
- this.state = 527;
2404
+ this.state = 459;
2457
2405
  this.errorHandler.sync(this);
2458
2406
  _la = this.tokenStream.LA(1);
2459
- } while (_la === 13);
2407
+ } while (_la === 15);
2460
2408
  }
2461
2409
  }
2462
2410
  catch (re) {
@@ -2474,214 +2422,184 @@ export class plurnkParser extends antlr.Parser {
2474
2422
  return localContext;
2475
2423
  }
2476
2424
  static _serializedATN = [
2477
- 4, 1, 40, 530, 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,
2425
+ 4, 1, 42, 462, 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,
2478
2426
  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,
2479
2427
  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,
2480
2428
  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,
2481
2429
  2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33,
2482
2430
  7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39,
2483
- 2, 40, 7, 40, 1, 0, 1, 0, 1, 0, 1, 1, 4, 1, 87, 8, 1, 11, 1, 12, 1, 88, 1, 1, 1, 1, 1, 2, 1,
2484
- 2, 3, 2, 95, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 5, 3, 102, 8, 3, 10, 3, 12, 3, 105, 9, 3, 1,
2485
- 3, 1, 3, 1, 3, 5, 3, 110, 8, 3, 10, 3, 12, 3, 113, 9, 3, 1, 3, 1, 3, 5, 3, 117, 8, 3, 10, 3,
2486
- 12, 3, 120, 9, 3, 1, 4, 5, 4, 123, 8, 4, 10, 4, 12, 4, 126, 9, 4, 1, 4, 1, 4, 1, 5, 5, 5, 131,
2487
- 8, 5, 10, 5, 12, 5, 134, 9, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 3, 6, 141, 8, 6, 1, 7, 1, 7, 1,
2488
- 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 157, 8, 7, 1, 8, 1,
2489
- 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 171, 8, 8, 1, 9, 1, 9, 3,
2490
- 9, 175, 8, 9, 1, 9, 3, 9, 178, 8, 9, 1, 9, 3, 9, 181, 8, 9, 1, 9, 1, 9, 1, 10, 1, 10, 3, 10,
2491
- 187, 8, 10, 1, 10, 3, 10, 190, 8, 10, 1, 10, 3, 10, 193, 8, 10, 1, 10, 1, 10, 1, 11, 1,
2492
- 11, 3, 11, 199, 8, 11, 1, 11, 3, 11, 202, 8, 11, 1, 11, 3, 11, 205, 8, 11, 1, 11, 1, 11,
2493
- 1, 12, 1, 12, 3, 12, 211, 8, 12, 1, 12, 3, 12, 214, 8, 12, 1, 12, 3, 12, 217, 8, 12, 1,
2494
- 12, 1, 12, 1, 13, 1, 13, 3, 13, 223, 8, 13, 1, 13, 3, 13, 226, 8, 13, 1, 13, 3, 13, 229,
2495
- 8, 13, 1, 13, 1, 13, 1, 14, 1, 14, 3, 14, 235, 8, 14, 1, 14, 3, 14, 238, 8, 14, 1, 14, 3,
2496
- 14, 241, 8, 14, 1, 14, 1, 14, 1, 15, 1, 15, 3, 15, 247, 8, 15, 1, 15, 3, 15, 250, 8, 15,
2497
- 1, 15, 3, 15, 253, 8, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 3, 16, 260, 8, 16, 1, 16, 3,
2498
- 16, 263, 8, 16, 1, 16, 1, 16, 1, 17, 1, 17, 3, 17, 269, 8, 17, 1, 17, 3, 17, 272, 8, 17,
2499
- 1, 17, 3, 17, 275, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 3, 18, 281, 8, 18, 1, 18, 3, 18, 284,
2500
- 8, 18, 1, 18, 3, 18, 287, 8, 18, 1, 18, 1, 18, 1, 19, 1, 19, 3, 19, 293, 8, 19, 1, 19, 1,
2501
- 19, 1, 19, 1, 19, 1, 20, 1, 20, 3, 20, 301, 8, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1,
2502
- 21, 3, 21, 309, 8, 21, 1, 21, 3, 21, 312, 8, 21, 1, 21, 3, 21, 315, 8, 21, 1, 21, 1, 21,
2503
- 1, 22, 1, 22, 3, 22, 321, 8, 22, 1, 22, 3, 22, 324, 8, 22, 1, 22, 3, 22, 327, 8, 22, 1,
2504
- 22, 1, 22, 1, 23, 1, 23, 3, 23, 333, 8, 23, 1, 23, 3, 23, 336, 8, 23, 1, 23, 3, 23, 339,
2505
- 8, 23, 1, 23, 1, 23, 1, 24, 1, 24, 3, 24, 345, 8, 24, 1, 24, 3, 24, 348, 8, 24, 1, 24, 3,
2506
- 24, 351, 8, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 3, 25, 358, 8, 25, 1, 25, 1, 25, 3, 25,
2507
- 362, 8, 25, 3, 25, 364, 8, 25, 1, 25, 1, 25, 1, 25, 3, 25, 369, 8, 25, 1, 25, 1, 25, 3,
2508
- 25, 373, 8, 25, 3, 25, 375, 8, 25, 1, 25, 1, 25, 1, 25, 3, 25, 380, 8, 25, 1, 25, 1, 25,
2509
- 3, 25, 384, 8, 25, 3, 25, 386, 8, 25, 3, 25, 388, 8, 25, 1, 26, 1, 26, 3, 26, 392, 8, 26,
2510
- 1, 26, 1, 26, 3, 26, 396, 8, 26, 3, 26, 398, 8, 26, 1, 27, 1, 27, 3, 27, 402, 8, 27, 1,
2511
- 27, 1, 27, 3, 27, 406, 8, 27, 3, 27, 408, 8, 27, 1, 28, 1, 28, 3, 28, 412, 8, 28, 1, 28,
2512
- 1, 28, 3, 28, 416, 8, 28, 3, 28, 418, 8, 28, 1, 29, 1, 29, 3, 29, 422, 8, 29, 1, 29, 3,
2513
- 29, 425, 8, 29, 1, 29, 1, 29, 1, 29, 3, 29, 430, 8, 29, 3, 29, 432, 8, 29, 1, 30, 1, 30,
2514
- 3, 30, 436, 8, 30, 1, 30, 1, 30, 3, 30, 440, 8, 30, 3, 30, 442, 8, 30, 1, 31, 1, 31, 1,
2515
- 31, 3, 31, 447, 8, 31, 1, 31, 1, 31, 3, 31, 451, 8, 31, 3, 31, 453, 8, 31, 1, 31, 1, 31,
2516
- 1, 31, 3, 31, 458, 8, 31, 1, 31, 1, 31, 3, 31, 462, 8, 31, 3, 31, 464, 8, 31, 1, 31, 1,
2517
- 31, 1, 31, 3, 31, 469, 8, 31, 1, 31, 1, 31, 3, 31, 473, 8, 31, 3, 31, 475, 8, 31, 3, 31,
2518
- 477, 8, 31, 1, 32, 1, 32, 5, 32, 481, 8, 32, 10, 32, 12, 32, 484, 9, 32, 1, 32, 1, 32,
2519
- 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 3, 34, 494, 8, 34, 1, 34, 1, 34, 1, 35, 1, 35,
2520
- 3, 35, 500, 8, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 3, 37, 510, 8,
2521
- 37, 1, 37, 1, 37, 1, 38, 1, 38, 5, 38, 516, 8, 38, 10, 38, 12, 38, 519, 9, 38, 1, 38, 1,
2522
- 38, 1, 39, 1, 39, 1, 40, 4, 40, 526, 8, 40, 11, 40, 12, 40, 527, 1, 40, 0, 0, 41, 0, 2,
2523
- 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48,
2524
- 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 0, 2, 2, 0, 7, 7, 11, 11,
2525
- 1, 0, 8, 9, 615, 0, 82, 1, 0, 0, 0, 2, 86, 1, 0, 0, 0, 4, 92, 1, 0, 0, 0, 6, 103, 1, 0, 0, 0,
2526
- 8, 124, 1, 0, 0, 0, 10, 132, 1, 0, 0, 0, 12, 140, 1, 0, 0, 0, 14, 156, 1, 0, 0, 0, 16, 170,
2527
- 1, 0, 0, 0, 18, 172, 1, 0, 0, 0, 20, 184, 1, 0, 0, 0, 22, 196, 1, 0, 0, 0, 24, 208, 1, 0,
2528
- 0, 0, 26, 220, 1, 0, 0, 0, 28, 232, 1, 0, 0, 0, 30, 244, 1, 0, 0, 0, 32, 256, 1, 0, 0, 0,
2529
- 34, 266, 1, 0, 0, 0, 36, 278, 1, 0, 0, 0, 38, 290, 1, 0, 0, 0, 40, 298, 1, 0, 0, 0, 42, 306,
2530
- 1, 0, 0, 0, 44, 318, 1, 0, 0, 0, 46, 330, 1, 0, 0, 0, 48, 342, 1, 0, 0, 0, 50, 387, 1, 0,
2531
- 0, 0, 52, 397, 1, 0, 0, 0, 54, 407, 1, 0, 0, 0, 56, 417, 1, 0, 0, 0, 58, 431, 1, 0, 0, 0,
2532
- 60, 441, 1, 0, 0, 0, 62, 476, 1, 0, 0, 0, 64, 478, 1, 0, 0, 0, 66, 487, 1, 0, 0, 0, 68, 491,
2533
- 1, 0, 0, 0, 70, 497, 1, 0, 0, 0, 72, 503, 1, 0, 0, 0, 74, 507, 1, 0, 0, 0, 76, 513, 1, 0,
2534
- 0, 0, 78, 522, 1, 0, 0, 0, 80, 525, 1, 0, 0, 0, 82, 83, 3, 6, 3, 0, 83, 84, 5, 0, 0, 1, 84,
2535
- 1, 1, 0, 0, 0, 85, 87, 3, 4, 2, 0, 86, 85, 1, 0, 0, 0, 87, 88, 1, 0, 0, 0, 88, 86, 1, 0, 0,
2536
- 0, 88, 89, 1, 0, 0, 0, 89, 90, 1, 0, 0, 0, 90, 91, 5, 0, 0, 1, 91, 3, 1, 0, 0, 0, 92, 94, 5,
2537
- 16, 0, 0, 93, 95, 3, 50, 25, 0, 94, 93, 1, 0, 0, 0, 94, 95, 1, 0, 0, 0, 95, 96, 1, 0, 0, 0,
2538
- 96, 97, 5, 6, 0, 0, 97, 98, 3, 6, 3, 0, 98, 99, 5, 17, 0, 0, 99, 5, 1, 0, 0, 0, 100, 102,
2539
- 5, 15, 0, 0, 101, 100, 1, 0, 0, 0, 102, 105, 1, 0, 0, 0, 103, 101, 1, 0, 0, 0, 103, 104,
2540
- 1, 0, 0, 0, 104, 106, 1, 0, 0, 0, 105, 103, 1, 0, 0, 0, 106, 111, 3, 44, 22, 0, 107, 110,
2541
- 3, 16, 8, 0, 108, 110, 5, 15, 0, 0, 109, 107, 1, 0, 0, 0, 109, 108, 1, 0, 0, 0, 110, 113,
2542
- 1, 0, 0, 0, 111, 109, 1, 0, 0, 0, 111, 112, 1, 0, 0, 0, 112, 114, 1, 0, 0, 0, 113, 111,
2543
- 1, 0, 0, 0, 114, 118, 3, 32, 16, 0, 115, 117, 5, 15, 0, 0, 116, 115, 1, 0, 0, 0, 117, 120,
2544
- 1, 0, 0, 0, 118, 116, 1, 0, 0, 0, 118, 119, 1, 0, 0, 0, 119, 7, 1, 0, 0, 0, 120, 118, 1,
2545
- 0, 0, 0, 121, 123, 3, 14, 7, 0, 122, 121, 1, 0, 0, 0, 123, 126, 1, 0, 0, 0, 124, 122, 1,
2546
- 0, 0, 0, 124, 125, 1, 0, 0, 0, 125, 127, 1, 0, 0, 0, 126, 124, 1, 0, 0, 0, 127, 128, 5,
2547
- 0, 0, 1, 128, 9, 1, 0, 0, 0, 129, 131, 3, 12, 6, 0, 130, 129, 1, 0, 0, 0, 131, 134, 1, 0,
2548
- 0, 0, 132, 130, 1, 0, 0, 0, 132, 133, 1, 0, 0, 0, 133, 135, 1, 0, 0, 0, 134, 132, 1, 0,
2549
- 0, 0, 135, 136, 5, 0, 0, 1, 136, 11, 1, 0, 0, 0, 137, 141, 3, 14, 7, 0, 138, 141, 3, 46,
2550
- 23, 0, 139, 141, 3, 48, 24, 0, 140, 137, 1, 0, 0, 0, 140, 138, 1, 0, 0, 0, 140, 139, 1,
2551
- 0, 0, 0, 141, 13, 1, 0, 0, 0, 142, 157, 3, 18, 9, 0, 143, 157, 3, 20, 10, 0, 144, 157,
2552
- 3, 22, 11, 0, 145, 157, 3, 24, 12, 0, 146, 157, 3, 26, 13, 0, 147, 157, 3, 28, 14, 0,
2553
- 148, 157, 3, 30, 15, 0, 149, 157, 3, 32, 16, 0, 150, 157, 3, 34, 17, 0, 151, 157, 3,
2554
- 36, 18, 0, 152, 157, 3, 38, 19, 0, 153, 157, 3, 40, 20, 0, 154, 157, 3, 42, 21, 0, 155,
2555
- 157, 3, 44, 22, 0, 156, 142, 1, 0, 0, 0, 156, 143, 1, 0, 0, 0, 156, 144, 1, 0, 0, 0, 156,
2556
- 145, 1, 0, 0, 0, 156, 146, 1, 0, 0, 0, 156, 147, 1, 0, 0, 0, 156, 148, 1, 0, 0, 0, 156,
2557
- 149, 1, 0, 0, 0, 156, 150, 1, 0, 0, 0, 156, 151, 1, 0, 0, 0, 156, 152, 1, 0, 0, 0, 156,
2558
- 153, 1, 0, 0, 0, 156, 154, 1, 0, 0, 0, 156, 155, 1, 0, 0, 0, 157, 15, 1, 0, 0, 0, 158, 171,
2559
- 3, 18, 9, 0, 159, 171, 3, 20, 10, 0, 160, 171, 3, 22, 11, 0, 161, 171, 3, 24, 12, 0, 162,
2560
- 171, 3, 26, 13, 0, 163, 171, 3, 28, 14, 0, 164, 171, 3, 30, 15, 0, 165, 171, 3, 34, 17,
2561
- 0, 166, 171, 3, 36, 18, 0, 167, 171, 3, 38, 19, 0, 168, 171, 3, 40, 20, 0, 169, 171,
2562
- 3, 42, 21, 0, 170, 158, 1, 0, 0, 0, 170, 159, 1, 0, 0, 0, 170, 160, 1, 0, 0, 0, 170, 161,
2563
- 1, 0, 0, 0, 170, 162, 1, 0, 0, 0, 170, 163, 1, 0, 0, 0, 170, 164, 1, 0, 0, 0, 170, 165,
2564
- 1, 0, 0, 0, 170, 166, 1, 0, 0, 0, 170, 167, 1, 0, 0, 0, 170, 168, 1, 0, 0, 0, 170, 169,
2565
- 1, 0, 0, 0, 171, 17, 1, 0, 0, 0, 172, 174, 5, 18, 0, 0, 173, 175, 3, 50, 25, 0, 174, 173,
2566
- 1, 0, 0, 0, 174, 175, 1, 0, 0, 0, 175, 177, 1, 0, 0, 0, 176, 178, 5, 6, 0, 0, 177, 176,
2567
- 1, 0, 0, 0, 177, 178, 1, 0, 0, 0, 178, 180, 1, 0, 0, 0, 179, 181, 3, 80, 40, 0, 180, 179,
2568
- 1, 0, 0, 0, 180, 181, 1, 0, 0, 0, 181, 182, 1, 0, 0, 0, 182, 183, 5, 14, 0, 0, 183, 19,
2569
- 1, 0, 0, 0, 184, 186, 5, 19, 0, 0, 185, 187, 3, 50, 25, 0, 186, 185, 1, 0, 0, 0, 186, 187,
2570
- 1, 0, 0, 0, 187, 189, 1, 0, 0, 0, 188, 190, 5, 6, 0, 0, 189, 188, 1, 0, 0, 0, 189, 190,
2571
- 1, 0, 0, 0, 190, 192, 1, 0, 0, 0, 191, 193, 3, 80, 40, 0, 192, 191, 1, 0, 0, 0, 192, 193,
2572
- 1, 0, 0, 0, 193, 194, 1, 0, 0, 0, 194, 195, 5, 14, 0, 0, 195, 21, 1, 0, 0, 0, 196, 198,
2573
- 5, 20, 0, 0, 197, 199, 3, 50, 25, 0, 198, 197, 1, 0, 0, 0, 198, 199, 1, 0, 0, 0, 199, 201,
2574
- 1, 0, 0, 0, 200, 202, 5, 6, 0, 0, 201, 200, 1, 0, 0, 0, 201, 202, 1, 0, 0, 0, 202, 204,
2575
- 1, 0, 0, 0, 203, 205, 3, 80, 40, 0, 204, 203, 1, 0, 0, 0, 204, 205, 1, 0, 0, 0, 205, 206,
2576
- 1, 0, 0, 0, 206, 207, 5, 14, 0, 0, 207, 23, 1, 0, 0, 0, 208, 210, 5, 21, 0, 0, 209, 211,
2577
- 3, 50, 25, 0, 210, 209, 1, 0, 0, 0, 210, 211, 1, 0, 0, 0, 211, 213, 1, 0, 0, 0, 212, 214,
2578
- 5, 6, 0, 0, 213, 212, 1, 0, 0, 0, 213, 214, 1, 0, 0, 0, 214, 216, 1, 0, 0, 0, 215, 217,
2579
- 3, 80, 40, 0, 216, 215, 1, 0, 0, 0, 216, 217, 1, 0, 0, 0, 217, 218, 1, 0, 0, 0, 218, 219,
2580
- 5, 14, 0, 0, 219, 25, 1, 0, 0, 0, 220, 222, 5, 22, 0, 0, 221, 223, 3, 50, 25, 0, 222, 221,
2581
- 1, 0, 0, 0, 222, 223, 1, 0, 0, 0, 223, 225, 1, 0, 0, 0, 224, 226, 5, 6, 0, 0, 225, 224,
2582
- 1, 0, 0, 0, 225, 226, 1, 0, 0, 0, 226, 228, 1, 0, 0, 0, 227, 229, 3, 80, 40, 0, 228, 227,
2583
- 1, 0, 0, 0, 228, 229, 1, 0, 0, 0, 229, 230, 1, 0, 0, 0, 230, 231, 5, 14, 0, 0, 231, 27,
2584
- 1, 0, 0, 0, 232, 234, 5, 23, 0, 0, 233, 235, 3, 52, 26, 0, 234, 233, 1, 0, 0, 0, 234, 235,
2585
- 1, 0, 0, 0, 235, 237, 1, 0, 0, 0, 236, 238, 5, 6, 0, 0, 237, 236, 1, 0, 0, 0, 237, 238,
2586
- 1, 0, 0, 0, 238, 240, 1, 0, 0, 0, 239, 241, 3, 80, 40, 0, 240, 239, 1, 0, 0, 0, 240, 241,
2587
- 1, 0, 0, 0, 241, 242, 1, 0, 0, 0, 242, 243, 5, 14, 0, 0, 243, 29, 1, 0, 0, 0, 244, 246,
2588
- 5, 24, 0, 0, 245, 247, 3, 52, 26, 0, 246, 245, 1, 0, 0, 0, 246, 247, 1, 0, 0, 0, 247, 249,
2589
- 1, 0, 0, 0, 248, 250, 5, 6, 0, 0, 249, 248, 1, 0, 0, 0, 249, 250, 1, 0, 0, 0, 250, 252,
2590
- 1, 0, 0, 0, 251, 253, 3, 80, 40, 0, 252, 251, 1, 0, 0, 0, 252, 253, 1, 0, 0, 0, 253, 254,
2591
- 1, 0, 0, 0, 254, 255, 5, 14, 0, 0, 255, 31, 1, 0, 0, 0, 256, 257, 5, 25, 0, 0, 257, 259,
2592
- 3, 58, 29, 0, 258, 260, 5, 6, 0, 0, 259, 258, 1, 0, 0, 0, 259, 260, 1, 0, 0, 0, 260, 262,
2593
- 1, 0, 0, 0, 261, 263, 3, 80, 40, 0, 262, 261, 1, 0, 0, 0, 262, 263, 1, 0, 0, 0, 263, 264,
2594
- 1, 0, 0, 0, 264, 265, 5, 14, 0, 0, 265, 33, 1, 0, 0, 0, 266, 268, 5, 25, 0, 0, 267, 269,
2595
- 3, 60, 30, 0, 268, 267, 1, 0, 0, 0, 268, 269, 1, 0, 0, 0, 269, 271, 1, 0, 0, 0, 270, 272,
2596
- 5, 6, 0, 0, 271, 270, 1, 0, 0, 0, 271, 272, 1, 0, 0, 0, 272, 274, 1, 0, 0, 0, 273, 275,
2597
- 3, 80, 40, 0, 274, 273, 1, 0, 0, 0, 274, 275, 1, 0, 0, 0, 275, 276, 1, 0, 0, 0, 276, 277,
2598
- 5, 14, 0, 0, 277, 35, 1, 0, 0, 0, 278, 280, 5, 26, 0, 0, 279, 281, 3, 62, 31, 0, 280, 279,
2599
- 1, 0, 0, 0, 280, 281, 1, 0, 0, 0, 281, 283, 1, 0, 0, 0, 282, 284, 5, 6, 0, 0, 283, 282,
2600
- 1, 0, 0, 0, 283, 284, 1, 0, 0, 0, 284, 286, 1, 0, 0, 0, 285, 287, 3, 80, 40, 0, 286, 285,
2601
- 1, 0, 0, 0, 286, 287, 1, 0, 0, 0, 287, 288, 1, 0, 0, 0, 288, 289, 5, 14, 0, 0, 289, 37,
2602
- 1, 0, 0, 0, 290, 292, 5, 27, 0, 0, 291, 293, 3, 56, 28, 0, 292, 291, 1, 0, 0, 0, 292, 293,
2603
- 1, 0, 0, 0, 293, 294, 1, 0, 0, 0, 294, 295, 5, 6, 0, 0, 295, 296, 3, 80, 40, 0, 296, 297,
2604
- 5, 14, 0, 0, 297, 39, 1, 0, 0, 0, 298, 300, 5, 28, 0, 0, 299, 301, 3, 56, 28, 0, 300, 299,
2605
- 1, 0, 0, 0, 300, 301, 1, 0, 0, 0, 301, 302, 1, 0, 0, 0, 302, 303, 5, 6, 0, 0, 303, 304,
2606
- 3, 80, 40, 0, 304, 305, 5, 14, 0, 0, 305, 41, 1, 0, 0, 0, 306, 308, 5, 29, 0, 0, 307, 309,
2607
- 3, 54, 27, 0, 308, 307, 1, 0, 0, 0, 308, 309, 1, 0, 0, 0, 309, 311, 1, 0, 0, 0, 310, 312,
2608
- 5, 6, 0, 0, 311, 310, 1, 0, 0, 0, 311, 312, 1, 0, 0, 0, 312, 314, 1, 0, 0, 0, 313, 315,
2609
- 3, 80, 40, 0, 314, 313, 1, 0, 0, 0, 314, 315, 1, 0, 0, 0, 315, 316, 1, 0, 0, 0, 316, 317,
2610
- 5, 14, 0, 0, 317, 43, 1, 0, 0, 0, 318, 320, 5, 30, 0, 0, 319, 321, 3, 50, 25, 0, 320, 319,
2611
- 1, 0, 0, 0, 320, 321, 1, 0, 0, 0, 321, 323, 1, 0, 0, 0, 322, 324, 5, 6, 0, 0, 323, 322,
2612
- 1, 0, 0, 0, 323, 324, 1, 0, 0, 0, 324, 326, 1, 0, 0, 0, 325, 327, 3, 80, 40, 0, 326, 325,
2613
- 1, 0, 0, 0, 326, 327, 1, 0, 0, 0, 327, 328, 1, 0, 0, 0, 328, 329, 5, 14, 0, 0, 329, 45,
2614
- 1, 0, 0, 0, 330, 332, 5, 31, 0, 0, 331, 333, 3, 50, 25, 0, 332, 331, 1, 0, 0, 0, 332, 333,
2615
- 1, 0, 0, 0, 333, 335, 1, 0, 0, 0, 334, 336, 5, 6, 0, 0, 335, 334, 1, 0, 0, 0, 335, 336,
2616
- 1, 0, 0, 0, 336, 338, 1, 0, 0, 0, 337, 339, 3, 80, 40, 0, 338, 337, 1, 0, 0, 0, 338, 339,
2617
- 1, 0, 0, 0, 339, 340, 1, 0, 0, 0, 340, 341, 5, 14, 0, 0, 341, 47, 1, 0, 0, 0, 342, 344,
2618
- 5, 32, 0, 0, 343, 345, 3, 50, 25, 0, 344, 343, 1, 0, 0, 0, 344, 345, 1, 0, 0, 0, 345, 347,
2619
- 1, 0, 0, 0, 346, 348, 5, 6, 0, 0, 347, 346, 1, 0, 0, 0, 347, 348, 1, 0, 0, 0, 348, 350,
2620
- 1, 0, 0, 0, 349, 351, 3, 80, 40, 0, 350, 349, 1, 0, 0, 0, 350, 351, 1, 0, 0, 0, 351, 352,
2621
- 1, 0, 0, 0, 352, 353, 5, 14, 0, 0, 353, 49, 1, 0, 0, 0, 354, 363, 3, 64, 32, 0, 355, 357,
2622
- 3, 76, 38, 0, 356, 358, 3, 78, 39, 0, 357, 356, 1, 0, 0, 0, 357, 358, 1, 0, 0, 0, 358,
2623
- 364, 1, 0, 0, 0, 359, 361, 3, 78, 39, 0, 360, 362, 3, 76, 38, 0, 361, 360, 1, 0, 0, 0,
2624
- 361, 362, 1, 0, 0, 0, 362, 364, 1, 0, 0, 0, 363, 355, 1, 0, 0, 0, 363, 359, 1, 0, 0, 0,
2625
- 363, 364, 1, 0, 0, 0, 364, 388, 1, 0, 0, 0, 365, 374, 3, 76, 38, 0, 366, 368, 3, 64, 32,
2626
- 0, 367, 369, 3, 78, 39, 0, 368, 367, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 375, 1, 0,
2627
- 0, 0, 370, 372, 3, 78, 39, 0, 371, 373, 3, 64, 32, 0, 372, 371, 1, 0, 0, 0, 372, 373,
2628
- 1, 0, 0, 0, 373, 375, 1, 0, 0, 0, 374, 366, 1, 0, 0, 0, 374, 370, 1, 0, 0, 0, 374, 375,
2629
- 1, 0, 0, 0, 375, 388, 1, 0, 0, 0, 376, 385, 3, 78, 39, 0, 377, 379, 3, 64, 32, 0, 378,
2630
- 380, 3, 76, 38, 0, 379, 378, 1, 0, 0, 0, 379, 380, 1, 0, 0, 0, 380, 386, 1, 0, 0, 0, 381,
2631
- 383, 3, 76, 38, 0, 382, 384, 3, 64, 32, 0, 383, 382, 1, 0, 0, 0, 383, 384, 1, 0, 0, 0,
2632
- 384, 386, 1, 0, 0, 0, 385, 377, 1, 0, 0, 0, 385, 381, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0,
2633
- 386, 388, 1, 0, 0, 0, 387, 354, 1, 0, 0, 0, 387, 365, 1, 0, 0, 0, 387, 376, 1, 0, 0, 0,
2634
- 388, 51, 1, 0, 0, 0, 389, 391, 3, 64, 32, 0, 390, 392, 3, 76, 38, 0, 391, 390, 1, 0, 0,
2635
- 0, 391, 392, 1, 0, 0, 0, 392, 398, 1, 0, 0, 0, 393, 395, 3, 76, 38, 0, 394, 396, 3, 64,
2636
- 32, 0, 395, 394, 1, 0, 0, 0, 395, 396, 1, 0, 0, 0, 396, 398, 1, 0, 0, 0, 397, 389, 1, 0,
2637
- 0, 0, 397, 393, 1, 0, 0, 0, 398, 53, 1, 0, 0, 0, 399, 401, 3, 68, 34, 0, 400, 402, 3, 76,
2638
- 38, 0, 401, 400, 1, 0, 0, 0, 401, 402, 1, 0, 0, 0, 402, 408, 1, 0, 0, 0, 403, 405, 3, 76,
2639
- 38, 0, 404, 406, 3, 68, 34, 0, 405, 404, 1, 0, 0, 0, 405, 406, 1, 0, 0, 0, 406, 408, 1,
2640
- 0, 0, 0, 407, 399, 1, 0, 0, 0, 407, 403, 1, 0, 0, 0, 408, 55, 1, 0, 0, 0, 409, 411, 3, 66,
2641
- 33, 0, 410, 412, 3, 76, 38, 0, 411, 410, 1, 0, 0, 0, 411, 412, 1, 0, 0, 0, 412, 418, 1,
2642
- 0, 0, 0, 413, 415, 3, 76, 38, 0, 414, 416, 3, 66, 33, 0, 415, 414, 1, 0, 0, 0, 415, 416,
2643
- 1, 0, 0, 0, 416, 418, 1, 0, 0, 0, 417, 409, 1, 0, 0, 0, 417, 413, 1, 0, 0, 0, 418, 57, 1,
2644
- 0, 0, 0, 419, 421, 3, 72, 36, 0, 420, 422, 3, 76, 38, 0, 421, 420, 1, 0, 0, 0, 421, 422,
2645
- 1, 0, 0, 0, 422, 424, 1, 0, 0, 0, 423, 425, 3, 78, 39, 0, 424, 423, 1, 0, 0, 0, 424, 425,
2646
- 1, 0, 0, 0, 425, 432, 1, 0, 0, 0, 426, 427, 3, 76, 38, 0, 427, 429, 3, 72, 36, 0, 428,
2647
- 430, 3, 78, 39, 0, 429, 428, 1, 0, 0, 0, 429, 430, 1, 0, 0, 0, 430, 432, 1, 0, 0, 0, 431,
2648
- 419, 1, 0, 0, 0, 431, 426, 1, 0, 0, 0, 432, 59, 1, 0, 0, 0, 433, 435, 3, 70, 35, 0, 434,
2649
- 436, 3, 76, 38, 0, 435, 434, 1, 0, 0, 0, 435, 436, 1, 0, 0, 0, 436, 442, 1, 0, 0, 0, 437,
2650
- 439, 3, 76, 38, 0, 438, 440, 3, 70, 35, 0, 439, 438, 1, 0, 0, 0, 439, 440, 1, 0, 0, 0,
2651
- 440, 442, 1, 0, 0, 0, 441, 433, 1, 0, 0, 0, 441, 437, 1, 0, 0, 0, 442, 61, 1, 0, 0, 0, 443,
2652
- 452, 3, 74, 37, 0, 444, 446, 3, 76, 38, 0, 445, 447, 3, 78, 39, 0, 446, 445, 1, 0, 0,
2653
- 0, 446, 447, 1, 0, 0, 0, 447, 453, 1, 0, 0, 0, 448, 450, 3, 78, 39, 0, 449, 451, 3, 76,
2654
- 38, 0, 450, 449, 1, 0, 0, 0, 450, 451, 1, 0, 0, 0, 451, 453, 1, 0, 0, 0, 452, 444, 1, 0,
2655
- 0, 0, 452, 448, 1, 0, 0, 0, 452, 453, 1, 0, 0, 0, 453, 477, 1, 0, 0, 0, 454, 463, 3, 76,
2656
- 38, 0, 455, 457, 3, 74, 37, 0, 456, 458, 3, 78, 39, 0, 457, 456, 1, 0, 0, 0, 457, 458,
2657
- 1, 0, 0, 0, 458, 464, 1, 0, 0, 0, 459, 461, 3, 78, 39, 0, 460, 462, 3, 74, 37, 0, 461,
2658
- 460, 1, 0, 0, 0, 461, 462, 1, 0, 0, 0, 462, 464, 1, 0, 0, 0, 463, 455, 1, 0, 0, 0, 463,
2659
- 459, 1, 0, 0, 0, 463, 464, 1, 0, 0, 0, 464, 477, 1, 0, 0, 0, 465, 474, 3, 78, 39, 0, 466,
2660
- 468, 3, 74, 37, 0, 467, 469, 3, 76, 38, 0, 468, 467, 1, 0, 0, 0, 468, 469, 1, 0, 0, 0,
2661
- 469, 475, 1, 0, 0, 0, 470, 472, 3, 76, 38, 0, 471, 473, 3, 74, 37, 0, 472, 471, 1, 0,
2662
- 0, 0, 472, 473, 1, 0, 0, 0, 473, 475, 1, 0, 0, 0, 474, 466, 1, 0, 0, 0, 474, 470, 1, 0,
2663
- 0, 0, 474, 475, 1, 0, 0, 0, 475, 477, 1, 0, 0, 0, 476, 443, 1, 0, 0, 0, 476, 454, 1, 0,
2664
- 0, 0, 476, 465, 1, 0, 0, 0, 477, 63, 1, 0, 0, 0, 478, 482, 5, 1, 0, 0, 479, 481, 7, 0, 0,
2665
- 0, 480, 479, 1, 0, 0, 0, 481, 484, 1, 0, 0, 0, 482, 480, 1, 0, 0, 0, 482, 483, 1, 0, 0,
2666
- 0, 483, 485, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 485, 486, 5, 2, 0, 0, 486, 65, 1, 0, 0, 0,
2667
- 487, 488, 5, 1, 0, 0, 488, 489, 5, 11, 0, 0, 489, 490, 5, 2, 0, 0, 490, 67, 1, 0, 0, 0,
2668
- 491, 493, 5, 1, 0, 0, 492, 494, 7, 1, 0, 0, 493, 492, 1, 0, 0, 0, 493, 494, 1, 0, 0, 0,
2669
- 494, 495, 1, 0, 0, 0, 495, 496, 5, 2, 0, 0, 496, 69, 1, 0, 0, 0, 497, 499, 5, 1, 0, 0, 498,
2670
- 500, 5, 8, 0, 0, 499, 498, 1, 0, 0, 0, 499, 500, 1, 0, 0, 0, 500, 501, 1, 0, 0, 0, 501,
2671
- 502, 5, 2, 0, 0, 502, 71, 1, 0, 0, 0, 503, 504, 5, 1, 0, 0, 504, 505, 5, 9, 0, 0, 505, 506,
2672
- 5, 2, 0, 0, 506, 73, 1, 0, 0, 0, 507, 509, 5, 1, 0, 0, 508, 510, 5, 10, 0, 0, 509, 508,
2673
- 1, 0, 0, 0, 509, 510, 1, 0, 0, 0, 510, 511, 1, 0, 0, 0, 511, 512, 5, 2, 0, 0, 512, 75, 1,
2674
- 0, 0, 0, 513, 517, 5, 3, 0, 0, 514, 516, 5, 12, 0, 0, 515, 514, 1, 0, 0, 0, 516, 519, 1,
2675
- 0, 0, 0, 517, 515, 1, 0, 0, 0, 517, 518, 1, 0, 0, 0, 518, 520, 1, 0, 0, 0, 519, 517, 1,
2676
- 0, 0, 0, 520, 521, 5, 4, 0, 0, 521, 77, 1, 0, 0, 0, 522, 523, 5, 5, 0, 0, 523, 79, 1, 0,
2677
- 0, 0, 524, 526, 5, 13, 0, 0, 525, 524, 1, 0, 0, 0, 526, 527, 1, 0, 0, 0, 527, 525, 1, 0,
2678
- 0, 0, 527, 528, 1, 0, 0, 0, 528, 81, 1, 0, 0, 0, 96, 88, 94, 103, 109, 111, 118, 124,
2679
- 132, 140, 156, 170, 174, 177, 180, 186, 189, 192, 198, 201, 204, 210, 213, 216,
2680
- 222, 225, 228, 234, 237, 240, 246, 249, 252, 259, 262, 268, 271, 274, 280, 283,
2681
- 286, 292, 300, 308, 311, 314, 320, 323, 326, 332, 335, 338, 344, 347, 350, 357,
2682
- 361, 363, 368, 372, 374, 379, 383, 385, 387, 391, 395, 397, 401, 405, 407, 411,
2683
- 415, 417, 421, 424, 429, 431, 435, 439, 441, 446, 450, 452, 457, 461, 463, 468,
2684
- 472, 474, 476, 482, 493, 499, 509, 517, 527
2431
+ 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 93, 8, 0,
2432
+ 1, 0, 1, 0, 3, 0, 97, 8, 0, 1, 1, 4, 1, 100, 8, 1, 11, 1, 12, 1, 101, 1, 1, 1, 1, 1, 2, 5, 2,
2433
+ 107, 8, 2, 10, 2, 12, 2, 110, 9, 2, 1, 2, 1, 2, 1, 3, 1, 3, 5, 3, 116, 8, 3, 10, 3, 12, 3,
2434
+ 119, 9, 3, 1, 3, 1, 3, 1, 4, 5, 4, 124, 8, 4, 10, 4, 12, 4, 127, 9, 4, 1, 4, 1, 4, 1, 5, 5,
2435
+ 5, 132, 8, 5, 10, 5, 12, 5, 135, 9, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 3, 6, 142, 8, 6, 1, 7,
2436
+ 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 159,
2437
+ 8, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 174,
2438
+ 8, 8, 1, 9, 1, 9, 3, 9, 178, 8, 9, 1, 9, 1, 9, 1, 10, 1, 10, 3, 10, 184, 8, 10, 1, 10, 1, 10,
2439
+ 1, 11, 1, 11, 3, 11, 190, 8, 11, 1, 11, 1, 11, 1, 12, 1, 12, 3, 12, 196, 8, 12, 1, 12, 1,
2440
+ 12, 1, 13, 1, 13, 3, 13, 202, 8, 13, 1, 13, 1, 13, 1, 14, 1, 14, 3, 14, 208, 8, 14, 1, 14,
2441
+ 1, 14, 1, 15, 1, 15, 3, 15, 214, 8, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17,
2442
+ 1, 17, 3, 17, 224, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 3, 18, 230, 8, 18, 1, 18, 1, 18, 1,
2443
+ 19, 1, 19, 3, 19, 236, 8, 19, 1, 19, 1, 19, 1, 20, 1, 20, 3, 20, 242, 8, 20, 1, 20, 1, 20,
2444
+ 1, 21, 1, 21, 3, 21, 248, 8, 21, 1, 21, 1, 21, 1, 22, 1, 22, 3, 22, 254, 8, 22, 1, 22, 1,
2445
+ 22, 1, 23, 1, 23, 3, 23, 260, 8, 23, 1, 23, 1, 23, 1, 24, 1, 24, 3, 24, 266, 8, 24, 1, 24,
2446
+ 1, 24, 1, 25, 1, 25, 3, 25, 272, 8, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 3, 26, 279, 8,
2447
+ 26, 1, 26, 3, 26, 282, 8, 26, 1, 26, 3, 26, 285, 8, 26, 1, 27, 1, 27, 1, 27, 3, 27, 290,
2448
+ 8, 27, 1, 27, 1, 27, 3, 27, 294, 8, 27, 3, 27, 296, 8, 27, 1, 27, 1, 27, 1, 27, 3, 27, 301,
2449
+ 8, 27, 1, 27, 1, 27, 3, 27, 305, 8, 27, 3, 27, 307, 8, 27, 1, 27, 1, 27, 1, 27, 3, 27, 312,
2450
+ 8, 27, 1, 27, 1, 27, 3, 27, 316, 8, 27, 3, 27, 318, 8, 27, 3, 27, 320, 8, 27, 1, 28, 1,
2451
+ 28, 3, 28, 324, 8, 28, 1, 28, 1, 28, 3, 28, 328, 8, 28, 3, 28, 330, 8, 28, 1, 29, 1, 29,
2452
+ 3, 29, 334, 8, 29, 1, 29, 1, 29, 3, 29, 338, 8, 29, 3, 29, 340, 8, 29, 1, 30, 1, 30, 3,
2453
+ 30, 344, 8, 30, 1, 30, 1, 30, 3, 30, 348, 8, 30, 3, 30, 350, 8, 30, 1, 31, 1, 31, 3, 31,
2454
+ 354, 8, 31, 1, 31, 3, 31, 357, 8, 31, 1, 31, 1, 31, 1, 31, 3, 31, 362, 8, 31, 3, 31, 364,
2455
+ 8, 31, 1, 32, 1, 32, 3, 32, 368, 8, 32, 1, 32, 1, 32, 3, 32, 372, 8, 32, 3, 32, 374, 8,
2456
+ 32, 1, 33, 1, 33, 1, 33, 3, 33, 379, 8, 33, 1, 33, 1, 33, 3, 33, 383, 8, 33, 3, 33, 385,
2457
+ 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 390, 8, 33, 1, 33, 1, 33, 3, 33, 394, 8, 33, 3, 33, 396,
2458
+ 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 401, 8, 33, 1, 33, 1, 33, 3, 33, 405, 8, 33, 3, 33, 407,
2459
+ 8, 33, 3, 33, 409, 8, 33, 1, 34, 1, 34, 5, 34, 413, 8, 34, 10, 34, 12, 34, 416, 9, 34,
2460
+ 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 3, 36, 426, 8, 36, 1, 36, 1, 36,
2461
+ 1, 37, 1, 37, 3, 37, 432, 8, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39,
2462
+ 3, 39, 442, 8, 39, 1, 39, 1, 39, 1, 40, 1, 40, 5, 40, 448, 8, 40, 10, 40, 12, 40, 451,
2463
+ 9, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 42, 4, 42, 458, 8, 42, 11, 42, 12, 42, 459, 1, 42,
2464
+ 0, 0, 43, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40,
2465
+ 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84,
2466
+ 0, 2, 2, 0, 9, 9, 13, 13, 1, 0, 10, 11, 523, 0, 96, 1, 0, 0, 0, 2, 99, 1, 0, 0, 0, 4, 108,
2467
+ 1, 0, 0, 0, 6, 113, 1, 0, 0, 0, 8, 125, 1, 0, 0, 0, 10, 133, 1, 0, 0, 0, 12, 141, 1, 0, 0,
2468
+ 0, 14, 158, 1, 0, 0, 0, 16, 173, 1, 0, 0, 0, 18, 175, 1, 0, 0, 0, 20, 181, 1, 0, 0, 0, 22,
2469
+ 187, 1, 0, 0, 0, 24, 193, 1, 0, 0, 0, 26, 199, 1, 0, 0, 0, 28, 205, 1, 0, 0, 0, 30, 211,
2470
+ 1, 0, 0, 0, 32, 217, 1, 0, 0, 0, 34, 221, 1, 0, 0, 0, 36, 227, 1, 0, 0, 0, 38, 233, 1, 0,
2471
+ 0, 0, 40, 239, 1, 0, 0, 0, 42, 245, 1, 0, 0, 0, 44, 251, 1, 0, 0, 0, 46, 257, 1, 0, 0, 0,
2472
+ 48, 263, 1, 0, 0, 0, 50, 269, 1, 0, 0, 0, 52, 284, 1, 0, 0, 0, 54, 319, 1, 0, 0, 0, 56, 329,
2473
+ 1, 0, 0, 0, 58, 339, 1, 0, 0, 0, 60, 349, 1, 0, 0, 0, 62, 363, 1, 0, 0, 0, 64, 373, 1, 0,
2474
+ 0, 0, 66, 408, 1, 0, 0, 0, 68, 410, 1, 0, 0, 0, 70, 419, 1, 0, 0, 0, 72, 423, 1, 0, 0, 0,
2475
+ 74, 429, 1, 0, 0, 0, 76, 435, 1, 0, 0, 0, 78, 439, 1, 0, 0, 0, 80, 445, 1, 0, 0, 0, 82, 454,
2476
+ 1, 0, 0, 0, 84, 457, 1, 0, 0, 0, 86, 87, 3, 4, 2, 0, 87, 88, 5, 0, 0, 1, 88, 97, 1, 0, 0, 0,
2477
+ 89, 90, 5, 33, 0, 0, 90, 92, 3, 6, 3, 0, 91, 93, 5, 34, 0, 0, 92, 91, 1, 0, 0, 0, 92, 93,
2478
+ 1, 0, 0, 0, 93, 94, 1, 0, 0, 0, 94, 95, 5, 0, 0, 1, 95, 97, 1, 0, 0, 0, 96, 86, 1, 0, 0, 0,
2479
+ 96, 89, 1, 0, 0, 0, 97, 1, 1, 0, 0, 0, 98, 100, 3, 4, 2, 0, 99, 98, 1, 0, 0, 0, 100, 101,
2480
+ 1, 0, 0, 0, 101, 99, 1, 0, 0, 0, 101, 102, 1, 0, 0, 0, 102, 103, 1, 0, 0, 0, 103, 104, 5,
2481
+ 0, 0, 1, 104, 3, 1, 0, 0, 0, 105, 107, 5, 16, 0, 0, 106, 105, 1, 0, 0, 0, 107, 110, 1, 0,
2482
+ 0, 0, 108, 106, 1, 0, 0, 0, 108, 109, 1, 0, 0, 0, 109, 111, 1, 0, 0, 0, 110, 108, 1, 0,
2483
+ 0, 0, 111, 112, 3, 6, 3, 0, 112, 5, 1, 0, 0, 0, 113, 117, 3, 46, 23, 0, 114, 116, 3, 16,
2484
+ 8, 0, 115, 114, 1, 0, 0, 0, 116, 119, 1, 0, 0, 0, 117, 115, 1, 0, 0, 0, 117, 118, 1, 0,
2485
+ 0, 0, 118, 120, 1, 0, 0, 0, 119, 117, 1, 0, 0, 0, 120, 121, 3, 32, 16, 0, 121, 7, 1, 0,
2486
+ 0, 0, 122, 124, 3, 14, 7, 0, 123, 122, 1, 0, 0, 0, 124, 127, 1, 0, 0, 0, 125, 123, 1, 0,
2487
+ 0, 0, 125, 126, 1, 0, 0, 0, 126, 128, 1, 0, 0, 0, 127, 125, 1, 0, 0, 0, 128, 129, 5, 0,
2488
+ 0, 1, 129, 9, 1, 0, 0, 0, 130, 132, 3, 12, 6, 0, 131, 130, 1, 0, 0, 0, 132, 135, 1, 0, 0,
2489
+ 0, 133, 131, 1, 0, 0, 0, 133, 134, 1, 0, 0, 0, 134, 136, 1, 0, 0, 0, 135, 133, 1, 0, 0,
2490
+ 0, 136, 137, 5, 0, 0, 1, 137, 11, 1, 0, 0, 0, 138, 142, 3, 14, 7, 0, 139, 142, 3, 48, 24,
2491
+ 0, 140, 142, 3, 50, 25, 0, 141, 138, 1, 0, 0, 0, 141, 139, 1, 0, 0, 0, 141, 140, 1, 0,
2492
+ 0, 0, 142, 13, 1, 0, 0, 0, 143, 159, 3, 18, 9, 0, 144, 159, 3, 20, 10, 0, 145, 159, 3,
2493
+ 22, 11, 0, 146, 159, 3, 24, 12, 0, 147, 159, 3, 26, 13, 0, 148, 159, 3, 28, 14, 0, 149,
2494
+ 159, 3, 30, 15, 0, 150, 159, 3, 32, 16, 0, 151, 159, 3, 34, 17, 0, 152, 159, 3, 36, 18,
2495
+ 0, 153, 159, 3, 38, 19, 0, 154, 159, 3, 40, 20, 0, 155, 159, 3, 42, 21, 0, 156, 159,
2496
+ 3, 44, 22, 0, 157, 159, 3, 46, 23, 0, 158, 143, 1, 0, 0, 0, 158, 144, 1, 0, 0, 0, 158,
2497
+ 145, 1, 0, 0, 0, 158, 146, 1, 0, 0, 0, 158, 147, 1, 0, 0, 0, 158, 148, 1, 0, 0, 0, 158,
2498
+ 149, 1, 0, 0, 0, 158, 150, 1, 0, 0, 0, 158, 151, 1, 0, 0, 0, 158, 152, 1, 0, 0, 0, 158,
2499
+ 153, 1, 0, 0, 0, 158, 154, 1, 0, 0, 0, 158, 155, 1, 0, 0, 0, 158, 156, 1, 0, 0, 0, 158,
2500
+ 157, 1, 0, 0, 0, 159, 15, 1, 0, 0, 0, 160, 174, 3, 18, 9, 0, 161, 174, 3, 20, 10, 0, 162,
2501
+ 174, 3, 22, 11, 0, 163, 174, 3, 24, 12, 0, 164, 174, 3, 26, 13, 0, 165, 174, 3, 28, 14,
2502
+ 0, 166, 174, 3, 30, 15, 0, 167, 174, 3, 34, 17, 0, 168, 174, 3, 36, 18, 0, 169, 174,
2503
+ 3, 38, 19, 0, 170, 174, 3, 40, 20, 0, 171, 174, 3, 42, 21, 0, 172, 174, 3, 44, 22, 0,
2504
+ 173, 160, 1, 0, 0, 0, 173, 161, 1, 0, 0, 0, 173, 162, 1, 0, 0, 0, 173, 163, 1, 0, 0, 0,
2505
+ 173, 164, 1, 0, 0, 0, 173, 165, 1, 0, 0, 0, 173, 166, 1, 0, 0, 0, 173, 167, 1, 0, 0, 0,
2506
+ 173, 168, 1, 0, 0, 0, 173, 169, 1, 0, 0, 0, 173, 170, 1, 0, 0, 0, 173, 171, 1, 0, 0, 0,
2507
+ 173, 172, 1, 0, 0, 0, 174, 17, 1, 0, 0, 0, 175, 177, 5, 18, 0, 0, 176, 178, 3, 54, 27,
2508
+ 0, 177, 176, 1, 0, 0, 0, 177, 178, 1, 0, 0, 0, 178, 179, 1, 0, 0, 0, 179, 180, 3, 52, 26,
2509
+ 0, 180, 19, 1, 0, 0, 0, 181, 183, 5, 19, 0, 0, 182, 184, 3, 54, 27, 0, 183, 182, 1, 0,
2510
+ 0, 0, 183, 184, 1, 0, 0, 0, 184, 185, 1, 0, 0, 0, 185, 186, 3, 52, 26, 0, 186, 21, 1, 0,
2511
+ 0, 0, 187, 189, 5, 20, 0, 0, 188, 190, 3, 54, 27, 0, 189, 188, 1, 0, 0, 0, 189, 190, 1,
2512
+ 0, 0, 0, 190, 191, 1, 0, 0, 0, 191, 192, 3, 52, 26, 0, 192, 23, 1, 0, 0, 0, 193, 195, 5,
2513
+ 21, 0, 0, 194, 196, 3, 54, 27, 0, 195, 194, 1, 0, 0, 0, 195, 196, 1, 0, 0, 0, 196, 197,
2514
+ 1, 0, 0, 0, 197, 198, 3, 52, 26, 0, 198, 25, 1, 0, 0, 0, 199, 201, 5, 22, 0, 0, 200, 202,
2515
+ 3, 54, 27, 0, 201, 200, 1, 0, 0, 0, 201, 202, 1, 0, 0, 0, 202, 203, 1, 0, 0, 0, 203, 204,
2516
+ 3, 52, 26, 0, 204, 27, 1, 0, 0, 0, 205, 207, 5, 23, 0, 0, 206, 208, 3, 56, 28, 0, 207,
2517
+ 206, 1, 0, 0, 0, 207, 208, 1, 0, 0, 0, 208, 209, 1, 0, 0, 0, 209, 210, 3, 52, 26, 0, 210,
2518
+ 29, 1, 0, 0, 0, 211, 213, 5, 24, 0, 0, 212, 214, 3, 56, 28, 0, 213, 212, 1, 0, 0, 0, 213,
2519
+ 214, 1, 0, 0, 0, 214, 215, 1, 0, 0, 0, 215, 216, 3, 52, 26, 0, 216, 31, 1, 0, 0, 0, 217,
2520
+ 218, 5, 25, 0, 0, 218, 219, 3, 62, 31, 0, 219, 220, 3, 52, 26, 0, 220, 33, 1, 0, 0, 0,
2521
+ 221, 223, 5, 25, 0, 0, 222, 224, 3, 64, 32, 0, 223, 222, 1, 0, 0, 0, 223, 224, 1, 0, 0,
2522
+ 0, 224, 225, 1, 0, 0, 0, 225, 226, 3, 52, 26, 0, 226, 35, 1, 0, 0, 0, 227, 229, 5, 26,
2523
+ 0, 0, 228, 230, 3, 66, 33, 0, 229, 228, 1, 0, 0, 0, 229, 230, 1, 0, 0, 0, 230, 231, 1,
2524
+ 0, 0, 0, 231, 232, 3, 52, 26, 0, 232, 37, 1, 0, 0, 0, 233, 235, 5, 27, 0, 0, 234, 236,
2525
+ 3, 68, 34, 0, 235, 234, 1, 0, 0, 0, 235, 236, 1, 0, 0, 0, 236, 237, 1, 0, 0, 0, 237, 238,
2526
+ 3, 52, 26, 0, 238, 39, 1, 0, 0, 0, 239, 241, 5, 28, 0, 0, 240, 242, 3, 60, 30, 0, 241,
2527
+ 240, 1, 0, 0, 0, 241, 242, 1, 0, 0, 0, 242, 243, 1, 0, 0, 0, 243, 244, 3, 52, 26, 0, 244,
2528
+ 41, 1, 0, 0, 0, 245, 247, 5, 29, 0, 0, 246, 248, 3, 60, 30, 0, 247, 246, 1, 0, 0, 0, 247,
2529
+ 248, 1, 0, 0, 0, 248, 249, 1, 0, 0, 0, 249, 250, 3, 52, 26, 0, 250, 43, 1, 0, 0, 0, 251,
2530
+ 253, 5, 30, 0, 0, 252, 254, 3, 58, 29, 0, 253, 252, 1, 0, 0, 0, 253, 254, 1, 0, 0, 0, 254,
2531
+ 255, 1, 0, 0, 0, 255, 256, 3, 52, 26, 0, 256, 45, 1, 0, 0, 0, 257, 259, 5, 17, 0, 0, 258,
2532
+ 260, 3, 54, 27, 0, 259, 258, 1, 0, 0, 0, 259, 260, 1, 0, 0, 0, 260, 261, 1, 0, 0, 0, 261,
2533
+ 262, 3, 52, 26, 0, 262, 47, 1, 0, 0, 0, 263, 265, 5, 31, 0, 0, 264, 266, 3, 54, 27, 0,
2534
+ 265, 264, 1, 0, 0, 0, 265, 266, 1, 0, 0, 0, 266, 267, 1, 0, 0, 0, 267, 268, 3, 52, 26,
2535
+ 0, 268, 49, 1, 0, 0, 0, 269, 271, 5, 32, 0, 0, 270, 272, 3, 54, 27, 0, 271, 270, 1, 0,
2536
+ 0, 0, 271, 272, 1, 0, 0, 0, 272, 273, 1, 0, 0, 0, 273, 274, 3, 52, 26, 0, 274, 51, 1, 0,
2537
+ 0, 0, 275, 285, 5, 8, 0, 0, 276, 278, 5, 7, 0, 0, 277, 279, 3, 84, 42, 0, 278, 277, 1,
2538
+ 0, 0, 0, 278, 279, 1, 0, 0, 0, 279, 281, 1, 0, 0, 0, 280, 282, 5, 8, 0, 0, 281, 280, 1,
2539
+ 0, 0, 0, 281, 282, 1, 0, 0, 0, 282, 285, 1, 0, 0, 0, 283, 285, 1, 0, 0, 0, 284, 275, 1,
2540
+ 0, 0, 0, 284, 276, 1, 0, 0, 0, 284, 283, 1, 0, 0, 0, 285, 53, 1, 0, 0, 0, 286, 295, 3, 68,
2541
+ 34, 0, 287, 289, 3, 80, 40, 0, 288, 290, 3, 82, 41, 0, 289, 288, 1, 0, 0, 0, 289, 290,
2542
+ 1, 0, 0, 0, 290, 296, 1, 0, 0, 0, 291, 293, 3, 82, 41, 0, 292, 294, 3, 80, 40, 0, 293,
2543
+ 292, 1, 0, 0, 0, 293, 294, 1, 0, 0, 0, 294, 296, 1, 0, 0, 0, 295, 287, 1, 0, 0, 0, 295,
2544
+ 291, 1, 0, 0, 0, 295, 296, 1, 0, 0, 0, 296, 320, 1, 0, 0, 0, 297, 306, 3, 80, 40, 0, 298,
2545
+ 300, 3, 68, 34, 0, 299, 301, 3, 82, 41, 0, 300, 299, 1, 0, 0, 0, 300, 301, 1, 0, 0, 0,
2546
+ 301, 307, 1, 0, 0, 0, 302, 304, 3, 82, 41, 0, 303, 305, 3, 68, 34, 0, 304, 303, 1, 0,
2547
+ 0, 0, 304, 305, 1, 0, 0, 0, 305, 307, 1, 0, 0, 0, 306, 298, 1, 0, 0, 0, 306, 302, 1, 0,
2548
+ 0, 0, 306, 307, 1, 0, 0, 0, 307, 320, 1, 0, 0, 0, 308, 317, 3, 82, 41, 0, 309, 311, 3,
2549
+ 68, 34, 0, 310, 312, 3, 80, 40, 0, 311, 310, 1, 0, 0, 0, 311, 312, 1, 0, 0, 0, 312, 318,
2550
+ 1, 0, 0, 0, 313, 315, 3, 80, 40, 0, 314, 316, 3, 68, 34, 0, 315, 314, 1, 0, 0, 0, 315,
2551
+ 316, 1, 0, 0, 0, 316, 318, 1, 0, 0, 0, 317, 309, 1, 0, 0, 0, 317, 313, 1, 0, 0, 0, 317,
2552
+ 318, 1, 0, 0, 0, 318, 320, 1, 0, 0, 0, 319, 286, 1, 0, 0, 0, 319, 297, 1, 0, 0, 0, 319,
2553
+ 308, 1, 0, 0, 0, 320, 55, 1, 0, 0, 0, 321, 323, 3, 68, 34, 0, 322, 324, 3, 80, 40, 0, 323,
2554
+ 322, 1, 0, 0, 0, 323, 324, 1, 0, 0, 0, 324, 330, 1, 0, 0, 0, 325, 327, 3, 80, 40, 0, 326,
2555
+ 328, 3, 68, 34, 0, 327, 326, 1, 0, 0, 0, 327, 328, 1, 0, 0, 0, 328, 330, 1, 0, 0, 0, 329,
2556
+ 321, 1, 0, 0, 0, 329, 325, 1, 0, 0, 0, 330, 57, 1, 0, 0, 0, 331, 333, 3, 72, 36, 0, 332,
2557
+ 334, 3, 80, 40, 0, 333, 332, 1, 0, 0, 0, 333, 334, 1, 0, 0, 0, 334, 340, 1, 0, 0, 0, 335,
2558
+ 337, 3, 80, 40, 0, 336, 338, 3, 72, 36, 0, 337, 336, 1, 0, 0, 0, 337, 338, 1, 0, 0, 0,
2559
+ 338, 340, 1, 0, 0, 0, 339, 331, 1, 0, 0, 0, 339, 335, 1, 0, 0, 0, 340, 59, 1, 0, 0, 0, 341,
2560
+ 343, 3, 70, 35, 0, 342, 344, 3, 80, 40, 0, 343, 342, 1, 0, 0, 0, 343, 344, 1, 0, 0, 0,
2561
+ 344, 350, 1, 0, 0, 0, 345, 347, 3, 80, 40, 0, 346, 348, 3, 70, 35, 0, 347, 346, 1, 0,
2562
+ 0, 0, 347, 348, 1, 0, 0, 0, 348, 350, 1, 0, 0, 0, 349, 341, 1, 0, 0, 0, 349, 345, 1, 0,
2563
+ 0, 0, 350, 61, 1, 0, 0, 0, 351, 353, 3, 76, 38, 0, 352, 354, 3, 80, 40, 0, 353, 352, 1,
2564
+ 0, 0, 0, 353, 354, 1, 0, 0, 0, 354, 356, 1, 0, 0, 0, 355, 357, 3, 82, 41, 0, 356, 355,
2565
+ 1, 0, 0, 0, 356, 357, 1, 0, 0, 0, 357, 364, 1, 0, 0, 0, 358, 359, 3, 80, 40, 0, 359, 361,
2566
+ 3, 76, 38, 0, 360, 362, 3, 82, 41, 0, 361, 360, 1, 0, 0, 0, 361, 362, 1, 0, 0, 0, 362,
2567
+ 364, 1, 0, 0, 0, 363, 351, 1, 0, 0, 0, 363, 358, 1, 0, 0, 0, 364, 63, 1, 0, 0, 0, 365, 367,
2568
+ 3, 74, 37, 0, 366, 368, 3, 80, 40, 0, 367, 366, 1, 0, 0, 0, 367, 368, 1, 0, 0, 0, 368,
2569
+ 374, 1, 0, 0, 0, 369, 371, 3, 80, 40, 0, 370, 372, 3, 74, 37, 0, 371, 370, 1, 0, 0, 0,
2570
+ 371, 372, 1, 0, 0, 0, 372, 374, 1, 0, 0, 0, 373, 365, 1, 0, 0, 0, 373, 369, 1, 0, 0, 0,
2571
+ 374, 65, 1, 0, 0, 0, 375, 384, 3, 78, 39, 0, 376, 378, 3, 80, 40, 0, 377, 379, 3, 82,
2572
+ 41, 0, 378, 377, 1, 0, 0, 0, 378, 379, 1, 0, 0, 0, 379, 385, 1, 0, 0, 0, 380, 382, 3, 82,
2573
+ 41, 0, 381, 383, 3, 80, 40, 0, 382, 381, 1, 0, 0, 0, 382, 383, 1, 0, 0, 0, 383, 385, 1,
2574
+ 0, 0, 0, 384, 376, 1, 0, 0, 0, 384, 380, 1, 0, 0, 0, 384, 385, 1, 0, 0, 0, 385, 409, 1,
2575
+ 0, 0, 0, 386, 395, 3, 80, 40, 0, 387, 389, 3, 78, 39, 0, 388, 390, 3, 82, 41, 0, 389,
2576
+ 388, 1, 0, 0, 0, 389, 390, 1, 0, 0, 0, 390, 396, 1, 0, 0, 0, 391, 393, 3, 82, 41, 0, 392,
2577
+ 394, 3, 78, 39, 0, 393, 392, 1, 0, 0, 0, 393, 394, 1, 0, 0, 0, 394, 396, 1, 0, 0, 0, 395,
2578
+ 387, 1, 0, 0, 0, 395, 391, 1, 0, 0, 0, 395, 396, 1, 0, 0, 0, 396, 409, 1, 0, 0, 0, 397,
2579
+ 406, 3, 82, 41, 0, 398, 400, 3, 78, 39, 0, 399, 401, 3, 80, 40, 0, 400, 399, 1, 0, 0,
2580
+ 0, 400, 401, 1, 0, 0, 0, 401, 407, 1, 0, 0, 0, 402, 404, 3, 80, 40, 0, 403, 405, 3, 78,
2581
+ 39, 0, 404, 403, 1, 0, 0, 0, 404, 405, 1, 0, 0, 0, 405, 407, 1, 0, 0, 0, 406, 398, 1, 0,
2582
+ 0, 0, 406, 402, 1, 0, 0, 0, 406, 407, 1, 0, 0, 0, 407, 409, 1, 0, 0, 0, 408, 375, 1, 0,
2583
+ 0, 0, 408, 386, 1, 0, 0, 0, 408, 397, 1, 0, 0, 0, 409, 67, 1, 0, 0, 0, 410, 414, 5, 1, 0,
2584
+ 0, 411, 413, 7, 0, 0, 0, 412, 411, 1, 0, 0, 0, 413, 416, 1, 0, 0, 0, 414, 412, 1, 0, 0,
2585
+ 0, 414, 415, 1, 0, 0, 0, 415, 417, 1, 0, 0, 0, 416, 414, 1, 0, 0, 0, 417, 418, 5, 2, 0,
2586
+ 0, 418, 69, 1, 0, 0, 0, 419, 420, 5, 1, 0, 0, 420, 421, 5, 13, 0, 0, 421, 422, 5, 2, 0,
2587
+ 0, 422, 71, 1, 0, 0, 0, 423, 425, 5, 1, 0, 0, 424, 426, 7, 1, 0, 0, 425, 424, 1, 0, 0, 0,
2588
+ 425, 426, 1, 0, 0, 0, 426, 427, 1, 0, 0, 0, 427, 428, 5, 2, 0, 0, 428, 73, 1, 0, 0, 0, 429,
2589
+ 431, 5, 1, 0, 0, 430, 432, 5, 10, 0, 0, 431, 430, 1, 0, 0, 0, 431, 432, 1, 0, 0, 0, 432,
2590
+ 433, 1, 0, 0, 0, 433, 434, 5, 2, 0, 0, 434, 75, 1, 0, 0, 0, 435, 436, 5, 1, 0, 0, 436, 437,
2591
+ 5, 11, 0, 0, 437, 438, 5, 2, 0, 0, 438, 77, 1, 0, 0, 0, 439, 441, 5, 1, 0, 0, 440, 442,
2592
+ 5, 12, 0, 0, 441, 440, 1, 0, 0, 0, 441, 442, 1, 0, 0, 0, 442, 443, 1, 0, 0, 0, 443, 444,
2593
+ 5, 2, 0, 0, 444, 79, 1, 0, 0, 0, 445, 449, 5, 3, 0, 0, 446, 448, 5, 14, 0, 0, 447, 446,
2594
+ 1, 0, 0, 0, 448, 451, 1, 0, 0, 0, 449, 447, 1, 0, 0, 0, 449, 450, 1, 0, 0, 0, 450, 452,
2595
+ 1, 0, 0, 0, 451, 449, 1, 0, 0, 0, 452, 453, 5, 4, 0, 0, 453, 81, 1, 0, 0, 0, 454, 455, 5,
2596
+ 5, 0, 0, 455, 83, 1, 0, 0, 0, 456, 458, 5, 15, 0, 0, 457, 456, 1, 0, 0, 0, 458, 459, 1,
2597
+ 0, 0, 0, 459, 457, 1, 0, 0, 0, 459, 460, 1, 0, 0, 0, 460, 85, 1, 0, 0, 0, 71, 92, 96, 101,
2598
+ 108, 117, 125, 133, 141, 158, 173, 177, 183, 189, 195, 201, 207, 213, 223, 229,
2599
+ 235, 241, 247, 253, 259, 265, 271, 278, 281, 284, 289, 293, 295, 300, 304, 306,
2600
+ 311, 315, 317, 319, 323, 327, 329, 333, 337, 339, 343, 347, 349, 353, 356, 361,
2601
+ 363, 367, 371, 373, 378, 382, 384, 389, 393, 395, 400, 404, 406, 408, 414, 425,
2602
+ 431, 441, 449, 459
2685
2603
  ];
2686
2604
  static __ATN;
2687
2605
  static get _ATN() {
@@ -2706,6 +2624,15 @@ export class DocumentContext extends antlr.ParserRuleContext {
2706
2624
  EOF() {
2707
2625
  return this.getToken(plurnkParser.EOF, 0);
2708
2626
  }
2627
+ FENCE_OPEN() {
2628
+ return this.getToken(plurnkParser.FENCE_OPEN, 0);
2629
+ }
2630
+ turn() {
2631
+ return this.getRuleContext(0, TurnContext);
2632
+ }
2633
+ FENCE_CLOSE() {
2634
+ return this.getToken(plurnkParser.FENCE_CLOSE, 0);
2635
+ }
2709
2636
  get ruleIndex() {
2710
2637
  return plurnkParser.RULE_document;
2711
2638
  }
@@ -2725,11 +2652,11 @@ export class LogContext extends antlr.ParserRuleContext {
2725
2652
  EOF() {
2726
2653
  return this.getToken(plurnkParser.EOF, 0);
2727
2654
  }
2728
- turnStatement(i) {
2655
+ turnContent(i) {
2729
2656
  if (i === undefined) {
2730
- return this.getRuleContexts(TurnStatementContext);
2657
+ return this.getRuleContexts(TurnContentContext);
2731
2658
  }
2732
- return this.getRuleContext(i, TurnStatementContext);
2659
+ return this.getRuleContext(i, TurnContentContext);
2733
2660
  }
2734
2661
  get ruleIndex() {
2735
2662
  return plurnkParser.RULE_log;
@@ -2743,38 +2670,34 @@ export class LogContext extends antlr.ParserRuleContext {
2743
2670
  }
2744
2671
  }
2745
2672
  }
2746
- export class TurnStatementContext extends antlr.ParserRuleContext {
2673
+ export class TurnContentContext extends antlr.ParserRuleContext {
2747
2674
  constructor(parent, invokingState) {
2748
2675
  super(parent, invokingState);
2749
2676
  }
2750
- OPEN_TURN() {
2751
- return this.getToken(plurnkParser.OPEN_TURN, 0);
2752
- }
2753
- COLON() {
2754
- return this.getToken(plurnkParser.COLON, 0);
2755
- }
2756
- turnContent() {
2757
- return this.getRuleContext(0, TurnContentContext);
2758
- }
2759
- CLOSE_TURN() {
2760
- return this.getToken(plurnkParser.CLOSE_TURN, 0);
2677
+ turn() {
2678
+ return this.getRuleContext(0, TurnContext);
2761
2679
  }
2762
- tagOpModifiers() {
2763
- return this.getRuleContext(0, TagOpModifiersContext);
2680
+ TEXT(i) {
2681
+ if (i === undefined) {
2682
+ return this.getTokens(plurnkParser.TEXT);
2683
+ }
2684
+ else {
2685
+ return this.getToken(plurnkParser.TEXT, i);
2686
+ }
2764
2687
  }
2765
2688
  get ruleIndex() {
2766
- return plurnkParser.RULE_turnStatement;
2689
+ return plurnkParser.RULE_turnContent;
2767
2690
  }
2768
2691
  accept(visitor) {
2769
- if (visitor.visitTurnStatement) {
2770
- return visitor.visitTurnStatement(this);
2692
+ if (visitor.visitTurnContent) {
2693
+ return visitor.visitTurnContent(this);
2771
2694
  }
2772
2695
  else {
2773
2696
  return visitor.visitChildren(this);
2774
2697
  }
2775
2698
  }
2776
2699
  }
2777
- export class TurnContentContext extends antlr.ParserRuleContext {
2700
+ export class TurnContext extends antlr.ParserRuleContext {
2778
2701
  constructor(parent, invokingState) {
2779
2702
  super(parent, invokingState);
2780
2703
  }
@@ -2784,14 +2707,6 @@ export class TurnContentContext extends antlr.ParserRuleContext {
2784
2707
  sendStatement() {
2785
2708
  return this.getRuleContext(0, SendStatementContext);
2786
2709
  }
2787
- TEXT(i) {
2788
- if (i === undefined) {
2789
- return this.getTokens(plurnkParser.TEXT);
2790
- }
2791
- else {
2792
- return this.getToken(plurnkParser.TEXT, i);
2793
- }
2794
- }
2795
2710
  midStatement(i) {
2796
2711
  if (i === undefined) {
2797
2712
  return this.getRuleContexts(MidStatementContext);
@@ -2799,11 +2714,11 @@ export class TurnContentContext extends antlr.ParserRuleContext {
2799
2714
  return this.getRuleContext(i, MidStatementContext);
2800
2715
  }
2801
2716
  get ruleIndex() {
2802
- return plurnkParser.RULE_turnContent;
2717
+ return plurnkParser.RULE_turn;
2803
2718
  }
2804
2719
  accept(visitor) {
2805
- if (visitor.visitTurnContent) {
2806
- return visitor.visitTurnContent(this);
2720
+ if (visitor.visitTurn) {
2721
+ return visitor.visitTurn(this);
2807
2722
  }
2808
2723
  else {
2809
2724
  return visitor.visitChildren(this);
@@ -2919,6 +2834,9 @@ export class StatementContext extends antlr.ParserRuleContext {
2919
2834
  execStatement() {
2920
2835
  return this.getRuleContext(0, ExecStatementContext);
2921
2836
  }
2837
+ bareStatement() {
2838
+ return this.getRuleContext(0, BareStatementContext);
2839
+ }
2922
2840
  workStatement() {
2923
2841
  return this.getRuleContext(0, WorkStatementContext);
2924
2842
  }
@@ -2974,6 +2892,9 @@ export class MidStatementContext extends antlr.ParserRuleContext {
2974
2892
  execStatement() {
2975
2893
  return this.getRuleContext(0, ExecStatementContext);
2976
2894
  }
2895
+ bareStatement() {
2896
+ return this.getRuleContext(0, BareStatementContext);
2897
+ }
2977
2898
  workStatement() {
2978
2899
  return this.getRuleContext(0, WorkStatementContext);
2979
2900
  }
@@ -3002,18 +2923,12 @@ export class FindStatementContext extends antlr.ParserRuleContext {
3002
2923
  OPEN_FIND() {
3003
2924
  return this.getToken(plurnkParser.OPEN_FIND, 0);
3004
2925
  }
3005
- CLOSE_TAG() {
3006
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
2926
+ statementEnd() {
2927
+ return this.getRuleContext(0, StatementEndContext);
3007
2928
  }
3008
2929
  tagOpModifiers() {
3009
2930
  return this.getRuleContext(0, TagOpModifiersContext);
3010
2931
  }
3011
- COLON() {
3012
- return this.getToken(plurnkParser.COLON, 0);
3013
- }
3014
- body() {
3015
- return this.getRuleContext(0, BodyContext);
3016
- }
3017
2932
  get ruleIndex() {
3018
2933
  return plurnkParser.RULE_findStatement;
3019
2934
  }
@@ -3033,18 +2948,12 @@ export class ReadStatementContext extends antlr.ParserRuleContext {
3033
2948
  OPEN_READ() {
3034
2949
  return this.getToken(plurnkParser.OPEN_READ, 0);
3035
2950
  }
3036
- CLOSE_TAG() {
3037
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
2951
+ statementEnd() {
2952
+ return this.getRuleContext(0, StatementEndContext);
3038
2953
  }
3039
2954
  tagOpModifiers() {
3040
2955
  return this.getRuleContext(0, TagOpModifiersContext);
3041
2956
  }
3042
- COLON() {
3043
- return this.getToken(plurnkParser.COLON, 0);
3044
- }
3045
- body() {
3046
- return this.getRuleContext(0, BodyContext);
3047
- }
3048
2957
  get ruleIndex() {
3049
2958
  return plurnkParser.RULE_readStatement;
3050
2959
  }
@@ -3064,18 +2973,12 @@ export class EditStatementContext extends antlr.ParserRuleContext {
3064
2973
  OPEN_EDIT() {
3065
2974
  return this.getToken(plurnkParser.OPEN_EDIT, 0);
3066
2975
  }
3067
- CLOSE_TAG() {
3068
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
2976
+ statementEnd() {
2977
+ return this.getRuleContext(0, StatementEndContext);
3069
2978
  }
3070
2979
  tagOpModifiers() {
3071
2980
  return this.getRuleContext(0, TagOpModifiersContext);
3072
2981
  }
3073
- COLON() {
3074
- return this.getToken(plurnkParser.COLON, 0);
3075
- }
3076
- body() {
3077
- return this.getRuleContext(0, BodyContext);
3078
- }
3079
2982
  get ruleIndex() {
3080
2983
  return plurnkParser.RULE_editStatement;
3081
2984
  }
@@ -3095,18 +2998,12 @@ export class CopyStatementContext extends antlr.ParserRuleContext {
3095
2998
  OPEN_COPY() {
3096
2999
  return this.getToken(plurnkParser.OPEN_COPY, 0);
3097
3000
  }
3098
- CLOSE_TAG() {
3099
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3001
+ statementEnd() {
3002
+ return this.getRuleContext(0, StatementEndContext);
3100
3003
  }
3101
3004
  tagOpModifiers() {
3102
3005
  return this.getRuleContext(0, TagOpModifiersContext);
3103
3006
  }
3104
- COLON() {
3105
- return this.getToken(plurnkParser.COLON, 0);
3106
- }
3107
- body() {
3108
- return this.getRuleContext(0, BodyContext);
3109
- }
3110
3007
  get ruleIndex() {
3111
3008
  return plurnkParser.RULE_copyStatement;
3112
3009
  }
@@ -3126,18 +3023,12 @@ export class MoveStatementContext extends antlr.ParserRuleContext {
3126
3023
  OPEN_MOVE() {
3127
3024
  return this.getToken(plurnkParser.OPEN_MOVE, 0);
3128
3025
  }
3129
- CLOSE_TAG() {
3130
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3026
+ statementEnd() {
3027
+ return this.getRuleContext(0, StatementEndContext);
3131
3028
  }
3132
3029
  tagOpModifiers() {
3133
3030
  return this.getRuleContext(0, TagOpModifiersContext);
3134
3031
  }
3135
- COLON() {
3136
- return this.getToken(plurnkParser.COLON, 0);
3137
- }
3138
- body() {
3139
- return this.getRuleContext(0, BodyContext);
3140
- }
3141
3032
  get ruleIndex() {
3142
3033
  return plurnkParser.RULE_moveStatement;
3143
3034
  }
@@ -3157,18 +3048,12 @@ export class OpenStatementContext extends antlr.ParserRuleContext {
3157
3048
  OPEN_OPEN() {
3158
3049
  return this.getToken(plurnkParser.OPEN_OPEN, 0);
3159
3050
  }
3160
- CLOSE_TAG() {
3161
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3051
+ statementEnd() {
3052
+ return this.getRuleContext(0, StatementEndContext);
3162
3053
  }
3163
3054
  curationModifiers() {
3164
3055
  return this.getRuleContext(0, CurationModifiersContext);
3165
3056
  }
3166
- COLON() {
3167
- return this.getToken(plurnkParser.COLON, 0);
3168
- }
3169
- body() {
3170
- return this.getRuleContext(0, BodyContext);
3171
- }
3172
3057
  get ruleIndex() {
3173
3058
  return plurnkParser.RULE_openStatement;
3174
3059
  }
@@ -3188,18 +3073,12 @@ export class FoldStatementContext extends antlr.ParserRuleContext {
3188
3073
  OPEN_FOLD() {
3189
3074
  return this.getToken(plurnkParser.OPEN_FOLD, 0);
3190
3075
  }
3191
- CLOSE_TAG() {
3192
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3076
+ statementEnd() {
3077
+ return this.getRuleContext(0, StatementEndContext);
3193
3078
  }
3194
3079
  curationModifiers() {
3195
3080
  return this.getRuleContext(0, CurationModifiersContext);
3196
3081
  }
3197
- COLON() {
3198
- return this.getToken(plurnkParser.COLON, 0);
3199
- }
3200
- body() {
3201
- return this.getRuleContext(0, BodyContext);
3202
- }
3203
3082
  get ruleIndex() {
3204
3083
  return plurnkParser.RULE_foldStatement;
3205
3084
  }
@@ -3222,14 +3101,8 @@ export class SendStatementContext extends antlr.ParserRuleContext {
3222
3101
  termModifiers() {
3223
3102
  return this.getRuleContext(0, TermModifiersContext);
3224
3103
  }
3225
- CLOSE_TAG() {
3226
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3227
- }
3228
- COLON() {
3229
- return this.getToken(plurnkParser.COLON, 0);
3230
- }
3231
- body() {
3232
- return this.getRuleContext(0, BodyContext);
3104
+ statementEnd() {
3105
+ return this.getRuleContext(0, StatementEndContext);
3233
3106
  }
3234
3107
  get ruleIndex() {
3235
3108
  return plurnkParser.RULE_sendStatement;
@@ -3250,18 +3123,12 @@ export class MidSendContext extends antlr.ParserRuleContext {
3250
3123
  OPEN_SEND() {
3251
3124
  return this.getToken(plurnkParser.OPEN_SEND, 0);
3252
3125
  }
3253
- CLOSE_TAG() {
3254
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3126
+ statementEnd() {
3127
+ return this.getRuleContext(0, StatementEndContext);
3255
3128
  }
3256
3129
  midModifiers() {
3257
3130
  return this.getRuleContext(0, MidModifiersContext);
3258
3131
  }
3259
- COLON() {
3260
- return this.getToken(plurnkParser.COLON, 0);
3261
- }
3262
- body() {
3263
- return this.getRuleContext(0, BodyContext);
3264
- }
3265
3132
  get ruleIndex() {
3266
3133
  return plurnkParser.RULE_midSend;
3267
3134
  }
@@ -3281,18 +3148,12 @@ export class ExecStatementContext extends antlr.ParserRuleContext {
3281
3148
  OPEN_EXEC() {
3282
3149
  return this.getToken(plurnkParser.OPEN_EXEC, 0);
3283
3150
  }
3284
- CLOSE_TAG() {
3285
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3151
+ statementEnd() {
3152
+ return this.getRuleContext(0, StatementEndContext);
3286
3153
  }
3287
3154
  execModifiers() {
3288
3155
  return this.getRuleContext(0, ExecModifiersContext);
3289
3156
  }
3290
- COLON() {
3291
- return this.getToken(plurnkParser.COLON, 0);
3292
- }
3293
- body() {
3294
- return this.getRuleContext(0, BodyContext);
3295
- }
3296
3157
  get ruleIndex() {
3297
3158
  return plurnkParser.RULE_execStatement;
3298
3159
  }
@@ -3305,6 +3166,31 @@ export class ExecStatementContext extends antlr.ParserRuleContext {
3305
3166
  }
3306
3167
  }
3307
3168
  }
3169
+ export class BareStatementContext extends antlr.ParserRuleContext {
3170
+ constructor(parent, invokingState) {
3171
+ super(parent, invokingState);
3172
+ }
3173
+ OPEN_BARE() {
3174
+ return this.getToken(plurnkParser.OPEN_BARE, 0);
3175
+ }
3176
+ statementEnd() {
3177
+ return this.getRuleContext(0, StatementEndContext);
3178
+ }
3179
+ tagSignal() {
3180
+ return this.getRuleContext(0, TagSignalContext);
3181
+ }
3182
+ get ruleIndex() {
3183
+ return plurnkParser.RULE_bareStatement;
3184
+ }
3185
+ accept(visitor) {
3186
+ if (visitor.visitBareStatement) {
3187
+ return visitor.visitBareStatement(this);
3188
+ }
3189
+ else {
3190
+ return visitor.visitChildren(this);
3191
+ }
3192
+ }
3193
+ }
3308
3194
  export class WorkStatementContext extends antlr.ParserRuleContext {
3309
3195
  constructor(parent, invokingState) {
3310
3196
  super(parent, invokingState);
@@ -3312,14 +3198,8 @@ export class WorkStatementContext extends antlr.ParserRuleContext {
3312
3198
  OPEN_WORK() {
3313
3199
  return this.getToken(plurnkParser.OPEN_WORK, 0);
3314
3200
  }
3315
- COLON() {
3316
- return this.getToken(plurnkParser.COLON, 0);
3317
- }
3318
- body() {
3319
- return this.getRuleContext(0, BodyContext);
3320
- }
3321
- CLOSE_TAG() {
3322
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3201
+ statementEnd() {
3202
+ return this.getRuleContext(0, StatementEndContext);
3323
3203
  }
3324
3204
  branchModifiers() {
3325
3205
  return this.getRuleContext(0, BranchModifiersContext);
@@ -3343,14 +3223,8 @@ export class ForkStatementContext extends antlr.ParserRuleContext {
3343
3223
  OPEN_FORK() {
3344
3224
  return this.getToken(plurnkParser.OPEN_FORK, 0);
3345
3225
  }
3346
- COLON() {
3347
- return this.getToken(plurnkParser.COLON, 0);
3348
- }
3349
- body() {
3350
- return this.getRuleContext(0, BodyContext);
3351
- }
3352
- CLOSE_TAG() {
3353
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3226
+ statementEnd() {
3227
+ return this.getRuleContext(0, StatementEndContext);
3354
3228
  }
3355
3229
  branchModifiers() {
3356
3230
  return this.getRuleContext(0, BranchModifiersContext);
@@ -3374,18 +3248,12 @@ export class KillStatementContext extends antlr.ParserRuleContext {
3374
3248
  OPEN_KILL() {
3375
3249
  return this.getToken(plurnkParser.OPEN_KILL, 0);
3376
3250
  }
3377
- CLOSE_TAG() {
3378
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3251
+ statementEnd() {
3252
+ return this.getRuleContext(0, StatementEndContext);
3379
3253
  }
3380
3254
  intOpModifiers() {
3381
3255
  return this.getRuleContext(0, IntOpModifiersContext);
3382
3256
  }
3383
- COLON() {
3384
- return this.getToken(plurnkParser.COLON, 0);
3385
- }
3386
- body() {
3387
- return this.getRuleContext(0, BodyContext);
3388
- }
3389
3257
  get ruleIndex() {
3390
3258
  return plurnkParser.RULE_killStatement;
3391
3259
  }
@@ -3405,18 +3273,12 @@ export class PlanStatementContext extends antlr.ParserRuleContext {
3405
3273
  OPEN_PLAN() {
3406
3274
  return this.getToken(plurnkParser.OPEN_PLAN, 0);
3407
3275
  }
3408
- CLOSE_TAG() {
3409
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3276
+ statementEnd() {
3277
+ return this.getRuleContext(0, StatementEndContext);
3410
3278
  }
3411
3279
  tagOpModifiers() {
3412
3280
  return this.getRuleContext(0, TagOpModifiersContext);
3413
3281
  }
3414
- COLON() {
3415
- return this.getToken(plurnkParser.COLON, 0);
3416
- }
3417
- body() {
3418
- return this.getRuleContext(0, BodyContext);
3419
- }
3420
3282
  get ruleIndex() {
3421
3283
  return plurnkParser.RULE_planStatement;
3422
3284
  }
@@ -3436,18 +3298,12 @@ export class LookStatementContext extends antlr.ParserRuleContext {
3436
3298
  OPEN_LOOK() {
3437
3299
  return this.getToken(plurnkParser.OPEN_LOOK, 0);
3438
3300
  }
3439
- CLOSE_TAG() {
3440
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3301
+ statementEnd() {
3302
+ return this.getRuleContext(0, StatementEndContext);
3441
3303
  }
3442
3304
  tagOpModifiers() {
3443
3305
  return this.getRuleContext(0, TagOpModifiersContext);
3444
3306
  }
3445
- COLON() {
3446
- return this.getToken(plurnkParser.COLON, 0);
3447
- }
3448
- body() {
3449
- return this.getRuleContext(0, BodyContext);
3450
- }
3451
3307
  get ruleIndex() {
3452
3308
  return plurnkParser.RULE_lookStatement;
3453
3309
  }
@@ -3467,24 +3323,43 @@ export class BuffStatementContext extends antlr.ParserRuleContext {
3467
3323
  OPEN_BUFF() {
3468
3324
  return this.getToken(plurnkParser.OPEN_BUFF, 0);
3469
3325
  }
3470
- CLOSE_TAG() {
3471
- return this.getToken(plurnkParser.CLOSE_TAG, 0);
3326
+ statementEnd() {
3327
+ return this.getRuleContext(0, StatementEndContext);
3472
3328
  }
3473
3329
  tagOpModifiers() {
3474
3330
  return this.getRuleContext(0, TagOpModifiersContext);
3475
3331
  }
3476
- COLON() {
3477
- return this.getToken(plurnkParser.COLON, 0);
3332
+ get ruleIndex() {
3333
+ return plurnkParser.RULE_buffStatement;
3334
+ }
3335
+ accept(visitor) {
3336
+ if (visitor.visitBuffStatement) {
3337
+ return visitor.visitBuffStatement(this);
3338
+ }
3339
+ else {
3340
+ return visitor.visitChildren(this);
3341
+ }
3342
+ }
3343
+ }
3344
+ export class StatementEndContext extends antlr.ParserRuleContext {
3345
+ constructor(parent, invokingState) {
3346
+ super(parent, invokingState);
3347
+ }
3348
+ SECTION_END() {
3349
+ return this.getToken(plurnkParser.SECTION_END, 0);
3350
+ }
3351
+ BODY_OPEN() {
3352
+ return this.getToken(plurnkParser.BODY_OPEN, 0);
3478
3353
  }
3479
3354
  body() {
3480
3355
  return this.getRuleContext(0, BodyContext);
3481
3356
  }
3482
3357
  get ruleIndex() {
3483
- return plurnkParser.RULE_buffStatement;
3358
+ return plurnkParser.RULE_statementEnd;
3484
3359
  }
3485
3360
  accept(visitor) {
3486
- if (visitor.visitBuffStatement) {
3487
- return visitor.visitBuffStatement(this);
3361
+ if (visitor.visitStatementEnd) {
3362
+ return visitor.visitStatementEnd(this);
3488
3363
  }
3489
3364
  else {
3490
3365
  return visitor.visitChildren(this);