Coverage for src/pyensae/languages/RParser.py: 0%

2993 statements  

« prev     ^ index     » next       coverage.py v7.2.7, created at 2023-07-03 02:16 +0200

1# Generated from \R.g4 by ANTLR 4.10.1 

2# encoding: utf-8 

3from antlr4 import * 

4from io import StringIO 

5import sys 

6if sys.version_info[1] > 5: 

7 from typing import TextIO 

8else: 

9 from typing.io import TextIO 

10 

11 

12def serializedATN(): 

13 return [ 

14 4, 1, 70, 746, 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, 2, 45, 7, 45, 2, 46, 

21 7, 46, 2, 47, 7, 47, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 101, 8, 0, 10, 0, 12, 0, 104, 9, 0, 1, 0, 

22 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 120, 8, 1, 

23 10, 1, 12, 1, 123, 9, 1, 1, 1, 1, 1, 5, 1, 127, 8, 1, 10, 1, 12, 1, 130, 9, 1, 1, 1, 1, 1, 

24 5, 1, 134, 8, 1, 10, 1, 12, 1, 137, 9, 1, 1, 1, 1, 1, 5, 1, 141, 8, 1, 10, 1, 12, 1, 144, 

25 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 159, 

26 8, 1, 10, 1, 12, 1, 162, 9, 1, 1, 1, 1, 1, 5, 1, 166, 8, 1, 10, 1, 12, 1, 169, 9, 1, 1, 1, 

27 1, 1, 1, 1, 1, 1, 3, 1, 175, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 183, 8, 1, 10, 1, 

28 12, 1, 186, 9, 1, 1, 1, 1, 1, 5, 1, 190, 8, 1, 10, 1, 12, 1, 193, 9, 1, 1, 1, 1, 1, 1, 1, 5, 

29 1, 198, 8, 1, 10, 1, 12, 1, 201, 9, 1, 1, 1, 1, 1, 5, 1, 205, 8, 1, 10, 1, 12, 1, 208, 9, 

30 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 214, 8, 1, 10, 1, 12, 1, 217, 9, 1, 1, 1, 1, 1, 5, 1, 221, 

31 8, 1, 10, 1, 12, 1, 224, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 230, 8, 1, 10, 1, 12, 1, 233, 

32 9, 1, 1, 1, 1, 1, 5, 1, 237, 8, 1, 10, 1, 12, 1, 240, 9, 1, 1, 1, 1, 1, 1, 1, 5, 1, 245, 8, 

33 1, 10, 1, 12, 1, 248, 9, 1, 1, 1, 1, 1, 5, 1, 252, 8, 1, 10, 1, 12, 1, 255, 9, 1, 1, 1, 1, 

34 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 273, 

35 8, 1, 10, 1, 12, 1, 276, 9, 1, 1, 2, 1, 2, 5, 2, 280, 8, 2, 10, 2, 12, 2, 283, 9, 2, 1, 2, 

36 1, 2, 5, 2, 287, 8, 2, 10, 2, 12, 2, 290, 9, 2, 1, 2, 1, 2, 5, 2, 294, 8, 2, 10, 2, 12, 2, 

37 297, 9, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 5, 4, 307, 8, 4, 10, 4, 12, 4, 310, 

38 9, 4, 1, 4, 3, 4, 313, 8, 4, 1, 4, 5, 4, 316, 8, 4, 10, 4, 12, 4, 319, 9, 4, 1, 4, 1, 4, 1, 

39 5, 1, 5, 1, 5, 5, 5, 326, 8, 5, 10, 5, 12, 5, 329, 9, 5, 1, 5, 3, 5, 332, 8, 5, 1, 5, 5, 5, 

40 335, 8, 5, 10, 5, 12, 5, 338, 9, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 3, 

41 7, 349, 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 5, 9, 358, 8, 9, 10, 9, 12, 9, 361, 

42 9, 9, 1, 10, 1, 10, 3, 10, 365, 8, 10, 1, 11, 1, 11, 3, 11, 369, 8, 11, 1, 11, 1, 11, 5, 

43 11, 373, 8, 11, 10, 11, 12, 11, 376, 9, 11, 1, 11, 5, 11, 379, 8, 11, 10, 11, 12, 11, 

44 382, 9, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 390, 8, 12, 1, 13, 1, 13, 1, 

45 14, 1, 14, 5, 14, 396, 8, 14, 10, 14, 12, 14, 399, 9, 14, 1, 14, 1, 14, 5, 14, 403, 8, 

46 14, 10, 14, 12, 14, 406, 9, 14, 1, 14, 1, 14, 3, 14, 410, 8, 14, 1, 14, 5, 14, 413, 8, 

47 14, 10, 14, 12, 14, 416, 9, 14, 5, 14, 418, 8, 14, 10, 14, 12, 14, 421, 9, 14, 1, 15, 

48 1, 15, 3, 15, 425, 8, 15, 1, 15, 1, 15, 3, 15, 429, 8, 15, 1, 15, 1, 15, 3, 15, 433, 8, 

49 15, 5, 15, 435, 8, 15, 10, 15, 12, 15, 438, 9, 15, 1, 16, 1, 16, 3, 16, 442, 8, 16, 1, 

50 17, 1, 17, 1, 17, 1, 17, 3, 17, 448, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 

51 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 462, 8, 17, 1, 18, 1, 18, 3, 18, 466, 8, 18, 

52 1, 19, 1, 19, 3, 19, 470, 8, 19, 1, 19, 1, 19, 1, 19, 3, 19, 475, 8, 19, 1, 20, 1, 20, 1, 

53 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 3, 21, 485, 8, 21, 1, 22, 1, 22, 3, 22, 489, 8, 22, 

54 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 

55 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 510, 8, 24, 1, 25, 1, 25, 1, 26, 1, 26, 

56 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 

57 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 538, 8, 30, 10, 30, 

58 12, 30, 541, 9, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 549, 8, 30, 10, 30, 

59 12, 30, 552, 9, 30, 1, 30, 1, 30, 5, 30, 556, 8, 30, 10, 30, 12, 30, 559, 9, 30, 5, 30, 

60 561, 8, 30, 10, 30, 12, 30, 564, 9, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 5, 31, 571, 

61 8, 31, 10, 31, 12, 31, 574, 9, 31, 1, 31, 1, 31, 5, 31, 578, 8, 31, 10, 31, 12, 31, 581, 

62 9, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 5, 31, 588, 8, 31, 10, 31, 12, 31, 591, 9, 31, 

63 1, 31, 1, 31, 5, 31, 595, 8, 31, 10, 31, 12, 31, 598, 9, 31, 5, 31, 600, 8, 31, 10, 31, 

64 12, 31, 603, 9, 31, 1, 31, 1, 31, 5, 31, 607, 8, 31, 10, 31, 12, 31, 610, 9, 31, 1, 31, 

65 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 

66 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 5, 34, 631, 8, 34, 10, 34, 12, 34, 634, 9, 34, 1, 34, 

67 1, 34, 5, 34, 638, 8, 34, 10, 34, 12, 34, 641, 9, 34, 1, 34, 1, 34, 3, 34, 645, 8, 34, 

68 1, 35, 5, 35, 648, 8, 35, 10, 35, 12, 35, 651, 9, 35, 1, 35, 1, 35, 5, 35, 655, 8, 35, 

69 10, 35, 12, 35, 658, 9, 35, 1, 35, 1, 35, 5, 35, 662, 8, 35, 10, 35, 12, 35, 665, 9, 35, 

70 1, 35, 1, 35, 5, 35, 669, 8, 35, 10, 35, 12, 35, 672, 9, 35, 1, 36, 1, 36, 1, 36, 3, 36, 

71 677, 8, 36, 1, 37, 3, 37, 680, 8, 37, 1, 37, 1, 37, 1, 37, 3, 37, 685, 8, 37, 1, 38, 1, 

72 38, 1, 38, 1, 38, 1, 38, 1, 38, 5, 38, 693, 8, 38, 10, 38, 12, 38, 696, 9, 38, 1, 38, 1, 

73 38, 1, 38, 5, 38, 701, 8, 38, 10, 38, 12, 38, 704, 9, 38, 1, 38, 5, 38, 707, 8, 38, 10, 

74 38, 12, 38, 710, 9, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 718, 8, 38, 1, 

75 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 728, 8, 39, 1, 40, 1, 40, 1, 

76 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 

77 47, 1, 47, 0, 1, 2, 48, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 

78 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 

79 80, 82, 84, 86, 88, 90, 92, 94, 0, 10, 2, 0, 1, 1, 69, 69, 1, 0, 5, 6, 1, 0, 8, 9, 1, 0, 10, 

80 11, 1, 0, 28, 29, 2, 0, 20, 20, 39, 43, 2, 0, 23, 23, 46, 47, 1, 0, 48, 49, 3, 0, 5, 6, 24, 

81 24, 50, 54, 1, 0, 55, 60, 821, 0, 102, 1, 0, 0, 0, 2, 174, 1, 0, 0, 0, 4, 277, 1, 0, 0, 0, 

82 6, 300, 1, 0, 0, 0, 8, 303, 1, 0, 0, 0, 10, 322, 1, 0, 0, 0, 12, 341, 1, 0, 0, 0, 14, 346, 

83 1, 0, 0, 0, 16, 352, 1, 0, 0, 0, 18, 355, 1, 0, 0, 0, 20, 362, 1, 0, 0, 0, 22, 366, 1, 0, 

84 0, 0, 24, 389, 1, 0, 0, 0, 26, 391, 1, 0, 0, 0, 28, 393, 1, 0, 0, 0, 30, 422, 1, 0, 0, 0, 

85 32, 441, 1, 0, 0, 0, 34, 461, 1, 0, 0, 0, 36, 465, 1, 0, 0, 0, 38, 469, 1, 0, 0, 0, 40, 476, 

86 1, 0, 0, 0, 42, 484, 1, 0, 0, 0, 44, 488, 1, 0, 0, 0, 46, 493, 1, 0, 0, 0, 48, 509, 1, 0, 

87 0, 0, 50, 511, 1, 0, 0, 0, 52, 513, 1, 0, 0, 0, 54, 515, 1, 0, 0, 0, 56, 518, 1, 0, 0, 0, 

88 58, 524, 1, 0, 0, 0, 60, 532, 1, 0, 0, 0, 62, 565, 1, 0, 0, 0, 64, 613, 1, 0, 0, 0, 66, 616, 

89 1, 0, 0, 0, 68, 621, 1, 0, 0, 0, 70, 649, 1, 0, 0, 0, 72, 676, 1, 0, 0, 0, 74, 679, 1, 0, 

90 0, 0, 76, 686, 1, 0, 0, 0, 78, 721, 1, 0, 0, 0, 80, 729, 1, 0, 0, 0, 82, 731, 1, 0, 0, 0, 

91 84, 733, 1, 0, 0, 0, 86, 735, 1, 0, 0, 0, 88, 737, 1, 0, 0, 0, 90, 739, 1, 0, 0, 0, 92, 741, 

92 1, 0, 0, 0, 94, 743, 1, 0, 0, 0, 96, 97, 3, 2, 1, 0, 97, 98, 7, 0, 0, 0, 98, 101, 1, 0, 0, 

93 0, 99, 101, 5, 69, 0, 0, 100, 96, 1, 0, 0, 0, 100, 99, 1, 0, 0, 0, 101, 104, 1, 0, 0, 0, 

94 102, 100, 1, 0, 0, 0, 102, 103, 1, 0, 0, 0, 103, 105, 1, 0, 0, 0, 104, 102, 1, 0, 0, 0, 

95 105, 106, 5, 0, 0, 1, 106, 1, 1, 0, 0, 0, 107, 108, 6, 1, - 

96 1, 0, 108, 175, 3, 36, 18, 0, 

97 109, 175, 3, 42, 21, 0, 110, 111, 7, 1, 0, 0, 111, 175, 3, 2, 1, 27, 112, 113, 5, 7, 0, 

98 0, 113, 175, 3, 2, 1, 21, 114, 175, 3, 72, 36, 0, 115, 175, 3, 4, 2, 0, 116, 175, 3, 6, 

99 3, 0, 117, 175, 3, 68, 34, 0, 118, 120, 5, 69, 0, 0, 119, 118, 1, 0, 0, 0, 120, 123, 1, 

100 0, 0, 0, 121, 119, 1, 0, 0, 0, 121, 122, 1, 0, 0, 0, 122, 124, 1, 0, 0, 0, 123, 121, 1, 

101 0, 0, 0, 124, 128, 5, 12, 0, 0, 125, 127, 5, 69, 0, 0, 126, 125, 1, 0, 0, 0, 127, 130, 

102 1, 0, 0, 0, 128, 126, 1, 0, 0, 0, 128, 129, 1, 0, 0, 0, 129, 131, 1, 0, 0, 0, 130, 128, 

103 1, 0, 0, 0, 131, 135, 3, 18, 9, 0, 132, 134, 5, 69, 0, 0, 133, 132, 1, 0, 0, 0, 134, 137, 

104 1, 0, 0, 0, 135, 133, 1, 0, 0, 0, 135, 136, 1, 0, 0, 0, 136, 138, 1, 0, 0, 0, 137, 135, 

105 1, 0, 0, 0, 138, 142, 5, 13, 0, 0, 139, 141, 5, 69, 0, 0, 140, 139, 1, 0, 0, 0, 141, 144, 

106 1, 0, 0, 0, 142, 140, 1, 0, 0, 0, 142, 143, 1, 0, 0, 0, 143, 175, 1, 0, 0, 0, 144, 142, 

107 1, 0, 0, 0, 145, 175, 3, 66, 33, 0, 146, 175, 3, 62, 31, 0, 147, 175, 3, 60, 30, 0, 148, 

108 175, 3, 58, 29, 0, 149, 175, 3, 56, 28, 0, 150, 175, 3, 54, 27, 0, 151, 152, 5, 14, 0, 

109 0, 152, 175, 3, 2, 1, 7, 153, 175, 3, 12, 6, 0, 154, 175, 3, 52, 26, 0, 155, 175, 5, 15, 

110 0, 0, 156, 160, 5, 16, 0, 0, 157, 159, 5, 69, 0, 0, 158, 157, 1, 0, 0, 0, 159, 162, 1, 

111 0, 0, 0, 160, 158, 1, 0, 0, 0, 160, 161, 1, 0, 0, 0, 161, 163, 1, 0, 0, 0, 162, 160, 1, 

112 0, 0, 0, 163, 167, 3, 2, 1, 0, 164, 166, 5, 69, 0, 0, 165, 164, 1, 0, 0, 0, 166, 169, 1, 

113 0, 0, 0, 167, 165, 1, 0, 0, 0, 167, 168, 1, 0, 0, 0, 168, 170, 1, 0, 0, 0, 169, 167, 1, 

114 0, 0, 0, 170, 171, 5, 17, 0, 0, 171, 175, 1, 0, 0, 0, 172, 175, 3, 48, 24, 0, 173, 175, 

115 3, 84, 42, 0, 174, 107, 1, 0, 0, 0, 174, 109, 1, 0, 0, 0, 174, 110, 1, 0, 0, 0, 174, 112, 

116 1, 0, 0, 0, 174, 114, 1, 0, 0, 0, 174, 115, 1, 0, 0, 0, 174, 116, 1, 0, 0, 0, 174, 117, 

117 1, 0, 0, 0, 174, 121, 1, 0, 0, 0, 174, 145, 1, 0, 0, 0, 174, 146, 1, 0, 0, 0, 174, 147, 

118 1, 0, 0, 0, 174, 148, 1, 0, 0, 0, 174, 149, 1, 0, 0, 0, 174, 150, 1, 0, 0, 0, 174, 151, 

119 1, 0, 0, 0, 174, 153, 1, 0, 0, 0, 174, 154, 1, 0, 0, 0, 174, 155, 1, 0, 0, 0, 174, 156, 

120 1, 0, 0, 0, 174, 172, 1, 0, 0, 0, 174, 173, 1, 0, 0, 0, 175, 274, 1, 0, 0, 0, 176, 177, 

121 10, 28, 0, 0, 177, 178, 3, 90, 45, 0, 178, 179, 3, 2, 1, 29, 179, 273, 1, 0, 0, 0, 180, 

122 184, 10, 24, 0, 0, 181, 183, 5, 69, 0, 0, 182, 181, 1, 0, 0, 0, 183, 186, 1, 0, 0, 0, 184, 

123 182, 1, 0, 0, 0, 184, 185, 1, 0, 0, 0, 185, 187, 1, 0, 0, 0, 186, 184, 1, 0, 0, 0, 187, 

124 191, 5, 68, 0, 0, 188, 190, 5, 69, 0, 0, 189, 188, 1, 0, 0, 0, 190, 193, 1, 0, 0, 0, 191, 

125 189, 1, 0, 0, 0, 191, 192, 1, 0, 0, 0, 192, 194, 1, 0, 0, 0, 193, 191, 1, 0, 0, 0, 194, 

126 273, 3, 2, 1, 24, 195, 199, 10, 23, 0, 0, 196, 198, 5, 69, 0, 0, 197, 196, 1, 0, 0, 0, 

127 198, 201, 1, 0, 0, 0, 199, 197, 1, 0, 0, 0, 199, 200, 1, 0, 0, 0, 200, 202, 1, 0, 0, 0, 

128 201, 199, 1, 0, 0, 0, 202, 206, 3, 92, 46, 0, 203, 205, 5, 69, 0, 0, 204, 203, 1, 0, 0, 

129 0, 205, 208, 1, 0, 0, 0, 206, 204, 1, 0, 0, 0, 206, 207, 1, 0, 0, 0, 207, 209, 1, 0, 0, 

130 0, 208, 206, 1, 0, 0, 0, 209, 210, 3, 2, 1, 23, 210, 273, 1, 0, 0, 0, 211, 215, 10, 22, 

131 0, 0, 212, 214, 5, 69, 0, 0, 213, 212, 1, 0, 0, 0, 214, 217, 1, 0, 0, 0, 215, 213, 1, 0, 

132 0, 0, 215, 216, 1, 0, 0, 0, 216, 218, 1, 0, 0, 0, 217, 215, 1, 0, 0, 0, 218, 222, 3, 94, 

133 47, 0, 219, 221, 5, 69, 0, 0, 220, 219, 1, 0, 0, 0, 221, 224, 1, 0, 0, 0, 222, 220, 1, 

134 0, 0, 0, 222, 223, 1, 0, 0, 0, 223, 225, 1, 0, 0, 0, 224, 222, 1, 0, 0, 0, 225, 226, 3, 

135 2, 1, 22, 226, 273, 1, 0, 0, 0, 227, 231, 10, 20, 0, 0, 228, 230, 5, 69, 0, 0, 229, 228, 

136 1, 0, 0, 0, 230, 233, 1, 0, 0, 0, 231, 229, 1, 0, 0, 0, 231, 232, 1, 0, 0, 0, 232, 234, 

137 1, 0, 0, 0, 233, 231, 1, 0, 0, 0, 234, 238, 7, 2, 0, 0, 235, 237, 5, 69, 0, 0, 236, 235, 

138 1, 0, 0, 0, 237, 240, 1, 0, 0, 0, 238, 236, 1, 0, 0, 0, 238, 239, 1, 0, 0, 0, 239, 241, 

139 1, 0, 0, 0, 240, 238, 1, 0, 0, 0, 241, 273, 3, 2, 1, 21, 242, 246, 10, 19, 0, 0, 243, 245, 

140 5, 69, 0, 0, 244, 243, 1, 0, 0, 0, 245, 248, 1, 0, 0, 0, 246, 244, 1, 0, 0, 0, 246, 247, 

141 1, 0, 0, 0, 247, 249, 1, 0, 0, 0, 248, 246, 1, 0, 0, 0, 249, 253, 7, 3, 0, 0, 250, 252, 

142 5, 69, 0, 0, 251, 250, 1, 0, 0, 0, 252, 255, 1, 0, 0, 0, 253, 251, 1, 0, 0, 0, 253, 254, 

143 1, 0, 0, 0, 254, 256, 1, 0, 0, 0, 255, 253, 1, 0, 0, 0, 256, 273, 3, 2, 1, 20, 257, 258, 

144 10, 30, 0, 0, 258, 259, 5, 2, 0, 0, 259, 260, 3, 28, 14, 0, 260, 261, 5, 3, 0, 0, 261, 

145 262, 5, 3, 0, 0, 262, 273, 1, 0, 0, 0, 263, 264, 10, 29, 0, 0, 264, 265, 5, 4, 0, 0, 265, 

146 266, 3, 28, 14, 0, 266, 267, 5, 3, 0, 0, 267, 273, 1, 0, 0, 0, 268, 269, 10, 26, 0, 0, 

147 269, 273, 3, 14, 7, 0, 270, 271, 10, 25, 0, 0, 271, 273, 3, 16, 8, 0, 272, 176, 1, 0, 

148 0, 0, 272, 180, 1, 0, 0, 0, 272, 195, 1, 0, 0, 0, 272, 211, 1, 0, 0, 0, 272, 227, 1, 0, 

149 0, 0, 272, 242, 1, 0, 0, 0, 272, 257, 1, 0, 0, 0, 272, 263, 1, 0, 0, 0, 272, 268, 1, 0, 

150 0, 0, 272, 270, 1, 0, 0, 0, 273, 276, 1, 0, 0, 0, 274, 272, 1, 0, 0, 0, 274, 275, 1, 0, 

151 0, 0, 275, 3, 1, 0, 0, 0, 276, 274, 1, 0, 0, 0, 277, 281, 3, 10, 5, 0, 278, 280, 5, 69, 

152 0, 0, 279, 278, 1, 0, 0, 0, 280, 283, 1, 0, 0, 0, 281, 279, 1, 0, 0, 0, 281, 282, 1, 0, 

153 0, 0, 282, 284, 1, 0, 0, 0, 283, 281, 1, 0, 0, 0, 284, 288, 5, 12, 0, 0, 285, 287, 5, 69, 

154 0, 0, 286, 285, 1, 0, 0, 0, 287, 290, 1, 0, 0, 0, 288, 286, 1, 0, 0, 0, 288, 289, 1, 0, 

155 0, 0, 289, 291, 1, 0, 0, 0, 290, 288, 1, 0, 0, 0, 291, 295, 3, 18, 9, 0, 292, 294, 5, 69, 

156 0, 0, 293, 292, 1, 0, 0, 0, 294, 297, 1, 0, 0, 0, 295, 293, 1, 0, 0, 0, 295, 296, 1, 0, 

157 0, 0, 296, 298, 1, 0, 0, 0, 297, 295, 1, 0, 0, 0, 298, 299, 5, 13, 0, 0, 299, 5, 1, 0, 0, 

158 0, 300, 301, 3, 8, 4, 0, 301, 302, 3, 2, 1, 0, 302, 7, 1, 0, 0, 0, 303, 304, 3, 82, 41, 

159 0, 304, 308, 5, 16, 0, 0, 305, 307, 5, 69, 0, 0, 306, 305, 1, 0, 0, 0, 307, 310, 1, 0, 

160 0, 0, 308, 306, 1, 0, 0, 0, 308, 309, 1, 0, 0, 0, 309, 312, 1, 0, 0, 0, 310, 308, 1, 0, 

161 0, 0, 311, 313, 3, 22, 11, 0, 312, 311, 1, 0, 0, 0, 312, 313, 1, 0, 0, 0, 313, 317, 1, 

162 0, 0, 0, 314, 316, 5, 69, 0, 0, 315, 314, 1, 0, 0, 0, 316, 319, 1, 0, 0, 0, 317, 315, 1, 

163 0, 0, 0, 317, 318, 1, 0, 0, 0, 318, 320, 1, 0, 0, 0, 319, 317, 1, 0, 0, 0, 320, 321, 5, 

164 17, 0, 0, 321, 9, 1, 0, 0, 0, 322, 323, 3, 82, 41, 0, 323, 327, 5, 16, 0, 0, 324, 326, 

165 5, 69, 0, 0, 325, 324, 1, 0, 0, 0, 326, 329, 1, 0, 0, 0, 327, 325, 1, 0, 0, 0, 327, 328, 

166 1, 0, 0, 0, 328, 331, 1, 0, 0, 0, 329, 327, 1, 0, 0, 0, 330, 332, 3, 22, 11, 0, 331, 330, 

167 1, 0, 0, 0, 331, 332, 1, 0, 0, 0, 332, 336, 1, 0, 0, 0, 333, 335, 5, 69, 0, 0, 334, 333, 

168 1, 0, 0, 0, 335, 338, 1, 0, 0, 0, 336, 334, 1, 0, 0, 0, 336, 337, 1, 0, 0, 0, 337, 339, 

169 1, 0, 0, 0, 338, 336, 1, 0, 0, 0, 339, 340, 5, 17, 0, 0, 340, 11, 1, 0, 0, 0, 341, 342, 

170 5, 18, 0, 0, 342, 343, 5, 16, 0, 0, 343, 344, 3, 84, 42, 0, 344, 345, 5, 17, 0, 0, 345, 

171 13, 1, 0, 0, 0, 346, 348, 3, 80, 40, 0, 347, 349, 5, 69, 0, 0, 348, 347, 1, 0, 0, 0, 348, 

172 349, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 351, 3, 2, 1, 0, 351, 15, 1, 0, 0, 0, 352, 353, 

173 3, 88, 44, 0, 353, 354, 3, 2, 1, 0, 354, 17, 1, 0, 0, 0, 355, 359, 3, 2, 1, 0, 356, 358, 

174 3, 20, 10, 0, 357, 356, 1, 0, 0, 0, 358, 361, 1, 0, 0, 0, 359, 357, 1, 0, 0, 0, 359, 360, 

175 1, 0, 0, 0, 360, 19, 1, 0, 0, 0, 361, 359, 1, 0, 0, 0, 362, 364, 7, 0, 0, 0, 363, 365, 3, 

176 2, 1, 0, 364, 363, 1, 0, 0, 0, 364, 365, 1, 0, 0, 0, 365, 21, 1, 0, 0, 0, 366, 380, 3, 24, 

177 12, 0, 367, 369, 5, 69, 0, 0, 368, 367, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 370, 1, 

178 0, 0, 0, 370, 374, 5, 19, 0, 0, 371, 373, 5, 69, 0, 0, 372, 371, 1, 0, 0, 0, 373, 376, 

179 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 377, 1, 0, 0, 0, 376, 374, 

180 1, 0, 0, 0, 377, 379, 3, 24, 12, 0, 378, 368, 1, 0, 0, 0, 379, 382, 1, 0, 0, 0, 380, 378, 

181 1, 0, 0, 0, 380, 381, 1, 0, 0, 0, 381, 23, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 383, 390, 3, 

182 26, 13, 0, 384, 385, 3, 26, 13, 0, 385, 386, 5, 20, 0, 0, 386, 387, 3, 2, 1, 0, 387, 390, 

183 1, 0, 0, 0, 388, 390, 5, 21, 0, 0, 389, 383, 1, 0, 0, 0, 389, 384, 1, 0, 0, 0, 389, 388, 

184 1, 0, 0, 0, 390, 25, 1, 0, 0, 0, 391, 392, 5, 67, 0, 0, 392, 27, 1, 0, 0, 0, 393, 419, 3, 

185 32, 16, 0, 394, 396, 5, 69, 0, 0, 395, 394, 1, 0, 0, 0, 396, 399, 1, 0, 0, 0, 397, 395, 

186 1, 0, 0, 0, 397, 398, 1, 0, 0, 0, 398, 400, 1, 0, 0, 0, 399, 397, 1, 0, 0, 0, 400, 404, 

187 5, 19, 0, 0, 401, 403, 5, 69, 0, 0, 402, 401, 1, 0, 0, 0, 403, 406, 1, 0, 0, 0, 404, 402, 

188 1, 0, 0, 0, 404, 405, 1, 0, 0, 0, 405, 409, 1, 0, 0, 0, 406, 404, 1, 0, 0, 0, 407, 410, 

189 3, 70, 35, 0, 408, 410, 3, 32, 16, 0, 409, 407, 1, 0, 0, 0, 409, 408, 1, 0, 0, 0, 410, 

190 414, 1, 0, 0, 0, 411, 413, 5, 69, 0, 0, 412, 411, 1, 0, 0, 0, 413, 416, 1, 0, 0, 0, 414, 

191 412, 1, 0, 0, 0, 414, 415, 1, 0, 0, 0, 415, 418, 1, 0, 0, 0, 416, 414, 1, 0, 0, 0, 417, 

192 397, 1, 0, 0, 0, 418, 421, 1, 0, 0, 0, 419, 417, 1, 0, 0, 0, 419, 420, 1, 0, 0, 0, 420, 

193 29, 1, 0, 0, 0, 421, 419, 1, 0, 0, 0, 422, 436, 3, 84, 42, 0, 423, 425, 5, 69, 0, 0, 424, 

194 423, 1, 0, 0, 0, 424, 425, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 428, 5, 6, 0, 0, 427, 

195 429, 5, 69, 0, 0, 428, 427, 1, 0, 0, 0, 428, 429, 1, 0, 0, 0, 429, 430, 1, 0, 0, 0, 430, 

196 432, 3, 84, 42, 0, 431, 433, 5, 69, 0, 0, 432, 431, 1, 0, 0, 0, 432, 433, 1, 0, 0, 0, 433, 

197 435, 1, 0, 0, 0, 434, 424, 1, 0, 0, 0, 435, 438, 1, 0, 0, 0, 436, 434, 1, 0, 0, 0, 436, 

198 437, 1, 0, 0, 0, 437, 31, 1, 0, 0, 0, 438, 436, 1, 0, 0, 0, 439, 442, 3, 34, 17, 0, 440, 

199 442, 3, 2, 1, 0, 441, 439, 1, 0, 0, 0, 441, 440, 1, 0, 0, 0, 442, 33, 1, 0, 0, 0, 443, 444, 

200 3, 84, 42, 0, 444, 447, 5, 20, 0, 0, 445, 448, 3, 70, 35, 0, 446, 448, 3, 2, 1, 0, 447, 

201 445, 1, 0, 0, 0, 447, 446, 1, 0, 0, 0, 448, 462, 1, 0, 0, 0, 449, 450, 5, 66, 0, 0, 450, 

202 462, 5, 20, 0, 0, 451, 452, 5, 66, 0, 0, 452, 453, 5, 20, 0, 0, 453, 462, 3, 2, 1, 0, 454, 

203 455, 5, 22, 0, 0, 455, 462, 5, 20, 0, 0, 456, 457, 5, 22, 0, 0, 457, 458, 5, 20, 0, 0, 

204 458, 462, 3, 2, 1, 0, 459, 462, 5, 21, 0, 0, 460, 462, 5, 23, 0, 0, 461, 443, 1, 0, 0, 

205 0, 461, 449, 1, 0, 0, 0, 461, 451, 1, 0, 0, 0, 461, 454, 1, 0, 0, 0, 461, 456, 1, 0, 0, 

206 0, 461, 459, 1, 0, 0, 0, 461, 460, 1, 0, 0, 0, 462, 35, 1, 0, 0, 0, 463, 466, 3, 38, 19, 

207 0, 464, 466, 3, 40, 20, 0, 465, 463, 1, 0, 0, 0, 465, 464, 1, 0, 0, 0, 466, 37, 1, 0, 0, 

208 0, 467, 470, 3, 84, 42, 0, 468, 470, 5, 63, 0, 0, 469, 467, 1, 0, 0, 0, 469, 468, 1, 0, 

209 0, 0, 470, 471, 1, 0, 0, 0, 471, 474, 5, 23, 0, 0, 472, 475, 3, 84, 42, 0, 473, 475, 5, 

210 63, 0, 0, 474, 472, 1, 0, 0, 0, 474, 473, 1, 0, 0, 0, 475, 39, 1, 0, 0, 0, 476, 477, 5, 

211 16, 0, 0, 477, 478, 3, 2, 1, 0, 478, 479, 5, 17, 0, 0, 479, 480, 5, 23, 0, 0, 480, 481, 

212 3, 2, 1, 0, 481, 41, 1, 0, 0, 0, 482, 485, 3, 44, 22, 0, 483, 485, 3, 46, 23, 0, 484, 482, 

213 1, 0, 0, 0, 484, 483, 1, 0, 0, 0, 485, 43, 1, 0, 0, 0, 486, 489, 3, 84, 42, 0, 487, 489, 

214 3, 48, 24, 0, 488, 486, 1, 0, 0, 0, 488, 487, 1, 0, 0, 0, 489, 490, 1, 0, 0, 0, 490, 491, 

215 5, 24, 0, 0, 491, 492, 3, 2, 1, 0, 492, 45, 1, 0, 0, 0, 493, 494, 5, 16, 0, 0, 494, 495, 

216 3, 2, 1, 0, 495, 496, 5, 17, 0, 0, 496, 497, 5, 24, 0, 0, 497, 498, 3, 2, 1, 0, 498, 47, 

217 1, 0, 0, 0, 499, 510, 5, 66, 0, 0, 500, 510, 5, 62, 0, 0, 501, 510, 5, 63, 0, 0, 502, 510, 

218 5, 64, 0, 0, 503, 510, 5, 65, 0, 0, 504, 510, 5, 22, 0, 0, 505, 510, 5, 25, 0, 0, 506, 

219 510, 5, 26, 0, 0, 507, 510, 5, 27, 0, 0, 508, 510, 3, 50, 25, 0, 509, 499, 1, 0, 0, 0, 

220 509, 500, 1, 0, 0, 0, 509, 501, 1, 0, 0, 0, 509, 502, 1, 0, 0, 0, 509, 503, 1, 0, 0, 0, 

221 509, 504, 1, 0, 0, 0, 509, 505, 1, 0, 0, 0, 509, 506, 1, 0, 0, 0, 509, 507, 1, 0, 0, 0, 

222 509, 508, 1, 0, 0, 0, 510, 49, 1, 0, 0, 0, 511, 512, 7, 4, 0, 0, 512, 51, 1, 0, 0, 0, 513, 

223 514, 5, 30, 0, 0, 514, 53, 1, 0, 0, 0, 515, 516, 5, 31, 0, 0, 516, 517, 3, 2, 1, 0, 517, 

224 55, 1, 0, 0, 0, 518, 519, 5, 32, 0, 0, 519, 520, 5, 16, 0, 0, 520, 521, 3, 2, 1, 0, 521, 

225 522, 5, 17, 0, 0, 522, 523, 3, 2, 1, 0, 523, 57, 1, 0, 0, 0, 524, 525, 5, 33, 0, 0, 525, 

226 526, 5, 16, 0, 0, 526, 527, 3, 84, 42, 0, 527, 528, 5, 34, 0, 0, 528, 529, 3, 2, 1, 0, 

227 529, 530, 5, 17, 0, 0, 530, 531, 3, 2, 1, 0, 531, 59, 1, 0, 0, 0, 532, 533, 5, 35, 0, 0, 

228 533, 534, 5, 16, 0, 0, 534, 535, 3, 2, 1, 0, 535, 539, 5, 17, 0, 0, 536, 538, 5, 69, 0, 

229 0, 537, 536, 1, 0, 0, 0, 538, 541, 1, 0, 0, 0, 539, 537, 1, 0, 0, 0, 539, 540, 1, 0, 0, 

230 0, 540, 542, 1, 0, 0, 0, 541, 539, 1, 0, 0, 0, 542, 562, 3, 2, 1, 0, 543, 544, 3, 64, 32, 

231 0, 544, 545, 5, 16, 0, 0, 545, 546, 3, 2, 1, 0, 546, 550, 5, 17, 0, 0, 547, 549, 5, 69, 

232 0, 0, 548, 547, 1, 0, 0, 0, 549, 552, 1, 0, 0, 0, 550, 548, 1, 0, 0, 0, 550, 551, 1, 0, 

233 0, 0, 551, 553, 1, 0, 0, 0, 552, 550, 1, 0, 0, 0, 553, 557, 3, 2, 1, 0, 554, 556, 5, 69, 

234 0, 0, 555, 554, 1, 0, 0, 0, 556, 559, 1, 0, 0, 0, 557, 555, 1, 0, 0, 0, 557, 558, 1, 0, 

235 0, 0, 558, 561, 1, 0, 0, 0, 559, 557, 1, 0, 0, 0, 560, 543, 1, 0, 0, 0, 561, 564, 1, 0, 

236 0, 0, 562, 560, 1, 0, 0, 0, 562, 563, 1, 0, 0, 0, 563, 61, 1, 0, 0, 0, 564, 562, 1, 0, 0, 

237 0, 565, 566, 5, 35, 0, 0, 566, 567, 5, 16, 0, 0, 567, 568, 3, 2, 1, 0, 568, 572, 5, 17, 

238 0, 0, 569, 571, 5, 69, 0, 0, 570, 569, 1, 0, 0, 0, 571, 574, 1, 0, 0, 0, 572, 570, 1, 0, 

239 0, 0, 572, 573, 1, 0, 0, 0, 573, 575, 1, 0, 0, 0, 574, 572, 1, 0, 0, 0, 575, 579, 3, 2, 

240 1, 0, 576, 578, 5, 69, 0, 0, 577, 576, 1, 0, 0, 0, 578, 581, 1, 0, 0, 0, 579, 577, 1, 0, 

241 0, 0, 579, 580, 1, 0, 0, 0, 580, 601, 1, 0, 0, 0, 581, 579, 1, 0, 0, 0, 582, 583, 3, 64, 

242 32, 0, 583, 584, 5, 16, 0, 0, 584, 585, 3, 2, 1, 0, 585, 589, 5, 17, 0, 0, 586, 588, 5, 

243 69, 0, 0, 587, 586, 1, 0, 0, 0, 588, 591, 1, 0, 0, 0, 589, 587, 1, 0, 0, 0, 589, 590, 1, 

244 0, 0, 0, 590, 592, 1, 0, 0, 0, 591, 589, 1, 0, 0, 0, 592, 596, 3, 2, 1, 0, 593, 595, 5, 

245 69, 0, 0, 594, 593, 1, 0, 0, 0, 595, 598, 1, 0, 0, 0, 596, 594, 1, 0, 0, 0, 596, 597, 1, 

246 0, 0, 0, 597, 600, 1, 0, 0, 0, 598, 596, 1, 0, 0, 0, 599, 582, 1, 0, 0, 0, 600, 603, 1, 

247 0, 0, 0, 601, 599, 1, 0, 0, 0, 601, 602, 1, 0, 0, 0, 602, 604, 1, 0, 0, 0, 603, 601, 1, 

248 0, 0, 0, 604, 608, 5, 36, 0, 0, 605, 607, 5, 69, 0, 0, 606, 605, 1, 0, 0, 0, 607, 610, 

249 1, 0, 0, 0, 608, 606, 1, 0, 0, 0, 608, 609, 1, 0, 0, 0, 609, 611, 1, 0, 0, 0, 610, 608, 

250 1, 0, 0, 0, 611, 612, 3, 2, 1, 0, 612, 63, 1, 0, 0, 0, 613, 614, 5, 36, 0, 0, 614, 615, 

251 5, 35, 0, 0, 615, 65, 1, 0, 0, 0, 616, 617, 5, 37, 0, 0, 617, 618, 5, 16, 0, 0, 618, 619, 

252 3, 2, 1, 0, 619, 620, 5, 17, 0, 0, 620, 67, 1, 0, 0, 0, 621, 644, 3, 84, 42, 0, 622, 623, 

253 5, 16, 0, 0, 623, 645, 5, 17, 0, 0, 624, 625, 5, 16, 0, 0, 625, 626, 3, 70, 35, 0, 626, 

254 627, 5, 17, 0, 0, 627, 645, 1, 0, 0, 0, 628, 632, 5, 16, 0, 0, 629, 631, 5, 69, 0, 0, 630, 

255 629, 1, 0, 0, 0, 631, 634, 1, 0, 0, 0, 632, 630, 1, 0, 0, 0, 632, 633, 1, 0, 0, 0, 633, 

256 635, 1, 0, 0, 0, 634, 632, 1, 0, 0, 0, 635, 639, 3, 28, 14, 0, 636, 638, 5, 69, 0, 0, 637, 

257 636, 1, 0, 0, 0, 638, 641, 1, 0, 0, 0, 639, 637, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, 640, 

258 642, 1, 0, 0, 0, 641, 639, 1, 0, 0, 0, 642, 643, 5, 17, 0, 0, 643, 645, 1, 0, 0, 0, 644, 

259 622, 1, 0, 0, 0, 644, 624, 1, 0, 0, 0, 644, 628, 1, 0, 0, 0, 645, 69, 1, 0, 0, 0, 646, 648, 

260 5, 69, 0, 0, 647, 646, 1, 0, 0, 0, 648, 651, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 649, 650, 

261 1, 0, 0, 0, 650, 652, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 652, 656, 5, 12, 0, 0, 653, 655, 

262 5, 69, 0, 0, 654, 653, 1, 0, 0, 0, 655, 658, 1, 0, 0, 0, 656, 654, 1, 0, 0, 0, 656, 657, 

263 1, 0, 0, 0, 657, 659, 1, 0, 0, 0, 658, 656, 1, 0, 0, 0, 659, 663, 3, 18, 9, 0, 660, 662, 

264 5, 69, 0, 0, 661, 660, 1, 0, 0, 0, 662, 665, 1, 0, 0, 0, 663, 661, 1, 0, 0, 0, 663, 664, 

265 1, 0, 0, 0, 664, 666, 1, 0, 0, 0, 665, 663, 1, 0, 0, 0, 666, 670, 5, 13, 0, 0, 667, 669, 

266 5, 69, 0, 0, 668, 667, 1, 0, 0, 0, 669, 672, 1, 0, 0, 0, 670, 668, 1, 0, 0, 0, 670, 671, 

267 1, 0, 0, 0, 671, 71, 1, 0, 0, 0, 672, 670, 1, 0, 0, 0, 673, 677, 3, 76, 38, 0, 674, 677, 

268 3, 74, 37, 0, 675, 677, 3, 78, 39, 0, 676, 673, 1, 0, 0, 0, 676, 674, 1, 0, 0, 0, 676, 

269 675, 1, 0, 0, 0, 677, 73, 1, 0, 0, 0, 678, 680, 3, 84, 42, 0, 679, 678, 1, 0, 0, 0, 679, 

270 680, 1, 0, 0, 0, 680, 681, 1, 0, 0, 0, 681, 684, 3, 86, 43, 0, 682, 685, 3, 30, 15, 0, 

271 683, 685, 5, 18, 0, 0, 684, 682, 1, 0, 0, 0, 684, 683, 1, 0, 0, 0, 685, 75, 1, 0, 0, 0, 

272 686, 687, 5, 38, 0, 0, 687, 688, 5, 16, 0, 0, 688, 689, 3, 84, 42, 0, 689, 717, 5, 19, 

273 0, 0, 690, 694, 5, 12, 0, 0, 691, 693, 5, 69, 0, 0, 692, 691, 1, 0, 0, 0, 693, 696, 1, 

274 0, 0, 0, 694, 692, 1, 0, 0, 0, 694, 695, 1, 0, 0, 0, 695, 697, 1, 0, 0, 0, 696, 694, 1, 

275 0, 0, 0, 697, 702, 3, 2, 1, 0, 698, 699, 5, 1, 0, 0, 699, 701, 3, 2, 1, 0, 700, 698, 1, 

276 0, 0, 0, 701, 704, 1, 0, 0, 0, 702, 700, 1, 0, 0, 0, 702, 703, 1, 0, 0, 0, 703, 708, 1, 

277 0, 0, 0, 704, 702, 1, 0, 0, 0, 705, 707, 5, 69, 0, 0, 706, 705, 1, 0, 0, 0, 707, 710, 1, 

278 0, 0, 0, 708, 706, 1, 0, 0, 0, 708, 709, 1, 0, 0, 0, 709, 711, 1, 0, 0, 0, 710, 708, 1, 

279 0, 0, 0, 711, 712, 5, 13, 0, 0, 712, 718, 1, 0, 0, 0, 713, 714, 3, 84, 42, 0, 714, 715, 

280 3, 80, 40, 0, 715, 716, 3, 2, 1, 0, 716, 718, 1, 0, 0, 0, 717, 690, 1, 0, 0, 0, 717, 713, 

281 1, 0, 0, 0, 718, 719, 1, 0, 0, 0, 719, 720, 5, 17, 0, 0, 720, 77, 1, 0, 0, 0, 721, 722, 

282 5, 16, 0, 0, 722, 723, 3, 2, 1, 0, 723, 724, 5, 17, 0, 0, 724, 727, 3, 86, 43, 0, 725, 

283 728, 3, 30, 15, 0, 726, 728, 5, 18, 0, 0, 727, 725, 1, 0, 0, 0, 727, 726, 1, 0, 0, 0, 728, 

284 79, 1, 0, 0, 0, 729, 730, 7, 5, 0, 0, 730, 81, 1, 0, 0, 0, 731, 732, 5, 44, 0, 0, 732, 83, 

285 1, 0, 0, 0, 733, 734, 5, 67, 0, 0, 734, 85, 1, 0, 0, 0, 735, 736, 5, 45, 0, 0, 736, 87, 

286 1, 0, 0, 0, 737, 738, 7, 6, 0, 0, 738, 89, 1, 0, 0, 0, 739, 740, 7, 7, 0, 0, 740, 91, 1, 

287 0, 0, 0, 741, 742, 7, 8, 0, 0, 742, 93, 1, 0, 0, 0, 743, 744, 7, 9, 0, 0, 744, 95, 1, 0, 

288 0, 0, 80, 100, 102, 121, 128, 135, 142, 160, 167, 174, 184, 191, 199, 206, 215, 222, 

289 231, 238, 246, 253, 272, 274, 281, 288, 295, 308, 312, 317, 327, 331, 336, 348, 

290 359, 364, 368, 374, 380, 389, 397, 404, 409, 414, 419, 424, 428, 432, 436, 441, 

291 447, 461, 465, 469, 474, 484, 488, 509, 539, 550, 557, 562, 572, 579, 589, 596, 

292 601, 608, 632, 639, 644, 649, 656, 663, 670, 676, 679, 684, 694, 702, 708, 717, 

293 727 

294 ] 

