Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1# Generated from \R.g4 by ANTLR 4.9 

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 with StringIO() as buf: 

14 buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3H") 

15 buf.write("\u02ec\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") 

16 buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16") 

17 buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") 

18 buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31") 

19 buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36") 

20 buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t") 

21 buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") 

22 buf.write("/\t/\4\60\t\60\4\61\t\61\3\2\3\2\3\2\3\2\7\2g\n\2\f\2") 

23 buf.write("\16\2j\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3") 

24 buf.write("\3\3\3\3\3\3\3\7\3z\n\3\f\3\16\3}\13\3\3\3\3\3\7\3\u0081") 

25 buf.write("\n\3\f\3\16\3\u0084\13\3\3\3\3\3\7\3\u0088\n\3\f\3\16") 

26 buf.write("\3\u008b\13\3\3\3\3\3\7\3\u008f\n\3\f\3\16\3\u0092\13") 

27 buf.write("\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3") 

28 buf.write("\7\3\u00a1\n\3\f\3\16\3\u00a4\13\3\3\3\3\3\7\3\u00a8\n") 

29 buf.write("\3\f\3\16\3\u00ab\13\3\3\3\3\3\3\3\3\3\5\3\u00b1\n\3\3") 

30 buf.write("\3\3\3\3\3\3\3\3\3\3\3\7\3\u00b9\n\3\f\3\16\3\u00bc\13") 

31 buf.write("\3\3\3\3\3\7\3\u00c0\n\3\f\3\16\3\u00c3\13\3\3\3\3\3\3") 

32 buf.write("\3\7\3\u00c8\n\3\f\3\16\3\u00cb\13\3\3\3\3\3\7\3\u00cf") 

33 buf.write("\n\3\f\3\16\3\u00d2\13\3\3\3\3\3\3\3\3\3\7\3\u00d8\n\3") 

34 buf.write("\f\3\16\3\u00db\13\3\3\3\3\3\7\3\u00df\n\3\f\3\16\3\u00e2") 

35 buf.write("\13\3\3\3\3\3\3\3\3\3\7\3\u00e8\n\3\f\3\16\3\u00eb\13") 

36 buf.write("\3\3\3\3\3\7\3\u00ef\n\3\f\3\16\3\u00f2\13\3\3\3\3\3\3") 

37 buf.write("\3\7\3\u00f7\n\3\f\3\16\3\u00fa\13\3\3\3\3\3\7\3\u00fe") 

38 buf.write("\n\3\f\3\16\3\u0101\13\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3") 

39 buf.write("\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\7\3\u0113\n\3\f\3\16") 

40 buf.write("\3\u0116\13\3\3\4\3\4\7\4\u011a\n\4\f\4\16\4\u011d\13") 

41 buf.write("\4\3\4\3\4\7\4\u0121\n\4\f\4\16\4\u0124\13\4\3\4\3\4\7") 

42 buf.write("\4\u0128\n\4\f\4\16\4\u012b\13\4\3\4\3\4\3\5\3\5\3\5\3") 

43 buf.write("\6\3\6\3\6\7\6\u0135\n\6\f\6\16\6\u0138\13\6\3\6\5\6\u013b") 

44 buf.write("\n\6\3\6\7\6\u013e\n\6\f\6\16\6\u0141\13\6\3\6\3\6\3\7") 

45 buf.write("\3\7\3\7\7\7\u0148\n\7\f\7\16\7\u014b\13\7\3\7\5\7\u014e") 

46 buf.write("\n\7\3\7\7\7\u0151\n\7\f\7\16\7\u0154\13\7\3\7\3\7\3\b") 

47 buf.write("\3\b\3\b\3\b\3\b\3\t\3\t\5\t\u015f\n\t\3\t\3\t\3\n\3\n") 

48 buf.write("\3\n\3\13\3\13\7\13\u0168\n\13\f\13\16\13\u016b\13\13") 

49 buf.write("\3\f\3\f\5\f\u016f\n\f\3\r\3\r\5\r\u0173\n\r\3\r\3\r\7") 

50 buf.write("\r\u0177\n\r\f\r\16\r\u017a\13\r\3\r\7\r\u017d\n\r\f\r") 

51 buf.write("\16\r\u0180\13\r\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u0188") 

52 buf.write("\n\16\3\17\3\17\3\20\3\20\7\20\u018e\n\20\f\20\16\20\u0191") 

53 buf.write("\13\20\3\20\3\20\7\20\u0195\n\20\f\20\16\20\u0198\13\20") 

54 buf.write("\3\20\3\20\5\20\u019c\n\20\3\20\7\20\u019f\n\20\f\20\16") 

55 buf.write("\20\u01a2\13\20\7\20\u01a4\n\20\f\20\16\20\u01a7\13\20") 

56 buf.write("\3\21\3\21\5\21\u01ab\n\21\3\21\3\21\5\21\u01af\n\21\3") 

57 buf.write("\21\3\21\5\21\u01b3\n\21\7\21\u01b5\n\21\f\21\16\21\u01b8") 

58 buf.write("\13\21\3\22\3\22\5\22\u01bc\n\22\3\23\3\23\3\23\3\23\5") 

59 buf.write("\23\u01c2\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23") 

60 buf.write("\3\23\3\23\3\23\3\23\5\23\u01d0\n\23\3\24\3\24\5\24\u01d4") 

61 buf.write("\n\24\3\25\3\25\5\25\u01d8\n\25\3\25\3\25\3\25\5\25\u01dd") 

62 buf.write("\n\25\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27\5\27\u01e7") 

63 buf.write("\n\27\3\30\3\30\5\30\u01eb\n\30\3\30\3\30\3\30\3\31\3") 

64 buf.write("\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32") 

65 buf.write("\3\32\3\32\3\32\3\32\5\32\u0200\n\32\3\33\3\33\3\34\3") 

66 buf.write("\34\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\37") 

67 buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \7 ") 

68 buf.write("\u021c\n \f \16 \u021f\13 \3 \3 \3 \3 \3 \3 \7 \u0227") 

69 buf.write("\n \f \16 \u022a\13 \3 \3 \7 \u022e\n \f \16 \u0231\13") 

70 buf.write(" \7 \u0233\n \f \16 \u0236\13 \3!\3!\3!\3!\3!\7!\u023d") 

71 buf.write("\n!\f!\16!\u0240\13!\3!\3!\7!\u0244\n!\f!\16!\u0247\13") 

72 buf.write("!\3!\3!\3!\3!\3!\7!\u024e\n!\f!\16!\u0251\13!\3!\3!\7") 

73 buf.write("!\u0255\n!\f!\16!\u0258\13!\7!\u025a\n!\f!\16!\u025d\13") 

74 buf.write("!\3!\3!\7!\u0261\n!\f!\16!\u0264\13!\3!\3!\3\"\3\"\3\"") 

75 buf.write("\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\3$\7$\u0279\n") 

76 buf.write("$\f$\16$\u027c\13$\3$\3$\7$\u0280\n$\f$\16$\u0283\13$") 

77 buf.write("\3$\3$\5$\u0287\n$\3%\7%\u028a\n%\f%\16%\u028d\13%\3%") 

78 buf.write("\3%\7%\u0291\n%\f%\16%\u0294\13%\3%\3%\7%\u0298\n%\f%") 

79 buf.write("\16%\u029b\13%\3%\3%\7%\u029f\n%\f%\16%\u02a2\13%\3&\3") 

80 buf.write("&\3&\5&\u02a7\n&\3\'\5\'\u02aa\n\'\3\'\3\'\3\'\5\'\u02af") 

81 buf.write("\n\'\3(\3(\3(\3(\3(\3(\7(\u02b7\n(\f(\16(\u02ba\13(\3") 

82 buf.write("(\3(\3(\7(\u02bf\n(\f(\16(\u02c2\13(\3(\7(\u02c5\n(\f") 

83 buf.write("(\16(\u02c8\13(\3(\3(\3(\3(\3(\3(\5(\u02d0\n(\3(\3(\3") 

84 buf.write(")\3)\3)\3)\3)\3)\5)\u02da\n)\3*\3*\3+\3+\3,\3,\3-\3-\3") 

85 buf.write(".\3.\3/\3/\3\60\3\60\3\61\3\61\3\61\2\3\4\62\2\4\6\b\n") 

86 buf.write("\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<") 

87 buf.write(">@BDFHJLNPRTVXZ\\^`\2\f\4\2\3\3GG\3\2\7\b\3\2\n\13\3\2") 

88 buf.write("\f\r\3\2\36\37\4\2\26\26)-\4\2\31\31\60\61\3\2\62\63\5") 

89 buf.write("\2\7\b\32\32\648\3\29>\2\u0337\2h\3\2\2\2\4\u00b0\3\2") 

90 buf.write("\2\2\6\u0117\3\2\2\2\b\u012e\3\2\2\2\n\u0131\3\2\2\2\f") 

91 buf.write("\u0144\3\2\2\2\16\u0157\3\2\2\2\20\u015c\3\2\2\2\22\u0162") 

92 buf.write("\3\2\2\2\24\u0165\3\2\2\2\26\u016c\3\2\2\2\30\u0170\3") 

93 buf.write("\2\2\2\32\u0187\3\2\2\2\34\u0189\3\2\2\2\36\u018b\3\2") 

94 buf.write("\2\2 \u01a8\3\2\2\2\"\u01bb\3\2\2\2$\u01cf\3\2\2\2&\u01d3") 

95 buf.write("\3\2\2\2(\u01d7\3\2\2\2*\u01de\3\2\2\2,\u01e6\3\2\2\2") 

96 buf.write(".\u01ea\3\2\2\2\60\u01ef\3\2\2\2\62\u01ff\3\2\2\2\64\u0201") 

97 buf.write("\3\2\2\2\66\u0203\3\2\2\28\u0205\3\2\2\2:\u0208\3\2\2") 

98 buf.write("\2<\u020e\3\2\2\2>\u0216\3\2\2\2@\u0237\3\2\2\2B\u0267") 

99 buf.write("\3\2\2\2D\u026a\3\2\2\2F\u026f\3\2\2\2H\u028b\3\2\2\2") 

100 buf.write("J\u02a6\3\2\2\2L\u02a9\3\2\2\2N\u02b0\3\2\2\2P\u02d3\3") 

101 buf.write("\2\2\2R\u02db\3\2\2\2T\u02dd\3\2\2\2V\u02df\3\2\2\2X\u02e1") 

102 buf.write("\3\2\2\2Z\u02e3\3\2\2\2\\\u02e5\3\2\2\2^\u02e7\3\2\2\2") 

103 buf.write("`\u02e9\3\2\2\2bc\5\4\3\2cd\t\2\2\2dg\3\2\2\2eg\7G\2\2") 

104 buf.write("fb\3\2\2\2fe\3\2\2\2gj\3\2\2\2hf\3\2\2\2hi\3\2\2\2ik\3") 

105 buf.write("\2\2\2jh\3\2\2\2kl\7\2\2\3l\3\3\2\2\2mn\b\3\1\2n\u00b1") 

106 buf.write("\5&\24\2o\u00b1\5,\27\2pq\t\3\2\2q\u00b1\5\4\3\35rs\7") 

107 buf.write("\t\2\2s\u00b1\5\4\3\27t\u00b1\5J&\2u\u00b1\5\6\4\2v\u00b1") 

108 buf.write("\5\b\5\2w\u00b1\5F$\2xz\7G\2\2yx\3\2\2\2z}\3\2\2\2{y\3") 

109 buf.write("\2\2\2{|\3\2\2\2|~\3\2\2\2}{\3\2\2\2~\u0082\7\16\2\2\177") 

110 buf.write("\u0081\7G\2\2\u0080\177\3\2\2\2\u0081\u0084\3\2\2\2\u0082") 

111 buf.write("\u0080\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0085\3\2\2\2") 

112 buf.write("\u0084\u0082\3\2\2\2\u0085\u0089\5\24\13\2\u0086\u0088") 

113 buf.write("\7G\2\2\u0087\u0086\3\2\2\2\u0088\u008b\3\2\2\2\u0089") 

114 buf.write("\u0087\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008c\3\2\2\2") 

115 buf.write("\u008b\u0089\3\2\2\2\u008c\u0090\7\17\2\2\u008d\u008f") 

116 buf.write("\7G\2\2\u008e\u008d\3\2\2\2\u008f\u0092\3\2\2\2\u0090") 

117 buf.write("\u008e\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u00b1\3\2\2\2") 

118 buf.write("\u0092\u0090\3\2\2\2\u0093\u00b1\5D#\2\u0094\u00b1\5@") 

119 buf.write("!\2\u0095\u00b1\5> \2\u0096\u00b1\5<\37\2\u0097\u00b1") 

120 buf.write("\5:\36\2\u0098\u00b1\58\35\2\u0099\u009a\7\20\2\2\u009a") 

121 buf.write("\u00b1\5\4\3\t\u009b\u00b1\5\16\b\2\u009c\u00b1\5\66\34") 

122 buf.write("\2\u009d\u00b1\7\21\2\2\u009e\u00a2\7\22\2\2\u009f\u00a1") 

123 buf.write("\7G\2\2\u00a0\u009f\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2") 

124 buf.write("\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a5\3\2\2\2") 

125 buf.write("\u00a4\u00a2\3\2\2\2\u00a5\u00a9\5\4\3\2\u00a6\u00a8\7") 

126 buf.write("G\2\2\u00a7\u00a6\3\2\2\2\u00a8\u00ab\3\2\2\2\u00a9\u00a7") 

127 buf.write("\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ac\3\2\2\2\u00ab") 

128 buf.write("\u00a9\3\2\2\2\u00ac\u00ad\7\23\2\2\u00ad\u00b1\3\2\2") 

129 buf.write("\2\u00ae\u00b1\5\62\32\2\u00af\u00b1\5V,\2\u00b0m\3\2") 

130 buf.write("\2\2\u00b0o\3\2\2\2\u00b0p\3\2\2\2\u00b0r\3\2\2\2\u00b0") 

131 buf.write("t\3\2\2\2\u00b0u\3\2\2\2\u00b0v\3\2\2\2\u00b0w\3\2\2\2") 

132 buf.write("\u00b0{\3\2\2\2\u00b0\u0093\3\2\2\2\u00b0\u0094\3\2\2") 

133 buf.write("\2\u00b0\u0095\3\2\2\2\u00b0\u0096\3\2\2\2\u00b0\u0097") 

134 buf.write("\3\2\2\2\u00b0\u0098\3\2\2\2\u00b0\u0099\3\2\2\2\u00b0") 

135 buf.write("\u009b\3\2\2\2\u00b0\u009c\3\2\2\2\u00b0\u009d\3\2\2\2") 

136 buf.write("\u00b0\u009e\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b0\u00af\3") 

137 buf.write("\2\2\2\u00b1\u0114\3\2\2\2\u00b2\u00b3\f\36\2\2\u00b3") 

138 buf.write("\u00b4\5\\/\2\u00b4\u00b5\5\4\3\37\u00b5\u0113\3\2\2\2") 

139 buf.write("\u00b6\u00ba\f\32\2\2\u00b7\u00b9\7G\2\2\u00b8\u00b7\3") 

140 buf.write("\2\2\2\u00b9\u00bc\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00bb") 

141 buf.write("\3\2\2\2\u00bb\u00bd\3\2\2\2\u00bc\u00ba\3\2\2\2\u00bd") 

142 buf.write("\u00c1\7F\2\2\u00be\u00c0\7G\2\2\u00bf\u00be\3\2\2\2\u00c0") 

143 buf.write("\u00c3\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c1\u00c2\3\2\2\2") 

144 buf.write("\u00c2\u00c4\3\2\2\2\u00c3\u00c1\3\2\2\2\u00c4\u0113\5") 

145 buf.write("\4\3\32\u00c5\u00c9\f\31\2\2\u00c6\u00c8\7G\2\2\u00c7") 

146 buf.write("\u00c6\3\2\2\2\u00c8\u00cb\3\2\2\2\u00c9\u00c7\3\2\2\2") 

147 buf.write("\u00c9\u00ca\3\2\2\2\u00ca\u00cc\3\2\2\2\u00cb\u00c9\3") 

148 buf.write("\2\2\2\u00cc\u00d0\5^\60\2\u00cd\u00cf\7G\2\2\u00ce\u00cd") 

149 buf.write("\3\2\2\2\u00cf\u00d2\3\2\2\2\u00d0\u00ce\3\2\2\2\u00d0") 

150 buf.write("\u00d1\3\2\2\2\u00d1\u00d3\3\2\2\2\u00d2\u00d0\3\2\2\2") 

151 buf.write("\u00d3\u00d4\5\4\3\31\u00d4\u0113\3\2\2\2\u00d5\u00d9") 

152 buf.write("\f\30\2\2\u00d6\u00d8\7G\2\2\u00d7\u00d6\3\2\2\2\u00d8") 

153 buf.write("\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da\3\2\2\2") 

154 buf.write("\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00e0\5") 

155 buf.write("`\61\2\u00dd\u00df\7G\2\2\u00de\u00dd\3\2\2\2\u00df\u00e2") 

156 buf.write("\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1") 

157 buf.write("\u00e3\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3\u00e4\5\4\3\30") 

158 buf.write("\u00e4\u0113\3\2\2\2\u00e5\u00e9\f\26\2\2\u00e6\u00e8") 

159 buf.write("\7G\2\2\u00e7\u00e6\3\2\2\2\u00e8\u00eb\3\2\2\2\u00e9") 

160 buf.write("\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00ec\3\2\2\2") 

161 buf.write("\u00eb\u00e9\3\2\2\2\u00ec\u00f0\t\4\2\2\u00ed\u00ef\7") 

162 buf.write("G\2\2\u00ee\u00ed\3\2\2\2\u00ef\u00f2\3\2\2\2\u00f0\u00ee") 

163 buf.write("\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f3\3\2\2\2\u00f2") 

164 buf.write("\u00f0\3\2\2\2\u00f3\u0113\5\4\3\27\u00f4\u00f8\f\25\2") 

165 buf.write("\2\u00f5\u00f7\7G\2\2\u00f6\u00f5\3\2\2\2\u00f7\u00fa") 

166 buf.write("\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9") 

167 buf.write("\u00fb\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fb\u00ff\t\5\2\2") 

168 buf.write("\u00fc\u00fe\7G\2\2\u00fd\u00fc\3\2\2\2\u00fe\u0101\3") 

169 buf.write("\2\2\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0102") 

170 buf.write("\3\2\2\2\u0101\u00ff\3\2\2\2\u0102\u0113\5\4\3\26\u0103") 

171 buf.write("\u0104\f \2\2\u0104\u0105\7\4\2\2\u0105\u0106\5\36\20") 

172 buf.write("\2\u0106\u0107\7\5\2\2\u0107\u0108\7\5\2\2\u0108\u0113") 

173 buf.write("\3\2\2\2\u0109\u010a\f\37\2\2\u010a\u010b\7\6\2\2\u010b") 

174 buf.write("\u010c\5\36\20\2\u010c\u010d\7\5\2\2\u010d\u0113\3\2\2") 

175 buf.write("\2\u010e\u010f\f\34\2\2\u010f\u0113\5\20\t\2\u0110\u0111") 

