mal-toolbox 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (31) hide show
  1. {mal_toolbox-1.1.0.dist-info → mal_toolbox-1.1.2.dist-info}/METADATA +26 -2
  2. mal_toolbox-1.1.2.dist-info/RECORD +32 -0
  3. maltoolbox/__init__.py +6 -7
  4. maltoolbox/__main__.py +17 -9
  5. maltoolbox/attackgraph/__init__.py +2 -3
  6. maltoolbox/attackgraph/attackgraph.py +379 -362
  7. maltoolbox/attackgraph/node.py +14 -19
  8. maltoolbox/exceptions.py +7 -10
  9. maltoolbox/file_utils.py +10 -4
  10. maltoolbox/language/__init__.py +1 -1
  11. maltoolbox/language/compiler/__init__.py +4 -4
  12. maltoolbox/language/compiler/mal_lexer.py +154 -154
  13. maltoolbox/language/compiler/mal_parser.py +784 -1136
  14. maltoolbox/language/languagegraph.py +491 -636
  15. maltoolbox/model.py +85 -77
  16. maltoolbox/patternfinder/attackgraph_patterns.py +17 -8
  17. maltoolbox/translators/__init__.py +8 -0
  18. maltoolbox/translators/networkx.py +42 -0
  19. maltoolbox/translators/updater.py +18 -25
  20. maltoolbox/visualization/__init__.py +4 -4
  21. maltoolbox/visualization/draw_io_utils.py +6 -5
  22. maltoolbox/visualization/graphviz_utils.py +4 -2
  23. maltoolbox/visualization/neo4j_utils.py +13 -14
  24. maltoolbox/visualization/utils.py +2 -3
  25. mal_toolbox-1.1.0.dist-info/RECORD +0 -32
  26. maltoolbox/translators/securicad.py +0 -179
  27. {mal_toolbox-1.1.0.dist-info → mal_toolbox-1.1.2.dist-info}/WHEEL +0 -0
  28. {mal_toolbox-1.1.0.dist-info → mal_toolbox-1.1.2.dist-info}/entry_points.txt +0 -0
  29. {mal_toolbox-1.1.0.dist-info → mal_toolbox-1.1.2.dist-info}/licenses/AUTHORS +0 -0
  30. {mal_toolbox-1.1.0.dist-info → mal_toolbox-1.1.2.dist-info}/licenses/LICENSE +0 -0
  31. {mal_toolbox-1.1.0.dist-info → mal_toolbox-1.1.2.dist-info}/top_level.txt +0 -0
@@ -1,192 +1,195 @@
1
1
  # mypy: ignore-errors
2
2
  # Generated from mal.g4 by ANTLR 4.13.2
3
3
  # encoding: utf-8
4
- from antlr4 import *
5
- from io import StringIO
6
4
  import sys
5
+
6
+ from antlr4 import *
7
+
7
8
  if sys.version_info[1] > 5:
8
9
  from typing import TextIO
9
10
  else:
10
11
  from typing.io import TextIO
11
12
 
13
+
12
14
  def serializedATN():
