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

5233 statements  

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

1# Generated from \Python3.g4 by ANTLR 4.10.1 

2# encoding: utf-8 

3from antlr4 import * 

4from io import StringIO 

5import sys 

6if sys.version_info[1] > 5: 

7 from typing import TextIO 

8else: 

9 from typing.io import TextIO 

10 

11def serializedATN(): 

12 return [ 

13 4,1,99,1104,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6, 

14 7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7, 

15 13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2, 

16 20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7, 

17 26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2, 

18 33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7, 

19 39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2, 

20 46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7, 

21 52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2, 

22 59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7, 

23 65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2, 

24 72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7, 

25 78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2, 

26 85,7,85,1,0,1,0,1,0,1,0,1,0,3,0,178,8,0,1,1,1,1,5,1,182,8,1,10,1, 

27 12,1,185,9,1,1,1,1,1,1,2,1,2,5,2,191,8,2,10,2,12,2,194,9,2,1,2,1, 

28 2,1,3,1,3,1,3,1,3,3,3,202,8,3,1,3,3,3,205,8,3,1,3,1,3,1,4,4,4,210, 

29 8,4,11,4,12,4,211,1,5,1,5,1,5,1,5,3,5,218,8,5,1,6,1,6,1,6,1,7,1, 

30 7,1,7,1,7,1,7,3,7,228,8,7,1,7,1,7,1,7,1,8,1,8,3,8,235,8,8,1,8,1, 

31 8,1,9,1,9,1,9,3,9,242,8,9,1,9,1,9,1,9,1,9,3,9,248,8,9,5,9,250,8, 

32 9,10,9,12,9,253,9,9,1,9,1,9,1,9,3,9,258,8,9,1,9,1,9,1,9,1,9,3,9, 

33 264,8,9,5,9,266,8,9,10,9,12,9,269,9,9,1,9,1,9,1,9,1,9,3,9,275,8, 

34 9,3,9,277,8,9,3,9,279,8,9,1,9,1,9,1,9,3,9,284,8,9,3,9,286,8,9,3, 

35 9,288,8,9,1,9,1,9,3,9,292,8,9,1,9,1,9,1,9,1,9,3,9,298,8,9,5,9,300, 

36 8,9,10,9,12,9,303,9,9,1,9,1,9,1,9,1,9,3,9,309,8,9,3,9,311,8,9,3, 

37 9,313,8,9,1,9,1,9,1,9,3,9,318,8,9,3,9,320,8,9,1,10,1,10,1,10,3,10, 

38 325,8,10,1,11,1,11,1,11,3,11,330,8,11,1,11,1,11,1,11,1,11,3,11,336, 

39 8,11,5,11,338,8,11,10,11,12,11,341,9,11,1,11,1,11,1,11,3,11,346, 

40 8,11,1,11,1,11,1,11,1,11,3,11,352,8,11,5,11,354,8,11,10,11,12,11, 

41 357,9,11,1,11,1,11,1,11,1,11,3,11,363,8,11,3,11,365,8,11,3,11,367, 

42 8,11,1,11,1,11,1,11,3,11,372,8,11,3,11,374,8,11,3,11,376,8,11,1, 

43 11,1,11,3,11,380,8,11,1,11,1,11,1,11,1,11,3,11,386,8,11,5,11,388, 

44 8,11,10,11,12,11,391,9,11,1,11,1,11,1,11,1,11,3,11,397,8,11,3,11, 

45 399,8,11,3,11,401,8,11,1,11,1,11,1,11,3,11,406,8,11,3,11,408,8,11, 

46 1,12,1,12,1,13,1,13,3,13,414,8,13,1,14,1,14,1,14,5,14,419,8,14,10, 

47 14,12,14,422,9,14,1,14,3,14,425,8,14,1,14,1,14,1,15,1,15,1,15,1, 

48 15,1,15,1,15,1,15,1,15,3,15,437,8,15,1,16,1,16,1,16,1,16,1,16,3, 

49 16,444,8,16,1,16,1,16,1,16,3,16,449,8,16,5,16,451,8,16,10,16,12, 

50 16,454,9,16,3,16,456,8,16,1,17,1,17,1,17,1,17,3,17,462,8,17,1,18, 

51 1,18,3,18,466,8,18,1,18,1,18,1,18,3,18,471,8,18,5,18,473,8,18,10, 

52 18,12,18,476,9,18,1,18,3,18,479,8,18,1,19,1,19,1,20,1,20,1,20,1, 

53 21,1,21,1,22,1,22,1,22,1,22,1,22,3,22,493,8,22,1,23,1,23,1,24,1, 

54 24,1,25,1,25,3,25,501,8,25,1,26,1,26,1,27,1,27,1,27,1,27,3,27,509, 

55 8,27,3,27,511,8,27,1,28,1,28,3,28,515,8,28,1,29,1,29,1,29,1,30,1, 

56 30,5,30,522,8,30,10,30,12,30,525,9,30,1,30,1,30,4,30,529,8,30,11, 

57 30,12,30,530,3,30,533,8,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,3, 

58 30,542,8,30,1,31,1,31,1,31,3,31,547,8,31,1,32,1,32,1,32,3,32,552, 

59 8,32,1,33,1,33,1,33,5,33,557,8,33,10,33,12,33,560,9,33,1,33,3,33, 

60 563,8,33,1,34,1,34,1,34,5,34,568,8,34,10,34,12,34,571,9,34,1,35, 

61 1,35,1,35,5,35,576,8,35,10,35,12,35,579,9,35,1,36,1,36,1,36,1,36, 

62 5,36,585,8,36,10,36,12,36,588,9,36,1,37,1,37,1,37,1,37,5,37,594, 

63 8,37,10,37,12,37,597,9,37,1,38,1,38,1,38,1,38,3,38,603,8,38,1,39, 

64 1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,3,39,614,8,39,1,40,1,40, 

65 1,40,1,40,3,40,620,8,40,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41, 

66 1,41,5,41,631,8,41,10,41,12,41,634,9,41,1,41,1,41,1,41,3,41,639, 

67 8,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,3,42,648,8,42,1,43,1,43, 

68 1,43,1,43,1,43,1,43,1,43,1,43,1,43,3,43,659,8,43,1,44,1,44,1,44, 

69 1,44,1,44,1,44,1,44,4,44,668,8,44,11,44,12,44,669,1,44,1,44,1,44, 

70 3,44,675,8,44,1,44,1,44,1,44,3,44,680,8,44,1,44,1,44,1,44,3,44,685, 

71 8,44,1,45,1,45,1,45,1,45,5,45,691,8,45,10,45,12,45,694,9,45,1,45, 

72 1,45,1,45,1,46,1,46,1,46,3,46,702,8,46,1,47,1,47,1,47,1,47,3,47, 

73 708,8,47,3,47,710,8,47,1,48,1,48,1,48,1,48,4,48,716,8,48,11,48,12, 

74 48,717,1,48,1,48,3,48,722,8,48,1,49,1,49,1,49,1,49,1,49,1,49,3,49, 

75 730,8,49,1,49,3,49,733,8,49,1,50,1,50,3,50,737,8,50,1,51,1,51,3, 

76 51,741,8,51,1,51,1,51,1,51,1,52,1,52,3,52,748,8,52,1,52,1,52,1,52, 

77 1,53,1,53,1,53,5,53,756,8,53,10,53,12,53,759,9,53,1,54,1,54,1,54, 

78 5,54,764,8,54,10,54,12,54,767,9,54,1,55,1,55,1,55,3,55,772,8,55, 

79 1,56,1,56,1,56,1,56,5,56,778,8,56,10,56,12,56,781,9,56,1,57,1,57, 

80 1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,3,57,796, 

81 8,57,1,58,1,58,1,58,1,59,1,59,1,59,5,59,804,8,59,10,59,12,59,807, 

82 9,59,1,60,1,60,1,60,5,60,812,8,60,10,60,12,60,815,9,60,1,61,1,61, 

83 1,61,5,61,820,8,61,10,61,12,61,823,9,61,1,62,1,62,1,62,5,62,828, 

84 8,62,10,62,12,62,831,9,62,1,63,1,63,1,63,5,63,836,8,63,10,63,12, 

85 63,839,9,63,1,64,1,64,1,64,5,64,844,8,64,10,64,12,64,847,9,64,1, 

86 65,1,65,1,65,3,65,852,8,65,1,66,1,66,1,66,3,66,857,8,66,1,67,3,67, 

87 860,8,67,1,67,1,67,5,67,864,8,67,10,67,12,67,867,9,67,1,68,1,68, 

88 1,68,3,68,872,8,68,1,68,1,68,1,68,3,68,877,8,68,1,68,1,68,1,68,3, 

89 68,882,8,68,1,68,1,68,1,68,1,68,4,68,888,8,68,11,68,12,68,889,1, 

90 68,1,68,1,68,1,68,3,68,896,8,68,1,69,1,69,3,69,900,8,69,1,69,1,69, 

91 1,69,1,69,3,69,906,8,69,5,69,908,8,69,10,69,12,69,911,9,69,1,69, 

92 3,69,914,8,69,3,69,916,8,69,1,70,1,70,3,70,920,8,70,1,70,1,70,1, 

93 70,1,70,1,70,1,70,1,70,3,70,929,8,70,1,71,1,71,1,71,5,71,934,8,71, 

94 10,71,12,71,937,9,71,1,71,3,71,940,8,71,1,72,1,72,3,72,944,8,72, 

95 1,72,1,72,3,72,948,8,72,1,72,3,72,951,8,72,3,72,953,8,72,1,73,1, 

96 73,3,73,957,8,73,1,74,1,74,3,74,961,8,74,1,74,1,74,1,74,3,74,966, 

97 8,74,5,74,968,8,74,10,74,12,74,971,9,74,1,74,3,74,974,8,74,1,75, 

98 1,75,1,75,5,75,979,8,75,10,75,12,75,982,9,75,1,75,3,75,985,8,75, 

99 1,76,1,76,1,76,1,76,1,76,1,76,3,76,993,8,76,1,76,1,76,1,76,1,76, 

100 1,76,1,76,1,76,1,76,3,76,1003,8,76,5,76,1005,8,76,10,76,12,76,1008, 

101 9,76,1,76,3,76,1011,8,76,3,76,1013,8,76,1,76,1,76,3,76,1017,8,76, 

102 1,76,1,76,1,76,1,76,3,76,1023,8,76,5,76,1025,8,76,10,76,12,76,1028, 

103 9,76,1,76,3,76,1031,8,76,3,76,1033,8,76,3,76,1035,8,76,1,77,1,77, 

104 1,77,1,77,3,77,1041,8,77,1,77,3,77,1044,8,77,1,77,1,77,1,77,1,78, 

105 1,78,1,78,5,78,1052,8,78,10,78,12,78,1055,9,78,1,78,3,78,1058,8, 

106 78,1,79,1,79,3,79,1062,8,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1, 

107 79,3,79,1072,8,79,1,80,1,80,3,80,1076,8,80,1,81,3,81,1079,8,81,1, 

108 81,1,81,1,81,1,81,1,81,3,81,1086,8,81,1,82,1,82,1,82,3,82,1091,8, 

109 82,1,83,1,83,1,84,1,84,3,84,1097,8,84,1,85,1,85,1,85,3,85,1102,8, 

110 85,1,85,0,0,86,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34, 

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

112 80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116, 

113 118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148, 

114 150,152,154,156,158,160,162,164,166,168,170,0,6,1,0,83,95,1,0,49, 

115 50,1,0,64,65,1,0,66,67,3,0,51,51,68,70,81,81,2,0,66,67,71,71,1229, 

116 0,177,1,0,0,0,2,183,1,0,0,0,4,188,1,0,0,0,6,197,1,0,0,0,8,209,1, 

117 0,0,0,10,213,1,0,0,0,12,219,1,0,0,0,14,222,1,0,0,0,16,232,1,0,0, 

118 0,18,319,1,0,0,0,20,321,1,0,0,0,22,407,1,0,0,0,24,409,1,0,0,0,26, 

119 413,1,0,0,0,28,415,1,0,0,0,30,436,1,0,0,0,32,438,1,0,0,0,34,457, 

120 1,0,0,0,36,465,1,0,0,0,38,480,1,0,0,0,40,482,1,0,0,0,42,485,1,0, 

121 0,0,44,492,1,0,0,0,46,494,1,0,0,0,48,496,1,0,0,0,50,498,1,0,0,0, 

122 52,502,1,0,0,0,54,504,1,0,0,0,56,514,1,0,0,0,58,516,1,0,0,0,60,519, 

123 1,0,0,0,62,543,1,0,0,0,64,548,1,0,0,0,66,553,1,0,0,0,68,564,1,0, 

124 0,0,70,572,1,0,0,0,72,580,1,0,0,0,74,589,1,0,0,0,76,598,1,0,0,0, 

125 78,613,1,0,0,0,80,615,1,0,0,0,82,621,1,0,0,0,84,640,1,0,0,0,86,649, 

126 1,0,0,0,88,660,1,0,0,0,90,686,1,0,0,0,92,698,1,0,0,0,94,703,1,0, 

127 0,0,96,721,1,0,0,0,98,732,1,0,0,0,100,736,1,0,0,0,102,738,1,0,0, 

128 0,104,745,1,0,0,0,106,752,1,0,0,0,108,760,1,0,0,0,110,771,1,0,0, 

129 0,112,773,1,0,0,0,114,795,1,0,0,0,116,797,1,0,0,0,118,800,1,0,0, 

130 0,120,808,1,0,0,0,122,816,1,0,0,0,124,824,1,0,0,0,126,832,1,0,0, 

131 0,128,840,1,0,0,0,130,851,1,0,0,0,132,853,1,0,0,0,134,859,1,0,0, 

132 0,136,895,1,0,0,0,138,899,1,0,0,0,140,928,1,0,0,0,142,930,1,0,0, 

133 0,144,952,1,0,0,0,146,954,1,0,0,0,148,960,1,0,0,0,150,975,1,0,0, 

134 0,152,1034,1,0,0,0,154,1036,1,0,0,0,156,1048,1,0,0,0,158,1071,1, 

135 0,0,0,160,1075,1,0,0,0,162,1078,1,0,0,0,164,1087,1,0,0,0,166,1092, 

136 1,0,0,0,168,1094,1,0,0,0,170,1101,1,0,0,0,172,178,5,39,0,0,173,178, 

137 3,28,14,0,174,175,3,78,39,0,175,176,5,39,0,0,176,178,1,0,0,0,177, 

138 172,1,0,0,0,177,173,1,0,0,0,177,174,1,0,0,0,178,1,1,0,0,0,179,182, 

139 5,39,0,0,180,182,3,26,13,0,181,179,1,0,0,0,181,180,1,0,0,0,182,185, 

140 1,0,0,0,183,181,1,0,0,0,183,184,1,0,0,0,184,186,1,0,0,0,185,183, 

141 1,0,0,0,186,187,5,0,0,1,187,3,1,0,0,0,188,192,3,150,75,0,189,191, 

142 5,39,0,0,190,189,1,0,0,0,191,194,1,0,0,0,192,190,1,0,0,0,192,193, 

143 1,0,0,0,193,195,1,0,0,0,194,192,1,0,0,0,195,196,5,0,0,1,196,5,1, 

144 0,0,0,197,198,5,81,0,0,198,204,3,70,35,0,199,201,5,52,0,0,200,202, 

145 3,156,78,0,201,200,1,0,0,0,201,202,1,0,0,0,202,203,1,0,0,0,203,205, 

146 5,53,0,0,204,199,1,0,0,0,204,205,1,0,0,0,205,206,1,0,0,0,206,207, 

147 5,39,0,0,207,7,1,0,0,0,208,210,3,6,3,0,209,208,1,0,0,0,210,211,1, 

148 0,0,0,211,209,1,0,0,0,211,212,1,0,0,0,212,9,1,0,0,0,213,217,3,8, 

149 4,0,214,218,3,154,77,0,215,218,3,14,7,0,216,218,3,12,6,0,217,214, 

150 1,0,0,0,217,215,1,0,0,0,217,216,1,0,0,0,218,11,1,0,0,0,219,220,5, 

151 37,0,0,220,221,3,14,7,0,221,13,1,0,0,0,222,223,5,4,0,0,223,224,5, 

152 40,0,0,224,227,3,16,8,0,225,226,5,82,0,0,226,228,3,98,49,0,227,225, 

153 1,0,0,0,227,228,1,0,0,0,228,229,1,0,0,0,229,230,5,55,0,0,230,231, 

154 3,96,48,0,231,15,1,0,0,0,232,234,5,52,0,0,233,235,3,18,9,0,234,233, 

155 1,0,0,0,234,235,1,0,0,0,235,236,1,0,0,0,236,237,5,53,0,0,237,17, 

156 1,0,0,0,238,241,3,20,10,0,239,240,5,58,0,0,240,242,3,98,49,0,241, 

157 239,1,0,0,0,241,242,1,0,0,0,242,251,1,0,0,0,243,244,5,54,0,0,244, 

158 247,3,20,10,0,245,246,5,58,0,0,246,248,3,98,49,0,247,245,1,0,0,0, 

159 247,248,1,0,0,0,248,250,1,0,0,0,249,243,1,0,0,0,250,253,1,0,0,0, 

160 251,249,1,0,0,0,251,252,1,0,0,0,252,287,1,0,0,0,253,251,1,0,0,0, 

161 254,285,5,54,0,0,255,257,5,51,0,0,256,258,3,20,10,0,257,256,1,0, 

162 0,0,257,258,1,0,0,0,258,267,1,0,0,0,259,260,5,54,0,0,260,263,3,20, 

163 10,0,261,262,5,58,0,0,262,264,3,98,49,0,263,261,1,0,0,0,263,264, 

164 1,0,0,0,264,266,1,0,0,0,265,259,1,0,0,0,266,269,1,0,0,0,267,265, 

165 1,0,0,0,267,268,1,0,0,0,268,278,1,0,0,0,269,267,1,0,0,0,270,276, 

166 5,54,0,0,271,272,5,57,0,0,272,274,3,20,10,0,273,275,5,54,0,0,274, 

167 273,1,0,0,0,274,275,1,0,0,0,275,277,1,0,0,0,276,271,1,0,0,0,276, 

168 277,1,0,0,0,277,279,1,0,0,0,278,270,1,0,0,0,278,279,1,0,0,0,279, 

169 286,1,0,0,0,280,281,5,57,0,0,281,283,3,20,10,0,282,284,5,54,0,0, 

170 283,282,1,0,0,0,283,284,1,0,0,0,284,286,1,0,0,0,285,255,1,0,0,0, 

171 285,280,1,0,0,0,285,286,1,0,0,0,286,288,1,0,0,0,287,254,1,0,0,0, 

172 287,288,1,0,0,0,288,320,1,0,0,0,289,291,5,51,0,0,290,292,3,20,10, 

173 0,291,290,1,0,0,0,291,292,1,0,0,0,292,301,1,0,0,0,293,294,5,54,0, 

174 0,294,297,3,20,10,0,295,296,5,58,0,0,296,298,3,98,49,0,297,295,1, 

175 0,0,0,297,298,1,0,0,0,298,300,1,0,0,0,299,293,1,0,0,0,300,303,1, 

176 0,0,0,301,299,1,0,0,0,301,302,1,0,0,0,302,312,1,0,0,0,303,301,1, 

177 0,0,0,304,310,5,54,0,0,305,306,5,57,0,0,306,308,3,20,10,0,307,309, 

178 5,54,0,0,308,307,1,0,0,0,308,309,1,0,0,0,309,311,1,0,0,0,310,305, 

179 1,0,0,0,310,311,1,0,0,0,311,313,1,0,0,0,312,304,1,0,0,0,312,313, 

180 1,0,0,0,313,320,1,0,0,0,314,315,5,57,0,0,315,317,3,20,10,0,316,318, 

181 5,54,0,0,317,316,1,0,0,0,317,318,1,0,0,0,318,320,1,0,0,0,319,238, 

182 1,0,0,0,319,289,1,0,0,0,319,314,1,0,0,0,320,19,1,0,0,0,321,324,5, 

183 40,0,0,322,323,5,55,0,0,323,325,3,98,49,0,324,322,1,0,0,0,324,325, 

184 1,0,0,0,325,21,1,0,0,0,326,329,3,24,12,0,327,328,5,58,0,0,328,330, 

185 3,98,49,0,329,327,1,0,0,0,329,330,1,0,0,0,330,339,1,0,0,0,331,332, 

186 5,54,0,0,332,335,3,24,12,0,333,334,5,58,0,0,334,336,3,98,49,0,335, 

187 333,1,0,0,0,335,336,1,0,0,0,336,338,1,0,0,0,337,331,1,0,0,0,338, 

188 341,1,0,0,0,339,337,1,0,0,0,339,340,1,0,0,0,340,375,1,0,0,0,341, 

189 339,1,0,0,0,342,373,5,54,0,0,343,345,5,51,0,0,344,346,3,24,12,0, 

190 345,344,1,0,0,0,345,346,1,0,0,0,346,355,1,0,0,0,347,348,5,54,0,0, 

191 348,351,3,24,12,0,349,350,5,58,0,0,350,352,3,98,49,0,351,349,1,0, 

192 0,0,351,352,1,0,0,0,352,354,1,0,0,0,353,347,1,0,0,0,354,357,1,0, 

193 0,0,355,353,1,0,0,0,355,356,1,0,0,0,356,366,1,0,0,0,357,355,1,0, 

194 0,0,358,364,5,54,0,0,359,360,5,57,0,0,360,362,3,24,12,0,361,363, 

195 5,54,0,0,362,361,1,0,0,0,362,363,1,0,0,0,363,365,1,0,0,0,364,359, 

196 1,0,0,0,364,365,1,0,0,0,365,367,1,0,0,0,366,358,1,0,0,0,366,367, 

197 1,0,0,0,367,374,1,0,0,0,368,369,5,57,0,0,369,371,3,24,12,0,370,372, 

198 5,54,0,0,371,370,1,0,0,0,371,372,1,0,0,0,372,374,1,0,0,0,373,343, 

199 1,0,0,0,373,368,1,0,0,0,373,374,1,0,0,0,374,376,1,0,0,0,375,342, 

200 1,0,0,0,375,376,1,0,0,0,376,408,1,0,0,0,377,379,5,51,0,0,378,380, 

201 3,24,12,0,379,378,1,0,0,0,379,380,1,0,0,0,380,389,1,0,0,0,381,382, 

202 5,54,0,0,382,385,3,24,12,0,383,384,5,58,0,0,384,386,3,98,49,0,385, 

203 383,1,0,0,0,385,386,1,0,0,0,386,388,1,0,0,0,387,381,1,0,0,0,388, 

204 391,1,0,0,0,389,387,1,0,0,0,389,390,1,0,0,0,390,400,1,0,0,0,391, 

205 389,1,0,0,0,392,398,5,54,0,0,393,394,5,57,0,0,394,396,3,24,12,0, 

206 395,397,5,54,0,0,396,395,1,0,0,0,396,397,1,0,0,0,397,399,1,0,0,0, 

207 398,393,1,0,0,0,398,399,1,0,0,0,399,401,1,0,0,0,400,392,1,0,0,0, 

208 400,401,1,0,0,0,401,408,1,0,0,0,402,403,5,57,0,0,403,405,3,24,12, 

209 0,404,406,5,54,0,0,405,404,1,0,0,0,405,406,1,0,0,0,406,408,1,0,0, 

210 0,407,326,1,0,0,0,407,377,1,0,0,0,407,402,1,0,0,0,408,23,1,0,0,0, 

211 409,410,5,40,0,0,410,25,1,0,0,0,411,414,3,28,14,0,412,414,3,78,39, 

212 0,413,411,1,0,0,0,413,412,1,0,0,0,414,27,1,0,0,0,415,420,3,30,15, 

213 0,416,417,5,56,0,0,417,419,3,30,15,0,418,416,1,0,0,0,419,422,1,0, 

214 0,0,420,418,1,0,0,0,420,421,1,0,0,0,421,424,1,0,0,0,422,420,1,0, 

215 0,0,423,425,5,56,0,0,424,423,1,0,0,0,424,425,1,0,0,0,425,426,1,0, 

216 0,0,426,427,5,39,0,0,427,29,1,0,0,0,428,437,3,32,16,0,429,437,3, 

217 40,20,0,430,437,3,42,21,0,431,437,3,44,22,0,432,437,3,56,28,0,433, 

218 437,3,72,36,0,434,437,3,74,37,0,435,437,3,76,38,0,436,428,1,0,0, 

219 0,436,429,1,0,0,0,436,430,1,0,0,0,436,431,1,0,0,0,436,432,1,0,0, 

220 0,436,433,1,0,0,0,436,434,1,0,0,0,436,435,1,0,0,0,437,31,1,0,0,0, 

221 438,455,3,36,18,0,439,456,3,34,17,0,440,443,3,38,19,0,441,444,3, 

222 168,84,0,442,444,3,150,75,0,443,441,1,0,0,0,443,442,1,0,0,0,444, 

223 456,1,0,0,0,445,448,5,58,0,0,446,449,3,168,84,0,447,449,3,36,18, 

224 0,448,446,1,0,0,0,448,447,1,0,0,0,449,451,1,0,0,0,450,445,1,0,0, 

225 0,451,454,1,0,0,0,452,450,1,0,0,0,452,453,1,0,0,0,453,456,1,0,0, 

226 0,454,452,1,0,0,0,455,439,1,0,0,0,455,440,1,0,0,0,455,452,1,0,0, 

227 0,456,33,1,0,0,0,457,458,5,55,0,0,458,461,3,98,49,0,459,460,5,58, 

228 0,0,460,462,3,98,49,0,461,459,1,0,0,0,461,462,1,0,0,0,462,35,1,0, 

229 0,0,463,466,3,98,49,0,464,466,3,116,58,0,465,463,1,0,0,0,465,464, 

230 1,0,0,0,466,474,1,0,0,0,467,470,5,54,0,0,468,471,3,98,49,0,469,471, 

231 3,116,58,0,470,468,1,0,0,0,470,469,1,0,0,0,471,473,1,0,0,0,472,467, 

232 1,0,0,0,473,476,1,0,0,0,474,472,1,0,0,0,474,475,1,0,0,0,475,478, 

233 1,0,0,0,476,474,1,0,0,0,477,479,5,54,0,0,478,477,1,0,0,0,478,479, 

234 1,0,0,0,479,37,1,0,0,0,480,481,7,0,0,0,481,39,1,0,0,0,482,483,5, 

235 33,0,0,483,484,3,148,74,0,484,41,1,0,0,0,485,486,5,34,0,0,486,43, 

236 1,0,0,0,487,493,3,46,23,0,488,493,3,48,24,0,489,493,3,50,25,0,490, 

237 493,3,54,27,0,491,493,3,52,26,0,492,487,1,0,0,0,492,488,1,0,0,0, 

238 492,489,1,0,0,0,492,490,1,0,0,0,492,491,1,0,0,0,493,45,1,0,0,0,494, 

239 495,5,36,0,0,495,47,1,0,0,0,496,497,5,35,0,0,497,49,1,0,0,0,498, 

240 500,5,5,0,0,499,501,3,150,75,0,500,499,1,0,0,0,500,501,1,0,0,0,501, 

241 51,1,0,0,0,502,503,3,168,84,0,503,53,1,0,0,0,504,510,5,6,0,0,505, 

242 508,3,98,49,0,506,507,5,7,0,0,507,509,3,98,49,0,508,506,1,0,0,0, 

243 508,509,1,0,0,0,509,511,1,0,0,0,510,505,1,0,0,0,510,511,1,0,0,0, 

244 511,55,1,0,0,0,512,515,3,58,29,0,513,515,3,60,30,0,514,512,1,0,0, 

245 0,514,513,1,0,0,0,515,57,1,0,0,0,516,517,5,8,0,0,517,518,3,68,34, 

246 0,518,59,1,0,0,0,519,532,5,7,0,0,520,522,7,1,0,0,521,520,1,0,0,0, 

247 522,525,1,0,0,0,523,521,1,0,0,0,523,524,1,0,0,0,524,526,1,0,0,0, 

248 525,523,1,0,0,0,526,533,3,70,35,0,527,529,7,1,0,0,528,527,1,0,0, 

249 0,529,530,1,0,0,0,530,528,1,0,0,0,530,531,1,0,0,0,531,533,1,0,0, 

250 0,532,523,1,0,0,0,532,528,1,0,0,0,533,534,1,0,0,0,534,541,5,8,0, 

251 0,535,542,5,51,0,0,536,537,5,52,0,0,537,538,3,66,33,0,538,539,5, 

252 53,0,0,539,542,1,0,0,0,540,542,3,66,33,0,541,535,1,0,0,0,541,536, 

253 1,0,0,0,541,540,1,0,0,0,542,61,1,0,0,0,543,546,5,40,0,0,544,545, 

254 5,9,0,0,545,547,5,40,0,0,546,544,1,0,0,0,546,547,1,0,0,0,547,63, 

255 1,0,0,0,548,551,3,70,35,0,549,550,5,9,0,0,550,552,5,40,0,0,551,549, 

256 1,0,0,0,551,552,1,0,0,0,552,65,1,0,0,0,553,558,3,62,31,0,554,555, 

257 5,54,0,0,555,557,3,62,31,0,556,554,1,0,0,0,557,560,1,0,0,0,558,556, 

258 1,0,0,0,558,559,1,0,0,0,559,562,1,0,0,0,560,558,1,0,0,0,561,563, 

259 5,54,0,0,562,561,1,0,0,0,562,563,1,0,0,0,563,67,1,0,0,0,564,569, 

260 3,64,32,0,565,566,5,54,0,0,566,568,3,64,32,0,567,565,1,0,0,0,568, 

261 571,1,0,0,0,569,567,1,0,0,0,569,570,1,0,0,0,570,69,1,0,0,0,571,569, 

262 1,0,0,0,572,577,5,40,0,0,573,574,5,49,0,0,574,576,5,40,0,0,575,573, 

263 1,0,0,0,576,579,1,0,0,0,577,575,1,0,0,0,577,578,1,0,0,0,578,71,1, 

264 0,0,0,579,577,1,0,0,0,580,581,5,10,0,0,581,586,5,40,0,0,582,583, 

265 5,54,0,0,583,585,5,40,0,0,584,582,1,0,0,0,585,588,1,0,0,0,586,584, 

266 1,0,0,0,586,587,1,0,0,0,587,73,1,0,0,0,588,586,1,0,0,0,589,590,5, 

267 11,0,0,590,595,5,40,0,0,591,592,5,54,0,0,592,594,5,40,0,0,593,591, 

268 1,0,0,0,594,597,1,0,0,0,595,593,1,0,0,0,595,596,1,0,0,0,596,75,1, 

269 0,0,0,597,595,1,0,0,0,598,599,5,12,0,0,599,602,3,98,49,0,600,601, 

270 5,54,0,0,601,603,3,98,49,0,602,600,1,0,0,0,602,603,1,0,0,0,603,77, 

271 1,0,0,0,604,614,3,82,41,0,605,614,3,84,42,0,606,614,3,86,43,0,607, 

272 614,3,88,44,0,608,614,3,90,45,0,609,614,3,14,7,0,610,614,3,154,77, 

273 0,611,614,3,10,5,0,612,614,3,80,40,0,613,604,1,0,0,0,613,605,1,0, 

274 0,0,613,606,1,0,0,0,613,607,1,0,0,0,613,608,1,0,0,0,613,609,1,0, 

275 0,0,613,610,1,0,0,0,613,611,1,0,0,0,613,612,1,0,0,0,614,79,1,0,0, 

276 0,615,619,5,37,0,0,616,620,3,14,7,0,617,620,3,90,45,0,618,620,3, 

277 86,43,0,619,616,1,0,0,0,619,617,1,0,0,0,619,618,1,0,0,0,620,81,1, 

278 0,0,0,621,622,5,13,0,0,622,623,3,98,49,0,623,624,5,55,0,0,624,632, 

279 3,96,48,0,625,626,5,14,0,0,626,627,3,98,49,0,627,628,5,55,0,0,628, 

280 629,3,96,48,0,629,631,1,0,0,0,630,625,1,0,0,0,631,634,1,0,0,0,632, 

281 630,1,0,0,0,632,633,1,0,0,0,633,638,1,0,0,0,634,632,1,0,0,0,635, 

282 636,5,15,0,0,636,637,5,55,0,0,637,639,3,96,48,0,638,635,1,0,0,0, 

283 638,639,1,0,0,0,639,83,1,0,0,0,640,641,5,16,0,0,641,642,3,98,49, 

284 0,642,643,5,55,0,0,643,647,3,96,48,0,644,645,5,15,0,0,645,646,5, 

285 55,0,0,646,648,3,96,48,0,647,644,1,0,0,0,647,648,1,0,0,0,648,85, 

286 1,0,0,0,649,650,5,17,0,0,650,651,3,148,74,0,651,652,5,18,0,0,652, 

287 653,3,150,75,0,653,654,5,55,0,0,654,658,3,96,48,0,655,656,5,15,0, 

288 0,656,657,5,55,0,0,657,659,3,96,48,0,658,655,1,0,0,0,658,659,1,0, 

289 0,0,659,87,1,0,0,0,660,661,5,19,0,0,661,662,5,55,0,0,662,684,3,96, 

290 48,0,663,664,3,94,47,0,664,665,5,55,0,0,665,666,3,96,48,0,666,668, 

291 1,0,0,0,667,663,1,0,0,0,668,669,1,0,0,0,669,667,1,0,0,0,669,670, 

292 1,0,0,0,670,674,1,0,0,0,671,672,5,15,0,0,672,673,5,55,0,0,673,675, 

293 3,96,48,0,674,671,1,0,0,0,674,675,1,0,0,0,675,679,1,0,0,0,676,677, 

294 5,20,0,0,677,678,5,55,0,0,678,680,3,96,48,0,679,676,1,0,0,0,679, 

295 680,1,0,0,0,680,685,1,0,0,0,681,682,5,20,0,0,682,683,5,55,0,0,683, 

296 685,3,96,48,0,684,667,1,0,0,0,684,681,1,0,0,0,685,89,1,0,0,0,686, 

297 687,5,21,0,0,687,692,3,92,46,0,688,689,5,54,0,0,689,691,3,92,46, 

298 0,690,688,1,0,0,0,691,694,1,0,0,0,692,690,1,0,0,0,692,693,1,0,0, 

299 0,693,695,1,0,0,0,694,692,1,0,0,0,695,696,5,55,0,0,696,697,3,96, 

300 48,0,697,91,1,0,0,0,698,701,3,98,49,0,699,700,5,9,0,0,700,702,3, 

301 118,59,0,701,699,1,0,0,0,701,702,1,0,0,0,702,93,1,0,0,0,703,709, 

302 5,22,0,0,704,707,3,98,49,0,705,706,5,9,0,0,706,708,5,40,0,0,707, 

303 705,1,0,0,0,707,708,1,0,0,0,708,710,1,0,0,0,709,704,1,0,0,0,709, 

304 710,1,0,0,0,710,95,1,0,0,0,711,722,3,28,14,0,712,713,5,39,0,0,713, 

305 715,5,98,0,0,714,716,3,26,13,0,715,714,1,0,0,0,716,717,1,0,0,0,717, 

306 715,1,0,0,0,717,718,1,0,0,0,718,719,1,0,0,0,719,720,5,99,0,0,720, 

307 722,1,0,0,0,721,711,1,0,0,0,721,712,1,0,0,0,722,97,1,0,0,0,723,729, 

308 3,106,53,0,724,725,5,13,0,0,725,726,3,106,53,0,726,727,5,15,0,0, 

309 727,728,3,98,49,0,728,730,1,0,0,0,729,724,1,0,0,0,729,730,1,0,0, 

310 0,730,733,1,0,0,0,731,733,3,102,51,0,732,723,1,0,0,0,732,731,1,0, 

311 0,0,733,99,1,0,0,0,734,737,3,106,53,0,735,737,3,104,52,0,736,734, 

312 1,0,0,0,736,735,1,0,0,0,737,101,1,0,0,0,738,740,5,23,0,0,739,741, 

313 3,22,11,0,740,739,1,0,0,0,740,741,1,0,0,0,741,742,1,0,0,0,742,743, 

314 5,55,0,0,743,744,3,98,49,0,744,103,1,0,0,0,745,747,5,23,0,0,746, 

315 748,3,22,11,0,747,746,1,0,0,0,747,748,1,0,0,0,748,749,1,0,0,0,749, 

316 750,5,55,0,0,750,751,3,100,50,0,751,105,1,0,0,0,752,757,3,108,54, 

317 0,753,754,5,24,0,0,754,756,3,108,54,0,755,753,1,0,0,0,756,759,1, 

318 0,0,0,757,755,1,0,0,0,757,758,1,0,0,0,758,107,1,0,0,0,759,757,1, 

319 0,0,0,760,765,3,110,55,0,761,762,5,25,0,0,762,764,3,110,55,0,763, 

320 761,1,0,0,0,764,767,1,0,0,0,765,763,1,0,0,0,765,766,1,0,0,0,766, 

321 109,1,0,0,0,767,765,1,0,0,0,768,769,5,26,0,0,769,772,3,110,55,0, 

322 770,772,3,112,56,0,771,768,1,0,0,0,771,770,1,0,0,0,772,111,1,0,0, 

323 0,773,779,3,118,59,0,774,775,3,114,57,0,775,776,3,118,59,0,776,778, 

324 1,0,0,0,777,774,1,0,0,0,778,781,1,0,0,0,779,777,1,0,0,0,779,780, 

325 1,0,0,0,780,113,1,0,0,0,781,779,1,0,0,0,782,796,5,74,0,0,783,796, 

326 5,75,0,0,784,796,5,76,0,0,785,796,5,77,0,0,786,796,5,78,0,0,787, 

327 796,5,79,0,0,788,796,5,80,0,0,789,796,5,18,0,0,790,791,5,26,0,0, 

328 791,796,5,18,0,0,792,796,5,27,0,0,793,794,5,27,0,0,794,796,5,26, 

329 0,0,795,782,1,0,0,0,795,783,1,0,0,0,795,784,1,0,0,0,795,785,1,0, 

330 0,0,795,786,1,0,0,0,795,787,1,0,0,0,795,788,1,0,0,0,795,789,1,0, 

331 0,0,795,790,1,0,0,0,795,792,1,0,0,0,795,793,1,0,0,0,796,115,1,0, 

332 0,0,797,798,5,51,0,0,798,799,3,118,59,0,799,117,1,0,0,0,800,805, 

333 3,120,60,0,801,802,5,61,0,0,802,804,3,120,60,0,803,801,1,0,0,0,804, 

334 807,1,0,0,0,805,803,1,0,0,0,805,806,1,0,0,0,806,119,1,0,0,0,807, 

335 805,1,0,0,0,808,813,3,122,61,0,809,810,5,62,0,0,810,812,3,122,61, 

336 0,811,809,1,0,0,0,812,815,1,0,0,0,813,811,1,0,0,0,813,814,1,0,0, 

337 0,814,121,1,0,0,0,815,813,1,0,0,0,816,821,3,124,62,0,817,818,5,63, 

338 0,0,818,820,3,124,62,0,819,817,1,0,0,0,820,823,1,0,0,0,821,819,1, 

339 0,0,0,821,822,1,0,0,0,822,123,1,0,0,0,823,821,1,0,0,0,824,829,3, 

340 126,63,0,825,826,7,2,0,0,826,828,3,126,63,0,827,825,1,0,0,0,828, 

341 831,1,0,0,0,829,827,1,0,0,0,829,830,1,0,0,0,830,125,1,0,0,0,831, 

342 829,1,0,0,0,832,837,3,128,64,0,833,834,7,3,0,0,834,836,3,128,64, 

343 0,835,833,1,0,0,0,836,839,1,0,0,0,837,835,1,0,0,0,837,838,1,0,0, 

344 0,838,127,1,0,0,0,839,837,1,0,0,0,840,845,3,130,65,0,841,842,7,4, 

345 0,0,842,844,3,130,65,0,843,841,1,0,0,0,844,847,1,0,0,0,845,843,1, 

346 0,0,0,845,846,1,0,0,0,846,129,1,0,0,0,847,845,1,0,0,0,848,849,7, 

347 5,0,0,849,852,3,130,65,0,850,852,3,132,66,0,851,848,1,0,0,0,851, 

348 850,1,0,0,0,852,131,1,0,0,0,853,856,3,134,67,0,854,855,5,57,0,0, 

349 855,857,3,130,65,0,856,854,1,0,0,0,856,857,1,0,0,0,857,133,1,0,0, 

350 0,858,860,5,38,0,0,859,858,1,0,0,0,859,860,1,0,0,0,860,861,1,0,0, 

351 0,861,865,3,136,68,0,862,864,3,140,70,0,863,862,1,0,0,0,864,867, 

352 1,0,0,0,865,863,1,0,0,0,865,866,1,0,0,0,866,135,1,0,0,0,867,865, 

353 1,0,0,0,868,871,5,52,0,0,869,872,3,168,84,0,870,872,3,138,69,0,871, 

354 869,1,0,0,0,871,870,1,0,0,0,871,872,1,0,0,0,872,873,1,0,0,0,873, 

355 896,5,53,0,0,874,876,5,59,0,0,875,877,3,138,69,0,876,875,1,0,0,0, 

356 876,877,1,0,0,0,877,878,1,0,0,0,878,896,5,60,0,0,879,881,5,72,0, 

357 0,880,882,3,152,76,0,881,880,1,0,0,0,881,882,1,0,0,0,882,883,1,0, 

358 0,0,883,896,5,73,0,0,884,896,5,40,0,0,885,896,5,2,0,0,886,888,5, 

359 1,0,0,887,886,1,0,0,0,888,889,1,0,0,0,889,887,1,0,0,0,889,890,1, 

360 0,0,0,890,896,1,0,0,0,891,896,5,50,0,0,892,896,5,28,0,0,893,896, 

361 5,29,0,0,894,896,5,30,0,0,895,868,1,0,0,0,895,874,1,0,0,0,895,879, 

362 1,0,0,0,895,884,1,0,0,0,895,885,1,0,0,0,895,887,1,0,0,0,895,891, 

363 1,0,0,0,895,892,1,0,0,0,895,893,1,0,0,0,895,894,1,0,0,0,896,137, 

364 1,0,0,0,897,900,3,98,49,0,898,900,3,116,58,0,899,897,1,0,0,0,899, 

365 898,1,0,0,0,900,915,1,0,0,0,901,916,3,162,81,0,902,905,5,54,0,0, 

366 903,906,3,98,49,0,904,906,3,116,58,0,905,903,1,0,0,0,905,904,1,0, 

367 0,0,906,908,1,0,0,0,907,902,1,0,0,0,908,911,1,0,0,0,909,907,1,0, 

368 0,0,909,910,1,0,0,0,910,913,1,0,0,0,911,909,1,0,0,0,912,914,5,54, 

369 0,0,913,912,1,0,0,0,913,914,1,0,0,0,914,916,1,0,0,0,915,901,1,0, 

370 0,0,915,909,1,0,0,0,916,139,1,0,0,0,917,919,5,52,0,0,918,920,3,156, 

371 78,0,919,918,1,0,0,0,919,920,1,0,0,0,920,921,1,0,0,0,921,929,5,53, 

372 0,0,922,923,5,59,0,0,923,924,3,142,71,0,924,925,5,60,0,0,925,929, 

373 1,0,0,0,926,927,5,49,0,0,927,929,5,40,0,0,928,917,1,0,0,0,928,922, 

374 1,0,0,0,928,926,1,0,0,0,929,141,1,0,0,0,930,935,3,144,72,0,931,932, 

375 5,54,0,0,932,934,3,144,72,0,933,931,1,0,0,0,934,937,1,0,0,0,935, 

376 933,1,0,0,0,935,936,1,0,0,0,936,939,1,0,0,0,937,935,1,0,0,0,938, 

377 940,5,54,0,0,939,938,1,0,0,0,939,940,1,0,0,0,940,143,1,0,0,0,941, 

378 953,3,98,49,0,942,944,3,98,49,0,943,942,1,0,0,0,943,944,1,0,0,0, 

379 944,945,1,0,0,0,945,947,5,55,0,0,946,948,3,98,49,0,947,946,1,0,0, 

380 0,947,948,1,0,0,0,948,950,1,0,0,0,949,951,3,146,73,0,950,949,1,0, 

381 0,0,950,951,1,0,0,0,951,953,1,0,0,0,952,941,1,0,0,0,952,943,1,0, 

382 0,0,953,145,1,0,0,0,954,956,5,55,0,0,955,957,3,98,49,0,956,955,1, 

383 0,0,0,956,957,1,0,0,0,957,147,1,0,0,0,958,961,3,118,59,0,959,961, 

384 3,116,58,0,960,958,1,0,0,0,960,959,1,0,0,0,961,969,1,0,0,0,962,965, 

385 5,54,0,0,963,966,3,118,59,0,964,966,3,116,58,0,965,963,1,0,0,0,965, 

386 964,1,0,0,0,966,968,1,0,0,0,967,962,1,0,0,0,968,971,1,0,0,0,969, 

387 967,1,0,0,0,969,970,1,0,0,0,970,973,1,0,0,0,971,969,1,0,0,0,972, 

388 974,5,54,0,0,973,972,1,0,0,0,973,974,1,0,0,0,974,149,1,0,0,0,975, 

389 980,3,98,49,0,976,977,5,54,0,0,977,979,3,98,49,0,978,976,1,0,0,0, 

390 979,982,1,0,0,0,980,978,1,0,0,0,980,981,1,0,0,0,981,984,1,0,0,0, 

391 982,980,1,0,0,0,983,985,5,54,0,0,984,983,1,0,0,0,984,985,1,0,0,0, 

392 985,151,1,0,0,0,986,987,3,98,49,0,987,988,5,55,0,0,988,989,3,98, 

393 49,0,989,993,1,0,0,0,990,991,5,57,0,0,991,993,3,118,59,0,992,986, 

394 1,0,0,0,992,990,1,0,0,0,993,1012,1,0,0,0,994,1013,3,162,81,0,995, 

395 1002,5,54,0,0,996,997,3,98,49,0,997,998,5,55,0,0,998,999,3,98,49, 

396 0,999,1003,1,0,0,0,1000,1001,5,57,0,0,1001,1003,3,118,59,0,1002, 

397 996,1,0,0,0,1002,1000,1,0,0,0,1003,1005,1,0,0,0,1004,995,1,0,0,0, 

398 1005,1008,1,0,0,0,1006,1004,1,0,0,0,1006,1007,1,0,0,0,1007,1010, 

399 1,0,0,0,1008,1006,1,0,0,0,1009,1011,5,54,0,0,1010,1009,1,0,0,0,1010, 

400 1011,1,0,0,0,1011,1013,1,0,0,0,1012,994,1,0,0,0,1012,1006,1,0,0, 

401 0,1013,1035,1,0,0,0,1014,1017,3,98,49,0,1015,1017,3,116,58,0,1016, 

402 1014,1,0,0,0,1016,1015,1,0,0,0,1017,1032,1,0,0,0,1018,1033,3,162, 

403 81,0,1019,1022,5,54,0,0,1020,1023,3,98,49,0,1021,1023,3,116,58,0, 

404 1022,1020,1,0,0,0,1022,1021,1,0,0,0,1023,1025,1,0,0,0,1024,1019, 

405 1,0,0,0,1025,1028,1,0,0,0,1026,1024,1,0,0,0,1026,1027,1,0,0,0,1027, 

406 1030,1,0,0,0,1028,1026,1,0,0,0,1029,1031,5,54,0,0,1030,1029,1,0, 

407 0,0,1030,1031,1,0,0,0,1031,1033,1,0,0,0,1032,1018,1,0,0,0,1032,1026, 

408 1,0,0,0,1033,1035,1,0,0,0,1034,992,1,0,0,0,1034,1016,1,0,0,0,1035, 

409 153,1,0,0,0,1036,1037,5,31,0,0,1037,1043,5,40,0,0,1038,1040,5,52, 

410 0,0,1039,1041,3,156,78,0,1040,1039,1,0,0,0,1040,1041,1,0,0,0,1041, 

411 1042,1,0,0,0,1042,1044,5,53,0,0,1043,1038,1,0,0,0,1043,1044,1,0, 

412 0,0,1044,1045,1,0,0,0,1045,1046,5,55,0,0,1046,1047,3,96,48,0,1047, 

413 155,1,0,0,0,1048,1053,3,158,79,0,1049,1050,5,54,0,0,1050,1052,3, 

414 158,79,0,1051,1049,1,0,0,0,1052,1055,1,0,0,0,1053,1051,1,0,0,0,1053, 

415 1054,1,0,0,0,1054,1057,1,0,0,0,1055,1053,1,0,0,0,1056,1058,5,54, 

416 0,0,1057,1056,1,0,0,0,1057,1058,1,0,0,0,1058,157,1,0,0,0,1059,1061, 

417 3,98,49,0,1060,1062,3,162,81,0,1061,1060,1,0,0,0,1061,1062,1,0,0, 

418 0,1062,1072,1,0,0,0,1063,1064,3,98,49,0,1064,1065,5,58,0,0,1065, 

419 1066,3,98,49,0,1066,1072,1,0,0,0,1067,1068,5,57,0,0,1068,1072,3, 

420 98,49,0,1069,1070,5,51,0,0,1070,1072,3,98,49,0,1071,1059,1,0,0,0, 

421 1071,1063,1,0,0,0,1071,1067,1,0,0,0,1071,1069,1,0,0,0,1072,159,1, 

422 0,0,0,1073,1076,3,162,81,0,1074,1076,3,164,82,0,1075,1073,1,0,0, 

423 0,1075,1074,1,0,0,0,1076,161,1,0,0,0,1077,1079,5,37,0,0,1078,1077, 

424 1,0,0,0,1078,1079,1,0,0,0,1079,1080,1,0,0,0,1080,1081,5,17,0,0,1081, 

425 1082,3,148,74,0,1082,1083,5,18,0,0,1083,1085,3,106,53,0,1084,1086, 

426 3,160,80,0,1085,1084,1,0,0,0,1085,1086,1,0,0,0,1086,163,1,0,0,0, 

427 1087,1088,5,13,0,0,1088,1090,3,100,50,0,1089,1091,3,160,80,0,1090, 

428 1089,1,0,0,0,1090,1091,1,0,0,0,1091,165,1,0,0,0,1092,1093,5,40,0, 

429 0,1093,167,1,0,0,0,1094,1096,5,32,0,0,1095,1097,3,170,85,0,1096, 

430 1095,1,0,0,0,1096,1097,1,0,0,0,1097,169,1,0,0,0,1098,1099,5,7,0, 

431 0,1099,1102,3,98,49,0,1100,1102,3,150,75,0,1101,1098,1,0,0,0,1101, 

432 1100,1,0,0,0,1102,171,1,0,0,0,166,177,181,183,192,201,204,211,217, 

433 227,234,241,247,251,257,263,267,274,276,278,283,285,287,291,297, 

434 301,308,310,312,317,319,324,329,335,339,345,351,355,362,364,366, 

435 371,373,375,379,385,389,396,398,400,405,407,413,420,424,436,443, 

436 448,452,455,461,465,470,474,478,492,500,508,510,514,523,530,532, 

437 541,546,551,558,562,569,577,586,595,602,613,619,632,638,647,658, 

438 669,674,679,684,692,701,707,709,717,721,729,732,736,740,747,757, 

439 765,771,779,795,805,813,821,829,837,845,851,856,859,865,871,876, 

440 881,889,895,899,905,909,913,915,919,928,935,939,943,947,950,952, 

441 956,960,965,969,973,980,984,992,1002,1006,1010,1012,1016,1022,1026, 

442 1030,1032,1034,1040,1043,1053,1057,1061,1071,1075,1078,1085,1090, 

443 1096,1101 

444 ] 