295 

296 

297class RParser (Parser): 

298 

299 grammarFileName = "R.g4" 

300 

301 atn = ATNDeserializer().deserialize(serializedATN()) 

302 

303 decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] 

304 

305 sharedContextCache = PredictionContextCache() 

306 

307 literalNames = ["<INVALID>", "';'", "'[['", "']'", "'['", "'-'", "'+'", 

308 "'!'", "'&'", "'&&'", "'|'", "'||'", "'{'", "'}'", 

309 "'?'", "'break'", "'('", "')'", "'.'", "','", "'='", 

310 "'...'", "'NULL'", "':'", "'%in%'", "'NA'", "'Inf'", 

311 "'NaN'", "'TRUE'", "'FALSE'", "'next'", "'repeat'", 

312 "'while'", "'for'", "'in'", "'if'", "'else'", "'return'", 

313 "'within'", "'<-'", "'<<-'", "'->'", "'->>'", "':='", 

314 "'function'", "'~'", "'::'", "':::'", "'$'", "'@'", 

315 "'*'", "'/'", "'%'", "'^'", "'%%'", "'>'", "'>='", 

316 "'<'", "'<='", "'=='", "'!='"] 

317 

318 symbolicNames = ["<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

319 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

320 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

321 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

322 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

323 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

324 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

325 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

326 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

327 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

328 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

329 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

330 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

331 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

332 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

333 "<INVALID>", "PARENTHESIS", "HEX", "INT", "FLOAT", 

334 "COMPLEX", "STRING", "ID", "USER_OP", "NL", "WS"] 

