cpython/Parser/parser.c

// @generated by pegen from python.gram
#include "pegen.h"

#if defined(Py_DEBUG) && defined(Py_BUILD_CORE)
#define D
#else
#define D(x)
#endif

#ifdef __wasi__
#  ifdef Py_DEBUG
#define MAXSTACK
#  else
#define MAXSTACK
#  endif
#else
#define MAXSTACK
#endif
static const int n_keyword_lists =;
static KeywordToken *reserved_keywords[] =;
static char *soft_keywords[] =;
#define file_type
#define interactive_type
#define eval_type
#define func_type_type
#define statements_type
#define statement_type
#define statement_newline_type
#define simple_stmts_type
#define simple_stmt_type
#define compound_stmt_type
#define assignment_type
#define annotated_rhs_type
#define augassign_type
#define return_stmt_type
#define raise_stmt_type
#define global_stmt_type
#define nonlocal_stmt_type
#define del_stmt_type
#define yield_stmt_type
#define assert_stmt_type
#define import_stmt_type
#define import_name_type
#define import_from_type
#define import_from_targets_type
#define import_from_as_names_type
#define import_from_as_name_type
#define dotted_as_names_type
#define dotted_as_name_type
#define dotted_name_type
#define block_type
#define decorators_type
#define class_def_type
#define class_def_raw_type
#define function_def_type
#define function_def_raw_type
#define params_type
#define parameters_type
#define slash_no_default_type
#define slash_with_default_type
#define star_etc_type
#define kwds_type
#define param_no_default_type
#define param_no_default_star_annotation_type
#define param_with_default_type
#define param_maybe_default_type
#define param_type
#define param_star_annotation_type
#define annotation_type
#define star_annotation_type
#define default_type
#define if_stmt_type
#define elif_stmt_type
#define else_block_type
#define while_stmt_type
#define for_stmt_type
#define with_stmt_type
#define with_item_type
#define try_stmt_type
#define except_block_type
#define except_star_block_type
#define finally_block_type
#define match_stmt_type
#define subject_expr_type
#define case_block_type
#define guard_type
#define patterns_type
#define pattern_type
#define as_pattern_type
#define or_pattern_type
#define closed_pattern_type
#define literal_pattern_type
#define literal_expr_type
#define complex_number_type
#define signed_number_type
#define signed_real_number_type
#define real_number_type
#define imaginary_number_type
#define capture_pattern_type
#define pattern_capture_target_type
#define wildcard_pattern_type
#define value_pattern_type
#define attr_type
#define name_or_attr_type
#define group_pattern_type
#define sequence_pattern_type
#define open_sequence_pattern_type
#define maybe_sequence_pattern_type
#define maybe_star_pattern_type
#define star_pattern_type
#define mapping_pattern_type
#define items_pattern_type
#define key_value_pattern_type
#define double_star_pattern_type
#define class_pattern_type
#define positional_patterns_type
#define keyword_patterns_type
#define keyword_pattern_type
#define type_alias_type
#define type_params_type
#define type_param_seq_type
#define type_param_type
#define type_param_bound_type
#define type_param_default_type
#define type_param_starred_default_type
#define expressions_type
#define expression_type
#define yield_expr_type
#define star_expressions_type
#define star_expression_type
#define star_named_expressions_type
#define star_named_expression_type
#define assignment_expression_type
#define named_expression_type
#define disjunction_type
#define conjunction_type
#define inversion_type
#define comparison_type
#define compare_op_bitwise_or_pair_type
#define eq_bitwise_or_type
#define noteq_bitwise_or_type
#define lte_bitwise_or_type
#define lt_bitwise_or_type
#define gte_bitwise_or_type
#define gt_bitwise_or_type
#define notin_bitwise_or_type
#define in_bitwise_or_type
#define isnot_bitwise_or_type
#define is_bitwise_or_type
#define bitwise_or_type
#define bitwise_xor_type
#define bitwise_and_type
#define shift_expr_type
#define sum_type
#define term_type
#define factor_type
#define power_type
#define await_primary_type
#define primary_type
#define slices_type
#define slice_type
#define atom_type
#define group_type
#define lambdef_type
#define lambda_params_type
#define lambda_parameters_type
#define lambda_slash_no_default_type
#define lambda_slash_with_default_type
#define lambda_star_etc_type
#define lambda_kwds_type
#define lambda_param_no_default_type
#define lambda_param_with_default_type
#define lambda_param_maybe_default_type
#define lambda_param_type
#define fstring_middle_type
#define fstring_replacement_field_type
#define fstring_conversion_type
#define fstring_full_format_spec_type
#define fstring_format_spec_type
#define fstring_type
#define string_type
#define strings_type
#define list_type
#define tuple_type
#define set_type
#define dict_type
#define double_starred_kvpairs_type
#define double_starred_kvpair_type
#define kvpair_type
#define for_if_clauses_type
#define for_if_clause_type
#define listcomp_type
#define setcomp_type
#define genexp_type
#define dictcomp_type
#define arguments_type
#define args_type
#define kwargs_type
#define starred_expression_type
#define kwarg_or_starred_type
#define kwarg_or_double_starred_type
#define star_targets_type
#define star_targets_list_seq_type
#define star_targets_tuple_seq_type
#define star_target_type
#define target_with_star_atom_type
#define star_atom_type
#define single_target_type
#define single_subscript_attribute_target_type
#define t_primary_type
#define t_lookahead_type
#define del_targets_type
#define del_target_type
#define del_t_atom_type
#define type_expressions_type
#define func_type_comment_type
#define invalid_arguments_type
#define invalid_kwarg_type
#define expression_without_invalid_type
#define invalid_legacy_expression_type
#define invalid_type_param_type
#define invalid_expression_type
#define invalid_named_expression_type
#define invalid_assignment_type
#define invalid_ann_assign_target_type
#define invalid_del_stmt_type
#define invalid_block_type
#define invalid_comprehension_type
#define invalid_dict_comprehension_type
#define invalid_parameters_type
#define invalid_default_type
#define invalid_star_etc_type
#define invalid_kwds_type
#define invalid_parameters_helper_type
#define invalid_lambda_parameters_type
#define invalid_lambda_parameters_helper_type
#define invalid_lambda_star_etc_type
#define invalid_lambda_kwds_type
#define invalid_double_type_comments_type
#define invalid_with_item_type
#define invalid_for_if_clause_type
#define invalid_for_target_type
#define invalid_group_type
#define invalid_import_type
#define invalid_import_from_targets_type
#define invalid_with_stmt_type
#define invalid_with_stmt_indent_type
#define invalid_try_stmt_type
#define invalid_except_stmt_type
#define invalid_except_star_stmt_type
#define invalid_finally_stmt_type
#define invalid_except_stmt_indent_type
#define invalid_except_star_stmt_indent_type
#define invalid_match_stmt_type
#define invalid_case_block_type
#define invalid_as_pattern_type
#define invalid_class_pattern_type
#define invalid_class_argument_pattern_type
#define invalid_if_stmt_type
#define invalid_elif_stmt_type
#define invalid_else_stmt_type
#define invalid_while_stmt_type
#define invalid_for_stmt_type
#define invalid_def_raw_type
#define invalid_class_def_raw_type
#define invalid_double_starred_kvpairs_type
#define invalid_kvpair_type
#define invalid_starred_expression_unpacking_type
#define invalid_starred_expression_type
#define invalid_replacement_field_type
#define invalid_conversion_character_type
#define invalid_arithmetic_type
#define invalid_factor_type
#define invalid_type_params_type
#define _loop0_1_type
#define _loop0_2_type
#define _loop1_3_type
#define _loop0_5_type
#define _gather_4_type
#define _tmp_6_type
#define _tmp_7_type
#define _tmp_8_type
#define _tmp_9_type
#define _tmp_10_type
#define _tmp_11_type
#define _tmp_12_type
#define _tmp_13_type
#define _loop1_14_type
#define _tmp_15_type
#define _tmp_16_type
#define _tmp_17_type
#define _loop0_19_type
#define _gather_18_type
#define _loop0_21_type
#define _gather_20_type
#define _tmp_22_type
#define _tmp_23_type
#define _loop0_24_type
#define _loop1_25_type
#define _loop0_27_type
#define _gather_26_type
#define _tmp_28_type
#define _loop0_30_type
#define _gather_29_type
#define _tmp_31_type
#define _loop1_32_type
#define _tmp_33_type
#define _tmp_34_type
#define _tmp_35_type
#define _loop0_36_type
#define _loop0_37_type
#define _loop0_38_type
#define _loop1_39_type
#define _loop0_40_type
#define _loop1_41_type
#define _loop1_42_type
#define _loop1_43_type
#define _loop0_44_type
#define _loop1_45_type
#define _loop0_46_type
#define _loop1_47_type
#define _loop0_48_type
#define _loop0_49_type
#define _loop1_50_type
#define _loop0_52_type
#define _gather_51_type
#define _loop0_54_type
#define _gather_53_type
#define _loop0_56_type
#define _gather_55_type
#define _loop0_58_type
#define _gather_57_type
#define _tmp_59_type
#define _loop1_60_type
#define _loop1_61_type
#define _tmp_62_type
#define _tmp_63_type
#define _loop1_64_type
#define _loop0_66_type
#define _gather_65_type
#define _tmp_67_type
#define _tmp_68_type
#define _tmp_69_type
#define _tmp_70_type
#define _loop0_72_type
#define _gather_71_type
#define _loop0_74_type
#define _gather_73_type
#define _tmp_75_type
#define _loop0_77_type
#define _gather_76_type
#define _loop0_79_type
#define _gather_78_type
#define _loop0_81_type
#define _gather_80_type
#define _loop1_82_type
#define _loop1_83_type
#define _loop0_85_type
#define _gather_84_type
#define _loop1_86_type
#define _loop1_87_type
#define _loop1_88_type
#define _tmp_89_type
#define _loop0_91_type
#define _gather_90_type
#define _tmp_92_type
#define _tmp_93_type
#define _tmp_94_type
#define _tmp_95_type
#define _tmp_96_type
#define _tmp_97_type
#define _loop0_98_type
#define _loop0_99_type
#define _loop0_100_type
#define _loop1_101_type
#define _loop0_102_type
#define _loop1_103_type
#define _loop1_104_type
#define _loop1_105_type
#define _loop0_106_type
#define _loop1_107_type
#define _loop0_108_type
#define _loop1_109_type
#define _loop0_110_type
#define _loop1_111_type
#define _loop0_112_type
#define _loop0_113_type
#define _loop1_114_type
#define _tmp_115_type
#define _loop0_117_type
#define _gather_116_type
#define _loop1_118_type
#define _loop0_119_type
#define _loop0_120_type
#define _tmp_121_type
#define _loop0_123_type
#define _gather_122_type
#define _tmp_124_type
#define _loop0_126_type
#define _gather_125_type
#define _loop0_128_type
#define _gather_127_type
#define _loop0_130_type
#define _gather_129_type
#define _loop0_132_type
#define _gather_131_type
#define _loop0_133_type
#define _loop0_135_type
#define _gather_134_type
#define _loop1_136_type
#define _tmp_137_type
#define _loop0_139_type
#define _gather_138_type
#define _loop0_141_type
#define _gather_140_type
#define _loop0_143_type
#define _gather_142_type
#define _loop0_145_type
#define _gather_144_type
#define _loop0_147_type
#define _gather_146_type
#define _tmp_148_type
#define _tmp_149_type
#define _loop0_151_type
#define _gather_150_type
#define _tmp_152_type
#define _tmp_153_type
#define _tmp_154_type
#define _tmp_155_type
#define _tmp_156_type
#define _tmp_157_type
#define _tmp_158_type
#define _tmp_159_type
#define _tmp_160_type
#define _tmp_161_type
#define _loop0_162_type
#define _loop0_163_type
#define _loop0_164_type
#define _tmp_165_type
#define _tmp_166_type
#define _tmp_167_type
#define _tmp_168_type
#define _loop0_169_type
#define _loop0_170_type
#define _loop0_171_type
#define _loop1_172_type
#define _tmp_173_type
#define _loop0_174_type
#define _tmp_175_type
#define _loop0_176_type
#define _loop1_177_type
#define _tmp_178_type
#define _tmp_179_type
#define _tmp_180_type
#define _loop0_181_type
#define _tmp_182_type
#define _tmp_183_type
#define _loop1_184_type
#define _tmp_185_type
#define _loop0_186_type
#define _loop0_187_type
#define _loop0_188_type
#define _loop0_190_type
#define _gather_189_type
#define _tmp_191_type
#define _loop0_192_type
#define _tmp_193_type
#define _loop0_194_type
#define _loop1_195_type
#define _loop1_196_type
#define _tmp_197_type
#define _tmp_198_type
#define _loop0_199_type
#define _tmp_200_type
#define _tmp_201_type
#define _tmp_202_type
#define _tmp_203_type
#define _loop0_205_type
#define _gather_204_type
#define _loop0_207_type
#define _gather_206_type
#define _loop0_209_type
#define _gather_208_type
#define _loop0_211_type
#define _gather_210_type
#define _loop0_213_type
#define _gather_212_type
#define _tmp_214_type
#define _loop0_215_type
#define _loop1_216_type
#define _tmp_217_type
#define _loop0_218_type
#define _loop1_219_type
#define _tmp_220_type
#define _tmp_221_type
#define _tmp_222_type
#define _tmp_223_type
#define _tmp_224_type
#define _tmp_225_type
#define _tmp_226_type
#define _tmp_227_type
#define _tmp_228_type
#define _tmp_229_type
#define _tmp_230_type
#define _tmp_231_type
#define _tmp_232_type
#define _loop0_234_type
#define _gather_233_type
#define _tmp_235_type
#define _tmp_236_type
#define _tmp_237_type
#define _tmp_238_type
#define _tmp_239_type
#define _tmp_240_type
#define _tmp_241_type
#define _loop0_242_type
#define _tmp_243_type
#define _tmp_244_type
#define _tmp_245_type
#define _tmp_246_type
#define _tmp_247_type
#define _tmp_248_type
#define _tmp_249_type
#define _tmp_250_type
#define _tmp_251_type
#define _tmp_252_type
#define _tmp_253_type
#define _tmp_254_type
#define _tmp_255_type
#define _tmp_256_type
#define _tmp_257_type
#define _tmp_258_type
#define _tmp_259_type
#define _tmp_260_type
#define _tmp_261_type
#define _tmp_262_type
#define _tmp_263_type
#define _tmp_264_type
#define _tmp_265_type
#define _tmp_266_type
#define _tmp_267_type
#define _loop0_268_type
#define _tmp_269_type
#define _tmp_270_type
#define _tmp_271_type
#define _tmp_272_type
#define _tmp_273_type
#define _tmp_274_type
#define _loop0_276_type
#define _gather_275_type
#define _tmp_277_type
#define _tmp_278_type
#define _tmp_279_type
#define _tmp_280_type
#define _tmp_281_type
#define _tmp_282_type
#define _tmp_283_type

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* statement_newline_rule(Parser *p);
static asdl_stmt_seq* simple_stmts_rule(Parser *p);
static stmt_ty simple_stmt_rule(Parser *p);
static stmt_ty compound_stmt_rule(Parser *p);
static stmt_ty assignment_rule(Parser *p);
static expr_ty annotated_rhs_rule(Parser *p);
static AugOperator* augassign_rule(Parser *p);
static stmt_ty return_stmt_rule(Parser *p);
static stmt_ty raise_stmt_rule(Parser *p);
static stmt_ty global_stmt_rule(Parser *p);
static stmt_ty nonlocal_stmt_rule(Parser *p);
static stmt_ty del_stmt_rule(Parser *p);
static stmt_ty yield_stmt_rule(Parser *p);
static stmt_ty assert_stmt_rule(Parser *p);
static stmt_ty import_stmt_rule(Parser *p);
static stmt_ty import_name_rule(Parser *p);
static stmt_ty import_from_rule(Parser *p);
static asdl_alias_seq* import_from_targets_rule(Parser *p);
static asdl_alias_seq* import_from_as_names_rule(Parser *p);
static alias_ty import_from_as_name_rule(Parser *p);
static asdl_alias_seq* dotted_as_names_rule(Parser *p);
static alias_ty dotted_as_name_rule(Parser *p);
static expr_ty dotted_name_rule(Parser *p);
static asdl_stmt_seq* block_rule(Parser *p);
static asdl_expr_seq* decorators_rule(Parser *p);
static stmt_ty class_def_rule(Parser *p);
static stmt_ty class_def_raw_rule(Parser *p);
static stmt_ty function_def_rule(Parser *p);
static stmt_ty function_def_raw_rule(Parser *p);
static arguments_ty params_rule(Parser *p);
static arguments_ty parameters_rule(Parser *p);
static asdl_arg_seq* slash_no_default_rule(Parser *p);
static SlashWithDefault* slash_with_default_rule(Parser *p);
static StarEtc* star_etc_rule(Parser *p);
static arg_ty kwds_rule(Parser *p);
static arg_ty param_no_default_rule(Parser *p);
static arg_ty param_no_default_star_annotation_rule(Parser *p);
static NameDefaultPair* param_with_default_rule(Parser *p);
static NameDefaultPair* param_maybe_default_rule(Parser *p);
static arg_ty param_rule(Parser *p);
static arg_ty param_star_annotation_rule(Parser *p);
static expr_ty annotation_rule(Parser *p);
static expr_ty star_annotation_rule(Parser *p);
static expr_ty default_rule(Parser *p);
static stmt_ty if_stmt_rule(Parser *p);
static stmt_ty elif_stmt_rule(Parser *p);
static asdl_stmt_seq* else_block_rule(Parser *p);
static stmt_ty while_stmt_rule(Parser *p);
static stmt_ty for_stmt_rule(Parser *p);
static stmt_ty with_stmt_rule(Parser *p);
static withitem_ty with_item_rule(Parser *p);
static stmt_ty try_stmt_rule(Parser *p);
static excepthandler_ty except_block_rule(Parser *p);
static excepthandler_ty except_star_block_rule(Parser *p);
static asdl_stmt_seq* finally_block_rule(Parser *p);
static stmt_ty match_stmt_rule(Parser *p);
static expr_ty subject_expr_rule(Parser *p);
static match_case_ty case_block_rule(Parser *p);
static expr_ty guard_rule(Parser *p);
static pattern_ty patterns_rule(Parser *p);
static pattern_ty pattern_rule(Parser *p);
static pattern_ty as_pattern_rule(Parser *p);
static pattern_ty or_pattern_rule(Parser *p);
static pattern_ty closed_pattern_rule(Parser *p);
static pattern_ty literal_pattern_rule(Parser *p);
static expr_ty literal_expr_rule(Parser *p);
static expr_ty complex_number_rule(Parser *p);
static expr_ty signed_number_rule(Parser *p);
static expr_ty signed_real_number_rule(Parser *p);
static expr_ty real_number_rule(Parser *p);
static expr_ty imaginary_number_rule(Parser *p);
static pattern_ty capture_pattern_rule(Parser *p);
static expr_ty pattern_capture_target_rule(Parser *p);
static pattern_ty wildcard_pattern_rule(Parser *p);
static pattern_ty value_pattern_rule(Parser *p);
static expr_ty attr_rule(Parser *p);
static expr_ty name_or_attr_rule(Parser *p);
static pattern_ty group_pattern_rule(Parser *p);
static pattern_ty sequence_pattern_rule(Parser *p);
static asdl_seq* open_sequence_pattern_rule(Parser *p);
static asdl_seq* maybe_sequence_pattern_rule(Parser *p);
static pattern_ty maybe_star_pattern_rule(Parser *p);
static pattern_ty star_pattern_rule(Parser *p);
static pattern_ty mapping_pattern_rule(Parser *p);
static asdl_seq* items_pattern_rule(Parser *p);
static KeyPatternPair* key_value_pattern_rule(Parser *p);
static expr_ty double_star_pattern_rule(Parser *p);
static pattern_ty class_pattern_rule(Parser *p);
static asdl_pattern_seq* positional_patterns_rule(Parser *p);
static asdl_seq* keyword_patterns_rule(Parser *p);
static KeyPatternPair* keyword_pattern_rule(Parser *p);
static stmt_ty type_alias_rule(Parser *p);
static asdl_type_param_seq* type_params_rule(Parser *p);
static asdl_type_param_seq* type_param_seq_rule(Parser *p);
static type_param_ty type_param_rule(Parser *p);
static expr_ty type_param_bound_rule(Parser *p);
static expr_ty type_param_default_rule(Parser *p);
static expr_ty type_param_starred_default_rule(Parser *p);
static expr_ty expressions_rule(Parser *p);
static expr_ty expression_rule(Parser *p);
static expr_ty yield_expr_rule(Parser *p);
static expr_ty star_expressions_rule(Parser *p);
static expr_ty star_expression_rule(Parser *p);
static asdl_expr_seq* star_named_expressions_rule(Parser *p);
static expr_ty star_named_expression_rule(Parser *p);
static expr_ty assignment_expression_rule(Parser *p);
static expr_ty named_expression_rule(Parser *p);
static expr_ty disjunction_rule(Parser *p);
static expr_ty conjunction_rule(Parser *p);
static expr_ty inversion_rule(Parser *p);
static expr_ty comparison_rule(Parser *p);
static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p);
static CmpopExprPair* eq_bitwise_or_rule(Parser *p);
static CmpopExprPair* noteq_bitwise_or_rule(Parser *p);
static CmpopExprPair* lte_bitwise_or_rule(Parser *p);
static CmpopExprPair* lt_bitwise_or_rule(Parser *p);
static CmpopExprPair* gte_bitwise_or_rule(Parser *p);
static CmpopExprPair* gt_bitwise_or_rule(Parser *p);
static CmpopExprPair* notin_bitwise_or_rule(Parser *p);
static CmpopExprPair* in_bitwise_or_rule(Parser *p);
static CmpopExprPair* isnot_bitwise_or_rule(Parser *p);
static CmpopExprPair* is_bitwise_or_rule(Parser *p);
static expr_ty bitwise_or_rule(Parser *p);
static expr_ty bitwise_xor_rule(Parser *p);
static expr_ty bitwise_and_rule(Parser *p);
static expr_ty shift_expr_rule(Parser *p);
static expr_ty sum_rule(Parser *p);
static expr_ty term_rule(Parser *p);
static expr_ty factor_rule(Parser *p);
static expr_ty power_rule(Parser *p);
static expr_ty await_primary_rule(Parser *p);
static expr_ty primary_rule(Parser *p);
static expr_ty slices_rule(Parser *p);
static expr_ty slice_rule(Parser *p);
static expr_ty atom_rule(Parser *p);
static expr_ty group_rule(Parser *p);
static expr_ty lambdef_rule(Parser *p);
static arguments_ty lambda_params_rule(Parser *p);
static arguments_ty lambda_parameters_rule(Parser *p);
static asdl_arg_seq* lambda_slash_no_default_rule(Parser *p);
static SlashWithDefault* lambda_slash_with_default_rule(Parser *p);
static StarEtc* lambda_star_etc_rule(Parser *p);
static arg_ty lambda_kwds_rule(Parser *p);
static arg_ty lambda_param_no_default_rule(Parser *p);
static NameDefaultPair* lambda_param_with_default_rule(Parser *p);
static NameDefaultPair* lambda_param_maybe_default_rule(Parser *p);
static arg_ty lambda_param_rule(Parser *p);
static expr_ty fstring_middle_rule(Parser *p);
static expr_ty fstring_replacement_field_rule(Parser *p);
static ResultTokenWithMetadata* fstring_conversion_rule(Parser *p);
static ResultTokenWithMetadata* fstring_full_format_spec_rule(Parser *p);
static expr_ty fstring_format_spec_rule(Parser *p);
static expr_ty fstring_rule(Parser *p);
static expr_ty string_rule(Parser *p);
static expr_ty strings_rule(Parser *p);
static expr_ty list_rule(Parser *p);
static expr_ty tuple_rule(Parser *p);
static expr_ty set_rule(Parser *p);
static expr_ty dict_rule(Parser *p);
static asdl_seq* double_starred_kvpairs_rule(Parser *p);
static KeyValuePair* double_starred_kvpair_rule(Parser *p);
static KeyValuePair* kvpair_rule(Parser *p);
static asdl_comprehension_seq* for_if_clauses_rule(Parser *p);
static comprehension_ty for_if_clause_rule(Parser *p);
static expr_ty listcomp_rule(Parser *p);
static expr_ty setcomp_rule(Parser *p);
static expr_ty genexp_rule(Parser *p);
static expr_ty dictcomp_rule(Parser *p);
static expr_ty arguments_rule(Parser *p);
static expr_ty args_rule(Parser *p);
static asdl_seq* kwargs_rule(Parser *p);
static expr_ty starred_expression_rule(Parser *p);
static KeywordOrStarred* kwarg_or_starred_rule(Parser *p);
static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p);
static expr_ty star_targets_rule(Parser *p);
static asdl_expr_seq* star_targets_list_seq_rule(Parser *p);
static asdl_expr_seq* star_targets_tuple_seq_rule(Parser *p);
static expr_ty star_target_rule(Parser *p);
static expr_ty target_with_star_atom_rule(Parser *p);
static expr_ty star_atom_rule(Parser *p);
static expr_ty single_target_rule(Parser *p);
static expr_ty single_subscript_attribute_target_rule(Parser *p);
static expr_ty t_primary_rule(Parser *p);
static void *t_lookahead_rule(Parser *p);
static asdl_expr_seq* del_targets_rule(Parser *p);
static expr_ty del_target_rule(Parser *p);
static expr_ty del_t_atom_rule(Parser *p);
static asdl_expr_seq* type_expressions_rule(Parser *p);
static Token* func_type_comment_rule(Parser *p);
static void *invalid_arguments_rule(Parser *p);
static void *invalid_kwarg_rule(Parser *p);
static expr_ty expression_without_invalid_rule(Parser *p);
static void *invalid_legacy_expression_rule(Parser *p);
static void *invalid_type_param_rule(Parser *p);
static void *invalid_expression_rule(Parser *p);
static void *invalid_named_expression_rule(Parser *p);
static void *invalid_assignment_rule(Parser *p);
static expr_ty invalid_ann_assign_target_rule(Parser *p);
static void *invalid_del_stmt_rule(Parser *p);
static void *invalid_block_rule(Parser *p);
static void *invalid_comprehension_rule(Parser *p);
static void *invalid_dict_comprehension_rule(Parser *p);
static void *invalid_parameters_rule(Parser *p);
static void *invalid_default_rule(Parser *p);
static void *invalid_star_etc_rule(Parser *p);
static void *invalid_kwds_rule(Parser *p);
static void *invalid_parameters_helper_rule(Parser *p);
static void *invalid_lambda_parameters_rule(Parser *p);
static void *invalid_lambda_parameters_helper_rule(Parser *p);
static void *invalid_lambda_star_etc_rule(Parser *p);
static void *invalid_lambda_kwds_rule(Parser *p);
static void *invalid_double_type_comments_rule(Parser *p);
static void *invalid_with_item_rule(Parser *p);
static void *invalid_for_if_clause_rule(Parser *p);
static void *invalid_for_target_rule(Parser *p);
static void *invalid_group_rule(Parser *p);
static void *invalid_import_rule(Parser *p);
static void *invalid_import_from_targets_rule(Parser *p);
static void *invalid_with_stmt_rule(Parser *p);
static void *invalid_with_stmt_indent_rule(Parser *p);
static void *invalid_try_stmt_rule(Parser *p);
static void *invalid_except_stmt_rule(Parser *p);
static void *invalid_except_star_stmt_rule(Parser *p);
static void *invalid_finally_stmt_rule(Parser *p);
static void *invalid_except_stmt_indent_rule(Parser *p);
static void *invalid_except_star_stmt_indent_rule(Parser *p);
static void *invalid_match_stmt_rule(Parser *p);
static void *invalid_case_block_rule(Parser *p);
static void *invalid_as_pattern_rule(Parser *p);
static void *invalid_class_pattern_rule(Parser *p);
static asdl_pattern_seq* invalid_class_argument_pattern_rule(Parser *p);
static void *invalid_if_stmt_rule(Parser *p);
static void *invalid_elif_stmt_rule(Parser *p);
static void *invalid_else_stmt_rule(Parser *p);
static void *invalid_while_stmt_rule(Parser *p);
static void *invalid_for_stmt_rule(Parser *p);
static void *invalid_def_raw_rule(Parser *p);
static void *invalid_class_def_raw_rule(Parser *p);
static void *invalid_double_starred_kvpairs_rule(Parser *p);
static void *invalid_kvpair_rule(Parser *p);
static void *invalid_starred_expression_unpacking_rule(Parser *p);
static void *invalid_starred_expression_rule(Parser *p);
static void *invalid_replacement_field_rule(Parser *p);
static void *invalid_conversion_character_rule(Parser *p);
static void *invalid_arithmetic_rule(Parser *p);
static void *invalid_factor_rule(Parser *p);
static void *invalid_type_params_rule(Parser *p);
static asdl_seq *_loop0_1_rule(Parser *p);
static asdl_seq *_loop0_2_rule(Parser *p);
static asdl_seq *_loop1_3_rule(Parser *p);
static asdl_seq *_loop0_5_rule(Parser *p);
static asdl_seq *_gather_4_rule(Parser *p);
static void *_tmp_6_rule(Parser *p);
static void *_tmp_7_rule(Parser *p);
static void *_tmp_8_rule(Parser *p);
static void *_tmp_9_rule(Parser *p);
static void *_tmp_10_rule(Parser *p);
static void *_tmp_11_rule(Parser *p);
static void *_tmp_12_rule(Parser *p);
static void *_tmp_13_rule(Parser *p);
static asdl_seq *_loop1_14_rule(Parser *p);
static void *_tmp_15_rule(Parser *p);
static void *_tmp_16_rule(Parser *p);
static void *_tmp_17_rule(Parser *p);
static asdl_seq *_loop0_19_rule(Parser *p);
static asdl_seq *_gather_18_rule(Parser *p);
static asdl_seq *_loop0_21_rule(Parser *p);
static asdl_seq *_gather_20_rule(Parser *p);
static void *_tmp_22_rule(Parser *p);
static void *_tmp_23_rule(Parser *p);
static asdl_seq *_loop0_24_rule(Parser *p);
static asdl_seq *_loop1_25_rule(Parser *p);
static asdl_seq *_loop0_27_rule(Parser *p);
static asdl_seq *_gather_26_rule(Parser *p);
static void *_tmp_28_rule(Parser *p);
static asdl_seq *_loop0_30_rule(Parser *p);
static asdl_seq *_gather_29_rule(Parser *p);
static void *_tmp_31_rule(Parser *p);
static asdl_seq *_loop1_32_rule(Parser *p);
static void *_tmp_33_rule(Parser *p);
static void *_tmp_34_rule(Parser *p);
static void *_tmp_35_rule(Parser *p);
static asdl_seq *_loop0_36_rule(Parser *p);
static asdl_seq *_loop0_37_rule(Parser *p);
static asdl_seq *_loop0_38_rule(Parser *p);
static asdl_seq *_loop1_39_rule(Parser *p);
static asdl_seq *_loop0_40_rule(Parser *p);
static asdl_seq *_loop1_41_rule(Parser *p);
static asdl_seq *_loop1_42_rule(Parser *p);
static asdl_seq *_loop1_43_rule(Parser *p);
static asdl_seq *_loop0_44_rule(Parser *p);
static asdl_seq *_loop1_45_rule(Parser *p);
static asdl_seq *_loop0_46_rule(Parser *p);
static asdl_seq *_loop1_47_rule(Parser *p);
static asdl_seq *_loop0_48_rule(Parser *p);
static asdl_seq *_loop0_49_rule(Parser *p);
static asdl_seq *_loop1_50_rule(Parser *p);
static asdl_seq *_loop0_52_rule(Parser *p);
static asdl_seq *_gather_51_rule(Parser *p);
static asdl_seq *_loop0_54_rule(Parser *p);
static asdl_seq *_gather_53_rule(Parser *p);
static asdl_seq *_loop0_56_rule(Parser *p);
static asdl_seq *_gather_55_rule(Parser *p);
static asdl_seq *_loop0_58_rule(Parser *p);
static asdl_seq *_gather_57_rule(Parser *p);
static void *_tmp_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 void *_tmp_63_rule(Parser *p);
static asdl_seq *_loop1_64_rule(Parser *p);
static asdl_seq *_loop0_66_rule(Parser *p);
static asdl_seq *_gather_65_rule(Parser *p);
static void *_tmp_67_rule(Parser *p);
static void *_tmp_68_rule(Parser *p);
static void *_tmp_69_rule(Parser *p);
static void *_tmp_70_rule(Parser *p);
static asdl_seq *_loop0_72_rule(Parser *p);
static asdl_seq *_gather_71_rule(Parser *p);
static asdl_seq *_loop0_74_rule(Parser *p);
static asdl_seq *_gather_73_rule(Parser *p);
static void *_tmp_75_rule(Parser *p);
static asdl_seq *_loop0_77_rule(Parser *p);
static asdl_seq *_gather_76_rule(Parser *p);
static asdl_seq *_loop0_79_rule(Parser *p);
static asdl_seq *_gather_78_rule(Parser *p);
static asdl_seq *_loop0_81_rule(Parser *p);
static asdl_seq *_gather_80_rule(Parser *p);
static asdl_seq *_loop1_82_rule(Parser *p);
static asdl_seq *_loop1_83_rule(Parser *p);
static asdl_seq *_loop0_85_rule(Parser *p);
static asdl_seq *_gather_84_rule(Parser *p);
static asdl_seq *_loop1_86_rule(Parser *p);
static asdl_seq *_loop1_87_rule(Parser *p);
static asdl_seq *_loop1_88_rule(Parser *p);
static void *_tmp_89_rule(Parser *p);
static asdl_seq *_loop0_91_rule(Parser *p);
static asdl_seq *_gather_90_rule(Parser *p);
static void *_tmp_92_rule(Parser *p);
static void *_tmp_93_rule(Parser *p);
static void *_tmp_94_rule(Parser *p);
static void *_tmp_95_rule(Parser *p);
static void *_tmp_96_rule(Parser *p);
static void *_tmp_97_rule(Parser *p);
static asdl_seq *_loop0_98_rule(Parser *p);
static asdl_seq *_loop0_99_rule(Parser *p);
static asdl_seq *_loop0_100_rule(Parser *p);
static asdl_seq *_loop1_101_rule(Parser *p);
static asdl_seq *_loop0_102_rule(Parser *p);
static asdl_seq *_loop1_103_rule(Parser *p);
static asdl_seq *_loop1_104_rule(Parser *p);
static asdl_seq *_loop1_105_rule(Parser *p);
static asdl_seq *_loop0_106_rule(Parser *p);
static asdl_seq *_loop1_107_rule(Parser *p);
static asdl_seq *_loop0_108_rule(Parser *p);
static asdl_seq *_loop1_109_rule(Parser *p);
static asdl_seq *_loop0_110_rule(Parser *p);
static asdl_seq *_loop1_111_rule(Parser *p);
static asdl_seq *_loop0_112_rule(Parser *p);
static asdl_seq *_loop0_113_rule(Parser *p);
static asdl_seq *_loop1_114_rule(Parser *p);
static void *_tmp_115_rule(Parser *p);
static asdl_seq *_loop0_117_rule(Parser *p);
static asdl_seq *_gather_116_rule(Parser *p);
static asdl_seq *_loop1_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 asdl_seq *_loop0_123_rule(Parser *p);
static asdl_seq *_gather_122_rule(Parser *p);
static void *_tmp_124_rule(Parser *p);
static asdl_seq *_loop0_126_rule(Parser *p);
static asdl_seq *_gather_125_rule(Parser *p);
static asdl_seq *_loop0_128_rule(Parser *p);
static asdl_seq *_gather_127_rule(Parser *p);
static asdl_seq *_loop0_130_rule(Parser *p);
static asdl_seq *_gather_129_rule(Parser *p);
static asdl_seq *_loop0_132_rule(Parser *p);
static asdl_seq *_gather_131_rule(Parser *p);
static asdl_seq *_loop0_133_rule(Parser *p);
static asdl_seq *_loop0_135_rule(Parser *p);
static asdl_seq *_gather_134_rule(Parser *p);
static asdl_seq *_loop1_136_rule(Parser *p);
static void *_tmp_137_rule(Parser *p);
static asdl_seq *_loop0_139_rule(Parser *p);
static asdl_seq *_gather_138_rule(Parser *p);
static asdl_seq *_loop0_141_rule(Parser *p);
static asdl_seq *_gather_140_rule(Parser *p);
static asdl_seq *_loop0_143_rule(Parser *p);
static asdl_seq *_gather_142_rule(Parser *p);
static asdl_seq *_loop0_145_rule(Parser *p);
static asdl_seq *_gather_144_rule(Parser *p);
static asdl_seq *_loop0_147_rule(Parser *p);
static asdl_seq *_gather_146_rule(Parser *p);
static void *_tmp_148_rule(Parser *p);
static void *_tmp_149_rule(Parser *p);
static asdl_seq *_loop0_151_rule(Parser *p);
static asdl_seq *_gather_150_rule(Parser *p);
static void *_tmp_152_rule(Parser *p);
static void *_tmp_153_rule(Parser *p);
static void *_tmp_154_rule(Parser *p);
static void *_tmp_155_rule(Parser *p);
static void *_tmp_156_rule(Parser *p);
static void *_tmp_157_rule(Parser *p);
static void *_tmp_158_rule(Parser *p);
static void *_tmp_159_rule(Parser *p);
static void *_tmp_160_rule(Parser *p);
static void *_tmp_161_rule(Parser *p);
static asdl_seq *_loop0_162_rule(Parser *p);
static asdl_seq *_loop0_163_rule(Parser *p);
static asdl_seq *_loop0_164_rule(Parser *p);
static void *_tmp_165_rule(Parser *p);
static void *_tmp_166_rule(Parser *p);
static void *_tmp_167_rule(Parser *p);
static void *_tmp_168_rule(Parser *p);
static asdl_seq *_loop0_169_rule(Parser *p);
static asdl_seq *_loop0_170_rule(Parser *p);
static asdl_seq *_loop0_171_rule(Parser *p);
static asdl_seq *_loop1_172_rule(Parser *p);
static void *_tmp_173_rule(Parser *p);
static asdl_seq *_loop0_174_rule(Parser *p);
static void *_tmp_175_rule(Parser *p);
static asdl_seq *_loop0_176_rule(Parser *p);
static asdl_seq *_loop1_177_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 asdl_seq *_loop0_181_rule(Parser *p);
static void *_tmp_182_rule(Parser *p);
static void *_tmp_183_rule(Parser *p);
static asdl_seq *_loop1_184_rule(Parser *p);
static void *_tmp_185_rule(Parser *p);
static asdl_seq *_loop0_186_rule(Parser *p);
static asdl_seq *_loop0_187_rule(Parser *p);
static asdl_seq *_loop0_188_rule(Parser *p);
static asdl_seq *_loop0_190_rule(Parser *p);
static asdl_seq *_gather_189_rule(Parser *p);
static void *_tmp_191_rule(Parser *p);
static asdl_seq *_loop0_192_rule(Parser *p);
static void *_tmp_193_rule(Parser *p);
static asdl_seq *_loop0_194_rule(Parser *p);
static asdl_seq *_loop1_195_rule(Parser *p);
static asdl_seq *_loop1_196_rule(Parser *p);
static void *_tmp_197_rule(Parser *p);
static void *_tmp_198_rule(Parser *p);
static asdl_seq *_loop0_199_rule(Parser *p);
static void *_tmp_200_rule(Parser *p);
static void *_tmp_201_rule(Parser *p);
static void *_tmp_202_rule(Parser *p);
static void *_tmp_203_rule(Parser *p);
static asdl_seq *_loop0_205_rule(Parser *p);
static asdl_seq *_gather_204_rule(Parser *p);
static asdl_seq *_loop0_207_rule(Parser *p);
static asdl_seq *_gather_206_rule(Parser *p);
static asdl_seq *_loop0_209_rule(Parser *p);
static asdl_seq *_gather_208_rule(Parser *p);
static asdl_seq *_loop0_211_rule(Parser *p);
static asdl_seq *_gather_210_rule(Parser *p);
static asdl_seq *_loop0_213_rule(Parser *p);
static asdl_seq *_gather_212_rule(Parser *p);
static void *_tmp_214_rule(Parser *p);
static asdl_seq *_loop0_215_rule(Parser *p);
static asdl_seq *_loop1_216_rule(Parser *p);
static void *_tmp_217_rule(Parser *p);
static asdl_seq *_loop0_218_rule(Parser *p);
static asdl_seq *_loop1_219_rule(Parser *p);
static void *_tmp_220_rule(Parser *p);
static void *_tmp_221_rule(Parser *p);
static void *_tmp_222_rule(Parser *p);
static void *_tmp_223_rule(Parser *p);
static void *_tmp_224_rule(Parser *p);
static void *_tmp_225_rule(Parser *p);
static void *_tmp_226_rule(Parser *p);
static void *_tmp_227_rule(Parser *p);
static void *_tmp_228_rule(Parser *p);
static void *_tmp_229_rule(Parser *p);
static void *_tmp_230_rule(Parser *p);
static void *_tmp_231_rule(Parser *p);
static void *_tmp_232_rule(Parser *p);
static asdl_seq *_loop0_234_rule(Parser *p);
static asdl_seq *_gather_233_rule(Parser *p);
static void *_tmp_235_rule(Parser *p);
static void *_tmp_236_rule(Parser *p);
static void *_tmp_237_rule(Parser *p);
static void *_tmp_238_rule(Parser *p);
static void *_tmp_239_rule(Parser *p);
static void *_tmp_240_rule(Parser *p);
static void *_tmp_241_rule(Parser *p);
static asdl_seq *_loop0_242_rule(Parser *p);
static void *_tmp_243_rule(Parser *p);
static void *_tmp_244_rule(Parser *p);
static void *_tmp_245_rule(Parser *p);
static void *_tmp_246_rule(Parser *p);
static void *_tmp_247_rule(Parser *p);
static void *_tmp_248_rule(Parser *p);
static void *_tmp_249_rule(Parser *p);
static void *_tmp_250_rule(Parser *p);
static void *_tmp_251_rule(Parser *p);
static void *_tmp_252_rule(Parser *p);
static void *_tmp_253_rule(Parser *p);
static void *_tmp_254_rule(Parser *p);
static void *_tmp_255_rule(Parser *p);
static void *_tmp_256_rule(Parser *p);
static void *_tmp_257_rule(Parser *p);
static void *_tmp_258_rule(Parser *p);
static void *_tmp_259_rule(Parser *p);
static void *_tmp_260_rule(Parser *p);
static void *_tmp_261_rule(Parser *p);
static void *_tmp_262_rule(Parser *p);
static void *_tmp_263_rule(Parser *p);
static void *_tmp_264_rule(Parser *p);
static void *_tmp_265_rule(Parser *p);
static void *_tmp_266_rule(Parser *p);
static void *_tmp_267_rule(Parser *p);
static asdl_seq *_loop0_268_rule(Parser *p);
static void *_tmp_269_rule(Parser *p);
static void *_tmp_270_rule(Parser *p);
static void *_tmp_271_rule(Parser *p);
static void *_tmp_272_rule(Parser *p);
static void *_tmp_273_rule(Parser *p);
static void *_tmp_274_rule(Parser *p);
static asdl_seq *_loop0_276_rule(Parser *p);
static asdl_seq *_gather_275_rule(Parser *p);
static void *_tmp_277_rule(Parser *p);
static void *_tmp_278_rule(Parser *p);
static void *_tmp_279_rule(Parser *p);
static void *_tmp_280_rule(Parser *p);
static void *_tmp_281_rule(Parser *p);
static void *_tmp_282_rule(Parser *p);
static void *_tmp_283_rule(Parser *p);


