// @generated by pegen from python.gram

#include "pegen.h"

#if defined(Py_DEBUG) && defined(Py_BUILD_CORE)

#  define D(x) if (p->debug) { x; }

#else

#  define D(x)

#endif

#ifdef __wasi__

#  ifdef Py_DEBUG

#    define MAXSTACK 1000

#  else

#    define MAXSTACK 4000

#  endif

#else

#  define MAXSTACK 6000

#endif

static const int n_keyword_lists = 9;

static KeywordToken *reserved_keywords[] = {

    (KeywordToken[]) {{NULL, -1}},

    (KeywordToken[]) {{NULL, -1}},

    (KeywordToken[]) {

        {"if", 687},

        {"as", 685},

        {"in", 700},

        {"or", 589},

        {"is", 597},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"del", 630},

        {"def", 704},

        {"for", 699},

        {"try", 661},

        {"and", 590},

        {"not", 708},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"from", 638},

        {"pass", 527},

        {"with", 652},

        {"elif", 692},

        {"else", 691},

        {"None", 624},

        {"True", 623},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"raise", 628},

        {"yield", 588},

        {"break", 528},

        {"async", 703},

        {"class", 706},

        {"while", 694},

        {"False", 625},

        {"await", 598},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"return", 522},

        {"import", 639},

        {"assert", 533},

        {"global", 530},

        {"except", 682},

        {"lambda", 622},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"finally", 678},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"continue", 529},

        {"nonlocal", 531},

        {NULL, -1},

    },

};

static char *soft_keywords[] = {

    "_",

    "case",

    "match",

    "type",

    NULL,

};

#define file_type 1000

#define interactive_type 1001

#define eval_type 1002

#define func_type_type 1003

#define statements_type 1004

#define statement_type 1005

#define single_compound_stmt_type 1006

#define statement_newline_type 1007

#define simple_stmts_type 1008

#define simple_stmt_type 1009

#define compound_stmt_type 1010

#define assignment_type 1011

#define annotated_rhs_type 1012

#define augassign_type 1013

#define return_stmt_type 1014

#define raise_stmt_type 1015

#define pass_stmt_type 1016

#define break_stmt_type 1017

#define continue_stmt_type 1018

#define global_stmt_type 1019

#define nonlocal_stmt_type 1020

#define del_stmt_type 1021

#define yield_stmt_type 1022

#define assert_stmt_type 1023

#define import_stmt_type 1024

#define import_name_type 1025

#define import_from_type 1026

#define import_from_targets_type 1027

#define import_from_as_names_type 1028

#define import_from_as_name_type 1029

#define dotted_as_names_type 1030

#define dotted_as_name_type 1031

#define dotted_name_type 1032  // Left-recursive

#define block_type 1033

#define decorators_type 1034

#define class_def_type 1035

#define class_def_raw_type 1036

#define function_def_type 1037

#define function_def_raw_type 1038

#define params_type 1039

#define parameters_type 1040

#define slash_no_default_type 1041

#define slash_with_default_type 1042

#define star_etc_type 1043

#define kwds_type 1044

#define param_no_default_type 1045

#define param_no_default_star_annotation_type 1046

#define param_with_default_type 1047

#define param_maybe_default_type 1048

#define param_type 1049

#define param_star_annotation_type 1050

#define annotation_type 1051

#define star_annotation_type 1052

#define default_type 1053

#define if_stmt_type 1054

#define elif_stmt_type 1055

#define else_block_type 1056

#define while_stmt_type 1057

#define for_stmt_type 1058

#define with_stmt_type 1059

#define with_item_type 1060

#define try_stmt_type 1061

#define except_block_type 1062

#define except_star_block_type 1063

#define finally_block_type 1064

#define match_stmt_type 1065

#define subject_expr_type 1066

#define case_block_type 1067

#define guard_type 1068

#define patterns_type 1069

#define pattern_type 1070

#define as_pattern_type 1071

#define or_pattern_type 1072

#define closed_pattern_type 1073

#define literal_pattern_type 1074

#define literal_expr_type 1075

#define complex_number_type 1076

#define signed_number_type 1077

#define signed_real_number_type 1078

#define real_number_type 1079

#define imaginary_number_type 1080

#define capture_pattern_type 1081

#define pattern_capture_target_type 1082

#define wildcard_pattern_type 1083

#define value_pattern_type 1084

#define attr_type 1085  // Left-recursive

#define name_or_attr_type 1086  // Left-recursive

#define group_pattern_type 1087

#define sequence_pattern_type 1088

#define open_sequence_pattern_type 1089

#define maybe_sequence_pattern_type 1090

#define maybe_star_pattern_type 1091

#define star_pattern_type 1092

#define mapping_pattern_type 1093

#define items_pattern_type 1094

#define key_value_pattern_type 1095

#define double_star_pattern_type 1096

#define class_pattern_type 1097

#define positional_patterns_type 1098

#define keyword_patterns_type 1099

#define keyword_pattern_type 1100

#define type_alias_type 1101

#define type_params_type 1102

#define type_param_seq_type 1103

#define type_param_type 1104

#define type_param_bound_type 1105

#define type_param_default_type 1106

#define type_param_starred_default_type 1107