335 

336 RULE_parse = 0 

337 RULE_expr = 1 

338 RULE_functiondefbody = 2 

339 RULE_functiondeflambda = 3 

340 RULE_functiondefargslambda = 4 

341 RULE_functiondefargs = 5 

342 RULE_implicit_column_name = 6 

343 RULE_affectation = 7 

344 RULE_rangeopexpr = 8 

345 RULE_exprlist = 9 

346 RULE_rightexpr = 10 

347 RULE_formlist = 11 

348 RULE_form = 12 

349 RULE_argumentname = 13 

350 RULE_sublist = 14 

351 RULE_sublistadd = 15 

352 RULE_sub = 16 

353 RULE_subnobracket = 17 

354 RULE_ranges = 18 

355 RULE_range_simple = 19 

356 RULE_range_complexe = 20 

357 RULE_intersections = 21 

358 RULE_intersection_simple = 22 

359 RULE_intersection_complexe = 23 

360 RULE_constant = 24 

361 RULE_boolean = 25 

362 RULE_nextexpr = 26 

363 RULE_repeatexpr = 27 

364 RULE_whileexpr = 28 

365 RULE_forexpr = 29 

366 RULE_ifexpr = 30 

367 RULE_ifelseexpr = 31 

368 RULE_elseif = 32 

369 RULE_returnexpr = 33 

370 RULE_functioncall = 34 

371 RULE_inlinefunction = 35 

372 RULE_formula_simple = 36 

373 RULE_formula_simple_A = 37 

374 RULE_formula_simple_B = 38 

375 RULE_formula_simple_C = 39 

376 RULE_affectop = 40 

377 RULE_functiondef = 41 

378 RULE_identifier = 42 

379 RULE_formop = 43 

380 RULE_rangeop = 44 

381 RULE_dotop = 45 

382 RULE_operator = 46 

383 RULE_comparison = 47 

384 

385 ruleNames = ["parse", "expr", "functiondefbody", "functiondeflambda", 

386 "functiondefargslambda", "functiondefargs", "implicit_column_name", 

387 "affectation", "rangeopexpr", "exprlist", "rightexpr", 

388 "formlist", "form", "argumentname", "sublist", "sublistadd", 

389 "sub", "subnobracket", "ranges", "range_simple", "range_complexe", 

390 "intersections", "intersection_simple", "intersection_complexe", 

391 "constant", "boolean", "nextexpr", "repeatexpr", "whileexpr", 

392 "forexpr", "ifexpr", "ifelseexpr", "elseif", "returnexpr", 

393 "functioncall", "inlinefunction", "formula_simple", "formula_simple_A", 

394 "formula_simple_B", "formula_simple_C", "affectop", "functiondef", 

395 "identifier", "formop", "rangeop", "dotop", "operator", 

396 "comparison"] 

397 

398 EOF = Token.EOF 

399 T__0 = 1 

400 T__1 = 2 

401 T__2 = 3 

402 T__3 = 4 

403 T__4 = 5 

404 T__5 = 6 

405 T__6 = 7 

406 T__7 = 8 

407 T__8 = 9 

408 T__9 = 10 

409 T__10 = 11 

410 T__11 = 12 

411 T__12 = 13 

412 T__13 = 14 

413 T__14 = 15 

414 T__15 = 16 

415 T__16 = 17 

416 T__17 = 18 

417 T__18 = 19 

418 T__19 = 20 

419 T__20 = 21 

420 T__21 = 22 

421 T__22 = 23 

422 T__23 = 24 

423 T__24 = 25 

424 T__25 = 26 

425 T__26 = 27 

426 T__27 = 28 

427 T__28 = 29 

428 T__29 = 30 

429 T__30 = 31 

430 T__31 = 32 

431 T__32 = 33 

432 T__33 = 34 

433 T__34 = 35 

434 T__35 = 36 

435 T__36 = 37 

436 T__37 = 38 

437 T__38 = 39 

438 T__39 = 40 

439 T__40 = 41 

440 T__41 = 42 

441 T__42 = 43 

442 T__43 = 44 

443 T__44 = 45 

444 T__45 = 46 

445 T__46 = 47 

446 T__47 = 48 

447 T__48 = 49 

448 T__49 = 50 

449 T__50 = 51 

450 T__51 = 52 

451 T__52 = 53 

452 T__53 = 54 

453 T__54 = 55 

454 T__55 = 56 

455 T__56 = 57 

456 T__57 = 58 

457 T__58 = 59 

458 T__59 = 60 

459 PARENTHESIS = 61 

460 HEX = 62 

461 INT = 63 

462 FLOAT = 64 

463 COMPLEX = 65 

464 STRING = 66 

465 ID = 67 

466 USER_OP = 68 

467 NL = 69 

468 WS = 70 

469 

470 def __init__(self, input: TokenStream, output: TextIO = sys.stdout): 

471 super().__init__(input, output) 

472 self.checkVersion("4.10.1") 

473 self._interp = ParserATNSimulator( 

474 self, self.atn, self.decisionsToDFA, self.sharedContextCache) 

475 self._predicates = None 

476 

477 class ParseContext(ParserRuleContext): 

478 __slots__ = 'parser' 

479 

480 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

481 super().__init__(parent, invokingState) 

482 self.parser = parser 

483 

484 def EOF(self): 

485 return self.getToken(RParser.EOF, 0) 

486 

487 def expr(self, i: int = None): 

488 if i is None: 

489 return self.getTypedRuleContexts(RParser.ExprContext) 

490 else: 

491 return self.getTypedRuleContext(RParser.ExprContext, i) 

492 

493 def NL(self, i: int = None): 

494 if i is None: 

495 return self.getTokens(RParser.NL) 

496 else: 

497 return self.getToken(RParser.NL, i) 

498 

499 def getRuleIndex(self): 

500 return RParser.RULE_parse 

501 

502 def enterRule(self, listener: ParseTreeListener): 

503 if hasattr(listener, "enterParse"): 

504 listener.enterParse(self) 

505 

506 def exitRule(self, listener: ParseTreeListener): 

507 if hasattr(listener, "exitParse"): 

508 listener.exitParse(self) 

509 

510 def parse(self): 

511 

512 localctx = RParser.ParseContext(self, self._ctx, self.state) 

513 self.enterRule(localctx, 0, self.RULE_parse) 

514 self._la = 0 # Token type 

515 try: 

516 self.enterOuterAlt(localctx, 1) 

517 self.state = 102 

518 self._errHandler.sync(self) 

519 _la = self._input.LA(1) 

520 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__4) | (1 << RParser.T__5) | (1 << RParser.T__6) | (1 << RParser.T__11) | (1 << RParser.T__13) | (1 << RParser.T__14) | (1 << RParser.T__15) | (1 << RParser.T__17) | (1 << RParser.T__21) | (1 << RParser.T__24) | (1 << RParser.T__25) | (1 << RParser.T__26) | (1 << RParser.T__27) | (1 << RParser.T__28) | (1 << RParser.T__29) | (1 << RParser.T__30) | (1 << RParser.T__31) | (1 << RParser.T__32) | (1 << RParser.T__34) | (1 << RParser.T__36) | (1 << RParser.T__37) | (1 << RParser.T__43) | (1 << RParser.T__44) | (1 << RParser.HEX) | (1 << RParser.INT))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (RParser.FLOAT - 64)) | (1 << (RParser.COMPLEX - 64)) | (1 << (RParser.STRING - 64)) | (1 << (RParser.ID - 64)) | (1 << (RParser.NL - 64)))) != 0): 

521 self.state = 100 

522 self._errHandler.sync(self) 

523 la_ = self._interp.adaptivePredict(self._input, 0, self._ctx) 

524 if la_ == 1: 

525 self.state = 96 

526 self.expr(0) 

527 self.state = 97 

528 _la = self._input.LA(1) 

529 if not (_la == RParser.T__0 or _la == RParser.NL): 

530 self._errHandler.recoverInline(self) 

531 else: 

532 self._errHandler.reportMatch(self) 

533 self.consume() 

534 pass 

535 

536 elif la_ == 2: 

537 self.state = 99 

538 self.match(RParser.NL) 

539 pass 

540 

541 self.state = 104 

542 self._errHandler.sync(self) 

543 _la = self._input.LA(1) 

544 

545 self.state = 105 

546 self.match(RParser.EOF) 

547 except RecognitionException as re: 

548 localctx.exception = re 

549 self._errHandler.reportError(self, re) 

550 self._errHandler.recover(self, re) 

551 finally: 

552 self.exitRule() 

553 return localctx 

554 

555 class ExprContext(ParserRuleContext): 

556 __slots__ = 'parser' 

557 

558 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

559 super().__init__(parent, invokingState) 

560 self.parser = parser 

561 

562 def ranges(self): 

563 return self.getTypedRuleContext(RParser.RangesContext, 0) 

564 

565 def intersections(self): 

566 return self.getTypedRuleContext(RParser.IntersectionsContext, 0) 

567 

568 def expr(self, i: int = None): 

569 if i is None: 

570 return self.getTypedRuleContexts(RParser.ExprContext) 

571 else: 

572 return self.getTypedRuleContext(RParser.ExprContext, i) 

573 

574 def formula_simple(self): 

575 return self.getTypedRuleContext(RParser.Formula_simpleContext, 0) 

576 

577 def functiondefbody(self): 

578 return self.getTypedRuleContext(RParser.FunctiondefbodyContext, 0) 

579 

580 def functiondeflambda(self): 

581 return self.getTypedRuleContext(RParser.FunctiondeflambdaContext, 0) 

582 

583 def functioncall(self): 

584 return self.getTypedRuleContext(RParser.FunctioncallContext, 0) 

585 

586 def exprlist(self): 

587 return self.getTypedRuleContext(RParser.ExprlistContext, 0) 

588 

589 def NL(self, i: int = None): 

590 if i is None: 

591 return self.getTokens(RParser.NL) 

592 else: 

593 return self.getToken(RParser.NL, i) 

594 

595 def returnexpr(self): 

596 return self.getTypedRuleContext(RParser.ReturnexprContext, 0) 

597 

598 def ifelseexpr(self): 

599 return self.getTypedRuleContext(RParser.IfelseexprContext, 0) 

600 

601 def ifexpr(self): 

602 return self.getTypedRuleContext(RParser.IfexprContext, 0) 

603 

604 def forexpr(self): 

605 return self.getTypedRuleContext(RParser.ForexprContext, 0) 

606 

607 def whileexpr(self): 

608 return self.getTypedRuleContext(RParser.WhileexprContext, 0) 

609 

610 def repeatexpr(self): 

611 return self.getTypedRuleContext(RParser.RepeatexprContext, 0) 

612 

613 def implicit_column_name(self): 

614 return self.getTypedRuleContext(RParser.Implicit_column_nameContext, 0) 

615 

616 def nextexpr(self): 

617 return self.getTypedRuleContext(RParser.NextexprContext, 0) 

618 

619 def constant(self): 

620 return self.getTypedRuleContext(RParser.ConstantContext, 0) 

621 

622 def identifier(self): 

623 return self.getTypedRuleContext(RParser.IdentifierContext, 0) 

624 

625 def dotop(self): 

626 return self.getTypedRuleContext(RParser.DotopContext, 0) 

627 

628 def USER_OP(self): 

629 return self.getToken(RParser.USER_OP, 0) 

630 

631 def operator(self): 

632 return self.getTypedRuleContext(RParser.OperatorContext, 0) 

633 

634 def comparison(self): 

635 return self.getTypedRuleContext(RParser.ComparisonContext, 0) 

636 

637 def sublist(self): 

638 return self.getTypedRuleContext(RParser.SublistContext, 0) 

639 

640 def affectation(self): 

641 return self.getTypedRuleContext(RParser.AffectationContext, 0) 

642 

643 def rangeopexpr(self): 

644 return self.getTypedRuleContext(RParser.RangeopexprContext, 0) 

645 

646 def getRuleIndex(self): 

647 return RParser.RULE_expr 

648 

649 def enterRule(self, listener: ParseTreeListener): 

650 if hasattr(listener, "enterExpr"): 

651 listener.enterExpr(self) 

652 

653 def exitRule(self, listener: ParseTreeListener): 

654 if hasattr(listener, "exitExpr"): 

655 listener.exitExpr(self) 

656 

657 def expr(self, _p: int = 0): 

658 _parentctx = self._ctx 

659 _parentState = self.state 

660 localctx = RParser.ExprContext(self, self._ctx, _parentState) 

661 _prevctx = localctx 

662 _startState = 2 

663 self.enterRecursionRule(localctx, 2, self.RULE_expr, _p) 

664 self._la = 0 # Token type 

665 try: 

666 self.enterOuterAlt(localctx, 1) 

667 self.state = 174 

668 self._errHandler.sync(self) 

669 la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) 

670 if la_ == 1: 

671 self.state = 108 

672 self.ranges() 

673 pass 

674 

675 elif la_ == 2: 

676 self.state = 109 

677 self.intersections() 

678 pass 

679 

680 elif la_ == 3: 

681 self.state = 110 

682 _la = self._input.LA(1) 

683 if not (_la == RParser.T__4 or _la == RParser.T__5): 

684 self._errHandler.recoverInline(self) 

685 else: 

686 self._errHandler.reportMatch(self) 

687 self.consume() 

688 self.state = 111 

689 self.expr(27) 

690 pass 

691 

692 elif la_ == 4: 

693 self.state = 112 

694 self.match(RParser.T__6) 

695 self.state = 113 

696 self.expr(21) 

697 pass 

698 

699 elif la_ == 5: 

700 self.state = 114 

701 self.formula_simple() 

702 pass 

703 

704 elif la_ == 6: 

705 self.state = 115 

706 self.functiondefbody() 

707 pass 

708 

709 elif la_ == 7: 

710 self.state = 116 

711 self.functiondeflambda() 

712 pass 

713 

714 elif la_ == 8: 

715 self.state = 117 

716 self.functioncall() 

717 pass 

718 

719 elif la_ == 9: 

720 self.state = 121 

721 self._errHandler.sync(self) 

722 _la = self._input.LA(1) 

723 while _la == RParser.NL: 

724 self.state = 118 

725 self.match(RParser.NL) 

726 self.state = 123 

727 self._errHandler.sync(self) 

728 _la = self._input.LA(1) 

729 

730 self.state = 124 

731 self.match(RParser.T__11) 

732 self.state = 128 

733 self._errHandler.sync(self) 

734 _alt = self._interp.adaptivePredict(self._input, 3, self._ctx) 

735 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

736 if _alt == 1: 

737 self.state = 125 

738 self.match(RParser.NL) 

739 self.state = 130 

740 self._errHandler.sync(self) 

741 _alt = self._interp.adaptivePredict( 

742 self._input, 3, self._ctx) 

743 

744 self.state = 131 

745 self.exprlist() 

746 self.state = 135 

747 self._errHandler.sync(self) 

748 _la = self._input.LA(1) 

749 while _la == RParser.NL: 

750 self.state = 132 

751 self.match(RParser.NL) 

752 self.state = 137 

753 self._errHandler.sync(self) 

754 _la = self._input.LA(1) 

755 

756 self.state = 138 

757 self.match(RParser.T__12) 

758 self.state = 142 

759 self._errHandler.sync(self) 

760 _alt = self._interp.adaptivePredict(self._input, 5, self._ctx) 

761 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

762 if _alt == 1: 

763 self.state = 139 

764 self.match(RParser.NL) 

765 self.state = 144 

766 self._errHandler.sync(self) 

767 _alt = self._interp.adaptivePredict( 

768 self._input, 5, self._ctx) 

769 

770 pass 

771 

772 elif la_ == 10: 

773 self.state = 145 

774 self.returnexpr() 

775 pass 

776 

777 elif la_ == 11: 

778 self.state = 146 

779 self.ifelseexpr() 

780 pass 

781 

782 elif la_ == 12: 

783 self.state = 147 

784 self.ifexpr() 

785 pass 

786 

787 elif la_ == 13: 

788 self.state = 148 

789 self.forexpr() 

790 pass 

791 

792 elif la_ == 14: 

793 self.state = 149 

794 self.whileexpr() 

795 pass 

796 

797 elif la_ == 15: 

798 self.state = 150 

799 self.repeatexpr() 

800 pass 

801 

802 elif la_ == 16: 

803 self.state = 151 

804 self.match(RParser.T__13) 

805 self.state = 152 

806 self.expr(7) 

807 pass 

808 

809 elif la_ == 17: 

810 self.state = 153 

811 self.implicit_column_name() 

812 pass 

813 

814 elif la_ == 18: 

815 self.state = 154 

816 self.nextexpr() 

817 pass 

818 

819 elif la_ == 19: 

820 self.state = 155 

821 self.match(RParser.T__14) 

822 pass 

823 

824 elif la_ == 20: 

825 self.state = 156 

826 self.match(RParser.T__15) 

827 self.state = 160 

828 self._errHandler.sync(self) 

829 _alt = self._interp.adaptivePredict(self._input, 6, self._ctx) 

830 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

831 if _alt == 1: 

832 self.state = 157 

833 self.match(RParser.NL) 

834 self.state = 162 

835 self._errHandler.sync(self) 

836 _alt = self._interp.adaptivePredict( 

837 self._input, 6, self._ctx) 

838 

839 self.state = 163 

840 self.expr(0) 

841 self.state = 167 

842 self._errHandler.sync(self) 

843 _la = self._input.LA(1) 

844 while _la == RParser.NL: 

845 self.state = 164 

846 self.match(RParser.NL) 

847 self.state = 169 

848 self._errHandler.sync(self) 

849 _la = self._input.LA(1) 

850 

851 self.state = 170 

852 self.match(RParser.T__16) 

853 pass 

854 

855 elif la_ == 21: 

856 self.state = 172 

857 self.constant() 

858 pass 

859 

860 elif la_ == 22: 

861 self.state = 173 

862 self.identifier() 

863 pass 

864 

865 self._ctx.stop = self._input.LT(-1) 

866 self.state = 274 

867 self._errHandler.sync(self) 

868 _alt = self._interp.adaptivePredict(self._input, 20, self._ctx) 

869 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

870 if _alt == 1: 

871 if self._parseListeners is not None: 

872 self.triggerExitRuleEvent() 

873 _prevctx = localctx 

874 self.state = 272 

875 self._errHandler.sync(self) 

876 la_ = self._interp.adaptivePredict( 

877 self._input, 19, self._ctx) 

878 if la_ == 1: 

879 localctx = RParser.ExprContext( 

880 self, _parentctx, _parentState) 

881 self.pushNewRecursionContext( 

882 localctx, _startState, self.RULE_expr) 

883 self.state = 176 

884 if not self.precpred(self._ctx, 28): 

885 from antlr4.error.Errors import FailedPredicateException 

886 raise FailedPredicateException( 

887 self, "self.precpred(self._ctx, 28)") 

888 self.state = 177 

889 self.dotop() 

890 self.state = 178 

891 self.expr(29) 

892 pass 

893 

894 elif la_ == 2: 

895 localctx = RParser.ExprContext( 

896 self, _parentctx, _parentState) 

897 self.pushNewRecursionContext( 

898 localctx, _startState, self.RULE_expr) 

899 self.state = 180 

900 if not self.precpred(self._ctx, 24): 

901 from antlr4.error.Errors import FailedPredicateException 

902 raise FailedPredicateException( 

903 self, "self.precpred(self._ctx, 24)") 

904 self.state = 184 

905 self._errHandler.sync(self) 

906 _la = self._input.LA(1) 

907 while _la == RParser.NL: 

908 self.state = 181 

909 self.match(RParser.NL) 

910 self.state = 186 

911 self._errHandler.sync(self) 

912 _la = self._input.LA(1) 

913 

914 self.state = 187 

915 self.match(RParser.USER_OP) 

916 self.state = 191 

917 self._errHandler.sync(self) 

918 _alt = self._interp.adaptivePredict( 

919 self._input, 10, self._ctx) 

920 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

921 if _alt == 1: 

922 self.state = 188 

923 self.match(RParser.NL) 

924 self.state = 193 

