diff --git a/Parser/pegen/parse.c b/Parser/pegen/parse.c
new file mode 100644
index 0000000..25607ea
--- /dev/null
+++ b/Parser/pegen/parse.c
@@ -0,0 +1,15391 @@
+// @generated by pegen.py from ./Grammar/python.gram
+#include "pegen.h"
+static const int n_keyword_lists = 15;
+static KeywordToken *reserved_keywords[] = {
+    NULL,
+    NULL,
+    (KeywordToken[]) {
+        {"if", 510},
+        {"in", 518},
+        {"is", 526},
+        {"as", 531},
+        {"or", 532},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"del", 503},
+        {"try", 511},
+        {"for", 517},
+        {"def", 522},
+        {"not", 525},
+        {"and", 533},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"pass", 502},
+        {"from", 514},
+        {"elif", 515},
+        {"else", 516},
+        {"with", 519},
+        {"True", 527},
+        {"None", 529},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"raise", 501},
+        {"yield", 504},
+        {"break", 506},
+        {"while", 512},
+        {"class", 523},
+        {"False", 528},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"return", 500},
+        {"assert", 505},
+        {"global", 508},
+        {"import", 513},
+        {"except", 520},
+        {"lambda", 524},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"finally", 521},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"continue", 507},
+        {"nonlocal", 509},
+        {NULL, -1},
+    },
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    (KeywordToken[]) {
+        {"__new_parser__", 530},
+        {NULL, -1},
+    },
+};
+#define file_type 1000
+#define interactive_type 1001
+#define eval_type 1002
+#define fstring_type 1003
+#define statements_type 1004
+#define statement_type 1005
+#define statement_newline_type 1006
+#define simple_stmt_type 1007
+#define small_stmt_type 1008
+#define compound_stmt_type 1009
+#define assignment_type 1010
+#define augassign_type 1011
+#define global_stmt_type 1012
+#define nonlocal_stmt_type 1013
+#define yield_stmt_type 1014
+#define assert_stmt_type 1015
+#define del_stmt_type 1016
+#define import_stmt_type 1017
+#define import_name_type 1018
+#define import_from_type 1019
+#define import_from_targets_type 1020
+#define import_from_as_names_type 1021
+#define import_from_as_name_type 1022
+#define dotted_as_names_type 1023
+#define dotted_as_name_type 1024
+#define dotted_name_type 1025  // Left-recursive
+#define if_stmt_type 1026
+#define elif_stmt_type 1027
+#define else_block_type 1028
+#define while_stmt_type 1029
+#define for_stmt_type 1030
+#define with_stmt_type 1031
+#define with_item_type 1032
+#define try_stmt_type 1033
+#define except_block_type 1034
+#define finally_block_type 1035
+#define return_stmt_type 1036
+#define raise_stmt_type 1037
+#define function_def_type 1038
+#define function_def_raw_type 1039
+#define params_type 1040
+#define parameters_type 1041
+#define slash_without_default_type 1042
+#define slash_with_default_type 1043
+#define star_etc_type 1044
+#define name_with_optional_default_type 1045
+#define names_with_default_type 1046
+#define name_with_default_type 1047
+#define plain_names_type 1048
+#define plain_name_type 1049
+#define kwds_type 1050
+#define annotation_type 1051
+#define decorators_type 1052
+#define class_def_type 1053
+#define class_def_raw_type 1054
+#define block_type 1055
+#define expressions_list_type 1056
+#define star_expressions_type 1057
+#define star_expression_type 1058
+#define star_named_expressions_type 1059
+#define star_named_expression_type 1060
+#define named_expression_type 1061
+#define annotated_rhs_type 1062
+#define expressions_type 1063
+#define expression_type 1064
+#define lambdef_type 1065
+#define lambda_parameters_type 1066
+#define lambda_slash_without_default_type 1067
+#define lambda_slash_with_default_type 1068
+#define lambda_star_etc_type 1069
+#define lambda_name_with_optional_default_type 1070
+#define lambda_names_with_default_type 1071
+#define lambda_name_with_default_type 1072
+#define lambda_plain_names_type 1073
+#define lambda_plain_name_type 1074
+#define lambda_kwds_type 1075
+#define disjunction_type 1076
+#define conjunction_type 1077
+#define inversion_type 1078
+#define comparison_type 1079
+#define compare_op_bitwise_or_pair_type 1080
+#define eq_bitwise_or_type 1081
+#define noteq_bitwise_or_type 1082
+#define lte_bitwise_or_type 1083
+#define lt_bitwise_or_type 1084
+#define gte_bitwise_or_type 1085
+#define gt_bitwise_or_type 1086
+#define notin_bitwise_or_type 1087
+#define in_bitwise_or_type 1088
+#define isnot_bitwise_or_type 1089
+#define is_bitwise_or_type 1090
+#define bitwise_or_type 1091  // Left-recursive
+#define bitwise_xor_type 1092  // Left-recursive
+#define bitwise_and_type 1093  // Left-recursive
+#define shift_expr_type 1094  // Left-recursive
+#define sum_type 1095  // Left-recursive
+#define term_type 1096  // Left-recursive
+#define factor_type 1097
+#define power_type 1098
+#define await_primary_type 1099
+#define primary_type 1100  // Left-recursive
+#define slices_type 1101
+#define slice_type 1102
+#define atom_type 1103
+#define strings_type 1104
+#define list_type 1105
+#define listcomp_type 1106
+#define tuple_type 1107
+#define group_type 1108
+#define genexp_type 1109
+#define set_type 1110
+#define setcomp_type 1111
+#define dict_type 1112
+#define dictcomp_type 1113
+#define kvpairs_type 1114
+#define kvpair_type 1115
+#define for_if_clauses_type 1116
+#define yield_expr_type 1117
+#define arguments_type 1118
+#define args_type 1119
+#define kwargs_type 1120
+#define starred_expression_type 1121
+#define kwarg_or_starred_type 1122
+#define kwarg_or_double_starred_type 1123
+#define star_targets_type 1124
+#define star_targets_seq_type 1125
+#define star_target_type 1126
+#define star_atom_type 1127
+#define inside_paren_ann_assign_target_type 1128
+#define ann_assign_subscript_attribute_target_type 1129
+#define del_targets_type 1130
+#define del_target_type 1131
+#define del_t_atom_type 1132
+#define targets_type 1133
+#define target_type 1134
+#define t_primary_type 1135  // Left-recursive
+#define t_lookahead_type 1136
+#define t_atom_type 1137
+#define incorrect_arguments_type 1138
+#define invalid_named_expression_type 1139
+#define invalid_assignment_type 1140
+#define invalid_block_type 1141
+#define invalid_comprehension_type 1142
+#define invalid_parameters_type 1143
+#define _loop0_1_type 1144
+#define _loop1_2_type 1145
+#define _loop0_4_type 1146
+#define _gather_3_type 1147
+#define _tmp_5_type 1148
+#define _tmp_6_type 1149
+#define _tmp_7_type 1150
+#define _tmp_8_type 1151
+#define _tmp_9_type 1152
+#define _tmp_10_type 1153
+#define _tmp_11_type 1154
+#define _tmp_12_type 1155
+#define _loop1_13_type 1156
+#define _tmp_14_type 1157
+#define _tmp_15_type 1158
+#define _loop0_17_type 1159
+#define _gather_16_type 1160
+#define _loop0_19_type 1161
+#define _gather_18_type 1162
+#define _tmp_20_type 1163
+#define _loop0_21_type 1164
+#define _loop1_22_type 1165
+#define _loop0_24_type 1166
+#define _gather_23_type 1167
+#define _tmp_25_type 1168
+#define _loop0_27_type 1169
+#define _gather_26_type 1170
+#define _tmp_28_type 1171
+#define _loop0_30_type 1172
+#define _gather_29_type 1173
+#define _loop0_32_type 1174
+#define _gather_31_type 1175
+#define _tmp_33_type 1176
+#define _loop1_34_type 1177
+#define _tmp_35_type 1178
+#define _tmp_36_type 1179
+#define _tmp_37_type 1180
+#define _tmp_38_type 1181
+#define _tmp_39_type 1182
+#define _tmp_40_type 1183
+#define _tmp_41_type 1184
+#define _tmp_42_type 1185
+#define _tmp_43_type 1186
+#define _tmp_44_type 1187
+#define _tmp_45_type 1188
+#define _tmp_46_type 1189
+#define _loop0_47_type 1190
+#define _tmp_48_type 1191
+#define _loop1_49_type 1192
+#define _tmp_50_type 1193
+#define _tmp_51_type 1194
+#define _loop0_53_type 1195
+#define _gather_52_type 1196
+#define _loop0_55_type 1197
+#define _gather_54_type 1198
+#define _tmp_56_type 1199
+#define _loop1_57_type 1200
+#define _tmp_58_type 1201
+#define _loop0_60_type 1202
+#define _gather_59_type 1203
+#define _loop1_61_type 1204
+#define _loop0_63_type 1205
+#define _gather_62_type 1206
+#define _loop1_64_type 1207
+#define _tmp_65_type 1208
+#define _tmp_66_type 1209
+#define _tmp_67_type 1210
+#define _tmp_68_type 1211
+#define _tmp_69_type 1212
+#define _tmp_70_type 1213
+#define _tmp_71_type 1214
+#define _tmp_72_type 1215
+#define _tmp_73_type 1216
+#define _loop0_74_type 1217
+#define _tmp_75_type 1218
+#define _loop1_76_type 1219
+#define _tmp_77_type 1220
+#define _tmp_78_type 1221
+#define _loop0_80_type 1222
+#define _gather_79_type 1223
+#define _loop0_82_type 1224
+#define _gather_81_type 1225
+#define _loop1_83_type 1226
+#define _loop1_84_type 1227
+#define _loop1_85_type 1228
+#define _loop0_87_type 1229
+#define _gather_86_type 1230
+#define _tmp_88_type 1231
+#define _tmp_89_type 1232
+#define _tmp_90_type 1233
+#define _tmp_91_type 1234
+#define _loop1_92_type 1235
+#define _tmp_93_type 1236
+#define _tmp_94_type 1237
+#define _loop0_96_type 1238
+#define _gather_95_type 1239
+#define _loop1_97_type 1240
+#define _tmp_98_type 1241
+#define _tmp_99_type 1242
+#define _loop0_101_type 1243
+#define _gather_100_type 1244
+#define _loop0_103_type 1245
+#define _gather_102_type 1246
+#define _loop0_105_type 1247
+#define _gather_104_type 1248
+#define _loop0_107_type 1249
+#define _gather_106_type 1250
+#define _loop0_108_type 1251
+#define _loop0_110_type 1252
+#define _gather_109_type 1253
+#define _tmp_111_type 1254
+#define _loop0_113_type 1255
+#define _gather_112_type 1256
+#define _loop0_115_type 1257
+#define _gather_114_type 1258
+#define _tmp_116_type 1259
+#define _tmp_117_type 1260
+#define _tmp_118_type 1261
+#define _tmp_119_type 1262
+#define _tmp_120_type 1263
+#define _tmp_121_type 1264
+#define _tmp_122_type 1265
+#define _tmp_123_type 1266
+#define _tmp_124_type 1267
+#define _tmp_125_type 1268
+#define _tmp_126_type 1269
+#define _tmp_127_type 1270
+#define _tmp_128_type 1271
+#define _tmp_129_type 1272
+#define _tmp_130_type 1273
+#define _tmp_131_type 1274
+#define _tmp_132_type 1275
+#define _tmp_133_type 1276
+#define _tmp_134_type 1277
+#define _loop0_135_type 1278
+#define _tmp_136_type 1279
+
+static mod_ty file_rule(Parser *p);
+static mod_ty interactive_rule(Parser *p);
+static mod_ty eval_rule(Parser *p);
+static expr_ty fstring_rule(Parser *p);
+static asdl_seq* statements_rule(Parser *p);
+static asdl_seq* statement_rule(Parser *p);
+static asdl_seq* statement_newline_rule(Parser *p);
+static asdl_seq* simple_stmt_rule(Parser *p);
+static stmt_ty small_stmt_rule(Parser *p);
+static stmt_ty compound_stmt_rule(Parser *p);
+static void *assignment_rule(Parser *p);
+static AugOperator* augassign_rule(Parser *p);
+static stmt_ty global_stmt_rule(Parser *p);
+static stmt_ty nonlocal_stmt_rule(Parser *p);
+static stmt_ty yield_stmt_rule(Parser *p);
+static stmt_ty assert_stmt_rule(Parser *p);
+static stmt_ty del_stmt_rule(Parser *p);
+static stmt_ty import_stmt_rule(Parser *p);
+static stmt_ty import_name_rule(Parser *p);
+static stmt_ty import_from_rule(Parser *p);
+static asdl_seq* import_from_targets_rule(Parser *p);
+static asdl_seq* import_from_as_names_rule(Parser *p);
+static alias_ty import_from_as_name_rule(Parser *p);
+static asdl_seq* dotted_as_names_rule(Parser *p);
+static alias_ty dotted_as_name_rule(Parser *p);
+static expr_ty dotted_name_rule(Parser *p);
+static stmt_ty if_stmt_rule(Parser *p);
+static stmt_ty elif_stmt_rule(Parser *p);
+static asdl_seq* else_block_rule(Parser *p);
+static stmt_ty while_stmt_rule(Parser *p);
+static stmt_ty for_stmt_rule(Parser *p);
+static stmt_ty with_stmt_rule(Parser *p);
+static withitem_ty with_item_rule(Parser *p);
+static stmt_ty try_stmt_rule(Parser *p);
+static excepthandler_ty except_block_rule(Parser *p);
+static asdl_seq* finally_block_rule(Parser *p);
+static stmt_ty return_stmt_rule(Parser *p);
+static stmt_ty raise_stmt_rule(Parser *p);
+static stmt_ty function_def_rule(Parser *p);
+static stmt_ty function_def_raw_rule(Parser *p);
+static arguments_ty params_rule(Parser *p);
+static arguments_ty parameters_rule(Parser *p);
+static asdl_seq* slash_without_default_rule(Parser *p);
+static SlashWithDefault* slash_with_default_rule(Parser *p);
+static StarEtc* star_etc_rule(Parser *p);
+static NameDefaultPair* name_with_optional_default_rule(Parser *p);
+static asdl_seq* names_with_default_rule(Parser *p);
+static NameDefaultPair* name_with_default_rule(Parser *p);
+static asdl_seq* plain_names_rule(Parser *p);
+static arg_ty plain_name_rule(Parser *p);
+static arg_ty kwds_rule(Parser *p);
+static expr_ty annotation_rule(Parser *p);
+static asdl_seq* decorators_rule(Parser *p);
+static stmt_ty class_def_rule(Parser *p);
+static stmt_ty class_def_raw_rule(Parser *p);
+static asdl_seq* block_rule(Parser *p);
+static asdl_seq* expressions_list_rule(Parser *p);
+static expr_ty star_expressions_rule(Parser *p);
+static expr_ty star_expression_rule(Parser *p);
+static asdl_seq* star_named_expressions_rule(Parser *p);
+static expr_ty star_named_expression_rule(Parser *p);
+static expr_ty named_expression_rule(Parser *p);
+static expr_ty annotated_rhs_rule(Parser *p);
+static expr_ty expressions_rule(Parser *p);
+static expr_ty expression_rule(Parser *p);
+static expr_ty lambdef_rule(Parser *p);
+static arguments_ty lambda_parameters_rule(Parser *p);
+static asdl_seq* lambda_slash_without_default_rule(Parser *p);
+static SlashWithDefault* lambda_slash_with_default_rule(Parser *p);
+static StarEtc* lambda_star_etc_rule(Parser *p);
+static NameDefaultPair* lambda_name_with_optional_default_rule(Parser *p);
+static asdl_seq* lambda_names_with_default_rule(Parser *p);
+static NameDefaultPair* lambda_name_with_default_rule(Parser *p);
+static asdl_seq* lambda_plain_names_rule(Parser *p);
+static arg_ty lambda_plain_name_rule(Parser *p);
+static arg_ty lambda_kwds_rule(Parser *p);
+static expr_ty disjunction_rule(Parser *p);
+static expr_ty conjunction_rule(Parser *p);
+static expr_ty inversion_rule(Parser *p);
+static expr_ty comparison_rule(Parser *p);
+static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p);
+static CmpopExprPair* eq_bitwise_or_rule(Parser *p);
+static CmpopExprPair* noteq_bitwise_or_rule(Parser *p);
+static CmpopExprPair* lte_bitwise_or_rule(Parser *p);
+static CmpopExprPair* lt_bitwise_or_rule(Parser *p);
+static CmpopExprPair* gte_bitwise_or_rule(Parser *p);
+static CmpopExprPair* gt_bitwise_or_rule(Parser *p);
+static CmpopExprPair* notin_bitwise_or_rule(Parser *p);
+static CmpopExprPair* in_bitwise_or_rule(Parser *p);
+static CmpopExprPair* isnot_bitwise_or_rule(Parser *p);
+static CmpopExprPair* is_bitwise_or_rule(Parser *p);
+static expr_ty bitwise_or_rule(Parser *p);
+static expr_ty bitwise_xor_rule(Parser *p);
+static expr_ty bitwise_and_rule(Parser *p);
+static expr_ty shift_expr_rule(Parser *p);
+static expr_ty sum_rule(Parser *p);
+static expr_ty term_rule(Parser *p);
+static expr_ty factor_rule(Parser *p);
+static expr_ty power_rule(Parser *p);
+static expr_ty await_primary_rule(Parser *p);
+static expr_ty primary_rule(Parser *p);
+static expr_ty slices_rule(Parser *p);
+static expr_ty slice_rule(Parser *p);
+static expr_ty atom_rule(Parser *p);
+static expr_ty strings_rule(Parser *p);
+static expr_ty list_rule(Parser *p);
+static expr_ty listcomp_rule(Parser *p);
+static expr_ty tuple_rule(Parser *p);
+static expr_ty group_rule(Parser *p);
+static expr_ty genexp_rule(Parser *p);
+static expr_ty set_rule(Parser *p);
+static expr_ty setcomp_rule(Parser *p);
+static expr_ty dict_rule(Parser *p);
+static expr_ty dictcomp_rule(Parser *p);
+static asdl_seq* kvpairs_rule(Parser *p);
+static KeyValuePair* kvpair_rule(Parser *p);
+static asdl_seq* for_if_clauses_rule(Parser *p);
+static expr_ty yield_expr_rule(Parser *p);
+static expr_ty arguments_rule(Parser *p);
+static expr_ty args_rule(Parser *p);
+static asdl_seq* kwargs_rule(Parser *p);
+static expr_ty starred_expression_rule(Parser *p);
+static KeywordOrStarred* kwarg_or_starred_rule(Parser *p);
+static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p);
+static expr_ty star_targets_rule(Parser *p);
+static asdl_seq* star_targets_seq_rule(Parser *p);
+static expr_ty star_target_rule(Parser *p);
+static expr_ty star_atom_rule(Parser *p);
+static expr_ty inside_paren_ann_assign_target_rule(Parser *p);
+static expr_ty ann_assign_subscript_attribute_target_rule(Parser *p);
+static asdl_seq* del_targets_rule(Parser *p);
+static expr_ty del_target_rule(Parser *p);
+static expr_ty del_t_atom_rule(Parser *p);
+static asdl_seq* targets_rule(Parser *p);
+static expr_ty target_rule(Parser *p);
+static expr_ty t_primary_rule(Parser *p);
+static void *t_lookahead_rule(Parser *p);
+static expr_ty t_atom_rule(Parser *p);
+static void *incorrect_arguments_rule(Parser *p);
+static void *invalid_named_expression_rule(Parser *p);
+static void *invalid_assignment_rule(Parser *p);
+static void *invalid_block_rule(Parser *p);
+static void *invalid_comprehension_rule(Parser *p);
+static void *invalid_parameters_rule(Parser *p);
+static asdl_seq *_loop0_1_rule(Parser *p);
+static asdl_seq *_loop1_2_rule(Parser *p);
+static asdl_seq *_loop0_4_rule(Parser *p);
+static asdl_seq *_gather_3_rule(Parser *p);
+static void *_tmp_5_rule(Parser *p);
+static void *_tmp_6_rule(Parser *p);
+static void *_tmp_7_rule(Parser *p);
+static void *_tmp_8_rule(Parser *p);
+static void *_tmp_9_rule(Parser *p);
+static void *_tmp_10_rule(Parser *p);
+static void *_tmp_11_rule(Parser *p);
+static void *_tmp_12_rule(Parser *p);
+static asdl_seq *_loop1_13_rule(Parser *p);
+static void *_tmp_14_rule(Parser *p);
+static void *_tmp_15_rule(Parser *p);
+static asdl_seq *_loop0_17_rule(Parser *p);
+static asdl_seq *_gather_16_rule(Parser *p);
+static asdl_seq *_loop0_19_rule(Parser *p);
+static asdl_seq *_gather_18_rule(Parser *p);
+static void *_tmp_20_rule(Parser *p);
+static asdl_seq *_loop0_21_rule(Parser *p);
+static asdl_seq *_loop1_22_rule(Parser *p);
+static asdl_seq *_loop0_24_rule(Parser *p);
+static asdl_seq *_gather_23_rule(Parser *p);
+static void *_tmp_25_rule(Parser *p);
+static asdl_seq *_loop0_27_rule(Parser *p);
+static asdl_seq *_gather_26_rule(Parser *p);
+static void *_tmp_28_rule(Parser *p);
+static asdl_seq *_loop0_30_rule(Parser *p);
+static asdl_seq *_gather_29_rule(Parser *p);
+static asdl_seq *_loop0_32_rule(Parser *p);
+static asdl_seq *_gather_31_rule(Parser *p);
+static void *_tmp_33_rule(Parser *p);
+static asdl_seq *_loop1_34_rule(Parser *p);
+static void *_tmp_35_rule(Parser *p);
+static void *_tmp_36_rule(Parser *p);
+static void *_tmp_37_rule(Parser *p);
+static void *_tmp_38_rule(Parser *p);
+static void *_tmp_39_rule(Parser *p);
+static void *_tmp_40_rule(Parser *p);
+static void *_tmp_41_rule(Parser *p);
+static void *_tmp_42_rule(Parser *p);
+static void *_tmp_43_rule(Parser *p);
+static void *_tmp_44_rule(Parser *p);
+static void *_tmp_45_rule(Parser *p);
+static void *_tmp_46_rule(Parser *p);
+static asdl_seq *_loop0_47_rule(Parser *p);
+static void *_tmp_48_rule(Parser *p);
+static asdl_seq *_loop1_49_rule(Parser *p);
+static void *_tmp_50_rule(Parser *p);
+static void *_tmp_51_rule(Parser *p);
+static asdl_seq *_loop0_53_rule(Parser *p);
+static asdl_seq *_gather_52_rule(Parser *p);
+static asdl_seq *_loop0_55_rule(Parser *p);
+static asdl_seq *_gather_54_rule(Parser *p);
+static void *_tmp_56_rule(Parser *p);
+static asdl_seq *_loop1_57_rule(Parser *p);
+static void *_tmp_58_rule(Parser *p);
+static asdl_seq *_loop0_60_rule(Parser *p);
+static asdl_seq *_gather_59_rule(Parser *p);
+static asdl_seq *_loop1_61_rule(Parser *p);
+static asdl_seq *_loop0_63_rule(Parser *p);
+static asdl_seq *_gather_62_rule(Parser *p);
+static asdl_seq *_loop1_64_rule(Parser *p);
+static void *_tmp_65_rule(Parser *p);
+static void *_tmp_66_rule(Parser *p);
+static void *_tmp_67_rule(Parser *p);
+static void *_tmp_68_rule(Parser *p);
+static void *_tmp_69_rule(Parser *p);
+static void *_tmp_70_rule(Parser *p);
+static void *_tmp_71_rule(Parser *p);
+static void *_tmp_72_rule(Parser *p);
+static void *_tmp_73_rule(Parser *p);
+static asdl_seq *_loop0_74_rule(Parser *p);
+static void *_tmp_75_rule(Parser *p);
+static asdl_seq *_loop1_76_rule(Parser *p);
+static void *_tmp_77_rule(Parser *p);
+static void *_tmp_78_rule(Parser *p);
+static asdl_seq *_loop0_80_rule(Parser *p);
+static asdl_seq *_gather_79_rule(Parser *p);
+static asdl_seq *_loop0_82_rule(Parser *p);
+static asdl_seq *_gather_81_rule(Parser *p);
+static asdl_seq *_loop1_83_rule(Parser *p);
+static asdl_seq *_loop1_84_rule(Parser *p);
+static asdl_seq *_loop1_85_rule(Parser *p);
+static asdl_seq *_loop0_87_rule(Parser *p);
+static asdl_seq *_gather_86_rule(Parser *p);
+static void *_tmp_88_rule(Parser *p);
+static void *_tmp_89_rule(Parser *p);
+static void *_tmp_90_rule(Parser *p);
+static void *_tmp_91_rule(Parser *p);
+static asdl_seq *_loop1_92_rule(Parser *p);
+static void *_tmp_93_rule(Parser *p);
+static void *_tmp_94_rule(Parser *p);
+static asdl_seq *_loop0_96_rule(Parser *p);
+static asdl_seq *_gather_95_rule(Parser *p);
+static asdl_seq *_loop1_97_rule(Parser *p);
+static void *_tmp_98_rule(Parser *p);
+static void *_tmp_99_rule(Parser *p);
+static asdl_seq *_loop0_101_rule(Parser *p);
+static asdl_seq *_gather_100_rule(Parser *p);
+static asdl_seq *_loop0_103_rule(Parser *p);
+static asdl_seq *_gather_102_rule(Parser *p);
+static asdl_seq *_loop0_105_rule(Parser *p);
+static asdl_seq *_gather_104_rule(Parser *p);
+static asdl_seq *_loop0_107_rule(Parser *p);
+static asdl_seq *_gather_106_rule(Parser *p);
+static asdl_seq *_loop0_108_rule(Parser *p);
+static asdl_seq *_loop0_110_rule(Parser *p);
+static asdl_seq *_gather_109_rule(Parser *p);
+static void *_tmp_111_rule(Parser *p);
+static asdl_seq *_loop0_113_rule(Parser *p);
+static asdl_seq *_gather_112_rule(Parser *p);
+static asdl_seq *_loop0_115_rule(Parser *p);
+static asdl_seq *_gather_114_rule(Parser *p);
+static void *_tmp_116_rule(Parser *p);
+static void *_tmp_117_rule(Parser *p);
+static void *_tmp_118_rule(Parser *p);
+static void *_tmp_119_rule(Parser *p);
+static void *_tmp_120_rule(Parser *p);
+static void *_tmp_121_rule(Parser *p);
+static void *_tmp_122_rule(Parser *p);
+static void *_tmp_123_rule(Parser *p);
+static void *_tmp_124_rule(Parser *p);
+static void *_tmp_125_rule(Parser *p);
+static void *_tmp_126_rule(Parser *p);
+static void *_tmp_127_rule(Parser *p);
+static void *_tmp_128_rule(Parser *p);
+static void *_tmp_129_rule(Parser *p);
+static void *_tmp_130_rule(Parser *p);
+static void *_tmp_131_rule(Parser *p);
+static void *_tmp_132_rule(Parser *p);
+static void *_tmp_133_rule(Parser *p);
+static void *_tmp_134_rule(Parser *p);
+static asdl_seq *_loop0_135_rule(Parser *p);
+static void *_tmp_136_rule(Parser *p);
+
+
+// file: statements? $
+static mod_ty
+file_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    mod_ty res = NULL;
+    int mark = p->mark;
+    { // statements? $
+        void *a;
+        void *endmarker_var;
+        if (
+            (a = statements_rule(p), 1)
+            &&
+            (endmarker_var = _PyPegen_endmarker_token(p))
+        )
+        {
+            res = Module ( a , NULL , p -> arena );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// interactive: statement_newline
+static mod_ty
+interactive_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    mod_ty res = NULL;
+    int mark = p->mark;
+    { // statement_newline
+        asdl_seq* a;
+        if (
+            (a = statement_newline_rule(p))
+        )
+        {
+            res = Interactive ( a , p -> arena );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// eval: expressions NEWLINE* $
+static mod_ty
+eval_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    mod_ty res = NULL;
+    int mark = p->mark;
+    { // expressions NEWLINE* $
+        asdl_seq * _loop0_1_var;
+        expr_ty a;
+        void *endmarker_var;
+        if (
+            (a = expressions_rule(p))
+            &&
+            (_loop0_1_var = _loop0_1_rule(p))
+            &&
+            (endmarker_var = _PyPegen_endmarker_token(p))
+        )
+        {
+            res = Expression ( a , p -> arena );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// fstring: star_expressions
+static expr_ty
+fstring_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    { // star_expressions
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))
+        )
+        {
+            res = star_expressions_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// statements: statement+
+static asdl_seq*
+statements_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // statement+
+        asdl_seq * a;
+        if (
+            (a = _loop1_2_rule(p))
+        )
+        {
+            res = _PyPegen_seq_flatten ( p , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// statement: compound_stmt | simple_stmt
+static asdl_seq*
+statement_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // compound_stmt
+        stmt_ty a;
+        if (
+            (a = compound_stmt_rule(p))
+        )
+        {
+            res = _PyPegen_singleton_seq ( p , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // simple_stmt
+        asdl_seq* simple_stmt_var;
+        if (
+            (simple_stmt_var = simple_stmt_rule(p))
+        )
+        {
+            res = simple_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// statement_newline: compound_stmt NEWLINE | simple_stmt | NEWLINE | $
+static asdl_seq*
+statement_newline_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // compound_stmt NEWLINE
+        stmt_ty a;
+        void *newline_var;
+        if (
+            (a = compound_stmt_rule(p))
+            &&
+            (newline_var = _PyPegen_newline_token(p))
+        )
+        {
+            res = _PyPegen_singleton_seq ( p , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // simple_stmt
+        asdl_seq* simple_stmt_var;
+        if (
+            (simple_stmt_var = simple_stmt_rule(p))
+        )
+        {
+            res = simple_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // NEWLINE
+        void *newline_var;
+        if (
+            (newline_var = _PyPegen_newline_token(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _PyPegen_singleton_seq ( p , CHECK ( _Py_Pass ( EXTRA ) ) );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // $
+        void *endmarker_var;
+        if (
+            (endmarker_var = _PyPegen_endmarker_token(p))
+        )
+        {
+            res = _PyPegen_interactive_exit ( p );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// simple_stmt: small_stmt !';' NEWLINE | ';'.small_stmt+ ';'? NEWLINE
+static asdl_seq*
+simple_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // small_stmt !';' NEWLINE
+        stmt_ty a;
+        void *newline_var;
+        if (
+            (a = small_stmt_rule(p))
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13)
+            &&
+            (newline_var = _PyPegen_newline_token(p))
+        )
+        {
+            res = _PyPegen_singleton_seq ( p , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ';'.small_stmt+ ';'? NEWLINE
+        asdl_seq * a;
+        void *newline_var;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = _gather_3_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 13), 1)
+            &&
+            (newline_var = _PyPegen_newline_token(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// small_stmt:
+//     | assignment
+//     | star_expressions
+//     | &'return' return_stmt
+//     | &('import' | 'from') import_stmt
+//     | &'raise' raise_stmt
+//     | 'pass'
+//     | &'del' del_stmt
+//     | &'yield' yield_stmt
+//     | &'assert' assert_stmt
+//     | 'break'
+//     | 'continue'
+//     | &'global' global_stmt
+//     | &'nonlocal' nonlocal_stmt
+static stmt_ty
+small_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    if (_PyPegen_is_memoized(p, small_stmt_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // assignment
+        void *assignment_var;
+        if (
+            (assignment_var = assignment_rule(p))
+        )
+        {
+            res = assignment_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_expressions
+        expr_ty e;
+        if (
+            (e = star_expressions_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Expr ( e , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'return' return_stmt
+        stmt_ty return_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 500)
+            &&
+            (return_stmt_var = return_stmt_rule(p))
+        )
+        {
+            res = return_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &('import' | 'from') import_stmt
+        stmt_ty import_stmt_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_5_rule, p)
+            &&
+            (import_stmt_var = import_stmt_rule(p))
+        )
+        {
+            res = import_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'raise' raise_stmt
+        stmt_ty raise_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 501)
+            &&
+            (raise_stmt_var = raise_stmt_rule(p))
+        )
+        {
+            res = raise_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'pass'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 502))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Pass ( EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'del' del_stmt
+        stmt_ty del_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 503)
+            &&
+            (del_stmt_var = del_stmt_rule(p))
+        )
+        {
+            res = del_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'yield' yield_stmt
+        stmt_ty yield_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 504)
+            &&
+            (yield_stmt_var = yield_stmt_rule(p))
+        )
+        {
+            res = yield_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'assert' assert_stmt
+        stmt_ty assert_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 505)
+            &&
+            (assert_stmt_var = assert_stmt_rule(p))
+        )
+        {
+            res = assert_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'break'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 506))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Break ( EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'continue'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 507))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Continue ( EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'global' global_stmt
+        stmt_ty global_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 508)
+            &&
+            (global_stmt_var = global_stmt_rule(p))
+        )
+        {
+            res = global_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'nonlocal' nonlocal_stmt
+        stmt_ty nonlocal_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 509)
+            &&
+            (nonlocal_stmt_var = nonlocal_stmt_rule(p))
+        )
+        {
+            res = nonlocal_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, small_stmt_type, res);
+    return res;
+}
+
+// compound_stmt:
+//     | &('def' | '@' | ASYNC) function_def
+//     | &'if' if_stmt
+//     | &('class' | '@') class_def
+//     | &('with' | ASYNC) with_stmt
+//     | &('for' | ASYNC) for_stmt
+//     | &'try' try_stmt
+//     | &'while' while_stmt
+static stmt_ty
+compound_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    { // &('def' | '@' | ASYNC) function_def
+        stmt_ty function_def_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_6_rule, p)
+            &&
+            (function_def_var = function_def_rule(p))
+        )
+        {
+            res = function_def_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'if' if_stmt
+        stmt_ty if_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 510)
+            &&
+            (if_stmt_var = if_stmt_rule(p))
+        )
+        {
+            res = if_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &('class' | '@') class_def
+        stmt_ty class_def_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_7_rule, p)
+            &&
+            (class_def_var = class_def_rule(p))
+        )
+        {
+            res = class_def_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &('with' | ASYNC) with_stmt
+        stmt_ty with_stmt_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_8_rule, p)
+            &&
+            (with_stmt_var = with_stmt_rule(p))
+        )
+        {
+            res = with_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &('for' | ASYNC) for_stmt
+        stmt_ty for_stmt_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_9_rule, p)
+            &&
+            (for_stmt_var = for_stmt_rule(p))
+        )
+        {
+            res = for_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'try' try_stmt
+        stmt_ty try_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 511)
+            &&
+            (try_stmt_var = try_stmt_rule(p))
+        )
+        {
+            res = try_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'while' while_stmt
+        stmt_ty while_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 512)
+            &&
+            (while_stmt_var = while_stmt_rule(p))
+        )
+        {
+            res = while_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// assignment:
+//     | NAME ':' expression ['=' annotated_rhs]
+//     | ('(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target) ':' expression ['=' annotated_rhs]
+//     | ((star_targets '='))+ (yield_expr | star_expressions)
+//     | target augassign (yield_expr | star_expressions)
+//     | invalid_assignment
+static void *
+assignment_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME ':' expression ['=' annotated_rhs]
+        expr_ty a;
+        expr_ty b;
+        void *c;
+        void *literal;
+        if (
+            (a = _PyPegen_name_token(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = expression_rule(p))
+            &&
+            (c = _tmp_10_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_AnnAssign ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , c , 1 , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ('(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target) ':' expression ['=' annotated_rhs]
+        void *a;
+        expr_ty b;
+        void *c;
+        void *literal;
+        if (
+            (a = _tmp_11_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = expression_rule(p))
+            &&
+            (c = _tmp_12_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_AnnAssign ( a , b , c , 0 , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ((star_targets '='))+ (yield_expr | star_expressions)
+        asdl_seq * a;
+        void *b;
+        if (
+            (a = _loop1_13_rule(p))
+            &&
+            (b = _tmp_14_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Assign ( a , b , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // target augassign (yield_expr | star_expressions)
+        expr_ty a;
+        AugOperator* b;
+        void *c;
+        if (
+            (a = target_rule(p))
+            &&
+            (b = augassign_rule(p))
+            &&
+            (c = _tmp_15_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_AugAssign ( a , b -> kind , c , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // invalid_assignment
+        void *invalid_assignment_var;
+        if (
+            (invalid_assignment_var = invalid_assignment_rule(p))
+        )
+        {
+            res = invalid_assignment_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// augassign:
+//     | '+='
+//     | '-='
+//     | '*='
+//     | '@='
+//     | '/='
+//     | '%='
+//     | '&='
+//     | '|='
+//     | '^='
+//     | '<<='
+//     | '>>='
+//     | '**='
+//     | '//='
+static AugOperator*
+augassign_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    AugOperator* res = NULL;
+    int mark = p->mark;
+    { // '+='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 36))
+        )
+        {
+            res = _PyPegen_augoperator ( p , Add );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '-='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 37))
+        )
+        {
+            res = _PyPegen_augoperator ( p , Sub );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '*='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 38))
+        )
+        {
+            res = _PyPegen_augoperator ( p , Mult );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '@='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 50))
+        )
+        {
+            res = _PyPegen_augoperator ( p , MatMult );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '/='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 39))
+        )
+        {
+            res = _PyPegen_augoperator ( p , Div );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '%='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 40))
+        )
+        {
+            res = _PyPegen_augoperator ( p , Mod );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '&='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 41))
+        )
+        {
+            res = _PyPegen_augoperator ( p , BitAnd );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '|='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 42))
+        )
+        {
+            res = _PyPegen_augoperator ( p , BitOr );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '^='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 43))
+        )
+        {
+            res = _PyPegen_augoperator ( p , BitXor );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '<<='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 44))
+        )
+        {
+            res = _PyPegen_augoperator ( p , LShift );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '>>='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 45))
+        )
+        {
+            res = _PyPegen_augoperator ( p , RShift );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '**='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 46))
+        )
+        {
+            res = _PyPegen_augoperator ( p , Pow );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '//='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 48))
+        )
+        {
+            res = _PyPegen_augoperator ( p , FloorDiv );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// global_stmt: 'global' ','.NAME+
+static stmt_ty
+global_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'global' ','.NAME+
+        asdl_seq * a;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 508))
+            &&
+            (a = _gather_16_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Global ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// nonlocal_stmt: 'nonlocal' ','.NAME+
+static stmt_ty
+nonlocal_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'nonlocal' ','.NAME+
+        asdl_seq * a;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 509))
+            &&
+            (a = _gather_18_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Nonlocal ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// yield_stmt: yield_expr
+static stmt_ty
+yield_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // yield_expr
+        expr_ty y;
+        if (
+            (y = yield_expr_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Expr ( y , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// assert_stmt: 'assert' expression [',' expression]
+static stmt_ty
+assert_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'assert' expression [',' expression]
+        expr_ty a;
+        void *b;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 505))
+            &&
+            (a = expression_rule(p))
+            &&
+            (b = _tmp_20_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Assert ( a , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// del_stmt: 'del' del_targets
+static stmt_ty
+del_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'del' del_targets
+        asdl_seq* a;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 503))
+            &&
+            (a = del_targets_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Delete ( a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// import_stmt: import_name | import_from
+static stmt_ty
+import_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    { // import_name
+        stmt_ty import_name_var;
+        if (
+            (import_name_var = import_name_rule(p))
+        )
+        {
+            res = import_name_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // import_from
+        stmt_ty import_from_var;
+        if (
+            (import_from_var = import_from_rule(p))
+        )
+        {
+            res = import_from_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// import_name: 'import' dotted_as_names
+static stmt_ty
+import_name_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'import' dotted_as_names
+        asdl_seq* a;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 513))
+            &&
+            (a = dotted_as_names_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Import ( a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// import_from:
+//     | 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
+//     | 'from' (('.' | '...'))+ 'import' import_from_targets
+static stmt_ty
+import_from_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
+        asdl_seq * a;
+        expr_ty b;
+        asdl_seq* c;
+        void *keyword;
+        void *keyword_1;
+        if (
+            (keyword = _PyPegen_expect_token(p, 514))
+            &&
+            (a = _loop0_21_rule(p))
+            &&
+            (b = dotted_name_rule(p))
+            &&
+            (keyword_1 = _PyPegen_expect_token(p, 513))
+            &&
+            (c = import_from_targets_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'from' (('.' | '...'))+ 'import' import_from_targets
+        asdl_seq * a;
+        asdl_seq* b;
+        void *keyword;
+        void *keyword_1;
+        if (
+            (keyword = _PyPegen_expect_token(p, 514))
+            &&
+            (a = _loop1_22_rule(p))
+            &&
+            (keyword_1 = _PyPegen_expect_token(p, 513))
+            &&
+            (b = import_from_targets_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// import_from_targets: '(' import_from_as_names ','? ')' | import_from_as_names | '*'
+static asdl_seq*
+import_from_targets_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // '(' import_from_as_names ','? ')'
+        asdl_seq* a;
+        void *literal;
+        void *literal_1;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = import_from_as_names_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // import_from_as_names
+        asdl_seq* import_from_as_names_var;
+        if (
+            (import_from_as_names_var = import_from_as_names_rule(p))
+        )
+        {
+            res = import_from_as_names_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '*'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 16))
+        )
+        {
+            res = _PyPegen_singleton_seq ( p , CHECK ( _PyPegen_alias_for_star ( p ) ) );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// import_from_as_names: ','.import_from_as_name+
+static asdl_seq*
+import_from_as_names_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.import_from_as_name+
+        asdl_seq * a;
+        if (
+            (a = _gather_23_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// import_from_as_name: NAME ['as' NAME]
+static alias_ty
+import_from_as_name_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    alias_ty res = NULL;
+    int mark = p->mark;
+    { // NAME ['as' NAME]
+        expr_ty a;
+        void *b;
+        if (
+            (a = _PyPegen_name_token(p))
+            &&
+            (b = _tmp_25_rule(p), 1)
+        )
+        {
+            res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// dotted_as_names: ','.dotted_as_name+
+static asdl_seq*
+dotted_as_names_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.dotted_as_name+
+        asdl_seq * a;
+        if (
+            (a = _gather_26_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// dotted_as_name: dotted_name ['as' NAME]
+static alias_ty
+dotted_as_name_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    alias_ty res = NULL;
+    int mark = p->mark;
+    { // dotted_name ['as' NAME]
+        expr_ty a;
+        void *b;
+        if (
+            (a = dotted_name_rule(p))
+            &&
+            (b = _tmp_28_rule(p), 1)
+        )
+        {
+            res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// Left-recursive
+// dotted_name: dotted_name '.' NAME | NAME
+static expr_ty dotted_name_raw(Parser *);
+static expr_ty
+dotted_name_rule(Parser *p)
+{
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, dotted_name_type, &res))
+        return res;
+    int mark = p->mark;
+    int resmark = p->mark;
+    while (1) {
+        int tmpvar_0 = _PyPegen_update_memo(p, mark, dotted_name_type, res);
+        if (tmpvar_0) {
+            return res;
+        }
+        p->mark = mark;
+        void *raw = dotted_name_raw(p);
+        if (raw == NULL || p->mark <= resmark)
+            break;
+        resmark = p->mark;
+        res = raw;
+    }
+    p->mark = resmark;
+    return res;
+}
+static expr_ty
+dotted_name_raw(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    { // dotted_name '.' NAME
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = dotted_name_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 23))
+            &&
+            (b = _PyPegen_name_token(p))
+        )
+        {
+            res = _PyPegen_join_names_with_dot ( p , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // NAME
+        expr_ty name_var;
+        if (
+            (name_var = _PyPegen_name_token(p))
+        )
+        {
+            res = name_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// if_stmt:
+//     | 'if' named_expression ':' block elif_stmt
+//     | 'if' named_expression ':' block else_block?
+static stmt_ty
+if_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'if' named_expression ':' block elif_stmt
+        expr_ty a;
+        asdl_seq* b;
+        stmt_ty c;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 510))
+            &&
+            (a = named_expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+            &&
+            (c = elif_stmt_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'if' named_expression ':' block else_block?
+        expr_ty a;
+        asdl_seq* b;
+        void *c;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 510))
+            &&
+            (a = named_expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+            &&
+            (c = else_block_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_If ( a , b , c , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// elif_stmt:
+//     | 'elif' named_expression ':' block elif_stmt
+//     | 'elif' named_expression ':' block else_block?
+static stmt_ty
+elif_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'elif' named_expression ':' block elif_stmt
+        expr_ty a;
+        asdl_seq* b;
+        stmt_ty c;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 515))
+            &&
+            (a = named_expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+            &&
+            (c = elif_stmt_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'elif' named_expression ':' block else_block?
+        expr_ty a;
+        asdl_seq* b;
+        void *c;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 515))
+            &&
+            (a = named_expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+            &&
+            (c = else_block_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_If ( a , b , c , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// else_block: 'else' ':' block
+static asdl_seq*
+else_block_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // 'else' ':' block
+        asdl_seq* b;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 516))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+        )
+        {
+            res = b;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// while_stmt: 'while' named_expression ':' block else_block?
+static stmt_ty
+while_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'while' named_expression ':' block else_block?
+        expr_ty a;
+        asdl_seq* b;
+        void *c;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 512))
+            &&
+            (a = named_expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+            &&
+            (c = else_block_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_While ( a , b , c , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// for_stmt: ASYNC? 'for' star_targets 'in' star_expressions ':' block else_block?
+static stmt_ty
+for_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // ASYNC? 'for' star_targets 'in' star_expressions ':' block else_block?
+        asdl_seq* b;
+        void *el;
+        expr_ty ex;
+        void *is_async;
+        void *keyword;
+        void *keyword_1;
+        void *literal;
+        expr_ty t;
+        if (
+            (is_async = _PyPegen_async_token(p), 1)
+            &&
+            (keyword = _PyPegen_expect_token(p, 517))
+            &&
+            (t = star_targets_rule(p))
+            &&
+            (keyword_1 = _PyPegen_expect_token(p, 518))
+            &&
+            (ex = star_expressions_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+            &&
+            (el = else_block_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = ( is_async ? _Py_AsyncFor : _Py_For ) ( t , ex , b , el , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// with_stmt:
+//     | ASYNC? 'with' '(' ','.with_item+ ')' ':' block
+//     | ASYNC? 'with' ','.with_item+ ':' block
+static stmt_ty
+with_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // ASYNC? 'with' '(' ','.with_item+ ')' ':' block
+        asdl_seq * a;
+        asdl_seq* b;
+        void *is_async;
+        void *keyword;
+        void *literal;
+        void *literal_1;
+        void *literal_2;
+        if (
+            (is_async = _PyPegen_async_token(p), 1)
+            &&
+            (keyword = _PyPegen_expect_token(p, 519))
+            &&
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = _gather_29_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+            &&
+            (literal_2 = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = ( is_async ? _Py_AsyncWith : _Py_With ) ( a , b , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ASYNC? 'with' ','.with_item+ ':' block
+        asdl_seq * a;
+        asdl_seq* b;
+        void *is_async;
+        void *keyword;
+        void *literal;
+        if (
+            (is_async = _PyPegen_async_token(p), 1)
+            &&
+            (keyword = _PyPegen_expect_token(p, 519))
+            &&
+            (a = _gather_31_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = ( is_async ? _Py_AsyncWith : _Py_With ) ( a , b , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// with_item: expression ['as' target]
+static withitem_ty
+with_item_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    withitem_ty res = NULL;
+    int mark = p->mark;
+    { // expression ['as' target]
+        expr_ty e;
+        void *o;
+        if (
+            (e = expression_rule(p))
+            &&
+            (o = _tmp_33_rule(p), 1)
+        )
+        {
+            res = _Py_withitem ( e , o , p -> arena );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// try_stmt:
+//     | 'try' ':' block finally_block
+//     | 'try' ':' block except_block+ else_block? finally_block?
+static stmt_ty
+try_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'try' ':' block finally_block
+        asdl_seq* b;
+        asdl_seq* f;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 511))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+            &&
+            (f = finally_block_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Try ( b , NULL , NULL , f , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'try' ':' block except_block+ else_block? finally_block?
+        asdl_seq* b;
+        void *el;
+        asdl_seq * ex;
+        void *f;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 511))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+            &&
+            (ex = _loop1_34_rule(p))
+            &&
+            (el = else_block_rule(p), 1)
+            &&
+            (f = finally_block_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Try ( b , ex , el , f , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// except_block: 'except' expression ['as' target] ':' block | 'except' ':' block
+static excepthandler_ty
+except_block_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    excepthandler_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'except' expression ['as' target] ':' block
+        asdl_seq* b;
+        expr_ty e;
+        void *keyword;
+        void *literal;
+        void *t;
+        if (
+            (keyword = _PyPegen_expect_token(p, 520))
+            &&
+            (e = expression_rule(p))
+            &&
+            (t = _tmp_35_rule(p), 1)
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'except' ':' block
+        asdl_seq* b;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 520))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_ExceptHandler ( NULL , NULL , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// finally_block: 'finally' ':' block
+static asdl_seq*
+finally_block_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // 'finally' ':' block
+        asdl_seq* a;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 521))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (a = block_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// return_stmt: 'return' star_expressions?
+static stmt_ty
+return_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'return' star_expressions?
+        void *a;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 500))
+            &&
+            (a = star_expressions_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Return ( a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// raise_stmt: 'raise' expression ['from' expression] | 'raise'
+static stmt_ty
+raise_stmt_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'raise' expression ['from' expression]
+        expr_ty a;
+        void *b;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 501))
+            &&
+            (a = expression_rule(p))
+            &&
+            (b = _tmp_36_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Raise ( a , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'raise'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 501))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Raise ( NULL , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// function_def: decorators function_def_raw | function_def_raw
+static stmt_ty
+function_def_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    { // decorators function_def_raw
+        asdl_seq* d;
+        stmt_ty f;
+        if (
+            (d = decorators_rule(p))
+            &&
+            (f = function_def_raw_rule(p))
+        )
+        {
+            res = _PyPegen_function_def_decorators ( p , d , f );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // function_def_raw
+        stmt_ty function_def_raw_var;
+        if (
+            (function_def_raw_var = function_def_raw_rule(p))
+        )
+        {
+            res = function_def_raw_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// function_def_raw: ASYNC? 'def' NAME '(' params? ')' ['->' annotation] ':' block
+static stmt_ty
+function_def_raw_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // ASYNC? 'def' NAME '(' params? ')' ['->' annotation] ':' block
+        void *a;
+        asdl_seq* b;
+        void *is_async;
+        void *keyword;
+        void *literal;
+        void *literal_1;
+        void *literal_2;
+        expr_ty n;
+        void *params;
+        if (
+            (is_async = _PyPegen_async_token(p), 1)
+            &&
+            (keyword = _PyPegen_expect_token(p, 522))
+            &&
+            (n = _PyPegen_name_token(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (params = params_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+            &&
+            (a = _tmp_37_rule(p), 1)
+            &&
+            (literal_2 = _PyPegen_expect_token(p, 11))
+            &&
+            (b = block_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = ( is_async ? _Py_AsyncFunctionDef : _Py_FunctionDef ) ( n -> v . Name . id , ( params ) ? params : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// params: invalid_parameters | parameters
+static arguments_ty
+params_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    arguments_ty res = NULL;
+    int mark = p->mark;
+    { // invalid_parameters
+        void *invalid_parameters_var;
+        if (
+            (invalid_parameters_var = invalid_parameters_rule(p))
+        )
+        {
+            res = invalid_parameters_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // parameters
+        arguments_ty parameters_var;
+        if (
+            (parameters_var = parameters_rule(p))
+        )
+        {
+            res = parameters_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// parameters:
+//     | slash_without_default [',' plain_names] [',' names_with_default] [',' star_etc?]
+//     | slash_with_default [',' names_with_default] [',' star_etc?]
+//     | plain_names [',' names_with_default] [',' star_etc?]
+//     | names_with_default [',' star_etc?]
+//     | star_etc
+static arguments_ty
+parameters_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    arguments_ty res = NULL;
+    int mark = p->mark;
+    { // slash_without_default [',' plain_names] [',' names_with_default] [',' star_etc?]
+        asdl_seq* a;
+        void *b;
+        void *c;
+        void *d;
+        if (
+            (a = slash_without_default_rule(p))
+            &&
+            (b = _tmp_38_rule(p), 1)
+            &&
+            (c = _tmp_39_rule(p), 1)
+            &&
+            (d = _tmp_40_rule(p), 1)
+        )
+        {
+            res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // slash_with_default [',' names_with_default] [',' star_etc?]
+        SlashWithDefault* a;
+        void *b;
+        void *c;
+        if (
+            (a = slash_with_default_rule(p))
+            &&
+            (b = _tmp_41_rule(p), 1)
+            &&
+            (c = _tmp_42_rule(p), 1)
+        )
+        {
+            res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // plain_names [',' names_with_default] [',' star_etc?]
+        asdl_seq* a;
+        void *b;
+        void *c;
+        if (
+            (a = plain_names_rule(p))
+            &&
+            (b = _tmp_43_rule(p), 1)
+            &&
+            (c = _tmp_44_rule(p), 1)
+        )
+        {
+            res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // names_with_default [',' star_etc?]
+        asdl_seq* a;
+        void *b;
+        if (
+            (a = names_with_default_rule(p))
+            &&
+            (b = _tmp_45_rule(p), 1)
+        )
+        {
+            res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_etc
+        StarEtc* a;
+        if (
+            (a = star_etc_rule(p))
+        )
+        {
+            res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// slash_without_default: plain_names ',' '/'
+static asdl_seq*
+slash_without_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // plain_names ',' '/'
+        asdl_seq* a;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = plain_names_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 17))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// slash_with_default: [plain_names ','] names_with_default ',' '/'
+static SlashWithDefault*
+slash_with_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    SlashWithDefault* res = NULL;
+    int mark = p->mark;
+    { // [plain_names ','] names_with_default ',' '/'
+        void *a;
+        asdl_seq* b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = _tmp_46_rule(p), 1)
+            &&
+            (b = names_with_default_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 17))
+        )
+        {
+            res = _PyPegen_slash_with_default ( p , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// star_etc:
+//     | '*' plain_name name_with_optional_default* [',' kwds] ','?
+//     | '*' name_with_optional_default+ [',' kwds] ','?
+//     | kwds ','?
+static StarEtc*
+star_etc_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    StarEtc* res = NULL;
+    int mark = p->mark;
+    { // '*' plain_name name_with_optional_default* [',' kwds] ','?
+        arg_ty a;
+        asdl_seq * b;
+        void *c;
+        void *literal;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (a = plain_name_rule(p))
+            &&
+            (b = _loop0_47_rule(p))
+            &&
+            (c = _tmp_48_rule(p), 1)
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = _PyPegen_star_etc ( p , a , b , c );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '*' name_with_optional_default+ [',' kwds] ','?
+        asdl_seq * b;
+        void *c;
+        void *literal;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (b = _loop1_49_rule(p))
+            &&
+            (c = _tmp_50_rule(p), 1)
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = _PyPegen_star_etc ( p , NULL , b , c );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // kwds ','?
+        arg_ty a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = kwds_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = _PyPegen_star_etc ( p , NULL , NULL , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// name_with_optional_default: ',' plain_name ['=' expression]
+static NameDefaultPair*
+name_with_optional_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    NameDefaultPair* res = NULL;
+    int mark = p->mark;
+    { // ',' plain_name ['=' expression]
+        arg_ty a;
+        void *b;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (a = plain_name_rule(p))
+            &&
+            (b = _tmp_51_rule(p), 1)
+        )
+        {
+            res = _PyPegen_name_default_pair ( p , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// names_with_default: ','.name_with_default+
+static asdl_seq*
+names_with_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.name_with_default+
+        asdl_seq * a;
+        if (
+            (a = _gather_52_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// name_with_default: plain_name '=' expression
+static NameDefaultPair*
+name_with_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    NameDefaultPair* res = NULL;
+    int mark = p->mark;
+    { // plain_name '=' expression
+        expr_ty e;
+        void *literal;
+        arg_ty n;
+        if (
+            (n = plain_name_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 22))
+            &&
+            (e = expression_rule(p))
+        )
+        {
+            res = _PyPegen_name_default_pair ( p , n , e );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// plain_names: ','.(plain_name !'=')+
+static asdl_seq*
+plain_names_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    if (_PyPegen_is_memoized(p, plain_names_type, &res))
+        return res;
+    int mark = p->mark;
+    { // ','.(plain_name !'=')+
+        asdl_seq * a;
+        if (
+            (a = _gather_54_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, plain_names_type, res);
+    return res;
+}
+
+// plain_name: NAME [':' annotation]
+static arg_ty
+plain_name_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    arg_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME [':' annotation]
+        expr_ty a;
+        void *b;
+        if (
+            (a = _PyPegen_name_token(p))
+            &&
+            (b = _tmp_56_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_arg ( a -> v . Name . id , b , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// kwds: '**' plain_name
+static arg_ty
+kwds_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    arg_ty res = NULL;
+    int mark = p->mark;
+    { // '**' plain_name
+        arg_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 35))
+            &&
+            (a = plain_name_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// annotation: expression
+static expr_ty
+annotation_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    { // expression
+        expr_ty expression_var;
+        if (
+            (expression_var = expression_rule(p))
+        )
+        {
+            res = expression_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// decorators: (('@' named_expression NEWLINE))+
+static asdl_seq*
+decorators_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // (('@' named_expression NEWLINE))+
+        asdl_seq * a;
+        if (
+            (a = _loop1_57_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// class_def: decorators class_def_raw | class_def_raw
+static stmt_ty
+class_def_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    { // decorators class_def_raw
+        asdl_seq* a;
+        stmt_ty b;
+        if (
+            (a = decorators_rule(p))
+            &&
+            (b = class_def_raw_rule(p))
+        )
+        {
+            res = _PyPegen_class_def_decorators ( p , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // class_def_raw
+        stmt_ty class_def_raw_var;
+        if (
+            (class_def_raw_var = class_def_raw_rule(p))
+        )
+        {
+            res = class_def_raw_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// class_def_raw: 'class' NAME ['(' arguments? ')'] ':' block
+static stmt_ty
+class_def_raw_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    stmt_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'class' NAME ['(' arguments? ')'] ':' block
+        expr_ty a;
+        void *b;
+        asdl_seq* c;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 523))
+            &&
+            (a = _PyPegen_name_token(p))
+            &&
+            (b = _tmp_58_rule(p), 1)
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (c = block_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , c , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// block: NEWLINE INDENT statements DEDENT | simple_stmt | invalid_block
+static asdl_seq*
+block_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    if (_PyPegen_is_memoized(p, block_type, &res))
+        return res;
+    int mark = p->mark;
+    { // NEWLINE INDENT statements DEDENT
+        asdl_seq* a;
+        void *dedent_var;
+        void *indent_var;
+        void *newline_var;
+        if (
+            (newline_var = _PyPegen_newline_token(p))
+            &&
+            (indent_var = _PyPegen_indent_token(p))
+            &&
+            (a = statements_rule(p))
+            &&
+            (dedent_var = _PyPegen_dedent_token(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // simple_stmt
+        asdl_seq* simple_stmt_var;
+        if (
+            (simple_stmt_var = simple_stmt_rule(p))
+        )
+        {
+            res = simple_stmt_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // invalid_block
+        void *invalid_block_var;
+        if (
+            (invalid_block_var = invalid_block_rule(p))
+        )
+        {
+            res = invalid_block_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, block_type, res);
+    return res;
+}
+
+// expressions_list: ','.star_expression+ ','?
+static asdl_seq*
+expressions_list_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.star_expression+ ','?
+        asdl_seq * a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = _gather_59_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// star_expressions:
+//     | star_expression ((',' star_expression))+ ','?
+//     | star_expression ','
+//     | star_expression
+static expr_ty
+star_expressions_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // star_expression ((',' star_expression))+ ','?
+        expr_ty a;
+        asdl_seq * b;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = star_expression_rule(p))
+            &&
+            (b = _loop1_61_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_expression ','
+        expr_ty a;
+        void *literal;
+        if (
+            (a = star_expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_expression
+        expr_ty star_expression_var;
+        if (
+            (star_expression_var = star_expression_rule(p))
+        )
+        {
+            res = star_expression_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// star_expression: '*' bitwise_or | expression
+static expr_ty
+star_expression_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, star_expression_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '*' bitwise_or
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Starred ( a , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression
+        expr_ty expression_var;
+        if (
+            (expression_var = expression_rule(p))
+        )
+        {
+            res = expression_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, star_expression_type, res);
+    return res;
+}
+
+// star_named_expressions: ','.star_named_expression+ ','?
+static asdl_seq*
+star_named_expressions_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.star_named_expression+ ','?
+        asdl_seq * a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = _gather_62_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// star_named_expression: '*' bitwise_or | named_expression
+static expr_ty
+star_named_expression_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '*' bitwise_or
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Starred ( a , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // named_expression
+        expr_ty named_expression_var;
+        if (
+            (named_expression_var = named_expression_rule(p))
+        )
+        {
+            res = named_expression_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// named_expression: NAME ':=' expression | expression !':=' | invalid_named_expression
+static expr_ty
+named_expression_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME ':=' expression
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = _PyPegen_name_token(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 53))
+            &&
+            (b = expression_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_NamedExpr ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression !':='
+        expr_ty expression_var;
+        if (
+            (expression_var = expression_rule(p))
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)
+        )
+        {
+            res = expression_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // invalid_named_expression
+        void *invalid_named_expression_var;
+        if (
+            (invalid_named_expression_var = invalid_named_expression_rule(p))
+        )
+        {
+            res = invalid_named_expression_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// annotated_rhs: yield_expr | star_expressions
+static expr_ty
+annotated_rhs_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    { // yield_expr
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))
+        )
+        {
+            res = yield_expr_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_expressions
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))
+        )
+        {
+            res = star_expressions_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// expressions: expression ((',' expression))+ ','? | expression ',' | expression
+static expr_ty
+expressions_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // expression ((',' expression))+ ','?
+        expr_ty a;
+        asdl_seq * b;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = expression_rule(p))
+            &&
+            (b = _loop1_64_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression ','
+        expr_ty a;
+        void *literal;
+        if (
+            (a = expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression
+        expr_ty expression_var;
+        if (
+            (expression_var = expression_rule(p))
+        )
+        {
+            res = expression_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// expression: disjunction 'if' disjunction 'else' expression | disjunction | lambdef
+static expr_ty
+expression_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, expression_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // disjunction 'if' disjunction 'else' expression
+        expr_ty a;
+        expr_ty b;
+        expr_ty c;
+        void *keyword;
+        void *keyword_1;
+        if (
+            (a = disjunction_rule(p))
+            &&
+            (keyword = _PyPegen_expect_token(p, 510))
+            &&
+            (b = disjunction_rule(p))
+            &&
+            (keyword_1 = _PyPegen_expect_token(p, 516))
+            &&
+            (c = expression_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_IfExp ( b , a , c , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // disjunction
+        expr_ty disjunction_var;
+        if (
+            (disjunction_var = disjunction_rule(p))
+        )
+        {
+            res = disjunction_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // lambdef
+        expr_ty lambdef_var;
+        if (
+            (lambdef_var = lambdef_rule(p))
+        )
+        {
+            res = lambdef_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, expression_type, res);
+    return res;
+}
+
+// lambdef: 'lambda' lambda_parameters? ':' expression
+static expr_ty
+lambdef_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'lambda' lambda_parameters? ':' expression
+        void *a;
+        expr_ty b;
+        void *keyword;
+        void *literal;
+        if (
+            (keyword = _PyPegen_expect_token(p, 524))
+            &&
+            (a = lambda_parameters_rule(p), 1)
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = expression_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Lambda ( ( a ) ? a : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_parameters:
+//     | lambda_slash_without_default [',' lambda_plain_names] [',' lambda_names_with_default] [',' lambda_star_etc?]
+//     | lambda_slash_with_default [',' lambda_names_with_default] [',' lambda_star_etc?]
+//     | lambda_plain_names [',' lambda_names_with_default] [',' lambda_star_etc?]
+//     | lambda_names_with_default [',' lambda_star_etc?]
+//     | lambda_star_etc
+static arguments_ty
+lambda_parameters_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    arguments_ty res = NULL;
+    int mark = p->mark;
+    { // lambda_slash_without_default [',' lambda_plain_names] [',' lambda_names_with_default] [',' lambda_star_etc?]
+        asdl_seq* a;
+        void *b;
+        void *c;
+        void *d;
+        if (
+            (a = lambda_slash_without_default_rule(p))
+            &&
+            (b = _tmp_65_rule(p), 1)
+            &&
+            (c = _tmp_66_rule(p), 1)
+            &&
+            (d = _tmp_67_rule(p), 1)
+        )
+        {
+            res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // lambda_slash_with_default [',' lambda_names_with_default] [',' lambda_star_etc?]
+        SlashWithDefault* a;
+        void *b;
+        void *c;
+        if (
+            (a = lambda_slash_with_default_rule(p))
+            &&
+            (b = _tmp_68_rule(p), 1)
+            &&
+            (c = _tmp_69_rule(p), 1)
+        )
+        {
+            res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // lambda_plain_names [',' lambda_names_with_default] [',' lambda_star_etc?]
+        asdl_seq* a;
+        void *b;
+        void *c;
+        if (
+            (a = lambda_plain_names_rule(p))
+            &&
+            (b = _tmp_70_rule(p), 1)
+            &&
+            (c = _tmp_71_rule(p), 1)
+        )
+        {
+            res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // lambda_names_with_default [',' lambda_star_etc?]
+        asdl_seq* a;
+        void *b;
+        if (
+            (a = lambda_names_with_default_rule(p))
+            &&
+            (b = _tmp_72_rule(p), 1)
+        )
+        {
+            res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // lambda_star_etc
+        StarEtc* a;
+        if (
+            (a = lambda_star_etc_rule(p))
+        )
+        {
+            res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_slash_without_default: lambda_plain_names ',' '/'
+static asdl_seq*
+lambda_slash_without_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // lambda_plain_names ',' '/'
+        asdl_seq* a;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = lambda_plain_names_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 17))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_slash_with_default: [lambda_plain_names ','] lambda_names_with_default ',' '/'
+static SlashWithDefault*
+lambda_slash_with_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    SlashWithDefault* res = NULL;
+    int mark = p->mark;
+    { // [lambda_plain_names ','] lambda_names_with_default ',' '/'
+        void *a;
+        asdl_seq* b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = _tmp_73_rule(p), 1)
+            &&
+            (b = lambda_names_with_default_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 17))
+        )
+        {
+            res = _PyPegen_slash_with_default ( p , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_star_etc:
+//     | '*' lambda_plain_name lambda_name_with_optional_default* [',' lambda_kwds] ','?
+//     | '*' lambda_name_with_optional_default+ [',' lambda_kwds] ','?
+//     | lambda_kwds ','?
+static StarEtc*
+lambda_star_etc_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    StarEtc* res = NULL;
+    int mark = p->mark;
+    { // '*' lambda_plain_name lambda_name_with_optional_default* [',' lambda_kwds] ','?
+        arg_ty a;
+        asdl_seq * b;
+        void *c;
+        void *literal;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (a = lambda_plain_name_rule(p))
+            &&
+            (b = _loop0_74_rule(p))
+            &&
+            (c = _tmp_75_rule(p), 1)
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = _PyPegen_star_etc ( p , a , b , c );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '*' lambda_name_with_optional_default+ [',' lambda_kwds] ','?
+        asdl_seq * b;
+        void *c;
+        void *literal;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (b = _loop1_76_rule(p))
+            &&
+            (c = _tmp_77_rule(p), 1)
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = _PyPegen_star_etc ( p , NULL , b , c );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // lambda_kwds ','?
+        arg_ty a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = lambda_kwds_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = _PyPegen_star_etc ( p , NULL , NULL , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_name_with_optional_default: ',' lambda_plain_name ['=' expression]
+static NameDefaultPair*
+lambda_name_with_optional_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    NameDefaultPair* res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_plain_name ['=' expression]
+        arg_ty a;
+        void *b;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (a = lambda_plain_name_rule(p))
+            &&
+            (b = _tmp_78_rule(p), 1)
+        )
+        {
+            res = _PyPegen_name_default_pair ( p , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_names_with_default: ','.lambda_name_with_default+
+static asdl_seq*
+lambda_names_with_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.lambda_name_with_default+
+        asdl_seq * a;
+        if (
+            (a = _gather_79_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_name_with_default: lambda_plain_name '=' expression
+static NameDefaultPair*
+lambda_name_with_default_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    NameDefaultPair* res = NULL;
+    int mark = p->mark;
+    { // lambda_plain_name '=' expression
+        expr_ty e;
+        void *literal;
+        arg_ty n;
+        if (
+            (n = lambda_plain_name_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 22))
+            &&
+            (e = expression_rule(p))
+        )
+        {
+            res = _PyPegen_name_default_pair ( p , n , e );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_plain_names: ','.(lambda_plain_name !'=')+
+static asdl_seq*
+lambda_plain_names_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.(lambda_plain_name !'=')+
+        asdl_seq * a;
+        if (
+            (a = _gather_81_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_plain_name: NAME
+static arg_ty
+lambda_plain_name_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    arg_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME
+        expr_ty a;
+        if (
+            (a = _PyPegen_name_token(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_arg ( a -> v . Name . id , NULL , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lambda_kwds: '**' lambda_plain_name
+static arg_ty
+lambda_kwds_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    arg_ty res = NULL;
+    int mark = p->mark;
+    { // '**' lambda_plain_name
+        arg_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 35))
+            &&
+            (a = lambda_plain_name_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// disjunction: conjunction (('or' conjunction))+ | conjunction
+static expr_ty
+disjunction_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, disjunction_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // conjunction (('or' conjunction))+
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = conjunction_rule(p))
+            &&
+            (b = _loop1_83_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BoolOp ( Or , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // conjunction
+        expr_ty conjunction_var;
+        if (
+            (conjunction_var = conjunction_rule(p))
+        )
+        {
+            res = conjunction_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, disjunction_type, res);
+    return res;
+}
+
+// conjunction: inversion (('and' inversion))+ | inversion
+static expr_ty
+conjunction_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, conjunction_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // inversion (('and' inversion))+
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = inversion_rule(p))
+            &&
+            (b = _loop1_84_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BoolOp ( And , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // inversion
+        expr_ty inversion_var;
+        if (
+            (inversion_var = inversion_rule(p))
+        )
+        {
+            res = inversion_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, conjunction_type, res);
+    return res;
+}
+
+// inversion: 'not' inversion | comparison
+static expr_ty
+inversion_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, inversion_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'not' inversion
+        expr_ty a;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 525))
+            &&
+            (a = inversion_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_UnaryOp ( Not , a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // comparison
+        expr_ty comparison_var;
+        if (
+            (comparison_var = comparison_rule(p))
+        )
+        {
+            res = comparison_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, inversion_type, res);
+    return res;
+}
+
+// comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or
+static expr_ty
+comparison_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // bitwise_or compare_op_bitwise_or_pair+
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = bitwise_or_rule(p))
+            &&
+            (b = _loop1_85_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Compare ( a , CHECK ( _PyPegen_get_cmpops ( p , b ) ) , CHECK ( _PyPegen_get_exprs ( p , b ) ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // bitwise_or
+        expr_ty bitwise_or_var;
+        if (
+            (bitwise_or_var = bitwise_or_rule(p))
+        )
+        {
+            res = bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// compare_op_bitwise_or_pair:
+//     | eq_bitwise_or
+//     | noteq_bitwise_or
+//     | lte_bitwise_or
+//     | lt_bitwise_or
+//     | gte_bitwise_or
+//     | gt_bitwise_or
+//     | notin_bitwise_or
+//     | in_bitwise_or
+//     | isnot_bitwise_or
+//     | is_bitwise_or
+static CmpopExprPair*
+compare_op_bitwise_or_pair_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // eq_bitwise_or
+        CmpopExprPair* eq_bitwise_or_var;
+        if (
+            (eq_bitwise_or_var = eq_bitwise_or_rule(p))
+        )
+        {
+            res = eq_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // noteq_bitwise_or
+        CmpopExprPair* noteq_bitwise_or_var;
+        if (
+            (noteq_bitwise_or_var = noteq_bitwise_or_rule(p))
+        )
+        {
+            res = noteq_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // lte_bitwise_or
+        CmpopExprPair* lte_bitwise_or_var;
+        if (
+            (lte_bitwise_or_var = lte_bitwise_or_rule(p))
+        )
+        {
+            res = lte_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // lt_bitwise_or
+        CmpopExprPair* lt_bitwise_or_var;
+        if (
+            (lt_bitwise_or_var = lt_bitwise_or_rule(p))
+        )
+        {
+            res = lt_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // gte_bitwise_or
+        CmpopExprPair* gte_bitwise_or_var;
+        if (
+            (gte_bitwise_or_var = gte_bitwise_or_rule(p))
+        )
+        {
+            res = gte_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // gt_bitwise_or
+        CmpopExprPair* gt_bitwise_or_var;
+        if (
+            (gt_bitwise_or_var = gt_bitwise_or_rule(p))
+        )
+        {
+            res = gt_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // notin_bitwise_or
+        CmpopExprPair* notin_bitwise_or_var;
+        if (
+            (notin_bitwise_or_var = notin_bitwise_or_rule(p))
+        )
+        {
+            res = notin_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // in_bitwise_or
+        CmpopExprPair* in_bitwise_or_var;
+        if (
+            (in_bitwise_or_var = in_bitwise_or_rule(p))
+        )
+        {
+            res = in_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // isnot_bitwise_or
+        CmpopExprPair* isnot_bitwise_or_var;
+        if (
+            (isnot_bitwise_or_var = isnot_bitwise_or_rule(p))
+        )
+        {
+            res = isnot_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // is_bitwise_or
+        CmpopExprPair* is_bitwise_or_var;
+        if (
+            (is_bitwise_or_var = is_bitwise_or_rule(p))
+        )
+        {
+            res = is_bitwise_or_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// eq_bitwise_or: '==' bitwise_or
+static CmpopExprPair*
+eq_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // '==' bitwise_or
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 27))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , Eq , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// noteq_bitwise_or: '!=' bitwise_or
+static CmpopExprPair*
+noteq_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // '!=' bitwise_or
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 28))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , NotEq , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lte_bitwise_or: '<=' bitwise_or
+static CmpopExprPair*
+lte_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // '<=' bitwise_or
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 29))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , LtE , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// lt_bitwise_or: '<' bitwise_or
+static CmpopExprPair*
+lt_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // '<' bitwise_or
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 20))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , Lt , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// gte_bitwise_or: '>=' bitwise_or
+static CmpopExprPair*
+gte_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // '>=' bitwise_or
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 30))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , GtE , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// gt_bitwise_or: '>' bitwise_or
+static CmpopExprPair*
+gt_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // '>' bitwise_or
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 21))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , Gt , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// notin_bitwise_or: 'not' 'in' bitwise_or
+static CmpopExprPair*
+notin_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // 'not' 'in' bitwise_or
+        expr_ty a;
+        void *keyword;
+        void *keyword_1;
+        if (
+            (keyword = _PyPegen_expect_token(p, 525))
+            &&
+            (keyword_1 = _PyPegen_expect_token(p, 518))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , NotIn , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// in_bitwise_or: 'in' bitwise_or
+static CmpopExprPair*
+in_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // 'in' bitwise_or
+        expr_ty a;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 518))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , In , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// isnot_bitwise_or: 'is' 'not' bitwise_or
+static CmpopExprPair*
+isnot_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // 'is' 'not' bitwise_or
+        expr_ty a;
+        void *keyword;
+        void *keyword_1;
+        if (
+            (keyword = _PyPegen_expect_token(p, 526))
+            &&
+            (keyword_1 = _PyPegen_expect_token(p, 525))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , IsNot , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// is_bitwise_or: 'is' bitwise_or
+static CmpopExprPair*
+is_bitwise_or_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    CmpopExprPair* res = NULL;
+    int mark = p->mark;
+    { // 'is' bitwise_or
+        expr_ty a;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 526))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_cmpop_expr_pair ( p , Is , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// Left-recursive
+// bitwise_or: bitwise_or '|' bitwise_xor | bitwise_xor
+static expr_ty bitwise_or_raw(Parser *);
+static expr_ty
+bitwise_or_rule(Parser *p)
+{
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, bitwise_or_type, &res))
+        return res;
+    int mark = p->mark;
+    int resmark = p->mark;
+    while (1) {
+        int tmpvar_1 = _PyPegen_update_memo(p, mark, bitwise_or_type, res);
+        if (tmpvar_1) {
+            return res;
+        }
+        p->mark = mark;
+        void *raw = bitwise_or_raw(p);
+        if (raw == NULL || p->mark <= resmark)
+            break;
+        resmark = p->mark;
+        res = raw;
+    }
+    p->mark = resmark;
+    return res;
+}
+static expr_ty
+bitwise_or_raw(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // bitwise_or '|' bitwise_xor
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = bitwise_or_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 18))
+            &&
+            (b = bitwise_xor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , BitOr , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // bitwise_xor
+        expr_ty bitwise_xor_var;
+        if (
+            (bitwise_xor_var = bitwise_xor_rule(p))
+        )
+        {
+            res = bitwise_xor_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// Left-recursive
+// bitwise_xor: bitwise_xor '^' bitwise_and | bitwise_and
+static expr_ty bitwise_xor_raw(Parser *);
+static expr_ty
+bitwise_xor_rule(Parser *p)
+{
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, bitwise_xor_type, &res))
+        return res;
+    int mark = p->mark;
+    int resmark = p->mark;
+    while (1) {
+        int tmpvar_2 = _PyPegen_update_memo(p, mark, bitwise_xor_type, res);
+        if (tmpvar_2) {
+            return res;
+        }
+        p->mark = mark;
+        void *raw = bitwise_xor_raw(p);
+        if (raw == NULL || p->mark <= resmark)
+            break;
+        resmark = p->mark;
+        res = raw;
+    }
+    p->mark = resmark;
+    return res;
+}
+static expr_ty
+bitwise_xor_raw(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // bitwise_xor '^' bitwise_and
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = bitwise_xor_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 32))
+            &&
+            (b = bitwise_and_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , BitXor , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // bitwise_and
+        expr_ty bitwise_and_var;
+        if (
+            (bitwise_and_var = bitwise_and_rule(p))
+        )
+        {
+            res = bitwise_and_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// Left-recursive
+// bitwise_and: bitwise_and '&' shift_expr | shift_expr
+static expr_ty bitwise_and_raw(Parser *);
+static expr_ty
+bitwise_and_rule(Parser *p)
+{
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, bitwise_and_type, &res))
+        return res;
+    int mark = p->mark;
+    int resmark = p->mark;
+    while (1) {
+        int tmpvar_3 = _PyPegen_update_memo(p, mark, bitwise_and_type, res);
+        if (tmpvar_3) {
+            return res;
+        }
+        p->mark = mark;
+        void *raw = bitwise_and_raw(p);
+        if (raw == NULL || p->mark <= resmark)
+            break;
+        resmark = p->mark;
+        res = raw;
+    }
+    p->mark = resmark;
+    return res;
+}
+static expr_ty
+bitwise_and_raw(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // bitwise_and '&' shift_expr
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = bitwise_and_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 19))
+            &&
+            (b = shift_expr_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , BitAnd , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // shift_expr
+        expr_ty shift_expr_var;
+        if (
+            (shift_expr_var = shift_expr_rule(p))
+        )
+        {
+            res = shift_expr_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// Left-recursive
+// shift_expr: shift_expr '<<' sum | shift_expr '>>' sum | sum
+static expr_ty shift_expr_raw(Parser *);
+static expr_ty
+shift_expr_rule(Parser *p)
+{
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, shift_expr_type, &res))
+        return res;
+    int mark = p->mark;
+    int resmark = p->mark;
+    while (1) {
+        int tmpvar_4 = _PyPegen_update_memo(p, mark, shift_expr_type, res);
+        if (tmpvar_4) {
+            return res;
+        }
+        p->mark = mark;
+        void *raw = shift_expr_raw(p);
+        if (raw == NULL || p->mark <= resmark)
+            break;
+        resmark = p->mark;
+        res = raw;
+    }
+    p->mark = resmark;
+    return res;
+}
+static expr_ty
+shift_expr_raw(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // shift_expr '<<' sum
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = shift_expr_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 33))
+            &&
+            (b = sum_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , LShift , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // shift_expr '>>' sum
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = shift_expr_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 34))
+            &&
+            (b = sum_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , RShift , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // sum
+        expr_ty sum_var;
+        if (
+            (sum_var = sum_rule(p))
+        )
+        {
+            res = sum_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// Left-recursive
+// sum: sum '+' term | sum '-' term | term
+static expr_ty sum_raw(Parser *);
+static expr_ty
+sum_rule(Parser *p)
+{
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, sum_type, &res))
+        return res;
+    int mark = p->mark;
+    int resmark = p->mark;
+    while (1) {
+        int tmpvar_5 = _PyPegen_update_memo(p, mark, sum_type, res);
+        if (tmpvar_5) {
+            return res;
+        }
+        p->mark = mark;
+        void *raw = sum_raw(p);
+        if (raw == NULL || p->mark <= resmark)
+            break;
+        resmark = p->mark;
+        res = raw;
+    }
+    p->mark = resmark;
+    return res;
+}
+static expr_ty
+sum_raw(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // sum '+' term
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = sum_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 14))
+            &&
+            (b = term_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , Add , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // sum '-' term
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = sum_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 15))
+            &&
+            (b = term_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , Sub , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // term
+        expr_ty term_var;
+        if (
+            (term_var = term_rule(p))
+        )
+        {
+            res = term_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// Left-recursive
+// term:
+//     | term '*' factor
+//     | term '/' factor
+//     | term '//' factor
+//     | term '%' factor
+//     | term '@' factor
+//     | factor
+static expr_ty term_raw(Parser *);
+static expr_ty
+term_rule(Parser *p)
+{
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, term_type, &res))
+        return res;
+    int mark = p->mark;
+    int resmark = p->mark;
+    while (1) {
+        int tmpvar_6 = _PyPegen_update_memo(p, mark, term_type, res);
+        if (tmpvar_6) {
+            return res;
+        }
+        p->mark = mark;
+        void *raw = term_raw(p);
+        if (raw == NULL || p->mark <= resmark)
+            break;
+        resmark = p->mark;
+        res = raw;
+    }
+    p->mark = resmark;
+    return res;
+}
+static expr_ty
+term_raw(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // term '*' factor
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = term_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (b = factor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , Mult , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // term '/' factor
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = term_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 17))
+            &&
+            (b = factor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , Div , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // term '//' factor
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = term_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 47))
+            &&
+            (b = factor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , FloorDiv , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // term '%' factor
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = term_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 24))
+            &&
+            (b = factor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , Mod , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // term '@' factor
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = term_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 49))
+            &&
+            (b = factor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , MatMult , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // factor
+        expr_ty factor_var;
+        if (
+            (factor_var = factor_rule(p))
+        )
+        {
+            res = factor_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// factor: '+' factor | '-' factor | '~' factor | power
+static expr_ty
+factor_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, factor_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '+' factor
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 14))
+            &&
+            (a = factor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_UnaryOp ( UAdd , a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '-' factor
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 15))
+            &&
+            (a = factor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_UnaryOp ( USub , a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '~' factor
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 31))
+            &&
+            (a = factor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_UnaryOp ( Invert , a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // power
+        expr_ty power_var;
+        if (
+            (power_var = power_rule(p))
+        )
+        {
+            res = power_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, factor_type, res);
+    return res;
+}
+
+// power: await_primary '**' factor | await_primary
+static expr_ty
+power_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // await_primary '**' factor
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = await_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 35))
+            &&
+            (b = factor_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_BinOp ( a , Pow , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // await_primary
+        expr_ty await_primary_var;
+        if (
+            (await_primary_var = await_primary_rule(p))
+        )
+        {
+            res = await_primary_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// await_primary: AWAIT primary | primary
+static expr_ty
+await_primary_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, await_primary_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // AWAIT primary
+        expr_ty a;
+        void *await_var;
+        if (
+            (await_var = _PyPegen_await_token(p))
+            &&
+            (a = primary_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Await ( a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // primary
+        expr_ty primary_var;
+        if (
+            (primary_var = primary_rule(p))
+        )
+        {
+            res = primary_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, await_primary_type, res);
+    return res;
+}
+
+// Left-recursive
+// primary:
+//     | primary '.' NAME
+//     | primary genexp
+//     | primary '(' arguments? ')'
+//     | primary '[' slices ']'
+//     | atom
+static expr_ty primary_raw(Parser *);
+static expr_ty
+primary_rule(Parser *p)
+{
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, primary_type, &res))
+        return res;
+    int mark = p->mark;
+    int resmark = p->mark;
+    while (1) {
+        int tmpvar_7 = _PyPegen_update_memo(p, mark, primary_type, res);
+        if (tmpvar_7) {
+            return res;
+        }
+        p->mark = mark;
+        void *raw = primary_raw(p);
+        if (raw == NULL || p->mark <= resmark)
+            break;
+        resmark = p->mark;
+        res = raw;
+    }
+    p->mark = resmark;
+    return res;
+}
+static expr_ty
+primary_raw(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // primary '.' NAME
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 23))
+            &&
+            (b = _PyPegen_name_token(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // primary genexp
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = primary_rule(p))
+            &&
+            (b = genexp_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // primary '(' arguments? ')'
+        expr_ty a;
+        void *b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (b = arguments_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // primary '[' slices ']'
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (b = slices_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Subscript ( a , b , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // atom
+        expr_ty atom_var;
+        if (
+            (atom_var = atom_rule(p))
+        )
+        {
+            res = atom_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// slices: slice !',' | ','.slice+ ','?
+static expr_ty
+slices_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // slice !','
+        expr_ty a;
+        if (
+            (a = slice_rule(p))
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ','.slice+ ','?
+        asdl_seq * a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = _gather_86_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( a , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// slice: expression? ':' expression? [':' expression?] | expression
+static expr_ty
+slice_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // expression? ':' expression? [':' expression?]
+        void *a;
+        void *b;
+        void *c;
+        void *literal;
+        if (
+            (a = expression_rule(p), 1)
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = expression_rule(p), 1)
+            &&
+            (c = _tmp_88_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Slice ( a , b , c , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression
+        expr_ty a;
+        if (
+            (a = expression_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// atom:
+//     | NAME
+//     | 'True'
+//     | 'False'
+//     | 'None'
+//     | '__new_parser__'
+//     | &STRING strings
+//     | NUMBER
+//     | &'(' (tuple | group | genexp)
+//     | &'[' (list | listcomp)
+//     | &'{' (dict | set | dictcomp | setcomp)
+//     | '...'
+static expr_ty
+atom_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME
+        expr_ty name_var;
+        if (
+            (name_var = _PyPegen_name_token(p))
+        )
+        {
+            res = name_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'True'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 527))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Constant ( Py_True , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'False'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 528))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Constant ( Py_False , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'None'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 529))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Constant ( Py_None , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '__new_parser__'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 530))
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "You found it!" );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &STRING strings
+        expr_ty strings_var;
+        if (
+            _PyPegen_lookahead(1, _PyPegen_string_token, p)
+            &&
+            (strings_var = strings_rule(p))
+        )
+        {
+            res = strings_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // NUMBER
+        expr_ty number_var;
+        if (
+            (number_var = _PyPegen_number_token(p))
+        )
+        {
+            res = number_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'(' (tuple | group | genexp)
+        void *_tmp_89_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7)
+            &&
+            (_tmp_89_var = _tmp_89_rule(p))
+        )
+        {
+            res = _tmp_89_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'[' (list | listcomp)
+        void *_tmp_90_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9)
+            &&
+            (_tmp_90_var = _tmp_90_rule(p))
+        )
+        {
+            res = _tmp_90_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // &'{' (dict | set | dictcomp | setcomp)
+        void *_tmp_91_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25)
+            &&
+            (_tmp_91_var = _tmp_91_rule(p))
+        )
+        {
+            res = _tmp_91_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '...'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 52))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Constant ( Py_Ellipsis , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// strings: STRING+
+static expr_ty
+strings_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, strings_type, &res))
+        return res;
+    int mark = p->mark;
+    { // STRING+
+        asdl_seq * a;
+        if (
+            (a = _loop1_92_rule(p))
+        )
+        {
+            res = _PyPegen_concatenate_strings ( p , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, strings_type, res);
+    return res;
+}
+
+// list: '[' star_named_expressions? ']'
+static expr_ty
+list_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '[' star_named_expressions? ']'
+        void *a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (a = star_named_expressions_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_List ( a , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension
+static expr_ty
+listcomp_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '[' named_expression for_if_clauses ']'
+        expr_ty a;
+        asdl_seq* b;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (a = named_expression_rule(p))
+            &&
+            (b = for_if_clauses_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_ListComp ( a , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // invalid_comprehension
+        void *invalid_comprehension_var;
+        if (
+            (invalid_comprehension_var = invalid_comprehension_rule(p))
+        )
+        {
+            res = invalid_comprehension_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// tuple: '(' [star_named_expression ',' star_named_expressions?] ')'
+static expr_ty
+tuple_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '(' [star_named_expression ',' star_named_expressions?] ')'
+        void *a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = _tmp_93_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( a , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// group: '(' (yield_expr | named_expression) ')'
+static expr_ty
+group_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    { // '(' (yield_expr | named_expression) ')'
+        void *a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = _tmp_94_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// genexp: '(' expression for_if_clauses ')' | invalid_comprehension
+static expr_ty
+genexp_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '(' expression for_if_clauses ')'
+        expr_ty a;
+        asdl_seq* b;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = expression_rule(p))
+            &&
+            (b = for_if_clauses_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_GeneratorExp ( a , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // invalid_comprehension
+        void *invalid_comprehension_var;
+        if (
+            (invalid_comprehension_var = invalid_comprehension_rule(p))
+        )
+        {
+            res = invalid_comprehension_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// set: '{' expressions_list '}'
+static expr_ty
+set_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '{' expressions_list '}'
+        asdl_seq* a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 25))
+            &&
+            (a = expressions_list_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 26))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Set ( a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// setcomp: '{' expression for_if_clauses '}' | invalid_comprehension
+static expr_ty
+setcomp_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '{' expression for_if_clauses '}'
+        expr_ty a;
+        asdl_seq* b;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 25))
+            &&
+            (a = expression_rule(p))
+            &&
+            (b = for_if_clauses_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 26))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_SetComp ( a , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // invalid_comprehension
+        void *invalid_comprehension_var;
+        if (
+            (invalid_comprehension_var = invalid_comprehension_rule(p))
+        )
+        {
+            res = invalid_comprehension_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// dict: '{' kvpairs? '}'
+static expr_ty
+dict_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '{' kvpairs? '}'
+        void *a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 25))
+            &&
+            (a = kvpairs_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 26))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Dict ( CHECK ( _PyPegen_get_keys ( p , a ) ) , CHECK ( _PyPegen_get_values ( p , a ) ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// dictcomp: '{' kvpair for_if_clauses '}'
+static expr_ty
+dictcomp_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '{' kvpair for_if_clauses '}'
+        KeyValuePair* a;
+        asdl_seq* b;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 25))
+            &&
+            (a = kvpair_rule(p))
+            &&
+            (b = for_if_clauses_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 26))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_DictComp ( a -> key , a -> value , b , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// kvpairs: ','.kvpair+ ','?
+static asdl_seq*
+kvpairs_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.kvpair+ ','?
+        asdl_seq * a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = _gather_95_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// kvpair: '**' bitwise_or | expression ':' expression
+static KeyValuePair*
+kvpair_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    KeyValuePair* res = NULL;
+    int mark = p->mark;
+    { // '**' bitwise_or
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 35))
+            &&
+            (a = bitwise_or_rule(p))
+        )
+        {
+            res = _PyPegen_key_value_pair ( p , NULL , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression ':' expression
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (b = expression_rule(p))
+        )
+        {
+            res = _PyPegen_key_value_pair ( p , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// for_if_clauses: ((ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*))+
+static asdl_seq*
+for_if_clauses_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ((ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*))+
+        asdl_seq * a;
+        if (
+            (a = _loop1_97_rule(p))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// yield_expr: 'yield' 'from' expression | 'yield' star_expressions?
+static expr_ty
+yield_expr_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // 'yield' 'from' expression
+        expr_ty a;
+        void *keyword;
+        void *keyword_1;
+        if (
+            (keyword = _PyPegen_expect_token(p, 504))
+            &&
+            (keyword_1 = _PyPegen_expect_token(p, 514))
+            &&
+            (a = expression_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_YieldFrom ( a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'yield' star_expressions?
+        void *a;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 504))
+            &&
+            (a = star_expressions_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Yield ( a , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// arguments: args ','? &')' | incorrect_arguments
+static expr_ty
+arguments_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, arguments_type, &res))
+        return res;
+    int mark = p->mark;
+    { // args ','? &')'
+        expr_ty a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = args_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // incorrect_arguments
+        void *incorrect_arguments_var;
+        if (
+            (incorrect_arguments_var = incorrect_arguments_rule(p))
+        )
+        {
+            res = incorrect_arguments_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, arguments_type, res);
+    return res;
+}
+
+// args: starred_expression [',' args] | kwargs | named_expression [',' args]
+static expr_ty
+args_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // starred_expression [',' args]
+        expr_ty a;
+        void *b;
+        if (
+            (a = starred_expression_rule(p))
+            &&
+            (b = _tmp_98_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Call ( _PyPegen_dummy_name ( p ) , ( b ) ? CHECK ( _PyPegen_seq_insert_in_front ( p , a , ( ( expr_ty ) b ) -> v . Call . args ) ) : CHECK ( _PyPegen_singleton_seq ( p , a ) ) , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // kwargs
+        asdl_seq* a;
+        if (
+            (a = kwargs_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Call ( _PyPegen_dummy_name ( p ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_extract_starred_exprs ( p , a ) ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_delete_starred_exprs ( p , a ) ) , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // named_expression [',' args]
+        expr_ty a;
+        void *b;
+        if (
+            (a = named_expression_rule(p))
+            &&
+            (b = _tmp_99_rule(p), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Call ( _PyPegen_dummy_name ( p ) , ( b ) ? CHECK ( _PyPegen_seq_insert_in_front ( p , a , ( ( expr_ty ) b ) -> v . Call . args ) ) : CHECK ( _PyPegen_singleton_seq ( p , a ) ) , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// kwargs:
+//     | ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
+//     | ','.kwarg_or_starred+
+//     | ','.kwarg_or_double_starred+
+static asdl_seq*
+kwargs_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
+        asdl_seq * a;
+        asdl_seq * b;
+        void *literal;
+        if (
+            (a = _gather_100_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (b = _gather_102_rule(p))
+        )
+        {
+            res = _PyPegen_join_sequences ( p , a , b );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ','.kwarg_or_starred+
+        asdl_seq * _gather_104_var;
+        if (
+            (_gather_104_var = _gather_104_rule(p))
+        )
+        {
+            res = _gather_104_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ','.kwarg_or_double_starred+
+        asdl_seq * _gather_106_var;
+        if (
+            (_gather_106_var = _gather_106_rule(p))
+        )
+        {
+            res = _gather_106_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// starred_expression: '*' expression
+static expr_ty
+starred_expression_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '*' expression
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (a = expression_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Starred ( a , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// kwarg_or_starred: NAME '=' expression | starred_expression
+static KeywordOrStarred*
+kwarg_or_starred_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    KeywordOrStarred* res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME '=' expression
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = _PyPegen_name_token(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 22))
+            &&
+            (b = expression_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // starred_expression
+        expr_ty a;
+        if (
+            (a = starred_expression_rule(p))
+        )
+        {
+            res = _PyPegen_keyword_or_starred ( p , a , 0 );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// kwarg_or_double_starred: NAME '=' expression | '**' expression
+static KeywordOrStarred*
+kwarg_or_double_starred_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    KeywordOrStarred* res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME '=' expression
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = _PyPegen_name_token(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 22))
+            &&
+            (b = expression_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '**' expression
+        expr_ty a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 35))
+            &&
+            (a = expression_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( NULL , a , EXTRA ) ) , 1 );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// star_targets: star_target !',' | star_target ((',' star_target))* ','?
+static expr_ty
+star_targets_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // star_target !','
+        expr_ty a;
+        if (
+            (a = star_target_rule(p))
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_target ((',' star_target))* ','?
+        expr_ty a;
+        asdl_seq * b;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = star_target_rule(p))
+            &&
+            (b = _loop0_108_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// star_targets_seq: ','.star_target+ ','?
+static asdl_seq*
+star_targets_seq_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.star_target+ ','?
+        asdl_seq * a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = _gather_109_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// star_target:
+//     | '*' (!'*' star_target)
+//     | t_primary '.' NAME !t_lookahead
+//     | t_primary '[' slices ']' !t_lookahead
+//     | star_atom
+static expr_ty
+star_target_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, star_target_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // '*' (!'*' star_target)
+        void *a;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (a = _tmp_111_rule(p))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Starred ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // t_primary '.' NAME !t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 23))
+            &&
+            (b = _PyPegen_name_token(p))
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // t_primary '[' slices ']' !t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (b = slices_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Subscript ( a , b , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_atom
+        expr_ty star_atom_var;
+        if (
+            (star_atom_var = star_atom_rule(p))
+        )
+        {
+            res = star_atom_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, star_target_type, res);
+    return res;
+}
+
+// star_atom:
+//     | NAME
+//     | '(' star_target ')'
+//     | '(' star_targets_seq? ')'
+//     | '[' star_targets_seq? ']'
+static expr_ty
+star_atom_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME
+        expr_ty a;
+        if (
+            (a = _PyPegen_name_token(p))
+        )
+        {
+            res = _PyPegen_set_expr_context ( p , a , Store );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '(' star_target ')'
+        expr_ty a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = star_target_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            res = _PyPegen_set_expr_context ( p , a , Store );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '(' star_targets_seq? ')'
+        void *a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = star_targets_seq_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( a , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '[' star_targets_seq? ']'
+        void *a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (a = star_targets_seq_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_List ( a , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// inside_paren_ann_assign_target:
+//     | ann_assign_subscript_attribute_target
+//     | NAME
+//     | '(' inside_paren_ann_assign_target ')'
+static expr_ty
+inside_paren_ann_assign_target_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    { // ann_assign_subscript_attribute_target
+        expr_ty ann_assign_subscript_attribute_target_var;
+        if (
+            (ann_assign_subscript_attribute_target_var = ann_assign_subscript_attribute_target_rule(p))
+        )
+        {
+            res = ann_assign_subscript_attribute_target_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // NAME
+        expr_ty a;
+        if (
+            (a = _PyPegen_name_token(p))
+        )
+        {
+            res = _PyPegen_set_expr_context ( p , a , Store );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '(' inside_paren_ann_assign_target ')'
+        expr_ty a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = inside_paren_ann_assign_target_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// ann_assign_subscript_attribute_target:
+//     | t_primary '.' NAME !t_lookahead
+//     | t_primary '[' slices ']' !t_lookahead
+static expr_ty
+ann_assign_subscript_attribute_target_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // t_primary '.' NAME !t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 23))
+            &&
+            (b = _PyPegen_name_token(p))
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // t_primary '[' slices ']' !t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (b = slices_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Subscript ( a , b , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// del_targets: ','.del_target+ ','?
+static asdl_seq*
+del_targets_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.del_target+ ','?
+        asdl_seq * a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = _gather_112_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// del_target:
+//     | t_primary '.' NAME !t_lookahead
+//     | t_primary '[' slices ']' !t_lookahead
+//     | del_t_atom
+static expr_ty
+del_target_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, del_target_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // t_primary '.' NAME !t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 23))
+            &&
+            (b = _PyPegen_name_token(p))
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Attribute ( a , b -> v . Name . id , Del , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // t_primary '[' slices ']' !t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (b = slices_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Subscript ( a , b , Del , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // del_t_atom
+        expr_ty del_t_atom_var;
+        if (
+            (del_t_atom_var = del_t_atom_rule(p))
+        )
+        {
+            res = del_t_atom_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, del_target_type, res);
+    return res;
+}
+
+// del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']'
+static expr_ty
+del_t_atom_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME
+        expr_ty a;
+        if (
+            (a = _PyPegen_name_token(p))
+        )
+        {
+            res = _PyPegen_set_expr_context ( p , a , Del );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '(' del_target ')'
+        expr_ty a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = del_target_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            res = _PyPegen_set_expr_context ( p , a , Del );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '(' del_targets? ')'
+        void *a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = del_targets_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( a , Del , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '[' del_targets? ']'
+        void *a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (a = del_targets_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_List ( a , Del , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// targets: ','.target+ ','?
+static asdl_seq*
+targets_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq* res = NULL;
+    int mark = p->mark;
+    { // ','.target+ ','?
+        asdl_seq * a;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (a = _gather_114_rule(p))
+            &&
+            (opt_var = _PyPegen_expect_token(p, 12), 1)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// target:
+//     | t_primary '.' NAME !t_lookahead
+//     | t_primary '[' slices ']' !t_lookahead
+//     | t_atom
+static expr_ty
+target_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, target_type, &res))
+        return res;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // t_primary '.' NAME !t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 23))
+            &&
+            (b = _PyPegen_name_token(p))
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // t_primary '[' slices ']' !t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (b = slices_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Subscript ( a , b , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // t_atom
+        expr_ty t_atom_var;
+        if (
+            (t_atom_var = t_atom_rule(p))
+        )
+        {
+            res = t_atom_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    _PyPegen_insert_memo(p, mark, target_type, res);
+    return res;
+}
+
+// Left-recursive
+// t_primary:
+//     | t_primary '.' NAME &t_lookahead
+//     | t_primary '[' slices ']' &t_lookahead
+//     | t_primary genexp &t_lookahead
+//     | t_primary '(' arguments? ')' &t_lookahead
+//     | atom &t_lookahead
+static expr_ty t_primary_raw(Parser *);
+static expr_ty
+t_primary_rule(Parser *p)
+{
+    expr_ty res = NULL;
+    if (_PyPegen_is_memoized(p, t_primary_type, &res))
+        return res;
+    int mark = p->mark;
+    int resmark = p->mark;
+    while (1) {
+        int tmpvar_8 = _PyPegen_update_memo(p, mark, t_primary_type, res);
+        if (tmpvar_8) {
+            return res;
+        }
+        p->mark = mark;
+        void *raw = t_primary_raw(p);
+        if (raw == NULL || p->mark <= resmark)
+            break;
+        resmark = p->mark;
+        res = raw;
+    }
+    p->mark = resmark;
+    return res;
+}
+static expr_ty
+t_primary_raw(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // t_primary '.' NAME &t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 23))
+            &&
+            (b = _PyPegen_name_token(p))
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // t_primary '[' slices ']' &t_lookahead
+        expr_ty a;
+        expr_ty b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (b = slices_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Subscript ( a , b , Load , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // t_primary genexp &t_lookahead
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (b = genexp_rule(p))
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // t_primary '(' arguments? ')' &t_lookahead
+        expr_ty a;
+        void *b;
+        void *literal;
+        void *literal_1;
+        if (
+            (a = t_primary_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (b = arguments_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // atom &t_lookahead
+        expr_ty a;
+        if (
+            (a = atom_rule(p))
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            res = a;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// t_lookahead: '(' | '[' | '.'
+static void *
+t_lookahead_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '('
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '['
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 9))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '.'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 23))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// t_atom: NAME | '(' target ')' | '(' targets? ')' | '[' targets? ']'
+static expr_ty
+t_atom_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    expr_ty res = NULL;
+    int mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    int start_lineno = p->tokens[mark]->lineno;
+    UNUSED(start_lineno); // Only used by EXTRA macro
+    int start_col_offset = p->tokens[mark]->col_offset;
+    UNUSED(start_col_offset); // Only used by EXTRA macro
+    { // NAME
+        expr_ty a;
+        if (
+            (a = _PyPegen_name_token(p))
+        )
+        {
+            res = _PyPegen_set_expr_context ( p , a , Store );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '(' target ')'
+        expr_ty a;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (a = target_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            res = _PyPegen_set_expr_context ( p , a , Store );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '(' targets? ')'
+        void *b;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (b = targets_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_Tuple ( b , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '[' targets? ']'
+        void *b;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 9))
+            &&
+            (b = targets_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 10))
+        )
+        {
+            Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (token == NULL) {
+                return NULL;
+            }
+            int end_lineno = token->end_lineno;
+            UNUSED(end_lineno); // Only used by EXTRA macro
+            int end_col_offset = token->end_col_offset;
+            UNUSED(end_col_offset); // Only used by EXTRA macro
+            res = _Py_List ( b , Store , EXTRA );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// incorrect_arguments:
+//     | args ',' '*'
+//     | expression for_if_clauses ',' [args | expression for_if_clauses]
+//     | args ',' args
+static void *
+incorrect_arguments_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // args ',' '*'
+        expr_ty args_var;
+        void *literal;
+        void *literal_1;
+        if (
+            (args_var = args_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 16))
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "iterable argument unpacking follows keyword argument unpacking" );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression for_if_clauses ',' [args | expression for_if_clauses]
+        expr_ty expression_var;
+        asdl_seq* for_if_clauses_var;
+        void *literal;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (expression_var = expression_rule(p))
+            &&
+            (for_if_clauses_var = for_if_clauses_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (opt_var = _tmp_116_rule(p), 1)
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "Generator expression must be parenthesized" );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // args ',' args
+        expr_ty a;
+        expr_ty args_var;
+        void *literal;
+        if (
+            (a = args_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (args_var = args_rule(p))
+        )
+        {
+            res = _PyPegen_arguments_parsing_error ( p , a );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// invalid_named_expression: expression ':=' expression
+static void *
+invalid_named_expression_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // expression ':=' expression
+        expr_ty a;
+        expr_ty expression_var;
+        void *literal;
+        if (
+            (a = expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 53))
+            &&
+            (expression_var = expression_rule(p))
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "cannot use assignment expressions with %s" , _PyPegen_get_expr_name ( a ) );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// invalid_assignment:
+//     | list ':'
+//     | tuple ':'
+//     | expression ':' expression ['=' annotated_rhs]
+//     | expression ('=' | augassign) (yield_expr | star_expressions)
+static void *
+invalid_assignment_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // list ':'
+        expr_ty list_var;
+        void *literal;
+        if (
+            (list_var = list_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "only single target (not list) can be annotated" );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // tuple ':'
+        void *literal;
+        expr_ty tuple_var;
+        if (
+            (tuple_var = tuple_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "only single target (not tuple) can be annotated" );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression ':' expression ['=' annotated_rhs]
+        expr_ty expression_var;
+        expr_ty expression_var_1;
+        void *literal;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        if (
+            (expression_var = expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (expression_var_1 = expression_rule(p))
+            &&
+            (opt_var = _tmp_117_rule(p), 1)
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "illegal target for annotation" );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression ('=' | augassign) (yield_expr | star_expressions)
+        void *_tmp_118_var;
+        void *_tmp_119_var;
+        expr_ty a;
+        if (
+            (a = expression_rule(p))
+            &&
+            (_tmp_118_var = _tmp_118_rule(p))
+            &&
+            (_tmp_119_var = _tmp_119_rule(p))
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "cannot assign to %s" , _PyPegen_get_expr_name ( a ) );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// invalid_block: NEWLINE !INDENT
+static void *
+invalid_block_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // NEWLINE !INDENT
+        void *newline_var;
+        if (
+            (newline_var = _PyPegen_newline_token(p))
+            &&
+            _PyPegen_lookahead(0, _PyPegen_indent_token, p)
+        )
+        {
+            res = RAISE_INDENTATION_ERROR ( "expected an indented block" );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// invalid_comprehension: ('[' | '(' | '{') '*' expression for_if_clauses
+static void *
+invalid_comprehension_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ('[' | '(' | '{') '*' expression for_if_clauses
+        void *_tmp_120_var;
+        expr_ty expression_var;
+        asdl_seq* for_if_clauses_var;
+        void *literal;
+        if (
+            (_tmp_120_var = _tmp_120_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 16))
+            &&
+            (expression_var = expression_rule(p))
+            &&
+            (for_if_clauses_var = for_if_clauses_rule(p))
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "iterable unpacking cannot be used in comprehension" );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// invalid_parameters:
+//     | [plain_names ','] (slash_with_default | names_with_default) ',' plain_names
+static void *
+invalid_parameters_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // [plain_names ','] (slash_with_default | names_with_default) ',' plain_names
+        void *_tmp_122_var;
+        void *literal;
+        void *opt_var;
+        UNUSED(opt_var); // Silence compiler warnings
+        asdl_seq* plain_names_var;
+        if (
+            (opt_var = _tmp_121_rule(p), 1)
+            &&
+            (_tmp_122_var = _tmp_122_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (plain_names_var = plain_names_rule(p))
+        )
+        {
+            res = RAISE_SYNTAX_ERROR ( "non-default argument follows default argument" );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_1: NEWLINE
+static asdl_seq *
+_loop0_1_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // NEWLINE
+        void *newline_var;
+        while (
+            (newline_var = _PyPegen_newline_token(p))
+        )
+        {
+            res = newline_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_1");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_1_type, seq);
+    return seq;
+}
+
+// _loop1_2: statement
+static asdl_seq *
+_loop1_2_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // statement
+        asdl_seq* statement_var;
+        while (
+            (statement_var = statement_rule(p))
+        )
+        {
+            res = statement_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_2");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_2_type, seq);
+    return seq;
+}
+
+// _loop0_4: ';' small_stmt
+static asdl_seq *
+_loop0_4_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ';' small_stmt
+        stmt_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 13))
+            &&
+            (elem = small_stmt_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_4");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_4_type, seq);
+    return seq;
+}
+
+// _gather_3: small_stmt _loop0_4
+static asdl_seq *
+_gather_3_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // small_stmt _loop0_4
+        stmt_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = small_stmt_rule(p))
+            &&
+            (seq = _loop0_4_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_5: 'import' | 'from'
+static void *
+_tmp_5_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'import'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 513))
+        )
+        {
+            res = keyword;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // 'from'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 514))
+        )
+        {
+            res = keyword;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_6: 'def' | '@' | ASYNC
+static void *
+_tmp_6_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'def'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 522))
+        )
+        {
+            res = keyword;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '@'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 49))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ASYNC
+        void *async_var;
+        if (
+            (async_var = _PyPegen_async_token(p))
+        )
+        {
+            res = async_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_7: 'class' | '@'
+static void *
+_tmp_7_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'class'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 523))
+        )
+        {
+            res = keyword;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '@'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 49))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_8: 'with' | ASYNC
+static void *
+_tmp_8_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'with'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 519))
+        )
+        {
+            res = keyword;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ASYNC
+        void *async_var;
+        if (
+            (async_var = _PyPegen_async_token(p))
+        )
+        {
+            res = async_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_9: 'for' | ASYNC
+static void *
+_tmp_9_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'for'
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 517))
+        )
+        {
+            res = keyword;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ASYNC
+        void *async_var;
+        if (
+            (async_var = _PyPegen_async_token(p))
+        )
+        {
+            res = async_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_10: '=' annotated_rhs
+static void *
+_tmp_10_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '=' annotated_rhs
+        expr_ty d;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 22))
+            &&
+            (d = annotated_rhs_rule(p))
+        )
+        {
+            res = d;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_11: '(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target
+static void *
+_tmp_11_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '(' inside_paren_ann_assign_target ')'
+        expr_ty b;
+        void *literal;
+        void *literal_1;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (b = inside_paren_ann_assign_target_rule(p))
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            res = b;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // ann_assign_subscript_attribute_target
+        expr_ty ann_assign_subscript_attribute_target_var;
+        if (
+            (ann_assign_subscript_attribute_target_var = ann_assign_subscript_attribute_target_rule(p))
+        )
+        {
+            res = ann_assign_subscript_attribute_target_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_12: '=' annotated_rhs
+static void *
+_tmp_12_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '=' annotated_rhs
+        expr_ty d;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 22))
+            &&
+            (d = annotated_rhs_rule(p))
+        )
+        {
+            res = d;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_13: (star_targets '=')
+static asdl_seq *
+_loop1_13_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // (star_targets '=')
+        void *_tmp_123_var;
+        while (
+            (_tmp_123_var = _tmp_123_rule(p))
+        )
+        {
+            res = _tmp_123_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_13");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_13_type, seq);
+    return seq;
+}
+
+// _tmp_14: yield_expr | star_expressions
+static void *
+_tmp_14_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // yield_expr
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))
+        )
+        {
+            res = yield_expr_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_expressions
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))
+        )
+        {
+            res = star_expressions_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_15: yield_expr | star_expressions
+static void *
+_tmp_15_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // yield_expr
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))
+        )
+        {
+            res = yield_expr_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_expressions
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))
+        )
+        {
+            res = star_expressions_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_17: ',' NAME
+static asdl_seq *
+_loop0_17_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' NAME
+        expr_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = _PyPegen_name_token(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_17");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_17_type, seq);
+    return seq;
+}
+
+// _gather_16: NAME _loop0_17
+static asdl_seq *
+_gather_16_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // NAME _loop0_17
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = _PyPegen_name_token(p))
+            &&
+            (seq = _loop0_17_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_19: ',' NAME
+static asdl_seq *
+_loop0_19_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' NAME
+        expr_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = _PyPegen_name_token(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_19");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_19_type, seq);
+    return seq;
+}
+
+// _gather_18: NAME _loop0_19
+static asdl_seq *
+_gather_18_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // NAME _loop0_19
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = _PyPegen_name_token(p))
+            &&
+            (seq = _loop0_19_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_20: ',' expression
+static void *
+_tmp_20_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' expression
+        void *literal;
+        expr_ty z;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = expression_rule(p))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_21: ('.' | '...')
+static asdl_seq *
+_loop0_21_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ('.' | '...')
+        void *_tmp_124_var;
+        while (
+            (_tmp_124_var = _tmp_124_rule(p))
+        )
+        {
+            res = _tmp_124_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_21");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_21_type, seq);
+    return seq;
+}
+
+// _loop1_22: ('.' | '...')
+static asdl_seq *
+_loop1_22_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ('.' | '...')
+        void *_tmp_125_var;
+        while (
+            (_tmp_125_var = _tmp_125_rule(p))
+        )
+        {
+            res = _tmp_125_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_22");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_22_type, seq);
+    return seq;
+}
+
+// _loop0_24: ',' import_from_as_name
+static asdl_seq *
+_loop0_24_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' import_from_as_name
+        alias_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = import_from_as_name_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_24");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_24_type, seq);
+    return seq;
+}
+
+// _gather_23: import_from_as_name _loop0_24
+static asdl_seq *
+_gather_23_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // import_from_as_name _loop0_24
+        alias_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = import_from_as_name_rule(p))
+            &&
+            (seq = _loop0_24_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_25: 'as' NAME
+static void *
+_tmp_25_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'as' NAME
+        void *keyword;
+        expr_ty z;
+        if (
+            (keyword = _PyPegen_expect_token(p, 531))
+            &&
+            (z = _PyPegen_name_token(p))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_27: ',' dotted_as_name
+static asdl_seq *
+_loop0_27_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' dotted_as_name
+        alias_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = dotted_as_name_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_27");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_27_type, seq);
+    return seq;
+}
+
+// _gather_26: dotted_as_name _loop0_27
+static asdl_seq *
+_gather_26_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // dotted_as_name _loop0_27
+        alias_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = dotted_as_name_rule(p))
+            &&
+            (seq = _loop0_27_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_28: 'as' NAME
+static void *
+_tmp_28_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'as' NAME
+        void *keyword;
+        expr_ty z;
+        if (
+            (keyword = _PyPegen_expect_token(p, 531))
+            &&
+            (z = _PyPegen_name_token(p))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_30: ',' with_item
+static asdl_seq *
+_loop0_30_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' with_item
+        withitem_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = with_item_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_30");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_30_type, seq);
+    return seq;
+}
+
+// _gather_29: with_item _loop0_30
+static asdl_seq *
+_gather_29_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // with_item _loop0_30
+        withitem_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = with_item_rule(p))
+            &&
+            (seq = _loop0_30_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_32: ',' with_item
+static asdl_seq *
+_loop0_32_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' with_item
+        withitem_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = with_item_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_32");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_32_type, seq);
+    return seq;
+}
+
+// _gather_31: with_item _loop0_32
+static asdl_seq *
+_gather_31_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // with_item _loop0_32
+        withitem_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = with_item_rule(p))
+            &&
+            (seq = _loop0_32_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_33: 'as' target
+static void *
+_tmp_33_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'as' target
+        void *keyword;
+        expr_ty t;
+        if (
+            (keyword = _PyPegen_expect_token(p, 531))
+            &&
+            (t = target_rule(p))
+        )
+        {
+            res = t;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_34: except_block
+static asdl_seq *
+_loop1_34_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // except_block
+        excepthandler_ty except_block_var;
+        while (
+            (except_block_var = except_block_rule(p))
+        )
+        {
+            res = except_block_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_34");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_34_type, seq);
+    return seq;
+}
+
+// _tmp_35: 'as' target
+static void *
+_tmp_35_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'as' target
+        void *keyword;
+        expr_ty z;
+        if (
+            (keyword = _PyPegen_expect_token(p, 531))
+            &&
+            (z = target_rule(p))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_36: 'from' expression
+static void *
+_tmp_36_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'from' expression
+        void *keyword;
+        expr_ty z;
+        if (
+            (keyword = _PyPegen_expect_token(p, 514))
+            &&
+            (z = expression_rule(p))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_37: '->' annotation
+static void *
+_tmp_37_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '->' annotation
+        void *literal;
+        expr_ty z;
+        if (
+            (literal = _PyPegen_expect_token(p, 51))
+            &&
+            (z = annotation_rule(p))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_38: ',' plain_names
+static void *
+_tmp_38_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' plain_names
+        void *literal;
+        asdl_seq* x;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (x = plain_names_rule(p))
+        )
+        {
+            res = x;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_39: ',' names_with_default
+static void *
+_tmp_39_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' names_with_default
+        void *literal;
+        asdl_seq* y;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (y = names_with_default_rule(p))
+        )
+        {
+            res = y;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_40: ',' star_etc?
+static void *
+_tmp_40_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' star_etc?
+        void *literal;
+        void *z;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = star_etc_rule(p), 1)
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_41: ',' names_with_default
+static void *
+_tmp_41_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' names_with_default
+        void *literal;
+        asdl_seq* y;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (y = names_with_default_rule(p))
+        )
+        {
+            res = y;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_42: ',' star_etc?
+static void *
+_tmp_42_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' star_etc?
+        void *literal;
+        void *z;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = star_etc_rule(p), 1)
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_43: ',' names_with_default
+static void *
+_tmp_43_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' names_with_default
+        void *literal;
+        asdl_seq* y;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (y = names_with_default_rule(p))
+        )
+        {
+            res = y;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_44: ',' star_etc?
+static void *
+_tmp_44_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' star_etc?
+        void *literal;
+        void *z;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = star_etc_rule(p), 1)
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_45: ',' star_etc?
+static void *
+_tmp_45_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' star_etc?
+        void *literal;
+        void *z;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = star_etc_rule(p), 1)
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_46: plain_names ','
+static void *
+_tmp_46_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // plain_names ','
+        void *literal;
+        asdl_seq* n;
+        if (
+            (n = plain_names_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+        )
+        {
+            res = n;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_47: name_with_optional_default
+static asdl_seq *
+_loop0_47_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // name_with_optional_default
+        NameDefaultPair* name_with_optional_default_var;
+        while (
+            (name_with_optional_default_var = name_with_optional_default_rule(p))
+        )
+        {
+            res = name_with_optional_default_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_47");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_47_type, seq);
+    return seq;
+}
+
+// _tmp_48: ',' kwds
+static void *
+_tmp_48_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' kwds
+        arg_ty d;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (d = kwds_rule(p))
+        )
+        {
+            res = d;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_49: name_with_optional_default
+static asdl_seq *
+_loop1_49_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // name_with_optional_default
+        NameDefaultPair* name_with_optional_default_var;
+        while (
+            (name_with_optional_default_var = name_with_optional_default_rule(p))
+        )
+        {
+            res = name_with_optional_default_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_49");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_49_type, seq);
+    return seq;
+}
+
+// _tmp_50: ',' kwds
+static void *
+_tmp_50_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' kwds
+        arg_ty d;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (d = kwds_rule(p))
+        )
+        {
+            res = d;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_51: '=' expression
+static void *
+_tmp_51_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '=' expression
+        expr_ty e;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 22))
+            &&
+            (e = expression_rule(p))
+        )
+        {
+            res = e;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_53: ',' name_with_default
+static asdl_seq *
+_loop0_53_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' name_with_default
+        NameDefaultPair* elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = name_with_default_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_53");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_53_type, seq);
+    return seq;
+}
+
+// _gather_52: name_with_default _loop0_53
+static asdl_seq *
+_gather_52_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // name_with_default _loop0_53
+        NameDefaultPair* elem;
+        asdl_seq * seq;
+        if (
+            (elem = name_with_default_rule(p))
+            &&
+            (seq = _loop0_53_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_55: ',' (plain_name !'=')
+static asdl_seq *
+_loop0_55_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' (plain_name !'=')
+        void *elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = _tmp_126_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_55");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_55_type, seq);
+    return seq;
+}
+
+// _gather_54: (plain_name !'=') _loop0_55
+static asdl_seq *
+_gather_54_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // (plain_name !'=') _loop0_55
+        void *elem;
+        asdl_seq * seq;
+        if (
+            (elem = _tmp_126_rule(p))
+            &&
+            (seq = _loop0_55_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_56: ':' annotation
+static void *
+_tmp_56_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ':' annotation
+        void *literal;
+        expr_ty z;
+        if (
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (z = annotation_rule(p))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_57: ('@' named_expression NEWLINE)
+static asdl_seq *
+_loop1_57_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ('@' named_expression NEWLINE)
+        void *_tmp_127_var;
+        while (
+            (_tmp_127_var = _tmp_127_rule(p))
+        )
+        {
+            res = _tmp_127_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_57");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_57_type, seq);
+    return seq;
+}
+
+// _tmp_58: '(' arguments? ')'
+static void *
+_tmp_58_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '(' arguments? ')'
+        void *literal;
+        void *literal_1;
+        void *z;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+            &&
+            (z = arguments_rule(p), 1)
+            &&
+            (literal_1 = _PyPegen_expect_token(p, 8))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_60: ',' star_expression
+static asdl_seq *
+_loop0_60_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' star_expression
+        expr_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = star_expression_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_60");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_60_type, seq);
+    return seq;
+}
+
+// _gather_59: star_expression _loop0_60
+static asdl_seq *
+_gather_59_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // star_expression _loop0_60
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = star_expression_rule(p))
+            &&
+            (seq = _loop0_60_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_61: (',' star_expression)
+static asdl_seq *
+_loop1_61_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // (',' star_expression)
+        void *_tmp_128_var;
+        while (
+            (_tmp_128_var = _tmp_128_rule(p))
+        )
+        {
+            res = _tmp_128_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_61");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_61_type, seq);
+    return seq;
+}
+
+// _loop0_63: ',' star_named_expression
+static asdl_seq *
+_loop0_63_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' star_named_expression
+        expr_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = star_named_expression_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_63");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_63_type, seq);
+    return seq;
+}
+
+// _gather_62: star_named_expression _loop0_63
+static asdl_seq *
+_gather_62_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // star_named_expression _loop0_63
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = star_named_expression_rule(p))
+            &&
+            (seq = _loop0_63_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_64: (',' expression)
+static asdl_seq *
+_loop1_64_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // (',' expression)
+        void *_tmp_129_var;
+        while (
+            (_tmp_129_var = _tmp_129_rule(p))
+        )
+        {
+            res = _tmp_129_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_64");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_64_type, seq);
+    return seq;
+}
+
+// _tmp_65: ',' lambda_plain_names
+static void *
+_tmp_65_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_plain_names
+        void *literal;
+        asdl_seq* x;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (x = lambda_plain_names_rule(p))
+        )
+        {
+            res = x;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_66: ',' lambda_names_with_default
+static void *
+_tmp_66_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_names_with_default
+        void *literal;
+        asdl_seq* y;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (y = lambda_names_with_default_rule(p))
+        )
+        {
+            res = y;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_67: ',' lambda_star_etc?
+static void *
+_tmp_67_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_star_etc?
+        void *literal;
+        void *z;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = lambda_star_etc_rule(p), 1)
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_68: ',' lambda_names_with_default
+static void *
+_tmp_68_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_names_with_default
+        void *literal;
+        asdl_seq* y;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (y = lambda_names_with_default_rule(p))
+        )
+        {
+            res = y;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_69: ',' lambda_star_etc?
+static void *
+_tmp_69_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_star_etc?
+        void *literal;
+        void *z;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = lambda_star_etc_rule(p), 1)
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_70: ',' lambda_names_with_default
+static void *
+_tmp_70_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_names_with_default
+        void *literal;
+        asdl_seq* y;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (y = lambda_names_with_default_rule(p))
+        )
+        {
+            res = y;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_71: ',' lambda_star_etc?
+static void *
+_tmp_71_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_star_etc?
+        void *literal;
+        void *z;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = lambda_star_etc_rule(p), 1)
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_72: ',' lambda_star_etc?
+static void *
+_tmp_72_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_star_etc?
+        void *literal;
+        void *z;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = lambda_star_etc_rule(p), 1)
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_73: lambda_plain_names ','
+static void *
+_tmp_73_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // lambda_plain_names ','
+        void *literal;
+        asdl_seq* n;
+        if (
+            (n = lambda_plain_names_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+        )
+        {
+            res = n;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_74: lambda_name_with_optional_default
+static asdl_seq *
+_loop0_74_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // lambda_name_with_optional_default
+        NameDefaultPair* lambda_name_with_optional_default_var;
+        while (
+            (lambda_name_with_optional_default_var = lambda_name_with_optional_default_rule(p))
+        )
+        {
+            res = lambda_name_with_optional_default_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_74");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_74_type, seq);
+    return seq;
+}
+
+// _tmp_75: ',' lambda_kwds
+static void *
+_tmp_75_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_kwds
+        arg_ty d;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (d = lambda_kwds_rule(p))
+        )
+        {
+            res = d;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_76: lambda_name_with_optional_default
+static asdl_seq *
+_loop1_76_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // lambda_name_with_optional_default
+        NameDefaultPair* lambda_name_with_optional_default_var;
+        while (
+            (lambda_name_with_optional_default_var = lambda_name_with_optional_default_rule(p))
+        )
+        {
+            res = lambda_name_with_optional_default_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_76");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_76_type, seq);
+    return seq;
+}
+
+// _tmp_77: ',' lambda_kwds
+static void *
+_tmp_77_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' lambda_kwds
+        arg_ty d;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (d = lambda_kwds_rule(p))
+        )
+        {
+            res = d;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_78: '=' expression
+static void *
+_tmp_78_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '=' expression
+        expr_ty e;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 22))
+            &&
+            (e = expression_rule(p))
+        )
+        {
+            res = e;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_80: ',' lambda_name_with_default
+static asdl_seq *
+_loop0_80_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' lambda_name_with_default
+        NameDefaultPair* elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = lambda_name_with_default_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_80");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_80_type, seq);
+    return seq;
+}
+
+// _gather_79: lambda_name_with_default _loop0_80
+static asdl_seq *
+_gather_79_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // lambda_name_with_default _loop0_80
+        NameDefaultPair* elem;
+        asdl_seq * seq;
+        if (
+            (elem = lambda_name_with_default_rule(p))
+            &&
+            (seq = _loop0_80_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_82: ',' (lambda_plain_name !'=')
+static asdl_seq *
+_loop0_82_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' (lambda_plain_name !'=')
+        void *elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = _tmp_130_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_82");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_82_type, seq);
+    return seq;
+}
+
+// _gather_81: (lambda_plain_name !'=') _loop0_82
+static asdl_seq *
+_gather_81_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // (lambda_plain_name !'=') _loop0_82
+        void *elem;
+        asdl_seq * seq;
+        if (
+            (elem = _tmp_130_rule(p))
+            &&
+            (seq = _loop0_82_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_83: ('or' conjunction)
+static asdl_seq *
+_loop1_83_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ('or' conjunction)
+        void *_tmp_131_var;
+        while (
+            (_tmp_131_var = _tmp_131_rule(p))
+        )
+        {
+            res = _tmp_131_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_83");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_83_type, seq);
+    return seq;
+}
+
+// _loop1_84: ('and' inversion)
+static asdl_seq *
+_loop1_84_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ('and' inversion)
+        void *_tmp_132_var;
+        while (
+            (_tmp_132_var = _tmp_132_rule(p))
+        )
+        {
+            res = _tmp_132_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_84");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_84_type, seq);
+    return seq;
+}
+
+// _loop1_85: compare_op_bitwise_or_pair
+static asdl_seq *
+_loop1_85_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // compare_op_bitwise_or_pair
+        CmpopExprPair* compare_op_bitwise_or_pair_var;
+        while (
+            (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p))
+        )
+        {
+            res = compare_op_bitwise_or_pair_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_85");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_85_type, seq);
+    return seq;
+}
+
+// _loop0_87: ',' slice
+static asdl_seq *
+_loop0_87_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' slice
+        expr_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = slice_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_87");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_87_type, seq);
+    return seq;
+}
+
+// _gather_86: slice _loop0_87
+static asdl_seq *
+_gather_86_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // slice _loop0_87
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = slice_rule(p))
+            &&
+            (seq = _loop0_87_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_88: ':' expression?
+static void *
+_tmp_88_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ':' expression?
+        void *d;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 11))
+            &&
+            (d = expression_rule(p), 1)
+        )
+        {
+            res = d;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_89: tuple | group | genexp
+static void *
+_tmp_89_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // tuple
+        expr_ty tuple_var;
+        if (
+            (tuple_var = tuple_rule(p))
+        )
+        {
+            res = tuple_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // group
+        expr_ty group_var;
+        if (
+            (group_var = group_rule(p))
+        )
+        {
+            res = group_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // genexp
+        expr_ty genexp_var;
+        if (
+            (genexp_var = genexp_rule(p))
+        )
+        {
+            res = genexp_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_90: list | listcomp
+static void *
+_tmp_90_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // list
+        expr_ty list_var;
+        if (
+            (list_var = list_rule(p))
+        )
+        {
+            res = list_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // listcomp
+        expr_ty listcomp_var;
+        if (
+            (listcomp_var = listcomp_rule(p))
+        )
+        {
+            res = listcomp_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_91: dict | set | dictcomp | setcomp
+static void *
+_tmp_91_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // dict
+        expr_ty dict_var;
+        if (
+            (dict_var = dict_rule(p))
+        )
+        {
+            res = dict_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // set
+        expr_ty set_var;
+        if (
+            (set_var = set_rule(p))
+        )
+        {
+            res = set_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // dictcomp
+        expr_ty dictcomp_var;
+        if (
+            (dictcomp_var = dictcomp_rule(p))
+        )
+        {
+            res = dictcomp_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // setcomp
+        expr_ty setcomp_var;
+        if (
+            (setcomp_var = setcomp_rule(p))
+        )
+        {
+            res = setcomp_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_92: STRING
+static asdl_seq *
+_loop1_92_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // STRING
+        expr_ty string_var;
+        while (
+            (string_var = _PyPegen_string_token(p))
+        )
+        {
+            res = string_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_92");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_92_type, seq);
+    return seq;
+}
+
+// _tmp_93: star_named_expression ',' star_named_expressions?
+static void *
+_tmp_93_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // star_named_expression ',' star_named_expressions?
+        void *literal;
+        expr_ty y;
+        void *z;
+        if (
+            (y = star_named_expression_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (z = star_named_expressions_rule(p), 1)
+        )
+        {
+            res = _PyPegen_seq_insert_in_front ( p , y , z );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_94: yield_expr | named_expression
+static void *
+_tmp_94_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // yield_expr
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))
+        )
+        {
+            res = yield_expr_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // named_expression
+        expr_ty named_expression_var;
+        if (
+            (named_expression_var = named_expression_rule(p))
+        )
+        {
+            res = named_expression_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_96: ',' kvpair
+static asdl_seq *
+_loop0_96_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' kvpair
+        KeyValuePair* elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = kvpair_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_96");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_96_type, seq);
+    return seq;
+}
+
+// _gather_95: kvpair _loop0_96
+static asdl_seq *
+_gather_95_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // kvpair _loop0_96
+        KeyValuePair* elem;
+        asdl_seq * seq;
+        if (
+            (elem = kvpair_rule(p))
+            &&
+            (seq = _loop0_96_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop1_97: (ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*)
+static asdl_seq *
+_loop1_97_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // (ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*)
+        void *_tmp_133_var;
+        while (
+            (_tmp_133_var = _tmp_133_rule(p))
+        )
+        {
+            res = _tmp_133_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    if (n == 0) {
+        PyMem_Free(children);
+        return NULL;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_97");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop1_97_type, seq);
+    return seq;
+}
+
+// _tmp_98: ',' args
+static void *
+_tmp_98_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' args
+        expr_ty c;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (c = args_rule(p))
+        )
+        {
+            res = c;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_99: ',' args
+static void *
+_tmp_99_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' args
+        expr_ty c;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (c = args_rule(p))
+        )
+        {
+            res = c;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_101: ',' kwarg_or_starred
+static asdl_seq *
+_loop0_101_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' kwarg_or_starred
+        KeywordOrStarred* elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = kwarg_or_starred_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_101");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_101_type, seq);
+    return seq;
+}
+
+// _gather_100: kwarg_or_starred _loop0_101
+static asdl_seq *
+_gather_100_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // kwarg_or_starred _loop0_101
+        KeywordOrStarred* elem;
+        asdl_seq * seq;
+        if (
+            (elem = kwarg_or_starred_rule(p))
+            &&
+            (seq = _loop0_101_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_103: ',' kwarg_or_double_starred
+static asdl_seq *
+_loop0_103_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' kwarg_or_double_starred
+        KeywordOrStarred* elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = kwarg_or_double_starred_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_103");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_103_type, seq);
+    return seq;
+}
+
+// _gather_102: kwarg_or_double_starred _loop0_103
+static asdl_seq *
+_gather_102_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // kwarg_or_double_starred _loop0_103
+        KeywordOrStarred* elem;
+        asdl_seq * seq;
+        if (
+            (elem = kwarg_or_double_starred_rule(p))
+            &&
+            (seq = _loop0_103_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_105: ',' kwarg_or_starred
+static asdl_seq *
+_loop0_105_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' kwarg_or_starred
+        KeywordOrStarred* elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = kwarg_or_starred_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_105");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_105_type, seq);
+    return seq;
+}
+
+// _gather_104: kwarg_or_starred _loop0_105
+static asdl_seq *
+_gather_104_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // kwarg_or_starred _loop0_105
+        KeywordOrStarred* elem;
+        asdl_seq * seq;
+        if (
+            (elem = kwarg_or_starred_rule(p))
+            &&
+            (seq = _loop0_105_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_107: ',' kwarg_or_double_starred
+static asdl_seq *
+_loop0_107_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' kwarg_or_double_starred
+        KeywordOrStarred* elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = kwarg_or_double_starred_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_107");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_107_type, seq);
+    return seq;
+}
+
+// _gather_106: kwarg_or_double_starred _loop0_107
+static asdl_seq *
+_gather_106_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // kwarg_or_double_starred _loop0_107
+        KeywordOrStarred* elem;
+        asdl_seq * seq;
+        if (
+            (elem = kwarg_or_double_starred_rule(p))
+            &&
+            (seq = _loop0_107_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_108: (',' star_target)
+static asdl_seq *
+_loop0_108_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // (',' star_target)
+        void *_tmp_134_var;
+        while (
+            (_tmp_134_var = _tmp_134_rule(p))
+        )
+        {
+            res = _tmp_134_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_108");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_108_type, seq);
+    return seq;
+}
+
+// _loop0_110: ',' star_target
+static asdl_seq *
+_loop0_110_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' star_target
+        expr_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = star_target_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_110");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_110_type, seq);
+    return seq;
+}
+
+// _gather_109: star_target _loop0_110
+static asdl_seq *
+_gather_109_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // star_target _loop0_110
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = star_target_rule(p))
+            &&
+            (seq = _loop0_110_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_111: !'*' star_target
+static void *
+_tmp_111_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // !'*' star_target
+        expr_ty star_target_var;
+        if (
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16)
+            &&
+            (star_target_var = star_target_rule(p))
+        )
+        {
+            res = star_target_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_113: ',' del_target
+static asdl_seq *
+_loop0_113_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' del_target
+        expr_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = del_target_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_113");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_113_type, seq);
+    return seq;
+}
+
+// _gather_112: del_target _loop0_113
+static asdl_seq *
+_gather_112_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // del_target _loop0_113
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = del_target_rule(p))
+            &&
+            (seq = _loop0_113_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_115: ',' target
+static asdl_seq *
+_loop0_115_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ',' target
+        expr_ty elem;
+        void *literal;
+        while (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (elem = target_rule(p))
+        )
+        {
+            res = elem;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(children);
+                return NULL;
+            }
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_115");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_115_type, seq);
+    return seq;
+}
+
+// _gather_114: target _loop0_115
+static asdl_seq *
+_gather_114_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    asdl_seq * res = NULL;
+    int mark = p->mark;
+    { // target _loop0_115
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = target_rule(p))
+            &&
+            (seq = _loop0_115_rule(p))
+        )
+        {
+            res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_116: args | expression for_if_clauses
+static void *
+_tmp_116_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // args
+        expr_ty args_var;
+        if (
+            (args_var = args_rule(p))
+        )
+        {
+            res = args_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // expression for_if_clauses
+        expr_ty expression_var;
+        asdl_seq* for_if_clauses_var;
+        if (
+            (expression_var = expression_rule(p))
+            &&
+            (for_if_clauses_var = for_if_clauses_rule(p))
+        )
+        {
+            res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_117: '=' annotated_rhs
+static void *
+_tmp_117_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '=' annotated_rhs
+        expr_ty annotated_rhs_var;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 22))
+            &&
+            (annotated_rhs_var = annotated_rhs_rule(p))
+        )
+        {
+            res = _PyPegen_dummy_name(p, literal, annotated_rhs_var);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_118: '=' | augassign
+static void *
+_tmp_118_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '='
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 22))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // augassign
+        AugOperator* augassign_var;
+        if (
+            (augassign_var = augassign_rule(p))
+        )
+        {
+            res = augassign_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_119: yield_expr | star_expressions
+static void *
+_tmp_119_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // yield_expr
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))
+        )
+        {
+            res = yield_expr_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // star_expressions
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))
+        )
+        {
+            res = star_expressions_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_120: '[' | '(' | '{'
+static void *
+_tmp_120_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '['
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 9))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '('
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 7))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '{'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 25))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_121: plain_names ','
+static void *
+_tmp_121_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // plain_names ','
+        void *literal;
+        asdl_seq* plain_names_var;
+        if (
+            (plain_names_var = plain_names_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 12))
+        )
+        {
+            res = _PyPegen_dummy_name(p, plain_names_var, literal);
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_122: slash_with_default | names_with_default
+static void *
+_tmp_122_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // slash_with_default
+        SlashWithDefault* slash_with_default_var;
+        if (
+            (slash_with_default_var = slash_with_default_rule(p))
+        )
+        {
+            res = slash_with_default_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // names_with_default
+        asdl_seq* names_with_default_var;
+        if (
+            (names_with_default_var = names_with_default_rule(p))
+        )
+        {
+            res = names_with_default_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_123: star_targets '='
+static void *
+_tmp_123_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // star_targets '='
+        void *literal;
+        expr_ty z;
+        if (
+            (z = star_targets_rule(p))
+            &&
+            (literal = _PyPegen_expect_token(p, 22))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_124: '.' | '...'
+static void *
+_tmp_124_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '.'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 23))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '...'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 52))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_125: '.' | '...'
+static void *
+_tmp_125_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '.'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 23))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    { // '...'
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 52))
+        )
+        {
+            res = literal;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_126: plain_name !'='
+static void *
+_tmp_126_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // plain_name !'='
+        arg_ty plain_name_var;
+        if (
+            (plain_name_var = plain_name_rule(p))
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)
+        )
+        {
+            res = plain_name_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_127: '@' named_expression NEWLINE
+static void *
+_tmp_127_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // '@' named_expression NEWLINE
+        expr_ty f;
+        void *literal;
+        void *newline_var;
+        if (
+            (literal = _PyPegen_expect_token(p, 49))
+            &&
+            (f = named_expression_rule(p))
+            &&
+            (newline_var = _PyPegen_newline_token(p))
+        )
+        {
+            res = f;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_128: ',' star_expression
+static void *
+_tmp_128_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' star_expression
+        expr_ty c;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (c = star_expression_rule(p))
+        )
+        {
+            res = c;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_129: ',' expression
+static void *
+_tmp_129_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' expression
+        expr_ty c;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (c = expression_rule(p))
+        )
+        {
+            res = c;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_130: lambda_plain_name !'='
+static void *
+_tmp_130_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // lambda_plain_name !'='
+        arg_ty lambda_plain_name_var;
+        if (
+            (lambda_plain_name_var = lambda_plain_name_rule(p))
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)
+        )
+        {
+            res = lambda_plain_name_var;
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_131: 'or' conjunction
+static void *
+_tmp_131_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'or' conjunction
+        expr_ty c;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 532))
+            &&
+            (c = conjunction_rule(p))
+        )
+        {
+            res = c;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_132: 'and' inversion
+static void *
+_tmp_132_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'and' inversion
+        expr_ty c;
+        void *keyword;
+        if (
+            (keyword = _PyPegen_expect_token(p, 533))
+            &&
+            (c = inversion_rule(p))
+        )
+        {
+            res = c;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_133: ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*
+static void *
+_tmp_133_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*
+        expr_ty a;
+        expr_ty b;
+        asdl_seq * c;
+        void *keyword;
+        void *keyword_1;
+        void *y;
+        if (
+            (y = _PyPegen_async_token(p), 1)
+            &&
+            (keyword = _PyPegen_expect_token(p, 517))
+            &&
+            (a = star_targets_rule(p))
+            &&
+            (keyword_1 = _PyPegen_expect_token(p, 518))
+            &&
+            (b = disjunction_rule(p))
+            &&
+            (c = _loop0_135_rule(p))
+        )
+        {
+            res = _Py_comprehension ( a , b , c , y != NULL , p -> arena );
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _tmp_134: ',' star_target
+static void *
+_tmp_134_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // ',' star_target
+        expr_ty c;
+        void *literal;
+        if (
+            (literal = _PyPegen_expect_token(p, 12))
+            &&
+            (c = star_target_rule(p))
+        )
+        {
+            res = c;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+// _loop0_135: ('if' disjunction)
+static asdl_seq *
+_loop0_135_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void *res = NULL;
+    int mark = p->mark;
+    int start_mark = p->mark;
+    void **children = PyMem_Malloc(sizeof(void *));
+    if (!children) {
+        PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+        return NULL;
+    }
+    ssize_t children_capacity = 1;
+    ssize_t n = 0;
+    { // ('if' disjunction)
+        void *_tmp_136_var;
+        while (
+            (_tmp_136_var = _tmp_136_rule(p))
+        )
+        {
+            res = _tmp_136_var;
+            if (n == children_capacity) {
+                children_capacity *= 2;
+                children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+                if (!children) {
+                    PyErr_Format(PyExc_MemoryError, "realloc None");
+                    return NULL;
+                }
+            }
+            children[n++] = res;
+            mark = p->mark;
+        }
+        p->mark = mark;
+    }
+    asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+    if (!seq) {
+        PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_135");
+        PyMem_Free(children);
+        return NULL;
+    }
+    for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+    PyMem_Free(children);
+    _PyPegen_insert_memo(p, start_mark, _loop0_135_type, seq);
+    return seq;
+}
+
+// _tmp_136: 'if' disjunction
+static void *
+_tmp_136_rule(Parser *p)
+{
+    if (p->error_indicator) {
+        return NULL;
+    }
+    void * res = NULL;
+    int mark = p->mark;
+    { // 'if' disjunction
+        void *keyword;
+        expr_ty z;
+        if (
+            (keyword = _PyPegen_expect_token(p, 510))
+            &&
+            (z = disjunction_rule(p))
+        )
+        {
+            res = z;
+            if (res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = mark;
+    }
+    res = NULL;
+  done:
+    return res;
+}
+
+void *
+_PyPegen_parse(Parser *p)
+{
+    // Initialize keywords
+    p->keywords = reserved_keywords;
+    p->n_keyword_lists = n_keyword_lists;
+
+    // Run parser
+    void *result = NULL;
+    if (p->start_rule == Py_file_input) {
+        result = file_rule(p);
+    } else if (p->start_rule == Py_single_input) {
+        result = interactive_rule(p);
+    } else if (p->start_rule == Py_eval_input) {
+        result = eval_rule(p);
+    } else if (p->start_rule == Py_fstring_input) {
+        result = fstring_rule(p);
+    }
+
+    return result;
+}
+
+// The end
diff --git a/Parser/pegen/parse_string.c b/Parser/pegen/parse_string.c
new file mode 100644
index 0000000..41485a9
--- /dev/null
+++ b/Parser/pegen/parse_string.c
@@ -0,0 +1,1387 @@
+#include <Python.h>
+
+#include "../tokenizer.h"
+#include "pegen.h"
+#include "parse_string.h"
+
+//// STRING HANDLING FUNCTIONS ////
+
+// These functions are ported directly from Python/ast.c with some modifications
+// to account for the use of "Parser *p", the fact that don't have parser nodes
+// to pass around and the usage of some specialized APIs present only in this
+// file (like "_PyPegen_raise_syntax_error").
+
+static int
+warn_invalid_escape_sequence(Parser *p, unsigned char first_invalid_escape_char)
+{
+    PyObject *msg =
+        PyUnicode_FromFormat("invalid escape sequence \\%c", first_invalid_escape_char);
+    if (msg == NULL) {
+        return -1;
+    }
+    if (PyErr_WarnExplicitObject(PyExc_DeprecationWarning, msg, p->tok->filename,
+                                 p->tok->lineno, NULL, NULL) < 0) {
+        if (PyErr_ExceptionMatches(PyExc_DeprecationWarning)) {
+            /* Replace the DeprecationWarning exception with a SyntaxError
+               to get a more accurate error report */
+            PyErr_Clear();
+            RAISE_SYNTAX_ERROR("invalid escape sequence \\%c", first_invalid_escape_char);
+        }
+        Py_DECREF(msg);
+        return -1;
+    }
+    Py_DECREF(msg);
+    return 0;
+}
+
+static PyObject *
+decode_utf8(const char **sPtr, const char *end)
+{
+    const char *s, *t;
+    t = s = *sPtr;
+    while (s < end && (*s & 0x80)) {
+        s++;
+    }
+    *sPtr = s;
+    return PyUnicode_DecodeUTF8(t, s - t, NULL);
+}
+
+static PyObject *
+decode_unicode_with_escapes(Parser *parser, const char *s, size_t len)
+{
+    PyObject *v, *u;
+    char *buf;
+    char *p;
+    const char *end;
+
+    /* check for integer overflow */
+    if (len > SIZE_MAX / 6) {
+        return NULL;
+    }
+    /* "ä" (2 bytes) may become "\U000000E4" (10 bytes), or 1:5
+       "\ä" (3 bytes) may become "\u005c\U000000E4" (16 bytes), or ~1:6 */
+    u = PyBytes_FromStringAndSize((char *)NULL, len * 6);
+    if (u == NULL) {
+        return NULL;
+    }
+    p = buf = PyBytes_AsString(u);
+    end = s + len;
+    while (s < end) {
+        if (*s == '\\') {
+            *p++ = *s++;
+            if (s >= end || *s & 0x80) {
+                strcpy(p, "u005c");
+                p += 5;
+                if (s >= end) {
+                    break;
+                }
+            }
+        }
+        if (*s & 0x80) {
+            PyObject *w;
+            int kind;
+            void *data;
+            Py_ssize_t len, i;
+            w = decode_utf8(&s, end);
+            if (w == NULL) {
+                Py_DECREF(u);
+                return NULL;
+            }
+            kind = PyUnicode_KIND(w);
+            data = PyUnicode_DATA(w);
+            len = PyUnicode_GET_LENGTH(w);
+            for (i = 0; i < len; i++) {
+                Py_UCS4 chr = PyUnicode_READ(kind, data, i);
+                sprintf(p, "\\U%08x", chr);
+                p += 10;
+            }
+            /* Should be impossible to overflow */
+            assert(p - buf <= PyBytes_GET_SIZE(u));
+            Py_DECREF(w);
+        }
+        else {
+            *p++ = *s++;
+        }
+    }
+    len = p - buf;
+    s = buf;
+
+    const char *first_invalid_escape;
+    v = _PyUnicode_DecodeUnicodeEscape(s, len, NULL, &first_invalid_escape);
+
+    if (v != NULL && first_invalid_escape != NULL) {
+        if (warn_invalid_escape_sequence(parser, *first_invalid_escape) < 0) {
+            /* We have not decref u before because first_invalid_escape points
+               inside u. */
+            Py_XDECREF(u);
+            Py_DECREF(v);
+            return NULL;
+        }
+    }
+    Py_XDECREF(u);
+    return v;
+}
+
+static PyObject *
+decode_bytes_with_escapes(Parser *p, const char *s, Py_ssize_t len)
+{
+    const char *first_invalid_escape;
+    PyObject *result = _PyBytes_DecodeEscape(s, len, NULL, &first_invalid_escape);
+    if (result == NULL) {
+        return NULL;
+    }
+
+    if (first_invalid_escape != NULL) {
+        if (warn_invalid_escape_sequence(p, *first_invalid_escape) < 0) {
+            Py_DECREF(result);
+            return NULL;
+        }
+    }
+    return result;
+}
+
+/* s must include the bracketing quote characters, and r, b, u,
+   &/or f prefixes (if any), and embedded escape sequences (if any).
+   _PyPegen_parsestr parses it, and sets *result to decoded Python string object.
+   If the string is an f-string, set *fstr and *fstrlen to the unparsed
+   string object.  Return 0 if no errors occurred.  */
+int
+_PyPegen_parsestr(Parser *p, const char *s, int *bytesmode, int *rawmode, PyObject **result,
+         const char **fstr, Py_ssize_t *fstrlen)
+{
+    size_t len;
+    int quote = Py_CHARMASK(*s);
+    int fmode = 0;
+    *bytesmode = 0;
+    *rawmode = 0;
+    *result = NULL;
+    *fstr = NULL;
+    if (Py_ISALPHA(quote)) {
+        while (!*bytesmode || !*rawmode) {
+            if (quote == 'b' || quote == 'B') {
+                quote = *++s;
+                *bytesmode = 1;
+            }
+            else if (quote == 'u' || quote == 'U') {
+                quote = *++s;
+            }
+            else if (quote == 'r' || quote == 'R') {
+                quote = *++s;
+                *rawmode = 1;
+            }
+            else if (quote == 'f' || quote == 'F') {
+                quote = *++s;
+                fmode = 1;
+            }
+            else {
+                break;
+            }
+        }
+    }
+
+    if (fmode && *bytesmode) {
+        PyErr_BadInternalCall();
+        return -1;
+    }
+    if (quote != '\'' && quote != '\"') {
+        PyErr_BadInternalCall();
+        return -1;
+    }
+    /* Skip the leading quote char. */
+    s++;
+    len = strlen(s);
+    if (len > INT_MAX) {
+        PyErr_SetString(PyExc_OverflowError, "string to parse is too long");
+        return -1;
+    }
+    if (s[--len] != quote) {
+        /* Last quote char must match the first. */
+        PyErr_BadInternalCall();
+        return -1;
+    }
+    if (len >= 4 && s[0] == quote && s[1] == quote) {
+        /* A triple quoted string. We've already skipped one quote at
+           the start and one at the end of the string. Now skip the
+           two at the start. */
+        s += 2;
+        len -= 2;
+        /* And check that the last two match. */
+        if (s[--len] != quote || s[--len] != quote) {
+            PyErr_BadInternalCall();
+            return -1;
+        }
+    }
+
+    if (fmode) {
+        /* Just return the bytes. The caller will parse the resulting
+           string. */
+        *fstr = s;
+        *fstrlen = len;
+        return 0;
+    }
+
+    /* Not an f-string. */
+    /* Avoid invoking escape decoding routines if possible. */
+    *rawmode = *rawmode || strchr(s, '\\') == NULL;
+    if (*bytesmode) {
+        /* Disallow non-ASCII characters. */
+        const char *ch;
+        for (ch = s; *ch; ch++) {
+            if (Py_CHARMASK(*ch) >= 0x80) {
+                RAISE_SYNTAX_ERROR(
+                                   "bytes can only contain ASCII "
+                                   "literal characters.");
+                return -1;
+            }
+        }
+        if (*rawmode) {
+            *result = PyBytes_FromStringAndSize(s, len);
+        }
+        else {
+            *result = decode_bytes_with_escapes(p, s, len);
+        }
+    }
+    else {
+        if (*rawmode) {
+            *result = PyUnicode_DecodeUTF8Stateful(s, len, NULL, NULL);
+        }
+        else {
+            *result = decode_unicode_with_escapes(p, s, len);
+        }
+    }
+    return *result == NULL ? -1 : 0;
+}
+
+
+
+// FSTRING STUFF
+
+static void fstring_shift_expr_locations(expr_ty n, int lineno, int col_offset);
+static void fstring_shift_argument(expr_ty parent, arg_ty args, int lineno, int col_offset);
+
+
+static inline void shift_expr(expr_ty parent, expr_ty n, int line, int col) {
+    if (parent->lineno < n->lineno) {
+        col = 0;
+    }
+    fstring_shift_expr_locations(n, line, col);
+}
+
+static inline void shift_arg(expr_ty parent, arg_ty n, int line, int col) {
+    if (parent->lineno < n->lineno) {
+        col = 0;
+    }
+    fstring_shift_argument(parent, n, line, col);
+}
+
+static void fstring_shift_seq_locations(expr_ty parent, asdl_seq *seq, int lineno, int col_offset) {
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+        expr_ty expr = asdl_seq_GET(seq, i);
+        if (expr == NULL){
+            continue;
+        }
+        shift_expr(parent, expr, lineno, col_offset);
+    }
+}
+
+static void fstring_shift_slice_locations(expr_ty parent, expr_ty slice, int lineno, int col_offset) {
+    switch (slice->kind) {
+        case Slice_kind:
+            if (slice->v.Slice.lower) {
+                shift_expr(parent, slice->v.Slice.lower, lineno, col_offset);
+            }
+            if (slice->v.Slice.upper) {
+                shift_expr(parent, slice->v.Slice.upper, lineno, col_offset);
+            }
+            if (slice->v.Slice.step) {
+                shift_expr(parent, slice->v.Slice.step, lineno, col_offset);
+            }
+            break;
+        case Tuple_kind:
+            fstring_shift_seq_locations(parent, slice->v.Tuple.elts, lineno, col_offset);
+            break;
+        default:
+            break;
+    }
+}
+
+static void fstring_shift_comprehension(expr_ty parent, comprehension_ty comp, int lineno, int col_offset) {
+    shift_expr(parent, comp->target, lineno, col_offset);
+    shift_expr(parent, comp->iter, lineno, col_offset);
+    fstring_shift_seq_locations(parent, comp->ifs, lineno, col_offset);
+}
+
+static void fstring_shift_argument(expr_ty parent, arg_ty arg, int lineno, int col_offset) {
+    if (arg->annotation != NULL){
+        shift_expr(parent, arg->annotation, lineno, col_offset);
+    }
+    arg->col_offset = arg->col_offset + col_offset;
+    arg->end_col_offset = arg->end_col_offset + col_offset;
+    arg->lineno = arg->lineno + lineno;
+    arg->end_lineno = arg->end_lineno + lineno;
+}
+
+static void fstring_shift_arguments(expr_ty parent, arguments_ty args, int lineno, int col_offset) {
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(args->posonlyargs); i < l; i++) {
+       arg_ty arg = asdl_seq_GET(args->posonlyargs, i);
+       shift_arg(parent, arg, lineno, col_offset);
+    }
+
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(args->args); i < l; i++) {
+       arg_ty arg = asdl_seq_GET(args->args, i);
+       shift_arg(parent, arg, lineno, col_offset);
+    }
+
+    if (args->vararg != NULL) {
+        shift_arg(parent, args->vararg, lineno, col_offset);
+    }
+
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(args->kwonlyargs); i < l; i++) {
+       arg_ty arg = asdl_seq_GET(args->kwonlyargs, i);
+       shift_arg(parent, arg, lineno, col_offset);
+    }
+
+    fstring_shift_seq_locations(parent, args->kw_defaults, lineno, col_offset);
+
+    if (args->kwarg != NULL) {
+        shift_arg(parent, args->kwarg, lineno, col_offset);
+    }
+
+    fstring_shift_seq_locations(parent, args->defaults, lineno, col_offset);
+}
+
+static void fstring_shift_children_locations(expr_ty n, int lineno, int col_offset) {
+    switch (n->kind) {
+        case BoolOp_kind:
+            fstring_shift_seq_locations(n, n->v.BoolOp.values, lineno, col_offset);
+            break;
+        case NamedExpr_kind:
+            shift_expr(n, n->v.NamedExpr.target, lineno, col_offset);
+            shift_expr(n, n->v.NamedExpr.value, lineno, col_offset);
+            break;
+        case BinOp_kind:
+            shift_expr(n, n->v.BinOp.left, lineno, col_offset);
+            shift_expr(n, n->v.BinOp.right, lineno, col_offset);
+            break;
+        case UnaryOp_kind:
+            shift_expr(n, n->v.UnaryOp.operand, lineno, col_offset);
+            break;
+        case Lambda_kind:
+            fstring_shift_arguments(n, n->v.Lambda.args, lineno, col_offset);
+            shift_expr(n, n->v.Lambda.body, lineno, col_offset);
+            break;
+        case IfExp_kind:
+            shift_expr(n, n->v.IfExp.test, lineno, col_offset);
+            shift_expr(n, n->v.IfExp.body, lineno, col_offset);
+            shift_expr(n, n->v.IfExp.orelse, lineno, col_offset);
+            break;
+        case Dict_kind:
+            fstring_shift_seq_locations(n, n->v.Dict.keys, lineno, col_offset);
+            fstring_shift_seq_locations(n, n->v.Dict.values, lineno, col_offset);
+            break;
+        case Set_kind:
+            fstring_shift_seq_locations(n, n->v.Set.elts, lineno, col_offset);
+            break;
+        case ListComp_kind:
+            shift_expr(n, n->v.ListComp.elt, lineno, col_offset);
+            for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.ListComp.generators); i < l; i++) {
+                comprehension_ty comp = asdl_seq_GET(n->v.ListComp.generators, i);
+                fstring_shift_comprehension(n, comp, lineno, col_offset);
+            }
+            break;
+        case SetComp_kind:
+            shift_expr(n, n->v.SetComp.elt, lineno, col_offset);
+            for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.SetComp.generators); i < l; i++) {
+                comprehension_ty comp = asdl_seq_GET(n->v.SetComp.generators, i);
+                fstring_shift_comprehension(n, comp, lineno, col_offset);
+            }
+            break;
+        case DictComp_kind:
+            shift_expr(n, n->v.DictComp.key, lineno, col_offset);
+            shift_expr(n, n->v.DictComp.value, lineno, col_offset);
+            for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.DictComp.generators); i < l; i++) {
+                comprehension_ty comp = asdl_seq_GET(n->v.DictComp.generators, i);
+                fstring_shift_comprehension(n, comp, lineno, col_offset);
+            }
+            break;
+        case GeneratorExp_kind:
+            shift_expr(n, n->v.GeneratorExp.elt, lineno, col_offset);
+            for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.GeneratorExp.generators); i < l; i++) {
+                comprehension_ty comp = asdl_seq_GET(n->v.GeneratorExp.generators, i);
+                fstring_shift_comprehension(n, comp, lineno, col_offset);
+            }
+            break;
+        case Await_kind:
+            shift_expr(n, n->v.Await.value, lineno, col_offset);
+            break;
+        case Yield_kind:
+            shift_expr(n, n->v.Yield.value, lineno, col_offset);
+            break;
+        case YieldFrom_kind:
+            shift_expr(n, n->v.YieldFrom.value, lineno, col_offset);
+            break;
+        case Compare_kind:
+            shift_expr(n, n->v.Compare.left, lineno, col_offset);
+            fstring_shift_seq_locations(n, n->v.Compare.comparators, lineno, col_offset);
+            break;
+        case Call_kind:
+            shift_expr(n, n->v.Call.func, lineno, col_offset);
+            fstring_shift_seq_locations(n, n->v.Call.args, lineno, col_offset);
+            for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.Call.keywords); i < l; i++) {
+                keyword_ty keyword = asdl_seq_GET(n->v.Call.keywords, i);
+                shift_expr(n, keyword->value, lineno, col_offset);
+            }
+            break;
+        case Attribute_kind:
+            shift_expr(n, n->v.Attribute.value, lineno, col_offset);
+            break;
+        case Subscript_kind:
+            shift_expr(n, n->v.Subscript.value, lineno, col_offset);
+            fstring_shift_slice_locations(n, n->v.Subscript.slice, lineno, col_offset);
+            shift_expr(n, n->v.Subscript.slice, lineno, col_offset);
+            break;
+        case Starred_kind:
+            shift_expr(n, n->v.Starred.value, lineno, col_offset);
+            break;
+        case List_kind:
+            fstring_shift_seq_locations(n, n->v.List.elts, lineno, col_offset);
+            break;
+        case Tuple_kind:
+            fstring_shift_seq_locations(n, n->v.Tuple.elts, lineno, col_offset);
+            break;
+        default:
+            return;
+    }
+}
+
+/* Shift locations for the given node and all its children by adding `lineno`
+   and `col_offset` to existing locations. Note that n is the already parsed
+   expression. */
+static void fstring_shift_expr_locations(expr_ty n, int lineno, int col_offset)
+{
+    n->col_offset = n->col_offset + col_offset;
+
+    // The following is needed, in order for nodes spanning across multiple lines
+    // to be shifted correctly. An example of such a node is a Call node, the closing
+    // parenthesis of which is not on the same line as its name.
+    if (n->lineno == n->end_lineno) {
+        n->end_col_offset = n->end_col_offset + col_offset;
+    }
+
+    fstring_shift_children_locations(n, lineno, col_offset);
+    n->lineno = n->lineno + lineno;
+    n->end_lineno = n->end_lineno + lineno;
+}
+
+/* Fix locations for the given node and its children.
+
+   `parent` is the enclosing node.
+   `n` is the node which locations are going to be fixed relative to parent.
+   `expr_str` is the child node's string representation, including braces.
+*/
+static void
+fstring_fix_expr_location(Token *parent, expr_ty n, char *expr_str)
+{
+    char *substr = NULL;
+    char *start;
+    int lines = 0;
+    int cols = 0;
+
+    if (parent && parent->bytes) {
+        char *parent_str = PyBytes_AsString(parent->bytes);
+        if (!parent_str) {
+            return;
+        }
+        substr = strstr(parent_str, expr_str);
+        if (substr) {
+            // The following is needed, in order to correctly shift the column
+            // offset, in the case that (disregarding any whitespace) a newline
+            // immediately follows the opening curly brace of the fstring expression.
+            int newline_after_brace = 1;
+            start = substr + 1;
+            while (start && *start != '}' && *start != '\n') {
+                if (*start != ' ' && *start != '\t' && *start != '\f') {
+                    newline_after_brace = 0;
+                    break;
+                }
+                start++;
+            }
+
+            // Account for the characters from the last newline character to our
+            // left until the beginning of substr.
+            if (!newline_after_brace) {
+                start = substr;
+                while (start > parent_str && *start != '\n') {
+                    start--;
+                }
+                cols += (int)(substr - start);
+            }
+            /* adjust the start based on the number of newlines encountered
+               before the f-string expression */
+            for (char* p = parent_str; p < substr; p++) {
+                if (*p == '\n') {
+                    lines++;
+                }
+            }
+        }
+    }
+    fstring_shift_expr_locations(n, lines, cols);
+}
+
+
+/* Compile this expression in to an expr_ty.  Add parens around the
+   expression, in order to allow leading spaces in the expression. */
+static expr_ty
+fstring_compile_expr(Parser *p, const char *expr_start, const char *expr_end,
+                     Token *t)
+{
+    expr_ty expr = NULL;
+    char *str;
+    Py_ssize_t len;
+    const char *s;
+    expr_ty result = NULL;
+
+    assert(expr_end >= expr_start);
+    assert(*(expr_start-1) == '{');
+    assert(*expr_end == '}' || *expr_end == '!' || *expr_end == ':' ||
+           *expr_end == '=');
+
+    /* If the substring is all whitespace, it's an error.  We need to catch this
+       here, and not when we call PyParser_SimpleParseStringFlagsFilename,
+       because turning the expression '' in to '()' would go from being invalid
+       to valid. */
+    for (s = expr_start; s != expr_end; s++) {
+        char c = *s;
+        /* The Python parser ignores only the following whitespace
+           characters (\r already is converted to \n). */
+        if (!(c == ' ' || c == '\t' || c == '\n' || c == '\f')) {
+            break;
+        }
+    }
+    if (s == expr_end) {
+        RAISE_SYNTAX_ERROR("f-string: empty expression not allowed");
+        return NULL;
+    }
+
+    len = expr_end - expr_start;
+    /* Allocate 3 extra bytes: open paren, close paren, null byte. */
+    str = PyMem_RawMalloc(len + 3);
+    if (str == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    str[0] = '(';
+    memcpy(str+1, expr_start, len);
+    str[len+1] = ')';
+    str[len+2] = 0;
+
+    struct tok_state* tok = PyTokenizer_FromString(str, 1);
+    if (tok == NULL) {
+        return NULL;
+    }
+    tok->filename = PyUnicode_FromString("<fstring>");
+    if (!tok->filename) {
+        PyTokenizer_Free(tok);
+        return NULL;
+    }
+
+    Parser *p2 = _PyPegen_Parser_New(tok, Py_fstring_input, NULL, p->arena);
+    p2->starting_lineno = p->starting_lineno + p->tok->first_lineno - 1;
+    p2->starting_col_offset = p->tok->first_lineno == p->tok->lineno
+                              ? p->starting_col_offset + t->col_offset : 0;
+
+    expr = _PyPegen_run_parser(p2);
+
+    if (expr == NULL) {
+        goto exit;
+    }
+
+    /* Reuse str to find the correct column offset. */
+    str[0] = '{';
+    str[len+1] = '}';
+    fstring_fix_expr_location(t, expr, str);
+
+    result = expr;
+
+exit:
+    _PyPegen_Parser_Free(p2);
+    PyTokenizer_Free(tok);
+    return result;
+}
+
+/* Return -1 on error.
+
+   Return 0 if we reached the end of the literal.
+
+   Return 1 if we haven't reached the end of the literal, but we want
+   the caller to process the literal up to this point. Used for
+   doubled braces.
+*/
+static int
+fstring_find_literal(Parser *p, const char **str, const char *end, int raw,
+                     PyObject **literal, int recurse_lvl)
+{
+    /* Get any literal string. It ends when we hit an un-doubled left
+       brace (which isn't part of a unicode name escape such as
+       "\N{EULER CONSTANT}"), or the end of the string. */
+
+    const char *s = *str;
+    const char *literal_start = s;
+    int result = 0;
+
+    assert(*literal == NULL);
+    while (s < end) {
+        char ch = *s++;
+        if (!raw && ch == '\\' && s < end) {
+            ch = *s++;
+            if (ch == 'N') {
+                if (s < end && *s++ == '{') {
+                    while (s < end && *s++ != '}') {
+                    }
+                    continue;
+                }
+                break;
+            }
+            if (ch == '{' && warn_invalid_escape_sequence(p, ch) < 0) {
+                return -1;
+            }
+        }
+        if (ch == '{' || ch == '}') {
+            /* Check for doubled braces, but only at the top level. If
+               we checked at every level, then f'{0:{3}}' would fail
+               with the two closing braces. */
+            if (recurse_lvl == 0) {
+                if (s < end && *s == ch) {
+                    /* We're going to tell the caller that the literal ends
+                       here, but that they should continue scanning. But also
+                       skip over the second brace when we resume scanning. */
+                    *str = s + 1;
+                    result = 1;
+                    goto done;
+                }
+
+                /* Where a single '{' is the start of a new expression, a
+                   single '}' is not allowed. */
+                if (ch == '}') {
+                    *str = s - 1;
+                    RAISE_SYNTAX_ERROR("f-string: single '}' is not allowed");
+                    return -1;
+                }
+            }
+            /* We're either at a '{', which means we're starting another
+               expression; or a '}', which means we're at the end of this
+               f-string (for a nested format_spec). */
+            s--;
+            break;
+        }
+    }
+    *str = s;
+    assert(s <= end);
+    assert(s == end || *s == '{' || *s == '}');
+done:
+    if (literal_start != s) {
+        if (raw)
+            *literal = PyUnicode_DecodeUTF8Stateful(literal_start,
+                                                    s - literal_start,
+                                                    NULL, NULL);
+        else
+            *literal = decode_unicode_with_escapes(p, literal_start,
+                                                   s - literal_start);
+        if (!*literal)
+            return -1;
+    }
+    return result;
+}
+
+/* Forward declaration because parsing is recursive. */
+static expr_ty
+fstring_parse(Parser *p, const char **str, const char *end, int raw, int recurse_lvl,
+              Token *first_token, Token* t, Token *last_token);
+
+/* Parse the f-string at *str, ending at end.  We know *str starts an
+   expression (so it must be a '{'). Returns the FormattedValue node, which
+   includes the expression, conversion character, format_spec expression, and
+   optionally the text of the expression (if = is used).
+
+   Note that I don't do a perfect job here: I don't make sure that a
+   closing brace doesn't match an opening paren, for example. It
+   doesn't need to error on all invalid expressions, just correctly
+   find the end of all valid ones. Any errors inside the expression
+   will be caught when we parse it later.
+
+   *expression is set to the expression.  For an '=' "debug" expression,
+   *expr_text is set to the debug text (the original text of the expression,
+   including the '=' and any whitespace around it, as a string object).  If
+   not a debug expression, *expr_text set to NULL. */
+static int
+fstring_find_expr(Parser *p, const char **str, const char *end, int raw, int recurse_lvl,
+                  PyObject **expr_text, expr_ty *expression, Token *first_token,
+                  Token *t, Token *last_token)
+{
+    /* Return -1 on error, else 0. */
+
+    const char *expr_start;
+    const char *expr_end;
+    expr_ty simple_expression;
+    expr_ty format_spec = NULL; /* Optional format specifier. */
+    int conversion = -1; /* The conversion char.  Use default if not
+                            specified, or !r if using = and no format
+                            spec. */
+
+    /* 0 if we're not in a string, else the quote char we're trying to
+       match (single or double quote). */
+    char quote_char = 0;
+
+    /* If we're inside a string, 1=normal, 3=triple-quoted. */
+    int string_type = 0;
+
+    /* Keep track of nesting level for braces/parens/brackets in
+       expressions. */
+    Py_ssize_t nested_depth = 0;
+    char parenstack[MAXLEVEL];
+
+    *expr_text = NULL;
+
+    /* Can only nest one level deep. */
+    if (recurse_lvl >= 2) {
+        RAISE_SYNTAX_ERROR("f-string: expressions nested too deeply");
+        goto error;
+    }
+
+    /* The first char must be a left brace, or we wouldn't have gotten
+       here. Skip over it. */
+    assert(**str == '{');
+    *str += 1;
+
+    expr_start = *str;
+    for (; *str < end; (*str)++) {
+        char ch;
+
+        /* Loop invariants. */
+        assert(nested_depth >= 0);
+        assert(*str >= expr_start && *str < end);
+        if (quote_char)
+            assert(string_type == 1 || string_type == 3);
+        else
+            assert(string_type == 0);
+
+        ch = **str;
+        /* Nowhere inside an expression is a backslash allowed. */
+        if (ch == '\\') {
+            /* Error: can't include a backslash character, inside
+               parens or strings or not. */
+            RAISE_SYNTAX_ERROR(
+                      "f-string expression part "
+                      "cannot include a backslash");
+            goto error;
+        }
+        if (quote_char) {
+            /* We're inside a string. See if we're at the end. */
+            /* This code needs to implement the same non-error logic
+               as tok_get from tokenizer.c, at the letter_quote
+               label. To actually share that code would be a
+               nightmare. But, it's unlikely to change and is small,
+               so duplicate it here. Note we don't need to catch all
+               of the errors, since they'll be caught when parsing the
+               expression. We just need to match the non-error
+               cases. Thus we can ignore \n in single-quoted strings,
+               for example. Or non-terminated strings. */
+            if (ch == quote_char) {
+                /* Does this match the string_type (single or triple
+                   quoted)? */
+                if (string_type == 3) {
+                    if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) {
+                        /* We're at the end of a triple quoted string. */
+                        *str += 2;
+                        string_type = 0;
+                        quote_char = 0;
+                        continue;
+                    }
+                } else {
+                    /* We're at the end of a normal string. */
+                    quote_char = 0;
+                    string_type = 0;
+                    continue;
+                }
+            }
+        } else if (ch == '\'' || ch == '"') {
+            /* Is this a triple quoted string? */
+            if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) {
+                string_type = 3;
+                *str += 2;
+            } else {
+                /* Start of a normal string. */
+                string_type = 1;
+            }
+            /* Start looking for the end of the string. */
+            quote_char = ch;
+        } else if (ch == '[' || ch == '{' || ch == '(') {
+            if (nested_depth >= MAXLEVEL) {
+                RAISE_SYNTAX_ERROR("f-string: too many nested parenthesis");
+                goto error;
+            }
+            parenstack[nested_depth] = ch;
+            nested_depth++;
+        } else if (ch == '#') {
+            /* Error: can't include a comment character, inside parens
+               or not. */
+            RAISE_SYNTAX_ERROR("f-string expression part cannot include '#'");
+            goto error;
+        } else if (nested_depth == 0 &&
+                   (ch == '!' || ch == ':' || ch == '}' ||
+                    ch == '=' || ch == '>' || ch == '<')) {
+            /* See if there's a next character. */
+            if (*str+1 < end) {
+                char next = *(*str+1);
+
+                /* For "!=". since '=' is not an allowed conversion character,
+                   nothing is lost in this test. */
+                if ((ch == '!' && next == '=') ||   /* != */
+                    (ch == '=' && next == '=') ||   /* == */
+                    (ch == '<' && next == '=') ||   /* <= */
+                    (ch == '>' && next == '=')      /* >= */
+                    ) {
+                    *str += 1;
+                    continue;
+                }
+                /* Don't get out of the loop for these, if they're single
+                   chars (not part of 2-char tokens). If by themselves, they
+                   don't end an expression (unlike say '!'). */
+                if (ch == '>' || ch == '<') {
+                    continue;
+                }
+            }
+
+            /* Normal way out of this loop. */
+            break;
+        } else if (ch == ']' || ch == '}' || ch == ')') {
+            if (!nested_depth) {
+                RAISE_SYNTAX_ERROR("f-string: unmatched '%c'", ch);
+                goto error;
+            }
+            nested_depth--;
+            int opening = parenstack[nested_depth];
+            if (!((opening == '(' && ch == ')') ||
+                  (opening == '[' && ch == ']') ||
+                  (opening == '{' && ch == '}')))
+            {
+                RAISE_SYNTAX_ERROR(
+                          "f-string: closing parenthesis '%c' "
+                          "does not match opening parenthesis '%c'",
+                          ch, opening);
+                goto error;
+            }
+        } else {
+            /* Just consume this char and loop around. */
+        }
+    }
+    expr_end = *str;
+    /* If we leave this loop in a string or with mismatched parens, we
+       don't care. We'll get a syntax error when compiling the
+       expression. But, we can produce a better error message, so
+       let's just do that.*/
+    if (quote_char) {
+        RAISE_SYNTAX_ERROR("f-string: unterminated string");
+        goto error;
+    }
+    if (nested_depth) {
+        int opening = parenstack[nested_depth - 1];
+        RAISE_SYNTAX_ERROR("f-string: unmatched '%c'", opening);
+        goto error;
+    }
+
+    if (*str >= end)
+        goto unexpected_end_of_string;
+
+    /* Compile the expression as soon as possible, so we show errors
+       related to the expression before errors related to the
+       conversion or format_spec. */
+    simple_expression = fstring_compile_expr(p, expr_start, expr_end, t);
+    if (!simple_expression)
+        goto error;
+
+    /* Check for =, which puts the text value of the expression in
+       expr_text. */
+    if (**str == '=') {
+        *str += 1;
+
+        /* Skip over ASCII whitespace.  No need to test for end of string
+           here, since we know there's at least a trailing quote somewhere
+           ahead. */
+        while (Py_ISSPACE(**str)) {
+            *str += 1;
+        }
+
+        /* Set *expr_text to the text of the expression. */
+        *expr_text = PyUnicode_FromStringAndSize(expr_start, *str-expr_start);
+        if (!*expr_text) {
+            goto error;
+        }
+    }
+
+    /* Check for a conversion char, if present. */
+    if (**str == '!') {
+        *str += 1;
+        if (*str >= end)
+            goto unexpected_end_of_string;
+
+        conversion = **str;
+        *str += 1;
+
+        /* Validate the conversion. */
+        if (!(conversion == 's' || conversion == 'r' || conversion == 'a')) {
+            RAISE_SYNTAX_ERROR(
+                      "f-string: invalid conversion character: "
+                      "expected 's', 'r', or 'a'");
+            goto error;
+        }
+
+    }
+
+    /* Check for the format spec, if present. */
+    if (*str >= end)
+        goto unexpected_end_of_string;
+    if (**str == ':') {
+        *str += 1;
+        if (*str >= end)
+            goto unexpected_end_of_string;
+
+        /* Parse the format spec. */
+        format_spec = fstring_parse(p, str, end, raw, recurse_lvl+1,
+                                    first_token, t, last_token);
+        if (!format_spec)
+            goto error;
+    }
+
+    if (*str >= end || **str != '}')
+        goto unexpected_end_of_string;
+
+    /* We're at a right brace. Consume it. */
+    assert(*str < end);
+    assert(**str == '}');
+    *str += 1;
+
+    /* If we're in = mode (detected by non-NULL expr_text), and have no format
+       spec and no explicit conversion, set the conversion to 'r'. */
+    if (*expr_text && format_spec == NULL && conversion == -1) {
+        conversion = 'r';
+    }
+
+    /* And now create the FormattedValue node that represents this
+       entire expression with the conversion and format spec. */
+    //TODO: Fix this
+    *expression = FormattedValue(simple_expression, conversion,
+                                 format_spec, first_token->lineno,
+                                 first_token->col_offset, last_token->end_lineno,
+                                 last_token->end_col_offset, p->arena);
+    if (!*expression)
+        goto error;
+
+    return 0;
+
+unexpected_end_of_string:
+    RAISE_SYNTAX_ERROR("f-string: expecting '}'");
+    /* Falls through to error. */
+
+error:
+    Py_XDECREF(*expr_text);
+    return -1;
+
+}
+
+/* Return -1 on error.
+
+   Return 0 if we have a literal (possible zero length) and an
+   expression (zero length if at the end of the string.
+
+   Return 1 if we have a literal, but no expression, and we want the
+   caller to call us again. This is used to deal with doubled
+   braces.
+
+   When called multiple times on the string 'a{{b{0}c', this function
+   will return:
+
+   1. the literal 'a{' with no expression, and a return value
+      of 1. Despite the fact that there's no expression, the return
+      value of 1 means we're not finished yet.
+
+   2. the literal 'b' and the expression '0', with a return value of
+      0. The fact that there's an expression means we're not finished.
+
+   3. literal 'c' with no expression and a return value of 0. The
+      combination of the return value of 0 with no expression means
+      we're finished.
+*/
+static int
+fstring_find_literal_and_expr(Parser *p, const char **str, const char *end, int raw,
+                              int recurse_lvl, PyObject **literal,
+                              PyObject **expr_text, expr_ty *expression,
+                              Token *first_token, Token *t, Token *last_token)
+{
+    int result;
+
+    assert(*literal == NULL && *expression == NULL);
+
+    /* Get any literal string. */
+    result = fstring_find_literal(p, str, end, raw, literal, recurse_lvl);
+    if (result < 0)
+        goto error;
+
+    assert(result == 0 || result == 1);
+
+    if (result == 1)
+        /* We have a literal, but don't look at the expression. */
+        return 1;
+
+    if (*str >= end || **str == '}')
+        /* We're at the end of the string or the end of a nested
+           f-string: no expression. The top-level error case where we
+           expect to be at the end of the string but we're at a '}' is
+           handled later. */
+        return 0;
+
+    /* We must now be the start of an expression, on a '{'. */
+    assert(**str == '{');
+
+    if (fstring_find_expr(p, str, end, raw, recurse_lvl, expr_text,
+                          expression, first_token, t, last_token) < 0)
+        goto error;
+
+    return 0;
+
+error:
+    Py_CLEAR(*literal);
+    return -1;
+}
+
+#ifdef NDEBUG
+#define ExprList_check_invariants(l)
+#else
+static void
+ExprList_check_invariants(ExprList *l)
+{
+    /* Check our invariants. Make sure this object is "live", and
+       hasn't been deallocated. */
+    assert(l->size >= 0);
+    assert(l->p != NULL);
+    if (l->size <= EXPRLIST_N_CACHED)
+        assert(l->data == l->p);
+}
+#endif
+
+static void
+ExprList_Init(ExprList *l)
+{
+    l->allocated = EXPRLIST_N_CACHED;
+    l->size = 0;
+
+    /* Until we start allocating dynamically, p points to data. */
+    l->p = l->data;
+
+    ExprList_check_invariants(l);
+}
+
+static int
+ExprList_Append(ExprList *l, expr_ty exp)
+{
+    ExprList_check_invariants(l);
+    if (l->size >= l->allocated) {
+        /* We need to alloc (or realloc) the memory. */
+        Py_ssize_t new_size = l->allocated * 2;
+
+        /* See if we've ever allocated anything dynamically. */
+        if (l->p == l->data) {
+            Py_ssize_t i;
+            /* We're still using the cached data. Switch to
+               alloc-ing. */
+            l->p = PyMem_RawMalloc(sizeof(expr_ty) * new_size);
+            if (!l->p)
+                return -1;
+            /* Copy the cached data into the new buffer. */
+            for (i = 0; i < l->size; i++)
+                l->p[i] = l->data[i];
+        } else {
+            /* Just realloc. */
+            expr_ty *tmp = PyMem_RawRealloc(l->p, sizeof(expr_ty) * new_size);
+            if (!tmp) {
+                PyMem_RawFree(l->p);
+                l->p = NULL;
+                return -1;
+            }
+            l->p = tmp;
+        }
+
+        l->allocated = new_size;
+        assert(l->allocated == 2 * l->size);
+    }
+
+    l->p[l->size++] = exp;
+
+    ExprList_check_invariants(l);
+    return 0;
+}
+
+static void
+ExprList_Dealloc(ExprList *l)
+{
+    ExprList_check_invariants(l);
+
+    /* If there's been an error, or we've never dynamically allocated,
+       do nothing. */
+    if (!l->p || l->p == l->data) {
+        /* Do nothing. */
+    } else {
+        /* We have dynamically allocated. Free the memory. */
+        PyMem_RawFree(l->p);
+    }
+    l->p = NULL;
+    l->size = -1;
+}
+
+static asdl_seq *
+ExprList_Finish(ExprList *l, PyArena *arena)
+{
+    asdl_seq *seq;
+
+    ExprList_check_invariants(l);
+
+    /* Allocate the asdl_seq and copy the expressions in to it. */
+    seq = _Py_asdl_seq_new(l->size, arena);
+    if (seq) {
+        Py_ssize_t i;
+        for (i = 0; i < l->size; i++)
+            asdl_seq_SET(seq, i, l->p[i]);
+    }
+    ExprList_Dealloc(l);
+    return seq;
+}
+
+#ifdef NDEBUG
+#define FstringParser_check_invariants(state)
+#else
+static void
+FstringParser_check_invariants(FstringParser *state)
+{
+    if (state->last_str)
+        assert(PyUnicode_CheckExact(state->last_str));
+    ExprList_check_invariants(&state->expr_list);
+}
+#endif
+
+void
+_PyPegen_FstringParser_Init(FstringParser *state)
+{
+    state->last_str = NULL;
+    state->fmode = 0;
+    ExprList_Init(&state->expr_list);
+    FstringParser_check_invariants(state);
+}
+
+void
+_PyPegen_FstringParser_Dealloc(FstringParser *state)
+{
+    FstringParser_check_invariants(state);
+
+    Py_XDECREF(state->last_str);
+    ExprList_Dealloc(&state->expr_list);
+}
+
+/* Make a Constant node, but decref the PyUnicode object being added. */
+static expr_ty
+make_str_node_and_del(Parser *p, PyObject **str, Token* first_token, Token *last_token)
+{
+    PyObject *s = *str;
+    PyObject *kind = NULL;
+    *str = NULL;
+    assert(PyUnicode_CheckExact(s));
+    if (PyArena_AddPyObject(p->arena, s) < 0) {
+        Py_DECREF(s);
+        return NULL;
+    }
+    const char* the_str = PyBytes_AsString(first_token->bytes);
+    if (the_str && the_str[0] == 'u') {
+        kind = _PyPegen_new_identifier(p, "u");
+    }
+
+    if (kind == NULL && PyErr_Occurred()) {
+        return NULL;
+    }
+
+    return Constant(s, kind, first_token->lineno, first_token->col_offset,
+                    last_token->end_lineno, last_token->end_col_offset, p->arena);
+
+}
+
+
+/* Add a non-f-string (that is, a regular literal string). str is
+   decref'd. */
+int
+_PyPegen_FstringParser_ConcatAndDel(FstringParser *state, PyObject *str)
+{
+    FstringParser_check_invariants(state);
+
+    assert(PyUnicode_CheckExact(str));
+
+    if (PyUnicode_GET_LENGTH(str) == 0) {
+        Py_DECREF(str);
+        return 0;
+    }
+
+    if (!state->last_str) {
+        /* We didn't have a string before, so just remember this one. */
+        state->last_str = str;
+    } else {
+        /* Concatenate this with the previous string. */
+        PyUnicode_AppendAndDel(&state->last_str, str);
+        if (!state->last_str)
+            return -1;
+    }
+    FstringParser_check_invariants(state);
+    return 0;
+}
+
+/* Parse an f-string. The f-string is in *str to end, with no
+   'f' or quotes. */
+int
+_PyPegen_FstringParser_ConcatFstring(Parser *p, FstringParser *state, const char **str,
+                            const char *end, int raw, int recurse_lvl,
+                            Token *first_token, Token* t, Token *last_token)
+{
+    FstringParser_check_invariants(state);
+    state->fmode = 1;
+
+    /* Parse the f-string. */
+    while (1) {
+        PyObject *literal = NULL;
+        PyObject *expr_text = NULL;
+        expr_ty expression = NULL;
+
+        /* If there's a zero length literal in front of the
+           expression, literal will be NULL. If we're at the end of
+           the f-string, expression will be NULL (unless result == 1,
+           see below). */
+        int result = fstring_find_literal_and_expr(p, str, end, raw, recurse_lvl,
+                                                   &literal, &expr_text,
+                                                   &expression, first_token, t, last_token);
+        if (result < 0)
+            return -1;
+
+        /* Add the literal, if any. */
+        if (literal && _PyPegen_FstringParser_ConcatAndDel(state, literal) < 0) {
+            Py_XDECREF(expr_text);
+            return -1;
+        }
+        /* Add the expr_text, if any. */
+        if (expr_text && _PyPegen_FstringParser_ConcatAndDel(state, expr_text) < 0) {
+            return -1;
+        }
+
+        /* We've dealt with the literal and expr_text, their ownership has
+           been transferred to the state object.  Don't look at them again. */
+
+        /* See if we should just loop around to get the next literal
+           and expression, while ignoring the expression this
+           time. This is used for un-doubling braces, as an
+           optimization. */
+        if (result == 1)
+            continue;
+
+        if (!expression)
+            /* We're done with this f-string. */
+            break;
+
+        /* We know we have an expression. Convert any existing string
+           to a Constant node. */
+        if (!state->last_str) {
+            /* Do nothing. No previous literal. */
+        } else {
+            /* Convert the existing last_str literal to a Constant node. */
+            expr_ty str = make_str_node_and_del(p, &state->last_str, first_token, last_token);
+            if (!str || ExprList_Append(&state->expr_list, str) < 0)
+                return -1;
+        }
+
+        if (ExprList_Append(&state->expr_list, expression) < 0)
+            return -1;
+    }
+
+    /* If recurse_lvl is zero, then we must be at the end of the
+       string. Otherwise, we must be at a right brace. */
+
+    if (recurse_lvl == 0 && *str < end-1) {
+        RAISE_SYNTAX_ERROR("f-string: unexpected end of string");
+        return -1;
+    }
+    if (recurse_lvl != 0 && **str != '}') {
+        RAISE_SYNTAX_ERROR("f-string: expecting '}'");
+        return -1;
+    }
+
+    FstringParser_check_invariants(state);
+    return 0;
+}
+
+/* Convert the partial state reflected in last_str and expr_list to an
+   expr_ty. The expr_ty can be a Constant, or a JoinedStr. */
+expr_ty
+_PyPegen_FstringParser_Finish(Parser *p, FstringParser *state, Token* first_token,
+                     Token *last_token)
+{
+    asdl_seq *seq;
+
+    FstringParser_check_invariants(state);
+
+    /* If we're just a constant string with no expressions, return
+       that. */
+    if (!state->fmode) {
+        assert(!state->expr_list.size);
+        if (!state->last_str) {
+            /* Create a zero length string. */
+            state->last_str = PyUnicode_FromStringAndSize(NULL, 0);
+            if (!state->last_str)
+                goto error;
+        }
+        return make_str_node_and_del(p, &state->last_str, first_token, last_token);
+    }
+
+    /* Create a Constant node out of last_str, if needed. It will be the
+       last node in our expression list. */
+    if (state->last_str) {
+        expr_ty str = make_str_node_and_del(p, &state->last_str, first_token, last_token);
+        if (!str || ExprList_Append(&state->expr_list, str) < 0)
+            goto error;
+    }
+    /* This has already been freed. */
+    assert(state->last_str == NULL);
+
+    seq = ExprList_Finish(&state->expr_list, p->arena);
+    if (!seq)
+        goto error;
+
+    return _Py_JoinedStr(seq, first_token->lineno, first_token->col_offset,
+                         last_token->end_lineno, last_token->end_col_offset, p->arena);
+
+error:
+    _PyPegen_FstringParser_Dealloc(state);
+    return NULL;
+}
+
+/* Given an f-string (with no 'f' or quotes) that's in *str and ends
+   at end, parse it into an expr_ty.  Return NULL on error.  Adjust
+   str to point past the parsed portion. */
+static expr_ty
+fstring_parse(Parser *p, const char **str, const char *end, int raw,
+              int recurse_lvl, Token *first_token, Token* t, Token *last_token)
+{
+    FstringParser state;
+
+    _PyPegen_FstringParser_Init(&state);
+    if (_PyPegen_FstringParser_ConcatFstring(p, &state, str, end, raw, recurse_lvl,
+                                    first_token, t, last_token) < 0) {
+        _PyPegen_FstringParser_Dealloc(&state);
+        return NULL;
+    }
+
+    return _PyPegen_FstringParser_Finish(p, &state, t, t);
+}
diff --git a/Parser/pegen/parse_string.h b/Parser/pegen/parse_string.h
new file mode 100644
index 0000000..4f2aa94
--- /dev/null
+++ b/Parser/pegen/parse_string.h
@@ -0,0 +1,46 @@
+#ifndef STRINGS_H
+#define STRINGS_H
+
+#include <Python.h>
+#include <Python-ast.h>
+#include "pegen.h"
+
+#define EXPRLIST_N_CACHED  64
+
+typedef struct {
+    /* Incrementally build an array of expr_ty, so be used in an
+       asdl_seq. Cache some small but reasonably sized number of
+       expr_ty's, and then after that start dynamically allocating,
+       doubling the number allocated each time. Note that the f-string
+       f'{0}a{1}' contains 3 expr_ty's: 2 FormattedValue's, and one
+       Constant for the literal 'a'. So you add expr_ty's about twice as
+       fast as you add expressions in an f-string. */
+
+    Py_ssize_t allocated;  /* Number we've allocated. */
+    Py_ssize_t size;       /* Number we've used. */
+    expr_ty    *p;         /* Pointer to the memory we're actually
+                              using. Will point to 'data' until we
+                              start dynamically allocating. */
+    expr_ty    data[EXPRLIST_N_CACHED];
+} ExprList;
+
+/* The FstringParser is designed to add a mix of strings and
+   f-strings, and concat them together as needed. Ultimately, it
+   generates an expr_ty. */
+typedef struct {
+    PyObject *last_str;
+    ExprList expr_list;
+    int fmode;
+} FstringParser;
+
+void _PyPegen_FstringParser_Init(FstringParser *);
+int _PyPegen_parsestr(Parser *, const char *, int *, int *, PyObject **,
+             const char **, Py_ssize_t *);
+int _PyPegen_FstringParser_ConcatFstring(Parser *, FstringParser *, const char **,
+                                const char *, int, int, Token *, Token *,
+                                Token *);
+int _PyPegen_FstringParser_ConcatAndDel(FstringParser *, PyObject *);
+expr_ty _PyPegen_FstringParser_Finish(Parser *, FstringParser *, Token *, Token *);
+void _PyPegen_FstringParser_Dealloc(FstringParser *);
+
+#endif
diff --git a/Parser/pegen/peg_api.c b/Parser/pegen/peg_api.c
new file mode 100644
index 0000000..7c6903c
--- /dev/null
+++ b/Parser/pegen/peg_api.c
@@ -0,0 +1,134 @@
+#include <pegen_interface.h>
+
+#include "../tokenizer.h"
+#include "pegen.h"
+
+mod_ty
+PyPegen_ASTFromString(const char *str, int mode, PyCompilerFlags *flags, PyArena *arena)
+{
+    PyObject *filename_ob = PyUnicode_FromString("<string>");
+    if (filename_ob == NULL) {
+        return NULL;
+    }
+    mod_ty result = PyPegen_ASTFromStringObject(str, filename_ob, mode, flags, arena);
+    Py_XDECREF(filename_ob);
+    return result;
+}
+
+mod_ty
+PyPegen_ASTFromStringObject(const char *str, PyObject* filename, int mode, PyCompilerFlags *flags, PyArena *arena)
+{
+    if (PySys_Audit("compile", "yO", str, filename) < 0) {
+        return NULL;
+    }
+
+    int iflags = flags != NULL ? flags->cf_flags : PyCF_IGNORE_COOKIE;
+    mod_ty result = _PyPegen_run_parser_from_string(str, mode, filename, iflags, arena);
+    return result;
+}
+
+mod_ty
+PyPegen_ASTFromFile(const char *filename, int mode, PyArena *arena)
+{
+    PyObject *filename_ob = PyUnicode_FromString(filename);
+    if (filename_ob == NULL) {
+        return NULL;
+    }
+
+    mod_ty result = _PyPegen_run_parser_from_file(filename, mode, filename_ob, arena);
+    Py_XDECREF(filename_ob);
+    return result;
+}
+
+mod_ty
+PyPegen_ASTFromFileObject(FILE *fp, PyObject *filename_ob, int mode,
+                          const char *enc, const char *ps1, const char* ps2,
+                          int *errcode, PyArena *arena)
+{
+    if (PySys_Audit("compile", "OO", Py_None, filename_ob) < 0) {
+        return NULL;
+    }
+    return _PyPegen_run_parser_from_file_pointer(fp, mode, filename_ob, enc, ps1, ps2,
+                                        errcode, arena);
+}
+
+PyCodeObject *
+PyPegen_CodeObjectFromString(const char *str, int mode, PyCompilerFlags *flags)
+{
+    PyArena *arena = PyArena_New();
+    if (arena == NULL) {
+        return NULL;
+    }
+
+    PyCodeObject *result = NULL;
+
+    PyObject *filename_ob = PyUnicode_FromString("<string>");
+    if (filename_ob == NULL) {
+        goto error;
+    }
+
+    mod_ty res = PyPegen_ASTFromString(str, mode, flags, arena);
+    if (res == NULL) {
+        goto error;
+    }
+
+    result = PyAST_CompileObject(res, filename_ob, NULL, -1, arena);
+
+error:
+    Py_XDECREF(filename_ob);
+    PyArena_Free(arena);
+    return result;
+}
+
+PyCodeObject *
+PyPegen_CodeObjectFromFile(const char *filename, int mode)
+{
+    PyArena *arena = PyArena_New();
+    if (arena == NULL) {
+        return NULL;
+    }
+
+    PyCodeObject *result = NULL;
+
+    PyObject *filename_ob = PyUnicode_FromString(filename);
+    if (filename_ob == NULL) {
+        goto error;
+    }
+
+    mod_ty res = PyPegen_ASTFromFile(filename, mode, arena);
+    if (res == NULL) {
+        goto error;
+    }
+
+    result = PyAST_CompileObject(res, filename_ob, NULL, -1, arena);
+
+error:
+    Py_XDECREF(filename_ob);
+    PyArena_Free(arena);
+    return result;
+}
+
+PyCodeObject *
+PyPegen_CodeObjectFromFileObject(FILE *fp, PyObject *filename_ob, int mode,
+                                 const char *ps1, const char *ps2, const char *enc,
+                                 int *errcode)
+{
+    PyArena *arena = PyArena_New();
+    if (arena == NULL) {
+        return NULL;
+    }
+
+    PyCodeObject *result = NULL;
+
+    mod_ty res = PyPegen_ASTFromFileObject(fp, filename_ob, mode, enc, ps1, ps2,
+                                           errcode, arena);
+    if (res == NULL) {
+        goto error;
+    }
+
+    result = PyAST_CompileObject(res, filename_ob, NULL, -1, arena);
+
+error:
+    PyArena_Free(arena);
+    return result;
+}
diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c
new file mode 100644
index 0000000..47b712f
--- /dev/null
+++ b/Parser/pegen/pegen.c
@@ -0,0 +1,1865 @@
+#include <Python.h>
+#include <errcode.h>
+#include "../tokenizer.h"
+
+#include "pegen.h"
+#include "parse_string.h"
+
+static int
+init_normalization(Parser *p)
+{
+    PyObject *m = PyImport_ImportModuleNoBlock("unicodedata");
+    if (!m)
+    {
+        return 0;
+    }
+    p->normalize = PyObject_GetAttrString(m, "normalize");
+    Py_DECREF(m);
+    if (!p->normalize)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+PyObject *
+_PyPegen_new_identifier(Parser *p, char *n)
+{
+    PyObject *id = PyUnicode_DecodeUTF8(n, strlen(n), NULL);
+    if (!id) {
+        goto error;
+    }
+    /* PyUnicode_DecodeUTF8 should always return a ready string. */
+    assert(PyUnicode_IS_READY(id));
+    /* Check whether there are non-ASCII characters in the
+       identifier; if so, normalize to NFKC. */
+    if (!PyUnicode_IS_ASCII(id))
+    {
+        PyObject *id2;
+        if (!p->normalize && !init_normalization(p))
+        {
+            Py_DECREF(id);
+            goto error;
+        }
+        PyObject *form = PyUnicode_InternFromString("NFKC");
+        if (form == NULL)
+        {
+            Py_DECREF(id);
+            goto error;
+        }
+        PyObject *args[2] = {form, id};
+        id2 = _PyObject_FastCall(p->normalize, args, 2);
+        Py_DECREF(id);
+        Py_DECREF(form);
+        if (!id2) {
+            goto error;
+        }
+        if (!PyUnicode_Check(id2))
+        {
+            PyErr_Format(PyExc_TypeError,
+                         "unicodedata.normalize() must return a string, not "
+                         "%.200s",
+                         _PyType_Name(Py_TYPE(id2)));
+            Py_DECREF(id2);
+            goto error;
+        }
+        id = id2;
+    }
+    PyUnicode_InternInPlace(&id);
+    if (PyArena_AddPyObject(p->arena, id) < 0)
+    {
+        Py_DECREF(id);
+        goto error;
+    }
+    return id;
+
+error:
+    p->error_indicator = 1;
+    return NULL;
+}
+
+static PyObject *
+_create_dummy_identifier(Parser *p)
+{
+    return _PyPegen_new_identifier(p, "");
+}
+
+static inline Py_ssize_t
+byte_offset_to_character_offset(PyObject *line, int col_offset)
+{
+    const char *str = PyUnicode_AsUTF8(line);
+    PyObject *text = PyUnicode_DecodeUTF8(str, col_offset, NULL);
+    if (!text) {
+        return 0;
+    }
+    Py_ssize_t size = PyUnicode_GET_LENGTH(text);
+    Py_DECREF(text);
+    return size;
+}
+
+const char *
+_PyPegen_get_expr_name(expr_ty e)
+{
+    switch (e->kind) {
+        case Attribute_kind:
+            return "attribute";
+        case Subscript_kind:
+            return "subscript";
+        case Starred_kind:
+            return "starred";
+        case Name_kind:
+            return "name";
+        case List_kind:
+            return "list";
+        case Tuple_kind:
+            return "tuple";
+        case Lambda_kind:
+            return "lambda";
+        case Call_kind:
+            return "function call";
+        case BoolOp_kind:
+        case BinOp_kind:
+        case UnaryOp_kind:
+            return "operator";
+        case GeneratorExp_kind:
+            return "generator expression";
+        case Yield_kind:
+        case YieldFrom_kind:
+            return "yield expression";
+        case Await_kind:
+            return "await expression";
+        case ListComp_kind:
+            return "list comprehension";
+        case SetComp_kind:
+            return "set comprehension";
+        case DictComp_kind:
+            return "dict comprehension";
+        case Dict_kind:
+            return "dict display";
+        case Set_kind:
+            return "set display";
+        case JoinedStr_kind:
+        case FormattedValue_kind:
+            return "f-string expression";
+        case Constant_kind: {
+            PyObject *value = e->v.Constant.value;
+            if (value == Py_None) {
+                return "None";
+            }
+            if (value == Py_False) {
+                return "False";
+            }
+            if (value == Py_True) {
+                return "True";
+            }
+            if (value == Py_Ellipsis) {
+                return "Ellipsis";
+            }
+            return "literal";
+        }
+        case Compare_kind:
+            return "comparison";
+        case IfExp_kind:
+            return "conditional expression";
+        case NamedExpr_kind:
+            return "named expression";
+        default:
+            PyErr_Format(PyExc_SystemError,
+                         "unexpected expression in assignment %d (line %d)",
+                         e->kind, e->lineno);
+            return NULL;
+    }
+}
+
+static void
+raise_decode_error(Parser *p)
+{
+    const char *errtype = NULL;
+    if (PyErr_ExceptionMatches(PyExc_UnicodeError)) {
+        errtype = "unicode error";
+    }
+    else if (PyErr_ExceptionMatches(PyExc_ValueError)) {
+        errtype = "value error";
+    }
+    if (errtype) {
+        PyObject *type, *value, *tback, *errstr;
+        PyErr_Fetch(&type, &value, &tback);
+        errstr = PyObject_Str(value);
+        if (errstr) {
+            RAISE_SYNTAX_ERROR("(%s) %U", errtype, errstr);
+            Py_DECREF(errstr);
+        }
+        else {
+            PyErr_Clear();
+            RAISE_SYNTAX_ERROR("(%s) unknown error", errtype);
+        }
+        Py_XDECREF(type);
+        Py_XDECREF(value);
+        Py_XDECREF(tback);
+    }
+}
+
+static void
+raise_tokenizer_init_error(PyObject *filename)
+{
+    if (!(PyErr_ExceptionMatches(PyExc_LookupError)
+          || PyErr_ExceptionMatches(PyExc_ValueError)
+          || PyErr_ExceptionMatches(PyExc_UnicodeDecodeError))) {
+        return;
+    }
+    PyObject *type, *value, *tback, *errstr;
+    PyErr_Fetch(&type, &value, &tback);
+    errstr = PyObject_Str(value);
+
+    Py_INCREF(Py_None);
+    PyObject *tmp = Py_BuildValue("(OiiN)", filename, 0, -1, Py_None);
+    if (!tmp) {
+        goto error;
+    }
+
+    value = PyTuple_Pack(2, errstr, tmp);
+    Py_DECREF(tmp);
+    if (!value) {
+        goto error;
+    }
+    PyErr_SetObject(PyExc_SyntaxError, value);
+
+error:
+    Py_XDECREF(type);
+    Py_XDECREF(value);
+    Py_XDECREF(tback);
+}
+
+static inline PyObject *
+get_error_line(char *buffer)
+{
+    char *newline = strchr(buffer, '\n');
+    if (newline) {
+        return PyUnicode_FromStringAndSize(buffer, newline - buffer);
+    }
+    else {
+        return PyUnicode_FromString(buffer);
+    }
+}
+
+static int
+tokenizer_error_with_col_offset(Parser *p, PyObject *errtype, const char *errmsg)
+{
+    PyObject *errstr = NULL;
+    PyObject *value = NULL;
+    int col_number = -1;
+
+    errstr = PyUnicode_FromString(errmsg);
+    if (!errstr) {
+        return -1;
+    }
+
+    PyObject *loc = NULL;
+    if (p->start_rule == Py_file_input) {
+        loc = PyErr_ProgramTextObject(p->tok->filename, p->tok->lineno);
+    }
+    if (!loc) {
+        loc = get_error_line(p->tok->buf);
+    }
+
+    if (loc) {
+        col_number = p->tok->cur - p->tok->buf;
+    }
+    else {
+        Py_INCREF(Py_None);
+        loc = Py_None;
+    }
+
+    PyObject *tmp = Py_BuildValue("(OiiN)", p->tok->filename, p->tok->lineno,
+                                  col_number, loc);
+    if (!tmp) {
+        goto error;
+    }
+
+    value = PyTuple_Pack(2, errstr, tmp);
+    Py_DECREF(tmp);
+    if (!value) {
+        goto error;
+    }
+    PyErr_SetObject(errtype, value);
+
+    Py_XDECREF(value);
+    Py_XDECREF(errstr);
+    return -1;
+
+error:
+    Py_XDECREF(errstr);
+    Py_XDECREF(loc);
+    return -1;
+}
+
+static int
+tokenizer_error(Parser *p)
+{
+    if (PyErr_Occurred()) {
+        return -1;
+    }
+
+    const char *msg = NULL;
+    PyObject* errtype = PyExc_SyntaxError;
+    switch (p->tok->done) {
+        case E_TOKEN:
+            msg = "invalid token";
+            break;
+        case E_IDENTIFIER:
+            msg = "invalid character in identifier";
+            break;
+        case E_BADPREFIX:
+            return tokenizer_error_with_col_offset(p,
+                PyExc_SyntaxError, "invalid string prefix");
+        case E_EOFS:
+            return tokenizer_error_with_col_offset(p,
+                PyExc_SyntaxError, "EOF while scanning triple-quoted string literal");
+        case E_EOLS:
+            return tokenizer_error_with_col_offset(p,
+                PyExc_SyntaxError, "EOL while scanning string literal");
+        case E_DEDENT:
+            return tokenizer_error_with_col_offset(p,
+                PyExc_IndentationError, "unindent does not match any outer indentation level");
+        case E_INTR:
+            if (!PyErr_Occurred()) {
+                PyErr_SetNone(PyExc_KeyboardInterrupt);
+            }
+            return -1;
+        case E_NOMEM:
+            PyErr_NoMemory();
+            return -1;
+        case E_TABSPACE:
+            errtype = PyExc_TabError;
+            msg = "inconsistent use of tabs and spaces in indentation";
+            break;
+        case E_TOODEEP:
+            errtype = PyExc_IndentationError;
+            msg = "too many levels of indentation";
+            break;
+        case E_DECODE:
+            raise_decode_error(p);
+            return -1;
+        case E_LINECONT:
+            msg = "unexpected character after line continuation character";
+            break;
+        default:
+            msg = "unknown parsing error";
+    }
+
+    PyErr_Format(errtype, msg);
+    // There is no reliable column information for this error
+    PyErr_SyntaxLocationObject(p->tok->filename, p->tok->lineno, 0);
+
+    return -1;
+}
+
+void *
+_PyPegen_raise_error(Parser *p, PyObject *errtype, const char *errmsg, ...)
+{
+    PyObject *value = NULL;
+    PyObject *errstr = NULL;
+    PyObject *loc = NULL;
+    PyObject *tmp = NULL;
+    Token *t = p->tokens[p->fill - 1];
+    Py_ssize_t col_number = 0;
+    va_list va;
+
+    va_start(va, errmsg);
+    errstr = PyUnicode_FromFormatV(errmsg, va);
+    va_end(va);
+    if (!errstr) {
+        goto error;
+    }
+
+    if (p->start_rule == Py_file_input) {
+        loc = PyErr_ProgramTextObject(p->tok->filename, t->lineno);
+    }
+
+    if (!loc) {
+        loc = get_error_line(p->tok->buf);
+    }
+
+    if (loc) {
+        int col_offset = t->col_offset == -1 ? 0 : t->col_offset;
+        col_number = byte_offset_to_character_offset(loc, col_offset) + 1;
+    }
+    else {
+        Py_INCREF(Py_None);
+        loc = Py_None;
+    }
+
+
+    tmp = Py_BuildValue("(OiiN)", p->tok->filename, t->lineno, col_number, loc);
+    if (!tmp) {
+        goto error;
+    }
+    value = PyTuple_Pack(2, errstr, tmp);
+    Py_DECREF(tmp);
+    if (!value) {
+        goto error;
+    }
+    PyErr_SetObject(errtype, value);
+
+    Py_DECREF(errstr);
+    Py_DECREF(value);
+    return NULL;
+
+error:
+    Py_XDECREF(errstr);
+    Py_XDECREF(loc);
+    return NULL;
+}
+
+void *_PyPegen_arguments_parsing_error(Parser *p, expr_ty e) {
+    int kwarg_unpacking = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(e->v.Call.keywords); i < l; i++) {
+        keyword_ty keyword = asdl_seq_GET(e->v.Call.keywords, i);
+        if (!keyword->arg) {
+            kwarg_unpacking = 1;
+        }
+    }
+
+    const char *msg = NULL;
+    if (kwarg_unpacking) {
+        msg = "positional argument follows keyword argument unpacking";
+    } else {
+        msg = "positional argument follows keyword argument";
+    }
+
+    return RAISE_SYNTAX_ERROR(msg);
+}
+
+#if 0
+static const char *
+token_name(int type)
+{
+    if (0 <= type && type <= N_TOKENS) {
+        return _PyParser_TokenNames[type];
+    }
+    return "<Huh?>";
+}
+#endif
+
+// Here, mark is the start of the node, while p->mark is the end.
+// If node==NULL, they should be the same.
+int
+_PyPegen_insert_memo(Parser *p, int mark, int type, void *node)
+{
+    // Insert in front
+    Memo *m = PyArena_Malloc(p->arena, sizeof(Memo));
+    if (m == NULL) {
+        return -1;
+    }
+    m->type = type;
+    m->node = node;
+    m->mark = p->mark;
+    m->next = p->tokens[mark]->memo;
+    p->tokens[mark]->memo = m;
+    return 0;
+}
+
+// Like _PyPegen_insert_memo(), but updates an existing node if found.
+int
+_PyPegen_update_memo(Parser *p, int mark, int type, void *node)
+{
+    for (Memo *m = p->tokens[mark]->memo; m != NULL; m = m->next) {
+        if (m->type == type) {
+            // Update existing node.
+            m->node = node;
+            m->mark = p->mark;
+            return 0;
+        }
+    }
+    // Insert new node.
+    return _PyPegen_insert_memo(p, mark, type, node);
+}
+
+// Return dummy NAME.
+void *
+_PyPegen_dummy_name(Parser *p, ...)
+{
+    static void *cache = NULL;
+
+    if (cache != NULL) {
+        return cache;
+    }
+
+    PyObject *id = _create_dummy_identifier(p);
+    if (!id) {
+        return NULL;
+    }
+    cache = Name(id, Load, 1, 0, 1, 0, p->arena);
+    return cache;
+}
+
+static int
+_get_keyword_or_name_type(Parser *p, const char *name, int name_len)
+{
+    if (name_len >= p->n_keyword_lists || p->keywords[name_len] == NULL) {
+        return NAME;
+    }
+    for (KeywordToken *k = p->keywords[name_len]; k->type != -1; k++) {
+        if (strncmp(k->str, name, name_len) == 0) {
+            return k->type;
+        }
+    }
+    return NAME;
+}
+
+int
+_PyPegen_fill_token(Parser *p)
+{
+    const char *start, *end;
+    int type = PyTokenizer_Get(p->tok, &start, &end);
+    if (type == ERRORTOKEN) {
+        return tokenizer_error(p);
+    }
+    if (type == ENDMARKER && p->start_rule == Py_single_input && p->parsing_started) {
+        type = NEWLINE; /* Add an extra newline */
+        p->parsing_started = 0;
+
+        if (p->tok->indent) {
+            p->tok->pendin = -p->tok->indent;
+            p->tok->indent = 0;
+        }
+    }
+    else {
+        p->parsing_started = 1;
+    }
+
+    if (p->fill == p->size) {
+        int newsize = p->size * 2;
+        p->tokens = PyMem_Realloc(p->tokens, newsize * sizeof(Token *));
+        if (p->tokens == NULL) {
+            PyErr_Format(PyExc_MemoryError, "Realloc tokens failed");
+            return -1;
+        }
+        for (int i = p->size; i < newsize; i++) {
+            p->tokens[i] = PyMem_Malloc(sizeof(Token));
+            memset(p->tokens[i], '\0', sizeof(Token));
+        }
+        p->size = newsize;
+    }
+
+    Token *t = p->tokens[p->fill];
+    t->type = (type == NAME) ? _get_keyword_or_name_type(p, start, (int)(end - start)) : type;
+    t->bytes = PyBytes_FromStringAndSize(start, end - start);
+    if (t->bytes == NULL) {
+        return -1;
+    }
+    PyArena_AddPyObject(p->arena, t->bytes);
+
+    int lineno = type == STRING ? p->tok->first_lineno : p->tok->lineno;
+    const char *line_start = type == STRING ? p->tok->multi_line_start : p->tok->line_start;
+    int end_lineno = p->tok->lineno;
+    int col_offset = -1, end_col_offset = -1;
+    if (start != NULL && start >= line_start) {
+        col_offset = start - line_start;
+    }
+    if (end != NULL && end >= p->tok->line_start) {
+        end_col_offset = end - p->tok->line_start;
+    }
+
+    t->lineno = p->starting_lineno + lineno;
+    t->col_offset = p->tok->lineno == 1 ? p->starting_col_offset + col_offset : col_offset;
+    t->end_lineno = p->starting_lineno + end_lineno;
+    t->end_col_offset = p->tok->lineno == 1 ? p->starting_col_offset + end_col_offset : end_col_offset;
+
+    // if (p->fill % 100 == 0) fprintf(stderr, "Filled at %d: %s \"%s\"\n", p->fill,
+    // token_name(type), PyBytes_AsString(t->bytes));
+    p->fill += 1;
+    return 0;
+}
+
+// Instrumentation to count the effectiveness of memoization.
+// The array counts the number of tokens skipped by memoization,
+// indexed by type.
+
+#define NSTATISTICS 2000
+static long memo_statistics[NSTATISTICS];
+
+void
+_PyPegen_clear_memo_statistics()
+{
+    for (int i = 0; i < NSTATISTICS; i++) {
+        memo_statistics[i] = 0;
+    }
+}
+
+PyObject *
+_PyPegen_get_memo_statistics()
+{
+    PyObject *ret = PyList_New(NSTATISTICS);
+    if (ret == NULL) {
+        return NULL;
+    }
+    for (int i = 0; i < NSTATISTICS; i++) {
+        PyObject *value = PyLong_FromLong(memo_statistics[i]);
+        if (value == NULL) {
+            Py_DECREF(ret);
+            return NULL;
+        }
+        // PyList_SetItem borrows a reference to value.
+        if (PyList_SetItem(ret, i, value) < 0) {
+            Py_DECREF(ret);
+            return NULL;
+        }
+    }
+    return ret;
+}
+
+int  // bool
+_PyPegen_is_memoized(Parser *p, int type, void *pres)
+{
+    if (p->mark == p->fill) {
+        if (_PyPegen_fill_token(p) < 0) {
+            return -1;
+        }
+    }
+
+    Token *t = p->tokens[p->mark];
+
+    for (Memo *m = t->memo; m != NULL; m = m->next) {
+        if (m->type == type) {
+            if (0 <= type && type < NSTATISTICS) {
+                long count = m->mark - p->mark;
+                // A memoized negative result counts for one.
+                if (count <= 0) {
+                    count = 1;
+                }
+                memo_statistics[type] += count;
+            }
+            p->mark = m->mark;
+            *(void **)(pres) = m->node;
+            // fprintf(stderr, "%d < %d: memoized!\n", p->mark, p->fill);
+            return 1;
+        }
+    }
+    // fprintf(stderr, "%d < %d: not memoized\n", p->mark, p->fill);
+    return 0;
+}
+
+int
+_PyPegen_lookahead_with_string(int positive, void *(func)(Parser *, const char *), Parser *p,
+                      const char *arg)
+{
+    int mark = p->mark;
+    void *res = func(p, arg);
+    p->mark = mark;
+    return (res != NULL) == positive;
+}
+
+int
+_PyPegen_lookahead_with_int(int positive, Token *(func)(Parser *, int), Parser *p, int arg)
+{
+    int mark = p->mark;
+    void *res = func(p, arg);
+    p->mark = mark;
+    return (res != NULL) == positive;
+}
+
+int
+_PyPegen_lookahead(int positive, void *(func)(Parser *), Parser *p)
+{
+    int mark = p->mark;
+    void *res = func(p);
+    p->mark = mark;
+    return (res != NULL) == positive;
+}
+
+Token *
+_PyPegen_expect_token(Parser *p, int type)
+{
+    if (p->mark == p->fill) {
+        if (_PyPegen_fill_token(p) < 0) {
+            return NULL;
+        }
+    }
+    Token *t = p->tokens[p->mark];
+    if (t->type != type) {
+        // fprintf(stderr, "No %s at %d\n", token_name(type), p->mark);
+        return NULL;
+    }
+    p->mark += 1;
+    // fprintf(stderr, "Got %s at %d: %s\n", token_name(type), p->mark,
+    // PyBytes_AsString(t->bytes));
+
+    return t;
+}
+
+Token *
+_PyPegen_get_last_nonnwhitespace_token(Parser *p)
+{
+    assert(p->mark >= 0);
+    Token *token = NULL;
+    for (int m = p->mark - 1; m >= 0; m--) {
+        token = p->tokens[m];
+        if (token->type != ENDMARKER && (token->type < NEWLINE || token->type > DEDENT)) {
+            break;
+        }
+    }
+    return token;
+}
+
+void *
+_PyPegen_async_token(Parser *p)
+{
+    return _PyPegen_expect_token(p, ASYNC);
+}
+
+void *
+_PyPegen_await_token(Parser *p)
+{
+    return _PyPegen_expect_token(p, AWAIT);
+}
+
+void *
+_PyPegen_endmarker_token(Parser *p)
+{
+    return _PyPegen_expect_token(p, ENDMARKER);
+}
+
+expr_ty
+_PyPegen_name_token(Parser *p)
+{
+    Token *t = _PyPegen_expect_token(p, NAME);
+    if (t == NULL) {
+        return NULL;
+    }
+    char* s = PyBytes_AsString(t->bytes);
+    if (!s) {
+        return NULL;
+    }
+    PyObject *id = _PyPegen_new_identifier(p, s);
+    if (id == NULL) {
+        return NULL;
+    }
+    return Name(id, Load, t->lineno, t->col_offset, t->end_lineno, t->end_col_offset,
+                p->arena);
+}
+
+void *
+_PyPegen_string_token(Parser *p)
+{
+    return _PyPegen_expect_token(p, STRING);
+}
+
+void *
+_PyPegen_newline_token(Parser *p)
+{
+    return _PyPegen_expect_token(p, NEWLINE);
+}
+
+void *
+_PyPegen_indent_token(Parser *p)
+{
+    return _PyPegen_expect_token(p, INDENT);
+}
+
+void *
+_PyPegen_dedent_token(Parser *p)
+{
+    return _PyPegen_expect_token(p, DEDENT);
+}
+
+static PyObject *
+parsenumber_raw(const char *s)
+{
+    const char *end;
+    long x;
+    double dx;
+    Py_complex compl;
+    int imflag;
+
+    assert(s != NULL);
+    errno = 0;
+    end = s + strlen(s) - 1;
+    imflag = *end == 'j' || *end == 'J';
+    if (s[0] == '0') {
+        x = (long)PyOS_strtoul(s, (char **)&end, 0);
+        if (x < 0 && errno == 0) {
+            return PyLong_FromString(s, (char **)0, 0);
+        }
+    }
+    else
+        x = PyOS_strtol(s, (char **)&end, 0);
+    if (*end == '\0') {
+        if (errno != 0)
+            return PyLong_FromString(s, (char **)0, 0);
+        return PyLong_FromLong(x);
+    }
+    /* XXX Huge floats may silently fail */
+    if (imflag) {
+        compl.real = 0.;
+        compl.imag = PyOS_string_to_double(s, (char **)&end, NULL);
+        if (compl.imag == -1.0 && PyErr_Occurred())
+            return NULL;
+        return PyComplex_FromCComplex(compl);
+    }
+    else {
+        dx = PyOS_string_to_double(s, NULL, NULL);
+        if (dx == -1.0 && PyErr_Occurred())
+            return NULL;
+        return PyFloat_FromDouble(dx);
+    }
+}
+
+static PyObject *
+parsenumber(const char *s)
+{
+    char *dup, *end;
+    PyObject *res = NULL;
+
+    assert(s != NULL);
+
+    if (strchr(s, '_') == NULL) {
+        return parsenumber_raw(s);
+    }
+    /* Create a duplicate without underscores. */
+    dup = PyMem_Malloc(strlen(s) + 1);
+    if (dup == NULL) {
+        return PyErr_NoMemory();
+    }
+    end = dup;
+    for (; *s; s++) {
+        if (*s != '_') {
+            *end++ = *s;
+        }
+    }
+    *end = '\0';
+    res = parsenumber_raw(dup);
+    PyMem_Free(dup);
+    return res;
+}
+
+expr_ty
+_PyPegen_number_token(Parser *p)
+{
+    Token *t = _PyPegen_expect_token(p, NUMBER);
+    if (t == NULL) {
+        return NULL;
+    }
+
+    char *num_raw = PyBytes_AsString(t->bytes);
+
+    if (num_raw == NULL) {
+        return NULL;
+    }
+
+    PyObject *c = parsenumber(num_raw);
+
+    if (c == NULL) {
+        return NULL;
+    }
+
+    if (PyArena_AddPyObject(p->arena, c) < 0) {
+        Py_DECREF(c);
+        return NULL;
+    }
+
+    return Constant(c, NULL, t->lineno, t->col_offset, t->end_lineno, t->end_col_offset,
+                    p->arena);
+}
+
+void
+_PyPegen_Parser_Free(Parser *p)
+{
+    Py_XDECREF(p->normalize);
+    for (int i = 0; i < p->size; i++) {
+        PyMem_Free(p->tokens[i]);
+    }
+    PyMem_Free(p->tokens);
+    PyMem_Free(p);
+}
+
+Parser *
+_PyPegen_Parser_New(struct tok_state *tok, int start_rule, int *errcode, PyArena *arena)
+{
+    Parser *p = PyMem_Malloc(sizeof(Parser));
+    if (p == NULL) {
+        PyErr_Format(PyExc_MemoryError, "Out of memory for Parser");
+        return NULL;
+    }
+    assert(tok != NULL);
+    p->tok = tok;
+    p->keywords = NULL;
+    p->n_keyword_lists = -1;
+    p->tokens = PyMem_Malloc(sizeof(Token *));
+    if (!p->tokens) {
+        PyMem_Free(p);
+        PyErr_Format(PyExc_MemoryError, "Out of memory for tokens");
+        return NULL;
+    }
+    p->tokens[0] = PyMem_Malloc(sizeof(Token));
+    memset(p->tokens[0], '\0', sizeof(Token));
+    p->mark = 0;
+    p->fill = 0;
+    p->size = 1;
+
+    p->errcode = errcode;
+    p->arena = arena;
+    p->start_rule = start_rule;
+    p->parsing_started = 0;
+    p->normalize = NULL;
+    p->error_indicator = 0;
+
+    p->starting_lineno = 0;
+    p->starting_col_offset = 0;
+
+    return p;
+}
+
+void *
+_PyPegen_run_parser(Parser *p)
+{
+    void *res = _PyPegen_parse(p);
+    if (res == NULL) {
+        if (PyErr_Occurred()) {
+            return NULL;
+        }
+        if (p->fill == 0) {
+            RAISE_SYNTAX_ERROR("error at start before reading any input");
+        }
+        else if (p->tok->done == E_EOF) {
+            RAISE_SYNTAX_ERROR("unexpected EOF while parsing");
+        }
+        else {
+            if (p->tokens[p->fill-1]->type == INDENT) {
+                RAISE_INDENTATION_ERROR("unexpected indent");
+            }
+            else if (p->tokens[p->fill-1]->type == DEDENT) {
+                RAISE_INDENTATION_ERROR("unexpected unindent");
+            }
+            else {
+                RAISE_SYNTAX_ERROR("invalid syntax");
+            }
+        }
+        return NULL;
+    }
+
+    return res;
+}
+
+mod_ty
+_PyPegen_run_parser_from_file_pointer(FILE *fp, int start_rule, PyObject *filename_ob,
+                             const char *enc, const char *ps1, const char *ps2,
+                             int *errcode, PyArena *arena)
+{
+    struct tok_state *tok = PyTokenizer_FromFile(fp, enc, ps1, ps2);
+    if (tok == NULL) {
+        if (PyErr_Occurred()) {
+            raise_tokenizer_init_error(filename_ob);
+            return NULL;
+        }
+        return NULL;
+    }
+    // This transfers the ownership to the tokenizer
+    tok->filename = filename_ob;
+    Py_INCREF(filename_ob);
+
+    // From here on we need to clean up even if there's an error
+    mod_ty result = NULL;
+
+    Parser *p = _PyPegen_Parser_New(tok, start_rule, errcode, arena);
+    if (p == NULL) {
+        goto error;
+    }
+
+    result = _PyPegen_run_parser(p);
+    _PyPegen_Parser_Free(p);
+
+error:
+    PyTokenizer_Free(tok);
+    return result;
+}
+
+mod_ty
+_PyPegen_run_parser_from_file(const char *filename, int start_rule,
+                     PyObject *filename_ob, PyArena *arena)
+{
+    FILE *fp = fopen(filename, "rb");
+    if (fp == NULL) {
+        PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename);
+        return NULL;
+    }
+
+    mod_ty result = _PyPegen_run_parser_from_file_pointer(fp, start_rule, filename_ob,
+                                                 NULL, NULL, NULL, NULL, arena);
+
+    fclose(fp);
+    return result;
+}
+
+mod_ty
+_PyPegen_run_parser_from_string(const char *str, int start_rule, PyObject *filename_ob,
+                       int iflags, PyArena *arena)
+{
+    int exec_input = start_rule == Py_file_input;
+
+    struct tok_state *tok;
+    if (iflags & PyCF_IGNORE_COOKIE) {
+        tok = PyTokenizer_FromUTF8(str, exec_input);
+    } else {
+        tok = PyTokenizer_FromString(str, exec_input);
+    }
+    if (tok == NULL) {
+        if (PyErr_Occurred()) {
+            raise_tokenizer_init_error(filename_ob);
+        }
+        return NULL;
+    }
+    // This transfers the ownership to the tokenizer
+    tok->filename = filename_ob;
+    Py_INCREF(filename_ob);
+
+    // We need to clear up from here on
+    mod_ty result = NULL;
+
+    Parser *p = _PyPegen_Parser_New(tok, start_rule, NULL, arena);
+    if (p == NULL) {
+        goto error;
+    }
+
+    result = _PyPegen_run_parser(p);
+    _PyPegen_Parser_Free(p);
+
+error:
+    PyTokenizer_Free(tok);
+    return result;
+}
+
+void *
+_PyPegen_interactive_exit(Parser *p)
+{
+    if (p->errcode) {
+        *(p->errcode) = E_EOF;
+    }
+    return NULL;
+}
+
+/* Creates a single-element asdl_seq* that contains a */
+asdl_seq *
+_PyPegen_singleton_seq(Parser *p, void *a)
+{
+    assert(a != NULL);
+    asdl_seq *seq = _Py_asdl_seq_new(1, p->arena);
+    if (!seq) {
+        return NULL;
+    }
+    asdl_seq_SET(seq, 0, a);
+    return seq;
+}
+
+/* Creates a copy of seq and prepends a to it */
+asdl_seq *
+_PyPegen_seq_insert_in_front(Parser *p, void *a, asdl_seq *seq)
+{
+    assert(a != NULL);
+    if (!seq) {
+        return _PyPegen_singleton_seq(p, a);
+    }
+
+    asdl_seq *new_seq = _Py_asdl_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+
+    asdl_seq_SET(new_seq, 0, a);
+    for (int i = 1, l = asdl_seq_LEN(new_seq); i < l; i++) {
+        asdl_seq_SET(new_seq, i, asdl_seq_GET(seq, i - 1));
+    }
+    return new_seq;
+}
+
+static int
+_get_flattened_seq_size(asdl_seq *seqs)
+{
+    int size = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
+        asdl_seq *inner_seq = asdl_seq_GET(seqs, i);
+        size += asdl_seq_LEN(inner_seq);
+    }
+    return size;
+}
+
+/* Flattens an asdl_seq* of asdl_seq*s */
+asdl_seq *
+_PyPegen_seq_flatten(Parser *p, asdl_seq *seqs)
+{
+    int flattened_seq_size = _get_flattened_seq_size(seqs);
+    assert(flattened_seq_size > 0);
+
+    asdl_seq *flattened_seq = _Py_asdl_seq_new(flattened_seq_size, p->arena);
+    if (!flattened_seq) {
+        return NULL;
+    }
+
+    int flattened_seq_idx = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
+        asdl_seq *inner_seq = asdl_seq_GET(seqs, i);
+        for (int j = 0, li = asdl_seq_LEN(inner_seq); j < li; j++) {
+            asdl_seq_SET(flattened_seq, flattened_seq_idx++, asdl_seq_GET(inner_seq, j));
+        }
+    }
+    assert(flattened_seq_idx == flattened_seq_size);
+
+    return flattened_seq;
+}
+
+/* Creates a new name of the form <first_name>.<second_name> */
+expr_ty
+_PyPegen_join_names_with_dot(Parser *p, expr_ty first_name, expr_ty second_name)
+{
+    assert(first_name != NULL && second_name != NULL);
+    PyObject *first_identifier = first_name->v.Name.id;
+    PyObject *second_identifier = second_name->v.Name.id;
+
+    if (PyUnicode_READY(first_identifier) == -1) {
+        return NULL;
+    }
+    if (PyUnicode_READY(second_identifier) == -1) {
+        return NULL;
+    }
+    const char *first_str = PyUnicode_AsUTF8(first_identifier);
+    if (!first_str) {
+        return NULL;
+    }
+    const char *second_str = PyUnicode_AsUTF8(second_identifier);
+    if (!second_str) {
+        return NULL;
+    }
+    ssize_t len = strlen(first_str) + strlen(second_str) + 1;  // +1 for the dot
+
+    PyObject *str = PyBytes_FromStringAndSize(NULL, len);
+    if (!str) {
+        return NULL;
+    }
+
+    char *s = PyBytes_AS_STRING(str);
+    if (!s) {
+        return NULL;
+    }
+
+    strcpy(s, first_str);
+    s += strlen(first_str);
+    *s++ = '.';
+    strcpy(s, second_str);
+    s += strlen(second_str);
+    *s = '\0';
+
+    PyObject *uni = PyUnicode_DecodeUTF8(PyBytes_AS_STRING(str), PyBytes_GET_SIZE(str), NULL);
+    Py_DECREF(str);
+    if (!uni) {
+        return NULL;
+    }
+    PyUnicode_InternInPlace(&uni);
+    if (PyArena_AddPyObject(p->arena, uni) < 0) {
+        Py_DECREF(uni);
+        return NULL;
+    }
+
+    return _Py_Name(uni, Load, EXTRA_EXPR(first_name, second_name));
+}
+
+/* Counts the total number of dots in seq's tokens */
+int
+_PyPegen_seq_count_dots(asdl_seq *seq)
+{
+    int number_of_dots = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+        Token *current_expr = asdl_seq_GET(seq, i);
+        switch (current_expr->type) {
+            case ELLIPSIS:
+                number_of_dots += 3;
+                break;
+            case DOT:
+                number_of_dots += 1;
+                break;
+            default:
+                assert(current_expr->type == ELLIPSIS || current_expr->type == DOT);
+        }
+    }
+
+    return number_of_dots;
+}
+
+/* Creates an alias with '*' as the identifier name */
+alias_ty
+_PyPegen_alias_for_star(Parser *p)
+{
+    PyObject *str = PyUnicode_InternFromString("*");
+    if (!str) {
+        return NULL;
+    }
+    if (PyArena_AddPyObject(p->arena, str) < 0) {
+        Py_DECREF(str);
+        return NULL;
+    }
+    return alias(str, NULL, p->arena);
+}
+
+/* Creates a new asdl_seq* with the identifiers of all the names in seq */
+asdl_seq *
+_PyPegen_map_names_to_ids(Parser *p, asdl_seq *seq)
+{
+    int len = asdl_seq_LEN(seq);
+    assert(len > 0);
+
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        expr_ty e = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, e->v.Name.id);
+    }
+    return new_seq;
+}
+
+/* Constructs a CmpopExprPair */
+CmpopExprPair *
+_PyPegen_cmpop_expr_pair(Parser *p, cmpop_ty cmpop, expr_ty expr)
+{
+    assert(expr != NULL);
+    CmpopExprPair *a = PyArena_Malloc(p->arena, sizeof(CmpopExprPair));
+    if (!a) {
+        return NULL;
+    }
+    a->cmpop = cmpop;
+    a->expr = expr;
+    return a;
+}
+
+asdl_int_seq *
+_PyPegen_get_cmpops(Parser *p, asdl_seq *seq)
+{
+    int len = asdl_seq_LEN(seq);
+    assert(len > 0);
+
+    asdl_int_seq *new_seq = _Py_asdl_int_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        CmpopExprPair *pair = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, pair->cmpop);
+    }
+    return new_seq;
+}
+
+asdl_seq *
+_PyPegen_get_exprs(Parser *p, asdl_seq *seq)
+{
+    int len = asdl_seq_LEN(seq);
+    assert(len > 0);
+
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        CmpopExprPair *pair = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, pair->expr);
+    }
+    return new_seq;
+}
+
+/* Creates an asdl_seq* where all the elements have been changed to have ctx as context */
+static asdl_seq *
+_set_seq_context(Parser *p, asdl_seq *seq, expr_context_ty ctx)
+{
+    int len = asdl_seq_LEN(seq);
+    if (len == 0) {
+        return NULL;
+    }
+
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        expr_ty e = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, _PyPegen_set_expr_context(p, e, ctx));
+    }
+    return new_seq;
+}
+
+static expr_ty
+_set_name_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Name(e->v.Name.id, ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_tuple_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Tuple(_set_seq_context(p, e->v.Tuple.elts, ctx), ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_list_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_List(_set_seq_context(p, e->v.List.elts, ctx), ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_subscript_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Subscript(e->v.Subscript.value, e->v.Subscript.slice, ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_attribute_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Attribute(e->v.Attribute.value, e->v.Attribute.attr, ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_starred_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Starred(_PyPegen_set_expr_context(p, e->v.Starred.value, ctx), ctx, EXTRA_EXPR(e, e));
+}
+
+/* Creates an `expr_ty` equivalent to `expr` but with `ctx` as context */
+expr_ty
+_PyPegen_set_expr_context(Parser *p, expr_ty expr, expr_context_ty ctx)
+{
+    assert(expr != NULL);
+
+    expr_ty new = NULL;
+    switch (expr->kind) {
+        case Name_kind:
+            new = _set_name_context(p, expr, ctx);
+            break;
+        case Tuple_kind:
+            new = _set_tuple_context(p, expr, ctx);
+            break;
+        case List_kind:
+            new = _set_list_context(p, expr, ctx);
+            break;
+        case Subscript_kind:
+            new = _set_subscript_context(p, expr, ctx);
+            break;
+        case Attribute_kind:
+            new = _set_attribute_context(p, expr, ctx);
+            break;
+        case Starred_kind:
+            new = _set_starred_context(p, expr, ctx);
+            break;
+        default:
+            new = expr;
+    }
+    return new;
+}
+
+/* Constructs a KeyValuePair that is used when parsing a dict's key value pairs */
+KeyValuePair *
+_PyPegen_key_value_pair(Parser *p, expr_ty key, expr_ty value)
+{
+    KeyValuePair *a = PyArena_Malloc(p->arena, sizeof(KeyValuePair));
+    if (!a) {
+        return NULL;
+    }
+    a->key = key;
+    a->value = value;
+    return a;
+}
+
+/* Extracts all keys from an asdl_seq* of KeyValuePair*'s */
+asdl_seq *
+_PyPegen_get_keys(Parser *p, asdl_seq *seq)
+{
+    int len = asdl_seq_LEN(seq);
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        KeyValuePair *pair = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, pair->key);
+    }
+    return new_seq;
+}
+
+/* Extracts all values from an asdl_seq* of KeyValuePair*'s */
+asdl_seq *
+_PyPegen_get_values(Parser *p, asdl_seq *seq)
+{
+    int len = asdl_seq_LEN(seq);
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        KeyValuePair *pair = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, pair->value);
+    }
+    return new_seq;
+}
+
+/* Constructs a NameDefaultPair */
+NameDefaultPair *
+_PyPegen_name_default_pair(Parser *p, arg_ty arg, expr_ty value)
+{
+    NameDefaultPair *a = PyArena_Malloc(p->arena, sizeof(NameDefaultPair));
+    if (!a) {
+        return NULL;
+    }
+    a->arg = arg;
+    a->value = value;
+    return a;
+}
+
+/* Constructs a SlashWithDefault */
+SlashWithDefault *
+_PyPegen_slash_with_default(Parser *p, asdl_seq *plain_names, asdl_seq *names_with_defaults)
+{
+    SlashWithDefault *a = PyArena_Malloc(p->arena, sizeof(SlashWithDefault));
+    if (!a) {
+        return NULL;
+    }
+    a->plain_names = plain_names;
+    a->names_with_defaults = names_with_defaults;
+    return a;
+}
+
+/* Constructs a StarEtc */
+StarEtc *
+_PyPegen_star_etc(Parser *p, arg_ty vararg, asdl_seq *kwonlyargs, arg_ty kwarg)
+{
+    StarEtc *a = PyArena_Malloc(p->arena, sizeof(StarEtc));
+    if (!a) {
+        return NULL;
+    }
+    a->vararg = vararg;
+    a->kwonlyargs = kwonlyargs;
+    a->kwarg = kwarg;
+    return a;
+}
+
+asdl_seq *
+_PyPegen_join_sequences(Parser *p, asdl_seq *a, asdl_seq *b)
+{
+    int first_len = asdl_seq_LEN(a);
+    int second_len = asdl_seq_LEN(b);
+    asdl_seq *new_seq = _Py_asdl_seq_new(first_len + second_len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+
+    int k = 0;
+    for (Py_ssize_t i = 0; i < first_len; i++) {
+        asdl_seq_SET(new_seq, k++, asdl_seq_GET(a, i));
+    }
+    for (Py_ssize_t i = 0; i < second_len; i++) {
+        asdl_seq_SET(new_seq, k++, asdl_seq_GET(b, i));
+    }
+
+    return new_seq;
+}
+
+static asdl_seq *
+_get_names(Parser *p, asdl_seq *names_with_defaults)
+{
+    int len = asdl_seq_LEN(names_with_defaults);
+    asdl_seq *seq = _Py_asdl_seq_new(len, p->arena);
+    if (!seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        NameDefaultPair *pair = asdl_seq_GET(names_with_defaults, i);
+        asdl_seq_SET(seq, i, pair->arg);
+    }
+    return seq;
+}
+
+static asdl_seq *
+_get_defaults(Parser *p, asdl_seq *names_with_defaults)
+{
+    int len = asdl_seq_LEN(names_with_defaults);
+    asdl_seq *seq = _Py_asdl_seq_new(len, p->arena);
+    if (!seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        NameDefaultPair *pair = asdl_seq_GET(names_with_defaults, i);
+        asdl_seq_SET(seq, i, pair->value);
+    }
+    return seq;
+}
+
+/* Constructs an arguments_ty object out of all the parsed constructs in the parameters rule */
+arguments_ty
+_PyPegen_make_arguments(Parser *p, asdl_seq *slash_without_default,
+                        SlashWithDefault *slash_with_default, asdl_seq *plain_names,
+                        asdl_seq *names_with_default, StarEtc *star_etc)
+{
+    asdl_seq *posonlyargs;
+    if (slash_without_default != NULL) {
+        posonlyargs = slash_without_default;
+    }
+    else if (slash_with_default != NULL) {
+        asdl_seq *slash_with_default_names =
+            _get_names(p, slash_with_default->names_with_defaults);
+        if (!slash_with_default_names) {
+            return NULL;
+        }
+        posonlyargs = _PyPegen_join_sequences(p, slash_with_default->plain_names, slash_with_default_names);
+        if (!posonlyargs) {
+            return NULL;
+        }
+    }
+    else {
+        posonlyargs = _Py_asdl_seq_new(0, p->arena);
+        if (!posonlyargs) {
+            return NULL;
+        }
+    }
+
+    asdl_seq *posargs;
+    if (plain_names != NULL && names_with_default != NULL) {
+        asdl_seq *names_with_default_names = _get_names(p, names_with_default);
+        if (!names_with_default_names) {
+            return NULL;
+        }
+        posargs = _PyPegen_join_sequences(p, plain_names, names_with_default_names);
+        if (!posargs) {
+            return NULL;
+        }
+    }
+    else if (plain_names == NULL && names_with_default != NULL) {
+        posargs = _get_names(p, names_with_default);
+        if (!posargs) {
+            return NULL;
+        }
+    }
+    else if (plain_names != NULL && names_with_default == NULL) {
+        posargs = plain_names;
+    }
+    else {
+        posargs = _Py_asdl_seq_new(0, p->arena);
+        if (!posargs) {
+            return NULL;
+        }
+    }
+
+    asdl_seq *posdefaults;
+    if (slash_with_default != NULL && names_with_default != NULL) {
+        asdl_seq *slash_with_default_values =
+            _get_defaults(p, slash_with_default->names_with_defaults);
+        if (!slash_with_default_values) {
+            return NULL;
+        }
+        asdl_seq *names_with_default_values = _get_defaults(p, names_with_default);
+        if (!names_with_default_values) {
+            return NULL;
+        }
+        posdefaults = _PyPegen_join_sequences(p, slash_with_default_values, names_with_default_values);
+        if (!posdefaults) {
+            return NULL;
+        }
+    }
+    else if (slash_with_default == NULL && names_with_default != NULL) {
+        posdefaults = _get_defaults(p, names_with_default);
+        if (!posdefaults) {
+            return NULL;
+        }
+    }
+    else if (slash_with_default != NULL && names_with_default == NULL) {
+        posdefaults = _get_defaults(p, slash_with_default->names_with_defaults);
+        if (!posdefaults) {
+            return NULL;
+        }
+    }
+    else {
+        posdefaults = _Py_asdl_seq_new(0, p->arena);
+        if (!posdefaults) {
+            return NULL;
+        }
+    }
+
+    arg_ty vararg = NULL;
+    if (star_etc != NULL && star_etc->vararg != NULL) {
+        vararg = star_etc->vararg;
+    }
+
+    asdl_seq *kwonlyargs;
+    if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
+        kwonlyargs = _get_names(p, star_etc->kwonlyargs);
+        if (!kwonlyargs) {
+            return NULL;
+        }
+    }
+    else {
+        kwonlyargs = _Py_asdl_seq_new(0, p->arena);
+        if (!kwonlyargs) {
+            return NULL;
+        }
+    }
+
+    asdl_seq *kwdefaults;
+    if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
+        kwdefaults = _get_defaults(p, star_etc->kwonlyargs);
+        if (!kwdefaults) {
+            return NULL;
+        }
+    }
+    else {
+        kwdefaults = _Py_asdl_seq_new(0, p->arena);
+        if (!kwdefaults) {
+            return NULL;
+        }
+    }
+
+    arg_ty kwarg = NULL;
+    if (star_etc != NULL && star_etc->kwarg != NULL) {
+        kwarg = star_etc->kwarg;
+    }
+
+    return _Py_arguments(posonlyargs, posargs, vararg, kwonlyargs, kwdefaults, kwarg,
+                         posdefaults, p->arena);
+}
+
+/* Constructs an empty arguments_ty object, that gets used when a function accepts no
+ * arguments. */
+arguments_ty
+_PyPegen_empty_arguments(Parser *p)
+{
+    asdl_seq *posonlyargs = _Py_asdl_seq_new(0, p->arena);
+    if (!posonlyargs) {
+        return NULL;
+    }
+    asdl_seq *posargs = _Py_asdl_seq_new(0, p->arena);
+    if (!posargs) {
+        return NULL;
+    }
+    asdl_seq *posdefaults = _Py_asdl_seq_new(0, p->arena);
+    if (!posdefaults) {
+        return NULL;
+    }
+    asdl_seq *kwonlyargs = _Py_asdl_seq_new(0, p->arena);
+    if (!kwonlyargs) {
+        return NULL;
+    }
+    asdl_seq *kwdefaults = _Py_asdl_seq_new(0, p->arena);
+    if (!kwdefaults) {
+        return NULL;
+    }
+
+    return _Py_arguments(posonlyargs, posargs, NULL, kwonlyargs, kwdefaults, NULL, kwdefaults,
+                         p->arena);
+}
+
+/* Encapsulates the value of an operator_ty into an AugOperator struct */
+AugOperator *
+_PyPegen_augoperator(Parser *p, operator_ty kind)
+{
+    AugOperator *a = PyArena_Malloc(p->arena, sizeof(AugOperator));
+    if (!a) {
+        return NULL;
+    }
+    a->kind = kind;
+    return a;
+}
+
+/* Construct a FunctionDef equivalent to function_def, but with decorators */
+stmt_ty
+_PyPegen_function_def_decorators(Parser *p, asdl_seq *decorators, stmt_ty function_def)
+{
+    assert(function_def != NULL);
+    if (function_def->kind == AsyncFunctionDef_kind) {
+        return _Py_AsyncFunctionDef(
+            function_def->v.FunctionDef.name, function_def->v.FunctionDef.args,
+            function_def->v.FunctionDef.body, decorators, function_def->v.FunctionDef.returns,
+            function_def->v.FunctionDef.type_comment, function_def->lineno,
+            function_def->col_offset, function_def->end_lineno, function_def->end_col_offset,
+            p->arena);
+    }
+
+    return _Py_FunctionDef(function_def->v.FunctionDef.name, function_def->v.FunctionDef.args,
+                           function_def->v.FunctionDef.body, decorators,
+                           function_def->v.FunctionDef.returns,
+                           function_def->v.FunctionDef.type_comment, function_def->lineno,
+                           function_def->col_offset, function_def->end_lineno,
+                           function_def->end_col_offset, p->arena);
+}
+
+/* Construct a ClassDef equivalent to class_def, but with decorators */
+stmt_ty
+_PyPegen_class_def_decorators(Parser *p, asdl_seq *decorators, stmt_ty class_def)
+{
+    assert(class_def != NULL);
+    return _Py_ClassDef(class_def->v.ClassDef.name, class_def->v.ClassDef.bases,
+                        class_def->v.ClassDef.keywords, class_def->v.ClassDef.body, decorators,
+                        class_def->lineno, class_def->col_offset, class_def->end_lineno,
+                        class_def->end_col_offset, p->arena);
+}
+
+/* Construct a KeywordOrStarred */
+KeywordOrStarred *
+_PyPegen_keyword_or_starred(Parser *p, void *element, int is_keyword)
+{
+    KeywordOrStarred *a = PyArena_Malloc(p->arena, sizeof(KeywordOrStarred));
+    if (!a) {
+        return NULL;
+    }
+    a->element = element;
+    a->is_keyword = is_keyword;
+    return a;
+}
+
+/* Get the number of starred expressions in an asdl_seq* of KeywordOrStarred*s */
+static int
+_seq_number_of_starred_exprs(asdl_seq *seq)
+{
+    int n = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+        KeywordOrStarred *k = asdl_seq_GET(seq, i);
+        if (!k->is_keyword) {
+            n++;
+        }
+    }
+    return n;
+}
+
+/* Extract the starred expressions of an asdl_seq* of KeywordOrStarred*s */
+asdl_seq *
+_PyPegen_seq_extract_starred_exprs(Parser *p, asdl_seq *kwargs)
+{
+    int new_len = _seq_number_of_starred_exprs(kwargs);
+    if (new_len == 0) {
+        return NULL;
+    }
+    asdl_seq *new_seq = _Py_asdl_seq_new(new_len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+
+    int idx = 0;
+    for (Py_ssize_t i = 0, len = asdl_seq_LEN(kwargs); i < len; i++) {
+        KeywordOrStarred *k = asdl_seq_GET(kwargs, i);
+        if (!k->is_keyword) {
+            asdl_seq_SET(new_seq, idx++, k->element);
+        }
+    }
+    return new_seq;
+}
+
+/* Return a new asdl_seq* with only the keywords in kwargs */
+asdl_seq *
+_PyPegen_seq_delete_starred_exprs(Parser *p, asdl_seq *kwargs)
+{
+    int len = asdl_seq_LEN(kwargs);
+    int new_len = len - _seq_number_of_starred_exprs(kwargs);
+    if (new_len == 0) {
+        return NULL;
+    }
+    asdl_seq *new_seq = _Py_asdl_seq_new(new_len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+
+    int idx = 0;
+    for (Py_ssize_t i = 0; i < len; i++) {
+        KeywordOrStarred *k = asdl_seq_GET(kwargs, i);
+        if (k->is_keyword) {
+            asdl_seq_SET(new_seq, idx++, k->element);
+        }
+    }
+    return new_seq;
+}
+
+expr_ty
+_PyPegen_concatenate_strings(Parser *p, asdl_seq *strings)
+{
+    int len = asdl_seq_LEN(strings);
+    assert(len > 0);
+
+    Token *first = asdl_seq_GET(strings, 0);
+    Token *last = asdl_seq_GET(strings, len - 1);
+
+    int bytesmode = 0;
+    PyObject *bytes_str = NULL;
+
+    FstringParser state;
+    _PyPegen_FstringParser_Init(&state);
+
+    for (Py_ssize_t i = 0; i < len; i++) {
+        Token *t = asdl_seq_GET(strings, i);
+
+        int this_bytesmode;
+        int this_rawmode;
+        PyObject *s;
+        const char *fstr;
+        Py_ssize_t fstrlen = -1;
+
+        char *this_str = PyBytes_AsString(t->bytes);
+        if (!this_str) {
+            goto error;
+        }
+
+        if (_PyPegen_parsestr(p, this_str, &this_bytesmode, &this_rawmode, &s, &fstr, &fstrlen) != 0) {
+            goto error;
+        }
+
+        /* Check that we are not mixing bytes with unicode. */
+        if (i != 0 && bytesmode != this_bytesmode) {
+            RAISE_SYNTAX_ERROR("cannot mix bytes and nonbytes literals");
+            Py_XDECREF(s);
+            goto error;
+        }
+        bytesmode = this_bytesmode;
+
+        if (fstr != NULL) {
+            assert(s == NULL && !bytesmode);
+
+            int result = _PyPegen_FstringParser_ConcatFstring(p, &state, &fstr, fstr + fstrlen,
+                                                     this_rawmode, 0, first, t, last);
+            if (result < 0) {
+                goto error;
+            }
+        }
+        else {
+            /* String or byte string. */
+            assert(s != NULL && fstr == NULL);
+            assert(bytesmode ? PyBytes_CheckExact(s) : PyUnicode_CheckExact(s));
+
+            if (bytesmode) {
+                if (i == 0) {
+                    bytes_str = s;
+                }
+                else {
+                    PyBytes_ConcatAndDel(&bytes_str, s);
+                    if (!bytes_str) {
+                        goto error;
+                    }
+                }
+            }
+            else {
+                /* This is a regular string. Concatenate it. */
+                if (_PyPegen_FstringParser_ConcatAndDel(&state, s) < 0) {
+                    goto error;
+                }
+            }
+        }
+    }
+
+    if (bytesmode) {
+        if (PyArena_AddPyObject(p->arena, bytes_str) < 0) {
+            goto error;
+        }
+        return Constant(bytes_str, NULL, first->lineno, first->col_offset, last->end_lineno,
+                        last->end_col_offset, p->arena);
+    }
+
+    return _PyPegen_FstringParser_Finish(p, &state, first, last);
+
+error:
+    Py_XDECREF(bytes_str);
+    _PyPegen_FstringParser_Dealloc(&state);
+    if (PyErr_Occurred()) {
+        raise_decode_error(p);
+    }
+    return NULL;
+}
diff --git a/Parser/pegen/pegen.h b/Parser/pegen/pegen.h
new file mode 100644
index 0000000..5acd988
--- /dev/null
+++ b/Parser/pegen/pegen.h
@@ -0,0 +1,179 @@
+#ifndef PEGEN_H
+#define PEGEN_H
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <token.h>
+#include <Python-ast.h>
+#include <pyarena.h>
+
+typedef struct _memo {
+    int type;
+    void *node;
+    int mark;
+    struct _memo *next;
+} Memo;
+
+typedef struct {
+    int type;
+    PyObject *bytes;
+    int lineno, col_offset, end_lineno, end_col_offset;
+    Memo *memo;
+} Token;
+
+typedef struct {
+    char *str;
+    int type;
+} KeywordToken;
+
+typedef struct {
+    struct tok_state *tok;
+    Token **tokens;
+    int mark;
+    int fill, size;
+    PyArena *arena;
+    KeywordToken **keywords;
+    int n_keyword_lists;
+    int start_rule;
+    int *errcode;
+    int parsing_started;
+    PyObject* normalize;
+    int starting_lineno;
+    int starting_col_offset;
+    int error_indicator;
+} Parser;
+
+typedef struct {
+    cmpop_ty cmpop;
+    expr_ty expr;
+} CmpopExprPair;
+
+typedef struct {
+    expr_ty key;
+    expr_ty value;
+} KeyValuePair;
+
+typedef struct {
+    arg_ty arg;
+    expr_ty value;
+} NameDefaultPair;
+
+typedef struct {
+    asdl_seq *plain_names;
+    asdl_seq *names_with_defaults; // asdl_seq* of NameDefaultsPair's
+} SlashWithDefault;
+
+typedef struct {
+    arg_ty vararg;
+    asdl_seq *kwonlyargs; // asdl_seq* of NameDefaultsPair's
+    arg_ty kwarg;
+} StarEtc;
+
+typedef struct {
+    operator_ty kind;
+} AugOperator;
+
+typedef struct {
+    void *element;
+    int is_keyword;
+} KeywordOrStarred;
+
+void _PyPegen_clear_memo_statistics(void);
+PyObject *_PyPegen_get_memo_statistics(void);
+
+int _PyPegen_insert_memo(Parser *p, int mark, int type, void *node);
+int _PyPegen_update_memo(Parser *p, int mark, int type, void *node);
+int _PyPegen_is_memoized(Parser *p, int type, void *pres);
+
+int _PyPegen_lookahead_with_string(int, void *(func)(Parser *, const char *), Parser *, const char *);
+int _PyPegen_lookahead_with_int(int, Token *(func)(Parser *, int), Parser *, int);
+int _PyPegen_lookahead(int, void *(func)(Parser *), Parser *);
+
+Token *_PyPegen_expect_token(Parser *p, int type);
+Token *_PyPegen_get_last_nonnwhitespace_token(Parser *);
+int _PyPegen_fill_token(Parser *p);
+void *_PyPegen_async_token(Parser *p);
+void *_PyPegen_await_token(Parser *p);
+void *_PyPegen_endmarker_token(Parser *p);
+expr_ty _PyPegen_name_token(Parser *p);
+void *_PyPegen_newline_token(Parser *p);
+void *_PyPegen_indent_token(Parser *p);
+void *_PyPegen_dedent_token(Parser *p);
+expr_ty _PyPegen_number_token(Parser *p);
+void *_PyPegen_string_token(Parser *p);
+const char *_PyPegen_get_expr_name(expr_ty);
+void *_PyPegen_raise_error(Parser *p, PyObject *, const char *errmsg, ...);
+void *_PyPegen_dummy_name(Parser *p, ...);
+
+#define UNUSED(expr) do { (void)(expr); } while (0)
+#define EXTRA_EXPR(head, tail) head->lineno, head->col_offset, tail->end_lineno, tail->end_col_offset, p->arena
+#define EXTRA start_lineno, start_col_offset, end_lineno, end_col_offset, p->arena
+#define RAISE_SYNTAX_ERROR(msg, ...) _PyPegen_raise_error(p, PyExc_SyntaxError, msg, ##__VA_ARGS__)
+#define RAISE_INDENTATION_ERROR(msg, ...) _PyPegen_raise_error(p, PyExc_IndentationError, msg, ##__VA_ARGS__)
+
+Py_LOCAL_INLINE(void *)
+CHECK_CALL(Parser *p, void *result)
+{
+    if (result == NULL) {
+        assert(PyErr_Occurred());
+        p->error_indicator = 1;
+    }
+    return result;
+}
+
+/* This is needed for helper functions that are allowed to
+   return NULL without an error. Example: _PyPegen_seq_extract_starred_exprs */
+Py_LOCAL_INLINE(void *)
+CHECK_CALL_NULL_ALLOWED(Parser *p, void *result)
+{
+    if (result == NULL && PyErr_Occurred()) {
+        p->error_indicator = 1;
+    }
+    return result;
+}
+
+#define CHECK(result) CHECK_CALL(p, result)
+#define CHECK_NULL_ALLOWED(result) CHECK_CALL_NULL_ALLOWED(p, result)
+
+PyObject *_PyPegen_new_identifier(Parser *, char *);
+Parser *_PyPegen_Parser_New(struct tok_state *, int, int *, PyArena *);
+void _PyPegen_Parser_Free(Parser *);
+mod_ty _PyPegen_run_parser_from_file_pointer(FILE *, int, PyObject *, const char *,
+                                    const char *, const char *, int *, PyArena *);
+void *_PyPegen_run_parser(Parser *);
+mod_ty _PyPegen_run_parser_from_file(const char *, int, PyObject *, PyArena *);
+mod_ty _PyPegen_run_parser_from_string(const char *, int, PyObject *, int, PyArena *);
+void *_PyPegen_interactive_exit(Parser *);
+asdl_seq *_PyPegen_singleton_seq(Parser *, void *);
+asdl_seq *_PyPegen_seq_insert_in_front(Parser *, void *, asdl_seq *);
+asdl_seq *_PyPegen_seq_flatten(Parser *, asdl_seq *);
+expr_ty _PyPegen_join_names_with_dot(Parser *, expr_ty, expr_ty);
+int _PyPegen_seq_count_dots(asdl_seq *);
+alias_ty _PyPegen_alias_for_star(Parser *);
+asdl_seq *_PyPegen_map_names_to_ids(Parser *, asdl_seq *);
+CmpopExprPair *_PyPegen_cmpop_expr_pair(Parser *, cmpop_ty, expr_ty);
+asdl_int_seq *_PyPegen_get_cmpops(Parser *p, asdl_seq *);
+asdl_seq *_PyPegen_get_exprs(Parser *, asdl_seq *);
+expr_ty _PyPegen_set_expr_context(Parser *, expr_ty, expr_context_ty);
+KeyValuePair *_PyPegen_key_value_pair(Parser *, expr_ty, expr_ty);
+asdl_seq *_PyPegen_get_keys(Parser *, asdl_seq *);
+asdl_seq *_PyPegen_get_values(Parser *, asdl_seq *);
+NameDefaultPair *_PyPegen_name_default_pair(Parser *, arg_ty, expr_ty);
+SlashWithDefault *_PyPegen_slash_with_default(Parser *, asdl_seq *, asdl_seq *);
+StarEtc *_PyPegen_star_etc(Parser *, arg_ty, asdl_seq *, arg_ty);
+arguments_ty _PyPegen_make_arguments(Parser *, asdl_seq *, SlashWithDefault *,
+                            asdl_seq *, asdl_seq *, StarEtc *);
+arguments_ty _PyPegen_empty_arguments(Parser *);
+AugOperator *_PyPegen_augoperator(Parser*, operator_ty type);
+stmt_ty _PyPegen_function_def_decorators(Parser *, asdl_seq *, stmt_ty);
+stmt_ty _PyPegen_class_def_decorators(Parser *, asdl_seq *, stmt_ty);
+KeywordOrStarred *_PyPegen_keyword_or_starred(Parser *, void *, int);
+asdl_seq *_PyPegen_seq_extract_starred_exprs(Parser *, asdl_seq *);
+asdl_seq *_PyPegen_seq_delete_starred_exprs(Parser *, asdl_seq *);
+expr_ty _PyPegen_concatenate_strings(Parser *p, asdl_seq *);
+asdl_seq *_PyPegen_join_sequences(Parser *, asdl_seq *, asdl_seq *);
+void *_PyPegen_arguments_parsing_error(Parser *, expr_ty);
+
+void *_PyPegen_parse(Parser *);
+
+#endif