#define expressions_type 1108

#define expression_type 1109

#define yield_expr_type 1110

#define star_expressions_type 1111

#define star_expression_type 1112

#define star_named_expressions_type 1113

#define star_named_expression_type 1114

#define assignment_expression_type 1115

#define named_expression_type 1116

#define disjunction_type 1117

#define conjunction_type 1118

#define inversion_type 1119

#define comparison_type 1120

#define compare_op_bitwise_or_pair_type 1121

#define eq_bitwise_or_type 1122

#define noteq_bitwise_or_type 1123

#define lte_bitwise_or_type 1124

#define lt_bitwise_or_type 1125

#define gte_bitwise_or_type 1126

#define gt_bitwise_or_type 1127

#define notin_bitwise_or_type 1128

#define in_bitwise_or_type 1129

#define isnot_bitwise_or_type 1130

#define is_bitwise_or_type 1131

#define bitwise_or_type 1132  // Left-recursive

#define bitwise_xor_type 1133  // Left-recursive

#define bitwise_and_type 1134  // Left-recursive

#define shift_expr_type 1135  // Left-recursive

#define sum_type 1136  // Left-recursive

#define term_type 1137  // Left-recursive

#define factor_type 1138

#define power_type 1139

#define await_primary_type 1140

#define primary_type 1141  // Left-recursive

#define slices_type 1142

#define slice_type 1143

#define atom_type 1144

#define group_type 1145

#define lambdef_type 1146

#define lambda_params_type 1147

#define lambda_parameters_type 1148

#define lambda_slash_no_default_type 1149

#define lambda_slash_with_default_type 1150

#define lambda_star_etc_type 1151

#define lambda_kwds_type 1152

#define lambda_param_no_default_type 1153

#define lambda_param_with_default_type 1154

#define lambda_param_maybe_default_type 1155

#define lambda_param_type 1156

#define fstring_middle_type 1157

#define fstring_replacement_field_type 1158

#define fstring_conversion_type 1159

#define fstring_full_format_spec_type 1160

#define fstring_format_spec_type 1161

#define fstring_type 1162

#define tstring_format_spec_replacement_field_type 1163

#define tstring_format_spec_type 1164

#define tstring_full_format_spec_type 1165

#define tstring_replacement_field_type 1166

#define tstring_middle_type 1167

#define tstring_type 1168

#define string_type 1169

#define strings_type 1170

#define list_type 1171

#define tuple_type 1172

#define set_type 1173

#define dict_type 1174

#define double_starred_kvpairs_type 1175

#define double_starred_kvpair_type 1176

#define kvpair_type 1177

#define for_if_clauses_type 1178

#define for_if_clause_type 1179

#define listcomp_type 1180

#define setcomp_type 1181

#define genexp_type 1182

#define dictcomp_type 1183

#define arguments_type 1184

#define args_type 1185

#define kwargs_type 1186

#define starred_expression_type 1187

#define kwarg_or_starred_type 1188

#define kwarg_or_double_starred_type 1189

#define star_targets_type 1190

#define star_targets_list_seq_type 1191

#define star_targets_tuple_seq_type 1192

#define star_target_type 1193

#define target_with_star_atom_type 1194

#define star_atom_type 1195

#define single_target_type 1196

#define single_subscript_attribute_target_type 1197

#define t_primary_type 1198  // Left-recursive

#define t_lookahead_type 1199

#define del_targets_type 1200

#define del_target_type 1201

#define del_t_atom_type 1202

#define type_expressions_type 1203

#define func_type_comment_type 1204

#define invalid_arguments_type 1205

#define invalid_kwarg_type 1206

#define expression_without_invalid_type 1207

#define invalid_legacy_expression_type 1208

#define invalid_type_param_type 1209

#define invalid_expression_type 1210

#define invalid_named_expression_type 1211

#define invalid_assignment_type 1212

#define invalid_ann_assign_target_type 1213

#define invalid_raise_stmt_type 1214

#define invalid_del_stmt_type 1215

#define invalid_block_type 1216

#define invalid_comprehension_type 1217

#define invalid_dict_comprehension_type 1218

#define invalid_parameters_type 1219

#define invalid_default_type 1220

#define invalid_star_etc_type 1221

#define invalid_kwds_type 1222

#define invalid_parameters_helper_type 1223

#define invalid_lambda_parameters_type 1224

#define invalid_lambda_parameters_helper_type 1225

#define invalid_lambda_star_etc_type 1226

#define invalid_lambda_kwds_type 1227

#define invalid_double_type_comments_type 1228

#define invalid_with_item_type 1229

#define invalid_for_if_clause_type 1230

#define invalid_for_target_type 1231

#define invalid_group_type 1232

#define invalid_import_type 1233

#define invalid_dotted_as_name_type 1234

#define invalid_import_from_as_name_type 1235

#define invalid_import_from_targets_type 1236

#define invalid_with_stmt_type 1237

#define invalid_with_stmt_indent_type 1238

#define invalid_try_stmt_type 1239

#define invalid_except_stmt_type 1240

#define invalid_except_star_stmt_type 1241

#define invalid_finally_stmt_type 1242

#define invalid_except_stmt_indent_type 1243

