// @generated by pegen from invalid.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

#define invalid_arguments_type 1193

#define invalid_kwarg_type 1194

#define expression_without_invalid_type 1195

#define invalid_legacy_expression_type 1196

#define invalid_type_param_type 1197

#define invalid_expression_type 1198

#define invalid_if_expression_type 1199

#define invalid_named_expression_type 1200

#define invalid_assignment_type 1201

#define invalid_ann_assign_target_type 1202

#define invalid_raise_stmt_type 1203

#define invalid_del_stmt_type 1204

#define invalid_assert_stmt_type 1205

#define invalid_block_type 1206

#define invalid_comprehension_type 1207

#define invalid_parameters_type 1208

#define invalid_default_type 1209

#define invalid_star_etc_type 1210

#define invalid_kwds_type 1211

#define invalid_parameters_helper_type 1212

#define invalid_lambda_parameters_type 1213

#define invalid_lambda_parameters_helper_type 1214

#define invalid_lambda_star_etc_type 1215

#define invalid_lambda_kwds_type 1216

#define invalid_double_type_comments_type 1217

#define invalid_with_item_type 1218

#define invalid_for_if_clause_type 1219

#define invalid_for_target_type 1220

#define invalid_group_type 1221

#define invalid_import_type 1222

#define invalid_dotted_as_name_type 1223

#define invalid_import_from_as_name_type 1224

#define invalid_import_from_type 1225

#define invalid_import_from_targets_type 1226

#define invalid_with_stmt_type 1227

#define invalid_with_stmt_indent_type 1228

#define invalid_try_stmt_type 1229

#define invalid_except_stmt_type 1230

#define invalid_except_star_stmt_type 1231

#define invalid_finally_stmt_type 1232

#define invalid_except_stmt_indent_type 1233

#define invalid_except_star_stmt_indent_type 1234

#define invalid_match_stmt_type 1235

#define invalid_case_block_type 1236

#define invalid_as_pattern_type 1237

#define invalid_class_pattern_type 1238

#define invalid_mapping_pattern_type 1239

#define invalid_class_argument_pattern_type 1240

#define invalid_if_stmt_type 1241

#define invalid_elif_stmt_type 1242

#define invalid_else_stmt_type 1243

#define invalid_while_stmt_type 1244

#define invalid_for_stmt_type 1245

#define invalid_def_raw_type 1246

#define invalid_class_def_raw_type 1247

#define invalid_double_starred_kvpairs_type 1248

#define invalid_kvpair_unpacking_type 1249

#define invalid_kvpair_type 1250

#define invalid_starred_expression_unpacking_type 1251

#define invalid_starred_expression_unpacking_sequence_type 1252

#define invalid_starred_expression_type 1253

#define invalid_fstring_replacement_field_type 1254

#define invalid_fstring_conversion_character_type 1255

#define invalid_tstring_replacement_field_type 1256

#define invalid_tstring_conversion_character_type 1257

#define invalid_string_tstring_concat_type 1258

#define invalid_arithmetic_type 1259  // Left-recursive

#define invalid_factor_type 1260

#define invalid_type_params_type 1261

#define invalid_bitwise_and_type 1262  // Left-recursive

#define invalid_bitwise_or_type 1263  // Left-recursive

#define invalid_noteq_type 1264

#define _tmp_106_type 1370

#define _loop0_107_type 1371

#define _gather_108_type 1372

#define _tmp_109_type 1373

#define _tmp_110_type 1374

#define _tmp_111_type 1375

#define _tmp_112_type 1376

#define _loop1_113_type 1377

#define _tmp_114_type 1378

#define _tmp_115_type 1379

#define _tmp_116_type 1380

#define _tmp_117_type 1381

#define _tmp_118_type 1382

#define _loop0_119_type 1383

#define _loop0_120_type 1384

#define _tmp_121_type 1385

#define _tmp_122_type 1386

#define _loop0_123_type 1387

#define _loop0_124_type 1388

#define _loop1_125_type 1389

#define _tmp_126_type 1390

#define _loop1_127_type 1391

#define _tmp_128_type 1392

#define _tmp_129_type 1393

#define _tmp_130_type 1394

#define _tmp_131_type 1395

#define _loop1_132_type 1396

#define _tmp_133_type 1397

#define _loop0_134_type 1398

#define _loop0_135_type 1399

#define _loop0_136_type 1400

#define _gather_137_type 1401

#define _tmp_138_type 1402

#define _loop1_139_type 1403

#define _loop1_140_type 1404

#define _tmp_141_type 1405

#define _tmp_142_type 1406

#define _tmp_143_type 1407

#define _tmp_144_type 1408

#define _loop0_145_type 1409

#define _gather_146_type 1410

#define _tmp_147_type 1411

#define _loop0_148_type 1412

#define _loop0_149_type 1413