// file: statements? $
static mod_ty
file_rule(Parser *p)
{}

// interactive: statement_newline
static mod_ty
interactive_rule(Parser *p)
{}

// eval: expressions NEWLINE* $
static mod_ty
eval_rule(Parser *p)
{}

// func_type: '(' type_expressions? ')' '->' expression NEWLINE* $
static mod_ty
func_type_rule(Parser *p)
{}

// statements: statement+
static asdl_stmt_seq*
statements_rule(Parser *p)
{}

// statement: compound_stmt | simple_stmts
static asdl_stmt_seq*
statement_rule(Parser *p)
{}

// statement_newline: compound_stmt NEWLINE | simple_stmts | NEWLINE | $
static asdl_stmt_seq*
statement_newline_rule(Parser *p)
{}

// simple_stmts: simple_stmt !';' NEWLINE | ';'.simple_stmt+ ';'? NEWLINE
static asdl_stmt_seq*
simple_stmts_rule(Parser *p)
{}

// simple_stmt:
//     | assignment
//     | &"type" type_alias
//     | star_expressions
//     | &'return' return_stmt
//     | &('import' | 'from') import_stmt
//     | &'raise' raise_stmt
//     | 'pass'
//     | &'del' del_stmt
//     | &'yield' yield_stmt
//     | &'assert' assert_stmt
//     | 'break'
//     | 'continue'
//     | &'global' global_stmt
//     | &'nonlocal' nonlocal_stmt
static stmt_ty
simple_stmt_rule(Parser *p)
{}