#define invalid_except_star_stmt_indent_type 1244

#define invalid_match_stmt_type 1245

#define invalid_case_block_type 1246

#define invalid_as_pattern_type 1247

#define invalid_class_pattern_type 1248

#define invalid_class_argument_pattern_type 1249

#define invalid_if_stmt_type 1250

#define invalid_elif_stmt_type 1251

#define invalid_else_stmt_type 1252

#define invalid_while_stmt_type 1253

#define invalid_for_stmt_type 1254

#define invalid_def_raw_type 1255

#define invalid_class_def_raw_type 1256

#define invalid_double_starred_kvpairs_type 1257

#define invalid_kvpair_type 1258

#define invalid_starred_expression_unpacking_type 1259

#define invalid_starred_expression_type 1260

#define invalid_fstring_replacement_field_type 1261

#define invalid_fstring_conversion_character_type 1262

#define invalid_tstring_replacement_field_type 1263

#define invalid_tstring_conversion_character_type 1264

#define invalid_arithmetic_type 1265

#define invalid_factor_type 1266

#define invalid_type_params_type 1267

#define _loop0_1_type 1268

#define _loop1_2_type 1269

#define _loop0_3_type 1270

#define _gather_4_type 1271

#define _tmp_5_type 1272

#define _tmp_6_type 1273

#define _tmp_7_type 1274

#define _tmp_8_type 1275

#define _tmp_9_type 1276

#define _tmp_10_type 1277

#define _tmp_11_type 1278

#define _loop1_12_type 1279

#define _loop0_13_type 1280

#define _gather_14_type 1281

#define _tmp_15_type 1282

#define _tmp_16_type 1283

#define _loop0_17_type 1284

#define _loop1_18_type 1285

#define _loop0_19_type 1286

#define _gather_20_type 1287

#define _tmp_21_type 1288

#define _loop0_22_type 1289

#define _gather_23_type 1290

#define _loop1_24_type 1291

#define _tmp_25_type 1292

#define _tmp_26_type 1293

#define _loop0_27_type 1294

#define _loop0_28_type 1295

#define _loop1_29_type 1296

#define _loop1_30_type 1297

#define _loop0_31_type 1298

#define _loop1_32_type 1299

#define _loop0_33_type 1300

#define _gather_34_type 1301

#define _tmp_35_type 1302

#define _loop1_36_type 1303

#define _loop1_37_type 1304

#define _loop1_38_type 1305

#define _loop0_39_type 1306

#define _gather_40_type 1307

#define _tmp_41_type 1308

#define _tmp_42_type 1309

#define _tmp_43_type 1310

#define _loop0_44_type 1311

#define _gather_45_type 1312

#define _loop0_46_type 1313

#define _gather_47_type 1314

#define _tmp_48_type 1315

#define _loop0_49_type 1316

#define _gather_50_type 1317

#define _loop0_51_type 1318

#define _gather_52_type 1319

#define _loop0_53_type 1320

#define _gather_54_type 1321

#define _loop1_55_type 1322

#define _loop1_56_type 1323

#define _loop0_57_type 1324

#define _gather_58_type 1325

#define _loop1_59_type 1326

#define _loop1_60_type 1327

#define _loop1_61_type 1328

#define _tmp_62_type 1329

#define _loop0_63_type 1330

#define _gather_64_type 1331

#define _tmp_65_type 1332

#define _tmp_66_type 1333

#define _tmp_67_type 1334

#define _tmp_68_type 1335

#define _tmp_69_type 1336

#define _loop0_70_type 1337

#define _loop0_71_type 1338

#define _loop1_72_type 1339

#define _loop1_73_type 1340

#define _loop0_74_type 1341

#define _loop1_75_type 1342

#define _loop0_76_type 1343

#define _loop0_77_type 1344

#define _loop0_78_type 1345

#define _loop0_79_type 1346

#define _loop1_80_type 1347

#define _tmp_81_type 1348

#define _loop0_82_type 1349

#define _gather_83_type 1350

#define _loop1_84_type 1351

#define _loop0_85_type 1352

#define _tmp_86_type 1353

#define _loop0_87_type 1354

#define _gather_88_type 1355

#define _tmp_89_type 1356

#define _loop0_90_type 1357

#define _gather_91_type 1358

#define _loop0_92_type 1359

#define _gather_93_type 1360

#define _loop0_94_type 1361

#define _loop0_95_type 1362

#define _gather_96_type 1363

#define _loop1_97_type 1364

#define _tmp_98_type 1365

#define _loop0_99_type 1366

#define _gather_100_type 1367

#define _loop0_101_type 1368

#define _gather_102_type 1369

#define _tmp_103_type 1370

#define _tmp_104_type 1371

#define _loop0_105_type 1372

#define _gather_106_type 1373

#define _tmp_107_type 1374

#define _tmp_108_type 1375

#define _tmp_109_type 1376

#define _tmp_110_type 1377

#define _tmp_111_type 1378

#define _loop1_112_type 1379

#define _tmp_113_type 1380

#define _tmp_114_type 1381

#define _tmp_115_type 1382

#define _tmp_116_type 1383

#define _tmp_117_type 1384

#define _loop0_118_type 1385

