0
server_def
1
0
client_def
2
0
sim_def
3
0
client
4
0
step
5
0
server
6
0
simulation
7
0
obj_def
8
0
NEWLINE
9
0
step_def
10
0
$
program -> 
0
program
11
1
$
obj_def -> server_def
1
server
obj_def -> server_def
1
simulation
obj_def -> server_def
1
step
obj_def -> server_def
1
NEWLINE
obj_def -> server_def
1
client
obj_def -> server_def
2
$
obj_def -> client_def
2
server
obj_def -> client_def
2
NEWLINE
obj_def -> client_def
2
step
obj_def -> client_def
2
client
obj_def -> client_def
2
simulation
obj_def -> client_def
3
$
obj_def -> sim_def
3
client
obj_def -> sim_def
3
NEWLINE
obj_def -> sim_def
3
simulation
obj_def -> sim_def
3
step
obj_def -> sim_def
3
server
obj_def -> sim_def
4
NAME
12
5
NAME
13
6
NAME
14
7
NAME
15
8
server_def
1
8
client_def
2
8
sim_def
3
8
client
4
8
step
5
8
server
6
8
simulation
7
8
obj_def
8
8
program
16
8
NEWLINE
9
8
step_def
10
8
$
program -> 
9
server_def
1
9
client_def
2
9
sim_def
3
9
client
4
9
step
5
9
server
6
9
simulation
7
9
obj_def
8
9
NEWLINE
9
9
step_def
10
9
program
17
9
$
program -> 
10
$
obj_def -> step_def
10
simulation
obj_def -> step_def
10
client
obj_def -> step_def
10
step
obj_def -> step_def
10
NEWLINE
obj_def -> step_def
10
server
obj_def -> step_def
11
$
OK
12
:
18
13
:
19
14
:
20
15
:
21
16
$
program -> obj_def program
17
$
program -> NEWLINE program
18
NEWLINE
22
18
obj_def_body
23
19
NEWLINE
22
19
obj_def_body
24
20
obj_def_body
25
20
NEWLINE
22
21
NEWLINE
22
21
obj_def_body
26
22
INDENT
27
23
NEWLINE
client_def -> client NAME : obj_def_body
23
$
client_def -> client NAME : obj_def_body
23
server
client_def -> client NAME : obj_def_body
23
step
client_def -> client NAME : obj_def_body
23
client
client_def -> client NAME : obj_def_body
23
simulation
client_def -> client NAME : obj_def_body
24
NEWLINE
step_def -> step NAME : obj_def_body
24
simulation
step_def -> step NAME : obj_def_body
24
step
step_def -> step NAME : obj_def_body
24
$
step_def -> step NAME : obj_def_body
24
client
step_def -> step NAME : obj_def_body
24
server
step_def -> step NAME : obj_def_body
25
NEWLINE
server_def -> server NAME : obj_def_body
25
step
server_def -> server NAME : obj_def_body
25
simulation
server_def -> server NAME : obj_def_body
25
$
server_def -> server NAME : obj_def_body
25
client
server_def -> server NAME : obj_def_body
25
server
server_def -> server NAME : obj_def_body
26
simulation
sim_def -> simulation NAME : obj_def_body
26
server
sim_def -> simulation NAME : obj_def_body
26
step
sim_def -> simulation NAME : obj_def_body
26
NEWLINE
sim_def -> simulation NAME : obj_def_body
26
$
sim_def -> simulation NAME : obj_def_body
26
client
sim_def -> simulation NAME : obj_def_body
27
obj_stmt_list
28
27
func_def
29
27
NEWLINE
30
27
DEDENT
obj_stmt_list -> 
27
NAME
31
27
obj_stmt
32
28
DEDENT
33
29
NAME
obj_stmt -> func_def
29
NEWLINE
obj_stmt -> func_def
29
DEDENT
obj_stmt -> func_def
30
func_def
29
30
NEWLINE
30
30
obj_stmt_list
34
30
DEDENT
obj_stmt_list -> 
30
NAME
31
30
obj_stmt
32
31
=
35
31
(
36
32
func_def
29
32
NEWLINE
30
32
DEDENT
obj_stmt_list -> 
32
obj_stmt_list
37
32
NAME
31
32
obj_stmt
32
33
simulation
obj_def_body -> NEWLINE INDENT obj_stmt_list DEDENT
33
server
obj_def_body -> NEWLINE INDENT obj_stmt_list DEDENT
33
NEWLINE
obj_def_body -> NEWLINE INDENT obj_stmt_list DEDENT
33
$
obj_def_body -> NEWLINE INDENT obj_stmt_list DEDENT
33
client
obj_def_body -> NEWLINE INDENT obj_stmt_list DEDENT
33
step
obj_def_body -> NEWLINE INDENT obj_stmt_list DEDENT
34
DEDENT
obj_stmt_list -> NEWLINE obj_stmt_list
35
call
38
35
factor
39
35
term
40
35
None
41
35
xor_expr
42
35
NAME
43
35
arith_expr
44
35
+
45
35
STRING
46
35
atom
47
35
shift_expr
48
35
True
49
35
[
50
35
expr
51
35
-
52
35
~
53
35
and_expr
54
35
comparison
55
35
power
56
35
NUMBER
57
35
False
58
35
and_test
59
35
or_test
60
35
not_test
61
35
not
62
35
test
63
36
)
name_list -> 
36
name_list
64
36
NAME
65
37
DEDENT
obj_stmt_list -> obj_stmt obj_stmt_list
38
%
atom -> call
38
&
atom -> call
38
-
atom -> call
38
<
atom -> call
38
DEDENT
atom -> call
38
and
atom -> call
38
>
atom -> call
38
>=
atom -> call
38
NEWLINE
atom -> call
38
<=
atom -> call
38
//
atom -> call
38
<<
atom -> call
38
or
atom -> call
38
/
atom -> call
38
|
atom -> call
38
*
atom -> call
38
+
atom -> call
38
>>
atom -> call
38
!=
atom -> call
38
**
atom -> call
38
NAME
atom -> call
38
==
atom -> call
38
^
atom -> call
39
%
66
39
//
67
39
>>
term -> factor
39
/
68
39
DEDENT
term -> factor
39
*
69
39
<<
term -> factor
39
NAME
term -> factor
39
==
term -> factor
39
<=
term -> factor
39
+
term -> factor
39
>=
term -> factor
39
&
term -> factor
39
>
term -> factor
39
<
term -> factor
39
!=
term -> factor
39
or
term -> factor
39
|
term -> factor
39
NEWLINE
term -> factor
39
^
term -> factor
39
and
term -> factor
39
-
term -> factor
40
+
70
40
<
arith_expr -> term
40
-
71
40
<=
arith_expr -> term
40
==
arith_expr -> term
40
NEWLINE
arith_expr -> term
40
and
arith_expr -> term
40
>
arith_expr -> term
40
>>
arith_expr -> term
40
^
arith_expr -> term
40
|
arith_expr -> term
40
DEDENT
arith_expr -> term
40
>=
arith_expr -> term
40
<<
arith_expr -> term
40
or
arith_expr -> term
40
!=
arith_expr -> term
40
NAME
arith_expr -> term
40
&
arith_expr -> term
41
NAME
atom -> None
41
<
atom -> None
41
<<
atom -> None
41
!=
atom -> None
41
<=
atom -> None
41
%
atom -> None
41
&
atom -> None
41
*
atom -> None
41
NEWLINE
atom -> None
41
>
atom -> None
41
-
atom -> None
41
and
atom -> None
41
^
atom -> None
41
DEDENT
atom -> None
41
>=
atom -> None
41
**
atom -> None
41
|
atom -> None
41
>>
atom -> None
41
/
atom -> None
41
//
atom -> None
41
==
atom -> None
41
+
atom -> None
41
or
atom -> None
42
|
72
42
!=
expr -> xor_expr
42
==
expr -> xor_expr
42
<
expr -> xor_expr
42
NEWLINE
expr -> xor_expr
42
NAME
expr -> xor_expr
42
DEDENT
expr -> xor_expr
42
>
expr -> xor_expr
42
<=
expr -> xor_expr
42
and
expr -> xor_expr
42
>=
expr -> xor_expr
42
or
expr -> xor_expr
43
(
73
43
&
atom -> NAME
43
%
atom -> NAME
43
DEDENT
atom -> NAME
43
NEWLINE
atom -> NAME
43
>>
atom -> NAME
43
^
atom -> NAME
43
>
atom -> NAME
43
<<
atom -> NAME
43
and
atom -> NAME
43
or
atom -> NAME
43
<
atom -> NAME
43
**
atom -> NAME
43
|
atom -> NAME
43
<=
atom -> NAME
43
==
atom -> NAME
43
/
atom -> NAME
43
>=
atom -> NAME
43
NAME
atom -> NAME
43
!=
atom -> NAME
43
+
atom -> NAME
43
*
atom -> NAME
43
-
atom -> NAME
43
//
atom -> NAME
44
>>
74
44
==
shift_expr -> arith_expr
44
NAME
shift_expr -> arith_expr
44
^
shift_expr -> arith_expr
44
<<
75
44
NEWLINE
shift_expr -> arith_expr
44
>=
shift_expr -> arith_expr
44
<=
shift_expr -> arith_expr
44
or
shift_expr -> arith_expr
44
|
shift_expr -> arith_expr
44
>
shift_expr -> arith_expr
44
!=
shift_expr -> arith_expr
44
DEDENT
shift_expr -> arith_expr
44
<
shift_expr -> arith_expr
44
and
shift_expr -> arith_expr
44
&
shift_expr -> arith_expr
45
call
38
45
None
41
45
power
56
45
NAME
43
45
+
45
45
-
52
45
NUMBER
57
45
STRING
46
45
atom
47
45
True
49
45
[
50
45
False
58
45
~
53
45
factor
76
46
!=
atom -> STRING
46
<<
atom -> STRING
46
//
atom -> STRING
46
/
atom -> STRING
46
<
atom -> STRING
46
==
atom -> STRING
46
|
atom -> STRING
46
>=
atom -> STRING
46
^
atom -> STRING
46
>>
atom -> STRING
46
<=
atom -> STRING
46
*
atom -> STRING
46
>
atom -> STRING
46
%
atom -> STRING
46
DEDENT
atom -> STRING
46
-
atom -> STRING
46
**
atom -> STRING
46
NEWLINE
atom -> STRING
46
+
atom -> STRING
46
and
atom -> STRING
46
NAME
atom -> STRING
46
or
atom -> STRING
46
&
atom -> STRING
47
<=
power -> atom
47
>
power -> atom
47
DEDENT
power -> atom
47
**
77
47
|
power -> atom
47
//
power -> atom
47
>>
power -> atom
47
-
power -> atom
47
and
power -> atom
47
>=
power -> atom
47
!=
power -> atom
47
/
power -> atom
47
NAME
power -> atom
47
<<
power -> atom
47
NEWLINE
power -> atom
47
&
power -> atom
47
%
power -> atom
47
^
power -> atom
47
+
power -> atom
47
or
power -> atom
47
*
power -> atom
47
==
power -> atom
47
<
power -> atom
48
and
and_expr -> shift_expr
48
<
and_expr -> shift_expr
48
^
and_expr -> shift_expr
48
NAME
and_expr -> shift_expr
48
&
78
48
>
and_expr -> shift_expr
48
==
and_expr -> shift_expr
48
|
and_expr -> shift_expr
48
!=
and_expr -> shift_expr
48
<=
and_expr -> shift_expr
48
NEWLINE
and_expr -> shift_expr
48
DEDENT
and_expr -> shift_expr
48
or
and_expr -> shift_expr
48
>=
and_expr -> shift_expr
49
>=
atom -> True
49
|
atom -> True
49
//
atom -> True
49
<
atom -> True
49
==
atom -> True
49
DEDENT
atom -> True
49
-
atom -> True
49
<<
atom -> True
49
/
atom -> True
49
or
atom -> True
49
NAME
atom -> True
49
!=
atom -> True
49
**
atom -> True
49
^
atom -> True
49
&
atom -> True
49
*
atom -> True
49
NEWLINE
atom -> True
49
%
atom -> True
49
<=
atom -> True
49
>
atom -> True
49
+
atom -> True
49
and
atom -> True
49
>>
atom -> True
50
call
79
50
factor
80
50
term
81
50
None
82
50
or_test
83
50
xor_expr
84
50
NAME
85
50
arith_expr
86
50
+
87
50
STRING
88
50
atom
89
50
shift_expr
90
50
True
91
50
[
92
50
test_list
93
50
-
94
50
expr
95
50
~
96
50
not_test
97
50
comparison
98
50
power
99
50
NUMBER
100
50
False
101
50
and_expr
102
50
and_test
103
50
not
104
50
test
105
51
DEDENT
comparison -> expr
51
>
106
51
>=
107
51
<
108
51
!=
109
51
==
110
51
and
comparison -> expr
51
<=
111
51
comp_op
112
51
NAME
comparison -> expr
51
NEWLINE
comparison -> expr
51
or
comparison -> expr
52
call
38
52
None
41
52
power
56
52
NAME
43
52
+
45
52
-
52
52
factor
113
52
NUMBER
57
52
STRING
46
52
atom
47
52
True
49
52
[
50
52
False
58
52
~
53
53
call
38
53
None
41
53
power
56
53
NAME
43
53
+
45
53
-
52
53
factor
114
53
NUMBER
57
53
STRING
46
53
atom
47
53
True
49
53
[
50
53
False
58
53
~
53
54
^
115
54
NEWLINE
xor_expr -> and_expr
54
and
xor_expr -> and_expr
54
>=
xor_expr -> and_expr
54
<=
xor_expr -> and_expr
54
==
xor_expr -> and_expr
54
or
xor_expr -> and_expr
54
<
xor_expr -> and_expr
54
NAME
xor_expr -> and_expr
54
!=
xor_expr -> and_expr
54
>
xor_expr -> and_expr
54
DEDENT
xor_expr -> and_expr
54
|
xor_expr -> and_expr
55
DEDENT
not_test -> comparison
55
and
not_test -> comparison
55
or
not_test -> comparison
55
NAME
not_test -> comparison
55
NEWLINE
not_test -> comparison
56
//
factor -> power
56
<<
factor -> power
56
<
factor -> power
56
DEDENT
factor -> power
56
!=
factor -> power
56
<=
factor -> power
56
|
factor -> power
56
-
factor -> power
56
NAME
factor -> power
56
>=
factor -> power
56
/
factor -> power
56
>>
factor -> power
56
*
factor -> power
56
==
factor -> power
56
&
factor -> power
56
NEWLINE
factor -> power
56
^
factor -> power
56
+
factor -> power
56
and
factor -> power
56
>
factor -> power
56
or
factor -> power
56
%
factor -> power
57
/
atom -> NUMBER
57
or
atom -> NUMBER
57
>>
atom -> NUMBER
57
*
atom -> NUMBER
57
<=
atom -> NUMBER
57
+
atom -> NUMBER
57
and
atom -> NUMBER
57
-
atom -> NUMBER
57
==
atom -> NUMBER
57
<
atom -> NUMBER
57
%
atom -> NUMBER
57
DEDENT
atom -> NUMBER
57
//
atom -> NUMBER
57
>=
atom -> NUMBER
57
>
atom -> NUMBER
57
NAME
atom -> NUMBER
57
!=
atom -> NUMBER
57
**
atom -> NUMBER
57
^
atom -> NUMBER
57
&
atom -> NUMBER
57
NEWLINE
atom -> NUMBER
57
<<
atom -> NUMBER
57
|
atom -> NUMBER
58
NAME
atom -> False
58
and
atom -> False
58
/
atom -> False
58
DEDENT
atom -> False
58
*
atom -> False
58
-
atom -> False
58
**
atom -> False
58
<<
atom -> False
58
>
atom -> False
58
>>
atom -> False
58
==
atom -> False
58
|
atom -> False
58
%
atom -> False
58
<=
atom -> False
58
NEWLINE
atom -> False
58
or
atom -> False
58
<
atom -> False
58
//
atom -> False
58
+
atom -> False
58
>=
atom -> False
58
&
atom -> False
58
^
atom -> False
58
!=
atom -> False
59
or
116
59
NEWLINE
or_test -> and_test
59
DEDENT
or_test -> and_test
59
NAME
or_test -> and_test
60
NEWLINE
test -> or_test
60
DEDENT
test -> or_test
60
NAME
test -> or_test
61
and
117
61
DEDENT
and_test -> not_test
61
NEWLINE
and_test -> not_test
61
or
and_test -> not_test
61
NAME
and_test -> not_test
62
call
38
62
factor
39
62
not_test
118
62
term
40
62
xor_expr
42
62
None
41
62
NAME
43
62
arith_expr
44
62
+
45
62
STRING
46
62
atom
47
62
shift_expr
48
62
True
49
62
[
50
62
expr
51
62
-
52
62
~
53
62
and_expr
54
62
comparison
55
62
power
56
62
NUMBER
57
62
False
58
62
not
62
63
NAME
obj_stmt -> NAME = test
63
DEDENT
obj_stmt -> NAME = test
63
NEWLINE
obj_stmt -> NAME = test
64
)
119
65
)
name_list -> 
65
name_list
120
65
NAME
65
66
call
38
66
factor
39
66
None
41
66
power
56
66
NAME
43
66
+
45
66
-
52
66
NUMBER
57
66
STRING
46
66
atom
47
66
True
49
66
[
50
66
False
58
66
~
53
66
term
121
67
call
38
67
factor
39
67
None
41
67
power
56
67
NAME
43
67
+
45
67
-
52
67
NUMBER
57
67
STRING
46
67
atom
47
67
True
49
67
[
50
67
False
58
67
~
53
67
term
122
68
call
38
68
factor
39
68
term
123
68
None
41
68
power
56
68
NAME
43
68
+
45
68
-
52
68
NUMBER
57
68
STRING
46
68
atom
47
68
True
49
68
[
50
68
False
58
68
~
53
69
call
38
69
factor
39
69
None
41
69
power
56
69
NAME
43
69
+
45
69
-
52
69
NUMBER
57
69
STRING
46
69
atom
47
69
True
49
69
[
50
69
False
58
69
term
124
69
~
53
70
call
38
70
factor
39
70
term
40
70
None
41
70
power
56
70
NAME
43
70
arith_expr
125
70
+
45
70
-
52
70
NUMBER
57
70
STRING
46
70
atom
47
70
True
49
70
[
50
70
False
58
70
~
53
71
call
38
71
factor
39
71
term
40
71
None
41
71
power
56
71
NAME
43
71
+
45
71
-
52
71
NUMBER
57
71
STRING
46
71
atom
47
71
True
49
71
[
50
71
arith_expr
126
71
False
58
71
~
53
72
call
38
72
factor
39
72
term
40
72
None
41
72
xor_expr
42
72
NAME
43
72
arith_expr
44
72
+
45
72
STRING
46
72
atom
47
72
shift_expr
48
72
True
49
72
[
50
72
-
52
72
~
53
72
and_expr
54
72
expr
127
72
power
56
72
NUMBER
57
72
False
58
73
call
128
73
factor
129
73
term
130
73
None
131
73
xor_expr
132
73
NAME
133
73
arith_expr
134
73
+
135
73
STRING
136
73
atom
137
73
shift_expr
138
73
True
139
73
[
140
73
-
141
73
not_test
142
73
expr
143
73
~
144
73
comparison
145
73
power
146
73
NUMBER
147
73
False
148
73
and_expr
149
73
not
150
73
)
151
73
test_list
152
73
and_test
153
73
or_test
154
73
test
155
74
call
38
74
factor
39
74
term
40
74
None
41
74
power
56
74
NAME
43
74
arith_expr
44
74
+
45
74
-
52
74
shift_expr
156
74
NUMBER
57
74
STRING
46
74
atom
47
74
True
49
74
[
50
74
False
58
74
~
53
75
call
38
75
factor
39
75
term
40
75
None
41
75
power
56
75
NAME
43
75
arith_expr
44
75
+
45
75
-
52
75
NUMBER
57
75
STRING
46
75
atom
47
75
True
49
75
[
50
75
shift_expr
157
75
False
58
75
~
53
76
>=
factor -> + factor
76
<=
factor -> + factor
76
*
factor -> + factor
76
==
factor -> + factor
76
>
factor -> + factor
76
DEDENT
factor -> + factor
76
NAME
factor -> + factor
76
!=
factor -> + factor
76
-
factor -> + factor
76
and
factor -> + factor
76
//
factor -> + factor
76
NEWLINE
factor -> + factor
76
%
factor -> + factor
76
/
factor -> + factor
76
<<
factor -> + factor
76
+
factor -> + factor
76
^
factor -> + factor
76
or
factor -> + factor
76
&
factor -> + factor
76
|
factor -> + factor
76
>>
factor -> + factor
76
<
factor -> + factor
77
call
38
77
factor
158
77
None
41
77
power
56
77
NAME
43
77
+
45
77
-
52
77
NUMBER
57
77
STRING
46
77
atom
47
77
True
49
77
[
50
77
False
58
77
~
53
78
and_expr
159
78
call
38
78
factor
39
78
term
40
78
None
41
78
power
56
78
NAME
43
78
arith_expr
44
78
+
45
78
-
52
78
NUMBER
57
78
STRING
46
78
atom
47
78
shift_expr
48
78
True
49
78
[
50
78
False
58
78
~
53
79
%
atom -> call
79
&
atom -> call
79
,
atom -> call
79
-
atom -> call
79
<
atom -> call
79
and
atom -> call
79
>
atom -> call
79
>=
atom -> call
79
<=
atom -> call
79
//
atom -> call
79
<<
atom -> call
79
or
atom -> call
79
/
atom -> call
79
|
atom -> call
79
*
atom -> call
79
]
atom -> call
79
+
atom -> call
79
>>
atom -> call
79
!=
atom -> call
79
**
atom -> call
79
==
atom -> call
79
^
atom -> call
80
%
160
80
*
161
80
//
162
80
>>
term -> factor
80
/
163
80
<<
term -> factor
80
==
term -> factor
80
<=
term -> factor
80
+
term -> factor
80
>=
term -> factor
80
&
term -> factor
80
>
term -> factor
80
<
term -> factor
80
!=
term -> factor
80
]
term -> factor
80
or
term -> factor
80
|
term -> factor
80
^
term -> factor
80
,
term -> factor
80
and
term -> factor
80
-
term -> factor
81
+
164
81
-
165
81
<
arith_expr -> term
81
<=
arith_expr -> term
81
==
arith_expr -> term
81
and
arith_expr -> term
81
,
arith_expr -> term
81
>
arith_expr -> term
81
>>
arith_expr -> term
81
]
arith_expr -> term
81
^
arith_expr -> term
81
|
arith_expr -> term
81
>=
arith_expr -> term
81
<<
arith_expr -> term
81
or
arith_expr -> term
81
!=
arith_expr -> term
81
&
arith_expr -> term
82
<
atom -> None
82
<<
atom -> None
82
!=
atom -> None
82
<=
atom -> None
82
%
atom -> None
82
&
atom -> None
82
*
atom -> None
82
-
atom -> None
82
>
atom -> None
82
and
atom -> None
82
]
atom -> None
82
^
atom -> None
82
>=
atom -> None
82
**
atom -> None
82
|
atom -> None
82
,
atom -> None
82
>>
atom -> None
82
/
atom -> None
82
//
atom -> None
82
==
atom -> None
82
+
atom -> None
82
or
atom -> None
83
,
test -> or_test
83
]
test -> or_test
84
|
166
84
!=
expr -> xor_expr
84
==
expr -> xor_expr
84
<
expr -> xor_expr
84
>
expr -> xor_expr
84
<=
expr -> xor_expr
84
and
expr -> xor_expr
84
>=
expr -> xor_expr
84
]
expr -> xor_expr
84
,
expr -> xor_expr
84
or
expr -> xor_expr
85
]
atom -> NAME
85
&
atom -> NAME
85
(
167
85
%
atom -> NAME
85
,
atom -> NAME
85
>>
atom -> NAME
85
^
atom -> NAME
85
>
atom -> NAME
85
<<
atom -> NAME
85
and
atom -> NAME
85
or
atom -> NAME
85
<
atom -> NAME
85
**
atom -> NAME
85
|
atom -> NAME
85
<=
atom -> NAME
85
==
atom -> NAME
85
/
atom -> NAME
85
>=
atom -> NAME
85
!=
atom -> NAME
85
+
atom -> NAME
85
*
atom -> NAME
85
-
atom -> NAME
85
//
atom -> NAME
86
>>
168
86
==
shift_expr -> arith_expr
86
^
shift_expr -> arith_expr
86
<<
169
86
>=
shift_expr -> arith_expr
86
<=
shift_expr -> arith_expr
86
or
shift_expr -> arith_expr
86
|
shift_expr -> arith_expr
86
>
shift_expr -> arith_expr
86
,
shift_expr -> arith_expr
86
!=
shift_expr -> arith_expr
86
]
shift_expr -> arith_expr
86
<
shift_expr -> arith_expr
86
and
shift_expr -> arith_expr
86
&
shift_expr -> arith_expr
87
call
79
87
None
82
87
power
99
87
NAME
85
87
NUMBER
100
87
+
87
87
-
94
87
STRING
88
87
atom
89
87
True
91
87
[
92
87
False
101
87
~
96
87
factor
170
88
]
atom -> STRING
88
,
atom -> STRING
88
!=
atom -> STRING
88
<<
atom -> STRING
88
//
atom -> STRING
88
/
atom -> STRING
88
<
atom -> STRING
88
==
atom -> STRING
88
|
atom -> STRING
88
>=
atom -> STRING
88
^
atom -> STRING
88
>>
atom -> STRING
88
<=
atom -> STRING
88
*
atom -> STRING
88
>
atom -> STRING
88
%
atom -> STRING
88
-
atom -> STRING
88
**
atom -> STRING
88
+
atom -> STRING
88
and
atom -> STRING
88
or
atom -> STRING
88
&
atom -> STRING
89
<=
power -> atom
89
>
power -> atom
89
**
171
89
|
power -> atom
89
//
power -> atom
89
>>
power -> atom
89
-
power -> atom
89
and
power -> atom
89
>=
power -> atom
89
!=
power -> atom
89
/
power -> atom
89
<<
power -> atom
89
]
power -> atom
89
&
power -> atom
89
%
power -> atom
89
,
power -> atom
89
^
power -> atom
89
+
power -> atom
89
or
power -> atom
89
*
power -> atom
89
==
power -> atom
89
<
power -> atom
90
]
and_expr -> shift_expr
90
,
and_expr -> shift_expr
90
and
and_expr -> shift_expr
90
<
and_expr -> shift_expr
90
^
and_expr -> shift_expr
90
&
172
90
>
and_expr -> shift_expr
90
==
and_expr -> shift_expr
90
|
and_expr -> shift_expr
90
!=
and_expr -> shift_expr
90
<=
and_expr -> shift_expr
90
or
and_expr -> shift_expr
90
>=
and_expr -> shift_expr
91
>=
atom -> True
91
|
atom -> True
91
//
atom -> True
91
<
atom -> True
91
==
atom -> True
91
-
atom -> True
91
,
atom -> True
91
<<
atom -> True
91
/
atom -> True
91
or
atom -> True
91
!=
atom -> True
91
**
atom -> True
91
]
atom -> True
91
^
atom -> True
91
&
atom -> True
91
*
atom -> True
91
%
atom -> True
91
<=
atom -> True
91
>
atom -> True
91
+
atom -> True
91
and
atom -> True
91
>>
atom -> True
92
call
79
92
factor
80
92
term
81
92
None
82
92
or_test
83
92
xor_expr
84
92
NAME
85
92
arith_expr
86
92
+
87
92
STRING
88
92
atom
89
92
shift_expr
90
92
True
91
92
[
92
92
test_list
173
92
-
94
92
expr
95
92
~
96
92
not_test
97
92
comparison
98
92
power
99
92
NUMBER
100
92
False
101
92
and_expr
102
92
and_test
103
92
not
104
92
test
105
93
]
174
94
call
79
94
None
82
94
power
99
94
NAME
85
94
NUMBER
100
94
+
87
94
-
94
94
factor
175
94
STRING
88
94
atom
89
94
True
91
94
[
92
94
False
101
94
~
96
95
>
106
95
>=
107
95
<
108
95
!=
109
95
]
comparison -> expr
95
==
110
95
and
comparison -> expr
95
<=
111
95
comp_op
176
95
,
comparison -> expr
95
or
comparison -> expr
96
call
79
96
None
82
96
power
99
96
NAME
85
96
NUMBER
100
96
+
87
96
-
94
96
factor
177
96
STRING
88
96
atom
89
96
True
91
96
[
92
96
False
101
96
~
96
97
and
178
97
,
and_test -> not_test
97
or
and_test -> not_test
97
]
and_test -> not_test
98
or
not_test -> comparison
98
,
not_test -> comparison
98
]
not_test -> comparison
98
and
not_test -> comparison
99
//
factor -> power
99
<<
factor -> power
99
<
factor -> power
99
!=
factor -> power
99
<=
factor -> power
99
|
factor -> power
99
-
factor -> power
99
,
factor -> power
99
>=
factor -> power
99
/
factor -> power
99
>>
factor -> power
99
*
factor -> power
99
==
factor -> power
99
&
factor -> power
99
]
factor -> power
99
^
factor -> power
99
+
factor -> power
99
and
factor -> power
99
>
factor -> power
99
or
factor -> power
99
%
factor -> power
100
/
atom -> NUMBER
100
or
atom -> NUMBER
100
>>
atom -> NUMBER
100
*
atom -> NUMBER
100
<=
atom -> NUMBER
100
+
atom -> NUMBER
100
and
atom -> NUMBER
100
-
atom -> NUMBER
100
==
atom -> NUMBER
100
<
atom -> NUMBER
100
%
atom -> NUMBER
100
//
atom -> NUMBER
100
>=
atom -> NUMBER
100
>
atom -> NUMBER
100
]
atom -> NUMBER
100
!=
atom -> NUMBER
100
**
atom -> NUMBER
100
,
atom -> NUMBER
100
^
atom -> NUMBER
100
&
atom -> NUMBER
100
<<
atom -> NUMBER
100
|
atom -> NUMBER
101
and
atom -> False
101
/
atom -> False
101
*
atom -> False
101
-
atom -> False
101
**
atom -> False
101
]
atom -> False
101
<<
atom -> False
101
>
atom -> False
101
>>
atom -> False
101
==
atom -> False
101
|
atom -> False
101
%
atom -> False
101
<=
atom -> False
101
,
atom -> False
101
or
atom -> False
101
<
atom -> False
101
//
atom -> False
101
+
atom -> False
101
>=
atom -> False
101
&
atom -> False
101
^
atom -> False
101
!=
atom -> False
102
and
xor_expr -> and_expr
102
^
179
102
>=
xor_expr -> and_expr
102
]
xor_expr -> and_expr
102
<=
xor_expr -> and_expr
102
==
xor_expr -> and_expr
102
or
xor_expr -> and_expr
102
,
xor_expr -> and_expr
102
<
xor_expr -> and_expr
102
!=
xor_expr -> and_expr
102
>
xor_expr -> and_expr
102
|
xor_expr -> and_expr
103
]
or_test -> and_test
103
or
180
103
,
or_test -> and_test
104
call
79
104
factor
80
104
term
81
104
None
82
104
xor_expr
84
104
power
99
104
NAME
85
104
NUMBER
100
104
arith_expr
86
104
+
87
104
-
94
104
STRING
88
104
and_expr
102
104
atom
89
104
shift_expr
90
104
True
91
104
[
92
104
False
101
104
expr
95
104
~
96
104
comparison
98
104
not_test
181
104
not
104
105
]
test_list -> test
105
,
182
106
STRING
comp_op -> >
106
True
comp_op -> >
106
None
comp_op -> >
106
False
comp_op -> >
106
~
comp_op -> >
106
NUMBER
comp_op -> >
106
-
comp_op -> >
106
[
comp_op -> >
106
NAME
comp_op -> >
106
+
comp_op -> >
107
+
comp_op -> >=
107
[
comp_op -> >=
107
STRING
comp_op -> >=
107
None
comp_op -> >=
107
-
comp_op -> >=
107
True
comp_op -> >=
107
~
comp_op -> >=
107
NUMBER
comp_op -> >=
107
False
comp_op -> >=
107
NAME
comp_op -> >=
108
NAME
comp_op -> <
108
NUMBER
comp_op -> <
108
-
comp_op -> <
108
True
comp_op -> <
108
+
comp_op -> <
108
STRING
comp_op -> <
108
None
comp_op -> <
108
[
comp_op -> <
108
~
comp_op -> <
108
False
comp_op -> <
109
None
comp_op -> !=
109
False
comp_op -> !=
109
NUMBER
comp_op -> !=
109
[
comp_op -> !=
109
+
comp_op -> !=
109
STRING
comp_op -> !=
109
True
comp_op -> !=
109
~
comp_op -> !=
109
-
comp_op -> !=
109
NAME
comp_op -> !=
110
True
comp_op -> ==
110
~
comp_op -> ==
110
NAME
comp_op -> ==
110
+
comp_op -> ==
110
NUMBER
comp_op -> ==
110
None
comp_op -> ==
110
-
comp_op -> ==
110
False
comp_op -> ==
110
[
comp_op -> ==
110
STRING
comp_op -> ==
111
STRING
comp_op -> <=
111
NAME
comp_op -> <=
111
False
comp_op -> <=
111
[
comp_op -> <=
111
-
comp_op -> <=
111
NUMBER
comp_op -> <=
111
True
comp_op -> <=
111
None
comp_op -> <=
111
~
comp_op -> <=
111
+
comp_op -> <=
112
call
38
112
factor
39
112
term
40
112
None
41
112
xor_expr
42
112
NAME
43
112
arith_expr
44
112
+
45
112
STRING
46
112
atom
47
112
shift_expr
48
112
True
49
112
[
50
112
expr
51
112
-
52
112
~
53
112
and_expr
54
112
power
56
112
NUMBER
57
112
False
58
112
comparison
183
113
or
factor -> - factor
113
*
factor -> - factor
113
NEWLINE
factor -> - factor
113
&
factor -> - factor
113
>=
factor -> - factor
113
and
factor -> - factor
113
>>
factor -> - factor
113
>
factor -> - factor
113
+
factor -> - factor
113
%
factor -> - factor
113
//
factor -> - factor
113
<=
factor -> - factor
113
==
factor -> - factor
113
/
factor -> - factor
113
-
factor -> - factor
113
<<
factor -> - factor
113
!=
factor -> - factor
113
^
factor -> - factor
113
|
factor -> - factor
113
<
factor -> - factor
113
NAME
factor -> - factor
113
DEDENT
factor -> - factor
114
and
factor -> ~ factor
114
>>
factor -> ~ factor
114
/
factor -> ~ factor
114
<=
factor -> ~ factor
114
-
factor -> ~ factor
114
!=
factor -> ~ factor
114
DEDENT
factor -> ~ factor
114
==
factor -> ~ factor
114
^
factor -> ~ factor
114
or
factor -> ~ factor
114
>=
factor -> ~ factor
114
>
factor -> ~ factor
114
<
factor -> ~ factor
114
NEWLINE
factor -> ~ factor
114
+
factor -> ~ factor
114
<<
factor -> ~ factor
114
|
factor -> ~ factor
114
NAME
factor -> ~ factor
114
&
factor -> ~ factor
114
*
factor -> ~ factor
114
%
factor -> ~ factor
114
//
factor -> ~ factor
115
call
38
115
factor
39
115
xor_expr
184
115
term
40
115
None
41
115
power
56
115
NAME
43
115
arith_expr
44
115
+
45
115
-
52
115
NUMBER
57
115
STRING
46
115
atom
47
115
shift_expr
48
115
True
49
115
[
50
115
and_expr
54
115
False
58
115
~
53
116
call
38
116
factor
39
116
term
40
116
None
41
116
xor_expr
42
116
NAME
43
116
arith_expr
44
116
+
45
116
STRING
46
116
atom
47
116
shift_expr
48
116
True
49
116
[
50
116
expr
51
116
-
52
116
~
53
116
and_expr
54
116
comparison
55
116
power
56
116
NUMBER
57
116
False
58
116
and_test
59
116
not_test
61
116
not
62
116
or_test
185
117
call
38
117
factor
39
117
term
40
117
None
41
117
xor_expr
42
117
NAME
43
117
arith_expr
44
117
+
45
117
STRING
46
117
atom
47
117
shift_expr
48
117
True
49
117
[
50
117
expr
51
117
-
52
117
~
53
117
and_expr
54
117
comparison
55
117
power
56
117
NUMBER
57
117
False
58
117
not_test
61
117
not
62
117
and_test
186
118
NAME
not_test -> not not_test
118
NEWLINE
not_test -> not not_test
118
and
not_test -> not not_test
118
or
not_test -> not not_test
118
DEDENT
not_test -> not not_test
119
:
187
120
)
name_list -> NAME name_list
121
NAME
term -> factor % term
121
+
term -> factor % term
121
>=
term -> factor % term
121
!=
term -> factor % term
121
^
term -> factor % term
121
or
term -> factor % term
121
<<
term -> factor % term
121
DEDENT
term -> factor % term
121
and
term -> factor % term
121
<
term -> factor % term
121
==
term -> factor % term
121
>
term -> factor % term
121
|
term -> factor % term
121
&
term -> factor % term
121
-
term -> factor % term
121
>>
term -> factor % term
121
NEWLINE
term -> factor % term
121
<=
term -> factor % term
122
&
term -> factor // term
122
>=
term -> factor // term
122
+
term -> factor // term
122
<<
term -> factor // term
122
!=
term -> factor // term
122
NEWLINE
term -> factor // term
122
<=
term -> factor // term
122
|
term -> factor // term
122
and
term -> factor // term
122
>>
term -> factor // term
122
^
term -> factor // term
122
NAME
term -> factor // term
122
-
term -> factor // term
122
<
term -> factor // term
122
DEDENT
term -> factor // term
122
>
term -> factor // term
122
==
term -> factor // term
122
or
term -> factor // term
123
NAME
term -> factor / term
123
|
term -> factor / term
123
or
term -> factor / term
123
and
term -> factor / term
123
<=
term -> factor / term
123
<<
term -> factor / term
123
^
term -> factor / term
123
NEWLINE
term -> factor / term
123
-
term -> factor / term
123
>>
term -> factor / term
123
==
term -> factor / term
123
>
term -> factor / term
123
>=
term -> factor / term
123
<
term -> factor / term
123
DEDENT
term -> factor / term
123
+
term -> factor / term
123
&
term -> factor / term
123
!=
term -> factor / term
124
>>
term -> factor * term
124
NEWLINE
term -> factor * term
124
NAME
term -> factor * term
124
>=
term -> factor * term
124
-
term -> factor * term
124
and
term -> factor * term
124
|
term -> factor * term
124
DEDENT
term -> factor * term
124
<=
term -> factor * term
124
or
term -> factor * term
124
+
term -> factor * term
124
<
term -> factor * term
124
>
term -> factor * term
124
^
term -> factor * term
124
&
term -> factor * term
124
==
term -> factor * term
124
<<
term -> factor * term
124
!=
term -> factor * term
125
|
arith_expr -> term + arith_expr
125
!=
arith_expr -> term + arith_expr
125
DEDENT
arith_expr -> term + arith_expr
125
>
arith_expr -> term + arith_expr
125
>=
arith_expr -> term + arith_expr
125
&
arith_expr -> term + arith_expr
125
==
arith_expr -> term + arith_expr
125
<=
arith_expr -> term + arith_expr
125
<
arith_expr -> term + arith_expr
125
<<
arith_expr -> term + arith_expr
125
and
arith_expr -> term + arith_expr
125
>>
arith_expr -> term + arith_expr
125
NAME
arith_expr -> term + arith_expr
125
^
arith_expr -> term + arith_expr
125
or
arith_expr -> term + arith_expr
125
NEWLINE
arith_expr -> term + arith_expr
126
or
arith_expr -> term - arith_expr
126
<=
arith_expr -> term - arith_expr
126
NAME
arith_expr -> term - arith_expr
126
>=
arith_expr -> term - arith_expr
126
NEWLINE
arith_expr -> term - arith_expr
126
==
arith_expr -> term - arith_expr
126
DEDENT
arith_expr -> term - arith_expr
126
>>
arith_expr -> term - arith_expr
126
|
arith_expr -> term - arith_expr
126
<<
arith_expr -> term - arith_expr
126
<
arith_expr -> term - arith_expr
126
!=
arith_expr -> term - arith_expr
126
>
arith_expr -> term - arith_expr
126
^
arith_expr -> term - arith_expr
126
&
arith_expr -> term - arith_expr
126
and
arith_expr -> term - arith_expr
127
NEWLINE
expr -> xor_expr | expr
127
<=
expr -> xor_expr | expr
127
!=
expr -> xor_expr | expr
127
==
expr -> xor_expr | expr
127
or
expr -> xor_expr | expr
127
DEDENT
expr -> xor_expr | expr
127
and
expr -> xor_expr | expr
127
>=
expr -> xor_expr | expr
127
NAME
expr -> xor_expr | expr
127
>
expr -> xor_expr | expr
127
<
expr -> xor_expr | expr
128
%
atom -> call
128
&
atom -> call
128
,
atom -> call
128
)
atom -> call
128
-
atom -> call
128
<
atom -> call
128
and
atom -> call
128
>
atom -> call
128
>=
atom -> call
128
<=
atom -> call
128
//
atom -> call
128
<<
atom -> call
128
or
atom -> call
128
/
atom -> call
128
|
atom -> call
128
*
atom -> call
128
+
atom -> call
128
>>
atom -> call
128
!=
atom -> call
128
**
atom -> call
128
==
atom -> call
128
^
atom -> call
129
%
188
129
//
189
129
>>
term -> factor
129
/
190
129
*
191
129
<<
term -> factor
129
==
term -> factor
129
)
term -> factor
129
<=
term -> factor
129
+
term -> factor
129
>=
term -> factor
129
&
term -> factor
129
>
term -> factor
129
<
term -> factor
129
!=
term -> factor
129
or
term -> factor
129
|
term -> factor
129
^
term -> factor
129
,
term -> factor
129
and
term -> factor
129
-
term -> factor
130
+
192
130
<
arith_expr -> term
130
-
193
130
<=
arith_expr -> term
130
==
arith_expr -> term
130
and
arith_expr -> term
130
,
arith_expr -> term
130
>
arith_expr -> term
130
>>
arith_expr -> term
130
^
arith_expr -> term
130
|
arith_expr -> term
130
>=
arith_expr -> term
130
<<
arith_expr -> term
130
or
arith_expr -> term
130
)
arith_expr -> term
130
!=
arith_expr -> term
130
&
arith_expr -> term
131
<
atom -> None
131
<<
atom -> None
131
!=
atom -> None
131
<=
atom -> None
131
)
atom -> None
131
%
atom -> None
131
&
atom -> None
131
*
atom -> None
131
-
atom -> None
131
>
atom -> None
131
and
atom -> None
131
^
atom -> None
131
>=
atom -> None
131
**
atom -> None
131
|
atom -> None
131
,
atom -> None
131
>>
atom -> None
131
/
atom -> None
131
//
atom -> None
131
==
atom -> None
131
+
atom -> None
131
or
atom -> None
132
|
194
132
!=
expr -> xor_expr
132
==
expr -> xor_expr
132
<
expr -> xor_expr
132
>
expr -> xor_expr
132
<=
expr -> xor_expr
132
>=
expr -> xor_expr
132
and
expr -> xor_expr
132
)
expr -> xor_expr
132
,
expr -> xor_expr
132
or
expr -> xor_expr
133
&
atom -> NAME
133
(
195
133
%
atom -> NAME
133
)
atom -> NAME
133
,
atom -> NAME
133
>>
atom -> NAME
133
^
atom -> NAME
133
>
atom -> NAME
133
<<
atom -> NAME
133
and
atom -> NAME
133
or
atom -> NAME
133
<
atom -> NAME
133
**
atom -> NAME
133
|
atom -> NAME
133
<=
atom -> NAME
133
==
atom -> NAME
133
/
atom -> NAME
133
>=
atom -> NAME
133
!=
atom -> NAME
133
+
atom -> NAME
133
*
atom -> NAME
133
-
atom -> NAME
133
//
atom -> NAME
134
>>
196
134
==
shift_expr -> arith_expr
134
)
shift_expr -> arith_expr
134
^
shift_expr -> arith_expr
134
<<
197
134
>=
shift_expr -> arith_expr
134
<=
shift_expr -> arith_expr
134
or
shift_expr -> arith_expr
134
|
shift_expr -> arith_expr
134
>
shift_expr -> arith_expr
134
,
shift_expr -> arith_expr
134
!=
shift_expr -> arith_expr
134
<
shift_expr -> arith_expr
134
and
shift_expr -> arith_expr
134
&
shift_expr -> arith_expr
135
call
128
135
None
131
135
power
146
135
NAME
133
135
NUMBER
147
135
+
135
135
-
141
135
STRING
136
135
atom
137
135
True
139
135
[
140
135
False
148
135
~
144
135
factor
198
136
,
atom -> STRING
136
!=
atom -> STRING
136
<<
atom -> STRING
136
//
atom -> STRING
136
/
atom -> STRING
136
<
atom -> STRING
136
==
atom -> STRING
136
|
atom -> STRING
136
>=
atom -> STRING
136
^
atom -> STRING
136
>>
atom -> STRING
136
<=
atom -> STRING
136
*
atom -> STRING
136
>
atom -> STRING
136
%
atom -> STRING
136
-
atom -> STRING
136
**
atom -> STRING
136
+
atom -> STRING
136
and
atom -> STRING
136
)
atom -> STRING
136
or
atom -> STRING
136
&
atom -> STRING
137
<=
power -> atom
137
>
power -> atom
137
**
199
137
|
power -> atom
137
//
power -> atom
137
>>
power -> atom
137
-
power -> atom
137
and
power -> atom
137
>=
power -> atom
137
!=
power -> atom
137
/
power -> atom
137
<<
power -> atom
137
)
power -> atom
137
&
power -> atom
137
%
power -> atom
137
,
power -> atom
137
^
power -> atom
137
+
power -> atom
137
or
power -> atom
137
*
power -> atom
137
==
power -> atom
137
<
power -> atom
138
,
and_expr -> shift_expr
138
and
and_expr -> shift_expr
138
<
and_expr -> shift_expr
138
^
and_expr -> shift_expr
138
&
200
138
>
and_expr -> shift_expr
138
==
and_expr -> shift_expr
138
|
and_expr -> shift_expr
138
)
and_expr -> shift_expr
138
!=
and_expr -> shift_expr
138
<=
and_expr -> shift_expr
138
or
and_expr -> shift_expr
138
>=
and_expr -> shift_expr
139
>=
atom -> True
139
|
atom -> True
139
//
atom -> True
139
<
atom -> True
139
==
atom -> True
139
-
atom -> True
139
,
atom -> True
139
<<
atom -> True
139
/
atom -> True
139
or
atom -> True
139
!=
atom -> True
139
**
atom -> True
139
)
atom -> True
139
^
atom -> True
139
&
atom -> True
139
*
atom -> True
139
%
atom -> True
139
<=
atom -> True
139
>
atom -> True
139
+
atom -> True
139
and
atom -> True
139
>>
atom -> True
140
call
79
140
factor
80
140
term
81
140
None
82
140
or_test
83
140
xor_expr
84
140
NAME
85
140
arith_expr
86
140
+
87
140
STRING
88
140
atom
89
140
shift_expr
90
140
True
91
140
[
92
140
test_list
201
140
-
94
140
expr
95
140
~
96
140
not_test
97
140
comparison
98
140
power
99
140
NUMBER
100
140
False
101
140
and_expr
102
140
and_test
103
140
not
104
140
test
105
141
call
128
141
None
131
141
power
146
141
NAME
133
141
NUMBER
147
141
+
135
141
-
141
141
factor
202
141
STRING
136
141
atom
137
141
True
139
141
[
140
141
False
148
141
~
144
142
and
203
142
,
and_test -> not_test
142
or
and_test -> not_test
142
)
and_test -> not_test
143
>
106
143
>=
107
143
<
108
143
!=
109
143
==
110
143
and
comparison -> expr
143
<=
111
143
comp_op
204
143
,
comparison -> expr
143
)
comparison -> expr
143
or
comparison -> expr
144
call
128
144
None
131
144
power
146
144
NAME
133
144
NUMBER
147
144
+
135
144
-
141
144
factor
205
144
STRING
136
144
atom
137
144
True
139
144
[
140
144
False
148
144
~
144
145
or
not_test -> comparison
145
,
not_test -> comparison
145
)
not_test -> comparison
145
and
not_test -> comparison
146
//
factor -> power
146
<<
factor -> power
146
)
factor -> power
146
<
factor -> power
146
!=
factor -> power
146
<=
factor -> power
146
|
factor -> power
146
-
factor -> power
146
,
factor -> power
146
>=
factor -> power
146
/
factor -> power
146
>>
factor -> power
146
*
factor -> power
146
==
factor -> power
146
&
factor -> power
146
^
factor -> power
146
+
factor -> power
146
and
factor -> power
146
>
factor -> power
146
or
factor -> power
146
%
factor -> power
147
/
atom -> NUMBER
147
or
atom -> NUMBER
147
>>
atom -> NUMBER
147
*
atom -> NUMBER
147
<=
atom -> NUMBER
147
+
atom -> NUMBER
147
and
atom -> NUMBER
147
-
atom -> NUMBER
147
==
atom -> NUMBER
147
<
atom -> NUMBER
147
%
atom -> NUMBER
147
//
atom -> NUMBER
147
>=
atom -> NUMBER
147
>
atom -> NUMBER
147
!=
atom -> NUMBER
147
**
atom -> NUMBER
147
,
atom -> NUMBER
147
&
atom -> NUMBER
147
^
atom -> NUMBER
147
<<
atom -> NUMBER
147
|
atom -> NUMBER
147
)
atom -> NUMBER
148
and
atom -> False
148
/
atom -> False
148
*
atom -> False
148
-
atom -> False
148
**
atom -> False
148
<<
atom -> False
148
>
atom -> False
148
>>
atom -> False
148
==
atom -> False
148
|
atom -> False
148
%
atom -> False
148
<=
atom -> False
148
,
atom -> False
148
or
atom -> False
148
<
atom -> False
148
//
atom -> False
148
+
atom -> False
148
>=
atom -> False
148
&
atom -> False
148
)
atom -> False
148
^
atom -> False
148
!=
atom -> False
149
and
xor_expr -> and_expr
149
^
206
149
>=
xor_expr -> and_expr
149
<=
xor_expr -> and_expr
149
==
xor_expr -> and_expr
149
or
xor_expr -> and_expr
149
,
xor_expr -> and_expr
149
<
xor_expr -> and_expr
149
!=
xor_expr -> and_expr
149
>
xor_expr -> and_expr
149
)
xor_expr -> and_expr
149
|
xor_expr -> and_expr
150
call
128
150
factor
129
150
term
130
150
None
131
150
xor_expr
132
150
power
146
150
NAME
133
150
NUMBER
147
150
arith_expr
134
150
+
135
150
-
141
150
STRING
136
150
atom
137
150
shift_expr
138
150
True
139
150
[
140
150
and_expr
149
150
False
148
150
expr
143
150
~
144
150
comparison
145
150
not_test
207
150
not
150
151
DEDENT
call -> NAME ( )
151
<<
call -> NAME ( )
151
//
call -> NAME ( )
151
or
call -> NAME ( )
151
>>
call -> NAME ( )
151
/
call -> NAME ( )
151
%
call -> NAME ( )
151
NAME
call -> NAME ( )
151
+
call -> NAME ( )
151
>
call -> NAME ( )
151
NEWLINE
call -> NAME ( )
151
>=
call -> NAME ( )
151
==
call -> NAME ( )
151
<
call -> NAME ( )
151
^
call -> NAME ( )
151
-
call -> NAME ( )
151
and
call -> NAME ( )
151
**
call -> NAME ( )
151
|
call -> NAME ( )
151
<=
call -> NAME ( )
151
!=
call -> NAME ( )
151
&
call -> NAME ( )
151
*
call -> NAME ( )
152
)
208
153
)
or_test -> and_test
153
or
209
153
,
or_test -> and_test
154
,
test -> or_test
154
)
test -> or_test
155
)
test_list -> test
155
,
210
156
>
shift_expr -> arith_expr >> shift_expr
156
DEDENT
shift_expr -> arith_expr >> shift_expr
156
NEWLINE
shift_expr -> arith_expr >> shift_expr
156
&
shift_expr -> arith_expr >> shift_expr
156
or
shift_expr -> arith_expr >> shift_expr
156
<
shift_expr -> arith_expr >> shift_expr
156
>=
shift_expr -> arith_expr >> shift_expr
156
^
shift_expr -> arith_expr >> shift_expr
156
<=
shift_expr -> arith_expr >> shift_expr
156
|
shift_expr -> arith_expr >> shift_expr
156
!=
shift_expr -> arith_expr >> shift_expr
156
==
shift_expr -> arith_expr >> shift_expr
156
NAME
shift_expr -> arith_expr >> shift_expr
156
and
shift_expr -> arith_expr >> shift_expr
157
|
shift_expr -> arith_expr << shift_expr
157
==
shift_expr -> arith_expr << shift_expr
157
>
shift_expr -> arith_expr << shift_expr
157
and
shift_expr -> arith_expr << shift_expr
157
NEWLINE
shift_expr -> arith_expr << shift_expr
157
<=
shift_expr -> arith_expr << shift_expr
157
DEDENT
shift_expr -> arith_expr << shift_expr
157
!=
shift_expr -> arith_expr << shift_expr
157
>=
shift_expr -> arith_expr << shift_expr
157
&
shift_expr -> arith_expr << shift_expr
157
<
shift_expr -> arith_expr << shift_expr
157
NAME
shift_expr -> arith_expr << shift_expr
157
^
shift_expr -> arith_expr << shift_expr
157
or
shift_expr -> arith_expr << shift_expr
158
DEDENT
power -> atom ** factor
158
<
power -> atom ** factor
158
/
power -> atom ** factor
158
*
power -> atom ** factor
158
-
power -> atom ** factor
158
<=
power -> atom ** factor
158
+
power -> atom ** factor
158
>>
power -> atom ** factor
158
or
power -> atom ** factor
158
&
power -> atom ** factor
158
NAME
power -> atom ** factor
158
!=
power -> atom ** factor
158
//
power -> atom ** factor
158
%
power -> atom ** factor
158
NEWLINE
power -> atom ** factor
158
>
power -> atom ** factor
158
<<
power -> atom ** factor
158
|
power -> atom ** factor
158
^
power -> atom ** factor
158
==
power -> atom ** factor
158
>=
power -> atom ** factor
158
and
power -> atom ** factor
159
<=
and_expr -> shift_expr & and_expr
159
^
and_expr -> shift_expr & and_expr
159
>=
and_expr -> shift_expr & and_expr
159
<
and_expr -> shift_expr & and_expr
159
NEWLINE
and_expr -> shift_expr & and_expr
159
==
and_expr -> shift_expr & and_expr
159
DEDENT
and_expr -> shift_expr & and_expr
159
NAME
and_expr -> shift_expr & and_expr
159
>
and_expr -> shift_expr & and_expr
159
or
and_expr -> shift_expr & and_expr
159
and
and_expr -> shift_expr & and_expr
159
|
and_expr -> shift_expr & and_expr
159
!=
and_expr -> shift_expr & and_expr
160
call
79
160
factor
80
160
None
82
160
power
99
160
NAME
85
160
NUMBER
100
160
+
87
160
-
94
160
STRING
88
160
atom
89
160
True
91
160
[
92
160
False
101
160
~
96
160
term
211
161
call
79
161
factor
80
161
None
82
161
power
99
161
NAME
85
161
NUMBER
100
161
+
87
161
-
94
161
STRING
88
161
atom
89
161
True
91
161
[
92
161
False
101
161
term
212
161
~
96
162
call
79
162
factor
80
162
None
82
162
power
99
162
NAME
85
162
NUMBER
100
162
+
87
162
-
94
162
STRING
88
162
atom
89
162
term
213
162
True
91
162
[
92
162
False
101
162
~
96
163
call
79
163
factor
80
163
term
214
163
None
82
163
power
99
163
NAME
85
163
NUMBER
100
163
+
87
163
-
94
163
STRING
88
163
atom
89
163
True
91
163
[
92
163
False
101
163
~
96
164
call
79
164
factor
80
164
term
81
164
None
82
164
power
99
164
NAME
85
164
NUMBER
100
164
+
87
164
-
94
164
STRING
88
164
atom
89
164
arith_expr
215
164
True
91
164
[
92
164
False
101
164
~
96
165
call
79
165
factor
80
165
term
81
165
None
82
165
power
99
165
NAME
85
165
NUMBER
100
165
+
87
165
-
94
165
STRING
88
165
atom
89
165
True
91
165
[
92
165
False
101
165
arith_expr
216
165
~
96
166
call
79
166
factor
80
166
term
81
166
None
82
166
xor_expr
84
166
power
99
166
NAME
85
166
NUMBER
100
166
arith_expr
86
166
+
87
166
-
94
166
STRING
88
166
and_expr
102
166
atom
89
166
shift_expr
90
166
True
91
166
[
92
166
False
101
166
~
96
166
expr
217
167
call
128
167
factor
129
167
term
130
167
None
131
167
xor_expr
132
167
NAME
133
167
arith_expr
134
167
+
135
167
STRING
136
167
atom
137
167
shift_expr
138
167
True
139
167
[
140
167
-
141
167
not_test
142
167
expr
143
167
~
144
167
comparison
145
167
power
146
167
NUMBER
147
167
False
148
167
and_expr
149
167
not
150
167
)
218
167
test_list
219
167
and_test
153
167
or_test
154
167
test
155
168
call
79
168
factor
80
168
term
81
168
None
82
168
power
99
168
NAME
85
168
NUMBER
100
168
arith_expr
86
168
+
87
168
-
94
168
shift_expr
220
168
STRING
88
168
atom
89
168
True
91
168
[
92
168
False
101
168
~
96
169
call
79
169
factor
80
169
term
81
169
None
82
169
power
99
169
NAME
85
169
NUMBER
100
169
arith_expr
86
169
+
87
169
-
94
169
STRING
88
169
atom
89
169
True
91
169
[
92
169
False
101
169
~
96
169
shift_expr
221
170
>=
factor -> + factor
170
<=
factor -> + factor
170
*
factor -> + factor
170
==
factor -> + factor
170
>
factor -> + factor
170
!=
factor -> + factor
170
-
factor -> + factor
170
and
factor -> + factor
170
//
factor -> + factor
170
%
factor -> + factor
170
/
factor -> + factor
170
<<
factor -> + factor
170
]
factor -> + factor
170
+
factor -> + factor
170
,
factor -> + factor
170
^
factor -> + factor
170
or
factor -> + factor
170
&
factor -> + factor
170
|
factor -> + factor
170
>>
factor -> + factor
170
<
factor -> + factor
171
call
79
171
factor
222
171
None
82
171
power
99
171
NAME
85
171
NUMBER
100
171
+
87
171
-
94
171
STRING
88
171
atom
89
171
True
91
171
[
92
171
False
101
171
~
96
172
and_expr
223
172
call
79
172
factor
80
172
term
81
172
None
82
172
power
99
172
NAME
85
172
NUMBER
100
172
arith_expr
86
172
+
87
172
-
94
172
STRING
88
172
atom
89
172
shift_expr
90
172
True
91
172
[
92
172
False
101
172
~
96
173
]
224
174
^
atom -> [ test_list ]
174
<
atom -> [ test_list ]
174
|
atom -> [ test_list ]
174
==
atom -> [ test_list ]
174
**
atom -> [ test_list ]
174
DEDENT
atom -> [ test_list ]
174
-
atom -> [ test_list ]
174
*
atom -> [ test_list ]
174
and
atom -> [ test_list ]
174
NAME
atom -> [ test_list ]
174
NEWLINE
atom -> [ test_list ]
174
>=
atom -> [ test_list ]
174
<<
atom -> [ test_list ]
174
/
atom -> [ test_list ]
174
!=
atom -> [ test_list ]
174
&
atom -> [ test_list ]
174
or
atom -> [ test_list ]
174
+
atom -> [ test_list ]
174
//
atom -> [ test_list ]
174
>>
atom -> [ test_list ]
174
>
atom -> [ test_list ]
174
<=
atom -> [ test_list ]
174
%
atom -> [ test_list ]
175
or
factor -> - factor
175
*
factor -> - factor
175
&
factor -> - factor
175
>=
factor -> - factor
175
and
factor -> - factor
175
>>
factor -> - factor
175
>
factor -> - factor
175
+
factor -> - factor
175
%
factor -> - factor
175
//
factor -> - factor
175
<=
factor -> - factor
175
==
factor -> - factor
175
/
factor -> - factor
175
]
factor -> - factor
175
-
factor -> - factor
175
<<
factor -> - factor
175
!=
factor -> - factor
175
,
factor -> - factor
175
^
factor -> - factor
175
|
factor -> - factor
175
<
factor -> - factor
176
call
79
176
factor
80
176
term
81
176
None
82
176
xor_expr
84
176
power
99
176
NAME
85
176
NUMBER
100
176
arith_expr
86
176
+
87
176
-
94
176
STRING
88
176
and_expr
102
176
atom
89
176
shift_expr
90
176
True
91
176
[
92
176
False
101
176
expr
95
176
~
96
176
comparison
225
177
and
factor -> ~ factor
177
/
factor -> ~ factor
177
>>
factor -> ~ factor
177
<=
factor -> ~ factor
177
,
factor -> ~ factor
177
-
factor -> ~ factor
177
!=
factor -> ~ factor
177
==
factor -> ~ factor
177
^
factor -> ~ factor
177
or
factor -> ~ factor
177
>=
factor -> ~ factor
177
>
factor -> ~ factor
177
<
factor -> ~ factor
177
+
factor -> ~ factor
177
<<
factor -> ~ factor
177
|
factor -> ~ factor
177
//
factor -> ~ factor
177
&
factor -> ~ factor
177
*
factor -> ~ factor
177
%
factor -> ~ factor
177
]
factor -> ~ factor
178
call
79
178
factor
80
178
term
81
178
None
82
178
xor_expr
84
178
power
99
178
NAME
85
178
NUMBER
100
178
arith_expr
86
178
+
87
178
-
94
178
STRING
88
178
and_expr
102
178
atom
89
178
shift_expr
90
178
True
91
178
[
92
178
False
101
178
expr
95
178
~
96
178
not_test
97
178
comparison
98
178
not
104
178
and_test
226
179
call
79
179
factor
80
179
term
81
179
None
82
179
power
99
179
NAME
85
179
NUMBER
100
179
arith_expr
86
179
+
87
179
-
94
179
STRING
88
179
and_expr
102
179
atom
89
179
shift_expr
90
179
True
91
179
[
92
179
False
101
179
~
96
179
xor_expr
227
180
call
79
180
factor
80
180
term
81
180
None
82
180
xor_expr
84
180
power
99
180
NAME
85
180
NUMBER
100
180
arith_expr
86
180
+
87
180
-
94
180
STRING
88
180
and_expr
102
180
atom
89
180
shift_expr
90
180
True
91
180
[
92
180
False
101
180
expr
95
180
~
96
180
not_test
97
180
comparison
98
180
or_test
228
180
and_test
103
180
not
104
181
or
not_test -> not not_test
181
,
not_test -> not not_test
181
]
not_test -> not not_test
181
and
not_test -> not not_test
182
call
79
182
factor
80
182
term
81
182
None
82
182
or_test
83
182
xor_expr
84
182
power
99
182
NUMBER
100
182
NAME
85
182
arith_expr
86
182
+
87
182
-
94
182
STRING
88
182
and_expr
102
182
atom
89
182
shift_expr
90
182
True
91
182
[
92
182
False
101
182
expr
95
182
~
96
182
not_test
97
182
comparison
98
182
and_test
103
182
not
104
182
test
105
182
test_list
229
183
and
comparison -> expr comp_op comparison
183
NAME
comparison -> expr comp_op comparison
183
NEWLINE
comparison -> expr comp_op comparison
183
or
comparison -> expr comp_op comparison
183
DEDENT
comparison -> expr comp_op comparison
184
DEDENT
xor_expr -> and_expr ^ xor_expr
184
NEWLINE
xor_expr -> and_expr ^ xor_expr
184
and
xor_expr -> and_expr ^ xor_expr
184
<=
xor_expr -> and_expr ^ xor_expr
184
or
xor_expr -> and_expr ^ xor_expr
184
|
xor_expr -> and_expr ^ xor_expr
184
==
xor_expr -> and_expr ^ xor_expr
184
>
xor_expr -> and_expr ^ xor_expr
184
<
xor_expr -> and_expr ^ xor_expr
184
!=
xor_expr -> and_expr ^ xor_expr
184
>=
xor_expr -> and_expr ^ xor_expr
184
NAME
xor_expr -> and_expr ^ xor_expr
185
DEDENT
or_test -> and_test or or_test
185
NEWLINE
or_test -> and_test or or_test
185
NAME
or_test -> and_test or or_test
186
NAME
and_test -> not_test and and_test
186
or
and_test -> not_test and and_test
186
NEWLINE
and_test -> not_test and and_test
186
DEDENT
and_test -> not_test and and_test
187
NEWLINE
230
187
suite
231
188
call
128
188
factor
129
188
None
131
188
power
146
188
NAME
133
188
NUMBER
147
188
+
135
188
-
141
188
STRING
136
188
atom
137
188
True
139
188
[
140
188
False
148
188
~
144
188
term
232
189
call
128
189
factor
129
189
None
131
189
power
146
189
NAME
133
189
NUMBER
147
189
+
135
189
-
141
189
STRING
136
189
atom
137
189
True
139
189
[
140
189
False
148
189
~
144
189
term
233
190
call
128
190
factor
129
190
term
234
190
None
131
190
power
146
190
NAME
133
190
NUMBER
147
190
+
135
190
-
141
190
STRING
136
190
atom
137
190
True
139
190
[
140
190
False
148
190
~
144
191
call
128
191
factor
129
191
None
131
191
power
146
191
NAME
133
191
NUMBER
147
191
+
135
191
-
141
191
STRING
136
191
atom
137
191
True
139
191
[
140
191
False
148
191
term
235
191
~
144
192
call
128
192
factor
129
192
term
130
192
None
131
192
power
146
192
NAME
133
192
NUMBER
147
192
+
135
192
-
141
192
STRING
136
192
atom
137
192
arith_expr
236
192
True
139
192
[
140
192
False
148
192
~
144
193
call
128
193
factor
129
193
term
130
193
None
131
193
power
146
193
NAME
133
193
NUMBER
147
193
+
135
193
-
141
193
STRING
136
193
atom
137
193
True
139
193
[
140
193
arith_expr
237
193
False
148
193
~
144
194
call
128
194
factor
129
194
term
130
194
None
131
194
xor_expr
132
194
power
146
194
NAME
133
194
NUMBER
147
194
arith_expr
134
194
+
135
194
-
141
194
STRING
136
194
atom
137
194
shift_expr
138
194
True
139
194
[
140
194
and_expr
149
194
False
148
194
~
144
194
expr
238
195
call
128
195
factor
129
195
term
130
195
None
131
195
xor_expr
132
195
NAME
133
195
arith_expr
134
195
+
135
195
STRING
136
195
atom
137
195
shift_expr
138
195
True
139
195
[
140
195
-
141
195
not_test
142
195
expr
143
195
~
144
195
comparison
145
195
power
146
195
NUMBER
147
195
False
148
195
and_expr
149
195
not
150
195
)
239
195
test_list
240
195
and_test
153
195
or_test
154
195
test
155
196
call
128
196
factor
129
196
term
130
196
None
131
196
power
146
196
NAME
133
196
NUMBER
147
196
arith_expr
134
196
+
135
196
-
141
196
shift_expr
241
196
STRING
136
196
atom
137
196
True
139
196
[
140
196
False
148
196
~
144
197
call
128
197
factor
129
197
term
130
197
None
131
197
power
146
197
NAME
133
197
NUMBER
147
197
arith_expr
134
197
+
135
197
-
141
197
STRING
136
197
atom
137
197
True
139
197
[
140
197
False
148
197
~
144
197
shift_expr
242
198
>=
factor -> + factor
198
<=
factor -> + factor
198
*
factor -> + factor
198
==
factor -> + factor
198
>
factor -> + factor
198
!=
factor -> + factor
198
-
factor -> + factor
198
and
factor -> + factor
198
//
factor -> + factor
198
%
factor -> + factor
198
)
factor -> + factor
198
/
factor -> + factor
198
<<
factor -> + factor
198
+
factor -> + factor
198
,
factor -> + factor
198
^
factor -> + factor
198
or
factor -> + factor
198
&
factor -> + factor
198
|
factor -> + factor
198
>>
factor -> + factor
198
<
factor -> + factor
199
call
128
199
factor
243
199
None
131
199
power
146
199
NAME
133
199
NUMBER
147
199
+
135
199
-
141
199
STRING
136
199
atom
137
199
True
139
199
[
140
199
False
148
199
~
144
200
and_expr
244
200
call
128
200
factor
129
200
term
130
200
None
131
200
power
146
200
NAME
133
200
NUMBER
147
200
arith_expr
134
200
+
135
200
-
141
200
STRING
136
200
atom
137
200
shift_expr
138
200
True
139
200
[
140
200
False
148
200
~
144
201
]
245
202
or
factor -> - factor
202
*
factor -> - factor
202
&
factor -> - factor
202
>=
factor -> - factor
202
and
factor -> - factor
202
>>
factor -> - factor
202
)
factor -> - factor
202
>
factor -> - factor
202
+
factor -> - factor
202
%
factor -> - factor
202
//
factor -> - factor
202
<=
factor -> - factor
202
==
factor -> - factor
202
/
factor -> - factor
202
-
factor -> - factor
202
<<
factor -> - factor
202
!=
factor -> - factor
202
,
factor -> - factor
202
^
factor -> - factor
202
|
factor -> - factor
202
<
factor -> - factor
203
call
128
203
factor
129
203
term
130
203
None
131
203
xor_expr
132
203
power
146
203
NAME
133
203
NUMBER
147
203
arith_expr
134
203
+
135
203
-
141
203
and_test
246
203
STRING
136
203
atom
137
203
shift_expr
138
203
True
139
203
[
140
203
and_expr
149
203
False
148
203
not_test
142
203
expr
143
203
~
144
203
comparison
145
203
not
150
204
call
128
204
factor
129
204
term
130
204
None
131
204
xor_expr
132
204
power
146
204
NAME
133
204
NUMBER
147
204
arith_expr
134
204
+
135
204
-
141
204
STRING
136
204
atom
137
204
shift_expr
138
204
True
139
204
[
140
204
and_expr
149
204
False
148
204
expr
143
204
~
144
204
comparison
247
205
and
factor -> ~ factor
205
/
factor -> ~ factor
205
)
factor -> ~ factor
205
>>
factor -> ~ factor
205
,
factor -> ~ factor
205
-
factor -> ~ factor
205
<=
factor -> ~ factor
205
!=
factor -> ~ factor
205
==
factor -> ~ factor
205
^
factor -> ~ factor
205
or
factor -> ~ factor
205
>=
factor -> ~ factor
205
>
factor -> ~ factor
205
<
factor -> ~ factor
205
+
factor -> ~ factor
205
<<
factor -> ~ factor
205
|
factor -> ~ factor
205
&
factor -> ~ factor
205
*
factor -> ~ factor
205
%
factor -> ~ factor
205
//
factor -> ~ factor
206
call
128
206
factor
129
206
term
130
206
None
131
206
power
146
206
NAME
133
206
NUMBER
147
206
arith_expr
134
206
+
135
206
-
141
206
STRING
136
206
atom
137
206
shift_expr
138
206
True
139
206
[
140
206
and_expr
149
206
False
148
206
~
144
206
xor_expr
248
207
or
not_test -> not not_test
207
,
not_test -> not not_test
207
)
not_test -> not not_test
207
and
not_test -> not not_test
208
!=
call -> NAME ( test_list )
208
//
call -> NAME ( test_list )
208
or
call -> NAME ( test_list )
208
<<
call -> NAME ( test_list )
208
DEDENT
call -> NAME ( test_list )
208
NEWLINE
call -> NAME ( test_list )
208
-
call -> NAME ( test_list )
208
>
call -> NAME ( test_list )
208
+
call -> NAME ( test_list )
208
<
call -> NAME ( test_list )
208
NAME
call -> NAME ( test_list )
208
>=
call -> NAME ( test_list )
208
and
call -> NAME ( test_list )
208
/
call -> NAME ( test_list )
208
|
call -> NAME ( test_list )
208
&
call -> NAME ( test_list )
208
==
call -> NAME ( test_list )
208
*
call -> NAME ( test_list )
208
>>
call -> NAME ( test_list )
208
**
call -> NAME ( test_list )
208
^
call -> NAME ( test_list )
208
<=
call -> NAME ( test_list )
208
%
call -> NAME ( test_list )
209
call
128
209
factor
129
209
term
130
209
None
131
209
xor_expr
132
209
power
146
209
NAME
133
209
NUMBER
147
209
arith_expr
134
209
+
135
209
-
141
209
STRING
136
209
atom
137
209
shift_expr
138
209
True
139
209
[
140
209
and_expr
149
209
False
148
209
not_test
142
209
expr
143
209
~
144
209
comparison
145
209
not
150
209
or_test
249
209
and_test
153
210
call
128
210
factor
129
210
term
130
210
None
131
210
xor_expr
132
210
power
146
210
NAME
133
210
NUMBER
147
210
arith_expr
134
210
+
135
210
-
141
210
STRING
136
210
atom
137
210
shift_expr
138
210
True
139
210
[
140
210
and_expr
149
210
False
148
210
not_test
142
210
expr
143
210
~
144
210
comparison
145
210
not
150
210
test_list
250
210
or_test
154
210
and_test
153
210
test
155
211
]
term -> factor % term
211
+
term -> factor % term
211
>=
term -> factor % term
211
!=
term -> factor % term
211
^
term -> factor % term
211
or
term -> factor % term
211
<<
term -> factor % term
211
and
term -> factor % term
211
==
term -> factor % term
211
>
term -> factor % term
211
|
term -> factor % term
211
&
term -> factor % term
211
-
term -> factor % term
211
>>
term -> factor % term
211
<
term -> factor % term
211
<=
term -> factor % term
211
,
term -> factor % term
212
>>
term -> factor * term
212
>=
term -> factor * term
212
-
term -> factor * term
212
and
term -> factor * term
212
,
term -> factor * term
212
|
term -> factor * term
212
<=
term -> factor * term
212
or
term -> factor * term
212
+
term -> factor * term
212
<
term -> factor * term
212
]
term -> factor * term
212
>
term -> factor * term
212
^
term -> factor * term
212
&
term -> factor * term
212
==
term -> factor * term
212
<<
term -> factor * term
212
!=
term -> factor * term
213
&
term -> factor // term
213
>=
term -> factor // term
213
,
term -> factor // term
213
+
term -> factor // term
213
<<
term -> factor // term
213
!=
term -> factor // term
213
<=
term -> factor // term
213
|
term -> factor // term
213
and
term -> factor // term
213
>>
term -> factor // term
213
^
term -> factor // term
213
]
term -> factor // term
213
-
term -> factor // term
213
<
term -> factor // term
213
>
term -> factor // term
213
==
term -> factor // term
213
or
term -> factor // term
214
|
term -> factor / term
214
or
term -> factor / term
214
]
term -> factor / term
214
and
term -> factor / term
214
<=
term -> factor / term
214
<<
term -> factor / term
214
^
term -> factor / term
214
,
term -> factor / term
214
-
term -> factor / term
214
>>
term -> factor / term
214
==
term -> factor / term
214
>
term -> factor / term
214
>=
term -> factor / term
214
<
term -> factor / term
214
+
term -> factor / term
214
&
term -> factor / term
214
!=
term -> factor / term
215
|
arith_expr -> term + arith_expr
215
!=
arith_expr -> term + arith_expr
215
>
arith_expr -> term + arith_expr
215
>=
arith_expr -> term + arith_expr
215
&
arith_expr -> term + arith_expr
215
==
arith_expr -> term + arith_expr
215
<=
arith_expr -> term + arith_expr
215
<
arith_expr -> term + arith_expr
215
<<
arith_expr -> term + arith_expr
215
and
arith_expr -> term + arith_expr
215
>>
arith_expr -> term + arith_expr
215
]
arith_expr -> term + arith_expr
215
,
arith_expr -> term + arith_expr
215
^
arith_expr -> term + arith_expr
215
or
arith_expr -> term + arith_expr
216
or
arith_expr -> term - arith_expr
216
<=
arith_expr -> term - arith_expr
216
>=
arith_expr -> term - arith_expr
216
]
arith_expr -> term - arith_expr
216
==
arith_expr -> term - arith_expr
216
>>
arith_expr -> term - arith_expr
216
|
arith_expr -> term - arith_expr
216
<<
arith_expr -> term - arith_expr
216
<
arith_expr -> term - arith_expr
216
!=
arith_expr -> term - arith_expr
216
>
arith_expr -> term - arith_expr
216
,
arith_expr -> term - arith_expr
216
^
arith_expr -> term - arith_expr
216
&
arith_expr -> term - arith_expr
216
and
arith_expr -> term - arith_expr
217
]
expr -> xor_expr | expr
217
==
expr -> xor_expr | expr
217
!=
expr -> xor_expr | expr
217
<=
expr -> xor_expr | expr
217
or
expr -> xor_expr | expr
217
and
expr -> xor_expr | expr
217
>=
expr -> xor_expr | expr
217
,
expr -> xor_expr | expr
217
>
expr -> xor_expr | expr
217
<
expr -> xor_expr | expr
218
<<
call -> NAME ( )
218
//
call -> NAME ( )
218
or
call -> NAME ( )
218
>>
call -> NAME ( )
218
/
call -> NAME ( )
218
%
call -> NAME ( )
218
+
call -> NAME ( )
218
>
call -> NAME ( )
218
>=
call -> NAME ( )
218
==
call -> NAME ( )
218
<
call -> NAME ( )
218
]
call -> NAME ( )
218
^
call -> NAME ( )
218
-
call -> NAME ( )
218
and
call -> NAME ( )
218
**
call -> NAME ( )
218
|
call -> NAME ( )
218
<=
call -> NAME ( )
218
!=
call -> NAME ( )
218
&
call -> NAME ( )
218
*
call -> NAME ( )
218
,
call -> NAME ( )
219
)
251
220
>
shift_expr -> arith_expr >> shift_expr
220
&
shift_expr -> arith_expr >> shift_expr
220
or
shift_expr -> arith_expr >> shift_expr
220
<
shift_expr -> arith_expr >> shift_expr
220
>=
shift_expr -> arith_expr >> shift_expr
220
^
shift_expr -> arith_expr >> shift_expr
220
<=
shift_expr -> arith_expr >> shift_expr
220
|
shift_expr -> arith_expr >> shift_expr
220
!=
shift_expr -> arith_expr >> shift_expr
220
]
shift_expr -> arith_expr >> shift_expr
220
==
shift_expr -> arith_expr >> shift_expr
220
,
shift_expr -> arith_expr >> shift_expr
220
and
shift_expr -> arith_expr >> shift_expr
221
|
shift_expr -> arith_expr << shift_expr
221
==
shift_expr -> arith_expr << shift_expr
221
>
shift_expr -> arith_expr << shift_expr
221
and
shift_expr -> arith_expr << shift_expr
221
]
shift_expr -> arith_expr << shift_expr
221
<=
shift_expr -> arith_expr << shift_expr
221
!=
shift_expr -> arith_expr << shift_expr
221
>=
shift_expr -> arith_expr << shift_expr
221
&
shift_expr -> arith_expr << shift_expr
221
<
shift_expr -> arith_expr << shift_expr
221
,
shift_expr -> arith_expr << shift_expr
221
^
shift_expr -> arith_expr << shift_expr
221
or
shift_expr -> arith_expr << shift_expr
222
<
power -> atom ** factor
222
/
power -> atom ** factor
222
*
power -> atom ** factor
222
-
power -> atom ** factor
222
<=
power -> atom ** factor
222
+
power -> atom ** factor
222
>>
power -> atom ** factor
222
or
power -> atom ** factor
222
&
power -> atom ** factor
222
]
power -> atom ** factor
222
!=
power -> atom ** factor
222
//
power -> atom ** factor
222
%
power -> atom ** factor
222
,
power -> atom ** factor
222
>
power -> atom ** factor
222
<<
power -> atom ** factor
222
|
power -> atom ** factor
222
^
power -> atom ** factor
222
==
power -> atom ** factor
222
>=
power -> atom ** factor
222
and
power -> atom ** factor
223
,
and_expr -> shift_expr & and_expr
223
<=
and_expr -> shift_expr & and_expr
223
^
and_expr -> shift_expr & and_expr
223
>=
and_expr -> shift_expr & and_expr
223
<
and_expr -> shift_expr & and_expr
223
==
and_expr -> shift_expr & and_expr
223
]
and_expr -> shift_expr & and_expr
223
or
and_expr -> shift_expr & and_expr
223
>
and_expr -> shift_expr & and_expr
223
and
and_expr -> shift_expr & and_expr
223
|
and_expr -> shift_expr & and_expr
223
!=
and_expr -> shift_expr & and_expr
224
,
atom -> [ test_list ]
224
^
atom -> [ test_list ]
224
<
atom -> [ test_list ]
224
|
atom -> [ test_list ]
224
==
atom -> [ test_list ]
224
**
atom -> [ test_list ]
224
-
atom -> [ test_list ]
224
*
atom -> [ test_list ]
224
and
atom -> [ test_list ]
224
>=
atom -> [ test_list ]
224
<<
atom -> [ test_list ]
224
/
atom -> [ test_list ]
224
!=
atom -> [ test_list ]
224
&
atom -> [ test_list ]
224
or
atom -> [ test_list ]
224
+
atom -> [ test_list ]
224
//
atom -> [ test_list ]
224
>>
atom -> [ test_list ]
224
>
atom -> [ test_list ]
224
<=
atom -> [ test_list ]
224
]
atom -> [ test_list ]
224
%
atom -> [ test_list ]
225
,
comparison -> expr comp_op comparison
225
]
comparison -> expr comp_op comparison
225
and
comparison -> expr comp_op comparison
225
or
comparison -> expr comp_op comparison
226
or
and_test -> not_test and and_test
226
,
and_test -> not_test and and_test
226
]
and_test -> not_test and and_test
227
]
xor_expr -> and_expr ^ xor_expr
227
<=
xor_expr -> and_expr ^ xor_expr
227
or
xor_expr -> and_expr ^ xor_expr
227
|
xor_expr -> and_expr ^ xor_expr
227
,
xor_expr -> and_expr ^ xor_expr
227
==
xor_expr -> and_expr ^ xor_expr
227
>
xor_expr -> and_expr ^ xor_expr
227
<
xor_expr -> and_expr ^ xor_expr
227
!=
xor_expr -> and_expr ^ xor_expr
227
>=
xor_expr -> and_expr ^ xor_expr
227
and
xor_expr -> and_expr ^ xor_expr
228
,
or_test -> and_test or or_test
228
]
or_test -> and_test or or_test
229
]
test_list -> test , test_list
230
INDENT
252
231
DEDENT
func_def -> NAME ( name_list ) : suite
231
NEWLINE
func_def -> NAME ( name_list ) : suite
231
NAME
func_def -> NAME ( name_list ) : suite
232
)
term -> factor % term
232
+
term -> factor % term
232
>=
term -> factor % term
232
!=
term -> factor % term
232
^
term -> factor % term
232
or
term -> factor % term
232
<<
term -> factor % term
232
and
term -> factor % term
232
==
term -> factor % term
232
>
term -> factor % term
232
|
term -> factor % term
232
&
term -> factor % term
232
-
term -> factor % term
232
>>
term -> factor % term
232
<
term -> factor % term
232
<=
term -> factor % term
232
,
term -> factor % term
233
&
term -> factor // term
233
>=
term -> factor // term
233
,
term -> factor // term
233
+
term -> factor // term
233
<<
term -> factor // term
233
!=
term -> factor // term
233
<=
term -> factor // term
233
|
term -> factor // term
233
and
term -> factor // term
233
>>
term -> factor // term
233
^
term -> factor // term
233
<
term -> factor // term
233
-
term -> factor // term
233
>
term -> factor // term
233
)
term -> factor // term
233
==
term -> factor // term
233
or
term -> factor // term
234
|
term -> factor / term
234
or
term -> factor / term
234
and
term -> factor / term
234
)
term -> factor / term
234
<=
term -> factor / term
234
<<
term -> factor / term
234
^
term -> factor / term
234
,
term -> factor / term
234
-
term -> factor / term
234
>>
term -> factor / term
234
==
term -> factor / term
234
>
term -> factor / term
234
>=
term -> factor / term
234
<
term -> factor / term
234
+
term -> factor / term
234
&
term -> factor / term
234
!=
term -> factor / term
235
>>
term -> factor * term
235
>=
term -> factor * term
235
)
term -> factor * term
235
-
term -> factor * term
235
and
term -> factor * term
235
,
term -> factor * term
235
|
term -> factor * term
235
<=
term -> factor * term
235
or
term -> factor * term
235
+
term -> factor * term
235
<
term -> factor * term
235
>
term -> factor * term
235
^
term -> factor * term
235
&
term -> factor * term
235
==
term -> factor * term
235
<<
term -> factor * term
235
!=
term -> factor * term
236
|
arith_expr -> term + arith_expr
236
!=
arith_expr -> term + arith_expr
236
>
arith_expr -> term + arith_expr
236
>=
arith_expr -> term + arith_expr
236
&
arith_expr -> term + arith_expr
236
==
arith_expr -> term + arith_expr
236
<=
arith_expr -> term + arith_expr
236
<
arith_expr -> term + arith_expr
236
<<
arith_expr -> term + arith_expr
236
and
arith_expr -> term + arith_expr
236
>>
arith_expr -> term + arith_expr
236
,
arith_expr -> term + arith_expr
236
^
arith_expr -> term + arith_expr
236
or
arith_expr -> term + arith_expr
236
)
arith_expr -> term + arith_expr
237
or
arith_expr -> term - arith_expr
237
<=
arith_expr -> term - arith_expr
237
>=
arith_expr -> term - arith_expr
237
==
arith_expr -> term - arith_expr
237
)
arith_expr -> term - arith_expr
237
>>
arith_expr -> term - arith_expr
237
|
arith_expr -> term - arith_expr
237
<<
arith_expr -> term - arith_expr
237
<
arith_expr -> term - arith_expr
237
!=
arith_expr -> term - arith_expr
237
>
arith_expr -> term - arith_expr
237
,
arith_expr -> term - arith_expr
237
^
arith_expr -> term - arith_expr
237
&
arith_expr -> term - arith_expr
237
and
arith_expr -> term - arith_expr
238
==
expr -> xor_expr | expr
238
!=
expr -> xor_expr | expr
238
<=
expr -> xor_expr | expr
238
or
expr -> xor_expr | expr
238
and
expr -> xor_expr | expr
238
>=
expr -> xor_expr | expr
238
,
expr -> xor_expr | expr
238
>
expr -> xor_expr | expr
238
)
expr -> xor_expr | expr
238
<
expr -> xor_expr | expr
239
<<
call -> NAME ( )
239
//
call -> NAME ( )
239
or
call -> NAME ( )
239
>>
call -> NAME ( )
239
/
call -> NAME ( )
239
%
call -> NAME ( )
239
+
call -> NAME ( )
239
>
call -> NAME ( )
239
>=
call -> NAME ( )
239
==
call -> NAME ( )
239
<
call -> NAME ( )
239
^
call -> NAME ( )
239
)
call -> NAME ( )
239
-
call -> NAME ( )
239
and
call -> NAME ( )
239
**
call -> NAME ( )
239
|
call -> NAME ( )
239
<=
call -> NAME ( )
239
!=
call -> NAME ( )
239
&
call -> NAME ( )
239
*
call -> NAME ( )
239
,
call -> NAME ( )
240
)
253
241
>
shift_expr -> arith_expr >> shift_expr
241
&
shift_expr -> arith_expr >> shift_expr
241
or
shift_expr -> arith_expr >> shift_expr
241
<
shift_expr -> arith_expr >> shift_expr
241
)
shift_expr -> arith_expr >> shift_expr
241
^
shift_expr -> arith_expr >> shift_expr
241
<=
shift_expr -> arith_expr >> shift_expr
241
|
shift_expr -> arith_expr >> shift_expr
241
!=
shift_expr -> arith_expr >> shift_expr
241
>=
shift_expr -> arith_expr >> shift_expr
241
==
shift_expr -> arith_expr >> shift_expr
241
,
shift_expr -> arith_expr >> shift_expr
241
and
shift_expr -> arith_expr >> shift_expr
242
|
shift_expr -> arith_expr << shift_expr
242
==
shift_expr -> arith_expr << shift_expr
242
>
shift_expr -> arith_expr << shift_expr
242
and
shift_expr -> arith_expr << shift_expr
242
<=
shift_expr -> arith_expr << shift_expr
242
!=
shift_expr -> arith_expr << shift_expr
242
>=
shift_expr -> arith_expr << shift_expr
242
&
shift_expr -> arith_expr << shift_expr
242
<
shift_expr -> arith_expr << shift_expr
242
)
shift_expr -> arith_expr << shift_expr
242
,
shift_expr -> arith_expr << shift_expr
242
^
shift_expr -> arith_expr << shift_expr
242
or
shift_expr -> arith_expr << shift_expr
243
<
power -> atom ** factor
243
/
power -> atom ** factor
243
*
power -> atom ** factor
243
-
power -> atom ** factor
243
<=
power -> atom ** factor
243
+
power -> atom ** factor
243
>>
power -> atom ** factor
243
or
power -> atom ** factor
243
&
power -> atom ** factor
243
!=
power -> atom ** factor
243
//
power -> atom ** factor
243
%
power -> atom ** factor
243
,
power -> atom ** factor
243
>
power -> atom ** factor
243
<<
power -> atom ** factor
243
|
power -> atom ** factor
243
^
power -> atom ** factor
243
)
power -> atom ** factor
243
==
power -> atom ** factor
243
>=
power -> atom ** factor
243
and
power -> atom ** factor
244
,
and_expr -> shift_expr & and_expr
244
<=
and_expr -> shift_expr & and_expr
244
^
and_expr -> shift_expr & and_expr
244
>=
and_expr -> shift_expr & and_expr
244
<
and_expr -> shift_expr & and_expr
244
==
and_expr -> shift_expr & and_expr
244
or
and_expr -> shift_expr & and_expr
244
>
and_expr -> shift_expr & and_expr
244
)
and_expr -> shift_expr & and_expr
244
and
and_expr -> shift_expr & and_expr
244
|
and_expr -> shift_expr & and_expr
244
!=
and_expr -> shift_expr & and_expr
245
,
atom -> [ test_list ]
245
^
atom -> [ test_list ]
245
<
atom -> [ test_list ]
245
|
atom -> [ test_list ]
245
==
atom -> [ test_list ]
245
**
atom -> [ test_list ]
245
-
atom -> [ test_list ]
245
*
atom -> [ test_list ]
245
and
atom -> [ test_list ]
245
>=
atom -> [ test_list ]
245
<<
atom -> [ test_list ]
245
/
atom -> [ test_list ]
245
!=
atom -> [ test_list ]
245
&
atom -> [ test_list ]
245
or
atom -> [ test_list ]
245
)
atom -> [ test_list ]
245
+
atom -> [ test_list ]
245
//
atom -> [ test_list ]
245
>>
atom -> [ test_list ]
245
>
atom -> [ test_list ]
245
<=
atom -> [ test_list ]
245
%
atom -> [ test_list ]
246
or
and_test -> not_test and and_test
246
,
and_test -> not_test and and_test
246
)
and_test -> not_test and and_test
247
,
comparison -> expr comp_op comparison
247
)
comparison -> expr comp_op comparison
247
and
comparison -> expr comp_op comparison
247
or
comparison -> expr comp_op comparison
248
<=
xor_expr -> and_expr ^ xor_expr
248
or
xor_expr -> and_expr ^ xor_expr
248
)
xor_expr -> and_expr ^ xor_expr
248
|
xor_expr -> and_expr ^ xor_expr
248
,
xor_expr -> and_expr ^ xor_expr
248
==
xor_expr -> and_expr ^ xor_expr
248
>
xor_expr -> and_expr ^ xor_expr
248
<
xor_expr -> and_expr ^ xor_expr
248
!=
xor_expr -> and_expr ^ xor_expr
248
>=
xor_expr -> and_expr ^ xor_expr
248
and
xor_expr -> and_expr ^ xor_expr
249
,
or_test -> and_test or or_test
249
)
or_test -> and_test or or_test
250
)
test_list -> test , test_list
251
!=
call -> NAME ( test_list )
251
//
call -> NAME ( test_list )
251
or
call -> NAME ( test_list )
251
<<
call -> NAME ( test_list )
251
-
call -> NAME ( test_list )
251
>
call -> NAME ( test_list )
251
+
call -> NAME ( test_list )
251
<
call -> NAME ( test_list )
251
>=
call -> NAME ( test_list )
251
and
call -> NAME ( test_list )
251
/
call -> NAME ( test_list )
251
|
call -> NAME ( test_list )
251
&
call -> NAME ( test_list )
251
]
call -> NAME ( test_list )
251
==
call -> NAME ( test_list )
251
*
call -> NAME ( test_list )
251
>>
call -> NAME ( test_list )
251
**
call -> NAME ( test_list )
251
,
call -> NAME ( test_list )
251
^
call -> NAME ( test_list )
251
<=
call -> NAME ( test_list )
251
%
call -> NAME ( test_list )
252
loop
254
252
NAME
255
252
nextloop
256
252
flow_stmt
257
252
return
258
252
loop_stmt
259
252
stmt_list
260
252
if
261
252
return_stmt
262
252
NEWLINE
263
252
endloop
264
252
var
265
252
DEDENT
stmt_list -> 
252
assign_stmt
266
252
call
267
252
if_stmt
268
252
decl_stmt
269
252
stmt
270
253
!=
call -> NAME ( test_list )
253
//
call -> NAME ( test_list )
253
or
call -> NAME ( test_list )
253
<<
call -> NAME ( test_list )
253
-
call -> NAME ( test_list )
253
>
call -> NAME ( test_list )
253
+
call -> NAME ( test_list )
253
<
call -> NAME ( test_list )
253
>=
call -> NAME ( test_list )
253
and
call -> NAME ( test_list )
253
/
call -> NAME ( test_list )
253
|
call -> NAME ( test_list )
253
&
call -> NAME ( test_list )
253
==
call -> NAME ( test_list )
253
)
call -> NAME ( test_list )
253
*
call -> NAME ( test_list )
253
>>
call -> NAME ( test_list )
253
**
call -> NAME ( test_list )
253
,
call -> NAME ( test_list )
253
^
call -> NAME ( test_list )
253
<=
call -> NAME ( test_list )
253
%
call -> NAME ( test_list )
254
NAME
271
254
:
272
255
(
273
255
=
274
256
nextloop
flow_stmt -> nextloop
256
DEDENT
flow_stmt -> nextloop
256
var
flow_stmt -> nextloop
256
NAME
flow_stmt -> nextloop
256
endloop
flow_stmt -> nextloop
256
loop
flow_stmt -> nextloop
256
return
flow_stmt -> nextloop
256
if
flow_stmt -> nextloop
256
NEWLINE
flow_stmt -> nextloop
257
if
stmt -> flow_stmt
257
nextloop
stmt -> flow_stmt
257
NAME
stmt -> flow_stmt
257
NEWLINE
stmt -> flow_stmt
257
DEDENT
stmt -> flow_stmt
257
return
stmt -> flow_stmt
257
var
stmt -> flow_stmt
257
loop
stmt -> flow_stmt
257
endloop
stmt -> flow_stmt
258
call
275
258
factor
276
258
expr
277
258
term
278
258
xor_expr
279
258
None
280
258
NAME
281
258
arith_expr
282
258
+
283
258
STRING
284
258
shift_expr
285
258
atom
286
258
True
287
258
[
288
258
-
289
258
False
290
258
~
291
258
and_expr
292
258
power
293
258
comparison
294
258
not_test
295
258
test
296
258
NUMBER
297
258
and_test
298
258
or_test
299
258
not
300
259
NAME
stmt -> loop_stmt
259
endloop
stmt -> loop_stmt
259
DEDENT
stmt -> loop_stmt
259
return
stmt -> loop_stmt
259
if
stmt -> loop_stmt
259
NEWLINE
stmt -> loop_stmt
259
nextloop
stmt -> loop_stmt
259
loop
stmt -> loop_stmt
259
var
stmt -> loop_stmt
260
DEDENT
301
261
call
302
261
factor
303
261
term
304
261
None
305
261
xor_expr
306
261
power
307
261
NAME
308
261
arith_expr
309
261
+
310
261
-
311
261
STRING
312
261
atom
313
261
shift_expr
314
261
True
315
261
[
316
261
and_expr
317
261
False
318
261
and_test
319
261
NUMBER
320
261
~
321
261
expr
322
261
test
323
261
comparison
324
261
not_test
325
261
or_test
326
261
not
327
262
DEDENT
stmt -> return_stmt
262
if
stmt -> return_stmt
262
NAME
stmt -> return_stmt
262
loop
stmt -> return_stmt
262
var
stmt -> return_stmt
262
endloop
stmt -> return_stmt
262
return
stmt -> return_stmt
262
nextloop
stmt -> return_stmt
262
NEWLINE
stmt -> return_stmt
263
loop
254
263
NAME
255
263
nextloop
256
263
flow_stmt
257
263
return
258
263
loop_stmt
259
263
if
261
263
return_stmt
262
263
NEWLINE
263
263
endloop
264
263
var
265
263
DEDENT
stmt_list -> 
263
assign_stmt
266
263
call
267
263
if_stmt
268
263
stmt_list
328
263
decl_stmt
269
263
stmt
270
264
loop
flow_stmt -> endloop
264
nextloop
flow_stmt -> endloop
264
var
flow_stmt -> endloop
264
DEDENT
flow_stmt -> endloop
264
return
flow_stmt -> endloop
264
NAME
flow_stmt -> endloop
264
endloop
flow_stmt -> endloop
264
if
flow_stmt -> endloop
264
NEWLINE
flow_stmt -> endloop
265
NAME
329
266
NAME
stmt -> assign_stmt
266
endloop
stmt -> assign_stmt
266
nextloop
stmt -> assign_stmt
266
if
stmt -> assign_stmt
266
loop
stmt -> assign_stmt
266
return
stmt -> assign_stmt
266
DEDENT
stmt -> assign_stmt
266
var
stmt -> assign_stmt
266
NEWLINE
stmt -> assign_stmt
267
if
stmt -> call
267
return
stmt -> call
267
nextloop
stmt -> call
267
endloop
stmt -> call
267
NAME
stmt -> call
267
var
stmt -> call
267
loop
stmt -> call
267
NEWLINE
stmt -> call
267
DEDENT
stmt -> call
268
DEDENT
stmt -> if_stmt
268
loop
stmt -> if_stmt
268
return
stmt -> if_stmt
268
NAME
stmt -> if_stmt
268
NEWLINE
stmt -> if_stmt
268
var
stmt -> if_stmt
268
endloop
stmt -> if_stmt
268
nextloop
stmt -> if_stmt
268
if
stmt -> if_stmt
269
DEDENT
stmt -> decl_stmt
269
loop
stmt -> decl_stmt
269
if
stmt -> decl_stmt
269
nextloop
stmt -> decl_stmt
269
return
stmt -> decl_stmt
269
endloop
stmt -> decl_stmt
269
NAME
stmt -> decl_stmt
269
var
stmt -> decl_stmt
269
NEWLINE
stmt -> decl_stmt
270
loop
254
270
NAME
255
270
nextloop
256
270
flow_stmt
257
270
return
258
270
loop_stmt
259
270
if
261
270
return_stmt
262
270
NEWLINE
263
270
endloop
264
270
var
265
270
DEDENT
stmt_list -> 
270
assign_stmt
266
270
call
267
270
if_stmt
268
270
decl_stmt
269
270
stmt_list
330
270
stmt
270
271
:
331
271
from
332
272
NEWLINE
333
272
suite
334
273
call
128
273
factor
129
273
term
130
273
None
131
273
xor_expr
132
273
NAME
133
273
arith_expr
134
273
+
135
273
STRING
136
273
atom
137
273
test_list
335
273
shift_expr
138
273
True
139
273
[
140
273
-
141
273
not_test
142
273
expr
143
273
~
144
273
)
336
273
comparison
145
273
power
146
273
NUMBER
147
273
False
148
273
and_expr
149
273
not
150
273
and_test
153
273
or_test
154
273
test
155
274
call
275
274
factor
276
274
expr
277
274
term
278
274
xor_expr
279
274
None
280
274
NAME
281
274
arith_expr
282
274
+
283
274
test
337
274
STRING
284
274
shift_expr
285
274
atom
286
274
True
287
274
[
288
274
-
289
274
False
290
274
~
291
274
and_expr
292
274
power
293
274
comparison
294
274
not_test
295
274
NUMBER
297
274
and_test
298
274
or_test
299
274
not
300
275
%
atom -> call
275
&
atom -> call
275
endloop
atom -> call
275
-
atom -> call
275
<
atom -> call
275
DEDENT
atom -> call
275
if
atom -> call
275
and
atom -> call
275
>
atom -> call
275
>=
atom -> call
275
NEWLINE
atom -> call
275
loop
atom -> call
275
<=
atom -> call
275
//
atom -> call
275
<<
atom -> call
275
or
atom -> call
275
/
atom -> call
275
|
atom -> call
275
*
atom -> call
275
nextloop
atom -> call
275
+
atom -> call
275
return
atom -> call
275
>>
atom -> call
275
!=
atom -> call
275
**
atom -> call
275
NAME
atom -> call
275
==
atom -> call
275
^
atom -> call
275
var
atom -> call
276
return
term -> factor
276
%
338
276
//
339
276
*
340
276
/
341
276
>>
term -> factor
276
DEDENT
term -> factor
276
<<
term -> factor
276
NAME
term -> factor
276
loop
term -> factor
276
==
term -> factor
276
<=
term -> factor
276
var
term -> factor
276
+
term -> factor
276
>=
term -> factor
276
&
term -> factor
276
nextloop
term -> factor
276
if
term -> factor
276
>
term -> factor
276
<
term -> factor
276
!=
term -> factor
276
or
term -> factor
276
|
term -> factor
276
NEWLINE
term -> factor
276
^
term -> factor
276
endloop
term -> factor
276
and
term -> factor
276
-
term -> factor
277
DEDENT
comparison -> expr
277
>
106
277
>=
107
277
<
108
277
!=
109
277
==
110
277
and
comparison -> expr
277
<=
111
277
comp_op
342
277
if
comparison -> expr
277
loop
comparison -> expr
277
nextloop
comparison -> expr
277
return
comparison -> expr
277
var
comparison -> expr
277
NAME
comparison -> expr
277
endloop
comparison -> expr
277
NEWLINE
comparison -> expr
277
or
comparison -> expr
278
+
343
278
return
arith_expr -> term
278
var
arith_expr -> term
278
<
arith_expr -> term
278
-
344
278
<=
arith_expr -> term
278
==
arith_expr -> term
278
NEWLINE
arith_expr -> term
278
and
arith_expr -> term
278
loop
arith_expr -> term
278
>
arith_expr -> term
278
nextloop
arith_expr -> term
278
>>
arith_expr -> term
278
if
arith_expr -> term
278
^
arith_expr -> term
278
|
arith_expr -> term
278
DEDENT
arith_expr -> term
278
>=
arith_expr -> term
278
<<
arith_expr -> term
278
or
arith_expr -> term
278
endloop
arith_expr -> term
278
!=
arith_expr -> term
278
NAME
arith_expr -> term
278
&
arith_expr -> term
279
|
345
279
endloop
expr -> xor_expr
279
if
expr -> xor_expr
279
nextloop
expr -> xor_expr
279
!=
expr -> xor_expr
279
==
expr -> xor_expr
279
<
expr -> xor_expr
279
NEWLINE
expr -> xor_expr
279
NAME
expr -> xor_expr
279
DEDENT
expr -> xor_expr
279
>
expr -> xor_expr
279
<=
expr -> xor_expr
279
loop
expr -> xor_expr
279
var
expr -> xor_expr
279
return
expr -> xor_expr
279
and
expr -> xor_expr
279
>=
expr -> xor_expr
279
or
expr -> xor_expr
280
NAME
atom -> None
280
if
atom -> None
280
<
atom -> None
280
<<
atom -> None
280
!=
atom -> None
280
<=
atom -> None
280
%
atom -> None
280
&
atom -> None
280
*
atom -> None
280
NEWLINE
atom -> None
280
>
atom -> None
280
-
atom -> None
280
and
atom -> None
280
endloop
atom -> None
280
var
atom -> None
280
^
atom -> None
280
DEDENT
atom -> None
280
>=
atom -> None
280
**
atom -> None
280
|
atom -> None
280
return
atom -> None
280
nextloop
atom -> None
280
>>
atom -> None
280
loop
atom -> None
280
/
atom -> None
280
//
atom -> None
280
==
atom -> None
280
+
atom -> None
280
or
atom -> None
281
(
346
281
loop
atom -> NAME
281
nextloop
atom -> NAME
281
<
atom -> NAME
281
**
atom -> NAME
281
<=
atom -> NAME
281
endloop
atom -> NAME
281
%
atom -> NAME
281
NEWLINE
atom -> NAME
281
<<
atom -> NAME
281
or
atom -> NAME
281
!=
atom -> NAME
281
-
atom -> NAME
281
//
atom -> NAME
281
DEDENT
atom -> NAME
281
>>
atom -> NAME
281
and
atom -> NAME
281
return
atom -> NAME
281
if
atom -> NAME
281
|
atom -> NAME
281
+
atom -> NAME
281
&
atom -> NAME
281
var
atom -> NAME
281
^
atom -> NAME
281
>
atom -> NAME
281
==
atom -> NAME
281
/
atom -> NAME
281
>=
atom -> NAME
281
NAME
atom -> NAME
281
*
atom -> NAME
282
>>
347
282
==
shift_expr -> arith_expr
282
NAME
shift_expr -> arith_expr
282
^
shift_expr -> arith_expr
282
<<
348
282
NEWLINE
shift_expr -> arith_expr
282
return
shift_expr -> arith_expr
282
>=
shift_expr -> arith_expr
282
endloop
shift_expr -> arith_expr
282
<=
shift_expr -> arith_expr
282
or
shift_expr -> arith_expr
282
|
shift_expr -> arith_expr
282
>
shift_expr -> arith_expr
282
!=
shift_expr -> arith_expr
282
var
shift_expr -> arith_expr
282
DEDENT
shift_expr -> arith_expr
282
<
shift_expr -> arith_expr
282
and
shift_expr -> arith_expr
282
&
shift_expr -> arith_expr
282
nextloop
shift_expr -> arith_expr
282
loop
shift_expr -> arith_expr
282
if
shift_expr -> arith_expr
283
call
275
283
factor
349
283
None
280
283
NUMBER
297
283
power
293
283
NAME
281
283
+
283
283
-
289
283
STRING
284
283
atom
286
283
True
287
283
[
288
283
False
290
283
~
291
284
endloop
atom -> STRING
284
!=
atom -> STRING
284
<<
atom -> STRING
284
//
atom -> STRING
284
/
atom -> STRING
284
<
atom -> STRING
284
==
atom -> STRING
284
|
atom -> STRING
284
>=
atom -> STRING
284
^
atom -> STRING
284
>>
atom -> STRING
284
return
atom -> STRING
284
<=
atom -> STRING
284
var
atom -> STRING
284
*
atom -> STRING
284
>
atom -> STRING
284
loop
atom -> STRING
284
nextloop
atom -> STRING
284
%
atom -> STRING
284
DEDENT
atom -> STRING
284
-
atom -> STRING
284
**
atom -> STRING
284
NEWLINE
atom -> STRING
284
+
atom -> STRING
284
and
atom -> STRING
284
NAME
atom -> STRING
284
or
atom -> STRING
284
&
atom -> STRING
284
if
atom -> STRING
285
and
and_expr -> shift_expr
285
<
and_expr -> shift_expr
285
^
and_expr -> shift_expr
285
NAME
and_expr -> shift_expr
285
&
350
285
>
and_expr -> shift_expr
285
return
and_expr -> shift_expr
285
endloop
and_expr -> shift_expr
285
var
and_expr -> shift_expr
285
==
and_expr -> shift_expr
285
|
and_expr -> shift_expr
285
nextloop
and_expr -> shift_expr
285
loop
and_expr -> shift_expr
285
!=
and_expr -> shift_expr
285
if
and_expr -> shift_expr
285
<=
and_expr -> shift_expr
285
NEWLINE
and_expr -> shift_expr
285
DEDENT
and_expr -> shift_expr
285
or
and_expr -> shift_expr
285
>=
and_expr -> shift_expr
286
<=
power -> atom
286
>
power -> atom
286
**
351
286
DEDENT
power -> atom
286
|
power -> atom
286
//
power -> atom
286
-
power -> atom
286
>>
power -> atom
286
loop
power -> atom
286
>=
power -> atom
286
!=
power -> atom
286
and
power -> atom
286
/
power -> atom
286
NAME
power -> atom
286
<<
power -> atom
286
NEWLINE
power -> atom
286
&
power -> atom
286
%
power -> atom
286
^
power -> atom
286
+
power -> atom
286
or
power -> atom
286
return
power -> atom
286
var
power -> atom
286
*
power -> atom
286
==
power -> atom
286
endloop
power -> atom
286
<
power -> atom
286
nextloop
power -> atom
286
if
power -> atom
287
>=
atom -> True
287
|
atom -> True
287
//
atom -> True
287
<
atom -> True
287
if
atom -> True
287
==
atom -> True
287
loop
atom -> True
287
nextloop
atom -> True
287
DEDENT
atom -> True
287
-
atom -> True
287
<<
atom -> True
287
/
atom -> True
287
or
atom -> True
287
NAME
atom -> True
287
!=
atom -> True
287
**
atom -> True
287
^
atom -> True
287
&
atom -> True
287
var
atom -> True
287
*
atom -> True
287
NEWLINE
atom -> True
287
%
atom -> True
287
return
atom -> True
287
<=
atom -> True
287
endloop
atom -> True
287
>
atom -> True
287
+
atom -> True
287
and
atom -> True
287
>>
atom -> True
288
call
79
288
factor
80
288
term
81
288
None
82
288
or_test
83
288
xor_expr
84
288
NAME
85
288
arith_expr
86
288
+
87
288
STRING
88
288
atom
89
288
shift_expr
90
288
True
91
288
[
92
288
test_list
352
288
-
94
288
expr
95
288
~
96
288
not_test
97
288
comparison
98
288
power
99
288
NUMBER
100
288
False
101
288
and_expr
102
288
and_test
103
288
not
104
288
test
105
289
call
275
289
None
280
289
NUMBER
297
289
power
293
289
NAME
281
289
+
283
289
-
289
289
factor
353
289
STRING
284
289
atom
286
289
True
287
289
[
288
289
False
290
289
~
291
290
NAME
atom -> False
290
endloop
atom -> False
290
and
atom -> False
290
/
atom -> False
290
DEDENT
atom -> False
290
var
atom -> False
290
*
atom -> False
290
-
atom -> False
290
if
atom -> False
290
**
atom -> False
290
return
atom -> False
290
<<
atom -> False
290
loop
atom -> False
290
>
atom -> False
290
>>
atom -> False
290
==
atom -> False
290
|
atom -> False
290
%
atom -> False
290
<=
atom -> False
290
NEWLINE
atom -> False
290
or
atom -> False
290
<
atom -> False
290
nextloop
atom -> False
290
>=
atom -> False
290
+
atom -> False
290
//
atom -> False
290
&
atom -> False
290
^
atom -> False
290
!=
atom -> False
291
call
275
291
None
280
291
NUMBER
297
291
power
293
291
NAME
281
291
+
283
291
-
289
291
factor
354
291
STRING
284
291
atom
286
291
True
287
291
[
288
291
False
290
291
~
291
292
^
355
292
loop
xor_expr -> and_expr
292
NEWLINE
xor_expr -> and_expr
292
and
xor_expr -> and_expr
292
>=
xor_expr -> and_expr
292
<=
xor_expr -> and_expr
292
==
xor_expr -> and_expr
292
return
xor_expr -> and_expr
292
or
xor_expr -> and_expr
292
<
xor_expr -> and_expr
292
NAME
xor_expr -> and_expr
292
nextloop
xor_expr -> and_expr
292
!=
xor_expr -> and_expr
292
>
xor_expr -> and_expr
292
var
xor_expr -> and_expr
292
endloop
xor_expr -> and_expr
292
DEDENT
xor_expr -> and_expr
292
|
xor_expr -> and_expr
292
if
xor_expr -> and_expr
293
if
factor -> power
293
//
factor -> power
293
loop
factor -> power
293
<<
factor -> power
293
var
factor -> power
293
<
factor -> power
293
DEDENT
factor -> power
293
!=
factor -> power
293
<=
factor -> power
293
|
factor -> power
293
-
factor -> power
293
NAME
factor -> power
293
>=
factor -> power
293
/
factor -> power
293
>>
factor -> power
293
*
factor -> power
293
==
factor -> power
293
&
factor -> power
293
nextloop
factor -> power
293
return
factor -> power
293
NEWLINE
factor -> power
293
endloop
factor -> power
293
^
factor -> power
293
+
factor -> power
293
and
factor -> power
293
>
factor -> power
293
or
factor -> power
293
%
factor -> power
294
DEDENT
not_test -> comparison
294
loop
not_test -> comparison
294
return
not_test -> comparison
294
endloop
not_test -> comparison
294
and
not_test -> comparison
294
or
not_test -> comparison
294
if
not_test -> comparison
294
NAME
not_test -> comparison
294
var
not_test -> comparison
294
NEWLINE
not_test -> comparison
294
nextloop
not_test -> comparison
295
and
356
295
if
and_test -> not_test
295
NAME
and_test -> not_test
295
DEDENT
and_test -> not_test
295
or
and_test -> not_test
295
loop
and_test -> not_test
295
var
and_test -> not_test
295
nextloop
and_test -> not_test
295
NEWLINE
and_test -> not_test
295
endloop
and_test -> not_test
295
return
and_test -> not_test
296
var
return_stmt -> return test
296
endloop
return_stmt -> return test
296
return
return_stmt -> return test
296
DEDENT
return_stmt -> return test
296
loop
return_stmt -> return test
296
NAME
return_stmt -> return test
296
if
return_stmt -> return test
296
nextloop
return_stmt -> return test
296
NEWLINE
return_stmt -> return test
297
/
atom -> NUMBER
297
endloop
atom -> NUMBER
297
loop
atom -> NUMBER
297
return
atom -> NUMBER
297
or
atom -> NUMBER
297
>>
atom -> NUMBER
297
*
atom -> NUMBER
297
<=
atom -> NUMBER
297
+
atom -> NUMBER
297
and
atom -> NUMBER
297
-
atom -> NUMBER
297
==
atom -> NUMBER
297
if
atom -> NUMBER
297
<
atom -> NUMBER
297
%
atom -> NUMBER
297
DEDENT
atom -> NUMBER
297
//
atom -> NUMBER
297
>=
atom -> NUMBER
297
nextloop
atom -> NUMBER
297
>
atom -> NUMBER
297
NAME
atom -> NUMBER
297
**
atom -> NUMBER
297
!=
atom -> NUMBER
297
^
atom -> NUMBER
297
var
atom -> NUMBER
297
&
atom -> NUMBER
297
NEWLINE
atom -> NUMBER
297
<<
atom -> NUMBER
297
|
atom -> NUMBER
298
or
357
298
nextloop
or_test -> and_test
298
var
or_test -> and_test
298
NEWLINE
or_test -> and_test
298
loop
or_test -> and_test
298
endloop
or_test -> and_test
298
if
or_test -> and_test
298
DEDENT
or_test -> and_test
298
return
or_test -> and_test
298
NAME
or_test -> and_test
299
endloop
test -> or_test
299
nextloop
test -> or_test
299
DEDENT
test -> or_test
299
NEWLINE
test -> or_test
299
loop
test -> or_test
299
var
test -> or_test
299
NAME
test -> or_test
299
return
test -> or_test
299
if
test -> or_test
300
call
275
300
factor
276
300
not_test
358
300
expr
277
300
term
278
300
xor_expr
279
300
None
280
300
NAME
281
300
arith_expr
282
300
+
283
300
STRING
284
300
shift_expr
285
300
atom
286
300
True
287
300
[
288
300
-
289
300
False
290
300
~
291
300
and_expr
292
300
power
293
300
comparison
294
300
NUMBER
297
300
not
300
301
NEWLINE
suite -> NEWLINE INDENT stmt_list DEDENT
301
DEDENT
suite -> NEWLINE INDENT stmt_list DEDENT
301
NAME
suite -> NEWLINE INDENT stmt_list DEDENT
302
%
atom -> call
302
&
atom -> call
302
-
atom -> call
302
:
atom -> call
302
<
atom -> call
302
and
atom -> call
302
>
atom -> call
302
>=
atom -> call
302
<=
atom -> call
302
//
atom -> call
302
<<
atom -> call
302
or
atom -> call
302
/
atom -> call
302
|
atom -> call
302
*
atom -> call
302
+
atom -> call
302
>>
atom -> call
302
!=
atom -> call
302
==
atom -> call
302
**
atom -> call
302
^
atom -> call
303
%
359
303
>>
term -> factor
303
/
360
303
//
361
303
*
362
303
<<
term -> factor
303
:
term -> factor
303
==
term -> factor
303
<=
term -> factor
303
+
term -> factor
303
>=
term -> factor
303
&
term -> factor
303
>
term -> factor
303
<
term -> factor
303
!=
term -> factor
303
or
term -> factor
303
|
term -> factor
303
^
term -> factor
303
and
term -> factor
303
-
term -> factor
304
+
363
304
-
364
304
<
arith_expr -> term
304
<=
arith_expr -> term
304
==
arith_expr -> term
304
and
arith_expr -> term
304
:
arith_expr -> term
304
>
arith_expr -> term
304
>>
arith_expr -> term
304
^
arith_expr -> term
304
|
arith_expr -> term
304
>=
arith_expr -> term
304
<<
arith_expr -> term
304
or
arith_expr -> term
304
!=
arith_expr -> term
304
&
arith_expr -> term
305
<
atom -> None
305
<<
atom -> None
305
!=
atom -> None
305
<=
atom -> None
305
%
atom -> None
305
&
atom -> None
305
*
atom -> None
305
-
atom -> None
305
>
atom -> None
305
and
atom -> None
305
^
atom -> None
305
>=
atom -> None
305
**
atom -> None
305
|
atom -> None
305
:
atom -> None
305
>>
atom -> None
305
/
atom -> None
305
//
atom -> None
305
==
atom -> None
305
+
atom -> None
305
or
atom -> None
306
==
expr -> xor_expr
306
<=
expr -> xor_expr
306
|
365
306
<
expr -> xor_expr
306
and
expr -> xor_expr
306
>=
expr -> xor_expr
306
:
expr -> xor_expr
306
!=
expr -> xor_expr
306
or
expr -> xor_expr
306
>
expr -> xor_expr
307
//
factor -> power
307
<<
factor -> power
307
<
factor -> power
307
!=
factor -> power
307
<=
factor -> power
307
|
factor -> power
307
-
factor -> power
307
>=
factor -> power
307
/
factor -> power
307
>>
factor -> power
307
:
factor -> power
307
*
factor -> power
307
==
factor -> power
307
&
factor -> power
307
and
factor -> power
307
+
factor -> power
307
^
factor -> power
307
>
factor -> power
307
or
factor -> power
307
%
factor -> power
308
&
atom -> NAME
308
(
366
308
%
atom -> NAME
308
>>
atom -> NAME
308
^
atom -> NAME
308
>
atom -> NAME
308
and
atom -> NAME
308
<<
atom -> NAME
308
or
atom -> NAME
308
<
atom -> NAME
308
**
atom -> NAME
308
|
atom -> NAME
308
<=
atom -> NAME
308
==
atom -> NAME
308
/
atom -> NAME
308
:
atom -> NAME
308
>=
atom -> NAME
308
!=
atom -> NAME
308
+
atom -> NAME
308
-
atom -> NAME
308
*
atom -> NAME
308
//
atom -> NAME
309
>>
367
309
==
shift_expr -> arith_expr
309
^
shift_expr -> arith_expr
309
<<
368
309
>=
shift_expr -> arith_expr
309
<=
shift_expr -> arith_expr
309
:
shift_expr -> arith_expr
309
or
shift_expr -> arith_expr
309
|
shift_expr -> arith_expr
309
>
shift_expr -> arith_expr
309
!=
shift_expr -> arith_expr
309
<
shift_expr -> arith_expr
309
and
shift_expr -> arith_expr
309
&
shift_expr -> arith_expr
310
call
302
310
None
305
310
power
307
310
NAME
308
310
+
310
310
-
311
310
STRING
312
310
atom
313
310
True
315
310
[
316
310
False
318
310
NUMBER
320
310
~
321
310
factor
369
311
call
302
311
None
305
311
power
307
311
NAME
308
311
+
310
311
-
311
311
factor
370
311
STRING
312
311
atom
313
311
True
315
311
[
316
311
False
318
311
NUMBER
320
311
~
321
312
!=
atom -> STRING
312
<<
atom -> STRING
312
//
atom -> STRING
312
/
atom -> STRING
312
<
atom -> STRING
312
==
atom -> STRING
312
|
atom -> STRING
312
^
atom -> STRING
312
>=
atom -> STRING
312
>>
atom -> STRING
312
<=
atom -> STRING
312
*
atom -> STRING
312
>
atom -> STRING
312
%
atom -> STRING
312
-
atom -> STRING
312
**
atom -> STRING
312
+
atom -> STRING
312
and
atom -> STRING
312
:
atom -> STRING
312
or
atom -> STRING
312
&
atom -> STRING
313
<=
power -> atom
313
>
power -> atom
313
**
371
313
|
power -> atom
313
//
power -> atom
313
>>
power -> atom
313
-
power -> atom
313
and
power -> atom
313
>=
power -> atom
313
!=
power -> atom
313
/
power -> atom
313
:
power -> atom
313
<<
power -> atom
313
&
power -> atom
313
%
power -> atom
313
^
power -> atom
313
or
power -> atom
313
+
power -> atom
313
*
power -> atom
313
==
power -> atom
313
<
power -> atom
314
&
372
314
:
and_expr -> shift_expr
314
and
and_expr -> shift_expr
314
^
and_expr -> shift_expr
314
<
and_expr -> shift_expr
314
>
and_expr -> shift_expr
314
==
and_expr -> shift_expr
314
|
and_expr -> shift_expr
314
!=
and_expr -> shift_expr
314
<=
and_expr -> shift_expr
314
or
and_expr -> shift_expr
314
>=
and_expr -> shift_expr
315
>=
atom -> True
315
//
atom -> True
315
|
atom -> True
315
:
atom -> True
315
<
atom -> True
315
==
atom -> True
315
-
atom -> True
315
<<
atom -> True
315
/
atom -> True
315
or
atom -> True
315
!=
atom -> True
315
**
atom -> True
315
^
atom -> True
315
&
atom -> True
315
*
atom -> True
315
%
atom -> True
315
<=
atom -> True
315
>
atom -> True
315
+
atom -> True
315
and
atom -> True
315
>>
atom -> True
316
call
79
316
factor
80
316
term
81
316
None
82
316
or_test
83
316
xor_expr
84
316
NAME
85
316
arith_expr
86
316
+
87
316
STRING
88
316
atom
89
316
shift_expr
90
316
True
91
316
[
92
316
test_list
373
316
-
94
316
expr
95
316
~
96
316
not_test
97
316
comparison
98
316
power
99
316
NUMBER
100
316
False
101
316
and_expr
102
316
and_test
103
316
not
104
316
test
105
317
:
xor_expr -> and_expr
317
and
xor_expr -> and_expr
317
>=
xor_expr -> and_expr
317
^
374
317
<=
xor_expr -> and_expr
317
==
xor_expr -> and_expr
317
or
xor_expr -> and_expr
317
<
xor_expr -> and_expr
317
!=
xor_expr -> and_expr
317
>
xor_expr -> and_expr
317
|
xor_expr -> and_expr
318
and
atom -> False
318
/
atom -> False
318
*
atom -> False
318
-
atom -> False
318
**
atom -> False
318
:
atom -> False
318
<<
atom -> False
318
>
atom -> False
318
>>
atom -> False
318
==
atom -> False
318
|
atom -> False
318
%
atom -> False
318
<=
atom -> False
318
<
atom -> False
318
or
atom -> False
318
>=
atom -> False
318
//
atom -> False
318
+
atom -> False
318
&
atom -> False
318
^
atom -> False
318
!=
atom -> False
319
or
375
319
:
or_test -> and_test
320
/
atom -> NUMBER
320
or
atom -> NUMBER
320
>>
atom -> NUMBER
320
*
atom -> NUMBER
320
<=
atom -> NUMBER
320
+
atom -> NUMBER
320
and
atom -> NUMBER
320
:
atom -> NUMBER
320
-
atom -> NUMBER
320
==
atom -> NUMBER
320
<
atom -> NUMBER
320
%
atom -> NUMBER
320
//
atom -> NUMBER
320
>=
atom -> NUMBER
320
>
atom -> NUMBER
320
**
atom -> NUMBER
320
!=
atom -> NUMBER
320
&
atom -> NUMBER
320
^
atom -> NUMBER
320
<<
atom -> NUMBER
320
|
atom -> NUMBER
321
call
302
321
None
305
321
power
307
321
NAME
308
321
+
310
321
-
311
321
factor
376
321
STRING
312
321
atom
313
321
True
315
321
[
316
321
False
318
321
NUMBER
320
321
~
321
322
>
106
322
>=
107
322
<
108
322
!=
109
322
==
110
322
and
comparison -> expr
322
<=
111
322
comp_op
377
322
:
comparison -> expr
322
or
comparison -> expr
323
:
378
324
or
not_test -> comparison
324
:
not_test -> comparison
324
and
not_test -> comparison
325
:
and_test -> not_test
325
and
379
325
or
and_test -> not_test
326
:
test -> or_test
327
call
302
327
factor
303
327
term
304
327
None
305
327
xor_expr
306
327
power
307
327
NAME
308
327
arith_expr
309
327
+
310
327
-
311
327
STRING
312
327
atom
313
327
shift_expr
314
327
True
315
327
[
316
327
and_expr
317
327
False
318
327
NUMBER
320
327
~
321
327
expr
322
327
comparison
324
327
not_test
380
327
not
327
328
DEDENT
stmt_list -> NEWLINE stmt_list
329
=
381
330
DEDENT
stmt_list -> stmt stmt_list
331
NEWLINE
333
331
suite
382
332
call
383
332
factor
384
332
term
385
332
None
386
332
xor_expr
387
332
NAME
388
332
arith_expr
389
332
+
390
332
STRING
391
332
atom
392
332
shift_expr
393
332
True
394
332
[
395
332
-
396
332
NUMBER
397
332
~
398
332
and_test
399
332
expr
400
332
test
401
332
comparison
402
332
power
403
332
False
404
332
and_expr
405
332
or_test
406
332
not_test
407
332
not
408
333
INDENT
409
334
return
loop_stmt -> loop : suite
334
var
loop_stmt -> loop : suite
334
endloop
loop_stmt -> loop : suite
334
loop
loop_stmt -> loop : suite
334
nextloop
loop_stmt -> loop : suite
334
NAME
loop_stmt -> loop : suite
334
NEWLINE
loop_stmt -> loop : suite
334
DEDENT
loop_stmt -> loop : suite
334
if
loop_stmt -> loop : suite
335
)
410
336
NAME
call -> NAME ( )
336
return
call -> NAME ( )
336
NEWLINE
call -> NAME ( )
336
if
call -> NAME ( )
336
nextloop
call -> NAME ( )
336
DEDENT
call -> NAME ( )
336
endloop
call -> NAME ( )
336
var
call -> NAME ( )
336
loop
call -> NAME ( )
337
DEDENT
assign_stmt -> NAME = test
337
NEWLINE
assign_stmt -> NAME = test
337
if
assign_stmt -> NAME = test
337
nextloop
assign_stmt -> NAME = test
337
loop
assign_stmt -> NAME = test
337
var
assign_stmt -> NAME = test
337
endloop
assign_stmt -> NAME = test
337
return
assign_stmt -> NAME = test
337
NAME
assign_stmt -> NAME = test
338
call
275
338
factor
276
338
None
280
338
NUMBER
297
338
power
293
338
NAME
281
338
+
283
338
-
289
338
STRING
284
338
atom
286
338
True
287
338
[
288
338
False
290
338
~
291
338
term
411
339
call
275
339
factor
276
339
None
280
339
NUMBER
297
339
power
293
339
NAME
281
339
term
412
339
+
283
339
-
289
339
STRING
284
339
atom
286
339
True
287
339
[
288
339
False
290
339
~
291
340
call
275
340
factor
276
340
None
280
340
NUMBER
297
340
power
293
340
NAME
281
340
term
413
340
+
283
340
-
289
340
STRING
284
340
atom
286
340
True
287
340
[
288
340
False
290
340
~
291
341
call
275
341
factor
276
341
term
414
341
None
280
341
NUMBER
297
341
power
293
341
NAME
281
341
+
283
341
-
289
341
STRING
284
341
atom
286
341
True
287
341
[
288
341
False
290
341
~
291
342
call
275
342
factor
276
342
expr
277
342
term
278
342
xor_expr
279
342
None
280
342
NAME
281
342
arith_expr
282
342
+
283
342
STRING
284
342
shift_expr
285
342
atom
286
342
True
287
342
[
288
342
-
289
342
False
290
342
~
291
342
and_expr
292
342
power
293
342
NUMBER
297
342
comparison
415
343
call
275
343
factor
276
343
term
278
343
None
280
343
NAME
281
343
arith_expr
416
343
+
283
343
STRING
284
343
atom
286
343
True
287
343
[
288
343
-
289
343
False
290
343
~
291
343
power
293
343
NUMBER
297
344
call
275
344
factor
276
344
term
278
344
None
280
344
NAME
281
344
+
283
344
STRING
284
344
atom
286
344
True
287
344
[
288
344
-
289
344
False
290
344
~
291
344
power
293
344
arith_expr
417
344
NUMBER
297
345
call
275
345
factor
276
345
term
278
345
xor_expr
279
345
None
280
345
NAME
281
345
arith_expr
282
345
+
283
345
STRING
284
345
shift_expr
285
345
atom
286
345
True
287
345
[
288
345
-
289
345
False
290
345
~
291
345
and_expr
292
345
power
293
345
expr
418
345
NUMBER
297
346
call
128
346
factor
129
346
term
130
346
None
131
346
xor_expr
132
346
NAME
133
346
arith_expr
134
346
+
135
346
STRING
136
346
atom
137
346
test_list
419
346
shift_expr
138
346
True
139
346
[
140
346
-
141
346
not_test
142
346
expr
143
346
~
144
346
)
420
346
False
148
346
comparison
145
346
power
146
346
NUMBER
147
346
and_expr
149
346
not
150
346
and_test
153
346
or_test
154
346
test
155
347
call
275
347
factor
276
347
term
278
347
None
280
347
NAME
281
347
arith_expr
282
347
+
283
347
shift_expr
421
347
STRING
284
347
atom
286
347
True
287
347
[
288
347
-
289
347
False
290
347
~
291
347
power
293
347
NUMBER
297
348
call
275
348
factor
276
348
term
278
348
None
280
348
NAME
281
348
arith_expr
282
348
+
283
348
STRING
284
348
atom
286
348
True
287
348
[
288
348
shift_expr
422
348
-
289
348
False
290
348
~
291
348
power
293
348
NUMBER
297
349
var
factor -> + factor
349
>=
factor -> + factor
349
<=
factor -> + factor
349
loop
factor -> + factor
349
*
factor -> + factor
349
return
factor -> + factor
349
==
factor -> + factor
349
>
factor -> + factor
349
endloop
factor -> + factor
349
DEDENT
factor -> + factor
349
nextloop
factor -> + factor
349
NAME
factor -> + factor
349
!=
factor -> + factor
349
-
factor -> + factor
349
and
factor -> + factor
349
//
factor -> + factor
349
NEWLINE
factor -> + factor
349
%
factor -> + factor
349
/
factor -> + factor
349
<<
factor -> + factor
349
+
factor -> + factor
349
if
factor -> + factor
349
^
factor -> + factor
349
or
factor -> + factor
349
&
factor -> + factor
349
|
factor -> + factor
349
>>
factor -> + factor
349
<
factor -> + factor
350
and_expr
423
350
call
275
350
factor
276
350
term
278
350
None
280
350
NAME
281
350
arith_expr
282
350
+
283
350
STRING
284
350
shift_expr
285
350
atom
286
350
True
287
350
[
288
350
-
289
350
False
290
350
~
291
350
power
293
350
NUMBER
297
351
call
275
351
factor
424
351
None
280
351
NUMBER
297
351
power
293
351
NAME
281
351
+
283
351
-
289
351
STRING
284
351
atom
286
351
True
287
351
[
288
351
False
290
351
~
291
352
]
425
353
or
factor -> - factor
353
*
factor -> - factor
353
NEWLINE
factor -> - factor
353
&
factor -> - factor
353
>=
factor -> - factor
353
and
factor -> - factor
353
>>
factor -> - factor
353
>
factor -> - factor
353
+
factor -> - factor
353
%
factor -> - factor
353
if
factor -> - factor
353
var
factor -> - factor
353
endloop
factor -> - factor
353
//
factor -> - factor
353
return
factor -> - factor
353
<=
factor -> - factor
353
==
factor -> - factor
353
/
factor -> - factor
353
-
factor -> - factor
353
loop
factor -> - factor
353
<<
factor -> - factor
353
!=
factor -> - factor
353
^
factor -> - factor
353
|
factor -> - factor
353
nextloop
factor -> - factor
353
<
factor -> - factor
353
NAME
factor -> - factor
353
DEDENT
factor -> - factor
354
and
factor -> ~ factor
354
endloop
factor -> ~ factor
354
nextloop
factor -> ~ factor
354
/
factor -> ~ factor
354
>>
factor -> ~ factor
354
<=
factor -> ~ factor
354
-
factor -> ~ factor
354
!=
factor -> ~ factor
354
DEDENT
factor -> ~ factor
354
var
factor -> ~ factor
354
==
factor -> ~ factor
354
if
factor -> ~ factor
354
^
factor -> ~ factor
354
or
factor -> ~ factor
354
>=
factor -> ~ factor
354
>
factor -> ~ factor
354
return
factor -> ~ factor
354
<
factor -> ~ factor
354
NEWLINE
factor -> ~ factor
354
loop
factor -> ~ factor
354
+
factor -> ~ factor
354
<<
factor -> ~ factor
354
|
factor -> ~ factor
354
NAME
factor -> ~ factor
354
&
factor -> ~ factor
354
*
factor -> ~ factor
354
%
factor -> ~ factor
354
//
factor -> ~ factor
355
call
275
355
factor
276
355
term
278
355
None
280
355
NAME
281
355
arith_expr
282
355
+
283
355
STRING
284
355
shift_expr
285
355
atom
286
355
True
287
355
[
288
355
-
289
355
False
290
355
~
291
355
and_expr
292
355
xor_expr
426
355
power
293
355
NUMBER
297
356
call
275
356
factor
276
356
expr
277
356
term
278
356
xor_expr
279
356
None
280
356
NAME
281
356
arith_expr
282
356
+
283
356
STRING
284
356
shift_expr
285
356
atom
286
356
True
287
356
[
288
356
-
289
356
False
290
356
~
291
356
and_expr
292
356
comparison
294
356
power
293
356
not_test
295
356
NUMBER
297
356
and_test
427
356
not
300
357
call
275
357
factor
276
357
expr
277
357
term
278
357
xor_expr
279
357
None
280
357
NAME
281
357
arith_expr
282
357
+
283
357
or_test
428
357
STRING
284
357
shift_expr
285
357
atom
286
357
True
287
357
[
288
357
-
289
357
False
290
357
~
291
357
and_expr
292
357
comparison
294
357
power
293
357
not_test
295
357
NUMBER
297
357
and_test
298
357
not
300
358
if
not_test -> not not_test
358
var
not_test -> not not_test
358
NEWLINE
not_test -> not not_test
358
NAME
not_test -> not not_test
358
endloop
not_test -> not not_test
358
nextloop
not_test -> not not_test
358
and
not_test -> not not_test
358
loop
not_test -> not not_test
358
return
not_test -> not not_test
358
or
not_test -> not not_test
358
DEDENT
not_test -> not not_test
359
call
302
359
factor
303
359
None
305
359
power
307
359
NAME
308
359
+
310
359
-
311
359
STRING
312
359
atom
313
359
True
315
359
[
316
359
False
318
359
NUMBER
320
359
~
321
359
term
429
360
call
302
360
factor
303
360
term
430
360
None
305
360
power
307
360
NAME
308
360
+
310
360
-
311
360
STRING
312
360
atom
313
360
True
315
360
[
316
360
False
318
360
NUMBER
320
360
~
321
361
call
302
361
factor
303
361
None
305
361
power
307
361
NAME
308
361
+
310
361
-
311
361
STRING
312
361
atom
313
361
True
315
361
[
316
361
False
318
361
NUMBER
320
361
~
321
361
term
431
362
call
302
362
factor
303
362
None
305
362
power
307
362
NAME
308
362
+
310
362
-
311
362
STRING
312
362
atom
313
362
True
315
362
[
316
362
False
318
362
NUMBER
320
362
term
432
362
~
321
363
call
302
363
factor
303
363
term
304
363
None
305
363
power
307
363
NAME
308
363
+
310
363
-
311
363
STRING
312
363
atom
313
363
arith_expr
433
363
True
315
363
[
316
363
False
318
363
NUMBER
320
363
~
321
364
call
302
364
factor
303
364
term
304
364
None
305
364
power
307
364
NAME
308
364
+
310
364
-
311
364
STRING
312
364
atom
313
364
True
315
364
[
316
364
arith_expr
434
364
False
318
364
NUMBER
320
364
~
321
365
call
302
365
factor
303
365
term
304
365
None
305
365
xor_expr
306
365
power
307
365
NAME
308
365
arith_expr
309
365
+
310
365
-
311
365
STRING
312
365
atom
313
365
shift_expr
314
365
True
315
365
[
316
365
and_expr
317
365
False
318
365
NUMBER
320
365
~
321
365
expr
435
366
call
128
366
factor
129
366
term
130
366
None
131
366
xor_expr
132
366
NAME
133
366
arith_expr
134
366
+
135
366
STRING
136
366
atom
137
366
shift_expr
138
366
True
139
366
[
140
366
-
141
366
not_test
142
366
expr
143
366
~
144
366
comparison
145
366
power
146
366
NUMBER
147
366
False
148
366
and_expr
149
366
not
150
366
)
436
366
test_list
437
366
and_test
153
366
or_test
154
366
test
155
367
call
302
367
factor
303
367
term
304
367
None
305
367
power
307
367
NAME
308
367
arith_expr
309
367
+
310
367
-
311
367
shift_expr
438
367
STRING
312
367
atom
313
367
True
315
367
[
316
367
False
318
367
NUMBER
320
367
~
321
368
call
302
368
factor
303
368
term
304
368
None
305
368
power
307
368
NAME
308
368
arith_expr
309
368
+
310
368
-
311
368
STRING
312
368
atom
313
368
True
315
368
[
316
368
False
318
368
NUMBER
320
368
~
321
368
shift_expr
439
369
>=
factor -> + factor
369
<=
factor -> + factor
369
*
factor -> + factor
369
==
factor -> + factor
369
>
factor -> + factor
369
!=
factor -> + factor
369
-
factor -> + factor
369
and
factor -> + factor
369
//
factor -> + factor
369
%
factor -> + factor
369
/
factor -> + factor
369
<<
factor -> + factor
369
+
factor -> + factor
369
^
factor -> + factor
369
or
factor -> + factor
369
:
factor -> + factor
369
&
factor -> + factor
369
|
factor -> + factor
369
>>
factor -> + factor
369
<
factor -> + factor
370
or
factor -> - factor
370
*
factor -> - factor
370
&
factor -> - factor
370
>=
factor -> - factor
370
:
factor -> - factor
370
and
factor -> - factor
370
>>
factor -> - factor
370
>
factor -> - factor
370
+
factor -> - factor
370
%
factor -> - factor
370
//
factor -> - factor
370
<=
factor -> - factor
370
==
factor -> - factor
370
/
factor -> - factor
370
-
factor -> - factor
370
<<
factor -> - factor
370
!=
factor -> - factor
370
^
factor -> - factor
370
|
factor -> - factor
370
<
factor -> - factor
371
call
302
371
factor
440
371
None
305
371
power
307
371
NAME
308
371
+
310
371
-
311
371
STRING
312
371
atom
313
371
True
315
371
[
316
371
False
318
371
NUMBER
320
371
~
321
372
and_expr
441
372
call
302
372
factor
303
372
term
304
372
None
305
372
power
307
372
NAME
308
372
arith_expr
309
372
+
310
372
-
311
372
STRING
312
372
atom
313
372
shift_expr
314
372
True
315
372
[
316
372
False
318
372
NUMBER
320
372
~
321
373
]
442
374
call
302
374
factor
303
374
term
304
374
None
305
374
power
307
374
NAME
308
374
arith_expr
309
374
+
310
374
-
311
374
STRING
312
374
atom
313
374
shift_expr
314
374
True
315
374
[
316
374
and_expr
317
374
False
318
374
NUMBER
320
374
~
321
374
xor_expr
443
375
call
302
375
factor
303
375
term
304
375
None
305
375
xor_expr
306
375
power
307
375
NAME
308
375
arith_expr
309
375
+
310
375
-
311
375
STRING
312
375
atom
313
375
shift_expr
314
375
True
315
375
[
316
375
and_expr
317
375
False
318
375
and_test
319
375
NUMBER
320
375
~
321
375
expr
322
375
comparison
324
375
not_test
325
375
or_test
444
375
not
327
376
and
factor -> ~ factor
376
/
factor -> ~ factor
376
>>
factor -> ~ factor
376
<=
factor -> ~ factor
376
-
factor -> ~ factor
376
!=
factor -> ~ factor
376
==
factor -> ~ factor
376
^
factor -> ~ factor
376
or
factor -> ~ factor
376
>=
factor -> ~ factor
376
>
factor -> ~ factor
376
<
factor -> ~ factor
376
:
factor -> ~ factor
376
+
factor -> ~ factor
376
<<
factor -> ~ factor
376
|
factor -> ~ factor
376
&
factor -> ~ factor
376
*
factor -> ~ factor
376
%
factor -> ~ factor
376
//
factor -> ~ factor
377
call
302
377
factor
303
377
term
304
377
None
305
377
xor_expr
306
377
power
307
377
NAME
308
377
arith_expr
309
377
+
310
377
-
311
377
STRING
312
377
atom
313
377
shift_expr
314
377
True
315
377
[
316
377
and_expr
317
377
False
318
377
NUMBER
320
377
~
321
377
expr
322
377
comparison
445
378
suite
446
378
NEWLINE
447
379
call
302
379
factor
303
379
term
304
379
None
305
379
xor_expr
306
379
power
307
379
NAME
308
379
arith_expr
309
379
+
310
379
-
311
379
STRING
312
379
atom
313
379
shift_expr
314
379
True
315
379
[
316
379
and_expr
317
379
False
318
379
NUMBER
320
379
~
321
379
expr
322
379
comparison
324
379
not_test
325
379
not
327
379
and_test
448
380
or
not_test -> not not_test
380
:
not_test -> not not_test
380
and
not_test -> not not_test
381
call
275
381
factor
276
381
expr
277
381
term
278
381
xor_expr
279
381
None
280
381
NAME
281
381
arith_expr
282
381
+
283
381
STRING
284
381
shift_expr
285
381
atom
286
381
test
449
381
True
287
381
[
288
381
-
289
381
False
290
381
~
291
381
and_expr
292
381
power
293
381
comparison
294
381
not_test
295
381
NUMBER
297
381
and_test
298
381
or_test
299
381
not
300
382
var
loop_stmt -> loop NAME : suite
382
NEWLINE
loop_stmt -> loop NAME : suite
382
loop
loop_stmt -> loop NAME : suite
382
NAME
loop_stmt -> loop NAME : suite
382
nextloop
loop_stmt -> loop NAME : suite
382
if
loop_stmt -> loop NAME : suite
382
return
loop_stmt -> loop NAME : suite
382
DEDENT
loop_stmt -> loop NAME : suite
382
endloop
loop_stmt -> loop NAME : suite
383
%
atom -> call
383
&
atom -> call
383
-
atom -> call
383
:
atom -> call
383
<
atom -> call
383
and
atom -> call
383
>
atom -> call
383
>=
atom -> call
383
<=
atom -> call
383
//
atom -> call
383
<<
atom -> call
383
or
atom -> call
383
/
atom -> call
383
|
atom -> call
383
*
atom -> call
383
+
atom -> call
383
>>
atom -> call
383
!=
atom -> call
383
**
atom -> call
383
==
atom -> call
383
^
atom -> call
383
to
atom -> call
384
%
450
384
>>
term -> factor
384
/
451
384
//
452
384
*
453
384
<<
term -> factor
384
:
term -> factor
384
==
term -> factor
384
<=
term -> factor
384
to
term -> factor
384
+
term -> factor
384
>=
term -> factor
384
&
term -> factor
384
>
term -> factor
384
<
term -> factor
384
!=
term -> factor
384
or
term -> factor
384
|
term -> factor
384
^
term -> factor
384
and
term -> factor
384
-
term -> factor
385
+
454
385
-
455
385
<
arith_expr -> term
385
<=
arith_expr -> term
385
==
arith_expr -> term
385
to
arith_expr -> term
385
and
arith_expr -> term
385
:
arith_expr -> term
385
>
arith_expr -> term
385
>>
arith_expr -> term
385
^
arith_expr -> term
385
|
arith_expr -> term
385
>=
arith_expr -> term
385
<<
arith_expr -> term
385
or
arith_expr -> term
385
!=
arith_expr -> term
385
&
arith_expr -> term
386
<
atom -> None
386
<<
atom -> None
386
!=
atom -> None
386
<=
atom -> None
386
%
atom -> None
386
&
atom -> None
386
*
atom -> None
386
-
atom -> None
386
>
atom -> None
386
and
atom -> None
386
^
atom -> None
386
>=
atom -> None
386
**
atom -> None
386
|
atom -> None
386
:
atom -> None
386
>>
atom -> None
386
/
atom -> None
386
//
atom -> None
386
==
atom -> None
386
to
atom -> None
386
+
atom -> None
386
or
atom -> None
387
|
456
387
:
expr -> xor_expr
387
!=
expr -> xor_expr
387
==
expr -> xor_expr
387
<
expr -> xor_expr
387
to
expr -> xor_expr
387
>
expr -> xor_expr
387
<=
expr -> xor_expr
387
and
expr -> xor_expr
387
>=
expr -> xor_expr
387
or
expr -> xor_expr
388
&
atom -> NAME
388
(
457
388
%
atom -> NAME
388
>>
atom -> NAME
388
^
atom -> NAME
388
>
atom -> NAME
388
<<
atom -> NAME
388
and
atom -> NAME
388
or
atom -> NAME
388
<
atom -> NAME
388
**
atom -> NAME
388
|
atom -> NAME
388
<=
atom -> NAME
388
==
atom -> NAME
388
to
atom -> NAME
388
:
atom -> NAME
388
>=
atom -> NAME
388
/
atom -> NAME
388
!=
atom -> NAME
388
+
atom -> NAME
388
*
atom -> NAME
388
-
atom -> NAME
388
//
atom -> NAME
389
>>
458
389
==
shift_expr -> arith_expr
389
^
shift_expr -> arith_expr
389
<<
459
389
>=
shift_expr -> arith_expr
389
to
shift_expr -> arith_expr
389
<=
shift_expr -> arith_expr
389
:
shift_expr -> arith_expr
389
or
shift_expr -> arith_expr
389
|
shift_expr -> arith_expr
389
>
shift_expr -> arith_expr
389
!=
shift_expr -> arith_expr
389
<
shift_expr -> arith_expr
389
and
shift_expr -> arith_expr
389
&
shift_expr -> arith_expr
390
call
383
390
None
386
390
power
403
390
NAME
388
390
+
390
390
-
396
390
STRING
391
390
atom
392
390
True
394
390
[
395
390
False
404
390
NUMBER
397
390
~
398
390
factor
460
391
!=
atom -> STRING
391
<<
atom -> STRING
391
//
atom -> STRING
391
/
atom -> STRING
391
<
atom -> STRING
391
==
atom -> STRING
391
|
atom -> STRING
391
>=
atom -> STRING
391
^
atom -> STRING
391
to
atom -> STRING
391
>>
atom -> STRING
391
<=
atom -> STRING
391
*
atom -> STRING
391
>
atom -> STRING
391
%
atom -> STRING
391
-
atom -> STRING
391
**
atom -> STRING
391
+
atom -> STRING
391
and
atom -> STRING
391
:
atom -> STRING
391
or
atom -> STRING
391
&
atom -> STRING
392
<=
power -> atom
392
>
power -> atom
392
**
461
392
|
power -> atom
392
//
power -> atom
392
>>
power -> atom
392
-
power -> atom
392
and
power -> atom
392
>=
power -> atom
392
!=
power -> atom
392
/
power -> atom
392
:
power -> atom
392
<<
power -> atom
392
&
power -> atom
392
%
power -> atom
392
^
power -> atom
392
+
power -> atom
392
or
power -> atom
392
*
power -> atom
392
==
power -> atom
392
<
power -> atom
392
to
power -> atom
393
&
462
393
:
and_expr -> shift_expr
393
and
and_expr -> shift_expr
393
<
and_expr -> shift_expr
393
^
and_expr -> shift_expr
393
to
and_expr -> shift_expr
393
>
and_expr -> shift_expr
393
==
and_expr -> shift_expr
393
|
and_expr -> shift_expr
393
!=
and_expr -> shift_expr
393
<=
and_expr -> shift_expr
393
or
and_expr -> shift_expr
393
>=
and_expr -> shift_expr
394
to
atom -> True
394
>=
atom -> True
394
|
atom -> True
394
//
atom -> True
394
<
atom -> True
394
:
atom -> True
394
==
atom -> True
394
-
atom -> True
394
<<
atom -> True
394
/
atom -> True
394
or
atom -> True
394
!=
atom -> True
394
**
atom -> True
394
^
atom -> True
394
&
atom -> True
394
*
atom -> True
394
%
atom -> True
394
<=
atom -> True
394
>
atom -> True
394
+
atom -> True
394
and
atom -> True
394
>>
atom -> True
395
call
79
395
factor
80
395
term
81
395
None
82
395
or_test
83
395
xor_expr
84
395
NAME
85
395
arith_expr
86
395
+
87
395
STRING
88
395
atom
89
395
shift_expr
90
395
True
91
395
[
92
395
test_list
463
395
-
94
395
expr
95
395
~
96
395
not_test
97
395
comparison
98
395
power
99
395
NUMBER
100
395
False
101
395
and_expr
102
395
and_test
103
395
not
104
395
test
105
396
call
383
396
None
386
396
power
403
396
NAME
388
396
+
390
396
-
396
396
factor
464
396
STRING
391
396
atom
392
396
True
394
396
[
395
396
False
404
396
NUMBER
397
396
~
398
397
/
atom -> NUMBER
397
or
atom -> NUMBER
397
>>
atom -> NUMBER
397
*
atom -> NUMBER
397
<=
atom -> NUMBER
397
+
atom -> NUMBER
397
and
atom -> NUMBER
397
:
atom -> NUMBER
397
-
atom -> NUMBER
397
==
atom -> NUMBER
397
<
atom -> NUMBER
397
%
atom -> NUMBER
397
//
atom -> NUMBER
397
>=
atom -> NUMBER
397
>
atom -> NUMBER
397
to
atom -> NUMBER
397
!=
atom -> NUMBER
397
**
atom -> NUMBER
397
^
atom -> NUMBER
397
&
atom -> NUMBER
397
<<
atom -> NUMBER
397
|
atom -> NUMBER
398
call
383
398
None
386
398
power
403
398
NAME
388
398
+
390
398
-
396
398
factor
465
398
STRING
391
398
atom
392
398
True
394
398
[
395
398
False
404
398
NUMBER
397
398
~
398
399
or
466
399
:
or_test -> and_test
399
to
or_test -> and_test
400
>
106
400
>=
107
400
<
108
400
!=
109
400
==
110
400
and
comparison -> expr
400
<=
111
400
comp_op
467
400
to
comparison -> expr
400
:
comparison -> expr
400
or
comparison -> expr
401
to
468
401
:
469
402
or
not_test -> comparison
402
to
not_test -> comparison
402
:
not_test -> comparison
402
and
not_test -> comparison
403
//
factor -> power
403
to
factor -> power
403
<<
factor -> power
403
<
factor -> power
403
!=
factor -> power
403
<=
factor -> power
403
|
factor -> power
403
-
factor -> power
403
>=
factor -> power
403
/
factor -> power
403
:
factor -> power
403
>>
factor -> power
403
*
factor -> power
403
==
factor -> power
403
&
factor -> power
403
^
factor -> power
403
+
factor -> power
403
and
factor -> power
403
>
factor -> power
403
or
factor -> power
403
%
factor -> power
404
and
atom -> False
404
/
atom -> False
404
*
atom -> False
404
-
atom -> False
404
**
atom -> False
404
:
atom -> False
404
<<
atom -> False
404
>
atom -> False
404
>>
atom -> False
404
==
atom -> False
404
|
atom -> False
404
%
atom -> False
404
<=
atom -> False
404
or
atom -> False
404
<
atom -> False
404
//
atom -> False
404
+
atom -> False
404
>=
atom -> False
404
&
atom -> False
404
to
atom -> False
404
^
atom -> False
404
!=
atom -> False
405
:
xor_expr -> and_expr
405
and
xor_expr -> and_expr
405
^
470
405
>=
xor_expr -> and_expr
405
<=
xor_expr -> and_expr
405
==
xor_expr -> and_expr
405
or
xor_expr -> and_expr
405
<
xor_expr -> and_expr
405
to
xor_expr -> and_expr
405
!=
xor_expr -> and_expr
405
>
xor_expr -> and_expr
405
|
xor_expr -> and_expr
406
:
test -> or_test
406
to
test -> or_test
407
to
and_test -> not_test
407
and
471
407
or
and_test -> not_test
407
:
and_test -> not_test
408
call
383
408
factor
384
408
term
385
408
None
386
408
xor_expr
387
408
power
403
408
NAME
388
408
arith_expr
389
408
+
390
408
-
396
408
STRING
391
408
atom
392
408
shift_expr
393
408
True
394
408
[
395
408
and_expr
405
408
False
404
408
NUMBER
397
408
~
398
408
expr
400
408
comparison
402
408
not_test
472
408
not
408
409
loop
254
409
NAME
255
409
nextloop
256
409
flow_stmt
257
409
return
258
409
loop_stmt
259
409
stmt_list
473
409
if
261
409
return_stmt
262
409
NEWLINE
263
409
endloop
264
409
var
265
409
DEDENT
stmt_list -> 
409
assign_stmt
266
409
call
267
409
if_stmt
268
409
decl_stmt
269
409
stmt
270
410
return
call -> NAME ( test_list )
410
nextloop
call -> NAME ( test_list )
410
NAME
call -> NAME ( test_list )
410
DEDENT
call -> NAME ( test_list )
410
NEWLINE
call -> NAME ( test_list )
410
var
call -> NAME ( test_list )
410
loop
call -> NAME ( test_list )
410
if
call -> NAME ( test_list )
410
endloop
call -> NAME ( test_list )
411
+
term -> factor % term
411
var
term -> factor % term
411
>=
term -> factor % term
411
^
term -> factor % term
411
if
term -> factor % term
411
nextloop
term -> factor % term
411
NEWLINE
term -> factor % term
411
NAME
term -> factor % term
411
and
term -> factor % term
411
==
term -> factor % term
411
>
term -> factor % term
411
>>
term -> factor % term
411
return
term -> factor % term
411
|
term -> factor % term
411
&
term -> factor % term
411
endloop
term -> factor % term
411
<
term -> factor % term
411
!=
term -> factor % term
411
<<
term -> factor % term
411
loop
term -> factor % term
411
DEDENT
term -> factor % term
411
-
term -> factor % term
411
or
term -> factor % term
411
<=
term -> factor % term
412
>=
term -> factor // term
412
!=
term -> factor // term
412
NAME
term -> factor // term
412
<<
term -> factor // term
412
==
term -> factor // term
412
&
term -> factor // term
412
+
term -> factor // term
412
if
term -> factor // term
412
|
term -> factor // term
412
and
term -> factor // term
412
>>
term -> factor // term
412
^
term -> factor // term
412
<
term -> factor // term
412
DEDENT
term -> factor // term
412
NEWLINE
term -> factor // term
412
loop
term -> factor // term
412
return
term -> factor // term
412
var
term -> factor // term
412
<=
term -> factor // term
412
endloop
term -> factor // term
412
-
term -> factor // term
412
>
term -> factor // term
412
nextloop
term -> factor // term
412
or
term -> factor // term
413
loop
term -> factor * term
413
|
term -> factor * term
413
<<
term -> factor * term
413
NEWLINE
term -> factor * term
413
&
term -> factor * term
413
!=
term -> factor * term
413
>>
term -> factor * term
413
or
term -> factor * term
413
+
term -> factor * term
413
>
term -> factor * term
413
endloop
term -> factor * term
413
>=
term -> factor * term
413
nextloop
term -> factor * term
413
<
term -> factor * term
413
var
term -> factor * term
413
return
term -> factor * term
413
DEDENT
term -> factor * term
413
NAME
term -> factor * term
413
-
term -> factor * term
413
and
term -> factor * term
413
<=
term -> factor * term
413
if
term -> factor * term
413
^
term -> factor * term
413
==
term -> factor * term
414
NAME
term -> factor / term
414
^
term -> factor / term
414
>>
term -> factor / term
414
==
term -> factor / term
414
>=
term -> factor / term
414
|
term -> factor / term
414
return
term -> factor / term
414
or
term -> factor / term
414
and
term -> factor / term
414
>
term -> factor / term
414
var
term -> factor / term
414
!=
term -> factor / term
414
-
term -> factor / term
414
endloop
term -> factor / term
414
<
term -> factor / term
414
+
term -> factor / term
414
NEWLINE
term -> factor / term
414
nextloop
term -> factor / term
414
<=
term -> factor / term
414
<<
term -> factor / term
414
loop
term -> factor / term
414
if
term -> factor / term
414
DEDENT
term -> factor / term
414
&
term -> factor / term
415
and
comparison -> expr comp_op comparison
415
var
comparison -> expr comp_op comparison
415
nextloop
comparison -> expr comp_op comparison
415
if
comparison -> expr comp_op comparison
415
endloop
comparison -> expr comp_op comparison
415
NAME
comparison -> expr comp_op comparison
415
DEDENT
comparison -> expr comp_op comparison
415
loop
comparison -> expr comp_op comparison
415
NEWLINE
comparison -> expr comp_op comparison
415
or
comparison -> expr comp_op comparison
415
return
comparison -> expr comp_op comparison
416
!=
arith_expr -> term + arith_expr
416
<=
arith_expr -> term + arith_expr
416
<<
arith_expr -> term + arith_expr
416
var
arith_expr -> term + arith_expr
416
>>
arith_expr -> term + arith_expr
416
return
arith_expr -> term + arith_expr
416
^
arith_expr -> term + arith_expr
416
endloop
arith_expr -> term + arith_expr
416
loop
arith_expr -> term + arith_expr
416
and
arith_expr -> term + arith_expr
416
nextloop
arith_expr -> term + arith_expr
416
or
arith_expr -> term + arith_expr
416
>
arith_expr -> term + arith_expr
416
<
arith_expr -> term + arith_expr
416
NAME
arith_expr -> term + arith_expr
416
NEWLINE
arith_expr -> term + arith_expr
416
|
arith_expr -> term + arith_expr
416
DEDENT
arith_expr -> term + arith_expr
416
>=
arith_expr -> term + arith_expr
416
if
arith_expr -> term + arith_expr
416
&
arith_expr -> term + arith_expr
416
==
arith_expr -> term + arith_expr
417
==
arith_expr -> term - arith_expr
417
>=
arith_expr -> term - arith_expr
417
>
arith_expr -> term - arith_expr
417
var
arith_expr -> term - arith_expr
417
or
arith_expr -> term - arith_expr
417
DEDENT
arith_expr -> term - arith_expr
417
if
arith_expr -> term - arith_expr
417
nextloop
arith_expr -> term - arith_expr
417
<=
arith_expr -> term - arith_expr
417
NAME
arith_expr -> term - arith_expr
417
loop
arith_expr -> term - arith_expr
417
<<
arith_expr -> term - arith_expr
417
!=
arith_expr -> term - arith_expr
417
<
arith_expr -> term - arith_expr
417
^
arith_expr -> term - arith_expr
417
endloop
arith_expr -> term - arith_expr
417
&
arith_expr -> term - arith_expr
417
NEWLINE
arith_expr -> term - arith_expr
417
>>
arith_expr -> term - arith_expr
417
|
arith_expr -> term - arith_expr
417
return
arith_expr -> term - arith_expr
417
and
arith_expr -> term - arith_expr
418
NEWLINE
expr -> xor_expr | expr
418
endloop
expr -> xor_expr | expr
418
<=
expr -> xor_expr | expr
418
!=
expr -> xor_expr | expr
418
==
expr -> xor_expr | expr
418
or
expr -> xor_expr | expr
418
if
expr -> xor_expr | expr
418
<
expr -> xor_expr | expr
418
loop
expr -> xor_expr | expr
418
DEDENT
expr -> xor_expr | expr
418
and
expr -> xor_expr | expr
418
return
expr -> xor_expr | expr
418
>=
expr -> xor_expr | expr
418
NAME
expr -> xor_expr | expr
418
>
expr -> xor_expr | expr
418
nextloop
expr -> xor_expr | expr
418
var
expr -> xor_expr | expr
419
)
474
420
nextloop
call -> NAME ( )
420
DEDENT
call -> NAME ( )
420
<<
call -> NAME ( )
420
//
call -> NAME ( )
420
or
call -> NAME ( )
420
>>
call -> NAME ( )
420
/
call -> NAME ( )
420
%
call -> NAME ( )
420
NAME
call -> NAME ( )
420
+
call -> NAME ( )
420
>
call -> NAME ( )
420
return
call -> NAME ( )
420
NEWLINE
call -> NAME ( )
420
if
call -> NAME ( )
420
>=
call -> NAME ( )
420
var
call -> NAME ( )
420
==
call -> NAME ( )
420
<
call -> NAME ( )
420
endloop
call -> NAME ( )
420
^
call -> NAME ( )
420
loop
call -> NAME ( )
420
-
call -> NAME ( )
420
and
call -> NAME ( )
420
**
call -> NAME ( )
420
|
call -> NAME ( )
420
<=
call -> NAME ( )
420
!=
call -> NAME ( )
420
&
call -> NAME ( )
420
*
call -> NAME ( )
421
DEDENT
shift_expr -> arith_expr >> shift_expr
421
<
shift_expr -> arith_expr >> shift_expr
421
^
shift_expr -> arith_expr >> shift_expr
421
==
shift_expr -> arith_expr >> shift_expr
421
return
shift_expr -> arith_expr >> shift_expr
421
NAME
shift_expr -> arith_expr >> shift_expr
421
endloop
shift_expr -> arith_expr >> shift_expr
421
>
shift_expr -> arith_expr >> shift_expr
421
if
shift_expr -> arith_expr >> shift_expr
421
loop
shift_expr -> arith_expr >> shift_expr
421
<=
shift_expr -> arith_expr >> shift_expr
421
|
shift_expr -> arith_expr >> shift_expr
421
var
shift_expr -> arith_expr >> shift_expr
421
and
shift_expr -> arith_expr >> shift_expr
421
NEWLINE
shift_expr -> arith_expr >> shift_expr
421
!=
shift_expr -> arith_expr >> shift_expr
421
&
shift_expr -> arith_expr >> shift_expr
421
nextloop
shift_expr -> arith_expr >> shift_expr
421
or
shift_expr -> arith_expr >> shift_expr
421
>=
shift_expr -> arith_expr >> shift_expr
422
loop
shift_expr -> arith_expr << shift_expr
422
<
shift_expr -> arith_expr << shift_expr
422
^
shift_expr -> arith_expr << shift_expr
422
or
shift_expr -> arith_expr << shift_expr
422
<=
shift_expr -> arith_expr << shift_expr
422
!=
shift_expr -> arith_expr << shift_expr
422
|
shift_expr -> arith_expr << shift_expr
422
return
shift_expr -> arith_expr << shift_expr
422
==
shift_expr -> arith_expr << shift_expr
422
NEWLINE
shift_expr -> arith_expr << shift_expr
422
endloop
shift_expr -> arith_expr << shift_expr
422
var
shift_expr -> arith_expr << shift_expr
422
>
shift_expr -> arith_expr << shift_expr
422
and
shift_expr -> arith_expr << shift_expr
422
DEDENT
shift_expr -> arith_expr << shift_expr
422
>=
shift_expr -> arith_expr << shift_expr
422
&
shift_expr -> arith_expr << shift_expr
422
nextloop
shift_expr -> arith_expr << shift_expr
422
NAME
shift_expr -> arith_expr << shift_expr
422
if
shift_expr -> arith_expr << shift_expr
423
loop
and_expr -> shift_expr & and_expr
423
DEDENT
and_expr -> shift_expr & and_expr
423
NEWLINE
and_expr -> shift_expr & and_expr
423
NAME
and_expr -> shift_expr & and_expr
423
^
and_expr -> shift_expr & and_expr
423
<
and_expr -> shift_expr & and_expr
423
==
and_expr -> shift_expr & and_expr
423
nextloop
and_expr -> shift_expr & and_expr
423
endloop
and_expr -> shift_expr & and_expr
423
and
and_expr -> shift_expr & and_expr
423
if
and_expr -> shift_expr & and_expr
423
|
and_expr -> shift_expr & and_expr
423
<=
and_expr -> shift_expr & and_expr
423
or
and_expr -> shift_expr & and_expr
423
>
and_expr -> shift_expr & and_expr
423
!=
and_expr -> shift_expr & and_expr
423
return
and_expr -> shift_expr & and_expr
423
>=
and_expr -> shift_expr & and_expr
423
var
and_expr -> shift_expr & and_expr
424
nextloop
power -> atom ** factor
424
DEDENT
power -> atom ** factor
424
var
power -> atom ** factor
424
<
power -> atom ** factor
424
return
power -> atom ** factor
424
/
power -> atom ** factor
424
*
power -> atom ** factor
424
-
power -> atom ** factor
424
<=
power -> atom ** factor
424
+
power -> atom ** factor
424
>>
power -> atom ** factor
424
if
power -> atom ** factor
424
loop
power -> atom ** factor
424
or
power -> atom ** factor
424
&
power -> atom ** factor
424
NAME
power -> atom ** factor
424
!=
power -> atom ** factor
424
//
power -> atom ** factor
424
%
power -> atom ** factor
424
NEWLINE
power -> atom ** factor
424
>
power -> atom ** factor
424
<<
power -> atom ** factor
424
|
power -> atom ** factor
424
^
power -> atom ** factor
424
endloop
power -> atom ** factor
424
==
power -> atom ** factor
424
>=
power -> atom ** factor
424
and
power -> atom ** factor
425
return
atom -> [ test_list ]
425
^
atom -> [ test_list ]
425
<
atom -> [ test_list ]
425
|
atom -> [ test_list ]
425
==
atom -> [ test_list ]
425
**
atom -> [ test_list ]
425
DEDENT
atom -> [ test_list ]
425
-
atom -> [ test_list ]
425
*
atom -> [ test_list ]
425
and
atom -> [ test_list ]
425
NAME
atom -> [ test_list ]
425
var
atom -> [ test_list ]
425
>=
atom -> [ test_list ]
425
<<
atom -> [ test_list ]
425
NEWLINE
atom -> [ test_list ]
425
/
atom -> [ test_list ]
425
!=
atom -> [ test_list ]
425
&
atom -> [ test_list ]
425
or
atom -> [ test_list ]
425
nextloop
atom -> [ test_list ]
425
if
atom -> [ test_list ]
425
+
atom -> [ test_list ]
425
//
atom -> [ test_list ]
425
>>
atom -> [ test_list ]
425
>
atom -> [ test_list ]
425
<=
atom -> [ test_list ]
425
loop
atom -> [ test_list ]
425
endloop
atom -> [ test_list ]
425
%
atom -> [ test_list ]
426
DEDENT
xor_expr -> and_expr ^ xor_expr
426
if
xor_expr -> and_expr ^ xor_expr
426
return
xor_expr -> and_expr ^ xor_expr
426
NEWLINE
xor_expr -> and_expr ^ xor_expr
426
and
xor_expr -> and_expr ^ xor_expr
426
<=
xor_expr -> and_expr ^ xor_expr
426
or
xor_expr -> and_expr ^ xor_expr
426
|
xor_expr -> and_expr ^ xor_expr
426
endloop
xor_expr -> and_expr ^ xor_expr
426
nextloop
xor_expr -> and_expr ^ xor_expr
426
==
xor_expr -> and_expr ^ xor_expr
426
loop
xor_expr -> and_expr ^ xor_expr
426
>
xor_expr -> and_expr ^ xor_expr
426
<
xor_expr -> and_expr ^ xor_expr
426
!=
xor_expr -> and_expr ^ xor_expr
426
>=
xor_expr -> and_expr ^ xor_expr
426
NAME
xor_expr -> and_expr ^ xor_expr
426
var
xor_expr -> and_expr ^ xor_expr
427
loop
and_test -> not_test and and_test
427
or
and_test -> not_test and and_test
427
NEWLINE
and_test -> not_test and and_test
427
if
and_test -> not_test and and_test
427
var
and_test -> not_test and and_test
427
return
and_test -> not_test and and_test
427
DEDENT
and_test -> not_test and and_test
427
NAME
and_test -> not_test and and_test
427
nextloop
and_test -> not_test and and_test
427
endloop
and_test -> not_test and and_test
428
loop
or_test -> and_test or or_test
428
endloop
or_test -> and_test or or_test
428
NAME
or_test -> and_test or or_test
428
if
or_test -> and_test or or_test
428
NEWLINE
or_test -> and_test or or_test
428
return
or_test -> and_test or or_test
428
nextloop
or_test -> and_test or or_test
428
DEDENT
or_test -> and_test or or_test
428
var
or_test -> and_test or or_test
429
+
term -> factor % term
429
>=
term -> factor % term
429
!=
term -> factor % term
429
^
term -> factor % term
429
or
term -> factor % term
429
<<
term -> factor % term
429
and
term -> factor % term
429
==
term -> factor % term
429
:
term -> factor % term
429
>
term -> factor % term
429
|
term -> factor % term
429
&
term -> factor % term
429
-
term -> factor % term
429
>>
term -> factor % term
429
<
term -> factor % term
429
<=
term -> factor % term
430
|
term -> factor / term
430
or
term -> factor / term
430
and
term -> factor / term
430
<=
term -> factor / term
430
<<
term -> factor / term
430
^
term -> factor / term
430
-
term -> factor / term
430
>>
term -> factor / term
430
==
term -> factor / term
430
>
term -> factor / term
430
>=
term -> factor / term
430
:
term -> factor / term
430
<
term -> factor / term
430
+
term -> factor / term
430
&
term -> factor / term
430
!=
term -> factor / term
431
&
term -> factor // term
431
>=
term -> factor // term
431
+
term -> factor // term
431
<<
term -> factor // term
431
!=
term -> factor // term
431
<=
term -> factor // term
431
:
term -> factor // term
431
|
term -> factor // term
431
and
term -> factor // term
431
>>
term -> factor // term
431
^
term -> factor // term
431
<
term -> factor // term
431
-
term -> factor // term
431
>
term -> factor // term
431
==
term -> factor // term
431
or
term -> factor // term
432
>>
term -> factor * term
432
>=
term -> factor * term
432
-
term -> factor * term
432
and
term -> factor * term
432
|
term -> factor * term
432
<=
term -> factor * term
432
or
term -> factor * term
432
+
term -> factor * term
432
<
term -> factor * term
432
>
term -> factor * term
432
^
term -> factor * term
432
:
term -> factor * term
432
==
term -> factor * term
432
<<
term -> factor * term
432
&
term -> factor * term
432
!=
term -> factor * term
433
|
arith_expr -> term + arith_expr
433
!=
arith_expr -> term + arith_expr
433
>
arith_expr -> term + arith_expr
433
>=
arith_expr -> term + arith_expr
433
&
arith_expr -> term + arith_expr
433
==
arith_expr -> term + arith_expr
433
<=
arith_expr -> term + arith_expr
433
<
arith_expr -> term + arith_expr
433
<<
arith_expr -> term + arith_expr
433
and
arith_expr -> term + arith_expr
433
>>
arith_expr -> term + arith_expr
433
:
arith_expr -> term + arith_expr
433
^
arith_expr -> term + arith_expr
433
or
arith_expr -> term + arith_expr
434
or
arith_expr -> term - arith_expr
434
<=
arith_expr -> term - arith_expr
434
>=
arith_expr -> term - arith_expr
434
==
arith_expr -> term - arith_expr
434
:
arith_expr -> term - arith_expr
434
>>
arith_expr -> term - arith_expr
434
|
arith_expr -> term - arith_expr
434
<<
arith_expr -> term - arith_expr
434
<
arith_expr -> term - arith_expr
434
!=
arith_expr -> term - arith_expr
434
>
arith_expr -> term - arith_expr
434
^
arith_expr -> term - arith_expr
434
&
arith_expr -> term - arith_expr
434
and
arith_expr -> term - arith_expr
435
==
expr -> xor_expr | expr
435
!=
expr -> xor_expr | expr
435
<=
expr -> xor_expr | expr
435
or
expr -> xor_expr | expr
435
and
expr -> xor_expr | expr
435
>=
expr -> xor_expr | expr
435
:
expr -> xor_expr | expr
435
>
expr -> xor_expr | expr
435
<
expr -> xor_expr | expr
436
<<
call -> NAME ( )
436
//
call -> NAME ( )
436
or
call -> NAME ( )
436
:
call -> NAME ( )
436
>>
call -> NAME ( )
436
/
call -> NAME ( )
436
%
call -> NAME ( )
436
+
call -> NAME ( )
436
>
call -> NAME ( )
436
>=
call -> NAME ( )
436
==
call -> NAME ( )
436
<
call -> NAME ( )
436
^
call -> NAME ( )
436
-
call -> NAME ( )
436
and
call -> NAME ( )
436
**
call -> NAME ( )
436
|
call -> NAME ( )
436
<=
call -> NAME ( )
436
!=
call -> NAME ( )
436
&
call -> NAME ( )
436
*
call -> NAME ( )
437
)
475
438
>
shift_expr -> arith_expr >> shift_expr
438
&
shift_expr -> arith_expr >> shift_expr
438
or
shift_expr -> arith_expr >> shift_expr
438
<
shift_expr -> arith_expr >> shift_expr
438
>=
shift_expr -> arith_expr >> shift_expr
438
<=
shift_expr -> arith_expr >> shift_expr
438
^
shift_expr -> arith_expr >> shift_expr
438
|
shift_expr -> arith_expr >> shift_expr
438
!=
shift_expr -> arith_expr >> shift_expr
438
==
shift_expr -> arith_expr >> shift_expr
438
:
shift_expr -> arith_expr >> shift_expr
438
and
shift_expr -> arith_expr >> shift_expr
439
|
shift_expr -> arith_expr << shift_expr
439
==
shift_expr -> arith_expr << shift_expr
439
>
shift_expr -> arith_expr << shift_expr
439
and
shift_expr -> arith_expr << shift_expr
439
<=
shift_expr -> arith_expr << shift_expr
439
!=
shift_expr -> arith_expr << shift_expr
439
>=
shift_expr -> arith_expr << shift_expr
439
&
shift_expr -> arith_expr << shift_expr
439
<
shift_expr -> arith_expr << shift_expr
439
:
shift_expr -> arith_expr << shift_expr
439
^
shift_expr -> arith_expr << shift_expr
439
or
shift_expr -> arith_expr << shift_expr
440
<
power -> atom ** factor
440
/
power -> atom ** factor
440
*
power -> atom ** factor
440
-
power -> atom ** factor
440
<=
power -> atom ** factor
440
+
power -> atom ** factor
440
>>
power -> atom ** factor
440
or
power -> atom ** factor
440
&
power -> atom ** factor
440
!=
power -> atom ** factor
440
//
power -> atom ** factor
440
%
power -> atom ** factor
440
>
power -> atom ** factor
440
:
power -> atom ** factor
440
<<
power -> atom ** factor
440
|
power -> atom ** factor
440
^
power -> atom ** factor
440
==
power -> atom ** factor
440
>=
power -> atom ** factor
440
and
power -> atom ** factor
441
<=
and_expr -> shift_expr & and_expr
441
^
and_expr -> shift_expr & and_expr
441
>=
and_expr -> shift_expr & and_expr
441
<
and_expr -> shift_expr & and_expr
441
==
and_expr -> shift_expr & and_expr
441
or
and_expr -> shift_expr & and_expr
441
:
and_expr -> shift_expr & and_expr
441
>
and_expr -> shift_expr & and_expr
441
and
and_expr -> shift_expr & and_expr
441
|
and_expr -> shift_expr & and_expr
441
!=
and_expr -> shift_expr & and_expr
442
^
atom -> [ test_list ]
442
<
atom -> [ test_list ]
442
|
atom -> [ test_list ]
442
==
atom -> [ test_list ]
442
**
atom -> [ test_list ]
442
-
atom -> [ test_list ]
442
*
atom -> [ test_list ]
442
and
atom -> [ test_list ]
442
>=
atom -> [ test_list ]
442
<<
atom -> [ test_list ]
442
/
atom -> [ test_list ]
442
!=
atom -> [ test_list ]
442
&
atom -> [ test_list ]
442
or
atom -> [ test_list ]
442
:
atom -> [ test_list ]
442
+
atom -> [ test_list ]
442
//
atom -> [ test_list ]
442
>>
atom -> [ test_list ]
442
>
atom -> [ test_list ]
442
<=
atom -> [ test_list ]
442
%
atom -> [ test_list ]
443
<=
xor_expr -> and_expr ^ xor_expr
443
or
xor_expr -> and_expr ^ xor_expr
443
|
xor_expr -> and_expr ^ xor_expr
443
:
xor_expr -> and_expr ^ xor_expr
443
==
xor_expr -> and_expr ^ xor_expr
443
>
xor_expr -> and_expr ^ xor_expr
443
<
xor_expr -> and_expr ^ xor_expr
443
!=
xor_expr -> and_expr ^ xor_expr
443
>=
xor_expr -> and_expr ^ xor_expr
443
and
xor_expr -> and_expr ^ xor_expr
444
:
or_test -> and_test or or_test
445
and
comparison -> expr comp_op comparison
445
:
comparison -> expr comp_op comparison
445
or
comparison -> expr comp_op comparison
446
NAME
if_stmt -> if test : suite
446
NEWLINE
if_stmt -> if test : suite
446
var
if_stmt -> if test : suite
446
else
476
446
nextloop
if_stmt -> if test : suite
446
endloop
if_stmt -> if test : suite
446
DEDENT
if_stmt -> if test : suite
446
if
if_stmt -> if test : suite
446
return
if_stmt -> if test : suite
446
loop
if_stmt -> if test : suite
447
INDENT
477
448
or
and_test -> not_test and and_test
448
:
and_test -> not_test and and_test
449
if
decl_stmt -> var NAME = test
449
NEWLINE
decl_stmt -> var NAME = test
449
var
decl_stmt -> var NAME = test
449
NAME
decl_stmt -> var NAME = test
449
loop
decl_stmt -> var NAME = test
449
endloop
decl_stmt -> var NAME = test
449
DEDENT
decl_stmt -> var NAME = test
449
nextloop
decl_stmt -> var NAME = test
449
return
decl_stmt -> var NAME = test
450
call
383
450
factor
384
450
None
386
450
power
403
450
NAME
388
450
+
390
450
-
396
450
STRING
391
450
atom
392
450
True
394
450
[
395
450
False
404
450
NUMBER
397
450
~
398
450
term
478
451
call
383
451
factor
384
451
term
479
451
None
386
451
power
403
451
NAME
388
451
+
390
451
-
396
451
STRING
391
451
atom
392
451
True
394
451
[
395
451
False
404
451
NUMBER
397
451
~
398
452
call
383
452
factor
384
452
None
386
452
power
403
452
NAME
388
452
+
390
452
-
396
452
STRING
391
452
atom
392
452
True
394
452
[
395
452
False
404
452
NUMBER
397
452
~
398
452
term
480
453
term
481
453
call
383
453
factor
384
453
None
386
453
power
403
453
NAME
388
453
+
390
453
-
396
453
STRING
391
453
atom
392
453
True
394
453
[
395
453
False
404
453
NUMBER
397
453
~
398
454
call
383
454
factor
384
454
term
385
454
None
386
454
power
403
454
NAME
388
454
+
390
454
-
396
454
STRING
391
454
atom
392
454
arith_expr
482
454
True
394
454
[
395
454
False
404
454
NUMBER
397
454
~
398
455
call
383
455
factor
384
455
term
385
455
None
386
455
power
403
455
NAME
388
455
+
390
455
-
396
455
STRING
391
455
atom
392
455
True
394
455
[
395
455
arith_expr
483
455
False
404
455
NUMBER
397
455
~
398
456
call
383
456
factor
384
456
term
385
456
None
386
456
xor_expr
387
456
power
403
456
NAME
388
456
arith_expr
389
456
+
390
456
-
396
456
STRING
391
456
atom
392
456
shift_expr
393
456
True
394
456
[
395
456
and_expr
405
456
False
404
456
NUMBER
397
456
~
398
456
expr
484
457
call
128
457
factor
129
457
term
130
457
None
131
457
xor_expr
132
457
NAME
133
457
arith_expr
134
457
+
135
457
STRING
136
457
atom
137
457
shift_expr
138
457
True
139
457
[
140
457
-
141
457
not_test
142
457
expr
143
457
~
144
457
comparison
145
457
power
146
457
NUMBER
147
457
False
148
457
and_expr
149
457
not
150
457
)
485
457
test_list
486
457
and_test
153
457
or_test
154
457
test
155
458
call
383
458
factor
384
458
term
385
458
None
386
458
power
403
458
NAME
388
458
arith_expr
389
458
+
390
458
-
396
458
shift_expr
487
458
STRING
391
458
atom
392
458
True
394
458
[
395
458
False
404
458
NUMBER
397
458
~
398
459
call
383
459
factor
384
459
term
385
459
None
386
459
power
403
459
NAME
388
459
arith_expr
389
459
+
390
459
-
396
459
STRING
391
459
atom
392
459
True
394
459
[
395
459
False
404
459
NUMBER
397
459
~
398
459
shift_expr
488
460
>=
factor -> + factor
460
<=
factor -> + factor
460
*
factor -> + factor
460
==
factor -> + factor
460
>
factor -> + factor
460
!=
factor -> + factor
460
-
factor -> + factor
460
to
factor -> + factor
460
and
factor -> + factor
460
//
factor -> + factor
460
%
factor -> + factor
460
/
factor -> + factor
460
<<
factor -> + factor
460
+
factor -> + factor
460
^
factor -> + factor
460
or
factor -> + factor
460
:
factor -> + factor
460
&
factor -> + factor
460
|
factor -> + factor
460
>>
factor -> + factor
460
<
factor -> + factor
461
call
383
461
factor
489
461
None
386
461
power
403
461
NAME
388
461
+
390
461
-
396
461
STRING
391
461
atom
392
461
True
394
461
[
395
461
False
404
461
NUMBER
397
461
~
398
462
and_expr
490
462
call
383
462
factor
384
462
term
385
462
None
386
462
power
403
462
NAME
388
462
arith_expr
389
462
+
390
462
-
396
462
STRING
391
462
atom
392
462
shift_expr
393
462
True
394
462
[
395
462
False
404
462
NUMBER
397
462
~
398
463
]
491
464
or
factor -> - factor
464
*
factor -> - factor
464
&
factor -> - factor
464
>=
factor -> - factor
464
:
factor -> - factor
464
and
factor -> - factor
464
>>
factor -> - factor
464
>
factor -> - factor
464
+
factor -> - factor
464
%
factor -> - factor
464
//
factor -> - factor
464
<=
factor -> - factor
464
==
factor -> - factor
464
/
factor -> - factor
464
-
factor -> - factor
464
<<
factor -> - factor
464
!=
factor -> - factor
464
^
factor -> - factor
464
|
factor -> - factor
464
<
factor -> - factor
464
to
factor -> - factor
465
and
factor -> ~ factor
465
/
factor -> ~ factor
465
>>
factor -> ~ factor
465
<=
factor -> ~ factor
465
-
factor -> ~ factor
465
!=
factor -> ~ factor
465
==
factor -> ~ factor
465
to
factor -> ~ factor
465
^
factor -> ~ factor
465
or
factor -> ~ factor
465
>=
factor -> ~ factor
465
>
factor -> ~ factor
465
<
factor -> ~ factor
465
:
factor -> ~ factor
465
+
factor -> ~ factor
465
<<
factor -> ~ factor
465
|
factor -> ~ factor
465
&
factor -> ~ factor
465
*
factor -> ~ factor
465
%
factor -> ~ factor
465
//
factor -> ~ factor
466
call
383
466
factor
384
466
term
385
466
None
386
466
xor_expr
387
466
power
403
466
NAME
388
466
arith_expr
389
466
+
390
466
-
396
466
STRING
391
466
atom
392
466
shift_expr
393
466
True
394
466
[
395
466
and_expr
405
466
False
404
466
and_test
399
466
NUMBER
397
466
~
398
466
not_test
407
466
expr
400
466
comparison
402
466
or_test
492
466
not
408
467
call
383
467
factor
384
467
term
385
467
None
386
467
xor_expr
387
467
power
403
467
NAME
388
467
arith_expr
389
467
+
390
467
-
396
467
STRING
391
467
atom
392
467
shift_expr
393
467
True
394
467
[
395
467
and_expr
405
467
False
404
467
NUMBER
397
467
~
398
467
expr
400
467
comparison
493
468
call
494
468
or_test
495
468
factor
496
468
term
497
468
None
498
468
xor_expr
499
468
NAME
500
468
arith_expr
501
468
+
502
468
STRING
503
468
atom
504
468
shift_expr
505
468
True
506
468
[
507
468
-
508
468
NUMBER
509
468
~
510
468
expr
511
468
comparison
512
468
power
513
468
False
514
468
and_expr
515
468
test
516
468
and_test
517
468
not_test
518
468
not
519
469
suite
520
469
NEWLINE
333
470
call
383
470
factor
384
470
term
385
470
None
386
470
power
403
470
NAME
388
470
arith_expr
389
470
+
390
470
-
396
470
STRING
391
470
atom
392
470
shift_expr
393
470
True
394
470
[
395
470
and_expr
405
470
False
404
470
xor_expr
521
470
NUMBER
397
470
~
398
471
call
383
471
factor
384
471
term
385
471
None
386
471
xor_expr
387
471
power
403
471
NAME
388
471
arith_expr
389
471
+
390
471
-
396
471
STRING
391
471
atom
392
471
shift_expr
393
471
True
394
471
[
395
471
and_expr
405
471
False
404
471
NUMBER
397
471
~
398
471
not_test
407
471
expr
400
471
comparison
402
471
and_test
522
471
not
408
472
or
not_test -> not not_test
472
:
not_test -> not not_test
472
to
not_test -> not not_test
472
and
not_test -> not not_test
473
DEDENT
523
474
!=
call -> NAME ( test_list )
474
//
call -> NAME ( test_list )
474
loop
call -> NAME ( test_list )
474
or
call -> NAME ( test_list )
474
<<
call -> NAME ( test_list )
474
DEDENT
call -> NAME ( test_list )
474
NEWLINE
call -> NAME ( test_list )
474
-
call -> NAME ( test_list )
474
endloop
call -> NAME ( test_list )
474
>
call -> NAME ( test_list )
474
+
call -> NAME ( test_list )
474
<
call -> NAME ( test_list )
474
return
call -> NAME ( test_list )
474
NAME
call -> NAME ( test_list )
474
>=
call -> NAME ( test_list )
474
and
call -> NAME ( test_list )
474
/
call -> NAME ( test_list )
474
|
call -> NAME ( test_list )
474
&
call -> NAME ( test_list )
474
==
call -> NAME ( test_list )
474
if
call -> NAME ( test_list )
474
*
call -> NAME ( test_list )
474
>>
call -> NAME ( test_list )
474
**
call -> NAME ( test_list )
474
nextloop
call -> NAME ( test_list )
474
^
call -> NAME ( test_list )
474
var
call -> NAME ( test_list )
474
<=
call -> NAME ( test_list )
474
%
call -> NAME ( test_list )
475
!=
call -> NAME ( test_list )
475
//
call -> NAME ( test_list )
475
or
call -> NAME ( test_list )
475
<<
call -> NAME ( test_list )
475
:
call -> NAME ( test_list )
475
-
call -> NAME ( test_list )
475
>
call -> NAME ( test_list )
475
+
call -> NAME ( test_list )
475
<
call -> NAME ( test_list )
475
>=
call -> NAME ( test_list )
475
and
call -> NAME ( test_list )
475
/
call -> NAME ( test_list )
475
|
call -> NAME ( test_list )
475
&
call -> NAME ( test_list )
475
==
call -> NAME ( test_list )
475
*
call -> NAME ( test_list )
475
>>
call -> NAME ( test_list )
475
**
call -> NAME ( test_list )
475
^
call -> NAME ( test_list )
475
<=
call -> NAME ( test_list )
475
%
call -> NAME ( test_list )
476
:
524
477
loop
254
477
NAME
255
477
nextloop
256
477
flow_stmt
257
477
return
258
477
loop_stmt
259
477
stmt_list
525
477
if
261
477
return_stmt
262
477
NEWLINE
263
477
endloop
264
477
var
265
477
DEDENT
stmt_list -> 
477
assign_stmt
266
477
call
267
477
if_stmt
268
477
decl_stmt
269
477
stmt
270
478
+
term -> factor % term
478
>=
term -> factor % term
478
!=
term -> factor % term
478
^
term -> factor % term
478
or
term -> factor % term
478
to
term -> factor % term
478
<<
term -> factor % term
478
and
term -> factor % term
478
==
term -> factor % term
478
:
term -> factor % term
478
>
term -> factor % term
478
|
term -> factor % term
478
&
term -> factor % term
478
-
term -> factor % term
478
>>
term -> factor % term
478
<
term -> factor % term
478
<=
term -> factor % term
479
|
term -> factor / term
479
or
term -> factor / term
479
and
term -> factor / term
479
<=
term -> factor / term
479
<<
term -> factor / term
479
^
term -> factor / term
479
-
term -> factor / term
479
&
term -> factor / term
479
>>
term -> factor / term
479
==
term -> factor / term
479
>
term -> factor / term
479
>=
term -> factor / term
479
:
term -> factor / term
479
<
term -> factor / term
479
+
term -> factor / term
479
to
term -> factor / term
479
!=
term -> factor / term
480
&
term -> factor // term
480
>=
term -> factor // term
480
+
term -> factor // term
480
<<
term -> factor // term
480
!=
term -> factor // term
480
<=
term -> factor // term
480
:
term -> factor // term
480
to
term -> factor // term
480
|
term -> factor // term
480
and
term -> factor // term
480
>>
term -> factor // term
480
^
term -> factor // term
480
<
term -> factor // term
480
-
term -> factor // term
480
>
term -> factor // term
480
==
term -> factor // term
480
or
term -> factor // term
481
>>
term -> factor * term
481
>=
term -> factor * term
481
-
term -> factor * term
481
to
term -> factor * term
481
and
term -> factor * term
481
|
term -> factor * term
481
<=
term -> factor * term
481
or
term -> factor * term
481
+
term -> factor * term
481
<
term -> factor * term
481
>
term -> factor * term
481
^
term -> factor * term
481
:
term -> factor * term
481
==
term -> factor * term
481
<<
term -> factor * term
481
&
term -> factor * term
481
!=
term -> factor * term
482
|
arith_expr -> term + arith_expr
482
!=
arith_expr -> term + arith_expr
482
>
arith_expr -> term + arith_expr
482
>=
arith_expr -> term + arith_expr
482
&
arith_expr -> term + arith_expr
482
to
arith_expr -> term + arith_expr
482
==
arith_expr -> term + arith_expr
482
<=
arith_expr -> term + arith_expr
482
<
arith_expr -> term + arith_expr
482
<<
arith_expr -> term + arith_expr
482
and
arith_expr -> term + arith_expr
482
>>
arith_expr -> term + arith_expr
482
:
arith_expr -> term + arith_expr
482
^
arith_expr -> term + arith_expr
482
or
arith_expr -> term + arith_expr
483
or
arith_expr -> term - arith_expr
483
<=
arith_expr -> term - arith_expr
483
>=
arith_expr -> term - arith_expr
483
==
arith_expr -> term - arith_expr
483
:
arith_expr -> term - arith_expr
483
>>
arith_expr -> term - arith_expr
483
|
arith_expr -> term - arith_expr
483
<<
arith_expr -> term - arith_expr
483
<
arith_expr -> term - arith_expr
483
!=
arith_expr -> term - arith_expr
483
>
arith_expr -> term - arith_expr
483
to
arith_expr -> term - arith_expr
483
^
arith_expr -> term - arith_expr
483
&
arith_expr -> term - arith_expr
483
and
arith_expr -> term - arith_expr
484
==
expr -> xor_expr | expr
484
!=
expr -> xor_expr | expr
484
<=
expr -> xor_expr | expr
484
or
expr -> xor_expr | expr
484
and
expr -> xor_expr | expr
484
to
expr -> xor_expr | expr
484
>=
expr -> xor_expr | expr
484
:
expr -> xor_expr | expr
484
>
expr -> xor_expr | expr
484
<
expr -> xor_expr | expr
485
<<
call -> NAME ( )
485
//
call -> NAME ( )
485
or
call -> NAME ( )
485
:
call -> NAME ( )
485
>>
call -> NAME ( )
485
/
call -> NAME ( )
485
%
call -> NAME ( )
485
+
call -> NAME ( )
485
>
call -> NAME ( )
485
>=
call -> NAME ( )
485
==
call -> NAME ( )
485
<
call -> NAME ( )
485
^
call -> NAME ( )
485
-
call -> NAME ( )
485
and
call -> NAME ( )
485
**
call -> NAME ( )
485
|
call -> NAME ( )
485
to
call -> NAME ( )
485
<=
call -> NAME ( )
485
!=
call -> NAME ( )
485
&
call -> NAME ( )
485
*
call -> NAME ( )
486
)
526
487
>
shift_expr -> arith_expr >> shift_expr
487
&
shift_expr -> arith_expr >> shift_expr
487
or
shift_expr -> arith_expr >> shift_expr
487
<
shift_expr -> arith_expr >> shift_expr
487
>=
shift_expr -> arith_expr >> shift_expr
487
<=
shift_expr -> arith_expr >> shift_expr
487
^
shift_expr -> arith_expr >> shift_expr
487
|
shift_expr -> arith_expr >> shift_expr
487
!=
shift_expr -> arith_expr >> shift_expr
487
==
shift_expr -> arith_expr >> shift_expr
487
:
shift_expr -> arith_expr >> shift_expr
487
to
shift_expr -> arith_expr >> shift_expr
487
and
shift_expr -> arith_expr >> shift_expr
488
|
shift_expr -> arith_expr << shift_expr
488
==
shift_expr -> arith_expr << shift_expr
488
>
shift_expr -> arith_expr << shift_expr
488
and
shift_expr -> arith_expr << shift_expr
488
to
shift_expr -> arith_expr << shift_expr
488
<=
shift_expr -> arith_expr << shift_expr
488
!=
shift_expr -> arith_expr << shift_expr
488
>=
shift_expr -> arith_expr << shift_expr
488
&
shift_expr -> arith_expr << shift_expr
488
<
shift_expr -> arith_expr << shift_expr
488
:
shift_expr -> arith_expr << shift_expr
488
^
shift_expr -> arith_expr << shift_expr
488
or
shift_expr -> arith_expr << shift_expr
489
<
power -> atom ** factor
489
/
power -> atom ** factor
489
*
power -> atom ** factor
489
-
power -> atom ** factor
489
to
power -> atom ** factor
489
<=
power -> atom ** factor
489
+
power -> atom ** factor
489
>>
power -> atom ** factor
489
or
power -> atom ** factor
489
&
power -> atom ** factor
489
!=
power -> atom ** factor
489
//
power -> atom ** factor
489
%
power -> atom ** factor
489
>
power -> atom ** factor
489
:
power -> atom ** factor
489
<<
power -> atom ** factor
489
|
power -> atom ** factor
489
^
power -> atom ** factor
489
==
power -> atom ** factor
489
>=
power -> atom ** factor
489
and
power -> atom ** factor
490
to
and_expr -> shift_expr & and_expr
490
<=
and_expr -> shift_expr & and_expr
490
^
and_expr -> shift_expr & and_expr
490
>=
and_expr -> shift_expr & and_expr
490
<
and_expr -> shift_expr & and_expr
490
==
and_expr -> shift_expr & and_expr
490
or
and_expr -> shift_expr & and_expr
490
:
and_expr -> shift_expr & and_expr
490
>
and_expr -> shift_expr & and_expr
490
and
and_expr -> shift_expr & and_expr
490
|
and_expr -> shift_expr & and_expr
490
!=
and_expr -> shift_expr & and_expr
491
^
atom -> [ test_list ]
491
<
atom -> [ test_list ]
491
|
atom -> [ test_list ]
491
==
atom -> [ test_list ]
491
**
atom -> [ test_list ]
491
-
atom -> [ test_list ]
491
*
atom -> [ test_list ]
491
and
atom -> [ test_list ]
491
>=
atom -> [ test_list ]
491
<<
atom -> [ test_list ]
491
/
atom -> [ test_list ]
491
!=
atom -> [ test_list ]
491
&
atom -> [ test_list ]
491
or
atom -> [ test_list ]
491
:
atom -> [ test_list ]
491
+
atom -> [ test_list ]
491
//
atom -> [ test_list ]
491
>>
atom -> [ test_list ]
491
>
atom -> [ test_list ]
491
<=
atom -> [ test_list ]
491
%
atom -> [ test_list ]
491
to
atom -> [ test_list ]
492
:
or_test -> and_test or or_test
492
to
or_test -> and_test or or_test
493
and
comparison -> expr comp_op comparison
493
to
comparison -> expr comp_op comparison
493
:
comparison -> expr comp_op comparison
493
or
comparison -> expr comp_op comparison
494
%
atom -> call
494
&
atom -> call
494
-
atom -> call
494
:
atom -> call
494
<
atom -> call
494
and
atom -> call
494
>
atom -> call
494
>=
atom -> call
494
<=
atom -> call
494
//
atom -> call
494
<<
atom -> call
494
or
atom -> call
494
/
atom -> call
494
by
atom -> call
494
|
atom -> call
494
*
atom -> call
494
+
atom -> call
494
>>
atom -> call
494
!=
atom -> call
494
**
atom -> call
494
==
atom -> call
494
^
atom -> call
495
:
test -> or_test
495
by
test -> or_test
496
%
527
496
>>
term -> factor
496
by
term -> factor
496
/
528
496
//
529
496
*
530
496
<<
term -> factor
496
:
term -> factor
496
==
term -> factor
496
<=
term -> factor
496
+
term -> factor
496
>=
term -> factor
496
&
term -> factor
496
>
term -> factor
496
<
term -> factor
496
!=
term -> factor
496
or
term -> factor
496
|
term -> factor
496
^
term -> factor
496
and
term -> factor
496
-
term -> factor
497
+
531
497
-
532
497
<
arith_expr -> term
497
<=
arith_expr -> term
497
==
arith_expr -> term
497
and
arith_expr -> term
497
:
arith_expr -> term
497
>
arith_expr -> term
497
>>
arith_expr -> term
497
^
arith_expr -> term
497
|
arith_expr -> term
497
by
arith_expr -> term
497
>=
arith_expr -> term
497
<<
arith_expr -> term
497
or
arith_expr -> term
497
!=
arith_expr -> term
497
&
arith_expr -> term
498
<
atom -> None
498
<<
atom -> None
498
!=
atom -> None
498
<=
atom -> None
498
%
atom -> None
498
&
atom -> None
498
*
atom -> None
498
-
atom -> None
498
>
atom -> None
498
and
atom -> None
498
^
atom -> None
498
>=
atom -> None
498
**
atom -> None
498
|
atom -> None
498
:
atom -> None
498
>>
atom -> None
498
/
atom -> None
498
//
atom -> None
498
==
atom -> None
498
by
atom -> None
498
+
atom -> None
498
or
atom -> None
499
|
533
499
:
expr -> xor_expr
499
!=
expr -> xor_expr
499
==
expr -> xor_expr
499
<
expr -> xor_expr
499
by
expr -> xor_expr
499
>
expr -> xor_expr
499
<=
expr -> xor_expr
499
and
expr -> xor_expr
499
>=
expr -> xor_expr
499
or
expr -> xor_expr
500
&
atom -> NAME
500
(
534
500
%
atom -> NAME
500
by
atom -> NAME
500
>>
atom -> NAME
500
^
atom -> NAME
500
>
atom -> NAME
500
<<
atom -> NAME
500
and
atom -> NAME
500
or
atom -> NAME
500
<
atom -> NAME
500
**
atom -> NAME
500
|
atom -> NAME
500
<=
atom -> NAME
500
==
atom -> NAME
500
/
atom -> NAME
500
:
atom -> NAME
500
>=
atom -> NAME
500
!=
atom -> NAME
500
+
atom -> NAME
500
*
atom -> NAME
500
-
atom -> NAME
500
//
atom -> NAME
501
>>
535
501
==
shift_expr -> arith_expr
501
^
shift_expr -> arith_expr
501
<<
536
501
>=
shift_expr -> arith_expr
501
<=
shift_expr -> arith_expr
501
:
shift_expr -> arith_expr
501
or
shift_expr -> arith_expr
501
|
shift_expr -> arith_expr
501
>
shift_expr -> arith_expr
501
!=
shift_expr -> arith_expr
501
<
shift_expr -> arith_expr
501
and
shift_expr -> arith_expr
501
by
shift_expr -> arith_expr
501
&
shift_expr -> arith_expr
502
call
494
502
None
498
502
power
513
502
NAME
500
502
+
502
502
-
508
502
STRING
503
502
atom
504
502
True
506
502
[
507
502
False
514
502
NUMBER
509
502
~
510
502
factor
537
503
!=
atom -> STRING
503
<<
atom -> STRING
503
//
atom -> STRING
503
/
atom -> STRING
503
<
atom -> STRING
503
==
atom -> STRING
503
by
atom -> STRING
503
|
atom -> STRING
503
>=
atom -> STRING
503
^
atom -> STRING
503
>>
atom -> STRING
503
<=
atom -> STRING
503
*
atom -> STRING
503
>
atom -> STRING
503
%
atom -> STRING
503
-
atom -> STRING
503
**
atom -> STRING
503
+
atom -> STRING
503
and
atom -> STRING
503
:
atom -> STRING
503
or
atom -> STRING
503
&
atom -> STRING
504
<=
power -> atom
504
>
power -> atom
504
**
538
504
|
power -> atom
504
//
power -> atom
504
>>
power -> atom
504
-
power -> atom
504
and
power -> atom
504
>=
power -> atom
504
!=
power -> atom
504
/
power -> atom
504
:
power -> atom
504
<<
power -> atom
504
&
power -> atom
504
%
power -> atom
504
by
power -> atom
504
^
power -> atom
504
+
power -> atom
504
or
power -> atom
504
*
power -> atom
504
==
power -> atom
504
<
power -> atom
505
&
539
505
:
and_expr -> shift_expr
505
and
and_expr -> shift_expr
505
<
and_expr -> shift_expr
505
^
and_expr -> shift_expr
505
>
and_expr -> shift_expr
505
==
and_expr -> shift_expr
505
by
and_expr -> shift_expr
505
|
and_expr -> shift_expr
505
!=
and_expr -> shift_expr
505
<=
and_expr -> shift_expr
505
or
and_expr -> shift_expr
505
>=
and_expr -> shift_expr
506
>=
atom -> True
506
|
atom -> True
506
//
atom -> True
506
<
atom -> True
506
:
atom -> True
506
==
atom -> True
506
-
atom -> True
506
<<
atom -> True
506
/
atom -> True
506
or
atom -> True
506
!=
atom -> True
506
**
atom -> True
506
^
atom -> True
506
&
atom -> True
506
*
atom -> True
506
%
atom -> True
506
<=
atom -> True
506
>
atom -> True
506
+
atom -> True
506
by
atom -> True
506
and
atom -> True
506
>>
atom -> True
507
call
79
507
factor
80
507
term
81
507
None
82
507
or_test
83
507
xor_expr
84
507
NAME
85
507
arith_expr
86
507
+
87
507
STRING
88
507
atom
89
507
shift_expr
90
507
True
91
507
[
92
507
test_list
540
507
-
94
507
expr
95
507
~
96
507
not_test
97
507
comparison
98
507
power
99
507
NUMBER
100
507
False
101
507
and_expr
102
507
and_test
103
507
not
104
507
test
105
508
call
494
508
None
498
508
power
513
508
NAME
500
508
+
502
508
-
508
508
factor
541
508
STRING
503
508
atom
504
508
True
506
508
[
507
508
False
514
508
NUMBER
509
508
~
510
509
/
atom -> NUMBER
509
or
atom -> NUMBER
509
>>
atom -> NUMBER
509
*
atom -> NUMBER
509
<=
atom -> NUMBER
509
+
atom -> NUMBER
509
and
atom -> NUMBER
509
:
atom -> NUMBER
509
-
atom -> NUMBER
509
==
atom -> NUMBER
509
<
atom -> NUMBER
509
%
atom -> NUMBER
509
//
atom -> NUMBER
509
>=
atom -> NUMBER
509
>
atom -> NUMBER
509
!=
atom -> NUMBER
509
**
atom -> NUMBER
509
&
atom -> NUMBER
509
^
atom -> NUMBER
509
<<
atom -> NUMBER
509
by
atom -> NUMBER
509
|
atom -> NUMBER
510
call
494
510
None
498
510
power
513
510
NAME
500
510
+
502
510
-
508
510
factor
542
510
STRING
503
510
atom
504
510
True
506
510
[
507
510
False
514
510
NUMBER
509
510
~
510
511
>
106
511
>=
107
511
by
comparison -> expr
511
<
108
511
!=
109
511
==
110
511
and
comparison -> expr
511
<=
111
511
comp_op
543
511
:
comparison -> expr
511
or
comparison -> expr
512
or
not_test -> comparison
512
:
not_test -> comparison
512
by
not_test -> comparison
512
and
not_test -> comparison
513
//
factor -> power
513
<<
factor -> power
513
<
factor -> power
513
!=
factor -> power
513
<=
factor -> power
513
|
factor -> power
513
-
factor -> power
513
>=
factor -> power
513
/
factor -> power
513
:
factor -> power
513
>>
factor -> power
513
*
factor -> power
513
==
factor -> power
513
&
factor -> power
513
^
factor -> power
513
+
factor -> power
513
and
factor -> power
513
by
factor -> power
513
>
factor -> power
513
or
factor -> power
513
%
factor -> power
514
and
atom -> False
514
/
atom -> False
514
*
atom -> False
514
-
atom -> False
514
**
atom -> False
514
:
atom -> False
514
<<
atom -> False
514
>
atom -> False
514
>>
atom -> False
514
==
atom -> False
514
|
atom -> False
514
%
atom -> False
514
<=
atom -> False
514
by
atom -> False
514
or
atom -> False
514
<
atom -> False
514
//
atom -> False
514
+
atom -> False
514
>=
atom -> False
514
&
atom -> False
514
^
atom -> False
514
!=
atom -> False
515
:
xor_expr -> and_expr
515
and
xor_expr -> and_expr
515
>=
xor_expr -> and_expr
515
^
544
515
<=
xor_expr -> and_expr
515
==
xor_expr -> and_expr
515
or
xor_expr -> and_expr
515
by
xor_expr -> and_expr
515
<
xor_expr -> and_expr
515
!=
xor_expr -> and_expr
515
>
xor_expr -> and_expr
515
|
xor_expr -> and_expr
516
:
545
516
by
546
517
:
or_test -> and_test
517
or
547
517
by
or_test -> and_test
518
and
548
518
or
and_test -> not_test
518
by
and_test -> not_test
518
:
and_test -> not_test
519
call
494
519
factor
496
519
term
497
519
None
498
519
xor_expr
499
519
power
513
519
NAME
500
519
arith_expr
501
519
+
502
519
-
508
519
STRING
503
519
atom
504
519
shift_expr
505
519
True
506
519
[
507
519
and_expr
515
519
False
514
519
NUMBER
509
519
~
510
519
expr
511
519
comparison
512
519
not_test
549
519
not
519
520
DEDENT
loop_stmt -> loop NAME from test : suite
520
var
loop_stmt -> loop NAME from test : suite
520
nextloop
loop_stmt -> loop NAME from test : suite
520
loop
loop_stmt -> loop NAME from test : suite
520
if
loop_stmt -> loop NAME from test : suite
520
NEWLINE
loop_stmt -> loop NAME from test : suite
520
return
loop_stmt -> loop NAME from test : suite
520
NAME
loop_stmt -> loop NAME from test : suite
520
endloop
loop_stmt -> loop NAME from test : suite
521
to
xor_expr -> and_expr ^ xor_expr
521
<=
xor_expr -> and_expr ^ xor_expr
521
or
xor_expr -> and_expr ^ xor_expr
521
|
xor_expr -> and_expr ^ xor_expr
521
:
xor_expr -> and_expr ^ xor_expr
521
==
xor_expr -> and_expr ^ xor_expr
521
>
xor_expr -> and_expr ^ xor_expr
521
<
xor_expr -> and_expr ^ xor_expr
521
!=
xor_expr -> and_expr ^ xor_expr
521
>=
xor_expr -> and_expr ^ xor_expr
521
and
xor_expr -> and_expr ^ xor_expr
522
or
and_test -> not_test and and_test
522
:
and_test -> not_test and and_test
522
to
and_test -> not_test and and_test
523
loop
suite -> NEWLINE INDENT stmt_list DEDENT
523
DEDENT
suite -> NEWLINE INDENT stmt_list DEDENT
523
NAME
suite -> NEWLINE INDENT stmt_list DEDENT
523
NEWLINE
suite -> NEWLINE INDENT stmt_list DEDENT
523
if
suite -> NEWLINE INDENT stmt_list DEDENT
523
endloop
suite -> NEWLINE INDENT stmt_list DEDENT
523
return
suite -> NEWLINE INDENT stmt_list DEDENT
523
var
suite -> NEWLINE INDENT stmt_list DEDENT
523
nextloop
suite -> NEWLINE INDENT stmt_list DEDENT
524
NEWLINE
333
524
suite
550
525
DEDENT
551
526
!=
call -> NAME ( test_list )
526
//
call -> NAME ( test_list )
526
or
call -> NAME ( test_list )
526
<<
call -> NAME ( test_list )
526
:
call -> NAME ( test_list )
526
-
call -> NAME ( test_list )
526
to
call -> NAME ( test_list )
526
>
call -> NAME ( test_list )
526
+
call -> NAME ( test_list )
526
<
call -> NAME ( test_list )
526
>=
call -> NAME ( test_list )
526
and
call -> NAME ( test_list )
526
/
call -> NAME ( test_list )
526
|
call -> NAME ( test_list )
526
&
call -> NAME ( test_list )
526
==
call -> NAME ( test_list )
526
*
call -> NAME ( test_list )
526
>>
call -> NAME ( test_list )
526
**
call -> NAME ( test_list )
526
^
call -> NAME ( test_list )
526
<=
call -> NAME ( test_list )
526
%
call -> NAME ( test_list )
527
call
494
527
factor
496
527
None
498
527
power
513
527
NAME
500
527
+
502
527
-
508
527
STRING
503
527
atom
504
527
True
506
527
[
507
527
False
514
527
NUMBER
509
527
~
510
527
term
552
528
call
494
528
factor
496
528
term
553
528
None
498
528
power
513
528
NAME
500
528
+
502
528
-
508
528
STRING
503
528
atom
504
528
True
506
528
[
507
528
False
514
528
NUMBER
509
528
~
510
529
call
494
529
factor
496
529
None
498
529
power
513
529
NAME
500
529
+
502
529
-
508
529
STRING
503
529
atom
504
529
True
506
529
[
507
529
False
514
529
NUMBER
509
529
~
510
529
term
554
530
call
494
530
factor
496
530
None
498
530
power
513
530
NAME
500
530
+
502
530
-
508
530
STRING
503
530
atom
504
530
True
506
530
[
507
530
False
514
530
NUMBER
509
530
term
555
530
~
510
531
call
494
531
factor
496
531
term
497
531
None
498
531
power
513
531
NAME
500
531
+
502
531
-
508
531
STRING
503
531
atom
504
531
arith_expr
556
531
True
506
531
[
507
531
False
514
531
NUMBER
509
531
~
510
532
call
494
532
factor
496
532
term
497
532
None
498
532
power
513
532
NAME
500
532
+
502
532
-
508
532
STRING
503
532
atom
504
532
True
506
532
[
507
532
arith_expr
557
532
False
514
532
NUMBER
509
532
~
510
533
call
494
533
factor
496
533
term
497
533
None
498
533
xor_expr
499
533
power
513
533
NAME
500
533
arith_expr
501
533
+
502
533
-
508
533
STRING
503
533
atom
504
533
shift_expr
505
533
True
506
533
[
507
533
and_expr
515
533
False
514
533
NUMBER
509
533
~
510
533
expr
558
534
call
128
534
factor
129
534
term
130
534
None
131
534
xor_expr
132
534
NAME
133
534
arith_expr
134
534
+
135
534
STRING
136
534
atom
137
534
shift_expr
138
534
True
139
534
[
140
534
-
141
534
not_test
142
534
expr
143
534
~
144
534
comparison
145
534
power
146
534
NUMBER
147
534
False
148
534
and_expr
149
534
not
150
534
)
559
534
test_list
560
534
and_test
153
534
or_test
154
534
test
155
535
call
494
535
factor
496
535
term
497
535
None
498
535
power
513
535
NAME
500
535
arith_expr
501
535
+
502
535
-
508
535
shift_expr
561
535
STRING
503
535
atom
504
535
True
506
535
[
507
535
False
514
535
NUMBER
509
535
~
510
536
call
494
536
factor
496
536
term
497
536
None
498
536
power
513
536
NAME
500
536
arith_expr
501
536
+
502
536
-
508
536
STRING
503
536
atom
504
536
True
506
536
[
507
536
False
514
536
NUMBER
509
536
~
510
536
shift_expr
562
537
>=
factor -> + factor
537
<=
factor -> + factor
537
*
factor -> + factor
537
==
factor -> + factor
537
>
factor -> + factor
537
by
factor -> + factor
537
!=
factor -> + factor
537
-
factor -> + factor
537
and
factor -> + factor
537
//
factor -> + factor
537
%
factor -> + factor
537
/
factor -> + factor
537
<<
factor -> + factor
537
+
factor -> + factor
537
^
factor -> + factor
537
or
factor -> + factor
537
:
factor -> + factor
537
&
factor -> + factor
537
|
factor -> + factor
537
>>
factor -> + factor
537
<
factor -> + factor
538
call
494
538
factor
563
538
None
498
538
power
513
538
NAME
500
538
+
502
538
-
508
538
STRING
503
538
atom
504
538
True
506
538
[
507
538
False
514
538
NUMBER
509
538
~
510
539
and_expr
564
539
call
494
539
factor
496
539
term
497
539
None
498
539
power
513
539
NAME
500
539
arith_expr
501
539
+
502
539
-
508
539
STRING
503
539
atom
504
539
shift_expr
505
539
True
506
539
[
507
539
False
514
539
NUMBER
509
539
~
510
540
]
565
541
or
factor -> - factor
541
by
factor -> - factor
541
*
factor -> - factor
541
&
factor -> - factor
541
>=
factor -> - factor
541
:
factor -> - factor
541
and
factor -> - factor
541
>>
factor -> - factor
541
>
factor -> - factor
541
+
factor -> - factor
541
%
factor -> - factor
541
//
factor -> - factor
541
<=
factor -> - factor
541
==
factor -> - factor
541
/
factor -> - factor
541
-
factor -> - factor
541
<<
factor -> - factor
541
!=
factor -> - factor
541
^
factor -> - factor
541
|
factor -> - factor
541
<
factor -> - factor
542
and
factor -> ~ factor
542
/
factor -> ~ factor
542
>>
factor -> ~ factor
542
<=
factor -> ~ factor
542
-
factor -> ~ factor
542
!=
factor -> ~ factor
542
==
factor -> ~ factor
542
^
factor -> ~ factor
542
or
factor -> ~ factor
542
>=
factor -> ~ factor
542
>
factor -> ~ factor
542
<
factor -> ~ factor
542
:
factor -> ~ factor
542
+
factor -> ~ factor
542
<<
factor -> ~ factor
542
|
factor -> ~ factor
542
&
factor -> ~ factor
542
by
factor -> ~ factor
542
*
factor -> ~ factor
542
%
factor -> ~ factor
542
//
factor -> ~ factor
543
call
494
543
factor
496
543
term
497
543
None
498
543
xor_expr
499
543
power
513
543
NAME
500
543
arith_expr
501
543
+
502
543
-
508
543
STRING
503
543
atom
504
543
shift_expr
505
543
True
506
543
[
507
543
and_expr
515
543
False
514
543
NUMBER
509
543
~
510
543
expr
511
543
comparison
566
544
call
494
544
factor
496
544
term
497
544
None
498
544
power
513
544
NAME
500
544
arith_expr
501
544
+
502
544
-
508
544
STRING
503
544
atom
504
544
shift_expr
505
544
True
506
544
[
507
544
and_expr
515
544
False
514
544
NUMBER
509
544
~
510
544
xor_expr
567
545
NEWLINE
333
545
suite
568
546
call
302
546
factor
303
546
term
304
546
None
305
546
xor_expr
306
546
power
307
546
NAME
308
546
arith_expr
309
546
+
310
546
-
311
546
STRING
312
546
atom
313
546
shift_expr
314
546
True
315
546
[
316
546
and_expr
317
546
False
318
546
and_test
319
546
NUMBER
320
546
~
321
546
expr
322
546
comparison
324
546
not_test
325
546
test
569
546
or_test
326
546
not
327
547
call
494
547
factor
496
547
term
497
547
None
498
547
xor_expr
499
547
power
513
547
NAME
500
547
not_test
518
547
arith_expr
501
547
+
502
547
-
508
547
STRING
503
547
atom
504
547
shift_expr
505
547
True
506
547
[
507
547
and_expr
515
547
False
514
547
and_test
517
547
NUMBER
509
547
~
510
547
expr
511
547
comparison
512
547
or_test
570
547
not
519
548
call
494
548
factor
496
548
term
497
548
None
498
548
xor_expr
499
548
power
513
548
NAME
500
548
not_test
518
548
arith_expr
501
548
+
502
548
-
508
548
STRING
503
548
atom
504
548
shift_expr
505
548
True
506
548
[
507
548
and_expr
515
548
False
514
548
NUMBER
509
548
~
510
548
expr
511
548
comparison
512
548
not
519
548
and_test
571
549
or
not_test -> not not_test
549
:
not_test -> not not_test
549
by
not_test -> not not_test
549
and
not_test -> not not_test
550
nextloop
if_stmt -> if test : suite else : suite
550
var
if_stmt -> if test : suite else : suite
550
DEDENT
if_stmt -> if test : suite else : suite
550
endloop
if_stmt -> if test : suite else : suite
550
NEWLINE
if_stmt -> if test : suite else : suite
550
loop
if_stmt -> if test : suite else : suite
550
if
if_stmt -> if test : suite else : suite
550
return
if_stmt -> if test : suite else : suite
550
NAME
if_stmt -> if test : suite else : suite
551
loop
suite -> NEWLINE INDENT stmt_list DEDENT
551
DEDENT
suite -> NEWLINE INDENT stmt_list DEDENT
551
NAME
suite -> NEWLINE INDENT stmt_list DEDENT
551
else
suite -> NEWLINE INDENT stmt_list DEDENT
551
if
suite -> NEWLINE INDENT stmt_list DEDENT
551
NEWLINE
suite -> NEWLINE INDENT stmt_list DEDENT
551
endloop
suite -> NEWLINE INDENT stmt_list DEDENT
551
return
suite -> NEWLINE INDENT stmt_list DEDENT
551
var
suite -> NEWLINE INDENT stmt_list DEDENT
551
nextloop
suite -> NEWLINE INDENT stmt_list DEDENT
552
by
term -> factor % term
552
+
term -> factor % term
552
>=
term -> factor % term
552
!=
term -> factor % term
552
^
term -> factor % term
552
or
term -> factor % term
552
<<
term -> factor % term
552
and
term -> factor % term
552
==
term -> factor % term
552
:
term -> factor % term
552
>
term -> factor % term
552
|
term -> factor % term
552
&
term -> factor % term
552
-
term -> factor % term
552
>>
term -> factor % term
552
<
term -> factor % term
552
<=
term -> factor % term
553
|
term -> factor / term
553
or
term -> factor / term
553
and
term -> factor / term
553
<=
term -> factor / term
553
<<
term -> factor / term
553
^
term -> factor / term
553
by
term -> factor / term
553
-
term -> factor / term
553
>>
term -> factor / term
553
==
term -> factor / term
553
>
term -> factor / term
553
>=
term -> factor / term
553
:
term -> factor / term
553
<
term -> factor / term
553
+
term -> factor / term
553
&
term -> factor / term
553
!=
term -> factor / term
554
&
term -> factor // term
554
>=
term -> factor // term
554
+
term -> factor // term
554
<<
term -> factor // term
554
!=
term -> factor // term
554
<=
term -> factor // term
554
:
term -> factor // term
554
|
term -> factor // term
554
and
term -> factor // term
554
>>
term -> factor // term
554
^
term -> factor // term
554
<
term -> factor // term
554
-
term -> factor // term
554
>
term -> factor // term
554
by
term -> factor // term
554
==
term -> factor // term
554
or
term -> factor // term
555
>>
term -> factor * term
555
>=
term -> factor * term
555
-
term -> factor * term
555
and
term -> factor * term
555
|
term -> factor * term
555
<=
term -> factor * term
555
or
term -> factor * term
555
+
term -> factor * term
555
<
term -> factor * term
555
>
term -> factor * term
555
by
term -> factor * term
555
^
term -> factor * term
555
:
term -> factor * term
555
==
term -> factor * term
555
<<
term -> factor * term
555
&
term -> factor * term
555
!=
term -> factor * term
556
|
arith_expr -> term + arith_expr
556
!=
arith_expr -> term + arith_expr
556
>
arith_expr -> term + arith_expr
556
>=
arith_expr -> term + arith_expr
556
&
arith_expr -> term + arith_expr
556
==
arith_expr -> term + arith_expr
556
<=
arith_expr -> term + arith_expr
556
<
arith_expr -> term + arith_expr
556
<<
arith_expr -> term + arith_expr
556
and
arith_expr -> term + arith_expr
556
>>
arith_expr -> term + arith_expr
556
:
arith_expr -> term + arith_expr
556
^
arith_expr -> term + arith_expr
556
or
arith_expr -> term + arith_expr
556
by
arith_expr -> term + arith_expr
557
or
arith_expr -> term - arith_expr
557
<=
arith_expr -> term - arith_expr
557
>=
arith_expr -> term - arith_expr
557
==
arith_expr -> term - arith_expr
557
:
arith_expr -> term - arith_expr
557
by
arith_expr -> term - arith_expr
557
>>
arith_expr -> term - arith_expr
557
|
arith_expr -> term - arith_expr
557
<<
arith_expr -> term - arith_expr
557
<
arith_expr -> term - arith_expr
557
!=
arith_expr -> term - arith_expr
557
>
arith_expr -> term - arith_expr
557
^
arith_expr -> term - arith_expr
557
&
arith_expr -> term - arith_expr
557
and
arith_expr -> term - arith_expr
558
==
expr -> xor_expr | expr
558
!=
expr -> xor_expr | expr
558
<=
expr -> xor_expr | expr
558
or
expr -> xor_expr | expr
558
and
expr -> xor_expr | expr
558
>=
expr -> xor_expr | expr
558
by
expr -> xor_expr | expr
558
:
expr -> xor_expr | expr
558
>
expr -> xor_expr | expr
558
<
expr -> xor_expr | expr
559
<<
call -> NAME ( )
559
//
call -> NAME ( )
559
by
call -> NAME ( )
559
or
call -> NAME ( )
559
:
call -> NAME ( )
559
>>
call -> NAME ( )
559
/
call -> NAME ( )
559
%
call -> NAME ( )
559
+
call -> NAME ( )
559
>
call -> NAME ( )
559
>=
call -> NAME ( )
559
==
call -> NAME ( )
559
<
call -> NAME ( )
559
^
call -> NAME ( )
559
-
call -> NAME ( )
559
and
call -> NAME ( )
559
**
call -> NAME ( )
559
|
call -> NAME ( )
559
<=
call -> NAME ( )
559
!=
call -> NAME ( )
559
&
call -> NAME ( )
559
*
call -> NAME ( )
560
)
572
561
by
shift_expr -> arith_expr >> shift_expr
561
>
shift_expr -> arith_expr >> shift_expr
561
&
shift_expr -> arith_expr >> shift_expr
561
or
shift_expr -> arith_expr >> shift_expr
561
<
shift_expr -> arith_expr >> shift_expr
561
>=
shift_expr -> arith_expr >> shift_expr
561
<=
shift_expr -> arith_expr >> shift_expr
561
^
shift_expr -> arith_expr >> shift_expr
561
|
shift_expr -> arith_expr >> shift_expr
561
!=
shift_expr -> arith_expr >> shift_expr
561
==
shift_expr -> arith_expr >> shift_expr
561
:
shift_expr -> arith_expr >> shift_expr
561
and
shift_expr -> arith_expr >> shift_expr
562
|
shift_expr -> arith_expr << shift_expr
562
==
shift_expr -> arith_expr << shift_expr
562
>
shift_expr -> arith_expr << shift_expr
562
and
shift_expr -> arith_expr << shift_expr
562
<=
shift_expr -> arith_expr << shift_expr
562
!=
shift_expr -> arith_expr << shift_expr
562
>=
shift_expr -> arith_expr << shift_expr
562
&
shift_expr -> arith_expr << shift_expr
562
<
shift_expr -> arith_expr << shift_expr
562
:
shift_expr -> arith_expr << shift_expr
562
^
shift_expr -> arith_expr << shift_expr
562
by
shift_expr -> arith_expr << shift_expr
562
or
shift_expr -> arith_expr << shift_expr
563
<
power -> atom ** factor
563
/
power -> atom ** factor
563
*
power -> atom ** factor
563
-
power -> atom ** factor
563
<=
power -> atom ** factor
563
+
power -> atom ** factor
563
>>
power -> atom ** factor
563
or
power -> atom ** factor
563
&
power -> atom ** factor
563
!=
power -> atom ** factor
563
//
power -> atom ** factor
563
%
power -> atom ** factor
563
>
power -> atom ** factor
563
:
power -> atom ** factor
563
<<
power -> atom ** factor
563
|
power -> atom ** factor
563
^
power -> atom ** factor
563
by
power -> atom ** factor
563
==
power -> atom ** factor
563
>=
power -> atom ** factor
563
and
power -> atom ** factor
564
<=
and_expr -> shift_expr & and_expr
564
^
and_expr -> shift_expr & and_expr
564
>=
and_expr -> shift_expr & and_expr
564
<
and_expr -> shift_expr & and_expr
564
==
and_expr -> shift_expr & and_expr
564
or
and_expr -> shift_expr & and_expr
564
:
and_expr -> shift_expr & and_expr
564
by
and_expr -> shift_expr & and_expr
564
>
and_expr -> shift_expr & and_expr
564
and
and_expr -> shift_expr & and_expr
564
|
and_expr -> shift_expr & and_expr
564
!=
and_expr -> shift_expr & and_expr
565
^
atom -> [ test_list ]
565
<
atom -> [ test_list ]
565
|
atom -> [ test_list ]
565
==
atom -> [ test_list ]
565
**
atom -> [ test_list ]
565
-
atom -> [ test_list ]
565
*
atom -> [ test_list ]
565
and
atom -> [ test_list ]
565
>=
atom -> [ test_list ]
565
<<
atom -> [ test_list ]
565
/
atom -> [ test_list ]
565
!=
atom -> [ test_list ]
565
&
atom -> [ test_list ]
565
or
atom -> [ test_list ]
565
by
atom -> [ test_list ]
565
:
atom -> [ test_list ]
565
+
atom -> [ test_list ]
565
//
atom -> [ test_list ]
565
>>
atom -> [ test_list ]
565
>
atom -> [ test_list ]
565
<=
atom -> [ test_list ]
565
%
atom -> [ test_list ]
566
by
comparison -> expr comp_op comparison
566
and
comparison -> expr comp_op comparison
566
or
comparison -> expr comp_op comparison
566
:
comparison -> expr comp_op comparison
567
<=
xor_expr -> and_expr ^ xor_expr
567
or
xor_expr -> and_expr ^ xor_expr
567
by
xor_expr -> and_expr ^ xor_expr
567
|
xor_expr -> and_expr ^ xor_expr
567
:
xor_expr -> and_expr ^ xor_expr
567
==
xor_expr -> and_expr ^ xor_expr
567
>
xor_expr -> and_expr ^ xor_expr
567
<
xor_expr -> and_expr ^ xor_expr
567
!=
xor_expr -> and_expr ^ xor_expr
567
>=
xor_expr -> and_expr ^ xor_expr
567
and
xor_expr -> and_expr ^ xor_expr
568
NAME
loop_stmt -> loop NAME from test to test : suite
568
DEDENT
loop_stmt -> loop NAME from test to test : suite
568
return
loop_stmt -> loop NAME from test to test : suite
568
if
loop_stmt -> loop NAME from test to test : suite
568
endloop
loop_stmt -> loop NAME from test to test : suite
568
var
loop_stmt -> loop NAME from test to test : suite
568
NEWLINE
loop_stmt -> loop NAME from test to test : suite
568
loop
loop_stmt -> loop NAME from test to test : suite
568
nextloop
loop_stmt -> loop NAME from test to test : suite
569
:
573
570
:
or_test -> and_test or or_test
570
by
or_test -> and_test or or_test
571
by
and_test -> not_test and and_test
571
or
and_test -> not_test and and_test
571
:
and_test -> not_test and and_test
572
!=
call -> NAME ( test_list )
572
//
call -> NAME ( test_list )
572
or
call -> NAME ( test_list )
572
<<
call -> NAME ( test_list )
572
by
call -> NAME ( test_list )
572
:
call -> NAME ( test_list )
572
-
call -> NAME ( test_list )
572
>
call -> NAME ( test_list )
572
+
call -> NAME ( test_list )
572
<
call -> NAME ( test_list )
572
>=
call -> NAME ( test_list )
572
and
call -> NAME ( test_list )
572
/
call -> NAME ( test_list )
572
|
call -> NAME ( test_list )
572
&
call -> NAME ( test_list )
572
==
call -> NAME ( test_list )
572
*
call -> NAME ( test_list )
572
>>
call -> NAME ( test_list )
572
**
call -> NAME ( test_list )
572
^
call -> NAME ( test_list )
572
<=
call -> NAME ( test_list )
572
%
call -> NAME ( test_list )
573
suite
574
573
NEWLINE
333
574
if
loop_stmt -> loop NAME from test to test by test : suite
574
return
loop_stmt -> loop NAME from test to test by test : suite
574
nextloop
loop_stmt -> loop NAME from test to test by test : suite
574
NAME
loop_stmt -> loop NAME from test to test by test : suite
574
DEDENT
loop_stmt -> loop NAME from test to test by test : suite
574
NEWLINE
loop_stmt -> loop NAME from test to test by test : suite
574
var
loop_stmt -> loop NAME from test to test by test : suite
574
endloop
loop_stmt -> loop NAME from test to test by test : suite
574
loop
loop_stmt -> loop NAME from test to test by test : suite