925 self._errHandler.sync(self) 

926 _alt = self._interp.adaptivePredict( 

927 self._input, 10, self._ctx) 

928 

929 self.state = 194 

930 self.expr(24) 

931 pass 

932 

933 elif la_ == 3: 

934 localctx = RParser.ExprContext( 

935 self, _parentctx, _parentState) 

936 self.pushNewRecursionContext( 

937 localctx, _startState, self.RULE_expr) 

938 self.state = 195 

939 if not self.precpred(self._ctx, 23): 

940 from antlr4.error.Errors import FailedPredicateException 

941 raise FailedPredicateException( 

942 self, "self.precpred(self._ctx, 23)") 

943 self.state = 199 

944 self._errHandler.sync(self) 

945 _la = self._input.LA(1) 

946 while _la == RParser.NL: 

947 self.state = 196 

948 self.match(RParser.NL) 

949 self.state = 201 

950 self._errHandler.sync(self) 

951 _la = self._input.LA(1) 

952 

953 self.state = 202 

954 self.operator() 

955 self.state = 206 

956 self._errHandler.sync(self) 

957 _alt = self._interp.adaptivePredict( 

958 self._input, 12, self._ctx) 

959 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

960 if _alt == 1: 

961 self.state = 203 

962 self.match(RParser.NL) 

963 self.state = 208 

964 self._errHandler.sync(self) 

965 _alt = self._interp.adaptivePredict( 

966 self._input, 12, self._ctx) 

967 

968 self.state = 209 

969 self.expr(23) 

970 pass 

971 

972 elif la_ == 4: 

973 localctx = RParser.ExprContext( 

974 self, _parentctx, _parentState) 

975 self.pushNewRecursionContext( 

976 localctx, _startState, self.RULE_expr) 

977 self.state = 211 

978 if not self.precpred(self._ctx, 22): 

979 from antlr4.error.Errors import FailedPredicateException 

980 raise FailedPredicateException( 

981 self, "self.precpred(self._ctx, 22)") 

982 self.state = 215 

983 self._errHandler.sync(self) 

984 _la = self._input.LA(1) 

985 while _la == RParser.NL: 

986 self.state = 212 

987 self.match(RParser.NL) 

988 self.state = 217 

989 self._errHandler.sync(self) 

990 _la = self._input.LA(1) 

991 

992 self.state = 218 

993 self.comparison() 

994 self.state = 222 

995 self._errHandler.sync(self) 

996 _alt = self._interp.adaptivePredict( 

997 self._input, 14, self._ctx) 

998 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

999 if _alt == 1: 

1000 self.state = 219 

1001 self.match(RParser.NL) 

1002 self.state = 224 

1003 self._errHandler.sync(self) 

1004 _alt = self._interp.adaptivePredict( 

1005 self._input, 14, self._ctx) 

1006 

1007 self.state = 225 

1008 self.expr(22) 

1009 pass 

1010 

1011 elif la_ == 5: 

1012 localctx = RParser.ExprContext( 

1013 self, _parentctx, _parentState) 

1014 self.pushNewRecursionContext( 

1015 localctx, _startState, self.RULE_expr) 

1016 self.state = 227 

1017 if not self.precpred(self._ctx, 20): 

1018 from antlr4.error.Errors import FailedPredicateException 

1019 raise FailedPredicateException( 

1020 self, "self.precpred(self._ctx, 20)") 

1021 self.state = 231 

1022 self._errHandler.sync(self) 

1023 _la = self._input.LA(1) 

1024 while _la == RParser.NL: 

1025 self.state = 228 

1026 self.match(RParser.NL) 

1027 self.state = 233 

1028 self._errHandler.sync(self) 

1029 _la = self._input.LA(1) 

1030 

1031 self.state = 234 

1032 _la = self._input.LA(1) 

1033 if not (_la == RParser.T__7 or _la == RParser.T__8): 

1034 self._errHandler.recoverInline(self) 

1035 else: 

1036 self._errHandler.reportMatch(self) 

1037 self.consume() 

1038 self.state = 238 

1039 self._errHandler.sync(self) 

1040 _alt = self._interp.adaptivePredict( 

1041 self._input, 16, self._ctx) 

1042 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1043 if _alt == 1: 

1044 self.state = 235 

1045 self.match(RParser.NL) 

1046 self.state = 240 

1047 self._errHandler.sync(self) 

1048 _alt = self._interp.adaptivePredict( 

1049 self._input, 16, self._ctx) 

1050 

1051 self.state = 241 

1052 self.expr(21) 

1053 pass 

1054 

1055 elif la_ == 6: 

1056 localctx = RParser.ExprContext( 

1057 self, _parentctx, _parentState) 

1058 self.pushNewRecursionContext( 

1059 localctx, _startState, self.RULE_expr) 

1060 self.state = 242 

1061 if not self.precpred(self._ctx, 19): 

1062 from antlr4.error.Errors import FailedPredicateException 

1063 raise FailedPredicateException( 

1064 self, "self.precpred(self._ctx, 19)") 

1065 self.state = 246 

1066 self._errHandler.sync(self) 

1067 _la = self._input.LA(1) 

1068 while _la == RParser.NL: 

1069 self.state = 243 

1070 self.match(RParser.NL) 

1071 self.state = 248 

1072 self._errHandler.sync(self) 

1073 _la = self._input.LA(1) 

1074 

1075 self.state = 249 

1076 _la = self._input.LA(1) 

1077 if not (_la == RParser.T__9 or _la == RParser.T__10): 

1078 self._errHandler.recoverInline(self) 

1079 else: 

1080 self._errHandler.reportMatch(self) 

1081 self.consume() 

1082 self.state = 253 

1083 self._errHandler.sync(self) 

1084 _alt = self._interp.adaptivePredict( 

1085 self._input, 18, self._ctx) 

1086 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1087 if _alt == 1: 

1088 self.state = 250 

1089 self.match(RParser.NL) 

1090 self.state = 255 

1091 self._errHandler.sync(self) 

1092 _alt = self._interp.adaptivePredict( 

1093 self._input, 18, self._ctx) 

1094 

1095 self.state = 256 

1096 self.expr(20) 

1097 pass 

1098 

1099 elif la_ == 7: 

1100 localctx = RParser.ExprContext( 

1101 self, _parentctx, _parentState) 

1102 self.pushNewRecursionContext( 

1103 localctx, _startState, self.RULE_expr) 

1104 self.state = 257 

1105 if not self.precpred(self._ctx, 30): 

1106 from antlr4.error.Errors import FailedPredicateException 

1107 raise FailedPredicateException( 

1108 self, "self.precpred(self._ctx, 30)") 

1109 self.state = 258 

1110 self.match(RParser.T__1) 

1111 self.state = 259 

1112 self.sublist() 

1113 self.state = 260 

1114 self.match(RParser.T__2) 

1115 self.state = 261 

1116 self.match(RParser.T__2) 

1117 pass 

1118 

1119 elif la_ == 8: 

1120 localctx = RParser.ExprContext( 

1121 self, _parentctx, _parentState) 

1122 self.pushNewRecursionContext( 

1123 localctx, _startState, self.RULE_expr) 

1124 self.state = 263 

1125 if not self.precpred(self._ctx, 29): 

1126 from antlr4.error.Errors import FailedPredicateException 

1127 raise FailedPredicateException( 

1128 self, "self.precpred(self._ctx, 29)") 

1129 self.state = 264 

1130 self.match(RParser.T__3) 

1131 self.state = 265 

1132 self.sublist() 

1133 self.state = 266 

1134 self.match(RParser.T__2) 

1135 pass 

1136 

1137 elif la_ == 9: 

1138 localctx = RParser.ExprContext( 

1139 self, _parentctx, _parentState) 

1140 self.pushNewRecursionContext( 

1141 localctx, _startState, self.RULE_expr) 

1142 self.state = 268 

1143 if not self.precpred(self._ctx, 26): 

1144 from antlr4.error.Errors import FailedPredicateException 

1145 raise FailedPredicateException( 

1146 self, "self.precpred(self._ctx, 26)") 

1147 self.state = 269 

1148 self.affectation() 

1149 pass 

1150 

1151 elif la_ == 10: 

1152 localctx = RParser.ExprContext( 

1153 self, _parentctx, _parentState) 

1154 self.pushNewRecursionContext( 

1155 localctx, _startState, self.RULE_expr) 

1156 self.state = 270 

1157 if not self.precpred(self._ctx, 25): 

1158 from antlr4.error.Errors import FailedPredicateException 

1159 raise FailedPredicateException( 

1160 self, "self.precpred(self._ctx, 25)") 

1161 self.state = 271 

1162 self.rangeopexpr() 

1163 pass 

1164 

1165 self.state = 276 

1166 self._errHandler.sync(self) 

1167 _alt = self._interp.adaptivePredict(self._input, 20, self._ctx) 

1168 

1169 except RecognitionException as re: 

1170 localctx.exception = re 

1171 self._errHandler.reportError(self, re) 

1172 self._errHandler.recover(self, re) 

1173 finally: 

1174 self.unrollRecursionContexts(_parentctx) 

1175 return localctx 

1176 

1177 class FunctiondefbodyContext(ParserRuleContext): 

1178 __slots__ = 'parser' 

1179 

1180 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1181 super().__init__(parent, invokingState) 

1182 self.parser = parser 

1183 

1184 def functiondefargs(self): 

1185 return self.getTypedRuleContext(RParser.FunctiondefargsContext, 0) 

1186 

1187 def exprlist(self): 

1188 return self.getTypedRuleContext(RParser.ExprlistContext, 0) 

1189 

1190 def NL(self, i: int = None): 

1191 if i is None: 

1192 return self.getTokens(RParser.NL) 

1193 else: 

1194 return self.getToken(RParser.NL, i) 

1195 

1196 def getRuleIndex(self): 

1197 return RParser.RULE_functiondefbody 

1198 

1199 def enterRule(self, listener: ParseTreeListener): 

1200 if hasattr(listener, "enterFunctiondefbody"): 

1201 listener.enterFunctiondefbody(self) 

1202 

1203 def exitRule(self, listener: ParseTreeListener): 

1204 if hasattr(listener, "exitFunctiondefbody"): 

1205 listener.exitFunctiondefbody(self) 

1206 

1207 def functiondefbody(self): 

1208 

1209 localctx = RParser.FunctiondefbodyContext(self, self._ctx, self.state) 

1210 self.enterRule(localctx, 4, self.RULE_functiondefbody) 

1211 self._la = 0 # Token type 

1212 try: 

1213 self.enterOuterAlt(localctx, 1) 

1214 self.state = 277 

1215 self.functiondefargs() 

1216 self.state = 281 

1217 self._errHandler.sync(self) 

1218 _la = self._input.LA(1) 

1219 while _la == RParser.NL: 

1220 self.state = 278 

1221 self.match(RParser.NL) 

1222 self.state = 283 

1223 self._errHandler.sync(self) 

1224 _la = self._input.LA(1) 

1225 

1226 self.state = 284 

1227 self.match(RParser.T__11) 

1228 self.state = 288 

1229 self._errHandler.sync(self) 

1230 _alt = self._interp.adaptivePredict(self._input, 22, self._ctx) 

1231 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1232 if _alt == 1: 

1233 self.state = 285 

1234 self.match(RParser.NL) 

1235 self.state = 290 

1236 self._errHandler.sync(self) 

1237 _alt = self._interp.adaptivePredict(self._input, 22, self._ctx) 

1238 

1239 self.state = 291 

1240 self.exprlist() 

1241 self.state = 295 

1242 self._errHandler.sync(self) 

1243 _la = self._input.LA(1) 

1244 while _la == RParser.NL: 

1245 self.state = 292 

1246 self.match(RParser.NL) 

1247 self.state = 297 

1248 self._errHandler.sync(self) 

1249 _la = self._input.LA(1) 

1250 

1251 self.state = 298 

1252 self.match(RParser.T__12) 

1253 except RecognitionException as re: 

1254 localctx.exception = re 

1255 self._errHandler.reportError(self, re) 

1256 self._errHandler.recover(self, re) 

1257 finally: 

1258 self.exitRule() 

1259 return localctx 

1260 

1261 class FunctiondeflambdaContext(ParserRuleContext): 

1262 __slots__ = 'parser' 

1263 

1264 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1265 super().__init__(parent, invokingState) 

1266 self.parser = parser 

1267 

1268 def functiondefargslambda(self): 

1269 return self.getTypedRuleContext(RParser.FunctiondefargslambdaContext, 0) 

1270 

1271 def expr(self): 

1272 return self.getTypedRuleContext(RParser.ExprContext, 0) 

1273 

1274 def getRuleIndex(self): 

1275 return RParser.RULE_functiondeflambda 

1276 

1277 def enterRule(self, listener: ParseTreeListener): 

1278 if hasattr(listener, "enterFunctiondeflambda"): 

1279 listener.enterFunctiondeflambda(self) 

1280 

1281 def exitRule(self, listener: ParseTreeListener): 

1282 if hasattr(listener, "exitFunctiondeflambda"): 

1283 listener.exitFunctiondeflambda(self) 

1284 

1285 def functiondeflambda(self): 

1286 

1287 localctx = RParser.FunctiondeflambdaContext( 

1288 self, self._ctx, self.state) 

1289 self.enterRule(localctx, 6, self.RULE_functiondeflambda) 

1290 try: 

1291 self.enterOuterAlt(localctx, 1) 

1292 self.state = 300 

1293 self.functiondefargslambda() 

1294 self.state = 301 

1295 self.expr(0) 

1296 except RecognitionException as re: 

1297 localctx.exception = re 

1298 self._errHandler.reportError(self, re) 

1299 self._errHandler.recover(self, re) 

1300 finally: 

1301 self.exitRule() 

1302 return localctx 

1303 

1304 class FunctiondefargslambdaContext(ParserRuleContext): 

1305 __slots__ = 'parser' 

1306 

1307 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1308 super().__init__(parent, invokingState) 

1309 self.parser = parser 

1310 

1311 def functiondef(self): 

1312 return self.getTypedRuleContext(RParser.FunctiondefContext, 0) 

1313 

1314 def NL(self, i: int = None): 

1315 if i is None: 

1316 return self.getTokens(RParser.NL) 

1317 else: 

1318 return self.getToken(RParser.NL, i) 

1319 

1320 def formlist(self): 

1321 return self.getTypedRuleContext(RParser.FormlistContext, 0) 

1322 

1323 def getRuleIndex(self): 

1324 return RParser.RULE_functiondefargslambda 

1325 

1326 def enterRule(self, listener: ParseTreeListener): 

1327 if hasattr(listener, "enterFunctiondefargslambda"): 

1328 listener.enterFunctiondefargslambda(self) 

1329 

1330 def exitRule(self, listener: ParseTreeListener): 

1331 if hasattr(listener, "exitFunctiondefargslambda"): 

1332 listener.exitFunctiondefargslambda(self) 

1333 

1334 def functiondefargslambda(self): 

1335 

1336 localctx = RParser.FunctiondefargslambdaContext( 

1337 self, self._ctx, self.state) 

1338 self.enterRule(localctx, 8, self.RULE_functiondefargslambda) 

1339 self._la = 0 # Token type 

1340 try: 

1341 self.enterOuterAlt(localctx, 1) 

1342 self.state = 303 

1343 self.functiondef() 

1344 self.state = 304 

1345 self.match(RParser.T__15) 

1346 self.state = 308 

1347 self._errHandler.sync(self) 

1348 _alt = self._interp.adaptivePredict(self._input, 24, self._ctx) 

1349 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1350 if _alt == 1: 

1351 self.state = 305 

1352 self.match(RParser.NL) 

1353 self.state = 310 

1354 self._errHandler.sync(self) 

1355 _alt = self._interp.adaptivePredict(self._input, 24, self._ctx) 

1356 

1357 self.state = 312 

1358 self._errHandler.sync(self) 

1359 _la = self._input.LA(1) 

1360 if _la == RParser.T__20 or _la == RParser.ID: 

1361 self.state = 311 

1362 self.formlist() 

1363 

1364 self.state = 317 

1365 self._errHandler.sync(self) 

1366 _la = self._input.LA(1) 

1367 while _la == RParser.NL: 

1368 self.state = 314 

1369 self.match(RParser.NL) 

1370 self.state = 319 

1371 self._errHandler.sync(self) 

1372 _la = self._input.LA(1) 

1373 

1374 self.state = 320 

1375 self.match(RParser.T__16) 

1376 except RecognitionException as re: 

1377 localctx.exception = re 

1378 self._errHandler.reportError(self, re) 

1379 self._errHandler.recover(self, re) 

1380 finally: 

1381 self.exitRule() 

1382 return localctx 

1383 

1384 class FunctiondefargsContext(ParserRuleContext): 

1385 __slots__ = 'parser' 

1386 

1387 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1388 super().__init__(parent, invokingState) 

1389 self.parser = parser 

1390 

1391 def functiondef(self): 

1392 return self.getTypedRuleContext(RParser.FunctiondefContext, 0) 

1393 

1394 def NL(self, i: int = None): 

1395 if i is None: 

1396 return self.getTokens(RParser.NL) 

1397 else: 

1398 return self.getToken(RParser.NL, i) 

1399 

1400 def formlist(self): 

1401 return self.getTypedRuleContext(RParser.FormlistContext, 0) 

1402 

1403 def getRuleIndex(self): 

1404 return RParser.RULE_functiondefargs 

1405 

1406 def enterRule(self, listener: ParseTreeListener): 

1407 if hasattr(listener, "enterFunctiondefargs"): 

1408 listener.enterFunctiondefargs(self) 

1409 

1410 def exitRule(self, listener: ParseTreeListener): 

1411 if hasattr(listener, "exitFunctiondefargs"): 

1412 listener.exitFunctiondefargs(self) 

1413 

1414 def functiondefargs(self): 

1415 

1416 localctx = RParser.FunctiondefargsContext(self, self._ctx, self.state) 

1417 self.enterRule(localctx, 10, self.RULE_functiondefargs) 

1418 self._la = 0 # Token type 

1419 try: 

1420 self.enterOuterAlt(localctx, 1) 

1421 self.state = 322 

1422 self.functiondef() 

1423 self.state = 323 

1424 self.match(RParser.T__15) 

1425 self.state = 327 

1426 self._errHandler.sync(self) 

1427 _alt = self._interp.adaptivePredict(self._input, 27, self._ctx) 

1428 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1429 if _alt == 1: 

1430 self.state = 324 

1431 self.match(RParser.NL) 

1432 self.state = 329 

1433 self._errHandler.sync(self) 

1434 _alt = self._interp.adaptivePredict(self._input, 27, self._ctx) 

1435 

1436 self.state = 331 

1437 self._errHandler.sync(self) 

1438 _la = self._input.LA(1) 

1439 if _la == RParser.T__20 or _la == RParser.ID: 

1440 self.state = 330 

1441 self.formlist() 

1442 

1443 self.state = 336 

1444 self._errHandler.sync(self) 

1445 _la = self._input.LA(1) 

1446 while _la == RParser.NL: 

1447 self.state = 333 

1448 self.match(RParser.NL) 

1449 self.state = 338 

1450 self._errHandler.sync(self) 

1451 _la = self._input.LA(1) 

1452 

1453 self.state = 339 

1454 self.match(RParser.T__16) 

1455 except RecognitionException as re: 

1456 localctx.exception = re 

1457 self._errHandler.reportError(self, re) 

1458 self._errHandler.recover(self, re) 

1459 finally: 

1460 self.exitRule() 

1461 return localctx 

1462 

1463 class Implicit_column_nameContext(ParserRuleContext): 

1464 __slots__ = 'parser' 

1465 

1466 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1467 super().__init__(parent, invokingState) 

1468 self.parser = parser 

1469 

1470 def identifier(self): 

1471 return self.getTypedRuleContext(RParser.IdentifierContext, 0) 

1472 

1473 def getRuleIndex(self): 

1474 return RParser.RULE_implicit_column_name 

1475 

1476 def enterRule(self, listener: ParseTreeListener): 

1477 if hasattr(listener, "enterImplicit_column_name"): 

1478 listener.enterImplicit_column_name(self) 

1479 

1480 def exitRule(self, listener: ParseTreeListener): 

1481 if hasattr(listener, "exitImplicit_column_name"): 

1482 listener.exitImplicit_column_name(self) 

1483 

1484 def implicit_column_name(self): 

1485 

1486 localctx = RParser.Implicit_column_nameContext( 

1487 self, self._ctx, self.state) 

1488 self.enterRule(localctx, 12, self.RULE_implicit_column_name) 

1489 try: 

1490 self.enterOuterAlt(localctx, 1) 

1491 self.state = 341 

1492 self.match(RParser.T__17) 

1493 self.state = 342 

1494 self.match(RParser.T__15) 

1495 self.state = 343 

1496 self.identifier() 

1497 self.state = 344 

1498 self.match(RParser.T__16) 

1499 except RecognitionException as re: 

1500 localctx.exception = re 

1501 self._errHandler.reportError(self, re) 

1502 self._errHandler.recover(self, re) 

1503 finally: 

1504 self.exitRule() 

1505 return localctx 

1506 

1507 class AffectationContext(ParserRuleContext): 

1508 __slots__ = 'parser' 

1509 

1510 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1511 super().__init__(parent, invokingState) 

1512 self.parser = parser 

1513 

1514 def affectop(self): 

1515 return self.getTypedRuleContext(RParser.AffectopContext, 0) 

1516 

1517 def expr(self): 

1518 return self.getTypedRuleContext(RParser.ExprContext, 0) 

1519 

1520 def NL(self): 

1521 return self.getToken(RParser.NL, 0) 

1522 

1523 def getRuleIndex(self): 

1524 return RParser.RULE_affectation 

1525 

1526 def enterRule(self, listener: ParseTreeListener): 

1527 if hasattr(listener, "enterAffectation"): 

1528 listener.enterAffectation(self) 

1529 

1530 def exitRule(self, listener: ParseTreeListener): 

1531 if hasattr(listener, "exitAffectation"): 

1532 listener.exitAffectation(self) 

1533 

1534 def affectation(self): 

1535 

1536 localctx = RParser.AffectationContext(self, self._ctx, self.state) 

1537 self.enterRule(localctx, 14, self.RULE_affectation) 

1538 try: 

1539 self.enterOuterAlt(localctx, 1) 

1540 self.state = 346 

1541 self.affectop() 

1542 self.state = 348 

1543 self._errHandler.sync(self) 

1544 la_ = self._interp.adaptivePredict(self._input, 30, self._ctx) 

1545 if la_ == 1: 

1546 self.state = 347 

1547 self.match(RParser.NL) 

1548 