#define _loop0_119_type 1386

#define _tmp_120_type 1387

#define _tmp_121_type 1388

#define _tmp_122_type 1389

#define _tmp_123_type 1390

#define _tmp_124_type 1391

#define _tmp_125_type 1392

#define _tmp_126_type 1393

#define _tmp_127_type 1394

#define _tmp_128_type 1395

#define _loop0_129_type 1396

#define _gather_130_type 1397

#define _tmp_131_type 1398

#define _tmp_132_type 1399

#define _tmp_133_type 1400

#define _tmp_134_type 1401

#define _loop0_135_type 1402

#define _gather_136_type 1403

#define _tmp_137_type 1404

#define _loop0_138_type 1405

#define _gather_139_type 1406

#define _loop0_140_type 1407

#define _gather_141_type 1408

#define _tmp_142_type 1409

#define _loop0_143_type 1410

#define _tmp_144_type 1411

#define _tmp_145_type 1412

#define _tmp_146_type 1413

#define _tmp_147_type 1414

#define _tmp_148_type 1415

#define _tmp_149_type 1416

#define _tmp_150_type 1417

#define _tmp_151_type 1418

#define _tmp_152_type 1419

#define _tmp_153_type 1420

#define _tmp_154_type 1421

#define _tmp_155_type 1422

#define _tmp_156_type 1423

#define _tmp_157_type 1424

#define _tmp_158_type 1425

#define _tmp_159_type 1426

#define _tmp_160_type 1427

#define _tmp_161_type 1428

#define _tmp_162_type 1429

#define _tmp_163_type 1430

#define _tmp_164_type 1431

#define _tmp_165_type 1432

#define _tmp_166_type 1433

#define _tmp_167_type 1434

#define _tmp_168_type 1435

#define _tmp_169_type 1436

#define _loop0_170_type 1437

#define _tmp_171_type 1438

#define _tmp_172_type 1439

#define _tmp_173_type 1440

#define _tmp_174_type 1441

#define _tmp_175_type 1442

static mod_ty file_rule(Parser *p);

static mod_ty interactive_rule(Parser *p);

static mod_ty eval_rule(Parser *p);

static mod_ty func_type_rule(Parser *p);

static asdl_stmt_seq* statements_rule(Parser *p);

static asdl_stmt_seq* statement_rule(Parser *p);

static asdl_stmt_seq* single_compound_stmt_rule(Parser *p);

static asdl_stmt_seq* statement_newline_rule(Parser *p);

static asdl_stmt_seq* simple_stmts_rule(Parser *p);

static stmt_ty simple_stmt_rule(Parser *p);

static stmt_ty compound_stmt_rule(Parser *p);

static stmt_ty assignment_rule(Parser *p);

static expr_ty annotated_rhs_rule(Parser *p);

static AugOperator* augassign_rule(Parser *p);

static stmt_ty return_stmt_rule(Parser *p);

static stmt_ty raise_stmt_rule(Parser *p);

static stmt_ty pass_stmt_rule(Parser *p);

static stmt_ty break_stmt_rule(Parser *p);

static stmt_ty continue_stmt_rule(Parser *p);

static stmt_ty global_stmt_rule(Parser *p);

static stmt_ty nonlocal_stmt_rule(Parser *p);

static stmt_ty del_stmt_rule(Parser *p);

static stmt_ty yield_stmt_rule(Parser *p);

static stmt_ty assert_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_alias_seq* import_from_targets_rule(Parser *p);

static asdl_alias_seq* import_from_as_names_rule(Parser *p);

static alias_ty import_from_as_name_rule(Parser *p);

static asdl_alias_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 asdl_stmt_seq* block_rule(Parser *p);

static asdl_expr_seq* decorators_rule(Parser *p);

static stmt_ty class_def_rule(Parser *p);

static stmt_ty class_def_raw_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_arg_seq* slash_no_default_rule(Parser *p);

static SlashWithDefault* slash_with_default_rule(Parser *p);

static StarEtc* star_etc_rule(Parser *p);

static arg_ty kwds_rule(Parser *p);

static arg_ty param_no_default_rule(Parser *p);

static arg_ty param_no_default_star_annotation_rule(Parser *p);

static NameDefaultPair* param_with_default_rule(Parser *p);

static NameDefaultPair* param_maybe_default_rule(Parser *p);

static arg_ty param_rule(Parser *p);

static arg_ty param_star_annotation_rule(Parser *p);

static expr_ty annotation_rule(Parser *p);

static expr_ty star_annotation_rule(Parser *p);

static expr_ty default_rule(Parser *p);

static stmt_ty if_stmt_rule(Parser *p);

static stmt_ty elif_stmt_rule(Parser *p);

static asdl_stmt_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 excepthandler_ty except_star_block_rule(Parser *p);

static asdl_stmt_seq* finally_block_rule(Parser *p);

static stmt_ty match_stmt_rule(Parser *p);

static expr_ty subject_expr_rule(Parser *p);

static match_case_ty case_block_rule(Parser *p);

static expr_ty guard_rule(Parser *p);

static pattern_ty patterns_rule(Parser *p);

static pattern_ty pattern_rule(Parser *p);