// compound_stmt:
//     | &('def' | '@' | 'async') function_def
//     | &'if' if_stmt
//     | &('class' | '@') class_def
//     | &('with' | 'async') with_stmt
//     | &('for' | 'async') for_stmt
//     | &'try' try_stmt
//     | &'while' while_stmt
//     | match_stmt
static stmt_ty
compound_stmt_rule(Parser *p)
{}

// assignment:
//     | NAME ':' expression ['=' annotated_rhs]
//     | ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]
//     | ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?
//     | single_target augassign ~ (yield_expr | star_expressions)
//     | invalid_assignment
static stmt_ty
assignment_rule(Parser *p)
{}

// annotated_rhs: yield_expr | star_expressions
static expr_ty
annotated_rhs_rule(Parser *p)
{}

// augassign:
//     | '+='
//     | '-='
//     | '*='
//     | '@='
//     | '/='
//     | '%='
//     | '&='
//     | '|='
//     | '^='
//     | '<<='
//     | '>>='
//     | '**='
//     | '//='
static AugOperator*
augassign_rule(Parser *p)
{}

// return_stmt: 'return' star_expressions?
static stmt_ty
return_stmt_rule(Parser *p)
{}

// raise_stmt: 'raise' expression ['from' expression] | 'raise'
static stmt_ty
raise_stmt_rule(Parser *p)
{}