445 

446class Python3Parser ( Parser ): 

447 

448 grammarFileName = "Python3.g4" 

449 

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

451 

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

453 

454 sharedContextCache = PredictionContextCache() 

455 

456 literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

457 "'def'", "'return'", "'raise'", "'from'", "'import'", 

458 "'as'", "'global'", "'nonlocal'", "'assert'", "'if'", 

459 "'elif'", "'else'", "'while'", "'for'", "'in'", "'try'", 

460 "'finally'", "'with'", "'except'", "'lambda'", "'or'", 

461 "'and'", "'not'", "'is'", "'None'", "'True'", "'False'", 

462 "'class'", "'yield'", "'del'", "'pass'", "'continue'", 

463 "'break'", "'async'", "'await'", "<INVALID>", "<INVALID>", 

464 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

465 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 

466 "'.'", "'...'", "'*'", "'('", "')'", "','", "':'", 

467 "';'", "'**'", "'='", "'['", "']'", "'|'", "'^'", "'&'", 

468 "'<<'", "'>>'", "'+'", "'-'", "'/'", "'%'", "'//'", 

469 "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", "'>='", 

470 "'<='", "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='", 

471 "'*='", "'@='", "'/='", "'%='", "'&='", "'|='", "'^='", 

472 "'<<='", "'>>='", "'**='", "'//='" ] 

473 

474 symbolicNames = [ "<INVALID>", "STRING", "NUMBER", "INTEGER", "DEF", 

475 "RETURN", "RAISE", "FROM", "IMPORT", "AS", "GLOBAL", 

476 "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE", "WHILE", 

477 "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA", 

478 "OR", "AND", "NOT", "IS", "NONE", "TRUE", "FALSE", 

479 "CLASS", "YIELD", "DEL", "PASS", "CONTINUE", "BREAK", 

480 "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL", 

481 "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", 

482 "HEX_INTEGER", "BIN_INTEGER", "FLOAT_NUMBER", "IMAG_NUMBER", 

483 "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", "CLOSE_PAREN", 

484 "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", 

485 "OPEN_BRACK", "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", 

486 "LEFT_SHIFT", "RIGHT_SHIFT", "ADD", "MINUS", "DIV", 

487 "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", 

488 "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", 

489 "NOT_EQ_1", "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", 

490 "SUB_ASSIGN", "MULT_ASSIGN", "AT_ASSIGN", "DIV_ASSIGN", 

491 "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", 

492 "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", 

493 "IDIV_ASSIGN", "SKIP_", "UNKNOWN_CHAR", "INDENT", 

494 "DEDENT" ] 

495 

496 RULE_single_input = 0 

497 RULE_file_input = 1 

498 RULE_eval_input = 2 

499 RULE_decorator = 3 

500 RULE_decorators = 4 

501 RULE_decorated = 5 

502 RULE_async_funcdef = 6 

503 RULE_funcdef = 7 

504 RULE_parameters = 8 

505 RULE_typedargslist = 9 

506 RULE_tfpdef = 10 

507 RULE_varargslist = 11 

508 RULE_vfpdef = 12 

509 RULE_stmt = 13 

510 RULE_simple_stmt = 14 

511 RULE_small_stmt = 15 

512 RULE_expr_stmt = 16 

513 RULE_annassign = 17 

514 RULE_testlist_star_expr = 18 

515 RULE_augassign = 19 

516 RULE_del_stmt = 20 

517 RULE_pass_stmt = 21 

518 RULE_flow_stmt = 22 

519 RULE_break_stmt = 23 

520 RULE_continue_stmt = 24 

521 RULE_return_stmt = 25 

522 RULE_yield_stmt = 26 

523 RULE_raise_stmt = 27 

524 RULE_import_stmt = 28 

525 RULE_import_name = 29 

526 RULE_import_from = 30 

527 RULE_import_as_name = 31 

528 RULE_dotted_as_name = 32 

529 RULE_import_as_names = 33 

530 RULE_dotted_as_names = 34 

531 RULE_dotted_name = 35 

532 RULE_global_stmt = 36 

533 RULE_nonlocal_stmt = 37 

534 RULE_assert_stmt = 38 

535 RULE_compound_stmt = 39 

536 RULE_async_stmt = 40 

537 RULE_if_stmt = 41 

538 RULE_while_stmt = 42 

539 RULE_for_stmt = 43 

540 RULE_try_stmt = 44 

541 RULE_with_stmt = 45 

542 RULE_with_item = 46 

543 RULE_except_clause = 47 

544 RULE_suite = 48 

545 RULE_test = 49 

546 RULE_test_nocond = 50 

547 RULE_lambdef = 51 

548 RULE_lambdef_nocond = 52 

549 RULE_or_test = 53 

550 RULE_and_test = 54 

551 RULE_not_test = 55 

552 RULE_comparison = 56 

553 RULE_comp_op = 57 

554 RULE_star_expr = 58 

555 RULE_expr = 59 

556 RULE_xor_expr = 60 

557 RULE_and_expr = 61 

558 RULE_shift_expr = 62 

559 RULE_arith_expr = 63 

560 RULE_term = 64 

561 RULE_factor = 65 

562 RULE_power = 66 

563 RULE_atom_expr = 67 

564 RULE_atom = 68 

565 RULE_testlist_comp = 69 

566 RULE_trailer = 70 

567 RULE_subscriptlist = 71 

568 RULE_subscript = 72 

569 RULE_sliceop = 73 

570 RULE_exprlist = 74 

571 RULE_testlist = 75 

572 RULE_dictorsetmaker = 76 

573 RULE_classdef = 77 

574 RULE_arglist = 78 

575 RULE_argument = 79 

576 RULE_comp_iter = 80 

577 RULE_comp_for = 81 

578 RULE_comp_if = 82 

579 RULE_encoding_decl = 83 

580 RULE_yield_expr = 84 

581 RULE_yield_arg = 85 

582 

583 ruleNames = [ "single_input", "file_input", "eval_input", "decorator", 

584 "decorators", "decorated", "async_funcdef", "funcdef", 

585 "parameters", "typedargslist", "tfpdef", "varargslist", 

586 "vfpdef", "stmt", "simple_stmt", "small_stmt", "expr_stmt", 

587 "annassign", "testlist_star_expr", "augassign", "del_stmt", 

588 "pass_stmt", "flow_stmt", "break_stmt", "continue_stmt", 

589 "return_stmt", "yield_stmt", "raise_stmt", "import_stmt", 

590 "import_name", "import_from", "import_as_name", "dotted_as_name", 

591 "import_as_names", "dotted_as_names", "dotted_name", 

592 "global_stmt", "nonlocal_stmt", "assert_stmt", "compound_stmt", 

593 "async_stmt", "if_stmt", "while_stmt", "for_stmt", "try_stmt", 

594 "with_stmt", "with_item", "except_clause", "suite", "test", 

595 "test_nocond", "lambdef", "lambdef_nocond", "or_test", 

596 "and_test", "not_test", "comparison", "comp_op", "star_expr", 

597 "expr", "xor_expr", "and_expr", "shift_expr", "arith_expr", 

598 "term", "factor", "power", "atom_expr", "atom", "testlist_comp", 

599 "trailer", "subscriptlist", "subscript", "sliceop", "exprlist", 

600 "testlist", "dictorsetmaker", "classdef", "arglist", 

601 "argument", "comp_iter", "comp_for", "comp_if", "encoding_decl", 

602 "yield_expr", "yield_arg" ] 

603 

604 EOF = Token.EOF 

605 STRING=1 

606 NUMBER=2 

607 INTEGER=3 

608 DEF=4 

609 RETURN=5 

610 RAISE=6 

611 FROM=7 

612 IMPORT=8 

613 AS=9 

614 GLOBAL=10 

615 NONLOCAL=11 

616 ASSERT=12 

617 IF=13 

618 ELIF=14 

619 ELSE=15 

620 WHILE=16 

621 FOR=17 

622 IN=18 

623 TRY=19 

624 FINALLY=20 

625 WITH=21 

626 EXCEPT=22 

627 LAMBDA=23 

628 OR=24 

629 AND=25 

630 NOT=26 

631 IS=27 

632 NONE=28 

633 TRUE=29 

634 FALSE=30 

635 CLASS=31 

636 YIELD=32 

637 DEL=33 

638 PASS=34 

639 CONTINUE=35 

640 BREAK=36 

641 ASYNC=37 

642 AWAIT=38 

643 NEWLINE=39 

644 NAME=40 

645 STRING_LITERAL=41 

646 BYTES_LITERAL=42 

647 DECIMAL_INTEGER=43 

648 OCT_INTEGER=44 

649 HEX_INTEGER=45 

650 BIN_INTEGER=46 

651 FLOAT_NUMBER=47 

652 IMAG_NUMBER=48 

653 DOT=49 

654 ELLIPSIS=50 

655 STAR=51 

656 OPEN_PAREN=52 

657 CLOSE_PAREN=53 

658 COMMA=54 

659 COLON=55 

660 SEMI_COLON=56 

661 POWER=57 

662 ASSIGN=58 

663 OPEN_BRACK=59 

664 CLOSE_BRACK=60 

665 OR_OP=61 

666 XOR=62 

667 AND_OP=63 

668 LEFT_SHIFT=64 

669 RIGHT_SHIFT=65 

670 ADD=66 

671 MINUS=67 

672 DIV=68 

673 MOD=69 

674 IDIV=70 

675 NOT_OP=71 

676 OPEN_BRACE=72 

677 CLOSE_BRACE=73 

678 LESS_THAN=74 

679 GREATER_THAN=75 

680 EQUALS=76 

681 GT_EQ=77 

682 LT_EQ=78 

683 NOT_EQ_1=79 

684 NOT_EQ_2=80 

685 AT=81 

686 ARROW=82 

687 ADD_ASSIGN=83 

688 SUB_ASSIGN=84 

689 MULT_ASSIGN=85 

690 AT_ASSIGN=86 

691 DIV_ASSIGN=87 

692 MOD_ASSIGN=88 

693 AND_ASSIGN=89 

694 OR_ASSIGN=90 

695 XOR_ASSIGN=91 

696 LEFT_SHIFT_ASSIGN=92 

697 RIGHT_SHIFT_ASSIGN=93 

698 POWER_ASSIGN=94 

699 IDIV_ASSIGN=95 

700 SKIP_=96 

701 UNKNOWN_CHAR=97 

702 INDENT=98 

703 DEDENT=99 

704 

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

706 super().__init__(input, output) 

707 self.checkVersion("4.10.1") 

708 self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) 

709 self._predicates = None 

710 

711 

712 

713 

714 class Single_inputContext(ParserRuleContext): 

715 __slots__ = 'parser' 

716 

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

718 super().__init__(parent, invokingState) 

719 self.parser = parser 

720 

721 def NEWLINE(self): 

722 return self.getToken(Python3Parser.NEWLINE, 0) 

723 

724 def simple_stmt(self): 

725 return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,0) 

726 

727 

728 def compound_stmt(self): 

729 return self.getTypedRuleContext(Python3Parser.Compound_stmtContext,0) 

730 

731 

732 def getRuleIndex(self): 

733 return Python3Parser.RULE_single_input 

734 

735 def enterRule(self, listener:ParseTreeListener): 

736 if hasattr( listener, "enterSingle_input" ): 

737 listener.enterSingle_input(self) 

738 

739 def exitRule(self, listener:ParseTreeListener): 

740 if hasattr( listener, "exitSingle_input" ): 

741 listener.exitSingle_input(self) 

742 

743 

744 

745 

746 def single_input(self): 

747 

748 localctx = Python3Parser.Single_inputContext(self, self._ctx, self.state) 

749 self.enterRule(localctx, 0, self.RULE_single_input) 

750 try: 

751 self.state = 177 

752 self._errHandler.sync(self) 

753 token = self._input.LA(1) 

754 if token in [Python3Parser.NEWLINE]: 

755 self.enterOuterAlt(localctx, 1) 

756 self.state = 172 

757 self.match(Python3Parser.NEWLINE) 

758 pass 

759 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.FROM, Python3Parser.IMPORT, Python3Parser.GLOBAL, Python3Parser.NONLOCAL, Python3Parser.ASSERT, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.YIELD, Python3Parser.DEL, Python3Parser.PASS, Python3Parser.CONTINUE, Python3Parser.BREAK, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

760 self.enterOuterAlt(localctx, 2) 

761 self.state = 173 

762 self.simple_stmt() 

763 pass 

764 elif token in [Python3Parser.DEF, Python3Parser.IF, Python3Parser.WHILE, Python3Parser.FOR, Python3Parser.TRY, Python3Parser.WITH, Python3Parser.CLASS, Python3Parser.ASYNC, Python3Parser.AT]: 

765 self.enterOuterAlt(localctx, 3) 

766 self.state = 174 

767 self.compound_stmt() 

768 self.state = 175 

769 self.match(Python3Parser.NEWLINE) 

770 pass 

771 else: 

772 raise NoViableAltException(self) 

773 

774 except RecognitionException as re: 

775 localctx.exception = re 

776 self._errHandler.reportError(self, re) 

777 self._errHandler.recover(self, re) 

778 finally: 

779 self.exitRule() 

780 return localctx 

781 

782 

783 class File_inputContext(ParserRuleContext): 

784 __slots__ = 'parser' 

785 

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

787 super().__init__(parent, invokingState) 

788 self.parser = parser 

789 

790 def EOF(self): 

791 return self.getToken(Python3Parser.EOF, 0) 

792 

793 def NEWLINE(self, i:int=None): 

794 if i is None: 

795 return self.getTokens(Python3Parser.NEWLINE) 

796 else: 

797 return self.getToken(Python3Parser.NEWLINE, i) 

798 

799 def stmt(self, i:int=None): 

800 if i is None: 

801 return self.getTypedRuleContexts(Python3Parser.StmtContext) 

802 else: 

803 return self.getTypedRuleContext(Python3Parser.StmtContext,i) 

804 

805 

806 def getRuleIndex(self): 

807 return Python3Parser.RULE_file_input 

808 

809 def enterRule(self, listener:ParseTreeListener): 

810 if hasattr( listener, "enterFile_input" ): 

811 listener.enterFile_input(self) 

812 

813 def exitRule(self, listener:ParseTreeListener): 

814 if hasattr( listener, "exitFile_input" ): 

815 listener.exitFile_input(self) 

816 

817 

818 

819 

820 def file_input(self): 

821 

822 localctx = Python3Parser.File_inputContext(self, self._ctx, self.state) 

823 self.enterRule(localctx, 2, self.RULE_file_input) 

824 self._la = 0 # Token type 

825 try: 

826 self.enterOuterAlt(localctx, 1) 

827 self.state = 183 

828 self._errHandler.sync(self) 

829 _la = self._input.LA(1) 

830 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.DEF) | (1 << Python3Parser.RETURN) | (1 << Python3Parser.RAISE) | (1 << Python3Parser.FROM) | (1 << Python3Parser.IMPORT) | (1 << Python3Parser.GLOBAL) | (1 << Python3Parser.NONLOCAL) | (1 << Python3Parser.ASSERT) | (1 << Python3Parser.IF) | (1 << Python3Parser.WHILE) | (1 << Python3Parser.FOR) | (1 << Python3Parser.TRY) | (1 << Python3Parser.WITH) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.CLASS) | (1 << Python3Parser.YIELD) | (1 << Python3Parser.DEL) | (1 << Python3Parser.PASS) | (1 << Python3Parser.CONTINUE) | (1 << Python3Parser.BREAK) | (1 << Python3Parser.ASYNC) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NEWLINE) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)) | (1 << (Python3Parser.AT - 66)))) != 0): 

831 self.state = 181 

832 self._errHandler.sync(self) 

833 token = self._input.LA(1) 

834 if token in [Python3Parser.NEWLINE]: 

835 self.state = 179 

836 self.match(Python3Parser.NEWLINE) 

837 pass 

838 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.DEF, Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.FROM, Python3Parser.IMPORT, Python3Parser.GLOBAL, Python3Parser.NONLOCAL, Python3Parser.ASSERT, Python3Parser.IF, Python3Parser.WHILE, Python3Parser.FOR, Python3Parser.TRY, Python3Parser.WITH, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.CLASS, Python3Parser.YIELD, Python3Parser.DEL, Python3Parser.PASS, Python3Parser.CONTINUE, Python3Parser.BREAK, Python3Parser.ASYNC, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE, Python3Parser.AT]: 

839 self.state = 180 

840 self.stmt() 

841 pass 

842 else: 

843 raise NoViableAltException(self) 

844 

845 self.state = 185 

846 self._errHandler.sync(self) 

847 _la = self._input.LA(1) 

848 

849 self.state = 186 

850 self.match(Python3Parser.EOF) 

851 except RecognitionException as re: 

852 localctx.exception = re 

853 self._errHandler.reportError(self, re) 

854 self._errHandler.recover(self, re) 

855 finally: 

856 self.exitRule() 

857 return localctx 

858 

859 

860 class Eval_inputContext(ParserRuleContext): 

861 __slots__ = 'parser' 

862 

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

864 super().__init__(parent, invokingState) 

865 self.parser = parser 

866 

867 def testlist(self): 

868 return self.getTypedRuleContext(Python3Parser.TestlistContext,0) 

869 

870 

871 def EOF(self): 

872 return self.getToken(Python3Parser.EOF, 0) 

873 

874 def NEWLINE(self, i:int=None): 

875 if i is None: 

876 return self.getTokens(Python3Parser.NEWLINE) 

877 else: 

878 return self.getToken(Python3Parser.NEWLINE, i) 

879 

880 def getRuleIndex(self): 

881 return Python3Parser.RULE_eval_input 

882 

883 def enterRule(self, listener:ParseTreeListener): 

884 if hasattr( listener, "enterEval_input" ): 

885 listener.enterEval_input(self) 

886 

887 def exitRule(self, listener:ParseTreeListener): 

888 if hasattr( listener, "exitEval_input" ): 

889 listener.exitEval_input(self) 

890 

891 

892 

893 

894 def eval_input(self): 

895 

896 localctx = Python3Parser.Eval_inputContext(self, self._ctx, self.state) 

897 self.enterRule(localctx, 4, self.RULE_eval_input) 

898 self._la = 0 # Token type 

899 try: 

900 self.enterOuterAlt(localctx, 1) 

901 self.state = 188 

902 self.testlist() 

903 self.state = 192 

904 self._errHandler.sync(self) 

905 _la = self._input.LA(1) 

906 while _la==Python3Parser.NEWLINE: 

907 self.state = 189 

908 self.match(Python3Parser.NEWLINE) 

909 self.state = 194 

910 self._errHandler.sync(self) 

911 _la = self._input.LA(1) 

912 

913 self.state = 195 

914 self.match(Python3Parser.EOF) 

915 except RecognitionException as re: 

916 localctx.exception = re 

917 self._errHandler.reportError(self, re) 

918 self._errHandler.recover(self, re) 

919 finally: 

920 self.exitRule() 

921 return localctx 

922 

923 

924 class DecoratorContext(ParserRuleContext): 

925 __slots__ = 'parser' 

926 

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

928 super().__init__(parent, invokingState) 

929 self.parser = parser 

930 

931 def AT(self): 

932 return self.getToken(Python3Parser.AT, 0) 

933 

934 def dotted_name(self): 

935 return self.getTypedRuleContext(Python3Parser.Dotted_nameContext,0) 

936 

937 

938 def NEWLINE(self): 

939 return self.getToken(Python3Parser.NEWLINE, 0) 

940 

941 def OPEN_PAREN(self): 

942 return self.getToken(Python3Parser.OPEN_PAREN, 0) 

943 

944 def CLOSE_PAREN(self): 

945 return self.getToken(Python3Parser.CLOSE_PAREN, 0) 

946 

947 def arglist(self): 

948 return self.getTypedRuleContext(Python3Parser.ArglistContext,0) 

949 

950 

951 def getRuleIndex(self): 

952 return Python3Parser.RULE_decorator 

953 

954 def enterRule(self, listener:ParseTreeListener): 

955 if hasattr( listener, "enterDecorator" ): 

956 listener.enterDecorator(self) 

957 

958 def exitRule(self, listener:ParseTreeListener): 

959 if hasattr( listener, "exitDecorator" ): 

960 listener.exitDecorator(self) 

961 

962 

963 

964 

965 def decorator(self): 

966 

967 localctx = Python3Parser.DecoratorContext(self, self._ctx, self.state) 

968 self.enterRule(localctx, 6, self.RULE_decorator) 

969 self._la = 0 # Token type 

970 try: 

971 self.enterOuterAlt(localctx, 1) 

972 self.state = 197 

973 self.match(Python3Parser.AT) 

974 self.state = 198 

975 self.dotted_name() 

976 self.state = 204 

977 self._errHandler.sync(self) 

978 _la = self._input.LA(1) 

979 if _la==Python3Parser.OPEN_PAREN: 

980 self.state = 199 

981 self.match(Python3Parser.OPEN_PAREN) 

982 self.state = 201 

983 self._errHandler.sync(self) 

984 _la = self._input.LA(1) 

985 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.POWER) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

986 self.state = 200 

987 self.arglist() 

988 

989 

990 self.state = 203 

991 self.match(Python3Parser.CLOSE_PAREN) 

992 

993 

994 self.state = 206 

995 self.match(Python3Parser.NEWLINE) 

996 except RecognitionException as re: 

997 localctx.exception = re 

998 self._errHandler.reportError(self, re) 

999 self._errHandler.recover(self, re) 

1000 finally: 

1001 self.exitRule() 

1002 return localctx 

1003 

1004 

1005 class DecoratorsContext(ParserRuleContext): 

1006 __slots__ = 'parser' 

1007 

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

1009 super().__init__(parent, invokingState) 

1010 self.parser = parser 

1011 

1012 def decorator(self, i:int=None): 

1013 if i is None: 

1014 return self.getTypedRuleContexts(Python3Parser.DecoratorContext) 

1015 else: 

1016 return self.getTypedRuleContext(Python3Parser.DecoratorContext,i) 

1017 

1018 

1019 def getRuleIndex(self): 

1020 return Python3Parser.RULE_decorators 

1021 

1022 def enterRule(self, listener:ParseTreeListener): 

1023 if hasattr( listener, "enterDecorators" ): 

1024 listener.enterDecorators(self) 

1025 

1026 def exitRule(self, listener:ParseTreeListener): 

1027 if hasattr( listener, "exitDecorators" ): 

1028 listener.exitDecorators(self) 

1029 

1030 

1031 

1032 

1033 def decorators(self): 

1034 

1035 localctx = Python3Parser.DecoratorsContext(self, self._ctx, self.state) 

1036 self.enterRule(localctx, 8, self.RULE_decorators) 

1037 self._la = 0 # Token type 

1038 try: 

1039 self.enterOuterAlt(localctx, 1) 

1040 self.state = 209 

1041 self._errHandler.sync(self) 

1042 _la = self._input.LA(1) 

1043 while True: 

1044 self.state = 208 

1045 self.decorator() 

1046 self.state = 211 

1047 self._errHandler.sync(self) 

1048 _la = self._input.LA(1) 

1049 if not (_la==Python3Parser.AT): 

1050 break 

1051 

1052 except RecognitionException as re: 

1053 localctx.exception = re 

1054 self._errHandler.reportError(self, re) 

1055 self._errHandler.recover(self, re) 

1056 finally: 

1057 self.exitRule() 

1058 return localctx 

1059 

1060 

1061 class DecoratedContext(ParserRuleContext): 

1062 __slots__ = 'parser' 

1063 

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

1065 super().__init__(parent, invokingState) 

1066 self.parser = parser 

1067 

1068 def decorators(self): 

1069 return self.getTypedRuleContext(Python3Parser.DecoratorsContext,0) 

1070 

