1# type: ignore
2
3from jsparagus import runtime
4from jsparagus.runtime import (Nt, InitNt, End, ErrorToken, StateTermValue,
5                               ShiftError, ShiftAccept)
6
7def state_43_actions(parser, lexer):
8    # { value = AstBuilder::id(1) [off: 0]; Unwind(Nt(InitNt(goal=Nt('grammar'))), 1, 0) }
9
10    value = None
11    value = parser.stack[-1].value
12    replay = []
13    replay.append(StateTermValue(0, Nt(InitNt(goal=Nt('grammar'))), value, False))
14    del parser.stack[-1:]
15    parser.replay.extend(replay)
16    r0 = parser.replay.pop()
17    state_84_actions(parser, lexer, r0)
18    return
19
20def state_44_actions(parser, lexer):
21    # { value = AstBuilder::nt_defs_single(1) [off: 0]; Unwind(Nt('nt_defs'), 1, 0) }
22
23    value = None
24    value = parser.methods.nt_defs_single(parser.stack[-1].value)
25    replay = []
26    replay.append(StateTermValue(0, Nt('nt_defs'), value, False))
27    del parser.stack[-1:]
28    parser.replay.extend(replay)
29    r0 = parser.replay.pop()
30    state_82_actions(parser, lexer, r0)
31    return
32
33def state_45_actions(parser, lexer):
34    # { value = AstBuilder::single(1) [off: 0]; Unwind(Nt('token_defs'), 1, 0) }
35
36    value = None
37    value = parser.methods.single(parser.stack[-1].value)
38    replay = []
39    replay.append(StateTermValue(0, Nt('token_defs'), value, False))
40    del parser.stack[-1:]
41    parser.replay.extend(replay)
42    r0 = parser.replay.pop()
43    state_83_actions(parser, lexer, r0)
44    return
45
46def state_46_actions(parser, lexer):
47    # { value = AstBuilder::nt_defs_append(2, 1) [off: 0]; Unwind(Nt('nt_defs'), 2, 0) }
48
49    value = None
50    value = parser.methods.nt_defs_append(parser.stack[-2].value, parser.stack[-1].value)
51    replay = []
52    replay.append(StateTermValue(0, Nt('nt_defs'), value, False))
53    del parser.stack[-2:]
54    parser.replay.extend(replay)
55    r0 = parser.replay.pop()
56    state_82_actions(parser, lexer, r0)
57    return
58
59def state_47_actions(parser, lexer):
60    # { value = AstBuilder::append(2, 1) [off: 0]; Unwind(Nt('token_defs'), 2, 0) }
61
62    value = None
63    value = parser.methods.append(parser.stack[-2].value, parser.stack[-1].value)
64    replay = []
65    replay.append(StateTermValue(0, Nt('token_defs'), value, False))
66    del parser.stack[-2:]
67    parser.replay.extend(replay)
68    r0 = parser.replay.pop()
69    state_83_actions(parser, lexer, r0)
70    return
71
72def state_48_actions(parser, lexer):
73    # { Accept(); Unwind(Nt(InitNt(goal=Nt('grammar'))), 2, 0) }
74
75    value = None
76    raise ShiftAccept()
77    replay = []
78    replay.append(StateTermValue(0, Nt(InitNt(goal=Nt('grammar'))), value, False))
79    del parser.stack[-2:]
80    parser.replay.extend(replay)
81    r0 = parser.replay.pop()
82    state_84_actions(parser, lexer, r0)
83    return
84
85def state_49_actions(parser, lexer):
86    # { value = AstBuilder::nt_def(None, None, 3, None) [off: 0]; Unwind(Nt('nt_def'), 4, 0) }
87
88    value = None
89    value = parser.methods.nt_def(None, None, parser.stack[-3].value, None)
90    replay = []
91    replay.append(StateTermValue(0, Nt('nt_def'), value, False))
92    del parser.stack[-4:]
93    parser.replay.extend(replay)
94    r0 = parser.replay.pop()
95    state_107_actions(parser, lexer, r0)
96    return
97
98def state_50_actions(parser, lexer):
99    # { value = AstBuilder::single(1) [off: 0]; Unwind(Nt('prods'), 1, 0) }
100
101    value = None
102    value = parser.methods.single(parser.stack[-1].value)
103    replay = []
104    replay.append(StateTermValue(0, Nt('prods'), value, False))
105    del parser.stack[-1:]
106    parser.replay.extend(replay)
107    r0 = parser.replay.pop()
108    state_94_actions(parser, lexer, r0)
109    return
110
111def state_51_actions(parser, lexer):
112    # { value = AstBuilder::single(1) [off: 0]; Unwind(Nt('terms'), 1, 0) }
113
114    value = None
115    value = parser.methods.single(parser.stack[-1].value)
116    replay = []
117    replay.append(StateTermValue(0, Nt('terms'), value, False))
118    del parser.stack[-1:]
119    parser.replay.extend(replay)
120    r0 = parser.replay.pop()
121    state_97_actions(parser, lexer, r0)
122    return
123
124def state_52_actions(parser, lexer):
125    # { value = AstBuilder::ident(1) [off: 0]; Unwind(Nt('symbol'), 1, 0) }
126
127    value = None
128    value = parser.methods.ident(parser.stack[-1].value)
129    replay = []
130    replay.append(StateTermValue(0, Nt('symbol'), value, False))
131    del parser.stack[-1:]
132    parser.replay.extend(replay)
133    r0 = parser.replay.pop()
134    state_91_actions(parser, lexer, r0)
135    return
136
137def state_53_actions(parser, lexer):
138    # { value = AstBuilder::str(1) [off: 0]; Unwind(Nt('symbol'), 1, 0) }
139
140    value = None
141    value = parser.methods.str(parser.stack[-1].value)
142    replay = []
143    replay.append(StateTermValue(0, Nt('symbol'), value, False))
144    del parser.stack[-1:]
145    parser.replay.extend(replay)
146    r0 = parser.replay.pop()
147    state_91_actions(parser, lexer, r0)
148    return
149
150def state_54_actions(parser, lexer):
151    # { value = AstBuilder::empty(1) [off: 0]; Unwind(Nt('prods'), 1, 0) }
152
153    value = None
154    value = parser.methods.empty(parser.stack[-1].value)
155    replay = []
156    replay.append(StateTermValue(0, Nt('prods'), value, False))
157    del parser.stack[-1:]
158    parser.replay.extend(replay)
159    r0 = parser.replay.pop()
160    state_94_actions(parser, lexer, r0)
161    return
162
163def state_55_actions(parser, lexer):
164    # { value = AstBuilder::var_token(2) [off: 0]; Unwind(Nt('token_def'), 4, 0) }
165
166    value = None
167    value = parser.methods.var_token(parser.stack[-2].value)
168    replay = []
169    replay.append(StateTermValue(0, Nt('token_def'), value, False))
170    del parser.stack[-4:]
171    parser.replay.extend(replay)
172    r0 = parser.replay.pop()
173    state_100_actions(parser, lexer, r0)
174    return
175
176def state_56_actions(parser, lexer):
177    # { value = AstBuilder::nt_def(None, None, 4, Some(inner=2)) [off: 0]; Unwind(Nt('nt_def'), 5, 0) }
178
179    value = None
180    value = parser.methods.nt_def(None, None, parser.stack[-4].value, parser.stack[-2].value)
181    replay = []
182    replay.append(StateTermValue(0, Nt('nt_def'), value, False))
183    del parser.stack[-5:]
184    parser.replay.extend(replay)
185    r0 = parser.replay.pop()
186    state_107_actions(parser, lexer, r0)
187    return
188
189def state_57_actions(parser, lexer):
190    # { value = AstBuilder::append(2, 1) [off: 0]; Unwind(Nt('prods'), 2, 0) }
191
192    value = None
193    value = parser.methods.append(parser.stack[-2].value, parser.stack[-1].value)
194    replay = []
195    replay.append(StateTermValue(0, Nt('prods'), value, False))
196    del parser.stack[-2:]
197    parser.replay.extend(replay)
198    r0 = parser.replay.pop()
199    state_94_actions(parser, lexer, r0)
200    return
201
202def state_58_actions(parser, lexer):
203    # { value = AstBuilder::prod(2, None) [off: 0]; Unwind(Nt('prod'), 2, 0) }
204
205    value = None
206    value = parser.methods.prod(parser.stack[-2].value, None)
207    replay = []
208    replay.append(StateTermValue(0, Nt('prod'), value, False))
209    del parser.stack[-2:]
210    parser.replay.extend(replay)
211    r0 = parser.replay.pop()
212    state_101_actions(parser, lexer, r0)
213    return
214
215def state_59_actions(parser, lexer):
216    # { value = AstBuilder::append(2, 1) [off: 0]; Unwind(Nt('terms'), 2, 0) }
217
218    value = None
219    value = parser.methods.append(parser.stack[-2].value, parser.stack[-1].value)
220    replay = []
221    replay.append(StateTermValue(0, Nt('terms'), value, False))
222    del parser.stack[-2:]
223    parser.replay.extend(replay)
224    r0 = parser.replay.pop()
225    state_97_actions(parser, lexer, r0)
226    return
227
228def state_60_actions(parser, lexer):
229    # { value = AstBuilder::optional(2) [off: 0]; Unwind(Nt('term'), 2, 0) }
230
231    value = None
232    value = parser.methods.optional(parser.stack[-2].value)
233    replay = []
234    replay.append(StateTermValue(0, Nt('term'), value, False))
235    del parser.stack[-2:]
236    parser.replay.extend(replay)
237    r0 = parser.replay.pop()
238    state_111_actions(parser, lexer, r0)
239    return
240
241def state_61_actions(parser, lexer):
242    # { value = AstBuilder::nt_def(Some(inner=5), None, 3, None) [off: 0]; Unwind(Nt('nt_def'), 5, 0) }
243
244    value = None
245    value = parser.methods.nt_def(parser.stack[-5].value, None, parser.stack[-3].value, None)
246    replay = []
247    replay.append(StateTermValue(0, Nt('nt_def'), value, False))
248    del parser.stack[-5:]
249    parser.replay.extend(replay)
250    r0 = parser.replay.pop()
251    state_107_actions(parser, lexer, r0)
252    return
253
254def state_62_actions(parser, lexer):
255    # { value = AstBuilder::nt_def(None, Some(inner=5), 3, None) [off: 0]; Unwind(Nt('nt_def'), 5, 0) }
256
257    value = None
258    value = parser.methods.nt_def(None, parser.stack[-5].value, parser.stack[-3].value, None)
259    replay = []
260    replay.append(StateTermValue(0, Nt('nt_def'), value, False))
261    del parser.stack[-5:]
262    parser.replay.extend(replay)
263    r0 = parser.replay.pop()
264    state_107_actions(parser, lexer, r0)
265    return
266
267def state_63_actions(parser, lexer):
268    # { value = AstBuilder::const_token(4, 2) [off: 0]; Unwind(Nt('token_def'), 5, 0) }
269
270    value = None
271    value = parser.methods.const_token(parser.stack[-4].value, parser.stack[-2].value)
272    replay = []
273    replay.append(StateTermValue(0, Nt('token_def'), value, False))
274    del parser.stack[-5:]
275    parser.replay.extend(replay)
276    r0 = parser.replay.pop()
277    state_100_actions(parser, lexer, r0)
278    return
279
280def state_64_actions(parser, lexer):
281    # { value = AstBuilder::prod(3, Some(inner=2)) [off: 0]; Unwind(Nt('prod'), 3, 0) }
282
283    value = None
284    value = parser.methods.prod(parser.stack[-3].value, parser.stack[-2].value)
285    replay = []
286    replay.append(StateTermValue(0, Nt('prod'), value, False))
287    del parser.stack[-3:]
288    parser.replay.extend(replay)
289    r0 = parser.replay.pop()
290    state_101_actions(parser, lexer, r0)
291    return
292
293def state_65_actions(parser, lexer):
294    # { value = AstBuilder::id(1) [off: 0]; Unwind(Nt('reducer'), 2, 0) }
295
296    value = None
297    value = parser.stack[-1].value
298    replay = []
299    replay.append(StateTermValue(0, Nt('reducer'), value, False))
300    del parser.stack[-2:]
301    parser.replay.extend(replay)
302    r0 = parser.replay.pop()
303    state_102_actions(parser, lexer, r0)
304    return
305
306def state_66_actions(parser, lexer):
307    # { value = AstBuilder::expr_match(1) [off: 0]; Unwind(Nt('expr'), 1, 0) }
308
309    value = None
310    value = parser.methods.expr_match(parser.stack[-1].value)
311    replay = []
312    replay.append(StateTermValue(0, Nt('expr'), value, False))
313    del parser.stack[-1:]
314    parser.replay.extend(replay)
315    r0 = parser.replay.pop()
316    state_108_actions(parser, lexer, r0)
317    return
318
319def state_67_actions(parser, lexer):
320    # { value = AstBuilder::expr_none() [off: 0]; Unwind(Nt('expr'), 1, 0) }
321
322    value = None
323    value = parser.methods.expr_none()
324    replay = []
325    replay.append(StateTermValue(0, Nt('expr'), value, False))
326    del parser.stack[-1:]
327    parser.replay.extend(replay)
328    r0 = parser.replay.pop()
329    state_108_actions(parser, lexer, r0)
330    return
331
332def state_68_actions(parser, lexer):
333    # { value = AstBuilder::nt_def(Some(inner=6), None, 4, Some(inner=2)) [off: 0]; Unwind(Nt('nt_def'), 6, 0) }
334
335    value = None
336    value = parser.methods.nt_def(parser.stack[-6].value, None, parser.stack[-4].value, parser.stack[-2].value)
337    replay = []
338    replay.append(StateTermValue(0, Nt('nt_def'), value, False))
339    del parser.stack[-6:]
340    parser.replay.extend(replay)
341    r0 = parser.replay.pop()
342    state_107_actions(parser, lexer, r0)
343    return
344
345def state_69_actions(parser, lexer):
346    # { value = AstBuilder::nt_def(Some(inner=6), Some(inner=5), 3, None) [off: 0]; Unwind(Nt('nt_def'), 6, 0) }
347
348    value = None
349    value = parser.methods.nt_def(parser.stack[-6].value, parser.stack[-5].value, parser.stack[-3].value, None)
350    replay = []
351    replay.append(StateTermValue(0, Nt('nt_def'), value, False))
352    del parser.stack[-6:]
353    parser.replay.extend(replay)
354    r0 = parser.replay.pop()
355    state_107_actions(parser, lexer, r0)
356    return
357
358def state_70_actions(parser, lexer):
359    # { value = AstBuilder::nt_def(None, Some(inner=6), 4, Some(inner=2)) [off: 0]; Unwind(Nt('nt_def'), 6, 0) }
360
361    value = None
362    value = parser.methods.nt_def(None, parser.stack[-6].value, parser.stack[-4].value, parser.stack[-2].value)
363    replay = []
364    replay.append(StateTermValue(0, Nt('nt_def'), value, False))
365    del parser.stack[-6:]
366    parser.replay.extend(replay)
367    r0 = parser.replay.pop()
368    state_107_actions(parser, lexer, r0)
369    return
370
371def state_71_actions(parser, lexer):
372    # { value = AstBuilder::nt_def(Some(inner=7), Some(inner=6), 4, Some(inner=2)) [off: 0]; Unwind(Nt('nt_def'), 7, 0) }
373
374    value = None
375    value = parser.methods.nt_def(parser.stack[-7].value, parser.stack[-6].value, parser.stack[-4].value, parser.stack[-2].value)
376    replay = []
377    replay.append(StateTermValue(0, Nt('nt_def'), value, False))
378    del parser.stack[-7:]
379    parser.replay.extend(replay)
380    r0 = parser.replay.pop()
381    state_107_actions(parser, lexer, r0)
382    return
383
384def state_72_actions(parser, lexer):
385    # { value = AstBuilder::expr_call(3, None) [off: 0]; Unwind(Nt('expr'), 3, 0) }
386
387    value = None
388    value = parser.methods.expr_call(parser.stack[-3].value, None)
389    replay = []
390    replay.append(StateTermValue(0, Nt('expr'), value, False))
391    del parser.stack[-3:]
392    parser.replay.extend(replay)
393    r0 = parser.replay.pop()
394    state_108_actions(parser, lexer, r0)
395    return
396
397def state_73_actions(parser, lexer):
398    # { value = AstBuilder::args_single(1) [off: 0]; Unwind(Nt('expr_args'), 1, 0) }
399
400    value = None
401    value = parser.methods.args_single(parser.stack[-1].value)
402    replay = []
403    replay.append(StateTermValue(0, Nt('expr_args'), value, False))
404    del parser.stack[-1:]
405    parser.replay.extend(replay)
406    r0 = parser.replay.pop()
407    state_109_actions(parser, lexer, r0)
408    return
409
410def state_74_actions(parser, lexer):
411    # { value = AstBuilder::expr_call(4, Some(inner=2)) [off: 0]; Unwind(Nt('expr'), 4, 0) }
412
413    value = None
414    value = parser.methods.expr_call(parser.stack[-4].value, parser.stack[-2].value)
415    replay = []
416    replay.append(StateTermValue(0, Nt('expr'), value, False))
417    del parser.stack[-4:]
418    parser.replay.extend(replay)
419    r0 = parser.replay.pop()
420    state_108_actions(parser, lexer, r0)
421    return
422
423def state_75_actions(parser, lexer):
424    # { value = AstBuilder::expr_some(2) [off: 0]; Unwind(Nt('expr'), 4, 0) }
425
426    value = None
427    value = parser.methods.expr_some(parser.stack[-2].value)
428    replay = []
429    replay.append(StateTermValue(0, Nt('expr'), value, False))
430    del parser.stack[-4:]
431    parser.replay.extend(replay)
432    r0 = parser.replay.pop()
433    state_108_actions(parser, lexer, r0)
434    return
435
436def state_76_actions(parser, lexer):
437    # { value = AstBuilder::args_append(3, 1) [off: 0]; Unwind(Nt('expr_args'), 3, 0) }
438
439    value = None
440    value = parser.methods.args_append(parser.stack[-3].value, parser.stack[-1].value)
441    replay = []
442    replay.append(StateTermValue(0, Nt('expr_args'), value, False))
443    del parser.stack[-3:]
444    parser.replay.extend(replay)
445    r0 = parser.replay.pop()
446    state_109_actions(parser, lexer, r0)
447    return
448
449def state_77_actions(parser, lexer):
450    # { value = AstBuilder::grammar(None, 1) [off: 1]; Unwind(Nt('grammar'), 1, 1) }
451
452    value = None
453    value = parser.methods.grammar(None, parser.stack[-2].value)
454    replay = []
455    replay.append(parser.stack.pop())
456    replay.append(StateTermValue(0, Nt('grammar'), value, False))
457    del parser.stack[-1:]
458    parser.replay.extend(replay)
459    r0 = parser.replay.pop()
460    state_110_actions(parser, lexer, r0)
461    return
462
463def state_78_actions(parser, lexer):
464    # { value = AstBuilder::grammar(Some(inner=2), 1) [off: 1]; Unwind(Nt('grammar'), 2, 1) }
465
466    value = None
467    value = parser.methods.grammar(parser.stack[-3].value, parser.stack[-2].value)
468    replay = []
469    replay.append(parser.stack.pop())
470    replay.append(StateTermValue(0, Nt('grammar'), value, False))
471    del parser.stack[-2:]
472    parser.replay.extend(replay)
473    r0 = parser.replay.pop()
474    state_110_actions(parser, lexer, r0)
475    return
476
477def state_79_actions(parser, lexer):
478    # { value = AstBuilder::id(1) [off: 1]; Unwind(Nt('term'), 1, 1) }
479
480    value = None
481    value = parser.stack[-2].value
482    replay = []
483    replay.append(parser.stack.pop())
484    replay.append(StateTermValue(0, Nt('term'), value, False))
485    del parser.stack[-1:]
486    parser.replay.extend(replay)
487    r0 = parser.replay.pop()
488    state_111_actions(parser, lexer, r0)
489    return
490
491def state_80_actions(parser, lexer, a0):
492    parser.replay.extend([a0])
493    # Replay((12,))
494
495    value = None
496    parser.replay_action(12)
497    top = parser.stack.pop()
498    top = StateTermValue(12, top.term, top.value, top.new_line)
499    parser.stack.append(top)
500    return
501
502def state_81_actions(parser, lexer, a0):
503    parser.replay.extend([a0])
504    # Replay((13,))
505
506    value = None
507    parser.replay_action(13)
508    top = parser.stack.pop()
509    top = StateTermValue(13, top.term, top.value, top.new_line)
510    parser.stack.append(top)
511    return
512
513def state_82_actions(parser, lexer, a0):
514    parser.replay.extend([a0])
515
516    value = None
517    if parser.top_state() in [10]:
518        r0 = parser.replay.pop()
519        state_80_actions(parser, lexer, r0)
520        return
521    if parser.top_state() in [11]:
522        r0 = parser.replay.pop()
523        state_81_actions(parser, lexer, r0)
524        return
525
526def state_83_actions(parser, lexer, a0):
527    parser.replay.extend([a0])
528    # Replay((11,))
529
530    value = None
531    parser.replay_action(11)
532    top = parser.stack.pop()
533    top = StateTermValue(11, top.term, top.value, top.new_line)
534    parser.stack.append(top)
535    return
536
537def state_84_actions(parser, lexer, a0):
538    parser.replay.extend([a0])
539    # Replay((23,))
540
541    value = None
542    parser.replay_action(23)
543    top = parser.stack.pop()
544    top = StateTermValue(23, top.term, top.value, top.new_line)
545    parser.stack.append(top)
546    return
547
548def state_85_actions(parser, lexer, a0):
549    parser.replay.extend([a0])
550    # { value = AstBuilder::nt_defs_single(1) [off: -1]; Unwind(Nt('nt_defs'), 1, -1) }
551    parser.stack.append(parser.replay.pop())
552
553    value = None
554    value = parser.methods.nt_defs_single(parser.stack[-1].value)
555    replay = []
556    replay.append(StateTermValue(0, Nt('nt_defs'), value, False))
557    del parser.stack[-1:]
558    parser.replay.extend(replay)
559    r0 = parser.replay.pop()
560    state_82_actions(parser, lexer, r0)
561    return
562
563def state_86_actions(parser, lexer, a0):
564    parser.replay.extend([a0])
565    # { value = AstBuilder::nt_defs_append(2, 1) [off: -1]; Unwind(Nt('nt_defs'), 2, -1) }
566    parser.stack.append(parser.replay.pop())
567
568    value = None
569    value = parser.methods.nt_defs_append(parser.stack[-2].value, parser.stack[-1].value)
570    replay = []
571    replay.append(StateTermValue(0, Nt('nt_defs'), value, False))
572    del parser.stack[-2:]
573    parser.replay.extend(replay)
574    r0 = parser.replay.pop()
575    state_82_actions(parser, lexer, r0)
576    return
577
578def state_87_actions(parser, lexer, a0):
579    parser.replay.extend([a0])
580    # Replay((4,))
581
582    value = None
583    parser.replay_action(4)
584    top = parser.stack.pop()
585    top = StateTermValue(4, top.term, top.value, top.new_line)
586    parser.stack.append(top)
587    return
588
589def state_88_actions(parser, lexer, a0):
590    parser.replay.extend([a0])
591    # Replay((5,))
592
593    value = None
594    parser.replay_action(5)
595    top = parser.stack.pop()
596    top = StateTermValue(5, top.term, top.value, top.new_line)
597    parser.stack.append(top)
598    return
599
600def state_89_actions(parser, lexer, a0):
601    parser.replay.extend([a0])
602    # Replay((6,))
603
604    value = None
605    parser.replay_action(6)
606    top = parser.stack.pop()
607    top = StateTermValue(6, top.term, top.value, top.new_line)
608    parser.stack.append(top)
609    return
610
611def state_90_actions(parser, lexer, a0):
612    parser.replay.extend([a0])
613    # Replay((7,))
614
615    value = None
616    parser.replay_action(7)
617    top = parser.stack.pop()
618    top = StateTermValue(7, top.term, top.value, top.new_line)
619    parser.stack.append(top)
620    return
621
622def state_91_actions(parser, lexer, a0):
623    parser.replay.extend([a0])
624    # Replay((9,))
625
626    value = None
627    parser.replay_action(9)
628    top = parser.stack.pop()
629    top = StateTermValue(9, top.term, top.value, top.new_line)
630    parser.stack.append(top)
631    return
632
633def state_92_actions(parser, lexer, a0):
634    parser.replay.extend([a0])
635    # { value = AstBuilder::single(1) [off: -1]; Unwind(Nt('token_defs'), 1, -1) }
636    parser.stack.append(parser.replay.pop())
637
638    value = None
639    value = parser.methods.single(parser.stack[-1].value)
640    replay = []
641    replay.append(StateTermValue(0, Nt('token_defs'), value, False))
642    del parser.stack[-1:]
643    parser.replay.extend(replay)
644    r0 = parser.replay.pop()
645    state_83_actions(parser, lexer, r0)
646    return
647
648def state_93_actions(parser, lexer, a0):
649    parser.replay.extend([a0])
650    # { value = AstBuilder::append(2, 1) [off: -1]; Unwind(Nt('token_defs'), 2, -1) }
651    parser.stack.append(parser.replay.pop())
652
653    value = None
654    value = parser.methods.append(parser.stack[-2].value, parser.stack[-1].value)
655    replay = []
656    replay.append(StateTermValue(0, Nt('token_defs'), value, False))
657    del parser.stack[-2:]
658    parser.replay.extend(replay)
659    r0 = parser.replay.pop()
660    state_83_actions(parser, lexer, r0)
661    return
662
663def state_94_actions(parser, lexer, a0):
664    parser.replay.extend([a0])
665
666    value = None
667    if parser.top_state() in [0]:
668        r0 = parser.replay.pop()
669        state_87_actions(parser, lexer, r0)
670        return
671    if parser.top_state() in [1]:
672        r0 = parser.replay.pop()
673        state_88_actions(parser, lexer, r0)
674        return
675    if parser.top_state() in [2]:
676        r0 = parser.replay.pop()
677        state_89_actions(parser, lexer, r0)
678        return
679    if parser.top_state() in [3]:
680        r0 = parser.replay.pop()
681        state_90_actions(parser, lexer, r0)
682        return
683
684def state_95_actions(parser, lexer, a0):
685    parser.replay.extend([a0])
686    # { value = AstBuilder::single(1) [off: -1]; Unwind(Nt('prods'), 1, -1) }
687    parser.stack.append(parser.replay.pop())
688
689    value = None
690    value = parser.methods.single(parser.stack[-1].value)
691    replay = []
692    replay.append(StateTermValue(0, Nt('prods'), value, False))
693    del parser.stack[-1:]
694    parser.replay.extend(replay)
695    r0 = parser.replay.pop()
696    state_94_actions(parser, lexer, r0)
697    return
698
699def state_96_actions(parser, lexer, a0):
700    parser.replay.extend([a0])
701    # { value = AstBuilder::append(2, 1) [off: -1]; Unwind(Nt('prods'), 2, -1) }
702    parser.stack.append(parser.replay.pop())
703
704    value = None
705    value = parser.methods.append(parser.stack[-2].value, parser.stack[-1].value)
706    replay = []
707    replay.append(StateTermValue(0, Nt('prods'), value, False))
708    del parser.stack[-2:]
709    parser.replay.extend(replay)
710    r0 = parser.replay.pop()
711    state_94_actions(parser, lexer, r0)
712    return
713
714def state_97_actions(parser, lexer, a0):
715    parser.replay.extend([a0])
716    # Replay((8,))
717
718    value = None
719    parser.replay_action(8)
720    top = parser.stack.pop()
721    top = StateTermValue(8, top.term, top.value, top.new_line)
722    parser.stack.append(top)
723    return
724
725def state_98_actions(parser, lexer, a0):
726    parser.replay.extend([a0])
727    # { value = AstBuilder::single(1) [off: -1]; Unwind(Nt('terms'), 1, -1) }
728    parser.stack.append(parser.replay.pop())
729
730    value = None
731    value = parser.methods.single(parser.stack[-1].value)
732    replay = []
733    replay.append(StateTermValue(0, Nt('terms'), value, False))
734    del parser.stack[-1:]
735    parser.replay.extend(replay)
736    r0 = parser.replay.pop()
737    state_97_actions(parser, lexer, r0)
738    return
739
740def state_99_actions(parser, lexer, a0):
741    parser.replay.extend([a0])
742    # { value = AstBuilder::append(2, 1) [off: -1]; Unwind(Nt('terms'), 2, -1) }
743    parser.stack.append(parser.replay.pop())
744
745    value = None
746    value = parser.methods.append(parser.stack[-2].value, parser.stack[-1].value)
747    replay = []
748    replay.append(StateTermValue(0, Nt('terms'), value, False))
749    del parser.stack[-2:]
750    parser.replay.extend(replay)
751    r0 = parser.replay.pop()
752    state_97_actions(parser, lexer, r0)
753    return
754
755def state_100_actions(parser, lexer, a0):
756    parser.replay.extend([a0])
757
758    value = None
759    if parser.top_state() in [10]:
760        r0 = parser.replay.pop()
761        state_92_actions(parser, lexer, r0)
762        return
763    if parser.top_state() in [11]:
764        r0 = parser.replay.pop()
765        state_93_actions(parser, lexer, r0)
766        return
767
768def state_101_actions(parser, lexer, a0):
769    parser.replay.extend([a0])
770
771    value = None
772    if parser.top_state() in [0, 1, 2, 3]:
773        r0 = parser.replay.pop()
774        state_95_actions(parser, lexer, r0)
775        return
776    if parser.top_state() in [4, 5, 6, 7]:
777        r0 = parser.replay.pop()
778        state_96_actions(parser, lexer, r0)
779        return
780
781def state_102_actions(parser, lexer, a0):
782    parser.replay.extend([a0])
783    # Replay((38,))
784
785    value = None
786    parser.replay_action(38)
787    top = parser.stack.pop()
788    top = StateTermValue(38, top.term, top.value, top.new_line)
789    parser.stack.append(top)
790    return
791
792def state_103_actions(parser, lexer, a0):
793    parser.replay.extend([a0])
794    # { value = AstBuilder::id(1) [off: -1]; Unwind(Nt('reducer'), 2, -1) }
795    parser.stack.append(parser.replay.pop())
796
797    value = None
798    value = parser.stack[-1].value
799    replay = []
800    replay.append(StateTermValue(0, Nt('reducer'), value, False))
801    del parser.stack[-2:]
802    parser.replay.extend(replay)
803    r0 = parser.replay.pop()
804    state_102_actions(parser, lexer, r0)
805    return
806
807def state_104_actions(parser, lexer, a0):
808    parser.replay.extend([a0])
809    # { value = AstBuilder::args_single(1) [off: -1]; Unwind(Nt('expr_args'), 1, -1) }
810    parser.stack.append(parser.replay.pop())
811
812    value = None
813    value = parser.methods.args_single(parser.stack[-1].value)
814    replay = []
815    replay.append(StateTermValue(0, Nt('expr_args'), value, False))
816    del parser.stack[-1:]
817    parser.replay.extend(replay)
818    r0 = parser.replay.pop()
819    state_109_actions(parser, lexer, r0)
820    return
821
822def state_105_actions(parser, lexer, a0):
823    parser.replay.extend([a0])
824    # Replay((42,))
825
826    value = None
827    parser.replay_action(42)
828    top = parser.stack.pop()
829    top = StateTermValue(42, top.term, top.value, top.new_line)
830    parser.stack.append(top)
831    return
832
833def state_106_actions(parser, lexer, a0):
834    parser.replay.extend([a0])
835    # { value = AstBuilder::args_append(3, 1) [off: -1]; Unwind(Nt('expr_args'), 3, -1) }
836    parser.stack.append(parser.replay.pop())
837
838    value = None
839    value = parser.methods.args_append(parser.stack[-3].value, parser.stack[-1].value)
840    replay = []
841    replay.append(StateTermValue(0, Nt('expr_args'), value, False))
842    del parser.stack[-3:]
843    parser.replay.extend(replay)
844    r0 = parser.replay.pop()
845    state_109_actions(parser, lexer, r0)
846    return
847
848def state_107_actions(parser, lexer, a0):
849    parser.replay.extend([a0])
850
851    value = None
852    if parser.top_state() in [10, 11]:
853        r0 = parser.replay.pop()
854        state_85_actions(parser, lexer, r0)
855        return
856    if parser.top_state() in [12, 13]:
857        r0 = parser.replay.pop()
858        state_86_actions(parser, lexer, r0)
859        return
860
861def state_108_actions(parser, lexer, a0):
862    parser.replay.extend([a0])
863
864    value = None
865    if parser.top_state() in [15]:
866        r0 = parser.replay.pop()
867        state_103_actions(parser, lexer, r0)
868        return
869    if parser.top_state() in [14]:
870        r0 = parser.replay.pop()
871        state_104_actions(parser, lexer, r0)
872        return
873    if parser.top_state() in [16]:
874        r0 = parser.replay.pop()
875        state_105_actions(parser, lexer, r0)
876        return
877    if parser.top_state() in [17]:
878        r0 = parser.replay.pop()
879        state_106_actions(parser, lexer, r0)
880        return
881
882def state_109_actions(parser, lexer, a0):
883    parser.replay.extend([a0])
884    # Replay((41,))
885
886    value = None
887    parser.replay_action(41)
888    top = parser.stack.pop()
889    top = StateTermValue(41, top.term, top.value, top.new_line)
890    parser.stack.append(top)
891    return
892
893def state_110_actions(parser, lexer, a0):
894    parser.replay.extend([a0])
895    # { value = AstBuilder::id(1) [off: -1]; Unwind(Nt(InitNt(goal=Nt('grammar'))), 1, -1) }
896    parser.stack.append(parser.replay.pop())
897
898    value = None
899    value = parser.stack[-1].value
900    replay = []
901    replay.append(StateTermValue(0, Nt(InitNt(goal=Nt('grammar'))), value, False))
902    del parser.stack[-1:]
903    parser.replay.extend(replay)
904    r0 = parser.replay.pop()
905    state_84_actions(parser, lexer, r0)
906    return
907
908def state_111_actions(parser, lexer, a0):
909    parser.replay.extend([a0])
910
911    value = None
912    if parser.top_state() in [0, 1, 2, 3, 4, 5, 6, 7]:
913        r0 = parser.replay.pop()
914        state_98_actions(parser, lexer, r0)
915        return
916    if parser.top_state() in [8]:
917        r0 = parser.replay.pop()
918        state_99_actions(parser, lexer, r0)
919        return
920
921actions = [
922    # 0.
923
924    {'}': 49, 'IDENT': 52, 'STR': 53, 'COMMENT': 54, Nt('prods'): 4, Nt('prod'): 50, Nt('terms'): 8, Nt('term'): 51, Nt('symbol'): 9},
925
926    # 1.
927
928    {'}': 61, 'IDENT': 52, 'STR': 53, 'COMMENT': 54, Nt('prods'): 5, Nt('prod'): 50, Nt('terms'): 8, Nt('term'): 51, Nt('symbol'): 9},
929
930    # 2.
931
932    {'}': 62, 'IDENT': 52, 'STR': 53, 'COMMENT': 54, Nt('prods'): 6, Nt('prod'): 50, Nt('terms'): 8, Nt('term'): 51, Nt('symbol'): 9},
933
934    # 3.
935
936    {'}': 69, 'IDENT': 52, 'STR': 53, 'COMMENT': 54, Nt('prods'): 7, Nt('prod'): 50, Nt('terms'): 8, Nt('term'): 51, Nt('symbol'): 9},
937
938    # 4.
939
940    {'}': 56, 'IDENT': 52, 'STR': 53, Nt('prod'): 57, Nt('terms'): 8, Nt('term'): 51, Nt('symbol'): 9},
941
942    # 5.
943
944    {'}': 68, 'IDENT': 52, 'STR': 53, Nt('prod'): 57, Nt('terms'): 8, Nt('term'): 51, Nt('symbol'): 9},
945
946    # 6.
947
948    {'}': 70, 'IDENT': 52, 'STR': 53, Nt('prod'): 57, Nt('terms'): 8, Nt('term'): 51, Nt('symbol'): 9},
949
950    # 7.
951
952    {'}': 71, 'IDENT': 52, 'STR': 53, Nt('prod'): 57, Nt('terms'): 8, Nt('term'): 51, Nt('symbol'): 9},
953
954    # 8.
955
956    {';': 58, 'IDENT': 52, 'STR': 53, '=>': 15, Nt('term'): 59, Nt('symbol'): 9, Nt('reducer'): 38},
957
958    # 9.
959
960    {'=>': 79, 'STR': 79, 'IDENT': 79, ';': 79, '?': 60, Nt('reducer'): 79, Nt('symbol'): 79, Nt('term'): 79},
961
962    # 10.
963
964    {'nt': 18, 'COMMENT': 19, 'goal': 20, 'token': 21, 'var': 22, Nt('grammar'): 43, Nt('nt_defs'): 12, Nt('nt_def'): 44, Nt('token_defs'): 11, Nt('token_def'): 45, Nt(InitNt(goal=Nt('grammar'))): 23},
965
966    # 11.
967
968    {'nt': 18, 'COMMENT': 19, 'goal': 20, 'token': 21, 'var': 22, Nt('nt_defs'): 13, Nt('nt_def'): 44, Nt('token_def'): 47},
969
970    # 12.
971
972    {End(): 77, 'goal': 20, 'COMMENT': 19, 'nt': 18, Nt('nt_def'): 46},
973
974    # 13.
975
976    {End(): 78, 'goal': 20, 'COMMENT': 19, 'nt': 18, Nt('nt_def'): 46},
977
978    # 14.
979
980    {')': 72, 'MATCH': 66, 'IDENT': 39, 'Some': 40, 'None': 67, Nt('expr_args'): 41, Nt('expr'): 73},
981
982    # 15.
983
984    {'MATCH': 66, 'IDENT': 39, 'Some': 40, 'None': 67, Nt('expr'): 65},
985
986    # 16.
987
988    {'MATCH': 66, 'IDENT': 39, 'Some': 40, 'None': 67, Nt('expr'): 42},
989
990    # 17.
991
992    {'MATCH': 66, 'IDENT': 39, 'Some': 40, 'None': 67, Nt('expr'): 76},
993
994    # 18.
995
996    {'IDENT': 25},
997
998    # 19.
999
1000    {'nt': 26, 'goal': 27},
1001
1002    # 20.
1003
1004    {'nt': 28},
1005
1006    # 21.
1007
1008    {'IDENT': 29},
1009
1010    # 22.
1011
1012    {'token': 30},
1013
1014    # 23.
1015
1016    {End(): 48},
1017
1018    # 24.
1019
1020    {},
1021
1022    # 25.
1023
1024    {'{': 0},
1025
1026    # 26.
1027
1028    {'IDENT': 31},
1029
1030    # 27.
1031
1032    {'nt': 32},
1033
1034    # 28.
1035
1036    {'IDENT': 33},
1037
1038    # 29.
1039
1040    {'=': 34},
1041
1042    # 30.
1043
1044    {'IDENT': 35},
1045
1046    # 31.
1047
1048    {'{': 1},
1049
1050    # 32.
1051
1052    {'IDENT': 36},
1053
1054    # 33.
1055
1056    {'{': 2},
1057
1058    # 34.
1059
1060    {'STR': 37},
1061
1062    # 35.
1063
1064    {';': 55},
1065
1066    # 36.
1067
1068    {'{': 3},
1069
1070    # 37.
1071
1072    {';': 63},
1073
1074    # 38.
1075
1076    {';': 64},
1077
1078    # 39.
1079
1080    {'(': 14},
1081
1082    # 40.
1083
1084    {'(': 16},
1085
1086    # 41.
1087
1088    {')': 74, ',': 17},
1089
1090    # 42.
1091
1092    {')': 75},
1093
1094    # 43.
1095
1096    state_43_actions,
1097
1098    # 44.
1099
1100    state_44_actions,
1101
1102    # 45.
1103
1104    state_45_actions,
1105
1106    # 46.
1107
1108    state_46_actions,
1109
1110    # 47.
1111
1112    state_47_actions,
1113
1114    # 48.
1115
1116    state_48_actions,
1117
1118    # 49.
1119
1120    state_49_actions,
1121
1122    # 50.
1123
1124    state_50_actions,
1125
1126    # 51.
1127
1128    state_51_actions,
1129
1130    # 52.
1131
1132    state_52_actions,
1133
1134    # 53.
1135
1136    state_53_actions,
1137
1138    # 54.
1139
1140    state_54_actions,
1141
1142    # 55.
1143
1144    state_55_actions,
1145
1146    # 56.
1147
1148    state_56_actions,
1149
1150    # 57.
1151
1152    state_57_actions,
1153
1154    # 58.
1155
1156    state_58_actions,
1157
1158    # 59.
1159
1160    state_59_actions,
1161
1162    # 60.
1163
1164    state_60_actions,
1165
1166    # 61.
1167
1168    state_61_actions,
1169
1170    # 62.
1171
1172    state_62_actions,
1173
1174    # 63.
1175
1176    state_63_actions,
1177
1178    # 64.
1179
1180    state_64_actions,
1181
1182    # 65.
1183
1184    state_65_actions,
1185
1186    # 66.
1187
1188    state_66_actions,
1189
1190    # 67.
1191
1192    state_67_actions,
1193
1194    # 68.
1195
1196    state_68_actions,
1197
1198    # 69.
1199
1200    state_69_actions,
1201
1202    # 70.
1203
1204    state_70_actions,
1205
1206    # 71.
1207
1208    state_71_actions,
1209
1210    # 72.
1211
1212    state_72_actions,
1213
1214    # 73.
1215
1216    state_73_actions,
1217
1218    # 74.
1219
1220    state_74_actions,
1221
1222    # 75.
1223
1224    state_75_actions,
1225
1226    # 76.
1227
1228    state_76_actions,
1229
1230    # 77.
1231
1232    state_77_actions,
1233
1234    # 78.
1235
1236    state_78_actions,
1237
1238    # 79.
1239
1240    state_79_actions,
1241
1242    # 80.
1243
1244    state_80_actions,
1245
1246    # 81.
1247
1248    state_81_actions,
1249
1250    # 82.
1251
1252    state_82_actions,
1253
1254    # 83.
1255
1256    state_83_actions,
1257
1258    # 84.
1259
1260    state_84_actions,
1261
1262    # 85.
1263
1264    state_85_actions,
1265
1266    # 86.
1267
1268    state_86_actions,
1269
1270    # 87.
1271
1272    state_87_actions,
1273
1274    # 88.
1275
1276    state_88_actions,
1277
1278    # 89.
1279
1280    state_89_actions,
1281
1282    # 90.
1283
1284    state_90_actions,
1285
1286    # 91.
1287
1288    state_91_actions,
1289
1290    # 92.
1291
1292    state_92_actions,
1293
1294    # 93.
1295
1296    state_93_actions,
1297
1298    # 94.
1299
1300    state_94_actions,
1301
1302    # 95.
1303
1304    state_95_actions,
1305
1306    # 96.
1307
1308    state_96_actions,
1309
1310    # 97.
1311
1312    state_97_actions,
1313
1314    # 98.
1315
1316    state_98_actions,
1317
1318    # 99.
1319
1320    state_99_actions,
1321
1322    # 100.
1323
1324    state_100_actions,
1325
1326    # 101.
1327
1328    state_101_actions,
1329
1330    # 102.
1331
1332    state_102_actions,
1333
1334    # 103.
1335
1336    state_103_actions,
1337
1338    # 104.
1339
1340    state_104_actions,
1341
1342    # 105.
1343
1344    state_105_actions,
1345
1346    # 106.
1347
1348    state_106_actions,
1349
1350    # 107.
1351
1352    state_107_actions,
1353
1354    # 108.
1355
1356    state_108_actions,
1357
1358    # 109.
1359
1360    state_109_actions,
1361
1362    # 110.
1363
1364    state_110_actions,
1365
1366    # 111.
1367
1368    state_111_actions,
1369
1370]
1371
1372error_codes = [
1373    None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None,
1374    None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None,
1375    None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None,
1376    None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None,
1377    None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None,
1378    None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None,
1379    None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None,
1380]
1381
1382goal_nt_to_init_state = {'grammar': 10}
1383
1384class DefaultMethods:
1385    def nt_defs_single(self, x0):
1386        return ('nt_defs_single', x0)
1387    def single(self, x0):
1388        return ('single', x0)
1389    def nt_defs_append(self, x0, x1):
1390        return ('nt_defs_append', x0, x1)
1391    def append(self, x0, x1):
1392        return ('append', x0, x1)
1393    def nt_def(self, x0, x1, x2, x3):
1394        return ('nt_def', x0, x1, x2, x3)
1395    def ident(self, x0):
1396        return ('ident', x0)
1397    def str(self, x0):
1398        return ('str', x0)
1399    def empty(self, x0):
1400        return ('empty', x0)
1401    def var_token(self, x0):
1402        return ('var_token', x0)
1403    def prod(self, x0, x1):
1404        return ('prod', x0, x1)
1405    def optional(self, x0):
1406        return ('optional', x0)
1407    def const_token(self, x0, x1):
1408        return ('const_token', x0, x1)
1409    def expr_match(self, x0):
1410        return ('expr_match', x0)
1411    def expr_none(self, ):
1412        return ('expr_none', )
1413    def expr_call(self, x0, x1):
1414        return ('expr_call', x0, x1)
1415    def args_single(self, x0):
1416        return ('args_single', x0)
1417    def expr_some(self, x0):
1418        return ('expr_some', x0)
1419    def args_append(self, x0, x1):
1420        return ('args_append', x0, x1)
1421    def grammar(self, x0, x1):
1422        return ('grammar', x0, x1)
1423
1424class Parser(runtime.Parser):
1425    def __init__(self, goal='grammar', builder=None):
1426        if builder is None:
1427            builder = DefaultMethods()
1428        super().__init__(actions, error_codes, goal_nt_to_init_state[goal], builder)
1429
1430