13
15
  return [
14
- 4,1,51,413,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,
15
- 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,
16
- 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,
17
- 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,
18
- 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,
19
- 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,
20
- 2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,1,0,4,0,92,8,0,
21
- 11,0,12,0,93,1,0,3,0,97,8,0,1,1,1,1,1,1,1,1,3,1,103,8,1,1,2,1,2,
22
- 1,2,1,3,1,3,1,3,1,3,1,3,1,4,1,4,1,4,5,4,116,8,4,10,4,12,4,119,9,
23
- 4,1,4,1,4,5,4,123,8,4,10,4,12,4,126,9,4,1,4,1,4,1,5,1,5,1,5,1,5,
24
- 1,5,1,6,1,6,1,7,3,7,138,8,7,1,7,1,7,1,7,1,7,3,7,144,8,7,1,7,5,7,
25
- 147,8,7,10,7,12,7,150,9,7,1,7,1,7,1,7,5,7,155,8,7,10,7,12,7,158,
26
- 9,7,1,7,1,7,1,8,1,8,1,8,5,8,165,8,8,10,8,12,8,168,9,8,1,8,3,8,171,
27
- 8,8,1,8,3,8,174,8,8,1,8,5,8,177,8,8,10,8,12,8,180,9,8,1,8,5,8,183,
28
- 8,8,10,8,12,8,186,9,8,1,8,3,8,189,8,8,1,8,3,8,192,8,8,1,9,1,9,1,
29
- 10,1,10,1,10,1,11,1,11,1,11,1,11,5,11,203,8,11,10,11,12,11,206,9,
30
- 11,1,11,1,11,1,12,1,12,1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15,1,
31
- 15,5,15,221,8,15,10,15,12,15,224,9,15,1,16,1,16,1,16,5,16,229,8,
32
- 16,10,16,12,16,232,9,16,1,17,1,17,1,17,3,17,237,8,17,1,18,1,18,1,
33
- 18,1,18,1,18,1,18,3,18,245,8,18,1,19,1,19,1,19,1,19,1,19,5,19,252,
34
- 8,19,10,19,12,19,255,9,19,3,19,257,8,19,1,19,3,19,260,8,19,1,20,
35
- 1,20,3,20,264,8,20,1,20,1,20,3,20,268,8,20,1,20,3,20,271,8,20,1,
36
- 21,1,21,1,22,1,22,1,22,5,22,278,8,22,10,22,12,22,281,9,22,1,23,1,
37
- 23,1,23,1,23,5,23,287,8,23,10,23,12,23,290,9,23,1,23,1,23,1,24,1,
38
- 24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,1,29,1,29,1,
39
- 29,5,29,309,8,29,10,29,12,29,312,9,29,1,30,1,30,1,30,1,30,5,30,318,
40
- 8,30,10,30,12,30,321,9,30,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,33,
41
- 1,33,1,33,1,33,5,33,334,8,33,10,33,12,33,337,9,33,1,34,1,34,1,34,
42
- 5,34,342,8,34,10,34,12,34,345,9,34,1,35,1,35,1,35,1,35,1,35,1,35,
43
- 1,35,1,35,1,35,3,35,356,8,35,1,35,3,35,359,8,35,1,35,5,35,362,8,
44
- 35,10,35,12,35,365,9,35,1,36,1,36,1,37,1,37,1,37,1,37,1,38,1,38,
45
- 1,39,1,39,1,39,5,39,378,8,39,10,39,12,39,381,9,39,1,39,1,39,1,40,
46
- 1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,5,40,395,8,40,10,40,
47
- 12,40,398,9,40,1,41,1,41,1,41,1,41,1,42,1,42,1,42,3,42,407,8,42,
48
- 1,43,1,43,1,44,1,44,1,44,0,0,45,0,2,4,6,8,10,12,14,16,18,20,22,24,
49
- 26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,
50
- 70,72,74,76,78,80,82,84,86,88,0,10,1,0,9,10,4,0,13,13,22,22,36,37,
51
- 39,39,1,0,14,16,2,0,31,31,45,45,2,0,28,28,46,46,2,0,38,38,48,48,
52
- 1,0,42,43,1,0,11,12,1,0,31,33,2,0,11,11,28,28,411,0,96,1,0,0,0,2,
53
- 102,1,0,0,0,4,104,1,0,0,0,6,107,1,0,0,0,8,112,1,0,0,0,10,129,1,0,
54
- 0,0,12,134,1,0,0,0,14,137,1,0,0,0,16,161,1,0,0,0,18,193,1,0,0,0,
55
- 20,195,1,0,0,0,22,198,1,0,0,0,24,209,1,0,0,0,26,211,1,0,0,0,28,213,
56
- 1,0,0,0,30,217,1,0,0,0,32,225,1,0,0,0,34,233,1,0,0,0,36,244,1,0,
57
- 0,0,38,246,1,0,0,0,40,261,1,0,0,0,42,272,1,0,0,0,44,274,1,0,0,0,
58
- 46,282,1,0,0,0,48,293,1,0,0,0,50,296,1,0,0,0,52,298,1,0,0,0,54,300,
59
- 1,0,0,0,56,302,1,0,0,0,58,304,1,0,0,0,60,313,1,0,0,0,62,322,1,0,
60
- 0,0,64,324,1,0,0,0,66,329,1,0,0,0,68,338,1,0,0,0,70,355,1,0,0,0,
61
- 72,366,1,0,0,0,74,368,1,0,0,0,76,372,1,0,0,0,78,374,1,0,0,0,80,384,
62
- 1,0,0,0,82,399,1,0,0,0,84,403,1,0,0,0,86,408,1,0,0,0,88,410,1,0,
63
- 0,0,90,92,3,2,1,0,91,90,1,0,0,0,92,93,1,0,0,0,93,91,1,0,0,0,93,94,
64
- 1,0,0,0,94,97,1,0,0,0,95,97,5,0,0,1,96,91,1,0,0,0,96,95,1,0,0,0,
65
- 97,1,1,0,0,0,98,103,3,4,2,0,99,103,3,6,3,0,100,103,3,8,4,0,101,103,
66
- 3,78,39,0,102,98,1,0,0,0,102,99,1,0,0,0,102,100,1,0,0,0,102,101,
67
- 1,0,0,0,103,3,1,0,0,0,104,105,5,5,0,0,105,106,5,9,0,0,106,5,1,0,
68
- 0,0,107,108,5,22,0,0,108,109,5,17,0,0,109,110,5,23,0,0,110,111,5,
69
- 9,0,0,111,7,1,0,0,0,112,113,5,6,0,0,113,117,5,17,0,0,114,116,3,10,
70
- 5,0,115,114,1,0,0,0,116,119,1,0,0,0,117,115,1,0,0,0,117,118,1,0,
71
- 0,0,118,120,1,0,0,0,119,117,1,0,0,0,120,124,5,20,0,0,121,123,3,14,
72
- 7,0,122,121,1,0,0,0,123,126,1,0,0,0,124,122,1,0,0,0,124,125,1,0,
73
- 0,0,125,127,1,0,0,0,126,124,1,0,0,0,127,128,5,21,0,0,128,9,1,0,0,
74
- 0,129,130,5,17,0,0,130,131,5,7,0,0,131,132,5,23,0,0,132,133,3,12,
75
- 6,0,133,11,1,0,0,0,134,135,7,0,0,0,135,13,1,0,0,0,136,138,5,1,0,
76
- 0,137,136,1,0,0,0,137,138,1,0,0,0,138,139,1,0,0,0,139,140,5,2,0,
77
- 0,140,143,5,17,0,0,141,142,5,4,0,0,142,144,5,17,0,0,143,141,1,0,
78
- 0,0,143,144,1,0,0,0,144,148,1,0,0,0,145,147,3,10,5,0,146,145,1,0,
79
- 0,0,147,150,1,0,0,0,148,146,1,0,0,0,148,149,1,0,0,0,149,151,1,0,
80
- 0,0,150,148,1,0,0,0,151,156,5,20,0,0,152,155,3,16,8,0,153,155,3,
81
- 64,32,0,154,152,1,0,0,0,154,153,1,0,0,0,155,158,1,0,0,0,156,154,
82
- 1,0,0,0,156,157,1,0,0,0,157,159,1,0,0,0,158,156,1,0,0,0,159,160,
83
- 5,21,0,0,160,15,1,0,0,0,161,162,3,18,9,0,162,166,5,17,0,0,163,165,
84
- 3,20,10,0,164,163,1,0,0,0,165,168,1,0,0,0,166,164,1,0,0,0,166,167,
85
- 1,0,0,0,167,170,1,0,0,0,168,166,1,0,0,0,169,171,3,22,11,0,170,169,
86
- 1,0,0,0,170,171,1,0,0,0,171,173,1,0,0,0,172,174,3,28,14,0,173,172,
87
- 1,0,0,0,173,174,1,0,0,0,174,178,1,0,0,0,175,177,3,10,5,0,176,175,
88
- 1,0,0,0,177,180,1,0,0,0,178,176,1,0,0,0,178,179,1,0,0,0,179,184,
89
- 1,0,0,0,180,178,1,0,0,0,181,183,3,40,20,0,182,181,1,0,0,0,183,186,
90
- 1,0,0,0,184,182,1,0,0,0,184,185,1,0,0,0,185,188,1,0,0,0,186,184,
91
- 1,0,0,0,187,189,3,58,29,0,188,187,1,0,0,0,188,189,1,0,0,0,189,191,
92
- 1,0,0,0,190,192,3,60,30,0,191,190,1,0,0,0,191,192,1,0,0,0,192,17,
93
- 1,0,0,0,193,194,7,1,0,0,194,19,1,0,0,0,195,196,5,40,0,0,196,197,
94
- 5,17,0,0,197,21,1,0,0,0,198,199,5,20,0,0,199,204,3,24,12,0,200,201,
95
- 5,44,0,0,201,203,3,24,12,0,202,200,1,0,0,0,203,206,1,0,0,0,204,202,
96
- 1,0,0,0,204,205,1,0,0,0,205,207,1,0,0,0,206,204,1,0,0,0,207,208,
97
- 5,21,0,0,208,23,1,0,0,0,209,210,7,2,0,0,210,25,1,0,0,0,211,212,3,
98
- 28,14,0,212,27,1,0,0,0,213,214,5,26,0,0,214,215,3,30,15,0,215,216,
99
- 5,27,0,0,216,29,1,0,0,0,217,222,3,32,16,0,218,219,7,3,0,0,219,221,
100
- 3,32,16,0,220,218,1,0,0,0,221,224,1,0,0,0,222,220,1,0,0,0,222,223,
101
- 1,0,0,0,223,31,1,0,0,0,224,222,1,0,0,0,225,230,3,34,17,0,226,227,
102
- 7,4,0,0,227,229,3,34,17,0,228,226,1,0,0,0,229,232,1,0,0,0,230,228,
103
- 1,0,0,0,230,231,1,0,0,0,231,33,1,0,0,0,232,230,1,0,0,0,233,236,3,
104
- 36,18,0,234,235,5,47,0,0,235,237,3,36,18,0,236,234,1,0,0,0,236,237,
105
- 1,0,0,0,237,35,1,0,0,0,238,245,3,38,19,0,239,240,5,18,0,0,240,241,
106
- 3,30,15,0,241,242,5,19,0,0,242,245,1,0,0,0,243,245,3,62,31,0,244,
107
- 238,1,0,0,0,244,239,1,0,0,0,244,243,1,0,0,0,245,37,1,0,0,0,246,259,
108
- 5,17,0,0,247,256,5,18,0,0,248,253,3,62,31,0,249,250,5,44,0,0,250,
109
- 252,3,62,31,0,251,249,1,0,0,0,252,255,1,0,0,0,253,251,1,0,0,0,253,
110
- 254,1,0,0,0,254,257,1,0,0,0,255,253,1,0,0,0,256,248,1,0,0,0,256,
111
- 257,1,0,0,0,257,258,1,0,0,0,258,260,5,19,0,0,259,247,1,0,0,0,259,
112
- 260,1,0,0,0,260,39,1,0,0,0,261,263,3,42,21,0,262,264,3,44,22,0,263,
113
- 262,1,0,0,0,263,264,1,0,0,0,264,265,1,0,0,0,265,267,3,46,23,0,266,
114
- 268,3,54,27,0,267,266,1,0,0,0,267,268,1,0,0,0,268,270,1,0,0,0,269,
115
- 271,3,56,28,0,270,269,1,0,0,0,270,271,1,0,0,0,271,41,1,0,0,0,272,
116
- 273,7,5,0,0,273,43,1,0,0,0,274,279,5,17,0,0,275,276,5,35,0,0,276,
117
- 278,5,17,0,0,277,275,1,0,0,0,278,281,1,0,0,0,279,277,1,0,0,0,279,
118
- 280,1,0,0,0,280,45,1,0,0,0,281,279,1,0,0,0,282,283,5,18,0,0,283,
119
- 288,3,48,24,0,284,285,5,44,0,0,285,287,3,48,24,0,286,284,1,0,0,0,
120
- 287,290,1,0,0,0,288,286,1,0,0,0,288,289,1,0,0,0,289,291,1,0,0,0,
121
- 290,288,1,0,0,0,291,292,5,19,0,0,292,47,1,0,0,0,293,294,3,50,25,
122
- 0,294,295,3,52,26,0,295,49,1,0,0,0,296,297,5,17,0,0,297,51,1,0,0,
123
- 0,298,299,5,17,0,0,299,53,1,0,0,0,300,301,5,17,0,0,301,55,1,0,0,
124
- 0,302,303,3,28,14,0,303,57,1,0,0,0,304,305,5,41,0,0,305,310,3,66,
125
- 33,0,306,307,5,44,0,0,307,309,3,66,33,0,308,306,1,0,0,0,309,312,
126
- 1,0,0,0,310,308,1,0,0,0,310,311,1,0,0,0,311,59,1,0,0,0,312,310,1,
127
- 0,0,0,313,314,7,6,0,0,314,319,3,66,33,0,315,316,5,44,0,0,316,318,
128
- 3,66,33,0,317,315,1,0,0,0,318,321,1,0,0,0,319,317,1,0,0,0,319,320,
129
- 1,0,0,0,320,61,1,0,0,0,321,319,1,0,0,0,322,323,7,7,0,0,323,63,1,
130
- 0,0,0,324,325,5,8,0,0,325,326,5,17,0,0,326,327,5,30,0,0,327,328,
131
- 3,66,33,0,328,65,1,0,0,0,329,335,3,68,34,0,330,331,3,76,38,0,331,
132
- 332,3,68,34,0,332,334,1,0,0,0,333,330,1,0,0,0,334,337,1,0,0,0,335,
133
- 333,1,0,0,0,335,336,1,0,0,0,336,67,1,0,0,0,337,335,1,0,0,0,338,343,
134
- 3,70,35,0,339,340,5,35,0,0,340,342,3,70,35,0,341,339,1,0,0,0,342,
135
- 345,1,0,0,0,343,341,1,0,0,0,343,344,1,0,0,0,344,69,1,0,0,0,345,343,
136
- 1,0,0,0,346,347,5,18,0,0,347,348,3,66,33,0,348,349,5,19,0,0,349,
137
- 356,1,0,0,0,350,351,3,72,36,0,351,352,5,18,0,0,352,353,5,19,0,0,
138
- 353,356,1,0,0,0,354,356,5,17,0,0,355,346,1,0,0,0,355,350,1,0,0,0,
139
- 355,354,1,0,0,0,356,358,1,0,0,0,357,359,5,28,0,0,358,357,1,0,0,0,
140
- 358,359,1,0,0,0,359,363,1,0,0,0,360,362,3,74,37,0,361,360,1,0,0,
141
- 0,362,365,1,0,0,0,363,361,1,0,0,0,363,364,1,0,0,0,364,71,1,0,0,0,
142
- 365,363,1,0,0,0,366,367,5,17,0,0,367,73,1,0,0,0,368,369,5,26,0,0,
143
- 369,370,5,17,0,0,370,371,5,27,0,0,371,75,1,0,0,0,372,373,7,8,0,0,
144
- 373,77,1,0,0,0,374,375,5,3,0,0,375,379,5,20,0,0,376,378,3,80,40,
145
- 0,377,376,1,0,0,0,378,381,1,0,0,0,379,377,1,0,0,0,379,380,1,0,0,
146
- 0,380,382,1,0,0,0,381,379,1,0,0,0,382,383,5,21,0,0,383,79,1,0,0,
147
- 0,384,385,5,17,0,0,385,386,3,82,41,0,386,387,3,84,42,0,387,388,5,
148
- 24,0,0,388,389,3,88,44,0,389,390,5,25,0,0,390,391,3,84,42,0,391,
149
- 392,3,82,41,0,392,396,5,17,0,0,393,395,3,10,5,0,394,393,1,0,0,0,
150
- 395,398,1,0,0,0,396,394,1,0,0,0,396,397,1,0,0,0,397,81,1,0,0,0,398,
151
- 396,1,0,0,0,399,400,5,26,0,0,400,401,5,17,0,0,401,402,5,27,0,0,402,
152
- 83,1,0,0,0,403,406,3,86,43,0,404,405,5,34,0,0,405,407,3,86,43,0,
153
- 406,404,1,0,0,0,406,407,1,0,0,0,407,85,1,0,0,0,408,409,7,9,0,0,409,
154
- 87,1,0,0,0,410,411,5,17,0,0,411,89,1,0,0,0,40,93,96,102,117,124,
155
- 137,143,148,154,156,166,170,173,178,184,188,191,204,222,230,236,
156
- 244,253,256,259,263,267,270,279,288,310,319,335,343,355,358,363,
157
- 379,396,406
16
+ 4, 1, 51, 413, 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,
17
+ 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,
18
+ 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,
19
+ 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,
20
+ 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,
21
+ 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,
22
+ 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 1, 0, 4, 0, 92, 8, 0,
23
+ 11, 0, 12, 0, 93, 1, 0, 3, 0, 97, 8, 0, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 103, 8, 1, 1, 2, 1, 2,
24
+ 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 5, 4, 116, 8, 4, 10, 4, 12, 4, 119, 9,
25
+ 4, 1, 4, 1, 4, 5, 4, 123, 8, 4, 10, 4, 12, 4, 126, 9, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5,
26
+ 1, 5, 1, 6, 1, 6, 1, 7, 3, 7, 138, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 144, 8, 7, 1, 7, 5, 7,
27
+ 147, 8, 7, 10, 7, 12, 7, 150, 9, 7, 1, 7, 1, 7, 1, 7, 5, 7, 155, 8, 7, 10, 7, 12, 7, 158,
28
+ 9, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 5, 8, 165, 8, 8, 10, 8, 12, 8, 168, 9, 8, 1, 8, 3, 8, 171,
29
+ 8, 8, 1, 8, 3, 8, 174, 8, 8, 1, 8, 5, 8, 177, 8, 8, 10, 8, 12, 8, 180, 9, 8, 1, 8, 5, 8, 183,
30
+ 8, 8, 10, 8, 12, 8, 186, 9, 8, 1, 8, 3, 8, 189, 8, 8, 1, 8, 3, 8, 192, 8, 8, 1, 9, 1, 9, 1,
31
+ 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 203, 8, 11, 10, 11, 12, 11, 206, 9,
32
+ 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1,
33
+ 15, 5, 15, 221, 8, 15, 10, 15, 12, 15, 224, 9, 15, 1, 16, 1, 16, 1, 16, 5, 16, 229, 8,
34
+ 16, 10, 16, 12, 16, 232, 9, 16, 1, 17, 1, 17, 1, 17, 3, 17, 237, 8, 17, 1, 18, 1, 18, 1,
35
+ 18, 1, 18, 1, 18, 1, 18, 3, 18, 245, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 5, 19, 252,
36
+ 8, 19, 10, 19, 12, 19, 255, 9, 19, 3, 19, 257, 8, 19, 1, 19, 3, 19, 260, 8, 19, 1, 20,
37
+ 1, 20, 3, 20, 264, 8, 20, 1, 20, 1, 20, 3, 20, 268, 8, 20, 1, 20, 3, 20, 271, 8, 20, 1,
38
+ 21, 1, 21, 1, 22, 1, 22, 1, 22, 5, 22, 278, 8, 22, 10, 22, 12, 22, 281, 9, 22, 1, 23, 1,
39
+ 23, 1, 23, 1, 23, 5, 23, 287, 8, 23, 10, 23, 12, 23, 290, 9, 23, 1, 23, 1, 23, 1, 24, 1,
40
+ 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1,
41
+ 29, 5, 29, 309, 8, 29, 10, 29, 12, 29, 312, 9, 29, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 318,
42
+ 8, 30, 10, 30, 12, 30, 321, 9, 30, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33,
43
+ 1, 33, 1, 33, 1, 33, 5, 33, 334, 8, 33, 10, 33, 12, 33, 337, 9, 33, 1, 34, 1, 34, 1, 34,
44
+ 5, 34, 342, 8, 34, 10, 34, 12, 34, 345, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35,
45
+ 1, 35, 1, 35, 1, 35, 3, 35, 356, 8, 35, 1, 35, 3, 35, 359, 8, 35, 1, 35, 5, 35, 362, 8,
46
+ 35, 10, 35, 12, 35, 365, 9, 35, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38,
47
+ 1, 39, 1, 39, 1, 39, 5, 39, 378, 8, 39, 10, 39, 12, 39, 381, 9, 39, 1, 39, 1, 39, 1, 40,
48
+ 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 5, 40, 395, 8, 40, 10, 40,
49
+ 12, 40, 398, 9, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 3, 42, 407, 8, 42,
50
+ 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 0, 0, 45, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24,
51
+ 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68,
52
+ 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 0, 10, 1, 0, 9, 10, 4, 0, 13, 13, 22, 22, 36, 37,
53
+ 39, 39, 1, 0, 14, 16, 2, 0, 31, 31, 45, 45, 2, 0, 28, 28, 46, 46, 2, 0, 38, 38, 48, 48,
54
+ 1, 0, 42, 43, 1, 0, 11, 12, 1, 0, 31, 33, 2, 0, 11, 11, 28, 28, 411, 0, 96, 1, 0, 0, 0, 2,
55
+ 102, 1, 0, 0, 0, 4, 104, 1, 0, 0, 0, 6, 107, 1, 0, 0, 0, 8, 112, 1, 0, 0, 0, 10, 129, 1, 0,
56
+ 0, 0, 12, 134, 1, 0, 0, 0, 14, 137, 1, 0, 0, 0, 16, 161, 1, 0, 0, 0, 18, 193, 1, 0, 0, 0,
57
+ 20, 195, 1, 0, 0, 0, 22, 198, 1, 0, 0, 0, 24, 209, 1, 0, 0, 0, 26, 211, 1, 0, 0, 0, 28, 213,
58
+ 1, 0, 0, 0, 30, 217, 1, 0, 0, 0, 32, 225, 1, 0, 0, 0, 34, 233, 1, 0, 0, 0, 36, 244, 1, 0,
59
+ 0, 0, 38, 246, 1, 0, 0, 0, 40, 261, 1, 0, 0, 0, 42, 272, 1, 0, 0, 0, 44, 274, 1, 0, 0, 0,
60
+ 46, 282, 1, 0, 0, 0, 48, 293, 1, 0, 0, 0, 50, 296, 1, 0, 0, 0, 52, 298, 1, 0, 0, 0, 54, 300,
61
+ 1, 0, 0, 0, 56, 302, 1, 0, 0, 0, 58, 304, 1, 0, 0, 0, 60, 313, 1, 0, 0, 0, 62, 322, 1, 0,
62
+ 0, 0, 64, 324, 1, 0, 0, 0, 66, 329, 1, 0, 0, 0, 68, 338, 1, 0, 0, 0, 70, 355, 1, 0, 0, 0,
63
+ 72, 366, 1, 0, 0, 0, 74, 368, 1, 0, 0, 0, 76, 372, 1, 0, 0, 0, 78, 374, 1, 0, 0, 0, 80, 384,
64
+ 1, 0, 0, 0, 82, 399, 1, 0, 0, 0, 84, 403, 1, 0, 0, 0, 86, 408, 1, 0, 0, 0, 88, 410, 1, 0,
65
+ 0, 0, 90, 92, 3, 2, 1, 0, 91, 90, 1, 0, 0, 0, 92, 93, 1, 0, 0, 0, 93, 91, 1, 0, 0, 0, 93, 94,
66
+ 1, 0, 0, 0, 94, 97, 1, 0, 0, 0, 95, 97, 5, 0, 0, 1, 96, 91, 1, 0, 0, 0, 96, 95, 1, 0, 0, 0,
67
+ 97, 1, 1, 0, 0, 0, 98, 103, 3, 4, 2, 0, 99, 103, 3, 6, 3, 0, 100, 103, 3, 8, 4, 0, 101, 103,
68
+ 3, 78, 39, 0, 102, 98, 1, 0, 0, 0, 102, 99, 1, 0, 0, 0, 102, 100, 1, 0, 0, 0, 102, 101,
69
+ 1, 0, 0, 0, 103, 3, 1, 0, 0, 0, 104, 105, 5, 5, 0, 0, 105, 106, 5, 9, 0, 0, 106, 5, 1, 0,
70
+ 0, 0, 107, 108, 5, 22, 0, 0, 108, 109, 5, 17, 0, 0, 109, 110, 5, 23, 0, 0, 110, 111, 5,
71
+ 9, 0, 0, 111, 7, 1, 0, 0, 0, 112, 113, 5, 6, 0, 0, 113, 117, 5, 17, 0, 0, 114, 116, 3, 10,
72
+ 5, 0, 115, 114, 1, 0, 0, 0, 116, 119, 1, 0, 0, 0, 117, 115, 1, 0, 0, 0, 117, 118, 1, 0,
73
+ 0, 0, 118, 120, 1, 0, 0, 0, 119, 117, 1, 0, 0, 0, 120, 124, 5, 20, 0, 0, 121, 123, 3, 14,
74
+ 7, 0, 122, 121, 1, 0, 0, 0, 123, 126, 1, 0, 0, 0, 124, 122, 1, 0, 0, 0, 124, 125, 1, 0,
75
+ 0, 0, 125, 127, 1, 0, 0, 0, 126, 124, 1, 0, 0, 0, 127, 128, 5, 21, 0, 0, 128, 9, 1, 0, 0,
76
+ 0, 129, 130, 5, 17, 0, 0, 130, 131, 5, 7, 0, 0, 131, 132, 5, 23, 0, 0, 132, 133, 3, 12,
77
+ 6, 0, 133, 11, 1, 0, 0, 0, 134, 135, 7, 0, 0, 0, 135, 13, 1, 0, 0, 0, 136, 138, 5, 1, 0,
78
+ 0, 137, 136, 1, 0, 0, 0, 137, 138, 1, 0, 0, 0, 138, 139, 1, 0, 0, 0, 139, 140, 5, 2, 0,
79
+ 0, 140, 143, 5, 17, 0, 0, 141, 142, 5, 4, 0, 0, 142, 144, 5, 17, 0, 0, 143, 141, 1, 0,
80
+ 0, 0, 143, 144, 1, 0, 0, 0, 144, 148, 1, 0, 0, 0, 145, 147, 3, 10, 5, 0, 146, 145, 1, 0,
81
+ 0, 0, 147, 150, 1, 0, 0, 0, 148, 146, 1, 0, 0, 0, 148, 149, 1, 0, 0, 0, 149, 151, 1, 0,
82
+ 0, 0, 150, 148, 1, 0, 0, 0, 151, 156, 5, 20, 0, 0, 152, 155, 3, 16, 8, 0, 153, 155, 3,
83
+ 64, 32, 0, 154, 152, 1, 0, 0, 0, 154, 153, 1, 0, 0, 0, 155, 158, 1, 0, 0, 0, 156, 154,
84
+ 1, 0, 0, 0, 156, 157, 1, 0, 0, 0, 157, 159, 1, 0, 0, 0, 158, 156, 1, 0, 0, 0, 159, 160,
85
+ 5, 21, 0, 0, 160, 15, 1, 0, 0, 0, 161, 162, 3, 18, 9, 0, 162, 166, 5, 17, 0, 0, 163, 165,
86
+ 3, 20, 10, 0, 164, 163, 1, 0, 0, 0, 165, 168, 1, 0, 0, 0, 166, 164, 1, 0, 0, 0, 166, 167,
87
+ 1, 0, 0, 0, 167, 170, 1, 0, 0, 0, 168, 166, 1, 0, 0, 0, 169, 171, 3, 22, 11, 0, 170, 169,
88
+ 1, 0, 0, 0, 170, 171, 1, 0, 0, 0, 171, 173, 1, 0, 0, 0, 172, 174, 3, 28, 14, 0, 173, 172,
89
+ 1, 0, 0, 0, 173, 174, 1, 0, 0, 0, 174, 178, 1, 0, 0, 0, 175, 177, 3, 10, 5, 0, 176, 175,
90
+ 1, 0, 0, 0, 177, 180, 1, 0, 0, 0, 178, 176, 1, 0, 0, 0, 178, 179, 1, 0, 0, 0, 179, 184,
91
+ 1, 0, 0, 0, 180, 178, 1, 0, 0, 0, 181, 183, 3, 40, 20, 0, 182, 181, 1, 0, 0, 0, 183, 186,
92
+ 1, 0, 0, 0, 184, 182, 1, 0, 0, 0, 184, 185, 1, 0, 0, 0, 185, 188, 1, 0, 0, 0, 186, 184,
93
+ 1, 0, 0, 0, 187, 189, 3, 58, 29, 0, 188, 187, 1, 0, 0, 0, 188, 189, 1, 0, 0, 0, 189, 191,
94
+ 1, 0, 0, 0, 190, 192, 3, 60, 30, 0, 191, 190, 1, 0, 0, 0, 191, 192, 1, 0, 0, 0, 192, 17,
95
+ 1, 0, 0, 0, 193, 194, 7, 1, 0, 0, 194, 19, 1, 0, 0, 0, 195, 196, 5, 40, 0, 0, 196, 197,
96
+ 5, 17, 0, 0, 197, 21, 1, 0, 0, 0, 198, 199, 5, 20, 0, 0, 199, 204, 3, 24, 12, 0, 200, 201,
97
+ 5, 44, 0, 0, 201, 203, 3, 24, 12, 0, 202, 200, 1, 0, 0, 0, 203, 206, 1, 0, 0, 0, 204, 202,
98
+ 1, 0, 0, 0, 204, 205, 1, 0, 0, 0, 205, 207, 1, 0, 0, 0, 206, 204, 1, 0, 0, 0, 207, 208,
99
+ 5, 21, 0, 0, 208, 23, 1, 0, 0, 0, 209, 210, 7, 2, 0, 0, 210, 25, 1, 0, 0, 0, 211, 212, 3,
100
+ 28, 14, 0, 212, 27, 1, 0, 0, 0, 213, 214, 5, 26, 0, 0, 214, 215, 3, 30, 15, 0, 215, 216,
101
+ 5, 27, 0, 0, 216, 29, 1, 0, 0, 0, 217, 222, 3, 32, 16, 0, 218, 219, 7, 3, 0, 0, 219, 221,
102
+ 3, 32, 16, 0, 220, 218, 1, 0, 0, 0, 221, 224, 1, 0, 0, 0, 222, 220, 1, 0, 0, 0, 222, 223,
103
+ 1, 0, 0, 0, 223, 31, 1, 0, 0, 0, 224, 222, 1, 0, 0, 0, 225, 230, 3, 34, 17, 0, 226, 227,
104
+ 7, 4, 0, 0, 227, 229, 3, 34, 17, 0, 228, 226, 1, 0, 0, 0, 229, 232, 1, 0, 0, 0, 230, 228,
105
+ 1, 0, 0, 0, 230, 231, 1, 0, 0, 0, 231, 33, 1, 0, 0, 0, 232, 230, 1, 0, 0, 0, 233, 236, 3,
106
+ 36, 18, 0, 234, 235, 5, 47, 0, 0, 235, 237, 3, 36, 18, 0, 236, 234, 1, 0, 0, 0, 236, 237,
107
+ 1, 0, 0, 0, 237, 35, 1, 0, 0, 0, 238, 245, 3, 38, 19, 0, 239, 240, 5, 18, 0, 0, 240, 241,
108
+ 3, 30, 15, 0, 241, 242, 5, 19, 0, 0, 242, 245, 1, 0, 0, 0, 243, 245, 3, 62, 31, 0, 244,
109
+ 238, 1, 0, 0, 0, 244, 239, 1, 0, 0, 0, 244, 243, 1, 0, 0, 0, 245, 37, 1, 0, 0, 0, 246, 259,
110
+ 5, 17, 0, 0, 247, 256, 5, 18, 0, 0, 248, 253, 3, 62, 31, 0, 249, 250, 5, 44, 0, 0, 250,
111
+ 252, 3, 62, 31, 0, 251, 249, 1, 0, 0, 0, 252, 255, 1, 0, 0, 0, 253, 251, 1, 0, 0, 0, 253,
112
+ 254, 1, 0, 0, 0, 254, 257, 1, 0, 0, 0, 255, 253, 1, 0, 0, 0, 256, 248, 1, 0, 0, 0, 256,
113
+ 257, 1, 0, 0, 0, 257, 258, 1, 0, 0, 0, 258, 260, 5, 19, 0, 0, 259, 247, 1, 0, 0, 0, 259,
114
+ 260, 1, 0, 0, 0, 260, 39, 1, 0, 0, 0, 261, 263, 3, 42, 21, 0, 262, 264, 3, 44, 22, 0, 263,
115
+ 262, 1, 0, 0, 0, 263, 264, 1, 0, 0, 0, 264, 265, 1, 0, 0, 0, 265, 267, 3, 46, 23, 0, 266,
116
+ 268, 3, 54, 27, 0, 267, 266, 1, 0, 0, 0, 267, 268, 1, 0, 0, 0, 268, 270, 1, 0, 0, 0, 269,
117
+ 271, 3, 56, 28, 0, 270, 269, 1, 0, 0, 0, 270, 271, 1, 0, 0, 0, 271, 41, 1, 0, 0, 0, 272,
118
+ 273, 7, 5, 0, 0, 273, 43, 1, 0, 0, 0, 274, 279, 5, 17, 0, 0, 275, 276, 5, 35, 0, 0, 276,
119
+ 278, 5, 17, 0, 0, 277, 275, 1, 0, 0, 0, 278, 281, 1, 0, 0, 0, 279, 277, 1, 0, 0, 0, 279,
120
+ 280, 1, 0, 0, 0, 280, 45, 1, 0, 0, 0, 281, 279, 1, 0, 0, 0, 282, 283, 5, 18, 0, 0, 283,
121
+ 288, 3, 48, 24, 0, 284, 285, 5, 44, 0, 0, 285, 287, 3, 48, 24, 0, 286, 284, 1, 0, 0, 0,
122
+ 287, 290, 1, 0, 0, 0, 288, 286, 1, 0, 0, 0, 288, 289, 1, 0, 0, 0, 289, 291, 1, 0, 0, 0,
123
+ 290, 288, 1, 0, 0, 0, 291, 292, 5, 19, 0, 0, 292, 47, 1, 0, 0, 0, 293, 294, 3, 50, 25,
124
+ 0, 294, 295, 3, 52, 26, 0, 295, 49, 1, 0, 0, 0, 296, 297, 5, 17, 0, 0, 297, 51, 1, 0, 0,
125
+ 0, 298, 299, 5, 17, 0, 0, 299, 53, 1, 0, 0, 0, 300, 301, 5, 17, 0, 0, 301, 55, 1, 0, 0,
126
+ 0, 302, 303, 3, 28, 14, 0, 303, 57, 1, 0, 0, 0, 304, 305, 5, 41, 0, 0, 305, 310, 3, 66,
127
+ 33, 0, 306, 307, 5, 44, 0, 0, 307, 309, 3, 66, 33, 0, 308, 306, 1, 0, 0, 0, 309, 312,
128
+ 1, 0, 0, 0, 310, 308, 1, 0, 0, 0, 310, 311, 1, 0, 0, 0, 311, 59, 1, 0, 0, 0, 312, 310, 1,
129
+ 0, 0, 0, 313, 314, 7, 6, 0, 0, 314, 319, 3, 66, 33, 0, 315, 316, 5, 44, 0, 0, 316, 318,
130
+ 3, 66, 33, 0, 317, 315, 1, 0, 0, 0, 318, 321, 1, 0, 0, 0, 319, 317, 1, 0, 0, 0, 319, 320,
131
+ 1, 0, 0, 0, 320, 61, 1, 0, 0, 0, 321, 319, 1, 0, 0, 0, 322, 323, 7, 7, 0, 0, 323, 63, 1,
132
+ 0, 0, 0, 324, 325, 5, 8, 0, 0, 325, 326, 5, 17, 0, 0, 326, 327, 5, 30, 0, 0, 327, 328,
133
+ 3, 66, 33, 0, 328, 65, 1, 0, 0, 0, 329, 335, 3, 68, 34, 0, 330, 331, 3, 76, 38, 0, 331,
134
+ 332, 3, 68, 34, 0, 332, 334, 1, 0, 0, 0, 333, 330, 1, 0, 0, 0, 334, 337, 1, 0, 0, 0, 335,
135
+ 333, 1, 0, 0, 0, 335, 336, 1, 0, 0, 0, 336, 67, 1, 0, 0, 0, 337, 335, 1, 0, 0, 0, 338, 343,
136
+ 3, 70, 35, 0, 339, 340, 5, 35, 0, 0, 340, 342, 3, 70, 35, 0, 341, 339, 1, 0, 0, 0, 342,
137
+ 345, 1, 0, 0, 0, 343, 341, 1, 0, 0, 0, 343, 344, 1, 0, 0, 0, 344, 69, 1, 0, 0, 0, 345, 343,
138
+ 1, 0, 0, 0, 346, 347, 5, 18, 0, 0, 347, 348, 3, 66, 33, 0, 348, 349, 5, 19, 0, 0, 349,
139
+ 356, 1, 0, 0, 0, 350, 351, 3, 72, 36, 0, 351, 352, 5, 18, 0, 0, 352, 353, 5, 19, 0, 0,
140
+ 353, 356, 1, 0, 0, 0, 354, 356, 5, 17, 0, 0, 355, 346, 1, 0, 0, 0, 355, 350, 1, 0, 0, 0,
141
+ 355, 354, 1, 0, 0, 0, 356, 358, 1, 0, 0, 0, 357, 359, 5, 28, 0, 0, 358, 357, 1, 0, 0, 0,
142
+ 358, 359, 1, 0, 0, 0, 359, 363, 1, 0, 0, 0, 360, 362, 3, 74, 37, 0, 361, 360, 1, 0, 0,
143
+ 0, 362, 365, 1, 0, 0, 0, 363, 361, 1, 0, 0, 0, 363, 364, 1, 0, 0, 0, 364, 71, 1, 0, 0, 0,
144
+ 365, 363, 1, 0, 0, 0, 366, 367, 5, 17, 0, 0, 367, 73, 1, 0, 0, 0, 368, 369, 5, 26, 0, 0,
145
+ 369, 370, 5, 17, 0, 0, 370, 371, 5, 27, 0, 0, 371, 75, 1, 0, 0, 0, 372, 373, 7, 8, 0, 0,
146
+ 373, 77, 1, 0, 0, 0, 374, 375, 5, 3, 0, 0, 375, 379, 5, 20, 0, 0, 376, 378, 3, 80, 40,
147
+ 0, 377, 376, 1, 0, 0, 0, 378, 381, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 379, 380, 1, 0, 0,
148
+ 0, 380, 382, 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 382, 383, 5, 21, 0, 0, 383, 79, 1, 0, 0,
149
+ 0, 384, 385, 5, 17, 0, 0, 385, 386, 3, 82, 41, 0, 386, 387, 3, 84, 42, 0, 387, 388, 5,
150
+ 24, 0, 0, 388, 389, 3, 88, 44, 0, 389, 390, 5, 25, 0, 0, 390, 391, 3, 84, 42, 0, 391,
151
+ 392, 3, 82, 41, 0, 392, 396, 5, 17, 0, 0, 393, 395, 3, 10, 5, 0, 394, 393, 1, 0, 0, 0,
152
+ 395, 398, 1, 0, 0, 0, 396, 394, 1, 0, 0, 0, 396, 397, 1, 0, 0, 0, 397, 81, 1, 0, 0, 0, 398,
153
+ 396, 1, 0, 0, 0, 399, 400, 5, 26, 0, 0, 400, 401, 5, 17, 0, 0, 401, 402, 5, 27, 0, 0, 402,
154
+ 83, 1, 0, 0, 0, 403, 406, 3, 86, 43, 0, 404, 405, 5, 34, 0, 0, 405, 407, 3, 86, 43, 0,
155
+ 406, 404, 1, 0, 0, 0, 406, 407, 1, 0, 0, 0, 407, 85, 1, 0, 0, 0, 408, 409, 7, 9, 0, 0, 409,
156
+ 87, 1, 0, 0, 0, 410, 411, 5, 17, 0, 0, 411, 89, 1, 0, 0, 0, 40, 93, 96, 102, 117, 124,
157
+ 137, 143, 148, 154, 156, 166, 170, 173, 178, 184, 188, 191, 204, 222, 230, 236,
158
+ 244, 253, 256, 259, 263, 267, 270, 279, 288, 310, 319, 335, 343, 355, 358, 363,
159
+ 379, 396, 406
158
160
  ]
159
161
 
160
- class malParser ( Parser ):
162
+
163
+ class malParser (Parser):
161
164
 
162
165
  grammarFileName = "mal.g4"
163
166
 
164
167
  atn = ATNDeserializer().deserialize(serializedATN())
165
168
 
166
- decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
169
+ decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]
167
170
 
168
171
  sharedContextCache = PredictionContextCache()
169
172
 