1071 

1072 def classdef(self): 

1073 return self.getTypedRuleContext(Python3Parser.ClassdefContext,0) 

1074 

1075 

1076 def funcdef(self): 

1077 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0) 

1078 

1079 

1080 def async_funcdef(self): 

1081 return self.getTypedRuleContext(Python3Parser.Async_funcdefContext,0) 

1082 

1083 

1084 def getRuleIndex(self): 

1085 return Python3Parser.RULE_decorated 

1086 

1087 def enterRule(self, listener:ParseTreeListener): 

1088 if hasattr( listener, "enterDecorated" ): 

1089 listener.enterDecorated(self) 

1090 

1091 def exitRule(self, listener:ParseTreeListener): 

1092 if hasattr( listener, "exitDecorated" ): 

1093 listener.exitDecorated(self) 

1094 

1095 

1096 

1097 

1098 def decorated(self): 

1099 

1100 localctx = Python3Parser.DecoratedContext(self, self._ctx, self.state) 

1101 self.enterRule(localctx, 10, self.RULE_decorated) 

1102 try: 

1103 self.enterOuterAlt(localctx, 1) 

1104 self.state = 213 

1105 self.decorators() 

1106 self.state = 217 

1107 self._errHandler.sync(self) 

1108 token = self._input.LA(1) 

1109 if token in [Python3Parser.CLASS]: 

1110 self.state = 214 

1111 self.classdef() 

1112 pass 

1113 elif token in [Python3Parser.DEF]: 

1114 self.state = 215 

1115 self.funcdef() 

1116 pass 

1117 elif token in [Python3Parser.ASYNC]: 

1118 self.state = 216 

1119 self.async_funcdef() 

1120 pass 

1121 else: 

1122 raise NoViableAltException(self) 

1123 

1124 except RecognitionException as re: 

1125 localctx.exception = re 

1126 self._errHandler.reportError(self, re) 

1127 self._errHandler.recover(self, re) 

1128 finally: 

1129 self.exitRule() 

1130 return localctx 

1131 

1132 

1133 class Async_funcdefContext(ParserRuleContext): 

1134 __slots__ = 'parser' 

1135 

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

1137 super().__init__(parent, invokingState) 

1138 self.parser = parser 

1139 

1140 def ASYNC(self): 

1141 return self.getToken(Python3Parser.ASYNC, 0) 

1142 

1143 def funcdef(self): 

1144 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0) 

1145 

1146 

1147 def getRuleIndex(self): 

1148 return Python3Parser.RULE_async_funcdef 

1149 

1150 def enterRule(self, listener:ParseTreeListener): 

1151 if hasattr( listener, "enterAsync_funcdef" ): 

1152 listener.enterAsync_funcdef(self) 

1153 

1154 def exitRule(self, listener:ParseTreeListener): 

1155 if hasattr( listener, "exitAsync_funcdef" ): 

1156 listener.exitAsync_funcdef(self) 

1157 

1158 

1159 

1160 

1161 def async_funcdef(self): 

1162 

1163 localctx = Python3Parser.Async_funcdefContext(self, self._ctx, self.state) 

1164 self.enterRule(localctx, 12, self.RULE_async_funcdef) 

1165 try: 

1166 self.enterOuterAlt(localctx, 1) 

1167 self.state = 219 

1168 self.match(Python3Parser.ASYNC) 

1169 self.state = 220 

1170 self.funcdef() 

1171 except RecognitionException as re: 

1172 localctx.exception = re 

1173 self._errHandler.reportError(self, re) 

1174 self._errHandler.recover(self, re) 

1175 finally: 

1176 self.exitRule() 

1177 return localctx 

1178 

1179 

1180 class FuncdefContext(ParserRuleContext): 

1181 __slots__ = 'parser' 

1182 

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

1184 super().__init__(parent, invokingState) 

1185 self.parser = parser 

1186 

1187 def DEF(self): 

1188 return self.getToken(Python3Parser.DEF, 0) 

1189 

1190 def NAME(self): 

1191 return self.getToken(Python3Parser.NAME, 0) 

1192 

1193 def parameters(self): 

1194 return self.getTypedRuleContext(Python3Parser.ParametersContext,0) 

1195 

1196 

1197 def COLON(self): 

1198 return self.getToken(Python3Parser.COLON, 0) 

1199 

1200 def suite(self): 

1201 return self.getTypedRuleContext(Python3Parser.SuiteContext,0) 

1202 

1203 

1204 def ARROW(self): 

1205 return self.getToken(Python3Parser.ARROW, 0) 

1206 

1207 def test(self): 

1208 return self.getTypedRuleContext(Python3Parser.TestContext,0) 

1209 

1210 

1211 def getRuleIndex(self): 

1212 return Python3Parser.RULE_funcdef 

1213 

1214 def enterRule(self, listener:ParseTreeListener): 

1215 if hasattr( listener, "enterFuncdef" ): 

1216 listener.enterFuncdef(self) 

1217 

1218 def exitRule(self, listener:ParseTreeListener): 

1219 if hasattr( listener, "exitFuncdef" ): 

1220 listener.exitFuncdef(self) 

1221 

1222 

1223 

1224 

1225 def funcdef(self): 

1226 

1227 localctx = Python3Parser.FuncdefContext(self, self._ctx, self.state) 

1228 self.enterRule(localctx, 14, self.RULE_funcdef) 

1229 self._la = 0 # Token type 

1230 try: 

1231 self.enterOuterAlt(localctx, 1) 

1232 self.state = 222 

1233 self.match(Python3Parser.DEF) 

1234 self.state = 223 

1235 self.match(Python3Parser.NAME) 

1236 self.state = 224 

1237 self.parameters() 

1238 self.state = 227 

1239 self._errHandler.sync(self) 

1240 _la = self._input.LA(1) 

1241 if _la==Python3Parser.ARROW: 

1242 self.state = 225 

1243 self.match(Python3Parser.ARROW) 

1244 self.state = 226 

1245 self.test() 

1246 

1247 

1248 self.state = 229 

1249 self.match(Python3Parser.COLON) 

1250 self.state = 230 

1251 self.suite() 

1252 except RecognitionException as re: 

1253 localctx.exception = re 

1254 self._errHandler.reportError(self, re) 

1255 self._errHandler.recover(self, re) 

1256 finally: 

1257 self.exitRule() 

1258 return localctx 

1259 

1260 

1261 class ParametersContext(ParserRuleContext): 

1262 __slots__ = 'parser' 

1263 

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

1265 super().__init__(parent, invokingState) 

1266 self.parser = parser 

1267 

1268 def OPEN_PAREN(self): 

1269 return self.getToken(Python3Parser.OPEN_PAREN, 0) 

1270 

1271 def CLOSE_PAREN(self): 

1272 return self.getToken(Python3Parser.CLOSE_PAREN, 0) 

1273 

1274 def typedargslist(self): 

1275 return self.getTypedRuleContext(Python3Parser.TypedargslistContext,0) 

1276 

1277 

1278 def getRuleIndex(self): 

1279 return Python3Parser.RULE_parameters 

1280 

1281 def enterRule(self, listener:ParseTreeListener): 

1282 if hasattr( listener, "enterParameters" ): 

1283 listener.enterParameters(self) 

1284 

1285 def exitRule(self, listener:ParseTreeListener): 

1286 if hasattr( listener, "exitParameters" ): 

1287 listener.exitParameters(self) 

1288 

1289 

1290 

1291 

1292 def parameters(self): 

1293 

1294 localctx = Python3Parser.ParametersContext(self, self._ctx, self.state) 

1295 self.enterRule(localctx, 16, self.RULE_parameters) 

1296 self._la = 0 # Token type 

1297 try: 

1298 self.enterOuterAlt(localctx, 1) 

1299 self.state = 232 

1300 self.match(Python3Parser.OPEN_PAREN) 

1301 self.state = 234 

1302 self._errHandler.sync(self) 

1303 _la = self._input.LA(1) 

1304 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.NAME) | (1 << Python3Parser.STAR) | (1 << Python3Parser.POWER))) != 0): 

1305 self.state = 233 

1306 self.typedargslist() 

1307 

1308 

1309 self.state = 236 

1310 self.match(Python3Parser.CLOSE_PAREN) 

1311 except RecognitionException as re: 

1312 localctx.exception = re 

1313 self._errHandler.reportError(self, re) 

1314 self._errHandler.recover(self, re) 

1315 finally: 

1316 self.exitRule() 

1317 return localctx 

1318 

1319 

1320 class TypedargslistContext(ParserRuleContext): 

1321 __slots__ = 'parser' 

1322 

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

1324 super().__init__(parent, invokingState) 

1325 self.parser = parser 

1326 

1327 def tfpdef(self, i:int=None): 

1328 if i is None: 

1329 return self.getTypedRuleContexts(Python3Parser.TfpdefContext) 

1330 else: 

1331 return self.getTypedRuleContext(Python3Parser.TfpdefContext,i) 

1332 

1333 

1334 def STAR(self): 

1335 return self.getToken(Python3Parser.STAR, 0) 

1336 

1337 def POWER(self): 

1338 return self.getToken(Python3Parser.POWER, 0) 

1339 

1340 def ASSIGN(self, i:int=None): 

1341 if i is None: 

1342 return self.getTokens(Python3Parser.ASSIGN) 

1343 else: 

1344 return self.getToken(Python3Parser.ASSIGN, i) 

1345 

1346 def test(self, i:int=None): 

1347 if i is None: 

1348 return self.getTypedRuleContexts(Python3Parser.TestContext) 

1349 else: 

1350 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

1351 

1352 

1353 def COMMA(self, i:int=None): 

1354 if i is None: 

1355 return self.getTokens(Python3Parser.COMMA) 

1356 else: 

1357 return self.getToken(Python3Parser.COMMA, i) 

1358 

1359 def getRuleIndex(self): 

1360 return Python3Parser.RULE_typedargslist 

1361 

1362 def enterRule(self, listener:ParseTreeListener): 

1363 if hasattr( listener, "enterTypedargslist" ): 

1364 listener.enterTypedargslist(self) 

1365 

1366 def exitRule(self, listener:ParseTreeListener): 

1367 if hasattr( listener, "exitTypedargslist" ): 

1368 listener.exitTypedargslist(self) 

1369 

1370 

1371 

1372 

1373 def typedargslist(self): 

1374 

1375 localctx = Python3Parser.TypedargslistContext(self, self._ctx, self.state) 

1376 self.enterRule(localctx, 18, self.RULE_typedargslist) 

1377 self._la = 0 # Token type 

1378 try: 

1379 self.enterOuterAlt(localctx, 1) 

1380 self.state = 319 

1381 self._errHandler.sync(self) 

1382 token = self._input.LA(1) 

1383 if token in [Python3Parser.NAME]: 

1384 self.state = 238 

1385 self.tfpdef() 

1386 self.state = 241 

1387 self._errHandler.sync(self) 

1388 _la = self._input.LA(1) 

1389 if _la==Python3Parser.ASSIGN: 

1390 self.state = 239 

1391 self.match(Python3Parser.ASSIGN) 

1392 self.state = 240 

1393 self.test() 

1394 

1395 

1396 self.state = 251 

1397 self._errHandler.sync(self) 

1398 _alt = self._interp.adaptivePredict(self._input,12,self._ctx) 

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

1400 if _alt==1: 

1401 self.state = 243 

1402 self.match(Python3Parser.COMMA) 

1403 self.state = 244 

1404 self.tfpdef() 

1405 self.state = 247 

1406 self._errHandler.sync(self) 

1407 _la = self._input.LA(1) 

1408 if _la==Python3Parser.ASSIGN: 

1409 self.state = 245 

1410 self.match(Python3Parser.ASSIGN) 

1411 self.state = 246 

1412 self.test() 

1413 

1414 

1415 self.state = 253 

1416 self._errHandler.sync(self) 

1417 _alt = self._interp.adaptivePredict(self._input,12,self._ctx) 

1418 

1419 self.state = 287 

1420 self._errHandler.sync(self) 

1421 _la = self._input.LA(1) 

1422 if _la==Python3Parser.COMMA: 

1423 self.state = 254 

1424 self.match(Python3Parser.COMMA) 

1425 self.state = 285 

1426 self._errHandler.sync(self) 

1427 token = self._input.LA(1) 

1428 if token in [Python3Parser.STAR]: 

1429 self.state = 255 

1430 self.match(Python3Parser.STAR) 

1431 self.state = 257 

1432 self._errHandler.sync(self) 

1433 _la = self._input.LA(1) 

1434 if _la==Python3Parser.NAME: 

1435 self.state = 256 

1436 self.tfpdef() 

1437 

1438 

1439 self.state = 267 

1440 self._errHandler.sync(self) 

1441 _alt = self._interp.adaptivePredict(self._input,15,self._ctx) 

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

1443 if _alt==1: 

1444 self.state = 259 

1445 self.match(Python3Parser.COMMA) 

1446 self.state = 260 

1447 self.tfpdef() 

1448 self.state = 263 

1449 self._errHandler.sync(self) 

1450 _la = self._input.LA(1) 

1451 if _la==Python3Parser.ASSIGN: 

1452 self.state = 261 

1453 self.match(Python3Parser.ASSIGN) 

1454 self.state = 262 

1455 self.test() 

1456 

1457 

1458 self.state = 269 

1459 self._errHandler.sync(self) 

1460 _alt = self._interp.adaptivePredict(self._input,15,self._ctx) 

1461 

1462 self.state = 278 

1463 self._errHandler.sync(self) 

1464 _la = self._input.LA(1) 

1465 if _la==Python3Parser.COMMA: 

1466 self.state = 270 

1467 self.match(Python3Parser.COMMA) 

1468 self.state = 276 

1469 self._errHandler.sync(self) 

1470 _la = self._input.LA(1) 

1471 if _la==Python3Parser.POWER: 

1472 self.state = 271 

1473 self.match(Python3Parser.POWER) 

1474 self.state = 272 

1475 self.tfpdef() 

1476 self.state = 274 

1477 self._errHandler.sync(self) 

1478 _la = self._input.LA(1) 

1479 if _la==Python3Parser.COMMA: 

1480 self.state = 273 

1481 self.match(Python3Parser.COMMA) 

1482 

1483 

1484 

1485 

1486 

1487 

1488 pass 

1489 elif token in [Python3Parser.POWER]: 

1490 self.state = 280 

1491 self.match(Python3Parser.POWER) 

1492 self.state = 281 

1493 self.tfpdef() 

1494 self.state = 283 

1495 self._errHandler.sync(self) 

1496 _la = self._input.LA(1) 

1497 if _la==Python3Parser.COMMA: 

1498 self.state = 282 

1499 self.match(Python3Parser.COMMA) 

1500 

1501 

1502 pass 

1503 elif token in [Python3Parser.CLOSE_PAREN]: 

1504 pass 

1505 else: 

1506 pass 

1507 

1508 

1509 pass 

1510 elif token in [Python3Parser.STAR]: 

1511 self.state = 289 

1512 self.match(Python3Parser.STAR) 

1513 self.state = 291 

1514 self._errHandler.sync(self) 

1515 _la = self._input.LA(1) 

1516 if _la==Python3Parser.NAME: 

1517 self.state = 290 

1518 self.tfpdef() 

1519 

1520 

1521 self.state = 301 

1522 self._errHandler.sync(self) 

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

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

1525 if _alt==1: 

1526 self.state = 293 

1527 self.match(Python3Parser.COMMA) 

1528 self.state = 294 

1529 self.tfpdef() 

1530 self.state = 297 

1531 self._errHandler.sync(self) 

1532 _la = self._input.LA(1) 

1533 if _la==Python3Parser.ASSIGN: 

1534 self.state = 295 

1535 self.match(Python3Parser.ASSIGN) 

1536 self.state = 296 

1537 self.test() 

1538 

1539 

1540 self.state = 303 

1541 self._errHandler.sync(self) 

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

1543 

1544 self.state = 312 

1545 self._errHandler.sync(self) 

1546 _la = self._input.LA(1) 

1547 if _la==Python3Parser.COMMA: 

1548 self.state = 304 

1549 self.match(Python3Parser.COMMA) 

1550 self.state = 310 

1551 self._errHandler.sync(self) 

1552 _la = self._input.LA(1) 

1553 if _la==Python3Parser.POWER: 

1554 self.state = 305 

1555 self.match(Python3Parser.POWER) 

1556 self.state = 306 

1557 self.tfpdef() 

1558 self.state = 308 

1559 self._errHandler.sync(self) 

1560 _la = self._input.LA(1) 

1561 if _la==Python3Parser.COMMA: 

1562 self.state = 307 

1563 self.match(Python3Parser.COMMA) 

1564 

1565 

1566 

1567 

1568 

1569 

1570 pass 

1571 elif token in [Python3Parser.POWER]: 

1572 self.state = 314 

1573 self.match(Python3Parser.POWER) 

1574 self.state = 315 

1575 self.tfpdef() 

1576 self.state = 317 

1577 self._errHandler.sync(self) 

1578 _la = self._input.LA(1) 

1579 if _la==Python3Parser.COMMA: 

1580 self.state = 316 

1581 self.match(Python3Parser.COMMA) 

1582 

1583 

1584 pass 

1585 else: 

1586 raise NoViableAltException(self) 

1587 

1588 except RecognitionException as re: 

1589 localctx.exception = re 

1590 self._errHandler.reportError(self, re) 

1591 self._errHandler.recover(self, re) 

1592 finally: 

1593 self.exitRule() 

1594 return localctx 

1595 

1596 

1597 class TfpdefContext(ParserRuleContext): 

1598 __slots__ = 'parser' 

1599 

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

1601 super().__init__(parent, invokingState) 

1602 self.parser = parser 

1603 

1604 def NAME(self): 

1605 return self.getToken(Python3Parser.NAME, 0) 

1606 

1607 def COLON(self): 

1608 return self.getToken(Python3Parser.COLON, 0) 

1609 

1610 def test(self): 

1611 return self.getTypedRuleContext(Python3Parser.TestContext,0) 

1612 

1613 

1614 def getRuleIndex(self): 

1615 return Python3Parser.RULE_tfpdef 

1616 

1617 def enterRule(self, listener:ParseTreeListener): 

1618 if hasattr( listener, "enterTfpdef" ): 

1619 listener.enterTfpdef(self) 

1620 

1621 def exitRule(self, listener:ParseTreeListener): 

1622 if hasattr( listener, "exitTfpdef" ): 

1623 listener.exitTfpdef(self) 

1624 

1625 

1626 

1627 

1628 def tfpdef(self): 

1629 

1630 localctx = Python3Parser.TfpdefContext(self, self._ctx, self.state) 

1631 self.enterRule(localctx, 20, self.RULE_tfpdef) 

1632 self._la = 0 # Token type 

1633 try: 

1634 self.enterOuterAlt(localctx, 1) 

1635 self.state = 321 

1636 self.match(Python3Parser.NAME) 

1637 self.state = 324 

1638 self._errHandler.sync(self) 

1639 _la = self._input.LA(1) 

1640 if _la==Python3Parser.COLON: 

1641 self.state = 322 

1642 self.match(Python3Parser.COLON) 

1643 self.state = 323 

1644 self.test() 

1645 

1646 

1647 except RecognitionException as re: 

1648 localctx.exception = re 

1649 self._errHandler.reportError(self, re) 

1650 self._errHandler.recover(self, re) 

1651 finally: 

1652 self.exitRule() 

1653 return localctx 

1654 

1655 

1656 class VarargslistContext(ParserRuleContext): 

1657 __slots__ = 'parser' 

1658 

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

1660 super().__init__(parent, invokingState) 

1661 self.parser = parser 

1662 

1663 def vfpdef(self, i:int=None): 

1664 if i is None: 

1665 return self.getTypedRuleContexts(Python3Parser.VfpdefContext) 

1666 else: 

1667 return self.getTypedRuleContext(Python3Parser.VfpdefContext,i) 

1668 

1669 

1670 def STAR(self): 

1671 return self.getToken(Python3Parser.STAR, 0) 

1672 

1673 def POWER(self): 

1674 return self.getToken(Python3Parser.POWER, 0) 

1675 

1676 def ASSIGN(self, i:int=None): 

1677 if i is None: 

1678 return self.getTokens(Python3Parser.ASSIGN) 

1679 else: 

1680 return self.getToken(Python3Parser.ASSIGN, i) 

1681 

1682 def test(self, i:int=None): 

1683 if i is None: 

1684 return self.getTypedRuleContexts(Python3Parser.TestContext) 

1685 else: 

1686 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

1687 

1688 

1689 def COMMA(self, i:int=None): 

1690 if i is None: 

1691 return self.getTokens(Python3Parser.COMMA) 

1692 else: 

1693 return self.getToken(Python3Parser.COMMA, i) 

1694 

1695 def getRuleIndex(self): 

1696 return Python3Parser.RULE_varargslist 

1697 

1698 def enterRule(self, listener:ParseTreeListener): 

1699 if hasattr( listener, "enterVarargslist" ): 

1700 listener.enterVarargslist(self) 

1701 

1702 def exitRule(self, listener:ParseTreeListener): 

1703 if hasattr( listener, "exitVarargslist" ): 

1704 listener.exitVarargslist(self) 

1705 

1706 

1707 

1708 

1709 def varargslist(self): 

1710 

1711 localctx = Python3Parser.VarargslistContext(self, self._ctx, self.state) 

1712 self.enterRule(localctx, 22, self.RULE_varargslist) 

1713 self._la = 0 # Token type 

1714 try: 

1715 self.enterOuterAlt(localctx, 1) 

1716 self.state = 407 

1717 self._errHandler.sync(self) 

1718 token = self._input.LA(1) 

1719 if token in [Python3Parser.NAME]: 

1720 self.state = 326 

1721 self.vfpdef() 

1722 self.state = 329 

1723 self._errHandler.sync(self) 

1724 _la = self._input.LA(1) 

1725 if _la==Python3Parser.ASSIGN: 

1726 self.state = 327 

1727 self.match(Python3Parser.ASSIGN) 

1728 self.state = 328 

1729 self.test() 

1730 

1731 

1732 self.state = 339 

1733 self._errHandler.sync(self) 

1734 _alt = self._interp.adaptivePredict(self._input,33,self._ctx) 

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

1736 if _alt==1: 

1737 self.state = 331 

1738 self.match(Python3Parser.COMMA) 

1739 self.state = 332 

1740 self.vfpdef() 

1741 self.state = 335 

1742 self._errHandler.sync(self) 

1743 _la = self._input.LA(1) 

1744 if _la==Python3Parser.ASSIGN: 

1745 self.state = 333 

1746 self.match(Python3Parser.ASSIGN) 

1747 self.state = 334 

1748 self.test() 

1749 

1750 

1751 self.state = 341 

1752 self._errHandler.sync(self) 

1753 _alt = self._interp.adaptivePredict(self._input,33,self._ctx) 

1754 

1755 self.state = 375 

1756 self._errHandler.sync(self) 

1757 _la = self._input.LA(1) 

1758 if _la==Python3Parser.COMMA: 

1759 self.state = 342 

1760 self.match(Python3Parser.COMMA) 

1761 self.state = 373 

1762 self._errHandler.sync(self) 

1763 token = self._input.LA(1) 

1764 if token in [Python3Parser.STAR]: 

1765 self.state = 343 

1766 self.match(Python3Parser.STAR) 

1767 self.state = 345 

1768 self._errHandler.sync(self) 

1769 _la = self._input.LA(1) 

1770 if _la==Python3Parser.NAME: 

1771 self.state = 344 

1772 self.vfpdef() 

1773 

1774 

1775 self.state = 355 

1776 self._errHandler.sync(self) 

1777 _alt = self._interp.adaptivePredict(self._input,36,self._ctx) 

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

1779 if _alt==1: 

1780 self.state = 347 

1781 self.match(Python3Parser.COMMA) 

1782 self.state = 348 

1783 self.vfpdef() 

1784 self.state = 351 

1785 self._errHandler.sync(self) 

1786 _la = self._input.LA(1) 

1787 if _la==Python3Parser.ASSIGN: 

1788 self.state = 349 

1789 self.match(Python3Parser.ASSIGN) 

1790 self.state = 350 

1791 self.test() 

1792 

1793 

1794 self.state = 357 

1795 self._errHandler.sync(self) 

1796 _alt = self._interp.adaptivePredict(self._input,36,self._ctx) 

1797 

1798 self.state = 366 

1799 self._errHandler.sync(self) 

1800 _la = self._input.LA(1) 

1801 if _la==Python3Parser.COMMA: 

1802 self.state = 358 

1803 self.match(Python3Parser.COMMA) 

1804 self.state = 364 

1805 self._errHandler.sync(self) 

1806 _la = self._input.LA(1) 

1807 if _la==Python3Parser.POWER: 

1808 self.state = 359 

1809 self.match(Python3Parser.POWER) 

1810 self.state = 360 

1811 self.vfpdef() 

1812 self.state = 362 

1813 self._errHandler.sync(self) 

1814 _la = self._input.LA(1) 

1815 if _la==Python3Parser.COMMA: 

1816 self.state = 361 

1817 self.match(Python3Parser.COMMA) 

1818 

1819 

1820 

1821 

1822 

1823 

1824 pass 

1825 elif token in [Python3Parser.POWER]: 

1826 self.state = 368 

1827 self.match(Python3Parser.POWER) 

1828 self.state = 369 

1829 self.vfpdef() 

1830 self.state = 371 

1831 self._errHandler.sync(self) 

1832 _la = self._input.LA(1) 

1833 if _la==Python3Parser.COMMA: 

1834 self.state = 370 

1835 self.match(Python3Parser.COMMA) 

1836 

1837 

1838 pass 

1839 elif token in [Python3Parser.COLON]: 

1840 pass 

1841 else: 

1842 pass 

1843 

1844 

1845 pass 

1846 elif token in [Python3Parser.STAR]: 

1847 self.state = 377 

1848 self.match(Python3Parser.STAR) 

1849 self.state = 379 

1850 self._errHandler.sync(self) 

1851 _la = self._input.LA(1) 

1852 if _la==Python3Parser.NAME: 

1853 self.state = 378 

1854 self.vfpdef() 

1855 

1856 

1857 self.state = 389 

1858 self._errHandler.sync(self) 

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

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

1861 if _alt==1: 

1862 self.state = 381 

1863 self.match(Python3Parser.COMMA) 

1864 self.state = 382 

1865 self.vfpdef() 

1866 self.state = 385 

1867 self._errHandler.sync(self) 

1868 _la = self._input.LA(1) 

1869 if _la==Python3Parser.ASSIGN: 

1870 self.state = 383 

1871 self.match(Python3Parser.ASSIGN) 

1872 self.state = 384 

1873 self.test() 

1874 

1875 

1876 self.state = 391 

1877 self._errHandler.sync(self) 

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

1879 

1880 self.state = 400 

1881 self._errHandler.sync(self) 

1882 _la = self._input.LA(1) 

1883 if _la==Python3Parser.COMMA: 

1884 self.state = 392 

1885 self.match(Python3Parser.COMMA) 

1886 self.state = 398 

1887 self._errHandler.sync(self) 

1888 _la = self._input.LA(1) 

1889 if _la==Python3Parser.POWER: 

1890 self.state = 393 

1891 self.match(Python3Parser.POWER) 

1892 self.state = 394 

1893 self.vfpdef() 

1894 self.state = 396 

1895 self._errHandler.sync(self) 

1896 _la = self._input.LA(1) 

1897 if _la==Python3Parser.COMMA: 

1898 self.state = 395 

1899 self.match(Python3Parser.COMMA) 

1900 

1901 

1902 

1903 

1904 

1905 

1906 pass 

1907 elif token in [Python3Parser.POWER]: 

1908 self.state = 402 

1909 self.match(Python3Parser.POWER) 

1910 self.state = 403 

1911 self.vfpdef() 

1912 self.state = 405 

1913 self._errHandler.sync(self) 

1914 _la = self._input.LA(1) 

1915 if _la==Python3Parser.COMMA: 

1916 self.state = 404 

1917 self.match(Python3Parser.COMMA) 

1918 

1919 

1920 pass 

1921 else: 

1922 raise NoViableAltException(self) 

1923 

1924 except RecognitionException as re: 

1925 localctx.exception = re 

1926 self._errHandler.reportError(self, re) 

1927 self._errHandler.recover(self, re) 

1928 finally: 

1929 self.exitRule() 

1930 return localctx 

1931 

1932 

1933 class VfpdefContext(ParserRuleContext): 

1934 __slots__ = 'parser' 

1935 

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

1937 super().__init__(parent, invokingState) 

1938 self.parser = parser 

1939 

1940 def NAME(self): 

1941 return self.getToken(Python3Parser.NAME, 0) 

1942 

1943 def getRuleIndex(self): 

1944 return Python3Parser.RULE_vfpdef 

1945 

1946 def enterRule(self, listener:ParseTreeListener): 

1947 if hasattr( listener, "enterVfpdef" ): 

1948 listener.enterVfpdef(self) 

1949 

1950 def exitRule(self, listener:ParseTreeListener): 

1951 if hasattr( listener, "exitVfpdef" ): 

1952 listener.exitVfpdef(self) 

1953 

1954 

1955 

1956 

1957 def vfpdef(self): 

1958 

1959 localctx = Python3Parser.VfpdefContext(self, self._ctx, self.state) 

1960 self.enterRule(localctx, 24, self.RULE_vfpdef) 

1961 try: 

1962 self.enterOuterAlt(localctx, 1) 

1963 self.state = 409 

1964 self.match(Python3Parser.NAME) 

1965 except RecognitionException as re: 

1966 localctx.exception = re 

1967 self._errHandler.reportError(self, re) 

1968 self._errHandler.recover(self, re) 

1969 finally: 

1970 self.exitRule() 

1971 return localctx 

1972 

1973 

1974 class StmtContext(ParserRuleContext): 

1975 __slots__ = 'parser' 

1976 

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

1978 super().__init__(parent, invokingState) 

1979 self.parser = parser 

1980 

1981 def simple_stmt(self): 

1982 return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,0) 

1983 

1984 

1985 def compound_stmt(self): 

1986 return self.getTypedRuleContext(Python3Parser.Compound_stmtContext,0) 

1987 

1988 

1989 def getRuleIndex(self): 

1990 return Python3Parser.RULE_stmt 

1991 

1992 def enterRule(self, listener:ParseTreeListener): 

1993 if hasattr( listener, "enterStmt" ): 

1994 listener.enterStmt(self) 

1995 

1996 def exitRule(self, listener:ParseTreeListener): 

1997 if hasattr( listener, "exitStmt" ): 

1998 listener.exitStmt(self) 

1999 

2000 

2001 

2002 

2003 def stmt(self): 

2004 

2005 localctx = Python3Parser.StmtContext(self, self._ctx, self.state) 

2006 self.enterRule(localctx, 26, self.RULE_stmt) 

2007 try: 

2008 self.state = 413 

2009 self._errHandler.sync(self) 

2010 token = self._input.LA(1) 

2011 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.FROM, Python3Parser.IMPORT, Python3Parser.GLOBAL, Python3Parser.NONLOCAL, Python3Parser.ASSERT, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.YIELD, Python3Parser.DEL, Python3Parser.PASS, Python3Parser.CONTINUE, Python3Parser.BREAK, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

2012 self.enterOuterAlt(localctx, 1) 

2013 self.state = 411 

2014 self.simple_stmt() 

2015 pass 

2016 elif token in [Python3Parser.DEF, Python3Parser.IF, Python3Parser.WHILE, Python3Parser.FOR, Python3Parser.TRY, Python3Parser.WITH, Python3Parser.CLASS, Python3Parser.ASYNC, Python3Parser.AT]: 

2017 self.enterOuterAlt(localctx, 2) 

2018 self.state = 412 

2019 self.compound_stmt() 

2020 pass 

2021 else: 

2022 raise NoViableAltException(self) 

2023 

2024 except RecognitionException as re: 

2025 localctx.exception = re 

2026 self._errHandler.reportError(self, re) 

2027 self._errHandler.recover(self, re) 

2028 finally: 

2029 self.exitRule() 

2030 return localctx 

2031 

2032 

2033 class Simple_stmtContext(ParserRuleContext): 

2034 __slots__ = 'parser' 

2035 

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

2037 super().__init__(parent, invokingState) 

2038 self.parser = parser 

2039 

2040 def small_stmt(self, i:int=None): 

2041 if i is None: 

2042 return self.getTypedRuleContexts(Python3Parser.Small_stmtContext) 

2043 else: 

2044 return self.getTypedRuleContext(Python3Parser.Small_stmtContext,i) 

2045 

2046 

2047 def NEWLINE(self): 

2048 return self.getToken(Python3Parser.NEWLINE, 0) 

2049 

2050 def SEMI_COLON(self, i:int=None): 

2051 if i is None: 

2052 return self.getTokens(Python3Parser.SEMI_COLON) 

2053 else: 

2054 return self.getToken(Python3Parser.SEMI_COLON, i) 

2055 

2056 def getRuleIndex(self): 

2057 return Python3Parser.RULE_simple_stmt 

2058 

2059 def enterRule(self, listener:ParseTreeListener): 

2060 if hasattr( listener, "enterSimple_stmt" ): 

2061 listener.enterSimple_stmt(self) 

2062 

2063 def exitRule(self, listener:ParseTreeListener): 

2064 if hasattr( listener, "exitSimple_stmt" ): 

2065 listener.exitSimple_stmt(self) 

2066 

2067 

2068 

2069 

2070 def simple_stmt(self): 

2071 

2072 localctx = Python3Parser.Simple_stmtContext(self, self._ctx, self.state) 

2073 self.enterRule(localctx, 28, self.RULE_simple_stmt) 

2074 self._la = 0 # Token type 

2075 try: 

2076 self.enterOuterAlt(localctx, 1) 

2077 self.state = 415 

2078 self.small_stmt() 

2079 self.state = 420 

2080 self._errHandler.sync(self) 

2081 _alt = self._interp.adaptivePredict(self._input,52,self._ctx) 

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

2083 if _alt==1: 

2084 self.state = 416 

2085 self.match(Python3Parser.SEMI_COLON) 

2086 self.state = 417 

2087 self.small_stmt() 

2088 self.state = 422 

2089 self._errHandler.sync(self) 

2090 _alt = self._interp.adaptivePredict(self._input,52,self._ctx) 

2091 

2092 self.state = 424 

2093 self._errHandler.sync(self) 

2094 _la = self._input.LA(1) 

2095 if _la==Python3Parser.SEMI_COLON: 

2096 self.state = 423 

2097 self.match(Python3Parser.SEMI_COLON) 

2098 

2099 

2100 self.state = 426 

2101 self.match(Python3Parser.NEWLINE) 

2102 except RecognitionException as re: 

2103 localctx.exception = re 

2104 self._errHandler.reportError(self, re) 

2105 self._errHandler.recover(self, re) 

2106 finally: 

2107 self.exitRule() 

2108 return localctx 

2109 

2110 

2111 class Small_stmtContext(ParserRuleContext): 

2112 __slots__ = 'parser' 

2113 

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

2115 super().__init__(parent, invokingState) 

2116 self.parser = parser 

2117 

2118 def expr_stmt(self): 

2119 return self.getTypedRuleContext(Python3Parser.Expr_stmtContext,0) 

2120 

2121 

2122 def del_stmt(self): 

2123 return self.getTypedRuleContext(Python3Parser.Del_stmtContext,0) 

2124 

2125 

2126 def pass_stmt(self): 

2127 return self.getTypedRuleContext(Python3Parser.Pass_stmtContext,0) 

2128 

2129 

2130 def flow_stmt(self): 

2131 return self.getTypedRuleContext(Python3Parser.Flow_stmtContext,0) 

2132 

2133 

2134 def import_stmt(self): 

2135 return self.getTypedRuleContext(Python3Parser.Import_stmtContext,0) 

2136 

2137 

2138 def global_stmt(self): 

2139 return self.getTypedRuleContext(Python3Parser.Global_stmtContext,0) 

2140 

2141 

2142 def nonlocal_stmt(self): 

2143 return self.getTypedRuleContext(Python3Parser.Nonlocal_stmtContext,0) 

2144 

2145 

2146 def assert_stmt(self): 

2147 return self.getTypedRuleContext(Python3Parser.Assert_stmtContext,0) 

2148 

2149 

2150 def getRuleIndex(self): 

2151 return Python3Parser.RULE_small_stmt 

2152 

2153 def enterRule(self, listener:ParseTreeListener): 

2154 if hasattr( listener, "enterSmall_stmt" ): 

2155 listener.enterSmall_stmt(self) 

2156 

2157 def exitRule(self, listener:ParseTreeListener): 

2158 if hasattr( listener, "exitSmall_stmt" ): 

2159 listener.exitSmall_stmt(self) 

2160 

2161 

2162 

2163 

2164 def small_stmt(self): 

2165 

2166 localctx = Python3Parser.Small_stmtContext(self, self._ctx, self.state) 

2167 self.enterRule(localctx, 30, self.RULE_small_stmt) 

2168 try: 

2169 self.enterOuterAlt(localctx, 1) 

2170 self.state = 436 

2171 self._errHandler.sync(self) 

2172 token = self._input.LA(1) 

2173 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

2174 self.state = 428 

2175 self.expr_stmt() 

2176 pass 

2177 elif token in [Python3Parser.DEL]: 

2178 self.state = 429 

2179 self.del_stmt() 

2180 pass 

2181 elif token in [Python3Parser.PASS]: 

2182 self.state = 430 

2183 self.pass_stmt() 

2184 pass 

2185 elif token in [Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.YIELD, Python3Parser.CONTINUE, Python3Parser.BREAK]: 

2186 self.state = 431 

2187 self.flow_stmt() 

2188 pass 

2189 elif token in [Python3Parser.FROM, Python3Parser.IMPORT]: 

2190 self.state = 432 