// global_stmt: 'global' ','.NAME+
static stmt_ty
global_stmt_rule(Parser *p)
{}

// nonlocal_stmt: 'nonlocal' ','.NAME+
static stmt_ty
nonlocal_stmt_rule(Parser *p)
{}

// del_stmt: 'del' del_targets &(';' | NEWLINE) | invalid_del_stmt
static stmt_ty
del_stmt_rule(Parser *p)
{}

// yield_stmt: yield_expr
static stmt_ty
yield_stmt_rule(Parser *p)
{}

// assert_stmt: 'assert' expression [',' expression]
static stmt_ty
assert_stmt_rule(Parser *p)
{}

// import_stmt: invalid_import | import_name | import_from
static stmt_ty
import_stmt_rule(Parser *p)
{}

// import_name: 'import' dotted_as_names
static stmt_ty
import_name_rule(Parser *p)
{}

// import_from:
//     | 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
//     | 'from' (('.' | '...'))+ 'import' import_from_targets
static stmt_ty
import_from_rule(Parser *p)
{}

// import_from_targets:
//     | '(' import_from_as_names ','? ')'
//     | import_from_as_names !','
//     | '*'
//     | invalid_import_from_targets
static asdl_alias_seq*
import_from_targets_rule(Parser *p)
{}

// import_from_as_names: ','.import_from_as_name+
static asdl_alias_seq*
import_from_as_names_rule(Parser *p)
{}

// import_from_as_name: NAME ['as' NAME]
static alias_ty
import_from_as_name_rule(Parser *p)
{}

// dotted_as_names: ','.dotted_as_name+
static asdl_alias_seq*
dotted_as_names_rule(Parser *p)
{}

// dotted_as_name: dotted_name ['as' NAME]
static alias_ty
dotted_as_name_rule(Parser *p)
{}

// Left-recursive
// dotted_name: dotted_name '.' NAME | NAME
static expr_ty dotted_name_raw(Parser *);
static expr_ty
dotted_name_rule(Parser *p)
{}
static expr_ty
dotted_name_raw(Parser *p)
{}

// block: NEWLINE INDENT statements DEDENT | simple_stmts | invalid_block
static asdl_stmt_seq*
block_rule(Parser *p)
{}

// decorators: (('@' named_expression NEWLINE))+
static asdl_expr_seq*
decorators_rule(Parser *p)
{}

// class_def: decorators class_def_raw | class_def_raw
static stmt_ty
class_def_rule(Parser *p)
{}

// class_def_raw:
//     | invalid_class_def_raw
//     | 'class' NAME type_params? ['(' arguments? ')'] ':' block
static stmt_ty
class_def_raw_rule(Parser *p)
{}

// function_def: decorators function_def_raw | function_def_raw
static stmt_ty
function_def_rule(Parser *p)
{}

// function_def_raw:
//     | invalid_def_raw
//     | 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block
//     | 'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block
static stmt_ty
function_def_raw_rule(Parser *p)
{}

// params: invalid_parameters | parameters
static arguments_ty
params_rule(Parser *p)
{}

// parameters:
//     | slash_no_default param_no_default* param_with_default* star_etc?
//     | slash_with_default param_with_default* star_etc?
//     | param_no_default+ param_with_default* star_etc?
//     | param_with_default+ star_etc?
//     | star_etc
static arguments_ty
parameters_rule(Parser *p)
{}

// slash_no_default: param_no_default+ '/' ',' | param_no_default+ '/' &')'
static asdl_arg_seq*
slash_no_default_rule(Parser *p)
{}

// slash_with_default:
//     | param_no_default* param_with_default+ '/' ','
//     | param_no_default* param_with_default+ '/' &')'
static SlashWithDefault*
slash_with_default_rule(Parser *p)
{}

// star_etc:
//     | invalid_star_etc
//     | '*' param_no_default param_maybe_default* kwds?
//     | '*' param_no_default_star_annotation param_maybe_default* kwds?
//     | '*' ',' param_maybe_default+ kwds?
//     | kwds
static StarEtc*
star_etc_rule(Parser *p)
{}

// kwds: invalid_kwds | '**' param_no_default
static arg_ty
kwds_rule(Parser *p)
{}

// param_no_default: param ',' TYPE_COMMENT? | param TYPE_COMMENT? &')'
static arg_ty
param_no_default_rule(Parser *p)
{}

// param_no_default_star_annotation:
//     | param_star_annotation ',' TYPE_COMMENT?
//     | param_star_annotation TYPE_COMMENT? &')'
static arg_ty
param_no_default_star_annotation_rule(Parser *p)
{}

// param_with_default: param default ',' TYPE_COMMENT? | param default TYPE_COMMENT? &')'
static NameDefaultPair*
param_with_default_rule(Parser *p)
{}

// param_maybe_default:
//     | param default? ',' TYPE_COMMENT?
//     | param default? TYPE_COMMENT? &')'
static NameDefaultPair*
param_maybe_default_rule(Parser *p)
{}

// param: NAME annotation?
static arg_ty
param_rule(Parser *p)
{}

// param_star_annotation: NAME star_annotation
static arg_ty
param_star_annotation_rule(Parser *p)
{}

// annotation: ':' expression
static expr_ty
annotation_rule(Parser *p)
{}

// star_annotation: ':' star_expression
static expr_ty
star_annotation_rule(Parser *p)
{}

// default: '=' expression | invalid_default
static expr_ty
default_rule(Parser *p)
{}

// if_stmt:
//     | invalid_if_stmt
//     | 'if' named_expression ':' block elif_stmt
//     | 'if' named_expression ':' block else_block?
static stmt_ty
if_stmt_rule(Parser *p)
{}

// elif_stmt:
//     | invalid_elif_stmt
//     | 'elif' named_expression ':' block elif_stmt
//     | 'elif' named_expression ':' block else_block?
static stmt_ty
elif_stmt_rule(Parser *p)
{}

// else_block: invalid_else_stmt | 'else' &&':' block
static asdl_stmt_seq*
else_block_rule(Parser *p)
{}

// while_stmt: invalid_while_stmt | 'while' named_expression ':' block else_block?
static stmt_ty
while_stmt_rule(Parser *p)
{}

// for_stmt:
//     | invalid_for_stmt
//     | 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
//     | 'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
//     | invalid_for_target
static stmt_ty
for_stmt_rule(Parser *p)
{}

// with_stmt:
//     | invalid_with_stmt_indent
//     | 'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block
//     | 'with' ','.with_item+ ':' TYPE_COMMENT? block
//     | 'async' 'with' '(' ','.with_item+ ','? ')' ':' block
//     | 'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block
//     | invalid_with_stmt
static stmt_ty
with_stmt_rule(Parser *p)
{}

// with_item:
//     | expression 'as' star_target &(',' | ')' | ':')
//     | invalid_with_item
//     | expression
static withitem_ty
with_item_rule(Parser *p)
{}

// try_stmt:
//     | invalid_try_stmt
//     | 'try' &&':' block finally_block
//     | 'try' &&':' block except_block+ else_block? finally_block?
//     | 'try' &&':' block except_star_block+ else_block? finally_block?
static stmt_ty
try_stmt_rule(Parser *p)
{}

// except_block:
//     | invalid_except_stmt_indent
//     | 'except' expression ['as' NAME] ':' block
//     | 'except' ':' block
//     | invalid_except_stmt
static excepthandler_ty
except_block_rule(Parser *p)
{}

// except_star_block:
//     | invalid_except_star_stmt_indent
//     | 'except' '*' expression ['as' NAME] ':' block
//     | invalid_except_star_stmt
static excepthandler_ty
except_star_block_rule(Parser *p)
{}

// finally_block: invalid_finally_stmt | 'finally' &&':' block
static asdl_stmt_seq*
finally_block_rule(Parser *p)
{}

// match_stmt:
//     | "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT
//     | invalid_match_stmt
static stmt_ty
match_stmt_rule(Parser *p)
{}

// subject_expr: star_named_expression ',' star_named_expressions? | named_expression
static expr_ty
subject_expr_rule(Parser *p)
{}

// case_block: invalid_case_block | "case" patterns guard? ':' block
static match_case_ty
case_block_rule(Parser *p)
{}

// guard: 'if' named_expression
static expr_ty
guard_rule(Parser *p)
{}

// patterns: open_sequence_pattern | pattern
static pattern_ty
patterns_rule(Parser *p)
{}

// pattern: as_pattern | or_pattern
static pattern_ty
pattern_rule(Parser *p)
{}

// as_pattern: or_pattern 'as' pattern_capture_target | invalid_as_pattern
static pattern_ty
as_pattern_rule(Parser *p)
{}

// or_pattern: '|'.closed_pattern+
static pattern_ty
or_pattern_rule(Parser *p)
{}

// closed_pattern:
//     | literal_pattern
//     | capture_pattern
//     | wildcard_pattern
//     | value_pattern
//     | group_pattern
//     | sequence_pattern
//     | mapping_pattern
//     | class_pattern
static pattern_ty
closed_pattern_rule(Parser *p)
{}

// literal_pattern:
//     | signed_number !('+' | '-')
//     | complex_number
//     | strings
//     | 'None'
//     | 'True'
//     | 'False'
static pattern_ty
literal_pattern_rule(Parser *p)
{}

// literal_expr:
//     | signed_number !('+' | '-')
//     | complex_number
//     | strings
//     | 'None'
//     | 'True'
//     | 'False'
static expr_ty
literal_expr_rule(Parser *p)
{}

// complex_number:
//     | signed_real_number '+' imaginary_number
//     | signed_real_number '-' imaginary_number
static expr_ty
complex_number_rule(Parser *p)
{}

// signed_number: NUMBER | '-' NUMBER
static expr_ty
signed_number_rule(Parser *p)
{}

// signed_real_number: real_number | '-' real_number
static expr_ty
signed_real_number_rule(Parser *p)
{}

// real_number: NUMBER
static expr_ty
real_number_rule(Parser *p)
{}

// imaginary_number: NUMBER
static expr_ty
imaginary_number_rule(Parser *p)
{}

// capture_pattern: pattern_capture_target
static pattern_ty
capture_pattern_rule(Parser *p)
{}

// pattern_capture_target: !"_" NAME !('.' | '(' | '=')
static expr_ty
pattern_capture_target_rule(Parser *p)
{}

// wildcard_pattern: "_"
static pattern_ty
wildcard_pattern_rule(Parser *p)
{}

// value_pattern: attr !('.' | '(' | '=')
static pattern_ty
value_pattern_rule(Parser *p)
{}

// Left-recursive
// attr: name_or_attr '.' NAME
static expr_ty attr_raw(Parser *);
static expr_ty
attr_rule(Parser *p)
{}
static expr_ty
attr_raw(Parser *p)
{}

// Left-recursive
// name_or_attr: attr | NAME
static expr_ty
name_or_attr_rule(Parser *p)
{}

// group_pattern: '(' pattern ')'
static pattern_ty
group_pattern_rule(Parser *p)
{}

// sequence_pattern: '[' maybe_sequence_pattern? ']' | '(' open_sequence_pattern? ')'
static pattern_ty
sequence_pattern_rule(Parser *p)
{}

// open_sequence_pattern: maybe_star_pattern ',' maybe_sequence_pattern?
static asdl_seq*
open_sequence_pattern_rule(Parser *p)
{}

// maybe_sequence_pattern: ','.maybe_star_pattern+ ','?
static asdl_seq*
maybe_sequence_pattern_rule(Parser *p)
{}

// maybe_star_pattern: star_pattern | pattern
static pattern_ty
maybe_star_pattern_rule(Parser *p)
{}

// star_pattern: '*' pattern_capture_target | '*' wildcard_pattern
static pattern_ty
star_pattern_rule(Parser *p)
{}

// mapping_pattern:
//     | '{' '}'
//     | '{' double_star_pattern ','? '}'
//     | '{' items_pattern ',' double_star_pattern ','? '}'
//     | '{' items_pattern ','? '}'
static pattern_ty
mapping_pattern_rule(Parser *p)
{}

// items_pattern: ','.key_value_pattern+
static asdl_seq*
items_pattern_rule(Parser *p)
{}

// key_value_pattern: (literal_expr | attr) ':' pattern
static KeyPatternPair*
key_value_pattern_rule(Parser *p)
{}

// double_star_pattern: '**' pattern_capture_target
static expr_ty
double_star_pattern_rule(Parser *p)
{}

