// @generated by pegen from python.gram

#include "pegen.h"

#include "pycore_ceval.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", 514},

        {"as", 520},

        {"in", 523},

        {"or", 529},

        {"is", 532},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"del", 505},

        {"def", 512},

        {"for", 517},

        {"try", 518},

        {"and", 530},

        {"not", 531},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"from", 501},

        {"pass", 504},

        {"with", 516},

        {"elif", 521},

        {"else", 522},

        {"None", 526},

        {"True", 527},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"raise", 503},

        {"yield", 506},

        {"break", 508},

        {"async", 513},

        {"class", 515},

        {"while", 519},

        {"False", 528},

        {"await", 533},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"import", 500},

        {"return", 502},

        {"assert", 507},

        {"global", 510},

        {"except", 524},

        {"lambda", 534},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"finally", 525},

        {NULL, -1},

    },

    (KeywordToken[]) {

        {"continue", 509},

        {"nonlocal", 511},

        {NULL, -1},

    },

};

static char *soft_keywords[] = {

    "_",

    "case",

    "lazy",

    "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 if_expression_type 1110

#define yield_expr_type 1111

#define star_expressions_type 1112

#define star_expression_type 1113

#define star_named_expressions_type 1114

#define star_named_expression_type 1115

#define assignment_expression_type 1116

#define named_expression_type 1117

#define disjunction_type 1118

#define conjunction_type 1119

#define inversion_type 1120

#define comparison_type 1121

#define compare_op_bitwise_or_pair_type 1122

#define bitwise_or_type 1123  // Left-recursive

#define bitwise_xor_type 1124  // Left-recursive

#define bitwise_and_type 1125  // Left-recursive

#define shift_expr_type 1126  // Left-recursive

#define sum_type 1127  // Left-recursive

#define term_type 1128  // Left-recursive

#define factor_type 1129

#define power_type 1130

#define await_primary_type 1131

#define primary_type 1132  // Left-recursive

#define slices_type 1133

#define slice_type 1134

#define atom_type 1135

#define group_type 1136

#define lambdef_type 1137

#define lambda_params_type 1138

#define lambda_parameters_type 1139

#define lambda_slash_no_default_type 1140

#define lambda_slash_with_default_type 1141

#define lambda_star_etc_type 1142

#define lambda_kwds_type 1143

#define lambda_param_no_default_type 1144

#define lambda_param_with_default_type 1145

#define lambda_param_maybe_default_type 1146

#define lambda_param_type 1147

#define fstring_middle_type 1148

#define fstring_replacement_field_type 1149

#define fstring_conversion_type 1150

#define fstring_full_format_spec_type 1151

#define fstring_format_spec_type 1152

#define fstring_type 1153

#define tstring_format_spec_replacement_field_type 1154

#define tstring_format_spec_type 1155

#define tstring_full_format_spec_type 1156

#define tstring_replacement_field_type 1157

#define tstring_middle_type 1158

#define tstring_type 1159

#define string_type 1160

#define strings_type 1161

#define display_items_type 1162

#define display_item_type 1163

#define list_type 1164

#define tuple_type 1165

#define set_type 1166

#define dict_type 1167

#define double_starred_kvpairs_type 1168

#define double_starred_kvpair_type 1169

#define kvpair_type 1170

#define for_if_clauses_type 1171

#define for_if_clause_type 1172

#define listcomp_type 1173

#define setcomp_type 1174

#define genexp_type 1175

#define dictcomp_type 1176

#define arguments_type 1177

#define args_type 1178

#define kwargs_type 1179

#define starred_expression_type 1180

#define kwarg_or_starred_type 1181

#define kwarg_or_double_starred_type 1182

#define star_targets_type 1183

#define star_target_type 1184

#define target_type 1185

#define single_target_type 1186

#define attribute_or_subscript_target_type 1187

#define target_value_type 1188

#define del_targets_type 1189

#define del_target_type 1190

#define type_expressions_type 1191

#define func_type_comment_type 1192

#define _loop0_1_type 1265

#define _loop1_2_type 1266

#define _loop0_3_type 1267

#define _gather_4_type 1268

#define _tmp_5_type 1269

#define _tmp_6_type 1270

#define _tmp_7_type 1271

#define _tmp_8_type 1272

#define _tmp_9_type 1273

#define _tmp_10_type 1274

#define _tmp_11_type 1275

#define _loop1_12_type 1276

#define _loop0_13_type 1277

#define _gather_14_type 1278

#define _tmp_15_type 1279

#define _tmp_16_type 1280

#define _loop0_17_type 1281

#define _loop1_18_type 1282

#define _loop0_19_type 1283

#define _gather_20_type 1284

#define _tmp_21_type 1285

#define _loop0_22_type 1286

#define _gather_23_type 1287

#define _loop1_24_type 1288

#define _tmp_25_type 1289

#define _tmp_26_type 1290

#define _loop0_27_type 1291

#define _loop0_28_type 1292

#define _loop1_29_type 1293

#define _loop1_30_type 1294

#define _loop0_31_type 1295

#define _loop1_32_type 1296

#define _loop0_33_type 1297

#define _gather_34_type 1298

#define _tmp_35_type 1299

#define _loop1_36_type 1300

#define _loop1_37_type 1301

#define _loop1_38_type 1302

#define _loop0_39_type 1303

#define _gather_40_type 1304

#define _tmp_41_type 1305

#define _tmp_42_type 1306

#define _tmp_43_type 1307

#define _loop0_44_type 1308

#define _gather_45_type 1309

#define _loop0_46_type 1310

#define _gather_47_type 1311

#define _tmp_48_type 1312

#define _loop0_49_type 1313

#define _gather_50_type 1314

#define _loop0_51_type 1315

#define _gather_52_type 1316

#define _loop0_53_type 1317

#define _gather_54_type 1318

#define _loop1_55_type 1319

#define _loop1_56_type 1320

#define _loop0_57_type 1321

#define _gather_58_type 1322

#define _loop1_59_type 1323

#define _loop1_60_type 1324

#define _loop1_61_type 1325

#define _tmp_62_type 1326

#define _loop0_63_type 1327

#define _gather_64_type 1328

#define _tmp_65_type 1329

#define _tmp_66_type 1330

#define _tmp_67_type 1331

#define _tmp_68_type 1332

#define _tmp_69_type 1333

#define _loop0_70_type 1334

#define _loop0_71_type 1335

#define _loop1_72_type 1336

#define _loop1_73_type 1337

#define _loop0_74_type 1338

#define _loop1_75_type 1339

#define _loop0_76_type 1340

#define _loop0_77_type 1341

#define _loop0_78_type 1342

#define _loop0_79_type 1343

#define _loop1_80_type 1344

#define _loop1_81_type 1345

#define _loop0_82_type 1346

#define _gather_83_type 1347

#define _tmp_84_type 1348

#define _loop0_85_type 1349

#define _gather_86_type 1350

#define _loop1_87_type 1351

#define _loop0_88_type 1352

#define _tmp_89_type 1353

#define _loop0_90_type 1354

#define _gather_91_type 1355

#define _tmp_92_type 1356

#define _loop0_93_type 1357

#define _gather_94_type 1358

#define _tmp_95_type 1359

#define _loop0_96_type 1360

#define _gather_97_type 1361

#define _loop0_98_type 1362

#define _tmp_99_type 1363

#define _tmp_100_type 1364

#define _loop0_101_type 1365

#define _gather_102_type 1366

#define _loop0_103_type 1367

#define _gather_104_type 1368

#define _tmp_105_type 1369

#define _tmp_178_type 1442

#define _tmp_179_type 1443

#define _tmp_180_type 1444

#define _tmp_181_type 1445

#define _tmp_182_type 1446

#define _tmp_183_type 1447

#define _tmp_184_type 1448

#define _tmp_185_type 1449

#define _tmp_186_type 1450

#define _tmp_187_type 1451

#define _tmp_188_type 1452

#define _tmp_200_type 1464

// Rules shared between the C files of this parser

#define simple_stmt_rule _PyPegen_simple_stmt_rule

Py_LOCAL_SYMBOL stmt_ty simple_stmt_rule(Parser *p);

#define annotated_rhs_rule _PyPegen_annotated_rhs_rule

Py_LOCAL_SYMBOL expr_ty annotated_rhs_rule(Parser *p);

#define augassign_rule _PyPegen_augassign_rule

Py_LOCAL_SYMBOL AugOperator* augassign_rule(Parser *p);

#define pass_stmt_rule _PyPegen_pass_stmt_rule

Py_LOCAL_SYMBOL stmt_ty pass_stmt_rule(Parser *p);

#define break_stmt_rule _PyPegen_break_stmt_rule

Py_LOCAL_SYMBOL stmt_ty break_stmt_rule(Parser *p);

#define continue_stmt_rule _PyPegen_continue_stmt_rule

Py_LOCAL_SYMBOL stmt_ty continue_stmt_rule(Parser *p);

#define import_from_targets_rule _PyPegen_import_from_targets_rule

Py_LOCAL_SYMBOL asdl_alias_seq* import_from_targets_rule(Parser *p);

#define import_from_as_names_rule _PyPegen_import_from_as_names_rule

Py_LOCAL_SYMBOL asdl_alias_seq* import_from_as_names_rule(Parser *p);

#define dotted_name_rule _PyPegen_dotted_name_rule

Py_LOCAL_SYMBOL expr_ty dotted_name_rule(Parser *p);

#define block_rule _PyPegen_block_rule

Py_LOCAL_SYMBOL asdl_stmt_seq* block_rule(Parser *p);

#define params_rule _PyPegen_params_rule

Py_LOCAL_SYMBOL arguments_ty params_rule(Parser *p);

#define slash_no_default_rule _PyPegen_slash_no_default_rule

Py_LOCAL_SYMBOL asdl_arg_seq* slash_no_default_rule(Parser *p);

#define slash_with_default_rule _PyPegen_slash_with_default_rule

Py_LOCAL_SYMBOL SlashWithDefault* slash_with_default_rule(Parser *p);

#define param_no_default_rule _PyPegen_param_no_default_rule

Py_LOCAL_SYMBOL arg_ty param_no_default_rule(Parser *p);

#define param_with_default_rule _PyPegen_param_with_default_rule

Py_LOCAL_SYMBOL NameDefaultPair* param_with_default_rule(Parser *p);

#define param_maybe_default_rule _PyPegen_param_maybe_default_rule

Py_LOCAL_SYMBOL NameDefaultPair* param_maybe_default_rule(Parser *p);

#define param_rule _PyPegen_param_rule

Py_LOCAL_SYMBOL arg_ty param_rule(Parser *p);

#define except_block_rule _PyPegen_except_block_rule

Py_LOCAL_SYMBOL excepthandler_ty except_block_rule(Parser *p);

#define except_star_block_rule _PyPegen_except_star_block_rule

Py_LOCAL_SYMBOL excepthandler_ty except_star_block_rule(Parser *p);

#define subject_expr_rule _PyPegen_subject_expr_rule

Py_LOCAL_SYMBOL expr_ty subject_expr_rule(Parser *p);

#define guard_rule _PyPegen_guard_rule

Py_LOCAL_SYMBOL expr_ty guard_rule(Parser *p);

#define patterns_rule _PyPegen_patterns_rule

Py_LOCAL_SYMBOL pattern_ty patterns_rule(Parser *p);

#define or_pattern_rule _PyPegen_or_pattern_rule

Py_LOCAL_SYMBOL pattern_ty or_pattern_rule(Parser *p);

#define name_or_attr_rule _PyPegen_name_or_attr_rule

Py_LOCAL_SYMBOL expr_ty name_or_attr_rule(Parser *p);

#define items_pattern_rule _PyPegen_items_pattern_rule

Py_LOCAL_SYMBOL asdl_seq* items_pattern_rule(Parser *p);

#define double_star_pattern_rule _PyPegen_double_star_pattern_rule

Py_LOCAL_SYMBOL expr_ty double_star_pattern_rule(Parser *p);

#define positional_patterns_rule _PyPegen_positional_patterns_rule

Py_LOCAL_SYMBOL asdl_pattern_seq* positional_patterns_rule(Parser *p);

#define keyword_patterns_rule _PyPegen_keyword_patterns_rule

Py_LOCAL_SYMBOL asdl_seq* keyword_patterns_rule(Parser *p);

#define type_params_rule _PyPegen_type_params_rule

Py_LOCAL_SYMBOL asdl_type_param_seq* type_params_rule(Parser *p);

#define expressions_rule _PyPegen_expressions_rule

Py_LOCAL_SYMBOL expr_ty expressions_rule(Parser *p);

#define expression_rule _PyPegen_expression_rule

Py_LOCAL_SYMBOL expr_ty expression_rule(Parser *p);

#define if_expression_rule _PyPegen_if_expression_rule

Py_LOCAL_SYMBOL expr_ty if_expression_rule(Parser *p);

#define yield_expr_rule _PyPegen_yield_expr_rule

Py_LOCAL_SYMBOL expr_ty yield_expr_rule(Parser *p);

#define star_expressions_rule _PyPegen_star_expressions_rule

Py_LOCAL_SYMBOL expr_ty star_expressions_rule(Parser *p);

#define star_named_expressions_rule _PyPegen_star_named_expressions_rule

Py_LOCAL_SYMBOL asdl_expr_seq* star_named_expressions_rule(Parser *p);

#define star_named_expression_rule _PyPegen_star_named_expression_rule

Py_LOCAL_SYMBOL expr_ty star_named_expression_rule(Parser *p);

#define assignment_expression_rule _PyPegen_assignment_expression_rule

Py_LOCAL_SYMBOL expr_ty assignment_expression_rule(Parser *p);

#define named_expression_rule _PyPegen_named_expression_rule

Py_LOCAL_SYMBOL expr_ty named_expression_rule(Parser *p);

#define disjunction_rule _PyPegen_disjunction_rule

Py_LOCAL_SYMBOL expr_ty disjunction_rule(Parser *p);

#define inversion_rule _PyPegen_inversion_rule

Py_LOCAL_SYMBOL expr_ty inversion_rule(Parser *p);

#define bitwise_or_rule _PyPegen_bitwise_or_rule

Py_LOCAL_SYMBOL expr_ty bitwise_or_rule(Parser *p);

#define bitwise_and_rule _PyPegen_bitwise_and_rule

Py_LOCAL_SYMBOL expr_ty bitwise_and_rule(Parser *p);

#define sum_rule _PyPegen_sum_rule

Py_LOCAL_SYMBOL expr_ty sum_rule(Parser *p);

#define factor_rule _PyPegen_factor_rule

Py_LOCAL_SYMBOL expr_ty factor_rule(Parser *p);

#define lambdef_rule _PyPegen_lambdef_rule

Py_LOCAL_SYMBOL expr_ty lambdef_rule(Parser *p);

#define lambda_params_rule _PyPegen_lambda_params_rule

Py_LOCAL_SYMBOL arguments_ty lambda_params_rule(Parser *p);

#define lambda_slash_no_default_rule _PyPegen_lambda_slash_no_default_rule

Py_LOCAL_SYMBOL asdl_arg_seq* lambda_slash_no_default_rule(Parser *p);

#define lambda_slash_with_default_rule _PyPegen_lambda_slash_with_default_rule

Py_LOCAL_SYMBOL SlashWithDefault* lambda_slash_with_default_rule(Parser *p);

#define lambda_param_no_default_rule _PyPegen_lambda_param_no_default_rule

Py_LOCAL_SYMBOL arg_ty lambda_param_no_default_rule(Parser *p);

#define lambda_param_with_default_rule _PyPegen_lambda_param_with_default_rule

Py_LOCAL_SYMBOL NameDefaultPair* lambda_param_with_default_rule(Parser *p);

#define lambda_param_maybe_default_rule _PyPegen_lambda_param_maybe_default_rule

Py_LOCAL_SYMBOL NameDefaultPair* lambda_param_maybe_default_rule(Parser *p);

#define lambda_param_rule _PyPegen_lambda_param_rule

Py_LOCAL_SYMBOL arg_ty lambda_param_rule(Parser *p);

#define fstring_format_spec_rule _PyPegen_fstring_format_spec_rule

Py_LOCAL_SYMBOL expr_ty fstring_format_spec_rule(Parser *p);

#define fstring_rule _PyPegen_fstring_rule

Py_LOCAL_SYMBOL expr_ty fstring_rule(Parser *p);

#define tstring_rule _PyPegen_tstring_rule

Py_LOCAL_SYMBOL expr_ty tstring_rule(Parser *p);

#define string_rule _PyPegen_string_rule

Py_LOCAL_SYMBOL expr_ty string_rule(Parser *p);

#define list_rule _PyPegen_list_rule

Py_LOCAL_SYMBOL expr_ty list_rule(Parser *p);

#define tuple_rule _PyPegen_tuple_rule

Py_LOCAL_SYMBOL expr_ty tuple_rule(Parser *p);

#define double_starred_kvpair_rule _PyPegen_double_starred_kvpair_rule

Py_LOCAL_SYMBOL KeyValuePair* double_starred_kvpair_rule(Parser *p);

#define for_if_clauses_rule _PyPegen_for_if_clauses_rule

Py_LOCAL_SYMBOL asdl_comprehension_seq* for_if_clauses_rule(Parser *p);

#define genexp_rule _PyPegen_genexp_rule

Py_LOCAL_SYMBOL expr_ty genexp_rule(Parser *p);

#define arguments_rule _PyPegen_arguments_rule

Py_LOCAL_SYMBOL expr_ty arguments_rule(Parser *p);

#define args_rule _PyPegen_args_rule

Py_LOCAL_SYMBOL expr_ty args_rule(Parser *p);

#define kwargs_rule _PyPegen_kwargs_rule

Py_LOCAL_SYMBOL asdl_seq* kwargs_rule(Parser *p);

#define starred_expression_rule _PyPegen_starred_expression_rule

Py_LOCAL_SYMBOL expr_ty starred_expression_rule(Parser *p);

#define star_targets_rule _PyPegen_star_targets_rule

Py_LOCAL_SYMBOL expr_ty star_targets_rule(Parser *p);

#define star_target_rule _PyPegen_star_target_rule

Py_LOCAL_SYMBOL expr_ty star_target_rule(Parser *p);

#define func_type_comment_rule _PyPegen_func_type_comment_rule

Py_LOCAL_SYMBOL Token* func_type_comment_rule(Parser *p);

#define invalid_arguments_rule _PyPegen_invalid_arguments_rule

Py_LOCAL_SYMBOL void *invalid_arguments_rule(Parser *p);

#define invalid_kwarg_rule _PyPegen_invalid_kwarg_rule

Py_LOCAL_SYMBOL void *invalid_kwarg_rule(Parser *p);

#define invalid_legacy_expression_rule _PyPegen_invalid_legacy_expression_rule

Py_LOCAL_SYMBOL void *invalid_legacy_expression_rule(Parser *p);

#define invalid_type_param_rule _PyPegen_invalid_type_param_rule

Py_LOCAL_SYMBOL void *invalid_type_param_rule(Parser *p);

#define invalid_expression_rule _PyPegen_invalid_expression_rule

Py_LOCAL_SYMBOL void *invalid_expression_rule(Parser *p);

#define invalid_if_expression_rule _PyPegen_invalid_if_expression_rule

Py_LOCAL_SYMBOL void *invalid_if_expression_rule(Parser *p);

#define invalid_named_expression_rule _PyPegen_invalid_named_expression_rule

Py_LOCAL_SYMBOL void *invalid_named_expression_rule(Parser *p);

#define invalid_assignment_rule _PyPegen_invalid_assignment_rule

Py_LOCAL_SYMBOL void *invalid_assignment_rule(Parser *p);

#define invalid_raise_stmt_rule _PyPegen_invalid_raise_stmt_rule

Py_LOCAL_SYMBOL void *invalid_raise_stmt_rule(Parser *p);

#define invalid_del_stmt_rule _PyPegen_invalid_del_stmt_rule

Py_LOCAL_SYMBOL void *invalid_del_stmt_rule(Parser *p);

#define invalid_assert_stmt_rule _PyPegen_invalid_assert_stmt_rule

Py_LOCAL_SYMBOL void *invalid_assert_stmt_rule(Parser *p);

#define invalid_block_rule _PyPegen_invalid_block_rule

Py_LOCAL_SYMBOL void *invalid_block_rule(Parser *p);

#define invalid_comprehension_rule _PyPegen_invalid_comprehension_rule

Py_LOCAL_SYMBOL void *invalid_comprehension_rule(Parser *p);

#define invalid_parameters_rule _PyPegen_invalid_parameters_rule

Py_LOCAL_SYMBOL void *invalid_parameters_rule(Parser *p);

#define invalid_default_rule _PyPegen_invalid_default_rule

Py_LOCAL_SYMBOL void *invalid_default_rule(Parser *p);

#define invalid_star_etc_rule _PyPegen_invalid_star_etc_rule

Py_LOCAL_SYMBOL void *invalid_star_etc_rule(Parser *p);

#define invalid_kwds_rule _PyPegen_invalid_kwds_rule

Py_LOCAL_SYMBOL void *invalid_kwds_rule(Parser *p);

#define invalid_lambda_parameters_rule _PyPegen_invalid_lambda_parameters_rule

Py_LOCAL_SYMBOL void *invalid_lambda_parameters_rule(Parser *p);

#define invalid_lambda_star_etc_rule _PyPegen_invalid_lambda_star_etc_rule

Py_LOCAL_SYMBOL void *invalid_lambda_star_etc_rule(Parser *p);

#define invalid_lambda_kwds_rule _PyPegen_invalid_lambda_kwds_rule

Py_LOCAL_SYMBOL void *invalid_lambda_kwds_rule(Parser *p);

#define invalid_double_type_comments_rule _PyPegen_invalid_double_type_comments_rule

Py_LOCAL_SYMBOL void *invalid_double_type_comments_rule(Parser *p);

#define invalid_with_item_rule _PyPegen_invalid_with_item_rule

Py_LOCAL_SYMBOL void *invalid_with_item_rule(Parser *p);

#define invalid_for_if_clause_rule _PyPegen_invalid_for_if_clause_rule

Py_LOCAL_SYMBOL void *invalid_for_if_clause_rule(Parser *p);

#define invalid_for_target_rule _PyPegen_invalid_for_target_rule

Py_LOCAL_SYMBOL void *invalid_for_target_rule(Parser *p);

#define invalid_group_rule _PyPegen_invalid_group_rule

Py_LOCAL_SYMBOL void *invalid_group_rule(Parser *p);

#define invalid_import_rule _PyPegen_invalid_import_rule

Py_LOCAL_SYMBOL void *invalid_import_rule(Parser *p);

#define invalid_dotted_as_name_rule _PyPegen_invalid_dotted_as_name_rule

Py_LOCAL_SYMBOL void *invalid_dotted_as_name_rule(Parser *p);

#define invalid_import_from_as_name_rule _PyPegen_invalid_import_from_as_name_rule

Py_LOCAL_SYMBOL void *invalid_import_from_as_name_rule(Parser *p);

#define invalid_import_from_rule _PyPegen_invalid_import_from_rule

Py_LOCAL_SYMBOL void *invalid_import_from_rule(Parser *p);

#define invalid_import_from_targets_rule _PyPegen_invalid_import_from_targets_rule

Py_LOCAL_SYMBOL void *invalid_import_from_targets_rule(Parser *p);

#define invalid_with_stmt_rule _PyPegen_invalid_with_stmt_rule

Py_LOCAL_SYMBOL void *invalid_with_stmt_rule(Parser *p);

#define invalid_with_stmt_indent_rule _PyPegen_invalid_with_stmt_indent_rule

Py_LOCAL_SYMBOL void *invalid_with_stmt_indent_rule(Parser *p);

#define invalid_try_stmt_rule _PyPegen_invalid_try_stmt_rule

Py_LOCAL_SYMBOL void *invalid_try_stmt_rule(Parser *p);

#define invalid_except_stmt_rule _PyPegen_invalid_except_stmt_rule

Py_LOCAL_SYMBOL void *invalid_except_stmt_rule(Parser *p);

#define invalid_except_star_stmt_rule _PyPegen_invalid_except_star_stmt_rule

Py_LOCAL_SYMBOL void *invalid_except_star_stmt_rule(Parser *p);

#define invalid_finally_stmt_rule _PyPegen_invalid_finally_stmt_rule

Py_LOCAL_SYMBOL void *invalid_finally_stmt_rule(Parser *p);

#define invalid_except_stmt_indent_rule _PyPegen_invalid_except_stmt_indent_rule

Py_LOCAL_SYMBOL void *invalid_except_stmt_indent_rule(Parser *p);

#define invalid_except_star_stmt_indent_rule _PyPegen_invalid_except_star_stmt_indent_rule

Py_LOCAL_SYMBOL void *invalid_except_star_stmt_indent_rule(Parser *p);

#define invalid_match_stmt_rule _PyPegen_invalid_match_stmt_rule

Py_LOCAL_SYMBOL void *invalid_match_stmt_rule(Parser *p);

#define invalid_case_block_rule _PyPegen_invalid_case_block_rule

Py_LOCAL_SYMBOL void *invalid_case_block_rule(Parser *p);

#define invalid_as_pattern_rule _PyPegen_invalid_as_pattern_rule

Py_LOCAL_SYMBOL void *invalid_as_pattern_rule(Parser *p);

#define invalid_class_pattern_rule _PyPegen_invalid_class_pattern_rule

Py_LOCAL_SYMBOL void *invalid_class_pattern_rule(Parser *p);

#define invalid_mapping_pattern_rule _PyPegen_invalid_mapping_pattern_rule

Py_LOCAL_SYMBOL void *invalid_mapping_pattern_rule(Parser *p);

#define invalid_if_stmt_rule _PyPegen_invalid_if_stmt_rule

Py_LOCAL_SYMBOL void *invalid_if_stmt_rule(Parser *p);

#define invalid_elif_stmt_rule _PyPegen_invalid_elif_stmt_rule

Py_LOCAL_SYMBOL void *invalid_elif_stmt_rule(Parser *p);

#define invalid_else_stmt_rule _PyPegen_invalid_else_stmt_rule

Py_LOCAL_SYMBOL void *invalid_else_stmt_rule(Parser *p);

#define invalid_while_stmt_rule _PyPegen_invalid_while_stmt_rule

Py_LOCAL_SYMBOL void *invalid_while_stmt_rule(Parser *p);

#define invalid_for_stmt_rule _PyPegen_invalid_for_stmt_rule

Py_LOCAL_SYMBOL void *invalid_for_stmt_rule(Parser *p);

#define invalid_def_raw_rule _PyPegen_invalid_def_raw_rule

Py_LOCAL_SYMBOL void *invalid_def_raw_rule(Parser *p);

#define invalid_class_def_raw_rule _PyPegen_invalid_class_def_raw_rule

Py_LOCAL_SYMBOL void *invalid_class_def_raw_rule(Parser *p);

#define invalid_double_starred_kvpairs_rule _PyPegen_invalid_double_starred_kvpairs_rule

Py_LOCAL_SYMBOL void *invalid_double_starred_kvpairs_rule(Parser *p);

#define invalid_starred_expression_unpacking_rule _PyPegen_invalid_starred_expression_unpacking_rule

Py_LOCAL_SYMBOL void *invalid_starred_expression_unpacking_rule(Parser *p);

#define invalid_starred_expression_unpacking_sequence_rule _PyPegen_invalid_starred_expression_unpacking_sequence_rule

Py_LOCAL_SYMBOL void *invalid_starred_expression_unpacking_sequence_rule(Parser *p);

#define invalid_starred_expression_rule _PyPegen_invalid_starred_expression_rule

Py_LOCAL_SYMBOL void *invalid_starred_expression_rule(Parser *p);

#define invalid_fstring_replacement_field_rule _PyPegen_invalid_fstring_replacement_field_rule

Py_LOCAL_SYMBOL void *invalid_fstring_replacement_field_rule(Parser *p);

#define invalid_tstring_replacement_field_rule _PyPegen_invalid_tstring_replacement_field_rule

Py_LOCAL_SYMBOL void *invalid_tstring_replacement_field_rule(Parser *p);

#define invalid_string_tstring_concat_rule _PyPegen_invalid_string_tstring_concat_rule

Py_LOCAL_SYMBOL void *invalid_string_tstring_concat_rule(Parser *p);

#define invalid_arithmetic_rule _PyPegen_invalid_arithmetic_rule

Py_LOCAL_SYMBOL void *invalid_arithmetic_rule(Parser *p);

#define invalid_factor_rule _PyPegen_invalid_factor_rule

Py_LOCAL_SYMBOL void *invalid_factor_rule(Parser *p);

#define invalid_type_params_rule _PyPegen_invalid_type_params_rule

Py_LOCAL_SYMBOL void *invalid_type_params_rule(Parser *p);

#define invalid_bitwise_and_rule _PyPegen_invalid_bitwise_and_rule

Py_LOCAL_SYMBOL void *invalid_bitwise_and_rule(Parser *p);

#define invalid_bitwise_or_rule _PyPegen_invalid_bitwise_or_rule

Py_LOCAL_SYMBOL void *invalid_bitwise_or_rule(Parser *p);

#define invalid_noteq_rule _PyPegen_invalid_noteq_rule

Py_LOCAL_SYMBOL void *invalid_noteq_rule(Parser *p);

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 compound_stmt_rule(Parser *p);

static stmt_ty assignment_rule(Parser *p);

static stmt_ty return_stmt_rule(Parser *p);

static stmt_ty raise_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 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 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 parameters_rule(Parser *p);

static StarEtc* star_etc_rule(Parser *p);

static arg_ty kwds_rule(Parser *p);

static arg_ty param_no_default_star_annotation_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 asdl_stmt_seq* finally_block_rule(Parser *p);

static stmt_ty match_stmt_rule(Parser *p);

static match_case_ty case_block_rule(Parser *p);

static pattern_ty pattern_rule(Parser *p);

static pattern_ty as_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 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 KeyPatternPair* key_value_pattern_rule(Parser *p);

static pattern_ty class_pattern_rule(Parser *p);

static KeyPatternPair* keyword_pattern_rule(Parser *p);

static stmt_ty type_alias_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 star_expression_rule(Parser *p);

static expr_ty conjunction_rule(Parser *p);

static expr_ty comparison_rule(Parser *p);

static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p);