170
- literalNames = [ "<INVALID>", "'abstract'", "'asset'", "'associations'",
171
- "'extends'", "'include'", "'category'", "'info'", "'let'",
172
- "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
173
- "'E'", "'C'", "'I'", "'A'", "<INVALID>", "'('", "')'",
174
- "'{'", "'}'", "'#'", "':'", "'<--'", "'-->'", "'['",
175
- "']'", "'*'", "'1'", "'='", "'-'", "'/\\'", "'\\/'",
176
- "'..'", "'.'", "'&'", "'|'", "'!'", "'!E'", "'@'",
177
- "'<-'", "'+>'", "'->'", "','", "'+'", "'/'", "'^'",
178
- "'//!'" ]
179
-
180
- symbolicNames = [ "<INVALID>", "ABSTRACT", "ASSET", "ASSOCIATIONS",
181
- "EXTENDS", "INCLUDE", "CATEGORY", "INFO", "LET", "STRING",
182
- "MULTILINE_STRING", "INT", "FLOAT", "EXISTS", "C",
183
- "I", "A", "ID", "LPAREN", "RPAREN", "LCURLY", "RCURLY",
184
- "HASH", "COLON", "LARROW", "RARROW", "LSQUARE", "RSQUARE",
185
- "STAR", "ONE", "ASSIGN", "MINUS", "INTERSECT", "UNION",
186
- "RANGE", "DOT", "AND", "OR", "EXCLAMATION", "NOTEXISTS",
187
- "AT", "REQUIRES", "INHERITS", "LEADSTO", "COMMA",
188
- "PLUS", "DIVIDE", "POWER", "EXCLM_COMM", "INLINE_COMMENT",
189
- "MULTILINE_COMMENT", "WS" ]
173
+ literalNames = ["<INVALID>", "'abstract'", "'asset'", "'associations'",
174
+ "'extends'", "'include'", "'category'", "'info'", "'let'",
175
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
176
+ "'E'", "'C'", "'I'", "'A'", "<INVALID>", "'('", "')'",
177
+ "'{'", "'}'", "'#'", "':'", "'<--'", "'-->'", "'['",
178
+ "']'", "'*'", "'1'", "'='", "'-'", "'/\\'", "'\\/'",
179
+ "'..'", "'.'", "'&'", "'|'", "'!'", "'!E'", "'@'",
180
+ "'<-'", "'+>'", "'->'", "','", "'+'", "'/'", "'^'",
181
+ "'//!'"]
182
+
183
+ symbolicNames = ["<INVALID>", "ABSTRACT", "ASSET", "ASSOCIATIONS",
184
+ "EXTENDS", "INCLUDE", "CATEGORY", "INFO", "LET", "STRING",
185
+ "MULTILINE_STRING", "INT", "FLOAT", "EXISTS", "C",
186
+ "I", "A", "ID", "LPAREN", "RPAREN", "LCURLY", "RCURLY",
187
+ "HASH", "COLON", "LARROW", "RARROW", "LSQUARE", "RSQUARE",
188
+ "STAR", "ONE", "ASSIGN", "MINUS", "INTERSECT", "UNION",
189
+ "RANGE", "DOT", "AND", "OR", "EXCLAMATION", "NOTEXISTS",
190
+ "AT", "REQUIRES", "INHERITS", "LEADSTO", "COMMA",
191
+ "PLUS", "DIVIDE", "POWER", "EXCLM_COMM", "INLINE_COMMENT",
192
+ "MULTILINE_COMMENT", "WS"]
190
193
 
191
194
  RULE_mal = 0
192
195
  RULE_declaration = 1
@@ -234,91 +237,86 @@ class malParser ( Parser ):
234
237
  RULE_multatom = 43
235
238
  RULE_linkname = 44
236
239
 
237
- ruleNames = [ "mal", "declaration", "include", "define", "category",
238
- "meta", "text", "asset", "step", "steptype", "tag", "cias",
239
- "cia", "ttc", "pdist", "pdistexpr", "pdistterm", "pdistfact",
240
- "pdistatom", "pdistdist", "detector", "bang", "detectorname",
241
- "context", "contextpart", "contextasset", "contextlabel",
242
- "detectortype", "tprate", "precondition", "reaches",
243
- "number", "variable", "expr", "parts", "part", "varsubst",
244
- "type", "setop", "associations", "association", "field",
245
- "mult", "multatom", "linkname" ]
240
+ ruleNames = ["mal", "declaration", "include", "define", "category",
241
+ "meta", "text", "asset", "step", "steptype", "tag", "cias",
242
+ "cia", "ttc", "pdist", "pdistexpr", "pdistterm", "pdistfact",
243
+ "pdistatom", "pdistdist", "detector", "bang", "detectorname",
244
+ "context", "contextpart", "contextasset", "contextlabel",
245
+ "detectortype", "tprate", "precondition", "reaches",
246
+ "number", "variable", "expr", "parts", "part", "varsubst",
247
+ "type", "setop", "associations", "association", "field",
248
+ "mult", "multatom", "linkname"]
246
249
 
247
250
  EOF = Token.EOF
248
- ABSTRACT=1
249
- ASSET=2
250
- ASSOCIATIONS=3
251
- EXTENDS=4
252
- INCLUDE=5
253
- CATEGORY=6
254
- INFO=7
255
- LET=8
256
- STRING=9
257
- MULTILINE_STRING=10
258
- INT=11
259
- FLOAT=12
260
- EXISTS=13
261
- C=14
262
- I=15
263
- A=16
264
- ID=17
265
- LPAREN=18
266
- RPAREN=19
267
- LCURLY=20
268
- RCURLY=21
269
- HASH=22
270
- COLON=23
271
- LARROW=24
272
- RARROW=25
273
- LSQUARE=26
274
- RSQUARE=27
275
- STAR=28
276
- ONE=29
277
- ASSIGN=30
278
- MINUS=31
279
- INTERSECT=32
280
- UNION=33
281
- RANGE=34
282
- DOT=35
283
- AND=36
284
- OR=37
285
- EXCLAMATION=38
286
- NOTEXISTS=39
287
- AT=40
288
- REQUIRES=41
289
- INHERITS=42
290
- LEADSTO=43
291
- COMMA=44
292
- PLUS=45
293
- DIVIDE=46
294
- POWER=47
295
- EXCLM_COMM=48
296
- INLINE_COMMENT=49
297
- MULTILINE_COMMENT=50
298
- WS=51
299
-
300
- def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
251
+ ABSTRACT = 1
252
+ ASSET = 2
253
+ ASSOCIATIONS = 3
254
+ EXTENDS = 4
255
+ INCLUDE = 5
256
+ CATEGORY = 6
257
+ INFO = 7
258
+ LET = 8
259
+ STRING = 9
260
+ MULTILINE_STRING = 10
261
+ INT = 11
262
+ FLOAT = 12
263
+ EXISTS = 13
264
+ C = 14
265
+ I = 15
266
+ A = 16
267
+ ID = 17
268
+ LPAREN = 18
269
+ RPAREN = 19
270
+ LCURLY = 20
271
+ RCURLY = 21
272
+ HASH = 22
273
+ COLON = 23
274
+ LARROW = 24
275
+ RARROW = 25
276
+ LSQUARE = 26
277
+ RSQUARE = 27
278
+ STAR = 28
279
+ ONE = 29
280
+ ASSIGN = 30
281
+ MINUS = 31
282
+ INTERSECT = 32
283
+ UNION = 33
284
+ RANGE = 34
285
+ DOT = 35
286
+ AND = 36
287
+ OR = 37
288
+ EXCLAMATION = 38
289
+ NOTEXISTS = 39
290
+ AT = 40
291
+ REQUIRES = 41
292
+ INHERITS = 42
293
+ LEADSTO = 43
294
+ COMMA = 44
295
+ PLUS = 45
296
+ DIVIDE = 46
297
+ POWER = 47
298
+ EXCLM_COMM = 48
299
+ INLINE_COMMENT = 49
300
+ MULTILINE_COMMENT = 50
301
+ WS = 51
302
+
303
+ def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
301
304
  super().__init__(input, output)
302
305
  self.checkVersion("4.13.2")
303
306
  self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
304
307
  self._predicates = None
305
308
 
306
-
307
-
308
-
309
309
  class MalContext(ParserRuleContext):
310
310
  __slots__ = 'parser'
311
311
 
312
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
312
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
313
313
  super().__init__(parent, invokingState)
314
314
  self.parser = parser
315
315
 
316
- def declaration(self, i:int=None):
316
+ def declaration(self, i: int = None):
317
317
  if i is None:
318
318
  return self.getTypedRuleContexts(malParser.DeclarationContext)
319
- else:
320
- return self.getTypedRuleContext(malParser.DeclarationContext,i)
321
-
319
+ return self.getTypedRuleContext(malParser.DeclarationContext, i)
322
320
 
323
321
  def EOF(self):
324
322
  return self.getToken(malParser.EOF, 0)
@@ -326,52 +324,46 @@ class malParser ( Parser ):
326
324
  def getRuleIndex(self):
327
325
  return malParser.RULE_mal
328
326
 
329
- def enterRule(self, listener:ParseTreeListener):
330
- if hasattr( listener, "enterMal" ):
327
+ def enterRule(self, listener: ParseTreeListener):
328
+ if hasattr(listener, "enterMal"):
331
329
  listener.enterMal(self)
332
330
 
333
- def exitRule(self, listener:ParseTreeListener):
334
- if hasattr( listener, "exitMal" ):
331
+ def exitRule(self, listener: ParseTreeListener):
332
+ if hasattr(listener, "exitMal"):
335
333
  listener.exitMal(self)
336
334
 
337
- def accept(self, visitor:ParseTreeVisitor):
338
- if hasattr( visitor, "visitMal" ):
335
+ def accept(self, visitor: ParseTreeVisitor):
336
+ if hasattr(visitor, "visitMal"):
339
337
  return visitor.visitMal(self)
340
- else:
341
- return visitor.visitChildren(self)
342
-
343
-
344
-
338
+ return visitor.visitChildren(self)
345
339
 
346
340
  def mal(self):
347
341
 
348
342
  localctx = malParser.MalContext(self, self._ctx, self.state)
349
343
  self.enterRule(localctx, 0, self.RULE_mal)
350
- self._la = 0 # Token type
344
+ self._la = 0 # Token type
351
345
  try:
352
346
  self.state = 96
353
347
  self._errHandler.sync(self)
354
348
  token = self._input.LA(1)
355
349
  if token in [3, 5, 6, 22]:
356
350
  self.enterOuterAlt(localctx, 1)
357
- self.state = 91
351
+ self.state = 91
358
352
  self._errHandler.sync(self)
359
353
  _la = self._input.LA(1)
360
354
  while True:
361
355
  self.state = 90
362
356
  self.declaration()
363
- self.state = 93
357
+ self.state = 93
364
358
  self._errHandler.sync(self)
365
359
  _la = self._input.LA(1)
366
- if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 4194408) != 0)):
360
+ if not (((_la) & ~0x3f) == 0 and ((1 << _la) & 4194408) != 0):
367
361
  break
368
362
 
369
- pass
370
- elif token in [-1]:
363
+ elif token == -1:
371
364
  self.enterOuterAlt(localctx, 2)
372
365
  self.state = 95
373
366
  self.match(malParser.EOF)
374
- pass
375
367
  else:
376
368
  raise NoViableAltException(self)
377
369
 
@@ -383,49 +375,40 @@ class malParser ( Parser ):
383
375
  self.exitRule()
384
376
  return localctx
385
377
 
386
-
387
378
  class DeclarationContext(ParserRuleContext):
388
379
  __slots__ = 'parser'
389
380
 
390
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
381
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
391
382
  super().__init__(parent, invokingState)
392
383
  self.parser = parser
393
384
 
394
385
  def include(self):
395
- return self.getTypedRuleContext(malParser.IncludeContext,0)
396
-
386
+ return self.getTypedRuleContext(malParser.IncludeContext, 0)
397
387
 
398
388
  def define(self):
399
- return self.getTypedRuleContext(malParser.DefineContext,0)
400
-
389
+ return self.getTypedRuleContext(malParser.DefineContext, 0)
401
390
 
402
391
  def category(self):
403
- return self.getTypedRuleContext(malParser.CategoryContext,0)
404
-
392
+ return self.getTypedRuleContext(malParser.CategoryContext, 0)
405
393
 
406
394
  def associations(self):
407
- return self.getTypedRuleContext(malParser.AssociationsContext,0)
408
-
395
+ return self.getTypedRuleContext(malParser.AssociationsContext, 0)
409
396
 
410
397
  def getRuleIndex(self):
411
398
  return malParser.RULE_declaration
412
399
 
413
- def enterRule(self, listener:ParseTreeListener):
414
- if hasattr( listener, "enterDeclaration" ):
400
+ def enterRule(self, listener: ParseTreeListener):
401
+ if hasattr(listener, "enterDeclaration"):
415
402
  listener.enterDeclaration(self)
416
403
 
417
- def exitRule(self, listener:ParseTreeListener):
418
- if hasattr( listener, "exitDeclaration" ):
404
+ def exitRule(self, listener: ParseTreeListener):
405
+ if hasattr(listener, "exitDeclaration"):
419
406
  listener.exitDeclaration(self)
420
407
 
421
- def accept(self, visitor:ParseTreeVisitor):
422
- if hasattr( visitor, "visitDeclaration" ):
408
+ def accept(self, visitor: ParseTreeVisitor):
409
+ if hasattr(visitor, "visitDeclaration"):
423
410
  return visitor.visitDeclaration(self)
424
- else:
425
- return visitor.visitChildren(self)
426
-
427
-
428
-
411
+ return visitor.visitChildren(self)
429
412
 
430
413
  def declaration(self):
431
414
 
@@ -435,26 +418,22 @@ class malParser ( Parser ):
435
418
  self.state = 102
436
419
  self._errHandler.sync(self)
437
420
  token = self._input.LA(1)
438
- if token in [5]:
421
+ if token == 5:
439
422
  self.enterOuterAlt(localctx, 1)
440
423
  self.state = 98
441
424
  self.include()
442
- pass
443
- elif token in [22]:
425
+ elif token == 22:
444
426
  self.enterOuterAlt(localctx, 2)
445
427
  self.state = 99
446
428
  self.define()
447
- pass
448
- elif token in [6]:
429
+ elif token == 6:
449
430
  self.enterOuterAlt(localctx, 3)
450
431
  self.state = 100
451
432
  self.category()
452
- pass
453
- elif token in [3]:
433
+ elif token == 3:
454
434
  self.enterOuterAlt(localctx, 4)
455
435
  self.state = 101
456
436
  self.associations()
457
- pass
458
437
  else:
459
438
  raise NoViableAltException(self)
460
439
 
@@ -466,11 +445,10 @@ class malParser ( Parser ):
466
445
  self.exitRule()
467
446
  return localctx
468
447
 
469
-
470
448
  class IncludeContext(ParserRuleContext):
471
449
  __slots__ = 'parser'
472
450
 
473
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
451
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
474
452
  super().__init__(parent, invokingState)
475
453
  self.parser = parser
476
454
 
@@ -483,22 +461,18 @@ class malParser ( Parser ):
483
461
  def getRuleIndex(self):
484
462
  return malParser.RULE_include
485
463
 
486
- def enterRule(self, listener:ParseTreeListener):
487
- if hasattr( listener, "enterInclude" ):
464
+ def enterRule(self, listener: ParseTreeListener):
465
+ if hasattr(listener, "enterInclude"):
488
466
  listener.enterInclude(self)
489
467
 
490
- def exitRule(self, listener:ParseTreeListener):
491
- if hasattr( listener, "exitInclude" ):
468
+ def exitRule(self, listener: ParseTreeListener):
469
+ if hasattr(listener, "exitInclude"):
492
470
  listener.exitInclude(self)
493
471
 
494
- def accept(self, visitor:ParseTreeVisitor):
495
- if hasattr( visitor, "visitInclude" ):
472
+ def accept(self, visitor: ParseTreeVisitor):
473
+ if hasattr(visitor, "visitInclude"):
496
474
  return visitor.visitInclude(self)
497
- else:
498
- return visitor.visitChildren(self)
499
-
500
-
501
-
475
+ return visitor.visitChildren(self)
502
476
 
503
477
  def include(self):
504
478
 
@@ -518,11 +492,10 @@ class malParser ( Parser ):
518
492
  self.exitRule()
519
493
  return localctx
520
494
 
521
-
522
495
  class DefineContext(ParserRuleContext):
523
496
  __slots__ = 'parser'
524
497
 
525
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
498
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
526
499
  super().__init__(parent, invokingState)
527
500
  self.parser = parser
528
501
 
@@ -541,22 +514,18 @@ class malParser ( Parser ):
541
514
  def getRuleIndex(self):
542
515
  return malParser.RULE_define
543
516
 
544
- def enterRule(self, listener:ParseTreeListener):
545
- if hasattr( listener, "enterDefine" ):
517
+ def enterRule(self, listener: ParseTreeListener):
518
+ if hasattr(listener, "enterDefine"):
546
519
  listener.enterDefine(self)
547
520
 
548
- def exitRule(self, listener:ParseTreeListener):
549
- if hasattr( listener, "exitDefine" ):
521
+ def exitRule(self, listener: ParseTreeListener):
522
+ if hasattr(listener, "exitDefine"):
550
523
  listener.exitDefine(self)
551
524
 
552
- def accept(self, visitor:ParseTreeVisitor):
553
- if hasattr( visitor, "visitDefine" ):
525
+ def accept(self, visitor: ParseTreeVisitor):
526
+ if hasattr(visitor, "visitDefine"):
554
527
  return visitor.visitDefine(self)
555
- else:
556
- return visitor.visitChildren(self)
557
-
558
-
559
-
528
+ return visitor.visitChildren(self)
560
529
 
561
530
  def define(self):
562
531
 
@@ -580,11 +549,10 @@ class malParser ( Parser ):
580
549
  self.exitRule()
581
550
  return localctx
582
551
 
583
-
584
552
  class CategoryContext(ParserRuleContext):
585
553
  __slots__ = 'parser'
586
554
 
587
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
555
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
588
556
  super().__init__(parent, invokingState)
589
557
  self.parser = parser
590
558
 
@@ -600,45 +568,37 @@ class malParser ( Parser ):
600
568
  def RCURLY(self):
601
569
  return self.getToken(malParser.RCURLY, 0)
602
570
 
603
- def meta(self, i:int=None):
571
+ def meta(self, i: int = None):
604
572
  if i is None:
605
573
  return self.getTypedRuleContexts(malParser.MetaContext)
606
- else:
607
- return self.getTypedRuleContext(malParser.MetaContext,i)
574
+ return self.getTypedRuleContext(malParser.MetaContext, i)
608
575
 
609
-
610
- def asset(self, i:int=None):
576
+ def asset(self, i: int = None):
611
577
  if i is None:
612
578
  return self.getTypedRuleContexts(malParser.AssetContext)
613
- else:
614
- return self.getTypedRuleContext(malParser.AssetContext,i)
615
-
579
+ return self.getTypedRuleContext(malParser.AssetContext, i)
616
580
 
617
581
  def getRuleIndex(self):
618
582
  return malParser.RULE_category
619
583
 
620
- def enterRule(self, listener:ParseTreeListener):
621
- if hasattr( listener, "enterCategory" ):
584
+ def enterRule(self, listener: ParseTreeListener):
585
+ if hasattr(listener, "enterCategory"):
622
586
  listener.enterCategory(self)
623
587
 
624
- def exitRule(self, listener:ParseTreeListener):
625
- if hasattr( listener, "exitCategory" ):
588
+ def exitRule(self, listener: ParseTreeListener):
589
+ if hasattr(listener, "exitCategory"):
626
590
  listener.exitCategory(self)
627
591
 
628
- def accept(self, visitor:ParseTreeVisitor):
629
- if hasattr( visitor, "visitCategory" ):
592
+ def accept(self, visitor: ParseTreeVisitor):
593
+ if hasattr(visitor, "visitCategory"):
630
594
  return visitor.visitCategory(self)
631
- else:
632
- return visitor.visitChildren(self)
633
-
634
-
635
-
595
+ return visitor.visitChildren(self)
636
596
 
637
597
  def category(self):
638
598
 
639
599
  localctx = malParser.CategoryContext(self, self._ctx, self.state)
640
600
  self.enterRule(localctx, 8, self.RULE_category)
641
- self._la = 0 # Token type
601
+ self._la = 0 # Token type
642
602
  try:
643
603
  self.enterOuterAlt(localctx, 1)
644
604
  self.state = 112
@@ -648,7 +608,7 @@ class malParser ( Parser ):
648
608
  self.state = 117
649
609
  self._errHandler.sync(self)
650
610
  _la = self._input.LA(1)
651
- while _la==17:
611
+ while _la == 17:
652
612
  self.state = 114
653
613
  self.meta()
654
614
  self.state = 119
@@ -660,7 +620,7 @@ class malParser ( Parser ):
660
620
  self.state = 124
661
621
  self._errHandler.sync(self)
662
622
  _la = self._input.LA(1)
663
- while _la==1 or _la==2:
623
+ while _la == 1 or _la == 2:
664
624
  self.state = 121
665
625
  self.asset()
666
626
  self.state = 126
@@ -677,11 +637,10 @@ class malParser ( Parser ):
677
637
  self.exitRule()
678
638
  return localctx
679
639
 
680
-
681
640
  class MetaContext(ParserRuleContext):
682
641
  __slots__ = 'parser'
683
642
 
684
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
643
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
685
644
  super().__init__(parent, invokingState)
686
645
  self.parser = parser
687
646
 
@@ -695,28 +654,23 @@ class malParser ( Parser ):
695
654
  return self.getToken(malParser.COLON, 0)
696
655
 
697
656
  def text(self):
698
- return self.getTypedRuleContext(malParser.TextContext,0)
699
-
657
+ return self.getTypedRuleContext(malParser.TextContext, 0)
700
658
 
701
659
  def getRuleIndex(self):
702
660
  return malParser.RULE_meta
703
661
 
704
- def enterRule(self, listener:ParseTreeListener):
705
- if hasattr( listener, "enterMeta" ):
662
+ def enterRule(self, listener: ParseTreeListener):
663
+ if hasattr(listener, "enterMeta"):
706
664
  listener.enterMeta(self)
707
665
 
708
- def exitRule(self, listener:ParseTreeListener):
709
- if hasattr( listener, "exitMeta" ):
666
+ def exitRule(self, listener: ParseTreeListener):
667
+ if hasattr(listener, "exitMeta"):
710
668
  listener.exitMeta(self)
711
669
 
712
- def accept(self, visitor:ParseTreeVisitor):
713
- if hasattr( visitor, "visitMeta" ):
670
+ def accept(self, visitor: ParseTreeVisitor):
671
+ if hasattr(visitor, "visitMeta"):
714
672
  return visitor.visitMeta(self)
715
- else:
716
- return visitor.visitChildren(self)
717
-
718
-
719
-
673
+ return visitor.visitChildren(self)
720
674
 
721
675
  def meta(self):
722
676
 
@@ -740,11 +694,10 @@ class malParser ( Parser ):
740
694
  self.exitRule()
741
695
  return localctx
742
696
 
743
-
744
697
  class TextContext(ParserRuleContext):
745
698
  __slots__ = 'parser'
746
699
 
747
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
700
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
748
701
  super().__init__(parent, invokingState)
749
702
  self.parser = parser
750
703
 