1549 self.state = 350 

1550 self.expr(0) 

1551 except RecognitionException as re: 

1552 localctx.exception = re 

1553 self._errHandler.reportError(self, re) 

1554 self._errHandler.recover(self, re) 

1555 finally: 

1556 self.exitRule() 

1557 return localctx 

1558 

1559 class RangeopexprContext(ParserRuleContext): 

1560 __slots__ = 'parser' 

1561 

1562 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1563 super().__init__(parent, invokingState) 

1564 self.parser = parser 

1565 

1566 def rangeop(self): 

1567 return self.getTypedRuleContext(RParser.RangeopContext, 0) 

1568 

1569 def expr(self): 

1570 return self.getTypedRuleContext(RParser.ExprContext, 0) 

1571 

1572 def getRuleIndex(self): 

1573 return RParser.RULE_rangeopexpr 

1574 

1575 def enterRule(self, listener: ParseTreeListener): 

1576 if hasattr(listener, "enterRangeopexpr"): 

1577 listener.enterRangeopexpr(self) 

1578 

1579 def exitRule(self, listener: ParseTreeListener): 

1580 if hasattr(listener, "exitRangeopexpr"): 

1581 listener.exitRangeopexpr(self) 

1582 

1583 def rangeopexpr(self): 

1584 

1585 localctx = RParser.RangeopexprContext(self, self._ctx, self.state) 

1586 self.enterRule(localctx, 16, self.RULE_rangeopexpr) 

1587 try: 

1588 self.enterOuterAlt(localctx, 1) 

1589 self.state = 352 

1590 self.rangeop() 

1591 self.state = 353 

1592 self.expr(0) 

1593 except RecognitionException as re: 

1594 localctx.exception = re 

1595 self._errHandler.reportError(self, re) 

1596 self._errHandler.recover(self, re) 

1597 finally: 

1598 self.exitRule() 

1599 return localctx 

1600 

1601 class ExprlistContext(ParserRuleContext): 

1602 __slots__ = 'parser' 

1603 

1604 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1605 super().__init__(parent, invokingState) 

1606 self.parser = parser 

1607 

1608 def expr(self): 

1609 return self.getTypedRuleContext(RParser.ExprContext, 0) 

1610 

1611 def rightexpr(self, i: int = None): 

1612 if i is None: 

1613 return self.getTypedRuleContexts(RParser.RightexprContext) 

1614 else: 

1615 return self.getTypedRuleContext(RParser.RightexprContext, i) 

1616 

1617 def getRuleIndex(self): 

1618 return RParser.RULE_exprlist 

1619 

1620 def enterRule(self, listener: ParseTreeListener): 

1621 if hasattr(listener, "enterExprlist"): 

1622 listener.enterExprlist(self) 

1623 

1624 def exitRule(self, listener: ParseTreeListener): 

1625 if hasattr(listener, "exitExprlist"): 

1626 listener.exitExprlist(self) 

1627 

1628 def exprlist(self): 

1629 

1630 localctx = RParser.ExprlistContext(self, self._ctx, self.state) 

1631 self.enterRule(localctx, 18, self.RULE_exprlist) 

1632 try: 

1633 self.enterOuterAlt(localctx, 1) 

1634 self.state = 355 

1635 self.expr(0) 

1636 self.state = 359 

1637 self._errHandler.sync(self) 

1638 _alt = self._interp.adaptivePredict(self._input, 31, self._ctx) 

1639 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1640 if _alt == 1: 

1641 self.state = 356 

1642 self.rightexpr() 

1643 self.state = 361 

1644 self._errHandler.sync(self) 

1645 _alt = self._interp.adaptivePredict(self._input, 31, self._ctx) 

1646 

1647 except RecognitionException as re: 

1648 localctx.exception = re 

1649 self._errHandler.reportError(self, re) 

1650 self._errHandler.recover(self, re) 

1651 finally: 

1652 self.exitRule() 

1653 return localctx 

1654 

1655 class RightexprContext(ParserRuleContext): 

1656 __slots__ = 'parser' 

1657 

1658 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1659 super().__init__(parent, invokingState) 

1660 self.parser = parser 

1661 

1662 def NL(self): 

1663 return self.getToken(RParser.NL, 0) 

1664 

1665 def expr(self): 

1666 return self.getTypedRuleContext(RParser.ExprContext, 0) 

1667 

1668 def getRuleIndex(self): 

1669 return RParser.RULE_rightexpr 

1670 

1671 def enterRule(self, listener: ParseTreeListener): 

1672 if hasattr(listener, "enterRightexpr"): 

1673 listener.enterRightexpr(self) 

1674 

1675 def exitRule(self, listener: ParseTreeListener): 

1676 if hasattr(listener, "exitRightexpr"): 

1677 listener.exitRightexpr(self) 

1678 

1679 def rightexpr(self): 

1680 

1681 localctx = RParser.RightexprContext(self, self._ctx, self.state) 

1682 self.enterRule(localctx, 20, self.RULE_rightexpr) 

1683 self._la = 0 # Token type 

1684 try: 

1685 self.enterOuterAlt(localctx, 1) 

1686 self.state = 362 

1687 _la = self._input.LA(1) 

1688 if not (_la == RParser.T__0 or _la == RParser.NL): 

1689 self._errHandler.recoverInline(self) 

1690 else: 

1691 self._errHandler.reportMatch(self) 

1692 self.consume() 

1693 self.state = 364 

1694 self._errHandler.sync(self) 

1695 la_ = self._interp.adaptivePredict(self._input, 32, self._ctx) 

1696 if la_ == 1: 

1697 self.state = 363 

1698 self.expr(0) 

1699 

1700 except RecognitionException as re: 

1701 localctx.exception = re 

1702 self._errHandler.reportError(self, re) 

1703 self._errHandler.recover(self, re) 

1704 finally: 

1705 self.exitRule() 

1706 return localctx 

1707 

1708 class FormlistContext(ParserRuleContext): 

1709 __slots__ = 'parser' 

1710 

1711 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1712 super().__init__(parent, invokingState) 

1713 self.parser = parser 

1714 

1715 def form(self, i: int = None): 

1716 if i is None: 

1717 return self.getTypedRuleContexts(RParser.FormContext) 

1718 else: 

1719 return self.getTypedRuleContext(RParser.FormContext, i) 

1720 

1721 def NL(self, i: int = None): 

1722 if i is None: 

1723 return self.getTokens(RParser.NL) 

1724 else: 

1725 return self.getToken(RParser.NL, i) 

1726 

1727 def getRuleIndex(self): 

1728 return RParser.RULE_formlist 

1729 

1730 def enterRule(self, listener: ParseTreeListener): 

1731 if hasattr(listener, "enterFormlist"): 

1732 listener.enterFormlist(self) 

1733 

1734 def exitRule(self, listener: ParseTreeListener): 

1735 if hasattr(listener, "exitFormlist"): 

1736 listener.exitFormlist(self) 

1737 

1738 def formlist(self): 

1739 

1740 localctx = RParser.FormlistContext(self, self._ctx, self.state) 

1741 self.enterRule(localctx, 22, self.RULE_formlist) 

1742 self._la = 0 # Token type 

1743 try: 

1744 self.enterOuterAlt(localctx, 1) 

1745 self.state = 366 

1746 self.form() 

1747 self.state = 380 

1748 self._errHandler.sync(self) 

1749 _alt = self._interp.adaptivePredict(self._input, 35, self._ctx) 

1750 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1751 if _alt == 1: 

1752 self.state = 368 

1753 self._errHandler.sync(self) 

1754 _la = self._input.LA(1) 

1755 if _la == RParser.NL: 

1756 self.state = 367 

1757 self.match(RParser.NL) 

1758 

1759 self.state = 370 

1760 self.match(RParser.T__18) 

1761 self.state = 374 

1762 self._errHandler.sync(self) 

1763 _la = self._input.LA(1) 

1764 while _la == RParser.NL: 

1765 self.state = 371 

1766 self.match(RParser.NL) 

1767 self.state = 376 

1768 self._errHandler.sync(self) 

1769 _la = self._input.LA(1) 

1770 

1771 self.state = 377 

1772 self.form() 

1773 self.state = 382 

1774 self._errHandler.sync(self) 

1775 _alt = self._interp.adaptivePredict(self._input, 35, self._ctx) 

1776 

1777 except RecognitionException as re: 

1778 localctx.exception = re 

1779 self._errHandler.reportError(self, re) 

1780 self._errHandler.recover(self, re) 

1781 finally: 

1782 self.exitRule() 

1783 return localctx 

1784 

1785 class FormContext(ParserRuleContext): 

1786 __slots__ = 'parser' 

1787 

1788 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1789 super().__init__(parent, invokingState) 

1790 self.parser = parser 

1791 

1792 def argumentname(self): 

1793 return self.getTypedRuleContext(RParser.ArgumentnameContext, 0) 

1794 

1795 def expr(self): 

1796 return self.getTypedRuleContext(RParser.ExprContext, 0) 

1797 

1798 def getRuleIndex(self): 

1799 return RParser.RULE_form 

1800 

1801 def enterRule(self, listener: ParseTreeListener): 

1802 if hasattr(listener, "enterForm"): 

1803 listener.enterForm(self) 

1804 

1805 def exitRule(self, listener: ParseTreeListener): 

1806 if hasattr(listener, "exitForm"): 

1807 listener.exitForm(self) 

1808 

1809 def form(self): 

1810 

1811 localctx = RParser.FormContext(self, self._ctx, self.state) 

1812 self.enterRule(localctx, 24, self.RULE_form) 

1813 try: 

1814 self.state = 389 

1815 self._errHandler.sync(self) 

1816 la_ = self._interp.adaptivePredict(self._input, 36, self._ctx) 

1817 if la_ == 1: 

1818 self.enterOuterAlt(localctx, 1) 

1819 self.state = 383 

1820 self.argumentname() 

1821 pass 

1822 

1823 elif la_ == 2: 

1824 self.enterOuterAlt(localctx, 2) 

1825 self.state = 384 

1826 self.argumentname() 

1827 self.state = 385 

1828 self.match(RParser.T__19) 

1829 self.state = 386 

1830 self.expr(0) 

1831 pass 

1832 

1833 elif la_ == 3: 

1834 self.enterOuterAlt(localctx, 3) 

1835 self.state = 388 

1836 self.match(RParser.T__20) 

1837 pass 

1838 

1839 except RecognitionException as re: 

1840 localctx.exception = re 

1841 self._errHandler.reportError(self, re) 

1842 self._errHandler.recover(self, re) 

1843 finally: 

1844 self.exitRule() 

1845 return localctx 

1846 

1847 class ArgumentnameContext(ParserRuleContext): 

1848 __slots__ = 'parser' 

1849 

1850 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1851 super().__init__(parent, invokingState) 

1852 self.parser = parser 

1853 

1854 def ID(self): 

1855 return self.getToken(RParser.ID, 0) 

1856 

1857 def getRuleIndex(self): 

1858 return RParser.RULE_argumentname 

1859 

1860 def enterRule(self, listener: ParseTreeListener): 

1861 if hasattr(listener, "enterArgumentname"): 

1862 listener.enterArgumentname(self) 

1863 

1864 def exitRule(self, listener: ParseTreeListener): 

1865 if hasattr(listener, "exitArgumentname"): 

1866 listener.exitArgumentname(self) 

1867 

1868 def argumentname(self): 

1869 

1870 localctx = RParser.ArgumentnameContext(self, self._ctx, self.state) 

1871 self.enterRule(localctx, 26, self.RULE_argumentname) 

1872 try: 

1873 self.enterOuterAlt(localctx, 1) 

1874 self.state = 391 

1875 self.match(RParser.ID) 

1876 except RecognitionException as re: 

1877 localctx.exception = re 

1878 self._errHandler.reportError(self, re) 

1879 self._errHandler.recover(self, re) 

1880 finally: 

1881 self.exitRule() 

1882 return localctx 

1883 

1884 class SublistContext(ParserRuleContext): 

1885 __slots__ = 'parser' 

1886 

1887 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

1888 super().__init__(parent, invokingState) 

1889 self.parser = parser 

1890 

1891 def sub(self, i: int = None): 

1892 if i is None: 

1893 return self.getTypedRuleContexts(RParser.SubContext) 

1894 else: 

1895 return self.getTypedRuleContext(RParser.SubContext, i) 

1896 

1897 def inlinefunction(self, i: int = None): 

1898 if i is None: 

1899 return self.getTypedRuleContexts(RParser.InlinefunctionContext) 

1900 else: 

1901 return self.getTypedRuleContext(RParser.InlinefunctionContext, i) 

1902 

1903 def NL(self, i: int = None): 

1904 if i is None: 

1905 return self.getTokens(RParser.NL) 

1906 else: 

1907 return self.getToken(RParser.NL, i) 

1908 

1909 def getRuleIndex(self): 

1910 return RParser.RULE_sublist 

1911 

1912 def enterRule(self, listener: ParseTreeListener): 

1913 if hasattr(listener, "enterSublist"): 

1914 listener.enterSublist(self) 

1915 

1916 def exitRule(self, listener: ParseTreeListener): 

1917 if hasattr(listener, "exitSublist"): 

1918 listener.exitSublist(self) 

1919 

1920 def sublist(self): 

1921 

1922 localctx = RParser.SublistContext(self, self._ctx, self.state) 

1923 self.enterRule(localctx, 28, self.RULE_sublist) 

1924 self._la = 0 # Token type 

1925 try: 

1926 self.enterOuterAlt(localctx, 1) 

1927 self.state = 393 

1928 self.sub() 

1929 self.state = 419 

1930 self._errHandler.sync(self) 

1931 _alt = self._interp.adaptivePredict(self._input, 41, self._ctx) 

1932 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1933 if _alt == 1: 

1934 self.state = 397 

1935 self._errHandler.sync(self) 

1936 _la = self._input.LA(1) 

1937 while _la == RParser.NL: 

1938 self.state = 394 

1939 self.match(RParser.NL) 

1940 self.state = 399 

1941 self._errHandler.sync(self) 

1942 _la = self._input.LA(1) 

1943 

1944 self.state = 400 

1945 self.match(RParser.T__18) 

1946 self.state = 404 

1947 self._errHandler.sync(self) 

1948 _alt = self._interp.adaptivePredict( 

1949 self._input, 38, self._ctx) 

1950 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1951 if _alt == 1: 

1952 self.state = 401 

1953 self.match(RParser.NL) 

1954 self.state = 406 

1955 self._errHandler.sync(self) 

1956 _alt = self._interp.adaptivePredict( 

1957 self._input, 38, self._ctx) 

1958 

1959 self.state = 409 

1960 self._errHandler.sync(self) 

1961 la_ = self._interp.adaptivePredict( 

1962 self._input, 39, self._ctx) 

1963 if la_ == 1: 

1964 self.state = 407 

1965 self.inlinefunction() 

1966 pass 

1967 

1968 elif la_ == 2: 

1969 self.state = 408 

1970 self.sub() 

1971 pass 

1972 

1973 self.state = 414 

1974 self._errHandler.sync(self) 

1975 _alt = self._interp.adaptivePredict( 

1976 self._input, 40, self._ctx) 

1977 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

1978 if _alt == 1: 

1979 self.state = 411 

1980 self.match(RParser.NL) 

1981 self.state = 416 

1982 self._errHandler.sync(self) 

1983 _alt = self._interp.adaptivePredict( 

1984 self._input, 40, self._ctx) 

1985 

1986 self.state = 421 

1987 self._errHandler.sync(self) 

1988 _alt = self._interp.adaptivePredict(self._input, 41, self._ctx) 

1989 

1990 except RecognitionException as re: 

1991 localctx.exception = re 

1992 self._errHandler.reportError(self, re) 

1993 self._errHandler.recover(self, re) 

1994 finally: 

1995 self.exitRule() 

1996 return localctx 

1997 

1998 class SublistaddContext(ParserRuleContext): 

1999 __slots__ = 'parser' 

2000 

2001 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2002 super().__init__(parent, invokingState) 

2003 self.parser = parser 

2004 

2005 def identifier(self, i: int = None): 

2006 if i is None: 

2007 return self.getTypedRuleContexts(RParser.IdentifierContext) 

2008 else: 

2009 return self.getTypedRuleContext(RParser.IdentifierContext, i) 

2010 

2011 def NL(self, i: int = None): 

2012 if i is None: 

2013 return self.getTokens(RParser.NL) 

2014 else: 

2015 return self.getToken(RParser.NL, i) 

2016 

2017 def getRuleIndex(self): 

2018 return RParser.RULE_sublistadd 

2019 

2020 def enterRule(self, listener: ParseTreeListener): 

2021 if hasattr(listener, "enterSublistadd"): 

2022 listener.enterSublistadd(self) 

2023 

2024 def exitRule(self, listener: ParseTreeListener): 

2025 if hasattr(listener, "exitSublistadd"): 

2026 listener.exitSublistadd(self) 

2027 

2028 def sublistadd(self): 

2029 

2030 localctx = RParser.SublistaddContext(self, self._ctx, self.state) 

2031 self.enterRule(localctx, 30, self.RULE_sublistadd) 

2032 self._la = 0 # Token type 

2033 try: 

2034 self.enterOuterAlt(localctx, 1) 

2035 self.state = 422 

2036 self.identifier() 

2037 self.state = 436 

2038 self._errHandler.sync(self) 

2039 _alt = self._interp.adaptivePredict(self._input, 45, self._ctx) 

2040 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

2041 if _alt == 1: 

2042 self.state = 424 

2043 self._errHandler.sync(self) 

2044 _la = self._input.LA(1) 

2045 if _la == RParser.NL: 

2046 self.state = 423 

2047 self.match(RParser.NL) 

2048 

2049 self.state = 426 

2050 self.match(RParser.T__5) 

2051 self.state = 428 

2052 self._errHandler.sync(self) 

2053 _la = self._input.LA(1) 

2054 if _la == RParser.NL: 

2055 self.state = 427 

2056 self.match(RParser.NL) 

2057 

2058 self.state = 430 

2059 self.identifier() 

2060 self.state = 432 

2061 self._errHandler.sync(self) 

2062 la_ = self._interp.adaptivePredict( 

2063 self._input, 44, self._ctx) 

2064 if la_ == 1: 

2065 self.state = 431 

2066 self.match(RParser.NL) 

2067 

2068 self.state = 438 

2069 self._errHandler.sync(self) 

2070 _alt = self._interp.adaptivePredict(self._input, 45, self._ctx) 

2071 

2072 except RecognitionException as re: 

2073 localctx.exception = re 

2074 self._errHandler.reportError(self, re) 

2075 self._errHandler.recover(self, re) 

2076 finally: 

2077 self.exitRule() 

2078 return localctx 

2079 

2080 class SubContext(ParserRuleContext): 

2081 __slots__ = 'parser' 

2082 

2083 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2084 super().__init__(parent, invokingState) 

2085 self.parser = parser 

2086 

2087 def subnobracket(self): 

2088 return self.getTypedRuleContext(RParser.SubnobracketContext, 0) 

2089 

2090 def expr(self): 

2091 return self.getTypedRuleContext(RParser.ExprContext, 0) 

2092 

2093 def getRuleIndex(self): 

2094 return RParser.RULE_sub 

2095 

2096 def enterRule(self, listener: ParseTreeListener): 

2097 if hasattr(listener, "enterSub"): 

2098 listener.enterSub(self) 

2099 

2100 def exitRule(self, listener: ParseTreeListener): 

2101 if hasattr(listener, "exitSub"): 

2102 listener.exitSub(self) 

2103 

2104 def sub(self): 

2105 

2106 localctx = RParser.SubContext(self, self._ctx, self.state) 

2107 self.enterRule(localctx, 32, self.RULE_sub) 

2108 try: 

2109 self.state = 441 

2110 self._errHandler.sync(self) 

2111 la_ = self._interp.adaptivePredict(self._input, 46, self._ctx) 

2112 if la_ == 1: 

2113 self.enterOuterAlt(localctx, 1) 

2114 self.state = 439 

2115 self.subnobracket() 

2116 pass 

2117 

2118 elif la_ == 2: 

2119 self.enterOuterAlt(localctx, 2) 

2120 self.state = 440 

2121 self.expr(0) 

2122 pass 

2123 

2124 except RecognitionException as re: 

2125 localctx.exception = re 

2126 self._errHandler.reportError(self, re) 

2127 self._errHandler.recover(self, re) 

2128 finally: 

2129 self.exitRule() 

2130 return localctx 

2131 

2132 class SubnobracketContext(ParserRuleContext): 

2133 __slots__ = 'parser' 

2134 

2135 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2136 super().__init__(parent, invokingState) 

2137 self.parser = parser 

2138 

2139 def identifier(self): 

2140 return self.getTypedRuleContext(RParser.IdentifierContext, 0) 

2141 

2142 def inlinefunction(self): 

2143 return self.getTypedRuleContext(RParser.InlinefunctionContext, 0) 

2144 

2145 def expr(self): 

2146 return self.getTypedRuleContext(RParser.ExprContext, 0) 

2147 

2148 def STRING(self): 

2149 return self.getToken(RParser.STRING, 0) 

2150 

2151 def getRuleIndex(self): 

2152 return RParser.RULE_subnobracket 

2153 

2154 def enterRule(self, listener: ParseTreeListener): 

2155 if hasattr(listener, "enterSubnobracket"): 

2156 listener.enterSubnobracket(self) 

2157 

2158 def exitRule(self, listener: ParseTreeListener): 

2159 if hasattr(listener, "exitSubnobracket"): 

2160 listener.exitSubnobracket(self) 

2161 

2162 def subnobracket(self): 

2163 

2164 localctx = RParser.SubnobracketContext(self, self._ctx, self.state) 

2165 self.enterRule(localctx, 34, self.RULE_subnobracket) 

2166 try: 

2167 self.state = 461 

2168 self._errHandler.sync(self) 

2169 la_ = self._interp.adaptivePredict(self._input, 48, self._ctx) 

2170 if la_ == 1: 

2171 self.enterOuterAlt(localctx, 1) 

2172 self.state = 443 

2173 self.identifier() 

2174 self.state = 444 

2175 self.match(RParser.T__19) 

2176 self.state = 447 

2177 self._errHandler.sync(self) 

2178 la_ = self._interp.adaptivePredict(self._input, 47, self._ctx) 

2179 if la_ == 1: 

2180 self.state = 445 

2181 self.inlinefunction() 

2182 pass 

2183 

2184 elif la_ == 2: 

2185 self.state = 446 

2186 self.expr(0) 

2187 pass 

2188 

2189 pass 

2190 

2191 elif la_ == 2: 

2192 self.enterOuterAlt(localctx, 2) 