static pattern_ty as_pattern_rule(Parser *p);

static pattern_ty or_pattern_rule(Parser *p);

static pattern_ty closed_pattern_rule(Parser *p);

static pattern_ty literal_pattern_rule(Parser *p);

static expr_ty literal_expr_rule(Parser *p);

static expr_ty complex_number_rule(Parser *p);

static expr_ty signed_number_rule(Parser *p);

static expr_ty signed_real_number_rule(Parser *p);

static expr_ty real_number_rule(Parser *p);

static expr_ty imaginary_number_rule(Parser *p);

static pattern_ty capture_pattern_rule(Parser *p);

static expr_ty pattern_capture_target_rule(Parser *p);

static pattern_ty wildcard_pattern_rule(Parser *p);

static pattern_ty value_pattern_rule(Parser *p);

static expr_ty attr_rule(Parser *p);

static expr_ty name_or_attr_rule(Parser *p);

static pattern_ty group_pattern_rule(Parser *p);

static pattern_ty sequence_pattern_rule(Parser *p);

static asdl_seq* open_sequence_pattern_rule(Parser *p);

static asdl_seq* maybe_sequence_pattern_rule(Parser *p);

static pattern_ty maybe_star_pattern_rule(Parser *p);

static pattern_ty star_pattern_rule(Parser *p);

static pattern_ty mapping_pattern_rule(Parser *p);

static asdl_seq* items_pattern_rule(Parser *p);

static KeyPatternPair* key_value_pattern_rule(Parser *p);

static expr_ty double_star_pattern_rule(Parser *p);

static pattern_ty class_pattern_rule(Parser *p);

static asdl_pattern_seq* positional_patterns_rule(Parser *p);

static asdl_seq* keyword_patterns_rule(Parser *p);

static KeyPatternPair* keyword_pattern_rule(Parser *p);

static stmt_ty type_alias_rule(Parser *p);

static asdl_type_param_seq* type_params_rule(Parser *p);

static asdl_type_param_seq* type_param_seq_rule(Parser *p);

static type_param_ty type_param_rule(Parser *p);

static expr_ty type_param_bound_rule(Parser *p);

static expr_ty type_param_default_rule(Parser *p);

static expr_ty type_param_starred_default_rule(Parser *p);

static expr_ty expressions_rule(Parser *p);

static expr_ty expression_rule(Parser *p);

static expr_ty yield_expr_rule(Parser *p);

static expr_ty star_expressions_rule(Parser *p);

static expr_ty star_expression_rule(Parser *p);

static asdl_expr_seq* star_named_expressions_rule(Parser *p);

static expr_ty star_named_expression_rule(Parser *p);

static expr_ty assignment_expression_rule(Parser *p);

static expr_ty named_expression_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 group_rule(Parser *p);

static expr_ty lambdef_rule(Parser *p);

static arguments_ty lambda_params_rule(Parser *p);

static arguments_ty lambda_parameters_rule(Parser *p);

static asdl_arg_seq* lambda_slash_no_default_rule(Parser *p);

static SlashWithDefault* lambda_slash_with_default_rule(Parser *p);

static StarEtc* lambda_star_etc_rule(Parser *p);

static arg_ty lambda_kwds_rule(Parser *p);

static arg_ty lambda_param_no_default_rule(Parser *p);

static NameDefaultPair* lambda_param_with_default_rule(Parser *p);

static NameDefaultPair* lambda_param_maybe_default_rule(Parser *p);

static arg_ty lambda_param_rule(Parser *p);

static expr_ty fstring_middle_rule(Parser *p);

static expr_ty fstring_replacement_field_rule(Parser *p);

static ResultTokenWithMetadata* fstring_conversion_rule(Parser *p);

static ResultTokenWithMetadata* fstring_full_format_spec_rule(Parser *p);

static expr_ty fstring_format_spec_rule(Parser *p);

static expr_ty fstring_rule(Parser *p);

static expr_ty tstring_format_spec_replacement_field_rule(Parser *p);

static expr_ty tstring_format_spec_rule(Parser *p);

static ResultTokenWithMetadata* tstring_full_format_spec_rule(Parser *p);

static expr_ty tstring_replacement_field_rule(Parser *p);

static expr_ty tstring_middle_rule(Parser *p);

static expr_ty tstring_rule(Parser *p);

static expr_ty string_rule(Parser *p);

static expr_ty strings_rule(Parser *p);

static expr_ty list_rule(Parser *p);

static expr_ty tuple_rule(Parser *p);

static expr_ty set_rule(Parser *p);

static expr_ty dict_rule(Parser *p);

static asdl_seq* double_starred_kvpairs_rule(Parser *p);

static KeyValuePair* double_starred_kvpair_rule(Parser *p);

static KeyValuePair* kvpair_rule(Parser *p);

static asdl_comprehension_seq* for_if_clauses_rule(Parser *p);

static comprehension_ty for_if_clause_rule(Parser *p);

static expr_ty listcomp_rule(Parser *p);

static expr_ty setcomp_rule(Parser *p);

static expr_ty genexp_rule(Parser *p);

static expr_ty dictcomp_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_expr_seq* star_targets_list_seq_rule(Parser *p);