static expr_ty bitwise_xor_rule(Parser *p);

static expr_ty shift_expr_rule(Parser *p);

static expr_ty term_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 arguments_ty lambda_parameters_rule(Parser *p);

static StarEtc* lambda_star_etc_rule(Parser *p);

static arg_ty lambda_kwds_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 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 strings_rule(Parser *p);

static asdl_expr_seq* display_items_rule(Parser *p);

static expr_ty display_item_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* kvpair_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 dictcomp_rule(Parser *p);

static KeywordOrStarred* kwarg_or_starred_rule(Parser *p);

static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p);

static expr_ty target_rule(Parser *p);

static expr_ty single_target_rule(Parser *p);

static expr_ty attribute_or_subscript_target_rule(Parser *p);

static expr_ty target_value_rule(Parser *p);

static asdl_expr_seq* del_targets_rule(Parser *p);

static expr_ty del_target_rule(Parser *p);

static asdl_expr_seq* type_expressions_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 asdl_seq *_loop1_81_rule(Parser *p);

static asdl_seq *_loop0_82_rule(Parser *p);

static asdl_seq *_gather_83_rule(Parser *p);

static void *_tmp_84_rule(Parser *p);

static asdl_seq *_loop0_85_rule(Parser *p);

static asdl_seq *_gather_86_rule(Parser *p);