2193 self.state = 449 

2194 self.match(RParser.STRING) 

2195 self.state = 450 

2196 self.match(RParser.T__19) 

2197 pass 

2198 

2199 elif la_ == 3: 

2200 self.enterOuterAlt(localctx, 3) 

2201 self.state = 451 

2202 self.match(RParser.STRING) 

2203 self.state = 452 

2204 self.match(RParser.T__19) 

2205 self.state = 453 

2206 self.expr(0) 

2207 pass 

2208 

2209 elif la_ == 4: 

2210 self.enterOuterAlt(localctx, 4) 

2211 self.state = 454 

2212 self.match(RParser.T__21) 

2213 self.state = 455 

2214 self.match(RParser.T__19) 

2215 pass 

2216 

2217 elif la_ == 5: 

2218 self.enterOuterAlt(localctx, 5) 

2219 self.state = 456 

2220 self.match(RParser.T__21) 

2221 self.state = 457 

2222 self.match(RParser.T__19) 

2223 self.state = 458 

2224 self.expr(0) 

2225 pass 

2226 

2227 elif la_ == 6: 

2228 self.enterOuterAlt(localctx, 6) 

2229 self.state = 459 

2230 self.match(RParser.T__20) 

2231 pass 

2232 

2233 elif la_ == 7: 

2234 self.enterOuterAlt(localctx, 7) 

2235 self.state = 460 

2236 self.match(RParser.T__22) 

2237 pass 

2238 

2239 except RecognitionException as re: 

2240 localctx.exception = re 

2241 self._errHandler.reportError(self, re) 

2242 self._errHandler.recover(self, re) 

2243 finally: 

2244 self.exitRule() 

2245 return localctx 

2246 

2247 class RangesContext(ParserRuleContext): 

2248 __slots__ = 'parser' 

2249 

2250 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2251 super().__init__(parent, invokingState) 

2252 self.parser = parser 

2253 

2254 def range_simple(self): 

2255 return self.getTypedRuleContext(RParser.Range_simpleContext, 0) 

2256 

2257 def range_complexe(self): 

2258 return self.getTypedRuleContext(RParser.Range_complexeContext, 0) 

2259 

2260 def getRuleIndex(self): 

2261 return RParser.RULE_ranges 

2262 

2263 def enterRule(self, listener: ParseTreeListener): 

2264 if hasattr(listener, "enterRanges"): 

2265 listener.enterRanges(self) 

2266 

2267 def exitRule(self, listener: ParseTreeListener): 

2268 if hasattr(listener, "exitRanges"): 

2269 listener.exitRanges(self) 

2270 

2271 def ranges(self): 

2272 

2273 localctx = RParser.RangesContext(self, self._ctx, self.state) 

2274 self.enterRule(localctx, 36, self.RULE_ranges) 

2275 try: 

2276 self.state = 465 

2277 self._errHandler.sync(self) 

2278 token = self._input.LA(1) 

2279 if token in [RParser.INT, RParser.ID]: 

2280 self.enterOuterAlt(localctx, 1) 

2281 self.state = 463 

2282 self.range_simple() 

2283 pass 

2284 elif token in [RParser.T__15]: 

2285 self.enterOuterAlt(localctx, 2) 

2286 self.state = 464 

2287 self.range_complexe() 

2288 pass 

2289 else: 

2290 raise NoViableAltException(self) 

2291 

2292 except RecognitionException as re: 

2293 localctx.exception = re 

2294 self._errHandler.reportError(self, re) 

2295 self._errHandler.recover(self, re) 

2296 finally: 

2297 self.exitRule() 

2298 return localctx 

2299 

2300 class Range_simpleContext(ParserRuleContext): 

2301 __slots__ = 'parser' 

2302 

2303 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2304 super().__init__(parent, invokingState) 

2305 self.parser = parser 

2306 

2307 def identifier(self, i: int = None): 

2308 if i is None: 

2309 return self.getTypedRuleContexts(RParser.IdentifierContext) 

2310 else: 

2311 return self.getTypedRuleContext(RParser.IdentifierContext, i) 

2312 

2313 def INT(self, i: int = None): 

2314 if i is None: 

2315 return self.getTokens(RParser.INT) 

2316 else: 

2317 return self.getToken(RParser.INT, i) 

2318 

2319 def getRuleIndex(self): 

2320 return RParser.RULE_range_simple 

2321 

2322 def enterRule(self, listener: ParseTreeListener): 

2323 if hasattr(listener, "enterRange_simple"): 

2324 listener.enterRange_simple(self) 

2325 

2326 def exitRule(self, listener: ParseTreeListener): 

2327 if hasattr(listener, "exitRange_simple"): 

2328 listener.exitRange_simple(self) 

2329 

2330 def range_simple(self): 

2331 

2332 localctx = RParser.Range_simpleContext(self, self._ctx, self.state) 

2333 self.enterRule(localctx, 38, self.RULE_range_simple) 

2334 try: 

2335 self.enterOuterAlt(localctx, 1) 

2336 self.state = 469 

2337 self._errHandler.sync(self) 

2338 token = self._input.LA(1) 

2339 if token in [RParser.ID]: 

2340 self.state = 467 

2341 self.identifier() 

2342 pass 

2343 elif token in [RParser.INT]: 

2344 self.state = 468 

2345 self.match(RParser.INT) 

2346 pass 

2347 else: 

2348 raise NoViableAltException(self) 

2349 

2350 self.state = 471 

2351 self.match(RParser.T__22) 

2352 self.state = 474 

2353 self._errHandler.sync(self) 

2354 token = self._input.LA(1) 

2355 if token in [RParser.ID]: 

2356 self.state = 472 

2357 self.identifier() 

2358 pass 

2359 elif token in [RParser.INT]: 

2360 self.state = 473 

2361 self.match(RParser.INT) 

2362 pass 

2363 else: 

2364 raise NoViableAltException(self) 

2365 

2366 except RecognitionException as re: 

2367 localctx.exception = re 

2368 self._errHandler.reportError(self, re) 

2369 self._errHandler.recover(self, re) 

2370 finally: 

2371 self.exitRule() 

2372 return localctx 

2373 

2374 class Range_complexeContext(ParserRuleContext): 

2375 __slots__ = 'parser' 

2376 

2377 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2378 super().__init__(parent, invokingState) 

2379 self.parser = parser 

2380 

2381 def expr(self, i: int = None): 

2382 if i is None: 

2383 return self.getTypedRuleContexts(RParser.ExprContext) 

2384 else: 

2385 return self.getTypedRuleContext(RParser.ExprContext, i) 

2386 

2387 def getRuleIndex(self): 

2388 return RParser.RULE_range_complexe 

2389 

2390 def enterRule(self, listener: ParseTreeListener): 

2391 if hasattr(listener, "enterRange_complexe"): 

2392 listener.enterRange_complexe(self) 

2393 

2394 def exitRule(self, listener: ParseTreeListener): 

2395 if hasattr(listener, "exitRange_complexe"): 

2396 listener.exitRange_complexe(self) 

2397 

2398 def range_complexe(self): 

2399 

2400 localctx = RParser.Range_complexeContext(self, self._ctx, self.state) 

2401 self.enterRule(localctx, 40, self.RULE_range_complexe) 

2402 try: 

2403 self.enterOuterAlt(localctx, 1) 

2404 self.state = 476 

2405 self.match(RParser.T__15) 

2406 self.state = 477 

2407 self.expr(0) 

2408 self.state = 478 

2409 self.match(RParser.T__16) 

2410 self.state = 479 

2411 self.match(RParser.T__22) 

2412 self.state = 480 

2413 self.expr(0) 

2414 except RecognitionException as re: 

2415 localctx.exception = re 

2416 self._errHandler.reportError(self, re) 

2417 self._errHandler.recover(self, re) 

2418 finally: 

2419 self.exitRule() 

2420 return localctx 

2421 

2422 class IntersectionsContext(ParserRuleContext): 

2423 __slots__ = 'parser' 

2424 

2425 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2426 super().__init__(parent, invokingState) 

2427 self.parser = parser 

2428 

2429 def intersection_simple(self): 

2430 return self.getTypedRuleContext(RParser.Intersection_simpleContext, 0) 

2431 

2432 def intersection_complexe(self): 

2433 return self.getTypedRuleContext(RParser.Intersection_complexeContext, 0) 

2434 

2435 def getRuleIndex(self): 

2436 return RParser.RULE_intersections 

2437 

2438 def enterRule(self, listener: ParseTreeListener): 

2439 if hasattr(listener, "enterIntersections"): 

2440 listener.enterIntersections(self) 

2441 

2442 def exitRule(self, listener: ParseTreeListener): 

2443 if hasattr(listener, "exitIntersections"): 

2444 listener.exitIntersections(self) 

2445 

2446 def intersections(self): 

2447 

2448 localctx = RParser.IntersectionsContext(self, self._ctx, self.state) 

2449 self.enterRule(localctx, 42, self.RULE_intersections) 

2450 try: 

2451 self.state = 484 

2452 self._errHandler.sync(self) 

2453 token = self._input.LA(1) 

2454 if token in [RParser.T__21, RParser.T__24, RParser.T__25, RParser.T__26, RParser.T__27, RParser.T__28, RParser.HEX, RParser.INT, RParser.FLOAT, RParser.COMPLEX, RParser.STRING, RParser.ID]: 

2455 self.enterOuterAlt(localctx, 1) 

2456 self.state = 482 

2457 self.intersection_simple() 

2458 pass 

2459 elif token in [RParser.T__15]: 

2460 self.enterOuterAlt(localctx, 2) 

2461 self.state = 483 

2462 self.intersection_complexe() 

2463 pass 

2464 else: 

2465 raise NoViableAltException(self) 

2466 

2467 except RecognitionException as re: 

2468 localctx.exception = re 

2469 self._errHandler.reportError(self, re) 

2470 self._errHandler.recover(self, re) 

2471 finally: 

2472 self.exitRule() 

2473 return localctx 

2474 

2475 class Intersection_simpleContext(ParserRuleContext): 

2476 __slots__ = 'parser' 

2477 

2478 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2479 super().__init__(parent, invokingState) 

2480 self.parser = parser 

2481 

2482 def expr(self): 

2483 return self.getTypedRuleContext(RParser.ExprContext, 0) 

2484 

2485 def identifier(self): 

2486 return self.getTypedRuleContext(RParser.IdentifierContext, 0) 

2487 

2488 def constant(self): 

2489 return self.getTypedRuleContext(RParser.ConstantContext, 0) 

2490 

2491 def getRuleIndex(self): 

2492 return RParser.RULE_intersection_simple 

2493 

2494 def enterRule(self, listener: ParseTreeListener): 

2495 if hasattr(listener, "enterIntersection_simple"): 

2496 listener.enterIntersection_simple(self) 

2497 

2498 def exitRule(self, listener: ParseTreeListener): 

2499 if hasattr(listener, "exitIntersection_simple"): 

2500 listener.exitIntersection_simple(self) 

2501 

2502 def intersection_simple(self): 

2503 

2504 localctx = RParser.Intersection_simpleContext( 

2505 self, self._ctx, self.state) 

2506 self.enterRule(localctx, 44, self.RULE_intersection_simple) 

2507 try: 

2508 self.enterOuterAlt(localctx, 1) 

2509 self.state = 488 

2510 self._errHandler.sync(self) 

2511 token = self._input.LA(1) 

2512 if token in [RParser.ID]: 

2513 self.state = 486 

2514 self.identifier() 

2515 pass 

2516 elif token in [RParser.T__21, RParser.T__24, RParser.T__25, RParser.T__26, RParser.T__27, RParser.T__28, RParser.HEX, RParser.INT, RParser.FLOAT, RParser.COMPLEX, RParser.STRING]: 

2517 self.state = 487 

2518 self.constant() 

2519 pass 

2520 else: 

2521 raise NoViableAltException(self) 

2522 

2523 self.state = 490 

2524 self.match(RParser.T__23) 

2525 self.state = 491 

2526 self.expr(0) 

2527 except RecognitionException as re: 

2528 localctx.exception = re 

2529 self._errHandler.reportError(self, re) 

2530 self._errHandler.recover(self, re) 

2531 finally: 

2532 self.exitRule() 

2533 return localctx 

2534 

2535 class Intersection_complexeContext(ParserRuleContext): 

2536 __slots__ = 'parser' 

2537 

2538 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2539 super().__init__(parent, invokingState) 

2540 self.parser = parser 

2541 

2542 def expr(self, i: int = None): 

2543 if i is None: 

2544 return self.getTypedRuleContexts(RParser.ExprContext) 

2545 else: 

2546 return self.getTypedRuleContext(RParser.ExprContext, i) 

2547 

2548 def getRuleIndex(self): 

2549 return RParser.RULE_intersection_complexe 

2550 

2551 def enterRule(self, listener: ParseTreeListener): 

2552 if hasattr(listener, "enterIntersection_complexe"): 

2553 listener.enterIntersection_complexe(self) 

2554 

2555 def exitRule(self, listener: ParseTreeListener): 

2556 if hasattr(listener, "exitIntersection_complexe"): 

2557 listener.exitIntersection_complexe(self) 

2558 

2559 def intersection_complexe(self): 

2560 

2561 localctx = RParser.Intersection_complexeContext( 

2562 self, self._ctx, self.state) 

2563 self.enterRule(localctx, 46, self.RULE_intersection_complexe) 

2564 try: 

2565 self.enterOuterAlt(localctx, 1) 

2566 self.state = 493 

2567 self.match(RParser.T__15) 

2568 self.state = 494 

2569 self.expr(0) 

2570 self.state = 495 

2571 self.match(RParser.T__16) 

2572 self.state = 496 

2573 self.match(RParser.T__23) 

2574 self.state = 497 

2575 self.expr(0) 

2576 except RecognitionException as re: 

2577 localctx.exception = re 

2578 self._errHandler.reportError(self, re) 

2579 self._errHandler.recover(self, re) 

2580 finally: 

2581 self.exitRule() 

2582 return localctx 

2583 

2584 class ConstantContext(ParserRuleContext): 

2585 __slots__ = 'parser' 

2586 

2587 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2588 super().__init__(parent, invokingState) 

2589 self.parser = parser 

2590 

2591 def STRING(self): 

2592 return self.getToken(RParser.STRING, 0) 

2593 

2594 def HEX(self): 

2595 return self.getToken(RParser.HEX, 0) 

2596 

2597 def INT(self): 

2598 return self.getToken(RParser.INT, 0) 

2599 

2600 def FLOAT(self): 

2601 return self.getToken(RParser.FLOAT, 0) 

2602 

2603 def COMPLEX(self): 

2604 return self.getToken(RParser.COMPLEX, 0) 

2605 

2606 def boolean(self): 

2607 return self.getTypedRuleContext(RParser.BooleanContext, 0) 

2608 

2609 def getRuleIndex(self): 

2610 return RParser.RULE_constant 

2611 

2612 def enterRule(self, listener: ParseTreeListener): 

2613 if hasattr(listener, "enterConstant"): 

2614 listener.enterConstant(self) 

2615 

2616 def exitRule(self, listener: ParseTreeListener): 

2617 if hasattr(listener, "exitConstant"): 

2618 listener.exitConstant(self) 

2619 

2620 def constant(self): 

2621 

2622 localctx = RParser.ConstantContext(self, self._ctx, self.state) 

2623 self.enterRule(localctx, 48, self.RULE_constant) 

2624 try: 

2625 self.state = 509 

2626 self._errHandler.sync(self) 

2627 token = self._input.LA(1) 

2628 if token in [RParser.STRING]: 

2629 self.enterOuterAlt(localctx, 1) 

2630 self.state = 499 

2631 self.match(RParser.STRING) 

2632 pass 

2633 elif token in [RParser.HEX]: 

2634 self.enterOuterAlt(localctx, 2) 

2635 self.state = 500 

2636 self.match(RParser.HEX) 

2637 pass 

2638 elif token in [RParser.INT]: 

2639 self.enterOuterAlt(localctx, 3) 

2640 self.state = 501 

2641 self.match(RParser.INT) 

2642 pass 

2643 elif token in [RParser.FLOAT]: 

2644 self.enterOuterAlt(localctx, 4) 

2645 self.state = 502 

2646 self.match(RParser.FLOAT) 

2647 pass 

2648 elif token in [RParser.COMPLEX]: 

2649 self.enterOuterAlt(localctx, 5) 

2650 self.state = 503 

2651 self.match(RParser.COMPLEX) 

2652 pass 

2653 elif token in [RParser.T__21]: 

2654 self.enterOuterAlt(localctx, 6) 

2655 self.state = 504 

2656 self.match(RParser.T__21) 

2657 pass 

2658 elif token in [RParser.T__24]: 

2659 self.enterOuterAlt(localctx, 7) 

2660 self.state = 505 

2661 self.match(RParser.T__24) 

2662 pass 

2663 elif token in [RParser.T__25]: 

2664 self.enterOuterAlt(localctx, 8) 

2665 self.state = 506 

2666 self.match(RParser.T__25) 

2667 pass 

2668 elif token in [RParser.T__26]: 

2669 self.enterOuterAlt(localctx, 9) 

2670 self.state = 507 

2671 self.match(RParser.T__26) 

2672 pass 

2673 elif token in [RParser.T__27, RParser.T__28]: 

2674 self.enterOuterAlt(localctx, 10) 

2675 self.state = 508 

2676 self.boolean() 

2677 pass 

2678 else: 

2679 raise NoViableAltException(self) 

2680 

2681 except RecognitionException as re: 

2682 localctx.exception = re 

2683 self._errHandler.reportError(self, re) 

2684 self._errHandler.recover(self, re) 

2685 finally: 

2686 self.exitRule() 

2687 return localctx 

2688 

2689 class BooleanContext(ParserRuleContext): 

2690 __slots__ = 'parser' 

2691 

2692 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2693 super().__init__(parent, invokingState) 

2694 self.parser = parser 

2695 

2696 def getRuleIndex(self): 

2697 return RParser.RULE_boolean 

2698 

2699 def enterRule(self, listener: ParseTreeListener): 

2700 if hasattr(listener, "enterBoolean"): 

2701 listener.enterBoolean(self) 

2702 

2703 def exitRule(self, listener: ParseTreeListener): 

2704 if hasattr(listener, "exitBoolean"): 

2705 listener.exitBoolean(self) 

2706 

2707 def boolean(self): 

2708 

2709 localctx = RParser.BooleanContext(self, self._ctx, self.state) 

2710 self.enterRule(localctx, 50, self.RULE_boolean) 

2711 self._la = 0 # Token type 

2712 try: 

2713 self.enterOuterAlt(localctx, 1) 

2714 self.state = 511 

2715 _la = self._input.LA(1) 

2716 if not (_la == RParser.T__27 or _la == RParser.T__28): 

2717 self._errHandler.recoverInline(self) 

2718 else: 

2719 self._errHandler.reportMatch(self) 

2720 self.consume() 

2721 except RecognitionException as re: 

2722 localctx.exception = re 

2723 self._errHandler.reportError(self, re) 

2724 self._errHandler.recover(self, re) 

2725 finally: 

2726 self.exitRule() 

2727 return localctx 

2728 

2729 class NextexprContext(ParserRuleContext): 

2730 __slots__ = 'parser' 

2731 

2732 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2733 super().__init__(parent, invokingState) 

2734 self.parser = parser 

2735 

2736 def getRuleIndex(self): 

2737 return RParser.RULE_nextexpr 

2738 

2739 def enterRule(self, listener: ParseTreeListener): 

2740 if hasattr(listener, "enterNextexpr"): 

2741 listener.enterNextexpr(self) 

2742 

2743 def exitRule(self, listener: ParseTreeListener): 

2744 if hasattr(listener, "exitNextexpr"): 

2745 listener.exitNextexpr(self) 

2746 

2747 def nextexpr(self): 

2748 

2749 localctx = RParser.NextexprContext(self, self._ctx, self.state) 

2750 self.enterRule(localctx, 52, self.RULE_nextexpr) 

2751 try: 

2752 self.enterOuterAlt(localctx, 1) 

2753 self.state = 513 

2754 self.match(RParser.T__29) 

2755 except RecognitionException as re: 

2756 localctx.exception = re 

2757 self._errHandler.reportError(self, re) 

2758 self._errHandler.recover(self, re) 

2759 finally: 

2760 self.exitRule() 

2761 return localctx 

2762 

2763 class RepeatexprContext(ParserRuleContext): 

2764 __slots__ = 'parser' 

2765 

2766 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2767 super().__init__(parent, invokingState) 

2768 self.parser = parser 

2769 

2770 def expr(self): 

2771 return self.getTypedRuleContext(RParser.ExprContext, 0) 

2772 

2773 def getRuleIndex(self): 

2774 return RParser.RULE_repeatexpr 

2775 

2776 def enterRule(self, listener: ParseTreeListener): 

2777 if hasattr(listener, "enterRepeatexpr"): 

2778 listener.enterRepeatexpr(self) 

2779 

2780 def exitRule(self, listener: ParseTreeListener): 

2781 if hasattr(listener, "exitRepeatexpr"): 

2782 listener.exitRepeatexpr(self) 

2783 

2784 def repeatexpr(self): 

2785 

2786 localctx = RParser.RepeatexprContext(self, self._ctx, self.state) 

2787 self.enterRule(localctx, 54, self.RULE_repeatexpr) 

2788 try: 

2789 self.enterOuterAlt(localctx, 1) 

2790 self.state = 515 

2791 self.match(RParser.T__30) 

2792 self.state = 516 

2793 self.expr(0) 

2794 except RecognitionException as re: 

2795 localctx.exception = re 

2796 self._errHandler.reportError(self, re) 

2797 self._errHandler.recover(self, re) 

2798 finally: 

2799 self.exitRule() 

2800 return localctx 

2801 

2802 class WhileexprContext(ParserRuleContext): 

2803 __slots__ = 'parser' 

2804 

2805 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2806 super().__init__(parent, invokingState) 

2807 self.parser = parser 

2808 

2809 def expr(self, i: int = None): 

2810 if i is None: 

2811 return self.getTypedRuleContexts(RParser.ExprContext) 

2812 else: 

2813 return self.getTypedRuleContext(RParser.ExprContext, i) 

2814 

2815 def getRuleIndex(self): 

2816 return RParser.RULE_whileexpr 

2817 

2818 def enterRule(self, listener: ParseTreeListener): 

2819 if hasattr(listener, "enterWhileexpr"): 

2820 listener.enterWhileexpr(self) 

2821 

2822 def exitRule(self, listener: ParseTreeListener): 

2823 if hasattr(listener, "exitWhileexpr"): 