@@ -757,33 +710,29 @@ class malParser ( Parser ):
757
710
  def getRuleIndex(self):
758
711
  return malParser.RULE_text
759
712
 
760
- def enterRule(self, listener:ParseTreeListener):
761
- if hasattr( listener, "enterText" ):
713
+ def enterRule(self, listener: ParseTreeListener):
714
+ if hasattr(listener, "enterText"):
762
715
  listener.enterText(self)
763
716
 
764
- def exitRule(self, listener:ParseTreeListener):
765
- if hasattr( listener, "exitText" ):
717
+ def exitRule(self, listener: ParseTreeListener):
718
+ if hasattr(listener, "exitText"):
766
719
  listener.exitText(self)
767
720
 
768
- def accept(self, visitor:ParseTreeVisitor):
769
- if hasattr( visitor, "visitText" ):
721
+ def accept(self, visitor: ParseTreeVisitor):
722
+ if hasattr(visitor, "visitText"):
770
723
  return visitor.visitText(self)
771
- else:
772
- return visitor.visitChildren(self)
773
-
774
-
775
-
724
+ return visitor.visitChildren(self)
776
725
 
777
726
  def text(self):
778
727
 
779
728
  localctx = malParser.TextContext(self, self._ctx, self.state)
780
729
  self.enterRule(localctx, 12, self.RULE_text)
781
- self._la = 0 # Token type
730
+ self._la = 0 # Token type
782
731
  try:
783
732
  self.enterOuterAlt(localctx, 1)
784
733
  self.state = 134
785
734
  _la = self._input.LA(1)
786
- if not(_la==9 or _la==10):
735
+ if not (_la == 9 or _la == 10):
787
736
  self._errHandler.recoverInline(self)
788
737
  else:
789
738
  self._errHandler.reportMatch(self)
@@ -796,22 +745,20 @@ class malParser ( Parser ):
796
745
  self.exitRule()
797
746
  return localctx
798
747
 
799
-
800
748
  class AssetContext(ParserRuleContext):
801
749
  __slots__ = 'parser'
802
750
 
803
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
751
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
804
752
  super().__init__(parent, invokingState)
805
753
  self.parser = parser
806
754
 
807
755
  def ASSET(self):
808
756
  return self.getToken(malParser.ASSET, 0)
809
757
 
810
- def ID(self, i:int=None):
758
+ def ID(self, i: int = None):
811
759
  if i is None:
812
760
  return self.getTokens(malParser.ID)
813
- else:
814
- return self.getToken(malParser.ID, i)
761
+ return self.getToken(malParser.ID, i)
815
762
 
816
763
  def LCURLY(self):
817
764
  return self.getToken(malParser.LCURLY, 0)
@@ -825,62 +772,51 @@ class malParser ( Parser ):
825
772
  def EXTENDS(self):
826
773
  return self.getToken(malParser.EXTENDS, 0)
827
774
 
828
- def meta(self, i:int=None):
775
+ def meta(self, i: int = None):
829
776
  if i is None:
830
777
  return self.getTypedRuleContexts(malParser.MetaContext)
831
- else:
832
- return self.getTypedRuleContext(malParser.MetaContext,i)
833
-
778
+ return self.getTypedRuleContext(malParser.MetaContext, i)
834
779
 
835
- def step(self, i:int=None):
780
+ def step(self, i: int = None):
836
781
  if i is None:
837
782
  return self.getTypedRuleContexts(malParser.StepContext)
838
- else:
839
- return self.getTypedRuleContext(malParser.StepContext,i)
840
-
783
+ return self.getTypedRuleContext(malParser.StepContext, i)
841
784
 
842
- def variable(self, i:int=None):
785
+ def variable(self, i: int = None):
843
786
  if i is None:
844
787
  return self.getTypedRuleContexts(malParser.VariableContext)
845
- else:
846
- return self.getTypedRuleContext(malParser.VariableContext,i)
847
-
788
+ return self.getTypedRuleContext(malParser.VariableContext, i)
848
789
 
849
790
  def getRuleIndex(self):
850
791
  return malParser.RULE_asset
851
792
 
852
- def enterRule(self, listener:ParseTreeListener):
853
- if hasattr( listener, "enterAsset" ):
793
+ def enterRule(self, listener: ParseTreeListener):
794
+ if hasattr(listener, "enterAsset"):
854
795
  listener.enterAsset(self)
855
796
 
856
- def exitRule(self, listener:ParseTreeListener):
857
- if hasattr( listener, "exitAsset" ):
797
+ def exitRule(self, listener: ParseTreeListener):
798
+ if hasattr(listener, "exitAsset"):
858
799
  listener.exitAsset(self)
859
800
 
860
- def accept(self, visitor:ParseTreeVisitor):
861
- if hasattr( visitor, "visitAsset" ):
801
+ def accept(self, visitor: ParseTreeVisitor):
802
+ if hasattr(visitor, "visitAsset"):
862
803
  return visitor.visitAsset(self)
863
- else:
864
- return visitor.visitChildren(self)
865
-
866
-
867
-
804
+ return visitor.visitChildren(self)
868
805
 
869
806
  def asset(self):
870
807
 
871
808
  localctx = malParser.AssetContext(self, self._ctx, self.state)
872
809
  self.enterRule(localctx, 14, self.RULE_asset)
873
- self._la = 0 # Token type
810
+ self._la = 0 # Token type
874
811
  try:
875
812
  self.enterOuterAlt(localctx, 1)
876
813
  self.state = 137
877
814
  self._errHandler.sync(self)
878
815
  _la = self._input.LA(1)
879
- if _la==1:
816
+ if _la == 1:
880
817
  self.state = 136
881
818
  self.match(malParser.ABSTRACT)
882
819
 
883
-
884
820
  self.state = 139
885
821
  self.match(malParser.ASSET)
886
822
  self.state = 140
@@ -888,17 +824,16 @@ class malParser ( Parser ):
888
824
  self.state = 143
889
825
  self._errHandler.sync(self)
890
826
  _la = self._input.LA(1)
891
- if _la==4:
827
+ if _la == 4:
892
828
  self.state = 141
893
829
  self.match(malParser.EXTENDS)
894
830
  self.state = 142
895
831
  self.match(malParser.ID)
896
832
 
897
-
898
833
  self.state = 148
899
834
  self._errHandler.sync(self)
900
835
  _la = self._input.LA(1)
901
- while _la==17:
836
+ while _la == 17:
902
837
  self.state = 145
903
838
  self.meta()
904
839
  self.state = 150
@@ -917,11 +852,9 @@ class malParser ( Parser ):
917
852
  if token in [13, 22, 36, 37, 39]:
918
853
  self.state = 152
919
854
  self.step()
920
- pass
921
- elif token in [8]:
855
+ elif token == 8:
922
856
  self.state = 153
923
857
  self.variable()
924
- pass
925
858
  else:
926
859
  raise NoViableAltException(self)
927
860
 
@@ -939,83 +872,67 @@ class malParser ( Parser ):
939
872
  self.exitRule()
940
873
  return localctx
941
874
 
942
-
943
875
  class StepContext(ParserRuleContext):
944
876
  __slots__ = 'parser'
945
877
 
946
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
878
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
947
879
  super().__init__(parent, invokingState)
948
880
  self.parser = parser
949
881
 
950
882
  def steptype(self):
951
- return self.getTypedRuleContext(malParser.SteptypeContext,0)
952
-
883
+ return self.getTypedRuleContext(malParser.SteptypeContext, 0)
953
884
 
954
885
  def ID(self):
955
886
  return self.getToken(malParser.ID, 0)
956
887
 
957
- def tag(self, i:int=None):
888
+ def tag(self, i: int = None):
958
889
  if i is None:
959
890
  return self.getTypedRuleContexts(malParser.TagContext)
960
- else:
961
- return self.getTypedRuleContext(malParser.TagContext,i)
962
-
891
+ return self.getTypedRuleContext(malParser.TagContext, i)
963
892
 
964
893
  def cias(self):
965
- return self.getTypedRuleContext(malParser.CiasContext,0)
966
-
894
+ return self.getTypedRuleContext(malParser.CiasContext, 0)
967
895
 
968
896
  def pdist(self):
969
- return self.getTypedRuleContext(malParser.PdistContext,0)
970
-
897
+ return self.getTypedRuleContext(malParser.PdistContext, 0)
971
898
 
972
- def meta(self, i:int=None):
899
+ def meta(self, i: int = None):
973
900
  if i is None:
974
901
  return self.getTypedRuleContexts(malParser.MetaContext)
975
- else:
976
- return self.getTypedRuleContext(malParser.MetaContext,i)
902
+ return self.getTypedRuleContext(malParser.MetaContext, i)
977
903
 
978
-
979
- def detector(self, i:int=None):
904
+ def detector(self, i: int = None):
980
905
  if i is None:
981
906
  return self.getTypedRuleContexts(malParser.DetectorContext)
982
- else:
983
- return self.getTypedRuleContext(malParser.DetectorContext,i)
984
-
907
+ return self.getTypedRuleContext(malParser.DetectorContext, i)
985
908
 
986
909
  def precondition(self):
987
- return self.getTypedRuleContext(malParser.PreconditionContext,0)
988
-
910
+ return self.getTypedRuleContext(malParser.PreconditionContext, 0)
989
911
 
990
912
  def reaches(self):
991
- return self.getTypedRuleContext(malParser.ReachesContext,0)
992
-
913
+ return self.getTypedRuleContext(malParser.ReachesContext, 0)
993
914
 
994
915
  def getRuleIndex(self):
995
916
  return malParser.RULE_step
996
917
 
997
- def enterRule(self, listener:ParseTreeListener):
998
- if hasattr( listener, "enterStep" ):
918
+ def enterRule(self, listener: ParseTreeListener):
919
+ if hasattr(listener, "enterStep"):
999
920
  listener.enterStep(self)
1000
921
 
1001
- def exitRule(self, listener:ParseTreeListener):
1002
- if hasattr( listener, "exitStep" ):
922
+ def exitRule(self, listener: ParseTreeListener):
923
+ if hasattr(listener, "exitStep"):
1003
924
  listener.exitStep(self)
1004
925
 
1005
- def accept(self, visitor:ParseTreeVisitor):
1006
- if hasattr( visitor, "visitStep" ):
926
+ def accept(self, visitor: ParseTreeVisitor):
927
+ if hasattr(visitor, "visitStep"):
1007
928
  return visitor.visitStep(self)
1008
- else:
1009
- return visitor.visitChildren(self)
1010
-
1011
-
1012
-
929
+ return visitor.visitChildren(self)
1013
930
 
1014
931
  def step(self):
1015
932
 
1016
933
  localctx = malParser.StepContext(self, self._ctx, self.state)
1017
934
  self.enterRule(localctx, 16, self.RULE_step)
1018
- self._la = 0 # Token type
935
+ self._la = 0 # Token type
1019
936
  try:
1020
937
  self.enterOuterAlt(localctx, 1)
1021
938
  self.state = 161
@@ -1025,7 +942,7 @@ class malParser ( Parser ):
1025
942
  self.state = 166
1026
943
  self._errHandler.sync(self)
1027
944
  _la = self._input.LA(1)
1028
- while _la==40:
945
+ while _la == 40:
1029
946
  self.state = 163
1030
947
  self.tag()
1031
948
  self.state = 168
@@ -1035,23 +952,21 @@ class malParser ( Parser ):
1035
952
  self.state = 170
1036
953
  self._errHandler.sync(self)
1037
954
  _la = self._input.LA(1)
1038
- if _la==20:
955
+ if _la == 20:
1039
956
  self.state = 169
1040
957
  self.cias()
1041
958
 
1042
-
1043
959
  self.state = 173
1044
960
  self._errHandler.sync(self)
1045
961
  _la = self._input.LA(1)
1046
- if _la==26:
962
+ if _la == 26:
1047
963
  self.state = 172
1048
964
  self.pdist()
1049
965
 
1050
-
1051
966
  self.state = 178
1052
967
  self._errHandler.sync(self)
1053
968
  _la = self._input.LA(1)
1054
- while _la==17:
969
+ while _la == 17:
1055
970
  self.state = 175
1056
971
  self.meta()
1057
972
  self.state = 180
@@ -1061,7 +976,7 @@ class malParser ( Parser ):
1061
976
  self.state = 184
1062
977
  self._errHandler.sync(self)
1063
978
  _la = self._input.LA(1)
1064
- while _la==38 or _la==48:
979
+ while _la == 38 or _la == 48:
1065
980
  self.state = 181
1066
981
  self.detector()
1067
982
  self.state = 186
@@ -1071,19 +986,17 @@ class malParser ( Parser ):
1071
986
  self.state = 188
1072
987
  self._errHandler.sync(self)
1073
988
  _la = self._input.LA(1)
1074
- if _la==41:
989
+ if _la == 41:
1075
990
  self.state = 187
1076
991
  self.precondition()
1077
992
 
1078
-
1079
993
  self.state = 191
1080
994
  self._errHandler.sync(self)
1081
995
  _la = self._input.LA(1)
1082
- if _la==42 or _la==43:
996
+ if _la == 42 or _la == 43:
1083
997
  self.state = 190
1084
998
  self.reaches()
1085
999
 
1086
-
1087
1000
  except RecognitionException as re:
1088
1001
  localctx.exception = re
1089
1002
  self._errHandler.reportError(self, re)
@@ -1092,11 +1005,10 @@ class malParser ( Parser ):
1092
1005
  self.exitRule()
1093
1006
  return localctx
1094
1007
 
1095
-
1096
1008
  class SteptypeContext(ParserRuleContext):
1097
1009
  __slots__ = 'parser'
1098
1010
 
1099
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1011
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1100
1012
  super().__init__(parent, invokingState)
1101
1013
  self.parser = parser
1102
1014
 
@@ -1118,33 +1030,29 @@ class malParser ( Parser ):
1118
1030
  def getRuleIndex(self):
1119
1031
  return malParser.RULE_steptype
1120
1032
 
1121
- def enterRule(self, listener:ParseTreeListener):
1122
- if hasattr( listener, "enterSteptype" ):
1033
+ def enterRule(self, listener: ParseTreeListener):
1034
+ if hasattr(listener, "enterSteptype"):
1123
1035
  listener.enterSteptype(self)
1124
1036
 
1125
- def exitRule(self, listener:ParseTreeListener):
1126
- if hasattr( listener, "exitSteptype" ):
1037
+ def exitRule(self, listener: ParseTreeListener):
1038
+ if hasattr(listener, "exitSteptype"):
1127
1039
  listener.exitSteptype(self)
1128
1040
 
1129
- def accept(self, visitor:ParseTreeVisitor):
1130
- if hasattr( visitor, "visitSteptype" ):
1041
+ def accept(self, visitor: ParseTreeVisitor):
1042
+ if hasattr(visitor, "visitSteptype"):
1131
1043
  return visitor.visitSteptype(self)
1132
- else:
1133
- return visitor.visitChildren(self)
1134
-
1135
-
1136
-
1044
+ return visitor.visitChildren(self)
1137
1045
 
1138
1046
  def steptype(self):
1139
1047
 
1140
1048
  localctx = malParser.SteptypeContext(self, self._ctx, self.state)
1141
1049
  self.enterRule(localctx, 18, self.RULE_steptype)
1142
- self._la = 0 # Token type
1050
+ self._la = 0 # Token type
1143
1051
  try:
1144
1052
  self.enterOuterAlt(localctx, 1)
1145
1053
  self.state = 193
1146
1054
  _la = self._input.LA(1)
1147
- if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 755918446592) != 0)):
1055
+ if not (((_la) & ~0x3f) == 0 and ((1 << _la) & 755918446592) != 0):
1148
1056
  self._errHandler.recoverInline(self)
1149
1057
  else:
1150
1058
  self._errHandler.reportMatch(self)
@@ -1157,11 +1065,10 @@ class malParser ( Parser ):
1157
1065
  self.exitRule()
1158
1066
  return localctx
1159
1067
 
1160
-
1161
1068
  class TagContext(ParserRuleContext):
1162
1069
  __slots__ = 'parser'
1163
1070
 
1164
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1071
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1165
1072
  super().__init__(parent, invokingState)
1166
1073
  self.parser = parser
1167
1074
 
@@ -1174,22 +1081,18 @@ class malParser ( Parser ):
1174
1081
  def getRuleIndex(self):
1175
1082
  return malParser.RULE_tag
1176
1083
 
1177
- def enterRule(self, listener:ParseTreeListener):
1178
- if hasattr( listener, "enterTag" ):
1084
+ def enterRule(self, listener: ParseTreeListener):
1085
+ if hasattr(listener, "enterTag"):
1179
1086
  listener.enterTag(self)
1180
1087
 
1181
- def exitRule(self, listener:ParseTreeListener):
1182
- if hasattr( listener, "exitTag" ):
1088
+ def exitRule(self, listener: ParseTreeListener):
1089
+ if hasattr(listener, "exitTag"):
1183
1090
  listener.exitTag(self)
1184
1091
 
1185
- def accept(self, visitor:ParseTreeVisitor):
1186
- if hasattr( visitor, "visitTag" ):
1092
+ def accept(self, visitor: ParseTreeVisitor):
1093
+ if hasattr(visitor, "visitTag"):
1187
1094
  return visitor.visitTag(self)
1188
- else:
1189
- return visitor.visitChildren(self)
1190
-
1191
-
1192
-
1095
+ return visitor.visitChildren(self)
1193
1096
 
1194
1097
  def tag(self):
1195
1098
 
@@ -1209,58 +1112,50 @@ class malParser ( Parser ):
1209
1112
  self.exitRule()
1210
1113
  return localctx
1211
1114
 
1212
-
1213
1115
  class CiasContext(ParserRuleContext):
1214
1116
  __slots__ = 'parser'
1215
1117
 
1216
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1118
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1217
1119
  super().__init__(parent, invokingState)
1218
1120
  self.parser = parser
1219
1121
 
1220
1122
  def LCURLY(self):
1221
1123
  return self.getToken(malParser.LCURLY, 0)
1222
1124
 
1223
- def cia(self, i:int=None):
1125
+ def cia(self, i: int = None):
1224
1126
  if i is None:
1225
1127
  return self.getTypedRuleContexts(malParser.CiaContext)
1226
- else:
1227
- return self.getTypedRuleContext(malParser.CiaContext,i)
1228
-
1128
+ return self.getTypedRuleContext(malParser.CiaContext, i)
1229
1129
 
1230
1130
  def RCURLY(self):
1231
1131
  return self.getToken(malParser.RCURLY, 0)
1232
1132
 
1233
- def COMMA(self, i:int=None):
1133
+ def COMMA(self, i: int = None):
1234
1134
  if i is None:
1235
1135
  return self.getTokens(malParser.COMMA)
1236
- else:
1237
- return self.getToken(malParser.COMMA, i)
1136
+ return self.getToken(malParser.COMMA, i)
1238
1137
 
1239
1138
  def getRuleIndex(self):
1240
1139
  return malParser.RULE_cias
1241
1140
 
1242
- def enterRule(self, listener:ParseTreeListener):
1243
- if hasattr( listener, "enterCias" ):
1141
+ def enterRule(self, listener: ParseTreeListener):
1142
+ if hasattr(listener, "enterCias"):
1244
1143
  listener.enterCias(self)
1245
1144
 
1246
- def exitRule(self, listener:ParseTreeListener):
1247
- if hasattr( listener, "exitCias" ):
1145
+ def exitRule(self, listener: ParseTreeListener):
1146
+ if hasattr(listener, "exitCias"):
1248
1147
  listener.exitCias(self)
1249
1148
 
1250
- def accept(self, visitor:ParseTreeVisitor):
1251
- if hasattr( visitor, "visitCias" ):
1149
+ def accept(self, visitor: ParseTreeVisitor):
1150
+ if hasattr(visitor, "visitCias"):
1252
1151
  return visitor.visitCias(self)
1253
- else:
1254
- return visitor.visitChildren(self)
1255
-
1256
-
1257
-
1152
+ return visitor.visitChildren(self)
1258
1153
 
1259
1154
  def cias(self):
1260
1155
 
1261
1156
  localctx = malParser.CiasContext(self, self._ctx, self.state)
1262
1157
  self.enterRule(localctx, 22, self.RULE_cias)
1263
- self._la = 0 # Token type
1158
+ self._la = 0 # Token type
1264
1159
  try:
1265
1160
  self.enterOuterAlt(localctx, 1)
1266
1161
  self.state = 198
@@ -1270,7 +1165,7 @@ class malParser ( Parser ):
1270
1165
  self.state = 204
1271
1166
  self._errHandler.sync(self)
1272
1167
  _la = self._input.LA(1)
1273
- while _la==44:
1168
+ while _la == 44:
1274
1169
  self.state = 200
1275
1170
  self.match(malParser.COMMA)
1276
1171
  self.state = 201
@@ -1289,11 +1184,10 @@ class malParser ( Parser ):
1289
1184
  self.exitRule()
1290
1185
  return localctx
1291
1186
 
1292
-
1293
1187
  class CiaContext(ParserRuleContext):
1294
1188
  __slots__ = 'parser'
1295
1189
 
1296
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1190
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1297
1191
  super().__init__(parent, invokingState)
1298
1192
  self.parser = parser
1299
1193
 
@@ -1309,33 +1203,29 @@ class malParser ( Parser ):
1309
1203
  def getRuleIndex(self):
1310
1204
  return malParser.RULE_cia
1311
1205
 
1312
- def enterRule(self, listener:ParseTreeListener):
1313
- if hasattr( listener, "enterCia" ):
1206
+ def enterRule(self, listener: ParseTreeListener):
1207
+ if hasattr(listener, "enterCia"):
1314
1208
  listener.enterCia(self)
1315
1209
 
1316
- def exitRule(self, listener:ParseTreeListener):
1317
- if hasattr( listener, "exitCia" ):
1210
+ def exitRule(self, listener: ParseTreeListener):
1211
+ if hasattr(listener, "exitCia"):
1318
1212
  listener.exitCia(self)
1319
1213
 
1320
- def accept(self, visitor:ParseTreeVisitor):
1321
- if hasattr( visitor, "visitCia" ):
1214
+ def accept(self, visitor: ParseTreeVisitor):
1215
+ if hasattr(visitor, "visitCia"):
1322
1216
  return visitor.visitCia(self)
1323
- else:
1324
- return visitor.visitChildren(self)
1325
-
1326
-
1327
-
1217
+ return visitor.visitChildren(self)
1328
1218
 
1329
1219
  def cia(self):
1330
1220
 
1331
1221
  localctx = malParser.CiaContext(self, self._ctx, self.state)
1332
1222
  self.enterRule(localctx, 24, self.RULE_cia)
1333
- self._la = 0 # Token type
1223
+ self._la = 0 # Token type
1334
1224
  try:
1335
1225
  self.enterOuterAlt(localctx, 1)
1336
1226
  self.state = 209