#define _gather_150_type 1414

#define _loop0_151_type 1415

#define _gather_152_type 1416

#define _tmp_153_type 1417

#define _loop0_154_type 1418

#define _loop1_155_type 1419

#define _tmp_156_type 1420

#define _loop1_157_type 1421

#define _tmp_158_type 1422

#define _tmp_159_type 1423

#define _tmp_160_type 1424

#define _tmp_161_type 1425

#define _tmp_162_type 1426

#define _tmp_163_type 1427

#define _loop0_164_type 1428

#define _gather_165_type 1429

#define _tmp_166_type 1430

#define _tmp_167_type 1431

#define _tmp_168_type 1432

#define _tmp_169_type 1433

#define _tmp_170_type 1434

#define _tmp_171_type 1435

#define _loop0_172_type 1436

#define _loop1_173_type 1437

#define _loop1_174_type 1438

#define _tmp_175_type 1439

#define _tmp_176_type 1440

#define _tmp_177_type 1441

#define _tmp_189_type 1453

#define _tmp_190_type 1454

#define _tmp_191_type 1455

#define _tmp_192_type 1456

#define _tmp_193_type 1457

#define _tmp_194_type 1458

#define _loop0_195_type 1459

#define _tmp_196_type 1460

#define _tmp_197_type 1461

#define _tmp_198_type 1462

#define _tmp_199_type 1463

#define _loop0_201_type 1465

#define _gather_202_type 1466

#define _tmp_203_type 1467

#define _tmp_204_type 1468

#define _tmp_205_type 1469

#define _tmp_206_type 1470

// 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 expr_ty expression_without_invalid_rule(Parser *p);

static expr_ty invalid_ann_assign_target_rule(Parser *p);

static void *invalid_parameters_helper_rule(Parser *p);

static void *invalid_lambda_parameters_helper_rule(Parser *p);

static asdl_pattern_seq* invalid_class_argument_pattern_rule(Parser *p);

static void *invalid_kvpair_unpacking_rule(Parser *p);

static void *invalid_kvpair_rule(Parser *p);

static void *invalid_fstring_conversion_character_rule(Parser *p);

static void *invalid_tstring_conversion_character_rule(Parser *p);

static void *_tmp_106_rule(Parser *p);

static asdl_seq *_loop0_107_rule(Parser *p);

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

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

static asdl_seq *_loop0_119_rule(Parser *p);

static asdl_seq *_loop0_120_rule(Parser *p);

static void *_tmp_121_rule(Parser *p);

static void *_tmp_122_rule(Parser *p);

static asdl_seq *_loop0_123_rule(Parser *p);

static asdl_seq *_loop0_124_rule(Parser *p);

static asdl_seq *_loop1_125_rule(Parser *p);

static void *_tmp_126_rule(Parser *p);

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

static void *_tmp_133_rule(Parser *p);

static asdl_seq *_loop0_134_rule(Parser *p);

static asdl_seq *_loop0_135_rule(Parser *p);

static asdl_seq *_loop0_136_rule(Parser *p);

static asdl_seq *_gather_137_rule(Parser *p);

static void *_tmp_138_rule(Parser *p);

static asdl_seq *_loop1_139_rule(Parser *p);

static asdl_seq *_loop1_140_rule(Parser *p);

static void *_tmp_141_rule(Parser *p);

static void *_tmp_142_rule(Parser *p);

static void *_tmp_143_rule(Parser *p);

static void *_tmp_144_rule(Parser *p);

static asdl_seq *_loop0_145_rule(Parser *p);

static asdl_seq *_gather_146_rule(Parser *p);

static void *_tmp_147_rule(Parser *p);

static asdl_seq *_loop0_148_rule(Parser *p);

static asdl_seq *_loop0_149_rule(Parser *p);

static asdl_seq *_gather_150_rule(Parser *p);

static asdl_seq *_loop0_151_rule(Parser *p);

static asdl_seq *_gather_152_rule(Parser *p);

static void *_tmp_153_rule(Parser *p);

static asdl_seq *_loop0_154_rule(Parser *p);

static asdl_seq *_loop1_155_rule(Parser *p);

static void *_tmp_156_rule(Parser *p);

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

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

static void *_tmp_171_rule(Parser *p);

static asdl_seq *_loop0_172_rule(Parser *p);

static asdl_seq *_loop1_173_rule(Parser *p);

static asdl_seq *_loop1_174_rule(Parser *p);

static void *_tmp_175_rule(Parser *p);

static void *_tmp_176_rule(Parser *p);

static void *_tmp_177_rule(Parser *p);

static void *_tmp_189_rule(Parser *p);

static void *_tmp_190_rule(Parser *p);

static void *_tmp_191_rule(Parser *p);

static void *_tmp_192_rule(Parser *p);

static void *_tmp_193_rule(Parser *p);