2824 listener.exitWhileexpr(self) 

2825 

2826 def whileexpr(self): 

2827 

2828 localctx = RParser.WhileexprContext(self, self._ctx, self.state) 

2829 self.enterRule(localctx, 56, self.RULE_whileexpr) 

2830 try: 

2831 self.enterOuterAlt(localctx, 1) 

2832 self.state = 518 

2833 self.match(RParser.T__31) 

2834 self.state = 519 

2835 self.match(RParser.T__15) 

2836 self.state = 520 

2837 self.expr(0) 

2838 self.state = 521 

2839 self.match(RParser.T__16) 

2840 self.state = 522 

2841 self.expr(0) 

2842 except RecognitionException as re: 

2843 localctx.exception = re 

2844 self._errHandler.reportError(self, re) 

2845 self._errHandler.recover(self, re) 

2846 finally: 

2847 self.exitRule() 

2848 return localctx 

2849 

2850 class ForexprContext(ParserRuleContext): 

2851 __slots__ = 'parser' 

2852 

2853 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2854 super().__init__(parent, invokingState) 

2855 self.parser = parser 

2856 

2857 def identifier(self): 

2858 return self.getTypedRuleContext(RParser.IdentifierContext, 0) 

2859 

2860 def expr(self, i: int = None): 

2861 if i is None: 

2862 return self.getTypedRuleContexts(RParser.ExprContext) 

2863 else: 

2864 return self.getTypedRuleContext(RParser.ExprContext, i) 

2865 

2866 def getRuleIndex(self): 

2867 return RParser.RULE_forexpr 

2868 

2869 def enterRule(self, listener: ParseTreeListener): 

2870 if hasattr(listener, "enterForexpr"): 

2871 listener.enterForexpr(self) 

2872 

2873 def exitRule(self, listener: ParseTreeListener): 

2874 if hasattr(listener, "exitForexpr"): 

2875 listener.exitForexpr(self) 

2876 

2877 def forexpr(self): 

2878 

2879 localctx = RParser.ForexprContext(self, self._ctx, self.state) 

2880 self.enterRule(localctx, 58, self.RULE_forexpr) 

2881 try: 

2882 self.enterOuterAlt(localctx, 1) 

2883 self.state = 524 

2884 self.match(RParser.T__32) 

2885 self.state = 525 

2886 self.match(RParser.T__15) 

2887 self.state = 526 

2888 self.identifier() 

2889 self.state = 527 

2890 self.match(RParser.T__33) 

2891 self.state = 528 

2892 self.expr(0) 

2893 self.state = 529 

2894 self.match(RParser.T__16) 

2895 self.state = 530 

2896 self.expr(0) 

2897 except RecognitionException as re: 

2898 localctx.exception = re 

2899 self._errHandler.reportError(self, re) 

2900 self._errHandler.recover(self, re) 

2901 finally: 

2902 self.exitRule() 

2903 return localctx 

2904 

2905 class IfexprContext(ParserRuleContext): 

2906 __slots__ = 'parser' 

2907 

2908 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

2909 super().__init__(parent, invokingState) 

2910 self.parser = parser 

2911 

2912 def expr(self, i: int = None): 

2913 if i is None: 

2914 return self.getTypedRuleContexts(RParser.ExprContext) 

2915 else: 

2916 return self.getTypedRuleContext(RParser.ExprContext, i) 

2917 

2918 def NL(self, i: int = None): 

2919 if i is None: 

2920 return self.getTokens(RParser.NL) 

2921 else: 

2922 return self.getToken(RParser.NL, i) 

2923 

2924 def elseif(self, i: int = None): 

2925 if i is None: 

2926 return self.getTypedRuleContexts(RParser.ElseifContext) 

2927 else: 

2928 return self.getTypedRuleContext(RParser.ElseifContext, i) 

2929 

2930 def getRuleIndex(self): 

2931 return RParser.RULE_ifexpr 

2932 

2933 def enterRule(self, listener: ParseTreeListener): 

2934 if hasattr(listener, "enterIfexpr"): 

2935 listener.enterIfexpr(self) 

2936 

2937 def exitRule(self, listener: ParseTreeListener): 

2938 if hasattr(listener, "exitIfexpr"): 

2939 listener.exitIfexpr(self) 

2940 

2941 def ifexpr(self): 

2942 

2943 localctx = RParser.IfexprContext(self, self._ctx, self.state) 

2944 self.enterRule(localctx, 60, self.RULE_ifexpr) 

2945 try: 

2946 self.enterOuterAlt(localctx, 1) 

2947 self.state = 532 

2948 self.match(RParser.T__34) 

2949 self.state = 533 

2950 self.match(RParser.T__15) 

2951 self.state = 534 

2952 self.expr(0) 

2953 self.state = 535 

2954 self.match(RParser.T__16) 

2955 self.state = 539 

2956 self._errHandler.sync(self) 

2957 _alt = self._interp.adaptivePredict(self._input, 55, self._ctx) 

2958 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

2959 if _alt == 1: 

2960 self.state = 536 

2961 self.match(RParser.NL) 

2962 self.state = 541 

2963 self._errHandler.sync(self) 

2964 _alt = self._interp.adaptivePredict(self._input, 55, self._ctx) 

2965 

2966 self.state = 542 

2967 self.expr(0) 

2968 self.state = 562 

2969 self._errHandler.sync(self) 

2970 _alt = self._interp.adaptivePredict(self._input, 58, self._ctx) 

2971 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

2972 if _alt == 1: 

2973 self.state = 543 

2974 self.elseif() 

2975 self.state = 544 

2976 self.match(RParser.T__15) 

2977 self.state = 545 

2978 self.expr(0) 

2979 self.state = 546 

2980 self.match(RParser.T__16) 

2981 self.state = 550 

2982 self._errHandler.sync(self) 

2983 _alt = self._interp.adaptivePredict( 

2984 self._input, 56, self._ctx) 

2985 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

2986 if _alt == 1: 

2987 self.state = 547 

2988 self.match(RParser.NL) 

2989 self.state = 552 

2990 self._errHandler.sync(self) 

2991 _alt = self._interp.adaptivePredict( 

2992 self._input, 56, self._ctx) 

2993 

2994 self.state = 553 

2995 self.expr(0) 

2996 self.state = 557 

2997 self._errHandler.sync(self) 

2998 _alt = self._interp.adaptivePredict( 

2999 self._input, 57, self._ctx) 

3000 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3001 if _alt == 1: 

3002 self.state = 554 

3003 self.match(RParser.NL) 

3004 self.state = 559 

3005 self._errHandler.sync(self) 

3006 _alt = self._interp.adaptivePredict( 

3007 self._input, 57, self._ctx) 

3008 

3009 self.state = 564 

3010 self._errHandler.sync(self) 

3011 _alt = self._interp.adaptivePredict(self._input, 58, self._ctx) 

3012 

3013 except RecognitionException as re: 

3014 localctx.exception = re 

3015 self._errHandler.reportError(self, re) 

3016 self._errHandler.recover(self, re) 

3017 finally: 

3018 self.exitRule() 

3019 return localctx 

3020 

3021 class IfelseexprContext(ParserRuleContext): 

3022 __slots__ = 'parser' 

3023 

3024 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3025 super().__init__(parent, invokingState) 

3026 self.parser = parser 

3027 

3028 def expr(self, i: int = None): 

3029 if i is None: 

3030 return self.getTypedRuleContexts(RParser.ExprContext) 

3031 else: 

3032 return self.getTypedRuleContext(RParser.ExprContext, i) 

3033 

3034 def NL(self, i: int = None): 

3035 if i is None: 

3036 return self.getTokens(RParser.NL) 

3037 else: 

3038 return self.getToken(RParser.NL, i) 

3039 

3040 def elseif(self, i: int = None): 

3041 if i is None: 

3042 return self.getTypedRuleContexts(RParser.ElseifContext) 

3043 else: 

3044 return self.getTypedRuleContext(RParser.ElseifContext, i) 

3045 

3046 def getRuleIndex(self): 

3047 return RParser.RULE_ifelseexpr 

3048 

3049 def enterRule(self, listener: ParseTreeListener): 

3050 if hasattr(listener, "enterIfelseexpr"): 

3051 listener.enterIfelseexpr(self) 

3052 

3053 def exitRule(self, listener: ParseTreeListener): 

3054 if hasattr(listener, "exitIfelseexpr"): 

3055 listener.exitIfelseexpr(self) 

3056 

3057 def ifelseexpr(self): 

3058 

3059 localctx = RParser.IfelseexprContext(self, self._ctx, self.state) 

3060 self.enterRule(localctx, 62, self.RULE_ifelseexpr) 

3061 self._la = 0 # Token type 

3062 try: 

3063 self.enterOuterAlt(localctx, 1) 

3064 self.state = 565 

3065 self.match(RParser.T__34) 

3066 self.state = 566 

3067 self.match(RParser.T__15) 

3068 self.state = 567 

3069 self.expr(0) 

3070 self.state = 568 

3071 self.match(RParser.T__16) 

3072 self.state = 572 

3073 self._errHandler.sync(self) 

3074 _alt = self._interp.adaptivePredict(self._input, 59, self._ctx) 

3075 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3076 if _alt == 1: 

3077 self.state = 569 

3078 self.match(RParser.NL) 

3079 self.state = 574 

3080 self._errHandler.sync(self) 

3081 _alt = self._interp.adaptivePredict(self._input, 59, self._ctx) 

3082 

3083 self.state = 575 

3084 self.expr(0) 

3085 self.state = 579 

3086 self._errHandler.sync(self) 

3087 _la = self._input.LA(1) 

3088 while _la == RParser.NL: 

3089 self.state = 576 

3090 self.match(RParser.NL) 

3091 self.state = 581 

3092 self._errHandler.sync(self) 

3093 _la = self._input.LA(1) 

3094 

3095 self.state = 601 

3096 self._errHandler.sync(self) 

3097 _alt = self._interp.adaptivePredict(self._input, 63, self._ctx) 

3098 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3099 if _alt == 1: 

3100 self.state = 582 

3101 self.elseif() 

3102 self.state = 583 

3103 self.match(RParser.T__15) 

3104 self.state = 584 

3105 self.expr(0) 

3106 self.state = 585 

3107 self.match(RParser.T__16) 

3108 self.state = 589 

3109 self._errHandler.sync(self) 

3110 _alt = self._interp.adaptivePredict( 

3111 self._input, 61, self._ctx) 

3112 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3113 if _alt == 1: 

3114 self.state = 586 

3115 self.match(RParser.NL) 

3116 self.state = 591 

3117 self._errHandler.sync(self) 

3118 _alt = self._interp.adaptivePredict( 

3119 self._input, 61, self._ctx) 

3120 

3121 self.state = 592 

3122 self.expr(0) 

3123 self.state = 596 

3124 self._errHandler.sync(self) 

3125 _la = self._input.LA(1) 

3126 while _la == RParser.NL: 

3127 self.state = 593 

3128 self.match(RParser.NL) 

3129 self.state = 598 

3130 self._errHandler.sync(self) 

3131 _la = self._input.LA(1) 

3132 

3133 self.state = 603 

3134 self._errHandler.sync(self) 

3135 _alt = self._interp.adaptivePredict(self._input, 63, self._ctx) 

3136 

3137 self.state = 604 

3138 self.match(RParser.T__35) 

3139 self.state = 608 

3140 self._errHandler.sync(self) 

3141 _alt = self._interp.adaptivePredict(self._input, 64, self._ctx) 

3142 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3143 if _alt == 1: 

3144 self.state = 605 

3145 self.match(RParser.NL) 

3146 self.state = 610 

3147 self._errHandler.sync(self) 

3148 _alt = self._interp.adaptivePredict(self._input, 64, self._ctx) 

3149 

3150 self.state = 611 

3151 self.expr(0) 

3152 except RecognitionException as re: 

3153 localctx.exception = re 

3154 self._errHandler.reportError(self, re) 

3155 self._errHandler.recover(self, re) 

3156 finally: 

3157 self.exitRule() 

3158 return localctx 

3159 

3160 class ElseifContext(ParserRuleContext): 

3161 __slots__ = 'parser' 

3162 

3163 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3164 super().__init__(parent, invokingState) 

3165 self.parser = parser 

3166 

3167 def getRuleIndex(self): 

3168 return RParser.RULE_elseif 

3169 

3170 def enterRule(self, listener: ParseTreeListener): 

3171 if hasattr(listener, "enterElseif"): 

3172 listener.enterElseif(self) 

3173 

3174 def exitRule(self, listener: ParseTreeListener): 

3175 if hasattr(listener, "exitElseif"): 

3176 listener.exitElseif(self) 

3177 

3178 def elseif(self): 

3179 

3180 localctx = RParser.ElseifContext(self, self._ctx, self.state) 

3181 self.enterRule(localctx, 64, self.RULE_elseif) 

3182 try: 

3183 self.enterOuterAlt(localctx, 1) 

3184 self.state = 613 

3185 self.match(RParser.T__35) 

3186 self.state = 614 

3187 self.match(RParser.T__34) 

3188 except RecognitionException as re: 

3189 localctx.exception = re 

3190 self._errHandler.reportError(self, re) 

3191 self._errHandler.recover(self, re) 

3192 finally: 

3193 self.exitRule() 

3194 return localctx 

3195 

3196 class ReturnexprContext(ParserRuleContext): 

3197 __slots__ = 'parser' 

3198 

3199 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3200 super().__init__(parent, invokingState) 

3201 self.parser = parser 

3202 

3203 def expr(self): 

3204 return self.getTypedRuleContext(RParser.ExprContext, 0) 

3205 

3206 def getRuleIndex(self): 

3207 return RParser.RULE_returnexpr 

3208 

3209 def enterRule(self, listener: ParseTreeListener): 

3210 if hasattr(listener, "enterReturnexpr"): 

3211 listener.enterReturnexpr(self) 

3212 

3213 def exitRule(self, listener: ParseTreeListener): 

3214 if hasattr(listener, "exitReturnexpr"): 

3215 listener.exitReturnexpr(self) 

3216 

3217 def returnexpr(self): 

3218 

3219 localctx = RParser.ReturnexprContext(self, self._ctx, self.state) 

3220 self.enterRule(localctx, 66, self.RULE_returnexpr) 

3221 try: 

3222 self.enterOuterAlt(localctx, 1) 

3223 self.state = 616 

3224 self.match(RParser.T__36) 

3225 self.state = 617 

3226 self.match(RParser.T__15) 

3227 self.state = 618 

3228 self.expr(0) 

3229 self.state = 619 

3230 self.match(RParser.T__16) 

3231 except RecognitionException as re: 

3232 localctx.exception = re 

3233 self._errHandler.reportError(self, re) 

3234 self._errHandler.recover(self, re) 

3235 finally: 

3236 self.exitRule() 

3237 return localctx 

3238 

3239 class FunctioncallContext(ParserRuleContext): 

3240 __slots__ = 'parser' 

3241 

3242 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3243 super().__init__(parent, invokingState) 

3244 self.parser = parser 

3245 

3246 def identifier(self): 

3247 return self.getTypedRuleContext(RParser.IdentifierContext, 0) 

3248 

3249 def inlinefunction(self): 

3250 return self.getTypedRuleContext(RParser.InlinefunctionContext, 0) 

3251 

3252 def sublist(self): 

3253 return self.getTypedRuleContext(RParser.SublistContext, 0) 

3254 

3255 def NL(self, i: int = None): 

3256 if i is None: 

3257 return self.getTokens(RParser.NL) 

3258 else: 

3259 return self.getToken(RParser.NL, i) 

3260 

3261 def getRuleIndex(self): 

3262 return RParser.RULE_functioncall 

3263 

3264 def enterRule(self, listener: ParseTreeListener): 

3265 if hasattr(listener, "enterFunctioncall"): 

3266 listener.enterFunctioncall(self) 

3267 

3268 def exitRule(self, listener: ParseTreeListener): 

3269 if hasattr(listener, "exitFunctioncall"): 

3270 listener.exitFunctioncall(self) 

3271 

3272 def functioncall(self): 

3273 

3274 localctx = RParser.FunctioncallContext(self, self._ctx, self.state) 

3275 self.enterRule(localctx, 68, self.RULE_functioncall) 

3276 self._la = 0 # Token type 

3277 try: 

3278 self.enterOuterAlt(localctx, 1) 

3279 self.state = 621 

3280 self.identifier() 

3281 self.state = 644 

3282 self._errHandler.sync(self) 

3283 la_ = self._interp.adaptivePredict(self._input, 67, self._ctx) 

3284 if la_ == 1: 

3285 self.state = 622 

3286 self.match(RParser.T__15) 

3287 self.state = 623 

3288 self.match(RParser.T__16) 

3289 pass 

3290 

3291 elif la_ == 2: 

3292 self.state = 624 

3293 self.match(RParser.T__15) 

3294 self.state = 625 

3295 self.inlinefunction() 

3296 self.state = 626 

3297 self.match(RParser.T__16) 

3298 pass 

3299 

3300 elif la_ == 3: 

3301 self.state = 628 

3302 self.match(RParser.T__15) 

3303 self.state = 632 

3304 self._errHandler.sync(self) 

3305 _alt = self._interp.adaptivePredict(self._input, 65, self._ctx) 

3306 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3307 if _alt == 1: 

3308 self.state = 629 

3309 self.match(RParser.NL) 

3310 self.state = 634 

3311 self._errHandler.sync(self) 

3312 _alt = self._interp.adaptivePredict( 

3313 self._input, 65, self._ctx) 

3314 

3315 self.state = 635 

3316 self.sublist() 

3317 self.state = 639 

3318 self._errHandler.sync(self) 

3319 _la = self._input.LA(1) 

3320 while _la == RParser.NL: 

3321 self.state = 636 

3322 self.match(RParser.NL) 

3323 self.state = 641 

3324 self._errHandler.sync(self) 

3325 _la = self._input.LA(1) 

3326 

3327 self.state = 642 

3328 self.match(RParser.T__16) 

3329 pass 

3330 

3331 except RecognitionException as re: 

3332 localctx.exception = re 

3333 self._errHandler.reportError(self, re) 

3334 self._errHandler.recover(self, re) 

3335 finally: 

3336 self.exitRule() 

3337 return localctx 

3338 

3339 class InlinefunctionContext(ParserRuleContext): 

3340 __slots__ = 'parser' 

3341 

3342 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3343 super().__init__(parent, invokingState) 

3344 self.parser = parser 

3345 

3346 def exprlist(self): 

3347 return self.getTypedRuleContext(RParser.ExprlistContext, 0) 

3348 

3349 def NL(self, i: int = None): 

3350 if i is None: 

3351 return self.getTokens(RParser.NL) 

3352 else: 

3353 return self.getToken(RParser.NL, i) 

3354 

3355 def getRuleIndex(self): 

3356 return RParser.RULE_inlinefunction 

3357 

3358 def enterRule(self, listener: ParseTreeListener): 

3359 if hasattr(listener, "enterInlinefunction"): 

3360 listener.enterInlinefunction(self) 

3361 

3362 def exitRule(self, listener: ParseTreeListener): 

3363 if hasattr(listener, "exitInlinefunction"): 

3364 listener.exitInlinefunction(self) 

3365 

3366 def inlinefunction(self): 

3367 

3368 localctx = RParser.InlinefunctionContext(self, self._ctx, self.state) 

3369 self.enterRule(localctx, 70, self.RULE_inlinefunction) 

3370 self._la = 0 # Token type 

3371 try: 

3372 self.enterOuterAlt(localctx, 1) 

3373 self.state = 649 

3374 self._errHandler.sync(self) 

3375 _la = self._input.LA(1) 

3376 while _la == RParser.NL: 

3377 self.state = 646 

3378 self.match(RParser.NL) 

3379 self.state = 651 

3380 self._errHandler.sync(self) 

3381 _la = self._input.LA(1) 

3382 

3383 self.state = 652 

3384 self.match(RParser.T__11) 

3385 self.state = 656 

3386 self._errHandler.sync(self) 

3387 _alt = self._interp.adaptivePredict(self._input, 69, self._ctx) 

3388 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3389 if _alt == 1: 

3390 self.state = 653 

3391 self.match(RParser.NL) 

3392 self.state = 658 

3393 self._errHandler.sync(self) 

3394 _alt = self._interp.adaptivePredict(self._input, 69, self._ctx) 

3395 

3396 self.state = 659 

3397 self.exprlist() 

3398 self.state = 663 

3399 self._errHandler.sync(self) 

3400 _la = self._input.LA(1) 

3401 while _la == RParser.NL: 

3402 self.state = 660 

3403 self.match(RParser.NL) 

3404 self.state = 665 

3405 self._errHandler.sync(self) 

3406 _la = self._input.LA(1) 

3407 

3408 self.state = 666 

3409 self.match(RParser.T__12) 

3410 self.state = 670 

3411 self._errHandler.sync(self) 

3412 _alt = self._interp.adaptivePredict(self._input, 71, self._ctx) 

3413 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3414 if _alt == 1: 

3415 self.state = 667 

3416 self.match(RParser.NL) 

3417 self.state = 672 

3418 self._errHandler.sync(self) 

3419 _alt = self._interp.adaptivePredict(self._input, 71, self._ctx) 

3420 

3421 except RecognitionException as re: 

3422 localctx.exception = re 

3423 self._errHandler.reportError(self, re) 

3424 self._errHandler.recover(self, re) 

3425 finally: 

3426 self.exitRule() 

3427 return localctx 

3428 

3429 class Formula_simpleContext(ParserRuleContext): 

3430 __slots__ = 'parser' 

3431 

3432 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3433 super().__init__(parent, invokingState) 

3434 self.parser = parser 

3435 

3436 def formula_simple_B(self): 

3437 return self.getTypedRuleContext(RParser.Formula_simple_BContext, 0) 

3438 

3439 def formula_simple_A(self): 

3440 return self.getTypedRuleContext(RParser.Formula_simple_AContext, 0) 

3441 

3442 def formula_simple_C(self): 

3443 return self.getTypedRuleContext(RParser.Formula_simple_CContext, 0) 

3444 

3445 def getRuleIndex(self): 

3446 return RParser.RULE_formula_simple 

3447 

3448 def enterRule(self, listener: ParseTreeListener): 

3449 if hasattr(listener, "enterFormula_simple"): 

3450 listener.enterFormula_simple(self) 

3451 

3452 def exitRule(self, listener: ParseTreeListener): 

3453 if hasattr(listener, "exitFormula_simple"): 

3454 listener.exitFormula_simple(self) 

3455 

3456 def formula_simple(self): 

3457 

3458 localctx = RParser.Formula_simpleContext(self, self._ctx, self.state) 