1337
1227
  _la = self._input.LA(1)
1338
- if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 114688) != 0)):
1228
+ if not (((_la) & ~0x3f) == 0 and ((1 << _la) & 114688) != 0):
1339
1229
  self._errHandler.recoverInline(self)
1340
1230
  else:
1341
1231
  self._errHandler.reportMatch(self)
@@ -1348,37 +1238,31 @@ class malParser ( Parser ):
1348
1238
  self.exitRule()
1349
1239
  return localctx
1350
1240
 
1351
-
1352
1241
  class TtcContext(ParserRuleContext):
1353
1242
  __slots__ = 'parser'
1354
1243
 
1355
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1244
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1356
1245
  super().__init__(parent, invokingState)
1357
1246
  self.parser = parser
1358
1247
 
1359
1248
  def pdist(self):
1360
- return self.getTypedRuleContext(malParser.PdistContext,0)
1361
-
1249
+ return self.getTypedRuleContext(malParser.PdistContext, 0)
1362
1250
 
1363
1251
  def getRuleIndex(self):
1364
1252
  return malParser.RULE_ttc
1365
1253
 
1366
- def enterRule(self, listener:ParseTreeListener):
1367
- if hasattr( listener, "enterTtc" ):
1254
+ def enterRule(self, listener: ParseTreeListener):
1255
+ if hasattr(listener, "enterTtc"):
1368
1256
  listener.enterTtc(self)
1369
1257
 
1370
- def exitRule(self, listener:ParseTreeListener):
1371
- if hasattr( listener, "exitTtc" ):
1258
+ def exitRule(self, listener: ParseTreeListener):
1259
+ if hasattr(listener, "exitTtc"):
1372
1260
  listener.exitTtc(self)
1373
1261
 
1374
- def accept(self, visitor:ParseTreeVisitor):
1375
- if hasattr( visitor, "visitTtc" ):
1262
+ def accept(self, visitor: ParseTreeVisitor):
1263
+ if hasattr(visitor, "visitTtc"):
1376
1264
  return visitor.visitTtc(self)
1377
- else:
1378
- return visitor.visitChildren(self)
1379
-
1380
-
1381
-
1265
+ return visitor.visitChildren(self)
1382
1266
 
1383
1267
  def ttc(self):
1384
1268
 
@@ -1396,11 +1280,10 @@ class malParser ( Parser ):
1396
1280
  self.exitRule()
1397
1281
  return localctx
1398
1282
 
1399
-
1400
1283
  class PdistContext(ParserRuleContext):
1401
1284
  __slots__ = 'parser'
1402
1285
 
1403
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1286
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1404
1287
  super().__init__(parent, invokingState)
1405
1288
  self.parser = parser
1406
1289
 
@@ -1408,8 +1291,7 @@ class malParser ( Parser ):
1408
1291
  return self.getToken(malParser.LSQUARE, 0)
1409
1292
 
1410
1293
  def pdistexpr(self):
1411
- return self.getTypedRuleContext(malParser.PdistexprContext,0)
1412
-
1294
+ return self.getTypedRuleContext(malParser.PdistexprContext, 0)
1413
1295
 
1414
1296
  def RSQUARE(self):
1415
1297
  return self.getToken(malParser.RSQUARE, 0)
@@ -1417,22 +1299,18 @@ class malParser ( Parser ):
1417
1299
  def getRuleIndex(self):
1418
1300
  return malParser.RULE_pdist
1419
1301
 
1420
- def enterRule(self, listener:ParseTreeListener):
1421
- if hasattr( listener, "enterPdist" ):
1302
+ def enterRule(self, listener: ParseTreeListener):
1303
+ if hasattr(listener, "enterPdist"):
1422
1304
  listener.enterPdist(self)
1423
1305
 
1424
- def exitRule(self, listener:ParseTreeListener):
1425
- if hasattr( listener, "exitPdist" ):
1306
+ def exitRule(self, listener: ParseTreeListener):
1307
+ if hasattr(listener, "exitPdist"):
1426
1308
  listener.exitPdist(self)
1427
1309
 
1428
- def accept(self, visitor:ParseTreeVisitor):
1429
- if hasattr( visitor, "visitPdist" ):
1310
+ def accept(self, visitor: ParseTreeVisitor):
1311
+ if hasattr(visitor, "visitPdist"):
1430
1312
  return visitor.visitPdist(self)
1431
- else:
1432
- return visitor.visitChildren(self)
1433
-
1434
-
1435
-
1313
+ return visitor.visitChildren(self)
1436
1314
 
1437
1315
  def pdist(self):
1438
1316
 
@@ -1454,58 +1332,49 @@ class malParser ( Parser ):
1454
1332
  self.exitRule()
1455
1333
  return localctx
1456
1334
 
1457
-
1458
1335
  class PdistexprContext(ParserRuleContext):
1459
1336
  __slots__ = 'parser'
1460
1337
 
1461
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1338
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1462
1339
  super().__init__(parent, invokingState)
1463
1340
  self.parser = parser
1464
1341
 
1465
- def pdistterm(self, i:int=None):
1342
+ def pdistterm(self, i: int = None):
1466
1343
  if i is None:
1467
1344
  return self.getTypedRuleContexts(malParser.PdisttermContext)
1468
- else:
1469
- return self.getTypedRuleContext(malParser.PdisttermContext,i)
1470
-
1345
+ return self.getTypedRuleContext(malParser.PdisttermContext, i)
1471
1346
 
1472
- def PLUS(self, i:int=None):
1347
+ def PLUS(self, i: int = None):
1473
1348
  if i is None:
1474
1349
  return self.getTokens(malParser.PLUS)
1475
- else:
1476
- return self.getToken(malParser.PLUS, i)
1350
+ return self.getToken(malParser.PLUS, i)
1477
1351
 
1478
- def MINUS(self, i:int=None):
1352
+ def MINUS(self, i: int = None):
1479
1353
  if i is None:
1480
1354
  return self.getTokens(malParser.MINUS)
1481
- else:
1482
- return self.getToken(malParser.MINUS, i)
1355
+ return self.getToken(malParser.MINUS, i)
1483
1356
 
1484
1357
  def getRuleIndex(self):
1485
1358
  return malParser.RULE_pdistexpr
1486
1359
 
1487
- def enterRule(self, listener:ParseTreeListener):
1488
- if hasattr( listener, "enterPdistexpr" ):
1360
+ def enterRule(self, listener: ParseTreeListener):
1361
+ if hasattr(listener, "enterPdistexpr"):
1489
1362
  listener.enterPdistexpr(self)
1490
1363
 
1491
- def exitRule(self, listener:ParseTreeListener):
1492
- if hasattr( listener, "exitPdistexpr" ):
1364
+ def exitRule(self, listener: ParseTreeListener):
1365
+ if hasattr(listener, "exitPdistexpr"):
1493
1366
  listener.exitPdistexpr(self)
1494
1367
 
1495
- def accept(self, visitor:ParseTreeVisitor):
1496
- if hasattr( visitor, "visitPdistexpr" ):
1368
+ def accept(self, visitor: ParseTreeVisitor):
1369
+ if hasattr(visitor, "visitPdistexpr"):
1497
1370
  return visitor.visitPdistexpr(self)
1498
- else:
1499
- return visitor.visitChildren(self)
1500
-
1501
-
1502
-
1371
+ return visitor.visitChildren(self)
1503
1372
 
1504
1373
  def pdistexpr(self):
1505
1374
 
1506
1375
  localctx = malParser.PdistexprContext(self, self._ctx, self.state)
1507
1376
  self.enterRule(localctx, 30, self.RULE_pdistexpr)
1508
- self._la = 0 # Token type
1377
+ self._la = 0 # Token type
1509
1378
  try:
1510
1379
  self.enterOuterAlt(localctx, 1)
1511
1380
  self.state = 217
@@ -1513,10 +1382,10 @@ class malParser ( Parser ):
1513
1382
  self.state = 222
1514
1383
  self._errHandler.sync(self)
1515
1384
  _la = self._input.LA(1)
1516
- while _la==31 or _la==45:
1385
+ while _la == 31 or _la == 45:
1517
1386
  self.state = 218
1518
1387
  _la = self._input.LA(1)
1519
- if not(_la==31 or _la==45):
1388
+ if not (_la == 31 or _la == 45):
1520
1389
  self._errHandler.recoverInline(self)
1521
1390
  else:
1522
1391
  self._errHandler.reportMatch(self)
@@ -1535,58 +1404,49 @@ class malParser ( Parser ):
1535
1404
  self.exitRule()
1536
1405
  return localctx
1537
1406
 
1538
-
1539
1407
  class PdisttermContext(ParserRuleContext):
1540
1408
  __slots__ = 'parser'
1541
1409
 
1542
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1410
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1543
1411
  super().__init__(parent, invokingState)
1544
1412
  self.parser = parser
1545
1413
 
1546
- def pdistfact(self, i:int=None):
1414
+ def pdistfact(self, i: int = None):
1547
1415
  if i is None:
1548
1416
  return self.getTypedRuleContexts(malParser.PdistfactContext)
1549
- else:
1550
- return self.getTypedRuleContext(malParser.PdistfactContext,i)
1417
+ return self.getTypedRuleContext(malParser.PdistfactContext, i)
1551
1418
 
1552
-
1553
- def STAR(self, i:int=None):
1419
+ def STAR(self, i: int = None):
1554
1420
  if i is None:
1555
1421
  return self.getTokens(malParser.STAR)
1556
- else:
1557
- return self.getToken(malParser.STAR, i)
1422
+ return self.getToken(malParser.STAR, i)
1558
1423
 
1559
- def DIVIDE(self, i:int=None):
1424
+ def DIVIDE(self, i: int = None):
1560
1425
  if i is None:
1561
1426
  return self.getTokens(malParser.DIVIDE)
1562
- else:
1563
- return self.getToken(malParser.DIVIDE, i)
1427
+ return self.getToken(malParser.DIVIDE, i)
1564
1428
 
1565
1429
  def getRuleIndex(self):
1566
1430
  return malParser.RULE_pdistterm
1567
1431
 
1568
- def enterRule(self, listener:ParseTreeListener):
1569
- if hasattr( listener, "enterPdistterm" ):
1432
+ def enterRule(self, listener: ParseTreeListener):
1433
+ if hasattr(listener, "enterPdistterm"):
1570
1434
  listener.enterPdistterm(self)
1571
1435
 
1572
- def exitRule(self, listener:ParseTreeListener):
1573
- if hasattr( listener, "exitPdistterm" ):
1436
+ def exitRule(self, listener: ParseTreeListener):
1437
+ if hasattr(listener, "exitPdistterm"):
1574
1438
  listener.exitPdistterm(self)
1575
1439
 
1576
- def accept(self, visitor:ParseTreeVisitor):
1577
- if hasattr( visitor, "visitPdistterm" ):
1440
+ def accept(self, visitor: ParseTreeVisitor):
1441
+ if hasattr(visitor, "visitPdistterm"):
1578
1442
  return visitor.visitPdistterm(self)
1579
- else:
1580
- return visitor.visitChildren(self)
1581
-
1582
-
1583
-
1443
+ return visitor.visitChildren(self)
1584
1444
 
1585
1445
  def pdistterm(self):
1586
1446
 
1587
1447
  localctx = malParser.PdisttermContext(self, self._ctx, self.state)
1588
1448
  self.enterRule(localctx, 32, self.RULE_pdistterm)
1589
- self._la = 0 # Token type
1449
+ self._la = 0 # Token type
1590
1450
  try:
1591
1451
  self.enterOuterAlt(localctx, 1)
1592
1452
  self.state = 225
@@ -1594,10 +1454,10 @@ class malParser ( Parser ):
1594
1454
  self.state = 230
1595
1455
  self._errHandler.sync(self)
1596
1456
  _la = self._input.LA(1)
1597
- while _la==28 or _la==46:
1457
+ while _la == 28 or _la == 46:
1598
1458
  self.state = 226
1599
1459
  _la = self._input.LA(1)
1600
- if not(_la==28 or _la==46):
1460
+ if not (_la == 28 or _la == 46):
1601
1461
  self._errHandler.recoverInline(self)
1602
1462
  else:
1603
1463
  self._errHandler.reportMatch(self)
@@ -1616,20 +1476,17 @@ class malParser ( Parser ):
1616
1476
  self.exitRule()
1617
1477
  return localctx
1618
1478
 
1619
-
1620
1479
  class PdistfactContext(ParserRuleContext):
1621
1480
  __slots__ = 'parser'
1622
1481
 
1623
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1482
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1624
1483
  super().__init__(parent, invokingState)
1625
1484
  self.parser = parser
1626
1485
 
1627
- def pdistatom(self, i:int=None):
1486
+ def pdistatom(self, i: int = None):
1628
1487
  if i is None:
1629
1488
  return self.getTypedRuleContexts(malParser.PdistatomContext)
1630
- else:
1631
- return self.getTypedRuleContext(malParser.PdistatomContext,i)
1632
-
1489
+ return self.getTypedRuleContext(malParser.PdistatomContext, i)
1633
1490
 
1634
1491
  def POWER(self):
1635
1492
  return self.getToken(malParser.POWER, 0)
@@ -1637,28 +1494,24 @@ class malParser ( Parser ):
1637
1494
  def getRuleIndex(self):
1638
1495
  return malParser.RULE_pdistfact
1639
1496
 
1640
- def enterRule(self, listener:ParseTreeListener):
1641
- if hasattr( listener, "enterPdistfact" ):
1497
+ def enterRule(self, listener: ParseTreeListener):
1498
+ if hasattr(listener, "enterPdistfact"):
1642
1499
  listener.enterPdistfact(self)
1643
1500
 
1644
- def exitRule(self, listener:ParseTreeListener):
1645
- if hasattr( listener, "exitPdistfact" ):
1501
+ def exitRule(self, listener: ParseTreeListener):
1502
+ if hasattr(listener, "exitPdistfact"):
1646
1503
  listener.exitPdistfact(self)
1647
1504
 
1648
- def accept(self, visitor:ParseTreeVisitor):
1649
- if hasattr( visitor, "visitPdistfact" ):
1505
+ def accept(self, visitor: ParseTreeVisitor):
1506
+ if hasattr(visitor, "visitPdistfact"):
1650
1507
  return visitor.visitPdistfact(self)
1651
- else:
1652
- return visitor.visitChildren(self)
1653
-
1654
-
1655
-
1508
+ return visitor.visitChildren(self)
1656
1509
 
1657
1510
  def pdistfact(self):
1658
1511
 
1659
1512
  localctx = malParser.PdistfactContext(self, self._ctx, self.state)
1660
1513
  self.enterRule(localctx, 34, self.RULE_pdistfact)
1661
- self._la = 0 # Token type
1514
+ self._la = 0 # Token type
1662
1515
  try:
1663
1516
  self.enterOuterAlt(localctx, 1)
1664
1517
  self.state = 233
@@ -1666,13 +1519,12 @@ class malParser ( Parser ):
1666
1519
  self.state = 236
1667
1520
  self._errHandler.sync(self)
1668
1521
  _la = self._input.LA(1)
1669
- if _la==47:
1522
+ if _la == 47:
1670
1523
  self.state = 234
1671
1524
  self.match(malParser.POWER)
1672
1525
  self.state = 235
1673
1526
  self.pdistatom()
1674
1527
 
1675
-
1676
1528
  except RecognitionException as re:
1677
1529
  localctx.exception = re
1678
1530
  self._errHandler.reportError(self, re)
@@ -1681,51 +1533,43 @@ class malParser ( Parser ):
1681
1533
  self.exitRule()
1682
1534
  return localctx
1683
1535
 
1684
-
1685
1536
  class PdistatomContext(ParserRuleContext):
1686
1537
  __slots__ = 'parser'
1687
1538
 
1688
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1539
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1689
1540
  super().__init__(parent, invokingState)
1690
1541
  self.parser = parser
1691
1542
 
1692
1543
  def pdistdist(self):
1693
- return self.getTypedRuleContext(malParser.PdistdistContext,0)
1694
-
1544
+ return self.getTypedRuleContext(malParser.PdistdistContext, 0)
1695
1545
 
1696
1546
  def LPAREN(self):
1697
1547
  return self.getToken(malParser.LPAREN, 0)
1698
1548
 
1699
1549
  def pdistexpr(self):
1700
- return self.getTypedRuleContext(malParser.PdistexprContext,0)
1701
-
1550
+ return self.getTypedRuleContext(malParser.PdistexprContext, 0)
1702
1551
 
1703
1552
  def RPAREN(self):
1704
1553
  return self.getToken(malParser.RPAREN, 0)
1705
1554
 
1706
1555
  def number(self):
1707
- return self.getTypedRuleContext(malParser.NumberContext,0)
1708
-
1556
+ return self.getTypedRuleContext(malParser.NumberContext, 0)
1709
1557
 
1710
1558
  def getRuleIndex(self):
1711
1559
  return malParser.RULE_pdistatom
1712
1560
 
1713
- def enterRule(self, listener:ParseTreeListener):
1714
- if hasattr( listener, "enterPdistatom" ):
1561
+ def enterRule(self, listener: ParseTreeListener):
1562
+ if hasattr(listener, "enterPdistatom"):
1715
1563
  listener.enterPdistatom(self)
1716
1564
 
1717
- def exitRule(self, listener:ParseTreeListener):
1718
- if hasattr( listener, "exitPdistatom" ):
1565
+ def exitRule(self, listener: ParseTreeListener):
1566
+ if hasattr(listener, "exitPdistatom"):
1719
1567
  listener.exitPdistatom(self)
1720
1568
 
1721
- def accept(self, visitor:ParseTreeVisitor):
1722
- if hasattr( visitor, "visitPdistatom" ):
1569
+ def accept(self, visitor: ParseTreeVisitor):
1570
+ if hasattr(visitor, "visitPdistatom"):
1723
1571
  return visitor.visitPdistatom(self)
1724
- else:
1725
- return visitor.visitChildren(self)
1726
-
1727
-
1728
-
1572
+ return visitor.visitChildren(self)
1729
1573
 
1730
1574
  def pdistatom(self):
1731
1575
 
@@ -1735,12 +1579,11 @@ class malParser ( Parser ):
1735
1579
  self.state = 244
1736
1580
  self._errHandler.sync(self)
1737
1581
  token = self._input.LA(1)
1738
- if token in [17]:
1582
+ if token == 17:
1739
1583
  self.enterOuterAlt(localctx, 1)
1740
1584
  self.state = 238
1741
1585
  self.pdistdist()
1742
- pass
1743
- elif token in [18]:
1586
+ elif token == 18:
1744
1587
  self.enterOuterAlt(localctx, 2)
1745
1588
  self.state = 239
1746
1589
  self.match(malParser.LPAREN)
@@ -1748,12 +1591,10 @@ class malParser ( Parser ):
1748
1591
  self.pdistexpr()
1749
1592
  self.state = 241
1750
1593
  self.match(malParser.RPAREN)
1751
- pass
1752
1594
  elif token in [11, 12]:
1753
1595
  self.enterOuterAlt(localctx, 3)
1754
1596
  self.state = 243
1755
1597
  self.number()
1756
- pass
1757
1598
  else:
1758
1599
  raise NoViableAltException(self)
1759
1600
 
@@ -1765,11 +1606,10 @@ class malParser ( Parser ):
1765
1606
  self.exitRule()
1766
1607
  return localctx
1767
1608
 
1768
-
1769
1609
  class PdistdistContext(ParserRuleContext):
1770
1610
  __slots__ = 'parser'
1771
1611
 
1772
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1612
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1773
1613
  super().__init__(parent, invokingState)
1774
1614
  self.parser = parser
1775
1615
 
@@ -1782,44 +1622,37 @@ class malParser ( Parser ):
1782
1622
  def RPAREN(self):
1783
1623
  return self.getToken(malParser.RPAREN, 0)
1784
1624
 
1785
- def number(self, i:int=None):
1625
+ def number(self, i: int = None):
1786
1626
  if i is None:
1787
1627
  return self.getTypedRuleContexts(malParser.NumberContext)
1788
- else:
1789
- return self.getTypedRuleContext(malParser.NumberContext,i)
1628
+ return self.getTypedRuleContext(malParser.NumberContext, i)
1790
1629
 
1791
-
1792
- def COMMA(self, i:int=None):
1630
+ def COMMA(self, i: int = None):
1793
1631
  if i is None:
1794
1632
  return self.getTokens(malParser.COMMA)
1795
- else:
1796
- return self.getToken(malParser.COMMA, i)
1633
+ return self.getToken(malParser.COMMA, i)
1797
1634
 
1798
1635
  def getRuleIndex(self):
1799
1636
  return malParser.RULE_pdistdist
1800
1637
 
1801
- def enterRule(self, listener:ParseTreeListener):
1802
- if hasattr( listener, "enterPdistdist" ):
1638
+ def enterRule(self, listener: ParseTreeListener):
1639
+ if hasattr(listener, "enterPdistdist"):
1803
1640
  listener.enterPdistdist(self)
1804
1641
 
1805
- def exitRule(self, listener:ParseTreeListener):
1806
- if hasattr( listener, "exitPdistdist" ):
1642
+ def exitRule(self, listener: ParseTreeListener):
1643
+ if hasattr(listener, "exitPdistdist"):
1807
1644
  listener.exitPdistdist(self)
1808
1645
 
1809
- def accept(self, visitor:ParseTreeVisitor):
1810
- if hasattr( visitor, "visitPdistdist" ):
1646
+ def accept(self, visitor: ParseTreeVisitor):
1647
+ if hasattr(visitor, "visitPdistdist"):
1811
1648
  return visitor.visitPdistdist(self)
1812
- else:
1813
- return visitor.visitChildren(self)
1814
-
1815
-
1816
-
1649
+ return visitor.visitChildren(self)
1817
1650
 
1818
1651
  def pdistdist(self):
1819
1652
 
1820
1653
  localctx = malParser.PdistdistContext(self, self._ctx, self.state)
1821
1654
  self.enterRule(localctx, 38, self.RULE_pdistdist)
1822
- self._la = 0 # Token type
1655
+ self._la = 0 # Token type
1823
1656
  try:
1824
1657
  self.enterOuterAlt(localctx, 1)
1825
1658
  self.state = 246
@@ -1827,19 +1660,19 @@ class malParser ( Parser ):
1827
1660
  self.state = 259
1828
1661
  self._errHandler.sync(self)
1829
1662
  _la = self._input.LA(1)
1830
- if _la==18:
1663
+ if _la == 18:
1831
1664
  self.state = 247
1832
1665
  self.match(malParser.LPAREN)
1833
1666
  self.state = 256
1834
1667
  self._errHandler.sync(self)
1835
1668
  _la = self._input.LA(1)
1836
- if _la==11 or _la==12:
1669
+ if _la == 11 or _la == 12:
1837
1670
  self.state = 248