// class_pattern:
//     | name_or_attr '(' ')'
//     | name_or_attr '(' positional_patterns ','? ')'
//     | name_or_attr '(' keyword_patterns ','? ')'
//     | name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'
//     | invalid_class_pattern
static pattern_ty
class_pattern_rule(Parser *p)
{}

// positional_patterns: ','.pattern+
static asdl_pattern_seq*
positional_patterns_rule(Parser *p)
{}

// keyword_patterns: ','.keyword_pattern+
static asdl_seq*
keyword_patterns_rule(Parser *p)
{}

// keyword_pattern: NAME '=' pattern
static KeyPatternPair*
keyword_pattern_rule(Parser *p)
{}

// type_alias: "type" NAME type_params? '=' expression
static stmt_ty
type_alias_rule(Parser *p)
{}

// type_params: invalid_type_params | '[' type_param_seq ']'
static asdl_type_param_seq*
type_params_rule(Parser *p)
{}

// type_param_seq: ','.type_param+ ','?
static asdl_type_param_seq*
type_param_seq_rule(Parser *p)
{}

// type_param:
//     | NAME type_param_bound? type_param_default?
//     | invalid_type_param
//     | '*' NAME type_param_starred_default?
//     | '**' NAME type_param_default?
static type_param_ty
type_param_rule(Parser *p)
{}

// type_param_bound: ':' expression
static expr_ty
type_param_bound_rule(Parser *p)
{}

// type_param_default: '=' expression
static expr_ty
type_param_default_rule(Parser *p)
{}

// type_param_starred_default: '=' star_expression
static expr_ty
type_param_starred_default_rule(Parser *p)
{}

// expressions: expression ((',' expression))+ ','? | expression ',' | expression
static expr_ty
expressions_rule(Parser *p)
{}

// expression:
//     | invalid_expression
//     | invalid_legacy_expression
//     | disjunction 'if' disjunction 'else' expression
//     | disjunction
//     | lambdef
static expr_ty
expression_rule(Parser *p)
{}

// yield_expr: 'yield' 'from' expression | 'yield' star_expressions?
static expr_ty
yield_expr_rule(Parser *p)
{}

// star_expressions:
//     | star_expression ((',' star_expression))+ ','?
//     | star_expression ','
//     | star_expression
static expr_ty
star_expressions_rule(Parser *p)
{}

// star_expression: '*' bitwise_or | expression
static expr_ty
star_expression_rule(Parser *p)
{}

// star_named_expressions: ','.star_named_expression+ ','?
static asdl_expr_seq*
star_named_expressions_rule(Parser *p)
{}

// star_named_expression: '*' bitwise_or | named_expression
static expr_ty
star_named_expression_rule(Parser *p)
{}

// assignment_expression: NAME ':=' ~ expression
static expr_ty
assignment_expression_rule(Parser *p)
{}

// named_expression: assignment_expression | invalid_named_expression | expression !':='
static expr_ty
named_expression_rule(Parser *p)
{}

// disjunction: conjunction (('or' conjunction))+ | conjunction
static expr_ty
disjunction_rule(Parser *p)
{}

// conjunction: inversion (('and' inversion))+ | inversion
static expr_ty
conjunction_rule(Parser *p)
{}

// inversion: 'not' inversion | comparison
static expr_ty
inversion_rule(Parser *p)
{}

// comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or
static expr_ty
comparison_rule(Parser *p)
{}

// compare_op_bitwise_or_pair:
//     | eq_bitwise_or
//     | noteq_bitwise_or
//     | lte_bitwise_or
//     | lt_bitwise_or
//     | gte_bitwise_or
//     | gt_bitwise_or
//     | notin_bitwise_or
//     | in_bitwise_or
//     | isnot_bitwise_or
//     | is_bitwise_or
static CmpopExprPair*
compare_op_bitwise_or_pair_rule(Parser *p)
{}

// eq_bitwise_or: '==' bitwise_or
static CmpopExprPair*
eq_bitwise_or_rule(Parser *p)
{}

// noteq_bitwise_or: ('!=') bitwise_or
static CmpopExprPair*
noteq_bitwise_or_rule(Parser *p)
{}

// lte_bitwise_or: '<=' bitwise_or
static CmpopExprPair*
lte_bitwise_or_rule(Parser *p)
{}

// lt_bitwise_or: '<' bitwise_or
static CmpopExprPair*
lt_bitwise_or_rule(Parser *p)
{}

// gte_bitwise_or: '>=' bitwise_or
static CmpopExprPair*
gte_bitwise_or_rule(Parser *p)
{}

// gt_bitwise_or: '>' bitwise_or
static CmpopExprPair*
gt_bitwise_or_rule(Parser *p)
{}

// notin_bitwise_or: 'not' 'in' bitwise_or
static CmpopExprPair*
notin_bitwise_or_rule(Parser *p)
{}

// in_bitwise_or: 'in' bitwise_or
static CmpopExprPair*
in_bitwise_or_rule(Parser *p)
{}

// isnot_bitwise_or: 'is' 'not' bitwise_or
static CmpopExprPair*
isnot_bitwise_or_rule(Parser *p)
{}

// is_bitwise_or: 'is' bitwise_or
static CmpopExprPair*
is_bitwise_or_rule(Parser *p)
{}

// Left-recursive
// bitwise_or: bitwise_or '|' bitwise_xor | bitwise_xor
static expr_ty bitwise_or_raw(Parser *);
static expr_ty
bitwise_or_rule(Parser *p)
{}
static expr_ty
bitwise_or_raw(Parser *p)
{}

// Left-recursive
// bitwise_xor: bitwise_xor '^' bitwise_and | bitwise_and
static expr_ty bitwise_xor_raw(Parser *);
static expr_ty
bitwise_xor_rule(Parser *p)
{}
static expr_ty
bitwise_xor_raw(Parser *p)
{}

// Left-recursive
// bitwise_and: bitwise_and '&' shift_expr | shift_expr
static expr_ty bitwise_and_raw(Parser *);
static expr_ty
bitwise_and_rule(Parser *p)
{}
static expr_ty
bitwise_and_raw(Parser *p)
{}

// Left-recursive
// shift_expr: shift_expr '<<' sum | shift_expr '>>' sum | invalid_arithmetic | sum
static expr_ty shift_expr_raw(Parser *);
static expr_ty
shift_expr_rule(Parser *p)
{}
static expr_ty
shift_expr_raw(Parser *p)
{}

// Left-recursive
// sum: sum '+' term | sum '-' term | term
static expr_ty sum_raw(Parser *);
static expr_ty
sum_rule(Parser *p)
{}
static expr_ty
sum_raw(Parser *p)
{}

// Left-recursive
// term:
//     | term '*' factor
//     | term '/' factor
//     | term '//' factor
//     | term '%' factor
//     | term '@' factor
//     | invalid_factor
//     | factor
static expr_ty term_raw(Parser *);
static expr_ty
term_rule(Parser *p)
{}
static expr_ty
term_raw(Parser *p)
{}

// factor: '+' factor | '-' factor | '~' factor | power
static expr_ty
factor_rule(Parser *p)
{}

// power: await_primary '**' factor | await_primary
static expr_ty
power_rule(Parser *p)
{}

// await_primary: 'await' primary | primary
static expr_ty
await_primary_rule(Parser *p)
{}

// Left-recursive
// primary:
//     | primary '.' NAME
//     | primary genexp
//     | primary '(' arguments? ')'
//     | primary '[' slices ']'
//     | atom
static expr_ty primary_raw(Parser *);
static expr_ty
primary_rule(Parser *p)
{}
static expr_ty
primary_raw(Parser *p)
{}

// slices: slice !',' | ','.(slice | starred_expression)+ ','?
static expr_ty
slices_rule(Parser *p)
{}

// slice: expression? ':' expression? [':' expression?] | named_expression
static expr_ty
slice_rule(Parser *p)
{}

// atom:
//     | NAME
//     | 'True'
//     | 'False'
//     | 'None'
//     | &(STRING | FSTRING_START) strings
//     | NUMBER
//     | &'(' (tuple | group | genexp)
//     | &'[' (list | listcomp)
//     | &'{' (dict | set | dictcomp | setcomp)
//     | '...'
static expr_ty
atom_rule(Parser *p)
{}

// group: '(' (yield_expr | named_expression) ')' | invalid_group
static expr_ty
group_rule(Parser *p)
{}

// lambdef: 'lambda' lambda_params? ':' expression
static expr_ty
lambdef_rule(Parser *p)
{}

// lambda_params: invalid_lambda_parameters | lambda_parameters
static arguments_ty
lambda_params_rule(Parser *p)
{}

// lambda_parameters:
//     | lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?
//     | lambda_slash_with_default lambda_param_with_default* lambda_star_etc?
//     | lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?
//     | lambda_param_with_default+ lambda_star_etc?
//     | lambda_star_etc
static arguments_ty
lambda_parameters_rule(Parser *p)
{}

// lambda_slash_no_default:
//     | lambda_param_no_default+ '/' ','
//     | lambda_param_no_default+ '/' &':'
static asdl_arg_seq*
lambda_slash_no_default_rule(Parser *p)
{}

// lambda_slash_with_default:
//     | lambda_param_no_default* lambda_param_with_default+ '/' ','
//     | lambda_param_no_default* lambda_param_with_default+ '/' &':'
static SlashWithDefault*
lambda_slash_with_default_rule(Parser *p)
{}

// lambda_star_etc:
//     | invalid_lambda_star_etc
//     | '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?
//     | '*' ',' lambda_param_maybe_default+ lambda_kwds?
//     | lambda_kwds
static StarEtc*
lambda_star_etc_rule(Parser *p)
{}

// lambda_kwds: invalid_lambda_kwds | '**' lambda_param_no_default
static arg_ty
lambda_kwds_rule(Parser *p)
{}

// lambda_param_no_default: lambda_param ',' | lambda_param &':'
static arg_ty
lambda_param_no_default_rule(Parser *p)
{}

// lambda_param_with_default: lambda_param default ',' | lambda_param default &':'
static NameDefaultPair*
lambda_param_with_default_rule(Parser *p)
{}

// lambda_param_maybe_default: lambda_param default? ',' | lambda_param default? &':'
static NameDefaultPair*
lambda_param_maybe_default_rule(Parser *p)
{}

// lambda_param: NAME
static arg_ty
lambda_param_rule(Parser *p)
{}

// fstring_middle: fstring_replacement_field | FSTRING_MIDDLE
static expr_ty
fstring_middle_rule(Parser *p)
{}

// fstring_replacement_field:
//     | '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'
//     | invalid_replacement_field
static expr_ty
fstring_replacement_field_rule(Parser *p)
{}

// fstring_conversion: "!" NAME
static ResultTokenWithMetadata*
fstring_conversion_rule(Parser *p)
{}

// fstring_full_format_spec: ':' fstring_format_spec*
static ResultTokenWithMetadata*
fstring_full_format_spec_rule(Parser *p)
{}

// fstring_format_spec: FSTRING_MIDDLE | fstring_replacement_field
static expr_ty
fstring_format_spec_rule(Parser *p)
{}

// fstring: FSTRING_START fstring_middle* FSTRING_END
static expr_ty
fstring_rule(Parser *p)
{}

// string: STRING
static expr_ty
string_rule(Parser *p)
{}

// strings: ((fstring | string))+
static expr_ty
strings_rule(Parser *p)
{}

// list: '[' star_named_expressions? ']'
static expr_ty
list_rule(Parser *p)
{}

// tuple: '(' [star_named_expression ',' star_named_expressions?] ')'
static expr_ty
tuple_rule(Parser *p)
{}

// set: '{' star_named_expressions '}'
static expr_ty
set_rule(Parser *p)
{}

// dict: '{' double_starred_kvpairs? '}' | '{' invalid_double_starred_kvpairs '}'
static expr_ty
dict_rule(Parser *p)
{}

// double_starred_kvpairs: ','.double_starred_kvpair+ ','?
static asdl_seq*
double_starred_kvpairs_rule(Parser *p)
{}

// double_starred_kvpair: '**' bitwise_or | kvpair
static KeyValuePair*
double_starred_kvpair_rule(Parser *p)
{}

// kvpair: expression ':' expression
static KeyValuePair*
kvpair_rule(Parser *p)
{}

// for_if_clauses: for_if_clause+
static asdl_comprehension_seq*
for_if_clauses_rule(Parser *p)
{}

// for_if_clause:
//     | 'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
//     | 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
//     | invalid_for_if_clause
//     | invalid_for_target
static comprehension_ty
for_if_clause_rule(Parser *p)
{}

// listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension
static expr_ty
listcomp_rule(Parser *p)
{}

// setcomp: '{' named_expression for_if_clauses '}' | invalid_comprehension
static expr_ty
setcomp_rule(Parser *p)
{}

// genexp:
//     | '(' (assignment_expression | expression !':=') for_if_clauses ')'
//     | invalid_comprehension
static expr_ty
genexp_rule(Parser *p)
{}

// dictcomp: '{' kvpair for_if_clauses '}' | invalid_dict_comprehension
static expr_ty
dictcomp_rule(Parser *p)
{}

// arguments: args ','? &')' | invalid_arguments
static expr_ty
arguments_rule(Parser *p)
{}

// args:
//     | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]
//     | kwargs
static expr_ty
args_rule(Parser *p)
{}

// kwargs:
//     | ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
//     | ','.kwarg_or_starred+
//     | ','.kwarg_or_double_starred+
static asdl_seq*
kwargs_rule(Parser *p)
{}

// starred_expression:
//     | invalid_starred_expression_unpacking
//     | '*' expression
//     | invalid_starred_expression
static expr_ty
starred_expression_rule(Parser *p)
{}

// kwarg_or_starred: invalid_kwarg | NAME '=' expression | starred_expression
static KeywordOrStarred*
kwarg_or_starred_rule(Parser *p)
{}

// kwarg_or_double_starred: invalid_kwarg | NAME '=' expression | '**' expression
static KeywordOrStarred*
kwarg_or_double_starred_rule(Parser *p)
{}

// star_targets: star_target !',' | star_target ((',' star_target))* ','?
static expr_ty
star_targets_rule(Parser *p)
{}

// star_targets_list_seq: ','.star_target+ ','?
static asdl_expr_seq*
star_targets_list_seq_rule(Parser *p)
{}

// star_targets_tuple_seq: star_target ((',' star_target))+ ','? | star_target ','
static asdl_expr_seq*
star_targets_tuple_seq_rule(Parser *p)
{}

// star_target: '*' (!'*' star_target) | target_with_star_atom
static expr_ty
star_target_rule(Parser *p)
{}

// target_with_star_atom:
//     | t_primary '.' NAME !t_lookahead
//     | t_primary '[' slices ']' !t_lookahead
//     | star_atom
static expr_ty
target_with_star_atom_rule(Parser *p)
{}

// star_atom:
//     | NAME
//     | '(' target_with_star_atom ')'
//     | '(' star_targets_tuple_seq? ')'
//     | '[' star_targets_list_seq? ']'
static expr_ty
star_atom_rule(Parser *p)
{}