2191 self.import_stmt() 

2192 pass 

2193 elif token in [Python3Parser.GLOBAL]: 

2194 self.state = 433 

2195 self.global_stmt() 

2196 pass 

2197 elif token in [Python3Parser.NONLOCAL]: 

2198 self.state = 434 

2199 self.nonlocal_stmt() 

2200 pass 

2201 elif token in [Python3Parser.ASSERT]: 

2202 self.state = 435 

2203 self.assert_stmt() 

2204 pass 

2205 else: 

2206 raise NoViableAltException(self) 

2207 

2208 except RecognitionException as re: 

2209 localctx.exception = re 

2210 self._errHandler.reportError(self, re) 

2211 self._errHandler.recover(self, re) 

2212 finally: 

2213 self.exitRule() 

2214 return localctx 

2215 

2216 

2217 class Expr_stmtContext(ParserRuleContext): 

2218 __slots__ = 'parser' 

2219 

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

2221 super().__init__(parent, invokingState) 

2222 self.parser = parser 

2223 

2224 def testlist_star_expr(self, i:int=None): 

2225 if i is None: 

2226 return self.getTypedRuleContexts(Python3Parser.Testlist_star_exprContext) 

2227 else: 

2228 return self.getTypedRuleContext(Python3Parser.Testlist_star_exprContext,i) 

2229 

2230 

2231 def annassign(self): 

2232 return self.getTypedRuleContext(Python3Parser.AnnassignContext,0) 

2233 

2234 

2235 def augassign(self): 

2236 return self.getTypedRuleContext(Python3Parser.AugassignContext,0) 

2237 

2238 

2239 def yield_expr(self, i:int=None): 

2240 if i is None: 

2241 return self.getTypedRuleContexts(Python3Parser.Yield_exprContext) 

2242 else: 

2243 return self.getTypedRuleContext(Python3Parser.Yield_exprContext,i) 

2244 

2245 

2246 def testlist(self): 

2247 return self.getTypedRuleContext(Python3Parser.TestlistContext,0) 

2248 

2249 

2250 def ASSIGN(self, i:int=None): 

2251 if i is None: 

2252 return self.getTokens(Python3Parser.ASSIGN) 

2253 else: 

2254 return self.getToken(Python3Parser.ASSIGN, i) 

2255 

2256 def getRuleIndex(self): 

2257 return Python3Parser.RULE_expr_stmt 

2258 

2259 def enterRule(self, listener:ParseTreeListener): 

2260 if hasattr( listener, "enterExpr_stmt" ): 

2261 listener.enterExpr_stmt(self) 

2262 

2263 def exitRule(self, listener:ParseTreeListener): 

2264 if hasattr( listener, "exitExpr_stmt" ): 

2265 listener.exitExpr_stmt(self) 

2266 

2267 

2268 

2269 

2270 def expr_stmt(self): 

2271 

2272 localctx = Python3Parser.Expr_stmtContext(self, self._ctx, self.state) 

2273 self.enterRule(localctx, 32, self.RULE_expr_stmt) 

2274 self._la = 0 # Token type 

2275 try: 

2276 self.enterOuterAlt(localctx, 1) 

2277 self.state = 438 

2278 self.testlist_star_expr() 

2279 self.state = 455 

2280 self._errHandler.sync(self) 

2281 token = self._input.LA(1) 

2282 if token in [Python3Parser.COLON]: 

2283 self.state = 439 

2284 self.annassign() 

2285 pass 

2286 elif token in [Python3Parser.ADD_ASSIGN, Python3Parser.SUB_ASSIGN, Python3Parser.MULT_ASSIGN, Python3Parser.AT_ASSIGN, Python3Parser.DIV_ASSIGN, Python3Parser.MOD_ASSIGN, Python3Parser.AND_ASSIGN, Python3Parser.OR_ASSIGN, Python3Parser.XOR_ASSIGN, Python3Parser.LEFT_SHIFT_ASSIGN, Python3Parser.RIGHT_SHIFT_ASSIGN, Python3Parser.POWER_ASSIGN, Python3Parser.IDIV_ASSIGN]: 

2287 self.state = 440 

2288 self.augassign() 

2289 self.state = 443 

2290 self._errHandler.sync(self) 

2291 token = self._input.LA(1) 

2292 if token in [Python3Parser.YIELD]: 

2293 self.state = 441 

2294 self.yield_expr() 

2295 pass 

2296 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

2297 self.state = 442 

2298 self.testlist() 

2299 pass 

2300 else: 

2301 raise NoViableAltException(self) 

2302 

2303 pass 

2304 elif token in [Python3Parser.NEWLINE, Python3Parser.SEMI_COLON, Python3Parser.ASSIGN]: 

2305 self.state = 452 

2306 self._errHandler.sync(self) 

2307 _la = self._input.LA(1) 

2308 while _la==Python3Parser.ASSIGN: 

2309 self.state = 445 

2310 self.match(Python3Parser.ASSIGN) 

2311 self.state = 448 

2312 self._errHandler.sync(self) 

2313 token = self._input.LA(1) 

2314 if token in [Python3Parser.YIELD]: 

2315 self.state = 446 

2316 self.yield_expr() 

2317 pass 

2318 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

2319 self.state = 447 

2320 self.testlist_star_expr() 

2321 pass 

2322 else: 

2323 raise NoViableAltException(self) 

2324 

2325 self.state = 454 

2326 self._errHandler.sync(self) 

2327 _la = self._input.LA(1) 

2328 

2329 pass 

2330 else: 

2331 raise NoViableAltException(self) 

2332 

2333 except RecognitionException as re: 

2334 localctx.exception = re 

2335 self._errHandler.reportError(self, re) 

2336 self._errHandler.recover(self, re) 

2337 finally: 

2338 self.exitRule() 

2339 return localctx 

2340 

2341 

2342 class AnnassignContext(ParserRuleContext): 

2343 __slots__ = 'parser' 

2344 

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

2346 super().__init__(parent, invokingState) 

2347 self.parser = parser 

2348 

2349 def COLON(self): 

2350 return self.getToken(Python3Parser.COLON, 0) 

2351 

2352 def test(self, i:int=None): 

2353 if i is None: 

2354 return self.getTypedRuleContexts(Python3Parser.TestContext) 

2355 else: 

2356 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

2357 

2358 

2359 def ASSIGN(self): 

2360 return self.getToken(Python3Parser.ASSIGN, 0) 

2361 

2362 def getRuleIndex(self): 

2363 return Python3Parser.RULE_annassign 

2364 

2365 def enterRule(self, listener:ParseTreeListener): 

2366 if hasattr( listener, "enterAnnassign" ): 

2367 listener.enterAnnassign(self) 

2368 

2369 def exitRule(self, listener:ParseTreeListener): 

2370 if hasattr( listener, "exitAnnassign" ): 

2371 listener.exitAnnassign(self) 

2372 

2373 

2374 

2375 

2376 def annassign(self): 

2377 

2378 localctx = Python3Parser.AnnassignContext(self, self._ctx, self.state) 

2379 self.enterRule(localctx, 34, self.RULE_annassign) 

2380 self._la = 0 # Token type 

2381 try: 

2382 self.enterOuterAlt(localctx, 1) 

2383 self.state = 457 

2384 self.match(Python3Parser.COLON) 

2385 self.state = 458 

2386 self.test() 

2387 self.state = 461 

2388 self._errHandler.sync(self) 

2389 _la = self._input.LA(1) 

2390 if _la==Python3Parser.ASSIGN: 

2391 self.state = 459 

2392 self.match(Python3Parser.ASSIGN) 

2393 self.state = 460 

2394 self.test() 

2395 

2396 

2397 except RecognitionException as re: 

2398 localctx.exception = re 

2399 self._errHandler.reportError(self, re) 

2400 self._errHandler.recover(self, re) 

2401 finally: 

2402 self.exitRule() 

2403 return localctx 

2404 

2405 

2406 class Testlist_star_exprContext(ParserRuleContext): 

2407 __slots__ = 'parser' 

2408 

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

2410 super().__init__(parent, invokingState) 

2411 self.parser = parser 

2412 

2413 def test(self, i:int=None): 

2414 if i is None: 

2415 return self.getTypedRuleContexts(Python3Parser.TestContext) 

2416 else: 

2417 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

2418 

2419 

2420 def star_expr(self, i:int=None): 

2421 if i is None: 

2422 return self.getTypedRuleContexts(Python3Parser.Star_exprContext) 

2423 else: 

2424 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i) 

2425 

2426 

2427 def COMMA(self, i:int=None): 

2428 if i is None: 

2429 return self.getTokens(Python3Parser.COMMA) 

2430 else: 

2431 return self.getToken(Python3Parser.COMMA, i) 

2432 

2433 def getRuleIndex(self): 

2434 return Python3Parser.RULE_testlist_star_expr 

2435 

2436 def enterRule(self, listener:ParseTreeListener): 

2437 if hasattr( listener, "enterTestlist_star_expr" ): 

2438 listener.enterTestlist_star_expr(self) 

2439 

2440 def exitRule(self, listener:ParseTreeListener): 

2441 if hasattr( listener, "exitTestlist_star_expr" ): 

2442 listener.exitTestlist_star_expr(self) 

2443 

2444 

2445 

2446 

2447 def testlist_star_expr(self): 

2448 

2449 localctx = Python3Parser.Testlist_star_exprContext(self, self._ctx, self.state) 

2450 self.enterRule(localctx, 36, self.RULE_testlist_star_expr) 

2451 self._la = 0 # Token type 

2452 try: 

2453 self.enterOuterAlt(localctx, 1) 

2454 self.state = 465 

2455 self._errHandler.sync(self) 

2456 token = self._input.LA(1) 

2457 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

2458 self.state = 463 

2459 self.test() 

2460 pass 

2461 elif token in [Python3Parser.STAR]: 

2462 self.state = 464 

2463 self.star_expr() 

2464 pass 

2465 else: 

2466 raise NoViableAltException(self) 

2467 

2468 self.state = 474 

2469 self._errHandler.sync(self) 

2470 _alt = self._interp.adaptivePredict(self._input,62,self._ctx) 

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

2472 if _alt==1: 

2473 self.state = 467 

2474 self.match(Python3Parser.COMMA) 

2475 self.state = 470 

2476 self._errHandler.sync(self) 

2477 token = self._input.LA(1) 

2478 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

2479 self.state = 468 

2480 self.test() 

2481 pass 

2482 elif token in [Python3Parser.STAR]: 

2483 self.state = 469 

2484 self.star_expr() 

2485 pass 

2486 else: 

2487 raise NoViableAltException(self) 

2488 

2489 self.state = 476 

2490 self._errHandler.sync(self) 

2491 _alt = self._interp.adaptivePredict(self._input,62,self._ctx) 

2492 

2493 self.state = 478 

2494 self._errHandler.sync(self) 

2495 _la = self._input.LA(1) 

2496 if _la==Python3Parser.COMMA: 

2497 self.state = 477 

2498 self.match(Python3Parser.COMMA) 

2499 

2500 

2501 except RecognitionException as re: 

2502 localctx.exception = re 

2503 self._errHandler.reportError(self, re) 

2504 self._errHandler.recover(self, re) 

2505 finally: 

2506 self.exitRule() 

2507 return localctx 

2508 

2509 

2510 class AugassignContext(ParserRuleContext): 

2511 __slots__ = 'parser' 

2512 

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

2514 super().__init__(parent, invokingState) 

2515 self.parser = parser 

2516 

2517 def ADD_ASSIGN(self): 

2518 return self.getToken(Python3Parser.ADD_ASSIGN, 0) 

2519 

2520 def SUB_ASSIGN(self): 

2521 return self.getToken(Python3Parser.SUB_ASSIGN, 0) 

2522 

2523 def MULT_ASSIGN(self): 

2524 return self.getToken(Python3Parser.MULT_ASSIGN, 0) 

2525 

2526 def AT_ASSIGN(self): 

2527 return self.getToken(Python3Parser.AT_ASSIGN, 0) 

2528 

2529 def DIV_ASSIGN(self): 

2530 return self.getToken(Python3Parser.DIV_ASSIGN, 0) 

2531 

2532 def MOD_ASSIGN(self): 

2533 return self.getToken(Python3Parser.MOD_ASSIGN, 0) 

2534 

2535 def AND_ASSIGN(self): 

2536 return self.getToken(Python3Parser.AND_ASSIGN, 0) 

2537 

2538 def OR_ASSIGN(self): 

2539 return self.getToken(Python3Parser.OR_ASSIGN, 0) 

2540 

2541 def XOR_ASSIGN(self): 

2542 return self.getToken(Python3Parser.XOR_ASSIGN, 0) 

2543 

2544 def LEFT_SHIFT_ASSIGN(self): 

2545 return self.getToken(Python3Parser.LEFT_SHIFT_ASSIGN, 0) 

2546 

2547 def RIGHT_SHIFT_ASSIGN(self): 

2548 return self.getToken(Python3Parser.RIGHT_SHIFT_ASSIGN, 0) 

2549 

2550 def POWER_ASSIGN(self): 

2551 return self.getToken(Python3Parser.POWER_ASSIGN, 0) 

2552 

2553 def IDIV_ASSIGN(self): 

2554 return self.getToken(Python3Parser.IDIV_ASSIGN, 0) 

2555 

2556 def getRuleIndex(self): 

2557 return Python3Parser.RULE_augassign 

2558 

2559 def enterRule(self, listener:ParseTreeListener): 

2560 if hasattr( listener, "enterAugassign" ): 

2561 listener.enterAugassign(self) 

2562 

2563 def exitRule(self, listener:ParseTreeListener): 

2564 if hasattr( listener, "exitAugassign" ): 

2565 listener.exitAugassign(self) 

2566 

2567 

2568 

2569 

2570 def augassign(self): 

2571 

2572 localctx = Python3Parser.AugassignContext(self, self._ctx, self.state) 

2573 self.enterRule(localctx, 38, self.RULE_augassign) 

2574 self._la = 0 # Token type 

2575 try: 

2576 self.enterOuterAlt(localctx, 1) 

2577 self.state = 480 

2578 _la = self._input.LA(1) 

2579 if not(((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (Python3Parser.ADD_ASSIGN - 83)) | (1 << (Python3Parser.SUB_ASSIGN - 83)) | (1 << (Python3Parser.MULT_ASSIGN - 83)) | (1 << (Python3Parser.AT_ASSIGN - 83)) | (1 << (Python3Parser.DIV_ASSIGN - 83)) | (1 << (Python3Parser.MOD_ASSIGN - 83)) | (1 << (Python3Parser.AND_ASSIGN - 83)) | (1 << (Python3Parser.OR_ASSIGN - 83)) | (1 << (Python3Parser.XOR_ASSIGN - 83)) | (1 << (Python3Parser.LEFT_SHIFT_ASSIGN - 83)) | (1 << (Python3Parser.RIGHT_SHIFT_ASSIGN - 83)) | (1 << (Python3Parser.POWER_ASSIGN - 83)) | (1 << (Python3Parser.IDIV_ASSIGN - 83)))) != 0)): 

2580 self._errHandler.recoverInline(self) 

2581 else: 

2582 self._errHandler.reportMatch(self) 

2583 self.consume() 

2584 except RecognitionException as re: 

2585 localctx.exception = re 

2586 self._errHandler.reportError(self, re) 

2587 self._errHandler.recover(self, re) 

2588 finally: 

2589 self.exitRule() 

2590 return localctx 

2591 

2592 

2593 class Del_stmtContext(ParserRuleContext): 

2594 __slots__ = 'parser' 

2595 

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

2597 super().__init__(parent, invokingState) 

2598 self.parser = parser 

2599 

2600 def DEL(self): 

2601 return self.getToken(Python3Parser.DEL, 0) 

2602 

2603 def exprlist(self): 

2604 return self.getTypedRuleContext(Python3Parser.ExprlistContext,0) 

2605 

2606 

2607 def getRuleIndex(self): 

2608 return Python3Parser.RULE_del_stmt 

2609 

2610 def enterRule(self, listener:ParseTreeListener): 

2611 if hasattr( listener, "enterDel_stmt" ): 

2612 listener.enterDel_stmt(self) 

2613 

2614 def exitRule(self, listener:ParseTreeListener): 

2615 if hasattr( listener, "exitDel_stmt" ): 

2616 listener.exitDel_stmt(self) 

2617 

2618 

2619 

2620 

2621 def del_stmt(self): 

2622 

2623 localctx = Python3Parser.Del_stmtContext(self, self._ctx, self.state) 

2624 self.enterRule(localctx, 40, self.RULE_del_stmt) 

2625 try: 

2626 self.enterOuterAlt(localctx, 1) 

2627 self.state = 482 

2628 self.match(Python3Parser.DEL) 

2629 self.state = 483 

2630 self.exprlist() 

2631 except RecognitionException as re: 

2632 localctx.exception = re 

2633 self._errHandler.reportError(self, re) 

2634 self._errHandler.recover(self, re) 

2635 finally: 

2636 self.exitRule() 

2637 return localctx 

2638 

2639 

2640 class Pass_stmtContext(ParserRuleContext): 

2641 __slots__ = 'parser' 

2642 

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

2644 super().__init__(parent, invokingState) 

2645 self.parser = parser 

2646 

2647 def PASS(self): 

2648 return self.getToken(Python3Parser.PASS, 0) 

2649 

2650 def getRuleIndex(self): 

2651 return Python3Parser.RULE_pass_stmt 

2652 

2653 def enterRule(self, listener:ParseTreeListener): 

2654 if hasattr( listener, "enterPass_stmt" ): 

2655 listener.enterPass_stmt(self) 

2656 

2657 def exitRule(self, listener:ParseTreeListener): 

2658 if hasattr( listener, "exitPass_stmt" ): 

2659 listener.exitPass_stmt(self) 

2660 

2661 

2662 

2663 

2664 def pass_stmt(self): 

2665 

2666 localctx = Python3Parser.Pass_stmtContext(self, self._ctx, self.state) 

2667 self.enterRule(localctx, 42, self.RULE_pass_stmt) 

2668 try: 

2669 self.enterOuterAlt(localctx, 1) 

2670 self.state = 485 

2671 self.match(Python3Parser.PASS) 

2672 except RecognitionException as re: 

2673 localctx.exception = re 

2674 self._errHandler.reportError(self, re) 

2675 self._errHandler.recover(self, re) 

2676 finally: 

2677 self.exitRule() 

2678 return localctx 

2679 

2680 

2681 class Flow_stmtContext(ParserRuleContext): 

2682 __slots__ = 'parser' 

2683 

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

2685 super().__init__(parent, invokingState) 

2686 self.parser = parser 

2687 

2688 def break_stmt(self): 

2689 return self.getTypedRuleContext(Python3Parser.Break_stmtContext,0) 

2690 

2691 

2692 def continue_stmt(self): 

2693 return self.getTypedRuleContext(Python3Parser.Continue_stmtContext,0) 

2694 

2695 

2696 def return_stmt(self): 

2697 return self.getTypedRuleContext(Python3Parser.Return_stmtContext,0) 

2698 

2699 

2700 def raise_stmt(self): 

2701 return self.getTypedRuleContext(Python3Parser.Raise_stmtContext,0) 

2702 

2703 

2704 def yield_stmt(self): 

2705 return self.getTypedRuleContext(Python3Parser.Yield_stmtContext,0) 

2706 

2707 

2708 def getRuleIndex(self): 

2709 return Python3Parser.RULE_flow_stmt 

2710 

2711 def enterRule(self, listener:ParseTreeListener): 

2712 if hasattr( listener, "enterFlow_stmt" ): 

2713 listener.enterFlow_stmt(self) 

2714 

2715 def exitRule(self, listener:ParseTreeListener): 

2716 if hasattr( listener, "exitFlow_stmt" ): 

2717 listener.exitFlow_stmt(self) 

2718 

2719 

2720 

2721 

2722 def flow_stmt(self): 

2723 

2724 localctx = Python3Parser.Flow_stmtContext(self, self._ctx, self.state) 

2725 self.enterRule(localctx, 44, self.RULE_flow_stmt) 

2726 try: 

2727 self.state = 492 

2728 self._errHandler.sync(self) 

2729 token = self._input.LA(1) 

2730 if token in [Python3Parser.BREAK]: 

2731 self.enterOuterAlt(localctx, 1) 

2732 self.state = 487 

2733 self.break_stmt() 

2734 pass 

2735 elif token in [Python3Parser.CONTINUE]: 

2736 self.enterOuterAlt(localctx, 2) 

2737 self.state = 488 

2738 self.continue_stmt() 

2739 pass 

2740 elif token in [Python3Parser.RETURN]: 

2741 self.enterOuterAlt(localctx, 3) 

2742 self.state = 489 

2743 self.return_stmt() 

2744 pass 

2745 elif token in [Python3Parser.RAISE]: 

2746 self.enterOuterAlt(localctx, 4) 

2747 self.state = 490 

2748 self.raise_stmt() 

2749 pass 

2750 elif token in [Python3Parser.YIELD]: 

2751 self.enterOuterAlt(localctx, 5) 

2752 self.state = 491 

2753 self.yield_stmt() 

2754 pass 

2755 else: 

2756 raise NoViableAltException(self) 

2757 

2758 except RecognitionException as re: 

2759 localctx.exception = re 

2760 self._errHandler.reportError(self, re) 

2761 self._errHandler.recover(self, re) 

2762 finally: 

2763 self.exitRule() 

2764 return localctx 

2765 

2766 

2767 class Break_stmtContext(ParserRuleContext): 

2768 __slots__ = 'parser' 

2769 

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

2771 super().__init__(parent, invokingState) 

2772 self.parser = parser 

2773 

2774 def BREAK(self): 

2775 return self.getToken(Python3Parser.BREAK, 0) 

2776 

2777 def getRuleIndex(self): 

2778 return Python3Parser.RULE_break_stmt 

2779 

2780 def enterRule(self, listener:ParseTreeListener): 

2781 if hasattr( listener, "enterBreak_stmt" ): 

2782 listener.enterBreak_stmt(self) 

2783 

2784 def exitRule(self, listener:ParseTreeListener): 

2785 if hasattr( listener, "exitBreak_stmt" ): 

2786 listener.exitBreak_stmt(self) 

2787 

2788 

2789 

2790 

2791 def break_stmt(self): 

2792 

2793 localctx = Python3Parser.Break_stmtContext(self, self._ctx, self.state) 

2794 self.enterRule(localctx, 46, self.RULE_break_stmt) 

2795 try: 

2796 self.enterOuterAlt(localctx, 1) 

2797 self.state = 494 

2798 self.match(Python3Parser.BREAK) 

2799 except RecognitionException as re: 

2800 localctx.exception = re 

2801 self._errHandler.reportError(self, re) 

2802 self._errHandler.recover(self, re) 

2803 finally: 

2804 self.exitRule() 

2805 return localctx 

2806 

2807 

2808 class Continue_stmtContext(ParserRuleContext): 

2809 __slots__ = 'parser' 

2810 

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

2812 super().__init__(parent, invokingState) 

2813 self.parser = parser 

2814 

2815 def CONTINUE(self): 

2816 return self.getToken(Python3Parser.CONTINUE, 0) 

2817 

2818 def getRuleIndex(self): 

2819 return Python3Parser.RULE_continue_stmt 

2820 

2821 def enterRule(self, listener:ParseTreeListener): 

2822 if hasattr( listener, "enterContinue_stmt" ): 

2823 listener.enterContinue_stmt(self) 

2824 

2825 def exitRule(self, listener:ParseTreeListener): 

2826 if hasattr( listener, "exitContinue_stmt" ): 

2827 listener.exitContinue_stmt(self) 

2828 

2829 

2830 

2831 

2832 def continue_stmt(self): 

2833 

2834 localctx = Python3Parser.Continue_stmtContext(self, self._ctx, self.state) 

2835 self.enterRule(localctx, 48, self.RULE_continue_stmt) 

2836 try: 

2837 self.enterOuterAlt(localctx, 1) 

2838 self.state = 496 

2839 self.match(Python3Parser.CONTINUE) 

2840 except RecognitionException as re: 

2841 localctx.exception = re 

2842 self._errHandler.reportError(self, re) 

2843 self._errHandler.recover(self, re) 

2844 finally: 

2845 self.exitRule() 

2846 return localctx 

2847 

2848 

2849 class Return_stmtContext(ParserRuleContext): 

2850 __slots__ = 'parser' 

2851 

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

2853 super().__init__(parent, invokingState) 

2854 self.parser = parser 

2855 

2856 def RETURN(self): 

2857 return self.getToken(Python3Parser.RETURN, 0) 

2858 

2859 def testlist(self): 

2860 return self.getTypedRuleContext(Python3Parser.TestlistContext,0) 

2861 

2862 

2863 def getRuleIndex(self): 

2864 return Python3Parser.RULE_return_stmt 

2865 

2866 def enterRule(self, listener:ParseTreeListener): 

2867 if hasattr( listener, "enterReturn_stmt" ): 

2868 listener.enterReturn_stmt(self) 

2869 

2870 def exitRule(self, listener:ParseTreeListener): 

2871 if hasattr( listener, "exitReturn_stmt" ): 

2872 listener.exitReturn_stmt(self) 

2873 

2874 

2875 

2876 

2877 def return_stmt(self): 

2878 

2879 localctx = Python3Parser.Return_stmtContext(self, self._ctx, self.state) 

2880 self.enterRule(localctx, 50, self.RULE_return_stmt) 

2881 self._la = 0 # Token type 

2882 try: 

2883 self.enterOuterAlt(localctx, 1) 

2884 self.state = 498 

2885 self.match(Python3Parser.RETURN) 

2886 self.state = 500 

2887 self._errHandler.sync(self) 

2888 _la = self._input.LA(1) 

2889 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

2890 self.state = 499 

2891 self.testlist() 

2892 

2893 

2894 except RecognitionException as re: 

2895 localctx.exception = re 

2896 self._errHandler.reportError(self, re) 

2897 self._errHandler.recover(self, re) 

2898 finally: 

2899 self.exitRule() 

2900 return localctx 

2901 

2902 

2903 class Yield_stmtContext(ParserRuleContext): 

2904 __slots__ = 'parser' 

2905 

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

2907 super().__init__(parent, invokingState) 

2908 self.parser = parser 

2909 

2910 def yield_expr(self): 

2911 return self.getTypedRuleContext(Python3Parser.Yield_exprContext,0) 

2912 

2913 

2914 def getRuleIndex(self): 

2915 return Python3Parser.RULE_yield_stmt 

2916 

2917 def enterRule(self, listener:ParseTreeListener): 

2918 if hasattr( listener, "enterYield_stmt" ): 

2919 listener.enterYield_stmt(self) 

2920 

2921 def exitRule(self, listener:ParseTreeListener): 

2922 if hasattr( listener, "exitYield_stmt" ): 

2923 listener.exitYield_stmt(self) 

2924 

2925 

2926 

2927 

2928 def yield_stmt(self): 

2929 

2930 localctx = Python3Parser.Yield_stmtContext(self, self._ctx, self.state) 

2931 self.enterRule(localctx, 52, self.RULE_yield_stmt) 

2932 try: 

2933 self.enterOuterAlt(localctx, 1) 

2934 self.state = 502 

2935 self.yield_expr() 

2936 except RecognitionException as re: 

2937 localctx.exception = re 

2938 self._errHandler.reportError(self, re) 

2939 self._errHandler.recover(self, re) 

2940 finally: 

2941 self.exitRule() 

2942 return localctx 

2943 

2944 

2945 class Raise_stmtContext(ParserRuleContext): 

2946 __slots__ = 'parser' 

2947 

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

2949 super().__init__(parent, invokingState) 

2950 self.parser = parser 

2951 

2952 def RAISE(self): 

2953 return self.getToken(Python3Parser.RAISE, 0) 

2954 

2955 def test(self, i:int=None): 

2956 if i is None: 

2957 return self.getTypedRuleContexts(Python3Parser.TestContext) 

2958 else: 

2959 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

2960 

2961 

2962 def FROM(self): 

2963 return self.getToken(Python3Parser.FROM, 0) 

2964 

2965 def getRuleIndex(self): 

2966 return Python3Parser.RULE_raise_stmt 

2967 

2968 def enterRule(self, listener:ParseTreeListener): 

2969 if hasattr( listener, "enterRaise_stmt" ): 

2970 listener.enterRaise_stmt(self) 

2971 

2972 def exitRule(self, listener:ParseTreeListener): 

2973 if hasattr( listener, "exitRaise_stmt" ): 

2974 listener.exitRaise_stmt(self) 

2975 

2976 

2977 

2978 

2979 def raise_stmt(self): 

2980 

2981 localctx = Python3Parser.Raise_stmtContext(self, self._ctx, self.state) 

2982 self.enterRule(localctx, 54, self.RULE_raise_stmt) 

2983 self._la = 0 # Token type 

2984 try: 

2985 self.enterOuterAlt(localctx, 1) 

2986 self.state = 504 

2987 self.match(Python3Parser.RAISE) 

2988 self.state = 510 

2989 self._errHandler.sync(self) 

2990 _la = self._input.LA(1) 

2991 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

2992 self.state = 505 

2993 self.test() 

2994 self.state = 508 

2995 self._errHandler.sync(self) 

2996 _la = self._input.LA(1) 

2997 if _la==Python3Parser.FROM: 

2998 self.state = 506 

2999 self.match(Python3Parser.FROM) 

3000 self.state = 507 

3001 self.test() 

3002 

3003 

3004 

3005 

3006 except RecognitionException as re: 

3007 localctx.exception = re 

3008 self._errHandler.reportError(self, re) 

3009 self._errHandler.recover(self, re) 

3010 finally: 

3011 self.exitRule() 

3012 return localctx 

3013 

3014 

3015 class Import_stmtContext(ParserRuleContext): 

3016 __slots__ = 'parser' 

3017 

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

3019 super().__init__(parent, invokingState) 

3020 self.parser = parser 

3021 

3022 def import_name(self): 

3023 return self.getTypedRuleContext(Python3Parser.Import_nameContext,0) 

3024 

3025 

3026 def import_from(self): 

3027 return self.getTypedRuleContext(Python3Parser.Import_fromContext,0) 

3028 

3029 

3030 def getRuleIndex(self): 

3031 return Python3Parser.RULE_import_stmt 

3032 

3033 def enterRule(self, listener:ParseTreeListener): 

3034 if hasattr( listener, "enterImport_stmt" ): 

3035 listener.enterImport_stmt(self) 

3036 

3037 def exitRule(self, listener:ParseTreeListener): 

3038 if hasattr( listener, "exitImport_stmt" ): 

3039 listener.exitImport_stmt(self) 

3040 

3041 

3042 

3043 

3044 def import_stmt(self): 

3045 

3046 localctx = Python3Parser.Import_stmtContext(self, self._ctx, self.state) 

3047 self.enterRule(localctx, 56, self.RULE_import_stmt) 

3048 try: 

3049 self.state = 514 

3050 self._errHandler.sync(self) 

3051 token = self._input.LA(1) 

3052 if token in [Python3Parser.IMPORT]: 

3053 self.enterOuterAlt(localctx, 1) 

3054 self.state = 512 

3055 self.import_name() 

3056 pass 

3057 elif token in [Python3Parser.FROM]: 

3058 self.enterOuterAlt(localctx, 2) 

3059 self.state = 513 

3060 self.import_from() 

3061 pass 

3062 else: 

3063 raise NoViableAltException(self) 

3064 

3065 except RecognitionException as re: 

3066 localctx.exception = re 

3067 self._errHandler.reportError(self, re) 

3068 self._errHandler.recover(self, re) 

3069 finally: 

3070 self.exitRule() 

3071 return localctx 

3072 

3073 

3074 class Import_nameContext(ParserRuleContext): 

3075 __slots__ = 'parser' 

3076 

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

3078 super().__init__(parent, invokingState) 

3079 self.parser = parser 

3080 

3081 def IMPORT(self): 

3082 return self.getToken(Python3Parser.IMPORT, 0) 

3083 

3084 def dotted_as_names(self): 

3085 return self.getTypedRuleContext(Python3Parser.Dotted_as_namesContext,0) 

3086 

3087 

3088 def getRuleIndex(self): 

3089 return Python3Parser.RULE_import_name 

3090 

3091 def enterRule(self, listener:ParseTreeListener): 

3092 if hasattr( listener, "enterImport_name" ): 

3093 listener.enterImport_name(self) 

3094 

3095 def exitRule(self, listener:ParseTreeListener): 

3096 if hasattr( listener, "exitImport_name" ): 

3097 listener.exitImport_name(self) 

3098 

3099 

3100 

3101 

3102 def import_name(self): 

3103 

3104 localctx = Python3Parser.Import_nameContext(self, self._ctx, self.state) 

3105 self.enterRule(localctx, 58, self.RULE_import_name) 

3106 try: 

3107 self.enterOuterAlt(localctx, 1) 

3108 self.state = 516 

3109 self.match(Python3Parser.IMPORT) 

3110 self.state = 517 

3111 self.dotted_as_names() 

3112 except RecognitionException as re: 

3113 localctx.exception = re 

3114 self._errHandler.reportError(self, re) 

3115 self._errHandler.recover(self, re) 

3116 finally: 

3117 self.exitRule() 

3118 return localctx 

3119 

3120 

3121 class Import_fromContext(ParserRuleContext): 

3122 __slots__ = 'parser' 

3123 

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

3125 super().__init__(parent, invokingState) 

3126 self.parser = parser 

3127 

3128 def FROM(self): 

3129 return self.getToken(Python3Parser.FROM, 0) 

3130 

3131 def IMPORT(self): 

3132 return self.getToken(Python3Parser.IMPORT, 0) 

3133 

3134 def dotted_name(self): 

3135 return self.getTypedRuleContext(Python3Parser.Dotted_nameContext,0) 

3136 

3137 

3138 def STAR(self): 

3139 return self.getToken(Python3Parser.STAR, 0) 

3140 

3141 def OPEN_PAREN(self): 

3142 return self.getToken(Python3Parser.OPEN_PAREN, 0) 

3143 

3144 def import_as_names(self): 

3145 return self.getTypedRuleContext(Python3Parser.Import_as_namesContext,0) 

3146 

3147 

3148 def CLOSE_PAREN(self): 

3149 return self.getToken(Python3Parser.CLOSE_PAREN, 0) 

3150 

3151 def DOT(self, i:int=None): 

3152 if i is None: 

3153 return self.getTokens(Python3Parser.DOT) 

3154 else: 

3155 return self.getToken(Python3Parser.DOT, i) 

3156 

3157 def ELLIPSIS(self, i:int=None): 

3158 if i is None: 

3159 return self.getTokens(Python3Parser.ELLIPSIS) 

3160 else: 

3161 return self.getToken(Python3Parser.ELLIPSIS, i) 

3162 

3163 def getRuleIndex(self): 

3164 return Python3Parser.RULE_import_from 

3165 

3166 def enterRule(self, listener:ParseTreeListener): 

3167 if hasattr( listener, "enterImport_from" ): 

3168 listener.enterImport_from(self) 

3169 

3170 def exitRule(self, listener:ParseTreeListener): 

3171 if hasattr( listener, "exitImport_from" ): 

3172 listener.exitImport_from(self) 

3173 

3174 

3175 

3176 

3177 def import_from(self): 

3178 

3179 localctx = Python3Parser.Import_fromContext(self, self._ctx, self.state) 

3180 self.enterRule(localctx, 60, self.RULE_import_from) 

3181 self._la = 0 # Token type 

3182 try: 

3183 self.enterOuterAlt(localctx, 1) 

3184 self.state = 519 

3185 self.match(Python3Parser.FROM) 

3186 self.state = 532 

3187 self._errHandler.sync(self) 

3188 la_ = self._interp.adaptivePredict(self._input,71,self._ctx) 

3189 if la_ == 1: 

3190 self.state = 523 

3191 self._errHandler.sync(self) 

3192 _la = self._input.LA(1) 

3193 while _la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS: 

3194 self.state = 520 

3195 _la = self._input.LA(1) 

3196 if not(_la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS): 

3197 self._errHandler.recoverInline(self) 

3198 else: 

3199 self._errHandler.reportMatch(self) 

3200 self.consume() 

3201 self.state = 525 

3202 self._errHandler.sync(self) 

3203 _la = self._input.LA(1) 

3204 

3205 self.state = 526 

3206 self.dotted_name() 

3207 pass 

3208 

3209 elif la_ == 2: 

3210 self.state = 528 

3211 self._errHandler.sync(self) 

3212 _la = self._input.LA(1) 

3213 while True: 

3214 self.state = 527 

3215 _la = self._input.LA(1) 

3216 if not(_la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS): 

3217 self._errHandler.recoverInline(self) 

3218 else: 

3219 self._errHandler.reportMatch(self) 

3220 self.consume() 

3221 self.state = 530 

3222 self._errHandler.sync(self) 

3223 _la = self._input.LA(1) 

3224 if not (_la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS): 

3225 break 

3226 

3227 pass 

3228 

3229 

3230 self.state = 534 

3231 self.match(Python3Parser.IMPORT) 

3232 self.state = 541 

3233 self._errHandler.sync(self) 

3234 token = self._input.LA(1) 

3235 if token in [Python3Parser.STAR]: 

3236 self.state = 535 

3237 self.match(Python3Parser.STAR) 

3238 pass 

3239 elif token in [Python3Parser.OPEN_PAREN]: 

3240 self.state = 536 

3241 self.match(Python3Parser.OPEN_PAREN) 

3242 self.state = 537 

3243 self.import_as_names() 

3244 self.state = 538 

3245 self.match(Python3Parser.CLOSE_PAREN) 

3246 pass 

3247 elif token in [Python3Parser.NAME]: 

3248 self.state = 540 

3249 self.import_as_names() 

3250 pass 

3251 else: 