176 buf.write("\f\33\2\2\u0111\u0113\5\22\n\2\u0112\u00b2\3\2\2\2\u0112") 

177 buf.write("\u00b6\3\2\2\2\u0112\u00c5\3\2\2\2\u0112\u00d5\3\2\2\2") 

178 buf.write("\u0112\u00e5\3\2\2\2\u0112\u00f4\3\2\2\2\u0112\u0103\3") 

179 buf.write("\2\2\2\u0112\u0109\3\2\2\2\u0112\u010e\3\2\2\2\u0112\u0110") 

180 buf.write("\3\2\2\2\u0113\u0116\3\2\2\2\u0114\u0112\3\2\2\2\u0114") 

181 buf.write("\u0115\3\2\2\2\u0115\5\3\2\2\2\u0116\u0114\3\2\2\2\u0117") 

182 buf.write("\u011b\5\f\7\2\u0118\u011a\7G\2\2\u0119\u0118\3\2\2\2") 

183 buf.write("\u011a\u011d\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011c\3") 

184 buf.write("\2\2\2\u011c\u011e\3\2\2\2\u011d\u011b\3\2\2\2\u011e\u0122") 

185 buf.write("\7\16\2\2\u011f\u0121\7G\2\2\u0120\u011f\3\2\2\2\u0121") 

186 buf.write("\u0124\3\2\2\2\u0122\u0120\3\2\2\2\u0122\u0123\3\2\2\2") 

187 buf.write("\u0123\u0125\3\2\2\2\u0124\u0122\3\2\2\2\u0125\u0129\5") 

188 buf.write("\24\13\2\u0126\u0128\7G\2\2\u0127\u0126\3\2\2\2\u0128") 

189 buf.write("\u012b\3\2\2\2\u0129\u0127\3\2\2\2\u0129\u012a\3\2\2\2") 

190 buf.write("\u012a\u012c\3\2\2\2\u012b\u0129\3\2\2\2\u012c\u012d\7") 

191 buf.write("\17\2\2\u012d\7\3\2\2\2\u012e\u012f\5\n\6\2\u012f\u0130") 

192 buf.write("\5\4\3\2\u0130\t\3\2\2\2\u0131\u0132\5T+\2\u0132\u0136") 

193 buf.write("\7\22\2\2\u0133\u0135\7G\2\2\u0134\u0133\3\2\2\2\u0135") 

194 buf.write("\u0138\3\2\2\2\u0136\u0134\3\2\2\2\u0136\u0137\3\2\2\2") 

195 buf.write("\u0137\u013a\3\2\2\2\u0138\u0136\3\2\2\2\u0139\u013b\5") 

196 buf.write("\30\r\2\u013a\u0139\3\2\2\2\u013a\u013b\3\2\2\2\u013b") 

197 buf.write("\u013f\3\2\2\2\u013c\u013e\7G\2\2\u013d\u013c\3\2\2\2") 

198 buf.write("\u013e\u0141\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3") 

199 buf.write("\2\2\2\u0140\u0142\3\2\2\2\u0141\u013f\3\2\2\2\u0142\u0143") 

200 buf.write("\7\23\2\2\u0143\13\3\2\2\2\u0144\u0145\5T+\2\u0145\u0149") 

201 buf.write("\7\22\2\2\u0146\u0148\7G\2\2\u0147\u0146\3\2\2\2\u0148") 

202 buf.write("\u014b\3\2\2\2\u0149\u0147\3\2\2\2\u0149\u014a\3\2\2\2") 

203 buf.write("\u014a\u014d\3\2\2\2\u014b\u0149\3\2\2\2\u014c\u014e\5") 

204 buf.write("\30\r\2\u014d\u014c\3\2\2\2\u014d\u014e\3\2\2\2\u014e") 

205 buf.write("\u0152\3\2\2\2\u014f\u0151\7G\2\2\u0150\u014f\3\2\2\2") 

206 buf.write("\u0151\u0154\3\2\2\2\u0152\u0150\3\2\2\2\u0152\u0153\3") 

207 buf.write("\2\2\2\u0153\u0155\3\2\2\2\u0154\u0152\3\2\2\2\u0155\u0156") 

208 buf.write("\7\23\2\2\u0156\r\3\2\2\2\u0157\u0158\7\24\2\2\u0158\u0159") 

209 buf.write("\7\22\2\2\u0159\u015a\5V,\2\u015a\u015b\7\23\2\2\u015b") 

210 buf.write("\17\3\2\2\2\u015c\u015e\5R*\2\u015d\u015f\7G\2\2\u015e") 

211 buf.write("\u015d\3\2\2\2\u015e\u015f\3\2\2\2\u015f\u0160\3\2\2\2") 

212 buf.write("\u0160\u0161\5\4\3\2\u0161\21\3\2\2\2\u0162\u0163\5Z.") 

213 buf.write("\2\u0163\u0164\5\4\3\2\u0164\23\3\2\2\2\u0165\u0169\5") 

214 buf.write("\4\3\2\u0166\u0168\5\26\f\2\u0167\u0166\3\2\2\2\u0168") 

215 buf.write("\u016b\3\2\2\2\u0169\u0167\3\2\2\2\u0169\u016a\3\2\2\2") 

216 buf.write("\u016a\25\3\2\2\2\u016b\u0169\3\2\2\2\u016c\u016e\t\2") 

217 buf.write("\2\2\u016d\u016f\5\4\3\2\u016e\u016d\3\2\2\2\u016e\u016f") 

218 buf.write("\3\2\2\2\u016f\27\3\2\2\2\u0170\u017e\5\32\16\2\u0171") 

219 buf.write("\u0173\7G\2\2\u0172\u0171\3\2\2\2\u0172\u0173\3\2\2\2") 

220 buf.write("\u0173\u0174\3\2\2\2\u0174\u0178\7\25\2\2\u0175\u0177") 

221 buf.write("\7G\2\2\u0176\u0175\3\2\2\2\u0177\u017a\3\2\2\2\u0178") 

222 buf.write("\u0176\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017b\3\2\2\2") 

223 buf.write("\u017a\u0178\3\2\2\2\u017b\u017d\5\32\16\2\u017c\u0172") 

224 buf.write("\3\2\2\2\u017d\u0180\3\2\2\2\u017e\u017c\3\2\2\2\u017e") 

225 buf.write("\u017f\3\2\2\2\u017f\31\3\2\2\2\u0180\u017e\3\2\2\2\u0181") 

226 buf.write("\u0188\5\34\17\2\u0182\u0183\5\34\17\2\u0183\u0184\7\26") 

227 buf.write("\2\2\u0184\u0185\5\4\3\2\u0185\u0188\3\2\2\2\u0186\u0188") 

228 buf.write("\7\27\2\2\u0187\u0181\3\2\2\2\u0187\u0182\3\2\2\2\u0187") 

229 buf.write("\u0186\3\2\2\2\u0188\33\3\2\2\2\u0189\u018a\7E\2\2\u018a") 

230 buf.write("\35\3\2\2\2\u018b\u01a5\5\"\22\2\u018c\u018e\7G\2\2\u018d") 

231 buf.write("\u018c\3\2\2\2\u018e\u0191\3\2\2\2\u018f\u018d\3\2\2\2") 

232 buf.write("\u018f\u0190\3\2\2\2\u0190\u0192\3\2\2\2\u0191\u018f\3") 

233 buf.write("\2\2\2\u0192\u0196\7\25\2\2\u0193\u0195\7G\2\2\u0194\u0193") 

234 buf.write("\3\2\2\2\u0195\u0198\3\2\2\2\u0196\u0194\3\2\2\2\u0196") 

235 buf.write("\u0197\3\2\2\2\u0197\u019b\3\2\2\2\u0198\u0196\3\2\2\2") 

236 buf.write("\u0199\u019c\5H%\2\u019a\u019c\5\"\22\2\u019b\u0199\3") 

237 buf.write("\2\2\2\u019b\u019a\3\2\2\2\u019c\u01a0\3\2\2\2\u019d\u019f") 

238 buf.write("\7G\2\2\u019e\u019d\3\2\2\2\u019f\u01a2\3\2\2\2\u01a0") 

239 buf.write("\u019e\3\2\2\2\u01a0\u01a1\3\2\2\2\u01a1\u01a4\3\2\2\2") 

240 buf.write("\u01a2\u01a0\3\2\2\2\u01a3\u018f\3\2\2\2\u01a4\u01a7\3") 

241 buf.write("\2\2\2\u01a5\u01a3\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\37") 

242 buf.write("\3\2\2\2\u01a7\u01a5\3\2\2\2\u01a8\u01b6\5V,\2\u01a9\u01ab") 

243 buf.write("\7G\2\2\u01aa\u01a9\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab") 

244 buf.write("\u01ac\3\2\2\2\u01ac\u01ae\7\b\2\2\u01ad\u01af\7G\2\2") 

245 buf.write("\u01ae\u01ad\3\2\2\2\u01ae\u01af\3\2\2\2\u01af\u01b0\3") 

246 buf.write("\2\2\2\u01b0\u01b2\5V,\2\u01b1\u01b3\7G\2\2\u01b2\u01b1") 

247 buf.write("\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3\u01b5\3\2\2\2\u01b4") 

248 buf.write("\u01aa\3\2\2\2\u01b5\u01b8\3\2\2\2\u01b6\u01b4\3\2\2\2") 

249 buf.write("\u01b6\u01b7\3\2\2\2\u01b7!\3\2\2\2\u01b8\u01b6\3\2\2") 

250 buf.write("\2\u01b9\u01bc\5$\23\2\u01ba\u01bc\5\4\3\2\u01bb\u01b9") 

251 buf.write("\3\2\2\2\u01bb\u01ba\3\2\2\2\u01bc#\3\2\2\2\u01bd\u01be") 

252 buf.write("\5V,\2\u01be\u01c1\7\26\2\2\u01bf\u01c2\5H%\2\u01c0\u01c2") 

253 buf.write("\5\4\3\2\u01c1\u01bf\3\2\2\2\u01c1\u01c0\3\2\2\2\u01c2") 

254 buf.write("\u01d0\3\2\2\2\u01c3\u01c4\7D\2\2\u01c4\u01d0\7\26\2\2") 

255 buf.write("\u01c5\u01c6\7D\2\2\u01c6\u01c7\7\26\2\2\u01c7\u01d0\5") 

256 buf.write("\4\3\2\u01c8\u01c9\7\30\2\2\u01c9\u01d0\7\26\2\2\u01ca") 

257 buf.write("\u01cb\7\30\2\2\u01cb\u01cc\7\26\2\2\u01cc\u01d0\5\4\3") 

258 buf.write("\2\u01cd\u01d0\7\27\2\2\u01ce\u01d0\7\31\2\2\u01cf\u01bd") 

259 buf.write("\3\2\2\2\u01cf\u01c3\3\2\2\2\u01cf\u01c5\3\2\2\2\u01cf") 

260 buf.write("\u01c8\3\2\2\2\u01cf\u01ca\3\2\2\2\u01cf\u01cd\3\2\2\2") 

261 buf.write("\u01cf\u01ce\3\2\2\2\u01d0%\3\2\2\2\u01d1\u01d4\5(\25") 

262 buf.write("\2\u01d2\u01d4\5*\26\2\u01d3\u01d1\3\2\2\2\u01d3\u01d2") 

263 buf.write("\3\2\2\2\u01d4\'\3\2\2\2\u01d5\u01d8\5V,\2\u01d6\u01d8") 

264 buf.write("\7A\2\2\u01d7\u01d5\3\2\2\2\u01d7\u01d6\3\2\2\2\u01d8") 

265 buf.write("\u01d9\3\2\2\2\u01d9\u01dc\7\31\2\2\u01da\u01dd\5V,\2") 

266 buf.write("\u01db\u01dd\7A\2\2\u01dc\u01da\3\2\2\2\u01dc\u01db\3") 

267 buf.write("\2\2\2\u01dd)\3\2\2\2\u01de\u01df\7\22\2\2\u01df\u01e0") 

268 buf.write("\5\4\3\2\u01e0\u01e1\7\23\2\2\u01e1\u01e2\7\31\2\2\u01e2") 

269 buf.write("\u01e3\5\4\3\2\u01e3+\3\2\2\2\u01e4\u01e7\5.\30\2\u01e5") 

270 buf.write("\u01e7\5\60\31\2\u01e6\u01e4\3\2\2\2\u01e6\u01e5\3\2\2") 

271 buf.write("\2\u01e7-\3\2\2\2\u01e8\u01eb\5V,\2\u01e9\u01eb\5\62\32") 

272 buf.write("\2\u01ea\u01e8\3\2\2\2\u01ea\u01e9\3\2\2\2\u01eb\u01ec") 

273 buf.write("\3\2\2\2\u01ec\u01ed\7\32\2\2\u01ed\u01ee\5\4\3\2\u01ee") 

274 buf.write("/\3\2\2\2\u01ef\u01f0\7\22\2\2\u01f0\u01f1\5\4\3\2\u01f1") 

275 buf.write("\u01f2\7\23\2\2\u01f2\u01f3\7\32\2\2\u01f3\u01f4\5\4\3") 

276 buf.write("\2\u01f4\61\3\2\2\2\u01f5\u0200\7D\2\2\u01f6\u0200\7@") 

277 buf.write("\2\2\u01f7\u0200\7A\2\2\u01f8\u0200\7B\2\2\u01f9\u0200") 

278 buf.write("\7C\2\2\u01fa\u0200\7\30\2\2\u01fb\u0200\7\33\2\2\u01fc") 

279 buf.write("\u0200\7\34\2\2\u01fd\u0200\7\35\2\2\u01fe\u0200\5\64") 

280 buf.write("\33\2\u01ff\u01f5\3\2\2\2\u01ff\u01f6\3\2\2\2\u01ff\u01f7") 

281 buf.write("\3\2\2\2\u01ff\u01f8\3\2\2\2\u01ff\u01f9\3\2\2\2\u01ff") 

282 buf.write("\u01fa\3\2\2\2\u01ff\u01fb\3\2\2\2\u01ff\u01fc\3\2\2\2") 

283 buf.write("\u01ff\u01fd\3\2\2\2\u01ff\u01fe\3\2\2\2\u0200\63\3\2") 

284 buf.write("\2\2\u0201\u0202\t\6\2\2\u0202\65\3\2\2\2\u0203\u0204") 

285 buf.write("\7 \2\2\u0204\67\3\2\2\2\u0205\u0206\7!\2\2\u0206\u0207") 

286 buf.write("\5\4\3\2\u02079\3\2\2\2\u0208\u0209\7\"\2\2\u0209\u020a") 

287 buf.write("\7\22\2\2\u020a\u020b\5\4\3\2\u020b\u020c\7\23\2\2\u020c") 

288 buf.write("\u020d\5\4\3\2\u020d;\3\2\2\2\u020e\u020f\7#\2\2\u020f") 

289 buf.write("\u0210\7\22\2\2\u0210\u0211\5V,\2\u0211\u0212\7$\2\2\u0212") 

290 buf.write("\u0213\5\4\3\2\u0213\u0214\7\23\2\2\u0214\u0215\5\4\3") 

291 buf.write("\2\u0215=\3\2\2\2\u0216\u0217\7%\2\2\u0217\u0218\7\22") 

292 buf.write("\2\2\u0218\u0219\5\4\3\2\u0219\u021d\7\23\2\2\u021a\u021c") 

293 buf.write("\7G\2\2\u021b\u021a\3\2\2\2\u021c\u021f\3\2\2\2\u021d") 

294 buf.write("\u021b\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u0220\3\2\2\2") 

295 buf.write("\u021f\u021d\3\2\2\2\u0220\u0234\5\4\3\2\u0221\u0222\5") 

296 buf.write("B\"\2\u0222\u0223\7\22\2\2\u0223\u0224\5\4\3\2\u0224\u0228") 

297 buf.write("\7\23\2\2\u0225\u0227\7G\2\2\u0226\u0225\3\2\2\2\u0227") 

298 buf.write("\u022a\3\2\2\2\u0228\u0226\3\2\2\2\u0228\u0229\3\2\2\2") 

299 buf.write("\u0229\u022b\3\2\2\2\u022a\u0228\3\2\2\2\u022b\u022f\5") 

300 buf.write("\4\3\2\u022c\u022e\7G\2\2\u022d\u022c\3\2\2\2\u022e\u0231") 

301 buf.write("\3\2\2\2\u022f\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230") 

302 buf.write("\u0233\3\2\2\2\u0231\u022f\3\2\2\2\u0232\u0221\3\2\2\2") 

303 buf.write("\u0233\u0236\3\2\2\2\u0234\u0232\3\2\2\2\u0234\u0235\3") 

304 buf.write("\2\2\2\u0235?\3\2\2\2\u0236\u0234\3\2\2\2\u0237\u0238") 

305 buf.write("\7%\2\2\u0238\u0239\7\22\2\2\u0239\u023a\5\4\3\2\u023a") 

306 buf.write("\u023e\7\23\2\2\u023b\u023d\7G\2\2\u023c\u023b\3\2\2\2") 

307 buf.write("\u023d\u0240\3\2\2\2\u023e\u023c\3\2\2\2\u023e\u023f\3") 

308 buf.write("\2\2\2\u023f\u0241\3\2\2\2\u0240\u023e\3\2\2\2\u0241\u0245") 

309 buf.write("\5\4\3\2\u0242\u0244\7G\2\2\u0243\u0242\3\2\2\2\u0244") 

310 buf.write("\u0247\3\2\2\2\u0245\u0243\3\2\2\2\u0245\u0246\3\2\2\2") 

311 buf.write("\u0246\u025b\3\2\2\2\u0247\u0245\3\2\2\2\u0248\u0249\5") 

312 buf.write("B\"\2\u0249\u024a\7\22\2\2\u024a\u024b\5\4\3\2\u024b\u024f") 

313 buf.write("\7\23\2\2\u024c\u024e\7G\2\2\u024d\u024c\3\2\2\2\u024e") 

314 buf.write("\u0251\3\2\2\2\u024f\u024d\3\2\2\2\u024f\u0250\3\2\2\2") 

315 buf.write("\u0250\u0252\3\2\2\2\u0251\u024f\3\2\2\2\u0252\u0256\5") 

316 buf.write("\4\3\2\u0253\u0255\7G\2\2\u0254\u0253\3\2\2\2\u0255\u0258") 

317 buf.write("\3\2\2\2\u0256\u0254\3\2\2\2\u0256\u0257\3\2\2\2\u0257") 

318 buf.write("\u025a\3\2\2\2\u0258\u0256\3\2\2\2\u0259\u0248\3\2\2\2") 

319 buf.write("\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b\u025c\3") 

320 buf.write("\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u0262") 

321 buf.write("\7&\2\2\u025f\u0261\7G\2\2\u0260\u025f\3\2\2\2\u0261\u0264") 

322 buf.write("\3\2\2\2\u0262\u0260\3\2\2\2\u0262\u0263\3\2\2\2\u0263") 

323 buf.write("\u0265\3\2\2\2\u0264\u0262\3\2\2\2\u0265\u0266\5\4\3\2") 

324 buf.write("\u0266A\3\2\2\2\u0267\u0268\7&\2\2\u0268\u0269\7%\2\2") 