static void *_tmp_194_rule(Parser *p);

static asdl_seq *_loop0_195_rule(Parser *p);

static void *_tmp_196_rule(Parser *p);

static void *_tmp_197_rule(Parser *p);

static void *_tmp_198_rule(Parser *p);

static void *_tmp_199_rule(Parser *p);

static asdl_seq *_loop0_201_rule(Parser *p);

static asdl_seq *_gather_202_rule(Parser *p);

static void *_tmp_203_rule(Parser *p);

static void *_tmp_204_rule(Parser *p);

static void *_tmp_205_rule(Parser *p);

static void *_tmp_206_rule(Parser *p);

// invalid_arguments:

//     | ((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+

//     | expression for_if_clauses ',' [args | expression for_if_clauses]

//     | NAME '=' expression for_if_clauses

//     | [(args ',')] NAME '=' &(',' | ')')

//     | args for_if_clauses

//     | args ',' expression for_if_clauses

//     | args ',' args

Py_LOCAL_SYMBOL void *

invalid_arguments_rule(Parser *p)

{

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

        _Pypegen_stack_overflow(p);

    }

    if (p->error_indicator) {

        p->level--;

        return NULL;

    }

    void * _res = NULL;

    int _mark = p->mark;

    { // ((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+"));

        asdl_seq * _gather_108_var;

        void *_tmp_106_var;

        Token * a;

        if (

            (_tmp_106_var = _tmp_106_rule(p))  // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs

            &&

            (a = _PyPegen_expect_token(p, 12))  // token=','

            &&

            (_gather_108_var = _gather_108_rule(p))  // ','.(starred_expression !'=')+

        )

        {

            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+"));

            _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "iterable argument unpacking follows keyword argument unpacking" );

            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 invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+"));

    }

    { // expression for_if_clauses ',' [args | expression for_if_clauses]

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]"));

        Token * _literal;

        void *_opt_var;

        UNUSED(_opt_var); // Silence compiler warnings

        expr_ty a;

        asdl_comprehension_seq* b;

        if (

            (a = expression_rule(p))  // expression

            &&

            (b = for_if_clauses_rule(p))  // for_if_clauses

            &&

            (_literal = _PyPegen_expect_token(p, 12))  // token=','

            &&

            (_opt_var = _tmp_109_rule(p), !p->error_indicator)  // [args | expression for_if_clauses]

        )

        {

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

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" );

            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 invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]"));

    }

    { // NAME '=' expression for_if_clauses

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses"));

        expr_ty a;

        Token * b;

        expr_ty expression_var;

        asdl_comprehension_seq* for_if_clauses_var;

        if (

            (a = _PyPegen_name_token(p))  // NAME

            &&

            (b = _PyPegen_expect_token(p, 22))  // token='='

            &&

            (expression_var = expression_rule(p))  // expression

            &&

            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses

        )

        {

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

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" );

            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 invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses"));

    }

    { // [(args ',')] NAME '=' &(',' | ')')

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')"));

        void *_opt_var;

        UNUSED(_opt_var); // Silence compiler warnings

        expr_ty a;

        Token * b;

        if (

            (_opt_var = _tmp_110_rule(p), !p->error_indicator)  // [(args ',')]

            &&

            (a = _PyPegen_name_token(p))  // NAME

            &&

            (b = _PyPegen_expect_token(p, 22))  // token='='

            &&

            _PyPegen_lookahead(1, _tmp_111_rule, p)

        )

        {

            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')"));

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expected argument value expression" );

            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 invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')"));

    }

    { // args for_if_clauses

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

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

        expr_ty a;

        asdl_comprehension_seq* b;

        if (

            (a = args_rule(p))  // args

            &&

            (b = for_if_clauses_rule(p))  // for_if_clauses

        )

        {

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

            _res = _PyPegen_nonparen_genexp_in_call ( p , a , b );

            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 invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',

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

    }

    { // args ',' expression for_if_clauses

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

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

        Token * _literal;

        expr_ty a;

        expr_ty args_var;

        asdl_comprehension_seq* b;

        if (

            (args_var = args_rule(p))  // args

            &&

            (_literal = _PyPegen_expect_token(p, 12))  // token=','

            &&

            (a = expression_rule(p))  // expression

            &&

            (b = for_if_clauses_rule(p))  // for_if_clauses

        )

        {

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

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" );

            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 invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' expression for_if_clauses"));

    }

    { // args ',' args

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

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

        Token * _literal;

        expr_ty a;

        expr_ty args_var;

        if (

            (a = args_rule(p))  // args

            &&

            (_literal = _PyPegen_expect_token(p, 12))  // token=','

            &&

            (args_var = args_rule(p))  // args

        )

        {

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

            _res = _PyPegen_arguments_parsing_error ( 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 invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',

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

    }

    _res = NULL;

  done:

    p->level--;

    return _res;

}

// invalid_kwarg:

//     | 'True' '='

//     | 'False' '='

//     | 'None' '='

//     | NAME '=' expression for_if_clauses

//     | !(NAME '=') expression '='

//     | '**' expression '=' expression

Py_LOCAL_SYMBOL void *

invalid_kwarg_rule(Parser *p)

{

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

        _Pypegen_stack_overflow(p);

    }

    if (p->error_indicator) {

        p->level--;

        return NULL;

    }

    void * _res = NULL;

    int _mark = p->mark;

    { // 'True' '='

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

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

        Token * a;

        Token * b;

        if (

            (a = _PyPegen_expect_token(p, 527))  // token='True'

            &&

            (b = _PyPegen_expect_token(p, 22))  // token='='

        )

        {

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

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to True" );

            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 invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True' '='"));

    }

    { // 'False' '='

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

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

        Token * a;

        Token * b;

        if (

            (a = _PyPegen_expect_token(p, 528))  // token='False'

            &&

            (b = _PyPegen_expect_token(p, 22))  // token='='

        )

        {

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

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to False" );

            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 invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False' '='"));

    }

    { // 'None' '='

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

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

        Token * a;

        Token * b;

        if (

            (a = _PyPegen_expect_token(p, 526))  // token='None'

            &&

            (b = _PyPegen_expect_token(p, 22))  // token='='

        )

        {

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

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to None" );

            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 invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None' '='"));

    }

    { // NAME '=' expression for_if_clauses

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses"));

        expr_ty a;

        Token * b;

        expr_ty expression_var;

        asdl_comprehension_seq* for_if_clauses_var;

        if (

            (a = _PyPegen_name_token(p))  // NAME

            &&

            (b = _PyPegen_expect_token(p, 22))  // token='='

            &&

            (expression_var = expression_rule(p))  // expression

            &&

            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses

        )

        {

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

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" );

            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 invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses"));

    }

    { // !(NAME '=') expression '='

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='"));

        expr_ty a;

        Token * b;

        if (

            _PyPegen_lookahead(0, _tmp_112_rule, p)

            &&

            (a = expression_rule(p))  // expression

            &&

            (b = _PyPegen_expect_token(p, 22))  // token='='

        )

        {

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

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expression cannot contain assignment, perhaps you meant \"==\"?" );

            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 invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME '=') expression '='"));

    }

    { // '**' expression '=' expression

        if (p->error_indicator) {

            p->level--;

            return NULL;

        }

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

        Token * _literal;

        Token * a;

        expr_ty b;

        expr_ty expression_var;

        if (

            (a = _PyPegen_expect_token(p, 35))  // token='**'

            &&

            (expression_var = expression_rule(p))  // expression

            &&

            (_literal = _PyPegen_expect_token(p, 22))  // token='='

            &&

            (b = expression_rule(p))  // expression

        )

        {

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

            _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to keyword argument unpacking" );

            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 invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',

                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression '=' expression"));

    }

    _res = NULL;

  done:

    p->level--;

    return _res;

}

// expression_without_invalid:

//     | disjunction 'if' disjunction 'else' expression

//     | disjunction

//     | lambdef

static expr_ty

expression_without_invalid_rule(Parser *p)

{

    int _prev_call_invalid = p->call_invalid_rules;

    p->call_invalid_rules = 0;

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

        _Pypegen_stack_overflow(p);

    }

    if (p->error_indicator) {

        p->call_invalid_rules = _prev_call_invalid;

        p->level--;

        return NULL;

    }

    expr_ty _res = NULL;

    int _mark = p->mark;

    expr_ty _prefix_11_result = NULL;

    int _prefix_11_end = 0, _prefix_11_valid = 0;

    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {

        p->error_indicator = 1;

        p->call_invalid_rules = _prev_call_invalid;

        p->level--;

        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

        if (p->error_indicator) {

            p->call_invalid_rules = _prev_call_invalid;

            p->level--;

            return NULL;

        }

        D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));

        Token * _keyword;

        Token * _keyword_1;

        expr_ty a;

        expr_ty b;

        expr_ty c;

        if (

            (a = ((!p->call_invalid_rules && _prefix_11_valid) ? (p->mark = _prefix_11_end, _prefix_11_result) : (_prefix_11_result = disjunction_rule(p), _prefix_11_end = p->mark, _prefix_11_valid = 1, _prefix_11_result)))  // disjunction

            &&

            (_keyword = _PyPegen_expect_token(p, 514))  // token='if'

            &&

            (b = disjunction_rule(p))  // disjunction

            &&

            (_keyword_1 = _PyPegen_expect_token(p, 522))  // token='else'

            &&

            (c = expression_rule(p))  // expression

        )