static asdl_expr_seq* star_targets_tuple_seq_rule(Parser *p);

static expr_ty star_target_rule(Parser *p);

static expr_ty target_with_star_atom_rule(Parser *p);

static expr_ty star_atom_rule(Parser *p);

static expr_ty single_target_rule(Parser *p);

static expr_ty single_subscript_attribute_target_rule(Parser *p);

static expr_ty t_primary_rule(Parser *p);

static void *t_lookahead_rule(Parser *p);

static asdl_expr_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_expr_seq* type_expressions_rule(Parser *p);

static Token* func_type_comment_rule(Parser *p);

static void *invalid_arguments_rule(Parser *p);

static void *invalid_kwarg_rule(Parser *p);

static expr_ty expression_without_invalid_rule(Parser *p);

static void *invalid_legacy_expression_rule(Parser *p);

static void *invalid_type_param_rule(Parser *p);

static void *invalid_expression_rule(Parser *p);

static void *invalid_named_expression_rule(Parser *p);

static void *invalid_assignment_rule(Parser *p);

static expr_ty invalid_ann_assign_target_rule(Parser *p);

static void *invalid_raise_stmt_rule(Parser *p);

static void *invalid_del_stmt_rule(Parser *p);

static void *invalid_block_rule(Parser *p);

static void *invalid_comprehension_rule(Parser *p);

static void *invalid_dict_comprehension_rule(Parser *p);

static void *invalid_parameters_rule(Parser *p);

static void *invalid_default_rule(Parser *p);

static void *invalid_star_etc_rule(Parser *p);

static void *invalid_kwds_rule(Parser *p);

static void *invalid_parameters_helper_rule(Parser *p);

static void *invalid_lambda_parameters_rule(Parser *p);

static void *invalid_lambda_parameters_helper_rule(Parser *p);

static void *invalid_lambda_star_etc_rule(Parser *p);

static void *invalid_lambda_kwds_rule(Parser *p);

static void *invalid_double_type_comments_rule(Parser *p);

static void *invalid_with_item_rule(Parser *p);

static void *invalid_for_if_clause_rule(Parser *p);

static void *invalid_for_target_rule(Parser *p);

static void *invalid_group_rule(Parser *p);

static void *invalid_import_rule(Parser *p);

static void *invalid_dotted_as_name_rule(Parser *p);

static void *invalid_import_from_as_name_rule(Parser *p);

static void *invalid_import_from_targets_rule(Parser *p);

static void *invalid_with_stmt_rule(Parser *p);

static void *invalid_with_stmt_indent_rule(Parser *p);

static void *invalid_try_stmt_rule(Parser *p);

static void *invalid_except_stmt_rule(Parser *p);

static void *invalid_except_star_stmt_rule(Parser *p);

static void *invalid_finally_stmt_rule(Parser *p);

static void *invalid_except_stmt_indent_rule(Parser *p);

static void *invalid_except_star_stmt_indent_rule(Parser *p);

static void *invalid_match_stmt_rule(Parser *p);

static void *invalid_case_block_rule(Parser *p);

static void *invalid_as_pattern_rule(Parser *p);

static void *invalid_class_pattern_rule(Parser *p);

static asdl_pattern_seq* invalid_class_argument_pattern_rule(Parser *p);

static void *invalid_if_stmt_rule(Parser *p);

static void *invalid_elif_stmt_rule(Parser *p);

static void *invalid_else_stmt_rule(Parser *p);

static void *invalid_while_stmt_rule(Parser *p);

static void *invalid_for_stmt_rule(Parser *p);

static void *invalid_def_raw_rule(Parser *p);

static void *invalid_class_def_raw_rule(Parser *p);

static void *invalid_double_starred_kvpairs_rule(Parser *p);

static void *invalid_kvpair_rule(Parser *p);

static void *invalid_starred_expression_unpacking_rule(Parser *p);

static void *invalid_starred_expression_rule(Parser *p);

static void *invalid_fstring_replacement_field_rule(Parser *p);

static void *invalid_fstring_conversion_character_rule(Parser *p);

static void *invalid_tstring_replacement_field_rule(Parser *p);

static void *invalid_tstring_conversion_character_rule(Parser *p);

static void *invalid_arithmetic_rule(Parser *p);

static void *invalid_factor_rule(Parser *p);

static void *invalid_type_params_rule(Parser *p);

static asdl_seq *_loop0_1_rule(Parser *p);

static asdl_seq *_loop1_2_rule(Parser *p);

static asdl_seq *_loop0_3_rule(Parser *p);

static asdl_seq *_gather_4_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 asdl_seq *_loop1_12_rule(Parser *p);

static asdl_seq *_loop0_13_rule(Parser *p);

static asdl_seq *_gather_14_rule(Parser *p);

static void *_tmp_15_rule(Parser *p);

static void *_tmp_16_rule(Parser *p);

static asdl_seq *_loop0_17_rule(Parser *p);

static asdl_seq *_loop1_18_rule(Parser *p);

static asdl_seq *_loop0_19_rule(Parser *p);

static asdl_seq *_gather_20_rule(Parser *p);

static void *_tmp_21_rule(Parser *p);

static asdl_seq *_loop0_22_rule(Parser *p);