static asdl_seq *_loop1_87_rule(Parser *p);

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

static asdl_seq *_loop0_93_rule(Parser *p);

static asdl_seq *_gather_94_rule(Parser *p);

static void *_tmp_95_rule(Parser *p);

static asdl_seq *_loop0_96_rule(Parser *p);

static asdl_seq *_gather_97_rule(Parser *p);

static asdl_seq *_loop0_98_rule(Parser *p);

static void *_tmp_99_rule(Parser *p);

static void *_tmp_100_rule(Parser *p);

static asdl_seq *_loop0_101_rule(Parser *p);

static asdl_seq *_gather_102_rule(Parser *p);

static asdl_seq *_loop0_103_rule(Parser *p);

static asdl_seq *_gather_104_rule(Parser *p);

static void *_tmp_105_rule(Parser *p);

static void *_tmp_178_rule(Parser *p);

static void *_tmp_179_rule(Parser *p);

static void *_tmp_180_rule(Parser *p);

static void *_tmp_181_rule(Parser *p);

static void *_tmp_182_rule(Parser *p);

static void *_tmp_183_rule(Parser *p);

static void *_tmp_184_rule(Parser *p);

static void *_tmp_185_rule(Parser *p);

static void *_tmp_186_rule(Parser *p);

static void *_tmp_187_rule(Parser *p);