3252 raise NoViableAltException(self) 

3253 

3254 except RecognitionException as re: 

3255 localctx.exception = re 

3256 self._errHandler.reportError(self, re) 

3257 self._errHandler.recover(self, re) 

3258 finally: 

3259 self.exitRule() 

3260 return localctx 

3261 

3262 

3263 class Import_as_nameContext(ParserRuleContext): 

3264 __slots__ = 'parser' 

3265 

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

3267 super().__init__(parent, invokingState) 

3268 self.parser = parser 

3269 

3270 def NAME(self, i:int=None): 

3271 if i is None: 

3272 return self.getTokens(Python3Parser.NAME) 

3273 else: 

3274 return self.getToken(Python3Parser.NAME, i) 

3275 

3276 def AS(self): 

3277 return self.getToken(Python3Parser.AS, 0) 

3278 

3279 def getRuleIndex(self): 

3280 return Python3Parser.RULE_import_as_name 

3281 

3282 def enterRule(self, listener:ParseTreeListener): 

3283 if hasattr( listener, "enterImport_as_name" ): 

3284 listener.enterImport_as_name(self) 

3285 

3286 def exitRule(self, listener:ParseTreeListener): 

3287 if hasattr( listener, "exitImport_as_name" ): 

3288 listener.exitImport_as_name(self) 

3289 

3290 

3291 

3292 

3293 def import_as_name(self): 

3294 

3295 localctx = Python3Parser.Import_as_nameContext(self, self._ctx, self.state) 

3296 self.enterRule(localctx, 62, self.RULE_import_as_name) 

3297 self._la = 0 # Token type 

3298 try: 

3299 self.enterOuterAlt(localctx, 1) 

3300 self.state = 543 

3301 self.match(Python3Parser.NAME) 

3302 self.state = 546 

3303 self._errHandler.sync(self) 

3304 _la = self._input.LA(1) 

3305 if _la==Python3Parser.AS: 

3306 self.state = 544 

3307 self.match(Python3Parser.AS) 

3308 self.state = 545 

3309 self.match(Python3Parser.NAME) 

3310 

3311 

3312 except RecognitionException as re: 

3313 localctx.exception = re 

3314 self._errHandler.reportError(self, re) 

3315 self._errHandler.recover(self, re) 

3316 finally: 

3317 self.exitRule() 

3318 return localctx 

3319 

3320 

3321 class Dotted_as_nameContext(ParserRuleContext): 

3322 __slots__ = 'parser' 

3323 

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

3325 super().__init__(parent, invokingState) 

3326 self.parser = parser 

3327 

3328 def dotted_name(self): 

3329 return self.getTypedRuleContext(Python3Parser.Dotted_nameContext,0) 

3330 

3331 

3332 def AS(self): 

3333 return self.getToken(Python3Parser.AS, 0) 

3334 

3335 def NAME(self): 

3336 return self.getToken(Python3Parser.NAME, 0) 

3337 

3338 def getRuleIndex(self): 

3339 return Python3Parser.RULE_dotted_as_name 

3340 

3341 def enterRule(self, listener:ParseTreeListener): 

3342 if hasattr( listener, "enterDotted_as_name" ): 

3343 listener.enterDotted_as_name(self) 

3344 

3345 def exitRule(self, listener:ParseTreeListener): 

3346 if hasattr( listener, "exitDotted_as_name" ): 

3347 listener.exitDotted_as_name(self) 

3348 

3349 

3350 

3351 

3352 def dotted_as_name(self): 

3353 

3354 localctx = Python3Parser.Dotted_as_nameContext(self, self._ctx, self.state) 

3355 self.enterRule(localctx, 64, self.RULE_dotted_as_name) 

3356 self._la = 0 # Token type 

3357 try: 

3358 self.enterOuterAlt(localctx, 1) 

3359 self.state = 548 

3360 self.dotted_name() 

3361 self.state = 551 

3362 self._errHandler.sync(self) 

3363 _la = self._input.LA(1) 

3364 if _la==Python3Parser.AS: 

3365 self.state = 549 

3366 self.match(Python3Parser.AS) 

3367 self.state = 550 

3368 self.match(Python3Parser.NAME) 

3369 

3370 

3371 except RecognitionException as re: 

3372 localctx.exception = re 

3373 self._errHandler.reportError(self, re) 

3374 self._errHandler.recover(self, re) 

3375 finally: 

3376 self.exitRule() 

3377 return localctx 

3378 

3379 

3380 class Import_as_namesContext(ParserRuleContext): 

3381 __slots__ = 'parser' 

3382 

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

3384 super().__init__(parent, invokingState) 

3385 self.parser = parser 

3386 

3387 def import_as_name(self, i:int=None): 

3388 if i is None: 

3389 return self.getTypedRuleContexts(Python3Parser.Import_as_nameContext) 

3390 else: 

3391 return self.getTypedRuleContext(Python3Parser.Import_as_nameContext,i) 

3392 

3393 

3394 def COMMA(self, i:int=None): 

3395 if i is None: 

3396 return self.getTokens(Python3Parser.COMMA) 

3397 else: 

3398 return self.getToken(Python3Parser.COMMA, i) 

3399 

3400 def getRuleIndex(self): 

3401 return Python3Parser.RULE_import_as_names 

3402 

3403 def enterRule(self, listener:ParseTreeListener): 

3404 if hasattr( listener, "enterImport_as_names" ): 

3405 listener.enterImport_as_names(self) 

3406 

3407 def exitRule(self, listener:ParseTreeListener): 

3408 if hasattr( listener, "exitImport_as_names" ): 

3409 listener.exitImport_as_names(self) 

3410 

3411 

3412 

3413 

3414 def import_as_names(self): 

3415 

3416 localctx = Python3Parser.Import_as_namesContext(self, self._ctx, self.state) 

3417 self.enterRule(localctx, 66, self.RULE_import_as_names) 

3418 self._la = 0 # Token type 

3419 try: 

3420 self.enterOuterAlt(localctx, 1) 

3421 self.state = 553 

3422 self.import_as_name() 

3423 self.state = 558 

3424 self._errHandler.sync(self) 

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

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

3427 if _alt==1: 

3428 self.state = 554 

3429 self.match(Python3Parser.COMMA) 

3430 self.state = 555 

3431 self.import_as_name() 

3432 self.state = 560 

3433 self._errHandler.sync(self) 

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

3435 

3436 self.state = 562 

3437 self._errHandler.sync(self) 

3438 _la = self._input.LA(1) 

3439 if _la==Python3Parser.COMMA: 

3440 self.state = 561 

3441 self.match(Python3Parser.COMMA) 

3442 

3443 

3444 except RecognitionException as re: 

3445 localctx.exception = re 

3446 self._errHandler.reportError(self, re) 

3447 self._errHandler.recover(self, re) 

3448 finally: 

3449 self.exitRule() 

3450 return localctx 

3451 

3452 

3453 class Dotted_as_namesContext(ParserRuleContext): 

3454 __slots__ = 'parser' 

3455 

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

3457 super().__init__(parent, invokingState) 

3458 self.parser = parser 

3459 

3460 def dotted_as_name(self, i:int=None): 

3461 if i is None: 

3462 return self.getTypedRuleContexts(Python3Parser.Dotted_as_nameContext) 

3463 else: 

3464 return self.getTypedRuleContext(Python3Parser.Dotted_as_nameContext,i) 

3465 

3466 

3467 def COMMA(self, i:int=None): 

3468 if i is None: 

3469 return self.getTokens(Python3Parser.COMMA) 

3470 else: 

3471 return self.getToken(Python3Parser.COMMA, i) 

3472 

3473 def getRuleIndex(self): 

3474 return Python3Parser.RULE_dotted_as_names 

3475 

3476 def enterRule(self, listener:ParseTreeListener): 

3477 if hasattr( listener, "enterDotted_as_names" ): 

3478 listener.enterDotted_as_names(self) 

3479 

3480 def exitRule(self, listener:ParseTreeListener): 

3481 if hasattr( listener, "exitDotted_as_names" ): 

3482 listener.exitDotted_as_names(self) 

3483 

3484 

3485 

3486 

3487 def dotted_as_names(self): 

3488 

3489 localctx = Python3Parser.Dotted_as_namesContext(self, self._ctx, self.state) 

3490 self.enterRule(localctx, 68, self.RULE_dotted_as_names) 

3491 self._la = 0 # Token type 

3492 try: 

3493 self.enterOuterAlt(localctx, 1) 

3494 self.state = 564 

3495 self.dotted_as_name() 

3496 self.state = 569 

3497 self._errHandler.sync(self) 

3498 _la = self._input.LA(1) 

3499 while _la==Python3Parser.COMMA: 

3500 self.state = 565 

3501 self.match(Python3Parser.COMMA) 

3502 self.state = 566 

3503 self.dotted_as_name() 

3504 self.state = 571 

3505 self._errHandler.sync(self) 

3506 _la = self._input.LA(1) 

3507 

3508 except RecognitionException as re: 

3509 localctx.exception = re 

3510 self._errHandler.reportError(self, re) 

3511 self._errHandler.recover(self, re) 

3512 finally: 

3513 self.exitRule() 

3514 return localctx 

3515 

3516 

3517 class Dotted_nameContext(ParserRuleContext): 

3518 __slots__ = 'parser' 

3519 

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

3521 super().__init__(parent, invokingState) 

3522 self.parser = parser 

3523 

3524 def NAME(self, i:int=None): 

3525 if i is None: 

3526 return self.getTokens(Python3Parser.NAME) 

3527 else: 

3528 return self.getToken(Python3Parser.NAME, i) 

3529 

3530 def DOT(self, i:int=None): 

3531 if i is None: 

3532 return self.getTokens(Python3Parser.DOT) 

3533 else: 

3534 return self.getToken(Python3Parser.DOT, i) 

3535 

3536 def getRuleIndex(self): 

3537 return Python3Parser.RULE_dotted_name 

3538 

3539 def enterRule(self, listener:ParseTreeListener): 

3540 if hasattr( listener, "enterDotted_name" ): 

3541 listener.enterDotted_name(self) 

3542 

3543 def exitRule(self, listener:ParseTreeListener): 

3544 if hasattr( listener, "exitDotted_name" ): 

3545 listener.exitDotted_name(self) 

3546 

3547 

3548 

3549 

3550 def dotted_name(self): 

3551 

3552 localctx = Python3Parser.Dotted_nameContext(self, self._ctx, self.state) 

3553 self.enterRule(localctx, 70, self.RULE_dotted_name) 

3554 self._la = 0 # Token type 

3555 try: 

3556 self.enterOuterAlt(localctx, 1) 

3557 self.state = 572 

3558 self.match(Python3Parser.NAME) 

3559 self.state = 577 

3560 self._errHandler.sync(self) 

3561 _la = self._input.LA(1) 

3562 while _la==Python3Parser.DOT: 

3563 self.state = 573 

3564 self.match(Python3Parser.DOT) 

3565 self.state = 574 

3566 self.match(Python3Parser.NAME) 

3567 self.state = 579 

3568 self._errHandler.sync(self) 

3569 _la = self._input.LA(1) 

3570 

3571 except RecognitionException as re: 

3572 localctx.exception = re 

3573 self._errHandler.reportError(self, re) 

3574 self._errHandler.recover(self, re) 

3575 finally: 

3576 self.exitRule() 

3577 return localctx 

3578 

3579 

3580 class Global_stmtContext(ParserRuleContext): 

3581 __slots__ = 'parser' 

3582 

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

3584 super().__init__(parent, invokingState) 

3585 self.parser = parser 

3586 

3587 def GLOBAL(self): 

3588 return self.getToken(Python3Parser.GLOBAL, 0) 

3589 

3590 def NAME(self, i:int=None): 

3591 if i is None: 

3592 return self.getTokens(Python3Parser.NAME) 

3593 else: 

3594 return self.getToken(Python3Parser.NAME, i) 

3595 

3596 def COMMA(self, i:int=None): 

3597 if i is None: 

3598 return self.getTokens(Python3Parser.COMMA) 

3599 else: 

3600 return self.getToken(Python3Parser.COMMA, i) 

3601 

3602 def getRuleIndex(self): 

3603 return Python3Parser.RULE_global_stmt 

3604 

3605 def enterRule(self, listener:ParseTreeListener): 

3606 if hasattr( listener, "enterGlobal_stmt" ): 

3607 listener.enterGlobal_stmt(self) 

3608 

3609 def exitRule(self, listener:ParseTreeListener): 

3610 if hasattr( listener, "exitGlobal_stmt" ): 

3611 listener.exitGlobal_stmt(self) 

3612 

3613 

3614 

3615 

3616 def global_stmt(self): 

3617 

3618 localctx = Python3Parser.Global_stmtContext(self, self._ctx, self.state) 

3619 self.enterRule(localctx, 72, self.RULE_global_stmt) 

3620 self._la = 0 # Token type 

3621 try: 

3622 self.enterOuterAlt(localctx, 1) 

3623 self.state = 580 

3624 self.match(Python3Parser.GLOBAL) 

3625 self.state = 581 

3626 self.match(Python3Parser.NAME) 

3627 self.state = 586 

3628 self._errHandler.sync(self) 

3629 _la = self._input.LA(1) 

3630 while _la==Python3Parser.COMMA: 

3631 self.state = 582 

3632 self.match(Python3Parser.COMMA) 

3633 self.state = 583 

3634 self.match(Python3Parser.NAME) 

3635 self.state = 588 

3636 self._errHandler.sync(self) 

3637 _la = self._input.LA(1) 

3638 

3639 except RecognitionException as re: 

3640 localctx.exception = re 

3641 self._errHandler.reportError(self, re) 

3642 self._errHandler.recover(self, re) 

3643 finally: 

3644 self.exitRule() 

3645 return localctx 

3646 

3647 

3648 class Nonlocal_stmtContext(ParserRuleContext): 

3649 __slots__ = 'parser' 

3650 

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

3652 super().__init__(parent, invokingState) 

3653 self.parser = parser 

3654 

3655 def NONLOCAL(self): 

3656 return self.getToken(Python3Parser.NONLOCAL, 0) 

3657 

3658 def NAME(self, i:int=None): 

3659 if i is None: 

3660 return self.getTokens(Python3Parser.NAME) 

3661 else: 

3662 return self.getToken(Python3Parser.NAME, i) 

3663 

3664 def COMMA(self, i:int=None): 

3665 if i is None: 

3666 return self.getTokens(Python3Parser.COMMA) 

3667 else: 

3668 return self.getToken(Python3Parser.COMMA, i) 

3669 

3670 def getRuleIndex(self): 

3671 return Python3Parser.RULE_nonlocal_stmt 

3672 

3673 def enterRule(self, listener:ParseTreeListener): 

3674 if hasattr( listener, "enterNonlocal_stmt" ): 

3675 listener.enterNonlocal_stmt(self) 

3676 

3677 def exitRule(self, listener:ParseTreeListener): 

3678 if hasattr( listener, "exitNonlocal_stmt" ): 

3679 listener.exitNonlocal_stmt(self) 

3680 

3681 

3682 

3683 

3684 def nonlocal_stmt(self): 

3685 

3686 localctx = Python3Parser.Nonlocal_stmtContext(self, self._ctx, self.state) 

3687 self.enterRule(localctx, 74, self.RULE_nonlocal_stmt) 

3688 self._la = 0 # Token type 

3689 try: 

3690 self.enterOuterAlt(localctx, 1) 

3691 self.state = 589 

3692 self.match(Python3Parser.NONLOCAL) 

3693 self.state = 590 

3694 self.match(Python3Parser.NAME) 

3695 self.state = 595 

3696 self._errHandler.sync(self) 

3697 _la = self._input.LA(1) 

3698 while _la==Python3Parser.COMMA: 

3699 self.state = 591 

3700 self.match(Python3Parser.COMMA) 

3701 self.state = 592 

3702 self.match(Python3Parser.NAME) 

3703 self.state = 597 

3704 self._errHandler.sync(self) 

3705 _la = self._input.LA(1) 

3706 

3707 except RecognitionException as re: 

3708 localctx.exception = re 

3709 self._errHandler.reportError(self, re) 

3710 self._errHandler.recover(self, re) 

3711 finally: 

3712 self.exitRule() 

3713 return localctx 

3714 

3715 

3716 class Assert_stmtContext(ParserRuleContext): 

3717 __slots__ = 'parser' 

3718 

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

3720 super().__init__(parent, invokingState) 

3721 self.parser = parser 

3722 

3723 def ASSERT(self): 

3724 return self.getToken(Python3Parser.ASSERT, 0) 

3725 

3726 def test(self, i:int=None): 

3727 if i is None: 

3728 return self.getTypedRuleContexts(Python3Parser.TestContext) 

3729 else: 

3730 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

3731 

3732 

3733 def COMMA(self): 

3734 return self.getToken(Python3Parser.COMMA, 0) 

3735 

3736 def getRuleIndex(self): 

3737 return Python3Parser.RULE_assert_stmt 

3738 

3739 def enterRule(self, listener:ParseTreeListener): 

3740 if hasattr( listener, "enterAssert_stmt" ): 

3741 listener.enterAssert_stmt(self) 

3742 

3743 def exitRule(self, listener:ParseTreeListener): 

3744 if hasattr( listener, "exitAssert_stmt" ): 

3745 listener.exitAssert_stmt(self) 

3746 

3747 

3748 

3749 

3750 def assert_stmt(self): 

3751 

3752 localctx = Python3Parser.Assert_stmtContext(self, self._ctx, self.state) 

3753 self.enterRule(localctx, 76, self.RULE_assert_stmt) 

3754 self._la = 0 # Token type 

3755 try: 

3756 self.enterOuterAlt(localctx, 1) 

3757 self.state = 598 

3758 self.match(Python3Parser.ASSERT) 

3759 self.state = 599 

3760 self.test() 

3761 self.state = 602 

3762 self._errHandler.sync(self) 

3763 _la = self._input.LA(1) 

3764 if _la==Python3Parser.COMMA: 

3765 self.state = 600 

3766 self.match(Python3Parser.COMMA) 

3767 self.state = 601 

3768 self.test() 

3769 

3770 

3771 except RecognitionException as re: 

3772 localctx.exception = re 

3773 self._errHandler.reportError(self, re) 

3774 self._errHandler.recover(self, re) 

3775 finally: 

3776 self.exitRule() 

3777 return localctx 

3778 

3779 

3780 class Compound_stmtContext(ParserRuleContext): 

3781 __slots__ = 'parser' 

3782 

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

3784 super().__init__(parent, invokingState) 

3785 self.parser = parser 

3786 

3787 def if_stmt(self): 

3788 return self.getTypedRuleContext(Python3Parser.If_stmtContext,0) 

3789 

3790 

3791 def while_stmt(self): 

3792 return self.getTypedRuleContext(Python3Parser.While_stmtContext,0) 

3793 

3794 

3795 def for_stmt(self): 

3796 return self.getTypedRuleContext(Python3Parser.For_stmtContext,0) 

3797 

3798 

3799 def try_stmt(self): 

3800 return self.getTypedRuleContext(Python3Parser.Try_stmtContext,0) 

3801 

3802 

3803 def with_stmt(self): 

3804 return self.getTypedRuleContext(Python3Parser.With_stmtContext,0) 

3805 

3806 

3807 def funcdef(self): 

3808 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0) 

3809 

3810 

3811 def classdef(self): 

3812 return self.getTypedRuleContext(Python3Parser.ClassdefContext,0) 

3813 

3814 

3815 def decorated(self): 

3816 return self.getTypedRuleContext(Python3Parser.DecoratedContext,0) 

3817 

3818 

3819 def async_stmt(self): 

3820 return self.getTypedRuleContext(Python3Parser.Async_stmtContext,0) 

3821 

3822 

3823 def getRuleIndex(self): 

3824 return Python3Parser.RULE_compound_stmt 

3825 

3826 def enterRule(self, listener:ParseTreeListener): 

3827 if hasattr( listener, "enterCompound_stmt" ): 

3828 listener.enterCompound_stmt(self) 

3829 

3830 def exitRule(self, listener:ParseTreeListener): 

3831 if hasattr( listener, "exitCompound_stmt" ): 

3832 listener.exitCompound_stmt(self) 

3833 

3834 

3835 

3836 

3837 def compound_stmt(self): 

3838 

3839 localctx = Python3Parser.Compound_stmtContext(self, self._ctx, self.state) 

3840 self.enterRule(localctx, 78, self.RULE_compound_stmt) 

3841 try: 

3842 self.state = 613 

3843 self._errHandler.sync(self) 

3844 token = self._input.LA(1) 

3845 if token in [Python3Parser.IF]: 

3846 self.enterOuterAlt(localctx, 1) 

3847 self.state = 604 

3848 self.if_stmt() 

3849 pass 

3850 elif token in [Python3Parser.WHILE]: 

3851 self.enterOuterAlt(localctx, 2) 

3852 self.state = 605 

3853 self.while_stmt() 

3854 pass 

3855 elif token in [Python3Parser.FOR]: 

3856 self.enterOuterAlt(localctx, 3) 

3857 self.state = 606 

3858 self.for_stmt() 

3859 pass 

3860 elif token in [Python3Parser.TRY]: 

3861 self.enterOuterAlt(localctx, 4) 

3862 self.state = 607 

3863 self.try_stmt() 

3864 pass 

3865 elif token in [Python3Parser.WITH]: 

3866 self.enterOuterAlt(localctx, 5) 

3867 self.state = 608 

3868 self.with_stmt() 

3869 pass 

3870 elif token in [Python3Parser.DEF]: 

3871 self.enterOuterAlt(localctx, 6) 

3872 self.state = 609 

3873 self.funcdef() 

3874 pass 

3875 elif token in [Python3Parser.CLASS]: 

3876 self.enterOuterAlt(localctx, 7) 

3877 self.state = 610 

3878 self.classdef() 

3879 pass 

3880 elif token in [Python3Parser.AT]: 

3881 self.enterOuterAlt(localctx, 8) 

3882 self.state = 611 

3883 self.decorated() 

3884 pass 

3885 elif token in [Python3Parser.ASYNC]: 

3886 self.enterOuterAlt(localctx, 9) 

3887 self.state = 612 

3888 self.async_stmt() 

3889 pass 

3890 else: 

3891 raise NoViableAltException(self) 

3892 

3893 except RecognitionException as re: 

3894 localctx.exception = re 

3895 self._errHandler.reportError(self, re) 

3896 self._errHandler.recover(self, re) 

3897 finally: 

3898 self.exitRule() 

3899 return localctx 

3900 

3901 

3902 class Async_stmtContext(ParserRuleContext): 

3903 __slots__ = 'parser' 

3904 

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

3906 super().__init__(parent, invokingState) 

3907 self.parser = parser 

3908 

3909 def ASYNC(self): 

3910 return self.getToken(Python3Parser.ASYNC, 0) 

3911 

3912 def funcdef(self): 

3913 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0) 

3914 

3915 

3916 def with_stmt(self): 

3917 return self.getTypedRuleContext(Python3Parser.With_stmtContext,0) 

3918 

3919 

3920 def for_stmt(self): 

3921 return self.getTypedRuleContext(Python3Parser.For_stmtContext,0) 

3922 

3923 

3924 def getRuleIndex(self): 

3925 return Python3Parser.RULE_async_stmt 

3926 

3927 def enterRule(self, listener:ParseTreeListener): 

3928 if hasattr( listener, "enterAsync_stmt" ): 

3929 listener.enterAsync_stmt(self) 

3930 

3931 def exitRule(self, listener:ParseTreeListener): 

3932 if hasattr( listener, "exitAsync_stmt" ): 

3933 listener.exitAsync_stmt(self) 

3934 

3935 

3936 

3937 

3938 def async_stmt(self): 

3939 

3940 localctx = Python3Parser.Async_stmtContext(self, self._ctx, self.state) 

3941 self.enterRule(localctx, 80, self.RULE_async_stmt) 

3942 try: 

3943 self.enterOuterAlt(localctx, 1) 

3944 self.state = 615 

3945 self.match(Python3Parser.ASYNC) 

3946 self.state = 619 

3947 self._errHandler.sync(self) 

3948 token = self._input.LA(1) 

3949 if token in [Python3Parser.DEF]: 

3950 self.state = 616 

3951 self.funcdef() 

3952 pass 

3953 elif token in [Python3Parser.WITH]: 

3954 self.state = 617 

3955 self.with_stmt() 

3956 pass 

3957 elif token in [Python3Parser.FOR]: 

3958 self.state = 618 

3959 self.for_stmt() 

3960 pass 

3961 else: 

3962 raise NoViableAltException(self) 

3963 

3964 except RecognitionException as re: 

3965 localctx.exception = re 

3966 self._errHandler.reportError(self, re) 

3967 self._errHandler.recover(self, re) 

3968 finally: 

3969 self.exitRule() 

3970 return localctx 

3971 

3972 

3973 class If_stmtContext(ParserRuleContext): 

3974 __slots__ = 'parser' 

3975 

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

3977 super().__init__(parent, invokingState) 

3978 self.parser = parser 

3979 

3980 def IF(self): 

3981 return self.getToken(Python3Parser.IF, 0) 

3982 

3983 def test(self, i:int=None): 

3984 if i is None: 

3985 return self.getTypedRuleContexts(Python3Parser.TestContext) 

3986 else: 

3987 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

3988 

3989 

3990 def COLON(self, i:int=None): 

3991 if i is None: 

3992 return self.getTokens(Python3Parser.COLON) 

3993 else: 

3994 return self.getToken(Python3Parser.COLON, i) 

3995 

3996 def suite(self, i:int=None): 

3997 if i is None: 

3998 return self.getTypedRuleContexts(Python3Parser.SuiteContext) 

3999 else: 

4000 return self.getTypedRuleContext(Python3Parser.SuiteContext,i) 

4001 

4002 

4003 def ELIF(self, i:int=None): 

4004 if i is None: 

4005 return self.getTokens(Python3Parser.ELIF) 

4006 else: 

4007 return self.getToken(Python3Parser.ELIF, i) 

4008 

4009 def ELSE(self): 

4010 return self.getToken(Python3Parser.ELSE, 0) 

4011 

4012 def getRuleIndex(self): 

4013 return Python3Parser.RULE_if_stmt 

4014 

4015 def enterRule(self, listener:ParseTreeListener): 

4016 if hasattr( listener, "enterIf_stmt" ): 

4017 listener.enterIf_stmt(self) 

4018 

4019 def exitRule(self, listener:ParseTreeListener): 

4020 if hasattr( listener, "exitIf_stmt" ): 

4021 listener.exitIf_stmt(self) 

4022 

4023 

4024 

4025 

4026 def if_stmt(self): 

4027 

4028 localctx = Python3Parser.If_stmtContext(self, self._ctx, self.state) 

4029 self.enterRule(localctx, 82, self.RULE_if_stmt) 

4030 self._la = 0 # Token type 

4031 try: 

4032 self.enterOuterAlt(localctx, 1) 

4033 self.state = 621 

4034 self.match(Python3Parser.IF) 

4035 self.state = 622 

4036 self.test() 

4037 self.state = 623 

4038 self.match(Python3Parser.COLON) 

4039 self.state = 624 

4040 self.suite() 

4041 self.state = 632 

4042 self._errHandler.sync(self) 

4043 _la = self._input.LA(1) 

4044 while _la==Python3Parser.ELIF: 

4045 self.state = 625 

4046 self.match(Python3Parser.ELIF) 

4047 self.state = 626 

4048 self.test() 

4049 self.state = 627 

4050 self.match(Python3Parser.COLON) 

4051 self.state = 628 

4052 self.suite() 

4053 self.state = 634 

4054 self._errHandler.sync(self) 

4055 _la = self._input.LA(1) 

4056 

4057 self.state = 638 

4058 self._errHandler.sync(self) 

4059 _la = self._input.LA(1) 

4060 if _la==Python3Parser.ELSE: 

4061 self.state = 635 

4062 self.match(Python3Parser.ELSE) 

4063 self.state = 636 

4064 self.match(Python3Parser.COLON) 

4065 self.state = 637 

4066 self.suite() 

4067 

4068 

4069 except RecognitionException as re: 

4070 localctx.exception = re 

4071 self._errHandler.reportError(self, re) 

4072 self._errHandler.recover(self, re) 

4073 finally: 

4074 self.exitRule() 

4075 return localctx 

4076 

4077 

4078 class While_stmtContext(ParserRuleContext): 

4079 __slots__ = 'parser' 

4080 

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

4082 super().__init__(parent, invokingState) 

4083 self.parser = parser 

4084 

4085 def WHILE(self): 

4086 return self.getToken(Python3Parser.WHILE, 0) 

4087 

4088 def test(self): 

4089 return self.getTypedRuleContext(Python3Parser.TestContext,0) 

4090 

4091 

4092 def COLON(self, i:int=None): 

4093 if i is None: 

4094 return self.getTokens(Python3Parser.COLON) 

4095 else: 

4096 return self.getToken(Python3Parser.COLON, i) 

4097 

4098 def suite(self, i:int=None): 

4099 if i is None: 

4100 return self.getTypedRuleContexts(Python3Parser.SuiteContext) 

4101 else: 

4102 return self.getTypedRuleContext(Python3Parser.SuiteContext,i) 

4103 

4104 

4105 def ELSE(self): 

4106 return self.getToken(Python3Parser.ELSE, 0) 

4107 

4108 def getRuleIndex(self): 

4109 return Python3Parser.RULE_while_stmt 

4110 

4111 def enterRule(self, listener:ParseTreeListener): 

4112 if hasattr( listener, "enterWhile_stmt" ): 

4113 listener.enterWhile_stmt(self) 

4114 

4115 def exitRule(self, listener:ParseTreeListener): 

4116 if hasattr( listener, "exitWhile_stmt" ): 

4117 listener.exitWhile_stmt(self) 

4118 

4119 

4120 

4121 

4122 def while_stmt(self): 

4123 

4124 localctx = Python3Parser.While_stmtContext(self, self._ctx, self.state) 

4125 self.enterRule(localctx, 84, self.RULE_while_stmt) 

4126 self._la = 0 # Token type 

4127 try: 

4128 self.enterOuterAlt(localctx, 1) 

4129 self.state = 640 

4130 self.match(Python3Parser.WHILE) 

4131 self.state = 641 

4132 self.test() 

4133 self.state = 642 

4134 self.match(Python3Parser.COLON) 

4135 self.state = 643 

4136 self.suite() 

4137 self.state = 647 

4138 self._errHandler.sync(self) 

4139 _la = self._input.LA(1) 

4140 if _la==Python3Parser.ELSE: 

4141 self.state = 644 

4142 self.match(Python3Parser.ELSE) 

4143 self.state = 645 

4144 self.match(Python3Parser.COLON) 

4145 self.state = 646 

4146 self.suite() 

4147 

4148 

4149 except RecognitionException as re: 

4150 localctx.exception = re 

4151 self._errHandler.reportError(self, re) 

4152 self._errHandler.recover(self, re) 

4153 finally: 

4154 self.exitRule() 

4155 return localctx 

4156 

4157 

4158 class For_stmtContext(ParserRuleContext): 

4159 __slots__ = 'parser' 

4160 

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

4162 super().__init__(parent, invokingState) 

4163 self.parser = parser 

4164 

4165 def FOR(self): 

4166 return self.getToken(Python3Parser.FOR, 0) 

4167 

4168 def exprlist(self): 

4169 return self.getTypedRuleContext(Python3Parser.ExprlistContext,0) 

4170 

4171 

4172 def IN(self): 

4173 return self.getToken(Python3Parser.IN, 0) 

4174 

4175 def testlist(self): 

4176 return self.getTypedRuleContext(Python3Parser.TestlistContext,0) 

4177 

4178 

4179 def COLON(self, i:int=None): 

4180 if i is None: 

4181 return self.getTokens(Python3Parser.COLON) 

4182 else: 

4183 return self.getToken(Python3Parser.COLON, i) 

4184 

4185 def suite(self, i:int=None): 

4186 if i is None: 

4187 return self.getTypedRuleContexts(Python3Parser.SuiteContext) 

4188 else: 

4189 return self.getTypedRuleContext(Python3Parser.SuiteContext,i) 

4190 

4191 

4192 def ELSE(self): 

4193 return self.getToken(Python3Parser.ELSE, 0) 

4194 

4195 def getRuleIndex(self): 

4196 return Python3Parser.RULE_for_stmt 

4197 

4198 def enterRule(self, listener:ParseTreeListener): 

4199 if hasattr( listener, "enterFor_stmt" ): 

4200 listener.enterFor_stmt(self) 

4201 

4202 def exitRule(self, listener:ParseTreeListener): 

4203 if hasattr( listener, "exitFor_stmt" ): 

4204 listener.exitFor_stmt(self) 

4205 

4206 

4207 

4208 

4209 def for_stmt(self): 

4210 

4211 localctx = Python3Parser.For_stmtContext(self, self._ctx, self.state) 

4212 self.enterRule(localctx, 86, self.RULE_for_stmt) 

4213 self._la = 0 # Token type 

4214 try: 

4215 self.enterOuterAlt(localctx, 1) 

4216 self.state = 649 

4217 self.match(Python3Parser.FOR) 

4218 self.state = 650 

4219 self.exprlist() 

4220 self.state = 651 

4221 self.match(Python3Parser.IN) 

4222 self.state = 652 

4223 self.testlist() 

4224 self.state = 653 

4225 self.match(Python3Parser.COLON) 

4226 self.state = 654 

4227 self.suite() 

4228 self.state = 658 

4229 self._errHandler.sync(self) 

4230 _la = self._input.LA(1) 

4231 if _la==Python3Parser.ELSE: 

4232 self.state = 655 

4233 self.match(Python3Parser.ELSE) 

4234 self.state = 656 

4235 self.match(Python3Parser.COLON) 

4236 self.state = 657 

4237 self.suite() 

4238 

4239 

4240 except RecognitionException as re: 

4241 localctx.exception = re 

4242 self._errHandler.reportError(self, re) 

4243 self._errHandler.recover(self, re) 

4244 finally: 

4245 self.exitRule() 

4246 return localctx 

4247 

4248 

4249 class Try_stmtContext(ParserRuleContext): 

4250 __slots__ = 'parser' 

4251 

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

4253 super().__init__(parent, invokingState) 

4254 self.parser = parser 

4255 

4256 def TRY(self): 

4257 return self.getToken(Python3Parser.TRY, 0) 

4258 

4259 def COLON(self, i:int=None): 

4260 if i is None: 

4261 return self.getTokens(Python3Parser.COLON) 

4262 else: 

4263 return self.getToken(Python3Parser.COLON, i) 

4264 

4265 def suite(self, i:int=None): 

4266 if i is None: 

4267 return self.getTypedRuleContexts(Python3Parser.SuiteContext) 

4268 else: 

4269 return self.getTypedRuleContext(Python3Parser.SuiteContext,i) 

4270 

4271 

4272 def FINALLY(self): 

4273 return self.getToken(Python3Parser.FINALLY, 0) 

4274 

4275 def except_clause(self, i:int=None): 

4276 if i is None: 

4277 return self.getTypedRuleContexts(Python3Parser.Except_clauseContext) 

4278 else: 

4279 return self.getTypedRuleContext(Python3Parser.Except_clauseContext,i) 

4280 

4281 

4282 def ELSE(self): 

4283 return self.getToken(Python3Parser.ELSE, 0) 

4284 

4285 def getRuleIndex(self): 

4286 return Python3Parser.RULE_try_stmt 

4287 

4288 def enterRule(self, listener:ParseTreeListener): 

4289 if hasattr( listener, "enterTry_stmt" ): 

4290 listener.enterTry_stmt(self) 

4291 

4292 def exitRule(self, listener:ParseTreeListener): 

4293 if hasattr( listener, "exitTry_stmt" ): 

4294 listener.exitTry_stmt(self) 

4295 

4296 

4297 

4298 

4299 def try_stmt(self): 

4300 

4301 localctx = Python3Parser.Try_stmtContext(self, self._ctx, self.state) 

4302 self.enterRule(localctx, 88, self.RULE_try_stmt) 

4303 self._la = 0 # Token type 

4304 try: 

4305 self.enterOuterAlt(localctx, 1) 

4306 self.state = 660 

4307 self.match(Python3Parser.TRY) 

4308 self.state = 661 

4309 self.match(Python3Parser.COLON) 

4310 self.state = 662 

4311 self.suite() 

4312 self.state = 684 

4313 self._errHandler.sync(self) 

4314 token = self._input.LA(1) 

4315 if token in [Python3Parser.EXCEPT]: 

4316 self.state = 667 

4317 self._errHandler.sync(self) 

4318 _la = self._input.LA(1) 

4319 while True: 

4320 self.state = 663 

4321 self.except_clause() 

4322 self.state = 664 

4323 self.match(Python3Parser.COLON) 

4324 self.state = 665 

4325 self.suite() 

4326 self.state = 669 

4327 self._errHandler.sync(self) 

4328 _la = self._input.LA(1) 

4329 if not (_la==Python3Parser.EXCEPT): 

4330 break 

4331 

4332 self.state = 674 

4333 self._errHandler.sync(self) 

4334 _la = self._input.LA(1) 

4335 if _la==Python3Parser.ELSE: 

4336 self.state = 671 

4337 self.match(Python3Parser.ELSE) 

4338 self.state = 672 

4339 self.match(Python3Parser.COLON) 

4340 self.state = 673 

4341 self.suite() 

4342 

4343 

4344 self.state = 679 

4345 self._errHandler.sync(self) 

4346 _la = self._input.LA(1) 

4347 if _la==Python3Parser.FINALLY: 

4348 self.state = 676 

4349 self.match(Python3Parser.FINALLY) 

4350 self.state = 677 

4351 self.match(Python3Parser.COLON) 

4352 self.state = 678 

4353 self.suite() 

4354 

4355 

4356 pass 