// single_target: single_subscript_attribute_target | NAME | '(' single_target ')'
static expr_ty
single_target_rule(Parser *p)
{}

// single_subscript_attribute_target:
//     | t_primary '.' NAME !t_lookahead
//     | t_primary '[' slices ']' !t_lookahead
static expr_ty
single_subscript_attribute_target_rule(Parser *p)
{}

// Left-recursive
// t_primary:
//     | t_primary '.' NAME &t_lookahead
//     | t_primary '[' slices ']' &t_lookahead
//     | t_primary genexp &t_lookahead
//     | t_primary '(' arguments? ')' &t_lookahead
//     | atom &t_lookahead
static expr_ty t_primary_raw(Parser *);
static expr_ty
t_primary_rule(Parser *p)
{}
static expr_ty
t_primary_raw(Parser *p)
{}

// t_lookahead: '(' | '[' | '.'
static void *
t_lookahead_rule(Parser *p)
{}

// del_targets: ','.del_target+ ','?
static asdl_expr_seq*
del_targets_rule(Parser *p)
{}

// del_target:
//     | t_primary '.' NAME !t_lookahead
//     | t_primary '[' slices ']' !t_lookahead
//     | del_t_atom
static expr_ty
del_target_rule(Parser *p)
{}

// del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']'
static expr_ty
del_t_atom_rule(Parser *p)
{}

// type_expressions:
//     | ','.expression+ ',' '*' expression ',' '**' expression
//     | ','.expression+ ',' '*' expression
//     | ','.expression+ ',' '**' expression
//     | '*' expression ',' '**' expression
//     | '*' expression
//     | '**' expression
//     | ','.expression+
static asdl_expr_seq*
type_expressions_rule(Parser *p)
{}

// func_type_comment:
//     | NEWLINE TYPE_COMMENT &(NEWLINE INDENT)
//     | invalid_double_type_comments
//     | TYPE_COMMENT
static Token*
func_type_comment_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
static void *
invalid_arguments_rule(Parser *p)
{}

// invalid_kwarg:
//     | ('True' | 'False' | 'None') '='
//     | NAME '=' expression for_if_clauses
//     | !(NAME '=') expression '='
//     | '**' expression '=' expression
static void *
invalid_kwarg_rule(Parser *p)
{}

// expression_without_invalid:
//     | disjunction 'if' disjunction 'else' expression
//     | disjunction
//     | lambdef
static expr_ty
expression_without_invalid_rule(Parser *p)
{}

// invalid_legacy_expression: NAME !'(' star_expressions
static void *
invalid_legacy_expression_rule(Parser *p)
{}

// invalid_type_param: '*' NAME ':' expression | '**' NAME ':' expression
static void *
invalid_type_param_rule(Parser *p)
{}

// invalid_expression:
//     | !(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid
//     | disjunction 'if' disjunction !('else' | ':')
//     | 'lambda' lambda_params? ':' &FSTRING_MIDDLE
static void *
invalid_expression_rule(Parser *p)
{}

// invalid_named_expression:
//     | expression ':=' expression
//     | NAME '=' bitwise_or !('=' | ':=')
//     | !(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')
static void *
invalid_named_expression_rule(Parser *p)
{}

// invalid_assignment:
//     | invalid_ann_assign_target ':' expression
//     | star_named_expression ',' star_named_expressions* ':' expression
//     | expression ':' expression
//     | ((star_targets '='))* star_expressions '='
//     | ((star_targets '='))* yield_expr '='
//     | star_expressions augassign annotated_rhs
static void *
invalid_assignment_rule(Parser *p)
{}

// invalid_ann_assign_target: list | tuple | '(' invalid_ann_assign_target ')'
static expr_ty
invalid_ann_assign_target_rule(Parser *p)
{}

// invalid_del_stmt: 'del' star_expressions
static void *
invalid_del_stmt_rule(Parser *p)
{}

// invalid_block: NEWLINE !INDENT
static void *
invalid_block_rule(Parser *p)
{}

// invalid_comprehension:
//     | ('[' | '(' | '{') starred_expression for_if_clauses
//     | ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses
//     | ('[' | '{') star_named_expression ',' for_if_clauses
static void *
invalid_comprehension_rule(Parser *p)
{}

// invalid_dict_comprehension: '{' '**' bitwise_or for_if_clauses '}'
static void *
invalid_dict_comprehension_rule(Parser *p)
{}

// invalid_parameters:
//     | "/" ','
//     | (slash_no_default | slash_with_default) param_maybe_default* '/'
//     | slash_no_default? param_no_default* invalid_parameters_helper param_no_default
//     | param_no_default* '(' param_no_default+ ','? ')'
//     | [(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'
//     | param_maybe_default+ '/' '*'
static void *
invalid_parameters_rule(Parser *p)
{}

// invalid_default: '=' &(')' | ',')
static void *
invalid_default_rule(Parser *p)
{}

// invalid_star_etc:
//     | '*' (')' | ',' (')' | '**'))
//     | '*' ',' TYPE_COMMENT
//     | '*' param '='
//     | '*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')
static void *
invalid_star_etc_rule(Parser *p)
{}

// invalid_kwds: '**' param '=' | '**' param ',' param | '**' param ',' ('*' | '**' | '/')
static void *
invalid_kwds_rule(Parser *p)
{}

// invalid_parameters_helper: slash_with_default | param_with_default+
static void *
invalid_parameters_helper_rule(Parser *p)
{}

// invalid_lambda_parameters:
//     | "/" ','
//     | (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'
//     | lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default
//     | lambda_param_no_default* '(' ','.lambda_param+ ','? ')'
//     | [(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'
//     | lambda_param_maybe_default+ '/' '*'
static void *
invalid_lambda_parameters_rule(Parser *p)
{}

// invalid_lambda_parameters_helper:
//     | lambda_slash_with_default
//     | lambda_param_with_default+
static void *
invalid_lambda_parameters_helper_rule(Parser *p)
{}

// invalid_lambda_star_etc:
//     | '*' (':' | ',' (':' | '**'))
//     | '*' lambda_param '='
//     | '*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')
static void *
invalid_lambda_star_etc_rule(Parser *p)
{}

// invalid_lambda_kwds:
//     | '**' lambda_param '='
//     | '**' lambda_param ',' lambda_param
//     | '**' lambda_param ',' ('*' | '**' | '/')
static void *
invalid_lambda_kwds_rule(Parser *p)
{}

// invalid_double_type_comments: TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT
static void *
invalid_double_type_comments_rule(Parser *p)
{}

// invalid_with_item: expression 'as' expression &(',' | ')' | ':')
static void *
invalid_with_item_rule(Parser *p)
{}

// invalid_for_if_clause: 'async'? 'for' (bitwise_or ((',' bitwise_or))* ','?) !'in'
static void *
invalid_for_if_clause_rule(Parser *p)
{}

// invalid_for_target: 'async'? 'for' star_expressions
static void *
invalid_for_target_rule(Parser *p)
{}

// invalid_group: '(' starred_expression ')' | '(' '**' expression ')'
static void *
invalid_group_rule(Parser *p)
{}

// invalid_import: 'import' ','.dotted_name+ 'from' dotted_name | 'import' NEWLINE
static void *
invalid_import_rule(Parser *p)
{}

// invalid_import_from_targets: import_from_as_names ',' NEWLINE | NEWLINE
static void *
invalid_import_from_targets_rule(Parser *p)
{}

// invalid_with_stmt:
//     | 'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE
//     | 'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE
static void *
invalid_with_stmt_rule(Parser *p)
{}

// invalid_with_stmt_indent:
//     | 'async'? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT
//     | 'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT
static void *
invalid_with_stmt_indent_rule(Parser *p)
{}

// invalid_try_stmt:
//     | 'try' ':' NEWLINE !INDENT
//     | 'try' ':' block !('except' | 'finally')
//     | 'try' ':' block* except_block+ 'except' '*' expression ['as' NAME] ':'
//     | 'try' ':' block* except_star_block+ 'except' [expression ['as' NAME]] ':'
static void *
invalid_try_stmt_rule(Parser *p)
{}

// invalid_except_stmt:
//     | 'except' expression ',' expressions ['as' NAME] ':'
//     | 'except' expression ['as' NAME] NEWLINE
//     | 'except' NEWLINE
//     | 'except' expression 'as' expression
static void *
invalid_except_stmt_rule(Parser *p)
{}

// invalid_except_star_stmt:
//     | 'except' '*' expression ',' expressions ['as' NAME] ':'
//     | 'except' '*' expression ['as' NAME] NEWLINE
//     | 'except' '*' (NEWLINE | ':')
//     | 'except' '*' expression 'as' expression
static void *
invalid_except_star_stmt_rule(Parser *p)
{}

// invalid_finally_stmt: 'finally' ':' NEWLINE !INDENT
static void *
invalid_finally_stmt_rule(Parser *p)
{}

// invalid_except_stmt_indent:
//     | 'except' expression ['as' NAME] ':' NEWLINE !INDENT
//     | 'except' ':' NEWLINE !INDENT
static void *
invalid_except_stmt_indent_rule(Parser *p)
{}

// invalid_except_star_stmt_indent:
//     | 'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT
static void *
invalid_except_star_stmt_indent_rule(Parser *p)
{}

// invalid_match_stmt:
//     | "match" subject_expr NEWLINE
//     | "match" subject_expr ':' NEWLINE !INDENT
static void *
invalid_match_stmt_rule(Parser *p)
{}

// invalid_case_block:
//     | "case" patterns guard? NEWLINE
//     | "case" patterns guard? ':' NEWLINE !INDENT
static void *
invalid_case_block_rule(Parser *p)
{}

// invalid_as_pattern: or_pattern 'as' "_" | or_pattern 'as' expression
static void *
invalid_as_pattern_rule(Parser *p)
{}

// invalid_class_pattern: name_or_attr '(' invalid_class_argument_pattern
static void *
invalid_class_pattern_rule(Parser *p)
{}

// invalid_class_argument_pattern:
//     | [positional_patterns ','] keyword_patterns ',' positional_patterns
static asdl_pattern_seq*
invalid_class_argument_pattern_rule(Parser *p)
{}

// invalid_if_stmt:
//     | 'if' named_expression NEWLINE
//     | 'if' named_expression ':' NEWLINE !INDENT
static void *
invalid_if_stmt_rule(Parser *p)
{}

// invalid_elif_stmt:
//     | 'elif' named_expression NEWLINE
//     | 'elif' named_expression ':' NEWLINE !INDENT
static void *
invalid_elif_stmt_rule(Parser *p)
{}

// invalid_else_stmt: 'else' ':' NEWLINE !INDENT
static void *
invalid_else_stmt_rule(Parser *p)
{}

// invalid_while_stmt:
//     | 'while' named_expression NEWLINE
//     | 'while' named_expression ':' NEWLINE !INDENT
static void *
invalid_while_stmt_rule(Parser *p)
{}

// invalid_for_stmt:
//     | 'async'? 'for' star_targets 'in' star_expressions NEWLINE
//     | 'async'? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT
static void *
invalid_for_stmt_rule(Parser *p)
{}

// invalid_def_raw:
//     | 'async'? 'def' NAME type_params? '(' params? ')' ['->' expression] ':' NEWLINE !INDENT
//     | 'async'? 'def' NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block
static void *
invalid_def_raw_rule(Parser *p)
{}

// invalid_class_def_raw:
//     | 'class' NAME type_params? ['(' arguments? ')'] NEWLINE
//     | 'class' NAME type_params? ['(' arguments? ')'] ':' NEWLINE !INDENT
static void *
invalid_class_def_raw_rule(Parser *p)
{}

// invalid_double_starred_kvpairs:
//     | ','.double_starred_kvpair+ ',' invalid_kvpair
//     | expression ':' '*' bitwise_or
//     | expression ':' &('}' | ',')
static void *
invalid_double_starred_kvpairs_rule(Parser *p)
{}

// invalid_kvpair:
//     | expression !(':')
//     | expression ':' '*' bitwise_or
//     | expression ':' &('}' | ',')
static void *
invalid_kvpair_rule(Parser *p)
{}

// invalid_starred_expression_unpacking: '*' expression '=' expression
static void *
invalid_starred_expression_unpacking_rule(Parser *p)
{}

// invalid_starred_expression: '*'
static void *
invalid_starred_expression_rule(Parser *p)
{}

// invalid_replacement_field:
//     | '{' '='
//     | '{' '!'
//     | '{' ':'
//     | '{' '}'
//     | '{' !annotated_rhs
//     | '{' annotated_rhs !('=' | '!' | ':' | '}')
//     | '{' annotated_rhs '=' !('!' | ':' | '}')
//     | '{' annotated_rhs '='? invalid_conversion_character
//     | '{' annotated_rhs '='? ['!' NAME] !(':' | '}')
//     | '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'
//     | '{' annotated_rhs '='? ['!' NAME] !'}'
static void *
invalid_replacement_field_rule(Parser *p)
{}

// invalid_conversion_character: '!' &(':' | '}') | '!' !NAME
static void *
invalid_conversion_character_rule(Parser *p)
{}

// invalid_arithmetic: sum ('+' | '-' | '*' | '/' | '%' | '//' | '@') 'not' inversion
static void *
invalid_arithmetic_rule(Parser *p)
{}

// invalid_factor: ('+' | '-' | '~') 'not' factor
static void *
invalid_factor_rule(Parser *p)
{}

// invalid_type_params: '[' ']'
static void *
invalid_type_params_rule(Parser *p)
{}

// _loop0_1: NEWLINE
static asdl_seq *
_loop0_1_rule(Parser *p)
{}

// _loop0_2: NEWLINE
static asdl_seq *
_loop0_2_rule(Parser *p)
{}

// _loop1_3: statement
static asdl_seq *
_loop1_3_rule(Parser *p)
{}

// _loop0_5: ';' simple_stmt
static asdl_seq *
_loop0_5_rule(Parser *p)
{}

// _gather_4: simple_stmt _loop0_5
static asdl_seq *
_gather_4_rule(Parser *p)
{}

// _tmp_6: 'import' | 'from'
static void *
_tmp_6_rule(Parser *p)
{}

// _tmp_7: 'def' | '@' | 'async'
static void *
_tmp_7_rule(Parser *p)
{}

// _tmp_8: 'class' | '@'
static void *
_tmp_8_rule(Parser *p)
{}

// _tmp_9: 'with' | 'async'
static void *
_tmp_9_rule(Parser *p)
{}

// _tmp_10: 'for' | 'async'
static void *
_tmp_10_rule(Parser *p)
{}

// _tmp_11: '=' annotated_rhs
static void *
_tmp_11_rule(Parser *p)
{}

// _tmp_12: '(' single_target ')' | single_subscript_attribute_target
static void *
_tmp_12_rule(Parser *p)
{}

// _tmp_13: '=' annotated_rhs
static void *
_tmp_13_rule(Parser *p)
{}

