louis_lifu
/
AReaL
mirror of https://github.com/inclusionAI/AReaL
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
AReaL/evaluation/latex2sympy/gen/PSParser.py

16513 lines
326 KiB
Python
Raw Blame History

# Generated from PS.g4 by ANTLR 4.11.1
# encoding: utf-8
from __future__ import print_function
import sys
from io import StringIO
from antlr4 import *
def serializedATN():
return [
4,
1,
194,
1046,
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,
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,
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,
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,
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,
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,
2,
40,
7,
40,
2,
41,
7,
41,
2,
42,
7,
42,
2,
43,
7,
43,
2,
44,
7,
44,
2,
45,
7,
45,
2,
46,
7,
46,
2,
47,
7,
47,
2,
48,
7,
48,
2,
49,
7,
49,
2,
50,
7,
50,
2,
51,
7,
51,
2,
52,
7,
52,
2,
53,
7,
53,
2,
54,
7,
54,
2,
55,
7,
55,
2,
56,
7,
56,
2,
57,
7,
57,
2,
58,
7,
58,
2,
59,
7,
59,
2,
60,
7,
60,
2,
61,
7,
61,
2,
62,
7,
62,
1,
0,
1,
0,
1,
1,
1,
1,
3,
1,
131,
8,
1,
1,
2,
1,
2,
1,
3,
1,
3,
1,
3,
1,
3,
1,
3,
1,
3,
3,
3,
141,
8,
3,
1,
4,
1,
4,
1,
4,
1,
4,
3,
4,
147,
8,
4,
1,
4,
1,
4,
1,
5,
1,
5,
1,
5,
1,
5,
1,
6,
1,
6,
1,
6,
1,
7,
1,
7,
1,
7,
3,
7,
161,
8,
7,
1,
8,
1,
8,
1,
8,
5,
8,
166,
8,
8,
10,
8,
12,
8,
169,
9,
8,
1,
9,
1,
9,
1,
9,
1,
9,
5,
9,
175,
8,
9,
10,
9,
12,
9,
178,
9,
9,
1,
9,
3,
9,
181,
8,
9,
1,
9,
1,
9,
1,
9,
1,
9,
1,
9,
1,
9,
3,
9,
189,
8,
9,
1,
9,
1,
9,
1,
9,
1,
9,
3,
9,
195,
8,
9,
1,
10,
1,
10,
1,
10,
1,
10,
5,
10,
201,
8,
10,
10,
10,
12,
10,
204,
9,
10,
1,
10,
3,
10,
207,
8,
10,
1,
10,
1,
10,
1,
11,
1,
11,
1,
11,
5,
11,
214,
8,
11,
10,
11,
12,
11,
217,
9,
11,
1,
12,
1,
12,
1,
12,
1,
12,
1,
12,
1,
12,
5,
12,
225,
8,
12,
10,
12,
12,
12,
228,
9,
12,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
3,
13,
267,
8,
13,
1,
14,
1,
14,
1,
14,
1,
14,
1,
14,
5,
14,
274,
8,
14,
10,
14,
12,
14,
277,
9,
14,
1,
14,
1,
14,
1,
14,
1,
14,
1,
14,
5,
14,
284,
8,
14,
10,
14,
12,
14,
287,
9,
14,
3,
14,
289,
8,
14,
1,
15,
1,
15,
1,
15,
1,
15,
1,
16,
1,
16,
1,
17,
1,
17,
1,
17,
1,
17,
1,
17,
1,
17,
5,
17,
303,
8,
17,
10,
17,
12,
17,
306,
9,
17,
1,
18,
1,
18,
1,
18,
1,
18,
1,
18,
1,
18,
5,
18,
314,
8,
18,
10,
18,
12,
18,
317,
9,
18,
1,
19,
1,
19,
1,
19,
1,
19,
1,
19,
1,
19,
5,
19,
325,
8,
19,
10,
19,
12,
19,
328,
9,
19,
1,
20,
1,
20,
1,
20,
4,
20,
333,
8,
20,
11,
20,
12,
20,
334,
3,
20,
337,
8,
20,
1,
21,
1,
21,
1,
21,
1,
21,
5,
21,
343,
8,
21,
10,
21,
12,
21,
346,
9,
21,
3,
21,
348,
8,
21,
1,
22,
1,
22,
5,
22,
352,
8,
22,
10,
22,
12,
22,
355,
9,
22,
1,
23,
1,
23,
5,
23,
359,
8,
23,
10,
23,
12,
23,
362,
9,
23,
1,
24,
1,
24,
1,
24,
3,
24,
367,
8,
24,
1,
25,
1,
25,
1,
25,
1,
25,
1,
25,
1,
25,
3,
25,
375,
8,
25,
1,
26,
1,
26,
1,
26,
1,
26,
3,
26,
381,
8,
26,
1,
26,
1,
26,
1,
27,
1,
27,
1,
27,
1,
27,
3,
27,
389,
8,
27,
1,
27,
1,
27,
1,
28,
1,
28,
1,
28,
1,
28,
1,
28,
1,
28,
1,
28,
1,
28,
1,
28,
1,
28,
3,
28,
403,
8,
28,
1,
28,
3,
28,
406,
8,
28,
5,
28,
408,
8,
28,
10,
28,
12,
28,
411,
9,
28,
1,
29,
1,
29,
1,
29,
1,
29,
1,
29,
1,
29,
1,
29,
1,
29,
1,
29,
1,
29,
3,
29,
423,
8,
29,
1,
29,
3,
29,
426,
8,
29,
5,
29,
428,
8,
29,
10,
29,
12,
29,
431,
9,
29,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
3,
30,
444,
8,
30,
1,
31,
1,
31,
1,
31,
1,
31,
1,
31,
1,
31,
1,
31,
1,
31,
1,
31,
1,
31,
3,
31,
456,
8,
31,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
1,
32,
3,
32,
570,
8,
32,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
33,
3,
33,
588,
8,
33,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
3,
34,
638,
8,
34,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
1,
35,
3,
35,
672,
8,
35,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
1,
36,
3,
36,
706,
8,
36,
1,
37,
1,
37,
1,
37,
1,
37,
1,
37,
1,
38,
1,
38,
1,
38,
1,
38,
3,
38,
717,
8,
38,
1,
38,
3,
38,
720,
8,
38,
1,
39,
1,
39,
1,
39,
1,
39,
3,
39,
726,
8,
39,
1,
39,
1,
39,
1,
39,
1,
39,
1,
39,
1,
39,
1,
39,
1,
39,
3,
39,
736,
8,
39,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
3,
40,
746,
8,
40,
1,
41,
1,
41,
1,
41,
1,
41,
1,
41,
1,
42,
4,
42,
754,
8,
42,
11,
42,
12,
42,
755,
1,
43,
1,
43,
1,
43,
1,
43,
1,
43,
1,
43,
1,
43,
1,
43,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
3,
44,
780,
8,
44,
1,
45,
1,
45,
1,
46,
1,
46,
1,
47,
1,
47,
1,
48,
1,
48,
1,
49,
1,
49,
1,
49,
1,
49,
1,
49,
1,
49,
3,
49,
796,
8,
49,
1,
50,
1,
50,
1,
50,
1,
50,
1,
50,
1,
50,
3,
50,
804,
8,
50,
1,
51,
1,
51,
3,
51,
808,
8,
51,
1,
51,
3,
51,
811,
8,
51,
1,
51,
3,
51,
814,
8,
51,
1,
51,
3,
51,
817,
8,
51,
3,
51,
819,
8,
51,
1,
51,
3,
51,
822,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
827,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
832,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
837,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
842,
8,
51,
1,
51,
1,
51,
3,
51,
846,
8,
51,
1,
51,
3,
51,
849,
8,
51,
1,
51,
3,
51,
852,
8,
51,
1,
51,
3,
51,
855,
8,
51,
3,
51,
857,
8,
51,
1,
51,
3,
51,
860,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
865,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
870,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
875,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
880,
8,
51,
1,
51,
1,
51,
3,
51,
884,
8,
51,
1,
51,
3,
51,
887,
8,
51,
1,
51,
1,
51,
1,
51,
1,
51,
3,
51,
893,
8,
51,
1,
51,
1,
51,
3,
51,
897,
8,
51,
1,
51,
1,
51,
3,
51,
901,
8,
51,
1,
51,
1,
51,
1,
51,
1,
51,
3,
51,
907,
8,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
3,
51,
932,
8,
51,
1,
51,
3,
51,
935,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
940,
8,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
3,
51,
947,
8,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
3,
51,
960,
8,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
1,
51,
3,
51,
970,
8,
51,
3,
51,
972,
8,
51,
1,
52,
1,
52,
1,
52,
1,
52,
1,
52,
3,
52,
979,
8,
52,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
3,
53,
989,
8,
53,
1,
54,
1,
54,
1,
54,
1,
54,
1,
54,
1,
54,
1,
54,
1,
54,
1,
54,
3,
54,
1000,
8,
54,
1,
54,
1,
54,
1,
55,
1,
55,
1,
56,
1,
56,
1,
57,
1,
57,
1,
57,
1,
57,
1,
57,
3,
57,
1013,
8,
57,
1,
58,
1,
58,
1,
59,
1,
59,
1,
59,
1,
59,
1,
59,
3,
59,
1022,
8,
59,
1,
59,
1,
59,
3,
59,
1026,
8,
59,
1,
60,
1,
60,
1,
60,
1,
60,
1,
60,
1,
60,
3,
60,
1034,
8,
60,
1,
61,
1,
61,
1,
61,
1,
61,
1,
61,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
0,
6,
24,
34,
36,
38,
56,
58,
63,
0,
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24,
26,
28,
30,
32,
34,
36,
38,
40,
42,
44,
46,
48,
50,
52,
54,
56,
58,
60,
62,
64,
66,
68,
70,
72,
74,
76,
78,
80,
82,
84,
86,
88,
90,
92,
94,
96,
98,
100,
102,
104,
106,
108,
110,
112,
114,
116,
118,
120,
122,
124,
0,
15,
2,
0,
1,
40,
154,
154,
1,
0,
41,
44,
1,
0,
181,
188,
1,
0,
182,
183,
1,
0,
47,
48,
4,
0,
49,
50,
147,
149,
153,
153,
169,
169,
1,
0,
174,
176,
3,
0,
87,
110,
124,
125,
128,
128,
2,
0,
122,
123,
126,
127,
6,
0,
111,
116,
119,
120,
129,
129,
132,
133,
135,
138,
142,
146,
4,
0,
117,
118,
130,
131,
134,
134,
139,
141,
2,
0,
51,
51,
61,
61,
2,
0,
52,
52,
62,
62,
1,
0,
85,
86,
2,
0,
176,
176,
191,
192,
1164,
0,
126,
1,
0,
0,
0,
2,
130,
1,
0,
0,
0,
4,
132,
1,
0,
0,
0,
6,
134,
1,
0,
0,
0,
8,
146,
1,
0,
0,
0,
10,
150,
1,
0,
0,
0,
12,
154,
1,
0,
0,
0,
14,
160,
1,
0,
0,
0,
16,
162,
1,
0,
0,
0,
18,
170,
1,
0,
0,
0,
20,
196,
1,
0,
0,
0,
22,
210,
1,
0,
0,
0,
24,
218,
1,
0,
0,
0,
26,
266,
1,
0,
0,
0,
28,
288,
1,
0,
0,
0,
30,
290,
1,
0,
0,
0,
32,
294,
1,
0,
0,
0,
34,
296,
1,
0,
0,
0,
36,
307,
1,
0,
0,
0,
38,
318,
1,
0,
0,
0,
40,
336,
1,
0,
0,
0,
42,
347,
1,
0,
0,
0,
44,
349,
1,
0,
0,
0,
46,
356,
1,
0,
0,
0,
48,
366,
1,
0,
0,
0,
50,
368,
1,
0,
0,
0,
52,
376,
1,
0,
0,
0,
54,
384,
1,
0,
0,
0,
56,
392,
1,
0,
0,
0,
58,
412,
1,
0,
0,
0,
60,
443,
1,
0,
0,
0,
62,
455,
1,
0,
0,
0,
64,
569,
1,
0,
0,
0,
66,
587,
1,
0,
0,
0,
68,
637,
1,
0,
0,
0,
70,
671,
1,
0,
0,
0,
72,
705,
1,
0,
0,
0,
74,
707,
1,
0,
0,
0,
76,
716,
1,
0,
0,
0,
78,
725,
1,
0,
0,
0,
80,
745,
1,
0,
0,
0,
82,
747,
1,
0,
0,
0,
84,
753,
1,
0,
0,
0,
86,
757,
1,
0,
0,
0,
88,
779,
1,
0,
0,
0,
90,
781,
1,
0,
0,
0,
92,
783,
1,
0,
0,
0,
94,
785,
1,
0,
0,
0,
96,
787,
1,
0,
0,
0,
98,
795,
1,
0,
0,
0,
100,
803,
1,
0,
0,
0,
102,
971,
1,
0,
0,
0,
104,
978,
1,
0,
0,
0,
106,
988,
1,
0,
0,
0,
108,
990,
1,
0,
0,
0,
110,
1003,
1,
0,
0,
0,
112,
1005,
1,
0,
0,
0,
114,
1012,
1,
0,
0,
0,
116,
1014,
1,
0,
0,
0,
118,
1016,
1,
0,
0,
0,
120,
1027,
1,
0,
0,
0,
122,
1035,
1,
0,
0,
0,
124,
1040,
1,
0,
0,
0,
126,
127,
7,
0,
0,
0,
127,
1,
1,
0,
0,
0,
128,
131,
3,
24,
12,
0,
129,
131,
3,
26,
13,
0,
130,
128,
1,
0,
0,
0,
130,
129,
1,
0,
0,
0,
131,
3,
1,
0,
0,
0,
132,
133,
7,
1,
0,
0,
133,
5,
1,
0,
0,
0,
134,
135,
5,
176,
0,
0,
135,
140,
5,
167,
0,
0,
136,
141,
5,
179,
0,
0,
137,
138,
5,
55,
0,
0,
138,
139,
5,
179,
0,
0,
139,
141,
5,
56,
0,
0,
140,
136,
1,
0,
0,
0,
140,
137,
1,
0,
0,
0,
141,
7,
1,
0,
0,
0,
142,
147,
3,
32,
16,
0,
143,
147,
3,
64,
32,
0,
144,
147,
5,
47,
0,
0,
145,
147,
5,
48,
0,
0,
146,
142,
1,
0,
0,
0,
146,
143,
1,
0,
0,
0,
146,
144,
1,
0,
0,
0,
146,
145,
1,
0,
0,
0,
147,
148,
1,
0,
0,
0,
148,
149,
3,
6,
3,
0,
149,
9,
1,
0,
0,
0,
150,
151,
3,
6,
3,
0,
151,
152,
5,
178,
0,
0,
152,
153,
3,
6,
3,
0,
153,
11,
1,
0,
0,
0,
154,
155,
3,
6,
3,
0,
155,
156,
3,
8,
4,
0,
156,
13,
1,
0,
0,
0,
157,
161,
3,
12,
6,
0,
158,
161,
3,
8,
4,
0,
159,
161,
3,
10,
5,
0,
160,
157,
1,
0,
0,
0,
160,
158,
1,
0,
0,
0,
160,
159,
1,
0,
0,
0,
161,
15,
1,
0,
0,
0,
162,
167,
3,
14,
7,
0,
163,
164,
5,
171,
0,
0,
164,
166,
3,
14,
7,
0,
165,
163,
1,
0,
0,
0,
166,
169,
1,
0,
0,
0,
167,
165,
1,
0,
0,
0,
167,
168,
1,
0,
0,
0,
168,
17,
1,
0,
0,
0,
169,
167,
1,
0,
0,
0,
170,
171,
5,
161,
0,
0,
171,
176,
3,
22,
11,
0,
172,
173,
5,
166,
0,
0,
173,
175,
3,
22,
11,
0,
174,
172,
1,
0,
0,
0,
175,
178,
1,
0,
0,
0,
176,
174,
1,
0,
0,
0,
176,
177,
1,
0,
0,
0,
177,
180,
1,
0,
0,
0,
178,
176,
1,
0,
0,
0,
179,
181,
5,
166,
0,
0,
180,
179,
1,
0,
0,
0,
180,
181,
1,
0,
0,
0,
181,
182,
1,
0,
0,
0,
182,
194,
5,
162,
0,
0,
183,
188,
5,
177,
0,
0,
184,
185,
5,
61,
0,
0,
185,
186,
3,
16,
8,
0,
186,
187,
5,
62,
0,
0,
187,
189,
1,
0,
0,
0,
188,
184,
1,
0,
0,
0,
188,
189,
1,
0,
0,
0,
189,
190,
1,
0,
0,
0,
190,
191,
5,
55,
0,
0,
191,
192,
3,
16,
8,
0,
192,
193,
5,
56,
0,
0,
193,
195,
1,
0,
0,
0,
194,
183,
1,
0,
0,
0,
194,
195,
1,
0,
0,
0,
195,
19,
1,
0,
0,
0,
196,
197,
5,
163,
0,
0,
197,
202,
3,
22,
11,
0,
198,
199,
5,
166,
0,
0,
199,
201,
3,
22,
11,
0,
200,
198,
1,
0,
0,
0,
201,
204,
1,
0,
0,
0,
202,
200,
1,
0,
0,
0,
202,
203,
1,
0,
0,
0,
203,
206,
1,
0,
0,
0,
204,
202,
1,
0,
0,
0,
205,
207,
5,
166,
0,
0,
206,
205,
1,
0,
0,
0,
206,
207,
1,
0,
0,
0,
207,
208,
1,
0,
0,
0,
208,
209,
5,
164,
0,
0,
209,
21,
1,
0,
0,
0,
210,
215,
3,
32,
16,
0,
211,
212,
5,
165,
0,
0,
212,
214,
3,
32,
16,
0,
213,
211,
1,
0,
0,
0,
214,
217,
1,
0,
0,
0,
215,
213,
1,
0,
0,
0,
215,
216,
1,
0,
0,
0,
216,
23,
1,
0,
0,
0,
217,
215,
1,
0,
0,
0,
218,
219,
6,
12,
-1,
0,
219,
220,
3,
32,
16,
0,
220,
226,
1,
0,
0,
0,
221,
222,
10,
2,
0,
0,
222,
223,
7,
2,
0,
0,
223,
225,
3,
24,
12,
3,
224,
221,
1,
0,
0,
0,
225,
228,
1,
0,
0,
0,
226,
224,
1,
0,
0,
0,
226,
227,
1,
0,
0,
0,
227,
25,
1,
0,
0,
0,
228,
226,
1,
0,
0,
0,
229,
267,
3,
28,
14,
0,
230,
231,
5,
61,
0,
0,
231,
232,
3,
28,
14,
0,
232,
233,
5,
62,
0,
0,
233,
267,
1,
0,
0,
0,
234,
235,
5,
55,
0,
0,
235,
236,
3,
28,
14,
0,
236,
237,
5,
56,
0,
0,
237,
267,
1,
0,
0,
0,
238,
239,
5,
57,
0,
0,
239,
240,
3,
28,
14,
0,
240,
241,
5,
58,
0,
0,
241,
267,
1,
0,
0,
0,
242,
243,
5,
78,
0,
0,
243,
244,
5,
61,
0,
0,
244,
245,
3,
28,
14,
0,
245,
246,
5,
79,
0,
0,
246,
247,
5,
62,
0,
0,
247,
267,
1,
0,
0,
0,
248,
249,
5,
78,
0,
0,
249,
250,
5,
57,
0,
0,
250,
251,
3,
28,
14,
0,
251,
252,
5,
79,
0,
0,
252,
253,
5,
58,
0,
0,
253,
267,
1,
0,
0,
0,
254,
255,
5,
80,
0,
0,
255,
256,
5,
61,
0,
0,
256,
257,
3,
28,
14,
0,
257,
258,
5,
81,
0,
0,
258,
259,
5,
62,
0,
0,
259,
267,
1,
0,
0,
0,
260,
261,
5,
80,
0,
0,
261,
262,
5,
57,
0,
0,
262,
263,
3,
28,
14,
0,
263,
264,
5,
81,
0,
0,
264,
265,
5,
58,
0,
0,
265,
267,
1,
0,
0,
0,
266,
229,
1,
0,
0,
0,
266,
230,
1,
0,
0,
0,
266,
234,
1,
0,
0,
0,
266,
238,
1,
0,
0,
0,
266,
242,
1,
0,
0,
0,
266,
248,
1,
0,
0,
0,
266,
254,
1,
0,
0,
0,
266,
260,
1,
0,
0,
0,
267,
27,
1,
0,
0,
0,
268,
269,
3,
24,
12,
0,
269,
270,
5,
171,
0,
0,
270,
275,
3,
24,
12,
0,
271,
272,
5,
171,
0,
0,
272,
274,
3,
24,
12,
0,
273,
271,
1,
0,
0,
0,
274,
277,
1,
0,
0,
0,
275,
273,
1,
0,
0,
0,
275,
276,
1,
0,
0,
0,
276,
289,
1,
0,
0,
0,
277,
275,
1,
0,
0,
0,
278,
279,
3,
24,
12,
0,
279,
280,
5,
170,
0,
0,
280,
285,
3,
24,
12,
0,
281,
282,
5,
170,
0,
0,
282,
284,
3,
24,
12,
0,
283,
281,
1,
0,
0,
0,
284,
287,
1,
0,
0,
0,
285,
283,
1,
0,
0,
0,
285,
286,
1,
0,
0,
0,
286,
289,
1,
0,
0,
0,
287,
285,
1,
0,
0,
0,
288,
268,
1,
0,
0,
0,
288,
278,
1,
0,
0,
0,
289,
29,
1,
0,
0,
0,
290,
291,
3,
32,
16,
0,
291,
292,
7,
3,
0,
0,
292,
293,
3,
32,
16,
0,
293,
31,
1,
0,
0,
0,
294,
295,
3,
34,
17,
0,
295,
33,
1,
0,
0,
0,
296,
297,
6,
17,
-1,
0,
297,
298,
3,
36,
18,
0,
298,
304,
1,
0,
0,
0,
299,
300,
10,
2,
0,
0,
300,
301,
7,
4,
0,
0,
301,
303,
3,
34,
17,
3,
302,
299,
1,
0,
0,
0,
303,
306,
1,
0,
0,
0,
304,
302,
1,
0,
0,
0,
304,
305,
1,
0,
0,
0,
305,
35,
1,
0,
0,
0,
306,
304,
1,
0,
0,
0,
307,
308,
6,
18,
-1,
0,
308,
309,
3,
40,
20,
0,
309,
315,
1,
0,
0,
0,
310,
311,
10,
2,
0,
0,
311,
312,
7,
5,
0,
0,
312,
314,
3,
36,
18,
3,
313,
310,
1,
0,
0,
0,
314,
317,
1,
0,
0,
0,
315,
313,
1,
0,
0,
0,
315,
316,
1,
0,
0,
0,
316,
37,
1,
0,
0,
0,
317,
315,
1,
0,
0,
0,
318,
319,
6,
19,
-1,
0,
319,
320,
3,
42,
21,
0,
320,
326,
1,
0,
0,
0,
321,
322,
10,
2,
0,
0,
322,
323,
7,
5,
0,
0,
323,
325,
3,
38,
19,
3,
324,
321,
1,
0,
0,
0,
325,
328,
1,
0,
0,
0,
326,
324,
1,
0,
0,
0,
326,
327,
1,
0,
0,
0,
327,
39,
1,
0,
0,
0,
328,
326,
1,
0,
0,
0,
329,
330,
7,
4,
0,
0,
330,
337,
3,
40,
20,
0,
331,
333,
3,
44,
22,
0,
332,
331,
1,
0,
0,
0,
333,
334,
1,
0,
0,
0,
334,
332,
1,
0,
0,
0,
334,
335,
1,
0,
0,
0,
335,
337,
1,
0,
0,
0,
336,
329,
1,
0,
0,
0,
336,
332,
1,
0,
0,
0,
337,
41,
1,
0,
0,
0,
338,
339,
7,
4,
0,
0,
339,
348,
3,
42,
21,
0,
340,
344,
3,
44,
22,
0,
341,
343,
3,
46,
23,
0,
342,
341,
1,
0,
0,
0,
343,
346,
1,
0,
0,
0,
344,
342,
1,
0,
0,
0,
344,
345,
1,
0,
0,
0,
345,
348,
1,
0,
0,
0,
346,
344,
1,
0,
0,
0,
347,
338,
1,
0,
0,
0,
347,
340,
1,
0,
0,
0,
348,
43,
1,
0,
0,
0,
349,
353,
3,
56,
28,
0,
350,
352,
3,
48,
24,
0,
351,
350,
1,
0,
0,
0,
352,
355,
1,
0,
0,
0,
353,
351,
1,
0,
0,
0,
353,
354,
1,
0,
0,
0,
354,
45,
1,
0,
0,
0,
355,
353,
1,
0,
0,
0,
356,
360,
3,
58,
29,
0,
357,
359,
3,
48,
24,
0,
358,
357,
1,
0,
0,
0,
359,
362,
1,
0,
0,
0,
360,
358,
1,
0,
0,
0,
360,
361,
1,
0,
0,
0,
361,
47,
1,
0,
0,
0,
362,
360,
1,
0,
0,
0,
363,
367,
5,
189,
0,
0,
364,
367,
3,
50,
25,
0,
365,
367,
3,
4,
2,
0,
366,
363,
1,
0,
0,
0,
366,
364,
1,
0,
0,
0,
366,
365,
1,
0,
0,
0,
367,
49,
1,
0,
0,
0,
368,
374,
5,
65,
0,
0,
369,
375,
3,
54,
27,
0,
370,
375,
3,
52,
26,
0,
371,
372,
3,
54,
27,
0,
372,
373,
3,
52,
26,
0,
373,
375,
1,
0,
0,
0,
374,
369,
1,
0,
0,
0,
374,
370,
1,
0,
0,
0,
374,
371,
1,
0,
0,
0,
375,
51,
1,
0,
0,
0,
376,
377,
5,
167,
0,
0,
377,
380,
5,
55,
0,
0,
378,
381,
3,
32,
16,
0,
379,
381,
3,
30,
15,
0,
380,
378,
1,
0,
0,
0,
380,
379,
1,
0,
0,
0,
381,
382,
1,
0,
0,
0,
382,
383,
5,
56,
0,
0,
383,
53,
1,
0,
0,
0,
384,
385,
5,
168,
0,
0,
385,
388,
5,
55,
0,
0,
386,
389,
3,
32,
16,
0,
387,
389,
3,
30,
15,
0,
388,
386,
1,
0,
0,
0,
388,
387,
1,
0,
0,
0,
389,
390,
1,
0,
0,
0,
390,
391,
5,
56,
0,
0,
391,
55,
1,
0,
0,
0,
392,
393,
6,
28,
-1,
0,
393,
394,
3,
60,
30,
0,
394,
409,
1,
0,
0,
0,
395,
396,
10,
2,
0,
0,
396,
402,
5,
168,
0,
0,
397,
403,
3,
80,
40,
0,
398,
399,
5,
55,
0,
0,
399,
400,
3,
32,
16,
0,
400,
401,
5,
56,
0,
0,
401,
403,
1,
0,
0,
0,
402,
397,
1,
0,
0,
0,
402,
398,
1,
0,
0,
0,
403,
405,
1,
0,
0,
0,
404,
406,
3,
118,
59,
0,
405,
404,
1,
0,
0,
0,
405,
406,
1,
0,
0,
0,
406,
408,
1,
0,
0,
0,
407,
395,
1,
0,
0,
0,
408,
411,
1,
0,
0,
0,
409,
407,
1,
0,
0,
0,
409,
410,
1,
0,
0,
0,
410,
57,
1,
0,
0,
0,
411,
409,
1,
0,
0,
0,
412,
413,
6,
29,
-1,
0,
413,
414,
3,
62,
31,
0,
414,
429,
1,
0,
0,
0,
415,
416,
10,
2,
0,
0,
416,
422,
5,
168,
0,
0,
417,
423,
3,
80,
40,
0,
418,
419,
5,
55,
0,
0,
419,
420,
3,
32,
16,
0,
420,
421,
5,
56,
0,
0,
421,
423,
1,
0,
0,
0,
422,
417,
1,
0,
0,
0,
422,
418,
1,
0,
0,
0,
423,
425,
1,
0,
0,
0,
424,
426,
3,
118,
59,
0,
425,
424,
1,
0,
0,
0,
425,
426,
1,
0,
0,
0,
426,
428,
1,
0,
0,
0,
427,
415,
1,
0,
0,
0,
428,
431,
1,
0,
0,
0,
429,
427,
1,
0,
0,
0,
429,
430,
1,
0,
0,
0,
430,
59,
1,
0,
0,
0,
431,
429,
1,
0,
0,
0,
432,
444,
3,
64,
32,
0,
433,
444,
3,
66,
33,
0,
434,
444,
3,
68,
34,
0,
435,
444,
3,
70,
35,
0,
436,
444,
3,
72,
36,
0,
437,
444,
3,
102,
51,
0,
438,
444,
3,
80,
40,
0,
439,
444,
3,
86,
43,
0,
440,
444,
3,
88,
44,
0,
441,
444,
3,
18,
9,
0,
442,
444,
3,
20,
10,
0,
443,
432,
1,
0,
0,
0,
443,
433,
1,
0,
0,
0,
443,
434,
1,
0,
0,
0,
443,
435,
1,
0,
0,
0,
443,
436,
1,
0,
0,
0,
443,
437,
1,
0,
0,
0,
443,
438,
1,
0,
0,
0,
443,
439,
1,
0,
0,
0,
443,
440,
1,
0,
0,
0,
443,
441,
1,
0,
0,
0,
443,
442,
1,
0,
0,
0,
444,
61,
1,
0,
0,
0,
445,
456,
3,
64,
32,
0,
446,
456,
3,
66,
33,
0,
447,
456,
3,
68,
34,
0,
448,
456,
3,
70,
35,
0,
449,
456,
3,
72,
36,
0,
450,
456,
3,
80,
40,
0,
451,
456,
3,
86,
43,
0,
452,
456,
3,
88,
44,
0,
453,
456,
3,
18,
9,
0,
454,
456,
3,
20,
10,
0,
455,
445,
1,
0,
0,
0,
455,
446,
1,
0,
0,
0,
455,
447,
1,
0,
0,
0,
455,
448,
1,
0,
0,
0,
455,
449,
1,
0,
0,
0,
455,
450,
1,
0,
0,
0,
455,
451,
1,
0,
0,
0,
455,
452,
1,
0,
0,
0,
455,
453,
1,
0,
0,
0,
455,
454,
1,
0,
0,
0,
456,
63,
1,
0,
0,
0,
457,
458,
5,
51,
0,
0,
458,
459,
3,
32,
16,
0,
459,
460,
5,
52,
0,
0,
460,
570,
1,
0,
0,
0,
461,
462,
5,
53,
0,
0,
462,
463,
3,
32,
16,
0,
463,
464,
5,
54,
0,
0,
464,
570,
1,
0,
0,
0,
465,
466,
5,
55,
0,
0,
466,
467,
3,
32,
16,
0,
467,
468,
5,
56,
0,
0,
468,
570,
1,
0,
0,
0,
469,
470,
5,
57,
0,
0,
470,
471,
3,
32,
16,
0,
471,
472,
5,
58,
0,
0,
472,
570,
1,
0,
0,
0,
473,
474,
5,
59,
0,
0,
474,
475,
3,
32,
16,
0,
475,
476,
5,
60,
0,
0,
476,
570,
1,
0,
0,
0,
477,
478,
5,
61,
0,
0,
478,
479,
3,
32,
16,
0,
479,
480,
5,
62,
0,
0,
480,
570,
1,
0,
0,
0,
481,
482,
5,
63,
0,
0,
482,
483,
3,
32,
16,
0,
483,
484,
5,
64,
0,
0,
484,
570,
1,
0,
0,
0,
485,
486,
5,
78,
0,
0,
486,
487,
5,
51,
0,
0,
487,
488,
3,
32,
16,
0,
488,
489,
5,
79,
0,
0,
489,
490,
5,
52,
0,
0,
490,
570,
1,
0,
0,
0,
491,
492,
5,
78,
0,
0,
492,
493,
5,
53,
0,
0,
493,
494,
3,
32,
16,
0,
494,
495,
5,
79,
0,
0,
495,
496,
5,
54,
0,
0,
496,
570,
1,
0,
0,
0,
497,
498,
5,
78,
0,
0,
498,
499,
5,
55,
0,
0,
499,
500,
3,
32,
16,
0,
500,
501,
5,
79,
0,
0,
501,
502,
5,
56,
0,
0,
502,
570,
1,
0,
0,
0,
503,
504,
5,
78,
0,
0,
504,
505,
5,
57,
0,
0,
505,
506,
3,
32,
16,
0,
506,
507,
5,
79,
0,
0,
507,
508,
5,
58,
0,
0,
508,
570,
1,
0,
0,
0,
509,
510,
5,
78,
0,
0,
510,
511,
5,
59,
0,
0,
511,
512,
3,
32,
16,
0,
512,
513,
5,
79,
0,
0,
513,
514,
5,
60,
0,
0,
514,
570,
1,
0,
0,
0,
515,
516,
5,
78,
0,
0,
516,
517,
5,
61,
0,
0,
517,
518,
3,
32,
16,
0,
518,
519,
5,
79,
0,
0,
519,
520,
5,
62,
0,
0,
520,
570,
1,
0,
0,
0,
521,
522,
5,
78,
0,
0,
522,
523,
5,
63,
0,
0,
523,
524,
3,
32,
16,
0,
524,
525,
5,
79,
0,
0,
525,
526,
5,
64,
0,
0,
526,
570,
1,
0,
0,
0,
527,
528,
5,
80,
0,
0,
528,
529,
5,
51,
0,
0,
529,
530,
3,
32,
16,
0,
530,
531,
5,
81,
0,
0,
531,
532,
5,
52,
0,
0,
532,
570,
1,
0,
0,
0,
533,
534,
5,
80,
0,
0,
534,
535,
5,
53,
0,
0,
535,
536,
3,
32,
16,
0,
536,
537,
5,
81,
0,
0,
537,
538,
5,
54,
0,
0,
538,
570,
1,
0,
0,
0,
539,
540,
5,
80,
0,
0,
540,
541,
5,
55,
0,
0,
541,
542,
3,
32,
16,
0,
542,
543,
5,
81,
0,
0,
543,
544,
5,
56,
0,
0,
544,
570,
1,
0,
0,
0,
545,
546,
5,
80,
0,
0,
546,
547,
5,
57,
0,
0,
547,
548,
3,
32,
16,
0,
548,
549,
5,
81,
0,
0,
549,
550,
5,
58,
0,
0,
550,
570,
1,
0,
0,
0,
551,
552,
5,
80,
0,
0,
552,
553,
5,
59,
0,
0,
553,
554,
3,
32,
16,
0,
554,
555,
5,
81,
0,
0,
555,
556,
5,
60,
0,
0,
556,
570,
1,
0,
0,
0,
557,
558,
5,
80,
0,
0,
558,
559,
5,
61,
0,
0,
559,
560,
3,
32,
16,
0,
560,
561,
5,
81,
0,
0,
561,
562,
5,
62,
0,
0,
562,
570,
1,
0,
0,
0,
563,
564,
5,
80,
0,
0,
564,
565,
5,
63,
0,
0,
565,
566,
3,
32,
16,
0,
566,
567,
5,
81,
0,
0,
567,
568,
5,
64,
0,
0,
568,
570,
1,
0,
0,
0,
569,
457,
1,
0,
0,
0,
569,
461,
1,
0,
0,
0,
569,
465,
1,
0,
0,
0,
569,
469,
1,
0,
0,
0,
569,
473,
1,
0,
0,
0,
569,
477,
1,
0,
0,
0,
569,
481,
1,
0,
0,
0,
569,
485,
1,
0,
0,
0,
569,
491,
1,
0,
0,
0,
569,
497,
1,
0,
0,
0,
569,
503,
1,
0,
0,
0,
569,
509,
1,
0,
0,
0,
569,
515,
1,
0,
0,
0,
569,
521,
1,
0,
0,
0,
569,
527,
1,
0,
0,
0,
569,
533,
1,
0,
0,
0,
569,
539,
1,
0,
0,
0,
569,
545,
1,
0,
0,
0,
569,
551,
1,
0,
0,
0,
569,
557,
1,
0,
0,
0,
569,
563,
1,
0,
0,
0,
570,
65,
1,
0,
0,
0,
571,
572,
5,
69,
0,
0,
572,
573,
3,
32,
16,
0,
573,
574,
5,
69,
0,
0,
574,
588,
1,
0,
0,
0,
575,
576,
5,
78,
0,
0,
576,
577,
5,
69,
0,
0,
577,
578,
3,
32,
16,
0,
578,
579,
5,
79,
0,
0,
579,
580,
5,
69,
0,
0,
580,
588,
1,
0,
0,
0,
581,
582,
5,
80,
0,
0,
582,
583,
5,
69,
0,
0,
583,
584,
3,
32,
16,
0,
584,
585,
5,
81,
0,
0,
585,
586,
5,
69,
0,
0,
586,
588,
1,
0,
0,
0,
587,
571,
1,
0,
0,
0,
587,
575,
1,
0,
0,
0,
587,
581,
1,
0,
0,
0,
588,
67,
1,
0,
0,
0,
589,
590,
5,
65,
0,
0,
590,
591,
3,
32,
16,
0,
591,
592,
5,
65,
0,
0,
592,
638,
1,
0,
0,
0,
593,
594,
5,
66,
0,
0,
594,
595,
3,
32,
16,
0,
595,
596,
5,
67,
0,
0,
596,
638,
1,
0,
0,
0,
597,
598,
5,
68,
0,
0,
598,
599,
3,
32,
16,
0,
599,
600,
5,
68,
0,
0,
600,
638,
1,
0,
0,
0,
601,
602,
5,
78,
0,
0,
602,
603,
5,
65,
0,
0,
603,
604,
3,
32,
16,
0,
604,
605,
5,
79,
0,
0,
605,
606,
5,
65,
0,
0,
606,
638,
1,
0,
0,
0,
607,
608,
5,
78,
0,
0,
608,
609,
5,
66,
0,
0,
609,
610,
3,
32,
16,
0,
610,
611,
5,
79,
0,
0,
611,
612,
5,
67,
0,
0,
612,
638,
1,
0,
0,
0,
613,
614,
5,
78,
0,
0,
614,
615,
5,
68,
0,
0,
615,
616,
3,
32,
16,
0,
616,
617,
5,
79,
0,
0,
617,
618,
5,
68,
0,
0,
618,
638,
1,
0,
0,
0,
619,
620,
5,
80,
0,
0,
620,
621,
5,
65,
0,
0,
621,
622,
3,
32,
16,
0,
622,
623,
5,
81,
0,
0,
623,
624,
5,
65,
0,
0,
624,
638,
1,
0,
0,
0,
625,
626,
5,
80,
0,
0,
626,
627,
5,
66,
0,
0,
627,
628,
3,
32,
16,
0,
628,
629,
5,
81,
0,
0,
629,
630,
5,
67,
0,
0,
630,
638,
1,
0,
0,
0,
631,
632,
5,
80,
0,
0,
632,
633,
5,
68,
0,
0,
633,
634,
3,
32,
16,
0,
634,
635,
5,
81,
0,
0,
635,
636,
5,
68,
0,
0,
636,
638,
1,
0,
0,
0,
637,
589,
1,
0,
0,
0,
637,
593,
1,
0,
0,
0,
637,
597,
1,
0,
0,
0,
637,
601,
1,
0,
0,
0,
637,
607,
1,
0,
0,
0,
637,
613,
1,
0,
0,
0,
637,
619,
1,
0,
0,
0,
637,
625,
1,
0,
0,
0,
637,
631,
1,
0,
0,
0,
638,
69,
1,
0,
0,
0,
639,
640,
5,
70,
0,
0,
640,
641,
3,
32,
16,
0,
641,
642,
5,
71,
0,
0,
642,
672,
1,
0,
0,
0,
643,
644,
5,
72,
0,
0,
644,
645,
3,
32,
16,
0,
645,
646,
5,
73,
0,
0,
646,
672,
1,
0,
0,
0,
647,
648,
5,
78,
0,
0,
648,
649,
5,
70,
0,
0,
649,
650,
3,
32,
16,
0,
650,
651,
5,
79,
0,
0,
651,
652,
5,
71,
0,
0,
652,
672,
1,
0,
0,
0,
653,
654,
5,
78,
0,
0,
654,
655,
5,
72,
0,
0,
655,
656,
3,
32,
16,
0,
656,
657,
5,
79,
0,
0,
657,
658,
5,
73,
0,
0,
658,
672,
1,
0,
0,
0,
659,
660,
5,
80,
0,
0,
660,
661,
5,
70,
0,
0,
661,
662,
3,
32,
16,
0,
662,
663,
5,
81,
0,
0,
663,
664,
5,
71,
0,
0,
664,
672,
1,
0,
0,
0,
665,
666,
5,
80,
0,
0,
666,
667,
5,
72,
0,
0,
667,
668,
3,
32,
16,
0,
668,
669,
5,
81,
0,
0,
669,
670,
5,
73,
0,
0,
670,
672,
1,
0,
0,
0,
671,
639,
1,
0,
0,
0,
671,
643,
1,
0,
0,
0,
671,
647,
1,
0,
0,
0,
671,
653,
1,
0,
0,
0,
671,
659,
1,
0,
0,
0,
671,
665,
1,
0,
0,
0,
672,
71,
1,
0,
0,
0,
673,
674,
5,
74,
0,
0,
674,
675,
3,
32,
16,
0,
675,
676,
5,
75,
0,
0,
676,
706,
1,
0,
0,
0,
677,
678,
5,
76,
0,
0,
678,
679,
3,
32,
16,
0,
679,
680,
5,
77,
0,
0,
680,
706,
1,
0,
0,
0,
681,
682,
5,
78,
0,
0,
682,
683,
5,
74,
0,
0,
683,
684,
3,
32,
16,
0,
684,
685,
5,
79,
0,
0,
685,
686,
5,
75,
0,
0,
686,
706,
1,
0,
0,
0,
687,
688,
5,
78,
0,
0,
688,
689,
5,
76,
0,
0,
689,
690,
3,
32,
16,
0,
690,
691,
5,
79,
0,
0,
691,
692,
5,
77,
0,
0,
692,
706,
1,
0,
0,
0,
693,
694,
5,
80,
0,
0,
694,
695,
5,
74,
0,
0,
695,
696,
3,
32,
16,
0,
696,
697,
5,
81,
0,
0,
697,
698,
5,
75,
0,
0,
698,
706,
1,
0,
0,
0,
699,
700,
5,
80,
0,
0,
700,
701,
5,
76,
0,
0,
701,
702,
3,
32,
16,
0,
702,
703,
5,
81,
0,
0,
703,
704,
5,
77,
0,
0,
704,
706,
1,
0,
0,
0,
705,
673,
1,
0,
0,
0,
705,
677,
1,
0,
0,
0,
705,
681,
1,
0,
0,
0,
705,
687,
1,
0,
0,
0,
705,
693,
1,
0,
0,
0,
705,
699,
1,
0,
0,
0,
706,
73,
1,
0,
0,
0,
707,
708,
3,
0,
0,
0,
708,
709,
5,
55,
0,
0,
709,
710,
3,
32,
16,
0,
710,
711,
5,
56,
0,
0,
711,
75,
1,
0,
0,
0,
712,
717,
5,
176,
0,
0,
713,
717,
5,
191,
0,
0,
714,
717,
5,
192,
0,
0,
715,
717,
3,
74,
37,
0,
716,
712,
1,
0,
0,
0,
716,
713,
1,
0,
0,
0,
716,
714,
1,
0,
0,
0,
716,
715,
1,
0,
0,
0,
717,
719,
1,
0,
0,
0,
718,
720,
3,
118,
59,
0,
719,
718,
1,
0,
0,
0,
719,
720,
1,
0,
0,
0,
720,
77,
1,
0,
0,
0,
721,
726,
5,
176,
0,
0,
722,
726,
5,
191,
0,
0,
723,
726,
5,
192,
0,
0,
724,
726,
3,
74,
37,
0,
725,
721,
1,
0,
0,
0,
725,
722,
1,
0,
0,
0,
725,
723,
1,
0,
0,
0,
725,
724,
1,
0,
0,
0,
726,
735,
1,
0,
0,
0,
727,
728,
3,
120,
60,
0,
728,
729,
3,
118,
59,
0,
729,
736,
1,
0,
0,
0,
730,
731,
3,
118,
59,
0,
731,
732,
3,
120,
60,
0,
732,
736,
1,
0,
0,
0,
733,
736,
3,
118,
59,
0,
734,
736,
3,
120,
60,
0,
735,
727,
1,
0,
0,
0,
735,
730,
1,
0,
0,
0,
735,
733,
1,
0,
0,
0,
735,
734,
1,
0,
0,
0,
735,
736,
1,
0,
0,
0,
736,
79,
1,
0,
0,
0,
737,
746,
3,
78,
39,
0,
738,
746,
5,
193,
0,
0,
739,
746,
5,
179,
0,
0,
740,
746,
5,
190,
0,
0,
741,
746,
5,
180,
0,
0,
742,
746,
5,
173,
0,
0,
743,
746,
3,
82,
41,
0,
744,
746,
5,
194,
0,
0,
745,
737,
1,
0,
0,
0,
745,
738,
1,
0,
0,
0,
745,
739,
1,
0,
0,
0,
745,
740,
1,
0,
0,
0,
745,
741,
1,
0,
0,
0,
745,
742,
1,
0,
0,
0,
745,
743,
1,
0,
0,
0,
745,
744,
1,
0,
0,
0,
746,
81,
1,
0,
0,
0,
747,
748,
5,
154,
0,
0,
748,
749,
5,
55,
0,
0,
749,
750,
3,
84,
42,
0,
750,
751,
5,
56,
0,
0,
751,
83,
1,
0,
0,
0,
752,
754,
7,
6,
0,
0,
753,
752,
1,
0,
0,
0,
754,
755,
1,
0,
0,
0,
755,
753,
1,
0,
0,
0,
755,
756,
1,
0,
0,
0,
756,
85,
1,
0,
0,
0,
757,
758,
5,
150,
0,
0,
758,
759,
5,
55,
0,
0,
759,
760,
3,
32,
16,
0,
760,
761,
5,
56,
0,
0,
761,
762,
5,
55,
0,
0,
762,
763,
3,
32,
16,
0,
763,
764,
5,
56,
0,
0,
764,
87,
1,
0,
0,
0,
765,
766,
5,
55,
0,
0,
766,
767,
3,
32,
16,
0,
767,
768,
5,
152,
0,
0,
768,
769,
3,
32,
16,
0,
769,
770,
5,
56,
0,
0,
770,
780,
1,
0,
0,
0,
771,
772,
5,
151,
0,
0,
772,
773,
5,
55,
0,
0,
773,
774,
3,
32,
16,
0,
774,
775,
5,
56,
0,
0,
775,
776,
5,
55,
0,
0,
776,
777,
3,
32,
16,
0,
777,
778,
5,
56,
0,
0,
778,
780,
1,
0,
0,
0,
779,
765,
1,
0,
0,
0,
779,
771,
1,
0,
0,
0,
780,
89,
1,
0,
0,
0,
781,
782,
7,
7,
0,
0,
782,
91,
1,
0,
0,
0,
783,
784,
7,
8,
0,
0,
784,
93,
1,
0,
0,
0,
785,
786,
7,
9,
0,
0,
786,
95,
1,
0,
0,
0,
787,
788,
7,
10,
0,
0,
788,
97,
1,
0,
0,
0,
789,
796,
3,
90,
45,
0,
790,
791,
5,
155,
0,
0,
791,
792,
5,
55,
0,
0,
792,
793,
3,
94,
47,
0,
793,
794,
5,
56,
0,
0,
794,
796,
1,
0,
0,
0,
795,
789,
1,
0,
0,
0,
795,
790,
1,
0,
0,
0,
796,
99,
1,
0,
0,
0,
797,
804,
3,
92,
46,
0,
798,
799,
5,
155,
0,
0,
799,
800,
5,
55,
0,
0,
800,
801,
3,
96,
48,
0,
801,
802,
5,
56,
0,
0,
802,
804,
1,
0,
0,
0,
803,
797,
1,
0,
0,
0,
803,
798,
1,
0,
0,
0,
804,
101,
1,
0,
0,
0,
805,
818,
3,
98,
49,
0,
806,
808,
3,
118,
59,
0,
807,
806,
1,
0,
0,
0,
807,
808,
1,
0,
0,
0,
808,
810,
1,
0,
0,
0,
809,
811,
3,
120,
60,
0,
810,
809,
1,
0,
0,
0,
810,
811,
1,
0,
0,
0,
811,
819,
1,
0,
0,
0,
812,
814,
3,
120,
60,
0,
813,
812,
1,
0,
0,
0,
813,
814,
1,
0,
0,
0,
814,
816,
1,
0,
0,
0,
815,
817,
3,
118,
59,
0,
816,
815,
1,
0,
0,
0,
816,
817,
1,
0,
0,
0,
817,
819,
1,
0,
0,
0,
818,
807,
1,
0,
0,
0,
818,
813,
1,
0,
0,
0,
819,
841,
1,
0,
0,
0,
820,
822,
5,
78,
0,
0,
821,
820,
1,
0,
0,
0,
821,
822,
1,
0,
0,
0,
822,
823,
1,
0,
0,
0,
823,
824,
5,
51,
0,
0,
824,
826,
3,
110,
55,
0,
825,
827,
5,
79,
0,
0,
826,
825,
1,
0,
0,
0,
826,
827,
1,
0,
0,
0,
827,
828,
1,
0,
0,
0,
828,
829,
5,
52,
0,
0,
829,
842,
1,
0,
0,
0,
830,
832,
5,
80,
0,
0,
831,
830,
1,
0,
0,
0,
831,
832,
1,
0,
0,
0,
832,
833,
1,
0,
0,
0,
833,
834,
5,
51,
0,
0,
834,
836,
3,
110,
55,
0,
835,
837,
5,
81,
0,
0,
836,
835,
1,
0,
0,
0,
836,
837,
1,
0,
0,
0,
837,
838,
1,
0,
0,
0,
838,
839,
5,
52,
0,
0,
839,
842,
1,
0,
0,
0,
840,
842,
3,
112,
56,
0,
841,
821,
1,
0,
0,
0,
841,
831,
1,
0,
0,
0,
841,
840,
1,
0,
0,
0,
842,
972,
1,
0,
0,
0,
843,
856,
3,
100,
50,
0,
844,
846,
3,
118,
59,
0,
845,
844,
1,
0,
0,
0,
845,
846,
1,
0,
0,
0,
846,
848,
1,
0,
0,
0,
847,
849,
3,
120,
60,
0,
848,
847,
1,
0,
0,
0,
848,
849,
1,
0,
0,
0,
849,
857,
1,
0,
0,
0,
850,
852,
3,
120,
60,
0,
851,
850,
1,
0,
0,
0,
851,
852,
1,
0,
0,
0,
852,
854,
1,
0,
0,
0,
853,
855,
3,
118,
59,
0,
854,
853,
1,
0,
0,
0,
854,
855,
1,
0,
0,
0,
855,
857,
1,
0,
0,
0,
856,
845,
1,
0,
0,
0,
856,
851,
1,
0,
0,
0,
857,
879,
1,
0,
0,
0,
858,
860,
5,
78,
0,
0,
859,
858,
1,
0,
0,
0,
859,
860,
1,
0,
0,
0,
860,
861,
1,
0,
0,
0,
861,
862,
5,
51,
0,
0,
862,
864,
3,
114,
57,
0,
863,
865,
5,
79,
0,
0,
864,
863,
1,
0,
0,
0,
864,
865,
1,
0,
0,
0,
865,
866,
1,
0,
0,
0,
866,
867,
5,
52,
0,
0,
867,
880,
1,
0,
0,
0,
868,
870,
5,
80,
0,
0,
869,
868,
1,
0,
0,
0,
869,
870,
1,
0,
0,
0,
870,
871,
1,
0,
0,
0,
871,
872,
5,
51,
0,
0,
872,
874,
3,
114,
57,
0,
873,
875,
5,
81,
0,
0,
874,
873,
1,
0,
0,
0,
874,
875,
1,
0,
0,
0,
875,
876,
1,
0,
0,
0,
876,
877,
5,
52,
0,
0,
877,
880,
1,
0,
0,
0,
878,
880,
3,
116,
58,
0,
879,
859,
1,
0,
0,
0,
879,
869,
1,
0,
0,
0,
879,
878,
1,
0,
0,
0,
880,
972,
1,
0,
0,
0,
881,
883,
3,
76,
38,
0,
882,
884,
3,
120,
60,
0,
883,
882,
1,
0,
0,
0,
883,
884,
1,
0,
0,
0,
884,
886,
1,
0,
0,
0,
885,
887,
5,
78,
0,
0,
886,
885,
1,
0,
0,
0,
886,
887,
1,
0,
0,
0,
887,
888,
1,
0,
0,
0,
888,
889,
7,
11,
0,
0,
889,
890,
3,
106,
53,
0,
890,
892,
7,
12,
0,
0,
891,
893,
5,
79,
0,
0,
892,
891,
1,
0,
0,
0,
892,
893,
1,
0,
0,
0,
893,
972,
1,
0,
0,
0,
894,
896,
3,
76,
38,
0,
895,
897,
3,
120,
60,
0,
896,
895,
1,
0,
0,
0,
896,
897,
1,
0,
0,
0,
897,
898,
1,
0,
0,
0,
898,
900,
5,
55,
0,
0,
899,
901,
5,
78,
0,
0,
900,
899,
1,
0,
0,
0,
900,
901,
1,
0,
0,
0,
901,
902,
1,
0,
0,
0,
902,
903,
7,
11,
0,
0,
903,
904,
3,
106,
53,
0,
904,
906,
7,
12,
0,
0,
905,
907,
5,
79,
0,
0,
906,
905,
1,
0,
0,
0,
906,
907,
1,
0,
0,
0,
907,
908,
1,
0,
0,
0,
908,
909,
5,
56,
0,
0,
909,
972,
1,
0,
0,
0,
910,
931,
5,
84,
0,
0,
911,
912,
3,
118,
59,
0,
912,
913,
3,
120,
60,
0,
913,
932,
1,
0,
0,
0,
914,
915,
3,
120,
60,
0,
915,
916,
3,
118,
59,
0,
916,
932,
1,
0,
0,
0,
917,
918,
5,
167,
0,
0,
918,
919,
5,
55,
0,
0,
919,
920,
5,
56,
0,
0,
920,
921,
1,
0,
0,
0,
921,
922,
5,
168,
0,
0,
922,
923,
5,
55,
0,
0,
923,
932,
5,
56,
0,
0,
924,
925,
5,
168,
0,
0,
925,
926,
5,
55,
0,
0,
926,
927,
5,
56,
0,
0,
927,
928,
1,
0,
0,
0,
928,
929,
5,
167,
0,
0,
929,
930,
5,
55,
0,
0,
930,
932,
5,
56,
0,
0,
931,
911,
1,
0,
0,
0,
931,
914,
1,
0,
0,
0,
931,
917,
1,
0,
0,
0,
931,
924,
1,
0,
0,
0,
931,
932,
1,
0,
0,
0,
932,
939,
1,
0,
0,
0,
933,
935,
3,
34,
17,
0,
934,
933,
1,
0,
0,
0,
934,
935,
1,
0,
0,
0,
935,
936,
1,
0,
0,
0,
936,
940,
5,
173,
0,
0,
937,
940,
3,
86,
43,
0,
938,
940,
3,
34,
17,
0,
939,
934,
1,
0,
0,
0,
939,
937,
1,
0,
0,
0,
939,
938,
1,
0,
0,
0,
940,
972,
1,
0,
0,
0,
941,
946,
5,
121,
0,
0,
942,
943,
5,
61,
0,
0,
943,
944,
3,
32,
16,
0,
944,
945,
5,
62,
0,
0,
945,
947,
1,
0,
0,
0,
946,
942,
1,
0,
0,
0,
946,
947,
1,
0,
0,
0,
947,
948,
1,
0,
0,
0,
948,
949,
5,
55,
0,
0,
949,
950,
3,
32,
16,
0,
950,
951,
5,
56,
0,
0,
951,
972,
1,
0,
0,
0,
952,
959,
7,
13,
0,
0,
953,
954,
3,
122,
61,
0,
954,
955,
3,
120,
60,
0,
955,
960,
1,
0,
0,
0,
956,
957,
3,
120,
60,
0,
957,
958,
3,
122,
61,
0,
958,
960,
1,
0,
0,
0,
959,
953,
1,
0,
0,
0,
959,
956,
1,
0,
0,
0,
960,
961,
1,
0,
0,
0,
961,
962,
3,
36,
18,
0,
962,
972,
1,
0,
0,
0,
963,
964,
5,
82,
0,
0,
964,
965,
3,
108,
54,
0,
965,
966,
3,
36,
18,
0,
966,
972,
1,
0,
0,
0,
967,
969,
5,
174,
0,
0,
968,
970,
3,
120,
60,
0,
969,
968,
1,
0,
0,
0,
969,
970,
1,
0,
0,
0,
970,
972,
1,
0,
0,
0,
971,
805,
1,
0,
0,
0,
971,
843,
1,
0,
0,
0,
971,
881,
1,
0,
0,
0,
971,
894,
1,
0,
0,
0,
971,
910,
1,
0,
0,
0,
971,
941,
1,
0,
0,
0,
971,
952,
1,
0,
0,
0,
971,
963,
1,
0,
0,
0,
971,
967,
1,
0,
0,
0,
972,
103,
1,
0,
0,
0,
973,
974,
3,
32,
16,
0,
974,
975,
5,
171,
0,
0,
975,
976,
3,
104,
52,
0,
976,
979,
1,
0,
0,
0,
977,
979,
3,
32,
16,
0,
978,
973,
1,
0,
0,
0,
978,
977,
1,
0,
0,
0,
979,
105,
1,
0,
0,
0,
980,
989,
3,
80,
40,
0,
981,
982,
3,
32,
16,
0,
982,
983,
5,
171,
0,
0,
983,
989,
1,
0,
0,
0,
984,
985,
3,
32,
16,
0,
985,
986,
5,
171,
0,
0,
986,
987,
3,
104,
52,
0,
987,
989,
1,
0,
0,
0,
988,
980,
1,
0,
0,
0,
988,
981,
1,
0,
0,
0,
988,
984,
1,
0,
0,
0,
989,
107,
1,
0,
0,
0,
990,
991,
5,
167,
0,
0,
991,
992,
5,
55,
0,
0,
992,
993,
7,
14,
0,
0,
993,
994,
5,
83,
0,
0,
994,
999,
3,
32,
16,
0,
995,
996,
5,
168,
0,
0,
996,
997,
5,
55,
0,
0,
997,
998,
7,
4,
0,
0,
998,
1000,
5,
56,
0,
0,
999,
995,
1,
0,
0,
0,
999,
1000,
1,
0,
0,
0,
1000,
1001,
1,
0,
0,
0,
1001,
1002,
5,
56,
0,
0,
1002,
109,
1,
0,
0,
0,
1003,
1004,
3,
32,
16,
0,
1004,
111,
1,
0,
0,
0,
1005,
1006,
3,
38,
19,
0,
1006,
113,
1,
0,
0,
0,
1007,
1013,
3,
32,
16,
0,
1008,
1009,
3,
32,
16,
0,
1009,
1010,
5,
171,
0,
0,
1010,
1011,
3,
114,
57,
0,
1011,
1013,
1,
0,
0,
0,
1012,
1007,
1,
0,
0,
0,
1012,
1008,
1,
0,
0,
0,
1013,
115,
1,
0,
0,
0,
1014,
1015,
3,
38,
19,
0,
1015,
117,
1,
0,
0,
0,
1016,
1025,
5,
167,
0,
0,
1017,
1026,
3,
80,
40,
0,
1018,
1021,
5,
55,
0,
0,
1019,
1022,
3,
32,
16,
0,
1020,
1022,
3,
104,
52,
0,
1021,
1019,
1,
0,
0,
0,
1021,
1020,
1,
0,
0,
0,
1022,
1023,
1,
0,
0,
0,
1023,
1024,
5,
56,
0,
0,
1024,
1026,
1,
0,
0,
0,
1025,
1017,
1,
0,
0,
0,
1025,
1018,
1,
0,
0,
0,
1026,
119,
1,
0,
0,
0,
1027,
1033,
5,
168,
0,
0,
1028,
1034,
3,
80,
40,
0,
1029,
1030,
5,
55,
0,
0,
1030,
1031,
3,
32,
16,
0,
1031,
1032,
5,
56,
0,
0,
1032,
1034,
1,
0,
0,
0,
1033,
1028,
1,
0,
0,
0,
1033,
1029,
1,
0,
0,
0,
1034,
121,
1,
0,
0,
0,
1035,
1036,
5,
167,
0,
0,
1036,
1037,
5,
55,
0,
0,
1037,
1038,
3,
30,
15,
0,
1038,
1039,
5,
56,
0,
0,
1039,
123,
1,
0,
0,
0,
1040,
1041,
5,
167,
0,
0,
1041,
1042,
5,
55,
0,
0,
1042,
1043,
3,
30,
15,
0,
1043,
1044,
5,
56,
0,
0,
1044,
125,
1,
0,
0,
0,
92,
130,
140,
146,
160,
167,
176,
180,
188,
194,
202,
206,
215,
226,
266,
275,
285,
288,
304,
315,
326,
334,
336,
344,
347,
353,
360,
366,
374,
380,
388,
402,
405,
409,
422,
425,
429,
443,
455,
569,
587,
637,
671,
705,
716,
719,
725,
735,
745,
755,
779,
795,
803,
807,
810,
813,
816,
818,
821,
826,
831,
836,
841,
845,
848,
851,
854,
856,
859,
864,
869,
874,
879,
883,
886,
892,
896,
900,
906,
931,
934,
939,
946,
959,
969,
971,
978,
988,
999,
1012,
1021,
1025,
1033,
]
class PSParser(Parser):
grammarFileName = "PS.g4"
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]
sharedContextCache = PredictionContextCache()
literalNames = [
"<INVALID>",
"'\\acute'",
"'\\bar'",
"'\\overline'",
"'\\breve'",
"'\\check'",
"'\\widecheck'",
"'\\dot'",
"'\\ddot'",
"'\\grave'",
"'\\hat'",
"'\\tilde'",
"'\\widetilde'",
"'\\vec'",
"'\\overrightarrow'",
"'\\bm'",
"'\\boldsymbol'",
"'\\text'",
"'\\textit'",
"'\\mathbb'",
"'\\mathbin'",
"'\\mathbf'",
"'\\mathcal'",
"'\\mathclap'",
"'\\mathclose'",
"'\\mathellipsis'",
"'\\mathfrak'",
"'\\mathinner'",
"'\\mathnormal'",
"'\\mathop'",
"'\\mathopen'",
"'\\mathord'",
"'\\mathpunct'",
"'\\mathrel'",
"'\\mathring'",
"'\\mathrlap'",
"'\\mathrm'",
"'\\mathscr'",
"'\\mathsf'",
"'\\mathsterling'",
"'\\mathtt'",
"'^T'",
"'^{T}'",
"'^{\\top}'",
"'''",
"<INVALID>",
"'\\$'",
"'+'",
"'-'",
"'*'",
"<INVALID>",
"'('",
"')'",
"'\\lgroup'",
"'\\rgroup'",
"'{'",
"'}'",
"'\\{'",
"'\\}'",
"'\\lbrace'",
"'\\rbrace'",
"'['",
"']'",
"'\\lbrack'",
"'\\rbrack'",
"'|'",
"'\\lvert'",
"'\\rvert'",
"'\\vert'",
"'\\|'",
"'\\lfloor'",
"'\\rfloor'",
"'\\llcorner'",
"'\\lrcorner'",
"'\\lceil'",
"'\\rceil'",
"'\\ulcorner'",
"'\\urcorner'",
"'\\left'",
"'\\right'",
"'\\mleft'",
"'\\mright'",
"'\\lim'",
"<INVALID>",
"'\\int'",
"'\\sum'",
"'\\prod'",
"'\\log'",
"'\\ln'",
"'\\exp'",
"'\\sin'",
"'\\cos'",
"'\\tan'",
"'\\csc'",
"'\\sec'",
"'\\cot'",
"'\\arcsin'",
"'\\arccos'",
"'\\arctan'",
"'\\arccsc'",
"'\\arcsec'",
"'\\arccot'",
"'\\sinh'",
"'\\cosh'",
"'\\tanh'",
"'\\arsinh'",
"'\\arcosh'",
"'\\artanh'",
"'\\arcsinh'",
"'\\arccosh'",
"'\\arctanh'",
"'arsinh'",
"'arcsinh'",
"'arcosh'",
"'arccosh'",
"'artanh'",
"'arctanh'",
"'gcd'",
"'lcm'",
"'floor'",
"'ceil'",
"'\\sqrt'",
"'\\gcd'",
"'\\lcm'",
"'\\floor'",
"'\\ceil'",
"'\\max'",
"'\\min'",
"'\\det'",
"'eye'",
"'zeros'",
"'ones'",
"'cols'",
"'rows'",
"'diag'",
"'norm'",
"'rank'",
"<INVALID>",
"'rref'",
"'hstack'",
"'vstack'",
"<INVALID>",
"'nullspace'",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"'\\times'",
"'\\cdot'",
"'\\div'",
"'\\frac'",
"<INVALID>",
"'\\choose'",
"'\\mod'",
"'\\mathit'",
"'\\operatorname'",
"'matrix'",
"'pmatrix'",
"'bmatrix'",
"'vmatrix'",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"'&'",
"'\\\\'",
"'_'",
"'^'",
"':'",
"';'",
"','",
"'.'",
"<INVALID>",
"<INVALID>",
"'E'",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"'\\in'",
"'='",
"<INVALID>",
"'<'",
"<INVALID>",
"'>'",
"<INVALID>",
"<INVALID>",
"'!'",
]
symbolicNames = [
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"WS",
"DOLLAR_SIGN",
"ADD",
"SUB",
"MUL",
"DIV",
"L_PAREN",
"R_PAREN",
"L_GROUP",
"R_GROUP",
"L_BRACE",
"R_BRACE",
"L_BRACE_VISUAL",
"R_BRACE_VISUAL",
"L_BRACE_CMD",
"R_BRACE_CMD",
"L_BRACKET",
"R_BRACKET",
"L_BRACK",
"R_BRACK",
"BAR",
"L_VERT",
"R_VERT",
"VERT",
"NORM",
"L_FLOOR",
"R_FLOOR",
"LL_CORNER",
"LR_CORNER",
"L_CEIL",
"R_CEIL",
"UL_CORNER",
"UR_CORNER",
"L_LEFT",
"R_RIGHT",
"ML_LEFT",
"MR_RIGHT",
"FUNC_LIM",
"LIM_APPROACH_SYM",
"FUNC_INT",
"FUNC_SUM",
"FUNC_PROD",
"FUNC_LOG",
"FUNC_LN",
"FUNC_EXP",
"FUNC_SIN",
"FUNC_COS",
"FUNC_TAN",
"FUNC_CSC",
"FUNC_SEC",
"FUNC_COT",
"FUNC_ARCSIN",
"FUNC_ARCCOS",
"FUNC_ARCTAN",
"FUNC_ARCCSC",
"FUNC_ARCSEC",
"FUNC_ARCCOT",
"FUNC_SINH",
"FUNC_COSH",
"FUNC_TANH",
"FUNC_ARSINH",
"FUNC_ARCOSH",
"FUNC_ARTANH",
"FUNC_ARCSINH",
"FUNC_ARCCOSH",
"FUNC_ARCTANH",
"FUNC_ARSINH_NAME",
"FUNC_ARCSINH_NAME",
"FUNC_ARCOSH_NAME",
"FUNC_ARCCOSH_NAME",
"FUNC_ARTANH_NAME",
"FUNC_ARCTANH_NAME",
"FUNC_GCD_NAME",
"FUNC_LCM_NAME",
"FUNC_FLOOR_NAME",
"FUNC_CEIL_NAME",
"FUNC_SQRT",
"FUNC_GCD",
"FUNC_LCM",
"FUNC_FLOOR",
"FUNC_CEIL",
"FUNC_MAX",
"FUNC_MIN",
"FUNC_DET",
"FUNC_EYE_NAME",
"FUNC_ZEROS_NAME",
"FUNC_ONES_NAME",
"FUNC_COLS_NAME",
"FUNC_ROWS_NAME",
"FUNC_DIAG_NAME",
"FUNC_NORM_NAME",
"FUNC_RANK_NAME",
"FUNC_TRACE_NAME",
"FUNC_RREF_NAME",
"FUNC_HSTACK_NAME",
"FUNC_VSTACK_NAME",
"FUNC_ORTHOGONALIZE_NAME",
"FUNC_NULLSPACE_NAME",
"FUNC_DIAGONALIZE_NAME",
"FUNC_EIGENVALS_NAME",
"FUNC_EIGENVECTORS_NAME",
"FUNC_SVD_NAME",
"CMD_TIMES",
"CMD_CDOT",
"CMD_DIV",
"CMD_FRAC",
"CMD_BINOM",
"CMD_CHOOSE",
"CMD_MOD",
"CMD_MATHIT",
"CMD_OPERATORNAME",
"MATRIX_TYPE_MATRIX",
"MATRIX_TYPE_PMATRIX",
"MATRIX_TYPE_BMATRIX",
"MATRIX_TYPE_DET",
"MATRIX_TYPES",
"CMD_MATRIX_START",
"CMD_MATRIX_END",
"CMD_DET_START",
"CMD_DET_END",
"MATRIX_DEL_COL",
"MATRIX_DEL_ROW",
"UNDERSCORE",
"CARET",
"COLON",
"SEMICOLON",
"COMMA",
"PERIOD",
"DIFFERENTIAL",
"EXP_E",
"E_NOTATION_E",
"LETTER_NO_E",
"MATRIX_XRIGHTARROW",
"TRANSFORM_EXCHANGE",
"NUMBER",
"E_NOTATION",
"IN",
"ASSIGNMENT",
"EQUAL",
"LT",
"LTE",
"GT",
"GTE",
"UNEQUAL",
"BANG",
"PERCENT_NUMBER",
"GREEK_CMD",
"OTHER_SYMBOL_CMD",
"SYMBOL",
"VARIABLE",
]
RULE_accent_symbol = 0
RULE_math = 1
RULE_transpose = 2
RULE_transform_atom = 3
RULE_transform_scale = 4
RULE_transform_swap = 5
RULE_transform_assignment = 6
RULE_elementary_transform = 7
RULE_elementary_transforms = 8
RULE_matrix = 9
RULE_det = 10
RULE_matrix_row = 11
RULE_relation = 12
RULE_relation_list = 13
RULE_relation_list_content = 14
RULE_equality = 15
RULE_expr = 16
RULE_additive = 17
RULE_mp = 18
RULE_mp_nofunc = 19
RULE_unary = 20
RULE_unary_nofunc = 21
RULE_postfix = 22
RULE_postfix_nofunc = 23
RULE_postfix_op = 24
RULE_eval_at = 25
RULE_eval_at_sub = 26
RULE_eval_at_sup = 27
RULE_exp = 28
RULE_exp_nofunc = 29
RULE_comp = 30
RULE_comp_nofunc = 31
RULE_group = 32
RULE_norm_group = 33
RULE_abs_group = 34
RULE_floor_group = 35
RULE_ceil_group = 36
RULE_accent = 37
RULE_atom_expr_no_supexpr = 38
RULE_atom_expr = 39
RULE_atom = 40
RULE_mathit = 41
RULE_mathit_text = 42
RULE_frac = 43
RULE_binom = 44
RULE_func_normal_functions_single_arg = 45
RULE_func_normal_functions_multi_arg = 46
RULE_func_operator_names_single_arg = 47
RULE_func_operator_names_multi_arg = 48
RULE_func_normal_single_arg = 49
RULE_func_normal_multi_arg = 50
RULE_func = 51
RULE_args = 52
RULE_func_common_args = 53
RULE_limit_sub = 54
RULE_func_single_arg = 55
RULE_func_single_arg_noparens = 56
RULE_func_multi_arg = 57
RULE_func_multi_arg_noparens = 58
RULE_subexpr = 59
RULE_supexpr = 60
RULE_subeq = 61
RULE_supeq = 62
ruleNames = [
"accent_symbol",
"math",
"transpose",
"transform_atom",
"transform_scale",
"transform_swap",
"transform_assignment",
"elementary_transform",
"elementary_transforms",
"matrix",
"det",
"matrix_row",
"relation",
"relation_list",
"relation_list_content",
"equality",
"expr",
"additive",
"mp",
"mp_nofunc",
"unary",
"unary_nofunc",
"postfix",
"postfix_nofunc",
"postfix_op",
"eval_at",
"eval_at_sub",
"eval_at_sup",
"exp",
"exp_nofunc",
"comp",
"comp_nofunc",
"group",
"norm_group",
"abs_group",
"floor_group",
"ceil_group",
"accent",
"atom_expr_no_supexpr",
"atom_expr",
"atom",
"mathit",
"mathit_text",
"frac",
"binom",
"func_normal_functions_single_arg",
"func_normal_functions_multi_arg",
"func_operator_names_single_arg",
"func_operator_names_multi_arg",
"func_normal_single_arg",
"func_normal_multi_arg",
"func",
"args",
"func_common_args",
"limit_sub",
"func_single_arg",
"func_single_arg_noparens",
"func_multi_arg",
"func_multi_arg_noparens",
"subexpr",
"supexpr",
"subeq",
"supeq",
]
EOF = Token.EOF
T__0 = 1
T__1 = 2
T__2 = 3
T__3 = 4
T__4 = 5
T__5 = 6
T__6 = 7
T__7 = 8
T__8 = 9
T__9 = 10
T__10 = 11
T__11 = 12
T__12 = 13
T__13 = 14
T__14 = 15
T__15 = 16
T__16 = 17
T__17 = 18
T__18 = 19
T__19 = 20
T__20 = 21
T__21 = 22
T__22 = 23
T__23 = 24
T__24 = 25
T__25 = 26
T__26 = 27
T__27 = 28
T__28 = 29
T__29 = 30
T__30 = 31
T__31 = 32
T__32 = 33
T__33 = 34
T__34 = 35
T__35 = 36
T__36 = 37
T__37 = 38
T__38 = 39
T__39 = 40
T__40 = 41
T__41 = 42
T__42 = 43
T__43 = 44
WS = 45
DOLLAR_SIGN = 46
ADD = 47
SUB = 48
MUL = 49
DIV = 50
L_PAREN = 51
R_PAREN = 52
L_GROUP = 53
R_GROUP = 54
L_BRACE = 55
R_BRACE = 56
L_BRACE_VISUAL = 57
R_BRACE_VISUAL = 58
L_BRACE_CMD = 59
R_BRACE_CMD = 60
L_BRACKET = 61
R_BRACKET = 62
L_BRACK = 63
R_BRACK = 64
BAR = 65
L_VERT = 66
R_VERT = 67
VERT = 68
NORM = 69
L_FLOOR = 70
R_FLOOR = 71
LL_CORNER = 72
LR_CORNER = 73
L_CEIL = 74
R_CEIL = 75
UL_CORNER = 76
UR_CORNER = 77
L_LEFT = 78
R_RIGHT = 79
ML_LEFT = 80
MR_RIGHT = 81
FUNC_LIM = 82
LIM_APPROACH_SYM = 83
FUNC_INT = 84
FUNC_SUM = 85
FUNC_PROD = 86
FUNC_LOG = 87
FUNC_LN = 88
FUNC_EXP = 89
FUNC_SIN = 90
FUNC_COS = 91
FUNC_TAN = 92
FUNC_CSC = 93
FUNC_SEC = 94
FUNC_COT = 95
FUNC_ARCSIN = 96
FUNC_ARCCOS = 97
FUNC_ARCTAN = 98
FUNC_ARCCSC = 99
FUNC_ARCSEC = 100
FUNC_ARCCOT = 101
FUNC_SINH = 102
FUNC_COSH = 103
FUNC_TANH = 104
FUNC_ARSINH = 105
FUNC_ARCOSH = 106
FUNC_ARTANH = 107
FUNC_ARCSINH = 108
FUNC_ARCCOSH = 109
FUNC_ARCTANH = 110
FUNC_ARSINH_NAME = 111
FUNC_ARCSINH_NAME = 112
FUNC_ARCOSH_NAME = 113
FUNC_ARCCOSH_NAME = 114
FUNC_ARTANH_NAME = 115
FUNC_ARCTANH_NAME = 116
FUNC_GCD_NAME = 117
FUNC_LCM_NAME = 118
FUNC_FLOOR_NAME = 119
FUNC_CEIL_NAME = 120
FUNC_SQRT = 121
FUNC_GCD = 122
FUNC_LCM = 123
FUNC_FLOOR = 124
FUNC_CEIL = 125
FUNC_MAX = 126
FUNC_MIN = 127
FUNC_DET = 128
FUNC_EYE_NAME = 129
FUNC_ZEROS_NAME = 130
FUNC_ONES_NAME = 131
FUNC_COLS_NAME = 132
FUNC_ROWS_NAME = 133
FUNC_DIAG_NAME = 134
FUNC_NORM_NAME = 135
FUNC_RANK_NAME = 136
FUNC_TRACE_NAME = 137
FUNC_RREF_NAME = 138
FUNC_HSTACK_NAME = 139
FUNC_VSTACK_NAME = 140
FUNC_ORTHOGONALIZE_NAME = 141
FUNC_NULLSPACE_NAME = 142
FUNC_DIAGONALIZE_NAME = 143
FUNC_EIGENVALS_NAME = 144
FUNC_EIGENVECTORS_NAME = 145
FUNC_SVD_NAME = 146
CMD_TIMES = 147
CMD_CDOT = 148
CMD_DIV = 149
CMD_FRAC = 150
CMD_BINOM = 151
CMD_CHOOSE = 152
CMD_MOD = 153
CMD_MATHIT = 154
CMD_OPERATORNAME = 155
MATRIX_TYPE_MATRIX = 156
MATRIX_TYPE_PMATRIX = 157
MATRIX_TYPE_BMATRIX = 158
MATRIX_TYPE_DET = 159
MATRIX_TYPES = 160
CMD_MATRIX_START = 161
CMD_MATRIX_END = 162
CMD_DET_START = 163
CMD_DET_END = 164
MATRIX_DEL_COL = 165
MATRIX_DEL_ROW = 166
UNDERSCORE = 167
CARET = 168
COLON = 169
SEMICOLON = 170
COMMA = 171
PERIOD = 172
DIFFERENTIAL = 173
EXP_E = 174
E_NOTATION_E = 175
LETTER_NO_E = 176
MATRIX_XRIGHTARROW = 177
TRANSFORM_EXCHANGE = 178
NUMBER = 179
E_NOTATION = 180
IN = 181
ASSIGNMENT = 182
EQUAL = 183
LT = 184
LTE = 185
GT = 186
GTE = 187
UNEQUAL = 188
BANG = 189
PERCENT_NUMBER = 190
GREEK_CMD = 191
OTHER_SYMBOL_CMD = 192
SYMBOL = 193
VARIABLE = 194
def __init__(self, input, output=sys.stdout):
super(PSParser, self).__init__(input, output=output)
self.checkVersion("4.11.1")
self._interp = ParserATNSimulator(
self, self.atn, self.decisionsToDFA, self.sharedContextCache
)
self._predicates = None
class Accent_symbolContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Accent_symbolContext, self).__init__(parent, invokingState)
self.parser = parser
def CMD_MATHIT(self):
return self.getToken(PSParser.CMD_MATHIT, 0)
def getRuleIndex(self):
return PSParser.RULE_accent_symbol
def enterRule(self, listener):
if hasattr(listener, "enterAccent_symbol"):
listener.enterAccent_symbol(self)
def exitRule(self, listener):
if hasattr(listener, "exitAccent_symbol"):
listener.exitAccent_symbol(self)
def accent_symbol(self):
localctx = PSParser.Accent_symbolContext(self, self._ctx, self.state)
self.enterRule(localctx, 0, self.RULE_accent_symbol)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 126
_la = self._input.LA(1)
if not (
((_la) & ~0x3F) == 0 and ((1 << _la) & 2199023255550) != 0 or _la == 154
):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class MathContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.MathContext, self).__init__(parent, invokingState)
self.parser = parser
def relation(self):
return self.getTypedRuleContext(PSParser.RelationContext, 0)
def relation_list(self):
return self.getTypedRuleContext(PSParser.Relation_listContext, 0)
def getRuleIndex(self):
return PSParser.RULE_math
def enterRule(self, listener):
if hasattr(listener, "enterMath"):
listener.enterMath(self)
def exitRule(self, listener):
if hasattr(listener, "exitMath"):
listener.exitMath(self)
def math(self):
localctx = PSParser.MathContext(self, self._ctx, self.state)
self.enterRule(localctx, 2, self.RULE_math)
try:
self.state = 130
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 0, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 128
self.relation(0)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 129
self.relation_list()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class TransposeContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.TransposeContext, self).__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return PSParser.RULE_transpose
def enterRule(self, listener):
if hasattr(listener, "enterTranspose"):
listener.enterTranspose(self)
def exitRule(self, listener):
if hasattr(listener, "exitTranspose"):
listener.exitTranspose(self)
def transpose(self):
localctx = PSParser.TransposeContext(self, self._ctx, self.state)
self.enterRule(localctx, 4, self.RULE_transpose)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 132
_la = self._input.LA(1)
if not (((_la) & ~0x3F) == 0 and ((1 << _la) & 32985348833280) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Transform_atomContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Transform_atomContext, self).__init__(parent, invokingState)
self.parser = parser
def LETTER_NO_E(self):
return self.getToken(PSParser.LETTER_NO_E, 0)
def UNDERSCORE(self):
return self.getToken(PSParser.UNDERSCORE, 0)
def NUMBER(self):
return self.getToken(PSParser.NUMBER, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def getRuleIndex(self):
return PSParser.RULE_transform_atom
def enterRule(self, listener):
if hasattr(listener, "enterTransform_atom"):
listener.enterTransform_atom(self)
def exitRule(self, listener):
if hasattr(listener, "exitTransform_atom"):
listener.exitTransform_atom(self)
def transform_atom(self):
localctx = PSParser.Transform_atomContext(self, self._ctx, self.state)
self.enterRule(localctx, 6, self.RULE_transform_atom)
try:
self.enterOuterAlt(localctx, 1)
self.state = 134
self.match(PSParser.LETTER_NO_E)
self.state = 135
self.match(PSParser.UNDERSCORE)
self.state = 140
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [179]:
self.state = 136
self.match(PSParser.NUMBER)
pass
elif token in [55]:
self.state = 137
self.match(PSParser.L_BRACE)
self.state = 138
self.match(PSParser.NUMBER)
self.state = 139
self.match(PSParser.R_BRACE)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Transform_scaleContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Transform_scaleContext, self).__init__(parent, invokingState)
self.parser = parser
def transform_atom(self):
return self.getTypedRuleContext(PSParser.Transform_atomContext, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def group(self):
return self.getTypedRuleContext(PSParser.GroupContext, 0)
def ADD(self):
return self.getToken(PSParser.ADD, 0)
def SUB(self):
return self.getToken(PSParser.SUB, 0)
def getRuleIndex(self):
return PSParser.RULE_transform_scale
def enterRule(self, listener):
if hasattr(listener, "enterTransform_scale"):
listener.enterTransform_scale(self)
def exitRule(self, listener):
if hasattr(listener, "exitTransform_scale"):
listener.exitTransform_scale(self)
def transform_scale(self):
localctx = PSParser.Transform_scaleContext(self, self._ctx, self.state)
self.enterRule(localctx, 8, self.RULE_transform_scale)
try:
self.enterOuterAlt(localctx, 1)
self.state = 146
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 2, self._ctx)
if la_ == 1:
self.state = 142
self.expr()
pass
elif la_ == 2:
self.state = 143
self.group()
pass
elif la_ == 3:
self.state = 144
self.match(PSParser.ADD)
pass
elif la_ == 4:
self.state = 145
self.match(PSParser.SUB)
pass
self.state = 148
self.transform_atom()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Transform_swapContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Transform_swapContext, self).__init__(parent, invokingState)
self.parser = parser
def transform_atom(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.Transform_atomContext)
else:
return self.getTypedRuleContext(PSParser.Transform_atomContext, i)
def TRANSFORM_EXCHANGE(self):
return self.getToken(PSParser.TRANSFORM_EXCHANGE, 0)
def getRuleIndex(self):
return PSParser.RULE_transform_swap
def enterRule(self, listener):
if hasattr(listener, "enterTransform_swap"):
listener.enterTransform_swap(self)
def exitRule(self, listener):
if hasattr(listener, "exitTransform_swap"):
listener.exitTransform_swap(self)
def transform_swap(self):
localctx = PSParser.Transform_swapContext(self, self._ctx, self.state)
self.enterRule(localctx, 10, self.RULE_transform_swap)
try:
self.enterOuterAlt(localctx, 1)
self.state = 150
self.transform_atom()
self.state = 151
self.match(PSParser.TRANSFORM_EXCHANGE)
self.state = 152
self.transform_atom()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Transform_assignmentContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Transform_assignmentContext, self).__init__(
parent, invokingState
)
self.parser = parser
def transform_atom(self):
return self.getTypedRuleContext(PSParser.Transform_atomContext, 0)
def transform_scale(self):
return self.getTypedRuleContext(PSParser.Transform_scaleContext, 0)
def getRuleIndex(self):
return PSParser.RULE_transform_assignment
def enterRule(self, listener):
if hasattr(listener, "enterTransform_assignment"):
listener.enterTransform_assignment(self)
def exitRule(self, listener):
if hasattr(listener, "exitTransform_assignment"):
listener.exitTransform_assignment(self)
def transform_assignment(self):
localctx = PSParser.Transform_assignmentContext(self, self._ctx, self.state)
self.enterRule(localctx, 12, self.RULE_transform_assignment)
try:
self.enterOuterAlt(localctx, 1)
self.state = 154
self.transform_atom()
self.state = 155
self.transform_scale()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Elementary_transformContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Elementary_transformContext, self).__init__(
parent, invokingState
)
self.parser = parser
def transform_assignment(self):
return self.getTypedRuleContext(PSParser.Transform_assignmentContext, 0)
def transform_scale(self):
return self.getTypedRuleContext(PSParser.Transform_scaleContext, 0)
def transform_swap(self):
return self.getTypedRuleContext(PSParser.Transform_swapContext, 0)
def getRuleIndex(self):
return PSParser.RULE_elementary_transform
def enterRule(self, listener):
if hasattr(listener, "enterElementary_transform"):
listener.enterElementary_transform(self)
def exitRule(self, listener):
if hasattr(listener, "exitElementary_transform"):
listener.exitElementary_transform(self)
def elementary_transform(self):
localctx = PSParser.Elementary_transformContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_elementary_transform)
try:
self.state = 160
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 3, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 157
self.transform_assignment()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 158
self.transform_scale()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 159
self.transform_swap()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Elementary_transformsContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Elementary_transformsContext, self).__init__(
parent, invokingState
)
self.parser = parser
def elementary_transform(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.Elementary_transformContext)
else:
return self.getTypedRuleContext(PSParser.Elementary_transformContext, i)
def COMMA(self, i=None):
if i is None:
return self.getTokens(PSParser.COMMA)
else:
return self.getToken(PSParser.COMMA, i)
def getRuleIndex(self):
return PSParser.RULE_elementary_transforms
def enterRule(self, listener):
if hasattr(listener, "enterElementary_transforms"):
listener.enterElementary_transforms(self)
def exitRule(self, listener):
if hasattr(listener, "exitElementary_transforms"):
listener.exitElementary_transforms(self)
def elementary_transforms(self):
localctx = PSParser.Elementary_transformsContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_elementary_transforms)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 162
self.elementary_transform()
self.state = 167
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 171:
self.state = 163
self.match(PSParser.COMMA)
self.state = 164
self.elementary_transform()
self.state = 169
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class MatrixContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.MatrixContext, self).__init__(parent, invokingState)
self.parser = parser
def CMD_MATRIX_START(self):
return self.getToken(PSParser.CMD_MATRIX_START, 0)
def matrix_row(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.Matrix_rowContext)
else:
return self.getTypedRuleContext(PSParser.Matrix_rowContext, i)
def CMD_MATRIX_END(self):
return self.getToken(PSParser.CMD_MATRIX_END, 0)
def MATRIX_DEL_ROW(self, i=None):
if i is None:
return self.getTokens(PSParser.MATRIX_DEL_ROW)
else:
return self.getToken(PSParser.MATRIX_DEL_ROW, i)
def MATRIX_XRIGHTARROW(self):
return self.getToken(PSParser.MATRIX_XRIGHTARROW, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def elementary_transforms(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.Elementary_transformsContext)
else:
return self.getTypedRuleContext(
PSParser.Elementary_transformsContext, i
)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def L_BRACKET(self):
return self.getToken(PSParser.L_BRACKET, 0)
def R_BRACKET(self):
return self.getToken(PSParser.R_BRACKET, 0)
def getRuleIndex(self):
return PSParser.RULE_matrix
def enterRule(self, listener):
if hasattr(listener, "enterMatrix"):
listener.enterMatrix(self)
def exitRule(self, listener):
if hasattr(listener, "exitMatrix"):
listener.exitMatrix(self)
def matrix(self):
localctx = PSParser.MatrixContext(self, self._ctx, self.state)
self.enterRule(localctx, 18, self.RULE_matrix)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 170
self.match(PSParser.CMD_MATRIX_START)
self.state = 171
self.matrix_row()
self.state = 176
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 5, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 172
self.match(PSParser.MATRIX_DEL_ROW)
self.state = 173
self.matrix_row()
self.state = 178
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 5, self._ctx)
self.state = 180
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 166:
self.state = 179
self.match(PSParser.MATRIX_DEL_ROW)
self.state = 182
self.match(PSParser.CMD_MATRIX_END)
self.state = 194
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 8, self._ctx)
if la_ == 1:
self.state = 183
self.match(PSParser.MATRIX_XRIGHTARROW)
self.state = 188
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 61:
self.state = 184
self.match(PSParser.L_BRACKET)
self.state = 185
self.elementary_transforms()
self.state = 186
self.match(PSParser.R_BRACKET)
self.state = 190
self.match(PSParser.L_BRACE)
self.state = 191
self.elementary_transforms()
self.state = 192
self.match(PSParser.R_BRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class DetContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.DetContext, self).__init__(parent, invokingState)
self.parser = parser
def CMD_DET_START(self):
return self.getToken(PSParser.CMD_DET_START, 0)
def matrix_row(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.Matrix_rowContext)
else:
return self.getTypedRuleContext(PSParser.Matrix_rowContext, i)
def CMD_DET_END(self):
return self.getToken(PSParser.CMD_DET_END, 0)
def MATRIX_DEL_ROW(self, i=None):
if i is None:
return self.getTokens(PSParser.MATRIX_DEL_ROW)
else:
return self.getToken(PSParser.MATRIX_DEL_ROW, i)
def getRuleIndex(self):
return PSParser.RULE_det
def enterRule(self, listener):
if hasattr(listener, "enterDet"):
listener.enterDet(self)
def exitRule(self, listener):
if hasattr(listener, "exitDet"):
listener.exitDet(self)
def det(self):
localctx = PSParser.DetContext(self, self._ctx, self.state)
self.enterRule(localctx, 20, self.RULE_det)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 196
self.match(PSParser.CMD_DET_START)
self.state = 197
self.matrix_row()
self.state = 202
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 9, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 198
self.match(PSParser.MATRIX_DEL_ROW)
self.state = 199
self.matrix_row()
self.state = 204
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 9, self._ctx)
self.state = 206
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 166:
self.state = 205
self.match(PSParser.MATRIX_DEL_ROW)
self.state = 208
self.match(PSParser.CMD_DET_END)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Matrix_rowContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Matrix_rowContext, self).__init__(parent, invokingState)
self.parser = parser
def expr(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.ExprContext)
else:
return self.getTypedRuleContext(PSParser.ExprContext, i)
def MATRIX_DEL_COL(self, i=None):
if i is None:
return self.getTokens(PSParser.MATRIX_DEL_COL)
else:
return self.getToken(PSParser.MATRIX_DEL_COL, i)
def getRuleIndex(self):
return PSParser.RULE_matrix_row
def enterRule(self, listener):
if hasattr(listener, "enterMatrix_row"):
listener.enterMatrix_row(self)
def exitRule(self, listener):
if hasattr(listener, "exitMatrix_row"):
listener.exitMatrix_row(self)
def matrix_row(self):
localctx = PSParser.Matrix_rowContext(self, self._ctx, self.state)
self.enterRule(localctx, 22, self.RULE_matrix_row)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 210
self.expr()
self.state = 215
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 165:
self.state = 211
self.match(PSParser.MATRIX_DEL_COL)
self.state = 212
self.expr()
self.state = 217
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class RelationContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.RelationContext, self).__init__(parent, invokingState)
self.parser = parser
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def relation(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.RelationContext)
else:
return self.getTypedRuleContext(PSParser.RelationContext, i)
def IN(self):
return self.getToken(PSParser.IN, 0)
def ASSIGNMENT(self):
return self.getToken(PSParser.ASSIGNMENT, 0)
def EQUAL(self):
return self.getToken(PSParser.EQUAL, 0)
def LT(self):
return self.getToken(PSParser.LT, 0)
def LTE(self):
return self.getToken(PSParser.LTE, 0)
def GT(self):
return self.getToken(PSParser.GT, 0)
def GTE(self):
return self.getToken(PSParser.GTE, 0)
def UNEQUAL(self):
return self.getToken(PSParser.UNEQUAL, 0)
def getRuleIndex(self):
return PSParser.RULE_relation
def enterRule(self, listener):
if hasattr(listener, "enterRelation"):
listener.enterRelation(self)
def exitRule(self, listener):
if hasattr(listener, "exitRelation"):
listener.exitRelation(self)
def relation(self, _p=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PSParser.RelationContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 24
self.enterRecursionRule(localctx, 24, self.RULE_relation, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 219
self.expr()
self._ctx.stop = self._input.LT(-1)
self.state = 226
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 12, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = PSParser.RelationContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(
localctx, _startState, self.RULE_relation
)
self.state = 221
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(
self, "self.precpred(self._ctx, 2)"
)
self.state = 222
_la = self._input.LA(1)
if not (
(((_la - 181)) & ~0x3F) == 0 and ((1 << (_la - 181)) & 255) != 0
):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 223
self.relation(3)
self.state = 228
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 12, self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class Relation_listContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Relation_listContext, self).__init__(parent, invokingState)
self.parser = parser
def relation_list_content(self):
return self.getTypedRuleContext(PSParser.Relation_list_contentContext, 0)
def L_BRACKET(self):
return self.getToken(PSParser.L_BRACKET, 0)
def R_BRACKET(self):
return self.getToken(PSParser.R_BRACKET, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def L_BRACE_VISUAL(self):
return self.getToken(PSParser.L_BRACE_VISUAL, 0)
def R_BRACE_VISUAL(self):
return self.getToken(PSParser.R_BRACE_VISUAL, 0)
def L_LEFT(self):
return self.getToken(PSParser.L_LEFT, 0)
def R_RIGHT(self):
return self.getToken(PSParser.R_RIGHT, 0)
def ML_LEFT(self):
return self.getToken(PSParser.ML_LEFT, 0)
def MR_RIGHT(self):
return self.getToken(PSParser.MR_RIGHT, 0)
def getRuleIndex(self):
return PSParser.RULE_relation_list
def enterRule(self, listener):
if hasattr(listener, "enterRelation_list"):
listener.enterRelation_list(self)
def exitRule(self, listener):
if hasattr(listener, "exitRelation_list"):
listener.exitRelation_list(self)
def relation_list(self):
localctx = PSParser.Relation_listContext(self, self._ctx, self.state)
self.enterRule(localctx, 26, self.RULE_relation_list)
try:
self.state = 266
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 13, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 229
self.relation_list_content()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 230
self.match(PSParser.L_BRACKET)
self.state = 231
self.relation_list_content()
self.state = 232
self.match(PSParser.R_BRACKET)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 234
self.match(PSParser.L_BRACE)
self.state = 235
self.relation_list_content()
self.state = 236
self.match(PSParser.R_BRACE)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 238
self.match(PSParser.L_BRACE_VISUAL)
self.state = 239
self.relation_list_content()
self.state = 240
self.match(PSParser.R_BRACE_VISUAL)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 242
self.match(PSParser.L_LEFT)
self.state = 243
self.match(PSParser.L_BRACKET)
self.state = 244
self.relation_list_content()
self.state = 245
self.match(PSParser.R_RIGHT)
self.state = 246
self.match(PSParser.R_BRACKET)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 248
self.match(PSParser.L_LEFT)
self.state = 249
self.match(PSParser.L_BRACE_VISUAL)
self.state = 250
self.relation_list_content()
self.state = 251
self.match(PSParser.R_RIGHT)
self.state = 252
self.match(PSParser.R_BRACE_VISUAL)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 254
self.match(PSParser.ML_LEFT)
self.state = 255
self.match(PSParser.L_BRACKET)
self.state = 256
self.relation_list_content()
self.state = 257
self.match(PSParser.MR_RIGHT)
self.state = 258
self.match(PSParser.R_BRACKET)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 260
self.match(PSParser.ML_LEFT)
self.state = 261
self.match(PSParser.L_BRACE_VISUAL)
self.state = 262
self.relation_list_content()
self.state = 263
self.match(PSParser.MR_RIGHT)
self.state = 264
self.match(PSParser.R_BRACE_VISUAL)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Relation_list_contentContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Relation_list_contentContext, self).__init__(
parent, invokingState
)
self.parser = parser
def relation(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.RelationContext)
else:
return self.getTypedRuleContext(PSParser.RelationContext, i)
def COMMA(self, i=None):
if i is None:
return self.getTokens(PSParser.COMMA)
else:
return self.getToken(PSParser.COMMA, i)
def SEMICOLON(self, i=None):
if i is None:
return self.getTokens(PSParser.SEMICOLON)
else:
return self.getToken(PSParser.SEMICOLON, i)
def getRuleIndex(self):
return PSParser.RULE_relation_list_content
def enterRule(self, listener):
if hasattr(listener, "enterRelation_list_content"):
listener.enterRelation_list_content(self)
def exitRule(self, listener):
if hasattr(listener, "exitRelation_list_content"):
listener.exitRelation_list_content(self)
def relation_list_content(self):
localctx = PSParser.Relation_list_contentContext(self, self._ctx, self.state)
self.enterRule(localctx, 28, self.RULE_relation_list_content)
self._la = 0 # Token type
try:
self.state = 288
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 16, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 268
self.relation(0)
self.state = 269
self.match(PSParser.COMMA)
self.state = 270
self.relation(0)
self.state = 275
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 171:
self.state = 271
self.match(PSParser.COMMA)
self.state = 272
self.relation(0)
self.state = 277
self._errHandler.sync(self)
_la = self._input.LA(1)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 278
self.relation(0)
self.state = 279
self.match(PSParser.SEMICOLON)
self.state = 280
self.relation(0)
self.state = 285
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 170:
self.state = 281
self.match(PSParser.SEMICOLON)
self.state = 282
self.relation(0)
self.state = 287
self._errHandler.sync(self)
_la = self._input.LA(1)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class EqualityContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.EqualityContext, self).__init__(parent, invokingState)
self.parser = parser
def expr(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.ExprContext)
else:
return self.getTypedRuleContext(PSParser.ExprContext, i)
def EQUAL(self):
return self.getToken(PSParser.EQUAL, 0)
def ASSIGNMENT(self):
return self.getToken(PSParser.ASSIGNMENT, 0)
def getRuleIndex(self):
return PSParser.RULE_equality
def enterRule(self, listener):
if hasattr(listener, "enterEquality"):
listener.enterEquality(self)
def exitRule(self, listener):
if hasattr(listener, "exitEquality"):
listener.exitEquality(self)
def equality(self):
localctx = PSParser.EqualityContext(self, self._ctx, self.state)
self.enterRule(localctx, 30, self.RULE_equality)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 290
self.expr()
self.state = 291
_la = self._input.LA(1)
if not (_la == 182 or _la == 183):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 292
self.expr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class ExprContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.ExprContext, self).__init__(parent, invokingState)
self.parser = parser
def additive(self):
return self.getTypedRuleContext(PSParser.AdditiveContext, 0)
def getRuleIndex(self):
return PSParser.RULE_expr
def enterRule(self, listener):
if hasattr(listener, "enterExpr"):
listener.enterExpr(self)
def exitRule(self, listener):
if hasattr(listener, "exitExpr"):
listener.exitExpr(self)
def expr(self):
localctx = PSParser.ExprContext(self, self._ctx, self.state)
self.enterRule(localctx, 32, self.RULE_expr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 294
self.additive(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class AdditiveContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.AdditiveContext, self).__init__(parent, invokingState)
self.parser = parser
def mp(self):
return self.getTypedRuleContext(PSParser.MpContext, 0)
def additive(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.AdditiveContext)
else:
return self.getTypedRuleContext(PSParser.AdditiveContext, i)
def ADD(self):
return self.getToken(PSParser.ADD, 0)
def SUB(self):
return self.getToken(PSParser.SUB, 0)
def getRuleIndex(self):
return PSParser.RULE_additive
def enterRule(self, listener):
if hasattr(listener, "enterAdditive"):
listener.enterAdditive(self)
def exitRule(self, listener):
if hasattr(listener, "exitAdditive"):
listener.exitAdditive(self)
def additive(self, _p=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PSParser.AdditiveContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 34
self.enterRecursionRule(localctx, 34, self.RULE_additive, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 297
self.mp(0)
self._ctx.stop = self._input.LT(-1)
self.state = 304
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 17, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = PSParser.AdditiveContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(
localctx, _startState, self.RULE_additive
)
self.state = 299
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(
self, "self.precpred(self._ctx, 2)"
)
self.state = 300
_la = self._input.LA(1)
if not (_la == 47 or _la == 48):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 301
self.additive(3)
self.state = 306
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 17, self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class MpContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.MpContext, self).__init__(parent, invokingState)
self.parser = parser
def unary(self):
return self.getTypedRuleContext(PSParser.UnaryContext, 0)
def mp(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.MpContext)
else:
return self.getTypedRuleContext(PSParser.MpContext, i)
def MUL(self):
return self.getToken(PSParser.MUL, 0)
def CMD_TIMES(self):
return self.getToken(PSParser.CMD_TIMES, 0)
def CMD_CDOT(self):
return self.getToken(PSParser.CMD_CDOT, 0)
def DIV(self):
return self.getToken(PSParser.DIV, 0)
def CMD_DIV(self):
return self.getToken(PSParser.CMD_DIV, 0)
def COLON(self):
return self.getToken(PSParser.COLON, 0)
def CMD_MOD(self):
return self.getToken(PSParser.CMD_MOD, 0)
def getRuleIndex(self):
return PSParser.RULE_mp
def enterRule(self, listener):
if hasattr(listener, "enterMp"):
listener.enterMp(self)
def exitRule(self, listener):
if hasattr(listener, "exitMp"):
listener.exitMp(self)
def mp(self, _p=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PSParser.MpContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 36
self.enterRecursionRule(localctx, 36, self.RULE_mp, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 308
self.unary()
self._ctx.stop = self._input.LT(-1)
self.state = 315
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 18, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = PSParser.MpContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_mp)
self.state = 310
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(
self, "self.precpred(self._ctx, 2)"
)
self.state = 311
_la = self._input.LA(1)
if not (
_la == 49
or _la == 50
or (((_la - 147)) & ~0x3F) == 0
and ((1 << (_la - 147)) & 4194375) != 0
):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 312
self.mp(3)
self.state = 317
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 18, self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class Mp_nofuncContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Mp_nofuncContext, self).__init__(parent, invokingState)
self.parser = parser
def unary_nofunc(self):
return self.getTypedRuleContext(PSParser.Unary_nofuncContext, 0)
def mp_nofunc(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.Mp_nofuncContext)
else:
return self.getTypedRuleContext(PSParser.Mp_nofuncContext, i)
def MUL(self):
return self.getToken(PSParser.MUL, 0)
def CMD_TIMES(self):
return self.getToken(PSParser.CMD_TIMES, 0)
def CMD_CDOT(self):
return self.getToken(PSParser.CMD_CDOT, 0)
def DIV(self):
return self.getToken(PSParser.DIV, 0)
def CMD_DIV(self):
return self.getToken(PSParser.CMD_DIV, 0)
def COLON(self):
return self.getToken(PSParser.COLON, 0)
def CMD_MOD(self):
return self.getToken(PSParser.CMD_MOD, 0)
def getRuleIndex(self):
return PSParser.RULE_mp_nofunc
def enterRule(self, listener):
if hasattr(listener, "enterMp_nofunc"):
listener.enterMp_nofunc(self)
def exitRule(self, listener):
if hasattr(listener, "exitMp_nofunc"):
listener.exitMp_nofunc(self)
def mp_nofunc(self, _p=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PSParser.Mp_nofuncContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 38
self.enterRecursionRule(localctx, 38, self.RULE_mp_nofunc, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 319
self.unary_nofunc()
self._ctx.stop = self._input.LT(-1)
self.state = 326
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 19, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = PSParser.Mp_nofuncContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(
localctx, _startState, self.RULE_mp_nofunc
)
self.state = 321
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(
self, "self.precpred(self._ctx, 2)"
)
self.state = 322
_la = self._input.LA(1)
if not (
_la == 49
or _la == 50
or (((_la - 147)) & ~0x3F) == 0
and ((1 << (_la - 147)) & 4194375) != 0
):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 323
self.mp_nofunc(3)
self.state = 328
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 19, self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class UnaryContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.UnaryContext, self).__init__(parent, invokingState)
self.parser = parser
def unary(self):
return self.getTypedRuleContext(PSParser.UnaryContext, 0)
def ADD(self):
return self.getToken(PSParser.ADD, 0)
def SUB(self):
return self.getToken(PSParser.SUB, 0)
def postfix(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.PostfixContext)
else:
return self.getTypedRuleContext(PSParser.PostfixContext, i)
def getRuleIndex(self):
return PSParser.RULE_unary
def enterRule(self, listener):
if hasattr(listener, "enterUnary"):
listener.enterUnary(self)
def exitRule(self, listener):
if hasattr(listener, "exitUnary"):
listener.exitUnary(self)
def unary(self):
localctx = PSParser.UnaryContext(self, self._ctx, self.state)
self.enterRule(localctx, 40, self.RULE_unary)
self._la = 0 # Token type
try:
self.state = 336
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [47, 48]:
self.enterOuterAlt(localctx, 1)
self.state = 329
_la = self._input.LA(1)
if not (_la == 47 or _la == 48):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 330
self.unary()
pass
elif token in [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
51,
53,
55,
57,
59,
61,
63,
65,
66,
68,
69,
70,
72,
74,
76,
78,
80,
82,
84,
85,
86,
87,
88,
89,
90,
91,
92,
93,
94,
95,
96,
97,
98,
99,
100,
101,
102,
103,
104,
105,
106,
107,
108,
109,
110,
121,
122,
123,
124,
125,
126,
127,
128,
150,
151,
154,
155,
161,
163,
173,
174,
176,
179,
180,
190,
191,
192,
193,
194,
]:
self.enterOuterAlt(localctx, 2)
self.state = 332
self._errHandler.sync(self)
_alt = 1
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 331
self.postfix()
else:
raise NoViableAltException(self)
self.state = 334
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 20, self._ctx)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Unary_nofuncContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Unary_nofuncContext, self).__init__(parent, invokingState)
self.parser = parser
def unary_nofunc(self):
return self.getTypedRuleContext(PSParser.Unary_nofuncContext, 0)
def ADD(self):
return self.getToken(PSParser.ADD, 0)
def SUB(self):
return self.getToken(PSParser.SUB, 0)
def postfix(self):
return self.getTypedRuleContext(PSParser.PostfixContext, 0)
def postfix_nofunc(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.Postfix_nofuncContext)
else:
return self.getTypedRuleContext(PSParser.Postfix_nofuncContext, i)
def getRuleIndex(self):
return PSParser.RULE_unary_nofunc
def enterRule(self, listener):
if hasattr(listener, "enterUnary_nofunc"):
listener.enterUnary_nofunc(self)
def exitRule(self, listener):
if hasattr(listener, "exitUnary_nofunc"):
listener.exitUnary_nofunc(self)
def unary_nofunc(self):
localctx = PSParser.Unary_nofuncContext(self, self._ctx, self.state)
self.enterRule(localctx, 42, self.RULE_unary_nofunc)
self._la = 0 # Token type
try:
self.state = 347
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [47, 48]:
self.enterOuterAlt(localctx, 1)
self.state = 338
_la = self._input.LA(1)
if not (_la == 47 or _la == 48):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 339
self.unary_nofunc()
pass
elif token in [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
51,
53,
55,
57,
59,
61,
63,
65,
66,
68,
69,
70,
72,
74,
76,
78,
80,
82,
84,
85,
86,
87,
88,
89,
90,
91,
92,
93,
94,
95,
96,
97,
98,
99,
100,
101,
102,
103,
104,
105,
106,
107,
108,
109,
110,
121,
122,
123,
124,
125,
126,
127,
128,
150,
151,
154,
155,
161,
163,
173,
174,
176,
179,
180,
190,
191,
192,
193,
194,
]:
self.enterOuterAlt(localctx, 2)
self.state = 340
self.postfix()
self.state = 344
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 22, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 341
self.postfix_nofunc()
self.state = 346
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 22, self._ctx)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class PostfixContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.PostfixContext, self).__init__(parent, invokingState)
self.parser = parser
def exp(self):
return self.getTypedRuleContext(PSParser.ExpContext, 0)
def postfix_op(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.Postfix_opContext)
else:
return self.getTypedRuleContext(PSParser.Postfix_opContext, i)
def getRuleIndex(self):
return PSParser.RULE_postfix
def enterRule(self, listener):
if hasattr(listener, "enterPostfix"):
listener.enterPostfix(self)
def exitRule(self, listener):
if hasattr(listener, "exitPostfix"):
listener.exitPostfix(self)
def postfix(self):
localctx = PSParser.PostfixContext(self, self._ctx, self.state)
self.enterRule(localctx, 44, self.RULE_postfix)
try:
self.enterOuterAlt(localctx, 1)
self.state = 349
self.exp(0)
self.state = 353
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 24, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 350
self.postfix_op()
self.state = 355
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 24, self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Postfix_nofuncContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Postfix_nofuncContext, self).__init__(parent, invokingState)
self.parser = parser
def exp_nofunc(self):
return self.getTypedRuleContext(PSParser.Exp_nofuncContext, 0)
def postfix_op(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.Postfix_opContext)
else:
return self.getTypedRuleContext(PSParser.Postfix_opContext, i)
def getRuleIndex(self):
return PSParser.RULE_postfix_nofunc
def enterRule(self, listener):
if hasattr(listener, "enterPostfix_nofunc"):
listener.enterPostfix_nofunc(self)
def exitRule(self, listener):
if hasattr(listener, "exitPostfix_nofunc"):
listener.exitPostfix_nofunc(self)
def postfix_nofunc(self):
localctx = PSParser.Postfix_nofuncContext(self, self._ctx, self.state)
self.enterRule(localctx, 46, self.RULE_postfix_nofunc)
try:
self.enterOuterAlt(localctx, 1)
self.state = 356
self.exp_nofunc(0)
self.state = 360
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 25, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 357
self.postfix_op()
self.state = 362
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 25, self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Postfix_opContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Postfix_opContext, self).__init__(parent, invokingState)
self.parser = parser
def BANG(self):
return self.getToken(PSParser.BANG, 0)
def eval_at(self):
return self.getTypedRuleContext(PSParser.Eval_atContext, 0)
def transpose(self):
return self.getTypedRuleContext(PSParser.TransposeContext, 0)
def getRuleIndex(self):
return PSParser.RULE_postfix_op
def enterRule(self, listener):
if hasattr(listener, "enterPostfix_op"):
listener.enterPostfix_op(self)
def exitRule(self, listener):
if hasattr(listener, "exitPostfix_op"):
listener.exitPostfix_op(self)
def postfix_op(self):
localctx = PSParser.Postfix_opContext(self, self._ctx, self.state)
self.enterRule(localctx, 48, self.RULE_postfix_op)
try:
self.state = 366
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [189]:
self.enterOuterAlt(localctx, 1)
self.state = 363
self.match(PSParser.BANG)
pass
elif token in [65]:
self.enterOuterAlt(localctx, 2)
self.state = 364
self.eval_at()
pass
elif token in [41, 42, 43, 44]:
self.enterOuterAlt(localctx, 3)
self.state = 365
self.transpose()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Eval_atContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Eval_atContext, self).__init__(parent, invokingState)
self.parser = parser
def BAR(self):
return self.getToken(PSParser.BAR, 0)
def eval_at_sup(self):
return self.getTypedRuleContext(PSParser.Eval_at_supContext, 0)
def eval_at_sub(self):
return self.getTypedRuleContext(PSParser.Eval_at_subContext, 0)
def getRuleIndex(self):
return PSParser.RULE_eval_at
def enterRule(self, listener):
if hasattr(listener, "enterEval_at"):
listener.enterEval_at(self)
def exitRule(self, listener):
if hasattr(listener, "exitEval_at"):
listener.exitEval_at(self)
def eval_at(self):
localctx = PSParser.Eval_atContext(self, self._ctx, self.state)
self.enterRule(localctx, 50, self.RULE_eval_at)
try:
self.enterOuterAlt(localctx, 1)
self.state = 368
self.match(PSParser.BAR)
self.state = 374
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 27, self._ctx)
if la_ == 1:
self.state = 369
self.eval_at_sup()
pass
elif la_ == 2:
self.state = 370
self.eval_at_sub()
pass
elif la_ == 3:
self.state = 371
self.eval_at_sup()
self.state = 372
self.eval_at_sub()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Eval_at_subContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Eval_at_subContext, self).__init__(parent, invokingState)
self.parser = parser
def UNDERSCORE(self):
return self.getToken(PSParser.UNDERSCORE, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def equality(self):
return self.getTypedRuleContext(PSParser.EqualityContext, 0)
def getRuleIndex(self):
return PSParser.RULE_eval_at_sub
def enterRule(self, listener):
if hasattr(listener, "enterEval_at_sub"):
listener.enterEval_at_sub(self)
def exitRule(self, listener):
if hasattr(listener, "exitEval_at_sub"):
listener.exitEval_at_sub(self)
def eval_at_sub(self):
localctx = PSParser.Eval_at_subContext(self, self._ctx, self.state)
self.enterRule(localctx, 52, self.RULE_eval_at_sub)
try:
self.enterOuterAlt(localctx, 1)
self.state = 376
self.match(PSParser.UNDERSCORE)
self.state = 377
self.match(PSParser.L_BRACE)
self.state = 380
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 28, self._ctx)
if la_ == 1:
self.state = 378
self.expr()
pass
elif la_ == 2:
self.state = 379
self.equality()
pass
self.state = 382
self.match(PSParser.R_BRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Eval_at_supContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Eval_at_supContext, self).__init__(parent, invokingState)
self.parser = parser
def CARET(self):
return self.getToken(PSParser.CARET, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def equality(self):
return self.getTypedRuleContext(PSParser.EqualityContext, 0)
def getRuleIndex(self):
return PSParser.RULE_eval_at_sup
def enterRule(self, listener):
if hasattr(listener, "enterEval_at_sup"):
listener.enterEval_at_sup(self)
def exitRule(self, listener):
if hasattr(listener, "exitEval_at_sup"):
listener.exitEval_at_sup(self)
def eval_at_sup(self):
localctx = PSParser.Eval_at_supContext(self, self._ctx, self.state)
self.enterRule(localctx, 54, self.RULE_eval_at_sup)
try:
self.enterOuterAlt(localctx, 1)
self.state = 384
self.match(PSParser.CARET)
self.state = 385
self.match(PSParser.L_BRACE)
self.state = 388
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 29, self._ctx)
if la_ == 1:
self.state = 386
self.expr()
pass
elif la_ == 2:
self.state = 387
self.equality()
pass
self.state = 390
self.match(PSParser.R_BRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class ExpContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.ExpContext, self).__init__(parent, invokingState)
self.parser = parser
def comp(self):
return self.getTypedRuleContext(PSParser.CompContext, 0)
def exp(self):
return self.getTypedRuleContext(PSParser.ExpContext, 0)
def CARET(self):
return self.getToken(PSParser.CARET, 0)
def atom(self):
return self.getTypedRuleContext(PSParser.AtomContext, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def subexpr(self):
return self.getTypedRuleContext(PSParser.SubexprContext, 0)
def getRuleIndex(self):
return PSParser.RULE_exp
def enterRule(self, listener):
if hasattr(listener, "enterExp"):
listener.enterExp(self)
def exitRule(self, listener):
if hasattr(listener, "exitExp"):
listener.exitExp(self)
def exp(self, _p=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PSParser.ExpContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 56
self.enterRecursionRule(localctx, 56, self.RULE_exp, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 393
self.comp()
self._ctx.stop = self._input.LT(-1)
self.state = 409
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 32, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = PSParser.ExpContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
self.state = 395
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(
self, "self.precpred(self._ctx, 2)"
)
self.state = 396
self.match(PSParser.CARET)
self.state = 402
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
154,
173,
176,
179,
180,
190,
191,
192,
193,
194,
]:
self.state = 397
self.atom()
pass
elif token in [55]:
self.state = 398
self.match(PSParser.L_BRACE)
self.state = 399
self.expr()
self.state = 400
self.match(PSParser.R_BRACE)
pass
else:
raise NoViableAltException(self)
self.state = 405
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 31, self._ctx)
if la_ == 1:
self.state = 404
self.subexpr()
self.state = 411
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 32, self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class Exp_nofuncContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Exp_nofuncContext, self).__init__(parent, invokingState)
self.parser = parser
def comp_nofunc(self):
return self.getTypedRuleContext(PSParser.Comp_nofuncContext, 0)
def exp_nofunc(self):
return self.getTypedRuleContext(PSParser.Exp_nofuncContext, 0)
def CARET(self):
return self.getToken(PSParser.CARET, 0)
def atom(self):
return self.getTypedRuleContext(PSParser.AtomContext, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def subexpr(self):
return self.getTypedRuleContext(PSParser.SubexprContext, 0)
def getRuleIndex(self):
return PSParser.RULE_exp_nofunc
def enterRule(self, listener):
if hasattr(listener, "enterExp_nofunc"):
listener.enterExp_nofunc(self)
def exitRule(self, listener):
if hasattr(listener, "exitExp_nofunc"):
listener.exitExp_nofunc(self)
def exp_nofunc(self, _p=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PSParser.Exp_nofuncContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 58
self.enterRecursionRule(localctx, 58, self.RULE_exp_nofunc, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 413
self.comp_nofunc()
self._ctx.stop = self._input.LT(-1)
self.state = 429
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 35, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = PSParser.Exp_nofuncContext(
self, _parentctx, _parentState
)
self.pushNewRecursionContext(
localctx, _startState, self.RULE_exp_nofunc
)
self.state = 415
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(
self, "self.precpred(self._ctx, 2)"
)
self.state = 416
self.match(PSParser.CARET)
self.state = 422
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
154,
173,
176,
179,
180,
190,
191,
192,
193,
194,
]:
self.state = 417
self.atom()
pass
elif token in [55]:
self.state = 418
self.match(PSParser.L_BRACE)
self.state = 419
self.expr()
self.state = 420
self.match(PSParser.R_BRACE)
pass
else:
raise NoViableAltException(self)
self.state = 425
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 34, self._ctx)
if la_ == 1:
self.state = 424
self.subexpr()
self.state = 431
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 35, self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class CompContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.CompContext, self).__init__(parent, invokingState)
self.parser = parser
def group(self):
return self.getTypedRuleContext(PSParser.GroupContext, 0)
def norm_group(self):
return self.getTypedRuleContext(PSParser.Norm_groupContext, 0)
def abs_group(self):
return self.getTypedRuleContext(PSParser.Abs_groupContext, 0)
def floor_group(self):
return self.getTypedRuleContext(PSParser.Floor_groupContext, 0)
def ceil_group(self):
return self.getTypedRuleContext(PSParser.Ceil_groupContext, 0)
def func(self):
return self.getTypedRuleContext(PSParser.FuncContext, 0)
def atom(self):
return self.getTypedRuleContext(PSParser.AtomContext, 0)
def frac(self):
return self.getTypedRuleContext(PSParser.FracContext, 0)
def binom(self):
return self.getTypedRuleContext(PSParser.BinomContext, 0)
def matrix(self):
return self.getTypedRuleContext(PSParser.MatrixContext, 0)
def det(self):
return self.getTypedRuleContext(PSParser.DetContext, 0)
def getRuleIndex(self):
return PSParser.RULE_comp
def enterRule(self, listener):
if hasattr(listener, "enterComp"):
listener.enterComp(self)
def exitRule(self, listener):
if hasattr(listener, "exitComp"):
listener.exitComp(self)
def comp(self):
localctx = PSParser.CompContext(self, self._ctx, self.state)
self.enterRule(localctx, 60, self.RULE_comp)
try:
self.state = 443
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 36, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 432
self.group()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 433
self.norm_group()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 434
self.abs_group()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 435
self.floor_group()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 436
self.ceil_group()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 437
self.func()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 438
self.atom()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 439
self.frac()
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 440
self.binom()
pass
elif la_ == 10:
self.enterOuterAlt(localctx, 10)
self.state = 441
self.matrix()
pass
elif la_ == 11:
self.enterOuterAlt(localctx, 11)
self.state = 442
self.det()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Comp_nofuncContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Comp_nofuncContext, self).__init__(parent, invokingState)
self.parser = parser
def group(self):
return self.getTypedRuleContext(PSParser.GroupContext, 0)
def norm_group(self):
return self.getTypedRuleContext(PSParser.Norm_groupContext, 0)
def abs_group(self):
return self.getTypedRuleContext(PSParser.Abs_groupContext, 0)
def floor_group(self):
return self.getTypedRuleContext(PSParser.Floor_groupContext, 0)
def ceil_group(self):
return self.getTypedRuleContext(PSParser.Ceil_groupContext, 0)
def atom(self):
return self.getTypedRuleContext(PSParser.AtomContext, 0)
def frac(self):
return self.getTypedRuleContext(PSParser.FracContext, 0)
def binom(self):
return self.getTypedRuleContext(PSParser.BinomContext, 0)
def matrix(self):
return self.getTypedRuleContext(PSParser.MatrixContext, 0)
def det(self):
return self.getTypedRuleContext(PSParser.DetContext, 0)
def getRuleIndex(self):
return PSParser.RULE_comp_nofunc
def enterRule(self, listener):
if hasattr(listener, "enterComp_nofunc"):
listener.enterComp_nofunc(self)
def exitRule(self, listener):
if hasattr(listener, "exitComp_nofunc"):
listener.exitComp_nofunc(self)
def comp_nofunc(self):
localctx = PSParser.Comp_nofuncContext(self, self._ctx, self.state)
self.enterRule(localctx, 62, self.RULE_comp_nofunc)
try:
self.state = 455
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 37, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 445
self.group()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 446
self.norm_group()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 447
self.abs_group()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 448
self.floor_group()
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 449
self.ceil_group()
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 450
self.atom()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 451
self.frac()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 452
self.binom()
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 453
self.matrix()
pass
elif la_ == 10:
self.enterOuterAlt(localctx, 10)
self.state = 454
self.det()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class GroupContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.GroupContext, self).__init__(parent, invokingState)
self.parser = parser
def L_PAREN(self):
return self.getToken(PSParser.L_PAREN, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def R_PAREN(self):
return self.getToken(PSParser.R_PAREN, 0)
def L_GROUP(self):
return self.getToken(PSParser.L_GROUP, 0)
def R_GROUP(self):
return self.getToken(PSParser.R_GROUP, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def L_BRACE_VISUAL(self):
return self.getToken(PSParser.L_BRACE_VISUAL, 0)
def R_BRACE_VISUAL(self):
return self.getToken(PSParser.R_BRACE_VISUAL, 0)
def L_BRACE_CMD(self):
return self.getToken(PSParser.L_BRACE_CMD, 0)
def R_BRACE_CMD(self):
return self.getToken(PSParser.R_BRACE_CMD, 0)
def L_BRACKET(self):
return self.getToken(PSParser.L_BRACKET, 0)
def R_BRACKET(self):
return self.getToken(PSParser.R_BRACKET, 0)
def L_BRACK(self):
return self.getToken(PSParser.L_BRACK, 0)
def R_BRACK(self):
return self.getToken(PSParser.R_BRACK, 0)
def L_LEFT(self):
return self.getToken(PSParser.L_LEFT, 0)
def R_RIGHT(self):
return self.getToken(PSParser.R_RIGHT, 0)
def ML_LEFT(self):
return self.getToken(PSParser.ML_LEFT, 0)
def MR_RIGHT(self):
return self.getToken(PSParser.MR_RIGHT, 0)
def getRuleIndex(self):
return PSParser.RULE_group
def enterRule(self, listener):
if hasattr(listener, "enterGroup"):
listener.enterGroup(self)
def exitRule(self, listener):
if hasattr(listener, "exitGroup"):
listener.exitGroup(self)
def group(self):
localctx = PSParser.GroupContext(self, self._ctx, self.state)
self.enterRule(localctx, 64, self.RULE_group)
try:
self.state = 569
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 38, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 457
self.match(PSParser.L_PAREN)
self.state = 458
self.expr()
self.state = 459
self.match(PSParser.R_PAREN)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 461
self.match(PSParser.L_GROUP)
self.state = 462
self.expr()
self.state = 463
self.match(PSParser.R_GROUP)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 465
self.match(PSParser.L_BRACE)
self.state = 466
self.expr()
self.state = 467
self.match(PSParser.R_BRACE)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 469
self.match(PSParser.L_BRACE_VISUAL)
self.state = 470
self.expr()
self.state = 471
self.match(PSParser.R_BRACE_VISUAL)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 473
self.match(PSParser.L_BRACE_CMD)
self.state = 474
self.expr()
self.state = 475
self.match(PSParser.R_BRACE_CMD)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 477
self.match(PSParser.L_BRACKET)
self.state = 478
self.expr()
self.state = 479
self.match(PSParser.R_BRACKET)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 481
self.match(PSParser.L_BRACK)
self.state = 482
self.expr()
self.state = 483
self.match(PSParser.R_BRACK)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 485
self.match(PSParser.L_LEFT)
self.state = 486
self.match(PSParser.L_PAREN)
self.state = 487
self.expr()
self.state = 488
self.match(PSParser.R_RIGHT)
self.state = 489
self.match(PSParser.R_PAREN)
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 491
self.match(PSParser.L_LEFT)
self.state = 492
self.match(PSParser.L_GROUP)
self.state = 493
self.expr()
self.state = 494
self.match(PSParser.R_RIGHT)
self.state = 495
self.match(PSParser.R_GROUP)
pass
elif la_ == 10:
self.enterOuterAlt(localctx, 10)
self.state = 497
self.match(PSParser.L_LEFT)
self.state = 498
self.match(PSParser.L_BRACE)
self.state = 499
self.expr()
self.state = 500
self.match(PSParser.R_RIGHT)
self.state = 501
self.match(PSParser.R_BRACE)
pass
elif la_ == 11:
self.enterOuterAlt(localctx, 11)
self.state = 503
self.match(PSParser.L_LEFT)
self.state = 504
self.match(PSParser.L_BRACE_VISUAL)
self.state = 505
self.expr()
self.state = 506
self.match(PSParser.R_RIGHT)
self.state = 507
self.match(PSParser.R_BRACE_VISUAL)
pass
elif la_ == 12:
self.enterOuterAlt(localctx, 12)
self.state = 509
self.match(PSParser.L_LEFT)
self.state = 510
self.match(PSParser.L_BRACE_CMD)
self.state = 511
self.expr()
self.state = 512
self.match(PSParser.R_RIGHT)
self.state = 513
self.match(PSParser.R_BRACE_CMD)
pass
elif la_ == 13:
self.enterOuterAlt(localctx, 13)
self.state = 515
self.match(PSParser.L_LEFT)
self.state = 516
self.match(PSParser.L_BRACKET)
self.state = 517
self.expr()
self.state = 518
self.match(PSParser.R_RIGHT)
self.state = 519
self.match(PSParser.R_BRACKET)
pass
elif la_ == 14:
self.enterOuterAlt(localctx, 14)
self.state = 521
self.match(PSParser.L_LEFT)
self.state = 522
self.match(PSParser.L_BRACK)
self.state = 523
self.expr()
self.state = 524
self.match(PSParser.R_RIGHT)
self.state = 525
self.match(PSParser.R_BRACK)
pass
elif la_ == 15:
self.enterOuterAlt(localctx, 15)
self.state = 527
self.match(PSParser.ML_LEFT)
self.state = 528
self.match(PSParser.L_PAREN)
self.state = 529
self.expr()
self.state = 530
self.match(PSParser.MR_RIGHT)
self.state = 531
self.match(PSParser.R_PAREN)
pass
elif la_ == 16:
self.enterOuterAlt(localctx, 16)
self.state = 533
self.match(PSParser.ML_LEFT)
self.state = 534
self.match(PSParser.L_GROUP)
self.state = 535
self.expr()
self.state = 536
self.match(PSParser.MR_RIGHT)
self.state = 537
self.match(PSParser.R_GROUP)
pass
elif la_ == 17:
self.enterOuterAlt(localctx, 17)
self.state = 539
self.match(PSParser.ML_LEFT)
self.state = 540
self.match(PSParser.L_BRACE)
self.state = 541
self.expr()
self.state = 542
self.match(PSParser.MR_RIGHT)
self.state = 543
self.match(PSParser.R_BRACE)
pass
elif la_ == 18:
self.enterOuterAlt(localctx, 18)
self.state = 545
self.match(PSParser.ML_LEFT)
self.state = 546
self.match(PSParser.L_BRACE_VISUAL)
self.state = 547
self.expr()
self.state = 548
self.match(PSParser.MR_RIGHT)
self.state = 549
self.match(PSParser.R_BRACE_VISUAL)
pass
elif la_ == 19:
self.enterOuterAlt(localctx, 19)
self.state = 551
self.match(PSParser.ML_LEFT)
self.state = 552
self.match(PSParser.L_BRACE_CMD)
self.state = 553
self.expr()
self.state = 554
self.match(PSParser.MR_RIGHT)
self.state = 555
self.match(PSParser.R_BRACE_CMD)
pass
elif la_ == 20:
self.enterOuterAlt(localctx, 20)
self.state = 557
self.match(PSParser.ML_LEFT)
self.state = 558
self.match(PSParser.L_BRACKET)
self.state = 559
self.expr()
self.state = 560
self.match(PSParser.MR_RIGHT)
self.state = 561
self.match(PSParser.R_BRACKET)
pass
elif la_ == 21:
self.enterOuterAlt(localctx, 21)
self.state = 563
self.match(PSParser.ML_LEFT)
self.state = 564
self.match(PSParser.L_BRACK)
self.state = 565
self.expr()
self.state = 566
self.match(PSParser.MR_RIGHT)
self.state = 567
self.match(PSParser.R_BRACK)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Norm_groupContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Norm_groupContext, self).__init__(parent, invokingState)
self.parser = parser
def NORM(self, i=None):
if i is None:
return self.getTokens(PSParser.NORM)
else:
return self.getToken(PSParser.NORM, i)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def L_LEFT(self):
return self.getToken(PSParser.L_LEFT, 0)
def R_RIGHT(self):
return self.getToken(PSParser.R_RIGHT, 0)
def ML_LEFT(self):
return self.getToken(PSParser.ML_LEFT, 0)
def MR_RIGHT(self):
return self.getToken(PSParser.MR_RIGHT, 0)
def getRuleIndex(self):
return PSParser.RULE_norm_group
def enterRule(self, listener):
if hasattr(listener, "enterNorm_group"):
listener.enterNorm_group(self)
def exitRule(self, listener):
if hasattr(listener, "exitNorm_group"):
listener.exitNorm_group(self)
def norm_group(self):
localctx = PSParser.Norm_groupContext(self, self._ctx, self.state)
self.enterRule(localctx, 66, self.RULE_norm_group)
try:
self.state = 587
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [69]:
self.enterOuterAlt(localctx, 1)
self.state = 571
self.match(PSParser.NORM)
self.state = 572
self.expr()
self.state = 573
self.match(PSParser.NORM)
pass
elif token in [78]:
self.enterOuterAlt(localctx, 2)
self.state = 575
self.match(PSParser.L_LEFT)
self.state = 576
self.match(PSParser.NORM)
self.state = 577
self.expr()
self.state = 578
self.match(PSParser.R_RIGHT)
self.state = 579
self.match(PSParser.NORM)
pass
elif token in [80]:
self.enterOuterAlt(localctx, 3)
self.state = 581
self.match(PSParser.ML_LEFT)
self.state = 582
self.match(PSParser.NORM)
self.state = 583
self.expr()
self.state = 584
self.match(PSParser.MR_RIGHT)
self.state = 585
self.match(PSParser.NORM)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Abs_groupContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Abs_groupContext, self).__init__(parent, invokingState)
self.parser = parser
def BAR(self, i=None):
if i is None:
return self.getTokens(PSParser.BAR)
else:
return self.getToken(PSParser.BAR, i)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def L_VERT(self):
return self.getToken(PSParser.L_VERT, 0)
def R_VERT(self):
return self.getToken(PSParser.R_VERT, 0)
def VERT(self, i=None):
if i is None:
return self.getTokens(PSParser.VERT)
else:
return self.getToken(PSParser.VERT, i)
def L_LEFT(self):
return self.getToken(PSParser.L_LEFT, 0)
def R_RIGHT(self):
return self.getToken(PSParser.R_RIGHT, 0)
def ML_LEFT(self):
return self.getToken(PSParser.ML_LEFT, 0)
def MR_RIGHT(self):
return self.getToken(PSParser.MR_RIGHT, 0)
def getRuleIndex(self):
return PSParser.RULE_abs_group
def enterRule(self, listener):
if hasattr(listener, "enterAbs_group"):
listener.enterAbs_group(self)
def exitRule(self, listener):
if hasattr(listener, "exitAbs_group"):
listener.exitAbs_group(self)
def abs_group(self):
localctx = PSParser.Abs_groupContext(self, self._ctx, self.state)
self.enterRule(localctx, 68, self.RULE_abs_group)
try:
self.state = 637
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 40, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 589
self.match(PSParser.BAR)
self.state = 590
self.expr()
self.state = 591
self.match(PSParser.BAR)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 593
self.match(PSParser.L_VERT)
self.state = 594
self.expr()
self.state = 595
self.match(PSParser.R_VERT)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 597
self.match(PSParser.VERT)
self.state = 598
self.expr()
self.state = 599
self.match(PSParser.VERT)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 601
self.match(PSParser.L_LEFT)
self.state = 602
self.match(PSParser.BAR)
self.state = 603
self.expr()
self.state = 604
self.match(PSParser.R_RIGHT)
self.state = 605
self.match(PSParser.BAR)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 607
self.match(PSParser.L_LEFT)
self.state = 608
self.match(PSParser.L_VERT)
self.state = 609
self.expr()
self.state = 610
self.match(PSParser.R_RIGHT)
self.state = 611
self.match(PSParser.R_VERT)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 613
self.match(PSParser.L_LEFT)
self.state = 614
self.match(PSParser.VERT)
self.state = 615
self.expr()
self.state = 616
self.match(PSParser.R_RIGHT)
self.state = 617
self.match(PSParser.VERT)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 619
self.match(PSParser.ML_LEFT)
self.state = 620
self.match(PSParser.BAR)
self.state = 621
self.expr()
self.state = 622
self.match(PSParser.MR_RIGHT)
self.state = 623
self.match(PSParser.BAR)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 625
self.match(PSParser.ML_LEFT)
self.state = 626
self.match(PSParser.L_VERT)
self.state = 627
self.expr()
self.state = 628
self.match(PSParser.MR_RIGHT)
self.state = 629
self.match(PSParser.R_VERT)
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 631
self.match(PSParser.ML_LEFT)
self.state = 632
self.match(PSParser.VERT)
self.state = 633
self.expr()
self.state = 634
self.match(PSParser.MR_RIGHT)
self.state = 635
self.match(PSParser.VERT)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Floor_groupContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Floor_groupContext, self).__init__(parent, invokingState)
self.parser = parser
def L_FLOOR(self):
return self.getToken(PSParser.L_FLOOR, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def R_FLOOR(self):
return self.getToken(PSParser.R_FLOOR, 0)
def LL_CORNER(self):
return self.getToken(PSParser.LL_CORNER, 0)
def LR_CORNER(self):
return self.getToken(PSParser.LR_CORNER, 0)
def L_LEFT(self):
return self.getToken(PSParser.L_LEFT, 0)
def R_RIGHT(self):
return self.getToken(PSParser.R_RIGHT, 0)
def ML_LEFT(self):
return self.getToken(PSParser.ML_LEFT, 0)
def MR_RIGHT(self):
return self.getToken(PSParser.MR_RIGHT, 0)
def getRuleIndex(self):
return PSParser.RULE_floor_group
def enterRule(self, listener):
if hasattr(listener, "enterFloor_group"):
listener.enterFloor_group(self)
def exitRule(self, listener):
if hasattr(listener, "exitFloor_group"):
listener.exitFloor_group(self)
def floor_group(self):
localctx = PSParser.Floor_groupContext(self, self._ctx, self.state)
self.enterRule(localctx, 70, self.RULE_floor_group)
try:
self.state = 671
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 41, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 639
self.match(PSParser.L_FLOOR)
self.state = 640
self.expr()
self.state = 641
self.match(PSParser.R_FLOOR)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 643
self.match(PSParser.LL_CORNER)
self.state = 644
self.expr()
self.state = 645
self.match(PSParser.LR_CORNER)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 647
self.match(PSParser.L_LEFT)
self.state = 648
self.match(PSParser.L_FLOOR)
self.state = 649
self.expr()
self.state = 650
self.match(PSParser.R_RIGHT)
self.state = 651
self.match(PSParser.R_FLOOR)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 653
self.match(PSParser.L_LEFT)
self.state = 654
self.match(PSParser.LL_CORNER)
self.state = 655
self.expr()
self.state = 656
self.match(PSParser.R_RIGHT)
self.state = 657
self.match(PSParser.LR_CORNER)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 659
self.match(PSParser.ML_LEFT)
self.state = 660
self.match(PSParser.L_FLOOR)
self.state = 661
self.expr()
self.state = 662
self.match(PSParser.MR_RIGHT)
self.state = 663
self.match(PSParser.R_FLOOR)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 665
self.match(PSParser.ML_LEFT)
self.state = 666
self.match(PSParser.LL_CORNER)
self.state = 667
self.expr()
self.state = 668
self.match(PSParser.MR_RIGHT)
self.state = 669
self.match(PSParser.LR_CORNER)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Ceil_groupContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Ceil_groupContext, self).__init__(parent, invokingState)
self.parser = parser
def L_CEIL(self):
return self.getToken(PSParser.L_CEIL, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def R_CEIL(self):
return self.getToken(PSParser.R_CEIL, 0)
def UL_CORNER(self):
return self.getToken(PSParser.UL_CORNER, 0)
def UR_CORNER(self):
return self.getToken(PSParser.UR_CORNER, 0)
def L_LEFT(self):
return self.getToken(PSParser.L_LEFT, 0)
def R_RIGHT(self):
return self.getToken(PSParser.R_RIGHT, 0)
def ML_LEFT(self):
return self.getToken(PSParser.ML_LEFT, 0)
def MR_RIGHT(self):
return self.getToken(PSParser.MR_RIGHT, 0)
def getRuleIndex(self):
return PSParser.RULE_ceil_group
def enterRule(self, listener):
if hasattr(listener, "enterCeil_group"):
listener.enterCeil_group(self)
def exitRule(self, listener):
if hasattr(listener, "exitCeil_group"):
listener.exitCeil_group(self)
def ceil_group(self):
localctx = PSParser.Ceil_groupContext(self, self._ctx, self.state)
self.enterRule(localctx, 72, self.RULE_ceil_group)
try:
self.state = 705
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 42, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 673
self.match(PSParser.L_CEIL)
self.state = 674
self.expr()
self.state = 675
self.match(PSParser.R_CEIL)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 677
self.match(PSParser.UL_CORNER)
self.state = 678
self.expr()
self.state = 679
self.match(PSParser.UR_CORNER)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 681
self.match(PSParser.L_LEFT)
self.state = 682
self.match(PSParser.L_CEIL)
self.state = 683
self.expr()
self.state = 684
self.match(PSParser.R_RIGHT)
self.state = 685
self.match(PSParser.R_CEIL)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 687
self.match(PSParser.L_LEFT)
self.state = 688
self.match(PSParser.UL_CORNER)
self.state = 689
self.expr()
self.state = 690
self.match(PSParser.R_RIGHT)
self.state = 691
self.match(PSParser.UR_CORNER)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 693
self.match(PSParser.ML_LEFT)
self.state = 694
self.match(PSParser.L_CEIL)
self.state = 695
self.expr()
self.state = 696
self.match(PSParser.MR_RIGHT)
self.state = 697
self.match(PSParser.R_CEIL)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 699
self.match(PSParser.ML_LEFT)
self.state = 700
self.match(PSParser.UL_CORNER)
self.state = 701
self.expr()
self.state = 702
self.match(PSParser.MR_RIGHT)
self.state = 703
self.match(PSParser.UR_CORNER)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class AccentContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.AccentContext, self).__init__(parent, invokingState)
self.parser = parser
self.base = None # ExprContext
def accent_symbol(self):
return self.getTypedRuleContext(PSParser.Accent_symbolContext, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def getRuleIndex(self):
return PSParser.RULE_accent
def enterRule(self, listener):
if hasattr(listener, "enterAccent"):
listener.enterAccent(self)
def exitRule(self, listener):
if hasattr(listener, "exitAccent"):
listener.exitAccent(self)
def accent(self):
localctx = PSParser.AccentContext(self, self._ctx, self.state)
self.enterRule(localctx, 74, self.RULE_accent)
try:
self.enterOuterAlt(localctx, 1)
self.state = 707
self.accent_symbol()
self.state = 708
self.match(PSParser.L_BRACE)
self.state = 709
localctx.base = self.expr()
self.state = 710
self.match(PSParser.R_BRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Atom_expr_no_supexprContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Atom_expr_no_supexprContext, self).__init__(
parent, invokingState
)
self.parser = parser
def LETTER_NO_E(self):
return self.getToken(PSParser.LETTER_NO_E, 0)
def GREEK_CMD(self):
return self.getToken(PSParser.GREEK_CMD, 0)
def OTHER_SYMBOL_CMD(self):
return self.getToken(PSParser.OTHER_SYMBOL_CMD, 0)
def accent(self):
return self.getTypedRuleContext(PSParser.AccentContext, 0)
def subexpr(self):
return self.getTypedRuleContext(PSParser.SubexprContext, 0)
def getRuleIndex(self):
return PSParser.RULE_atom_expr_no_supexpr
def enterRule(self, listener):
if hasattr(listener, "enterAtom_expr_no_supexpr"):
listener.enterAtom_expr_no_supexpr(self)
def exitRule(self, listener):
if hasattr(listener, "exitAtom_expr_no_supexpr"):
listener.exitAtom_expr_no_supexpr(self)
def atom_expr_no_supexpr(self):
localctx = PSParser.Atom_expr_no_supexprContext(self, self._ctx, self.state)
self.enterRule(localctx, 76, self.RULE_atom_expr_no_supexpr)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 716
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [176]:
self.state = 712
self.match(PSParser.LETTER_NO_E)
pass
elif token in [191]:
self.state = 713
self.match(PSParser.GREEK_CMD)
pass
elif token in [192]:
self.state = 714
self.match(PSParser.OTHER_SYMBOL_CMD)
pass
elif token in [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
154,
]:
self.state = 715
self.accent()
pass
else:
raise NoViableAltException(self)
self.state = 719
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 167:
self.state = 718
self.subexpr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Atom_exprContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Atom_exprContext, self).__init__(parent, invokingState)
self.parser = parser
def LETTER_NO_E(self):
return self.getToken(PSParser.LETTER_NO_E, 0)
def GREEK_CMD(self):
return self.getToken(PSParser.GREEK_CMD, 0)
def OTHER_SYMBOL_CMD(self):
return self.getToken(PSParser.OTHER_SYMBOL_CMD, 0)
def accent(self):
return self.getTypedRuleContext(PSParser.AccentContext, 0)
def supexpr(self):
return self.getTypedRuleContext(PSParser.SupexprContext, 0)
def subexpr(self):
return self.getTypedRuleContext(PSParser.SubexprContext, 0)
def getRuleIndex(self):
return PSParser.RULE_atom_expr
def enterRule(self, listener):
if hasattr(listener, "enterAtom_expr"):
listener.enterAtom_expr(self)
def exitRule(self, listener):
if hasattr(listener, "exitAtom_expr"):
listener.exitAtom_expr(self)
def atom_expr(self):
localctx = PSParser.Atom_exprContext(self, self._ctx, self.state)
self.enterRule(localctx, 78, self.RULE_atom_expr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 725
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [176]:
self.state = 721
self.match(PSParser.LETTER_NO_E)
pass
elif token in [191]:
self.state = 722
self.match(PSParser.GREEK_CMD)
pass
elif token in [192]:
self.state = 723
self.match(PSParser.OTHER_SYMBOL_CMD)
pass
elif token in [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
154,
]:
self.state = 724
self.accent()
pass
else:
raise NoViableAltException(self)
self.state = 735
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 46, self._ctx)
if la_ == 1:
self.state = 727
self.supexpr()
self.state = 728
self.subexpr()
elif la_ == 2:
self.state = 730
self.subexpr()
self.state = 731
self.supexpr()
elif la_ == 3:
self.state = 733
self.subexpr()
elif la_ == 4:
self.state = 734
self.supexpr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class AtomContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.AtomContext, self).__init__(parent, invokingState)
self.parser = parser
def atom_expr(self):
return self.getTypedRuleContext(PSParser.Atom_exprContext, 0)
def SYMBOL(self):
return self.getToken(PSParser.SYMBOL, 0)
def NUMBER(self):
return self.getToken(PSParser.NUMBER, 0)
def PERCENT_NUMBER(self):
return self.getToken(PSParser.PERCENT_NUMBER, 0)
def E_NOTATION(self):
return self.getToken(PSParser.E_NOTATION, 0)
def DIFFERENTIAL(self):
return self.getToken(PSParser.DIFFERENTIAL, 0)
def mathit(self):
return self.getTypedRuleContext(PSParser.MathitContext, 0)
def VARIABLE(self):
return self.getToken(PSParser.VARIABLE, 0)
def getRuleIndex(self):
return PSParser.RULE_atom
def enterRule(self, listener):
if hasattr(listener, "enterAtom"):
listener.enterAtom(self)
def exitRule(self, listener):
if hasattr(listener, "exitAtom"):
listener.exitAtom(self)
def atom(self):
localctx = PSParser.AtomContext(self, self._ctx, self.state)
self.enterRule(localctx, 80, self.RULE_atom)
try:
self.state = 745
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 47, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 737
self.atom_expr()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 738
self.match(PSParser.SYMBOL)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 739
self.match(PSParser.NUMBER)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 740
self.match(PSParser.PERCENT_NUMBER)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 741
self.match(PSParser.E_NOTATION)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 742
self.match(PSParser.DIFFERENTIAL)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 743
self.mathit()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 744
self.match(PSParser.VARIABLE)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class MathitContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.MathitContext, self).__init__(parent, invokingState)
self.parser = parser
def CMD_MATHIT(self):
return self.getToken(PSParser.CMD_MATHIT, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def mathit_text(self):
return self.getTypedRuleContext(PSParser.Mathit_textContext, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def getRuleIndex(self):
return PSParser.RULE_mathit
def enterRule(self, listener):
if hasattr(listener, "enterMathit"):
listener.enterMathit(self)
def exitRule(self, listener):
if hasattr(listener, "exitMathit"):
listener.exitMathit(self)
def mathit(self):
localctx = PSParser.MathitContext(self, self._ctx, self.state)
self.enterRule(localctx, 82, self.RULE_mathit)
try:
self.enterOuterAlt(localctx, 1)
self.state = 747
self.match(PSParser.CMD_MATHIT)
self.state = 748
self.match(PSParser.L_BRACE)
self.state = 749
self.mathit_text()
self.state = 750
self.match(PSParser.R_BRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Mathit_textContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Mathit_textContext, self).__init__(parent, invokingState)
self.parser = parser
def LETTER_NO_E(self, i=None):
if i is None:
return self.getTokens(PSParser.LETTER_NO_E)
else:
return self.getToken(PSParser.LETTER_NO_E, i)
def E_NOTATION_E(self, i=None):
if i is None:
return self.getTokens(PSParser.E_NOTATION_E)
else:
return self.getToken(PSParser.E_NOTATION_E, i)
def EXP_E(self, i=None):
if i is None:
return self.getTokens(PSParser.EXP_E)
else:
return self.getToken(PSParser.EXP_E, i)
def getRuleIndex(self):
return PSParser.RULE_mathit_text
def enterRule(self, listener):
if hasattr(listener, "enterMathit_text"):
listener.enterMathit_text(self)
def exitRule(self, listener):
if hasattr(listener, "exitMathit_text"):
listener.exitMathit_text(self)
def mathit_text(self):
localctx = PSParser.Mathit_textContext(self, self._ctx, self.state)
self.enterRule(localctx, 84, self.RULE_mathit_text)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 753
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 752
_la = self._input.LA(1)
if not ((((_la - 174)) & ~0x3F) == 0 and ((1 << (_la - 174)) & 7) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 755
self._errHandler.sync(self)
_la = self._input.LA(1)
if not ((((_la - 174)) & ~0x3F) == 0 and ((1 << (_la - 174)) & 7) != 0):
break
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class FracContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.FracContext, self).__init__(parent, invokingState)
self.parser = parser
self.upper = None # ExprContext
self.lower = None # ExprContext
def CMD_FRAC(self):
return self.getToken(PSParser.CMD_FRAC, 0)
def L_BRACE(self, i=None):
if i is None:
return self.getTokens(PSParser.L_BRACE)
else:
return self.getToken(PSParser.L_BRACE, i)
def R_BRACE(self, i=None):
if i is None:
return self.getTokens(PSParser.R_BRACE)
else:
return self.getToken(PSParser.R_BRACE, i)
def expr(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.ExprContext)
else:
return self.getTypedRuleContext(PSParser.ExprContext, i)
def getRuleIndex(self):
return PSParser.RULE_frac
def enterRule(self, listener):
if hasattr(listener, "enterFrac"):
listener.enterFrac(self)
def exitRule(self, listener):
if hasattr(listener, "exitFrac"):
listener.exitFrac(self)
def frac(self):
localctx = PSParser.FracContext(self, self._ctx, self.state)
self.enterRule(localctx, 86, self.RULE_frac)
try:
self.enterOuterAlt(localctx, 1)
self.state = 757
self.match(PSParser.CMD_FRAC)
self.state = 758
self.match(PSParser.L_BRACE)
self.state = 759
localctx.upper = self.expr()
self.state = 760
self.match(PSParser.R_BRACE)
self.state = 761
self.match(PSParser.L_BRACE)
self.state = 762
localctx.lower = self.expr()
self.state = 763
self.match(PSParser.R_BRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class BinomContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.BinomContext, self).__init__(parent, invokingState)
self.parser = parser
self.upper = None # ExprContext
self.lower = None # ExprContext
def L_BRACE(self, i=None):
if i is None:
return self.getTokens(PSParser.L_BRACE)
else:
return self.getToken(PSParser.L_BRACE, i)
def CMD_CHOOSE(self):
return self.getToken(PSParser.CMD_CHOOSE, 0)
def R_BRACE(self, i=None):
if i is None:
return self.getTokens(PSParser.R_BRACE)
else:
return self.getToken(PSParser.R_BRACE, i)
def expr(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.ExprContext)
else:
return self.getTypedRuleContext(PSParser.ExprContext, i)
def CMD_BINOM(self):
return self.getToken(PSParser.CMD_BINOM, 0)
def getRuleIndex(self):
return PSParser.RULE_binom
def enterRule(self, listener):
if hasattr(listener, "enterBinom"):
listener.enterBinom(self)
def exitRule(self, listener):
if hasattr(listener, "exitBinom"):
listener.exitBinom(self)
def binom(self):
localctx = PSParser.BinomContext(self, self._ctx, self.state)
self.enterRule(localctx, 88, self.RULE_binom)
try:
self.state = 779
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [55]:
self.enterOuterAlt(localctx, 1)
self.state = 765
self.match(PSParser.L_BRACE)
self.state = 766
localctx.upper = self.expr()
self.state = 767
self.match(PSParser.CMD_CHOOSE)
self.state = 768
localctx.lower = self.expr()
self.state = 769
self.match(PSParser.R_BRACE)
pass
elif token in [151]:
self.enterOuterAlt(localctx, 2)
self.state = 771
self.match(PSParser.CMD_BINOM)
self.state = 772
self.match(PSParser.L_BRACE)
self.state = 773
localctx.upper = self.expr()
self.state = 774
self.match(PSParser.R_BRACE)
self.state = 775
self.match(PSParser.L_BRACE)
self.state = 776
localctx.lower = self.expr()
self.state = 777
self.match(PSParser.R_BRACE)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_normal_functions_single_argContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_normal_functions_single_argContext, self).__init__(
parent, invokingState
)
self.parser = parser
def FUNC_LOG(self):
return self.getToken(PSParser.FUNC_LOG, 0)
def FUNC_LN(self):
return self.getToken(PSParser.FUNC_LN, 0)
def FUNC_EXP(self):
return self.getToken(PSParser.FUNC_EXP, 0)
def FUNC_SIN(self):
return self.getToken(PSParser.FUNC_SIN, 0)
def FUNC_COS(self):
return self.getToken(PSParser.FUNC_COS, 0)
def FUNC_TAN(self):
return self.getToken(PSParser.FUNC_TAN, 0)
def FUNC_CSC(self):
return self.getToken(PSParser.FUNC_CSC, 0)
def FUNC_SEC(self):
return self.getToken(PSParser.FUNC_SEC, 0)
def FUNC_COT(self):
return self.getToken(PSParser.FUNC_COT, 0)
def FUNC_ARCSIN(self):
return self.getToken(PSParser.FUNC_ARCSIN, 0)
def FUNC_ARCCOS(self):
return self.getToken(PSParser.FUNC_ARCCOS, 0)
def FUNC_ARCTAN(self):
return self.getToken(PSParser.FUNC_ARCTAN, 0)
def FUNC_ARCCSC(self):
return self.getToken(PSParser.FUNC_ARCCSC, 0)
def FUNC_ARCSEC(self):
return self.getToken(PSParser.FUNC_ARCSEC, 0)
def FUNC_ARCCOT(self):
return self.getToken(PSParser.FUNC_ARCCOT, 0)
def FUNC_SINH(self):
return self.getToken(PSParser.FUNC_SINH, 0)
def FUNC_COSH(self):
return self.getToken(PSParser.FUNC_COSH, 0)
def FUNC_TANH(self):
return self.getToken(PSParser.FUNC_TANH, 0)
def FUNC_ARSINH(self):
return self.getToken(PSParser.FUNC_ARSINH, 0)
def FUNC_ARCOSH(self):
return self.getToken(PSParser.FUNC_ARCOSH, 0)
def FUNC_ARTANH(self):
return self.getToken(PSParser.FUNC_ARTANH, 0)
def FUNC_ARCSINH(self):
return self.getToken(PSParser.FUNC_ARCSINH, 0)
def FUNC_ARCCOSH(self):
return self.getToken(PSParser.FUNC_ARCCOSH, 0)
def FUNC_ARCTANH(self):
return self.getToken(PSParser.FUNC_ARCTANH, 0)
def FUNC_FLOOR(self):
return self.getToken(PSParser.FUNC_FLOOR, 0)
def FUNC_CEIL(self):
return self.getToken(PSParser.FUNC_CEIL, 0)
def FUNC_DET(self):
return self.getToken(PSParser.FUNC_DET, 0)
def getRuleIndex(self):
return PSParser.RULE_func_normal_functions_single_arg
def enterRule(self, listener):
if hasattr(listener, "enterFunc_normal_functions_single_arg"):
listener.enterFunc_normal_functions_single_arg(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_normal_functions_single_arg"):
listener.exitFunc_normal_functions_single_arg(self)
def func_normal_functions_single_arg(self):
localctx = PSParser.Func_normal_functions_single_argContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 90, self.RULE_func_normal_functions_single_arg)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 781
_la = self._input.LA(1)
if not (
(((_la - 87)) & ~0x3F) == 0 and ((1 << (_la - 87)) & 2611356893183) != 0
):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_normal_functions_multi_argContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_normal_functions_multi_argContext, self).__init__(
parent, invokingState
)
self.parser = parser
def FUNC_GCD(self):
return self.getToken(PSParser.FUNC_GCD, 0)
def FUNC_LCM(self):
return self.getToken(PSParser.FUNC_LCM, 0)
def FUNC_MAX(self):
return self.getToken(PSParser.FUNC_MAX, 0)
def FUNC_MIN(self):
return self.getToken(PSParser.FUNC_MIN, 0)
def getRuleIndex(self):
return PSParser.RULE_func_normal_functions_multi_arg
def enterRule(self, listener):
if hasattr(listener, "enterFunc_normal_functions_multi_arg"):
listener.enterFunc_normal_functions_multi_arg(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_normal_functions_multi_arg"):
listener.exitFunc_normal_functions_multi_arg(self)
def func_normal_functions_multi_arg(self):
localctx = PSParser.Func_normal_functions_multi_argContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 92, self.RULE_func_normal_functions_multi_arg)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 783
_la = self._input.LA(1)
if not ((((_la - 122)) & ~0x3F) == 0 and ((1 << (_la - 122)) & 51) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_operator_names_single_argContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_operator_names_single_argContext, self).__init__(
parent, invokingState
)
self.parser = parser
def FUNC_ARSINH_NAME(self):
return self.getToken(PSParser.FUNC_ARSINH_NAME, 0)
def FUNC_ARCOSH_NAME(self):
return self.getToken(PSParser.FUNC_ARCOSH_NAME, 0)
def FUNC_ARTANH_NAME(self):
return self.getToken(PSParser.FUNC_ARTANH_NAME, 0)
def FUNC_ARCSINH_NAME(self):
return self.getToken(PSParser.FUNC_ARCSINH_NAME, 0)
def FUNC_ARCCOSH_NAME(self):
return self.getToken(PSParser.FUNC_ARCCOSH_NAME, 0)
def FUNC_ARCTANH_NAME(self):
return self.getToken(PSParser.FUNC_ARCTANH_NAME, 0)
def FUNC_FLOOR_NAME(self):
return self.getToken(PSParser.FUNC_FLOOR_NAME, 0)
def FUNC_CEIL_NAME(self):
return self.getToken(PSParser.FUNC_CEIL_NAME, 0)
def FUNC_EYE_NAME(self):
return self.getToken(PSParser.FUNC_EYE_NAME, 0)
def FUNC_RANK_NAME(self):
return self.getToken(PSParser.FUNC_RANK_NAME, 0)
def FUNC_TRACE_NAME(self):
return self.getToken(PSParser.FUNC_TRACE_NAME, 0)
def FUNC_RREF_NAME(self):
return self.getToken(PSParser.FUNC_RREF_NAME, 0)
def FUNC_NULLSPACE_NAME(self):
return self.getToken(PSParser.FUNC_NULLSPACE_NAME, 0)
def FUNC_DIAGONALIZE_NAME(self):
return self.getToken(PSParser.FUNC_DIAGONALIZE_NAME, 0)
def FUNC_NORM_NAME(self):
return self.getToken(PSParser.FUNC_NORM_NAME, 0)
def FUNC_EIGENVALS_NAME(self):
return self.getToken(PSParser.FUNC_EIGENVALS_NAME, 0)
def FUNC_EIGENVECTORS_NAME(self):
return self.getToken(PSParser.FUNC_EIGENVECTORS_NAME, 0)
def FUNC_SVD_NAME(self):
return self.getToken(PSParser.FUNC_SVD_NAME, 0)
def FUNC_COLS_NAME(self):
return self.getToken(PSParser.FUNC_COLS_NAME, 0)
def FUNC_ROWS_NAME(self):
return self.getToken(PSParser.FUNC_ROWS_NAME, 0)
def getRuleIndex(self):
return PSParser.RULE_func_operator_names_single_arg
def enterRule(self, listener):
if hasattr(listener, "enterFunc_operator_names_single_arg"):
listener.enterFunc_operator_names_single_arg(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_operator_names_single_arg"):
listener.exitFunc_operator_names_single_arg(self)
def func_operator_names_single_arg(self):
localctx = PSParser.Func_operator_names_single_argContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 94, self.RULE_func_operator_names_single_arg)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 785
_la = self._input.LA(1)
if not (
(((_la - 111)) & ~0x3F) == 0 and ((1 << (_la - 111)) & 66830205759) != 0
):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_operator_names_multi_argContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_operator_names_multi_argContext, self).__init__(
parent, invokingState
)
self.parser = parser
def FUNC_GCD_NAME(self):
return self.getToken(PSParser.FUNC_GCD_NAME, 0)
def FUNC_LCM_NAME(self):
return self.getToken(PSParser.FUNC_LCM_NAME, 0)
def FUNC_ZEROS_NAME(self):
return self.getToken(PSParser.FUNC_ZEROS_NAME, 0)
def FUNC_ORTHOGONALIZE_NAME(self):
return self.getToken(PSParser.FUNC_ORTHOGONALIZE_NAME, 0)
def FUNC_ONES_NAME(self):
return self.getToken(PSParser.FUNC_ONES_NAME, 0)
def FUNC_DIAG_NAME(self):
return self.getToken(PSParser.FUNC_DIAG_NAME, 0)
def FUNC_HSTACK_NAME(self):
return self.getToken(PSParser.FUNC_HSTACK_NAME, 0)
def FUNC_VSTACK_NAME(self):
return self.getToken(PSParser.FUNC_VSTACK_NAME, 0)
def getRuleIndex(self):
return PSParser.RULE_func_operator_names_multi_arg
def enterRule(self, listener):
if hasattr(listener, "enterFunc_operator_names_multi_arg"):
listener.enterFunc_operator_names_multi_arg(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_operator_names_multi_arg"):
listener.exitFunc_operator_names_multi_arg(self)
def func_operator_names_multi_arg(self):
localctx = PSParser.Func_operator_names_multi_argContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 96, self.RULE_func_operator_names_multi_arg)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 787
_la = self._input.LA(1)
if not (
(((_la - 117)) & ~0x3F) == 0 and ((1 << (_la - 117)) & 29515779) != 0
):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_normal_single_argContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_normal_single_argContext, self).__init__(
parent, invokingState
)
self.parser = parser
self.func_operator_name = None # Func_operator_names_single_argContext
def func_normal_functions_single_arg(self):
return self.getTypedRuleContext(
PSParser.Func_normal_functions_single_argContext, 0
)
def CMD_OPERATORNAME(self):
return self.getToken(PSParser.CMD_OPERATORNAME, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def func_operator_names_single_arg(self):
return self.getTypedRuleContext(
PSParser.Func_operator_names_single_argContext, 0
)
def getRuleIndex(self):
return PSParser.RULE_func_normal_single_arg
def enterRule(self, listener):
if hasattr(listener, "enterFunc_normal_single_arg"):
listener.enterFunc_normal_single_arg(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_normal_single_arg"):
listener.exitFunc_normal_single_arg(self)
def func_normal_single_arg(self):
localctx = PSParser.Func_normal_single_argContext(self, self._ctx, self.state)
self.enterRule(localctx, 98, self.RULE_func_normal_single_arg)
try:
self.state = 795
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
87,
88,
89,
90,
91,
92,
93,
94,
95,
96,
97,
98,
99,
100,
101,
102,
103,
104,
105,
106,
107,
108,
109,
110,
124,
125,
128,
]:
self.enterOuterAlt(localctx, 1)
self.state = 789
self.func_normal_functions_single_arg()
pass
elif token in [155]:
self.enterOuterAlt(localctx, 2)
self.state = 790
self.match(PSParser.CMD_OPERATORNAME)
self.state = 791
self.match(PSParser.L_BRACE)
self.state = 792
localctx.func_operator_name = self.func_operator_names_single_arg()
self.state = 793
self.match(PSParser.R_BRACE)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_normal_multi_argContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_normal_multi_argContext, self).__init__(
parent, invokingState
)
self.parser = parser
self.func_operator_name = None # Func_operator_names_multi_argContext
def func_normal_functions_multi_arg(self):
return self.getTypedRuleContext(
PSParser.Func_normal_functions_multi_argContext, 0
)
def CMD_OPERATORNAME(self):
return self.getToken(PSParser.CMD_OPERATORNAME, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def func_operator_names_multi_arg(self):
return self.getTypedRuleContext(
PSParser.Func_operator_names_multi_argContext, 0
)
def getRuleIndex(self):
return PSParser.RULE_func_normal_multi_arg
def enterRule(self, listener):
if hasattr(listener, "enterFunc_normal_multi_arg"):
listener.enterFunc_normal_multi_arg(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_normal_multi_arg"):
listener.exitFunc_normal_multi_arg(self)
def func_normal_multi_arg(self):
localctx = PSParser.Func_normal_multi_argContext(self, self._ctx, self.state)
self.enterRule(localctx, 100, self.RULE_func_normal_multi_arg)
try:
self.state = 803
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [122, 123, 126, 127]:
self.enterOuterAlt(localctx, 1)
self.state = 797
self.func_normal_functions_multi_arg()
pass
elif token in [155]:
self.enterOuterAlt(localctx, 2)
self.state = 798
self.match(PSParser.CMD_OPERATORNAME)
self.state = 799
self.match(PSParser.L_BRACE)
self.state = 800
localctx.func_operator_name = self.func_operator_names_multi_arg()
self.state = 801
self.match(PSParser.R_BRACE)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class FuncContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.FuncContext, self).__init__(parent, invokingState)
self.parser = parser
self.root = None # ExprContext
self.base = None # ExprContext
def func_normal_single_arg(self):
return self.getTypedRuleContext(PSParser.Func_normal_single_argContext, 0)
def L_PAREN(self):
return self.getToken(PSParser.L_PAREN, 0)
def func_single_arg(self):
return self.getTypedRuleContext(PSParser.Func_single_argContext, 0)
def R_PAREN(self):
return self.getToken(PSParser.R_PAREN, 0)
def func_single_arg_noparens(self):
return self.getTypedRuleContext(PSParser.Func_single_arg_noparensContext, 0)
def subexpr(self):
return self.getTypedRuleContext(PSParser.SubexprContext, 0)
def supexpr(self):
return self.getTypedRuleContext(PSParser.SupexprContext, 0)
def L_LEFT(self):
return self.getToken(PSParser.L_LEFT, 0)
def R_RIGHT(self):
return self.getToken(PSParser.R_RIGHT, 0)
def ML_LEFT(self):
return self.getToken(PSParser.ML_LEFT, 0)
def MR_RIGHT(self):
return self.getToken(PSParser.MR_RIGHT, 0)
def func_normal_multi_arg(self):
return self.getTypedRuleContext(PSParser.Func_normal_multi_argContext, 0)
def func_multi_arg(self):
return self.getTypedRuleContext(PSParser.Func_multi_argContext, 0)
def func_multi_arg_noparens(self):
return self.getTypedRuleContext(PSParser.Func_multi_arg_noparensContext, 0)
def atom_expr_no_supexpr(self):
return self.getTypedRuleContext(PSParser.Atom_expr_no_supexprContext, 0)
def func_common_args(self):
return self.getTypedRuleContext(PSParser.Func_common_argsContext, 0)
def L_BRACKET(self):
return self.getToken(PSParser.L_BRACKET, 0)
def R_BRACKET(self):
return self.getToken(PSParser.R_BRACKET, 0)
def L_BRACE(self, i=None):
if i is None:
return self.getTokens(PSParser.L_BRACE)
else:
return self.getToken(PSParser.L_BRACE, i)
def R_BRACE(self, i=None):
if i is None:
return self.getTokens(PSParser.R_BRACE)
else:
return self.getToken(PSParser.R_BRACE, i)
def FUNC_INT(self):
return self.getToken(PSParser.FUNC_INT, 0)
def DIFFERENTIAL(self):
return self.getToken(PSParser.DIFFERENTIAL, 0)
def frac(self):
return self.getTypedRuleContext(PSParser.FracContext, 0)
def additive(self):
return self.getTypedRuleContext(PSParser.AdditiveContext, 0)
def UNDERSCORE(self):
return self.getToken(PSParser.UNDERSCORE, 0)
def CARET(self):
return self.getToken(PSParser.CARET, 0)
def FUNC_SQRT(self):
return self.getToken(PSParser.FUNC_SQRT, 0)
def expr(self, i=None):
if i is None:
return self.getTypedRuleContexts(PSParser.ExprContext)
else:
return self.getTypedRuleContext(PSParser.ExprContext, i)
def mp(self):
return self.getTypedRuleContext(PSParser.MpContext, 0)
def FUNC_SUM(self):
return self.getToken(PSParser.FUNC_SUM, 0)
def FUNC_PROD(self):
return self.getToken(PSParser.FUNC_PROD, 0)
def subeq(self):
return self.getTypedRuleContext(PSParser.SubeqContext, 0)
def FUNC_LIM(self):
return self.getToken(PSParser.FUNC_LIM, 0)
def limit_sub(self):
return self.getTypedRuleContext(PSParser.Limit_subContext, 0)
def EXP_E(self):
return self.getToken(PSParser.EXP_E, 0)
def getRuleIndex(self):
return PSParser.RULE_func
def enterRule(self, listener):
if hasattr(listener, "enterFunc"):
listener.enterFunc(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc"):
listener.exitFunc(self)
def func(self):
localctx = PSParser.FuncContext(self, self._ctx, self.state)
self.enterRule(localctx, 102, self.RULE_func)
self._la = 0 # Token type
try:
self.state = 971
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 84, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 805
self.func_normal_single_arg()
self.state = 818
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 56, self._ctx)
if la_ == 1:
self.state = 807
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 167:
self.state = 806
self.subexpr()
self.state = 810
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 168:
self.state = 809
self.supexpr()
pass
elif la_ == 2:
self.state = 813
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 168:
self.state = 812
self.supexpr()
self.state = 816
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 167:
self.state = 815
self.subexpr()
pass
self.state = 841
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 61, self._ctx)
if la_ == 1:
self.state = 821
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 78:
self.state = 820
self.match(PSParser.L_LEFT)
self.state = 823
self.match(PSParser.L_PAREN)
self.state = 824
self.func_single_arg()
self.state = 826
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 79:
self.state = 825
self.match(PSParser.R_RIGHT)
self.state = 828
self.match(PSParser.R_PAREN)
pass
elif la_ == 2:
self.state = 831
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 830
self.match(PSParser.ML_LEFT)
self.state = 833
self.match(PSParser.L_PAREN)
self.state = 834
self.func_single_arg()
self.state = 836
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 81:
self.state = 835
self.match(PSParser.MR_RIGHT)
self.state = 838
self.match(PSParser.R_PAREN)
pass
elif la_ == 3:
self.state = 840
self.func_single_arg_noparens()
pass
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 843
self.func_normal_multi_arg()
self.state = 856
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 66, self._ctx)
if la_ == 1:
self.state = 845
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 167:
self.state = 844
self.subexpr()
self.state = 848
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 168:
self.state = 847
self.supexpr()
pass
elif la_ == 2:
self.state = 851
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 168:
self.state = 850
self.supexpr()
self.state = 854
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 167:
self.state = 853
self.subexpr()
pass
self.state = 879
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 71, self._ctx)
if la_ == 1:
self.state = 859
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 78:
self.state = 858
self.match(PSParser.L_LEFT)
self.state = 861
self.match(PSParser.L_PAREN)
self.state = 862
self.func_multi_arg()
self.state = 864
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 79:
self.state = 863
self.match(PSParser.R_RIGHT)
self.state = 866
self.match(PSParser.R_PAREN)
pass
elif la_ == 2:
self.state = 869
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 868
self.match(PSParser.ML_LEFT)
self.state = 871
self.match(PSParser.L_PAREN)
self.state = 872
self.func_multi_arg()
self.state = 874
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 81:
self.state = 873
self.match(PSParser.MR_RIGHT)
self.state = 876
self.match(PSParser.R_PAREN)
pass
elif la_ == 3:
self.state = 878
self.func_multi_arg_noparens()
pass
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 881
self.atom_expr_no_supexpr()
self.state = 883
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 168:
self.state = 882
self.supexpr()
self.state = 886
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 78:
self.state = 885
self.match(PSParser.L_LEFT)
self.state = 888
_la = self._input.LA(1)
if not (_la == 51 or _la == 61):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 889
self.func_common_args()
self.state = 890
_la = self._input.LA(1)
if not (_la == 52 or _la == 62):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 892
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 74, self._ctx)
if la_ == 1:
self.state = 891
self.match(PSParser.R_RIGHT)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 894
self.atom_expr_no_supexpr()
self.state = 896
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 168:
self.state = 895
self.supexpr()
self.state = 898
self.match(PSParser.L_BRACE)
self.state = 900
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 78:
self.state = 899
self.match(PSParser.L_LEFT)
self.state = 902
_la = self._input.LA(1)
if not (_la == 51 or _la == 61):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 903
self.func_common_args()
self.state = 904
_la = self._input.LA(1)
if not (_la == 52 or _la == 62):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 906
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 79:
self.state = 905
self.match(PSParser.R_RIGHT)
self.state = 908
self.match(PSParser.R_BRACE)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 910
self.match(PSParser.FUNC_INT)
self.state = 931
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 78, self._ctx)
if la_ == 1:
self.state = 911
self.subexpr()
self.state = 912
self.supexpr()
elif la_ == 2:
self.state = 914
self.supexpr()
self.state = 915
self.subexpr()
elif la_ == 3:
self.state = 917
self.match(PSParser.UNDERSCORE)
self.state = 918
self.match(PSParser.L_BRACE)
self.state = 919
self.match(PSParser.R_BRACE)
self.state = 921
self.match(PSParser.CARET)
self.state = 922
self.match(PSParser.L_BRACE)
self.state = 923
self.match(PSParser.R_BRACE)
elif la_ == 4:
self.state = 924
self.match(PSParser.CARET)
self.state = 925
self.match(PSParser.L_BRACE)
self.state = 926
self.match(PSParser.R_BRACE)
self.state = 928
self.match(PSParser.UNDERSCORE)
self.state = 929
self.match(PSParser.L_BRACE)
self.state = 930
self.match(PSParser.R_BRACE)
self.state = 939
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 80, self._ctx)
if la_ == 1:
self.state = 934
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 79, self._ctx)
if la_ == 1:
self.state = 933
self.additive(0)
self.state = 936
self.match(PSParser.DIFFERENTIAL)
pass
elif la_ == 2:
self.state = 937
self.frac()
pass
elif la_ == 3:
self.state = 938
self.additive(0)
pass
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 941
self.match(PSParser.FUNC_SQRT)
self.state = 946
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 61:
self.state = 942
self.match(PSParser.L_BRACKET)
self.state = 943
localctx.root = self.expr()
self.state = 944
self.match(PSParser.R_BRACKET)
self.state = 948
self.match(PSParser.L_BRACE)
self.state = 949
localctx.base = self.expr()
self.state = 950
self.match(PSParser.R_BRACE)
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 952
_la = self._input.LA(1)
if not (_la == 85 or _la == 86):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 959
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [167]:
self.state = 953
self.subeq()
self.state = 954
self.supexpr()
pass
elif token in [168]:
self.state = 956
self.supexpr()
self.state = 957
self.subeq()
pass
else:
raise NoViableAltException(self)
self.state = 961
self.mp(0)
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 963
self.match(PSParser.FUNC_LIM)
self.state = 964
self.limit_sub()
self.state = 965
self.mp(0)
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 967
self.match(PSParser.EXP_E)
self.state = 969
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 83, self._ctx)
if la_ == 1:
self.state = 968
self.supexpr()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class ArgsContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.ArgsContext, self).__init__(parent, invokingState)
self.parser = parser
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def COMMA(self):
return self.getToken(PSParser.COMMA, 0)
def args(self):
return self.getTypedRuleContext(PSParser.ArgsContext, 0)
def getRuleIndex(self):
return PSParser.RULE_args
def enterRule(self, listener):
if hasattr(listener, "enterArgs"):
listener.enterArgs(self)
def exitRule(self, listener):
if hasattr(listener, "exitArgs"):
listener.exitArgs(self)
def args(self):
localctx = PSParser.ArgsContext(self, self._ctx, self.state)
self.enterRule(localctx, 104, self.RULE_args)
try:
self.state = 978
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 85, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 973
self.expr()
self.state = 974
self.match(PSParser.COMMA)
self.state = 975
self.args()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 977
self.expr()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_common_argsContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_common_argsContext, self).__init__(
parent, invokingState
)
self.parser = parser
def atom(self):
return self.getTypedRuleContext(PSParser.AtomContext, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def COMMA(self):
return self.getToken(PSParser.COMMA, 0)
def args(self):
return self.getTypedRuleContext(PSParser.ArgsContext, 0)
def getRuleIndex(self):
return PSParser.RULE_func_common_args
def enterRule(self, listener):
if hasattr(listener, "enterFunc_common_args"):
listener.enterFunc_common_args(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_common_args"):
listener.exitFunc_common_args(self)
def func_common_args(self):
localctx = PSParser.Func_common_argsContext(self, self._ctx, self.state)
self.enterRule(localctx, 106, self.RULE_func_common_args)
try:
self.state = 988
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 86, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 980
self.atom()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 981
self.expr()
self.state = 982
self.match(PSParser.COMMA)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 984
self.expr()
self.state = 985
self.match(PSParser.COMMA)
self.state = 986
self.args()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Limit_subContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Limit_subContext, self).__init__(parent, invokingState)
self.parser = parser
def UNDERSCORE(self):
return self.getToken(PSParser.UNDERSCORE, 0)
def L_BRACE(self, i=None):
if i is None:
return self.getTokens(PSParser.L_BRACE)
else:
return self.getToken(PSParser.L_BRACE, i)
def LIM_APPROACH_SYM(self):
return self.getToken(PSParser.LIM_APPROACH_SYM, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def R_BRACE(self, i=None):
if i is None:
return self.getTokens(PSParser.R_BRACE)
else:
return self.getToken(PSParser.R_BRACE, i)
def LETTER_NO_E(self):
return self.getToken(PSParser.LETTER_NO_E, 0)
def GREEK_CMD(self):
return self.getToken(PSParser.GREEK_CMD, 0)
def OTHER_SYMBOL_CMD(self):
return self.getToken(PSParser.OTHER_SYMBOL_CMD, 0)
def CARET(self):
return self.getToken(PSParser.CARET, 0)
def ADD(self):
return self.getToken(PSParser.ADD, 0)
def SUB(self):
return self.getToken(PSParser.SUB, 0)
def getRuleIndex(self):
return PSParser.RULE_limit_sub
def enterRule(self, listener):
if hasattr(listener, "enterLimit_sub"):
listener.enterLimit_sub(self)
def exitRule(self, listener):
if hasattr(listener, "exitLimit_sub"):
listener.exitLimit_sub(self)
def limit_sub(self):
localctx = PSParser.Limit_subContext(self, self._ctx, self.state)
self.enterRule(localctx, 108, self.RULE_limit_sub)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 990
self.match(PSParser.UNDERSCORE)
self.state = 991
self.match(PSParser.L_BRACE)
self.state = 992
_la = self._input.LA(1)
if not ((((_la - 176)) & ~0x3F) == 0 and ((1 << (_la - 176)) & 98305) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 993
self.match(PSParser.LIM_APPROACH_SYM)
self.state = 994
self.expr()
self.state = 999
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 168:
self.state = 995
self.match(PSParser.CARET)
self.state = 996
self.match(PSParser.L_BRACE)
self.state = 997
_la = self._input.LA(1)
if not (_la == 47 or _la == 48):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 998
self.match(PSParser.R_BRACE)
self.state = 1001
self.match(PSParser.R_BRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_single_argContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_single_argContext, self).__init__(parent, invokingState)
self.parser = parser
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def getRuleIndex(self):
return PSParser.RULE_func_single_arg
def enterRule(self, listener):
if hasattr(listener, "enterFunc_single_arg"):
listener.enterFunc_single_arg(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_single_arg"):
listener.exitFunc_single_arg(self)
def func_single_arg(self):
localctx = PSParser.Func_single_argContext(self, self._ctx, self.state)
self.enterRule(localctx, 110, self.RULE_func_single_arg)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1003
self.expr()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_single_arg_noparensContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_single_arg_noparensContext, self).__init__(
parent, invokingState
)
self.parser = parser
def mp_nofunc(self):
return self.getTypedRuleContext(PSParser.Mp_nofuncContext, 0)
def getRuleIndex(self):
return PSParser.RULE_func_single_arg_noparens
def enterRule(self, listener):
if hasattr(listener, "enterFunc_single_arg_noparens"):
listener.enterFunc_single_arg_noparens(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_single_arg_noparens"):
listener.exitFunc_single_arg_noparens(self)
def func_single_arg_noparens(self):
localctx = PSParser.Func_single_arg_noparensContext(self, self._ctx, self.state)
self.enterRule(localctx, 112, self.RULE_func_single_arg_noparens)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1005
self.mp_nofunc(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_multi_argContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_multi_argContext, self).__init__(parent, invokingState)
self.parser = parser
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def COMMA(self):
return self.getToken(PSParser.COMMA, 0)
def func_multi_arg(self):
return self.getTypedRuleContext(PSParser.Func_multi_argContext, 0)
def getRuleIndex(self):
return PSParser.RULE_func_multi_arg
def enterRule(self, listener):
if hasattr(listener, "enterFunc_multi_arg"):
listener.enterFunc_multi_arg(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_multi_arg"):
listener.exitFunc_multi_arg(self)
def func_multi_arg(self):
localctx = PSParser.Func_multi_argContext(self, self._ctx, self.state)
self.enterRule(localctx, 114, self.RULE_func_multi_arg)
try:
self.state = 1012
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 88, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 1007
self.expr()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 1008
self.expr()
self.state = 1009
self.match(PSParser.COMMA)
self.state = 1010
self.func_multi_arg()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Func_multi_arg_noparensContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.Func_multi_arg_noparensContext, self).__init__(
parent, invokingState
)
self.parser = parser
def mp_nofunc(self):
return self.getTypedRuleContext(PSParser.Mp_nofuncContext, 0)
def getRuleIndex(self):
return PSParser.RULE_func_multi_arg_noparens
def enterRule(self, listener):
if hasattr(listener, "enterFunc_multi_arg_noparens"):
listener.enterFunc_multi_arg_noparens(self)
def exitRule(self, listener):
if hasattr(listener, "exitFunc_multi_arg_noparens"):
listener.exitFunc_multi_arg_noparens(self)
def func_multi_arg_noparens(self):
localctx = PSParser.Func_multi_arg_noparensContext(self, self._ctx, self.state)
self.enterRule(localctx, 116, self.RULE_func_multi_arg_noparens)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1014
self.mp_nofunc(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class SubexprContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.SubexprContext, self).__init__(parent, invokingState)
self.parser = parser
def UNDERSCORE(self):
return self.getToken(PSParser.UNDERSCORE, 0)
def atom(self):
return self.getTypedRuleContext(PSParser.AtomContext, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def args(self):
return self.getTypedRuleContext(PSParser.ArgsContext, 0)
def getRuleIndex(self):
return PSParser.RULE_subexpr
def enterRule(self, listener):
if hasattr(listener, "enterSubexpr"):
listener.enterSubexpr(self)
def exitRule(self, listener):
if hasattr(listener, "exitSubexpr"):
listener.exitSubexpr(self)
def subexpr(self):
localctx = PSParser.SubexprContext(self, self._ctx, self.state)
self.enterRule(localctx, 118, self.RULE_subexpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1016
self.match(PSParser.UNDERSCORE)
self.state = 1025
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
154,
173,
176,
179,
180,
190,
191,
192,
193,
194,
]:
self.state = 1017
self.atom()
pass
elif token in [55]:
self.state = 1018
self.match(PSParser.L_BRACE)
self.state = 1021
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 89, self._ctx)
if la_ == 1:
self.state = 1019
self.expr()
pass
elif la_ == 2:
self.state = 1020
self.args()
pass
self.state = 1023
self.match(PSParser.R_BRACE)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class SupexprContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.SupexprContext, self).__init__(parent, invokingState)
self.parser = parser
def CARET(self):
return self.getToken(PSParser.CARET, 0)
def atom(self):
return self.getTypedRuleContext(PSParser.AtomContext, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def expr(self):
return self.getTypedRuleContext(PSParser.ExprContext, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def getRuleIndex(self):
return PSParser.RULE_supexpr
def enterRule(self, listener):
if hasattr(listener, "enterSupexpr"):
listener.enterSupexpr(self)
def exitRule(self, listener):
if hasattr(listener, "exitSupexpr"):
listener.exitSupexpr(self)
def supexpr(self):
localctx = PSParser.SupexprContext(self, self._ctx, self.state)
self.enterRule(localctx, 120, self.RULE_supexpr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1027
self.match(PSParser.CARET)
self.state = 1033
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
154,
173,
176,
179,
180,
190,
191,
192,
193,
194,
]:
self.state = 1028
self.atom()
pass
elif token in [55]:
self.state = 1029
self.match(PSParser.L_BRACE)
self.state = 1030
self.expr()
self.state = 1031
self.match(PSParser.R_BRACE)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class SubeqContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.SubeqContext, self).__init__(parent, invokingState)
self.parser = parser
def UNDERSCORE(self):
return self.getToken(PSParser.UNDERSCORE, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def equality(self):
return self.getTypedRuleContext(PSParser.EqualityContext, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def getRuleIndex(self):
return PSParser.RULE_subeq
def enterRule(self, listener):
if hasattr(listener, "enterSubeq"):
listener.enterSubeq(self)
def exitRule(self, listener):
if hasattr(listener, "exitSubeq"):
listener.exitSubeq(self)
def subeq(self):
localctx = PSParser.SubeqContext(self, self._ctx, self.state)
self.enterRule(localctx, 122, self.RULE_subeq)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1035
self.match(PSParser.UNDERSCORE)
self.state = 1036
self.match(PSParser.L_BRACE)
self.state = 1037
self.equality()
self.state = 1038
self.match(PSParser.R_BRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class SupeqContext(ParserRuleContext):
def __init__(self, parser, parent=None, invokingState=-1):
super(PSParser.SupeqContext, self).__init__(parent, invokingState)
self.parser = parser
def UNDERSCORE(self):
return self.getToken(PSParser.UNDERSCORE, 0)
def L_BRACE(self):
return self.getToken(PSParser.L_BRACE, 0)
def equality(self):
return self.getTypedRuleContext(PSParser.EqualityContext, 0)
def R_BRACE(self):
return self.getToken(PSParser.R_BRACE, 0)
def getRuleIndex(self):
return PSParser.RULE_supeq
def enterRule(self, listener):
if hasattr(listener, "enterSupeq"):
listener.enterSupeq(self)
def exitRule(self, listener):
if hasattr(listener, "exitSupeq"):
listener.exitSupeq(self)
def supeq(self):
localctx = PSParser.SupeqContext(self, self._ctx, self.state)
self.enterRule(localctx, 124, self.RULE_supeq)
try:
self.enterOuterAlt(localctx, 1)
self.state = 1040
self.match(PSParser.UNDERSCORE)
self.state = 1041
self.match(PSParser.L_BRACE)
self.state = 1042
self.equality()
self.state = 1043
self.match(PSParser.R_BRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
def sempred(self, localctx, ruleIndex, predIndex):
if self._predicates == None:
self._predicates = dict()
self._predicates[12] = self.relation_sempred
self._predicates[17] = self.additive_sempred
self._predicates[18] = self.mp_sempred
self._predicates[19] = self.mp_nofunc_sempred
self._predicates[28] = self.exp_sempred
self._predicates[29] = self.exp_nofunc_sempred
pred = self._predicates.get(ruleIndex, None)
if pred is None:
raise Exception("No predicate with index:" + str(ruleIndex))
else:
return pred(localctx, predIndex)
def relation_sempred(self, localctx, predIndex):
if predIndex == 0:
return self.precpred(self._ctx, 2)
def additive_sempred(self, localctx, predIndex):
if predIndex == 1:
return self.precpred(self._ctx, 2)
def mp_sempred(self, localctx, predIndex):
if predIndex == 2:
return self.precpred(self._ctx, 2)
def mp_nofunc_sempred(self, localctx, predIndex):
if predIndex == 3:
return self.precpred(self._ctx, 2)
def exp_sempred(self, localctx, predIndex):
if predIndex == 4:
return self.precpred(self._ctx, 2)
def exp_nofunc_sempred(self, localctx, predIndex):
if predIndex == 5:
return self.precpred(self._ctx, 2)
Reference in New Issue View Git Blame Copy Permalink