3459 self.enterRule(localctx, 72, self.RULE_formula_simple) 

3460 try: 

3461 self.state = 676 

3462 self._errHandler.sync(self) 

3463 token = self._input.LA(1) 

3464 if token in [RParser.T__37]: 

3465 self.enterOuterAlt(localctx, 1) 

3466 self.state = 673 

3467 self.formula_simple_B() 

3468 pass 

3469 elif token in [RParser.T__44, RParser.ID]: 

3470 self.enterOuterAlt(localctx, 2) 

3471 self.state = 674 

3472 self.formula_simple_A() 

3473 pass 

3474 elif token in [RParser.T__15]: 

3475 self.enterOuterAlt(localctx, 3) 

3476 self.state = 675 

3477 self.formula_simple_C() 

3478 pass 

3479 else: 

3480 raise NoViableAltException(self) 

3481 

3482 except RecognitionException as re: 

3483 localctx.exception = re 

3484 self._errHandler.reportError(self, re) 

3485 self._errHandler.recover(self, re) 

3486 finally: 

3487 self.exitRule() 

3488 return localctx 

3489 

3490 class Formula_simple_AContext(ParserRuleContext): 

3491 __slots__ = 'parser' 

3492 

3493 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3494 super().__init__(parent, invokingState) 

3495 self.parser = parser 

3496 

3497 def formop(self): 

3498 return self.getTypedRuleContext(RParser.FormopContext, 0) 

3499 

3500 def sublistadd(self): 

3501 return self.getTypedRuleContext(RParser.SublistaddContext, 0) 

3502 

3503 def identifier(self): 

3504 return self.getTypedRuleContext(RParser.IdentifierContext, 0) 

3505 

3506 def getRuleIndex(self): 

3507 return RParser.RULE_formula_simple_A 

3508 

3509 def enterRule(self, listener: ParseTreeListener): 

3510 if hasattr(listener, "enterFormula_simple_A"): 

3511 listener.enterFormula_simple_A(self) 

3512 

3513 def exitRule(self, listener: ParseTreeListener): 

3514 if hasattr(listener, "exitFormula_simple_A"): 

3515 listener.exitFormula_simple_A(self) 

3516 

3517 def formula_simple_A(self): 

3518 

3519 localctx = RParser.Formula_simple_AContext(self, self._ctx, self.state) 

3520 self.enterRule(localctx, 74, self.RULE_formula_simple_A) 

3521 self._la = 0 # Token type 

3522 try: 

3523 self.enterOuterAlt(localctx, 1) 

3524 self.state = 679 

3525 self._errHandler.sync(self) 

3526 _la = self._input.LA(1) 

3527 if _la == RParser.ID: 

3528 self.state = 678 

3529 self.identifier() 

3530 

3531 self.state = 681 

3532 self.formop() 

3533 self.state = 684 

3534 self._errHandler.sync(self) 

3535 token = self._input.LA(1) 

3536 if token in [RParser.ID]: 

3537 self.state = 682 

3538 self.sublistadd() 

3539 pass 

3540 elif token in [RParser.T__17]: 

3541 self.state = 683 

3542 self.match(RParser.T__17) 

3543 pass 

3544 else: 

3545 raise NoViableAltException(self) 

3546 

3547 except RecognitionException as re: 

3548 localctx.exception = re 

3549 self._errHandler.reportError(self, re) 

3550 self._errHandler.recover(self, re) 

3551 finally: 

3552 self.exitRule() 

3553 return localctx 

3554 

3555 class Formula_simple_BContext(ParserRuleContext): 

3556 __slots__ = 'parser' 

3557 

3558 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3559 super().__init__(parent, invokingState) 

3560 self.parser = parser 

3561 

3562 def identifier(self, i: int = None): 

3563 if i is None: 

3564 return self.getTypedRuleContexts(RParser.IdentifierContext) 

3565 else: 

3566 return self.getTypedRuleContext(RParser.IdentifierContext, i) 

3567 

3568 def expr(self, i: int = None): 

3569 if i is None: 

3570 return self.getTypedRuleContexts(RParser.ExprContext) 

3571 else: 

3572 return self.getTypedRuleContext(RParser.ExprContext, i) 

3573 

3574 def affectop(self): 

3575 return self.getTypedRuleContext(RParser.AffectopContext, 0) 

3576 

3577 def NL(self, i: int = None): 

3578 if i is None: 

3579 return self.getTokens(RParser.NL) 

3580 else: 

3581 return self.getToken(RParser.NL, i) 

3582 

3583 def getRuleIndex(self): 

3584 return RParser.RULE_formula_simple_B 

3585 

3586 def enterRule(self, listener: ParseTreeListener): 

3587 if hasattr(listener, "enterFormula_simple_B"): 

3588 listener.enterFormula_simple_B(self) 

3589 

3590 def exitRule(self, listener: ParseTreeListener): 

3591 if hasattr(listener, "exitFormula_simple_B"): 

3592 listener.exitFormula_simple_B(self) 

3593 

3594 def formula_simple_B(self): 

3595 

3596 localctx = RParser.Formula_simple_BContext(self, self._ctx, self.state) 

3597 self.enterRule(localctx, 76, self.RULE_formula_simple_B) 

3598 self._la = 0 # Token type 

3599 try: 

3600 self.enterOuterAlt(localctx, 1) 

3601 self.state = 686 

3602 self.match(RParser.T__37) 

3603 self.state = 687 

3604 self.match(RParser.T__15) 

3605 self.state = 688 

3606 self.identifier() 

3607 self.state = 689 

3608 self.match(RParser.T__18) 

3609 self.state = 717 

3610 self._errHandler.sync(self) 

3611 token = self._input.LA(1) 

3612 if token in [RParser.T__11]: 

3613 self.state = 690 

3614 self.match(RParser.T__11) 

3615 self.state = 694 

3616 self._errHandler.sync(self) 

3617 _alt = self._interp.adaptivePredict(self._input, 75, self._ctx) 

3618 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: 

3619 if _alt == 1: 

3620 self.state = 691 

3621 self.match(RParser.NL) 

3622 self.state = 696 

3623 self._errHandler.sync(self) 

3624 _alt = self._interp.adaptivePredict( 

3625 self._input, 75, self._ctx) 

3626 

3627 self.state = 697 

3628 self.expr(0) 

3629 self.state = 702 

3630 self._errHandler.sync(self) 

3631 _la = self._input.LA(1) 

3632 while _la == RParser.T__0: 

3633 self.state = 698 

3634 self.match(RParser.T__0) 

3635 self.state = 699 

3636 self.expr(0) 

3637 self.state = 704 

3638 self._errHandler.sync(self) 

3639 _la = self._input.LA(1) 

3640 

3641 self.state = 708 

3642 self._errHandler.sync(self) 

3643 _la = self._input.LA(1) 

3644 while _la == RParser.NL: 

3645 self.state = 705 

3646 self.match(RParser.NL) 

3647 self.state = 710 

3648 self._errHandler.sync(self) 

3649 _la = self._input.LA(1) 

3650 

3651 self.state = 711 

3652 self.match(RParser.T__12) 

3653 pass 

3654 elif token in [RParser.ID]: 

3655 self.state = 713 

3656 self.identifier() 

3657 self.state = 714 

3658 self.affectop() 

3659 self.state = 715 

3660 self.expr(0) 

3661 pass 

3662 else: 

3663 raise NoViableAltException(self) 

3664 

3665 self.state = 719 

3666 self.match(RParser.T__16) 

3667 except RecognitionException as re: 

3668 localctx.exception = re 

3669 self._errHandler.reportError(self, re) 

3670 self._errHandler.recover(self, re) 

3671 finally: 

3672 self.exitRule() 

3673 return localctx 

3674 

3675 class Formula_simple_CContext(ParserRuleContext): 

3676 __slots__ = 'parser' 

3677 

3678 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3679 super().__init__(parent, invokingState) 

3680 self.parser = parser 

3681 

3682 def expr(self): 

3683 return self.getTypedRuleContext(RParser.ExprContext, 0) 

3684 

3685 def formop(self): 

3686 return self.getTypedRuleContext(RParser.FormopContext, 0) 

3687 

3688 def sublistadd(self): 

3689 return self.getTypedRuleContext(RParser.SublistaddContext, 0) 

3690 

3691 def getRuleIndex(self): 

3692 return RParser.RULE_formula_simple_C 

3693 

3694 def enterRule(self, listener: ParseTreeListener): 

3695 if hasattr(listener, "enterFormula_simple_C"): 

3696 listener.enterFormula_simple_C(self) 

3697 

3698 def exitRule(self, listener: ParseTreeListener): 

3699 if hasattr(listener, "exitFormula_simple_C"): 

3700 listener.exitFormula_simple_C(self) 

3701 

3702 def formula_simple_C(self): 

3703 

3704 localctx = RParser.Formula_simple_CContext(self, self._ctx, self.state) 

3705 self.enterRule(localctx, 78, self.RULE_formula_simple_C) 

3706 try: 

3707 self.enterOuterAlt(localctx, 1) 

3708 self.state = 721 

3709 self.match(RParser.T__15) 

3710 self.state = 722 

3711 self.expr(0) 

3712 self.state = 723 

3713 self.match(RParser.T__16) 

3714 self.state = 724 

3715 self.formop() 

3716 self.state = 727 

3717 self._errHandler.sync(self) 

3718 token = self._input.LA(1) 

3719 if token in [RParser.ID]: 

3720 self.state = 725 

3721 self.sublistadd() 

3722 pass 

3723 elif token in [RParser.T__17]: 

3724 self.state = 726 

3725 self.match(RParser.T__17) 

3726 pass 

3727 else: 

3728 raise NoViableAltException(self) 

3729 

3730 except RecognitionException as re: 

3731 localctx.exception = re 

3732 self._errHandler.reportError(self, re) 

3733 self._errHandler.recover(self, re) 

3734 finally: 

3735 self.exitRule() 

3736 return localctx 

3737 

3738 class AffectopContext(ParserRuleContext): 

3739 __slots__ = 'parser' 

3740 

3741 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3742 super().__init__(parent, invokingState) 

3743 self.parser = parser 

3744 

3745 def getRuleIndex(self): 

3746 return RParser.RULE_affectop 

3747 

3748 def enterRule(self, listener: ParseTreeListener): 

3749 if hasattr(listener, "enterAffectop"): 

3750 listener.enterAffectop(self) 

3751 

3752 def exitRule(self, listener: ParseTreeListener): 

3753 if hasattr(listener, "exitAffectop"): 

3754 listener.exitAffectop(self) 

3755 

3756 def affectop(self): 

3757 

3758 localctx = RParser.AffectopContext(self, self._ctx, self.state) 

3759 self.enterRule(localctx, 80, self.RULE_affectop) 

3760 self._la = 0 # Token type 

3761 try: 

3762 self.enterOuterAlt(localctx, 1) 

3763 self.state = 729 

3764 _la = self._input.LA(1) 

3765 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__19) | (1 << RParser.T__38) | (1 << RParser.T__39) | (1 << RParser.T__40) | (1 << RParser.T__41) | (1 << RParser.T__42))) != 0)): 

3766 self._errHandler.recoverInline(self) 

3767 else: 

3768 self._errHandler.reportMatch(self) 

3769 self.consume() 

3770 except RecognitionException as re: 

3771 localctx.exception = re 

3772 self._errHandler.reportError(self, re) 

3773 self._errHandler.recover(self, re) 

3774 finally: 

3775 self.exitRule() 

3776 return localctx 

3777 

3778 class FunctiondefContext(ParserRuleContext): 

3779 __slots__ = 'parser' 

3780 

3781 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3782 super().__init__(parent, invokingState) 

3783 self.parser = parser 

3784 

3785 def getRuleIndex(self): 

3786 return RParser.RULE_functiondef 

3787 

3788 def enterRule(self, listener: ParseTreeListener): 

3789 if hasattr(listener, "enterFunctiondef"): 

3790 listener.enterFunctiondef(self) 

3791 

3792 def exitRule(self, listener: ParseTreeListener): 

3793 if hasattr(listener, "exitFunctiondef"): 

3794 listener.exitFunctiondef(self) 

3795 

3796 def functiondef(self): 

3797 

3798 localctx = RParser.FunctiondefContext(self, self._ctx, self.state) 

3799 self.enterRule(localctx, 82, self.RULE_functiondef) 

3800 try: 

3801 self.enterOuterAlt(localctx, 1) 

3802 self.state = 731 

3803 self.match(RParser.T__43) 

3804 except RecognitionException as re: 

3805 localctx.exception = re 

3806 self._errHandler.reportError(self, re) 

3807 self._errHandler.recover(self, re) 

3808 finally: 

3809 self.exitRule() 

3810 return localctx 

3811 

3812 class IdentifierContext(ParserRuleContext): 

3813 __slots__ = 'parser' 

3814 

3815 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3816 super().__init__(parent, invokingState) 

3817 self.parser = parser 

3818 

3819 def ID(self): 

3820 return self.getToken(RParser.ID, 0) 

3821 

3822 def getRuleIndex(self): 

3823 return RParser.RULE_identifier 

3824 

3825 def enterRule(self, listener: ParseTreeListener): 

3826 if hasattr(listener, "enterIdentifier"): 

3827 listener.enterIdentifier(self) 

3828 

3829 def exitRule(self, listener: ParseTreeListener): 

3830 if hasattr(listener, "exitIdentifier"): 

3831 listener.exitIdentifier(self) 

3832 

3833 def identifier(self): 

3834 

3835 localctx = RParser.IdentifierContext(self, self._ctx, self.state) 

3836 self.enterRule(localctx, 84, self.RULE_identifier) 

3837 try: 

3838 self.enterOuterAlt(localctx, 1) 

3839 self.state = 733 

3840 self.match(RParser.ID) 

3841 except RecognitionException as re: 

3842 localctx.exception = re 

3843 self._errHandler.reportError(self, re) 

3844 self._errHandler.recover(self, re) 

3845 finally: 

3846 self.exitRule() 

3847 return localctx 

3848 

3849 class FormopContext(ParserRuleContext): 

3850 __slots__ = 'parser' 

3851 

3852 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3853 super().__init__(parent, invokingState) 

3854 self.parser = parser 

3855 

3856 def getRuleIndex(self): 

3857 return RParser.RULE_formop 

3858 

3859 def enterRule(self, listener: ParseTreeListener): 

3860 if hasattr(listener, "enterFormop"): 

3861 listener.enterFormop(self) 

3862 

3863 def exitRule(self, listener: ParseTreeListener): 

3864 if hasattr(listener, "exitFormop"): 

3865 listener.exitFormop(self) 

3866 

3867 def formop(self): 

3868 

3869 localctx = RParser.FormopContext(self, self._ctx, self.state) 

3870 self.enterRule(localctx, 86, self.RULE_formop) 

3871 try: 

3872 self.enterOuterAlt(localctx, 1) 

3873 self.state = 735 

3874 self.match(RParser.T__44) 

3875 except RecognitionException as re: 

3876 localctx.exception = re 

3877 self._errHandler.reportError(self, re) 

3878 self._errHandler.recover(self, re) 

3879 finally: 

3880 self.exitRule() 

3881 return localctx 

3882 

3883 class RangeopContext(ParserRuleContext): 

3884 __slots__ = 'parser' 

3885 

3886 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3887 super().__init__(parent, invokingState) 

3888 self.parser = parser 

3889 

3890 def getRuleIndex(self): 

3891 return RParser.RULE_rangeop 

3892 

3893 def enterRule(self, listener: ParseTreeListener): 

3894 if hasattr(listener, "enterRangeop"): 

3895 listener.enterRangeop(self) 

3896 

3897 def exitRule(self, listener: ParseTreeListener): 

3898 if hasattr(listener, "exitRangeop"): 

3899 listener.exitRangeop(self) 

3900 

3901 def rangeop(self): 

3902 

3903 localctx = RParser.RangeopContext(self, self._ctx, self.state) 

3904 self.enterRule(localctx, 88, self.RULE_rangeop) 

3905 self._la = 0 # Token type 

3906 try: 

3907 self.enterOuterAlt(localctx, 1) 

3908 self.state = 737 

3909 _la = self._input.LA(1) 

3910 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__22) | (1 << RParser.T__45) | (1 << RParser.T__46))) != 0)): 

3911 self._errHandler.recoverInline(self) 

3912 else: 

3913 self._errHandler.reportMatch(self) 

3914 self.consume() 

3915 except RecognitionException as re: 

3916 localctx.exception = re 

3917 self._errHandler.reportError(self, re) 

3918 self._errHandler.recover(self, re) 

3919 finally: 

3920 self.exitRule() 

3921 return localctx 

3922 

3923 class DotopContext(ParserRuleContext): 

3924 __slots__ = 'parser' 

3925 

3926 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3927 super().__init__(parent, invokingState) 

3928 self.parser = parser 

3929 

3930 def getRuleIndex(self): 

3931 return RParser.RULE_dotop 

3932 

3933 def enterRule(self, listener: ParseTreeListener): 

3934 if hasattr(listener, "enterDotop"): 

3935 listener.enterDotop(self) 

3936 

3937 def exitRule(self, listener: ParseTreeListener): 

3938 if hasattr(listener, "exitDotop"): 

3939 listener.exitDotop(self) 

3940 

3941 def dotop(self): 

3942 

3943 localctx = RParser.DotopContext(self, self._ctx, self.state) 

3944 self.enterRule(localctx, 90, self.RULE_dotop) 

3945 self._la = 0 # Token type 

3946 try: 

3947 self.enterOuterAlt(localctx, 1) 

3948 self.state = 739 

3949 _la = self._input.LA(1) 

3950 if not (_la == RParser.T__47 or _la == RParser.T__48): 

3951 self._errHandler.recoverInline(self) 

3952 else: 

3953 self._errHandler.reportMatch(self) 

3954 self.consume() 

3955 except RecognitionException as re: 

3956 localctx.exception = re 

3957 self._errHandler.reportError(self, re) 

3958 self._errHandler.recover(self, re) 

3959 finally: 

3960 self.exitRule() 

3961 return localctx 

3962 

3963 class OperatorContext(ParserRuleContext): 

3964 __slots__ = 'parser' 

3965 

3966 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

3967 super().__init__(parent, invokingState) 

3968 self.parser = parser 

3969 

3970 def getRuleIndex(self): 

3971 return RParser.RULE_operator 

3972 

3973 def enterRule(self, listener: ParseTreeListener): 

3974 if hasattr(listener, "enterOperator"): 

3975 listener.enterOperator(self) 

3976 

3977 def exitRule(self, listener: ParseTreeListener): 

3978 if hasattr(listener, "exitOperator"): 

3979 listener.exitOperator(self) 

3980 

3981 def operator(self): 

3982 

3983 localctx = RParser.OperatorContext(self, self._ctx, self.state) 

3984 self.enterRule(localctx, 92, self.RULE_operator) 

3985 self._la = 0 # Token type 

3986 try: 

3987 self.enterOuterAlt(localctx, 1) 

3988 self.state = 741 

3989 _la = self._input.LA(1) 

3990 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__4) | (1 << RParser.T__5) | (1 << RParser.T__23) | (1 << RParser.T__49) | (1 << RParser.T__50) | (1 << RParser.T__51) | (1 << RParser.T__52) | (1 << RParser.T__53))) != 0)): 

3991 self._errHandler.recoverInline(self) 

3992 else: 

3993 self._errHandler.reportMatch(self) 

3994 self.consume() 

3995 except RecognitionException as re: 

3996 localctx.exception = re 

3997 self._errHandler.reportError(self, re) 

3998 self._errHandler.recover(self, re) 

3999 finally: 

4000 self.exitRule() 

4001 return localctx 

4002 

4003 class ComparisonContext(ParserRuleContext): 

4004 __slots__ = 'parser' 

4005 

4006 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): 

4007 super().__init__(parent, invokingState) 

4008 self.parser = parser 

4009 

4010 def getRuleIndex(self): 

4011 return RParser.RULE_comparison 

4012 

4013 def enterRule(self, listener: ParseTreeListener): 

4014 if hasattr(listener, "enterComparison"): 

4015 listener.enterComparison(self) 

4016 

4017 def exitRule(self, listener: ParseTreeListener): 

4018 if hasattr(listener, "exitComparison"): 

4019 listener.exitComparison(self) 

4020 

4021 def comparison(self): 

4022 

4023 localctx = RParser.ComparisonContext(self, self._ctx, self.state) 

4024 self.enterRule(localctx, 94, self.RULE_comparison) 

4025 self._la = 0 # Token type 

4026 try: 

4027 self.enterOuterAlt(localctx, 1) 

4028 self.state = 743 

4029 _la = self._input.LA(1) 

4030 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__54) | (1 << RParser.T__55) | (1 << RParser.T__56) | (1 << RParser.T__57) | (1 << RParser.T__58) | (1 << RParser.T__59))) != 0)): 

4031 self._errHandler.recoverInline(self) 

4032 else: 

4033 self._errHandler.reportMatch(self) 

4034 self.consume() 

4035 except RecognitionException as re: 

4036 localctx.exception = re 

4037 self._errHandler.reportError(self, re) 

4038 self._errHandler.recover(self, re) 

4039 finally: 

4040 self.exitRule() 

4041 return localctx 

4042 

4043 def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int): 

4044 if self._predicates == None: 

4045 self._predicates = dict() 

4046 self._predicates[1] = self.expr_sempred 

4047 pred = self._predicates.get(ruleIndex, None) 

4048 if pred is None: 

4049 raise Exception("No predicate with index:" + str(ruleIndex)) 

4050 else: 

4051 return pred(localctx, predIndex) 

4052 

4053 def expr_sempred(self, localctx: ExprContext, predIndex: int): 

4054 if predIndex == 0: 

4055 return self.precpred(self._ctx, 28) 

4056 

4057 if predIndex == 1: 

4058 return self.precpred(self._ctx, 24) 

4059 

4060 if predIndex == 2: 

4061 return self.precpred(self._ctx, 23) 

4062 

4063 if predIndex == 3: 

4064 return self.precpred(self._ctx, 22) 

4065 

4066 if predIndex == 4: 

4067 return self.precpred(self._ctx, 20) 

4068 

4069 if predIndex == 5: 

4070 return self.precpred(self._ctx, 19) 

4071 

4072 if predIndex == 6: 

4073 return self.precpred(self._ctx, 30) 

4074 

4075 if predIndex == 7: 

4076 return self.precpred(self._ctx, 29) 

4077 

4078 if predIndex == 8: 

4079 return self.precpred(self._ctx, 26) 

4080 

4081 if predIndex == 9: 

4082 return self.precpred(self._ctx, 25)