325 buf.write("\u0269C\3\2\2\2\u026a\u026b\7\'\2\2\u026b\u026c\7\22\2") 

326 buf.write("\2\u026c\u026d\5\4\3\2\u026d\u026e\7\23\2\2\u026eE\3\2") 

327 buf.write("\2\2\u026f\u0286\5V,\2\u0270\u0271\7\22\2\2\u0271\u0287") 

328 buf.write("\7\23\2\2\u0272\u0273\7\22\2\2\u0273\u0274\5H%\2\u0274") 

329 buf.write("\u0275\7\23\2\2\u0275\u0287\3\2\2\2\u0276\u027a\7\22\2") 

330 buf.write("\2\u0277\u0279\7G\2\2\u0278\u0277\3\2\2\2\u0279\u027c") 

331 buf.write("\3\2\2\2\u027a\u0278\3\2\2\2\u027a\u027b\3\2\2\2\u027b") 

332 buf.write("\u027d\3\2\2\2\u027c\u027a\3\2\2\2\u027d\u0281\5\36\20") 

333 buf.write("\2\u027e\u0280\7G\2\2\u027f\u027e\3\2\2\2\u0280\u0283") 

334 buf.write("\3\2\2\2\u0281\u027f\3\2\2\2\u0281\u0282\3\2\2\2\u0282") 

335 buf.write("\u0284\3\2\2\2\u0283\u0281\3\2\2\2\u0284\u0285\7\23\2") 

336 buf.write("\2\u0285\u0287\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0272") 

337 buf.write("\3\2\2\2\u0286\u0276\3\2\2\2\u0287G\3\2\2\2\u0288\u028a") 

338 buf.write("\7G\2\2\u0289\u0288\3\2\2\2\u028a\u028d\3\2\2\2\u028b") 

339 buf.write("\u0289\3\2\2\2\u028b\u028c\3\2\2\2\u028c\u028e\3\2\2\2") 

340 buf.write("\u028d\u028b\3\2\2\2\u028e\u0292\7\16\2\2\u028f\u0291") 

341 buf.write("\7G\2\2\u0290\u028f\3\2\2\2\u0291\u0294\3\2\2\2\u0292") 

342 buf.write("\u0290\3\2\2\2\u0292\u0293\3\2\2\2\u0293\u0295\3\2\2\2") 

343 buf.write("\u0294\u0292\3\2\2\2\u0295\u0299\5\24\13\2\u0296\u0298") 

344 buf.write("\7G\2\2\u0297\u0296\3\2\2\2\u0298\u029b\3\2\2\2\u0299") 

345 buf.write("\u0297\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u029c\3\2\2\2") 

346 buf.write("\u029b\u0299\3\2\2\2\u029c\u02a0\7\17\2\2\u029d\u029f") 

347 buf.write("\7G\2\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0") 

348 buf.write("\u029e\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1I\3\2\2\2\u02a2") 

349 buf.write("\u02a0\3\2\2\2\u02a3\u02a7\5N(\2\u02a4\u02a7\5L\'\2\u02a5") 

350 buf.write("\u02a7\5P)\2\u02a6\u02a3\3\2\2\2\u02a6\u02a4\3\2\2\2\u02a6") 

351 buf.write("\u02a5\3\2\2\2\u02a7K\3\2\2\2\u02a8\u02aa\5V,\2\u02a9") 

352 buf.write("\u02a8\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ab\3\2\2\2") 

353 buf.write("\u02ab\u02ae\5X-\2\u02ac\u02af\5 \21\2\u02ad\u02af\7\24") 

354 buf.write("\2\2\u02ae\u02ac\3\2\2\2\u02ae\u02ad\3\2\2\2\u02afM\3") 

355 buf.write("\2\2\2\u02b0\u02b1\7(\2\2\u02b1\u02b2\7\22\2\2\u02b2\u02b3") 

356 buf.write("\5V,\2\u02b3\u02cf\7\25\2\2\u02b4\u02b8\7\16\2\2\u02b5") 

357 buf.write("\u02b7\7G\2\2\u02b6\u02b5\3\2\2\2\u02b7\u02ba\3\2\2\2") 

358 buf.write("\u02b8\u02b6\3\2\2\2\u02b8\u02b9\3\2\2\2\u02b9\u02bb\3") 

359 buf.write("\2\2\2\u02ba\u02b8\3\2\2\2\u02bb\u02c0\5\4\3\2\u02bc\u02bd") 

360 buf.write("\7\3\2\2\u02bd\u02bf\5\4\3\2\u02be\u02bc\3\2\2\2\u02bf") 

361 buf.write("\u02c2\3\2\2\2\u02c0\u02be\3\2\2\2\u02c0\u02c1\3\2\2\2") 

362 buf.write("\u02c1\u02c6\3\2\2\2\u02c2\u02c0\3\2\2\2\u02c3\u02c5\7") 

363 buf.write("G\2\2\u02c4\u02c3\3\2\2\2\u02c5\u02c8\3\2\2\2\u02c6\u02c4") 

364 buf.write("\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02c9\3\2\2\2\u02c8") 

365 buf.write("\u02c6\3\2\2\2\u02c9\u02ca\7\17\2\2\u02ca\u02d0\3\2\2") 

366 buf.write("\2\u02cb\u02cc\5V,\2\u02cc\u02cd\5R*\2\u02cd\u02ce\5\4") 

367 buf.write("\3\2\u02ce\u02d0\3\2\2\2\u02cf\u02b4\3\2\2\2\u02cf\u02cb") 

368 buf.write("\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d2\7\23\2\2\u02d2") 

369 buf.write("O\3\2\2\2\u02d3\u02d4\7\22\2\2\u02d4\u02d5\5\4\3\2\u02d5") 

370 buf.write("\u02d6\7\23\2\2\u02d6\u02d9\5X-\2\u02d7\u02da\5 \21\2") 

371 buf.write("\u02d8\u02da\7\24\2\2\u02d9\u02d7\3\2\2\2\u02d9\u02d8") 

372 buf.write("\3\2\2\2\u02daQ\3\2\2\2\u02db\u02dc\t\7\2\2\u02dcS\3\2") 

373 buf.write("\2\2\u02dd\u02de\7.\2\2\u02deU\3\2\2\2\u02df\u02e0\7E") 

374 buf.write("\2\2\u02e0W\3\2\2\2\u02e1\u02e2\7/\2\2\u02e2Y\3\2\2\2") 

375 buf.write("\u02e3\u02e4\t\b\2\2\u02e4[\3\2\2\2\u02e5\u02e6\t\t\2") 

376 buf.write("\2\u02e6]\3\2\2\2\u02e7\u02e8\t\n\2\2\u02e8_\3\2\2\2\u02e9") 

377 buf.write("\u02ea\t\13\2\2\u02eaa\3\2\2\2Rfh{\u0082\u0089\u0090\u00a2") 

378 buf.write("\u00a9\u00b0\u00ba\u00c1\u00c9\u00d0\u00d9\u00e0\u00e9") 

379 buf.write("\u00f0\u00f8\u00ff\u0112\u0114\u011b\u0122\u0129\u0136") 

380 buf.write("\u013a\u013f\u0149\u014d\u0152\u015e\u0169\u016e\u0172") 

381 buf.write("\u0178\u017e\u0187\u018f\u0196\u019b\u01a0\u01a5\u01aa") 

382 buf.write("\u01ae\u01b2\u01b6\u01bb\u01c1\u01cf\u01d3\u01d7\u01dc") 

383 buf.write("\u01e6\u01ea\u01ff\u021d\u0228\u022f\u0234\u023e\u0245") 

384 buf.write("\u024f\u0256\u025b\u0262\u027a\u0281\u0286\u028b\u0292") 

385 buf.write("\u0299\u02a0\u02a6\u02a9\u02ae\u02b8\u02c0\u02c6\u02cf") 

386 buf.write("\u02d9") 

387 return buf.getvalue() 

388 

389 

390class RParser (Parser): 

391 

392 grammarFileName = "R.g4" 

393 

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

395 

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

397 

398 sharedContextCache = PredictionContextCache() 

399 

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

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

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

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

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

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

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

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

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

409 "'<'", "'<='", "'=='", "'!='"] 

410 

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

412 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

413 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

414 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

415 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

416 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

417 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

418 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

419 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

420 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

421 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

422 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

423 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

424 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

425 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

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

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

428 

429 RULE_parse = 0 

430 RULE_expr = 1 

431 RULE_functiondefbody = 2 

432 RULE_functiondeflambda = 3 

433 RULE_functiondefargslambda = 4 

434 RULE_functiondefargs = 5 

435 RULE_implicit_column_name = 6 

436 RULE_affectation = 7 

437 RULE_rangeopexpr = 8 

438 RULE_exprlist = 9 

439 RULE_rightexpr = 10 

440 RULE_formlist = 11 

441 RULE_form = 12 

442 RULE_argumentname = 13 

443 RULE_sublist = 14 

444 RULE_sublistadd = 15 

445 RULE_sub = 16 

446 RULE_subnobracket = 17 

447 RULE_ranges = 18 

448 RULE_range_simple = 19 

449 RULE_range_complexe = 20 

450 RULE_intersections = 21 

451 RULE_intersection_simple = 22 

452 RULE_intersection_complexe = 23 

453 RULE_constant = 24 

454 RULE_boolean = 25 

455 RULE_nextexpr = 26 

456 RULE_repeatexpr = 27 

457 RULE_whileexpr = 28 

458 RULE_forexpr = 29 

459 RULE_ifexpr = 30 

460 RULE_ifelseexpr = 31 

461 RULE_elseif = 32 

462 RULE_returnexpr = 33 

463 RULE_functioncall = 34 

464 RULE_inlinefunction = 35 

465 RULE_formula_simple = 36 

466 RULE_formula_simple_A = 37 

467 RULE_formula_simple_B = 38 

468 RULE_formula_simple_C = 39 

469 RULE_affectop = 40 

470 RULE_functiondef = 41 

471 RULE_identifier = 42 

472 RULE_formop = 43 

473 RULE_rangeop = 44 

474 RULE_dotop = 45 

475 RULE_operator = 46 

476 RULE_comparison = 47 

477 

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

479 "functiondefargslambda", "functiondefargs", "implicit_column_name", 

480 "affectation", "rangeopexpr", "exprlist", "rightexpr", 

481 "formlist", "form", "argumentname", "sublist", "sublistadd", 

482 "sub", "subnobracket", "ranges", "range_simple", "range_complexe", 

483 "intersections", "intersection_simple", "intersection_complexe", 

484 "constant", "boolean", "nextexpr", "repeatexpr", "whileexpr", 

485 "forexpr", "ifexpr", "ifelseexpr", "elseif", "returnexpr", 

486 "functioncall", "inlinefunction", "formula_simple", "formula_simple_A", 

487 "formula_simple_B", "formula_simple_C", "affectop", "functiondef", 

488 "identifier", "formop", "rangeop", "dotop", "operator", 

489 "comparison"] 

490 

491 EOF = Token.EOF 

492 T__0 = 1 

493 T__1 = 2 

494 T__2 = 3 

495 T__3 = 4 

496 T__4 = 5 

497 T__5 = 6 

498 T__6 = 7 

499 T__7 = 8 

500 T__8 = 9 

501 T__9 = 10 

502 T__10 = 11 

503 T__11 = 12 

504 T__12 = 13 

505 T__13 = 14 

506 T__14 = 15 

507 T__15 = 16 

508 T__16 = 17 

509 T__17 = 18 

510 T__18 = 19 

511 T__19 = 20 

512 T__20 = 21 

513 T__21 = 22 

514 T__22 = 23 

515 T__23 = 24 

516 T__24 = 25 

517 T__25 = 26 

518 T__26 = 27 

519 T__27 = 28 

520 T__28 = 29 

521 T__29 = 30 

522 T__30 = 31 

523 T__31 = 32 

524 T__32 = 33 

525 T__33 = 34 

526 T__34 = 35 

527 T__35 = 36 

528 T__36 = 37 

529 T__37 = 38 

530 T__38 = 39 

531 T__39 = 40 

532 T__40 = 41 

533 T__41 = 42 

534 T__42 = 43 

535 T__43 = 44 

536 T__44 = 45 

537 T__45 = 46 

538 T__46 = 47 

539 T__47 = 48 

540 T__48 = 49 

541 T__49 = 50 

542 T__50 = 51 

543 T__51 = 52 

544 T__52 = 53 

545 T__53 = 54 

546 T__54 = 55 

547 T__55 = 56 

548 T__56 = 57 

549 T__57 = 58 

550 T__58 = 59 

551 T__59 = 60 

552 PARENTHESIS = 61 

553 HEX = 62 

554 INT = 63 

555 FLOAT = 64 

556 COMPLEX = 65 

557 STRING = 66 

558 ID = 67 

559 USER_OP = 68 

560 NL = 69 

561 WS = 70 

562 

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

564 super().__init__(input, output) 

565 self.checkVersion("4.9") 

566 self._interp = ParserATNSimulator( 

567 self, self.atn, self.decisionsToDFA, self.sharedContextCache) 

568 self._predicates = None 

569 

570 class ParseContext(ParserRuleContext): 

571 

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

573 super().__init__(parent, invokingState) 

574 self.parser = parser 

575 

576 def EOF(self): 

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

578 

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

580 if i is None: 

581 return self.getTypedRuleContexts(RParser.ExprContext) 

582 else: 

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

584 

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

586 if i is None: 

587 return self.getTokens(RParser.NL) 

588 else: 

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

590 

591 def getRuleIndex(self): 

592 return RParser.RULE_parse 

593 

594 def enterRule(self, listener: ParseTreeListener): 

595 if hasattr(listener, "enterParse"): 

596 listener.enterParse(self) 

597 

598 def exitRule(self, listener: ParseTreeListener): 

599 if hasattr(listener, "exitParse"): 

600 listener.exitParse(self) 

601 

602 def parse(self): 

603 

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

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

606 self._la = 0 # Token type 

607 try: 

608 self.enterOuterAlt(localctx, 1) 

609 self.state = 102 

610 self._errHandler.sync(self) 

611 _la = self._input.LA(1) 

612 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): 

613 self.state = 100 

614 self._errHandler.sync(self) 

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

616 if la_ == 1: 

617 self.state = 96 

618 self.expr(0) 

619 self.state = 97 

620 _la = self._input.LA(1) 

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

622 self._errHandler.recoverInline(self) 

623 else: 

624 self._errHandler.reportMatch(self) 

625 self.consume() 

626 pass 

627 

628 elif la_ == 2: 

629 self.state = 99 

630 self.match(RParser.NL) 

631 pass 

632 

633 self.state = 104 

634 self._errHandler.sync(self) 

635 _la = self._input.LA(1) 

636 

637 self.state = 105 

638 self.match(RParser.EOF) 

639 except RecognitionException as re: 

640 localctx.exception = re 

641 self._errHandler.reportError(self, re) 

642 self._errHandler.recover(self, re) 

643 finally: 

644 self.exitRule() 

645 return localctx 

646 

647 class ExprContext(ParserRuleContext): 

648 

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

650 super().__init__(parent, invokingState) 

651 self.parser = parser 

652 

653 def ranges(self): 

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

655 

656 def intersections(self): 

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

658 

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

660 if i is None: 

661 return self.getTypedRuleContexts(RParser.ExprContext) 

662 else: 

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

664 

665 def formula_simple(self): 

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

667 

668 def functiondefbody(self): 

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

670 

671 def functiondeflambda(self): 

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

673 

674 def functioncall(self): 

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

676 

677 def exprlist(self): 

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

679 

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

681 if i is None: 

682 return self.getTokens(RParser.NL) 

683 else: 

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

685 

686 def returnexpr(self): 

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

688 

689 def ifelseexpr(self): 

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

691 

692 def ifexpr(self): 

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

694 

695 def forexpr(self): 

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

697 

698 def whileexpr(self): 

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

700 

701 def repeatexpr(self): 

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

703 

704 def implicit_column_name(self): 

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

706 

707 def nextexpr(self): 

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

709 

710 def constant(self): 

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

712 

713 def identifier(self): 

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

715 

716 def dotop(self): 

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

718 

719 def USER_OP(self): 

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

721 

722 def operator(self): 

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

724 

725 def comparison(self): 

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

727 

728 def sublist(self): 

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

730 

731 def affectation(self): 

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

733 

734 def rangeopexpr(self): 

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

736 

737 def getRuleIndex(self): 

738 return RParser.RULE_expr 

739 

740 def enterRule(self, listener: ParseTreeListener): 

741 if hasattr(listener, "enterExpr"): 

742 listener.enterExpr(self) 

743 

744 def exitRule(self, listener: ParseTreeListener): 

745 if hasattr(listener, "exitExpr"): 

746 listener.exitExpr(self) 

747 

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

749 _parentctx = self._ctx 

750 _parentState = self.state 

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

752 _prevctx = localctx 

753 _startState = 2 

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

755 self._la = 0 # Token type 

756 try: 

757 self.enterOuterAlt(localctx, 1) 

758 self.state = 174 

759 self._errHandler.sync(self) 

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

761 if la_ == 1: 

762 self.state = 108 

763 self.ranges() 

764 pass 

765 

766 elif la_ == 2: 

767 self.state = 109 

768 self.intersections() 

769 pass 

770 

771 elif la_ == 3: 

772 self.state = 110 

773 _la = self._input.LA(1) 

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

775 self._errHandler.recoverInline(self) 

776 else: 

777 self._errHandler.reportMatch(self) 

778 self.consume() 

779 self.state = 111 

780 self.expr(27) 

781 pass 

782 

783 elif la_ == 4: 

784 self.state = 112 

785 self.match(RParser.T__6) 

786 self.state = 113 

787 self.expr(21) 

788 pass 

789 

790 elif la_ == 5: 

791 self.state = 114 

792 self.formula_simple() 

793 pass 

794 

795 elif la_ == 6: 

796 self.state = 115 

797 self.functiondefbody() 

798 pass 

799 

800 elif la_ == 7: 

801 self.state = 116 

802 self.functiondeflambda() 

803 pass 

804 

805 elif la_ == 8: 

806 self.state = 117 

807 self.functioncall() 

808 pass 

809 

810 elif la_ == 9: 

811 self.state = 121 

812 self._errHandler.sync(self) 

813 _la = self._input.LA(1) 

814 while _la == RParser.NL: 

815 self.state = 118 

816 self.match(RParser.NL) 

817 self.state = 123 

818 self._errHandler.sync(self) 

819 _la = self._input.LA(1) 

820 

821 self.state = 124 

822 self.match(RParser.T__11) 

823 self.state = 128 

824 self._errHandler.sync(self) 

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

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

827 if _alt == 1: 

828 self.state = 125 

829 self.match(RParser.NL) 

830 self.state = 130 

831 self._errHandler.sync(self) 

832 _alt = self._interp.adaptivePredict( 

833 self._input, 3, self._ctx) 

834 

835 self.state = 131 

836 self.exprlist() 

837 self.state = 135 

838 self._errHandler.sync(self) 

839 _la = self._input.LA(1) 

840 while _la == RParser.NL: 

841 self.state = 132 

842 self.match(RParser.NL) 

843 self.state = 137 

844 self._errHandler.sync(self) 