4357 elif token in [Python3Parser.FINALLY]: 

4358 self.state = 681 

4359 self.match(Python3Parser.FINALLY) 

4360 self.state = 682 

4361 self.match(Python3Parser.COLON) 

4362 self.state = 683 

4363 self.suite() 

4364 pass 

4365 else: 

4366 raise NoViableAltException(self) 

4367 

4368 except RecognitionException as re: 

4369 localctx.exception = re 

4370 self._errHandler.reportError(self, re) 

4371 self._errHandler.recover(self, re) 

4372 finally: 

4373 self.exitRule() 

4374 return localctx 

4375 

4376 

4377 class With_stmtContext(ParserRuleContext): 

4378 __slots__ = 'parser' 

4379 

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

4381 super().__init__(parent, invokingState) 

4382 self.parser = parser 

4383 

4384 def WITH(self): 

4385 return self.getToken(Python3Parser.WITH, 0) 

4386 

4387 def with_item(self, i:int=None): 

4388 if i is None: 

4389 return self.getTypedRuleContexts(Python3Parser.With_itemContext) 

4390 else: 

4391 return self.getTypedRuleContext(Python3Parser.With_itemContext,i) 

4392 

4393 

4394 def COLON(self): 

4395 return self.getToken(Python3Parser.COLON, 0) 

4396 

4397 def suite(self): 

4398 return self.getTypedRuleContext(Python3Parser.SuiteContext,0) 

4399 

4400 

4401 def COMMA(self, i:int=None): 

4402 if i is None: 

4403 return self.getTokens(Python3Parser.COMMA) 

4404 else: 

4405 return self.getToken(Python3Parser.COMMA, i) 

4406 

4407 def getRuleIndex(self): 

4408 return Python3Parser.RULE_with_stmt 

4409 

4410 def enterRule(self, listener:ParseTreeListener): 

4411 if hasattr( listener, "enterWith_stmt" ): 

4412 listener.enterWith_stmt(self) 

4413 

4414 def exitRule(self, listener:ParseTreeListener): 

4415 if hasattr( listener, "exitWith_stmt" ): 

4416 listener.exitWith_stmt(self) 

4417 

4418 

4419 

4420 

4421 def with_stmt(self): 

4422 

4423 localctx = Python3Parser.With_stmtContext(self, self._ctx, self.state) 

4424 self.enterRule(localctx, 90, self.RULE_with_stmt) 

4425 self._la = 0 # Token type 

4426 try: 

4427 self.enterOuterAlt(localctx, 1) 

4428 self.state = 686 

4429 self.match(Python3Parser.WITH) 

4430 self.state = 687 

4431 self.with_item() 

4432 self.state = 692 

4433 self._errHandler.sync(self) 

4434 _la = self._input.LA(1) 

4435 while _la==Python3Parser.COMMA: 

4436 self.state = 688 

4437 self.match(Python3Parser.COMMA) 

4438 self.state = 689 

4439 self.with_item() 

4440 self.state = 694 

4441 self._errHandler.sync(self) 

4442 _la = self._input.LA(1) 

4443 

4444 self.state = 695 

4445 self.match(Python3Parser.COLON) 

4446 self.state = 696 

4447 self.suite() 

4448 except RecognitionException as re: 

4449 localctx.exception = re 

4450 self._errHandler.reportError(self, re) 

4451 self._errHandler.recover(self, re) 

4452 finally: 

4453 self.exitRule() 

4454 return localctx 

4455 

4456 

4457 class With_itemContext(ParserRuleContext): 

4458 __slots__ = 'parser' 

4459 

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

4461 super().__init__(parent, invokingState) 

4462 self.parser = parser 

4463 

4464 def test(self): 

4465 return self.getTypedRuleContext(Python3Parser.TestContext,0) 

4466 

4467 

4468 def AS(self): 

4469 return self.getToken(Python3Parser.AS, 0) 

4470 

4471 def expr(self): 

4472 return self.getTypedRuleContext(Python3Parser.ExprContext,0) 

4473 

4474 

4475 def getRuleIndex(self): 

4476 return Python3Parser.RULE_with_item 

4477 

4478 def enterRule(self, listener:ParseTreeListener): 

4479 if hasattr( listener, "enterWith_item" ): 

4480 listener.enterWith_item(self) 

4481 

4482 def exitRule(self, listener:ParseTreeListener): 

4483 if hasattr( listener, "exitWith_item" ): 

4484 listener.exitWith_item(self) 

4485 

4486 

4487 

4488 

4489 def with_item(self): 

4490 

4491 localctx = Python3Parser.With_itemContext(self, self._ctx, self.state) 

4492 self.enterRule(localctx, 92, self.RULE_with_item) 

4493 self._la = 0 # Token type 

4494 try: 

4495 self.enterOuterAlt(localctx, 1) 

4496 self.state = 698 

4497 self.test() 

4498 self.state = 701 

4499 self._errHandler.sync(self) 

4500 _la = self._input.LA(1) 

4501 if _la==Python3Parser.AS: 

4502 self.state = 699 

4503 self.match(Python3Parser.AS) 

4504 self.state = 700 

4505 self.expr() 

4506 

4507 

4508 except RecognitionException as re: 

4509 localctx.exception = re 

4510 self._errHandler.reportError(self, re) 

4511 self._errHandler.recover(self, re) 

4512 finally: 

4513 self.exitRule() 

4514 return localctx 

4515 

4516 

4517 class Except_clauseContext(ParserRuleContext): 

4518 __slots__ = 'parser' 

4519 

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

4521 super().__init__(parent, invokingState) 

4522 self.parser = parser 

4523 

4524 def EXCEPT(self): 

4525 return self.getToken(Python3Parser.EXCEPT, 0) 

4526 

4527 def test(self): 

4528 return self.getTypedRuleContext(Python3Parser.TestContext,0) 

4529 

4530 

4531 def AS(self): 

4532 return self.getToken(Python3Parser.AS, 0) 

4533 

4534 def NAME(self): 

4535 return self.getToken(Python3Parser.NAME, 0) 

4536 

4537 def getRuleIndex(self): 

4538 return Python3Parser.RULE_except_clause 

4539 

4540 def enterRule(self, listener:ParseTreeListener): 

4541 if hasattr( listener, "enterExcept_clause" ): 

4542 listener.enterExcept_clause(self) 

4543 

4544 def exitRule(self, listener:ParseTreeListener): 

4545 if hasattr( listener, "exitExcept_clause" ): 

4546 listener.exitExcept_clause(self) 

4547 

4548 

4549 

4550 

4551 def except_clause(self): 

4552 

4553 localctx = Python3Parser.Except_clauseContext(self, self._ctx, self.state) 

4554 self.enterRule(localctx, 94, self.RULE_except_clause) 

4555 self._la = 0 # Token type 

4556 try: 

4557 self.enterOuterAlt(localctx, 1) 

4558 self.state = 703 

4559 self.match(Python3Parser.EXCEPT) 

4560 self.state = 709 

4561 self._errHandler.sync(self) 

4562 _la = self._input.LA(1) 

4563 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

4564 self.state = 704 

4565 self.test() 

4566 self.state = 707 

4567 self._errHandler.sync(self) 

4568 _la = self._input.LA(1) 

4569 if _la==Python3Parser.AS: 

4570 self.state = 705 

4571 self.match(Python3Parser.AS) 

4572 self.state = 706 

4573 self.match(Python3Parser.NAME) 

4574 

4575 

4576 

4577 

4578 except RecognitionException as re: 

4579 localctx.exception = re 

4580 self._errHandler.reportError(self, re) 

4581 self._errHandler.recover(self, re) 

4582 finally: 

4583 self.exitRule() 

4584 return localctx 

4585 

4586 

4587 class SuiteContext(ParserRuleContext): 

4588 __slots__ = 'parser' 

4589 

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

4591 super().__init__(parent, invokingState) 

4592 self.parser = parser 

4593 

4594 def simple_stmt(self): 

4595 return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,0) 

4596 

4597 

4598 def NEWLINE(self): 

4599 return self.getToken(Python3Parser.NEWLINE, 0) 

4600 

4601 def INDENT(self): 

4602 return self.getToken(Python3Parser.INDENT, 0) 

4603 

4604 def DEDENT(self): 

4605 return self.getToken(Python3Parser.DEDENT, 0) 

4606 

4607 def stmt(self, i:int=None): 

4608 if i is None: 

4609 return self.getTypedRuleContexts(Python3Parser.StmtContext) 

4610 else: 

4611 return self.getTypedRuleContext(Python3Parser.StmtContext,i) 

4612 

4613 

4614 def getRuleIndex(self): 

4615 return Python3Parser.RULE_suite 

4616 

4617 def enterRule(self, listener:ParseTreeListener): 

4618 if hasattr( listener, "enterSuite" ): 

4619 listener.enterSuite(self) 

4620 

4621 def exitRule(self, listener:ParseTreeListener): 

4622 if hasattr( listener, "exitSuite" ): 

4623 listener.exitSuite(self) 

4624 

4625 

4626 

4627 

4628 def suite(self): 

4629 

4630 localctx = Python3Parser.SuiteContext(self, self._ctx, self.state) 

4631 self.enterRule(localctx, 96, self.RULE_suite) 

4632 self._la = 0 # Token type 

4633 try: 

4634 self.state = 721 

4635 self._errHandler.sync(self) 

4636 token = self._input.LA(1) 

4637 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.FROM, Python3Parser.IMPORT, Python3Parser.GLOBAL, Python3Parser.NONLOCAL, Python3Parser.ASSERT, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.YIELD, Python3Parser.DEL, Python3Parser.PASS, Python3Parser.CONTINUE, Python3Parser.BREAK, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

4638 self.enterOuterAlt(localctx, 1) 

4639 self.state = 711 

4640 self.simple_stmt() 

4641 pass 

4642 elif token in [Python3Parser.NEWLINE]: 

4643 self.enterOuterAlt(localctx, 2) 

4644 self.state = 712 

4645 self.match(Python3Parser.NEWLINE) 

4646 self.state = 713 

4647 self.match(Python3Parser.INDENT) 

4648 self.state = 715 

4649 self._errHandler.sync(self) 

4650 _la = self._input.LA(1) 

4651 while True: 

4652 self.state = 714 

4653 self.stmt() 

4654 self.state = 717 

4655 self._errHandler.sync(self) 

4656 _la = self._input.LA(1) 

4657 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.DEF) | (1 << Python3Parser.RETURN) | (1 << Python3Parser.RAISE) | (1 << Python3Parser.FROM) | (1 << Python3Parser.IMPORT) | (1 << Python3Parser.GLOBAL) | (1 << Python3Parser.NONLOCAL) | (1 << Python3Parser.ASSERT) | (1 << Python3Parser.IF) | (1 << Python3Parser.WHILE) | (1 << Python3Parser.FOR) | (1 << Python3Parser.TRY) | (1 << Python3Parser.WITH) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.CLASS) | (1 << Python3Parser.YIELD) | (1 << Python3Parser.DEL) | (1 << Python3Parser.PASS) | (1 << Python3Parser.CONTINUE) | (1 << Python3Parser.BREAK) | (1 << Python3Parser.ASYNC) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)) | (1 << (Python3Parser.AT - 66)))) != 0)): 

4658 break 

4659 

4660 self.state = 719 

4661 self.match(Python3Parser.DEDENT) 

4662 pass 

4663 else: 

4664 raise NoViableAltException(self) 

4665 

4666 except RecognitionException as re: 

4667 localctx.exception = re 

4668 self._errHandler.reportError(self, re) 

4669 self._errHandler.recover(self, re) 

4670 finally: 

4671 self.exitRule() 

4672 return localctx 

4673 

4674 

4675 class TestContext(ParserRuleContext): 

4676 __slots__ = 'parser' 

4677 

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

4679 super().__init__(parent, invokingState) 

4680 self.parser = parser 

4681 

4682 def or_test(self, i:int=None): 

4683 if i is None: 

4684 return self.getTypedRuleContexts(Python3Parser.Or_testContext) 

4685 else: 

4686 return self.getTypedRuleContext(Python3Parser.Or_testContext,i) 

4687 

4688 

4689 def IF(self): 

4690 return self.getToken(Python3Parser.IF, 0) 

4691 

4692 def ELSE(self): 

4693 return self.getToken(Python3Parser.ELSE, 0) 

4694 

4695 def test(self): 

4696 return self.getTypedRuleContext(Python3Parser.TestContext,0) 

4697 

4698 

4699 def lambdef(self): 

4700 return self.getTypedRuleContext(Python3Parser.LambdefContext,0) 

4701 

4702 

4703 def getRuleIndex(self): 

4704 return Python3Parser.RULE_test 

4705 

4706 def enterRule(self, listener:ParseTreeListener): 

4707 if hasattr( listener, "enterTest" ): 

4708 listener.enterTest(self) 

4709 

4710 def exitRule(self, listener:ParseTreeListener): 

4711 if hasattr( listener, "exitTest" ): 

4712 listener.exitTest(self) 

4713 

4714 

4715 

4716 

4717 def test(self): 

4718 

4719 localctx = Python3Parser.TestContext(self, self._ctx, self.state) 

4720 self.enterRule(localctx, 98, self.RULE_test) 

4721 self._la = 0 # Token type 

4722 try: 

4723 self.state = 732 

4724 self._errHandler.sync(self) 

4725 token = self._input.LA(1) 

4726 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

4727 self.enterOuterAlt(localctx, 1) 

4728 self.state = 723 

4729 self.or_test() 

4730 self.state = 729 

4731 self._errHandler.sync(self) 

4732 _la = self._input.LA(1) 

4733 if _la==Python3Parser.IF: 

4734 self.state = 724 

4735 self.match(Python3Parser.IF) 

4736 self.state = 725 

4737 self.or_test() 

4738 self.state = 726 

4739 self.match(Python3Parser.ELSE) 

4740 self.state = 727 

4741 self.test() 

4742 

4743 

4744 pass 

4745 elif token in [Python3Parser.LAMBDA]: 

4746 self.enterOuterAlt(localctx, 2) 

4747 self.state = 731 

4748 self.lambdef() 

4749 pass 

4750 else: 

4751 raise NoViableAltException(self) 

4752 

4753 except RecognitionException as re: 

4754 localctx.exception = re 

4755 self._errHandler.reportError(self, re) 

4756 self._errHandler.recover(self, re) 

4757 finally: 

4758 self.exitRule() 

4759 return localctx 

4760 

4761 

4762 class Test_nocondContext(ParserRuleContext): 

4763 __slots__ = 'parser' 

4764 

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

4766 super().__init__(parent, invokingState) 

4767 self.parser = parser 

4768 

4769 def or_test(self): 

4770 return self.getTypedRuleContext(Python3Parser.Or_testContext,0) 

4771 

4772 

4773 def lambdef_nocond(self): 

4774 return self.getTypedRuleContext(Python3Parser.Lambdef_nocondContext,0) 

4775 

4776 

4777 def getRuleIndex(self): 

4778 return Python3Parser.RULE_test_nocond 

4779 

4780 def enterRule(self, listener:ParseTreeListener): 

4781 if hasattr( listener, "enterTest_nocond" ): 

4782 listener.enterTest_nocond(self) 

4783 

4784 def exitRule(self, listener:ParseTreeListener): 

4785 if hasattr( listener, "exitTest_nocond" ): 

4786 listener.exitTest_nocond(self) 

4787 

4788 

4789 

4790 

4791 def test_nocond(self): 

4792 

4793 localctx = Python3Parser.Test_nocondContext(self, self._ctx, self.state) 

4794 self.enterRule(localctx, 100, self.RULE_test_nocond) 

4795 try: 

4796 self.state = 736 

4797 self._errHandler.sync(self) 

4798 token = self._input.LA(1) 

4799 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

4800 self.enterOuterAlt(localctx, 1) 

4801 self.state = 734 

4802 self.or_test() 

4803 pass 

4804 elif token in [Python3Parser.LAMBDA]: 

4805 self.enterOuterAlt(localctx, 2) 

4806 self.state = 735 

4807 self.lambdef_nocond() 

4808 pass 

4809 else: 

4810 raise NoViableAltException(self) 

4811 

4812 except RecognitionException as re: 

4813 localctx.exception = re 

4814 self._errHandler.reportError(self, re) 

4815 self._errHandler.recover(self, re) 

4816 finally: 

4817 self.exitRule() 

4818 return localctx 

4819 

4820 

4821 class LambdefContext(ParserRuleContext): 

4822 __slots__ = 'parser' 

4823 

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

4825 super().__init__(parent, invokingState) 

4826 self.parser = parser 

4827 

4828 def LAMBDA(self): 

4829 return self.getToken(Python3Parser.LAMBDA, 0) 

4830 

4831 def COLON(self): 

4832 return self.getToken(Python3Parser.COLON, 0) 

4833 

4834 def test(self): 

4835 return self.getTypedRuleContext(Python3Parser.TestContext,0) 

4836 

4837 

4838 def varargslist(self): 

4839 return self.getTypedRuleContext(Python3Parser.VarargslistContext,0) 

4840 

4841 

4842 def getRuleIndex(self): 

4843 return Python3Parser.RULE_lambdef 

4844 

4845 def enterRule(self, listener:ParseTreeListener): 

4846 if hasattr( listener, "enterLambdef" ): 

4847 listener.enterLambdef(self) 

4848 

4849 def exitRule(self, listener:ParseTreeListener): 

4850 if hasattr( listener, "exitLambdef" ): 

4851 listener.exitLambdef(self) 

4852 

4853 

4854 

4855 

4856 def lambdef(self): 

4857 

4858 localctx = Python3Parser.LambdefContext(self, self._ctx, self.state) 

4859 self.enterRule(localctx, 102, self.RULE_lambdef) 

4860 self._la = 0 # Token type 

4861 try: 

4862 self.enterOuterAlt(localctx, 1) 

4863 self.state = 738 

4864 self.match(Python3Parser.LAMBDA) 

4865 self.state = 740 

4866 self._errHandler.sync(self) 

4867 _la = self._input.LA(1) 

4868 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.NAME) | (1 << Python3Parser.STAR) | (1 << Python3Parser.POWER))) != 0): 

4869 self.state = 739 

4870 self.varargslist() 

4871 

4872 

4873 self.state = 742 

4874 self.match(Python3Parser.COLON) 

4875 self.state = 743 

4876 self.test() 

4877 except RecognitionException as re: 

4878 localctx.exception = re 

4879 self._errHandler.reportError(self, re) 

4880 self._errHandler.recover(self, re) 

4881 finally: 

4882 self.exitRule() 

4883 return localctx 

4884 

4885 

4886 class Lambdef_nocondContext(ParserRuleContext): 

4887 __slots__ = 'parser' 

4888 

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

4890 super().__init__(parent, invokingState) 

4891 self.parser = parser 

4892 

4893 def LAMBDA(self): 

4894 return self.getToken(Python3Parser.LAMBDA, 0) 

4895 

4896 def COLON(self): 

4897 return self.getToken(Python3Parser.COLON, 0) 

4898 

4899 def test_nocond(self): 

4900 return self.getTypedRuleContext(Python3Parser.Test_nocondContext,0) 

4901 

4902 

4903 def varargslist(self): 

4904 return self.getTypedRuleContext(Python3Parser.VarargslistContext,0) 

4905 

4906 

4907 def getRuleIndex(self): 

4908 return Python3Parser.RULE_lambdef_nocond 

4909 

4910 def enterRule(self, listener:ParseTreeListener): 

4911 if hasattr( listener, "enterLambdef_nocond" ): 

4912 listener.enterLambdef_nocond(self) 

4913 

4914 def exitRule(self, listener:ParseTreeListener): 

4915 if hasattr( listener, "exitLambdef_nocond" ): 

4916 listener.exitLambdef_nocond(self) 

4917 

4918 

4919 

4920 

4921 def lambdef_nocond(self): 

4922 

4923 localctx = Python3Parser.Lambdef_nocondContext(self, self._ctx, self.state) 

4924 self.enterRule(localctx, 104, self.RULE_lambdef_nocond) 

4925 self._la = 0 # Token type 

4926 try: 

4927 self.enterOuterAlt(localctx, 1) 

4928 self.state = 745 

4929 self.match(Python3Parser.LAMBDA) 

4930 self.state = 747 

4931 self._errHandler.sync(self) 

4932 _la = self._input.LA(1) 

4933 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.NAME) | (1 << Python3Parser.STAR) | (1 << Python3Parser.POWER))) != 0): 

4934 self.state = 746 

4935 self.varargslist() 

4936 

4937 

4938 self.state = 749 

4939 self.match(Python3Parser.COLON) 

4940 self.state = 750 

4941 self.test_nocond() 

4942 except RecognitionException as re: 

4943 localctx.exception = re 

4944 self._errHandler.reportError(self, re) 

4945 self._errHandler.recover(self, re) 

4946 finally: 

4947 self.exitRule() 

4948 return localctx 

4949 

4950 

4951 class Or_testContext(ParserRuleContext): 

4952 __slots__ = 'parser' 

4953 

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

4955 super().__init__(parent, invokingState) 

4956 self.parser = parser 

4957 

4958 def and_test(self, i:int=None): 

4959 if i is None: 

4960 return self.getTypedRuleContexts(Python3Parser.And_testContext) 

4961 else: 

4962 return self.getTypedRuleContext(Python3Parser.And_testContext,i) 

4963 

4964 

4965 def OR(self, i:int=None): 

4966 if i is None: 

4967 return self.getTokens(Python3Parser.OR) 

4968 else: 

4969 return self.getToken(Python3Parser.OR, i) 

4970 

4971 def getRuleIndex(self): 

4972 return Python3Parser.RULE_or_test 

4973 

4974 def enterRule(self, listener:ParseTreeListener): 

4975 if hasattr( listener, "enterOr_test" ): 

4976 listener.enterOr_test(self) 

4977 

4978 def exitRule(self, listener:ParseTreeListener): 

4979 if hasattr( listener, "exitOr_test" ): 

4980 listener.exitOr_test(self) 

4981 

4982 

4983 

4984 

4985 def or_test(self): 

4986 

4987 localctx = Python3Parser.Or_testContext(self, self._ctx, self.state) 

4988 self.enterRule(localctx, 106, self.RULE_or_test) 

4989 self._la = 0 # Token type 

4990 try: 

4991 self.enterOuterAlt(localctx, 1) 

4992 self.state = 752 

4993 self.and_test() 

4994 self.state = 757 

4995 self._errHandler.sync(self) 

4996 _la = self._input.LA(1) 

4997 while _la==Python3Parser.OR: 

4998 self.state = 753 

4999 self.match(Python3Parser.OR) 

5000 self.state = 754 

5001 self.and_test() 

5002 self.state = 759 

5003 self._errHandler.sync(self) 

5004 _la = self._input.LA(1) 

5005 

5006 except RecognitionException as re: 

5007 localctx.exception = re 

5008 self._errHandler.reportError(self, re) 

5009 self._errHandler.recover(self, re) 

5010 finally: 

5011 self.exitRule() 

5012 return localctx 

5013 

5014 

5015 class And_testContext(ParserRuleContext): 

5016 __slots__ = 'parser' 

5017 

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

5019 super().__init__(parent, invokingState) 

5020 self.parser = parser 

5021 

5022 def not_test(self, i:int=None): 

5023 if i is None: 

5024 return self.getTypedRuleContexts(Python3Parser.Not_testContext) 

5025 else: 

5026 return self.getTypedRuleContext(Python3Parser.Not_testContext,i) 

5027 

5028 

5029 def AND(self, i:int=None): 

5030 if i is None: 

5031 return self.getTokens(Python3Parser.AND) 

5032 else: 

5033 return self.getToken(Python3Parser.AND, i) 

5034 

5035 def getRuleIndex(self): 

5036 return Python3Parser.RULE_and_test 

5037 

5038 def enterRule(self, listener:ParseTreeListener): 

5039 if hasattr( listener, "enterAnd_test" ): 

5040 listener.enterAnd_test(self) 

5041 

5042 def exitRule(self, listener:ParseTreeListener): 

5043 if hasattr( listener, "exitAnd_test" ): 

5044 listener.exitAnd_test(self) 

5045 

5046 

5047 

5048 

5049 def and_test(self): 

5050 

5051 localctx = Python3Parser.And_testContext(self, self._ctx, self.state) 

5052 self.enterRule(localctx, 108, self.RULE_and_test) 

5053 self._la = 0 # Token type 

5054 try: 

5055 self.enterOuterAlt(localctx, 1) 

5056 self.state = 760 

5057 self.not_test() 

5058 self.state = 765 

5059 self._errHandler.sync(self) 

5060 _la = self._input.LA(1) 

5061 while _la==Python3Parser.AND: 

5062 self.state = 761 

5063 self.match(Python3Parser.AND) 

5064 self.state = 762 

5065 self.not_test() 

5066 self.state = 767 

5067 self._errHandler.sync(self) 

5068 _la = self._input.LA(1) 

5069 

5070 except RecognitionException as re: 

5071 localctx.exception = re 

5072 self._errHandler.reportError(self, re) 

5073 self._errHandler.recover(self, re) 

5074 finally: 

5075 self.exitRule() 

5076 return localctx 

5077 

5078 

5079 class Not_testContext(ParserRuleContext): 

5080 __slots__ = 'parser' 

5081 

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

5083 super().__init__(parent, invokingState) 

5084 self.parser = parser 

5085 

5086 def NOT(self): 

5087 return self.getToken(Python3Parser.NOT, 0) 

5088 

5089 def not_test(self): 

5090 return self.getTypedRuleContext(Python3Parser.Not_testContext,0) 

5091 

5092 

5093 def comparison(self): 

5094 return self.getTypedRuleContext(Python3Parser.ComparisonContext,0) 

5095 

5096 

5097 def getRuleIndex(self): 

5098 return Python3Parser.RULE_not_test 

5099 

5100 def enterRule(self, listener:ParseTreeListener): 

5101 if hasattr( listener, "enterNot_test" ): 

5102 listener.enterNot_test(self) 

5103 

5104 def exitRule(self, listener:ParseTreeListener): 

5105 if hasattr( listener, "exitNot_test" ): 

5106 listener.exitNot_test(self) 

5107 

5108 

5109 

5110 

5111 def not_test(self): 

5112 

5113 localctx = Python3Parser.Not_testContext(self, self._ctx, self.state) 

5114 self.enterRule(localctx, 110, self.RULE_not_test) 

5115 try: 

5116 self.state = 771 

5117 self._errHandler.sync(self) 

5118 token = self._input.LA(1) 

5119 if token in [Python3Parser.NOT]: 

5120 self.enterOuterAlt(localctx, 1) 

5121 self.state = 768 

5122 self.match(Python3Parser.NOT) 

5123 self.state = 769 

5124 self.not_test() 

5125 pass 

5126 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

5127 self.enterOuterAlt(localctx, 2) 

5128 self.state = 770 

5129 self.comparison() 

5130 pass 

5131 else: 

5132 raise NoViableAltException(self) 

5133 

5134 except RecognitionException as re: 

5135 localctx.exception = re 

5136 self._errHandler.reportError(self, re) 

5137 self._errHandler.recover(self, re) 

5138 finally: 

5139 self.exitRule() 

5140 return localctx 

5141 

5142 

5143 class ComparisonContext(ParserRuleContext): 

5144 __slots__ = 'parser' 

5145 

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

5147 super().__init__(parent, invokingState) 

5148 self.parser = parser 

5149 

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

5151 if i is None: 

5152 return self.getTypedRuleContexts(Python3Parser.ExprContext) 

5153 else: 

5154 return self.getTypedRuleContext(Python3Parser.ExprContext,i) 

5155 

5156 

5157 def comp_op(self, i:int=None): 

5158 if i is None: 

5159 return self.getTypedRuleContexts(Python3Parser.Comp_opContext) 

5160 else: 

5161 return self.getTypedRuleContext(Python3Parser.Comp_opContext,i) 

5162 

5163 

5164 def getRuleIndex(self): 

5165 return Python3Parser.RULE_comparison 

5166 

5167 def enterRule(self, listener:ParseTreeListener): 

5168 if hasattr( listener, "enterComparison" ): 

5169 listener.enterComparison(self) 

5170 

5171 def exitRule(self, listener:ParseTreeListener): 

5172 if hasattr( listener, "exitComparison" ): 

5173 listener.exitComparison(self) 

5174 

5175 

5176 

5177 

5178 def comparison(self): 

5179 

5180 localctx = Python3Parser.ComparisonContext(self, self._ctx, self.state) 

5181 self.enterRule(localctx, 112, self.RULE_comparison) 

5182 self._la = 0 # Token type 

5183 try: 

5184 self.enterOuterAlt(localctx, 1) 

5185 self.state = 773 

5186 self.expr() 

5187 self.state = 779 

5188 self._errHandler.sync(self) 

5189 _la = self._input.LA(1) 

5190 while ((((_la - 18)) & ~0x3f) == 0 and ((1 << (_la - 18)) & ((1 << (Python3Parser.IN - 18)) | (1 << (Python3Parser.NOT - 18)) | (1 << (Python3Parser.IS - 18)) | (1 << (Python3Parser.LESS_THAN - 18)) | (1 << (Python3Parser.GREATER_THAN - 18)) | (1 << (Python3Parser.EQUALS - 18)) | (1 << (Python3Parser.GT_EQ - 18)) | (1 << (Python3Parser.LT_EQ - 18)) | (1 << (Python3Parser.NOT_EQ_1 - 18)) | (1 << (Python3Parser.NOT_EQ_2 - 18)))) != 0): 

5191 self.state = 774 

5192 self.comp_op() 

5193 self.state = 775 

5194 self.expr() 

5195 self.state = 781 

5196 self._errHandler.sync(self) 

5197 _la = self._input.LA(1) 

5198 

5199 except RecognitionException as re: 

5200 localctx.exception = re 

5201 self._errHandler.reportError(self, re) 

5202 self._errHandler.recover(self, re) 

5203 finally: 

5204 self.exitRule() 

5205 return localctx 

5206 

5207 

5208 class Comp_opContext(ParserRuleContext): 

5209 __slots__ = 'parser' 

5210 

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

5212 super().__init__(parent, invokingState) 

5213 self.parser = parser 

5214 

5215 def LESS_THAN(self): 

5216 return self.getToken(Python3Parser.LESS_THAN, 0) 

5217 

5218 def GREATER_THAN(self): 

5219 return self.getToken(Python3Parser.GREATER_THAN, 0) 

5220 

5221 def EQUALS(self): 

5222 return self.getToken(Python3Parser.EQUALS, 0) 

5223 

5224 def GT_EQ(self): 

5225 return self.getToken(Python3Parser.GT_EQ, 0) 

5226 

5227 def LT_EQ(self): 

5228 return self.getToken(Python3Parser.LT_EQ, 0) 

5229 

5230 def NOT_EQ_1(self): 

5231 return self.getToken(Python3Parser.NOT_EQ_1, 0) 

5232 

5233 def NOT_EQ_2(self): 

5234 return self.getToken(Python3Parser.NOT_EQ_2, 0) 

5235 

5236 def IN(self): 

5237 return self.getToken(Python3Parser.IN, 0) 

5238 

5239 def NOT(self): 

5240 return self.getToken(Python3Parser.NOT, 0) 

5241 

5242 def IS(self): 

5243 return self.getToken(Python3Parser.IS, 0) 

5244 

5245 def getRuleIndex(self): 

5246 return Python3Parser.RULE_comp_op 

5247 

5248 def enterRule(self, listener:ParseTreeListener): 

5249 if hasattr( listener, "enterComp_op" ): 

5250 listener.enterComp_op(self) 

5251 

5252 def exitRule(self, listener:ParseTreeListener): 

5253 if hasattr( listener, "exitComp_op" ): 

5254 listener.exitComp_op(self) 

5255 

5256 

5257 

5258 

5259 def comp_op(self): 

5260 

5261 localctx = Python3Parser.Comp_opContext(self, self._ctx, self.state) 

5262 self.enterRule(localctx, 114, self.RULE_comp_op) 

5263 try: 

5264 self.state = 795 

5265 self._errHandler.sync(self) 

5266 la_ = self._interp.adaptivePredict(self._input,107,self._ctx) 

5267 if la_ == 1: 

5268 self.enterOuterAlt(localctx, 1) 

5269 self.state = 782 

5270 self.match(Python3Parser.LESS_THAN) 

5271 pass 

5272 

5273 elif la_ == 2: 

5274 self.enterOuterAlt(localctx, 2) 

5275 self.state = 783 

5276 self.match(Python3Parser.GREATER_THAN) 

5277 pass 

5278 

5279 elif la_ == 3: 

5280 self.enterOuterAlt(localctx, 3) 

5281 self.state = 784 

5282 self.match(Python3Parser.EQUALS) 

5283 pass 

5284 

5285 elif la_ == 4: 

5286 self.enterOuterAlt(localctx, 4) 

5287 self.state = 785 

5288 self.match(Python3Parser.GT_EQ) 

5289 pass 

5290 

5291 elif la_ == 5: 

5292 self.enterOuterAlt(localctx, 5) 

5293 self.state = 786 

5294 self.match(Python3Parser.LT_EQ) 

5295 pass 

5296 

5297 elif la_ == 6: 

5298 self.enterOuterAlt(localctx, 6) 

5299 self.state = 787 

5300 self.match(Python3Parser.NOT_EQ_1) 

5301 pass 

5302 

5303 elif la_ == 7: 

5304 self.enterOuterAlt(localctx, 7) 

5305 self.state = 788 

5306 self.match(Python3Parser.NOT_EQ_2) 

5307 pass 

5308 

5309 elif la_ == 8: 

5310 self.enterOuterAlt(localctx, 8) 

5311 self.state = 789 

5312 self.match(Python3Parser.IN) 

5313 pass 

5314 

5315 elif la_ == 9: 

5316 self.enterOuterAlt(localctx, 9) 

5317 self.state = 790 

5318 self.match(Python3Parser.NOT) 

5319 self.state = 791 

5320 self.match(Python3Parser.IN) 

5321 pass 

5322 

5323 elif la_ == 10: 

5324 self.enterOuterAlt(localctx, 10) 

5325 self.state = 792 

5326 self.match(Python3Parser.IS) 

5327 pass 

5328 

5329 elif la_ == 11: 

5330 self.enterOuterAlt(localctx, 11) 

5331 self.state = 793 

5332 self.match(Python3Parser.IS) 

5333 self.state = 794 

5334 self.match(Python3Parser.NOT) 

5335 pass 

5336 

5337 

5338 except RecognitionException as re: 

5339 localctx.exception = re 

5340 self._errHandler.reportError(self, re) 

5341 self._errHandler.recover(self, re) 

5342 finally: 

5343 self.exitRule() 

5344 return localctx 

5345 

5346 

5347 class Star_exprContext(ParserRuleContext): 

5348 __slots__ = 'parser' 

5349 

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

5351 super().__init__(parent, invokingState) 

5352 self.parser = parser 

5353 

5354 def STAR(self): 

5355 return self.getToken(Python3Parser.STAR, 0) 

5356 

5357 def expr(self): 

5358 return self.getTypedRuleContext(Python3Parser.ExprContext,0) 

5359 

5360 

5361 def getRuleIndex(self): 

5362 return Python3Parser.RULE_star_expr 

5363 

5364 def enterRule(self, listener:ParseTreeListener): 

5365 if hasattr( listener, "enterStar_expr" ): 

5366 listener.enterStar_expr(self) 

5367 

5368 def exitRule(self, listener:ParseTreeListener): 

5369 if hasattr( listener, "exitStar_expr" ): 

5370 listener.exitStar_expr(self) 

5371 

5372 

5373 

5374 

5375 def star_expr(self): 

5376 

5377 localctx = Python3Parser.Star_exprContext(self, self._ctx, self.state) 

5378 self.enterRule(localctx, 116, self.RULE_star_expr) 

5379 try: 

5380 self.enterOuterAlt(localctx, 1) 

5381 self.state = 797 

5382 self.match(Python3Parser.STAR) 

5383 self.state = 798 

5384 self.expr() 

5385 except RecognitionException as re: 

5386 localctx.exception = re 

5387 self._errHandler.reportError(self, re) 

5388 self._errHandler.recover(self, re) 

5389 finally: 

5390 self.exitRule() 

5391 return localctx 

5392 

5393 

5394 class ExprContext(ParserRuleContext): 

5395 __slots__ = 'parser' 

5396 

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

5398 super().__init__(parent, invokingState) 

5399 self.parser = parser 

5400 

5401 def xor_expr(self, i:int=None): 

5402 if i is None: 

5403 return self.getTypedRuleContexts(Python3Parser.Xor_exprContext) 

5404 else: 

5405 return self.getTypedRuleContext(Python3Parser.Xor_exprContext,i) 

5406 

5407 

5408 def OR_OP(self, i:int=None): 

5409 if i is None: 

5410 return self.getTokens(Python3Parser.OR_OP) 

5411 else: 

5412 return self.getToken(Python3Parser.OR_OP, i) 

5413 

5414 def getRuleIndex(self): 

5415 return Python3Parser.RULE_expr 

5416 

5417 def enterRule(self, listener:ParseTreeListener): 

5418 if hasattr( listener, "enterExpr" ): 

5419 listener.enterExpr(self) 

5420 

5421 def exitRule(self, listener:ParseTreeListener): 

5422 if hasattr( listener, "exitExpr" ): 

5423 listener.exitExpr(self) 

5424 

5425 

5426 

5427 

5428 def expr(self): 

5429 

5430 localctx = Python3Parser.ExprContext(self, self._ctx, self.state) 

5431 self.enterRule(localctx, 118, self.RULE_expr) 

5432 self._la = 0 # Token type 

5433 try: 

5434 self.enterOuterAlt(localctx, 1) 

5435 self.state = 800 

5436 self.xor_expr() 

5437 self.state = 805 