1838
1671
  self.number()
1839
1672
  self.state = 253
1840
1673
  self._errHandler.sync(self)
1841
1674
  _la = self._input.LA(1)
1842
- while _la==44:
1675
+ while _la == 44:
1843
1676
  self.state = 249
1844
1677
  self.match(malParser.COMMA)
1845
1678
  self.state = 250
@@ -1848,12 +1681,9 @@ class malParser ( Parser ):
1848
1681
  self._errHandler.sync(self)
1849
1682
  _la = self._input.LA(1)
1850
1683
 
1851
-
1852
-
1853
1684
  self.state = 258
1854
1685
  self.match(malParser.RPAREN)
1855
1686
 
1856
-
1857
1687
  except RecognitionException as re:
1858
1688
  localctx.exception = re
1859
1689
  self._errHandler.reportError(self, re)
@@ -1862,59 +1692,49 @@ class malParser ( Parser ):
1862
1692
  self.exitRule()
1863
1693
  return localctx
1864
1694
 
1865
-
1866
1695
  class DetectorContext(ParserRuleContext):
1867
1696
  __slots__ = 'parser'
1868
1697
 
1869
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1698
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1870
1699
  super().__init__(parent, invokingState)
1871
1700
  self.parser = parser
1872
1701
 
1873
1702
  def bang(self):
1874
- return self.getTypedRuleContext(malParser.BangContext,0)
1875
-
1703
+ return self.getTypedRuleContext(malParser.BangContext, 0)
1876
1704
 
1877
1705
  def context(self):
1878
- return self.getTypedRuleContext(malParser.ContextContext,0)
1879
-
1706
+ return self.getTypedRuleContext(malParser.ContextContext, 0)
1880
1707
 
1881
1708
  def detectorname(self):
1882
- return self.getTypedRuleContext(malParser.DetectornameContext,0)
1883
-
1709
+ return self.getTypedRuleContext(malParser.DetectornameContext, 0)
1884
1710
 
1885
1711
  def detectortype(self):
1886
- return self.getTypedRuleContext(malParser.DetectortypeContext,0)
1887
-
1712
+ return self.getTypedRuleContext(malParser.DetectortypeContext, 0)
1888
1713
 
1889
1714
  def tprate(self):
1890
- return self.getTypedRuleContext(malParser.TprateContext,0)
1891
-
1715
+ return self.getTypedRuleContext(malParser.TprateContext, 0)
1892
1716
 
1893
1717
  def getRuleIndex(self):
1894
1718
  return malParser.RULE_detector
1895
1719
 
1896
- def enterRule(self, listener:ParseTreeListener):
1897
- if hasattr( listener, "enterDetector" ):
1720
+ def enterRule(self, listener: ParseTreeListener):
1721
+ if hasattr(listener, "enterDetector"):
1898
1722
  listener.enterDetector(self)
1899
1723
 
1900
- def exitRule(self, listener:ParseTreeListener):
1901
- if hasattr( listener, "exitDetector" ):
1724
+ def exitRule(self, listener: ParseTreeListener):
1725
+ if hasattr(listener, "exitDetector"):
1902
1726
  listener.exitDetector(self)
1903
1727
 
1904
- def accept(self, visitor:ParseTreeVisitor):
1905
- if hasattr( visitor, "visitDetector" ):
1728
+ def accept(self, visitor: ParseTreeVisitor):
1729
+ if hasattr(visitor, "visitDetector"):
1906
1730
  return visitor.visitDetector(self)
1907
- else:
1908
- return visitor.visitChildren(self)
1909
-
1910
-
1911
-
1731
+ return visitor.visitChildren(self)
1912
1732
 
1913
1733
  def detector(self):
1914
1734
 
1915
1735
  localctx = malParser.DetectorContext(self, self._ctx, self.state)
1916
1736
  self.enterRule(localctx, 40, self.RULE_detector)
1917
- self._la = 0 # Token type
1737
+ self._la = 0 # Token type
1918
1738
  try:
1919
1739
  self.enterOuterAlt(localctx, 1)
1920
1740
  self.state = 261
@@ -1922,29 +1742,26 @@ class malParser ( Parser ):
1922
1742
  self.state = 263
1923
1743
  self._errHandler.sync(self)
1924
1744
  _la = self._input.LA(1)
1925
- if _la==17:
1745
+ if _la == 17:
1926
1746
  self.state = 262
1927
1747
  self.detectorname()
1928
1748
 
1929
-
1930
1749
  self.state = 265
1931
1750
  self.context()
1932
1751
  self.state = 267
1933
1752
  self._errHandler.sync(self)
1934
1753
  _la = self._input.LA(1)
1935
- if _la==17:
1754
+ if _la == 17:
1936
1755
  self.state = 266
1937
1756
  self.detectortype()
1938
1757
 
1939
-
1940
1758
  self.state = 270
1941
1759
  self._errHandler.sync(self)
1942
1760
  _la = self._input.LA(1)
1943
- if _la==26:
1761
+ if _la == 26:
1944
1762
  self.state = 269
1945
1763
  self.tprate()
1946
1764
 
1947
-
1948
1765
  except RecognitionException as re:
1949
1766
  localctx.exception = re
1950
1767
  self._errHandler.reportError(self, re)
@@ -1953,11 +1770,10 @@ class malParser ( Parser ):
1953
1770
  self.exitRule()
1954
1771
  return localctx
1955
1772
 
1956
-
1957
1773
  class BangContext(ParserRuleContext):
1958
1774
  __slots__ = 'parser'
1959
1775
 
1960
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1776
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1961
1777
  super().__init__(parent, invokingState)
1962
1778
  self.parser = parser
1963
1779
 
@@ -1970,33 +1786,29 @@ class malParser ( Parser ):
1970
1786
  def getRuleIndex(self):
1971
1787
  return malParser.RULE_bang
1972
1788
 
1973
- def enterRule(self, listener:ParseTreeListener):
1974
- if hasattr( listener, "enterBang" ):
1789
+ def enterRule(self, listener: ParseTreeListener):
1790
+ if hasattr(listener, "enterBang"):
1975
1791
  listener.enterBang(self)
1976
1792
 
1977
- def exitRule(self, listener:ParseTreeListener):
1978
- if hasattr( listener, "exitBang" ):
1793
+ def exitRule(self, listener: ParseTreeListener):
1794
+ if hasattr(listener, "exitBang"):
1979
1795
  listener.exitBang(self)
1980
1796
 
1981
- def accept(self, visitor:ParseTreeVisitor):
1982
- if hasattr( visitor, "visitBang" ):
1797
+ def accept(self, visitor: ParseTreeVisitor):
1798
+ if hasattr(visitor, "visitBang"):
1983
1799
  return visitor.visitBang(self)
1984
- else:
1985
- return visitor.visitChildren(self)
1986
-
1987
-
1988
-
1800
+ return visitor.visitChildren(self)
1989
1801
 
1990
1802
  def bang(self):
1991
1803
 
1992
1804
  localctx = malParser.BangContext(self, self._ctx, self.state)
1993
1805
  self.enterRule(localctx, 42, self.RULE_bang)
1994
- self._la = 0 # Token type
1806
+ self._la = 0 # Token type
1995
1807
  try:
1996
1808
  self.enterOuterAlt(localctx, 1)
1997
1809
  self.state = 272
1998
1810
  _la = self._input.LA(1)
1999
- if not(_la==38 or _la==48):
1811
+ if not (_la == 38 or _la == 48):
2000
1812
  self._errHandler.recoverInline(self)
2001
1813
  else:
2002
1814
  self._errHandler.reportMatch(self)
@@ -2009,51 +1821,44 @@ class malParser ( Parser ):
2009
1821
  self.exitRule()
2010
1822
  return localctx
2011
1823
 
2012
-
2013
1824
  class DetectornameContext(ParserRuleContext):
2014
1825
  __slots__ = 'parser'
2015
1826
 
2016
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1827
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2017
1828
  super().__init__(parent, invokingState)
2018
1829
  self.parser = parser
2019
1830
 
2020
- def ID(self, i:int=None):
1831
+ def ID(self, i: int = None):
2021
1832
  if i is None:
2022
1833
  return self.getTokens(malParser.ID)
2023
- else:
2024
- return self.getToken(malParser.ID, i)
1834
+ return self.getToken(malParser.ID, i)
2025
1835
 
2026
- def DOT(self, i:int=None):
1836
+ def DOT(self, i: int = None):
2027
1837
  if i is None:
2028
1838
  return self.getTokens(malParser.DOT)
2029
- else:
2030
- return self.getToken(malParser.DOT, i)
1839
+ return self.getToken(malParser.DOT, i)
2031
1840
 
2032
1841
  def getRuleIndex(self):
2033
1842
  return malParser.RULE_detectorname
2034
1843
 
2035
- def enterRule(self, listener:ParseTreeListener):
2036
- if hasattr( listener, "enterDetectorname" ):
1844
+ def enterRule(self, listener: ParseTreeListener):
1845
+ if hasattr(listener, "enterDetectorname"):
2037
1846
  listener.enterDetectorname(self)
2038
1847
 
2039
- def exitRule(self, listener:ParseTreeListener):
2040
- if hasattr( listener, "exitDetectorname" ):
1848
+ def exitRule(self, listener: ParseTreeListener):
1849
+ if hasattr(listener, "exitDetectorname"):
2041
1850
  listener.exitDetectorname(self)
2042
1851
 
2043
- def accept(self, visitor:ParseTreeVisitor):
2044
- if hasattr( visitor, "visitDetectorname" ):
1852
+ def accept(self, visitor: ParseTreeVisitor):
1853
+ if hasattr(visitor, "visitDetectorname"):
2045
1854
  return visitor.visitDetectorname(self)
2046
- else:
2047
- return visitor.visitChildren(self)
2048
-
2049
-
2050
-
1855
+ return visitor.visitChildren(self)
2051
1856
 
2052
1857
  def detectorname(self):
2053
1858
 
2054
1859
  localctx = malParser.DetectornameContext(self, self._ctx, self.state)
2055
1860
  self.enterRule(localctx, 44, self.RULE_detectorname)
2056
- self._la = 0 # Token type
1861
+ self._la = 0 # Token type
2057
1862
  try:
2058
1863
  self.enterOuterAlt(localctx, 1)
2059
1864
  self.state = 274
@@ -2061,7 +1866,7 @@ class malParser ( Parser ):
2061
1866
  self.state = 279
2062
1867
  self._errHandler.sync(self)
2063
1868
  _la = self._input.LA(1)
2064
- while _la==35:
1869
+ while _la == 35:
2065
1870
  self.state = 275
2066
1871
  self.match(malParser.DOT)
2067
1872
  self.state = 276
@@ -2078,58 +1883,50 @@ class malParser ( Parser ):
2078
1883
  self.exitRule()
2079
1884
  return localctx
2080
1885
 
2081
-
2082
1886
  class ContextContext(ParserRuleContext):
2083
1887
  __slots__ = 'parser'
2084
1888
 
2085
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1889
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2086
1890
  super().__init__(parent, invokingState)
2087
1891
  self.parser = parser
2088
1892
 
2089
1893
  def LPAREN(self):
2090
1894
  return self.getToken(malParser.LPAREN, 0)
2091
1895
 
2092
- def contextpart(self, i:int=None):
1896
+ def contextpart(self, i: int = None):
2093
1897
  if i is None:
2094
1898
  return self.getTypedRuleContexts(malParser.ContextpartContext)
2095
- else:
2096
- return self.getTypedRuleContext(malParser.ContextpartContext,i)
2097
-
1899
+ return self.getTypedRuleContext(malParser.ContextpartContext, i)
2098
1900
 
2099
1901
  def RPAREN(self):
2100
1902
  return self.getToken(malParser.RPAREN, 0)
2101
1903
 
2102
- def COMMA(self, i:int=None):
1904
+ def COMMA(self, i: int = None):
2103
1905
  if i is None:
2104
1906
  return self.getTokens(malParser.COMMA)
2105
- else:
2106
- return self.getToken(malParser.COMMA, i)
1907
+ return self.getToken(malParser.COMMA, i)
2107
1908
 
2108
1909
  def getRuleIndex(self):
2109
1910
  return malParser.RULE_context
2110
1911
 
2111
- def enterRule(self, listener:ParseTreeListener):
2112
- if hasattr( listener, "enterContext" ):
1912
+ def enterRule(self, listener: ParseTreeListener):
1913
+ if hasattr(listener, "enterContext"):
2113
1914
  listener.enterContext(self)
2114
1915
 
2115
- def exitRule(self, listener:ParseTreeListener):
2116
- if hasattr( listener, "exitContext" ):
1916
+ def exitRule(self, listener: ParseTreeListener):
1917
+ if hasattr(listener, "exitContext"):
2117
1918
  listener.exitContext(self)
2118
1919
 
2119
- def accept(self, visitor:ParseTreeVisitor):
2120
- if hasattr( visitor, "visitContext" ):
1920
+ def accept(self, visitor: ParseTreeVisitor):
1921
+ if hasattr(visitor, "visitContext"):
2121
1922
  return visitor.visitContext(self)
2122
- else:
2123
- return visitor.visitChildren(self)
2124
-
2125
-
2126
-
1923
+ return visitor.visitChildren(self)
2127
1924
 
2128
1925
  def context(self):
2129
1926
 
2130
1927
  localctx = malParser.ContextContext(self, self._ctx, self.state)
2131
1928
  self.enterRule(localctx, 46, self.RULE_context)
2132
- self._la = 0 # Token type
1929
+ self._la = 0 # Token type
2133
1930
  try:
2134
1931
  self.enterOuterAlt(localctx, 1)
2135
1932
  self.state = 282
@@ -2139,7 +1936,7 @@ class malParser ( Parser ):
2139
1936
  self.state = 288
2140
1937
  self._errHandler.sync(self)
2141
1938
  _la = self._input.LA(1)
2142
- while _la==44:
1939
+ while _la == 44:
2143
1940
  self.state = 284
2144
1941
  self.match(malParser.COMMA)
2145
1942
  self.state = 285
@@ -2158,41 +1955,34 @@ class malParser ( Parser ):
2158
1955
  self.exitRule()
2159
1956
  return localctx
2160
1957
 
2161
-
2162
1958
  class ContextpartContext(ParserRuleContext):
2163
1959
  __slots__ = 'parser'
2164
1960
 
2165
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1961
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2166
1962
  super().__init__(parent, invokingState)
2167
1963
  self.parser = parser
2168
1964
 
2169
1965
  def contextasset(self):
2170
- return self.getTypedRuleContext(malParser.ContextassetContext,0)
2171
-
1966
+ return self.getTypedRuleContext(malParser.ContextassetContext, 0)
2172
1967
 
2173
1968
  def contextlabel(self):
2174
- return self.getTypedRuleContext(malParser.ContextlabelContext,0)
2175
-
1969
+ return self.getTypedRuleContext(malParser.ContextlabelContext, 0)
2176
1970
 
2177
1971
  def getRuleIndex(self):
2178
1972
  return malParser.RULE_contextpart
2179
1973
 
2180
- def enterRule(self, listener:ParseTreeListener):
2181
- if hasattr( listener, "enterContextpart" ):
1974
+ def enterRule(self, listener: ParseTreeListener):
1975
+ if hasattr(listener, "enterContextpart"):
2182
1976
  listener.enterContextpart(self)
2183
1977
 
2184
- def exitRule(self, listener:ParseTreeListener):
2185
- if hasattr( listener, "exitContextpart" ):
1978
+ def exitRule(self, listener: ParseTreeListener):
1979
+ if hasattr(listener, "exitContextpart"):
2186
1980
  listener.exitContextpart(self)
2187
1981
 
2188
- def accept(self, visitor:ParseTreeVisitor):
2189
- if hasattr( visitor, "visitContextpart" ):
1982
+ def accept(self, visitor: ParseTreeVisitor):
1983
+ if hasattr(visitor, "visitContextpart"):
2190
1984
  return visitor.visitContextpart(self)
2191
- else:
2192
- return visitor.visitChildren(self)
2193
-
2194
-
2195
-
1985
+ return visitor.visitChildren(self)
2196
1986
 
2197
1987
  def contextpart(self):
2198
1988
 
@@ -2212,11 +2002,10 @@ class malParser ( Parser ):
2212
2002
  self.exitRule()
2213
2003
  return localctx
2214
2004
 
2215
-
2216
2005
  class ContextassetContext(ParserRuleContext):
2217
2006
  __slots__ = 'parser'
2218
2007
 
2219
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2008
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2220
2009
  super().__init__(parent, invokingState)
2221
2010
  self.parser = parser
2222
2011
 
@@ -2226,22 +2015,18 @@ class malParser ( Parser ):
2226
2015
  def getRuleIndex(self):
2227
2016
  return malParser.RULE_contextasset
2228
2017
 
2229
- def enterRule(self, listener:ParseTreeListener):
2230
- if hasattr( listener, "enterContextasset" ):
2018
+ def enterRule(self, listener: ParseTreeListener):
2019
+ if hasattr(listener, "enterContextasset"):
2231
2020
  listener.enterContextasset(self)
2232
2021
 
2233
- def exitRule(self, listener:ParseTreeListener):
2234
- if hasattr( listener, "exitContextasset" ):
2022
+ def exitRule(self, listener: ParseTreeListener):
2023
+ if hasattr(listener, "exitContextasset"):
2235
2024
  listener.exitContextasset(self)
2236
2025
 
2237
- def accept(self, visitor:ParseTreeVisitor):
2238
- if hasattr( visitor, "visitContextasset" ):
2026
+ def accept(self, visitor: ParseTreeVisitor):
2027
+ if hasattr(visitor, "visitContextasset"):
2239
2028
  return visitor.visitContextasset(self)
2240
- else:
2241
- return visitor.visitChildren(self)
2242
-
2243
-
2244
-
2029
+ return visitor.visitChildren(self)
2245
2030
 
2246
2031
  def contextasset(self):
2247
2032
 
@@ -2259,11 +2044,10 @@ class malParser ( Parser ):
2259
2044
  self.exitRule()
2260
2045
  return localctx
2261
2046
 
2262
-
2263
2047
  class ContextlabelContext(ParserRuleContext):
2264
2048
  __slots__ = 'parser'
2265
2049
 
2266
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2050
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2267
2051
  super().__init__(parent, invokingState)
2268
2052
  self.parser = parser
2269
2053
 
@@ -2273,22 +2057,18 @@ class malParser ( Parser ):
2273
2057
  def getRuleIndex(self):
2274
2058
  return malParser.RULE_contextlabel
2275
2059
 
2276
- def enterRule(self, listener:ParseTreeListener):
2277
- if hasattr( listener, "enterContextlabel" ):
2060
+ def enterRule(self, listener: ParseTreeListener):
2061
+ if hasattr(listener, "enterContextlabel"):
2278
2062
  listener.enterContextlabel(self)
2279
2063
 
2280
- def exitRule(self, listener:ParseTreeListener):
2281
- if hasattr( listener, "exitContextlabel" ):
2064
+ def exitRule(self, listener: ParseTreeListener):
2065
+ if hasattr(listener, "exitContextlabel"):
2282
2066
  listener.exitContextlabel(self)
2283
2067
 
2284
- def accept(self, visitor:ParseTreeVisitor):
2285
- if hasattr( visitor, "visitContextlabel" ):
2068
+ def accept(self, visitor: ParseTreeVisitor):
2069
+ if hasattr(visitor, "visitContextlabel"):
2286
2070
  return visitor.visitContextlabel(self)
2287
- else:
2288
- return visitor.visitChildren(self)
2289
-
2290
-
2291
-
2071
+ return visitor.visitChildren(self)
2292
2072
 
2293
2073
  def contextlabel(self):
2294
2074
 
@@ -2306,11 +2086,10 @@ class malParser ( Parser ):
2306
2086
  self.exitRule()
2307
2087
  return localctx
2308
2088
 
2309
-
2310
2089
  class DetectortypeContext(ParserRuleContext):
2311
2090
  __slots__ = 'parser'
2312
2091
 
2313
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2092
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2314
2093
  super().__init__(parent, invokingState)
2315
2094
  self.parser = parser
2316
2095
 
@@ -2320,22 +2099,18 @@ class malParser ( Parser ):
2320
2099
  def getRuleIndex(self):
2321
2100
  return malParser.RULE_detectortype
2322
2101
 
2323
- def enterRule(self, listener:ParseTreeListener):
2324
- if hasattr( listener, "enterDetectortype" ):
2102
+ def enterRule(self, listener: ParseTreeListener):
2103
+ if hasattr(listener, "enterDetectortype"):
2325
2104
  listener.enterDetectortype(self)
2326
2105
 
2327
- def exitRule(self, listener:ParseTreeListener):
2328
- if hasattr( listener, "exitDetectortype" ):
2106
+ def exitRule(self, listener: ParseTreeListener):
2107
+ if hasattr(listener, "exitDetectortype"):
2329
2108
  listener.exitDetectortype(self)
2330
2109
 
2331
- def accept(self, visitor:ParseTreeVisitor):
2332
- if hasattr( visitor, "visitDetectortype" ):
2110
+ def accept(self, visitor: ParseTreeVisitor):
2111
+ if hasattr(visitor, "visitDetectortype"):
2333
2112
  return visitor.visitDetectortype(self)
2334
- else:
2335
- return visitor.visitChildren(self)
2336
-
2337
-
2338
-
2113
+ return visitor.visitChildren(self)
2339
2114
 
2340
2115
  def detectortype(self):
2341
2116
 
@@ -2353,37 +2128,31 @@ class malParser ( Parser ):
2353
2128
  self.exitRule()
2354
2129
  return localctx
2355
2130
 
2356
-
2357
2131
  class TprateContext(ParserRuleContext):
2358
2132
  __slots__ = 'parser'
2359
2133
 
2360
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2134
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2361
2135
  super().__init__(parent, invokingState)
2362
2136
  self.parser = parser
2363
2137
 
2364
2138
  def pdist(self):
2365
- return self.getTypedRuleContext(malParser.PdistContext,0)
2366
-
2139
+ return self.getTypedRuleContext(malParser.PdistContext, 0)
2367
2140
 
2368
2141
  def getRuleIndex(self):
2369
2142
  return malParser.RULE_tprate
2370
2143
 
2371
- def enterRule(self, listener:ParseTreeListener):
2372
- if hasattr( listener, "enterTprate" ):
2144
+ def enterRule(self, listener: ParseTreeListener):
2145
+ if hasattr(listener, "enterTprate"):
2373
2146
  listener.enterTprate(self)
2374
2147
 
2375
- def exitRule(self, listener:ParseTreeListener):
2376
- if hasattr( listener, "exitTprate" ):
2148
+ def exitRule(self, listener: ParseTreeListener):
2149
+ if hasattr(listener, "exitTprate"):
2377
2150
  listener.exitTprate(self)