static asdl_seq *_gather_23_rule(Parser *p);

static asdl_seq *_loop1_24_rule(Parser *p);

static void *_tmp_25_rule(Parser *p);

static void *_tmp_26_rule(Parser *p);

static asdl_seq *_loop0_27_rule(Parser *p);

static asdl_seq *_loop0_28_rule(Parser *p);

static asdl_seq *_loop1_29_rule(Parser *p);

static asdl_seq *_loop1_30_rule(Parser *p);

static asdl_seq *_loop0_31_rule(Parser *p);

static asdl_seq *_loop1_32_rule(Parser *p);

static asdl_seq *_loop0_33_rule(Parser *p);

static asdl_seq *_gather_34_rule(Parser *p);

static void *_tmp_35_rule(Parser *p);

static asdl_seq *_loop1_36_rule(Parser *p);

static asdl_seq *_loop1_37_rule(Parser *p);

static asdl_seq *_loop1_38_rule(Parser *p);

static asdl_seq *_loop0_39_rule(Parser *p);

static asdl_seq *_gather_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 asdl_seq *_loop0_44_rule(Parser *p);

static asdl_seq *_gather_45_rule(Parser *p);

static asdl_seq *_loop0_46_rule(Parser *p);

static asdl_seq *_gather_47_rule(Parser *p);

static void *_tmp_48_rule(Parser *p);

static asdl_seq *_loop0_49_rule(Parser *p);

static asdl_seq *_gather_50_rule(Parser *p);

static asdl_seq *_loop0_51_rule(Parser *p);

static asdl_seq *_gather_52_rule(Parser *p);

static asdl_seq *_loop0_53_rule(Parser *p);

static asdl_seq *_gather_54_rule(Parser *p);

static asdl_seq *_loop1_55_rule(Parser *p);

static asdl_seq *_loop1_56_rule(Parser *p);

static asdl_seq *_loop0_57_rule(Parser *p);

static asdl_seq *_gather_58_rule(Parser *p);

static asdl_seq *_loop1_59_rule(Parser *p);

static asdl_seq *_loop1_60_rule(Parser *p);

static asdl_seq *_loop1_61_rule(Parser *p);

static void *_tmp_62_rule(Parser *p);

static asdl_seq *_loop0_63_rule(Parser *p);

static asdl_seq *_gather_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 asdl_seq *_loop0_70_rule(Parser *p);

static asdl_seq *_loop0_71_rule(Parser *p);

static asdl_seq *_loop1_72_rule(Parser *p);

static asdl_seq *_loop1_73_rule(Parser *p);

static asdl_seq *_loop0_74_rule(Parser *p);

static asdl_seq *_loop1_75_rule(Parser *p);

static asdl_seq *_loop0_76_rule(Parser *p);

static asdl_seq *_loop0_77_rule(Parser *p);

static asdl_seq *_loop0_78_rule(Parser *p);

static asdl_seq *_loop0_79_rule(Parser *p);

static asdl_seq *_loop1_80_rule(Parser *p);

static void *_tmp_81_rule(Parser *p);

static asdl_seq *_loop0_82_rule(Parser *p);

static asdl_seq *_gather_83_rule(Parser *p);

static asdl_seq *_loop1_84_rule(Parser *p);

static asdl_seq *_loop0_85_rule(Parser *p);

static void *_tmp_86_rule(Parser *p);

static asdl_seq *_loop0_87_rule(Parser *p);

static asdl_seq *_gather_88_rule(Parser *p);

static void *_tmp_89_rule(Parser *p);

static asdl_seq *_loop0_90_rule(Parser *p);

static asdl_seq *_gather_91_rule(Parser *p);

static asdl_seq *_loop0_92_rule(Parser *p);

static asdl_seq *_gather_93_rule(Parser *p);

static asdl_seq *_loop0_94_rule(Parser *p);

static asdl_seq *_loop0_95_rule(Parser *p);

static asdl_seq *_gather_96_rule(Parser *p);

static asdl_seq *_loop1_97_rule(Parser *p);

static void *_tmp_98_rule(Parser *p);

static asdl_seq *_loop0_99_rule(Parser *p);

static asdl_seq *_gather_100_rule(Parser *p);

static asdl_seq *_loop0_101_rule(Parser *p);

static asdl_seq *_gather_102_rule(Parser *p);

static void *_tmp_103_rule(Parser *p);

static void *_tmp_104_rule(Parser *p);

static asdl_seq *_loop0_105_rule(Parser *p);

static asdl_seq *_gather_106_rule(Parser *p);

static void *_tmp_107_rule(Parser *p);

static void *_tmp_108_rule(Parser *p);

static void *_tmp_109_rule(Parser *p);

static void *_tmp_110_rule(Parser *p);

static void *_tmp_111_rule(Parser *p);

static asdl_seq *_loop1_112_rule(Parser *p);

static void *_tmp_113_rule(Parser *p);

static void *_tmp_114_rule(Parser *p);

static void *_tmp_115_rule(Parser *p);

static void *_tmp_116_rule(Parser *p);

static void *_tmp_117_rule(Parser *p);

static asdl_seq *_loop0_118_rule(Parser *p);