5438 self._errHandler.sync(self) 

5439 _la = self._input.LA(1) 

5440 while _la==Python3Parser.OR_OP: 

5441 self.state = 801 

5442 self.match(Python3Parser.OR_OP) 

5443 self.state = 802 

5444 self.xor_expr() 

5445 self.state = 807 

5446 self._errHandler.sync(self) 

5447 _la = self._input.LA(1) 

5448 

5449 except RecognitionException as re: 

5450 localctx.exception = re 

5451 self._errHandler.reportError(self, re) 

5452 self._errHandler.recover(self, re) 

5453 finally: 

5454 self.exitRule() 

5455 return localctx 

5456 

5457 

5458 class Xor_exprContext(ParserRuleContext): 

5459 __slots__ = 'parser' 

5460 

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

5462 super().__init__(parent, invokingState) 

5463 self.parser = parser 

5464 

5465 def and_expr(self, i:int=None): 

5466 if i is None: 

5467 return self.getTypedRuleContexts(Python3Parser.And_exprContext) 

5468 else: 

5469 return self.getTypedRuleContext(Python3Parser.And_exprContext,i) 

5470 

5471 

5472 def XOR(self, i:int=None): 

5473 if i is None: 

5474 return self.getTokens(Python3Parser.XOR) 

5475 else: 

5476 return self.getToken(Python3Parser.XOR, i) 

5477 

5478 def getRuleIndex(self): 

5479 return Python3Parser.RULE_xor_expr 

5480 

5481 def enterRule(self, listener:ParseTreeListener): 

5482 if hasattr( listener, "enterXor_expr" ): 

5483 listener.enterXor_expr(self) 

5484 

5485 def exitRule(self, listener:ParseTreeListener): 

5486 if hasattr( listener, "exitXor_expr" ): 

5487 listener.exitXor_expr(self) 

5488 

5489 

5490 

5491 

5492 def xor_expr(self): 

5493 

5494 localctx = Python3Parser.Xor_exprContext(self, self._ctx, self.state) 

5495 self.enterRule(localctx, 120, self.RULE_xor_expr) 

5496 self._la = 0 # Token type 

5497 try: 

5498 self.enterOuterAlt(localctx, 1) 

5499 self.state = 808 

5500 self.and_expr() 

5501 self.state = 813 

5502 self._errHandler.sync(self) 

5503 _la = self._input.LA(1) 

5504 while _la==Python3Parser.XOR: 

5505 self.state = 809 

5506 self.match(Python3Parser.XOR) 

5507 self.state = 810 

5508 self.and_expr() 

5509 self.state = 815 

5510 self._errHandler.sync(self) 

5511 _la = self._input.LA(1) 

5512 

5513 except RecognitionException as re: 

5514 localctx.exception = re 

5515 self._errHandler.reportError(self, re) 

5516 self._errHandler.recover(self, re) 

5517 finally: 

5518 self.exitRule() 

5519 return localctx 

5520 

5521 

5522 class And_exprContext(ParserRuleContext): 

5523 __slots__ = 'parser' 

5524 

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

5526 super().__init__(parent, invokingState) 

5527 self.parser = parser 

5528 

5529 def shift_expr(self, i:int=None): 

5530 if i is None: 

5531 return self.getTypedRuleContexts(Python3Parser.Shift_exprContext) 

5532 else: 

5533 return self.getTypedRuleContext(Python3Parser.Shift_exprContext,i) 

5534 

5535 

5536 def AND_OP(self, i:int=None): 

5537 if i is None: 

5538 return self.getTokens(Python3Parser.AND_OP) 

5539 else: 

5540 return self.getToken(Python3Parser.AND_OP, i) 

5541 

5542 def getRuleIndex(self): 

5543 return Python3Parser.RULE_and_expr 

5544 

5545 def enterRule(self, listener:ParseTreeListener): 

5546 if hasattr( listener, "enterAnd_expr" ): 

5547 listener.enterAnd_expr(self) 

5548 

5549 def exitRule(self, listener:ParseTreeListener): 

5550 if hasattr( listener, "exitAnd_expr" ): 

5551 listener.exitAnd_expr(self) 

5552 

5553 

5554 

5555 

5556 def and_expr(self): 

5557 

5558 localctx = Python3Parser.And_exprContext(self, self._ctx, self.state) 

5559 self.enterRule(localctx, 122, self.RULE_and_expr) 

5560 self._la = 0 # Token type 

5561 try: 

5562 self.enterOuterAlt(localctx, 1) 

5563 self.state = 816 

5564 self.shift_expr() 

5565 self.state = 821 

5566 self._errHandler.sync(self) 

5567 _la = self._input.LA(1) 

5568 while _la==Python3Parser.AND_OP: 

5569 self.state = 817 

5570 self.match(Python3Parser.AND_OP) 

5571 self.state = 818 

5572 self.shift_expr() 

5573 self.state = 823 

5574 self._errHandler.sync(self) 

5575 _la = self._input.LA(1) 

5576 

5577 except RecognitionException as re: 

5578 localctx.exception = re 

5579 self._errHandler.reportError(self, re) 

5580 self._errHandler.recover(self, re) 

5581 finally: 

5582 self.exitRule() 

5583 return localctx 

5584 

5585 

5586 class Shift_exprContext(ParserRuleContext): 

5587 __slots__ = 'parser' 

5588 

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

5590 super().__init__(parent, invokingState) 

5591 self.parser = parser 

5592 

5593 def arith_expr(self, i:int=None): 

5594 if i is None: 

5595 return self.getTypedRuleContexts(Python3Parser.Arith_exprContext) 

5596 else: 

5597 return self.getTypedRuleContext(Python3Parser.Arith_exprContext,i) 

5598 

5599 

5600 def LEFT_SHIFT(self, i:int=None): 

5601 if i is None: 

5602 return self.getTokens(Python3Parser.LEFT_SHIFT) 

5603 else: 

5604 return self.getToken(Python3Parser.LEFT_SHIFT, i) 

5605 

5606 def RIGHT_SHIFT(self, i:int=None): 

5607 if i is None: 

5608 return self.getTokens(Python3Parser.RIGHT_SHIFT) 

5609 else: 

5610 return self.getToken(Python3Parser.RIGHT_SHIFT, i) 

5611 

5612 def getRuleIndex(self): 

5613 return Python3Parser.RULE_shift_expr 

5614 

5615 def enterRule(self, listener:ParseTreeListener): 

5616 if hasattr( listener, "enterShift_expr" ): 

5617 listener.enterShift_expr(self) 

5618 

5619 def exitRule(self, listener:ParseTreeListener): 

5620 if hasattr( listener, "exitShift_expr" ): 

5621 listener.exitShift_expr(self) 

5622 

5623 

5624 

5625 

5626 def shift_expr(self): 

5627 

5628 localctx = Python3Parser.Shift_exprContext(self, self._ctx, self.state) 

5629 self.enterRule(localctx, 124, self.RULE_shift_expr) 

5630 self._la = 0 # Token type 

5631 try: 

5632 self.enterOuterAlt(localctx, 1) 

5633 self.state = 824 

5634 self.arith_expr() 

5635 self.state = 829 

5636 self._errHandler.sync(self) 

5637 _la = self._input.LA(1) 

5638 while _la==Python3Parser.LEFT_SHIFT or _la==Python3Parser.RIGHT_SHIFT: 

5639 self.state = 825 

5640 _la = self._input.LA(1) 

5641 if not(_la==Python3Parser.LEFT_SHIFT or _la==Python3Parser.RIGHT_SHIFT): 

5642 self._errHandler.recoverInline(self) 

5643 else: 

5644 self._errHandler.reportMatch(self) 

5645 self.consume() 

5646 self.state = 826 

5647 self.arith_expr() 

5648 self.state = 831 

5649 self._errHandler.sync(self) 

5650 _la = self._input.LA(1) 

5651 

5652 except RecognitionException as re: 

5653 localctx.exception = re 

5654 self._errHandler.reportError(self, re) 

5655 self._errHandler.recover(self, re) 

5656 finally: 

5657 self.exitRule() 

5658 return localctx 

5659 

5660 

5661 class Arith_exprContext(ParserRuleContext): 

5662 __slots__ = 'parser' 

5663 

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

5665 super().__init__(parent, invokingState) 

5666 self.parser = parser 

5667 

5668 def term(self, i:int=None): 

5669 if i is None: 

5670 return self.getTypedRuleContexts(Python3Parser.TermContext) 

5671 else: 

5672 return self.getTypedRuleContext(Python3Parser.TermContext,i) 

5673 

5674 

5675 def ADD(self, i:int=None): 

5676 if i is None: 

5677 return self.getTokens(Python3Parser.ADD) 

5678 else: 

5679 return self.getToken(Python3Parser.ADD, i) 

5680 

5681 def MINUS(self, i:int=None): 

5682 if i is None: 

5683 return self.getTokens(Python3Parser.MINUS) 

5684 else: 

5685 return self.getToken(Python3Parser.MINUS, i) 

5686 

5687 def getRuleIndex(self): 

5688 return Python3Parser.RULE_arith_expr 

5689 

5690 def enterRule(self, listener:ParseTreeListener): 

5691 if hasattr( listener, "enterArith_expr" ): 

5692 listener.enterArith_expr(self) 

5693 

5694 def exitRule(self, listener:ParseTreeListener): 

5695 if hasattr( listener, "exitArith_expr" ): 

5696 listener.exitArith_expr(self) 

5697 

5698 

5699 

5700 

5701 def arith_expr(self): 

5702 

5703 localctx = Python3Parser.Arith_exprContext(self, self._ctx, self.state) 

5704 self.enterRule(localctx, 126, self.RULE_arith_expr) 

5705 self._la = 0 # Token type 

5706 try: 

5707 self.enterOuterAlt(localctx, 1) 

5708 self.state = 832 

5709 self.term() 

5710 self.state = 837 

5711 self._errHandler.sync(self) 

5712 _la = self._input.LA(1) 

5713 while _la==Python3Parser.ADD or _la==Python3Parser.MINUS: 

5714 self.state = 833 

5715 _la = self._input.LA(1) 

5716 if not(_la==Python3Parser.ADD or _la==Python3Parser.MINUS): 

5717 self._errHandler.recoverInline(self) 

5718 else: 

5719 self._errHandler.reportMatch(self) 

5720 self.consume() 

5721 self.state = 834 

5722 self.term() 

5723 self.state = 839 

5724 self._errHandler.sync(self) 

5725 _la = self._input.LA(1) 

5726 

5727 except RecognitionException as re: 

5728 localctx.exception = re 

5729 self._errHandler.reportError(self, re) 

5730 self._errHandler.recover(self, re) 

5731 finally: 

5732 self.exitRule() 

5733 return localctx 

5734 

5735 

5736 class TermContext(ParserRuleContext): 

5737 __slots__ = 'parser' 

5738 

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

5740 super().__init__(parent, invokingState) 

5741 self.parser = parser 

5742 

5743 def factor(self, i:int=None): 

5744 if i is None: 

5745 return self.getTypedRuleContexts(Python3Parser.FactorContext) 

5746 else: 

5747 return self.getTypedRuleContext(Python3Parser.FactorContext,i) 

5748 

5749 

5750 def STAR(self, i:int=None): 

5751 if i is None: 

5752 return self.getTokens(Python3Parser.STAR) 

5753 else: 

5754 return self.getToken(Python3Parser.STAR, i) 

5755 

5756 def AT(self, i:int=None): 

5757 if i is None: 

5758 return self.getTokens(Python3Parser.AT) 

5759 else: 

5760 return self.getToken(Python3Parser.AT, i) 

5761 

5762 def DIV(self, i:int=None): 

5763 if i is None: 

5764 return self.getTokens(Python3Parser.DIV) 

5765 else: 

5766 return self.getToken(Python3Parser.DIV, i) 

5767 

5768 def MOD(self, i:int=None): 

5769 if i is None: 

5770 return self.getTokens(Python3Parser.MOD) 

5771 else: 

5772 return self.getToken(Python3Parser.MOD, i) 

5773 

5774 def IDIV(self, i:int=None): 

5775 if i is None: 

5776 return self.getTokens(Python3Parser.IDIV) 

5777 else: 

5778 return self.getToken(Python3Parser.IDIV, i) 

5779 

5780 def getRuleIndex(self): 

5781 return Python3Parser.RULE_term 

5782 

5783 def enterRule(self, listener:ParseTreeListener): 

5784 if hasattr( listener, "enterTerm" ): 

5785 listener.enterTerm(self) 

5786 

5787 def exitRule(self, listener:ParseTreeListener): 

5788 if hasattr( listener, "exitTerm" ): 

5789 listener.exitTerm(self) 

5790 

5791 

5792 

5793 

5794 def term(self): 

5795 

5796 localctx = Python3Parser.TermContext(self, self._ctx, self.state) 

5797 self.enterRule(localctx, 128, self.RULE_term) 

5798 self._la = 0 # Token type 

5799 try: 

5800 self.enterOuterAlt(localctx, 1) 

5801 self.state = 840 

5802 self.factor() 

5803 self.state = 845 

5804 self._errHandler.sync(self) 

5805 _la = self._input.LA(1) 

5806 while ((((_la - 51)) & ~0x3f) == 0 and ((1 << (_la - 51)) & ((1 << (Python3Parser.STAR - 51)) | (1 << (Python3Parser.DIV - 51)) | (1 << (Python3Parser.MOD - 51)) | (1 << (Python3Parser.IDIV - 51)) | (1 << (Python3Parser.AT - 51)))) != 0): 

5807 self.state = 841 

5808 _la = self._input.LA(1) 

5809 if not(((((_la - 51)) & ~0x3f) == 0 and ((1 << (_la - 51)) & ((1 << (Python3Parser.STAR - 51)) | (1 << (Python3Parser.DIV - 51)) | (1 << (Python3Parser.MOD - 51)) | (1 << (Python3Parser.IDIV - 51)) | (1 << (Python3Parser.AT - 51)))) != 0)): 

5810 self._errHandler.recoverInline(self) 

5811 else: 

5812 self._errHandler.reportMatch(self) 

5813 self.consume() 

5814 self.state = 842 

5815 self.factor() 

5816 self.state = 847 

5817 self._errHandler.sync(self) 

5818 _la = self._input.LA(1) 

5819 

5820 except RecognitionException as re: 

5821 localctx.exception = re 

5822 self._errHandler.reportError(self, re) 

5823 self._errHandler.recover(self, re) 

5824 finally: 

5825 self.exitRule() 

5826 return localctx 

5827 

5828 

5829 class FactorContext(ParserRuleContext): 

5830 __slots__ = 'parser' 

5831 

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

5833 super().__init__(parent, invokingState) 

5834 self.parser = parser 

5835 

5836 def factor(self): 

5837 return self.getTypedRuleContext(Python3Parser.FactorContext,0) 

5838 

5839 

5840 def ADD(self): 

5841 return self.getToken(Python3Parser.ADD, 0) 

5842 

5843 def MINUS(self): 

5844 return self.getToken(Python3Parser.MINUS, 0) 

5845 

5846 def NOT_OP(self): 

5847 return self.getToken(Python3Parser.NOT_OP, 0) 

5848 

5849 def power(self): 

5850 return self.getTypedRuleContext(Python3Parser.PowerContext,0) 

5851 

5852 

5853 def getRuleIndex(self): 

5854 return Python3Parser.RULE_factor 

5855 

5856 def enterRule(self, listener:ParseTreeListener): 

5857 if hasattr( listener, "enterFactor" ): 

5858 listener.enterFactor(self) 

5859 

5860 def exitRule(self, listener:ParseTreeListener): 

5861 if hasattr( listener, "exitFactor" ): 

5862 listener.exitFactor(self) 

5863 

5864 

5865 

5866 

5867 def factor(self): 

5868 

5869 localctx = Python3Parser.FactorContext(self, self._ctx, self.state) 

5870 self.enterRule(localctx, 130, self.RULE_factor) 

5871 self._la = 0 # Token type 

5872 try: 

5873 self.state = 851 

5874 self._errHandler.sync(self) 

5875 token = self._input.LA(1) 

5876 if token in [Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP]: 

5877 self.enterOuterAlt(localctx, 1) 

5878 self.state = 848 

5879 _la = self._input.LA(1) 

5880 if not(((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)))) != 0)): 

5881 self._errHandler.recoverInline(self) 

5882 else: 

5883 self._errHandler.reportMatch(self) 

5884 self.consume() 

5885 self.state = 849 

5886 self.factor() 

5887 pass 

5888 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.OPEN_BRACE]: 

5889 self.enterOuterAlt(localctx, 2) 

5890 self.state = 850 

5891 self.power() 

5892 pass 

5893 else: 

5894 raise NoViableAltException(self) 

5895 

5896 except RecognitionException as re: 

5897 localctx.exception = re 

5898 self._errHandler.reportError(self, re) 

5899 self._errHandler.recover(self, re) 

5900 finally: 

5901 self.exitRule() 

5902 return localctx 

5903 

5904 

5905 class PowerContext(ParserRuleContext): 

5906 __slots__ = 'parser' 

5907 

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

5909 super().__init__(parent, invokingState) 

5910 self.parser = parser 

5911 

5912 def atom_expr(self): 

5913 return self.getTypedRuleContext(Python3Parser.Atom_exprContext,0) 

5914 

5915 

5916 def POWER(self): 

5917 return self.getToken(Python3Parser.POWER, 0) 

5918 

5919 def factor(self): 

5920 return self.getTypedRuleContext(Python3Parser.FactorContext,0) 

5921 

5922 

5923 def getRuleIndex(self): 

5924 return Python3Parser.RULE_power 

5925 

5926 def enterRule(self, listener:ParseTreeListener): 

5927 if hasattr( listener, "enterPower" ): 

5928 listener.enterPower(self) 

5929 

5930 def exitRule(self, listener:ParseTreeListener): 

5931 if hasattr( listener, "exitPower" ): 

5932 listener.exitPower(self) 

5933 

5934 

5935 

5936 

5937 def power(self): 

5938 

5939 localctx = Python3Parser.PowerContext(self, self._ctx, self.state) 

5940 self.enterRule(localctx, 132, self.RULE_power) 

5941 self._la = 0 # Token type 

5942 try: 

5943 self.enterOuterAlt(localctx, 1) 

5944 self.state = 853 

5945 self.atom_expr() 

5946 self.state = 856 

5947 self._errHandler.sync(self) 

5948 _la = self._input.LA(1) 

5949 if _la==Python3Parser.POWER: 

5950 self.state = 854 

5951 self.match(Python3Parser.POWER) 

5952 self.state = 855 

5953 self.factor() 

5954 

5955 

5956 except RecognitionException as re: 

5957 localctx.exception = re 

5958 self._errHandler.reportError(self, re) 

5959 self._errHandler.recover(self, re) 

5960 finally: 

5961 self.exitRule() 

5962 return localctx 

5963 

5964 

5965 class Atom_exprContext(ParserRuleContext): 

5966 __slots__ = 'parser' 

5967 

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

5969 super().__init__(parent, invokingState) 

5970 self.parser = parser 

5971 

5972 def atom(self): 

5973 return self.getTypedRuleContext(Python3Parser.AtomContext,0) 

5974 

5975 

5976 def AWAIT(self): 

5977 return self.getToken(Python3Parser.AWAIT, 0) 

5978 

5979 def trailer(self, i:int=None): 

5980 if i is None: 

5981 return self.getTypedRuleContexts(Python3Parser.TrailerContext) 

5982 else: 

5983 return self.getTypedRuleContext(Python3Parser.TrailerContext,i) 

5984 

5985 

5986 def getRuleIndex(self): 

5987 return Python3Parser.RULE_atom_expr 

5988 

5989 def enterRule(self, listener:ParseTreeListener): 

5990 if hasattr( listener, "enterAtom_expr" ): 

5991 listener.enterAtom_expr(self) 

5992 

5993 def exitRule(self, listener:ParseTreeListener): 

5994 if hasattr( listener, "exitAtom_expr" ): 

5995 listener.exitAtom_expr(self) 

5996 

5997 

5998 

5999 

6000 def atom_expr(self): 

6001 

6002 localctx = Python3Parser.Atom_exprContext(self, self._ctx, self.state) 

6003 self.enterRule(localctx, 134, self.RULE_atom_expr) 

6004 self._la = 0 # Token type 

6005 try: 

6006 self.enterOuterAlt(localctx, 1) 

6007 self.state = 859 

6008 self._errHandler.sync(self) 

6009 _la = self._input.LA(1) 

6010 if _la==Python3Parser.AWAIT: 

6011 self.state = 858 

6012 self.match(Python3Parser.AWAIT) 

6013 

6014 

6015 self.state = 861 

6016 self.atom() 

6017 self.state = 865 

6018 self._errHandler.sync(self) 

6019 _la = self._input.LA(1) 

6020 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.DOT) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0): 

6021 self.state = 862 

6022 self.trailer() 

6023 self.state = 867 

6024 self._errHandler.sync(self) 

6025 _la = self._input.LA(1) 

6026 

6027 except RecognitionException as re: 

6028 localctx.exception = re 

6029 self._errHandler.reportError(self, re) 

6030 self._errHandler.recover(self, re) 

6031 finally: 

6032 self.exitRule() 

6033 return localctx 

6034 

6035 

6036 class AtomContext(ParserRuleContext): 

6037 __slots__ = 'parser' 

6038 

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

6040 super().__init__(parent, invokingState) 

6041 self.parser = parser 

6042 

6043 def OPEN_PAREN(self): 

6044 return self.getToken(Python3Parser.OPEN_PAREN, 0) 

6045 

6046 def CLOSE_PAREN(self): 

6047 return self.getToken(Python3Parser.CLOSE_PAREN, 0) 

6048 

6049 def OPEN_BRACK(self): 

6050 return self.getToken(Python3Parser.OPEN_BRACK, 0) 

6051 

6052 def CLOSE_BRACK(self): 

6053 return self.getToken(Python3Parser.CLOSE_BRACK, 0) 

6054 

6055 def OPEN_BRACE(self): 

6056 return self.getToken(Python3Parser.OPEN_BRACE, 0) 

6057 

6058 def CLOSE_BRACE(self): 

6059 return self.getToken(Python3Parser.CLOSE_BRACE, 0) 

6060 

6061 def NAME(self): 

6062 return self.getToken(Python3Parser.NAME, 0) 

6063 

6064 def NUMBER(self): 

6065 return self.getToken(Python3Parser.NUMBER, 0) 

6066 

6067 def ELLIPSIS(self): 

6068 return self.getToken(Python3Parser.ELLIPSIS, 0) 

6069 

6070 def NONE(self): 

6071 return self.getToken(Python3Parser.NONE, 0) 

6072 

6073 def TRUE(self): 

6074 return self.getToken(Python3Parser.TRUE, 0) 

6075 

6076 def FALSE(self): 

6077 return self.getToken(Python3Parser.FALSE, 0) 

6078 

6079 def yield_expr(self): 

6080 return self.getTypedRuleContext(Python3Parser.Yield_exprContext,0) 

6081 

6082 

6083 def testlist_comp(self): 

6084 return self.getTypedRuleContext(Python3Parser.Testlist_compContext,0) 

6085 

6086 

6087 def dictorsetmaker(self): 

6088 return self.getTypedRuleContext(Python3Parser.DictorsetmakerContext,0) 

6089 

6090 

6091 def STRING(self, i:int=None): 

6092 if i is None: 

6093 return self.getTokens(Python3Parser.STRING) 

6094 else: 

6095 return self.getToken(Python3Parser.STRING, i) 

6096 

6097 def getRuleIndex(self): 

6098 return Python3Parser.RULE_atom 

6099 

6100 def enterRule(self, listener:ParseTreeListener): 

6101 if hasattr( listener, "enterAtom" ): 

6102 listener.enterAtom(self) 

6103 

6104 def exitRule(self, listener:ParseTreeListener): 

6105 if hasattr( listener, "exitAtom" ): 

6106 listener.exitAtom(self) 

6107 

6108 

6109 

6110 

6111 def atom(self): 

6112 

6113 localctx = Python3Parser.AtomContext(self, self._ctx, self.state) 

6114 self.enterRule(localctx, 136, self.RULE_atom) 

6115 self._la = 0 # Token type 

6116 try: 

6117 self.enterOuterAlt(localctx, 1) 

6118 self.state = 895 

6119 self._errHandler.sync(self) 

6120 token = self._input.LA(1) 

6121 if token in [Python3Parser.OPEN_PAREN]: 

6122 self.state = 868 

6123 self.match(Python3Parser.OPEN_PAREN) 

6124 self.state = 871 

6125 self._errHandler.sync(self) 

6126 token = self._input.LA(1) 

6127 if token in [Python3Parser.YIELD]: 

6128 self.state = 869 

6129 self.yield_expr() 

6130 pass 

6131 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

6132 self.state = 870 

6133 self.testlist_comp() 

6134 pass 

6135 elif token in [Python3Parser.CLOSE_PAREN]: 

6136 pass 

6137 else: 

6138 pass 

6139 self.state = 873 

6140 self.match(Python3Parser.CLOSE_PAREN) 

6141 pass 

6142 elif token in [Python3Parser.OPEN_BRACK]: 

6143 self.state = 874 

6144 self.match(Python3Parser.OPEN_BRACK) 

6145 self.state = 876 

6146 self._errHandler.sync(self) 

6147 _la = self._input.LA(1) 

6148 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

6149 self.state = 875 

6150 self.testlist_comp() 

6151 

6152 

6153 self.state = 878 

6154 self.match(Python3Parser.CLOSE_BRACK) 

6155 pass 

6156 elif token in [Python3Parser.OPEN_BRACE]: 

6157 self.state = 879 

6158 self.match(Python3Parser.OPEN_BRACE) 

6159 self.state = 881 

6160 self._errHandler.sync(self) 

6161 _la = self._input.LA(1) 

6162 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.POWER) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

6163 self.state = 880 

6164 self.dictorsetmaker() 

6165 

6166 

6167 self.state = 883 

6168 self.match(Python3Parser.CLOSE_BRACE) 

6169 pass 

6170 elif token in [Python3Parser.NAME]: 

6171 self.state = 884 

6172 self.match(Python3Parser.NAME) 

6173 pass 

6174 elif token in [Python3Parser.NUMBER]: 

6175 self.state = 885 

6176 self.match(Python3Parser.NUMBER) 

6177 pass 

6178 elif token in [Python3Parser.STRING]: 

6179 self.state = 887 

6180 self._errHandler.sync(self) 

6181 _la = self._input.LA(1) 

6182 while True: 

6183 self.state = 886 

6184 self.match(Python3Parser.STRING) 

6185 self.state = 889 

6186 self._errHandler.sync(self) 

6187 _la = self._input.LA(1) 

6188 if not (_la==Python3Parser.STRING): 

6189 break 

6190 

6191 pass 

6192 elif token in [Python3Parser.ELLIPSIS]: 

6193 self.state = 891 

6194 self.match(Python3Parser.ELLIPSIS) 

6195 pass 

6196 elif token in [Python3Parser.NONE]: 

6197 self.state = 892 

6198 self.match(Python3Parser.NONE) 

6199 pass 

6200 elif token in [Python3Parser.TRUE]: 

6201 self.state = 893 

6202 self.match(Python3Parser.TRUE) 

6203 pass 

6204 elif token in [Python3Parser.FALSE]: 

6205 self.state = 894 

6206 self.match(Python3Parser.FALSE) 

6207 pass 

6208 else: 

6209 raise NoViableAltException(self) 

6210 

6211 except RecognitionException as re: 

6212 localctx.exception = re 

6213 self._errHandler.reportError(self, re) 

6214 self._errHandler.recover(self, re) 

6215 finally: 

6216 self.exitRule() 

6217 return localctx 

6218 

6219 

6220 class Testlist_compContext(ParserRuleContext): 

6221 __slots__ = 'parser' 

6222 

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

6224 super().__init__(parent, invokingState) 

6225 self.parser = parser 

6226 

6227 def test(self, i:int=None): 

6228 if i is None: 

6229 return self.getTypedRuleContexts(Python3Parser.TestContext) 

6230 else: 

6231 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

6232 

6233 

6234 def star_expr(self, i:int=None): 

6235 if i is None: 

6236 return self.getTypedRuleContexts(Python3Parser.Star_exprContext) 

6237 else: 

6238 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i) 

6239 

6240 

6241 def comp_for(self): 

6242 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0) 

6243 

6244 

6245 def COMMA(self, i:int=None): 

6246 if i is None: 

6247 return self.getTokens(Python3Parser.COMMA) 

6248 else: 

6249 return self.getToken(Python3Parser.COMMA, i) 

6250 

6251 def getRuleIndex(self): 

6252 return Python3Parser.RULE_testlist_comp 

6253 

6254 def enterRule(self, listener:ParseTreeListener): 

6255 if hasattr( listener, "enterTestlist_comp" ): 

6256 listener.enterTestlist_comp(self) 

6257 

6258 def exitRule(self, listener:ParseTreeListener): 

6259 if hasattr( listener, "exitTestlist_comp" ): 

6260 listener.exitTestlist_comp(self) 

6261 

6262 

6263 

6264 

6265 def testlist_comp(self): 

6266 

6267 localctx = Python3Parser.Testlist_compContext(self, self._ctx, self.state) 

6268 self.enterRule(localctx, 138, self.RULE_testlist_comp) 

6269 self._la = 0 # Token type 

6270 try: 

6271 self.enterOuterAlt(localctx, 1) 

6272 self.state = 899 

6273 self._errHandler.sync(self) 

6274 token = self._input.LA(1) 

6275 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

6276 self.state = 897 

6277 self.test() 

6278 pass 

6279 elif token in [Python3Parser.STAR]: 

6280 self.state = 898 

6281 self.star_expr() 

6282 pass 

6283 else: 

6284 raise NoViableAltException(self) 

6285 

6286 self.state = 915 

6287 self._errHandler.sync(self) 

6288 token = self._input.LA(1) 

6289 if token in [Python3Parser.FOR, Python3Parser.ASYNC]: 

6290 self.state = 901 

6291 self.comp_for() 

6292 pass 

6293 elif token in [Python3Parser.CLOSE_PAREN, Python3Parser.COMMA, Python3Parser.CLOSE_BRACK]: 

6294 self.state = 909 

6295 self._errHandler.sync(self) 

6296 _alt = self._interp.adaptivePredict(self._input,125,self._ctx) 

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

6298 if _alt==1: 

6299 self.state = 902 

6300 self.match(Python3Parser.COMMA) 

6301 self.state = 905 

6302 self._errHandler.sync(self) 

6303 token = self._input.LA(1) 

6304 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

6305 self.state = 903 

6306 self.test() 

6307 pass 

6308 elif token in [Python3Parser.STAR]: 

6309 self.state = 904 

6310 self.star_expr() 

6311 pass 

6312 else: 

6313 raise NoViableAltException(self) 

6314 

6315 self.state = 911 

6316 self._errHandler.sync(self) 

6317 _alt = self._interp.adaptivePredict(self._input,125,self._ctx) 

6318 

6319 self.state = 913 

6320 self._errHandler.sync(self) 

6321 _la = self._input.LA(1) 

6322 if _la==Python3Parser.COMMA: 

6323 self.state = 912 

6324 self.match(Python3Parser.COMMA) 

6325 

6326 

6327 pass 

6328 else: 

6329 raise NoViableAltException(self) 

6330 

6331 except RecognitionException as re: 

6332 localctx.exception = re 

6333 self._errHandler.reportError(self, re) 

6334 self._errHandler.recover(self, re) 

6335 finally: 

6336 self.exitRule() 

6337 return localctx 

6338 

6339 

6340 class TrailerContext(ParserRuleContext): 

6341 __slots__ = 'parser' 

6342 

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

6344 super().__init__(parent, invokingState) 

6345 self.parser = parser 

6346 

6347 def OPEN_PAREN(self): 

6348 return self.getToken(Python3Parser.OPEN_PAREN, 0) 

6349 

6350 def CLOSE_PAREN(self): 

6351 return self.getToken(Python3Parser.CLOSE_PAREN, 0) 

6352 

6353 def arglist(self): 

6354 return self.getTypedRuleContext(Python3Parser.ArglistContext,0) 

6355 

6356 

6357 def OPEN_BRACK(self): 

6358 return self.getToken(Python3Parser.OPEN_BRACK, 0) 

6359 

6360 def subscriptlist(self): 

6361 return self.getTypedRuleContext(Python3Parser.SubscriptlistContext,0) 

6362 

6363 

6364 def CLOSE_BRACK(self): 

6365 return self.getToken(Python3Parser.CLOSE_BRACK, 0) 

6366 

6367 def DOT(self): 

6368 return self.getToken(Python3Parser.DOT, 0) 

6369 

6370 def NAME(self): 

6371 return self.getToken(Python3Parser.NAME, 0) 

6372 

6373 def getRuleIndex(self): 

6374 return Python3Parser.RULE_trailer 

6375 

6376 def enterRule(self, listener:ParseTreeListener): 

6377 if hasattr( listener, "enterTrailer" ): 

6378 listener.enterTrailer(self) 

6379 

6380 def exitRule(self, listener:ParseTreeListener): 

6381 if hasattr( listener, "exitTrailer" ): 

6382 listener.exitTrailer(self) 

6383 

6384 

6385 

6386 

6387 def trailer(self): 

6388 

6389 localctx = Python3Parser.TrailerContext(self, self._ctx, self.state) 

6390 self.enterRule(localctx, 140, self.RULE_trailer) 

6391 self._la = 0 # Token type 

6392 try: 

6393 self.state = 928 

6394 self._errHandler.sync(self) 

6395 token = self._input.LA(1) 

6396 if token in [Python3Parser.OPEN_PAREN]: 

6397 self.enterOuterAlt(localctx, 1) 

6398 self.state = 917 

6399 self.match(Python3Parser.OPEN_PAREN) 

6400 self.state = 919 

6401 self._errHandler.sync(self) 

6402 _la = self._input.LA(1) 

6403 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.POWER) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

6404 self.state = 918 

6405 self.arglist() 

6406 

6407 

6408 self.state = 921 

6409 self.match(Python3Parser.CLOSE_PAREN) 

6410 pass 

6411 elif token in [Python3Parser.OPEN_BRACK]: 

6412 self.enterOuterAlt(localctx, 2) 

6413 self.state = 922 

6414 self.match(Python3Parser.OPEN_BRACK) 

6415 self.state = 923 

6416 self.subscriptlist() 

6417 self.state = 924 

6418 self.match(Python3Parser.CLOSE_BRACK) 

6419 pass 

6420 elif token in [Python3Parser.DOT]: 

6421 self.enterOuterAlt(localctx, 3) 

6422 self.state = 926 

6423 self.match(Python3Parser.DOT) 

6424 self.state = 927 

6425 self.match(Python3Parser.NAME) 

6426 pass 

6427 else: 

6428 raise NoViableAltException(self) 

6429 

6430 except RecognitionException as re: 

6431 localctx.exception = re 

6432 self._errHandler.reportError(self, re) 

6433 self._errHandler.recover(self, re) 

6434 finally: 

6435 self.exitRule() 

6436 return localctx 

6437 

6438 

6439 class SubscriptlistContext(ParserRuleContext): 

6440 __slots__ = 'parser' 

6441 

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

6443 super().__init__(parent, invokingState) 

6444 self.parser = parser 

6445 

6446 def subscript(self, i:int=None): 

6447 if i is None: 

6448 return self.getTypedRuleContexts(Python3Parser.SubscriptContext) 

6449 else: 

6450 return self.getTypedRuleContext(Python3Parser.SubscriptContext,i) 

6451 

6452 

6453 def COMMA(self, i:int=None): 

6454 if i is None: 

6455 return self.getTokens(Python3Parser.COMMA) 

6456 else: 

6457 return self.getToken(Python3Parser.COMMA, i) 

6458 

6459 def getRuleIndex(self): 

6460 return Python3Parser.RULE_subscriptlist 

6461 

6462 def enterRule(self, listener:ParseTreeListener): 

6463 if hasattr( listener, "enterSubscriptlist" ): 

6464 listener.enterSubscriptlist(self) 

6465 

6466 def exitRule(self, listener:ParseTreeListener): 

6467 if hasattr( listener, "exitSubscriptlist" ): 

6468 listener.exitSubscriptlist(self) 

6469 

6470 

6471 

6472 

6473 def subscriptlist(self): 

6474 

6475 localctx = Python3Parser.SubscriptlistContext(self, self._ctx, self.state) 

6476 self.enterRule(localctx, 142, self.RULE_subscriptlist) 

6477 self._la = 0 # Token type 

6478 try: 

6479 self.enterOuterAlt(localctx, 1) 

6480 self.state = 930 

6481 self.subscript() 

6482 self.state = 935 

6483 self._errHandler.sync(self) 

6484 _alt = self._interp.adaptivePredict(self._input,130,self._ctx) 

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

6486 if _alt==1: 

6487 self.state = 931 

6488 self.match(Python3Parser.COMMA) 

6489 self.state = 932 

6490 self.subscript() 

6491 self.state = 937 

6492 self._errHandler.sync(self) 

6493 _alt = self._interp.adaptivePredict(self._input,130,self._ctx) 

6494 

6495 self.state = 939 

6496 self._errHandler.sync(self) 

6497 _la = self._input.LA(1) 

6498 if _la==Python3Parser.COMMA: 

6499 self.state = 938 

6500 self.match(Python3Parser.COMMA) 

6501 

6502 

6503 except RecognitionException as re: 

6504 localctx.exception = re 

6505 self._errHandler.reportError(self, re) 

6506 self._errHandler.recover(self, re) 

6507 finally: 

6508 self.exitRule() 

6509 return localctx 

6510 

6511 

6512 class SubscriptContext(ParserRuleContext): 

6513 __slots__ = 'parser' 