2378
2151
 
2379
- def accept(self, visitor:ParseTreeVisitor):
2380
- if hasattr( visitor, "visitTprate" ):
2152
+ def accept(self, visitor: ParseTreeVisitor):
2153
+ if hasattr(visitor, "visitTprate"):
2381
2154
  return visitor.visitTprate(self)
2382
- else:
2383
- return visitor.visitChildren(self)
2384
-
2385
-
2386
-
2155
+ return visitor.visitChildren(self)
2387
2156
 
2388
2157
  def tprate(self):
2389
2158
 
@@ -2401,55 +2170,47 @@ class malParser ( Parser ):
2401
2170
  self.exitRule()
2402
2171
  return localctx
2403
2172
 
2404
-
2405
2173
  class PreconditionContext(ParserRuleContext):
2406
2174
  __slots__ = 'parser'
2407
2175
 
2408
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2176
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2409
2177
  super().__init__(parent, invokingState)
2410
2178
  self.parser = parser
2411
2179
 
2412
2180
  def REQUIRES(self):
2413
2181
  return self.getToken(malParser.REQUIRES, 0)
2414
2182
 
2415
- def expr(self, i:int=None):
2183
+ def expr(self, i: int = None):
2416
2184
  if i is None:
2417
2185
  return self.getTypedRuleContexts(malParser.ExprContext)
2418
- else:
2419
- return self.getTypedRuleContext(malParser.ExprContext,i)
2420
-
2186
+ return self.getTypedRuleContext(malParser.ExprContext, i)
2421
2187
 
2422
- def COMMA(self, i:int=None):
2188
+ def COMMA(self, i: int = None):
2423
2189
  if i is None:
2424
2190
  return self.getTokens(malParser.COMMA)
2425
- else:
2426
- return self.getToken(malParser.COMMA, i)
2191
+ return self.getToken(malParser.COMMA, i)
2427
2192
 
2428
2193
  def getRuleIndex(self):
2429
2194
  return malParser.RULE_precondition
2430
2195
 
2431
- def enterRule(self, listener:ParseTreeListener):
2432
- if hasattr( listener, "enterPrecondition" ):
2196
+ def enterRule(self, listener: ParseTreeListener):
2197
+ if hasattr(listener, "enterPrecondition"):
2433
2198
  listener.enterPrecondition(self)
2434
2199
 
2435
- def exitRule(self, listener:ParseTreeListener):
2436
- if hasattr( listener, "exitPrecondition" ):
2200
+ def exitRule(self, listener: ParseTreeListener):
2201
+ if hasattr(listener, "exitPrecondition"):
2437
2202
  listener.exitPrecondition(self)
2438
2203
 
2439
- def accept(self, visitor:ParseTreeVisitor):
2440
- if hasattr( visitor, "visitPrecondition" ):
2204
+ def accept(self, visitor: ParseTreeVisitor):
2205
+ if hasattr(visitor, "visitPrecondition"):
2441
2206
  return visitor.visitPrecondition(self)
2442
- else:
2443
- return visitor.visitChildren(self)
2444
-
2445
-
2446
-
2207
+ return visitor.visitChildren(self)
2447
2208
 
2448
2209
  def precondition(self):
2449
2210
 
2450
2211
  localctx = malParser.PreconditionContext(self, self._ctx, self.state)
2451
2212
  self.enterRule(localctx, 58, self.RULE_precondition)
2452
- self._la = 0 # Token type
2213
+ self._la = 0 # Token type
2453
2214
  try:
2454
2215
  self.enterOuterAlt(localctx, 1)
2455
2216
  self.state = 304
@@ -2459,7 +2220,7 @@ class malParser ( Parser ):
2459
2220
  self.state = 310
2460
2221
  self._errHandler.sync(self)
2461
2222
  _la = self._input.LA(1)
2462
- while _la==44:
2223
+ while _la == 44:
2463
2224
  self.state = 306
2464
2225
  self.match(malParser.COMMA)
2465
2226
  self.state = 307
@@ -2476,20 +2237,17 @@ class malParser ( Parser ):
2476
2237
  self.exitRule()
2477
2238
  return localctx
2478
2239
 
2479
-
2480
2240
  class ReachesContext(ParserRuleContext):
2481
2241
  __slots__ = 'parser'
2482
2242
 
2483
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2243
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2484
2244
  super().__init__(parent, invokingState)
2485
2245
  self.parser = parser
2486
2246
 
2487
- def expr(self, i:int=None):
2247
+ def expr(self, i: int = None):
2488
2248
  if i is None:
2489
2249
  return self.getTypedRuleContexts(malParser.ExprContext)
2490
- else:
2491
- return self.getTypedRuleContext(malParser.ExprContext,i)
2492
-
2250
+ return self.getTypedRuleContext(malParser.ExprContext, i)
2493
2251
 
2494
2252
  def INHERITS(self):
2495
2253
  return self.getToken(malParser.INHERITS, 0)
@@ -2497,42 +2255,37 @@ class malParser ( Parser ):
2497
2255
  def LEADSTO(self):
2498
2256
  return self.getToken(malParser.LEADSTO, 0)
2499
2257
 
2500
- def COMMA(self, i:int=None):
2258
+ def COMMA(self, i: int = None):
2501
2259
  if i is None:
2502
2260
  return self.getTokens(malParser.COMMA)
2503
- else:
2504
- return self.getToken(malParser.COMMA, i)
2261
+ return self.getToken(malParser.COMMA, i)
2505
2262
 
2506
2263
  def getRuleIndex(self):
2507
2264
  return malParser.RULE_reaches
2508
2265
 
2509
- def enterRule(self, listener:ParseTreeListener):
2510
- if hasattr( listener, "enterReaches" ):
2266
+ def enterRule(self, listener: ParseTreeListener):
2267
+ if hasattr(listener, "enterReaches"):
2511
2268
  listener.enterReaches(self)
2512
2269
 
2513
- def exitRule(self, listener:ParseTreeListener):
2514
- if hasattr( listener, "exitReaches" ):
2270
+ def exitRule(self, listener: ParseTreeListener):
2271
+ if hasattr(listener, "exitReaches"):
2515
2272
  listener.exitReaches(self)
2516
2273
 
2517
- def accept(self, visitor:ParseTreeVisitor):
2518
- if hasattr( visitor, "visitReaches" ):
2274
+ def accept(self, visitor: ParseTreeVisitor):
2275
+ if hasattr(visitor, "visitReaches"):
2519
2276
  return visitor.visitReaches(self)
2520
- else:
2521
- return visitor.visitChildren(self)
2522
-
2523
-
2524
-
2277
+ return visitor.visitChildren(self)
2525
2278
 
2526
2279
  def reaches(self):
2527
2280
 
2528
2281
  localctx = malParser.ReachesContext(self, self._ctx, self.state)
2529
2282
  self.enterRule(localctx, 60, self.RULE_reaches)
2530
- self._la = 0 # Token type
2283
+ self._la = 0 # Token type
2531
2284
  try:
2532
2285
  self.enterOuterAlt(localctx, 1)
2533
2286
  self.state = 313
2534
2287
  _la = self._input.LA(1)
2535
- if not(_la==42 or _la==43):
2288
+ if not (_la == 42 or _la == 43):
2536
2289
  self._errHandler.recoverInline(self)
2537
2290
  else:
2538
2291
  self._errHandler.reportMatch(self)
@@ -2542,7 +2295,7 @@ class malParser ( Parser ):
2542
2295
  self.state = 319
2543
2296
  self._errHandler.sync(self)
2544
2297
  _la = self._input.LA(1)
2545
- while _la==44:
2298
+ while _la == 44:
2546
2299
  self.state = 315
2547
2300
  self.match(malParser.COMMA)
2548
2301
  self.state = 316
@@ -2559,11 +2312,10 @@ class malParser ( Parser ):
2559
2312
  self.exitRule()
2560
2313
  return localctx
2561
2314
 
2562
-
2563
2315
  class NumberContext(ParserRuleContext):
2564
2316
  __slots__ = 'parser'
2565
2317
 
2566
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2318
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2567
2319
  super().__init__(parent, invokingState)
2568
2320
  self.parser = parser
2569
2321
 
@@ -2576,33 +2328,29 @@ class malParser ( Parser ):
2576
2328
  def getRuleIndex(self):
2577
2329
  return malParser.RULE_number
2578
2330
 
2579
- def enterRule(self, listener:ParseTreeListener):
2580
- if hasattr( listener, "enterNumber" ):
2331
+ def enterRule(self, listener: ParseTreeListener):
2332
+ if hasattr(listener, "enterNumber"):
2581
2333
  listener.enterNumber(self)
2582
2334
 
2583
- def exitRule(self, listener:ParseTreeListener):
2584
- if hasattr( listener, "exitNumber" ):
2335
+ def exitRule(self, listener: ParseTreeListener):
2336
+ if hasattr(listener, "exitNumber"):
2585
2337
  listener.exitNumber(self)
2586
2338
 
2587
- def accept(self, visitor:ParseTreeVisitor):
2588
- if hasattr( visitor, "visitNumber" ):
2339
+ def accept(self, visitor: ParseTreeVisitor):
2340
+ if hasattr(visitor, "visitNumber"):
2589
2341
  return visitor.visitNumber(self)
2590
- else:
2591
- return visitor.visitChildren(self)
2592
-
2593
-
2594
-
2342
+ return visitor.visitChildren(self)
2595
2343
 
2596
2344
  def number(self):
2597
2345
 
2598
2346
  localctx = malParser.NumberContext(self, self._ctx, self.state)
2599
2347
  self.enterRule(localctx, 62, self.RULE_number)
2600
- self._la = 0 # Token type
2348
+ self._la = 0 # Token type
2601
2349
  try:
2602
2350
  self.enterOuterAlt(localctx, 1)
2603
2351
  self.state = 322
2604
2352
  _la = self._input.LA(1)
2605
- if not(_la==11 or _la==12):
2353
+ if not (_la == 11 or _la == 12):
2606
2354
  self._errHandler.recoverInline(self)
2607
2355
  else:
2608
2356
  self._errHandler.reportMatch(self)
@@ -2615,11 +2363,10 @@ class malParser ( Parser ):
2615
2363
  self.exitRule()
2616
2364
  return localctx
2617
2365
 
2618
-
2619
2366
  class VariableContext(ParserRuleContext):
2620
2367
  __slots__ = 'parser'
2621
2368
 
2622
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2369
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2623
2370
  super().__init__(parent, invokingState)
2624
2371
  self.parser = parser
2625
2372
 
@@ -2633,28 +2380,23 @@ class malParser ( Parser ):
2633
2380
  return self.getToken(malParser.ASSIGN, 0)
2634
2381
 
2635
2382
  def expr(self):
2636
- return self.getTypedRuleContext(malParser.ExprContext,0)
2637
-
2383
+ return self.getTypedRuleContext(malParser.ExprContext, 0)
2638
2384
 
2639
2385
  def getRuleIndex(self):
2640
2386
  return malParser.RULE_variable
2641
2387
 
2642
- def enterRule(self, listener:ParseTreeListener):
2643
- if hasattr( listener, "enterVariable" ):
2388
+ def enterRule(self, listener: ParseTreeListener):
2389
+ if hasattr(listener, "enterVariable"):
2644
2390
  listener.enterVariable(self)
2645
2391
 
2646
- def exitRule(self, listener:ParseTreeListener):
2647
- if hasattr( listener, "exitVariable" ):
2392
+ def exitRule(self, listener: ParseTreeListener):
2393
+ if hasattr(listener, "exitVariable"):
2648
2394
  listener.exitVariable(self)
2649
2395
 
2650
- def accept(self, visitor:ParseTreeVisitor):
2651
- if hasattr( visitor, "visitVariable" ):
2396
+ def accept(self, visitor: ParseTreeVisitor):
2397
+ if hasattr(visitor, "visitVariable"):
2652
2398
  return visitor.visitVariable(self)
2653
- else:
2654
- return visitor.visitChildren(self)
2655
-
2656
-
2657
-
2399
+ return visitor.visitChildren(self)
2658
2400
 
2659
2401
  def variable(self):
2660
2402
 
@@ -2678,53 +2420,44 @@ class malParser ( Parser ):
2678
2420
  self.exitRule()
2679
2421
  return localctx
2680
2422
 
2681
-
2682
2423
  class ExprContext(ParserRuleContext):
2683
2424
  __slots__ = 'parser'
2684
2425
 
2685
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2426
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2686
2427
  super().__init__(parent, invokingState)
2687
2428
  self.parser = parser
2688
2429
 
2689
- def parts(self, i:int=None):
2430
+ def parts(self, i: int = None):
2690
2431
  if i is None:
2691
2432
  return self.getTypedRuleContexts(malParser.PartsContext)
2692
- else:
2693
- return self.getTypedRuleContext(malParser.PartsContext,i)
2694
-
2433
+ return self.getTypedRuleContext(malParser.PartsContext, i)
2695
2434
 
2696
- def setop(self, i:int=None):
2435
+ def setop(self, i: int = None):
2697
2436
  if i is None:
2698
2437
  return self.getTypedRuleContexts(malParser.SetopContext)
2699
- else:
2700
- return self.getTypedRuleContext(malParser.SetopContext,i)
2701
-
2438
+ return self.getTypedRuleContext(malParser.SetopContext, i)
2702
2439
 
2703
2440
  def getRuleIndex(self):
2704
2441
  return malParser.RULE_expr
2705
2442
 
2706
- def enterRule(self, listener:ParseTreeListener):
2707
- if hasattr( listener, "enterExpr" ):
2443
+ def enterRule(self, listener: ParseTreeListener):
2444
+ if hasattr(listener, "enterExpr"):
2708
2445
  listener.enterExpr(self)
2709
2446
 
2710
- def exitRule(self, listener:ParseTreeListener):
2711
- if hasattr( listener, "exitExpr" ):
2447
+ def exitRule(self, listener: ParseTreeListener):
2448
+ if hasattr(listener, "exitExpr"):
2712
2449
  listener.exitExpr(self)
2713
2450
 
2714
- def accept(self, visitor:ParseTreeVisitor):
2715
- if hasattr( visitor, "visitExpr" ):
2451
+ def accept(self, visitor: ParseTreeVisitor):
2452
+ if hasattr(visitor, "visitExpr"):
2716
2453
  return visitor.visitExpr(self)
2717
- else:
2718
- return visitor.visitChildren(self)
2719
-
2720
-
2721
-
2454
+ return visitor.visitChildren(self)
2722
2455
 
2723
2456
  def expr(self):
2724
2457
 
2725
2458
  localctx = malParser.ExprContext(self, self._ctx, self.state)
2726
2459
  self.enterRule(localctx, 66, self.RULE_expr)
2727
- self._la = 0 # Token type
2460
+ self._la = 0 # Token type
2728
2461
  try:
2729
2462
  self.enterOuterAlt(localctx, 1)
2730
2463
  self.state = 329
@@ -2749,52 +2482,44 @@ class malParser ( Parser ):
2749
2482
  self.exitRule()
2750
2483
  return localctx
2751
2484
 
2752
-
2753
2485
  class PartsContext(ParserRuleContext):
2754
2486
  __slots__ = 'parser'
2755
2487
 
2756
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2488
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2757
2489
  super().__init__(parent, invokingState)
2758
2490
  self.parser = parser
2759
2491
 
2760
- def part(self, i:int=None):
2492
+ def part(self, i: int = None):
2761
2493
  if i is None:
2762
2494
  return self.getTypedRuleContexts(malParser.PartContext)
2763
- else:
2764
- return self.getTypedRuleContext(malParser.PartContext,i)
2495
+ return self.getTypedRuleContext(malParser.PartContext, i)
2765
2496
 
2766
-
2767
- def DOT(self, i:int=None):
2497
+ def DOT(self, i: int = None):
2768
2498
  if i is None:
2769
2499
  return self.getTokens(malParser.DOT)
2770
- else:
2771
- return self.getToken(malParser.DOT, i)
2500
+ return self.getToken(malParser.DOT, i)
2772
2501
 
2773
2502
  def getRuleIndex(self):
2774
2503
  return malParser.RULE_parts
2775
2504
 
2776
- def enterRule(self, listener:ParseTreeListener):
2777
- if hasattr( listener, "enterParts" ):
2505
+ def enterRule(self, listener: ParseTreeListener):
2506
+ if hasattr(listener, "enterParts"):
2778
2507
  listener.enterParts(self)
2779
2508
 
2780
- def exitRule(self, listener:ParseTreeListener):
2781
- if hasattr( listener, "exitParts" ):
2509
+ def exitRule(self, listener: ParseTreeListener):
2510
+ if hasattr(listener, "exitParts"):
2782
2511
  listener.exitParts(self)
2783
2512
 
2784
- def accept(self, visitor:ParseTreeVisitor):
2785
- if hasattr( visitor, "visitParts" ):
2513
+ def accept(self, visitor: ParseTreeVisitor):
2514
+ if hasattr(visitor, "visitParts"):
2786
2515
  return visitor.visitParts(self)
2787
- else:
2788
- return visitor.visitChildren(self)
2789
-
2790
-
2791
-
2516
+ return visitor.visitChildren(self)
2792
2517
 
2793
2518
  def parts(self):
2794
2519
 
2795
2520
  localctx = malParser.PartsContext(self, self._ctx, self.state)
2796
2521
  self.enterRule(localctx, 68, self.RULE_parts)
2797
- self._la = 0 # Token type
2522
+ self._la = 0 # Token type
2798
2523
  try:
2799
2524
  self.enterOuterAlt(localctx, 1)
2800
2525
  self.state = 338
@@ -2802,7 +2527,7 @@ class malParser ( Parser ):
2802
2527
  self.state = 343
2803
2528
  self._errHandler.sync(self)
2804
2529
  _la = self._input.LA(1)
2805
- while _la==35:
2530
+ while _la == 35:
2806
2531
  self.state = 339
2807
2532
  self.match(malParser.DOT)
2808
2533
  self.state = 340
@@ -2819,11 +2544,10 @@ class malParser ( Parser ):
2819
2544
  self.exitRule()
2820
2545
  return localctx
2821
2546
 
2822
-
2823
2547
  class PartContext(ParserRuleContext):
2824
2548
  __slots__ = 'parser'
2825
2549
 
2826
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2550
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2827
2551
  super().__init__(parent, invokingState)
2828
2552
  self.parser = parser
2829
2553
 
@@ -2831,15 +2555,13 @@ class malParser ( Parser ):
2831
2555
  return self.getToken(malParser.LPAREN, 0)
2832
2556
 
2833
2557
  def expr(self):
2834
- return self.getTypedRuleContext(malParser.ExprContext,0)
2835
-
2558
+ return self.getTypedRuleContext(malParser.ExprContext, 0)
2836
2559
 
2837
2560
  def RPAREN(self):
2838
2561
  return self.getToken(malParser.RPAREN, 0)
2839
2562
 
2840
2563
  def varsubst(self):
2841
- return self.getTypedRuleContext(malParser.VarsubstContext,0)
2842
-
2564
+ return self.getTypedRuleContext(malParser.VarsubstContext, 0)
2843
2565
 
2844
2566
  def ID(self):
2845
2567
  return self.getToken(malParser.ID, 0)
@@ -2847,43 +2569,37 @@ class malParser ( Parser ):
2847
2569
  def STAR(self):
2848
2570
  return self.getToken(malParser.STAR, 0)
2849
2571
 
2850
- def type_(self, i:int=None):
2572
+ def type_(self, i: int = None):
2851
2573
  if i is None:
2852
2574
  return self.getTypedRuleContexts(malParser.TypeContext)
2853
- else:
2854
- return self.getTypedRuleContext(malParser.TypeContext,i)
2855
-
2575
+ return self.getTypedRuleContext(malParser.TypeContext, i)
2856
2576
 
2857
2577
  def getRuleIndex(self):
2858
2578
  return malParser.RULE_part
2859
2579
 
2860
- def enterRule(self, listener:ParseTreeListener):
2861
- if hasattr( listener, "enterPart" ):
2580
+ def enterRule(self, listener: ParseTreeListener):
2581
+ if hasattr(listener, "enterPart"):
2862
2582
  listener.enterPart(self)
2863
2583
 
2864
- def exitRule(self, listener:ParseTreeListener):
2865
- if hasattr( listener, "exitPart" ):
2584
+ def exitRule(self, listener: ParseTreeListener):
2585
+ if hasattr(listener, "exitPart"):
2866
2586
  listener.exitPart(self)
2867
2587
 
2868
- def accept(self, visitor:ParseTreeVisitor):
2869
- if hasattr( visitor, "visitPart" ):
2588
+ def accept(self, visitor: ParseTreeVisitor):
2589
+ if hasattr(visitor, "visitPart"):
2870
2590
  return visitor.visitPart(self)
2871
- else:
2872
- return visitor.visitChildren(self)
2873
-
2874
-
2875
-
2591
+ return visitor.visitChildren(self)
2876
2592
 
2877
2593
  def part(self):
2878
2594
 
2879
2595
  localctx = malParser.PartContext(self, self._ctx, self.state)
2880
2596
  self.enterRule(localctx, 70, self.RULE_part)
2881
- self._la = 0 # Token type
2597
+ self._la = 0 # Token type
2882
2598
  try:
2883
2599
  self.enterOuterAlt(localctx, 1)
2884
2600
  self.state = 355
2885
2601
  self._errHandler.sync(self)
2886
- la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
2602
+ la_ = self._interp.adaptivePredict(self._input, 34, self._ctx)
2887
2603
  if la_ == 1:
2888
2604
  self.state = 346
2889
2605
  self.match(malParser.LPAREN)
@@ -2891,7 +2607,6 @@ class malParser ( Parser ):
2891
2607
  self.expr()
2892
2608
  self.state = 348
2893
2609
  self.match(malParser.RPAREN)
2894
- pass
2895
2610
 
2896
2611
  elif la_ == 2:
2897
2612
  self.state = 350
@@ -2900,26 +2615,22 @@ class malParser ( Parser ):
2900
2615
  self.match(malParser.LPAREN)
2901
2616
  self.state = 352
2902
2617
  self.match(malParser.RPAREN)
2903
- pass
2904
2618
 
2905
2619
  elif la_ == 3:
2906
2620
  self.state = 354
2907
2621
  self.match(malParser.ID)
2908
- pass
2909
-
2910
2622
 
2911
2623
  self.state = 358
2912
2624
  self._errHandler.sync(self)
2913
2625
  _la = self._input.LA(1)
2914
- if _la==28:
2626
+ if _la == 28:
2915
2627
  self.state = 357
2916
2628
  self.match(malParser.STAR)
2917
2629
 
2918
-
2919
2630
  self.state = 363
2920
2631
  self._errHandler.sync(self)
2921
2632
  _la = self._input.LA(1)
2922
- while _la==26:
2633
+ while _la == 26:
2923
2634
  self.state = 360