// _loop1_14: (star_targets '=')
static asdl_seq *
_loop1_14_rule(Parser *p)
{}

// _tmp_15: yield_expr | star_expressions
static void *
_tmp_15_rule(Parser *p)
{}

// _tmp_16: yield_expr | star_expressions
static void *
_tmp_16_rule(Parser *p)
{}

// _tmp_17: 'from' expression
static void *
_tmp_17_rule(Parser *p)
{}

// _loop0_19: ',' NAME
static asdl_seq *
_loop0_19_rule(Parser *p)
{}

// _gather_18: NAME _loop0_19
static asdl_seq *
_gather_18_rule(Parser *p)
{}

// _loop0_21: ',' NAME
static asdl_seq *
_loop0_21_rule(Parser *p)
{}

// _gather_20: NAME _loop0_21
static asdl_seq *
_gather_20_rule(Parser *p)
{}

// _tmp_22: ';' | NEWLINE
static void *
_tmp_22_rule(Parser *p)
{}

// _tmp_23: ',' expression
static void *
_tmp_23_rule(Parser *p)
{}

// _loop0_24: ('.' | '...')
static asdl_seq *
_loop0_24_rule(Parser *p)
{}

// _loop1_25: ('.' | '...')
static asdl_seq *
_loop1_25_rule(Parser *p)
{}

// _loop0_27: ',' import_from_as_name
static asdl_seq *
_loop0_27_rule(Parser *p)
{}

// _gather_26: import_from_as_name _loop0_27
static asdl_seq *
_gather_26_rule(Parser *p)
{}

// _tmp_28: 'as' NAME
static void *
_tmp_28_rule(Parser *p)
{}

// _loop0_30: ',' dotted_as_name
static asdl_seq *
_loop0_30_rule(Parser *p)
{}

// _gather_29: dotted_as_name _loop0_30
static asdl_seq *
_gather_29_rule(Parser *p)
{}

// _tmp_31: 'as' NAME
static void *
_tmp_31_rule(Parser *p)
{}

// _loop1_32: ('@' named_expression NEWLINE)
static asdl_seq *
_loop1_32_rule(Parser *p)
{}

// _tmp_33: '(' arguments? ')'
static void *
_tmp_33_rule(Parser *p)
{}

// _tmp_34: '->' expression
static void *
_tmp_34_rule(Parser *p)
{}

// _tmp_35: '->' expression
static void *
_tmp_35_rule(Parser *p)
{}

// _loop0_36: param_no_default
static asdl_seq *
_loop0_36_rule(Parser *p)
{}

// _loop0_37: param_with_default
static asdl_seq *
_loop0_37_rule(Parser *p)
{}

// _loop0_38: param_with_default
static asdl_seq *
_loop0_38_rule(Parser *p)
{}

// _loop1_39: param_no_default
static asdl_seq *
_loop1_39_rule(Parser *p)
{}

// _loop0_40: param_with_default
static asdl_seq *
_loop0_40_rule(Parser *p)
{}

// _loop1_41: param_with_default
static asdl_seq *
_loop1_41_rule(Parser *p)
{}

// _loop1_42: param_no_default
static asdl_seq *
_loop1_42_rule(Parser *p)
{}

// _loop1_43: param_no_default
static asdl_seq *
_loop1_43_rule(Parser *p)
{}

// _loop0_44: param_no_default
static asdl_seq *
_loop0_44_rule(Parser *p)
{}

// _loop1_45: param_with_default
static asdl_seq *
_loop1_45_rule(Parser *p)
{}

// _loop0_46: param_no_default
static asdl_seq *
_loop0_46_rule(Parser *p)
{}

// _loop1_47: param_with_default
static asdl_seq *
_loop1_47_rule(Parser *p)
{}

// _loop0_48: param_maybe_default
static asdl_seq *
_loop0_48_rule(Parser *p)
{}

// _loop0_49: param_maybe_default
static asdl_seq *
_loop0_49_rule(Parser *p)
{}

// _loop1_50: param_maybe_default
static asdl_seq *
_loop1_50_rule(Parser *p)
{}

// _loop0_52: ',' with_item
static asdl_seq *
_loop0_52_rule(Parser *p)
{}

// _gather_51: with_item _loop0_52
static asdl_seq *
_gather_51_rule(Parser *p)
{}

// _loop0_54: ',' with_item
static asdl_seq *
_loop0_54_rule(Parser *p)
{}

// _gather_53: with_item _loop0_54
static asdl_seq *
_gather_53_rule(Parser *p)
{}

// _loop0_56: ',' with_item
static asdl_seq *
_loop0_56_rule(Parser *p)
{}

// _gather_55: with_item _loop0_56
static asdl_seq *
_gather_55_rule(Parser *p)
{}

// _loop0_58: ',' with_item
static asdl_seq *
_loop0_58_rule(Parser *p)
{}

// _gather_57: with_item _loop0_58
static asdl_seq *
_gather_57_rule(Parser *p)
{}

// _tmp_59: ',' | ')' | ':'
static void *
_tmp_59_rule(Parser *p)
{}

// _loop1_60: except_block
static asdl_seq *
_loop1_60_rule(Parser *p)
{}

// _loop1_61: except_star_block
static asdl_seq *
_loop1_61_rule(Parser *p)
{}

// _tmp_62: 'as' NAME
static void *
_tmp_62_rule(Parser *p)
{}

// _tmp_63: 'as' NAME
static void *
_tmp_63_rule(Parser *p)
{}

// _loop1_64: case_block
static asdl_seq *
_loop1_64_rule(Parser *p)
{}

// _loop0_66: '|' closed_pattern
static asdl_seq *
_loop0_66_rule(Parser *p)
{}

// _gather_65: closed_pattern _loop0_66
static asdl_seq *
_gather_65_rule(Parser *p)
{}

// _tmp_67: '+' | '-'
static void *
_tmp_67_rule(Parser *p)
{}

// _tmp_68: '+' | '-'
static void *
_tmp_68_rule(Parser *p)
{}

// _tmp_69: '.' | '(' | '='
static void *
_tmp_69_rule(Parser *p)
{}

// _tmp_70: '.' | '(' | '='
static void *
_tmp_70_rule(Parser *p)
{}

// _loop0_72: ',' maybe_star_pattern
static asdl_seq *
_loop0_72_rule(Parser *p)
{}

// _gather_71: maybe_star_pattern _loop0_72
static asdl_seq *
_gather_71_rule(Parser *p)
{}

// _loop0_74: ',' key_value_pattern
static asdl_seq *
_loop0_74_rule(Parser *p)
{}

// _gather_73: key_value_pattern _loop0_74
static asdl_seq *
_gather_73_rule(Parser *p)
{}

// _tmp_75: literal_expr | attr
static void *
_tmp_75_rule(Parser *p)
{}

// _loop0_77: ',' pattern
static asdl_seq *
_loop0_77_rule(Parser *p)
{}

// _gather_76: pattern _loop0_77
static asdl_seq *
_gather_76_rule(Parser *p)
{}

// _loop0_79: ',' keyword_pattern
static asdl_seq *
_loop0_79_rule(Parser *p)
{}

// _gather_78: keyword_pattern _loop0_79
static asdl_seq *
_gather_78_rule(Parser *p)
{}

// _loop0_81: ',' type_param
static asdl_seq *
_loop0_81_rule(Parser *p)
{}

// _gather_80: type_param _loop0_81
static asdl_seq *
_gather_80_rule(Parser *p)
{}

// _loop1_82: (',' expression)
static asdl_seq *
_loop1_82_rule(Parser *p)
{}

// _loop1_83: (',' star_expression)
static asdl_seq *
_loop1_83_rule(Parser *p)
{}

// _loop0_85: ',' star_named_expression
static asdl_seq *
_loop0_85_rule(Parser *p)
{}

// _gather_84: star_named_expression _loop0_85
static asdl_seq *
_gather_84_rule(Parser *p)
{}

// _loop1_86: ('or' conjunction)
static asdl_seq *
_loop1_86_rule(Parser *p)
{}

// _loop1_87: ('and' inversion)
static asdl_seq *
_loop1_87_rule(Parser *p)
{}

// _loop1_88: compare_op_bitwise_or_pair
static asdl_seq *
_loop1_88_rule(Parser *p)
{}

// _tmp_89: '!='
static void *
_tmp_89_rule(Parser *p)
{}

// _loop0_91: ',' (slice | starred_expression)
static asdl_seq *
_loop0_91_rule(Parser *p)
{}

// _gather_90: (slice | starred_expression) _loop0_91
static asdl_seq *
_gather_90_rule(Parser *p)
{}

// _tmp_92: ':' expression?
static void *
_tmp_92_rule(Parser *p)
{}

// _tmp_93: STRING | FSTRING_START
static void *
_tmp_93_rule(Parser *p)
{}

// _tmp_94: tuple | group | genexp
static void *
_tmp_94_rule(Parser *p)
{}

// _tmp_95: list | listcomp
static void *
_tmp_95_rule(Parser *p)
{}

// _tmp_96: dict | set | dictcomp | setcomp
static void *
_tmp_96_rule(Parser *p)
{}

// _tmp_97: yield_expr | named_expression
static void *
_tmp_97_rule(Parser *p)
{}

// _loop0_98: lambda_param_no_default
static asdl_seq *
_loop0_98_rule(Parser *p)
{}

// _loop0_99: lambda_param_with_default
static asdl_seq *
_loop0_99_rule(Parser *p)
{}

// _loop0_100: lambda_param_with_default
static asdl_seq *
_loop0_100_rule(Parser *p)
{}

// _loop1_101: lambda_param_no_default
static asdl_seq *
_loop1_101_rule(Parser *p)
{}

// _loop0_102: lambda_param_with_default
static asdl_seq *
_loop0_102_rule(Parser *p)
{}

// _loop1_103: lambda_param_with_default
static asdl_seq *
_loop1_103_rule(Parser *p)
{}

// _loop1_104: lambda_param_no_default
static asdl_seq *
_loop1_104_rule(Parser *p)
{}

// _loop1_105: lambda_param_no_default
static asdl_seq *
_loop1_105_rule(Parser *p)
{}

// _loop0_106: lambda_param_no_default
static asdl_seq *
_loop0_106_rule(Parser *p)
{}

// _loop1_107: lambda_param_with_default
static asdl_seq *
_loop1_107_rule(Parser *p)
{}

// _loop0_108: lambda_param_no_default
static asdl_seq *
_loop0_108_rule(Parser *p)
{}

// _loop1_109: lambda_param_with_default
static asdl_seq *
_loop1_109_rule(Parser *p)
{}

// _loop0_110: lambda_param_maybe_default
static asdl_seq *
_loop0_110_rule(Parser *p)
{}

// _loop1_111: lambda_param_maybe_default
static asdl_seq *
_loop1_111_rule(Parser *p)
{}

// _loop0_112: fstring_format_spec
static asdl_seq *
_loop0_112_rule(Parser *p)
{}

// _loop0_113: fstring_middle
static asdl_seq *
_loop0_113_rule(Parser *p)
{}

// _loop1_114: (fstring | string)
static asdl_seq *
_loop1_114_rule(Parser *p)
{}

// _tmp_115: star_named_expression ',' star_named_expressions?
static void *
_tmp_115_rule(Parser *p)
{}

// _loop0_117: ',' double_starred_kvpair
static asdl_seq *
_loop0_117_rule(Parser *p)
{}

// _gather_116: double_starred_kvpair _loop0_117
static asdl_seq *
_gather_116_rule(Parser *p)
{}

// _loop1_118: for_if_clause
static asdl_seq *
_loop1_118_rule(Parser *p)
{}

// _loop0_119: ('if' disjunction)
static asdl_seq *
_loop0_119_rule(Parser *p)
{}

// _loop0_120: ('if' disjunction)
static asdl_seq *
_loop0_120_rule(Parser *p)
{}

// _tmp_121: assignment_expression | expression !':='
static void *
_tmp_121_rule(Parser *p)
{}

// _loop0_123: ',' (starred_expression | (assignment_expression | expression !':=') !'=')
static asdl_seq *
_loop0_123_rule(Parser *p)
{}

// _gather_122:
//     | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_123
static asdl_seq *
_gather_122_rule(Parser *p)
{}

// _tmp_124: ',' kwargs
static void *
_tmp_124_rule(Parser *p)
{}

// _loop0_126: ',' kwarg_or_starred
static asdl_seq *
_loop0_126_rule(Parser *p)
{}

// _gather_125: kwarg_or_starred _loop0_126
static asdl_seq *
_gather_125_rule(Parser *p)
{}

// _loop0_128: ',' kwarg_or_double_starred
static asdl_seq *
_loop0_128_rule(Parser *p)
{}

// _gather_127: kwarg_or_double_starred _loop0_128
static asdl_seq *
_gather_127_rule(Parser *p)
{}

// _loop0_130: ',' kwarg_or_starred
static asdl_seq *
_loop0_130_rule(Parser *p)
{}

// _gather_129: kwarg_or_starred _loop0_130
static asdl_seq *
_gather_129_rule(Parser *p)
{}

// _loop0_132: ',' kwarg_or_double_starred
static asdl_seq *
_loop0_132_rule(Parser *p)
{}

// _gather_131: kwarg_or_double_starred _loop0_132
static asdl_seq *
_gather_131_rule(Parser *p)
{}

// _loop0_133: (',' star_target)
static asdl_seq *
_loop0_133_rule(Parser *p)
{}

// _loop0_135: ',' star_target
static asdl_seq *
_loop0_135_rule(Parser *p)
{}

// _gather_134: star_target _loop0_135
static asdl_seq *
_gather_134_rule(Parser *p)
{}

// _loop1_136: (',' star_target)
static asdl_seq *
_loop1_136_rule(Parser *p)
{}

// _tmp_137: !'*' star_target
static void *
_tmp_137_rule(Parser *p)
{}

// _loop0_139: ',' del_target
static asdl_seq *
_loop0_139_rule(Parser *p)
{}

// _gather_138: del_target _loop0_139
static asdl_seq *
_gather_138_rule(Parser *p)
{}

// _loop0_141: ',' expression
static asdl_seq *
_loop0_141_rule(Parser *p)
{}

// _gather_140: expression _loop0_141
static asdl_seq *
_gather_140_rule(Parser *p)
{}

// _loop0_143: ',' expression
static asdl_seq *
_loop0_143_rule(Parser *p)
{}

// _gather_142: expression _loop0_143
static asdl_seq *
_gather_142_rule(Parser *p)
{}

// _loop0_145: ',' expression
static asdl_seq *
_loop0_145_rule(Parser *p)
{}

// _gather_144: expression _loop0_145
static asdl_seq *
_gather_144_rule(Parser *p)
{}

// _loop0_147: ',' expression
static asdl_seq *
_loop0_147_rule(Parser *p)
{}

// _gather_146: expression _loop0_147
static asdl_seq *
_gather_146_rule(Parser *p)
{}