static asdl_seq *_loop0_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 asdl_seq *_loop0_129_rule(Parser *p);

static asdl_seq *_gather_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 asdl_seq *_gather_136_rule(Parser *p);

static void *_tmp_137_rule(Parser *p);

static asdl_seq *_loop0_138_rule(Parser *p);

static asdl_seq *_gather_139_rule(Parser *p);

static asdl_seq *_loop0_140_rule(Parser *p);

static asdl_seq *_gather_141_rule(Parser *p);

static void *_tmp_142_rule(Parser *p);

static asdl_seq *_loop0_143_rule(Parser *p);

static void *_tmp_144_rule(Parser *p);

static void *_tmp_145_rule(Parser *p);

static void *_tmp_146_rule(Parser *p);

static void *_tmp_147_rule(Parser *p);

static void *_tmp_148_rule(Parser *p);

static void *_tmp_149_rule(Parser *p);

static void *_tmp_150_rule(Parser *p);

static void *_tmp_151_rule(Parser *p);

static void *_tmp_152_rule(Parser *p);

static void *_tmp_153_rule(Parser *p);

static void *_tmp_154_rule(Parser *p);

static void *_tmp_155_rule(Parser *p);

static void *_tmp_156_rule(Parser *p);

static void *_tmp_157_rule(Parser *p);

static void *_tmp_158_rule(Parser *p);

static void *_tmp_159_rule(Parser *p);

static void *_tmp_160_rule(Parser *p);

static void *_tmp_161_rule(Parser *p);

static void *_tmp_162_rule(Parser *p);

static void *_tmp_163_rule(Parser *p);

static void *_tmp_164_rule(Parser *p);

static void *_tmp_165_rule(Parser *p);

static void *_tmp_166_rule(Parser *p);

static void *_tmp_167_rule(Parser *p);

static void *_tmp_168_rule(Parser *p);

static void *_tmp_169_rule(Parser *p);

static asdl_seq *_loop0_170_rule(Parser *p);

static void *_tmp_171_rule(Parser *p);

static void *_tmp_172_rule(Parser *p);

static void *_tmp_173_rule(Parser *p);

static void *_tmp_174_rule(Parser *p);

static void *_tmp_175_rule(Parser *p);

// file: statements? $

static mod_ty

file_rule(Parser *p)

{

    if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {

        _Pypegen_stack_overflow(p);

    }

    if (p->error_indicator) {

        p->level--;

        return NULL;

    }

    mod_ty _res = NULL;

    int _mark = p->mark;

    { // statements? $

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> file[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statements? $"));

        void *a;

        Token * endmarker_var;

        if (

            (a = statements_rule(p), !p->error_indicator)  // statements?

            &&

            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'

        )

        {

            D(fprintf(stderr, "%*c+ file[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statements? $"));

            _res = _PyPegen_make_module ( p , a );

            if (_res == NULL && PyErr_Occurred()) {

                p->error_indicator = 1;

                p->level--;

                return NULL;

            }

            goto done;

        }

        p->mark = _mark;

        D(fprintf(stderr, "%*c%s file[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statements? $"));

    }

    _res = NULL;

  done:

    p->level--;

    return _res;

}

// interactive: statement_newline

static mod_ty

interactive_rule(Parser *p)

{

    if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {

        _Pypegen_stack_overflow(p);

    }

    if (p->error_indicator) {

        p->level--;

        return NULL;

    }

    mod_ty _res = NULL;

    int _mark = p->mark;

    { // statement_newline

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> interactive[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement_newline"));

        asdl_stmt_seq* a;

        if (

            (a = statement_newline_rule(p))  // statement_newline

        )

        {

            D(fprintf(stderr, "%*c+ interactive[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement_newline"));

            _res = _PyAST_Interactive ( a , p -> arena );

            if (_res == NULL && PyErr_Occurred()) {

                p->error_indicator = 1;

                p->level--;

                return NULL;

            }

            goto done;

        }

        p->mark = _mark;

        D(fprintf(stderr, "%*c%s interactive[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement_newline"));

    }

    _res = NULL;

  done:

    p->level--;

    return _res;

}

// eval: expressions NEWLINE* $

static mod_ty

eval_rule(Parser *p)

{

    if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {

        _Pypegen_stack_overflow(p);

    }

    if (p->error_indicator) {

        p->level--;

        return NULL;

    }

    mod_ty _res = NULL;

    int _mark = p->mark;

    { // expressions NEWLINE* $

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> eval[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $"));

        asdl_seq * _loop0_1_var;

        expr_ty a;

        Token * endmarker_var;

        if (

            (a = expressions_rule(p))  // expressions

            &&

            (_loop0_1_var = _loop0_1_rule(p))  // NEWLINE*

            &&

            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'

        )

        {

            D(fprintf(stderr, "%*c+ eval[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $"));

            _res = _PyAST_Expression ( a , p -> arena );

            if (_res == NULL && PyErr_Occurred()) {

                p->error_indicator = 1;

                p->level--;

                return NULL;

            }

            goto done;

        }

        p->mark = _mark;

        D(fprintf(stderr, "%*c%s eval[%d-%d]: %s failed!\n", p->level, ' ',