2924
2635
  self.type_()
2925
2636
  self.state = 365
@@ -2934,11 +2645,10 @@ class malParser ( Parser ):
2934
2645
  self.exitRule()
2935
2646
  return localctx
2936
2647
 
2937
-
2938
2648
  class VarsubstContext(ParserRuleContext):
2939
2649
  __slots__ = 'parser'
2940
2650
 
2941
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2651
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2942
2652
  super().__init__(parent, invokingState)
2943
2653
  self.parser = parser
2944
2654
 
@@ -2948,22 +2658,18 @@ class malParser ( Parser ):
2948
2658
  def getRuleIndex(self):
2949
2659
  return malParser.RULE_varsubst
2950
2660
 
2951
- def enterRule(self, listener:ParseTreeListener):
2952
- if hasattr( listener, "enterVarsubst" ):
2661
+ def enterRule(self, listener: ParseTreeListener):
2662
+ if hasattr(listener, "enterVarsubst"):
2953
2663
  listener.enterVarsubst(self)
2954
2664
 
2955
- def exitRule(self, listener:ParseTreeListener):
2956
- if hasattr( listener, "exitVarsubst" ):
2665
+ def exitRule(self, listener: ParseTreeListener):
2666
+ if hasattr(listener, "exitVarsubst"):
2957
2667
  listener.exitVarsubst(self)
2958
2668
 
2959
- def accept(self, visitor:ParseTreeVisitor):
2960
- if hasattr( visitor, "visitVarsubst" ):
2669
+ def accept(self, visitor: ParseTreeVisitor):
2670
+ if hasattr(visitor, "visitVarsubst"):
2961
2671
  return visitor.visitVarsubst(self)
2962
- else:
2963
- return visitor.visitChildren(self)
2964
-
2965
-
2966
-
2672
+ return visitor.visitChildren(self)
2967
2673
 
2968
2674
  def varsubst(self):
2969
2675
 
@@ -2981,11 +2687,10 @@ class malParser ( Parser ):
2981
2687
  self.exitRule()
2982
2688
  return localctx
2983
2689
 
2984
-
2985
2690
  class TypeContext(ParserRuleContext):
2986
2691
  __slots__ = 'parser'
2987
2692
 
2988
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2693
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2989
2694
  super().__init__(parent, invokingState)
2990
2695
  self.parser = parser
2991
2696
 
@@ -3001,22 +2706,18 @@ class malParser ( Parser ):
3001
2706
  def getRuleIndex(self):
3002
2707
  return malParser.RULE_type
3003
2708
 
3004
- def enterRule(self, listener:ParseTreeListener):
3005
- if hasattr( listener, "enterType" ):
2709
+ def enterRule(self, listener: ParseTreeListener):
2710
+ if hasattr(listener, "enterType"):
3006
2711
  listener.enterType(self)
3007
2712
 
3008
- def exitRule(self, listener:ParseTreeListener):
3009
- if hasattr( listener, "exitType" ):
2713
+ def exitRule(self, listener: ParseTreeListener):
2714
+ if hasattr(listener, "exitType"):
3010
2715
  listener.exitType(self)
3011
2716
 
3012
- def accept(self, visitor:ParseTreeVisitor):
3013
- if hasattr( visitor, "visitType" ):
2717
+ def accept(self, visitor: ParseTreeVisitor):
2718
+ if hasattr(visitor, "visitType"):
3014
2719
  return visitor.visitType(self)
3015
- else:
3016
- return visitor.visitChildren(self)
3017
-
3018
-
3019
-
2720
+ return visitor.visitChildren(self)
3020
2721
 
3021
2722
  def type_(self):
3022
2723
 
@@ -3038,11 +2739,10 @@ class malParser ( Parser ):
3038
2739
  self.exitRule()
3039
2740
  return localctx
3040
2741
 
3041
-
3042
2742
  class SetopContext(ParserRuleContext):
3043
2743
  __slots__ = 'parser'
3044
2744
 
3045
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2745
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3046
2746
  super().__init__(parent, invokingState)
3047
2747
  self.parser = parser
3048
2748
 
@@ -3058,33 +2758,29 @@ class malParser ( Parser ):
3058
2758
  def getRuleIndex(self):
3059
2759
  return malParser.RULE_setop
3060
2760
 
3061
- def enterRule(self, listener:ParseTreeListener):
3062
- if hasattr( listener, "enterSetop" ):
2761
+ def enterRule(self, listener: ParseTreeListener):
2762
+ if hasattr(listener, "enterSetop"):
3063
2763
  listener.enterSetop(self)
3064
2764
 
3065
- def exitRule(self, listener:ParseTreeListener):
3066
- if hasattr( listener, "exitSetop" ):
2765
+ def exitRule(self, listener: ParseTreeListener):
2766
+ if hasattr(listener, "exitSetop"):
3067
2767
  listener.exitSetop(self)
3068
2768
 
3069
- def accept(self, visitor:ParseTreeVisitor):
3070
- if hasattr( visitor, "visitSetop" ):
2769
+ def accept(self, visitor: ParseTreeVisitor):
2770
+ if hasattr(visitor, "visitSetop"):
3071
2771
  return visitor.visitSetop(self)
3072
- else:
3073
- return visitor.visitChildren(self)
3074
-
3075
-
3076
-
2772
+ return visitor.visitChildren(self)
3077
2773
 
3078
2774
  def setop(self):
3079
2775
 
3080
2776
  localctx = malParser.SetopContext(self, self._ctx, self.state)
3081
2777
  self.enterRule(localctx, 76, self.RULE_setop)
3082
- self._la = 0 # Token type
2778
+ self._la = 0 # Token type
3083
2779
  try:
3084
2780
  self.enterOuterAlt(localctx, 1)
3085
2781
  self.state = 372
3086
2782
  _la = self._input.LA(1)
3087
- if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 15032385536) != 0)):
2783
+ if not (((_la) & ~0x3f) == 0 and ((1 << _la) & 15032385536) != 0):
3088
2784
  self._errHandler.recoverInline(self)
3089
2785
  else:
3090
2786
  self._errHandler.reportMatch(self)
@@ -3097,11 +2793,10 @@ class malParser ( Parser ):
3097
2793
  self.exitRule()
3098
2794
  return localctx
3099
2795
 
3100
-
3101
2796
  class AssociationsContext(ParserRuleContext):
3102
2797
  __slots__ = 'parser'
3103
2798
 
3104
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2799
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3105
2800
  super().__init__(parent, invokingState)
3106
2801
  self.parser = parser
3107
2802
 
@@ -3114,38 +2809,32 @@ class malParser ( Parser ):
3114
2809
  def RCURLY(self):
3115
2810
  return self.getToken(malParser.RCURLY, 0)
3116
2811
 
3117
- def association(self, i:int=None):
2812
+ def association(self, i: int = None):
3118
2813
  if i is None:
3119
2814
  return self.getTypedRuleContexts(malParser.AssociationContext)
3120
- else:
3121
- return self.getTypedRuleContext(malParser.AssociationContext,i)
3122
-
2815
+ return self.getTypedRuleContext(malParser.AssociationContext, i)
3123
2816
 
3124
2817
  def getRuleIndex(self):
3125
2818
  return malParser.RULE_associations
3126
2819
 
3127
- def enterRule(self, listener:ParseTreeListener):
3128
- if hasattr( listener, "enterAssociations" ):
2820
+ def enterRule(self, listener: ParseTreeListener):
2821
+ if hasattr(listener, "enterAssociations"):
3129
2822
  listener.enterAssociations(self)
3130
2823
 
3131
- def exitRule(self, listener:ParseTreeListener):
3132
- if hasattr( listener, "exitAssociations" ):
2824
+ def exitRule(self, listener: ParseTreeListener):
2825
+ if hasattr(listener, "exitAssociations"):
3133
2826
  listener.exitAssociations(self)
3134
2827
 
3135
- def accept(self, visitor:ParseTreeVisitor):
3136
- if hasattr( visitor, "visitAssociations" ):
2828
+ def accept(self, visitor: ParseTreeVisitor):
2829
+ if hasattr(visitor, "visitAssociations"):
3137
2830
  return visitor.visitAssociations(self)
3138
- else:
3139
- return visitor.visitChildren(self)
3140
-
3141
-
3142
-
2831
+ return visitor.visitChildren(self)
3143
2832
 
3144
2833
  def associations(self):
3145
2834
 
3146
2835
  localctx = malParser.AssociationsContext(self, self._ctx, self.state)
3147
2836
  self.enterRule(localctx, 78, self.RULE_associations)
3148
- self._la = 0 # Token type
2837
+ self._la = 0 # Token type
3149
2838
  try:
3150
2839
  self.enterOuterAlt(localctx, 1)
3151
2840
  self.state = 374
@@ -3155,7 +2844,7 @@ class malParser ( Parser ):
3155
2844
  self.state = 379
3156
2845
  self._errHandler.sync(self)
3157
2846
  _la = self._input.LA(1)
3158
- while _la==17:
2847
+ while _la == 17:
3159
2848
  self.state = 376
3160
2849
  self.association()
3161
2850
  self.state = 381
@@ -3172,70 +2861,57 @@ class malParser ( Parser ):
3172
2861
  self.exitRule()
3173
2862
  return localctx
3174
2863
 
3175
-
3176
2864
  class AssociationContext(ParserRuleContext):
3177
2865
  __slots__ = 'parser'
3178
2866
 
3179
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2867
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3180
2868
  super().__init__(parent, invokingState)
3181
2869
  self.parser = parser
3182
2870
 
3183
- def ID(self, i:int=None):
2871
+ def ID(self, i: int = None):
3184
2872
  if i is None:
3185
2873
  return self.getTokens(malParser.ID)
3186
- else:
3187
- return self.getToken(malParser.ID, i)
2874
+ return self.getToken(malParser.ID, i)
3188
2875
 
3189
- def field(self, i:int=None):
2876
+ def field(self, i: int = None):
3190
2877
  if i is None:
3191
2878
  return self.getTypedRuleContexts(malParser.FieldContext)
3192
- else:
3193
- return self.getTypedRuleContext(malParser.FieldContext,i)
3194
-
2879
+ return self.getTypedRuleContext(malParser.FieldContext, i)
3195
2880
 
3196
- def mult(self, i:int=None):
2881
+ def mult(self, i: int = None):
3197
2882
  if i is None:
3198
2883
  return self.getTypedRuleContexts(malParser.MultContext)
3199
- else:
3200
- return self.getTypedRuleContext(malParser.MultContext,i)
3201
-
2884
+ return self.getTypedRuleContext(malParser.MultContext, i)
3202
2885
 
3203
2886
  def LARROW(self):
3204
2887
  return self.getToken(malParser.LARROW, 0)
3205
2888
 
3206
2889
  def linkname(self):
3207
- return self.getTypedRuleContext(malParser.LinknameContext,0)
3208
-
2890
+ return self.getTypedRuleContext(malParser.LinknameContext, 0)
3209
2891
 
3210
2892
  def RARROW(self):
3211
2893
  return self.getToken(malParser.RARROW, 0)
3212
2894
 
3213
- def meta(self, i:int=None):
2895
+ def meta(self, i: int = None):
3214
2896
  if i is None:
3215
2897
  return self.getTypedRuleContexts(malParser.MetaContext)
3216
- else:
3217
- return self.getTypedRuleContext(malParser.MetaContext,i)
3218
-
2898
+ return self.getTypedRuleContext(malParser.MetaContext, i)
3219
2899
 
3220
2900
  def getRuleIndex(self):
3221
2901
  return malParser.RULE_association
3222
2902
 
3223
- def enterRule(self, listener:ParseTreeListener):
3224
- if hasattr( listener, "enterAssociation" ):
2903
+ def enterRule(self, listener: ParseTreeListener):
2904
+ if hasattr(listener, "enterAssociation"):
3225
2905
  listener.enterAssociation(self)
3226
2906
 
3227
- def exitRule(self, listener:ParseTreeListener):
3228
- if hasattr( listener, "exitAssociation" ):
2907
+ def exitRule(self, listener: ParseTreeListener):
2908
+ if hasattr(listener, "exitAssociation"):
3229
2909
  listener.exitAssociation(self)
3230
2910
 
3231
- def accept(self, visitor:ParseTreeVisitor):
3232
- if hasattr( visitor, "visitAssociation" ):
2911
+ def accept(self, visitor: ParseTreeVisitor):
2912
+ if hasattr(visitor, "visitAssociation"):
3233
2913
  return visitor.visitAssociation(self)
3234
- else:
3235
- return visitor.visitChildren(self)
3236
-
3237
-
3238
-
2914
+ return visitor.visitChildren(self)
3239
2915
 
3240
2916
  def association(self):
3241
2917
 
@@ -3263,14 +2939,14 @@ class malParser ( Parser ):
3263
2939
  self.match(malParser.ID)
3264
2940
  self.state = 396
3265
2941
  self._errHandler.sync(self)
3266
- _alt = self._interp.adaptivePredict(self._input,38,self._ctx)
3267
- while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
3268
- if _alt==1:
2942
+ _alt = self._interp.adaptivePredict(self._input, 38, self._ctx)
2943
+ while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
2944
+ if _alt == 1:
3269
2945
  self.state = 393
3270
- self.meta()
2946
+ self.meta()
3271
2947
  self.state = 398
3272
2948
  self._errHandler.sync(self)
3273
- _alt = self._interp.adaptivePredict(self._input,38,self._ctx)
2949
+ _alt = self._interp.adaptivePredict(self._input, 38, self._ctx)
3274
2950
 
3275
2951
  except RecognitionException as re:
3276
2952
  localctx.exception = re
@@ -3280,11 +2956,10 @@ class malParser ( Parser ):
3280
2956
  self.exitRule()
3281
2957
  return localctx
3282
2958
 
3283
-
3284
2959
  class FieldContext(ParserRuleContext):
3285
2960
  __slots__ = 'parser'
3286
2961
 
3287
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2962
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3288
2963
  super().__init__(parent, invokingState)
3289
2964
  self.parser = parser
3290
2965
 
@@ -3300,22 +2975,18 @@ class malParser ( Parser ):
3300
2975
  def getRuleIndex(self):
3301
2976
  return malParser.RULE_field
3302
2977
 
3303
- def enterRule(self, listener:ParseTreeListener):
3304
- if hasattr( listener, "enterField" ):
2978
+ def enterRule(self, listener: ParseTreeListener):
2979
+ if hasattr(listener, "enterField"):
3305
2980
  listener.enterField(self)
3306
2981
 
3307
- def exitRule(self, listener:ParseTreeListener):
3308
- if hasattr( listener, "exitField" ):
2982
+ def exitRule(self, listener: ParseTreeListener):
2983
+ if hasattr(listener, "exitField"):
3309
2984
  listener.exitField(self)
3310
2985
 
3311
- def accept(self, visitor:ParseTreeVisitor):
3312
- if hasattr( visitor, "visitField" ):
2986
+ def accept(self, visitor: ParseTreeVisitor):
2987
+ if hasattr(visitor, "visitField"):
3313
2988
  return visitor.visitField(self)
3314
- else:
3315
- return visitor.visitChildren(self)
3316
-
3317
-
3318
-
2989
+ return visitor.visitChildren(self)
3319
2990
 
3320
2991
  def field(self):
3321
2992
 
@@ -3337,20 +3008,17 @@ class malParser ( Parser ):
3337
3008
  self.exitRule()
3338
3009
  return localctx
3339
3010
 
3340
-
3341
3011
  class MultContext(ParserRuleContext):
3342
3012
  __slots__ = 'parser'
3343
3013
 
3344
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3014
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3345
3015
  super().__init__(parent, invokingState)
3346
3016
  self.parser = parser
3347
3017
 
3348
- def multatom(self, i:int=None):
3018
+ def multatom(self, i: int = None):
3349
3019
  if i is None:
3350
3020
  return self.getTypedRuleContexts(malParser.MultatomContext)
3351
- else:
3352
- return self.getTypedRuleContext(malParser.MultatomContext,i)
3353
-
3021
+ return self.getTypedRuleContext(malParser.MultatomContext, i)
3354
3022
 
3355
3023
  def RANGE(self):
3356
3024
  return self.getToken(malParser.RANGE, 0)
@@ -3358,28 +3026,24 @@ class malParser ( Parser ):
3358
3026
  def getRuleIndex(self):
3359
3027
  return malParser.RULE_mult
3360
3028
 
3361
- def enterRule(self, listener:ParseTreeListener):
3362
- if hasattr( listener, "enterMult" ):
3029
+ def enterRule(self, listener: ParseTreeListener):
3030
+ if hasattr(listener, "enterMult"):
3363
3031
  listener.enterMult(self)
3364
3032
 
3365
- def exitRule(self, listener:ParseTreeListener):
3366
- if hasattr( listener, "exitMult" ):
3033
+ def exitRule(self, listener: ParseTreeListener):
3034
+ if hasattr(listener, "exitMult"):
3367
3035
  listener.exitMult(self)
3368
3036
 
3369
- def accept(self, visitor:ParseTreeVisitor):
3370
- if hasattr( visitor, "visitMult" ):
3037
+ def accept(self, visitor: ParseTreeVisitor):
3038
+ if hasattr(visitor, "visitMult"):
3371
3039
  return visitor.visitMult(self)
3372
- else:
3373
- return visitor.visitChildren(self)
3374
-
3375
-
3376
-
3040
+ return visitor.visitChildren(self)
3377
3041
 
3378
3042
  def mult(self):
3379
3043
 
3380
3044
  localctx = malParser.MultContext(self, self._ctx, self.state)
3381
3045
  self.enterRule(localctx, 84, self.RULE_mult)
3382
- self._la = 0 # Token type
3046
+ self._la = 0 # Token type
3383
3047
  try:
3384
3048
  self.enterOuterAlt(localctx, 1)
3385
3049
  self.state = 403
@@ -3387,13 +3051,12 @@ class malParser ( Parser ):
3387
3051
  self.state = 406
3388
3052
  self._errHandler.sync(self)
3389
3053
  _la = self._input.LA(1)
3390
- if _la==34:
3054
+ if _la == 34:
3391
3055
  self.state = 404
3392
3056
  self.match(malParser.RANGE)
3393
3057
  self.state = 405
3394
3058
  self.multatom()
3395
3059
 
3396
-
3397
3060
  except RecognitionException as re:
3398
3061
  localctx.exception = re
3399
3062
  self._errHandler.reportError(self, re)
@@ -3402,11 +3065,10 @@ class malParser ( Parser ):
3402
3065
  self.exitRule()
3403
3066
  return localctx
3404
3067
 
3405
-
3406
3068
  class MultatomContext(ParserRuleContext):
3407
3069
  __slots__ = 'parser'
3408
3070
 
3409
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3071
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3410
3072
  super().__init__(parent, invokingState)
3411
3073
  self.parser = parser
3412
3074
 
@@ -3419,33 +3081,29 @@ class malParser ( Parser ):
3419
3081
  def getRuleIndex(self):
3420
3082
  return malParser.RULE_multatom
3421
3083
 
3422
- def enterRule(self, listener:ParseTreeListener):
3423
- if hasattr( listener, "enterMultatom" ):
3084
+ def enterRule(self, listener: ParseTreeListener):
3085
+ if hasattr(listener, "enterMultatom"):
3424
3086
  listener.enterMultatom(self)
3425
3087
 
3426
- def exitRule(self, listener:ParseTreeListener):
3427
- if hasattr( listener, "exitMultatom" ):
3088
+ def exitRule(self, listener: ParseTreeListener):
3089
+ if hasattr(listener, "exitMultatom"):
3428
3090
  listener.exitMultatom(self)
3429
3091
 
3430
- def accept(self, visitor:ParseTreeVisitor):
3431
- if hasattr( visitor, "visitMultatom" ):
3092
+ def accept(self, visitor: ParseTreeVisitor):
3093
+ if hasattr(visitor, "visitMultatom"):
3432
3094
  return visitor.visitMultatom(self)
3433
- else:
3434
- return visitor.visitChildren(self)
3435
-
3436
-
3437
-
3095
+ return visitor.visitChildren(self)
3438
3096
 
3439
3097
  def multatom(self):
3440
3098
 
3441
3099
  localctx = malParser.MultatomContext(self, self._ctx, self.state)
3442
3100
  self.enterRule(localctx, 86, self.RULE_multatom)
3443
- self._la = 0 # Token type
3101
+ self._la = 0 # Token type
3444
3102
  try:
3445
3103
  self.enterOuterAlt(localctx, 1)
3446
3104
  self.state = 408
3447
3105
  _la = self._input.LA(1)
3448
- if not(_la==11 or _la==28):
3106
+ if not (_la == 11 or _la == 28):
3449
3107
  self._errHandler.recoverInline(self)
3450
3108
  else:
3451
3109
  self._errHandler.reportMatch(self)
@@ -3458,11 +3116,10 @@ class malParser ( Parser ):
3458
3116
  self.exitRule()
3459
3117
  return localctx
3460
3118
 
3461
-
3462
3119
  class LinknameContext(ParserRuleContext):
3463
3120
  __slots__ = 'parser'
3464
3121
 
3465
- def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3122
+ def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3466
3123
  super().__init__(parent, invokingState)
3467
3124
  self.parser = parser
3468
3125
 
@@ -3472,22 +3129,18 @@ class malParser ( Parser ):
3472
3129
  def getRuleIndex(self):
3473
3130
  return malParser.RULE_linkname
3474
3131
 
3475
- def enterRule(self, listener:ParseTreeListener):
3476
- if hasattr( listener, "enterLinkname" ):
3132
+ def enterRule(self, listener: ParseTreeListener):
3133
+ if hasattr(listener, "enterLinkname"):
3477
3134
  listener.enterLinkname(self)
3478
3135
 
3479
- def exitRule(self, listener:ParseTreeListener):
3480
- if hasattr( listener, "exitLinkname" ):
3136
+ def exitRule(self, listener: ParseTreeListener):
3137
+ if hasattr(listener, "exitLinkname"):
3481
3138
  listener.exitLinkname(self)
3482
3139
 
3483
- def accept(self, visitor:ParseTreeVisitor):
3484
- if hasattr( visitor, "visitLinkname" ):
3140
+ def accept(self, visitor: ParseTreeVisitor):
3141
+ if hasattr(visitor, "visitLinkname"):
3485
3142
  return visitor.visitLinkname(self)
3486
- else:
3487
- return visitor.visitChildren(self)
3488
-
3489
-
3490
-
3143
+ return visitor.visitChildren(self)
3491
3144
 
3492
3145
  def linkname(self):
3493
3146
 
@@ -3504,8 +3157,3 @@ class malParser ( Parser ):
3504
3157
  finally:
3505
3158
  self.exitRule()
3506
3159
  return localctx
3507
-
3508
-
3509
-
3510
-
3511
-