// _tmp_148: NEWLINE INDENT
static void *
_tmp_148_rule(Parser *p)
{}

// _tmp_149:
//     | (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)
//     | kwargs
static void *
_tmp_149_rule(Parser *p)
{}

// _loop0_151: ',' (starred_expression !'=')
static asdl_seq *
_loop0_151_rule(Parser *p)
{}

// _gather_150: (starred_expression !'=') _loop0_151
static asdl_seq *
_gather_150_rule(Parser *p)
{}

// _tmp_152: args | expression for_if_clauses
static void *
_tmp_152_rule(Parser *p)
{}

// _tmp_153: args ','
static void *
_tmp_153_rule(Parser *p)
{}

// _tmp_154: ',' | ')'
static void *
_tmp_154_rule(Parser *p)
{}

// _tmp_155: 'True' | 'False' | 'None'
static void *
_tmp_155_rule(Parser *p)
{}

// _tmp_156: NAME '='
static void *
_tmp_156_rule(Parser *p)
{}

// _tmp_157: NAME STRING | SOFT_KEYWORD
static void *
_tmp_157_rule(Parser *p)
{}

// _tmp_158: 'else' | ':'
static void *
_tmp_158_rule(Parser *p)
{}

// _tmp_159: '=' | ':='
static void *
_tmp_159_rule(Parser *p)
{}

// _tmp_160: list | tuple | genexp | 'True' | 'None' | 'False'
static void *
_tmp_160_rule(Parser *p)
{}

// _tmp_161: '=' | ':='
static void *
_tmp_161_rule(Parser *p)
{}

// _loop0_162: star_named_expressions
static asdl_seq *
_loop0_162_rule(Parser *p)
{}

// _loop0_163: (star_targets '=')
static asdl_seq *
_loop0_163_rule(Parser *p)
{}

// _loop0_164: (star_targets '=')
static asdl_seq *
_loop0_164_rule(Parser *p)
{}

// _tmp_165: '[' | '(' | '{'
static void *
_tmp_165_rule(Parser *p)
{}

// _tmp_166: '[' | '{'
static void *
_tmp_166_rule(Parser *p)
{}

// _tmp_167: '[' | '{'
static void *
_tmp_167_rule(Parser *p)
{}

// _tmp_168: slash_no_default | slash_with_default
static void *
_tmp_168_rule(Parser *p)
{}

// _loop0_169: param_maybe_default
static asdl_seq *
_loop0_169_rule(Parser *p)
{}

// _loop0_170: param_no_default
static asdl_seq *
_loop0_170_rule(Parser *p)
{}

// _loop0_171: param_no_default
static asdl_seq *
_loop0_171_rule(Parser *p)
{}

// _loop1_172: param_no_default
static asdl_seq *
_loop1_172_rule(Parser *p)
{}

// _tmp_173: slash_no_default | slash_with_default
static void *
_tmp_173_rule(Parser *p)
{}

// _loop0_174: param_maybe_default
static asdl_seq *
_loop0_174_rule(Parser *p)
{}

// _tmp_175: ',' | param_no_default
static void *
_tmp_175_rule(Parser *p)
{}

// _loop0_176: param_maybe_default
static asdl_seq *
_loop0_176_rule(Parser *p)
{}

// _loop1_177: param_maybe_default
static asdl_seq *
_loop1_177_rule(Parser *p)
{}

// _tmp_178: ')' | ','
static void *
_tmp_178_rule(Parser *p)
{}

// _tmp_179: ')' | ',' (')' | '**')
static void *
_tmp_179_rule(Parser *p)
{}

// _tmp_180: param_no_default | ','
static void *
_tmp_180_rule(Parser *p)
{}

// _loop0_181: param_maybe_default
static asdl_seq *
_loop0_181_rule(Parser *p)
{}

// _tmp_182: param_no_default | ','
static void *
_tmp_182_rule(Parser *p)
{}

// _tmp_183: '*' | '**' | '/'
static void *
_tmp_183_rule(Parser *p)
{}

// _loop1_184: param_with_default
static asdl_seq *
_loop1_184_rule(Parser *p)
{}

// _tmp_185: lambda_slash_no_default | lambda_slash_with_default
static void *
_tmp_185_rule(Parser *p)
{}

// _loop0_186: lambda_param_maybe_default
static asdl_seq *
_loop0_186_rule(Parser *p)
{}

// _loop0_187: lambda_param_no_default
static asdl_seq *
_loop0_187_rule(Parser *p)
{}

// _loop0_188: lambda_param_no_default
static asdl_seq *
_loop0_188_rule(Parser *p)
{}

// _loop0_190: ',' lambda_param
static asdl_seq *
_loop0_190_rule(Parser *p)
{}

// _gather_189: lambda_param _loop0_190
static asdl_seq *
_gather_189_rule(Parser *p)
{}

// _tmp_191: lambda_slash_no_default | lambda_slash_with_default
static void *
_tmp_191_rule(Parser *p)
{}

// _loop0_192: lambda_param_maybe_default
static asdl_seq *
_loop0_192_rule(Parser *p)
{}

// _tmp_193: ',' | lambda_param_no_default
static void *
_tmp_193_rule(Parser *p)
{}

// _loop0_194: lambda_param_maybe_default
static asdl_seq *
_loop0_194_rule(Parser *p)
{}

// _loop1_195: lambda_param_maybe_default
static asdl_seq *
_loop1_195_rule(Parser *p)
{}

// _loop1_196: lambda_param_with_default
static asdl_seq *
_loop1_196_rule(Parser *p)
{}

// _tmp_197: ':' | ',' (':' | '**')
static void *
_tmp_197_rule(Parser *p)
{}

// _tmp_198: lambda_param_no_default | ','
static void *
_tmp_198_rule(Parser *p)
{}

// _loop0_199: lambda_param_maybe_default
static asdl_seq *
_loop0_199_rule(Parser *p)
{}

// _tmp_200: lambda_param_no_default | ','
static void *
_tmp_200_rule(Parser *p)
{}

// _tmp_201: '*' | '**' | '/'
static void *
_tmp_201_rule(Parser *p)
{}

// _tmp_202: ',' | ')' | ':'
static void *
_tmp_202_rule(Parser *p)
{}

// _tmp_203: bitwise_or ((',' bitwise_or))* ','?
static void *
_tmp_203_rule(Parser *p)
{}

// _loop0_205: ',' dotted_name
static asdl_seq *
_loop0_205_rule(Parser *p)
{}

// _gather_204: dotted_name _loop0_205
static asdl_seq *
_gather_204_rule(Parser *p)
{}

// _loop0_207: ',' (expression ['as' star_target])
static asdl_seq *
_loop0_207_rule(Parser *p)
{}

// _gather_206: (expression ['as' star_target]) _loop0_207
static asdl_seq *
_gather_206_rule(Parser *p)
{}

// _loop0_209: ',' (expressions ['as' star_target])
static asdl_seq *
_loop0_209_rule(Parser *p)
{}

// _gather_208: (expressions ['as' star_target]) _loop0_209
static asdl_seq *
_gather_208_rule(Parser *p)
{}

// _loop0_211: ',' (expression ['as' star_target])
static asdl_seq *
_loop0_211_rule(Parser *p)
{}

// _gather_210: (expression ['as' star_target]) _loop0_211
static asdl_seq *
_gather_210_rule(Parser *p)
{}

// _loop0_213: ',' (expressions ['as' star_target])
static asdl_seq *
_loop0_213_rule(Parser *p)
{}

// _gather_212: (expressions ['as' star_target]) _loop0_213
static asdl_seq *
_gather_212_rule(Parser *p)
{}

// _tmp_214: 'except' | 'finally'
static void *
_tmp_214_rule(Parser *p)
{}

// _loop0_215: block
static asdl_seq *
_loop0_215_rule(Parser *p)
{}

// _loop1_216: except_block
static asdl_seq *
_loop1_216_rule(Parser *p)
{}

// _tmp_217: 'as' NAME
static void *
_tmp_217_rule(Parser *p)
{}

// _loop0_218: block
static asdl_seq *
_loop0_218_rule(Parser *p)
{}

// _loop1_219: except_star_block
static asdl_seq *
_loop1_219_rule(Parser *p)
{}

// _tmp_220: expression ['as' NAME]
static void *
_tmp_220_rule(Parser *p)
{}

// _tmp_221: 'as' NAME
static void *
_tmp_221_rule(Parser *p)
{}

// _tmp_222: 'as' NAME
static void *
_tmp_222_rule(Parser *p)
{}

// _tmp_223: 'as' NAME
static void *
_tmp_223_rule(Parser *p)
{}

// _tmp_224: 'as' NAME
static void *
_tmp_224_rule(Parser *p)
{}

// _tmp_225: NEWLINE | ':'
static void *
_tmp_225_rule(Parser *p)
{}

// _tmp_226: 'as' NAME
static void *
_tmp_226_rule(Parser *p)
{}

// _tmp_227: 'as' NAME
static void *
_tmp_227_rule(Parser *p)
{}

// _tmp_228: positional_patterns ','
static void *
_tmp_228_rule(Parser *p)
{}

// _tmp_229: '->' expression
static void *
_tmp_229_rule(Parser *p)
{}

// _tmp_230: '->' expression
static void *
_tmp_230_rule(Parser *p)
{}

// _tmp_231: '(' arguments? ')'
static void *
_tmp_231_rule(Parser *p)
{}

// _tmp_232: '(' arguments? ')'
static void *
_tmp_232_rule(Parser *p)
{}

// _loop0_234: ',' double_starred_kvpair
static asdl_seq *
_loop0_234_rule(Parser *p)
{}

// _gather_233: double_starred_kvpair _loop0_234
static asdl_seq *
_gather_233_rule(Parser *p)
{}

// _tmp_235: '}' | ','
static void *
_tmp_235_rule(Parser *p)
{}

// _tmp_236: '}' | ','
static void *
_tmp_236_rule(Parser *p)
{}

// _tmp_237: '=' | '!' | ':' | '}'
static void *
_tmp_237_rule(Parser *p)
{}

// _tmp_238: '!' | ':' | '}'
static void *
_tmp_238_rule(Parser *p)
{}

// _tmp_239: '!' NAME
static void *
_tmp_239_rule(Parser *p)
{}

// _tmp_240: ':' | '}'
static void *
_tmp_240_rule(Parser *p)
{}

// _tmp_241: '!' NAME
static void *
_tmp_241_rule(Parser *p)
{}

// _loop0_242: fstring_format_spec
static asdl_seq *
_loop0_242_rule(Parser *p)
{}

// _tmp_243: '!' NAME
static void *
_tmp_243_rule(Parser *p)
{}

// _tmp_244: ':' | '}'
static void *
_tmp_244_rule(Parser *p)
{}

// _tmp_245: '+' | '-' | '*' | '/' | '%' | '//' | '@'
static void *
_tmp_245_rule(Parser *p)
{}

// _tmp_246: '+' | '-' | '~'
static void *
_tmp_246_rule(Parser *p)
{}

// _tmp_247: star_targets '='
static void *
_tmp_247_rule(Parser *p)
{}

// _tmp_248: '.' | '...'
static void *
_tmp_248_rule(Parser *p)
{}

// _tmp_249: '.' | '...'
static void *
_tmp_249_rule(Parser *p)
{}

// _tmp_250: '@' named_expression NEWLINE
static void *
_tmp_250_rule(Parser *p)
{}

// _tmp_251: ',' expression
static void *
_tmp_251_rule(Parser *p)
{}

// _tmp_252: ',' star_expression
static void *
_tmp_252_rule(Parser *p)
{}

// _tmp_253: 'or' conjunction
static void *
_tmp_253_rule(Parser *p)
{}

// _tmp_254: 'and' inversion
static void *
_tmp_254_rule(Parser *p)
{}

// _tmp_255: slice | starred_expression
static void *
_tmp_255_rule(Parser *p)
{}

// _tmp_256: fstring | string
static void *
_tmp_256_rule(Parser *p)
{}

// _tmp_257: 'if' disjunction
static void *
_tmp_257_rule(Parser *p)
{}

// _tmp_258: 'if' disjunction
static void *
_tmp_258_rule(Parser *p)
{}

// _tmp_259: starred_expression | (assignment_expression | expression !':=') !'='
static void *
_tmp_259_rule(Parser *p)
{}

// _tmp_260: ',' star_target
static void *
_tmp_260_rule(Parser *p)
{}

// _tmp_261: ',' star_target
static void *
_tmp_261_rule(Parser *p)
{}

// _tmp_262:
//     | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs
static void *
_tmp_262_rule(Parser *p)
{}

// _tmp_263: starred_expression !'='
static void *
_tmp_263_rule(Parser *p)
{}

// _tmp_264: star_targets '='
static void *
_tmp_264_rule(Parser *p)
{}

// _tmp_265: star_targets '='
static void *
_tmp_265_rule(Parser *p)
{}

// _tmp_266: ')' | '**'
static void *
_tmp_266_rule(Parser *p)
{}

// _tmp_267: ':' | '**'
static void *
_tmp_267_rule(Parser *p)
{}

// _loop0_268: (',' bitwise_or)
static asdl_seq *
_loop0_268_rule(Parser *p)
{}

// _tmp_269: expression ['as' star_target]
static void *
_tmp_269_rule(Parser *p)
{}

// _tmp_270: expressions ['as' star_target]
static void *
_tmp_270_rule(Parser *p)
{}

// _tmp_271: expression ['as' star_target]
static void *
_tmp_271_rule(Parser *p)
{}

// _tmp_272: expressions ['as' star_target]
static void *
_tmp_272_rule(Parser *p)
{}

// _tmp_273: 'as' NAME
static void *
_tmp_273_rule(Parser *p)
{}

// _tmp_274: assignment_expression | expression !':='
static void *
_tmp_274_rule(Parser *p)
{}

// _loop0_276: ',' (starred_expression | (assignment_expression | expression !':=') !'=')
static asdl_seq *
_loop0_276_rule(Parser *p)
{}

// _gather_275:
//     | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_276
static asdl_seq *
_gather_275_rule(Parser *p)
{}

// _tmp_277: ',' bitwise_or
static void *
_tmp_277_rule(Parser *p)
{}

// _tmp_278: 'as' star_target
static void *
_tmp_278_rule(Parser *p)
{}

// _tmp_279: 'as' star_target
static void *
_tmp_279_rule(Parser *p)
{}

// _tmp_280: 'as' star_target
static void *
_tmp_280_rule(Parser *p)
{}

// _tmp_281: 'as' star_target
static void *
_tmp_281_rule(Parser *p)
{}

// _tmp_282: starred_expression | (assignment_expression | expression !':=') !'='
static void *
_tmp_282_rule(Parser *p)
{}

// _tmp_283: assignment_expression | expression !':='
static void *
_tmp_283_rule(Parser *p)
{}

void *
_PyPegen_parse(Parser *p)
{}