static void *_tmp_188_rule(Parser *p);

static void *_tmp_200_rule(Parser *p);

// file: statements? $

static mod_ty

file_rule(Parser *p)

{

    if (p->level++ == MAXSTACK || _PyPegen_stack_exhausted(p)) {

        _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 || p->error_indicator) && 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 || _PyPegen_stack_exhausted(p)) {

        _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 || p->error_indicator) && 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 || _PyPegen_stack_exhausted(p)) {

        _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 || p->error_indicator) && 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, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions NEWLINE* $"));

    }

    _res = NULL;

  done:

    p->level--;

    return _res;

}

// func_type: '(' type_expressions? ')' '->' expression NEWLINE* $

static mod_ty

func_type_rule(Parser *p)

{

    if (p->level++ == MAXSTACK || _PyPegen_stack_exhausted(p)) {

        _Pypegen_stack_overflow(p);

    }

    if (p->error_indicator) {

        p->level--;

        return NULL;

    }

    mod_ty _res = NULL;

    int _mark = p->mark;

    { // '(' type_expressions? ')' '->' expression NEWLINE* $

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

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

        Token * _literal;

        Token * _literal_1;

        Token * _literal_2;

        asdl_seq * _loop0_1_var;

        void *a;

        expr_ty b;

        Token * endmarker_var;

        if (