845 _la = self._input.LA(1) 

846 

847 self.state = 138 

848 self.match(RParser.T__12) 

849 self.state = 142 

850 self._errHandler.sync(self) 

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

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

853 if _alt == 1: 

854 self.state = 139 

855 self.match(RParser.NL) 

856 self.state = 144 

857 self._errHandler.sync(self) 

858 _alt = self._interp.adaptivePredict( 

859 self._input, 5, self._ctx) 

860 

861 pass 

862 

863 elif la_ == 10: 

864 self.state = 145 

865 self.returnexpr() 

866 pass 

867 

868 elif la_ == 11: 

869 self.state = 146 

870 self.ifelseexpr() 

871 pass 

872 

873 elif la_ == 12: 

874 self.state = 147 

875 self.ifexpr() 

876 pass 

877 

878 elif la_ == 13: 

879 self.state = 148 

880 self.forexpr() 

881 pass 

882 

883 elif la_ == 14: 

884 self.state = 149 

885 self.whileexpr() 

886 pass 

887 

888 elif la_ == 15: 

889 self.state = 150 

890 self.repeatexpr() 

891 pass 

892 

893 elif la_ == 16: 

894 self.state = 151 

895 self.match(RParser.T__13) 

896 self.state = 152 

897 self.expr(7) 

898 pass 

899 

900 elif la_ == 17: 

901 self.state = 153 

902 self.implicit_column_name() 

903 pass 

904 

905 elif la_ == 18: 

906 self.state = 154 

907 self.nextexpr() 

908 pass 

909 

910 elif la_ == 19: 

911 self.state = 155 

912 self.match(RParser.T__14) 

913 pass 

914 

915 elif la_ == 20: 

916 self.state = 156 

917 self.match(RParser.T__15) 

918 self.state = 160 

919 self._errHandler.sync(self) 

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

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

922 if _alt == 1: 

923 self.state = 157 

924 self.match(RParser.NL) 

925 self.state = 162 

926 self._errHandler.sync(self) 

927 _alt = self._interp.adaptivePredict( 

928 self._input, 6, self._ctx) 

929 

930 self.state = 163 

931 self.expr(0) 

932 self.state = 167 

933 self._errHandler.sync(self) 

934 _la = self._input.LA(1) 

935 while _la == RParser.NL: 

936 self.state = 164 

937 self.match(RParser.NL) 

938 self.state = 169 

939 self._errHandler.sync(self) 

940 _la = self._input.LA(1) 

941 

942 self.state = 170 

943 self.match(RParser.T__16) 

944 pass 

945 

946 elif la_ == 21: 

947 self.state = 172 

948 self.constant() 

949 pass 

950 

951 elif la_ == 22: 

952 self.state = 173 

953 self.identifier() 

954 pass 

955 

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

957 self.state = 274 

958 self._errHandler.sync(self) 

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

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

961 if _alt == 1: 

962 if self._parseListeners is not None: 

963 self.triggerExitRuleEvent() 

964 _prevctx = localctx 

965 self.state = 272 

966 self._errHandler.sync(self) 

967 la_ = self._interp.adaptivePredict( 

968 self._input, 19, self._ctx) 

969 if la_ == 1: 

970 localctx = RParser.ExprContext( 

971 self, _parentctx, _parentState) 

972 self.pushNewRecursionContext( 

973 localctx, _startState, self.RULE_expr) 

974 self.state = 176 

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

976 from antlr4.error.Errors import FailedPredicateException 