6514 

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

6516 super().__init__(parent, invokingState) 

6517 self.parser = parser 

6518 

6519 def test(self, i:int=None): 

6520 if i is None: 

6521 return self.getTypedRuleContexts(Python3Parser.TestContext) 

6522 else: 

6523 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

6524 

6525 

6526 def COLON(self): 

6527 return self.getToken(Python3Parser.COLON, 0) 

6528 

6529 def sliceop(self): 

6530 return self.getTypedRuleContext(Python3Parser.SliceopContext,0) 

6531 

6532 

6533 def getRuleIndex(self): 

6534 return Python3Parser.RULE_subscript 

6535 

6536 def enterRule(self, listener:ParseTreeListener): 

6537 if hasattr( listener, "enterSubscript" ): 

6538 listener.enterSubscript(self) 

6539 

6540 def exitRule(self, listener:ParseTreeListener): 

6541 if hasattr( listener, "exitSubscript" ): 

6542 listener.exitSubscript(self) 

6543 

6544 

6545 

6546 

6547 def subscript(self): 

6548 

6549 localctx = Python3Parser.SubscriptContext(self, self._ctx, self.state) 

6550 self.enterRule(localctx, 144, self.RULE_subscript) 

6551 self._la = 0 # Token type 

6552 try: 

6553 self.state = 952 

6554 self._errHandler.sync(self) 

6555 la_ = self._interp.adaptivePredict(self._input,135,self._ctx) 

6556 if la_ == 1: 

6557 self.enterOuterAlt(localctx, 1) 

6558 self.state = 941 

6559 self.test() 

6560 pass 

6561 

6562 elif la_ == 2: 

6563 self.enterOuterAlt(localctx, 2) 

6564 self.state = 943 

6565 self._errHandler.sync(self) 

6566 _la = self._input.LA(1) 

6567 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

6568 self.state = 942 

6569 self.test() 

6570 

6571 

6572 self.state = 945 

6573 self.match(Python3Parser.COLON) 

6574 self.state = 947 

6575 self._errHandler.sync(self) 

6576 _la = self._input.LA(1) 

6577 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

6578 self.state = 946 

6579 self.test() 

6580 

6581 

6582 self.state = 950 

6583 self._errHandler.sync(self) 

6584 _la = self._input.LA(1) 

6585 if _la==Python3Parser.COLON: 

6586 self.state = 949 

6587 self.sliceop() 

6588 

6589 

6590 pass 

6591 

6592 

6593 except RecognitionException as re: 

6594 localctx.exception = re 

6595 self._errHandler.reportError(self, re) 

6596 self._errHandler.recover(self, re) 

6597 finally: 

6598 self.exitRule() 

6599 return localctx 

6600 

6601 

6602 class SliceopContext(ParserRuleContext): 

6603 __slots__ = 'parser' 

6604 

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

6606 super().__init__(parent, invokingState) 

6607 self.parser = parser 

6608 

6609 def COLON(self): 

6610 return self.getToken(Python3Parser.COLON, 0) 

6611 

6612 def test(self): 

6613 return self.getTypedRuleContext(Python3Parser.TestContext,0) 

6614 

6615 

6616 def getRuleIndex(self): 

6617 return Python3Parser.RULE_sliceop 

6618 

6619 def enterRule(self, listener:ParseTreeListener): 

6620 if hasattr( listener, "enterSliceop" ): 

6621 listener.enterSliceop(self) 

6622 

6623 def exitRule(self, listener:ParseTreeListener): 

6624 if hasattr( listener, "exitSliceop" ): 

6625 listener.exitSliceop(self) 

6626 

6627 

6628 

6629 

6630 def sliceop(self): 

6631 

6632 localctx = Python3Parser.SliceopContext(self, self._ctx, self.state) 

6633 self.enterRule(localctx, 146, self.RULE_sliceop) 

6634 self._la = 0 # Token type 

6635 try: 

6636 self.enterOuterAlt(localctx, 1) 

6637 self.state = 954 

6638 self.match(Python3Parser.COLON) 

6639 self.state = 956 

6640 self._errHandler.sync(self) 

6641 _la = self._input.LA(1) 

6642 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

6643 self.state = 955 

6644 self.test() 

6645 

6646 

6647 except RecognitionException as re: 

6648 localctx.exception = re 

6649 self._errHandler.reportError(self, re) 

6650 self._errHandler.recover(self, re) 

6651 finally: 

6652 self.exitRule() 

6653 return localctx 

6654 

6655 

6656 class ExprlistContext(ParserRuleContext): 

6657 __slots__ = 'parser' 

6658 

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

6660 super().__init__(parent, invokingState) 

6661 self.parser = parser 

6662 

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

6664 if i is None: 

6665 return self.getTypedRuleContexts(Python3Parser.ExprContext) 

6666 else: 

6667 return self.getTypedRuleContext(Python3Parser.ExprContext,i) 

6668 

6669 

6670 def star_expr(self, i:int=None): 

6671 if i is None: 

6672 return self.getTypedRuleContexts(Python3Parser.Star_exprContext) 

6673 else: 

6674 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i) 

6675 

6676 

6677 def COMMA(self, i:int=None): 

6678 if i is None: 

6679 return self.getTokens(Python3Parser.COMMA) 

6680 else: 

6681 return self.getToken(Python3Parser.COMMA, i) 

6682 

6683 def getRuleIndex(self): 

6684 return Python3Parser.RULE_exprlist 

6685 

6686 def enterRule(self, listener:ParseTreeListener): 

6687 if hasattr( listener, "enterExprlist" ): 

6688 listener.enterExprlist(self) 

6689 

6690 def exitRule(self, listener:ParseTreeListener): 

6691 if hasattr( listener, "exitExprlist" ): 

6692 listener.exitExprlist(self) 

6693 

6694 

6695 

6696 

6697 def exprlist(self): 

6698 

6699 localctx = Python3Parser.ExprlistContext(self, self._ctx, self.state) 

6700 self.enterRule(localctx, 148, self.RULE_exprlist) 

6701 self._la = 0 # Token type 

6702 try: 

6703 self.enterOuterAlt(localctx, 1) 

6704 self.state = 960 

6705 self._errHandler.sync(self) 

6706 token = self._input.LA(1) 

6707 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

6708 self.state = 958 

6709 self.expr() 

6710 pass 

6711 elif token in [Python3Parser.STAR]: 

6712 self.state = 959 

6713 self.star_expr() 

6714 pass 

6715 else: 

6716 raise NoViableAltException(self) 

6717 

6718 self.state = 969 

6719 self._errHandler.sync(self) 

6720 _alt = self._interp.adaptivePredict(self._input,139,self._ctx) 

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

6722 if _alt==1: 

6723 self.state = 962 

6724 self.match(Python3Parser.COMMA) 

6725 self.state = 965 

6726 self._errHandler.sync(self) 

6727 token = self._input.LA(1) 

6728 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

6729 self.state = 963 

6730 self.expr() 

6731 pass 

6732 elif token in [Python3Parser.STAR]: 

6733 self.state = 964 

6734 self.star_expr() 

6735 pass 

6736 else: 

6737 raise NoViableAltException(self) 

6738 

6739 self.state = 971 

6740 self._errHandler.sync(self) 

6741 _alt = self._interp.adaptivePredict(self._input,139,self._ctx) 

6742 

6743 self.state = 973 

6744 self._errHandler.sync(self) 

6745 _la = self._input.LA(1) 

6746 if _la==Python3Parser.COMMA: 

6747 self.state = 972 

6748 self.match(Python3Parser.COMMA) 

6749 

6750 

6751 except RecognitionException as re: 

6752 localctx.exception = re 

6753 self._errHandler.reportError(self, re) 

6754 self._errHandler.recover(self, re) 

6755 finally: 

6756 self.exitRule() 

6757 return localctx 

6758 

6759 

6760 class TestlistContext(ParserRuleContext): 

6761 __slots__ = 'parser' 

6762 

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

6764 super().__init__(parent, invokingState) 

6765 self.parser = parser 

6766 

6767 def test(self, i:int=None): 

6768 if i is None: 

6769 return self.getTypedRuleContexts(Python3Parser.TestContext) 

6770 else: 

6771 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

6772 

6773 

6774 def COMMA(self, i:int=None): 

6775 if i is None: 

6776 return self.getTokens(Python3Parser.COMMA) 

6777 else: 

6778 return self.getToken(Python3Parser.COMMA, i) 

6779 

6780 def getRuleIndex(self): 

6781 return Python3Parser.RULE_testlist 

6782 

6783 def enterRule(self, listener:ParseTreeListener): 

6784 if hasattr( listener, "enterTestlist" ): 

6785 listener.enterTestlist(self) 

6786 

6787 def exitRule(self, listener:ParseTreeListener): 

6788 if hasattr( listener, "exitTestlist" ): 

6789 listener.exitTestlist(self) 

6790 

6791 

6792 

6793 

6794 def testlist(self): 

6795 

6796 localctx = Python3Parser.TestlistContext(self, self._ctx, self.state) 

6797 self.enterRule(localctx, 150, self.RULE_testlist) 

6798 self._la = 0 # Token type 

6799 try: 

6800 self.enterOuterAlt(localctx, 1) 

6801 self.state = 975 

6802 self.test() 

6803 self.state = 980 

6804 self._errHandler.sync(self) 

6805 _alt = self._interp.adaptivePredict(self._input,141,self._ctx) 

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

6807 if _alt==1: 

6808 self.state = 976 

6809 self.match(Python3Parser.COMMA) 

6810 self.state = 977 

6811 self.test() 

6812 self.state = 982 

6813 self._errHandler.sync(self) 

6814 _alt = self._interp.adaptivePredict(self._input,141,self._ctx) 

6815 

6816 self.state = 984 

6817 self._errHandler.sync(self) 

6818 _la = self._input.LA(1) 

6819 if _la==Python3Parser.COMMA: 

6820 self.state = 983 

6821 self.match(Python3Parser.COMMA) 

6822 

6823 

6824 except RecognitionException as re: 

6825 localctx.exception = re 

6826 self._errHandler.reportError(self, re) 

6827 self._errHandler.recover(self, re) 

6828 finally: 

6829 self.exitRule() 

6830 return localctx 

6831 

6832 

6833 class DictorsetmakerContext(ParserRuleContext): 

6834 __slots__ = 'parser' 

6835 

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

6837 super().__init__(parent, invokingState) 

6838 self.parser = parser 

6839 

6840 def test(self, i:int=None): 

6841 if i is None: 

6842 return self.getTypedRuleContexts(Python3Parser.TestContext) 

6843 else: 

6844 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

6845 

6846 

6847 def COLON(self, i:int=None): 

6848 if i is None: 

6849 return self.getTokens(Python3Parser.COLON) 

6850 else: 

6851 return self.getToken(Python3Parser.COLON, i) 

6852 

6853 def POWER(self, i:int=None): 

6854 if i is None: 

6855 return self.getTokens(Python3Parser.POWER) 

6856 else: 

6857 return self.getToken(Python3Parser.POWER, i) 

6858 

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

6860 if i is None: 

6861 return self.getTypedRuleContexts(Python3Parser.ExprContext) 

6862 else: 

6863 return self.getTypedRuleContext(Python3Parser.ExprContext,i) 

6864 

6865 

6866 def comp_for(self): 

6867 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0) 

6868 

6869 

6870 def star_expr(self, i:int=None): 

6871 if i is None: 

6872 return self.getTypedRuleContexts(Python3Parser.Star_exprContext) 

6873 else: 

6874 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i) 

6875 

6876 

6877 def COMMA(self, i:int=None): 

6878 if i is None: 

6879 return self.getTokens(Python3Parser.COMMA) 

6880 else: 

6881 return self.getToken(Python3Parser.COMMA, i) 

6882 

6883 def getRuleIndex(self): 

6884 return Python3Parser.RULE_dictorsetmaker 

6885 

6886 def enterRule(self, listener:ParseTreeListener): 

6887 if hasattr( listener, "enterDictorsetmaker" ): 

6888 listener.enterDictorsetmaker(self) 

6889 

6890 def exitRule(self, listener:ParseTreeListener): 

6891 if hasattr( listener, "exitDictorsetmaker" ): 

6892 listener.exitDictorsetmaker(self) 

6893 

6894 

6895 

6896 

6897 def dictorsetmaker(self): 

6898 

6899 localctx = Python3Parser.DictorsetmakerContext(self, self._ctx, self.state) 

6900 self.enterRule(localctx, 152, self.RULE_dictorsetmaker) 

6901 self._la = 0 # Token type 

6902 try: 

6903 self.enterOuterAlt(localctx, 1) 

6904 self.state = 1034 

6905 self._errHandler.sync(self) 

6906 la_ = self._interp.adaptivePredict(self._input,153,self._ctx) 

6907 if la_ == 1: 

6908 self.state = 992 

6909 self._errHandler.sync(self) 

6910 token = self._input.LA(1) 

6911 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

6912 self.state = 986 

6913 self.test() 

6914 self.state = 987 

6915 self.match(Python3Parser.COLON) 

6916 self.state = 988 

6917 self.test() 

6918 pass 

6919 elif token in [Python3Parser.POWER]: 

6920 self.state = 990 

6921 self.match(Python3Parser.POWER) 

6922 self.state = 991 

6923 self.expr() 

6924 pass 

6925 else: 

6926 raise NoViableAltException(self) 

6927 

6928 self.state = 1012 

6929 self._errHandler.sync(self) 

6930 token = self._input.LA(1) 

6931 if token in [Python3Parser.FOR, Python3Parser.ASYNC]: 

6932 self.state = 994 

6933 self.comp_for() 

6934 pass 

6935 elif token in [Python3Parser.COMMA, Python3Parser.CLOSE_BRACE]: 

6936 self.state = 1006 

6937 self._errHandler.sync(self) 

6938 _alt = self._interp.adaptivePredict(self._input,145,self._ctx) 

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

6940 if _alt==1: 

6941 self.state = 995 

6942 self.match(Python3Parser.COMMA) 

6943 self.state = 1002 

6944 self._errHandler.sync(self) 

6945 token = self._input.LA(1) 

6946 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

6947 self.state = 996 

6948 self.test() 

6949 self.state = 997 

6950 self.match(Python3Parser.COLON) 

6951 self.state = 998 

6952 self.test() 

6953 pass 

6954 elif token in [Python3Parser.POWER]: 

6955 self.state = 1000 

6956 self.match(Python3Parser.POWER) 

6957 self.state = 1001 

6958 self.expr() 

6959 pass 

6960 else: 

6961 raise NoViableAltException(self) 

6962 

6963 self.state = 1008 

6964 self._errHandler.sync(self) 

6965 _alt = self._interp.adaptivePredict(self._input,145,self._ctx) 

6966 

6967 self.state = 1010 

6968 self._errHandler.sync(self) 

6969 _la = self._input.LA(1) 

6970 if _la==Python3Parser.COMMA: 

6971 self.state = 1009 

6972 self.match(Python3Parser.COMMA) 

6973 

6974 

6975 pass 

6976 else: 

6977 raise NoViableAltException(self) 

6978 

6979 pass 

6980 

6981 elif la_ == 2: 

6982 self.state = 1016 

6983 self._errHandler.sync(self) 

6984 token = self._input.LA(1) 

6985 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

6986 self.state = 1014 

6987 self.test() 

6988 pass 

6989 elif token in [Python3Parser.STAR]: 

6990 self.state = 1015 

6991 self.star_expr() 

6992 pass 

6993 else: 

6994 raise NoViableAltException(self) 

6995 

6996 self.state = 1032 

6997 self._errHandler.sync(self) 

6998 token = self._input.LA(1) 

6999 if token in [Python3Parser.FOR, Python3Parser.ASYNC]: 

7000 self.state = 1018 

7001 self.comp_for() 

7002 pass 

7003 elif token in [Python3Parser.COMMA, Python3Parser.CLOSE_BRACE]: 

7004 self.state = 1026 

7005 self._errHandler.sync(self) 

7006 _alt = self._interp.adaptivePredict(self._input,150,self._ctx) 

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

7008 if _alt==1: 

7009 self.state = 1019 

7010 self.match(Python3Parser.COMMA) 

7011 self.state = 1022 

7012 self._errHandler.sync(self) 

7013 token = self._input.LA(1) 

7014 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

7015 self.state = 1020 

7016 self.test() 

7017 pass 

7018 elif token in [Python3Parser.STAR]: 

7019 self.state = 1021 

7020 self.star_expr() 

7021 pass 

7022 else: 

7023 raise NoViableAltException(self) 

7024 

7025 self.state = 1028 

7026 self._errHandler.sync(self) 

7027 _alt = self._interp.adaptivePredict(self._input,150,self._ctx) 

7028 

7029 self.state = 1030 

7030 self._errHandler.sync(self) 

7031 _la = self._input.LA(1) 

7032 if _la==Python3Parser.COMMA: 

7033 self.state = 1029 

7034 self.match(Python3Parser.COMMA) 

7035 

7036 

7037 pass 

7038 else: 

7039 raise NoViableAltException(self) 

7040 

7041 pass 

7042 

7043 

7044 except RecognitionException as re: 

7045 localctx.exception = re 

7046 self._errHandler.reportError(self, re) 

7047 self._errHandler.recover(self, re) 

7048 finally: 

7049 self.exitRule() 

7050 return localctx 

7051 

7052 

7053 class ClassdefContext(ParserRuleContext): 

7054 __slots__ = 'parser' 

7055 

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

7057 super().__init__(parent, invokingState) 

7058 self.parser = parser 

7059 

7060 def CLASS(self): 

7061 return self.getToken(Python3Parser.CLASS, 0) 

7062 

7063 def NAME(self): 

7064 return self.getToken(Python3Parser.NAME, 0) 

7065 

7066 def COLON(self): 

7067 return self.getToken(Python3Parser.COLON, 0) 

7068 

7069 def suite(self): 

7070 return self.getTypedRuleContext(Python3Parser.SuiteContext,0) 

7071 

7072 

7073 def OPEN_PAREN(self): 

7074 return self.getToken(Python3Parser.OPEN_PAREN, 0) 

7075 

7076 def CLOSE_PAREN(self): 

7077 return self.getToken(Python3Parser.CLOSE_PAREN, 0) 

7078 

7079 def arglist(self): 

7080 return self.getTypedRuleContext(Python3Parser.ArglistContext,0) 

7081 

7082 

7083 def getRuleIndex(self): 

7084 return Python3Parser.RULE_classdef 

7085 

7086 def enterRule(self, listener:ParseTreeListener): 

7087 if hasattr( listener, "enterClassdef" ): 

7088 listener.enterClassdef(self) 

7089 

7090 def exitRule(self, listener:ParseTreeListener): 

7091 if hasattr( listener, "exitClassdef" ): 

7092 listener.exitClassdef(self) 

7093 

7094 

7095 

7096 

7097 def classdef(self): 

7098 

7099 localctx = Python3Parser.ClassdefContext(self, self._ctx, self.state) 

7100 self.enterRule(localctx, 154, self.RULE_classdef) 

7101 self._la = 0 # Token type 

7102 try: 

7103 self.enterOuterAlt(localctx, 1) 

7104 self.state = 1036 

7105 self.match(Python3Parser.CLASS) 

7106 self.state = 1037 

7107 self.match(Python3Parser.NAME) 

7108 self.state = 1043 

7109 self._errHandler.sync(self) 

7110 _la = self._input.LA(1) 

7111 if _la==Python3Parser.OPEN_PAREN: 

7112 self.state = 1038 

7113 self.match(Python3Parser.OPEN_PAREN) 

7114 self.state = 1040 

7115 self._errHandler.sync(self) 

7116 _la = self._input.LA(1) 

7117 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.POWER) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

7118 self.state = 1039 

7119 self.arglist() 

7120 

7121 

7122 self.state = 1042 

7123 self.match(Python3Parser.CLOSE_PAREN) 

7124 

7125 

7126 self.state = 1045 

7127 self.match(Python3Parser.COLON) 

7128 self.state = 1046 

7129 self.suite() 

7130 except RecognitionException as re: 

7131 localctx.exception = re 

7132 self._errHandler.reportError(self, re) 

7133 self._errHandler.recover(self, re) 

7134 finally: 

7135 self.exitRule() 

7136 return localctx 

7137 

7138 

7139 class ArglistContext(ParserRuleContext): 

7140 __slots__ = 'parser' 

7141 

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

7143 super().__init__(parent, invokingState) 

7144 self.parser = parser 

7145 

7146 def argument(self, i:int=None): 

7147 if i is None: 

7148 return self.getTypedRuleContexts(Python3Parser.ArgumentContext) 

7149 else: 

7150 return self.getTypedRuleContext(Python3Parser.ArgumentContext,i) 

7151 

7152 

7153 def COMMA(self, i:int=None): 

7154 if i is None: 

7155 return self.getTokens(Python3Parser.COMMA) 

7156 else: 

7157 return self.getToken(Python3Parser.COMMA, i) 

7158 

7159 def getRuleIndex(self): 

7160 return Python3Parser.RULE_arglist 

7161 

7162 def enterRule(self, listener:ParseTreeListener): 

7163 if hasattr( listener, "enterArglist" ): 

7164 listener.enterArglist(self) 

7165 

7166 def exitRule(self, listener:ParseTreeListener): 

7167 if hasattr( listener, "exitArglist" ): 

7168 listener.exitArglist(self) 

7169 

7170 

7171 

7172 

7173 def arglist(self): 

7174 

7175 localctx = Python3Parser.ArglistContext(self, self._ctx, self.state) 

7176 self.enterRule(localctx, 156, self.RULE_arglist) 

7177 self._la = 0 # Token type 

7178 try: 

7179 self.enterOuterAlt(localctx, 1) 

7180 self.state = 1048 

7181 self.argument() 

7182 self.state = 1053 

7183 self._errHandler.sync(self) 

7184 _alt = self._interp.adaptivePredict(self._input,156,self._ctx) 

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

7186 if _alt==1: 

7187 self.state = 1049 

7188 self.match(Python3Parser.COMMA) 

7189 self.state = 1050 

7190 self.argument() 

7191 self.state = 1055 

7192 self._errHandler.sync(self) 

7193 _alt = self._interp.adaptivePredict(self._input,156,self._ctx) 

7194 

7195 self.state = 1057 

7196 self._errHandler.sync(self) 

7197 _la = self._input.LA(1) 

7198 if _la==Python3Parser.COMMA: 

7199 self.state = 1056 

7200 self.match(Python3Parser.COMMA) 

7201 

7202 

7203 except RecognitionException as re: 

7204 localctx.exception = re 

7205 self._errHandler.reportError(self, re) 

7206 self._errHandler.recover(self, re) 

7207 finally: 

7208 self.exitRule() 

7209 return localctx 

7210 

7211 

7212 class ArgumentContext(ParserRuleContext): 

7213 __slots__ = 'parser' 

7214 

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

7216 super().__init__(parent, invokingState) 

7217 self.parser = parser 

7218 

7219 def test(self, i:int=None): 

7220 if i is None: 

7221 return self.getTypedRuleContexts(Python3Parser.TestContext) 

7222 else: 

7223 return self.getTypedRuleContext(Python3Parser.TestContext,i) 

7224 

7225 

7226 def ASSIGN(self): 

7227 return self.getToken(Python3Parser.ASSIGN, 0) 

7228 

7229 def POWER(self): 

7230 return self.getToken(Python3Parser.POWER, 0) 

7231 

7232 def STAR(self): 

7233 return self.getToken(Python3Parser.STAR, 0) 

7234 

7235 def comp_for(self): 

7236 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0) 

7237 

7238 

7239 def getRuleIndex(self): 

7240 return Python3Parser.RULE_argument 

7241 

7242 def enterRule(self, listener:ParseTreeListener): 

7243 if hasattr( listener, "enterArgument" ): 

7244 listener.enterArgument(self) 

7245 

7246 def exitRule(self, listener:ParseTreeListener): 

7247 if hasattr( listener, "exitArgument" ): 

7248 listener.exitArgument(self) 

7249 

7250 

7251 

7252 

7253 def argument(self): 

7254 

7255 localctx = Python3Parser.ArgumentContext(self, self._ctx, self.state) 

7256 self.enterRule(localctx, 158, self.RULE_argument) 

7257 self._la = 0 # Token type 

7258 try: 

7259 self.enterOuterAlt(localctx, 1) 

7260 self.state = 1071 

7261 self._errHandler.sync(self) 

7262 la_ = self._interp.adaptivePredict(self._input,159,self._ctx) 

7263 if la_ == 1: 

7264 self.state = 1059 

7265 self.test() 

7266 self.state = 1061 

7267 self._errHandler.sync(self) 

7268 _la = self._input.LA(1) 

7269 if _la==Python3Parser.FOR or _la==Python3Parser.ASYNC: 

7270 self.state = 1060 

7271 self.comp_for() 

7272 

7273 

7274 pass 

7275 

7276 elif la_ == 2: 

7277 self.state = 1063 

7278 self.test() 

7279 self.state = 1064 

7280 self.match(Python3Parser.ASSIGN) 

7281 self.state = 1065 

7282 self.test() 

7283 pass 

7284 

7285 elif la_ == 3: 

7286 self.state = 1067 

7287 self.match(Python3Parser.POWER) 

7288 self.state = 1068 

7289 self.test() 

7290 pass 

7291 

7292 elif la_ == 4: 

7293 self.state = 1069 

7294 self.match(Python3Parser.STAR) 

7295 self.state = 1070 

7296 self.test() 

7297 pass 

7298 

7299 

7300 except RecognitionException as re: 

7301 localctx.exception = re 

7302 self._errHandler.reportError(self, re) 

7303 self._errHandler.recover(self, re) 

7304 finally: 

7305 self.exitRule() 

7306 return localctx 

7307 

7308 

7309 class Comp_iterContext(ParserRuleContext): 

7310 __slots__ = 'parser' 

7311 

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

7313 super().__init__(parent, invokingState) 

7314 self.parser = parser 

7315 

7316 def comp_for(self): 

7317 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0) 

7318 

7319 

7320 def comp_if(self): 

7321 return self.getTypedRuleContext(Python3Parser.Comp_ifContext,0) 

7322 

7323 

7324 def getRuleIndex(self): 

7325 return Python3Parser.RULE_comp_iter 

7326 

7327 def enterRule(self, listener:ParseTreeListener): 

7328 if hasattr( listener, "enterComp_iter" ): 

7329 listener.enterComp_iter(self) 

7330 

7331 def exitRule(self, listener:ParseTreeListener): 

7332 if hasattr( listener, "exitComp_iter" ): 

7333 listener.exitComp_iter(self) 

7334 

7335 

7336 

7337 

7338 def comp_iter(self): 

7339 

7340 localctx = Python3Parser.Comp_iterContext(self, self._ctx, self.state) 

7341 self.enterRule(localctx, 160, self.RULE_comp_iter) 

7342 try: 

7343 self.state = 1075 

7344 self._errHandler.sync(self) 

7345 token = self._input.LA(1) 

7346 if token in [Python3Parser.FOR, Python3Parser.ASYNC]: 

7347 self.enterOuterAlt(localctx, 1) 

7348 self.state = 1073 

7349 self.comp_for() 

7350 pass 

7351 elif token in [Python3Parser.IF]: 

7352 self.enterOuterAlt(localctx, 2) 

7353 self.state = 1074 

7354 self.comp_if() 

7355 pass 

7356 else: 

7357 raise NoViableAltException(self) 

7358 

7359 except RecognitionException as re: 

7360 localctx.exception = re 

7361 self._errHandler.reportError(self, re) 

7362 self._errHandler.recover(self, re) 

7363 finally: 

7364 self.exitRule() 

7365 return localctx 

7366 

7367 

7368 class Comp_forContext(ParserRuleContext): 

7369 __slots__ = 'parser' 

7370 

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

7372 super().__init__(parent, invokingState) 

7373 self.parser = parser 

7374 

7375 def FOR(self): 

7376 return self.getToken(Python3Parser.FOR, 0) 

7377 

7378 def exprlist(self): 

7379 return self.getTypedRuleContext(Python3Parser.ExprlistContext,0) 

7380 

7381 

7382 def IN(self): 

7383 return self.getToken(Python3Parser.IN, 0) 

7384 

7385 def or_test(self): 

7386 return self.getTypedRuleContext(Python3Parser.Or_testContext,0) 

7387 

7388 

7389 def ASYNC(self): 

7390 return self.getToken(Python3Parser.ASYNC, 0) 

7391 

7392 def comp_iter(self): 

7393 return self.getTypedRuleContext(Python3Parser.Comp_iterContext,0) 

7394 

7395 

7396 def getRuleIndex(self): 

7397 return Python3Parser.RULE_comp_for 

7398 

7399 def enterRule(self, listener:ParseTreeListener): 

7400 if hasattr( listener, "enterComp_for" ): 

7401 listener.enterComp_for(self) 

7402 

7403 def exitRule(self, listener:ParseTreeListener): 

7404 if hasattr( listener, "exitComp_for" ): 

7405 listener.exitComp_for(self) 

7406 

7407 

7408 

7409 

7410 def comp_for(self): 

7411 

7412 localctx = Python3Parser.Comp_forContext(self, self._ctx, self.state) 

7413 self.enterRule(localctx, 162, self.RULE_comp_for) 

7414 self._la = 0 # Token type 

7415 try: 

7416 self.enterOuterAlt(localctx, 1) 

7417 self.state = 1078 

7418 self._errHandler.sync(self) 

7419 _la = self._input.LA(1) 

7420 if _la==Python3Parser.ASYNC: 

7421 self.state = 1077 

7422 self.match(Python3Parser.ASYNC) 

7423 

7424 

7425 self.state = 1080 

7426 self.match(Python3Parser.FOR) 

7427 self.state = 1081 

7428 self.exprlist() 

7429 self.state = 1082 

7430 self.match(Python3Parser.IN) 

7431 self.state = 1083 

7432 self.or_test() 

7433 self.state = 1085 

7434 self._errHandler.sync(self) 

7435 _la = self._input.LA(1) 

7436 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.IF) | (1 << Python3Parser.FOR) | (1 << Python3Parser.ASYNC))) != 0): 

7437 self.state = 1084 

7438 self.comp_iter() 

7439 

7440 

7441 except RecognitionException as re: 

7442 localctx.exception = re 

7443 self._errHandler.reportError(self, re) 

7444 self._errHandler.recover(self, re) 

7445 finally: 

7446 self.exitRule() 

7447 return localctx 

7448 

7449 

7450 class Comp_ifContext(ParserRuleContext): 

7451 __slots__ = 'parser' 

7452 

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

7454 super().__init__(parent, invokingState) 

7455 self.parser = parser 

7456 

7457 def IF(self): 

7458 return self.getToken(Python3Parser.IF, 0) 

7459 

7460 def test_nocond(self): 

7461 return self.getTypedRuleContext(Python3Parser.Test_nocondContext,0) 

7462 

7463 

7464 def comp_iter(self): 

7465 return self.getTypedRuleContext(Python3Parser.Comp_iterContext,0) 

7466 

7467 

7468 def getRuleIndex(self): 

7469 return Python3Parser.RULE_comp_if 

7470 

7471 def enterRule(self, listener:ParseTreeListener): 

7472 if hasattr( listener, "enterComp_if" ): 

7473 listener.enterComp_if(self) 

7474 

7475 def exitRule(self, listener:ParseTreeListener): 

7476 if hasattr( listener, "exitComp_if" ): 

7477 listener.exitComp_if(self) 

7478 

7479 

7480 

7481 

7482 def comp_if(self): 

7483 

7484 localctx = Python3Parser.Comp_ifContext(self, self._ctx, self.state) 

7485 self.enterRule(localctx, 164, self.RULE_comp_if) 

7486 self._la = 0 # Token type 

7487 try: 

7488 self.enterOuterAlt(localctx, 1) 

7489 self.state = 1087 

7490 self.match(Python3Parser.IF) 

7491 self.state = 1088 

7492 self.test_nocond() 

7493 self.state = 1090 

7494 self._errHandler.sync(self) 

7495 _la = self._input.LA(1) 

7496 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.IF) | (1 << Python3Parser.FOR) | (1 << Python3Parser.ASYNC))) != 0): 

7497 self.state = 1089 

7498 self.comp_iter() 

7499 

7500 

7501 except RecognitionException as re: 

7502 localctx.exception = re 

7503 self._errHandler.reportError(self, re) 

7504 self._errHandler.recover(self, re) 

7505 finally: 

7506 self.exitRule() 

7507 return localctx 

7508 

7509 

7510 class Encoding_declContext(ParserRuleContext): 

7511 __slots__ = 'parser' 

7512 

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

7514 super().__init__(parent, invokingState) 

7515 self.parser = parser 

7516 

7517 def NAME(self): 

7518 return self.getToken(Python3Parser.NAME, 0) 

7519 

7520 def getRuleIndex(self): 

7521 return Python3Parser.RULE_encoding_decl 

7522 

7523 def enterRule(self, listener:ParseTreeListener): 

7524 if hasattr( listener, "enterEncoding_decl" ): 

7525 listener.enterEncoding_decl(self) 

7526 

7527 def exitRule(self, listener:ParseTreeListener): 

7528 if hasattr( listener, "exitEncoding_decl" ): 

7529 listener.exitEncoding_decl(self) 

7530 

7531 

7532 

7533 

7534 def encoding_decl(self): 

7535 

7536 localctx = Python3Parser.Encoding_declContext(self, self._ctx, self.state) 

7537 self.enterRule(localctx, 166, self.RULE_encoding_decl) 

7538 try: 

7539 self.enterOuterAlt(localctx, 1) 

7540 self.state = 1092 

7541 self.match(Python3Parser.NAME) 

7542 except RecognitionException as re: 

7543 localctx.exception = re 

7544 self._errHandler.reportError(self, re) 

7545 self._errHandler.recover(self, re) 

7546 finally: 

7547 self.exitRule() 

7548 return localctx 

7549 

7550 

7551 class Yield_exprContext(ParserRuleContext): 

7552 __slots__ = 'parser' 

7553 

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

7555 super().__init__(parent, invokingState) 

7556 self.parser = parser 

7557 

7558 def YIELD(self): 

7559 return self.getToken(Python3Parser.YIELD, 0) 

7560 

7561 def yield_arg(self): 

7562 return self.getTypedRuleContext(Python3Parser.Yield_argContext,0) 

7563 

7564 

7565 def getRuleIndex(self): 

7566 return Python3Parser.RULE_yield_expr 

7567 

7568 def enterRule(self, listener:ParseTreeListener): 

7569 if hasattr( listener, "enterYield_expr" ): 

7570 listener.enterYield_expr(self) 

7571 

7572 def exitRule(self, listener:ParseTreeListener): 

7573 if hasattr( listener, "exitYield_expr" ): 

7574 listener.exitYield_expr(self) 

7575 

7576 

7577 

7578 

7579 def yield_expr(self): 

7580 

7581 localctx = Python3Parser.Yield_exprContext(self, self._ctx, self.state) 

7582 self.enterRule(localctx, 168, self.RULE_yield_expr) 

7583 self._la = 0 # Token type 

7584 try: 

7585 self.enterOuterAlt(localctx, 1) 

7586 self.state = 1094 

7587 self.match(Python3Parser.YIELD) 

7588 self.state = 1096 

7589 self._errHandler.sync(self) 

7590 _la = self._input.LA(1) 

7591 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.FROM) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0): 

7592 self.state = 1095 

7593 self.yield_arg() 

7594 

7595 

7596 except RecognitionException as re: 

7597 localctx.exception = re 

7598 self._errHandler.reportError(self, re) 

7599 self._errHandler.recover(self, re) 

7600 finally: 

7601 self.exitRule() 

7602 return localctx 

7603 

7604 

7605 class Yield_argContext(ParserRuleContext): 

7606 __slots__ = 'parser' 

7607 

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

7609 super().__init__(parent, invokingState) 

7610 self.parser = parser 

7611 

7612 def FROM(self): 

7613 return self.getToken(Python3Parser.FROM, 0) 

7614 

7615 def test(self): 

7616 return self.getTypedRuleContext(Python3Parser.TestContext,0) 

7617 

7618 

7619 def testlist(self): 

7620 return self.getTypedRuleContext(Python3Parser.TestlistContext,0) 

7621 

7622 

7623 def getRuleIndex(self): 

7624 return Python3Parser.RULE_yield_arg 

7625 

7626 def enterRule(self, listener:ParseTreeListener): 

7627 if hasattr( listener, "enterYield_arg" ): 

7628 listener.enterYield_arg(self) 

7629 

7630 def exitRule(self, listener:ParseTreeListener): 

7631 if hasattr( listener, "exitYield_arg" ): 

7632 listener.exitYield_arg(self) 

7633 

7634 

7635 

7636 

7637 def yield_arg(self): 

7638 

7639 localctx = Python3Parser.Yield_argContext(self, self._ctx, self.state) 

7640 self.enterRule(localctx, 170, self.RULE_yield_arg) 

7641 try: 

7642 self.state = 1101 

7643 self._errHandler.sync(self) 

7644 token = self._input.LA(1) 

7645 if token in [Python3Parser.FROM]: 

7646 self.enterOuterAlt(localctx, 1) 

7647 self.state = 1098 

7648 self.match(Python3Parser.FROM) 

7649 self.state = 1099 

7650 self.test() 

7651 pass 

7652 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]: 

7653 self.enterOuterAlt(localctx, 2) 

7654 self.state = 1100 

7655 self.testlist() 

7656 pass 

7657 else: 

7658 raise NoViableAltException(self) 

7659 

7660 except RecognitionException as re: 

7661 localctx.exception = re 

7662 self._errHandler.reportError(self, re) 

7663 self._errHandler.recover(self, re) 

7664 finally: 

7665 self.exitRule() 

7666 return localctx 

7667 

7668 

7669 

7670 

7671