977 raise FailedPredicateException( 

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

979 self.state = 177 

980 self.dotop() 

981 self.state = 178 

982 self.expr(29) 

983 pass 

984 

985 elif la_ == 2: 

986 localctx = RParser.ExprContext( 

987 self, _parentctx, _parentState) 

988 self.pushNewRecursionContext( 

989 localctx, _startState, self.RULE_expr) 

990 self.state = 180 

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

992 from antlr4.error.Errors import FailedPredicateException 

993 raise FailedPredicateException( 

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

995 self.state = 184 

996 self._errHandler.sync(self) 

997 _la = self._input.LA(1) 

998 while _la == RParser.NL: 

999 self.state = 181 

1000 self.match(RParser.NL) 

1001 self.state = 186 

1002 self._errHandler.sync(self) 

1003 _la = self._input.LA(1) 

1004 

1005 self.state = 187 

1006 self.match(RParser.USER_OP) 

1007 self.state = 191 

1008 self._errHandler.sync(self) 

1009 _alt = self._interp.adaptivePredict( 

1010 self._input, 10, self._ctx) 

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

1012 if _alt == 1: 

1013 self.state = 188 

1014 self.match(RParser.NL) 

1015 self.state = 193 

1016 self._errHandler.sync(self) 

1017 _alt = self._interp.adaptivePredict( 

1018 self._input, 10, self._ctx) 

1019 

1020 self.state = 194 

1021 self.expr(24) 

1022 pass 

1023 

1024 elif la_ == 3: 

1025 localctx = RParser.ExprContext( 

1026 self, _parentctx, _parentState) 

1027 self.pushNewRecursionContext( 

1028 localctx, _startState, self.RULE_expr) 

1029 self.state = 195 

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

1031 from antlr4.error.Errors import FailedPredicateException 

1032 raise FailedPredicateException( 

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

1034 self.state = 199 

1035 self._errHandler.sync(self) 

1036 _la = self._input.LA(1) 

1037 while _la == RParser.NL: 

1038 self.state = 196 

1039 self.match(RParser.NL) 

1040 self.state = 201 

1041 self._errHandler.sync(self) 

1042 _la = self._input.LA(1) 

1043 

1044 self.state = 202 

1045 self.operator() 

1046 self.state = 206 

1047 self._errHandler.sync(self) 

1048 _alt = self._interp.adaptivePredict( 

1049 self._input, 12, self._ctx) 

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

1051 if _alt == 1: 

1052 self.state = 203 

1053 self.match(RParser.NL) 

1054 self.state = 208 

1055 self._errHandler.sync(self) 

1056 _alt = self._interp.adaptivePredict( 

1057 self._input, 12, self._ctx) 

1058 

1059 self.state = 209 

1060 self.expr(23) 

1061 pass 

1062 

1063 elif la_ == 4: 

1064 localctx = RParser.ExprContext( 

1065 self, _parentctx, _parentState) 

1066 self.pushNewRecursionContext( 

1067 localctx, _startState, self.RULE_expr) 

1068 self.state = 211 

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

1070 from antlr4.error.Errors import FailedPredicateException 

1071 raise FailedPredicateException( 

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

1073 self.state = 215 

1074 self._errHandler.sync(self) 

1075 _la = self._input.LA(1) 

1076 while _la == RParser.NL: 

1077 self.state = 212 

1078 self.match(RParser.NL) 

1079 self.state = 217 

1080 self._errHandler.sync(self) 

1081 _la = self._input.LA(1) 

1082 

1083 self.state = 218 

1084 self.comparison() 

1085 self.state = 222 

1086 self._errHandler.sync(self) 

1087 _alt = self._interp.adaptivePredict( 

1088 self._input, 14, self._ctx) 

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

1090 if _alt == 1: 

1091 self.state = 219 

1092 self.match(RParser.NL) 

1093 self.state = 224 

1094 self._errHandler.sync(self) 

1095 _alt = self._interp.adaptivePredict( 

1096 self._input, 14, self._ctx) 

1097 

1098 self.state = 225 

1099 self.expr(22) 

1100 pass 

1101 

1102 elif la_ == 5: 

1103 localctx = RParser.ExprContext( 

1104 self, _parentctx, _parentState) 

1105 self.pushNewRecursionContext( 

1106 localctx, _startState, self.RULE_expr) 

1107 self.state = 227 

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

1109 from antlr4.error.Errors import FailedPredicateException 

1110 raise FailedPredicateException( 

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

1112 self.state = 231 

1113 self._errHandler.sync(self) 

1114 _la = self._input.LA(1) 

1115 while _la == RParser.NL: 

1116 self.state = 228 

1117 self.match(RParser.NL) 

1118 self.state = 233 

1119 self._errHandler.sync(self) 

1120 _la = self._input.LA(1) 

1121 

1122 self.state = 234 

1123 _la = self._input.LA(1) 

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

1125 self._errHandler.recoverInline(self) 

1126 else: 

1127 self._errHandler.reportMatch(self) 

1128 self.consume() 

1129 self.state = 238 

1130 self._errHandler.sync(self) 

1131 _alt = self._interp.adaptivePredict( 

1132 self._input, 16, self._ctx) 

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

1134 if _alt == 1: 

1135 self.state = 235 

1136 self.match(RParser.NL) 

1137 self.state = 240 

1138 self._errHandler.sync(self) 

1139 _alt = self._interp.adaptivePredict( 

1140 self._input, 16, self._ctx) 

1141 

1142 self.state = 241 

1143 self.expr(21) 

1144 pass 

1145 

1146 elif la_ == 6: 

1147 localctx = RParser.ExprContext( 

1148 self, _parentctx, _parentState) 

1149 self.pushNewRecursionContext( 

1150 localctx, _startState, self.RULE_expr) 

1151 self.state = 242 

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

1153 from antlr4.error.Errors import FailedPredicateException 

1154 raise FailedPredicateException( 

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

1156 self.state = 246 

1157 self._errHandler.sync(self) 

1158 _la = self._input.LA(1) 

1159 while _la == RParser.NL: 

1160 self.state = 243 

1161 self.match(RParser.NL) 

1162 self.state = 248 

1163 self._errHandler.sync(self) 

1164 _la = self._input.LA(1) 

1165 

1166 self.state = 249 

1167 _la = self._input.LA(1) 

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

1169 self._errHandler.recoverInline(self) 

1170 else: 

1171 self._errHandler.reportMatch(self) 

1172 self.consume() 

1173 self.state = 253 

1174 self._errHandler.sync(self) 

1175 _alt = self._interp.adaptivePredict( 

1176 self._input, 18, self._ctx) 

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

1178 if _alt == 1: 

1179 self.state = 250 

1180 self.match(RParser.NL) 

1181 self.state = 255 

1182 self._errHandler.sync(self) 

1183 _alt = self._interp.adaptivePredict( 

1184 self._input, 18, self._ctx) 

1185 

1186 self.state = 256 

1187 self.expr(20) 

1188 pass 

1189 

1190 elif la_ == 7: 

1191 localctx = RParser.ExprContext( 

1192 self, _parentctx, _parentState) 

1193 self.pushNewRecursionContext( 

1194 localctx, _startState, self.RULE_expr) 

1195 self.state = 257 

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

1197 from antlr4.error.Errors import FailedPredicateException 

1198 raise FailedPredicateException( 

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

1200 self.state = 258 

1201 self.match(RParser.T__1) 

1202 self.state = 259 

1203 self.sublist() 

1204 self.state = 260 

1205 self.match(RParser.T__2) 

1206 self.state = 261 

1207 self.match(RParser.T__2) 

1208 pass 

1209 

1210 elif la_ == 8: 

1211 localctx = RParser.ExprContext( 

1212 self, _parentctx, _parentState) 

1213 self.pushNewRecursionContext( 

1214 localctx, _startState, self.RULE_expr) 

1215 self.state = 263 

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

1217 from antlr4.error.Errors import FailedPredicateException 

1218 raise FailedPredicateException( 

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

1220 self.state = 264 

1221 self.match(RParser.T__3) 

1222 self.state = 265 

1223 self.sublist() 

1224 self.state = 266 

1225 self.match(RParser.T__2) 

1226 pass 

1227 

1228 elif la_ == 9: 

1229 localctx = RParser.ExprContext( 

1230 self, _parentctx, _parentState) 

1231 self.pushNewRecursionContext( 

1232 localctx, _startState, self.RULE_expr) 

1233 self.state = 268 

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

1235 from antlr4.error.Errors import FailedPredicateException 

1236 raise FailedPredicateException( 

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

1238 self.state = 269 

1239 self.affectation() 

1240 pass 

1241 

1242 elif la_ == 10: 

1243 localctx = RParser.ExprContext( 

1244 self, _parentctx, _parentState) 

1245 self.pushNewRecursionContext( 

1246 localctx, _startState, self.RULE_expr) 

1247 self.state = 270 

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

1249 from antlr4.error.Errors import FailedPredicateException 

1250 raise FailedPredicateException( 

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

1252 self.state = 271 

1253 self.rangeopexpr() 

1254 pass 

1255 

1256 self.state = 276 

1257 self._errHandler.sync(self) 

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

1259 

1260 except RecognitionException as re: 

1261 localctx.exception = re 

1262 self._errHandler.reportError(self, re) 

1263 self._errHandler.recover(self, re) 

1264 finally: 

1265 self.unrollRecursionContexts(_parentctx) 

1266 return localctx 

1267 

1268 class FunctiondefbodyContext(ParserRuleContext): 

1269 

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

1271 super().__init__(parent, invokingState) 

1272 self.parser = parser 

1273 

1274 def functiondefargs(self): 

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

1276 

1277 def exprlist(self): 

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

1279 

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

1281 if i is None: 

1282 return self.getTokens(RParser.NL) 

1283 else: 

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

1285 

1286 def getRuleIndex(self): 

1287 return RParser.RULE_functiondefbody 

1288 

1289 def enterRule(self, listener: ParseTreeListener): 

1290 if hasattr(listener, "enterFunctiondefbody"): 

1291 listener.enterFunctiondefbody(self) 

1292 

1293 def exitRule(self, listener: ParseTreeListener): 

1294 if hasattr(listener, "exitFunctiondefbody"): 

1295 listener.exitFunctiondefbody(self) 

1296 

1297 def functiondefbody(self): 

1298 

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

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

1301 self._la = 0 # Token type 

1302 try: 

1303 self.enterOuterAlt(localctx, 1) 

1304 self.state = 277 

1305 self.functiondefargs() 

1306 self.state = 281 

1307 self._errHandler.sync(self) 

1308 _la = self._input.LA(1) 

1309 while _la == RParser.NL: 

1310 self.state = 278 

1311 self.match(RParser.NL) 

1312 self.state = 283 

1313 self._errHandler.sync(self) 

1314 _la = self._input.LA(1) 

1315 

1316 self.state = 284 

1317 self.match(RParser.T__11) 

1318 self.state = 288 

1319 self._errHandler.sync(self) 

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

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

1322 if _alt == 1: 

1323 self.state = 285 

1324 self.match(RParser.NL) 

1325 self.state = 290 

1326 self._errHandler.sync(self) 

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

1328 

1329 self.state = 291 

1330 self.exprlist() 

1331 self.state = 295 

1332 self._errHandler.sync(self) 

1333 _la = self._input.LA(1) 

1334 while _la == RParser.NL: 

1335 self.state = 292 

1336 self.match(RParser.NL) 

1337 self.state = 297 

1338 self._errHandler.sync(self) 

1339 _la = self._input.LA(1) 

1340 

1341 self.state = 298 

1342 self.match(RParser.T__12) 

1343 except RecognitionException as re: 

1344 localctx.exception = re 

1345 self._errHandler.reportError(self, re) 

1346 self._errHandler.recover(self, re) 

1347 finally: 

1348 self.exitRule() 

1349 return localctx 

1350 

1351 class FunctiondeflambdaContext(ParserRuleContext): 

1352 

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

1354 super().__init__(parent, invokingState) 

1355 self.parser = parser 

1356 

1357 def functiondefargslambda(self): 

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

1359 

1360 def expr(self): 

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

1362 

1363 def getRuleIndex(self): 

1364 return RParser.RULE_functiondeflambda 

1365 

1366 def enterRule(self, listener: ParseTreeListener): 

1367 if hasattr(listener, "enterFunctiondeflambda"): 

1368 listener.enterFunctiondeflambda(self) 

1369 

1370 def exitRule(self, listener: ParseTreeListener): 

1371 if hasattr(listener, "exitFunctiondeflambda"): 

1372 listener.exitFunctiondeflambda(self) 

1373 

1374 def functiondeflambda(self): 

1375 

1376 localctx = RParser.FunctiondeflambdaContext( 

1377 self, self._ctx, self.state) 

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

1379 try: 

1380 self.enterOuterAlt(localctx, 1) 

1381 self.state = 300 

1382 self.functiondefargslambda() 

1383 self.state = 301 

1384 self.expr(0) 

1385 except RecognitionException as re: 

1386 localctx.exception = re 

1387 self._errHandler.reportError(self, re) 

1388 self._errHandler.recover(self, re) 

1389 finally: 

1390 self.exitRule() 

1391 return localctx 

1392 

1393 class FunctiondefargslambdaContext(ParserRuleContext): 

1394 

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

1396 super().__init__(parent, invokingState) 

1397 self.parser = parser 

1398 

1399 def functiondef(self): 

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

1401 

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

1403 if i is None: 

1404 return self.getTokens(RParser.NL) 

1405 else: 

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

1407 

1408 def formlist(self): 

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

1410 

1411 def getRuleIndex(self): 

1412 return RParser.RULE_functiondefargslambda 

1413 

1414 def enterRule(self, listener: ParseTreeListener): 

1415 if hasattr(listener, "enterFunctiondefargslambda"): 

1416 listener.enterFunctiondefargslambda(self) 

1417 

1418 def exitRule(self, listener: ParseTreeListener): 

1419 if hasattr(listener, "exitFunctiondefargslambda"): 

1420 listener.exitFunctiondefargslambda(self) 

1421 

1422 def functiondefargslambda(self): 

1423 

1424 localctx = RParser.FunctiondefargslambdaContext( 

1425 self, self._ctx, self.state) 

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

1427 self._la = 0 # Token type 

1428 try: 

1429 self.enterOuterAlt(localctx, 1) 

1430 self.state = 303 

1431 self.functiondef() 

1432 self.state = 304 

1433 self.match(RParser.T__15) 

1434 self.state = 308 

1435 self._errHandler.sync(self) 

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

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

1438 if _alt == 1: 

1439 self.state = 305 

1440 self.match(RParser.NL) 

1441 self.state = 310 

1442 self._errHandler.sync(self) 

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

1444 

1445 self.state = 312 

1446 self._errHandler.sync(self) 

1447 _la = self._input.LA(1) 

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

1449 self.state = 311 

1450 self.formlist() 

1451 

1452 self.state = 317 

1453 self._errHandler.sync(self) 

1454 _la = self._input.LA(1) 

1455 while _la == RParser.NL: 

1456 self.state = 314 

1457 self.match(RParser.NL) 

1458 self.state = 319 

1459 self._errHandler.sync(self) 

1460 _la = self._input.LA(1) 

1461 

1462 self.state = 320 

1463 self.match(RParser.T__16) 

1464 except RecognitionException as re: 

1465 localctx.exception = re 

1466 self._errHandler.reportError(self, re) 

1467 self._errHandler.recover(self, re) 

1468 finally: 

1469 self.exitRule() 

1470 return localctx 

1471 

1472 class FunctiondefargsContext(ParserRuleContext): 

1473 

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

1475 super().__init__(parent, invokingState) 

1476 self.parser = parser 

1477 

1478 def functiondef(self): 

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

1480 

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

1482 if i is None: 

1483 return self.getTokens(RParser.NL) 

1484 else: 

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

1486 

1487 def formlist(self): 

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

1489 

1490 def getRuleIndex(self): 

1491 return RParser.RULE_functiondefargs 

1492 

1493 def enterRule(self, listener: ParseTreeListener): 

1494 if hasattr(listener, "enterFunctiondefargs"): 

1495 listener.enterFunctiondefargs(self) 

1496 

1497 def exitRule(self, listener: ParseTreeListener): 

1498 if hasattr(listener, "exitFunctiondefargs"): 

1499 listener.exitFunctiondefargs(self) 

1500 

1501 def functiondefargs(self): 

1502 

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

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

1505 self._la = 0 # Token type 

1506 try: 

1507 self.enterOuterAlt(localctx, 1) 

1508 self.state = 322 

1509 self.functiondef() 

1510 self.state = 323 

1511 self.match(RParser.T__15) 

1512 self.state = 327 

1513 self._errHandler.sync(self) 

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

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

1516 if _alt == 1: 

1517 self.state = 324 

1518 self.match(RParser.NL) 

1519 self.state = 329 

1520 self._errHandler.sync(self) 

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

1522 

1523 self.state = 331 

1524 self._errHandler.sync(self) 

1525 _la = self._input.LA(1) 

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

1527 self.state = 330 

1528 self.formlist() 

1529 

1530 self.state = 336 

1531 self._errHandler.sync(self) 

1532 _la = self._input.LA(1) 

1533 while _la == RParser.NL: 

1534 self.state = 333 

1535 self.match(RParser.NL) 

1536 self.state = 338 

1537 self._errHandler.sync(self) 

1538 _la = self._input.LA(1) 

1539 

1540 self.state = 339 

1541 self.match(RParser.T__16) 

1542 except RecognitionException as re: 

1543 localctx.exception = re 

1544 self._errHandler.reportError(self, re) 

1545 self._errHandler.recover(self, re) 

1546 finally: 

1547 self.exitRule() 

1548 return localctx 

1549 

1550 class Implicit_column_nameContext(ParserRuleContext): 

1551 

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

1553 super().__init__(parent, invokingState) 

1554 self.parser = parser 

1555 

1556 def identifier(self): 

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

1558 

1559 def getRuleIndex(self): 

1560 return RParser.RULE_implicit_column_name 

1561 

1562 def enterRule(self, listener: ParseTreeListener): 

1563 if hasattr(listener, "enterImplicit_column_name"): 

1564 listener.enterImplicit_column_name(self) 

1565 

1566 def exitRule(self, listener: ParseTreeListener): 

1567 if hasattr(listener, "exitImplicit_column_name"): 

1568 listener.exitImplicit_column_name(self) 

1569 

1570 def implicit_column_name(self): 

1571 

1572 localctx = RParser.Implicit_column_nameContext( 

1573 self, self._ctx, self.state) 

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

1575 try: 

1576 self.enterOuterAlt(localctx, 1) 

1577 self.state = 341 

1578 self.match(RParser.T__17) 

1579 self.state = 342 

1580 self.match(RParser.T__15) 

1581 self.state = 343 

1582 self.identifier() 

1583 self.state = 344 

1584 self.match(RParser.T__16) 

1585 except RecognitionException as re: 

1586 localctx.exception = re 

1587 self._errHandler.reportError(self, re) 

1588 self._errHandler.recover(self, re) 

1589 finally: 

1590 self.exitRule() 

1591 return localctx 

1592 

1593 class AffectationContext(ParserRuleContext): 

1594 

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

1596 super().__init__(parent, invokingState) 

1597 self.parser = parser 

1598 

1599 def affectop(self): 

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

1601 

1602 def expr(self): 

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

1604 

1605 def NL(self): 

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

1607 

1608 def getRuleIndex(self): 

1609 return RParser.RULE_affectation 

1610 

1611 def enterRule(self, listener: ParseTreeListener): 

1612 if hasattr(listener, "enterAffectation"): 

1613 listener.enterAffectation(self) 

1614 

1615 def exitRule(self, listener: ParseTreeListener): 

1616 if hasattr(listener, "exitAffectation"): 

1617 listener.exitAffectation(self) 

1618 

1619 def affectation(self): 

1620 

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

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

1623 try: 

1624 self.enterOuterAlt(localctx, 1) 

1625 self.state = 346 

1626 self.affectop() 

1627 self.state = 348 

1628 self._errHandler.sync(self) 

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

1630 if la_ == 1: 

1631 self.state = 347 

1632 self.match(RParser.NL) 

1633 

1634 self.state = 350 

1635 self.expr(0) 

1636 except RecognitionException as re: 

1637 localctx.exception = re 

1638 self._errHandler.reportError(self, re) 

1639 self._errHandler.recover(self, re) 

1640 finally: 

1641 self.exitRule() 

1642 return localctx 

1643 

1644 class RangeopexprContext(ParserRuleContext): 

1645 

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

1647 super().__init__(parent, invokingState) 

1648 self.parser = parser 

1649 

1650 def rangeop(self): 

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

1652 

1653 def expr(self): 

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

1655 

1656 def getRuleIndex(self): 

1657 return RParser.RULE_rangeopexpr 

1658 

1659 def enterRule(self, listener: ParseTreeListener): 

1660 if hasattr(listener, "enterRangeopexpr"): 

1661 listener.enterRangeopexpr(self) 

1662 

1663 def exitRule(self, listener: ParseTreeListener): 

1664 if hasattr(listener, "exitRangeopexpr"): 

1665 listener.exitRangeopexpr(self) 

1666 

1667 def rangeopexpr(self): 

1668 

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

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

1671 try: 

1672 self.enterOuterAlt(localctx, 1) 

1673 self.state = 352 

1674 self.rangeop() 

1675 self.state = 353 

1676 self.expr(0) 

1677 except RecognitionException as re: 

1678 localctx.exception = re 

1679 self._errHandler.reportError(self, re) 

1680 self._errHandler.recover(self, re) 

1681 finally: 

1682 self.exitRule() 

1683 return localctx 

1684 

1685 class ExprlistContext(ParserRuleContext): 

1686 

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

1688 super().__init__(parent, invokingState) 

1689 self.parser = parser 

1690 

1691 def expr(self): 

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

1693 

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

1695 if i is None: 

1696 return self.getTypedRuleContexts(RParser.RightexprContext) 

1697 else: 

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

1699 

1700 def getRuleIndex(self): 

1701 return RParser.RULE_exprlist 

1702 

1703 def enterRule(self, listener: ParseTreeListener): 

1704 if hasattr(listener, "enterExprlist"): 

1705 listener.enterExprlist(self) 

1706 

1707 def exitRule(self, listener: ParseTreeListener): 

1708 if hasattr(listener, "exitExprlist"): 

1709 listener.exitExprlist(self) 

1710 

1711 def exprlist(self): 

1712 

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

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

1715 try: 

1716 self.enterOuterAlt(localctx, 1) 

1717 self.state = 355 

1718 self.expr(0) 

1719 self.state = 359 

1720 self._errHandler.sync(self) 

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

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

1723 if _alt == 1: 

1724 self.state = 356 

1725 self.rightexpr() 

1726 self.state = 361 

1727 self._errHandler.sync(self) 

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

1729 

1730 except RecognitionException as re: 

1731 localctx.exception = re 

1732 self._errHandler.reportError(self, re) 

1733 self._errHandler.recover(self, re) 

1734 finally: 

1735 self.exitRule() 

1736 return localctx 

1737 

1738 class RightexprContext(ParserRuleContext): 

1739 

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

1741 super().__init__(parent, invokingState) 

1742 self.parser = parser 

1743 

1744 def NL(self): 

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

1746 

1747 def expr(self): 

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

1749 

1750 def getRuleIndex(self): 

1751 return RParser.RULE_rightexpr 

1752 

1753 def enterRule(self, listener: ParseTreeListener): 

1754 if hasattr(listener, "enterRightexpr"): 

1755 listener.enterRightexpr(self) 

1756 

1757 def exitRule(self, listener: ParseTreeListener): 

1758 if hasattr(listener, "exitRightexpr"): 

1759 listener.exitRightexpr(self) 

1760 

1761 def rightexpr(self): 

1762 

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

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

1765 self._la = 0 # Token type 

1766 try: 

1767 self.enterOuterAlt(localctx, 1) 

1768 self.state = 362 

1769 _la = self._input.LA(1) 

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

1771 self._errHandler.recoverInline(self) 

1772 else: 

1773 self._errHandler.reportMatch(self) 

1774 self.consume() 

1775 self.state = 364 

1776 self._errHandler.sync(self) 

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

1778 if la_ == 1: 

1779 self.state = 363 

1780 self.expr(0) 

1781 

1782 except RecognitionException as re: 

1783 localctx.exception = re 

1784 self._errHandler.reportError(self, re) 

1785 self._errHandler.recover(self, re) 

1786 finally: 

1787 self.exitRule() 

1788 return localctx 

1789 

1790 class FormlistContext(ParserRuleContext): 

1791 

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

1793 super().__init__(parent, invokingState) 

1794 self.parser = parser 

1795 

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

1797 if i is None: 

1798 return self.getTypedRuleContexts(RParser.FormContext) 

1799 else: 

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

1801 

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

1803 if i is None: 

1804 return self.getTokens(RParser.NL) 

1805 else: 

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

1807 

1808 def getRuleIndex(self): 

1809 return RParser.RULE_formlist 

1810 

1811 def enterRule(self, listener: ParseTreeListener): 

1812 if hasattr(listener, "enterFormlist"): 

1813 listener.enterFormlist(self) 

1814 

1815 def exitRule(self, listener: ParseTreeListener): 

1816 if hasattr(listener, "exitFormlist"): 

1817 listener.exitFormlist(self) 

1818 

1819 def formlist(self): 

1820 

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

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

1823 self._la = 0 # Token type 

1824 try: 

1825 self.enterOuterAlt(localctx, 1) 

1826 self.state = 366 

1827 self.form() 

1828 self.state = 380 

1829 self._errHandler.sync(self) 

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

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

1832 if _alt == 1: 

1833 self.state = 368 

1834 self._errHandler.sync(self) 

1835 _la = self._input.LA(1) 

1836 if _la == RParser.NL: 

1837 self.state = 367 

1838 self.match(RParser.NL) 

1839 

1840 self.state = 370 

1841 self.match(RParser.T__18) 

1842 self.state = 374 

1843 self._errHandler.sync(self) 

1844 _la = self._input.LA(1) 

1845 while _la == RParser.NL: 

1846 self.state = 371 

1847 self.match(RParser.NL) 

1848 self.state = 376 

1849 self._errHandler.sync(self) 

1850 _la = self._input.LA(1) 

1851 

1852 self.state = 377 

1853 self.form() 

1854 self.state = 382 

1855 self._errHandler.sync(self) 

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

1857 

1858 except RecognitionException as re: 

1859 localctx.exception = re 

1860 self._errHandler.reportError(self, re) 

1861 self._errHandler.recover(self, re) 

1862 finally: 

1863 self.exitRule() 

1864 return localctx 

1865 

1866 class FormContext(ParserRuleContext): 

1867 

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

1869 super().__init__(parent, invokingState) 

1870 self.parser = parser 

1871 

1872 def argumentname(self): 

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

1874 

1875 def expr(self): 

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

1877 

1878 def getRuleIndex(self): 

1879 return RParser.RULE_form 

1880 

1881 def enterRule(self, listener: ParseTreeListener): 

1882 if hasattr(listener, "enterForm"): 

1883 listener.enterForm(self) 

1884 

1885 def exitRule(self, listener: ParseTreeListener): 

1886 if hasattr(listener, "exitForm"): 

1887 listener.exitForm(self) 

1888 

1889 def form(self): 

1890 

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

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

1893 try: 

1894 self.state = 389 

1895 self._errHandler.sync(self) 

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

1897 if la_ == 1: 

1898 self.enterOuterAlt(localctx, 1) 

1899 self.state = 383 

1900 self.argumentname() 

1901 pass 

1902 

1903 elif la_ == 2: 

1904 self.enterOuterAlt(localctx, 2) 

1905 self.state = 384 

1906 self.argumentname() 

1907 self.state = 385 

1908 self.match(RParser.T__19) 

1909 self.state = 386 

1910 self.expr(0) 

1911 pass 

1912 

1913 elif la_ == 3: 

1914 self.enterOuterAlt(localctx, 3) 

1915 self.state = 388 

1916 self.match(RParser.T__20) 

1917 pass 

1918 

1919 except RecognitionException as re: 

1920 localctx.exception = re 

1921 self._errHandler.reportError(self, re) 

1922 self._errHandler.recover(self, re) 

1923 finally: 

1924 self.exitRule() 

1925 return localctx 

1926 

1927 class ArgumentnameContext(ParserRuleContext): 

1928 

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

1930 super().__init__(parent, invokingState) 

1931 self.parser = parser 

1932 

1933 def ID(self): 

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

1935 

1936 def getRuleIndex(self): 

1937 return RParser.RULE_argumentname 

1938 

1939 def enterRule(self, listener: ParseTreeListener): 

1940 if hasattr(listener, "enterArgumentname"): 

1941 listener.enterArgumentname(self) 

1942 

1943 def exitRule(self, listener: ParseTreeListener): 

1944 if hasattr(listener, "exitArgumentname"): 

1945 listener.exitArgumentname(self) 

1946 

1947 def argumentname(self): 

1948 

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

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

1951 try: 

1952 self.enterOuterAlt(localctx, 1) 

1953 self.state = 391 

1954 self.match(RParser.ID) 

1955 except RecognitionException as re: 

1956 localctx.exception = re 

1957 self._errHandler.reportError(self, re) 

1958 self._errHandler.recover(self, re) 

1959 finally: 

1960 self.exitRule() 

1961 return localctx 

1962 

1963 class SublistContext(ParserRuleContext): 

1964 

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

1966 super().__init__(parent, invokingState) 

1967 self.parser = parser 

1968 

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

1970 if i is None: 

1971 return self.getTypedRuleContexts(RParser.SubContext) 

1972 else: 

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

1974 

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

1976 if i is None: 

1977 return self.getTypedRuleContexts(RParser.InlinefunctionContext) 

1978 else: 

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

1980 

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

1982 if i is None: 

1983 return self.getTokens(RParser.NL) 

1984 else: 

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

1986 

1987 def getRuleIndex(self): 

1988 return RParser.RULE_sublist 

1989 

1990 def enterRule(self, listener: ParseTreeListener): 

1991 if hasattr(listener, "enterSublist"): 

1992 listener.enterSublist(self) 

1993 

1994 def exitRule(self, listener: ParseTreeListener): 

1995 if hasattr(listener, "exitSublist"): 

1996 listener.exitSublist(self) 

1997 

1998 def sublist(self): 

1999 

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

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

2002 self._la = 0 # Token type 

2003 try: 

2004 self.enterOuterAlt(localctx, 1) 

2005 self.state = 393 

2006 self.sub() 

2007 self.state = 419 

2008 self._errHandler.sync(self) 

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

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

2011 if _alt == 1: 

2012 self.state = 397 

2013 self._errHandler.sync(self) 

2014 _la = self._input.LA(1) 

2015 while _la == RParser.NL: 

2016 self.state = 394 

2017 self.match(RParser.NL) 

2018 self.state = 399 

2019 self._errHandler.sync(self) 

2020 _la = self._input.LA(1) 

2021 

2022 self.state = 400 

2023 self.match(RParser.T__18) 

2024 self.state = 404 

2025 self._errHandler.sync(self) 

2026 _alt = self._interp.adaptivePredict( 

2027 self._input, 38, self._ctx) 

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

2029 if _alt == 1: 

2030 self.state = 401 

2031 self.match(RParser.NL) 

2032 self.state = 406 

2033 self._errHandler.sync(self) 

2034 _alt = self._interp.adaptivePredict( 

2035 self._input, 38, self._ctx) 

2036 

2037 self.state = 409 

2038 self._errHandler.sync(self) 

2039 la_ = self._interp.adaptivePredict( 

2040 self._input, 39, self._ctx) 

2041 if la_ == 1: 

2042 self.state = 407 

2043 self.inlinefunction() 

2044 pass 

2045 

2046 elif la_ == 2: 

2047 self.state = 408 

2048 self.sub() 

2049 pass 

2050 

2051 self.state = 414 

2052 self._errHandler.sync(self) 

2053 _alt = self._interp.adaptivePredict( 

2054 self._input, 40, self._ctx) 

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

2056 if _alt == 1: 

2057 self.state = 411 

2058 self.match(RParser.NL) 

2059 self.state = 416 

2060 self._errHandler.sync(self) 

2061 _alt = self._interp.adaptivePredict( 

2062 self._input, 40, self._ctx) 

2063 

2064 self.state = 421 

2065 self._errHandler.sync(self) 

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

2067 

2068 except RecognitionException as re: 

2069 localctx.exception = re 

2070 self._errHandler.reportError(self, re) 

2071 self._errHandler.recover(self, re) 

2072 finally: 

2073 self.exitRule() 

2074 return localctx 

2075 

2076 class SublistaddContext(ParserRuleContext): 

2077 

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

2079 super().__init__(parent, invokingState) 

2080 self.parser = parser 

2081 

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

2083 if i is None: 

2084 return self.getTypedRuleContexts(RParser.IdentifierContext) 

2085 else: 

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

2087 

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

2089 if i is None: 

2090 return self.getTokens(RParser.NL) 

2091 else: 

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

2093 

2094 def getRuleIndex(self): 

2095 return RParser.RULE_sublistadd 

2096 

2097 def enterRule(self, listener: ParseTreeListener): 

2098 if hasattr(listener, "enterSublistadd"): 

2099 listener.enterSublistadd(self) 

2100 

2101 def exitRule(self, listener: ParseTreeListener): 

2102 if hasattr(listener, "exitSublistadd"): 

2103 listener.exitSublistadd(self) 

2104 

2105 def sublistadd(self): 

2106 

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

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

2109 self._la = 0 # Token type 

2110 try: 

2111 self.enterOuterAlt(localctx, 1) 

2112 self.state = 422 

2113 self.identifier() 

2114 self.state = 436 

2115 self._errHandler.sync(self) 

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

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

2118 if _alt == 1: 

2119 self.state = 424 

2120 self._errHandler.sync(self) 

2121 _la = self._input.LA(1) 

2122 if _la == RParser.NL: 

2123 self.state = 423 

2124 self.match(RParser.NL) 

2125 

2126 self.state = 426 

2127 self.match(RParser.T__5) 

2128 self.state = 428 

2129 self._errHandler.sync(self) 

2130 _la = self._input.LA(1) 

2131 if _la == RParser.NL: 

2132 self.state = 427 

2133 self.match(RParser.NL) 

2134 

2135 self.state = 430 

2136 self.identifier() 

2137 self.state = 432 

2138 self._errHandler.sync(self) 

2139 la_ = self._interp.adaptivePredict( 

2140 self._input, 44, self._ctx) 

2141 if la_ == 1: 

2142 self.state = 431 

2143 self.match(RParser.NL) 

2144 

2145 self.state = 438 

2146 self._errHandler.sync(self) 

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

2148 

2149 except RecognitionException as re: 

2150 localctx.exception = re 

2151 self._errHandler.reportError(self, re) 

2152 self._errHandler.recover(self, re) 

2153 finally: 

2154 self.exitRule() 

2155 return localctx 

2156 

2157 class SubContext(ParserRuleContext): 

2158 

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

2160 super().__init__(parent, invokingState) 

2161 self.parser = parser 

2162 

2163 def subnobracket(self): 

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

2165 

2166 def expr(self): 

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

2168 

2169 def getRuleIndex(self): 

2170 return RParser.RULE_sub 

2171 

2172 def enterRule(self, listener: ParseTreeListener): 

2173 if hasattr(listener, "enterSub"): 

2174 listener.enterSub(self) 

2175 

2176 def exitRule(self, listener: ParseTreeListener): 

2177 if hasattr(listener, "exitSub"): 

2178 listener.exitSub(self) 

2179 

2180 def sub(self): 

2181 

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

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

2184 try: 

2185 self.state = 441 

2186 self._errHandler.sync(self) 

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

2188 if la_ == 1: 

2189 self.enterOuterAlt(localctx, 1) 

2190 self.state = 439 

2191 self.subnobracket() 

2192 pass 

2193 

2194 elif la_ == 2: 

2195 self.enterOuterAlt(localctx, 2) 

2196 self.state = 440 

2197 self.expr(0) 

2198 pass 

2199 

2200 except RecognitionException as re: 

2201 localctx.exception = re 

2202 self._errHandler.reportError(self, re) 

2203 self._errHandler.recover(self, re) 

2204 finally: 

2205 self.exitRule() 

2206 return localctx 

2207 

2208 class SubnobracketContext(ParserRuleContext): 

2209 

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

2211 super().__init__(parent, invokingState) 

2212 self.parser = parser 

2213 

2214 def identifier(self): 

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

2216 

2217 def inlinefunction(self): 

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

2219 

2220 def expr(self): 

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

2222 

2223 def STRING(self): 

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

2225 

2226 def getRuleIndex(self): 

2227 return RParser.RULE_subnobracket 

2228 

2229 def enterRule(self, listener: ParseTreeListener): 

2230 if hasattr(listener, "enterSubnobracket"): 

2231 listener.enterSubnobracket(self) 

2232 

2233 def exitRule(self, listener: ParseTreeListener): 

2234 if hasattr(listener, "exitSubnobracket"): 

2235 listener.exitSubnobracket(self) 

2236 

2237 def subnobracket(self): 

2238 

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

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

2241 try: 

2242 self.state = 461 

2243 self._errHandler.sync(self) 

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

2245 if la_ == 1: 

2246 self.enterOuterAlt(localctx, 1) 

2247 self.state = 443 

2248 self.identifier() 

2249 self.state = 444 

2250 self.match(RParser.T__19) 

2251 self.state = 447 

2252 self._errHandler.sync(self) 

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

2254 if la_ == 1: 

2255 self.state = 445 

2256 self.inlinefunction() 

2257 pass 

2258 

2259 elif la_ == 2: 

2260 self.state = 446 

2261 self.expr(0) 

2262 pass 

2263 

2264 pass 

2265 

2266 elif la_ == 2: 

2267 self.enterOuterAlt(localctx, 2) 

2268 self.state = 449 

2269 self.match(RParser.STRING) 

2270 self.state = 450 

2271 self.match(RParser.T__19) 

2272 pass 

2273 

2274 elif la_ == 3: 

2275 self.enterOuterAlt(localctx, 3) 

2276 self.state = 451 

2277 self.match(RParser.STRING) 

2278 self.state = 452 

2279 self.match(RParser.T__19) 

2280 self.state = 453 

2281 self.expr(0) 

2282 pass 

2283 

2284 elif la_ == 4: 

2285 self.enterOuterAlt(localctx, 4) 

2286 self.state = 454 

2287 self.match(RParser.T__21) 

2288 self.state = 455 

2289 self.match(RParser.T__19) 

2290 pass 

2291 

2292 elif la_ == 5: 

2293 self.enterOuterAlt(localctx, 5) 

2294 self.state = 456 

2295 self.match(RParser.T__21) 

2296 self.state = 457 

2297 self.match(RParser.T__19) 

2298 self.state = 458 

2299 self.expr(0) 

2300 pass 

2301 

2302 elif la_ == 6: 

2303 self.enterOuterAlt(localctx, 6) 

2304 self.state = 459 

2305 self.match(RParser.T__20) 

2306 pass 

2307 

2308 elif la_ == 7: 

2309 self.enterOuterAlt(localctx, 7) 

2310 self.state = 460 

2311 self.match(RParser.T__22) 

2312 pass 

2313 

2314 except RecognitionException as re: 

2315 localctx.exception = re 

2316 self._errHandler.reportError(self, re) 

2317 self._errHandler.recover(self, re) 

2318 finally: 

2319 self.exitRule() 

2320 return localctx 

2321 

2322 class RangesContext(ParserRuleContext): 

2323 

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

2325 super().__init__(parent, invokingState) 

2326 self.parser = parser 

2327 

2328 def range_simple(self): 

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

2330 

2331 def range_complexe(self): 

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

2333 

2334 def getRuleIndex(self): 

2335 return RParser.RULE_ranges 

2336 

2337 def enterRule(self, listener: ParseTreeListener): 

2338 if hasattr(listener, "enterRanges"): 

2339 listener.enterRanges(self) 

2340 

2341 def exitRule(self, listener: ParseTreeListener): 

2342 if hasattr(listener, "exitRanges"): 

2343 listener.exitRanges(self) 

2344 

2345 def ranges(self): 

2346 

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

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

2349 try: 

2350 self.state = 465 

2351 self._errHandler.sync(self) 

2352 token = self._input.LA(1) 

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

2354 self.enterOuterAlt(localctx, 1) 

2355 self.state = 463 

2356 self.range_simple() 

2357 pass 

2358 elif token in [RParser.T__15]: 

2359 self.enterOuterAlt(localctx, 2) 

2360 self.state = 464 

2361 self.range_complexe() 

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_simpleContext(ParserRuleContext): 

2375 

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

2377 super().__init__(parent, invokingState) 

2378 self.parser = parser 

2379 

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

2381 if i is None: 

2382 return self.getTypedRuleContexts(RParser.IdentifierContext) 

2383 else: 

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

2385 

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

2387 if i is None: 

2388 return self.getTokens(RParser.INT) 

2389 else: 

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

2391 

2392 def getRuleIndex(self): 

2393 return RParser.RULE_range_simple 

2394 

2395 def enterRule(self, listener: ParseTreeListener): 

2396 if hasattr(listener, "enterRange_simple"): 

2397 listener.enterRange_simple(self) 

2398 

2399 def exitRule(self, listener: ParseTreeListener): 

2400 if hasattr(listener, "exitRange_simple"): 

2401 listener.exitRange_simple(self) 

2402 

2403 def range_simple(self): 

2404 

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

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

2407 try: 

2408 self.enterOuterAlt(localctx, 1) 

2409 self.state = 469 

2410 self._errHandler.sync(self) 

2411 token = self._input.LA(1) 

2412 if token in [RParser.ID]: 

2413 self.state = 467 

2414 self.identifier() 

2415 pass 

2416 elif token in [RParser.INT]: 

2417 self.state = 468 

2418 self.match(RParser.INT) 

2419 pass 

2420 else: 

2421 raise NoViableAltException(self) 

2422 

2423 self.state = 471 

2424 self.match(RParser.T__22) 

2425 self.state = 474 

2426 self._errHandler.sync(self) 

2427 token = self._input.LA(1) 

2428 if token in [RParser.ID]: 

2429 self.state = 472 

2430 self.identifier() 

2431 pass 

2432 elif token in [RParser.INT]: 

2433 self.state = 473 

2434 self.match(RParser.INT) 

2435 pass 

2436 else: 

2437 raise NoViableAltException(self) 

2438 

2439 except RecognitionException as re: 

2440 localctx.exception = re 

2441 self._errHandler.reportError(self, re) 

2442 self._errHandler.recover(self, re) 

2443 finally: 

2444 self.exitRule() 

2445 return localctx 

2446 

2447 class Range_complexeContext(ParserRuleContext): 

2448 

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

2450 super().__init__(parent, invokingState) 

2451 self.parser = parser 

2452 

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

2454 if i is None: 

2455 return self.getTypedRuleContexts(RParser.ExprContext) 

2456 else: 

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

2458 

2459 def getRuleIndex(self): 

2460 return RParser.RULE_range_complexe 

2461 

2462 def enterRule(self, listener: ParseTreeListener): 

2463 if hasattr(listener, "enterRange_complexe"): 

2464 listener.enterRange_complexe(self) 

2465 

2466 def exitRule(self, listener: ParseTreeListener): 

2467 if hasattr(listener, "exitRange_complexe"): 

2468 listener.exitRange_complexe(self) 

2469 

2470 def range_complexe(self): 

2471 

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

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

2474 try: 

2475 self.enterOuterAlt(localctx, 1) 

2476 self.state = 476 

2477 self.match(RParser.T__15) 

2478 self.state = 477 

2479 self.expr(0) 

2480 self.state = 478 

2481 self.match(RParser.T__16) 

2482 self.state = 479 

2483 self.match(RParser.T__22) 

2484 self.state = 480 

2485 self.expr(0) 

2486 except RecognitionException as re: 

2487 localctx.exception = re 

2488 self._errHandler.reportError(self, re) 

2489 self._errHandler.recover(self, re) 

2490 finally: 

2491 self.exitRule() 

2492 return localctx 

2493 

2494 class IntersectionsContext(ParserRuleContext): 

2495 

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

2497 super().__init__(parent, invokingState) 

2498 self.parser = parser 

2499 

2500 def intersection_simple(self): 

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

2502 

2503 def intersection_complexe(self): 

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

2505 

2506 def getRuleIndex(self): 

2507 return RParser.RULE_intersections 

2508 

2509 def enterRule(self, listener: ParseTreeListener): 

2510 if hasattr(listener, "enterIntersections"): 

2511 listener.enterIntersections(self) 

2512 

2513 def exitRule(self, listener: ParseTreeListener): 

2514 if hasattr(listener, "exitIntersections"): 

2515 listener.exitIntersections(self) 

2516 

2517 def intersections(self): 

2518 

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

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

2521 try: 

2522 self.state = 484 

2523 self._errHandler.sync(self) 

2524 token = self._input.LA(1) 

2525 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]: 

2526 self.enterOuterAlt(localctx, 1) 

2527 self.state = 482 

2528 self.intersection_simple() 

2529 pass 

2530 elif token in [RParser.T__15]: 

2531 self.enterOuterAlt(localctx, 2) 

2532 self.state = 483 

2533 self.intersection_complexe() 

2534 pass 

2535 else: 

2536 raise NoViableAltException(self) 

2537 

2538 except RecognitionException as re: 

2539 localctx.exception = re 

2540 self._errHandler.reportError(self, re) 

2541 self._errHandler.recover(self, re) 

2542 finally: 

2543 self.exitRule() 

2544 return localctx 

2545 

2546 class Intersection_simpleContext(ParserRuleContext): 

2547 

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

2549 super().__init__(parent, invokingState) 

2550 self.parser = parser 

2551 

2552 def expr(self): 

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

2554 

2555 def identifier(self): 

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

2557 

2558 def constant(self): 

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

2560 

2561 def getRuleIndex(self): 

2562 return RParser.RULE_intersection_simple 

2563 

2564 def enterRule(self, listener: ParseTreeListener): 

2565 if hasattr(listener, "enterIntersection_simple"): 

2566 listener.enterIntersection_simple(self) 

2567 

2568 def exitRule(self, listener: ParseTreeListener): 

2569 if hasattr(listener, "exitIntersection_simple"): 

2570 listener.exitIntersection_simple(self) 

2571 

2572 def intersection_simple(self): 

2573 

2574 localctx = RParser.Intersection_simpleContext( 

2575 self, self._ctx, self.state) 

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

2577 try: 

2578 self.enterOuterAlt(localctx, 1) 

2579 self.state = 488 

2580 self._errHandler.sync(self) 

2581 token = self._input.LA(1) 

2582 if token in [RParser.ID]: 

2583 self.state = 486 

2584 self.identifier() 

2585 pass 

2586 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]: 

2587 self.state = 487 

2588 self.constant() 

2589 pass 

2590 else: 

2591 raise NoViableAltException(self) 

2592 

2593 self.state = 490 

2594 self.match(RParser.T__23) 

2595 self.state = 491 

2596 self.expr(0) 

2597 except RecognitionException as re: 

2598 localctx.exception = re 

2599 self._errHandler.reportError(self, re) 

2600 self._errHandler.recover(self, re) 

2601 finally: 

2602 self.exitRule() 

2603 return localctx 

2604 

2605 class Intersection_complexeContext(ParserRuleContext): 

2606 

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

2608 super().__init__(parent, invokingState) 

2609 self.parser = parser 

2610 

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

2612 if i is None: 

2613 return self.getTypedRuleContexts(RParser.ExprContext) 

2614 else: 

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

2616 

2617 def getRuleIndex(self): 

2618 return RParser.RULE_intersection_complexe 

2619 

2620 def enterRule(self, listener: ParseTreeListener): 

2621 if hasattr(listener, "enterIntersection_complexe"): 

2622 listener.enterIntersection_complexe(self) 

2623 

2624 def exitRule(self, listener: ParseTreeListener): 

2625 if hasattr(listener, "exitIntersection_complexe"): 

2626 listener.exitIntersection_complexe(self) 

2627 

2628 def intersection_complexe(self): 

2629 

2630 localctx = RParser.Intersection_complexeContext( 

2631 self, self._ctx, self.state) 

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

2633 try: 

2634 self.enterOuterAlt(localctx, 1) 

2635 self.state = 493 

2636 self.match(RParser.T__15) 

2637 self.state = 494 

2638 self.expr(0) 

2639 self.state = 495 

2640 self.match(RParser.T__16) 

2641 self.state = 496 

2642 self.match(RParser.T__23) 

2643 self.state = 497 

2644 self.expr(0) 

2645 except RecognitionException as re: 

2646 localctx.exception = re 

2647 self._errHandler.reportError(self, re) 

2648 self._errHandler.recover(self, re) 

2649 finally: 

2650 self.exitRule() 

2651 return localctx 

2652 

2653 class ConstantContext(ParserRuleContext): 

2654 

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

2656 super().__init__(parent, invokingState) 

2657 self.parser = parser 

2658 

2659 def STRING(self): 

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

2661 

2662 def HEX(self): 

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

2664 

2665 def INT(self): 

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

2667 

2668 def FLOAT(self): 

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

2670 

2671 def COMPLEX(self): 

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

2673 

2674 def boolean(self): 

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

2676 

2677 def getRuleIndex(self): 

2678 return RParser.RULE_constant 

2679 

2680 def enterRule(self, listener: ParseTreeListener): 

2681 if hasattr(listener, "enterConstant"): 

2682 listener.enterConstant(self) 

2683 

2684 def exitRule(self, listener: ParseTreeListener): 

2685 if hasattr(listener, "exitConstant"): 

2686 listener.exitConstant(self) 

2687 

2688 def constant(self): 

2689 

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

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

2692 try: 

2693 self.state = 509 

2694 self._errHandler.sync(self) 

2695 token = self._input.LA(1) 

2696 if token in [RParser.STRING]: 

2697 self.enterOuterAlt(localctx, 1) 

2698 self.state = 499 

2699 self.match(RParser.STRING) 

2700 pass 

2701 elif token in [RParser.HEX]: 

2702 self.enterOuterAlt(localctx, 2) 

2703 self.state = 500 

2704 self.match(RParser.HEX) 

2705 pass 

2706 elif token in [RParser.INT]: 

2707 self.enterOuterAlt(localctx, 3) 

2708 self.state = 501 

2709 self.match(RParser.INT) 

2710 pass 

2711 elif token in [RParser.FLOAT]: 

2712 self.enterOuterAlt(localctx, 4) 

2713 self.state = 502 

2714 self.match(RParser.FLOAT) 

2715 pass 

2716 elif token in [RParser.COMPLEX]: 

2717 self.enterOuterAlt(localctx, 5) 

2718 self.state = 503 

2719 self.match(RParser.COMPLEX) 

2720 pass 

2721 elif token in [RParser.T__21]: 

2722 self.enterOuterAlt(localctx, 6) 

2723 self.state = 504 

2724 self.match(RParser.T__21) 

2725 pass 

2726 elif token in [RParser.T__24]: 

2727 self.enterOuterAlt(localctx, 7) 

2728 self.state = 505 

2729 self.match(RParser.T__24) 

2730 pass 

2731 elif token in [RParser.T__25]: 

2732 self.enterOuterAlt(localctx, 8) 

2733 self.state = 506 

2734 self.match(RParser.T__25) 

2735 pass 

2736 elif token in [RParser.T__26]: 

2737 self.enterOuterAlt(localctx, 9) 

2738 self.state = 507 

2739 self.match(RParser.T__26) 

2740 pass 

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

2742 self.enterOuterAlt(localctx, 10) 

2743 self.state = 508 

2744 self.boolean() 

2745 pass 

2746 else: 

2747 raise NoViableAltException(self) 

2748 

2749 except RecognitionException as re: 

2750 localctx.exception = re 

2751 self._errHandler.reportError(self, re) 

2752 self._errHandler.recover(self, re) 

2753 finally: 

2754 self.exitRule() 

2755 return localctx 

2756 

2757 class BooleanContext(ParserRuleContext): 

2758 

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

2760 super().__init__(parent, invokingState) 

2761 self.parser = parser 

2762 

2763 def getRuleIndex(self): 

2764 return RParser.RULE_boolean 

2765 

2766 def enterRule(self, listener: ParseTreeListener): 

2767 if hasattr(listener, "enterBoolean"): 

2768 listener.enterBoolean(self) 

2769 

2770 def exitRule(self, listener: ParseTreeListener): 

2771 if hasattr(listener, "exitBoolean"): 

2772 listener.exitBoolean(self) 

2773 

2774 def boolean(self): 

2775 

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

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

2778 self._la = 0 # Token type 

2779 try: 

2780 self.enterOuterAlt(localctx, 1) 

2781 self.state = 511 

2782 _la = self._input.LA(1) 

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

2784 self._errHandler.recoverInline(self) 

2785 else: 

2786 self._errHandler.reportMatch(self) 

2787 self.consume() 

2788 except RecognitionException as re: 

2789 localctx.exception = re 

2790 self._errHandler.reportError(self, re) 

2791 self._errHandler.recover(self, re) 

2792 finally: 

2793 self.exitRule() 

2794 return localctx 

2795 

2796 class NextexprContext(ParserRuleContext): 

2797 

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

2799 super().__init__(parent, invokingState) 

2800 self.parser = parser 

2801 

2802 def getRuleIndex(self): 

2803 return RParser.RULE_nextexpr 

2804 

2805 def enterRule(self, listener: ParseTreeListener): 

2806 if hasattr(listener, "enterNextexpr"): 

2807 listener.enterNextexpr(self) 

2808 

2809 def exitRule(self, listener: ParseTreeListener): 

2810 if hasattr(listener, "exitNextexpr"): 

2811 listener.exitNextexpr(self) 

2812 

2813 def nextexpr(self): 

2814 

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

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

2817 try: 

2818 self.enterOuterAlt(localctx, 1) 

2819 self.state = 513 

2820 self.match(RParser.T__29) 

2821 except RecognitionException as re: 

2822 localctx.exception = re 

2823 self._errHandler.reportError(self, re) 

2824 self._errHandler.recover(self, re) 

2825 finally: 

2826 self.exitRule() 

2827 return localctx 

2828 

2829 class RepeatexprContext(ParserRuleContext): 

2830 

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

2832 super().__init__(parent, invokingState) 

2833 self.parser = parser 

2834 

2835 def expr(self): 

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

2837 

2838 def getRuleIndex(self): 

2839 return RParser.RULE_repeatexpr 

2840 

2841 def enterRule(self, listener: ParseTreeListener): 

2842 if hasattr(listener, "enterRepeatexpr"): 

2843 listener.enterRepeatexpr(self) 

2844 

2845 def exitRule(self, listener: ParseTreeListener): 

2846 if hasattr(listener, "exitRepeatexpr"): 

2847 listener.exitRepeatexpr(self) 

2848 

2849 def repeatexpr(self): 

2850 

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

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

2853 try: 

2854 self.enterOuterAlt(localctx, 1) 

2855 self.state = 515 

2856 self.match(RParser.T__30) 

2857 self.state = 516 

2858 self.expr(0) 

2859 except RecognitionException as re: 

2860 localctx.exception = re 

2861 self._errHandler.reportError(self, re) 

2862 self._errHandler.recover(self, re) 

2863 finally: 

2864 self.exitRule() 

2865 return localctx 

2866 

2867 class WhileexprContext(ParserRuleContext): 

2868 

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

2870 super().__init__(parent, invokingState) 

2871 self.parser = parser 

2872 

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

2874 if i is None: 

2875 return self.getTypedRuleContexts(RParser.ExprContext) 

2876 else: 

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

2878 

2879 def getRuleIndex(self): 

2880 return RParser.RULE_whileexpr 

2881 

2882 def enterRule(self, listener: ParseTreeListener): 

2883 if hasattr(listener, "enterWhileexpr"): 

2884 listener.enterWhileexpr(self) 

2885 

2886 def exitRule(self, listener: ParseTreeListener): 

2887 if hasattr(listener, "exitWhileexpr"): 

2888 listener.exitWhileexpr(self) 

2889 

2890 def whileexpr(self): 

2891 

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

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

2894 try: 

2895 self.enterOuterAlt(localctx, 1) 

2896 self.state = 518 

2897 self.match(RParser.T__31) 

2898 self.state = 519 

2899 self.match(RParser.T__15) 

2900 self.state = 520 

2901 self.expr(0) 

2902 self.state = 521 

2903 self.match(RParser.T__16) 

2904 self.state = 522 

2905 self.expr(0) 

2906 except RecognitionException as re: 

2907 localctx.exception = re 

2908 self._errHandler.reportError(self, re) 

2909 self._errHandler.recover(self, re) 

2910 finally: 

2911 self.exitRule() 

2912 return localctx 

2913 

2914 class ForexprContext(ParserRuleContext): 

2915 

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

2917 super().__init__(parent, invokingState) 

2918 self.parser = parser 

2919 

2920 def identifier(self): 

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

2922 

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

2924 if i is None: 

2925 return self.getTypedRuleContexts(RParser.ExprContext) 

2926 else: 

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

2928 

2929 def getRuleIndex(self): 

2930 return RParser.RULE_forexpr 

2931 

2932 def enterRule(self, listener: ParseTreeListener): 

2933 if hasattr(listener, "enterForexpr"): 

2934 listener.enterForexpr(self) 

2935 

2936 def exitRule(self, listener: ParseTreeListener): 

2937 if hasattr(listener, "exitForexpr"): 

2938 listener.exitForexpr(self) 

2939 

2940 def forexpr(self): 

2941 

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

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

2944 try: 

2945 self.enterOuterAlt(localctx, 1) 

2946 self.state = 524 

2947 self.match(RParser.T__32) 

2948 self.state = 525 

2949 self.match(RParser.T__15) 

2950 self.state = 526 

2951 self.identifier() 

2952 self.state = 527 

2953 self.match(RParser.T__33) 

2954 self.state = 528 

2955 self.expr(0) 

2956 self.state = 529 

2957 self.match(RParser.T__16) 

2958 self.state = 530 

2959 self.expr(0) 

2960 except RecognitionException as re: 

2961 localctx.exception = re 

2962 self._errHandler.reportError(self, re) 

2963 self._errHandler.recover(self, re) 

2964 finally: 

2965 self.exitRule() 

2966 return localctx 

2967 

2968 class IfexprContext(ParserRuleContext): 

2969 

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

2971 super().__init__(parent, invokingState) 

2972 self.parser = parser 

2973 

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

2975 if i is None: 

2976 return self.getTypedRuleContexts(RParser.ExprContext) 

2977 else: 

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

2979 

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

2981 if i is None: 

2982 return self.getTokens(RParser.NL) 

2983 else: 

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

2985 

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

2987 if i is None: 

2988 return self.getTypedRuleContexts(RParser.ElseifContext) 

2989 else: 

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

2991 

2992 def getRuleIndex(self): 

2993 return RParser.RULE_ifexpr 

2994 

2995 def enterRule(self, listener: ParseTreeListener): 

2996 if hasattr(listener, "enterIfexpr"): 

2997 listener.enterIfexpr(self) 

2998 

2999 def exitRule(self, listener: ParseTreeListener): 

3000 if hasattr(listener, "exitIfexpr"): 

3001 listener.exitIfexpr(self) 

3002 

3003 def ifexpr(self): 

3004 

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

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

3007 try: 

3008 self.enterOuterAlt(localctx, 1) 

3009 self.state = 532 

3010 self.match(RParser.T__34) 

3011 self.state = 533 

3012 self.match(RParser.T__15) 

3013 self.state = 534 

3014 self.expr(0) 

3015 self.state = 535 

3016 self.match(RParser.T__16) 

3017 self.state = 539 

3018 self._errHandler.sync(self) 

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

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

3021 if _alt == 1: 

3022 self.state = 536 

3023 self.match(RParser.NL) 

3024 self.state = 541 

3025 self._errHandler.sync(self) 

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

3027 

3028 self.state = 542 

3029 self.expr(0) 

3030 self.state = 562 

3031 self._errHandler.sync(self) 

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

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

3034 if _alt == 1: 

3035 self.state = 543 

3036 self.elseif() 

3037 self.state = 544 

3038 self.match(RParser.T__15) 

3039 self.state = 545 

3040 self.expr(0) 

3041 self.state = 546 

3042 self.match(RParser.T__16) 

3043 self.state = 550 

3044 self._errHandler.sync(self) 

3045 _alt = self._interp.adaptivePredict( 

3046 self._input, 56, self._ctx) 

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

3048 if _alt == 1: 

3049 self.state = 547 

3050 self.match(RParser.NL) 

3051 self.state = 552 

3052 self._errHandler.sync(self) 

3053 _alt = self._interp.adaptivePredict( 

3054 self._input, 56, self._ctx) 

3055 

3056 self.state = 553 

3057 self.expr(0) 

3058 self.state = 557 

3059 self._errHandler.sync(self) 

3060 _alt = self._interp.adaptivePredict( 

3061 self._input, 57, self._ctx) 

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

3063 if _alt == 1: 

3064 self.state = 554 

3065 self.match(RParser.NL) 

3066 self.state = 559 

3067 self._errHandler.sync(self) 

3068 _alt = self._interp.adaptivePredict( 

3069 self._input, 57, self._ctx) 

3070 

3071 self.state = 564 

3072 self._errHandler.sync(self) 

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

3074 

3075 except RecognitionException as re: 

3076 localctx.exception = re 

3077 self._errHandler.reportError(self, re) 

3078 self._errHandler.recover(self, re) 

3079 finally: 

3080 self.exitRule() 

3081 return localctx 

3082 

3083 class IfelseexprContext(ParserRuleContext): 

3084 

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

3086 super().__init__(parent, invokingState) 

3087 self.parser = parser 

3088 

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

3090 if i is None: 

3091 return self.getTypedRuleContexts(RParser.ExprContext) 

3092 else: 

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

3094 

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

3096 if i is None: 

3097 return self.getTokens(RParser.NL) 

3098 else: 

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

3100 

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

3102 if i is None: 

3103 return self.getTypedRuleContexts(RParser.ElseifContext) 

3104 else: 

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

3106 

3107 def getRuleIndex(self): 

3108 return RParser.RULE_ifelseexpr 

3109 

3110 def enterRule(self, listener: ParseTreeListener): 

3111 if hasattr(listener, "enterIfelseexpr"): 

3112 listener.enterIfelseexpr(self) 

3113 

3114 def exitRule(self, listener: ParseTreeListener): 

3115 if hasattr(listener, "exitIfelseexpr"): 

3116 listener.exitIfelseexpr(self) 

3117 

3118 def ifelseexpr(self): 

3119 

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

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

3122 self._la = 0 # Token type 

3123 try: 

3124 self.enterOuterAlt(localctx, 1) 

3125 self.state = 565 

3126 self.match(RParser.T__34) 

3127 self.state = 566 

3128 self.match(RParser.T__15) 

3129 self.state = 567 

3130 self.expr(0) 

3131 self.state = 568 

3132 self.match(RParser.T__16) 

3133 self.state = 572 

3134 self._errHandler.sync(self) 

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

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

3137 if _alt == 1: 

3138 self.state = 569 

3139 self.match(RParser.NL) 

3140 self.state = 574 

3141 self._errHandler.sync(self) 

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

3143 

3144 self.state = 575 

3145 self.expr(0) 

3146 self.state = 579 

3147 self._errHandler.sync(self) 

3148 _la = self._input.LA(1) 

3149 while _la == RParser.NL: 

3150 self.state = 576 

3151 self.match(RParser.NL) 

3152 self.state = 581 

3153 self._errHandler.sync(self) 

3154 _la = self._input.LA(1) 

3155 

3156 self.state = 601 

3157 self._errHandler.sync(self) 

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

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

3160 if _alt == 1: 

3161 self.state = 582 

3162 self.elseif() 

3163 self.state = 583 

3164 self.match(RParser.T__15) 

3165 self.state = 584 

3166 self.expr(0) 

3167 self.state = 585 

3168 self.match(RParser.T__16) 

3169 self.state = 589 

3170 self._errHandler.sync(self) 

3171 _alt = self._interp.adaptivePredict( 

3172 self._input, 61, self._ctx) 

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

3174 if _alt == 1: 

3175 self.state = 586 

3176 self.match(RParser.NL) 

3177 self.state = 591 

3178 self._errHandler.sync(self) 

3179 _alt = self._interp.adaptivePredict( 

3180 self._input, 61, self._ctx) 

3181 

3182 self.state = 592 

3183 self.expr(0) 

3184 self.state = 596 

3185 self._errHandler.sync(self) 

3186 _la = self._input.LA(1) 

3187 while _la == RParser.NL: 

3188 self.state = 593 

3189 self.match(RParser.NL) 

3190 self.state = 598 

3191 self._errHandler.sync(self) 

3192 _la = self._input.LA(1) 

3193 

3194 self.state = 603 

3195 self._errHandler.sync(self) 

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

3197 

3198 self.state = 604 

3199 self.match(RParser.T__35) 

3200 self.state = 608 

3201 self._errHandler.sync(self) 

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

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

3204 if _alt == 1: 

3205 self.state = 605 

3206 self.match(RParser.NL) 

3207 self.state = 610 

3208 self._errHandler.sync(self) 

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

3210 

3211 self.state = 611 

3212 self.expr(0) 

3213 except RecognitionException as re: 

3214 localctx.exception = re 

3215 self._errHandler.reportError(self, re) 

3216 self._errHandler.recover(self, re) 

3217 finally: 

3218 self.exitRule() 

3219 return localctx 

3220 

3221 class ElseifContext(ParserRuleContext): 

3222 

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

3224 super().__init__(parent, invokingState) 

3225 self.parser = parser 

3226 

3227 def getRuleIndex(self): 

3228 return RParser.RULE_elseif 

3229 

3230 def enterRule(self, listener: ParseTreeListener): 

3231 if hasattr(listener, "enterElseif"): 

3232 listener.enterElseif(self) 

3233 

3234 def exitRule(self, listener: ParseTreeListener): 

3235 if hasattr(listener, "exitElseif"): 

3236 listener.exitElseif(self) 

3237 

3238 def elseif(self): 

3239 

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

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

3242 try: 

3243 self.enterOuterAlt(localctx, 1) 

3244 self.state = 613 

3245 self.match(RParser.T__35) 

3246 self.state = 614 

3247 self.match(RParser.T__34) 

3248 except RecognitionException as re: 

3249 localctx.exception = re 

3250 self._errHandler.reportError(self, re) 

3251 self._errHandler.recover(self, re) 

3252 finally: 

3253 self.exitRule() 

3254 return localctx 

3255 

3256 class ReturnexprContext(ParserRuleContext): 

3257 

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

3259 super().__init__(parent, invokingState) 

3260 self.parser = parser 

3261 

3262 def expr(self): 

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

3264 

3265 def getRuleIndex(self): 

3266 return RParser.RULE_returnexpr 

3267 

3268 def enterRule(self, listener: ParseTreeListener): 

3269 if hasattr(listener, "enterReturnexpr"): 

3270 listener.enterReturnexpr(self) 

3271 

3272 def exitRule(self, listener: ParseTreeListener): 

3273 if hasattr(listener, "exitReturnexpr"): 

3274 listener.exitReturnexpr(self) 

3275 

3276 def returnexpr(self): 

3277 

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

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

3280 try: 

3281 self.enterOuterAlt(localctx, 1) 

3282 self.state = 616 

3283 self.match(RParser.T__36) 

3284 self.state = 617 

3285 self.match(RParser.T__15) 

3286 self.state = 618 

3287 self.expr(0) 

3288 self.state = 619 

3289 self.match(RParser.T__16) 

3290 except RecognitionException as re: 

3291 localctx.exception = re 

3292 self._errHandler.reportError(self, re) 

3293 self._errHandler.recover(self, re) 

3294 finally: 

3295 self.exitRule() 

3296 return localctx 

3297 

3298 class FunctioncallContext(ParserRuleContext): 

3299 

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

3301 super().__init__(parent, invokingState) 

3302 self.parser = parser 

3303 

3304 def identifier(self): 

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

3306 

3307 def inlinefunction(self): 

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

3309 

3310 def sublist(self): 

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

3312 

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

3314 if i is None: 

3315 return self.getTokens(RParser.NL) 

3316 else: 

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

3318 

3319 def getRuleIndex(self): 

3320 return RParser.RULE_functioncall 

3321 

3322 def enterRule(self, listener: ParseTreeListener): 

3323 if hasattr(listener, "enterFunctioncall"): 

3324 listener.enterFunctioncall(self) 

3325 

3326 def exitRule(self, listener: ParseTreeListener): 

3327 if hasattr(listener, "exitFunctioncall"): 

3328 listener.exitFunctioncall(self) 

3329 

3330 def functioncall(self): 

3331 

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

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

3334 self._la = 0 # Token type 

3335 try: 

3336 self.enterOuterAlt(localctx, 1) 

3337 self.state = 621 

3338 self.identifier() 

3339 self.state = 644 

3340 self._errHandler.sync(self) 

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

3342 if la_ == 1: 

3343 self.state = 622 

3344 self.match(RParser.T__15) 

3345 self.state = 623 

3346 self.match(RParser.T__16) 

3347 pass 

3348 

3349 elif la_ == 2: 

3350 self.state = 624 

3351 self.match(RParser.T__15) 

3352 self.state = 625 

3353 self.inlinefunction() 

3354 self.state = 626 

3355 self.match(RParser.T__16) 

3356 pass 

3357 

3358 elif la_ == 3: 

3359 self.state = 628 

3360 self.match(RParser.T__15) 

3361 self.state = 632 

3362 self._errHandler.sync(self) 

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

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

3365 if _alt == 1: 

3366 self.state = 629 

3367 self.match(RParser.NL) 

3368 self.state = 634 

3369 self._errHandler.sync(self) 

3370 _alt = self._interp.adaptivePredict( 

3371 self._input, 65, self._ctx) 

3372 

3373 self.state = 635 

3374 self.sublist() 

3375 self.state = 639 

3376 self._errHandler.sync(self) 

3377 _la = self._input.LA(1) 

3378 while _la == RParser.NL: 

3379 self.state = 636 

3380 self.match(RParser.NL) 

3381 self.state = 641 

3382 self._errHandler.sync(self) 

3383 _la = self._input.LA(1) 

3384 

3385 self.state = 642 

3386 self.match(RParser.T__16) 

3387 pass 

3388 

3389 except RecognitionException as re: 

3390 localctx.exception = re 

3391 self._errHandler.reportError(self, re) 

3392 self._errHandler.recover(self, re) 

3393 finally: 

3394 self.exitRule() 

3395 return localctx 

3396 

3397 class InlinefunctionContext(ParserRuleContext): 

3398 

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

3400 super().__init__(parent, invokingState) 

3401 self.parser = parser 

3402 

3403 def exprlist(self): 

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

3405 

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

3407 if i is None: 

3408 return self.getTokens(RParser.NL) 

3409 else: 

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

3411 

3412 def getRuleIndex(self): 

3413 return RParser.RULE_inlinefunction 

3414 

3415 def enterRule(self, listener: ParseTreeListener): 

3416 if hasattr(listener, "enterInlinefunction"): 

3417 listener.enterInlinefunction(self) 

3418 

3419 def exitRule(self, listener: ParseTreeListener): 

3420 if hasattr(listener, "exitInlinefunction"): 

3421 listener.exitInlinefunction(self) 

3422 

3423 def inlinefunction(self): 

3424 

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

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

3427 self._la = 0 # Token type 

3428 try: 

3429 self.enterOuterAlt(localctx, 1) 

3430 self.state = 649 

3431 self._errHandler.sync(self) 

3432 _la = self._input.LA(1) 

3433 while _la == RParser.NL: 

3434 self.state = 646 

3435 self.match(RParser.NL) 

3436 self.state = 651 

3437 self._errHandler.sync(self) 

3438 _la = self._input.LA(1) 

3439 

3440 self.state = 652 

3441 self.match(RParser.T__11) 

3442 self.state = 656 

3443 self._errHandler.sync(self) 

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

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

3446 if _alt == 1: 

3447 self.state = 653 

3448 self.match(RParser.NL) 

3449 self.state = 658 

3450 self._errHandler.sync(self) 

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

3452 

3453 self.state = 659 

3454 self.exprlist() 

3455 self.state = 663 

3456 self._errHandler.sync(self) 

3457 _la = self._input.LA(1) 

3458 while _la == RParser.NL: 

3459 self.state = 660 

3460 self.match(RParser.NL) 

3461 self.state = 665 

3462 self._errHandler.sync(self) 

3463 _la = self._input.LA(1) 

3464 

3465 self.state = 666 

3466 self.match(RParser.T__12) 

3467 self.state = 670 

3468 self._errHandler.sync(self) 

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

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

3471 if _alt == 1: 

3472 self.state = 667 

3473 self.match(RParser.NL) 

3474 self.state = 672 

3475 self._errHandler.sync(self) 

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

3477 

3478 except RecognitionException as re: 

3479 localctx.exception = re 

3480 self._errHandler.reportError(self, re) 

3481 self._errHandler.recover(self, re) 

3482 finally: 

3483 self.exitRule() 

3484 return localctx 

3485 

3486 class Formula_simpleContext(ParserRuleContext): 

3487 

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

3489 super().__init__(parent, invokingState) 

3490 self.parser = parser 

3491 

3492 def formula_simple_B(self): 

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

3494 

3495 def formula_simple_A(self): 

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

3497 

3498 def formula_simple_C(self): 

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

3500 

3501 def getRuleIndex(self): 

3502 return RParser.RULE_formula_simple 

3503 

3504 def enterRule(self, listener: ParseTreeListener): 

3505 if hasattr(listener, "enterFormula_simple"): 

3506 listener.enterFormula_simple(self) 

3507 

3508 def exitRule(self, listener: ParseTreeListener): 

3509 if hasattr(listener, "exitFormula_simple"): 

3510 listener.exitFormula_simple(self) 

3511 

3512 def formula_simple(self): 

3513 

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

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

3516 try: 

3517 self.state = 676 

3518 self._errHandler.sync(self) 

3519 token = self._input.LA(1) 

3520 if token in [RParser.T__37]: 

3521 self.enterOuterAlt(localctx, 1) 

3522 self.state = 673 

3523 self.formula_simple_B() 

3524 pass 

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

3526 self.enterOuterAlt(localctx, 2) 

3527 self.state = 674 

3528 self.formula_simple_A() 

3529 pass 

3530 elif token in [RParser.T__15]: 

3531 self.enterOuterAlt(localctx, 3) 

3532 self.state = 675 

3533 self.formula_simple_C() 

3534 pass 

3535 else: 

3536 raise NoViableAltException(self) 

3537 

3538 except RecognitionException as re: 

3539 localctx.exception = re 

3540 self._errHandler.reportError(self, re) 

3541 self._errHandler.recover(self, re) 

3542 finally: 

3543 self.exitRule() 

3544 return localctx 

3545 

3546 class Formula_simple_AContext(ParserRuleContext): 

3547 

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

3549 super().__init__(parent, invokingState) 

3550 self.parser = parser 

3551 

3552 def formop(self): 

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

3554 

3555 def sublistadd(self): 

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

3557 

3558 def identifier(self): 

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

3560 

3561 def getRuleIndex(self): 

3562 return RParser.RULE_formula_simple_A 

3563 

3564 def enterRule(self, listener: ParseTreeListener): 

3565 if hasattr(listener, "enterFormula_simple_A"): 

3566 listener.enterFormula_simple_A(self) 

3567 

3568 def exitRule(self, listener: ParseTreeListener): 

3569 if hasattr(listener, "exitFormula_simple_A"): 

3570 listener.exitFormula_simple_A(self) 

3571 

3572 def formula_simple_A(self): 

3573 

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

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

3576 self._la = 0 # Token type 

3577 try: 

3578 self.enterOuterAlt(localctx, 1) 

3579 self.state = 679 

3580 self._errHandler.sync(self) 

3581 _la = self._input.LA(1) 

3582 if _la == RParser.ID: 

3583 self.state = 678 

3584 self.identifier() 

3585 

3586 self.state = 681 

3587 self.formop() 

3588 self.state = 684 

3589 self._errHandler.sync(self) 

3590 token = self._input.LA(1) 

3591 if token in [RParser.ID]: 

3592 self.state = 682 

3593 self.sublistadd() 

3594 pass 

3595 elif token in [RParser.T__17]: 

3596 self.state = 683 

3597 self.match(RParser.T__17) 

3598 pass 

3599 else: 

3600 raise NoViableAltException(self) 

3601 

3602 except RecognitionException as re: 

3603 localctx.exception = re 

3604 self._errHandler.reportError(self, re) 

3605 self._errHandler.recover(self, re) 

3606 finally: 

3607 self.exitRule() 

3608 return localctx 

3609 

3610 class Formula_simple_BContext(ParserRuleContext): 

3611 

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

3613 super().__init__(parent, invokingState) 

3614 self.parser = parser 

3615 

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

3617 if i is None: 

3618 return self.getTypedRuleContexts(RParser.IdentifierContext) 

3619 else: 

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

3621 

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

3623 if i is None: 

3624 return self.getTypedRuleContexts(RParser.ExprContext) 

3625 else: 

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

3627 

3628 def affectop(self): 

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

3630 

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

3632 if i is None: 

3633 return self.getTokens(RParser.NL) 

3634 else: 

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

3636 

3637 def getRuleIndex(self): 

3638 return RParser.RULE_formula_simple_B 

3639 

3640 def enterRule(self, listener: ParseTreeListener): 

3641 if hasattr(listener, "enterFormula_simple_B"): 

3642 listener.enterFormula_simple_B(self) 

3643 

3644 def exitRule(self, listener: ParseTreeListener): 

3645 if hasattr(listener, "exitFormula_simple_B"): 

3646 listener.exitFormula_simple_B(self) 

3647 

3648 def formula_simple_B(self): 

3649 

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

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

3652 self._la = 0 # Token type 

3653 try: 

3654 self.enterOuterAlt(localctx, 1) 

3655 self.state = 686 

3656 self.match(RParser.T__37) 

3657 self.state = 687 

3658 self.match(RParser.T__15) 

3659 self.state = 688 

3660 self.identifier() 

3661 self.state = 689 

3662 self.match(RParser.T__18) 

3663 self.state = 717 

3664 self._errHandler.sync(self) 

3665 token = self._input.LA(1) 

3666 if token in [RParser.T__11]: 

3667 self.state = 690 

3668 self.match(RParser.T__11) 

3669 self.state = 694 

3670 self._errHandler.sync(self) 

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

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

3673 if _alt == 1: 

3674 self.state = 691 

3675 self.match(RParser.NL) 

3676 self.state = 696 

3677 self._errHandler.sync(self) 

3678 _alt = self._interp.adaptivePredict( 

3679 self._input, 75, self._ctx) 

3680 

3681 self.state = 697 

3682 self.expr(0) 

3683 self.state = 702 

3684 self._errHandler.sync(self) 

3685 _la = self._input.LA(1) 

3686 while _la == RParser.T__0: 

3687 self.state = 698 

3688 self.match(RParser.T__0) 

3689 self.state = 699 

3690 self.expr(0) 

3691 self.state = 704 

3692 self._errHandler.sync(self) 

3693 _la = self._input.LA(1) 

3694 

3695 self.state = 708 

3696 self._errHandler.sync(self) 

3697 _la = self._input.LA(1) 

3698 while _la == RParser.NL: 

3699 self.state = 705 

3700 self.match(RParser.NL) 

3701 self.state = 710 

3702 self._errHandler.sync(self) 

3703 _la = self._input.LA(1) 

3704 

3705 self.state = 711 

3706 self.match(RParser.T__12) 

3707 pass 

3708 elif token in [RParser.ID]: 

3709 self.state = 713 

3710 self.identifier() 

3711 self.state = 714 

3712 self.affectop() 

3713 self.state = 715 

3714 self.expr(0) 

3715 pass 

3716 else: 

3717 raise NoViableAltException(self) 

3718 

3719 self.state = 719 

3720 self.match(RParser.T__16) 

3721 except RecognitionException as re: 

3722 localctx.exception = re 

3723 self._errHandler.reportError(self, re) 

3724 self._errHandler.recover(self, re) 

3725 finally: 

3726 self.exitRule() 

3727 return localctx 

3728 

3729 class Formula_simple_CContext(ParserRuleContext): 

3730 

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

3732 super().__init__(parent, invokingState) 

3733 self.parser = parser 

3734 

3735 def expr(self): 

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

3737 

3738 def formop(self): 

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

3740 

3741 def sublistadd(self): 

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

3743 

3744 def getRuleIndex(self): 

3745 return RParser.RULE_formula_simple_C 

3746 

3747 def enterRule(self, listener: ParseTreeListener): 

3748 if hasattr(listener, "enterFormula_simple_C"): 

3749 listener.enterFormula_simple_C(self) 

3750 

3751 def exitRule(self, listener: ParseTreeListener): 

3752 if hasattr(listener, "exitFormula_simple_C"): 

3753 listener.exitFormula_simple_C(self) 

3754 

3755 def formula_simple_C(self): 

3756 

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

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

3759 try: 

3760 self.enterOuterAlt(localctx, 1) 

3761 self.state = 721 

3762 self.match(RParser.T__15) 

3763 self.state = 722 

3764 self.expr(0) 

3765 self.state = 723 

3766 self.match(RParser.T__16) 

3767 self.state = 724 

3768 self.formop() 

3769 self.state = 727 

3770 self._errHandler.sync(self) 

3771 token = self._input.LA(1) 

3772 if token in [RParser.ID]: 

3773 self.state = 725 

3774 self.sublistadd() 

3775 pass 

3776 elif token in [RParser.T__17]: 

3777 self.state = 726 

3778 self.match(RParser.T__17) 

3779 pass 

3780 else: 

3781 raise NoViableAltException(self) 

3782 

3783 except RecognitionException as re: 

3784 localctx.exception = re 

3785 self._errHandler.reportError(self, re) 

3786 self._errHandler.recover(self, re) 

3787 finally: 

3788 self.exitRule() 

3789 return localctx 

3790 

3791 class AffectopContext(ParserRuleContext): 

3792 

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

3794 super().__init__(parent, invokingState) 

3795 self.parser = parser 

3796 

3797 def getRuleIndex(self): 

3798 return RParser.RULE_affectop 

3799 

3800 def enterRule(self, listener: ParseTreeListener): 

3801 if hasattr(listener, "enterAffectop"): 

3802 listener.enterAffectop(self) 

3803 

3804 def exitRule(self, listener: ParseTreeListener): 

3805 if hasattr(listener, "exitAffectop"): 

3806 listener.exitAffectop(self) 

3807 

3808 def affectop(self): 

3809 

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

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

3812 self._la = 0 # Token type 

3813 try: 

3814 self.enterOuterAlt(localctx, 1) 

3815 self.state = 729 

3816 _la = self._input.LA(1) 

3817 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)): 

3818 self._errHandler.recoverInline(self) 

3819 else: 

3820 self._errHandler.reportMatch(self) 

3821 self.consume() 

3822 except RecognitionException as re: 

3823 localctx.exception = re 

3824 self._errHandler.reportError(self, re) 

3825 self._errHandler.recover(self, re) 

3826 finally: 

3827 self.exitRule() 

3828 return localctx 

3829 

3830 class FunctiondefContext(ParserRuleContext): 

3831 

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

3833 super().__init__(parent, invokingState) 

3834 self.parser = parser 

3835 

3836 def getRuleIndex(self): 

3837 return RParser.RULE_functiondef 

3838 

3839 def enterRule(self, listener: ParseTreeListener): 

3840 if hasattr(listener, "enterFunctiondef"): 

3841 listener.enterFunctiondef(self) 

3842 

3843 def exitRule(self, listener: ParseTreeListener): 

3844 if hasattr(listener, "exitFunctiondef"): 

3845 listener.exitFunctiondef(self) 

3846 

3847 def functiondef(self): 

3848 

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

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

3851 try: 

3852 self.enterOuterAlt(localctx, 1) 

3853 self.state = 731 

3854 self.match(RParser.T__43) 

3855 except RecognitionException as re: 

3856 localctx.exception = re 

3857 self._errHandler.reportError(self, re) 

3858 self._errHandler.recover(self, re) 

3859 finally: 

3860 self.exitRule() 

3861 return localctx 

3862 

3863 class IdentifierContext(ParserRuleContext): 

3864 

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

3866 super().__init__(parent, invokingState) 

3867 self.parser = parser 

3868 

3869 def ID(self): 

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

3871 

3872 def getRuleIndex(self): 

3873 return RParser.RULE_identifier 

3874 

3875 def enterRule(self, listener: ParseTreeListener): 

3876 if hasattr(listener, "enterIdentifier"): 

3877 listener.enterIdentifier(self) 

3878 

3879 def exitRule(self, listener: ParseTreeListener): 

3880 if hasattr(listener, "exitIdentifier"): 

3881 listener.exitIdentifier(self) 

3882 

3883 def identifier(self): 

3884 

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

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

3887 try: 

3888 self.enterOuterAlt(localctx, 1) 

3889 self.state = 733 

3890 self.match(RParser.ID) 

3891 except RecognitionException as re: 

3892 localctx.exception = re 

3893 self._errHandler.reportError(self, re) 

3894 self._errHandler.recover(self, re) 

3895 finally: 

3896 self.exitRule() 

3897 return localctx 

3898 

3899 class FormopContext(ParserRuleContext): 

3900 

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

3902 super().__init__(parent, invokingState) 

3903 self.parser = parser 

3904 

3905 def getRuleIndex(self): 

3906 return RParser.RULE_formop 

3907 

3908 def enterRule(self, listener: ParseTreeListener): 

3909 if hasattr(listener, "enterFormop"): 

3910 listener.enterFormop(self) 

3911 

3912 def exitRule(self, listener: ParseTreeListener): 

3913 if hasattr(listener, "exitFormop"): 

3914 listener.exitFormop(self) 

3915 

3916 def formop(self): 

3917 

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

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

3920 try: 

3921 self.enterOuterAlt(localctx, 1) 

3922 self.state = 735 

3923 self.match(RParser.T__44) 

3924 except RecognitionException as re: 

3925 localctx.exception = re 

3926 self._errHandler.reportError(self, re) 

3927 self._errHandler.recover(self, re) 

3928 finally: 

3929 self.exitRule() 

3930 return localctx 

3931 

3932 class RangeopContext(ParserRuleContext): 

3933 

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

3935 super().__init__(parent, invokingState) 

3936 self.parser = parser 

3937 

3938 def getRuleIndex(self): 

3939 return RParser.RULE_rangeop 

3940 

3941 def enterRule(self, listener: ParseTreeListener): 

3942 if hasattr(listener, "enterRangeop"): 

3943 listener.enterRangeop(self) 

3944 

3945 def exitRule(self, listener: ParseTreeListener): 

3946 if hasattr(listener, "exitRangeop"): 

3947 listener.exitRangeop(self) 

3948 

3949 def rangeop(self): 

3950 

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

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

3953 self._la = 0 # Token type 

3954 try: 

3955 self.enterOuterAlt(localctx, 1) 

3956 self.state = 737 

3957 _la = self._input.LA(1) 

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

3959 self._errHandler.recoverInline(self) 

3960 else: 

3961 self._errHandler.reportMatch(self) 

3962 self.consume() 

3963 except RecognitionException as re: 

3964 localctx.exception = re 

3965 self._errHandler.reportError(self, re) 

3966 self._errHandler.recover(self, re) 

3967 finally: 

3968 self.exitRule() 

3969 return localctx 

3970 

3971 class DotopContext(ParserRuleContext): 

3972 

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

3974 super().__init__(parent, invokingState) 

3975 self.parser = parser 

3976 

3977 def getRuleIndex(self): 

3978 return RParser.RULE_dotop 

3979 

3980 def enterRule(self, listener: ParseTreeListener): 

3981 if hasattr(listener, "enterDotop"): 

3982 listener.enterDotop(self) 

3983 

3984 def exitRule(self, listener: ParseTreeListener): 

3985 if hasattr(listener, "exitDotop"): 

3986 listener.exitDotop(self) 

3987 

3988 def dotop(self): 

3989 

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

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

3992 self._la = 0 # Token type 

3993 try: 

3994 self.enterOuterAlt(localctx, 1) 

3995 self.state = 739 

3996 _la = self._input.LA(1) 

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

3998 self._errHandler.recoverInline(self) 

3999 else: 

4000 self._errHandler.reportMatch(self) 

4001 self.consume() 

4002 except RecognitionException as re: 

4003 localctx.exception = re 

4004 self._errHandler.reportError(self, re) 

4005 self._errHandler.recover(self, re) 

4006 finally: 

4007 self.exitRule() 

4008 return localctx 

4009 

4010 class OperatorContext(ParserRuleContext): 

4011 

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

4013 super().__init__(parent, invokingState) 

4014 self.parser = parser 

4015 

4016 def getRuleIndex(self): 

4017 return RParser.RULE_operator 

4018 

4019 def enterRule(self, listener: ParseTreeListener): 

4020 if hasattr(listener, "enterOperator"): 

4021 listener.enterOperator(self) 

4022 

4023 def exitRule(self, listener: ParseTreeListener): 

4024 if hasattr(listener, "exitOperator"): 

4025 listener.exitOperator(self) 

4026 

4027 def operator(self): 

4028 

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

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

4031 self._la = 0 # Token type 

4032 try: 

4033 self.enterOuterAlt(localctx, 1) 

4034 self.state = 741 

4035 _la = self._input.LA(1) 

4036 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)): 

4037 self._errHandler.recoverInline(self) 

4038 else: 

4039 self._errHandler.reportMatch(self) 

4040 self.consume() 

4041 except RecognitionException as re: 

4042 localctx.exception = re 

4043 self._errHandler.reportError(self, re) 

4044 self._errHandler.recover(self, re) 

4045 finally: 

4046 self.exitRule() 

4047 return localctx 

4048 

4049 class ComparisonContext(ParserRuleContext): 

4050 

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

4052 super().__init__(parent, invokingState) 

4053 self.parser = parser 

4054 

4055 def getRuleIndex(self): 

4056 return RParser.RULE_comparison 

4057 

4058 def enterRule(self, listener: ParseTreeListener): 

4059 if hasattr(listener, "enterComparison"): 

4060 listener.enterComparison(self) 

4061 

4062 def exitRule(self, listener: ParseTreeListener): 

4063 if hasattr(listener, "exitComparison"): 

4064 listener.exitComparison(self) 

4065 

4066 def comparison(self): 

4067 

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

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

4070 self._la = 0 # Token type 

4071 try: 

4072 self.enterOuterAlt(localctx, 1) 

4073 self.state = 743 

4074 _la = self._input.LA(1) 

4075 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)): 

4076 self._errHandler.recoverInline(self) 

4077 else: 

4078 self._errHandler.reportMatch(self) 

4079 self.consume() 

4080 except RecognitionException as re: 

4081 localctx.exception = re 

4082 self._errHandler.reportError(self, re) 

4083 self._errHandler.recover(self, re) 

4084 finally: 

4085 self.exitRule() 

4086 return localctx 

4087 

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

4089 if self._predicates == None: 

4090 self._predicates = dict() 

4091 self._predicates[1] = self.expr_sempred 

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

4093 if pred is None: 

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

4095 else: 

4096 return pred(localctx, predIndex) 

4097 

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

4099 if predIndex == 0: 

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

4101 

4102 if predIndex == 1: 

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

4104 

4105 if predIndex == 2: 

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

4107 

4108 if predIndex == 3: 

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

4110 

4111 if predIndex == 4: 

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

4113 

4114 if predIndex == 5: 

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

4116 

4117 if predIndex == 6: 

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

4119 

4120 if predIndex == 7: 

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

4122 

4123 if predIndex == 8: 

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

4125 

4126 if predIndex == 9: 

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