13     (KeywordToken[]) {{NULL, -1}},
14     (KeywordToken[]) {{NULL, -1}},
21         {NULL, -1},
30         {NULL, -1},
40         {NULL, -1},
49         {NULL, -1},
58         {NULL, -1},
62         {NULL, -1},
67         {NULL, -1},
103 #define dotted_name_type 1027  // Left-recursive
134 #define attr_type 1058  // Left-recursive
135 #define name_or_attr_type 1059  // Left-recursive
206 #define bitwise_or_type 1130  // Left-recursive
207 #define bitwise_xor_type 1131  // Left-recursive
208 #define bitwise_and_type 1132  // Left-recursive
209 #define shift_expr_type 1133  // Left-recursive
210 #define sum_type 1134  // Left-recursive
211 #define term_type 1135  // Left-recursive
215 #define primary_type 1139  // Left-recursive
252 #define t_primary_type 1176  // Left-recursive
504 static mod_ty file_rule(Parser *p);
505 static mod_ty interactive_rule(Parser *p);
506 static mod_ty eval_rule(Parser *p);
507 static mod_ty func_type_rule(Parser *p);
508 static expr_ty fstring_rule(Parser *p);
509 static asdl_expr_seq* type_expressions_rule(Parser *p);
510 static asdl_stmt_seq* statements_rule(Parser *p);
511 static asdl_stmt_seq* statement_rule(Parser *p);
512 static asdl_stmt_seq* statement_newline_rule(Parser *p);
513 static asdl_stmt_seq* simple_stmts_rule(Parser *p);
514 static stmt_ty simple_stmt_rule(Parser *p);
515 static stmt_ty compound_stmt_rule(Parser *p);
516 static stmt_ty assignment_rule(Parser *p);
517 static AugOperator* augassign_rule(Parser *p);
518 static stmt_ty global_stmt_rule(Parser *p);
519 static stmt_ty nonlocal_stmt_rule(Parser *p);
520 static stmt_ty yield_stmt_rule(Parser *p);
521 static stmt_ty assert_stmt_rule(Parser *p);
522 static stmt_ty del_stmt_rule(Parser *p);
523 static stmt_ty import_stmt_rule(Parser *p);
524 static stmt_ty import_name_rule(Parser *p);
525 static stmt_ty import_from_rule(Parser *p);
526 static asdl_alias_seq* import_from_targets_rule(Parser *p);
527 static asdl_alias_seq* import_from_as_names_rule(Parser *p);
528 static alias_ty import_from_as_name_rule(Parser *p);
529 static asdl_alias_seq* dotted_as_names_rule(Parser *p);
530 static alias_ty dotted_as_name_rule(Parser *p);
531 static expr_ty dotted_name_rule(Parser *p);
532 static stmt_ty if_stmt_rule(Parser *p);
533 static stmt_ty elif_stmt_rule(Parser *p);
534 static asdl_stmt_seq* else_block_rule(Parser *p);
535 static stmt_ty while_stmt_rule(Parser *p);
536 static stmt_ty for_stmt_rule(Parser *p);
537 static stmt_ty with_stmt_rule(Parser *p);
538 static withitem_ty with_item_rule(Parser *p);
539 static stmt_ty try_stmt_rule(Parser *p);
540 static excepthandler_ty except_block_rule(Parser *p);
541 static asdl_stmt_seq* finally_block_rule(Parser *p);
542 static stmt_ty match_stmt_rule(Parser *p);
543 static expr_ty subject_expr_rule(Parser *p);
544 static match_case_ty case_block_rule(Parser *p);
545 static expr_ty guard_rule(Parser *p);
546 static pattern_ty patterns_rule(Parser *p);
547 static pattern_ty pattern_rule(Parser *p);
548 static pattern_ty as_pattern_rule(Parser *p);
549 static pattern_ty or_pattern_rule(Parser *p);
550 static pattern_ty closed_pattern_rule(Parser *p);
551 static pattern_ty literal_pattern_rule(Parser *p);
552 static expr_ty literal_expr_rule(Parser *p);
553 static expr_ty complex_number_rule(Parser *p);
554 static expr_ty signed_number_rule(Parser *p);
555 static expr_ty signed_real_number_rule(Parser *p);
556 static expr_ty real_number_rule(Parser *p);
557 static expr_ty imaginary_number_rule(Parser *p);
558 static pattern_ty capture_pattern_rule(Parser *p);
559 static expr_ty pattern_capture_target_rule(Parser *p);
560 static pattern_ty wildcard_pattern_rule(Parser *p);
561 static pattern_ty value_pattern_rule(Parser *p);
562 static expr_ty attr_rule(Parser *p);
563 static expr_ty name_or_attr_rule(Parser *p);
564 static pattern_ty group_pattern_rule(Parser *p);
565 static pattern_ty sequence_pattern_rule(Parser *p);
566 static asdl_seq* open_sequence_pattern_rule(Parser *p);
567 static asdl_seq* maybe_sequence_pattern_rule(Parser *p);
568 static pattern_ty maybe_star_pattern_rule(Parser *p);
569 static pattern_ty star_pattern_rule(Parser *p);
570 static pattern_ty mapping_pattern_rule(Parser *p);
571 static asdl_seq* items_pattern_rule(Parser *p);
572 static KeyPatternPair* key_value_pattern_rule(Parser *p);
573 static expr_ty double_star_pattern_rule(Parser *p);
574 static pattern_ty class_pattern_rule(Parser *p);
575 static asdl_pattern_seq* positional_patterns_rule(Parser *p);
576 static asdl_seq* keyword_patterns_rule(Parser *p);
577 static KeyPatternPair* keyword_pattern_rule(Parser *p);
578 static stmt_ty return_stmt_rule(Parser *p);
579 static stmt_ty raise_stmt_rule(Parser *p);
580 static stmt_ty function_def_rule(Parser *p);
581 static stmt_ty function_def_raw_rule(Parser *p);
582 static Token* func_type_comment_rule(Parser *p);
583 static arguments_ty params_rule(Parser *p);
584 static arguments_ty parameters_rule(Parser *p);
585 static asdl_arg_seq* slash_no_default_rule(Parser *p);
586 static SlashWithDefault* slash_with_default_rule(Parser *p);
587 static StarEtc* star_etc_rule(Parser *p);
588 static arg_ty kwds_rule(Parser *p);
589 static arg_ty param_no_default_rule(Parser *p);
590 static NameDefaultPair* param_with_default_rule(Parser *p);
591 static NameDefaultPair* param_maybe_default_rule(Parser *p);
592 static arg_ty param_rule(Parser *p);
593 static expr_ty annotation_rule(Parser *p);
594 static expr_ty default_rule(Parser *p);
595 static asdl_expr_seq* decorators_rule(Parser *p);
596 static stmt_ty class_def_rule(Parser *p);
597 static stmt_ty class_def_raw_rule(Parser *p);
598 static asdl_stmt_seq* block_rule(Parser *p);
599 static expr_ty star_expressions_rule(Parser *p);
600 static expr_ty star_expression_rule(Parser *p);
601 static asdl_expr_seq* star_named_expressions_rule(Parser *p);
602 static expr_ty star_named_expression_rule(Parser *p);
603 static expr_ty assignment_expression_rule(Parser *p);
604 static expr_ty named_expression_rule(Parser *p);
605 static expr_ty annotated_rhs_rule(Parser *p);
606 static expr_ty expressions_rule(Parser *p);
607 static expr_ty expression_rule(Parser *p);
608 static expr_ty lambdef_rule(Parser *p);
609 static arguments_ty lambda_params_rule(Parser *p);
610 static arguments_ty lambda_parameters_rule(Parser *p);
611 static asdl_arg_seq* lambda_slash_no_default_rule(Parser *p);
612 static SlashWithDefault* lambda_slash_with_default_rule(Parser *p);
613 static StarEtc* lambda_star_etc_rule(Parser *p);
614 static arg_ty lambda_kwds_rule(Parser *p);
615 static arg_ty lambda_param_no_default_rule(Parser *p);
616 static NameDefaultPair* lambda_param_with_default_rule(Parser *p);
617 static NameDefaultPair* lambda_param_maybe_default_rule(Parser *p);
618 static arg_ty lambda_param_rule(Parser *p);
619 static expr_ty disjunction_rule(Parser *p);
620 static expr_ty conjunction_rule(Parser *p);
621 static expr_ty inversion_rule(Parser *p);
622 static expr_ty comparison_rule(Parser *p);
623 static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p);
624 static CmpopExprPair* eq_bitwise_or_rule(Parser *p);
625 static CmpopExprPair* noteq_bitwise_or_rule(Parser *p);
626 static CmpopExprPair* lte_bitwise_or_rule(Parser *p);
627 static CmpopExprPair* lt_bitwise_or_rule(Parser *p);
628 static CmpopExprPair* gte_bitwise_or_rule(Parser *p);
629 static CmpopExprPair* gt_bitwise_or_rule(Parser *p);
630 static CmpopExprPair* notin_bitwise_or_rule(Parser *p);
631 static CmpopExprPair* in_bitwise_or_rule(Parser *p);
632 static CmpopExprPair* isnot_bitwise_or_rule(Parser *p);
633 static CmpopExprPair* is_bitwise_or_rule(Parser *p);
634 static expr_ty bitwise_or_rule(Parser *p);
635 static expr_ty bitwise_xor_rule(Parser *p);
636 static expr_ty bitwise_and_rule(Parser *p);
637 static expr_ty shift_expr_rule(Parser *p);
638 static expr_ty sum_rule(Parser *p);
639 static expr_ty term_rule(Parser *p);
640 static expr_ty factor_rule(Parser *p);
641 static expr_ty power_rule(Parser *p);
642 static expr_ty await_primary_rule(Parser *p);
643 static expr_ty primary_rule(Parser *p);
644 static expr_ty slices_rule(Parser *p);
645 static expr_ty slice_rule(Parser *p);
646 static expr_ty atom_rule(Parser *p);
647 static expr_ty strings_rule(Parser *p);
648 static expr_ty list_rule(Parser *p);
649 static expr_ty listcomp_rule(Parser *p);
650 static expr_ty tuple_rule(Parser *p);
651 static expr_ty group_rule(Parser *p);
652 static expr_ty genexp_rule(Parser *p);
653 static expr_ty set_rule(Parser *p);
654 static expr_ty setcomp_rule(Parser *p);
655 static expr_ty dict_rule(Parser *p);
656 static expr_ty dictcomp_rule(Parser *p);
657 static asdl_seq* double_starred_kvpairs_rule(Parser *p);
658 static KeyValuePair* double_starred_kvpair_rule(Parser *p);
659 static KeyValuePair* kvpair_rule(Parser *p);
660 static asdl_comprehension_seq* for_if_clauses_rule(Parser *p);
661 static comprehension_ty for_if_clause_rule(Parser *p);
662 static expr_ty yield_expr_rule(Parser *p);
663 static expr_ty arguments_rule(Parser *p);
664 static expr_ty args_rule(Parser *p);
665 static asdl_seq* kwargs_rule(Parser *p);
666 static expr_ty starred_expression_rule(Parser *p);
667 static KeywordOrStarred* kwarg_or_starred_rule(Parser *p);
668 static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p);
669 static expr_ty star_targets_rule(Parser *p);
670 static asdl_expr_seq* star_targets_list_seq_rule(Parser *p);
671 static asdl_expr_seq* star_targets_tuple_seq_rule(Parser *p);
672 static expr_ty star_target_rule(Parser *p);
673 static expr_ty target_with_star_atom_rule(Parser *p);
674 static expr_ty star_atom_rule(Parser *p);
675 static expr_ty single_target_rule(Parser *p);
676 static expr_ty single_subscript_attribute_target_rule(Parser *p);
677 static asdl_expr_seq* del_targets_rule(Parser *p);
678 static expr_ty del_target_rule(Parser *p);
679 static expr_ty del_t_atom_rule(Parser *p);
680 static expr_ty t_primary_rule(Parser *p);
681 static void *t_lookahead_rule(Parser *p);
682 static void *invalid_arguments_rule(Parser *p);
683 static void *invalid_kwarg_rule(Parser *p);
684 static expr_ty expression_without_invalid_rule(Parser *p);
685 static void *invalid_legacy_expression_rule(Parser *p);
686 static void *invalid_expression_rule(Parser *p);
687 static void *invalid_named_expression_rule(Parser *p);
688 static void *invalid_assignment_rule(Parser *p);
689 static expr_ty invalid_ann_assign_target_rule(Parser *p);
690 static void *invalid_del_stmt_rule(Parser *p);
691 static void *invalid_block_rule(Parser *p);
692 static void *invalid_comprehension_rule(Parser *p);
693 static void *invalid_dict_comprehension_rule(Parser *p);
694 static void *invalid_parameters_rule(Parser *p);
695 static void *invalid_parameters_helper_rule(Parser *p);
696 static void *invalid_lambda_parameters_rule(Parser *p);
697 static void *invalid_lambda_parameters_helper_rule(Parser *p);
698 static void *invalid_star_etc_rule(Parser *p);
699 static void *invalid_lambda_star_etc_rule(Parser *p);
700 static void *invalid_double_type_comments_rule(Parser *p);
701 static void *invalid_with_item_rule(Parser *p);
702 static void *invalid_for_target_rule(Parser *p);
703 static void *invalid_group_rule(Parser *p);
704 static void *invalid_import_from_targets_rule(Parser *p);
705 static void *invalid_with_stmt_rule(Parser *p);
706 static void *invalid_with_stmt_indent_rule(Parser *p);
707 static void *invalid_try_stmt_rule(Parser *p);
708 static void *invalid_except_stmt_rule(Parser *p);
709 static void *invalid_finally_stmt_rule(Parser *p);
710 static void *invalid_except_stmt_indent_rule(Parser *p);
711 static void *invalid_match_stmt_rule(Parser *p);
712 static void *invalid_case_block_rule(Parser *p);
713 static void *invalid_as_pattern_rule(Parser *p);
714 static void *invalid_class_pattern_rule(Parser *p);
715 static asdl_pattern_seq* invalid_class_argument_pattern_rule(Parser *p);
716 static void *invalid_if_stmt_rule(Parser *p);
717 static void *invalid_elif_stmt_rule(Parser *p);
718 static void *invalid_else_stmt_rule(Parser *p);
719 static void *invalid_while_stmt_rule(Parser *p);
720 static void *invalid_for_stmt_rule(Parser *p);
721 static void *invalid_def_raw_rule(Parser *p);
722 static void *invalid_class_def_raw_rule(Parser *p);
723 static void *invalid_double_starred_kvpairs_rule(Parser *p);
724 static void *invalid_kvpair_rule(Parser *p);
725 static asdl_seq *_loop0_1_rule(Parser *p);
726 static asdl_seq *_loop0_2_rule(Parser *p);
727 static asdl_seq *_loop0_4_rule(Parser *p);
728 static asdl_seq *_gather_3_rule(Parser *p);
729 static asdl_seq *_loop0_6_rule(Parser *p);
730 static asdl_seq *_gather_5_rule(Parser *p);
731 static asdl_seq *_loop0_8_rule(Parser *p);
732 static asdl_seq *_gather_7_rule(Parser *p);
733 static asdl_seq *_loop0_10_rule(Parser *p);
734 static asdl_seq *_gather_9_rule(Parser *p);
735 static asdl_seq *_loop1_11_rule(Parser *p);
736 static asdl_seq *_loop0_13_rule(Parser *p);
737 static asdl_seq *_gather_12_rule(Parser *p);
738 static void *_tmp_14_rule(Parser *p);
739 static void *_tmp_15_rule(Parser *p);
740 static void *_tmp_16_rule(Parser *p);
741 static void *_tmp_17_rule(Parser *p);
742 static void *_tmp_18_rule(Parser *p);
743 static void *_tmp_19_rule(Parser *p);
744 static void *_tmp_20_rule(Parser *p);
745 static void *_tmp_21_rule(Parser *p);
746 static asdl_seq *_loop1_22_rule(Parser *p);
747 static void *_tmp_23_rule(Parser *p);
748 static void *_tmp_24_rule(Parser *p);
749 static asdl_seq *_loop0_26_rule(Parser *p);
750 static asdl_seq *_gather_25_rule(Parser *p);
751 static asdl_seq *_loop0_28_rule(Parser *p);
752 static asdl_seq *_gather_27_rule(Parser *p);
753 static void *_tmp_29_rule(Parser *p);
754 static void *_tmp_30_rule(Parser *p);
755 static asdl_seq *_loop0_31_rule(Parser *p);
756 static asdl_seq *_loop1_32_rule(Parser *p);
757 static asdl_seq *_loop0_34_rule(Parser *p);
758 static asdl_seq *_gather_33_rule(Parser *p);
759 static void *_tmp_35_rule(Parser *p);
760 static asdl_seq *_loop0_37_rule(Parser *p);
761 static asdl_seq *_gather_36_rule(Parser *p);
762 static void *_tmp_38_rule(Parser *p);
763 static asdl_seq *_loop0_40_rule(Parser *p);
764 static asdl_seq *_gather_39_rule(Parser *p);
765 static asdl_seq *_loop0_42_rule(Parser *p);
766 static asdl_seq *_gather_41_rule(Parser *p);
767 static asdl_seq *_loop0_44_rule(Parser *p);
768 static asdl_seq *_gather_43_rule(Parser *p);
769 static asdl_seq *_loop0_46_rule(Parser *p);
770 static asdl_seq *_gather_45_rule(Parser *p);
771 static void *_tmp_47_rule(Parser *p);
772 static asdl_seq *_loop1_48_rule(Parser *p);
773 static void *_tmp_49_rule(Parser *p);
774 static asdl_seq *_loop1_50_rule(Parser *p);
775 static asdl_seq *_loop0_52_rule(Parser *p);
776 static asdl_seq *_gather_51_rule(Parser *p);
777 static void *_tmp_53_rule(Parser *p);
778 static void *_tmp_54_rule(Parser *p);
779 static void *_tmp_55_rule(Parser *p);
780 static void *_tmp_56_rule(Parser *p);
781 static asdl_seq *_loop0_58_rule(Parser *p);
782 static asdl_seq *_gather_57_rule(Parser *p);
783 static asdl_seq *_loop0_60_rule(Parser *p);
784 static asdl_seq *_gather_59_rule(Parser *p);
785 static void *_tmp_61_rule(Parser *p);
786 static asdl_seq *_loop0_63_rule(Parser *p);
787 static asdl_seq *_gather_62_rule(Parser *p);
788 static asdl_seq *_loop0_65_rule(Parser *p);
789 static asdl_seq *_gather_64_rule(Parser *p);
790 static void *_tmp_66_rule(Parser *p);
791 static void *_tmp_67_rule(Parser *p);
792 static void *_tmp_68_rule(Parser *p);
793 static void *_tmp_69_rule(Parser *p);
794 static asdl_seq *_loop0_70_rule(Parser *p);
795 static asdl_seq *_loop0_71_rule(Parser *p);
796 static asdl_seq *_loop0_72_rule(Parser *p);
797 static asdl_seq *_loop1_73_rule(Parser *p);
798 static asdl_seq *_loop0_74_rule(Parser *p);
799 static asdl_seq *_loop1_75_rule(Parser *p);
800 static asdl_seq *_loop1_76_rule(Parser *p);
801 static asdl_seq *_loop1_77_rule(Parser *p);
802 static asdl_seq *_loop0_78_rule(Parser *p);
803 static asdl_seq *_loop1_79_rule(Parser *p);
804 static asdl_seq *_loop0_80_rule(Parser *p);
805 static asdl_seq *_loop1_81_rule(Parser *p);
806 static asdl_seq *_loop0_82_rule(Parser *p);
807 static asdl_seq *_loop1_83_rule(Parser *p);
808 static asdl_seq *_loop1_84_rule(Parser *p);
809 static void *_tmp_85_rule(Parser *p);
810 static asdl_seq *_loop1_86_rule(Parser *p);
811 static asdl_seq *_loop0_88_rule(Parser *p);
812 static asdl_seq *_gather_87_rule(Parser *p);
813 static asdl_seq *_loop1_89_rule(Parser *p);
814 static asdl_seq *_loop0_90_rule(Parser *p);
815 static asdl_seq *_loop0_91_rule(Parser *p);
816 static asdl_seq *_loop0_92_rule(Parser *p);
817 static asdl_seq *_loop1_93_rule(Parser *p);
818 static asdl_seq *_loop0_94_rule(Parser *p);
819 static asdl_seq *_loop1_95_rule(Parser *p);
820 static asdl_seq *_loop1_96_rule(Parser *p);
821 static asdl_seq *_loop1_97_rule(Parser *p);
822 static asdl_seq *_loop0_98_rule(Parser *p);
823 static asdl_seq *_loop1_99_rule(Parser *p);
824 static asdl_seq *_loop0_100_rule(Parser *p);
825 static asdl_seq *_loop1_101_rule(Parser *p);
826 static asdl_seq *_loop0_102_rule(Parser *p);
827 static asdl_seq *_loop1_103_rule(Parser *p);
828 static asdl_seq *_loop1_104_rule(Parser *p);
829 static asdl_seq *_loop1_105_rule(Parser *p);
830 static asdl_seq *_loop1_106_rule(Parser *p);
831 static void *_tmp_107_rule(Parser *p);
832 static asdl_seq *_loop0_109_rule(Parser *p);
833 static asdl_seq *_gather_108_rule(Parser *p);
834 static void *_tmp_110_rule(Parser *p);
835 static void *_tmp_111_rule(Parser *p);
836 static void *_tmp_112_rule(Parser *p);
837 static void *_tmp_113_rule(Parser *p);
838 static asdl_seq *_loop1_114_rule(Parser *p);
839 static void *_tmp_115_rule(Parser *p);
840 static void *_tmp_116_rule(Parser *p);
841 static void *_tmp_117_rule(Parser *p);
842 static asdl_seq *_loop0_119_rule(Parser *p);
843 static asdl_seq *_gather_118_rule(Parser *p);
844 static asdl_seq *_loop1_120_rule(Parser *p);
845 static asdl_seq *_loop0_121_rule(Parser *p);
846 static asdl_seq *_loop0_122_rule(Parser *p);
847 static asdl_seq *_loop0_124_rule(Parser *p);
848 static asdl_seq *_gather_123_rule(Parser *p);
849 static void *_tmp_125_rule(Parser *p);
850 static asdl_seq *_loop0_127_rule(Parser *p);
851 static asdl_seq *_gather_126_rule(Parser *p);
852 static asdl_seq *_loop0_129_rule(Parser *p);
853 static asdl_seq *_gather_128_rule(Parser *p);
854 static asdl_seq *_loop0_131_rule(Parser *p);
855 static asdl_seq *_gather_130_rule(Parser *p);
856 static asdl_seq *_loop0_133_rule(Parser *p);
857 static asdl_seq *_gather_132_rule(Parser *p);
858 static asdl_seq *_loop0_134_rule(Parser *p);
859 static asdl_seq *_loop0_136_rule(Parser *p);
860 static asdl_seq *_gather_135_rule(Parser *p);
861 static asdl_seq *_loop1_137_rule(Parser *p);
862 static void *_tmp_138_rule(Parser *p);
863 static asdl_seq *_loop0_140_rule(Parser *p);
864 static asdl_seq *_gather_139_rule(Parser *p);
865 static void *_tmp_141_rule(Parser *p);
866 static void *_tmp_142_rule(Parser *p);
867 static void *_tmp_143_rule(Parser *p);
868 static void *_tmp_144_rule(Parser *p);
869 static void *_tmp_145_rule(Parser *p);
870 static void *_tmp_146_rule(Parser *p);
871 static void *_tmp_147_rule(Parser *p);
872 static void *_tmp_148_rule(Parser *p);
873 static asdl_seq *_loop0_149_rule(Parser *p);
874 static asdl_seq *_loop0_150_rule(Parser *p);
875 static asdl_seq *_loop0_151_rule(Parser *p);
876 static void *_tmp_152_rule(Parser *p);
877 static void *_tmp_153_rule(Parser *p);
878 static void *_tmp_154_rule(Parser *p);
879 static void *_tmp_155_rule(Parser *p);
880 static asdl_seq *_loop0_156_rule(Parser *p);
881 static asdl_seq *_loop1_157_rule(Parser *p);
882 static asdl_seq *_loop0_158_rule(Parser *p);
883 static asdl_seq *_loop1_159_rule(Parser *p);
884 static void *_tmp_160_rule(Parser *p);
885 static void *_tmp_161_rule(Parser *p);
886 static void *_tmp_162_rule(Parser *p);
887 static asdl_seq *_loop0_164_rule(Parser *p);
888 static asdl_seq *_gather_163_rule(Parser *p);
889 static asdl_seq *_loop0_166_rule(Parser *p);
890 static asdl_seq *_gather_165_rule(Parser *p);
891 static asdl_seq *_loop0_168_rule(Parser *p);
892 static asdl_seq *_gather_167_rule(Parser *p);
893 static asdl_seq *_loop0_170_rule(Parser *p);
894 static asdl_seq *_gather_169_rule(Parser *p);
895 static void *_tmp_171_rule(Parser *p);
896 static void *_tmp_172_rule(Parser *p);
897 static void *_tmp_173_rule(Parser *p);
898 static void *_tmp_174_rule(Parser *p);
899 static void *_tmp_175_rule(Parser *p);
900 static void *_tmp_176_rule(Parser *p);
901 static void *_tmp_177_rule(Parser *p);
902 static asdl_seq *_loop0_179_rule(Parser *p);
903 static asdl_seq *_gather_178_rule(Parser *p);
904 static void *_tmp_180_rule(Parser *p);
905 static void *_tmp_181_rule(Parser *p);
906 static void *_tmp_182_rule(Parser *p);
907 static void *_tmp_183_rule(Parser *p);
908 static void *_tmp_184_rule(Parser *p);
909 static void *_tmp_185_rule(Parser *p);
910 static void *_tmp_186_rule(Parser *p);
911 static void *_tmp_187_rule(Parser *p);
912 static void *_tmp_188_rule(Parser *p);
913 static void *_tmp_189_rule(Parser *p);
914 static void *_tmp_190_rule(Parser *p);
915 static void *_tmp_191_rule(Parser *p);
916 static void *_tmp_192_rule(Parser *p);
917 static void *_tmp_193_rule(Parser *p);
918 static void *_tmp_194_rule(Parser *p);
919 static void *_tmp_195_rule(Parser *p);
920 static void *_tmp_196_rule(Parser *p);
921 static void *_tmp_197_rule(Parser *p);
922 static void *_tmp_198_rule(Parser *p);
923 static void *_tmp_199_rule(Parser *p);
924 static void *_tmp_200_rule(Parser *p);
925 static void *_tmp_201_rule(Parser *p);
926 static void *_tmp_202_rule(Parser *p);
927 static void *_tmp_203_rule(Parser *p);
928 static void *_tmp_204_rule(Parser *p);
929 static void *_tmp_205_rule(Parser *p);
930 static void *_tmp_206_rule(Parser *p);
935 file_rule(Parser *p)  in file_rule()  argument
937     if (p->level++ == MAXSTACK) {  in file_rule()
938         p->error_indicator = 1;  in file_rule()
941     if (p->error_indicator) {  in file_rule()
942         p->level--;  in file_rule()
946     int _mark = p->mark;  in file_rule()
948         if (p->error_indicator) {  in file_rule()
949             p->level--;  in file_rule()
952 …      D(fprintf(stderr, "%*c> file[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statements? $"));  in file_rule()
956             (a = statements_rule(p), !p->error_indicator)  // statements?  in file_rule()
958             (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'  in file_rule()
961 …D(fprintf(stderr, "%*c+ file[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statements?…  in file_rule()
962             _res = _PyPegen_make_module ( p , a );  in file_rule()
964                 p->error_indicator = 1;  in file_rule()
965                 p->level--;  in file_rule()
970         p->mark = _mark;  in file_rule()
971         D(fprintf(stderr, "%*c%s file[%d-%d]: %s failed!\n", p->level, ' ',  in file_rule()
972                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statements? $"));  in file_rule()
976     p->level--;  in file_rule()
982 interactive_rule(Parser *p)  in interactive_rule()  argument
984     if (p->level++ == MAXSTACK) {  in interactive_rule()
985         p->error_indicator = 1;  in interactive_rule()
988     if (p->error_indicator) {  in interactive_rule()
989         p->level--;  in interactive_rule()
993     int _mark = p->mark;  in interactive_rule()
995         if (p->error_indicator) {  in interactive_rule()
996             p->level--;  in interactive_rule()
999 …D(fprintf(stderr, "%*c> interactive[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement_newli…  in interactive_rule()
1002             (a = statement_newline_rule(p))  // statement_newline  in interactive_rule()
1005 …D(fprintf(stderr, "%*c+ interactive[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "stat…  in interactive_rule()
1006             _res = _PyAST_Interactive ( a , p -> arena );  in interactive_rule()
1008                 p->error_indicator = 1;  in interactive_rule()
1009                 p->level--;  in interactive_rule()
1014         p->mark = _mark;  in interactive_rule()
1015         D(fprintf(stderr, "%*c%s interactive[%d-%d]: %s failed!\n", p->level, ' ',  in interactive_rule()
1016                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement_newline"));  in interactive_rule()
1020     p->level--;  in interactive_rule()
1026 eval_rule(Parser *p)  in eval_rule()  argument
1028     if (p->level++ == MAXSTACK) {  in eval_rule()
1029         p->error_indicator = 1;  in eval_rule()
1032     if (p->error_indicator) {  in eval_rule()
1033         p->level--;  in eval_rule()
1037     int _mark = p->mark;  in eval_rule()
1039         if (p->error_indicator) {  in eval_rule()
1040             p->level--;  in eval_rule()
1043 …D(fprintf(stderr, "%*c> eval[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $…  in eval_rule()
1048             (a = expressions_rule(p))  // expressions  in eval_rule()
1050             (_loop0_1_var = _loop0_1_rule(p))  // NEWLINE*  in eval_rule()
1052             (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'  in eval_rule()
1055 …D(fprintf(stderr, "%*c+ eval[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions…  in eval_rule()
1056             _res = _PyAST_Expression ( a , p -> arena );  in eval_rule()
1058                 p->error_indicator = 1;  in eval_rule()
1059                 p->level--;  in eval_rule()
1064         p->mark = _mark;  in eval_rule()
1065         D(fprintf(stderr, "%*c%s eval[%d-%d]: %s failed!\n", p->level, ' ',  in eval_rule()
1066                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions NEWLINE* $"));  in eval_rule()
1070     p->level--;  in eval_rule()
1074 // func_type: '(' type_expressions? ')' '->' expression NEWLINE* $
1076 func_type_rule(Parser *p)  in func_type_rule()  argument
1078     if (p->level++ == MAXSTACK) {  in func_type_rule()
1079         p->error_indicator = 1;  in func_type_rule()
1082     if (p->error_indicator) {  in func_type_rule()
1083         p->level--;  in func_type_rule()
1087     int _mark = p->mark;  in func_type_rule()
1088     { // '(' type_expressions? ')' '->' expression NEWLINE* $  in func_type_rule()
1089         if (p->error_indicator) {  in func_type_rule()
1090             p->level--;  in func_type_rule()
1093 …D(fprintf(stderr, "%*c> func_type[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' type_expressi…  in func_type_rule()
1102             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in func_type_rule()
1104             (a = type_expressions_rule(p), !p->error_indicator)  // type_expressions?  in func_type_rule()
1106             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in func_type_rule()
1108             (_literal_2 = _PyPegen_expect_token(p, 51))  // token='->'  in func_type_rule()
1110             (b = expression_rule(p))  // expression  in func_type_rule()
1112             (_loop0_2_var = _loop0_2_rule(p))  // NEWLINE*  in func_type_rule()
1114             (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'  in func_type_rule()
1117 …fprintf(stderr, "%*c+ func_type[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' type…  in func_type_rule()
1118             _res = _PyAST_FunctionType ( a , b , p -> arena );  in func_type_rule()
1120                 p->error_indicator = 1;  in func_type_rule()
1121                 p->level--;  in func_type_rule()
1126         p->mark = _mark;  in func_type_rule()
1127         D(fprintf(stderr, "%*c%s func_type[%d-%d]: %s failed!\n", p->level, ' ',  in func_type_rule()
1128 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' type_expressions? ')' '->' expression NE…  in func_type_rule()
1132     p->level--;  in func_type_rule()
1138 fstring_rule(Parser *p)  in fstring_rule()  argument
1140     if (p->level++ == MAXSTACK) {  in fstring_rule()
1141         p->error_indicator = 1;  in fstring_rule()
1144     if (p->error_indicator) {  in fstring_rule()
1145         p->level--;  in fstring_rule()
1149     int _mark = p->mark;  in fstring_rule()
1151         if (p->error_indicator) {  in fstring_rule()
1152             p->level--;  in fstring_rule()
1155 …D(fprintf(stderr, "%*c> fstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));  in fstring_rule()
1158             (star_expressions_var = star_expressions_rule(p))  // star_expressions  in fstring_rule()
1161 …D(fprintf(stderr, "%*c+ fstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_exp…  in fstring_rule()
1165         p->mark = _mark;  in fstring_rule()
1166         D(fprintf(stderr, "%*c%s fstring[%d-%d]: %s failed!\n", p->level, ' ',  in fstring_rule()
1167                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));  in fstring_rule()
1171     p->level--;  in fstring_rule()
1184 type_expressions_rule(Parser *p)  in type_expressions_rule()  argument
1186     if (p->level++ == MAXSTACK) {  in type_expressions_rule()
1187         p->error_indicator = 1;  in type_expressions_rule()
1190     if (p->error_indicator) {  in type_expressions_rule()
1191         p->level--;  in type_expressions_rule()
1195     int _mark = p->mark;  in type_expressions_rule()
1197         if (p->error_indicator) {  in type_expressions_rule()
1198             p->level--;  in type_expressions_rule()
1201 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expres…  in type_expressions_rule()
1210             (a = _gather_3_rule(p))  // ','.expression+  in type_expressions_rule()
1212             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in type_expressions_rule()
1214             (_literal_1 = _PyPegen_expect_token(p, 16))  // token='*'  in type_expressions_rule()
1216             (b = expression_rule(p))  // expression  in type_expressions_rule()
1218             (_literal_2 = _PyPegen_expect_token(p, 12))  // token=','  in type_expressions_rule()
1220             (_literal_3 = _PyPegen_expect_token(p, 35))  // token='**'  in type_expressions_rule()
1222             (c = expression_rule(p))  // expression  in type_expressions_rule()
1225 …D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in type_expressions_rule()
1226 …( asdl_expr_seq * ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq * , _PyPegen_seq_append_to_e…  in type_expressions_rule()
1228                 p->error_indicator = 1;  in type_expressions_rule()
1229                 p->level--;  in type_expressions_rule()
1234         p->mark = _mark;  in type_expressions_rule()
1235         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in type_expressions_rule()
1236 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' …  in type_expressions_rule()
1239         if (p->error_indicator) {  in type_expressions_rule()
1240             p->level--;  in type_expressions_rule()
1243 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expres…  in type_expressions_rule()
1249             (a = _gather_5_rule(p))  // ','.expression+  in type_expressions_rule()
1251             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in type_expressions_rule()
1253             (_literal_1 = _PyPegen_expect_token(p, 16))  // token='*'  in type_expressions_rule()
1255             (b = expression_rule(p))  // expression  in type_expressions_rule()
1258 …D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in type_expressions_rule()
1259             _res = ( asdl_expr_seq * ) _PyPegen_seq_append_to_end ( p , a , b );  in type_expressions_rule()
1261                 p->error_indicator = 1;  in type_expressions_rule()
1262                 p->level--;  in type_expressions_rule()
1267         p->mark = _mark;  in type_expressions_rule()
1268         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in type_expressions_rule()
1269 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression"));  in type_expressions_rule()
1272         if (p->error_indicator) {  in type_expressions_rule()
1273             p->level--;  in type_expressions_rule()
1276 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expres…  in type_expressions_rule()
1282             (a = _gather_7_rule(p))  // ','.expression+  in type_expressions_rule()
1284             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in type_expressions_rule()
1286             (_literal_1 = _PyPegen_expect_token(p, 35))  // token='**'  in type_expressions_rule()
1288             (b = expression_rule(p))  // expression  in type_expressions_rule()
1291 …D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in type_expressions_rule()
1292             _res = ( asdl_expr_seq * ) _PyPegen_seq_append_to_end ( p , a , b );  in type_expressions_rule()
1294                 p->error_indicator = 1;  in type_expressions_rule()
1295                 p->level--;  in type_expressions_rule()
1300         p->mark = _mark;  in type_expressions_rule()
1301         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in type_expressions_rule()
1302 …      p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '**' expression"));  in type_expressions_rule()
1305         if (p->error_indicator) {  in type_expressions_rule()
1306             p->level--;  in type_expressions_rule()
1309 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expres…  in type_expressions_rule()
1316             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in type_expressions_rule()
1318             (a = expression_rule(p))  // expression  in type_expressions_rule()
1320             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in type_expressions_rule()
1322             (_literal_2 = _PyPegen_expect_token(p, 35))  // token='**'  in type_expressions_rule()
1324             (b = expression_rule(p))  // expression  in type_expressions_rule()
1327 …D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in type_expressions_rule()
1328 …= ( asdl_expr_seq * ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq * , _PyPegen_singleton_seq…  in type_expressions_rule()
1330                 p->error_indicator = 1;  in type_expressions_rule()
1331                 p->level--;  in type_expressions_rule()
1336         p->mark = _mark;  in type_expressions_rule()
1337         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in type_expressions_rule()
1338 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression ',' '**' expression"));  in type_expressions_rule()
1341         if (p->error_indicator) {  in type_expressions_rule()
1342             p->level--;  in type_expressions_rule()
1345 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expres…  in type_expressions_rule()
1349             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in type_expressions_rule()
1351             (a = expression_rule(p))  // expression  in type_expressions_rule()
1354 …D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in type_expressions_rule()
1355             _res = ( asdl_expr_seq * ) _PyPegen_singleton_seq ( p , a );  in type_expressions_rule()
1357                 p->error_indicator = 1;  in type_expressions_rule()
1358                 p->level--;  in type_expressions_rule()
1363         p->mark = _mark;  in type_expressions_rule()
1364         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in type_expressions_rule()
1365                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression"));  in type_expressions_rule()
1368         if (p->error_indicator) {  in type_expressions_rule()
1369             p->level--;  in type_expressions_rule()
1372 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expre…  in type_expressions_rule()
1376             (_literal = _PyPegen_expect_token(p, 35))  // token='**'  in type_expressions_rule()
1378             (a = expression_rule(p))  // expression  in type_expressions_rule()
1381 …D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in type_expressions_rule()
1382             _res = ( asdl_expr_seq * ) _PyPegen_singleton_seq ( p , a );  in type_expressions_rule()
1384                 p->error_indicator = 1;  in type_expressions_rule()
1385                 p->level--;  in type_expressions_rule()
1390         p->mark = _mark;  in type_expressions_rule()
1391         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in type_expressions_rule()
1392                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression"));  in type_expressions_rule()
1395         if (p->error_indicator) {  in type_expressions_rule()
1396             p->level--;  in type_expressions_rule()
1399 …D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expres…  in type_expressions_rule()
1402             (a = (asdl_expr_seq*)_gather_9_rule(p))  // ','.expression+  in type_expressions_rule()
1405 …D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in type_expressions_rule()
1408                 p->error_indicator = 1;  in type_expressions_rule()
1409                 p->level--;  in type_expressions_rule()
1414         p->mark = _mark;  in type_expressions_rule()
1415         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in type_expressions_rule()
1416                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+"));  in type_expressions_rule()
1420     p->level--;  in type_expressions_rule()
1426 statements_rule(Parser *p)  in statements_rule()  argument
1428     if (p->level++ == MAXSTACK) {  in statements_rule()
1429         p->error_indicator = 1;  in statements_rule()
1432     if (p->error_indicator) {  in statements_rule()
1433         p->level--;  in statements_rule()
1437     int _mark = p->mark;  in statements_rule()
1439         if (p->error_indicator) {  in statements_rule()
1440             p->level--;  in statements_rule()
1443 …   D(fprintf(stderr, "%*c> statements[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement+"));  in statements_rule()
1446             (a = _loop1_11_rule(p))  // statement+  in statements_rule()
1449 …D(fprintf(stderr, "%*c+ statements[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "state…  in statements_rule()
1450             _res = ( asdl_stmt_seq * ) _PyPegen_seq_flatten ( p , a );  in statements_rule()
1452                 p->error_indicator = 1;  in statements_rule()
1453                 p->level--;  in statements_rule()
1458         p->mark = _mark;  in statements_rule()
1459         D(fprintf(stderr, "%*c%s statements[%d-%d]: %s failed!\n", p->level, ' ',  in statements_rule()
1460                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement+"));  in statements_rule()
1464     p->level--;  in statements_rule()
1470 statement_rule(Parser *p)  in statement_rule()  argument
1472     if (p->level++ == MAXSTACK) {  in statement_rule()
1473         p->error_indicator = 1;  in statement_rule()
1476     if (p->error_indicator) {  in statement_rule()
1477         p->level--;  in statement_rule()
1481     int _mark = p->mark;  in statement_rule()
1483         if (p->error_indicator) {  in statement_rule()
1484             p->level--;  in statement_rule()
1487 … D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt"));  in statement_rule()
1490             (a = compound_stmt_rule(p))  // compound_stmt  in statement_rule()
1493 …D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compou…  in statement_rule()
1494             _res = ( asdl_stmt_seq * ) _PyPegen_singleton_seq ( p , a );  in statement_rule()
1496                 p->error_indicator = 1;  in statement_rule()
1497                 p->level--;  in statement_rule()
1502         p->mark = _mark;  in statement_rule()
1503         D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ',  in statement_rule()
1504                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt"));  in statement_rule()
1507         if (p->error_indicator) {  in statement_rule()
1508             p->level--;  in statement_rule()
1511 …  D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts"));  in statement_rule()
1514             (a = (asdl_stmt_seq*)simple_stmts_rule(p))  // simple_stmts  in statement_rule()
1517 …D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple…  in statement_rule()
1520                 p->error_indicator = 1;  in statement_rule()
1521                 p->level--;  in statement_rule()
1526         p->mark = _mark;  in statement_rule()
1527         D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ',  in statement_rule()
1528                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts"));  in statement_rule()
1532     p->level--;  in statement_rule()
1538 statement_newline_rule(Parser *p)  in statement_newline_rule()  argument
1540     if (p->level++ == MAXSTACK) {  in statement_newline_rule()
1541         p->error_indicator = 1;  in statement_newline_rule()
1544     if (p->error_indicator) {  in statement_newline_rule()
1545         p->level--;  in statement_newline_rule()
1549     int _mark = p->mark;  in statement_newline_rule()
1550     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in statement_newline_rule()
1551         p->error_indicator = 1;  in statement_newline_rule()
1552         p->level--;  in statement_newline_rule()
1555     int _start_lineno = p->tokens[_mark]->lineno;  in statement_newline_rule()
1557     int _start_col_offset = p->tokens[_mark]->col_offset;  in statement_newline_rule()
1560         if (p->error_indicator) {  in statement_newline_rule()
1561             p->level--;  in statement_newline_rule()
1564 …D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_…  in statement_newline_rule()
1568             (a = compound_stmt_rule(p))  // compound_stmt  in statement_newline_rule()
1570             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in statement_newline_rule()
1573 …D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in statement_newline_rule()
1574             _res = ( asdl_stmt_seq * ) _PyPegen_singleton_seq ( p , a );  in statement_newline_rule()
1576                 p->error_indicator = 1;  in statement_newline_rule()
1577                 p->level--;  in statement_newline_rule()
1582         p->mark = _mark;  in statement_newline_rule()
1583         D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',  in statement_newline_rule()
1584                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt NEWLINE"));  in statement_newline_rule()
1587         if (p->error_indicator) {  in statement_newline_rule()
1588             p->level--;  in statement_newline_rule()
1591 …D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_st…  in statement_newline_rule()
1594             (simple_stmts_var = simple_stmts_rule(p))  // simple_stmts  in statement_newline_rule()
1597 …D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in statement_newline_rule()
1601         p->mark = _mark;  in statement_newline_rule()
1602         D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',  in statement_newline_rule()
1603                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts"));  in statement_newline_rule()
1606         if (p->error_indicator) {  in statement_newline_rule()
1607             p->level--;  in statement_newline_rule()
1610 …D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")…  in statement_newline_rule()
1613             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in statement_newline_rule()
1616 …D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in statement_newline_rule()
1617             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in statement_newline_rule()
1619                 p->level--;  in statement_newline_rule()
1622             int _end_lineno = _token->end_lineno;  in statement_newline_rule()
1624             int _end_col_offset = _token->end_col_offset;  in statement_newline_rule()
1626 …_res = ( asdl_stmt_seq * ) _PyPegen_singleton_seq ( p , CHECK ( stmt_ty , _PyAST_Pass ( EXTRA ) ) …  in statement_newline_rule()
1628                 p->error_indicator = 1;  in statement_newline_rule()
1629                 p->level--;  in statement_newline_rule()
1634         p->mark = _mark;  in statement_newline_rule()
1635         D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',  in statement_newline_rule()
1636                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));  in statement_newline_rule()
1639         if (p->error_indicator) {  in statement_newline_rule()
1640             p->level--;  in statement_newline_rule()
1643 …     D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "$"));  in statement_newline_rule()
1646             (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'  in statement_newline_rule()
1649 …D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in statement_newline_rule()
1650             _res = _PyPegen_interactive_exit ( p );  in statement_newline_rule()
1652                 p->error_indicator = 1;  in statement_newline_rule()
1653                 p->level--;  in statement_newline_rule()
1658         p->mark = _mark;  in statement_newline_rule()
1659         D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',  in statement_newline_rule()
1660                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "$"));  in statement_newline_rule()
1664     p->level--;  in statement_newline_rule()
1670 simple_stmts_rule(Parser *p)  in simple_stmts_rule()  argument
1672     if (p->level++ == MAXSTACK) {  in simple_stmts_rule()
1673         p->error_indicator = 1;  in simple_stmts_rule()
1676     if (p->error_indicator) {  in simple_stmts_rule()
1677         p->level--;  in simple_stmts_rule()
1681     int _mark = p->mark;  in simple_stmts_rule()
1683         if (p->error_indicator) {  in simple_stmts_rule()
1684             p->level--;  in simple_stmts_rule()
1687 …D(fprintf(stderr, "%*c> simple_stmts[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt !'…  in simple_stmts_rule()
1691             (a = simple_stmt_rule(p))  // simple_stmt  in simple_stmts_rule()
1693             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13)  // token=';'  in simple_stmts_rule()
1695             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in simple_stmts_rule()
1698 …D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sim…  in simple_stmts_rule()
1699             _res = ( asdl_stmt_seq * ) _PyPegen_singleton_seq ( p , a );  in simple_stmts_rule()
1701                 p->error_indicator = 1;  in simple_stmts_rule()
1702                 p->level--;  in simple_stmts_rule()
1707         p->mark = _mark;  in simple_stmts_rule()
1708         D(fprintf(stderr, "%*c%s simple_stmts[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmts_rule()
1709                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt !';' NEWLINE"));  in simple_stmts_rule()
1712         if (p->error_indicator) {  in simple_stmts_rule()
1713             p->level--;  in simple_stmts_rule()
1716 …D(fprintf(stderr, "%*c> simple_stmts[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'.simple_stm…  in simple_stmts_rule()
1722             (a = (asdl_stmt_seq*)_gather_12_rule(p))  // ';'.simple_stmt+  in simple_stmts_rule()
1724             (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator)  // ';'?  in simple_stmts_rule()
1726             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in simple_stmts_rule()
1729 …D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'…  in simple_stmts_rule()
1732                 p->error_indicator = 1;  in simple_stmts_rule()
1733                 p->level--;  in simple_stmts_rule()
1738         p->mark = _mark;  in simple_stmts_rule()
1739         D(fprintf(stderr, "%*c%s simple_stmts[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmts_rule()
1740 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE"));  in simple_stmts_rule()
1744     p->level--;  in simple_stmts_rule()
1763 simple_stmt_rule(Parser *p)  in simple_stmt_rule()  argument
1765     if (p->level++ == MAXSTACK) {  in simple_stmt_rule()
1766         p->error_indicator = 1;  in simple_stmt_rule()
1769     if (p->error_indicator) {  in simple_stmt_rule()
1770         p->level--;  in simple_stmt_rule()
1774     if (_PyPegen_is_memoized(p, simple_stmt_type, &_res)) {  in simple_stmt_rule()
1775         p->level--;  in simple_stmt_rule()
1778     int _mark = p->mark;  in simple_stmt_rule()
1779     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in simple_stmt_rule()
1780         p->error_indicator = 1;  in simple_stmt_rule()
1781         p->level--;  in simple_stmt_rule()
1784     int _start_lineno = p->tokens[_mark]->lineno;  in simple_stmt_rule()
1786     int _start_col_offset = p->tokens[_mark]->col_offset;  in simple_stmt_rule()
1789         if (p->error_indicator) {  in simple_stmt_rule()
1790             p->level--;  in simple_stmt_rule()
1793 …  D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment"));  in simple_stmt_rule()
1796             (assignment_var = assignment_rule(p))  // assignment  in simple_stmt_rule()
1799 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assi…  in simple_stmt_rule()
1803         p->mark = _mark;  in simple_stmt_rule()
1804         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
1805                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment"));  in simple_stmt_rule()
1808         if (p->error_indicator) {  in simple_stmt_rule()
1809             p->level--;  in simple_stmt_rule()
1812 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression…  in simple_stmt_rule()
1815             (e = star_expressions_rule(p))  // star_expressions  in simple_stmt_rule()
1818 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star…  in simple_stmt_rule()
1819             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in simple_stmt_rule()
1821                 p->level--;  in simple_stmt_rule()
1824             int _end_lineno = _token->end_lineno;  in simple_stmt_rule()
1826             int _end_col_offset = _token->end_col_offset;  in simple_stmt_rule()
1830                 p->error_indicator = 1;  in simple_stmt_rule()
1831                 p->level--;  in simple_stmt_rule()
1836         p->mark = _mark;  in simple_stmt_rule()
1837         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
1838                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));  in simple_stmt_rule()
1841         if (p->error_indicator) {  in simple_stmt_rule()
1842             p->level--;  in simple_stmt_rule()
1845 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'return' retur…  in simple_stmt_rule()
1848             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 500)  // token='return'  in simple_stmt_rule()
1850             (return_stmt_var = return_stmt_rule(p))  // return_stmt  in simple_stmt_rule()
1853 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'re…  in simple_stmt_rule()
1857         p->mark = _mark;  in simple_stmt_rule()
1858         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
1859                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'return' return_stmt"));  in simple_stmt_rule()
1862         if (p->error_indicator) {  in simple_stmt_rule()
1863             p->level--;  in simple_stmt_rule()
1866 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('import' | 'f…  in simple_stmt_rule()
1869             _PyPegen_lookahead(1, _tmp_14_rule, p)  in simple_stmt_rule()
1871             (import_stmt_var = import_stmt_rule(p))  // import_stmt  in simple_stmt_rule()
1874 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('i…  in simple_stmt_rule()
1878         p->mark = _mark;  in simple_stmt_rule()
1879         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
1880 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('import' | 'from') import_stmt"));  in simple_stmt_rule()
1883         if (p->error_indicator) {  in simple_stmt_rule()
1884             p->level--;  in simple_stmt_rule()
1887 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'raise' raise_…  in simple_stmt_rule()
1890             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 501)  // token='raise'  in simple_stmt_rule()
1892             (raise_stmt_var = raise_stmt_rule(p))  // raise_stmt  in simple_stmt_rule()
1895 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'ra…  in simple_stmt_rule()
1899         p->mark = _mark;  in simple_stmt_rule()
1900         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
1901                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'raise' raise_stmt"));  in simple_stmt_rule()
1904         if (p->error_indicator) {  in simple_stmt_rule()
1905             p->level--;  in simple_stmt_rule()
1908 …      D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'pass'"));  in simple_stmt_rule()
1911             (_keyword = _PyPegen_expect_token(p, 502))  // token='pass'  in simple_stmt_rule()
1914 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'pas…  in simple_stmt_rule()
1915             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in simple_stmt_rule()
1917                 p->level--;  in simple_stmt_rule()
1920             int _end_lineno = _token->end_lineno;  in simple_stmt_rule()
1922             int _end_col_offset = _token->end_col_offset;  in simple_stmt_rule()
1926                 p->error_indicator = 1;  in simple_stmt_rule()
1927                 p->level--;  in simple_stmt_rule()
1932         p->mark = _mark;  in simple_stmt_rule()
1933         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
1934                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'pass'"));  in simple_stmt_rule()
1937         if (p->error_indicator) {  in simple_stmt_rule()
1938             p->level--;  in simple_stmt_rule()
1941 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt…  in simple_stmt_rule()
1944             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 503)  // token='del'  in simple_stmt_rule()
1946             (del_stmt_var = del_stmt_rule(p))  // del_stmt  in simple_stmt_rule()
1949 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'de…  in simple_stmt_rule()
1953         p->mark = _mark;  in simple_stmt_rule()
1954         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
1955                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'del' del_stmt"));  in simple_stmt_rule()
1958         if (p->error_indicator) {  in simple_stmt_rule()
1959             p->level--;  in simple_stmt_rule()
1962 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'yield' yield_…  in simple_stmt_rule()
1965             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 504)  // token='yield'  in simple_stmt_rule()
1967             (yield_stmt_var = yield_stmt_rule(p))  // yield_stmt  in simple_stmt_rule()
1970 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'yi…  in simple_stmt_rule()
1974         p->mark = _mark;  in simple_stmt_rule()
1975         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
1976                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'yield' yield_stmt"));  in simple_stmt_rule()
1979         if (p->error_indicator) {  in simple_stmt_rule()
1980             p->level--;  in simple_stmt_rule()
1983 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'assert' asser…  in simple_stmt_rule()
1986             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 505)  // token='assert'  in simple_stmt_rule()
1988             (assert_stmt_var = assert_stmt_rule(p))  // assert_stmt  in simple_stmt_rule()
1991 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'as…  in simple_stmt_rule()
1995         p->mark = _mark;  in simple_stmt_rule()
1996         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
1997                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'assert' assert_stmt"));  in simple_stmt_rule()
2000         if (p->error_indicator) {  in simple_stmt_rule()
2001             p->level--;  in simple_stmt_rule()
2004 …     D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'break'"));  in simple_stmt_rule()
2007             (_keyword = _PyPegen_expect_token(p, 506))  // token='break'  in simple_stmt_rule()
2010 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'bre…  in simple_stmt_rule()
2011             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in simple_stmt_rule()
2013                 p->level--;  in simple_stmt_rule()
2016             int _end_lineno = _token->end_lineno;  in simple_stmt_rule()
2018             int _end_col_offset = _token->end_col_offset;  in simple_stmt_rule()
2022                 p->error_indicator = 1;  in simple_stmt_rule()
2023                 p->level--;  in simple_stmt_rule()
2028         p->mark = _mark;  in simple_stmt_rule()
2029         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
2030                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'break'"));  in simple_stmt_rule()
2033         if (p->error_indicator) {  in simple_stmt_rule()
2034             p->level--;  in simple_stmt_rule()
2037 …  D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'continue'"));  in simple_stmt_rule()
2040             (_keyword = _PyPegen_expect_token(p, 507))  // token='continue'  in simple_stmt_rule()
2043 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'con…  in simple_stmt_rule()
2044             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in simple_stmt_rule()
2046                 p->level--;  in simple_stmt_rule()
2049             int _end_lineno = _token->end_lineno;  in simple_stmt_rule()
2051             int _end_col_offset = _token->end_col_offset;  in simple_stmt_rule()
2055                 p->error_indicator = 1;  in simple_stmt_rule()
2056                 p->level--;  in simple_stmt_rule()
2061         p->mark = _mark;  in simple_stmt_rule()
2062         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
2063                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'continue'"));  in simple_stmt_rule()
2066         if (p->error_indicator) {  in simple_stmt_rule()
2067             p->level--;  in simple_stmt_rule()
2070 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'global' globa…  in simple_stmt_rule()
2073             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 508)  // token='global'  in simple_stmt_rule()
2075             (global_stmt_var = global_stmt_rule(p))  // global_stmt  in simple_stmt_rule()
2078 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'gl…  in simple_stmt_rule()
2082         p->mark = _mark;  in simple_stmt_rule()
2083         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
2084                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'global' global_stmt"));  in simple_stmt_rule()
2087         if (p->error_indicator) {  in simple_stmt_rule()
2088             p->level--;  in simple_stmt_rule()
2091 …D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'nonlocal' non…  in simple_stmt_rule()
2094             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 509)  // token='nonlocal'  in simple_stmt_rule()
2096             (nonlocal_stmt_var = nonlocal_stmt_rule(p))  // nonlocal_stmt  in simple_stmt_rule()
2099 …D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'no…  in simple_stmt_rule()
2103         p->mark = _mark;  in simple_stmt_rule()
2104         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in simple_stmt_rule()
2105 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'nonlocal' nonlocal_stmt"));  in simple_stmt_rule()
2109     _PyPegen_insert_memo(p, _mark, simple_stmt_type, _res);  in simple_stmt_rule()
2110     p->level--;  in simple_stmt_rule()
2124 compound_stmt_rule(Parser *p)  in compound_stmt_rule()  argument
2126     if (p->level++ == MAXSTACK) {  in compound_stmt_rule()
2127         p->error_indicator = 1;  in compound_stmt_rule()
2130     if (p->error_indicator) {  in compound_stmt_rule()
2131         p->level--;  in compound_stmt_rule()
2135     int _mark = p->mark;  in compound_stmt_rule()
2137         if (p->error_indicator) {  in compound_stmt_rule()
2138             p->level--;  in compound_stmt_rule()
2141 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('def' | '@'…  in compound_stmt_rule()
2144             _PyPegen_lookahead(1, _tmp_15_rule, p)  in compound_stmt_rule()
2146             (function_def_var = function_def_rule(p))  // function_def  in compound_stmt_rule()
2149 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(…  in compound_stmt_rule()
2153         p->mark = _mark;  in compound_stmt_rule()
2154         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in compound_stmt_rule()
2155 …      p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('def' | '@' | ASYNC) function_def"));  in compound_stmt_rule()
2158         if (p->error_indicator) {  in compound_stmt_rule()
2159             p->level--;  in compound_stmt_rule()
2162 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt…  in compound_stmt_rule()
2165             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 510)  // token='if'  in compound_stmt_rule()
2167             (if_stmt_var = if_stmt_rule(p))  // if_stmt  in compound_stmt_rule()
2170 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'…  in compound_stmt_rule()
2174         p->mark = _mark;  in compound_stmt_rule()
2175         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in compound_stmt_rule()
2176                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'if' if_stmt"));  in compound_stmt_rule()
2179         if (p->error_indicator) {  in compound_stmt_rule()
2180             p->level--;  in compound_stmt_rule()
2183 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('class' | '…  in compound_stmt_rule()
2186             _PyPegen_lookahead(1, _tmp_16_rule, p)  in compound_stmt_rule()
2188             (class_def_var = class_def_rule(p))  // class_def  in compound_stmt_rule()
2191 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(…  in compound_stmt_rule()
2195         p->mark = _mark;  in compound_stmt_rule()
2196         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in compound_stmt_rule()
2197 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('class' | '@') class_def"));  in compound_stmt_rule()
2200         if (p->error_indicator) {  in compound_stmt_rule()
2201             p->level--;  in compound_stmt_rule()
2204 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('with' | AS…  in compound_stmt_rule()
2207             _PyPegen_lookahead(1, _tmp_17_rule, p)  in compound_stmt_rule()
2209             (with_stmt_var = with_stmt_rule(p))  // with_stmt  in compound_stmt_rule()
2212 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(…  in compound_stmt_rule()
2216         p->mark = _mark;  in compound_stmt_rule()
2217         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in compound_stmt_rule()
2218 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('with' | ASYNC) with_stmt"));  in compound_stmt_rule()
2221         if (p->error_indicator) {  in compound_stmt_rule()
2222             p->level--;  in compound_stmt_rule()
2225 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('for' | ASY…  in compound_stmt_rule()
2228             _PyPegen_lookahead(1, _tmp_18_rule, p)  in compound_stmt_rule()
2230             (for_stmt_var = for_stmt_rule(p))  // for_stmt  in compound_stmt_rule()
2233 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(…  in compound_stmt_rule()
2237         p->mark = _mark;  in compound_stmt_rule()
2238         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in compound_stmt_rule()
2239 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('for' | ASYNC) for_stmt"));  in compound_stmt_rule()
2242         if (p->error_indicator) {  in compound_stmt_rule()
2243             p->level--;  in compound_stmt_rule()
2246 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'try' try_st…  in compound_stmt_rule()
2249             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 511)  // token='try'  in compound_stmt_rule()
2251             (try_stmt_var = try_stmt_rule(p))  // try_stmt  in compound_stmt_rule()
2254 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'…  in compound_stmt_rule()
2258         p->mark = _mark;  in compound_stmt_rule()
2259         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in compound_stmt_rule()
2260                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'try' try_stmt"));  in compound_stmt_rule()
2263         if (p->error_indicator) {  in compound_stmt_rule()
2264             p->level--;  in compound_stmt_rule()
2267 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'while' whil…  in compound_stmt_rule()
2270             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 512)  // token='while'  in compound_stmt_rule()
2272             (while_stmt_var = while_stmt_rule(p))  // while_stmt  in compound_stmt_rule()
2275 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'…  in compound_stmt_rule()
2279         p->mark = _mark;  in compound_stmt_rule()
2280         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in compound_stmt_rule()
2281                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'while' while_stmt"));  in compound_stmt_rule()
2284         if (p->error_indicator) {  in compound_stmt_rule()
2285             p->level--;  in compound_stmt_rule()
2288 …D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "match_stmt"));  in compound_stmt_rule()
2291             (match_stmt_var = match_stmt_rule(p))  // match_stmt  in compound_stmt_rule()
2294 …D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ma…  in compound_stmt_rule()
2298         p->mark = _mark;  in compound_stmt_rule()
2299         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in compound_stmt_rule()
2300                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "match_stmt"));  in compound_stmt_rule()
2304     p->level--;  in compound_stmt_rule()
2315 assignment_rule(Parser *p)  in assignment_rule()  argument
2317     if (p->level++ == MAXSTACK) {  in assignment_rule()
2318         p->error_indicator = 1;  in assignment_rule()
2321     if (p->error_indicator) {  in assignment_rule()
2322         p->level--;  in assignment_rule()
2326     int _mark = p->mark;  in assignment_rule()
2327     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in assignment_rule()
2328         p->error_indicator = 1;  in assignment_rule()
2329         p->level--;  in assignment_rule()
2332     int _start_lineno = p->tokens[_mark]->lineno;  in assignment_rule()
2334     int _start_col_offset = p->tokens[_mark]->col_offset;  in assignment_rule()
2337         if (p->error_indicator) {  in assignment_rule()
2338             p->level--;  in assignment_rule()
2341 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':' express…  in assignment_rule()
2347             (a = _PyPegen_name_token(p))  // NAME  in assignment_rule()
2349             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in assignment_rule()
2351             (b = expression_rule(p))  // expression  in assignment_rule()
2353             (c = _tmp_19_rule(p), !p->error_indicator)  // ['=' annotated_rhs]  in assignment_rule()
2356 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME …  in assignment_rule()
2357             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in assignment_rule()
2359                 p->level--;  in assignment_rule()
2362             int _end_lineno = _token->end_lineno;  in assignment_rule()
2364             int _end_col_offset = _token->end_col_offset;  in assignment_rule()
2366 …ntax is" , _PyAST_AnnAssign ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b …  in assignment_rule()
2368                 p->error_indicator = 1;  in assignment_rule()
2369                 p->level--;  in assignment_rule()
2374         p->mark = _mark;  in assignment_rule()
2375         D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',  in assignment_rule()
2376 …  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));  in assignment_rule()
2379         if (p->error_indicator) {  in assignment_rule()
2380             p->level--;  in assignment_rule()
2383 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('(' single_targ…  in assignment_rule()
2389             (a = _tmp_20_rule(p))  // '(' single_target ')' | single_subscript_attribute_target  in assignment_rule()
2391             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in assignment_rule()
2393             (b = expression_rule(p))  // expression  in assignment_rule()
2395             (c = _tmp_21_rule(p), !p->error_indicator)  // ['=' annotated_rhs]  in assignment_rule()
2398 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('(' …  in assignment_rule()
2399             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in assignment_rule()
2401                 p->level--;  in assignment_rule()
2404             int _end_lineno = _token->end_lineno;  in assignment_rule()
2406             int _end_col_offset = _token->end_col_offset;  in assignment_rule()
2410                 p->error_indicator = 1;  in assignment_rule()
2411                 p->level--;  in assignment_rule()
2416         p->mark = _mark;  in assignment_rule()
2417         D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',  in assignment_rule()
2418 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('(' single_target ')' | single_subscript_at…  in assignment_rule()
2421         if (p->error_indicator) {  in assignment_rule()
2422             p->level--;  in assignment_rule()
2425 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '…  in assignment_rule()
2430             (a = (asdl_expr_seq*)_loop1_22_rule(p))  // ((star_targets '='))+  in assignment_rule()
2432             (b = _tmp_23_rule(p))  // yield_expr | star_expressions  in assignment_rule()
2434             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)  // token='='  in assignment_rule()
2436             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in assignment_rule()
2439 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((sta…  in assignment_rule()
2440             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in assignment_rule()
2442                 p->level--;  in assignment_rule()
2445             int _end_lineno = _token->end_lineno;  in assignment_rule()
2447             int _end_col_offset = _token->end_col_offset;  in assignment_rule()
2449             _res = _PyAST_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );  in assignment_rule()
2451                 p->error_indicator = 1;  in assignment_rule()
2452                 p->level--;  in assignment_rule()
2457         p->mark = _mark;  in assignment_rule()
2458         D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',  in assignment_rule()
2459 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))+ (yield_expr | star_exp…  in assignment_rule()
2462         if (p->error_indicator) {  in assignment_rule()
2463             p->level--;  in assignment_rule()
2466 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_target au…  in assignment_rule()
2472             (a = single_target_rule(p))  // single_target  in assignment_rule()
2474             (b = augassign_rule(p))  // augassign  in assignment_rule()
2478             (c = _tmp_24_rule(p))  // yield_expr | star_expressions  in assignment_rule()
2481 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "singl…  in assignment_rule()
2482             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in assignment_rule()
2484                 p->level--;  in assignment_rule()
2487             int _end_lineno = _token->end_lineno;  in assignment_rule()
2489             int _end_col_offset = _token->end_col_offset;  in assignment_rule()
2491             _res = _PyAST_AugAssign ( a , b -> kind , c , EXTRA );  in assignment_rule()
2493                 p->error_indicator = 1;  in assignment_rule()
2494                 p->level--;  in assignment_rule()
2499         p->mark = _mark;  in assignment_rule()
2500         D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',  in assignment_rule()
2501 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_target augassign ~ (yield_expr | star…  in assignment_rule()
2503             p->level--;  in assignment_rule()
2507     if (p->call_invalid_rules) { // invalid_assignment  in assignment_rule()
2508         if (p->error_indicator) {  in assignment_rule()
2509             p->level--;  in assignment_rule()
2512 …D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_assignme…  in assignment_rule()
2515             (invalid_assignment_var = invalid_assignment_rule(p))  // invalid_assignment  in assignment_rule()
2518 …D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval…  in assignment_rule()
2522         p->mark = _mark;  in assignment_rule()
2523         D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',  in assignment_rule()
2524                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_assignment"));  in assignment_rule()
2528     p->level--;  in assignment_rule()
2534 //     | '-='
2547 augassign_rule(Parser *p)  in augassign_rule()  argument
2549     if (p->level++ == MAXSTACK) {  in augassign_rule()
2550         p->error_indicator = 1;  in augassign_rule()
2553     if (p->error_indicator) {  in augassign_rule()
2554         p->level--;  in augassign_rule()
2558     int _mark = p->mark;  in augassign_rule()
2560         if (p->error_indicator) {  in augassign_rule()
2561             p->level--;  in augassign_rule()
2564         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+='"));  in augassign_rule()
2567             (_literal = _PyPegen_expect_token(p, 36))  // token='+='  in augassign_rule()
2570 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+='")…  in augassign_rule()
2571             _res = _PyPegen_augoperator ( p , Add );  in augassign_rule()
2573                 p->error_indicator = 1;  in augassign_rule()
2574                 p->level--;  in augassign_rule()
2579         p->mark = _mark;  in augassign_rule()
2580         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2581                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+='"));  in augassign_rule()
2583     { // '-='  in augassign_rule()
2584         if (p->error_indicator) {  in augassign_rule()
2585             p->level--;  in augassign_rule()
2588         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-='"));  in augassign_rule()
2591             (_literal = _PyPegen_expect_token(p, 37))  // token='-='  in augassign_rule()
2594 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-='")…  in augassign_rule()
2595             _res = _PyPegen_augoperator ( p , Sub );  in augassign_rule()
2597                 p->error_indicator = 1;  in augassign_rule()
2598                 p->level--;  in augassign_rule()
2603         p->mark = _mark;  in augassign_rule()
2604         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2605                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-='"));  in augassign_rule()
2608         if (p->error_indicator) {  in augassign_rule()
2609             p->level--;  in augassign_rule()
2612         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*='"));  in augassign_rule()
2615             (_literal = _PyPegen_expect_token(p, 38))  // token='*='  in augassign_rule()
2618 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*='")…  in augassign_rule()
2619             _res = _PyPegen_augoperator ( p , Mult );  in augassign_rule()
2621                 p->error_indicator = 1;  in augassign_rule()
2622                 p->level--;  in augassign_rule()
2627         p->mark = _mark;  in augassign_rule()
2628         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2629                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*='"));  in augassign_rule()
2632         if (p->error_indicator) {  in augassign_rule()
2633             p->level--;  in augassign_rule()
2636         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@='"));  in augassign_rule()
2639             (_literal = _PyPegen_expect_token(p, 50))  // token='@='  in augassign_rule()
2642 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@='")…  in augassign_rule()
2643 …CHECK_VERSION ( AugOperator * , 5 , "The '@' operator is" , _PyPegen_augoperator ( p , MatMult ) );  in augassign_rule()
2645                 p->error_indicator = 1;  in augassign_rule()
2646                 p->level--;  in augassign_rule()
2651         p->mark = _mark;  in augassign_rule()
2652         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2653                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@='"));  in augassign_rule()
2656         if (p->error_indicator) {  in augassign_rule()
2657             p->level--;  in augassign_rule()
2660         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/='"));  in augassign_rule()
2663             (_literal = _PyPegen_expect_token(p, 39))  // token='/='  in augassign_rule()
2666 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/='")…  in augassign_rule()
2667             _res = _PyPegen_augoperator ( p , Div );  in augassign_rule()
2669                 p->error_indicator = 1;  in augassign_rule()
2670                 p->level--;  in augassign_rule()
2675         p->mark = _mark;  in augassign_rule()
2676         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2677                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/='"));  in augassign_rule()
2680         if (p->error_indicator) {  in augassign_rule()
2681             p->level--;  in augassign_rule()
2684         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%='"));  in augassign_rule()
2687             (_literal = _PyPegen_expect_token(p, 40))  // token='%='  in augassign_rule()
2690 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%='")…  in augassign_rule()
2691             _res = _PyPegen_augoperator ( p , Mod );  in augassign_rule()
2693                 p->error_indicator = 1;  in augassign_rule()
2694                 p->level--;  in augassign_rule()
2699         p->mark = _mark;  in augassign_rule()
2700         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2701                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%='"));  in augassign_rule()
2704         if (p->error_indicator) {  in augassign_rule()
2705             p->level--;  in augassign_rule()
2708         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'&='"));  in augassign_rule()
2711             (_literal = _PyPegen_expect_token(p, 41))  // token='&='  in augassign_rule()
2714 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'&='")…  in augassign_rule()
2715             _res = _PyPegen_augoperator ( p , BitAnd );  in augassign_rule()
2717                 p->error_indicator = 1;  in augassign_rule()
2718                 p->level--;  in augassign_rule()
2723         p->mark = _mark;  in augassign_rule()
2724         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2725                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'&='"));  in augassign_rule()
2728         if (p->error_indicator) {  in augassign_rule()
2729             p->level--;  in augassign_rule()
2732         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|='"));  in augassign_rule()
2735             (_literal = _PyPegen_expect_token(p, 42))  // token='|='  in augassign_rule()
2738 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|='")…  in augassign_rule()
2739             _res = _PyPegen_augoperator ( p , BitOr );  in augassign_rule()
2741                 p->error_indicator = 1;  in augassign_rule()
2742                 p->level--;  in augassign_rule()
2747         p->mark = _mark;  in augassign_rule()
2748         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2749                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|='"));  in augassign_rule()
2752         if (p->error_indicator) {  in augassign_rule()
2753             p->level--;  in augassign_rule()
2756         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'^='"));  in augassign_rule()
2759             (_literal = _PyPegen_expect_token(p, 43))  // token='^='  in augassign_rule()
2762 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'^='")…  in augassign_rule()
2763             _res = _PyPegen_augoperator ( p , BitXor );  in augassign_rule()
2765                 p->error_indicator = 1;  in augassign_rule()
2766                 p->level--;  in augassign_rule()
2771         p->mark = _mark;  in augassign_rule()
2772         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2773                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'^='"));  in augassign_rule()
2776         if (p->error_indicator) {  in augassign_rule()
2777             p->level--;  in augassign_rule()
2780         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<<='"));  in augassign_rule()
2783             (_literal = _PyPegen_expect_token(p, 44))  // token='<<='  in augassign_rule()
2786 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<<='"…  in augassign_rule()
2787             _res = _PyPegen_augoperator ( p , LShift );  in augassign_rule()
2789                 p->error_indicator = 1;  in augassign_rule()
2790                 p->level--;  in augassign_rule()
2795         p->mark = _mark;  in augassign_rule()
2796         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2797                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<<='"));  in augassign_rule()
2800         if (p->error_indicator) {  in augassign_rule()
2801             p->level--;  in augassign_rule()
2804         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>>='"));  in augassign_rule()
2807             (_literal = _PyPegen_expect_token(p, 45))  // token='>>='  in augassign_rule()
2810 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>>='"…  in augassign_rule()
2811             _res = _PyPegen_augoperator ( p , RShift );  in augassign_rule()
2813                 p->error_indicator = 1;  in augassign_rule()
2814                 p->level--;  in augassign_rule()
2819         p->mark = _mark;  in augassign_rule()
2820         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2821                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>>='"));  in augassign_rule()
2824         if (p->error_indicator) {  in augassign_rule()
2825             p->level--;  in augassign_rule()
2828         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**='"));  in augassign_rule()
2831             (_literal = _PyPegen_expect_token(p, 46))  // token='**='  in augassign_rule()
2834 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**='"…  in augassign_rule()
2835             _res = _PyPegen_augoperator ( p , Pow );  in augassign_rule()
2837                 p->error_indicator = 1;  in augassign_rule()
2838                 p->level--;  in augassign_rule()
2843         p->mark = _mark;  in augassign_rule()
2844         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2845                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**='"));  in augassign_rule()
2848         if (p->error_indicator) {  in augassign_rule()
2849             p->level--;  in augassign_rule()
2852         D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//='"));  in augassign_rule()
2855             (_literal = _PyPegen_expect_token(p, 48))  // token='//='  in augassign_rule()
2858 …D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//='"…  in augassign_rule()
2859             _res = _PyPegen_augoperator ( p , FloorDiv );  in augassign_rule()
2861                 p->error_indicator = 1;  in augassign_rule()
2862                 p->level--;  in augassign_rule()
2867         p->mark = _mark;  in augassign_rule()
2868         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',  in augassign_rule()
2869                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//='"));  in augassign_rule()
2873     p->level--;  in augassign_rule()
2879 global_stmt_rule(Parser *p)  in global_stmt_rule()  argument
2881     if (p->level++ == MAXSTACK) {  in global_stmt_rule()
2882         p->error_indicator = 1;  in global_stmt_rule()
2885     if (p->error_indicator) {  in global_stmt_rule()
2886         p->level--;  in global_stmt_rule()
2890     int _mark = p->mark;  in global_stmt_rule()
2891     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in global_stmt_rule()
2892         p->error_indicator = 1;  in global_stmt_rule()
2893         p->level--;  in global_stmt_rule()
2896     int _start_lineno = p->tokens[_mark]->lineno;  in global_stmt_rule()
2898     int _start_col_offset = p->tokens[_mark]->col_offset;  in global_stmt_rule()
2901         if (p->error_indicator) {  in global_stmt_rule()
2902             p->level--;  in global_stmt_rule()
2905 …D(fprintf(stderr, "%*c> global_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'global' ','.NA…  in global_stmt_rule()
2909             (_keyword = _PyPegen_expect_token(p, 508))  // token='global'  in global_stmt_rule()
2911             (a = (asdl_expr_seq*)_gather_25_rule(p))  // ','.NAME+  in global_stmt_rule()
2914 …D(fprintf(stderr, "%*c+ global_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'glo…  in global_stmt_rule()
2915             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in global_stmt_rule()
2917                 p->level--;  in global_stmt_rule()
2920             int _end_lineno = _token->end_lineno;  in global_stmt_rule()
2922             int _end_col_offset = _token->end_col_offset;  in global_stmt_rule()
2924 …_res = _PyAST_Global ( CHECK ( asdl_identifier_seq * , _PyPegen_map_names_to_ids ( p , a ) ) , EXT…  in global_stmt_rule()
2926                 p->error_indicator = 1;  in global_stmt_rule()
2927                 p->level--;  in global_stmt_rule()
2932         p->mark = _mark;  in global_stmt_rule()
2933         D(fprintf(stderr, "%*c%s global_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in global_stmt_rule()
2934                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'global' ','.NAME+"));  in global_stmt_rule()
2938     p->level--;  in global_stmt_rule()
2944 nonlocal_stmt_rule(Parser *p)  in nonlocal_stmt_rule()  argument
2946     if (p->level++ == MAXSTACK) {  in nonlocal_stmt_rule()
2947         p->error_indicator = 1;  in nonlocal_stmt_rule()
2950     if (p->error_indicator) {  in nonlocal_stmt_rule()
2951         p->level--;  in nonlocal_stmt_rule()
2955     int _mark = p->mark;  in nonlocal_stmt_rule()
2956     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in nonlocal_stmt_rule()
2957         p->error_indicator = 1;  in nonlocal_stmt_rule()
2958         p->level--;  in nonlocal_stmt_rule()
2961     int _start_lineno = p->tokens[_mark]->lineno;  in nonlocal_stmt_rule()
2963     int _start_col_offset = p->tokens[_mark]->col_offset;  in nonlocal_stmt_rule()
2966         if (p->error_indicator) {  in nonlocal_stmt_rule()
2967             p->level--;  in nonlocal_stmt_rule()
2970 …D(fprintf(stderr, "%*c> nonlocal_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'nonlocal' ',…  in nonlocal_stmt_rule()
2974             (_keyword = _PyPegen_expect_token(p, 509))  // token='nonlocal'  in nonlocal_stmt_rule()
2976             (a = (asdl_expr_seq*)_gather_27_rule(p))  // ','.NAME+  in nonlocal_stmt_rule()
2979 …D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'n…  in nonlocal_stmt_rule()
2980             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in nonlocal_stmt_rule()
2982                 p->level--;  in nonlocal_stmt_rule()
2985             int _end_lineno = _token->end_lineno;  in nonlocal_stmt_rule()
2987             int _end_col_offset = _token->end_col_offset;  in nonlocal_stmt_rule()
2989 …_res = _PyAST_Nonlocal ( CHECK ( asdl_identifier_seq * , _PyPegen_map_names_to_ids ( p , a ) ) , E…  in nonlocal_stmt_rule()
2991                 p->error_indicator = 1;  in nonlocal_stmt_rule()
2992                 p->level--;  in nonlocal_stmt_rule()
2997         p->mark = _mark;  in nonlocal_stmt_rule()
2998         D(fprintf(stderr, "%*c%s nonlocal_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in nonlocal_stmt_rule()
2999                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'nonlocal' ','.NAME+"));  in nonlocal_stmt_rule()
3003     p->level--;  in nonlocal_stmt_rule()
3009 yield_stmt_rule(Parser *p)  in yield_stmt_rule()  argument
3011     if (p->level++ == MAXSTACK) {  in yield_stmt_rule()
3012         p->error_indicator = 1;  in yield_stmt_rule()
3015     if (p->error_indicator) {  in yield_stmt_rule()
3016         p->level--;  in yield_stmt_rule()
3020     int _mark = p->mark;  in yield_stmt_rule()
3021     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in yield_stmt_rule()
3022         p->error_indicator = 1;  in yield_stmt_rule()
3023         p->level--;  in yield_stmt_rule()
3026     int _start_lineno = p->tokens[_mark]->lineno;  in yield_stmt_rule()
3028     int _start_col_offset = p->tokens[_mark]->col_offset;  in yield_stmt_rule()
3031         if (p->error_indicator) {  in yield_stmt_rule()
3032             p->level--;  in yield_stmt_rule()
3035 …   D(fprintf(stderr, "%*c> yield_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));  in yield_stmt_rule()
3038             (y = yield_expr_rule(p))  // yield_expr  in yield_stmt_rule()
3041 …D(fprintf(stderr, "%*c+ yield_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield…  in yield_stmt_rule()
3042             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in yield_stmt_rule()
3044                 p->level--;  in yield_stmt_rule()
3047             int _end_lineno = _token->end_lineno;  in yield_stmt_rule()
3049             int _end_col_offset = _token->end_col_offset;  in yield_stmt_rule()
3053                 p->error_indicator = 1;  in yield_stmt_rule()
3054                 p->level--;  in yield_stmt_rule()
3059         p->mark = _mark;  in yield_stmt_rule()
3060         D(fprintf(stderr, "%*c%s yield_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in yield_stmt_rule()
3061                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));  in yield_stmt_rule()
3065     p->level--;  in yield_stmt_rule()
3071 assert_stmt_rule(Parser *p)  in assert_stmt_rule()  argument
3073     if (p->level++ == MAXSTACK) {  in assert_stmt_rule()
3074         p->error_indicator = 1;  in assert_stmt_rule()
3077     if (p->error_indicator) {  in assert_stmt_rule()
3078         p->level--;  in assert_stmt_rule()
3082     int _mark = p->mark;  in assert_stmt_rule()
3083     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in assert_stmt_rule()
3084         p->error_indicator = 1;  in assert_stmt_rule()
3085         p->level--;  in assert_stmt_rule()
3088     int _start_lineno = p->tokens[_mark]->lineno;  in assert_stmt_rule()
3090     int _start_col_offset = p->tokens[_mark]->col_offset;  in assert_stmt_rule()
3093         if (p->error_indicator) {  in assert_stmt_rule()
3094             p->level--;  in assert_stmt_rule()
3097 …D(fprintf(stderr, "%*c> assert_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'assert' expres…  in assert_stmt_rule()
3102             (_keyword = _PyPegen_expect_token(p, 505))  // token='assert'  in assert_stmt_rule()
3104             (a = expression_rule(p))  // expression  in assert_stmt_rule()
3106             (b = _tmp_29_rule(p), !p->error_indicator)  // [',' expression]  in assert_stmt_rule()
3109 …D(fprintf(stderr, "%*c+ assert_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'ass…  in assert_stmt_rule()
3110             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in assert_stmt_rule()
3112                 p->level--;  in assert_stmt_rule()
3115             int _end_lineno = _token->end_lineno;  in assert_stmt_rule()
3117             int _end_col_offset = _token->end_col_offset;  in assert_stmt_rule()
3121                 p->error_indicator = 1;  in assert_stmt_rule()
3122                 p->level--;  in assert_stmt_rule()
3127         p->mark = _mark;  in assert_stmt_rule()
3128         D(fprintf(stderr, "%*c%s assert_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in assert_stmt_rule()
3129 …     p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'assert' expression [',' expression]"));  in assert_stmt_rule()
3133     p->level--;  in assert_stmt_rule()
3139 del_stmt_rule(Parser *p)  in del_stmt_rule()  argument
3141     if (p->level++ == MAXSTACK) {  in del_stmt_rule()
3142         p->error_indicator = 1;  in del_stmt_rule()
3145     if (p->error_indicator) {  in del_stmt_rule()
3146         p->level--;  in del_stmt_rule()
3150     int _mark = p->mark;  in del_stmt_rule()
3151     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in del_stmt_rule()
3152         p->error_indicator = 1;  in del_stmt_rule()
3153         p->level--;  in del_stmt_rule()
3156     int _start_lineno = p->tokens[_mark]->lineno;  in del_stmt_rule()
3158     int _start_col_offset = p->tokens[_mark]->col_offset;  in del_stmt_rule()
3161         if (p->error_indicator) {  in del_stmt_rule()
3162             p->level--;  in del_stmt_rule()
3165 …D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' del_targets …  in del_stmt_rule()
3169             (_keyword = _PyPegen_expect_token(p, 503))  // token='del'  in del_stmt_rule()
3171             (a = del_targets_rule(p))  // del_targets  in del_stmt_rule()
3173             _PyPegen_lookahead(1, _tmp_30_rule, p)  in del_stmt_rule()
3176 …D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' d…  in del_stmt_rule()
3177             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in del_stmt_rule()
3179                 p->level--;  in del_stmt_rule()
3182             int _end_lineno = _token->end_lineno;  in del_stmt_rule()
3184             int _end_col_offset = _token->end_col_offset;  in del_stmt_rule()
3188                 p->error_indicator = 1;  in del_stmt_rule()
3189                 p->level--;  in del_stmt_rule()
3194         p->mark = _mark;  in del_stmt_rule()
3195         D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in del_stmt_rule()
3196 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));  in del_stmt_rule()
3198     if (p->call_invalid_rules) { // invalid_del_stmt  in del_stmt_rule()
3199         if (p->error_indicator) {  in del_stmt_rule()
3200             p->level--;  in del_stmt_rule()
3203 …D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt")…  in del_stmt_rule()
3206             (invalid_del_stmt_var = invalid_del_stmt_rule(p))  // invalid_del_stmt  in del_stmt_rule()
3209 …D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid…  in del_stmt_rule()
3213         p->mark = _mark;  in del_stmt_rule()
3214         D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in del_stmt_rule()
3215                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_del_stmt"));  in del_stmt_rule()
3219     p->level--;  in del_stmt_rule()
3225 import_stmt_rule(Parser *p)  in import_stmt_rule()  argument
3227     if (p->level++ == MAXSTACK) {  in import_stmt_rule()
3228         p->error_indicator = 1;  in import_stmt_rule()
3231     if (p->error_indicator) {  in import_stmt_rule()
3232         p->level--;  in import_stmt_rule()
3236     int _mark = p->mark;  in import_stmt_rule()
3238         if (p->error_indicator) {  in import_stmt_rule()
3239             p->level--;  in import_stmt_rule()
3242 … D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_name"));  in import_stmt_rule()
3245             (import_name_var = import_name_rule(p))  // import_name  in import_stmt_rule()
3248 …D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "impo…  in import_stmt_rule()
3252         p->mark = _mark;  in import_stmt_rule()
3253         D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in import_stmt_rule()
3254                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_name"));  in import_stmt_rule()
3257         if (p->error_indicator) {  in import_stmt_rule()
3258             p->level--;  in import_stmt_rule()
3261 … D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from"));  in import_stmt_rule()
3264             (import_from_var = import_from_rule(p))  // import_from  in import_stmt_rule()
3267 …D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "impo…  in import_stmt_rule()
3271         p->mark = _mark;  in import_stmt_rule()
3272         D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in import_stmt_rule()
3273                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from"));  in import_stmt_rule()
3277     p->level--;  in import_stmt_rule()
3283 import_name_rule(Parser *p)  in import_name_rule()  argument
3285     if (p->level++ == MAXSTACK) {  in import_name_rule()
3286         p->error_indicator = 1;  in import_name_rule()
3289     if (p->error_indicator) {  in import_name_rule()
3290         p->level--;  in import_name_rule()
3294     int _mark = p->mark;  in import_name_rule()
3295     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in import_name_rule()
3296         p->error_indicator = 1;  in import_name_rule()
3297         p->level--;  in import_name_rule()
3300     int _start_lineno = p->tokens[_mark]->lineno;  in import_name_rule()
3302     int _start_col_offset = p->tokens[_mark]->col_offset;  in import_name_rule()
3305         if (p->error_indicator) {  in import_name_rule()
3306             p->level--;  in import_name_rule()
3309 …D(fprintf(stderr, "%*c> import_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' dotted…  in import_name_rule()
3313             (_keyword = _PyPegen_expect_token(p, 513))  // token='import'  in import_name_rule()
3315             (a = dotted_as_names_rule(p))  // dotted_as_names  in import_name_rule()
3318 …D(fprintf(stderr, "%*c+ import_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'imp…  in import_name_rule()
3319             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in import_name_rule()
3321                 p->level--;  in import_name_rule()
3324             int _end_lineno = _token->end_lineno;  in import_name_rule()
3326             int _end_col_offset = _token->end_col_offset;  in import_name_rule()
3330                 p->error_indicator = 1;  in import_name_rule()
3331                 p->level--;  in import_name_rule()
3336         p->mark = _mark;  in import_name_rule()
3337         D(fprintf(stderr, "%*c%s import_name[%d-%d]: %s failed!\n", p->level, ' ',  in import_name_rule()
3338                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import' dotted_as_names"));  in import_name_rule()
3342     p->level--;  in import_name_rule()
3350 import_from_rule(Parser *p)  in import_from_rule()  argument
3352     if (p->level++ == MAXSTACK) {  in import_from_rule()
3353         p->error_indicator = 1;  in import_from_rule()
3356     if (p->error_indicator) {  in import_from_rule()
3357         p->level--;  in import_from_rule()
3361     int _mark = p->mark;  in import_from_rule()
3362     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in import_from_rule()
3363         p->error_indicator = 1;  in import_from_rule()
3364         p->level--;  in import_from_rule()
3367     int _start_lineno = p->tokens[_mark]->lineno;  in import_from_rule()
3369     int _start_col_offset = p->tokens[_mark]->col_offset;  in import_from_rule()
3372         if (p->error_indicator) {  in import_from_rule()
3373             p->level--;  in import_from_rule()
3376 …D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | …  in import_from_rule()
3383             (_keyword = _PyPegen_expect_token(p, 514))  // token='from'  in import_from_rule()
3385             (a = _loop0_31_rule(p))  // (('.' | '...'))*  in import_from_rule()
3387             (b = dotted_name_rule(p))  // dotted_name  in import_from_rule()
3389             (_keyword_1 = _PyPegen_expect_token(p, 513))  // token='import'  in import_from_rule()
3391             (c = import_from_targets_rule(p))  // import_from_targets  in import_from_rule()
3394 …D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'fro…  in import_from_rule()
3395             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in import_from_rule()
3397                 p->level--;  in import_from_rule()
3400             int _end_lineno = _token->end_lineno;  in import_from_rule()
3402             int _end_col_offset = _token->end_col_offset;  in import_from_rule()
3404 …       _res = _PyAST_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA );  in import_from_rule()
3406                 p->error_indicator = 1;  in import_from_rule()
3407                 p->level--;  in import_from_rule()
3412         p->mark = _mark;  in import_from_rule()
3413         D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ',  in import_from_rule()
3414 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import'…  in import_from_rule()
3417         if (p->error_indicator) {  in import_from_rule()
3418             p->level--;  in import_from_rule()
3421 …D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | …  in import_from_rule()
3427             (_keyword = _PyPegen_expect_token(p, 514))  // token='from'  in import_from_rule()
3429             (a = _loop1_32_rule(p))  // (('.' | '...'))+  in import_from_rule()
3431             (_keyword_1 = _PyPegen_expect_token(p, 513))  // token='import'  in import_from_rule()
3433             (b = import_from_targets_rule(p))  // import_from_targets  in import_from_rule()
3436 …D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'fro…  in import_from_rule()
3437             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in import_from_rule()
3439                 p->level--;  in import_from_rule()
3442             int _end_lineno = _token->end_lineno;  in import_from_rule()
3444             int _end_col_offset = _token->end_col_offset;  in import_from_rule()
3448                 p->error_indicator = 1;  in import_from_rule()
3449                 p->level--;  in import_from_rule()
3454         p->mark = _mark;  in import_from_rule()
3455         D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ',  in import_from_rule()
3456 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from…  in import_from_rule()
3460     p->level--;  in import_from_rule()
3470 import_from_targets_rule(Parser *p)  in import_from_targets_rule()  argument
3472     if (p->level++ == MAXSTACK) {  in import_from_targets_rule()
3473         p->error_indicator = 1;  in import_from_targets_rule()
3476     if (p->error_indicator) {  in import_from_targets_rule()
3477         p->level--;  in import_from_targets_rule()
3481     int _mark = p->mark;  in import_from_targets_rule()
3482     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in import_from_targets_rule()
3483         p->error_indicator = 1;  in import_from_targets_rule()
3484         p->level--;  in import_from_targets_rule()
3487     int _start_lineno = p->tokens[_mark]->lineno;  in import_from_targets_rule()
3489     int _start_col_offset = p->tokens[_mark]->col_offset;  in import_from_targets_rule()
3492         if (p->error_indicator) {  in import_from_targets_rule()
3493             p->level--;  in import_from_targets_rule()
3496 …D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' imp…  in import_from_targets_rule()
3503             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in import_from_targets_rule()
3505             (a = import_from_as_names_rule(p))  // import_from_as_names  in import_from_targets_rule()
3507             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in import_from_targets_rule()
3509             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in import_from_targets_rule()
3512 …D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in import_from_targets_rule()
3515                 p->error_indicator = 1;  in import_from_targets_rule()
3516                 p->level--;  in import_from_targets_rule()
3521         p->mark = _mark;  in import_from_targets_rule()
3522         D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',  in import_from_targets_rule()
3523 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' import_from_as_names ','? ')'"));  in import_from_targets_rule()
3526         if (p->error_indicator) {  in import_from_targets_rule()
3527             p->level--;  in import_from_targets_rule()
3530 …D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_…  in import_from_targets_rule()
3533             (import_from_as_names_var = import_from_as_names_rule(p))  // import_from_as_names  in import_from_targets_rule()
3535             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)  // token=','  in import_from_targets_rule()
3538 …D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in import_from_targets_rule()
3542         p->mark = _mark;  in import_from_targets_rule()
3543         D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',  in import_from_targets_rule()
3544 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names !','"));  in import_from_targets_rule()
3547         if (p->error_indicator) {  in import_from_targets_rule()
3548             p->level--;  in import_from_targets_rule()
3551 … D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));  in import_from_targets_rule()
3554             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in import_from_targets_rule()
3557 …D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in import_from_targets_rule()
3558             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in import_from_targets_rule()
3560                 p->level--;  in import_from_targets_rule()
3563             int _end_lineno = _token->end_lineno;  in import_from_targets_rule()
3565             int _end_col_offset = _token->end_col_offset;  in import_from_targets_rule()
3567 …es = ( asdl_alias_seq * ) _PyPegen_singleton_seq ( p , CHECK ( alias_ty , _PyPegen_alias_for_star …  in import_from_targets_rule()
3569                 p->error_indicator = 1;  in import_from_targets_rule()
3570                 p->level--;  in import_from_targets_rule()
3575         p->mark = _mark;  in import_from_targets_rule()
3576         D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',  in import_from_targets_rule()
3577                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'"));  in import_from_targets_rule()
3579     if (p->call_invalid_rules) { // invalid_import_from_targets  in import_from_targets_rule()
3580         if (p->error_indicator) {  in import_from_targets_rule()
3581             p->level--;  in import_from_targets_rule()
3584 …D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid…  in import_from_targets_rule()
3587 …(invalid_import_from_targets_var = invalid_import_from_targets_rule(p))  // invalid_import_from_ta…  in import_from_targets_rule()
3590 …D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in import_from_targets_rule()
3594         p->mark = _mark;  in import_from_targets_rule()
3595         D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',  in import_from_targets_rule()
3596 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_import_from_targets"));  in import_from_targets_rule()
3600     p->level--;  in import_from_targets_rule()
3606 import_from_as_names_rule(Parser *p)  in import_from_as_names_rule()  argument
3608     if (p->level++ == MAXSTACK) {  in import_from_as_names_rule()
3609         p->error_indicator = 1;  in import_from_as_names_rule()
3612     if (p->error_indicator) {  in import_from_as_names_rule()
3613         p->level--;  in import_from_as_names_rule()
3617     int _mark = p->mark;  in import_from_as_names_rule()
3619         if (p->error_indicator) {  in import_from_as_names_rule()
3620             p->level--;  in import_from_as_names_rule()
3623 …D(fprintf(stderr, "%*c> import_from_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.im…  in import_from_as_names_rule()
3626             (a = (asdl_alias_seq*)_gather_33_rule(p))  // ','.import_from_as_name+  in import_from_as_names_rule()
3629 …D(fprintf(stderr, "%*c+ import_from_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->ma…  in import_from_as_names_rule()
3632                 p->error_indicator = 1;  in import_from_as_names_rule()
3633                 p->level--;  in import_from_as_names_rule()
3638         p->mark = _mark;  in import_from_as_names_rule()
3639         D(fprintf(stderr, "%*c%s import_from_as_names[%d-%d]: %s failed!\n", p->level, ' ',  in import_from_as_names_rule()
3640                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.import_from_as_name+"));  in import_from_as_names_rule()
3644     p->level--;  in import_from_as_names_rule()
3650 import_from_as_name_rule(Parser *p)  in import_from_as_name_rule()  argument
3652     if (p->level++ == MAXSTACK) {  in import_from_as_name_rule()
3653         p->error_indicator = 1;  in import_from_as_name_rule()
3656     if (p->error_indicator) {  in import_from_as_name_rule()
3657         p->level--;  in import_from_as_name_rule()
3661     int _mark = p->mark;  in import_from_as_name_rule()
3662     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in import_from_as_name_rule()
3663         p->error_indicator = 1;  in import_from_as_name_rule()
3664         p->level--;  in import_from_as_name_rule()
3667     int _start_lineno = p->tokens[_mark]->lineno;  in import_from_as_name_rule()
3669     int _start_col_offset = p->tokens[_mark]->col_offset;  in import_from_as_name_rule()
3672         if (p->error_indicator) {  in import_from_as_name_rule()
3673             p->level--;  in import_from_as_name_rule()
3676 …D(fprintf(stderr, "%*c> import_from_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ['…  in import_from_as_name_rule()
3680             (a = _PyPegen_name_token(p))  // NAME  in import_from_as_name_rule()
3682             (b = _tmp_35_rule(p), !p->error_indicator)  // ['as' NAME]  in import_from_as_name_rule()
3685 …D(fprintf(stderr, "%*c+ import_from_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in import_from_as_name_rule()
3686             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in import_from_as_name_rule()
3688                 p->level--;  in import_from_as_name_rule()
3691             int _end_lineno = _token->end_lineno;  in import_from_as_name_rule()
3693             int _end_col_offset = _token->end_col_offset;  in import_from_as_name_rule()
3695 …_res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXT…  in import_from_as_name_rule()
3697                 p->error_indicator = 1;  in import_from_as_name_rule()
3698                 p->level--;  in import_from_as_name_rule()
3703         p->mark = _mark;  in import_from_as_name_rule()
3704         D(fprintf(stderr, "%*c%s import_from_as_name[%d-%d]: %s failed!\n", p->level, ' ',  in import_from_as_name_rule()
3705                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ['as' NAME]"));  in import_from_as_name_rule()
3709     p->level--;  in import_from_as_name_rule()
3715 dotted_as_names_rule(Parser *p)  in dotted_as_names_rule()  argument
3717     if (p->level++ == MAXSTACK) {  in dotted_as_names_rule()
3718         p->error_indicator = 1;  in dotted_as_names_rule()
3721     if (p->error_indicator) {  in dotted_as_names_rule()
3722         p->level--;  in dotted_as_names_rule()
3726     int _mark = p->mark;  in dotted_as_names_rule()
3728         if (p->error_indicator) {  in dotted_as_names_rule()
3729             p->level--;  in dotted_as_names_rule()
3732 …D(fprintf(stderr, "%*c> dotted_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.dotted_…  in dotted_as_names_rule()
3735             (a = (asdl_alias_seq*)_gather_36_rule(p))  // ','.dotted_as_name+  in dotted_as_names_rule()
3738 …D(fprintf(stderr, "%*c+ dotted_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in dotted_as_names_rule()
3741                 p->error_indicator = 1;  in dotted_as_names_rule()
3742                 p->level--;  in dotted_as_names_rule()
3747         p->mark = _mark;  in dotted_as_names_rule()
3748         D(fprintf(stderr, "%*c%s dotted_as_names[%d-%d]: %s failed!\n", p->level, ' ',  in dotted_as_names_rule()
3749                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.dotted_as_name+"));  in dotted_as_names_rule()
3753     p->level--;  in dotted_as_names_rule()
3759 dotted_as_name_rule(Parser *p)  in dotted_as_name_rule()  argument
3761     if (p->level++ == MAXSTACK) {  in dotted_as_name_rule()
3762         p->error_indicator = 1;  in dotted_as_name_rule()
3765     if (p->error_indicator) {  in dotted_as_name_rule()
3766         p->level--;  in dotted_as_name_rule()
3770     int _mark = p->mark;  in dotted_as_name_rule()
3771     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in dotted_as_name_rule()
3772         p->error_indicator = 1;  in dotted_as_name_rule()
3773         p->level--;  in dotted_as_name_rule()
3776     int _start_lineno = p->tokens[_mark]->lineno;  in dotted_as_name_rule()
3778     int _start_col_offset = p->tokens[_mark]->col_offset;  in dotted_as_name_rule()
3781         if (p->error_indicator) {  in dotted_as_name_rule()
3782             p->level--;  in dotted_as_name_rule()
3785 …D(fprintf(stderr, "%*c> dotted_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name …  in dotted_as_name_rule()
3789             (a = dotted_name_rule(p))  // dotted_name  in dotted_as_name_rule()
3791             (b = _tmp_38_rule(p), !p->error_indicator)  // ['as' NAME]  in dotted_as_name_rule()
3794 …D(fprintf(stderr, "%*c+ dotted_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "d…  in dotted_as_name_rule()
3795             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in dotted_as_name_rule()
3797                 p->level--;  in dotted_as_name_rule()
3800             int _end_lineno = _token->end_lineno;  in dotted_as_name_rule()
3802             int _end_col_offset = _token->end_col_offset;  in dotted_as_name_rule()
3804 …_res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXT…  in dotted_as_name_rule()
3806                 p->error_indicator = 1;  in dotted_as_name_rule()
3807                 p->level--;  in dotted_as_name_rule()
3812         p->mark = _mark;  in dotted_as_name_rule()
3813         D(fprintf(stderr, "%*c%s dotted_as_name[%d-%d]: %s failed!\n", p->level, ' ',  in dotted_as_name_rule()
3814                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name ['as' NAME]"));  in dotted_as_name_rule()
3818     p->level--;  in dotted_as_name_rule()
3822 // Left-recursive
3826 dotted_name_rule(Parser *p)  in dotted_name_rule()  argument
3828     if (p->level++ == MAXSTACK) {  in dotted_name_rule()
3829         p->error_indicator = 1;  in dotted_name_rule()
3833     if (_PyPegen_is_memoized(p, dotted_name_type, &_res)) {  in dotted_name_rule()
3834         p->level--;  in dotted_name_rule()
3837     int _mark = p->mark;  in dotted_name_rule()
3838     int _resmark = p->mark;  in dotted_name_rule()
3840         int tmpvar_0 = _PyPegen_update_memo(p, _mark, dotted_name_type, _res);  in dotted_name_rule()
3842             p->level--;  in dotted_name_rule()
3845         p->mark = _mark;  in dotted_name_rule()
3846         void *_raw = dotted_name_raw(p);  in dotted_name_rule()
3847         if (p->error_indicator) {  in dotted_name_rule()
3848             p->level--;  in dotted_name_rule()
3851         if (_raw == NULL || p->mark <= _resmark)  in dotted_name_rule()
3853         _resmark = p->mark;  in dotted_name_rule()
3856     p->mark = _resmark;  in dotted_name_rule()
3857     p->level--;  in dotted_name_rule()
3861 dotted_name_raw(Parser *p)  in dotted_name_raw()  argument
3863     if (p->level++ == MAXSTACK) {  in dotted_name_raw()
3864         p->error_indicator = 1;  in dotted_name_raw()
3867     if (p->error_indicator) {  in dotted_name_raw()
3868         p->level--;  in dotted_name_raw()
3872     int _mark = p->mark;  in dotted_name_raw()
3874         if (p->error_indicator) {  in dotted_name_raw()
3875             p->level--;  in dotted_name_raw()
3878 …D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name '.'…  in dotted_name_raw()
3883             (a = dotted_name_rule(p))  // dotted_name  in dotted_name_raw()
3885             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in dotted_name_raw()
3887             (b = _PyPegen_name_token(p))  // NAME  in dotted_name_raw()
3890 …D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dott…  in dotted_name_raw()
3891             _res = _PyPegen_join_names_with_dot ( p , a , b );  in dotted_name_raw()
3893                 p->error_indicator = 1;  in dotted_name_raw()
3894                 p->level--;  in dotted_name_raw()
3899         p->mark = _mark;  in dotted_name_raw()
3900         D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ',  in dotted_name_raw()
3901                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name '.' NAME"));  in dotted_name_raw()
3904         if (p->error_indicator) {  in dotted_name_raw()
3905             p->level--;  in dotted_name_raw()
3908         D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));  in dotted_name_raw()
3911             (name_var = _PyPegen_name_token(p))  // NAME  in dotted_name_raw()
3914 …D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME…  in dotted_name_raw()
3918         p->mark = _mark;  in dotted_name_raw()
3919         D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ',  in dotted_name_raw()
3920                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));  in dotted_name_raw()
3924     p->level--;  in dotted_name_raw()
3933 if_stmt_rule(Parser *p)  in if_stmt_rule()  argument
3935     if (p->level++ == MAXSTACK) {  in if_stmt_rule()
3936         p->error_indicator = 1;  in if_stmt_rule()
3939     if (p->error_indicator) {  in if_stmt_rule()
3940         p->level--;  in if_stmt_rule()
3944     int _mark = p->mark;  in if_stmt_rule()
3945     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in if_stmt_rule()
3946         p->error_indicator = 1;  in if_stmt_rule()
3947         p->level--;  in if_stmt_rule()
3950     int _start_lineno = p->tokens[_mark]->lineno;  in if_stmt_rule()
3952     int _start_col_offset = p->tokens[_mark]->col_offset;  in if_stmt_rule()
3954     if (p->call_invalid_rules) { // invalid_if_stmt  in if_stmt_rule()
3955         if (p->error_indicator) {  in if_stmt_rule()
3956             p->level--;  in if_stmt_rule()
3959 … D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_if_stmt"));  in if_stmt_rule()
3962             (invalid_if_stmt_var = invalid_if_stmt_rule(p))  // invalid_if_stmt  in if_stmt_rule()
3965 …D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_…  in if_stmt_rule()
3969         p->mark = _mark;  in if_stmt_rule()
3970         D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in if_stmt_rule()
3971                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_if_stmt"));  in if_stmt_rule()
3974         if (p->error_indicator) {  in if_stmt_rule()
3975             p->level--;  in if_stmt_rule()
3978 …D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expressi…  in if_stmt_rule()
3985             (_keyword = _PyPegen_expect_token(p, 510))  // token='if'  in if_stmt_rule()
3987             (a = named_expression_rule(p))  // named_expression  in if_stmt_rule()
3989             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in if_stmt_rule()
3991             (b = block_rule(p))  // block  in if_stmt_rule()
3993             (c = elif_stmt_rule(p))  // elif_stmt  in if_stmt_rule()
3996 …D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' nam…  in if_stmt_rule()
3997             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in if_stmt_rule()
3999                 p->level--;  in if_stmt_rule()
4002             int _end_lineno = _token->end_lineno;  in if_stmt_rule()
4004             int _end_col_offset = _token->end_col_offset;  in if_stmt_rule()
4006 … _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq * , _PyPegen_singleton_seq ( p , c ) ) , EXTRA );  in if_stmt_rule()
4008                 p->error_indicator = 1;  in if_stmt_rule()
4009                 p->level--;  in if_stmt_rule()
4014         p->mark = _mark;  in if_stmt_rule()
4015         D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in if_stmt_rule()
4016 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block elif_stmt"));  in if_stmt_rule()
4019         if (p->error_indicator) {  in if_stmt_rule()
4020             p->level--;  in if_stmt_rule()
4023 …D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expressi…  in if_stmt_rule()
4030             (_keyword = _PyPegen_expect_token(p, 510))  // token='if'  in if_stmt_rule()
4032             (a = named_expression_rule(p))  // named_expression  in if_stmt_rule()
4034             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in if_stmt_rule()
4036             (b = block_rule(p))  // block  in if_stmt_rule()
4038             (c = else_block_rule(p), !p->error_indicator)  // else_block?  in if_stmt_rule()
4041 …D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' nam…  in if_stmt_rule()
4042             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in if_stmt_rule()
4044                 p->level--;  in if_stmt_rule()
4047             int _end_lineno = _token->end_lineno;  in if_stmt_rule()
4049             int _end_col_offset = _token->end_col_offset;  in if_stmt_rule()
4053                 p->error_indicator = 1;  in if_stmt_rule()
4054                 p->level--;  in if_stmt_rule()
4059         p->mark = _mark;  in if_stmt_rule()
4060         D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in if_stmt_rule()
4061 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block else_block?"…  in if_stmt_rule()
4065     p->level--;  in if_stmt_rule()
4074 elif_stmt_rule(Parser *p)  in elif_stmt_rule()  argument
4076     if (p->level++ == MAXSTACK) {  in elif_stmt_rule()
4077         p->error_indicator = 1;  in elif_stmt_rule()
4080     if (p->error_indicator) {  in elif_stmt_rule()
4081         p->level--;  in elif_stmt_rule()
4085     int _mark = p->mark;  in elif_stmt_rule()
4086     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in elif_stmt_rule()
4087         p->error_indicator = 1;  in elif_stmt_rule()
4088         p->level--;  in elif_stmt_rule()
4091     int _start_lineno = p->tokens[_mark]->lineno;  in elif_stmt_rule()
4093     int _start_col_offset = p->tokens[_mark]->col_offset;  in elif_stmt_rule()
4095     if (p->call_invalid_rules) { // invalid_elif_stmt  in elif_stmt_rule()
4096         if (p->error_indicator) {  in elif_stmt_rule()
4097             p->level--;  in elif_stmt_rule()
4100 …D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_elif_stmt…  in elif_stmt_rule()
4103             (invalid_elif_stmt_var = invalid_elif_stmt_rule(p))  // invalid_elif_stmt  in elif_stmt_rule()
4106 …D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali…  in elif_stmt_rule()
4110         p->mark = _mark;  in elif_stmt_rule()
4111         D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in elif_stmt_rule()
4112                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_elif_stmt"));  in elif_stmt_rule()
4115         if (p->error_indicator) {  in elif_stmt_rule()
4116             p->level--;  in elif_stmt_rule()
4119 …D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expr…  in elif_stmt_rule()
4126             (_keyword = _PyPegen_expect_token(p, 515))  // token='elif'  in elif_stmt_rule()
4128             (a = named_expression_rule(p))  // named_expression  in elif_stmt_rule()
4130             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in elif_stmt_rule()
4132             (b = block_rule(p))  // block  in elif_stmt_rule()
4134             (c = elif_stmt_rule(p))  // elif_stmt  in elif_stmt_rule()
4137 …D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif'…  in elif_stmt_rule()
4138             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in elif_stmt_rule()
4140                 p->level--;  in elif_stmt_rule()
4143             int _end_lineno = _token->end_lineno;  in elif_stmt_rule()
4145             int _end_col_offset = _token->end_col_offset;  in elif_stmt_rule()
4147 … _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq * , _PyPegen_singleton_seq ( p , c ) ) , EXTRA );  in elif_stmt_rule()
4149                 p->error_indicator = 1;  in elif_stmt_rule()
4150                 p->level--;  in elif_stmt_rule()
4155         p->mark = _mark;  in elif_stmt_rule()
4156         D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in elif_stmt_rule()
4157 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block elif_stmt"…  in elif_stmt_rule()
4160         if (p->error_indicator) {  in elif_stmt_rule()
4161             p->level--;  in elif_stmt_rule()
4164 …D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expr…  in elif_stmt_rule()
4171             (_keyword = _PyPegen_expect_token(p, 515))  // token='elif'  in elif_stmt_rule()
4173             (a = named_expression_rule(p))  // named_expression  in elif_stmt_rule()
4175             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in elif_stmt_rule()
4177             (b = block_rule(p))  // block  in elif_stmt_rule()
4179             (c = else_block_rule(p), !p->error_indicator)  // else_block?  in elif_stmt_rule()
4182 …D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif'…  in elif_stmt_rule()
4183             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in elif_stmt_rule()
4185                 p->level--;  in elif_stmt_rule()
4188             int _end_lineno = _token->end_lineno;  in elif_stmt_rule()
4190             int _end_col_offset = _token->end_col_offset;  in elif_stmt_rule()
4194                 p->error_indicator = 1;  in elif_stmt_rule()
4195                 p->level--;  in elif_stmt_rule()
4200         p->mark = _mark;  in elif_stmt_rule()
4201         D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in elif_stmt_rule()
4202 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block else_block…  in elif_stmt_rule()
4206     p->level--;  in elif_stmt_rule()
4212 else_block_rule(Parser *p)  in else_block_rule()  argument
4214     if (p->level++ == MAXSTACK) {  in else_block_rule()
4215         p->error_indicator = 1;  in else_block_rule()
4218     if (p->error_indicator) {  in else_block_rule()
4219         p->level--;  in else_block_rule()
4223     int _mark = p->mark;  in else_block_rule()
4224     if (p->call_invalid_rules) { // invalid_else_stmt  in else_block_rule()
4225         if (p->error_indicator) {  in else_block_rule()
4226             p->level--;  in else_block_rule()
4229 …D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_else_stm…  in else_block_rule()
4232             (invalid_else_stmt_var = invalid_else_stmt_rule(p))  // invalid_else_stmt  in else_block_rule()
4235 …D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval…  in else_block_rule()
4239         p->mark = _mark;  in else_block_rule()
4240         D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ',  in else_block_rule()
4241                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_else_stmt"));  in else_block_rule()
4244         if (p->error_indicator) {  in else_block_rule()
4245             p->level--;  in else_block_rule()
4248 …D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' &&':' blo…  in else_block_rule()
4253             (_keyword = _PyPegen_expect_token(p, 516))  // token='else'  in else_block_rule()
4255             (_literal = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in else_block_rule()
4257             (b = block_rule(p))  // block  in else_block_rule()
4260 …D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else…  in else_block_rule()
4263                 p->error_indicator = 1;  in else_block_rule()
4264                 p->level--;  in else_block_rule()
4269         p->mark = _mark;  in else_block_rule()
4270         D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ',  in else_block_rule()
4271                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' &&':' block"));  in else_block_rule()
4275     p->level--;  in else_block_rule()
4281 while_stmt_rule(Parser *p)  in while_stmt_rule()  argument
4283     if (p->level++ == MAXSTACK) {  in while_stmt_rule()
4284         p->error_indicator = 1;  in while_stmt_rule()
4287     if (p->error_indicator) {  in while_stmt_rule()
4288         p->level--;  in while_stmt_rule()
4292     int _mark = p->mark;  in while_stmt_rule()
4293     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in while_stmt_rule()
4294         p->error_indicator = 1;  in while_stmt_rule()
4295         p->level--;  in while_stmt_rule()
4298     int _start_lineno = p->tokens[_mark]->lineno;  in while_stmt_rule()
4300     int _start_col_offset = p->tokens[_mark]->col_offset;  in while_stmt_rule()
4302     if (p->call_invalid_rules) { // invalid_while_stmt  in while_stmt_rule()
4303         if (p->error_indicator) {  in while_stmt_rule()
4304             p->level--;  in while_stmt_rule()
4307 …D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_while_st…  in while_stmt_rule()
4310             (invalid_while_stmt_var = invalid_while_stmt_rule(p))  // invalid_while_stmt  in while_stmt_rule()
4313 …D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval…  in while_stmt_rule()
4317         p->mark = _mark;  in while_stmt_rule()
4318         D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in while_stmt_rule()
4319                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_while_stmt"));  in while_stmt_rule()
4322         if (p->error_indicator) {  in while_stmt_rule()
4323             p->level--;  in while_stmt_rule()
4326 …D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_ex…  in while_stmt_rule()
4333             (_keyword = _PyPegen_expect_token(p, 512))  // token='while'  in while_stmt_rule()
4335             (a = named_expression_rule(p))  // named_expression  in while_stmt_rule()
4337             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in while_stmt_rule()
4339             (b = block_rule(p))  // block  in while_stmt_rule()
4341             (c = else_block_rule(p), !p->error_indicator)  // else_block?  in while_stmt_rule()
4344 …D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'whil…  in while_stmt_rule()
4345             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in while_stmt_rule()
4347                 p->level--;  in while_stmt_rule()
4350             int _end_lineno = _token->end_lineno;  in while_stmt_rule()
4352             int _end_col_offset = _token->end_col_offset;  in while_stmt_rule()
4356                 p->error_indicator = 1;  in while_stmt_rule()
4357                 p->level--;  in while_stmt_rule()
4362         p->mark = _mark;  in while_stmt_rule()
4363         D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in while_stmt_rule()
4364 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' block else_bloc…  in while_stmt_rule()
4368     p->level--;  in while_stmt_rule()
4378 for_stmt_rule(Parser *p)  in for_stmt_rule()  argument
4380     if (p->level++ == MAXSTACK) {  in for_stmt_rule()
4381         p->error_indicator = 1;  in for_stmt_rule()
4384     if (p->error_indicator) {  in for_stmt_rule()
4385         p->level--;  in for_stmt_rule()
4389     int _mark = p->mark;  in for_stmt_rule()
4390     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in for_stmt_rule()
4391         p->error_indicator = 1;  in for_stmt_rule()
4392         p->level--;  in for_stmt_rule()
4395     int _start_lineno = p->tokens[_mark]->lineno;  in for_stmt_rule()
4397     int _start_col_offset = p->tokens[_mark]->col_offset;  in for_stmt_rule()
4399     if (p->call_invalid_rules) { // invalid_for_stmt  in for_stmt_rule()
4400         if (p->error_indicator) {  in for_stmt_rule()
4401             p->level--;  in for_stmt_rule()
4404 …D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_stmt")…  in for_stmt_rule()
4407             (invalid_for_stmt_var = invalid_for_stmt_rule(p))  // invalid_for_stmt  in for_stmt_rule()
4410 …D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid…  in for_stmt_rule()
4414         p->mark = _mark;  in for_stmt_rule()
4415         D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in for_stmt_rule()
4416                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_stmt"));  in for_stmt_rule()
4419         if (p->error_indicator) {  in for_stmt_rule()
4420             p->level--;  in for_stmt_rule()
4423 …D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets…  in for_stmt_rule()
4434             (_keyword = _PyPegen_expect_token(p, 517))  // token='for'  in for_stmt_rule()
4436             (t = star_targets_rule(p))  // star_targets  in for_stmt_rule()
4438             (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'  in for_stmt_rule()
4442             (ex = star_expressions_rule(p))  // star_expressions  in for_stmt_rule()
4444             (_literal = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in for_stmt_rule()
4446             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in for_stmt_rule()
4448             (b = block_rule(p))  // block  in for_stmt_rule()
4450             (el = else_block_rule(p), !p->error_indicator)  // else_block?  in for_stmt_rule()
4453 …D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' s…  in for_stmt_rule()
4454             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in for_stmt_rule()
4456                 p->level--;  in for_stmt_rule()
4459             int _end_lineno = _token->end_lineno;  in for_stmt_rule()
4461             int _end_col_offset = _token->end_col_offset;  in for_stmt_rule()
4463             _res = _PyAST_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );  in for_stmt_rule()
4465                 p->error_indicator = 1;  in for_stmt_rule()
4466                 p->level--;  in for_stmt_rule()
4471         p->mark = _mark;  in for_stmt_rule()
4472         D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in for_stmt_rule()
4473 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ star_expressions &…  in for_stmt_rule()
4475             p->level--;  in for_stmt_rule()
4480         if (p->error_indicator) {  in for_stmt_rule()
4481             p->level--;  in for_stmt_rule()
4484 …D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_t…  in for_stmt_rule()
4496             (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'  in for_stmt_rule()
4498             (_keyword = _PyPegen_expect_token(p, 517))  // token='for'  in for_stmt_rule()
4500             (t = star_targets_rule(p))  // star_targets  in for_stmt_rule()
4502             (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'  in for_stmt_rule()
4506             (ex = star_expressions_rule(p))  // star_expressions  in for_stmt_rule()
4508             (_literal = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in for_stmt_rule()
4510             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in for_stmt_rule()
4512             (b = block_rule(p))  // block  in for_stmt_rule()
4514             (el = else_block_rule(p), !p->error_indicator)  // else_block?  in for_stmt_rule()
4517 …D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC '…  in for_stmt_rule()
4518             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in for_stmt_rule()
4520                 p->level--;  in for_stmt_rule()
4523             int _end_lineno = _token->end_lineno;  in for_stmt_rule()
4525             int _end_col_offset = _token->end_col_offset;  in for_stmt_rule()
4527 …Async for loops are" , _PyAST_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );  in for_stmt_rule()
4529                 p->error_indicator = 1;  in for_stmt_rule()
4530                 p->level--;  in for_stmt_rule()
4535         p->mark = _mark;  in for_stmt_rule()
4536         D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in for_stmt_rule()
4537 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_express…  in for_stmt_rule()
4539             p->level--;  in for_stmt_rule()
4543     if (p->call_invalid_rules) { // invalid_for_target  in for_stmt_rule()
4544         if (p->error_indicator) {  in for_stmt_rule()
4545             p->level--;  in for_stmt_rule()
4548 …D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target…  in for_stmt_rule()
4551             (invalid_for_target_var = invalid_for_target_rule(p))  // invalid_for_target  in for_stmt_rule()
4554 …D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid…  in for_stmt_rule()
4558         p->mark = _mark;  in for_stmt_rule()
4559         D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in for_stmt_rule()
4560                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target"));  in for_stmt_rule()
4564     p->level--;  in for_stmt_rule()
4576 with_stmt_rule(Parser *p)  in with_stmt_rule()  argument
4578     if (p->level++ == MAXSTACK) {  in with_stmt_rule()
4579         p->error_indicator = 1;  in with_stmt_rule()
4582     if (p->error_indicator) {  in with_stmt_rule()
4583         p->level--;  in with_stmt_rule()
4587     int _mark = p->mark;  in with_stmt_rule()
4588     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in with_stmt_rule()
4589         p->error_indicator = 1;  in with_stmt_rule()
4590         p->level--;  in with_stmt_rule()
4593     int _start_lineno = p->tokens[_mark]->lineno;  in with_stmt_rule()
4595     int _start_col_offset = p->tokens[_mark]->col_offset;  in with_stmt_rule()
4597     if (p->call_invalid_rules) { // invalid_with_stmt_indent  in with_stmt_rule()
4598         if (p->error_indicator) {  in with_stmt_rule()
4599             p->level--;  in with_stmt_rule()
4602 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt…  in with_stmt_rule()
4605 …     (invalid_with_stmt_indent_var = invalid_with_stmt_indent_rule(p))  // invalid_with_stmt_indent  in with_stmt_rule()
4608 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali…  in with_stmt_rule()
4612         p->mark = _mark;  in with_stmt_rule()
4613         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in with_stmt_rule()
4614                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt_indent"));  in with_stmt_rule()
4617         if (p->error_indicator) {  in with_stmt_rule()
4618             p->level--;  in with_stmt_rule()
4621 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.wi…  in with_stmt_rule()
4631             (_keyword = _PyPegen_expect_token(p, 519))  // token='with'  in with_stmt_rule()
4633             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in with_stmt_rule()
4635             (a = (asdl_withitem_seq*)_gather_39_rule(p))  // ','.with_item+  in with_stmt_rule()
4637             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in with_stmt_rule()
4639             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in with_stmt_rule()
4641             (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':'  in with_stmt_rule()
4643             (b = block_rule(p))  // block  in with_stmt_rule()
4646 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'…  in with_stmt_rule()
4647             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in with_stmt_rule()
4649                 p->level--;  in with_stmt_rule()
4652             int _end_lineno = _token->end_lineno;  in with_stmt_rule()
4654             int _end_col_offset = _token->end_col_offset;  in with_stmt_rule()
4658                 p->error_indicator = 1;  in with_stmt_rule()
4659                 p->level--;  in with_stmt_rule()
4664         p->mark = _mark;  in with_stmt_rule()
4665         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in with_stmt_rule()
4666 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block…  in with_stmt_rule()
4669         if (p->error_indicator) {  in with_stmt_rule()
4670             p->level--;  in with_stmt_rule()
4673 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' ','.with_i…  in with_stmt_rule()
4680             (_keyword = _PyPegen_expect_token(p, 519))  // token='with'  in with_stmt_rule()
4682             (a = (asdl_withitem_seq*)_gather_41_rule(p))  // ','.with_item+  in with_stmt_rule()
4684             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in with_stmt_rule()
4686             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in with_stmt_rule()
4688             (b = block_rule(p))  // block  in with_stmt_rule()
4691 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'…  in with_stmt_rule()
4692             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in with_stmt_rule()
4694                 p->level--;  in with_stmt_rule()
4697             int _end_lineno = _token->end_lineno;  in with_stmt_rule()
4699             int _end_col_offset = _token->end_col_offset;  in with_stmt_rule()
4701             _res = _PyAST_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );  in with_stmt_rule()
4703                 p->error_indicator = 1;  in with_stmt_rule()
4704                 p->level--;  in with_stmt_rule()
4709         p->mark = _mark;  in with_stmt_rule()
4710         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in with_stmt_rule()
4711 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? bloc…  in with_stmt_rule()
4714         if (p->error_indicator) {  in with_stmt_rule()
4715             p->level--;  in with_stmt_rule()
4718 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' …  in with_stmt_rule()
4729             (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'  in with_stmt_rule()
4731             (_keyword = _PyPegen_expect_token(p, 519))  // token='with'  in with_stmt_rule()
4733             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in with_stmt_rule()
4735             (a = (asdl_withitem_seq*)_gather_43_rule(p))  // ','.with_item+  in with_stmt_rule()
4737             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in with_stmt_rule()
4739             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in with_stmt_rule()
4741             (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':'  in with_stmt_rule()
4743             (b = block_rule(p))  // block  in with_stmt_rule()
4746 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC …  in with_stmt_rule()
4747             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in with_stmt_rule()
4749                 p->level--;  in with_stmt_rule()
4752             int _end_lineno = _token->end_lineno;  in with_stmt_rule()
4754             int _end_col_offset = _token->end_col_offset;  in with_stmt_rule()
4758                 p->error_indicator = 1;  in with_stmt_rule()
4759                 p->level--;  in with_stmt_rule()
4764         p->mark = _mark;  in with_stmt_rule()
4765         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in with_stmt_rule()
4766 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':'…  in with_stmt_rule()
4769         if (p->error_indicator) {  in with_stmt_rule()
4770             p->level--;  in with_stmt_rule()
4773 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.…  in with_stmt_rule()
4781             (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'  in with_stmt_rule()
4783             (_keyword = _PyPegen_expect_token(p, 519))  // token='with'  in with_stmt_rule()
4785             (a = (asdl_withitem_seq*)_gather_45_rule(p))  // ','.with_item+  in with_stmt_rule()
4787             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in with_stmt_rule()
4789             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in with_stmt_rule()
4791             (b = block_rule(p))  // block  in with_stmt_rule()
4794 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC …  in with_stmt_rule()
4795             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in with_stmt_rule()
4797                 p->level--;  in with_stmt_rule()
4800             int _end_lineno = _token->end_lineno;  in with_stmt_rule()
4802             int _end_col_offset = _token->end_col_offset;  in with_stmt_rule()
4804 …, "Async with statements are" , _PyAST_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );  in with_stmt_rule()
4806                 p->error_indicator = 1;  in with_stmt_rule()
4807                 p->level--;  in with_stmt_rule()
4812         p->mark = _mark;  in with_stmt_rule()
4813         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in with_stmt_rule()
4814 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT…  in with_stmt_rule()
4816     if (p->call_invalid_rules) { // invalid_with_stmt  in with_stmt_rule()
4817         if (p->error_indicator) {  in with_stmt_rule()
4818             p->level--;  in with_stmt_rule()
4821 …D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt…  in with_stmt_rule()
4824             (invalid_with_stmt_var = invalid_with_stmt_rule(p))  // invalid_with_stmt  in with_stmt_rule()
4827 …D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali…  in with_stmt_rule()
4831         p->mark = _mark;  in with_stmt_rule()
4832         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in with_stmt_rule()
4833                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt"));  in with_stmt_rule()
4837     p->level--;  in with_stmt_rule()
4846 with_item_rule(Parser *p)  in with_item_rule()  argument
4848     if (p->level++ == MAXSTACK) {  in with_item_rule()
4849         p->error_indicator = 1;  in with_item_rule()
4852     if (p->error_indicator) {  in with_item_rule()
4853         p->level--;  in with_item_rule()
4857     int _mark = p->mark;  in with_item_rule()
4859         if (p->error_indicator) {  in with_item_rule()
4860             p->level--;  in with_item_rule()
4863 …D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' s…  in with_item_rule()
4868             (e = expression_rule(p))  // expression  in with_item_rule()
4870             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in with_item_rule()
4872             (t = star_target_rule(p))  // star_target  in with_item_rule()
4874             _PyPegen_lookahead(1, _tmp_47_rule, p)  in with_item_rule()
4877 …D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expres…  in with_item_rule()
4878             _res = _PyAST_withitem ( e , t , p -> arena );  in with_item_rule()
4880                 p->error_indicator = 1;  in with_item_rule()
4881                 p->level--;  in with_item_rule()
4886         p->mark = _mark;  in with_item_rule()
4887         D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ',  in with_item_rule()
4888 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':…  in with_item_rule()
4890     if (p->call_invalid_rules) { // invalid_with_item  in with_item_rule()
4891         if (p->error_indicator) {  in with_item_rule()
4892             p->level--;  in with_item_rule()
4895 …D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_item…  in with_item_rule()
4898             (invalid_with_item_var = invalid_with_item_rule(p))  // invalid_with_item  in with_item_rule()
4901 …D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali…  in with_item_rule()
4905         p->mark = _mark;  in with_item_rule()
4906         D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ',  in with_item_rule()
4907                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_item"));  in with_item_rule()
4910         if (p->error_indicator) {  in with_item_rule()
4911             p->level--;  in with_item_rule()
4914 …    D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));  in with_item_rule()
4917             (e = expression_rule(p))  // expression  in with_item_rule()
4920 …D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expres…  in with_item_rule()
4921             _res = _PyAST_withitem ( e , NULL , p -> arena );  in with_item_rule()
4923                 p->error_indicator = 1;  in with_item_rule()
4924                 p->level--;  in with_item_rule()
4929         p->mark = _mark;  in with_item_rule()
4930         D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ',  in with_item_rule()
4931                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));  in with_item_rule()
4935     p->level--;  in with_item_rule()
4944 try_stmt_rule(Parser *p)  in try_stmt_rule()  argument
4946     if (p->level++ == MAXSTACK) {  in try_stmt_rule()
4947         p->error_indicator = 1;  in try_stmt_rule()
4950     if (p->error_indicator) {  in try_stmt_rule()
4951         p->level--;  in try_stmt_rule()
4955     int _mark = p->mark;  in try_stmt_rule()
4956     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in try_stmt_rule()
4957         p->error_indicator = 1;  in try_stmt_rule()
4958         p->level--;  in try_stmt_rule()
4961     int _start_lineno = p->tokens[_mark]->lineno;  in try_stmt_rule()
4963     int _start_col_offset = p->tokens[_mark]->col_offset;  in try_stmt_rule()
4965     if (p->call_invalid_rules) { // invalid_try_stmt  in try_stmt_rule()
4966         if (p->error_indicator) {  in try_stmt_rule()
4967             p->level--;  in try_stmt_rule()
4970 …D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_try_stmt")…  in try_stmt_rule()
4973             (invalid_try_stmt_var = invalid_try_stmt_rule(p))  // invalid_try_stmt  in try_stmt_rule()
4976 …D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid…  in try_stmt_rule()
4980         p->mark = _mark;  in try_stmt_rule()
4981         D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in try_stmt_rule()
4982                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_try_stmt"));  in try_stmt_rule()
4985         if (p->error_indicator) {  in try_stmt_rule()
4986             p->level--;  in try_stmt_rule()
4989 …D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block …  in try_stmt_rule()
4995             (_keyword = _PyPegen_expect_token(p, 511))  // token='try'  in try_stmt_rule()
4997             (_literal = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in try_stmt_rule()
4999             (b = block_rule(p))  // block  in try_stmt_rule()
5001             (f = finally_block_rule(p))  // finally_block  in try_stmt_rule()
5004 …D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &…  in try_stmt_rule()
5005             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in try_stmt_rule()
5007                 p->level--;  in try_stmt_rule()
5010             int _end_lineno = _token->end_lineno;  in try_stmt_rule()
5012             int _end_col_offset = _token->end_col_offset;  in try_stmt_rule()
5016                 p->error_indicator = 1;  in try_stmt_rule()
5017                 p->level--;  in try_stmt_rule()
5022         p->mark = _mark;  in try_stmt_rule()
5023         D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in try_stmt_rule()
5024 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block finally_block"));  in try_stmt_rule()
5027         if (p->error_indicator) {  in try_stmt_rule()
5028             p->level--;  in try_stmt_rule()
5031 …D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block …  in try_stmt_rule()
5039             (_keyword = _PyPegen_expect_token(p, 511))  // token='try'  in try_stmt_rule()
5041             (_literal = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in try_stmt_rule()
5043             (b = block_rule(p))  // block  in try_stmt_rule()
5045             (ex = (asdl_excepthandler_seq*)_loop1_48_rule(p))  // except_block+  in try_stmt_rule()
5047             (el = else_block_rule(p), !p->error_indicator)  // else_block?  in try_stmt_rule()
5049             (f = finally_block_rule(p), !p->error_indicator)  // finally_block?  in try_stmt_rule()
5052 …D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &…  in try_stmt_rule()
5053             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in try_stmt_rule()
5055                 p->level--;  in try_stmt_rule()
5058             int _end_lineno = _token->end_lineno;  in try_stmt_rule()
5060             int _end_col_offset = _token->end_col_offset;  in try_stmt_rule()
5064                 p->error_indicator = 1;  in try_stmt_rule()
5065                 p->level--;  in try_stmt_rule()
5070         p->mark = _mark;  in try_stmt_rule()
5071         D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in try_stmt_rule()
5072 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block except_block+ else_block? …  in try_stmt_rule()
5076     p->level--;  in try_stmt_rule()
5086 except_block_rule(Parser *p)  in except_block_rule()  argument
5088     if (p->level++ == MAXSTACK) {  in except_block_rule()
5089         p->error_indicator = 1;  in except_block_rule()
5092     if (p->error_indicator) {  in except_block_rule()
5093         p->level--;  in except_block_rule()
5097     int _mark = p->mark;  in except_block_rule()
5098     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in except_block_rule()
5099         p->error_indicator = 1;  in except_block_rule()
5100         p->level--;  in except_block_rule()
5103     int _start_lineno = p->tokens[_mark]->lineno;  in except_block_rule()
5105     int _start_col_offset = p->tokens[_mark]->col_offset;  in except_block_rule()
5107     if (p->call_invalid_rules) { // invalid_except_stmt_indent  in except_block_rule()
5108         if (p->error_indicator) {  in except_block_rule()
5109             p->level--;  in except_block_rule()
5112 …D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except…  in except_block_rule()
5115 …(invalid_except_stmt_indent_var = invalid_except_stmt_indent_rule(p))  // invalid_except_stmt_inde…  in except_block_rule()
5118 …D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inv…  in except_block_rule()
5122         p->mark = _mark;  in except_block_rule()
5123         D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',  in except_block_rule()
5124 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt_indent"));  in except_block_rule()
5127         if (p->error_indicator) {  in except_block_rule()
5128             p->level--;  in except_block_rule()
5131 …D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' expre…  in except_block_rule()
5138             (_keyword = _PyPegen_expect_token(p, 521))  // token='except'  in except_block_rule()
5140             (e = expression_rule(p))  // expression  in except_block_rule()
5142             (t = _tmp_49_rule(p), !p->error_indicator)  // ['as' NAME]  in except_block_rule()
5144             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in except_block_rule()
5146             (b = block_rule(p))  // block  in except_block_rule()
5149 …D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'ex…  in except_block_rule()
5150             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in except_block_rule()
5152                 p->level--;  in except_block_rule()
5155             int _end_lineno = _token->end_lineno;  in except_block_rule()
5157             int _end_col_offset = _token->end_col_offset;  in except_block_rule()
5159 … _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );  in except_block_rule()
5161                 p->error_indicator = 1;  in except_block_rule()
5162                 p->level--;  in except_block_rule()
5167         p->mark = _mark;  in except_block_rule()
5168         D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',  in except_block_rule()
5169 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' block"));  in except_block_rule()
5172         if (p->error_indicator) {  in except_block_rule()
5173             p->level--;  in except_block_rule()
5176 …D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' ':' b…  in except_block_rule()
5181             (_keyword = _PyPegen_expect_token(p, 521))  // token='except'  in except_block_rule()
5183             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in except_block_rule()
5185             (b = block_rule(p))  // block  in except_block_rule()
5188 …D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'ex…  in except_block_rule()
5189             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in except_block_rule()
5191                 p->level--;  in except_block_rule()
5194             int _end_lineno = _token->end_lineno;  in except_block_rule()
5196             int _end_col_offset = _token->end_col_offset;  in except_block_rule()
5200                 p->error_indicator = 1;  in except_block_rule()
5201                 p->level--;  in except_block_rule()
5206         p->mark = _mark;  in except_block_rule()
5207         D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',  in except_block_rule()
5208                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' block"));  in except_block_rule()
5210     if (p->call_invalid_rules) { // invalid_except_stmt  in except_block_rule()
5211         if (p->error_indicator) {  in except_block_rule()
5212             p->level--;  in except_block_rule()
5215 …D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except…  in except_block_rule()
5218             (invalid_except_stmt_var = invalid_except_stmt_rule(p))  // invalid_except_stmt  in except_block_rule()
5221 …D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inv…  in except_block_rule()
5225         p->mark = _mark;  in except_block_rule()
5226         D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',  in except_block_rule()
5227                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt"));  in except_block_rule()
5231     p->level--;  in except_block_rule()
5237 finally_block_rule(Parser *p)  in finally_block_rule()  argument
5239     if (p->level++ == MAXSTACK) {  in finally_block_rule()
5240         p->error_indicator = 1;  in finally_block_rule()
5243     if (p->error_indicator) {  in finally_block_rule()
5244         p->level--;  in finally_block_rule()
5248     int _mark = p->mark;  in finally_block_rule()
5249     if (p->call_invalid_rules) { // invalid_finally_stmt  in finally_block_rule()
5250         if (p->error_indicator) {  in finally_block_rule()
5251             p->level--;  in finally_block_rule()
5254 …D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_final…  in finally_block_rule()
5257             (invalid_finally_stmt_var = invalid_finally_stmt_rule(p))  // invalid_finally_stmt  in finally_block_rule()
5260 …D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in…  in finally_block_rule()
5264         p->mark = _mark;  in finally_block_rule()
5265         D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ',  in finally_block_rule()
5266                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_finally_stmt"));  in finally_block_rule()
5269         if (p->error_indicator) {  in finally_block_rule()
5270             p->level--;  in finally_block_rule()
5273 …D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally' &&'…  in finally_block_rule()
5278             (_keyword = _PyPegen_expect_token(p, 522))  // token='finally'  in finally_block_rule()
5280             (_literal = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in finally_block_rule()
5282             (a = block_rule(p))  // block  in finally_block_rule()
5285 …D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f…  in finally_block_rule()
5288                 p->error_indicator = 1;  in finally_block_rule()
5289                 p->level--;  in finally_block_rule()
5294         p->mark = _mark;  in finally_block_rule()
5295         D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ',  in finally_block_rule()
5296                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' &&':' block"));  in finally_block_rule()
5300     p->level--;  in finally_block_rule()
5308 match_stmt_rule(Parser *p)  in match_stmt_rule()  argument
5310     if (p->level++ == MAXSTACK) {  in match_stmt_rule()
5311         p->error_indicator = 1;  in match_stmt_rule()
5314     if (p->error_indicator) {  in match_stmt_rule()
5315         p->level--;  in match_stmt_rule()
5319     int _mark = p->mark;  in match_stmt_rule()
5320     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in match_stmt_rule()
5321         p->error_indicator = 1;  in match_stmt_rule()
5322         p->level--;  in match_stmt_rule()
5325     int _start_lineno = p->tokens[_mark]->lineno;  in match_stmt_rule()
5327     int _start_col_offset = p->tokens[_mark]->col_offset;  in match_stmt_rule()
5330         if (p->error_indicator) {  in match_stmt_rule()
5331             p->level--;  in match_stmt_rule()
5334 …D(fprintf(stderr, "%*c> match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\" subjec…  in match_stmt_rule()
5343             (_keyword = _PyPegen_expect_soft_keyword(p, "match"))  // soft_keyword='"match"'  in match_stmt_rule()
5345             (subject = subject_expr_rule(p))  // subject_expr  in match_stmt_rule()
5347             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in match_stmt_rule()
5349             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in match_stmt_rule()
5351             (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT'  in match_stmt_rule()
5353             (cases = (asdl_match_case_seq*)_loop1_50_rule(p))  // case_block+  in match_stmt_rule()
5355             (dedent_var = _PyPegen_expect_token(p, DEDENT))  // token='DEDENT'  in match_stmt_rule()
5358 …D(fprintf(stderr, "%*c+ match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"mat…  in match_stmt_rule()
5359             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in match_stmt_rule()
5361                 p->level--;  in match_stmt_rule()
5364             int _end_lineno = _token->end_lineno;  in match_stmt_rule()
5366             int _end_col_offset = _token->end_col_offset;  in match_stmt_rule()
5370                 p->error_indicator = 1;  in match_stmt_rule()
5371                 p->level--;  in match_stmt_rule()
5376         p->mark = _mark;  in match_stmt_rule()
5377         D(fprintf(stderr, "%*c%s match_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in match_stmt_rule()
5378 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr ':' NEWLINE INDENT ca…  in match_stmt_rule()
5380     if (p->call_invalid_rules) { // invalid_match_stmt  in match_stmt_rule()
5381         if (p->error_indicator) {  in match_stmt_rule()
5382             p->level--;  in match_stmt_rule()
5385 …D(fprintf(stderr, "%*c> match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_match_st…  in match_stmt_rule()
5388             (invalid_match_stmt_var = invalid_match_stmt_rule(p))  // invalid_match_stmt  in match_stmt_rule()
5391 …D(fprintf(stderr, "%*c+ match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval…  in match_stmt_rule()
5395         p->mark = _mark;  in match_stmt_rule()
5396         D(fprintf(stderr, "%*c%s match_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in match_stmt_rule()
5397                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_match_stmt"));  in match_stmt_rule()
5401     p->level--;  in match_stmt_rule()
5407 subject_expr_rule(Parser *p)  in subject_expr_rule()  argument
5409     if (p->level++ == MAXSTACK) {  in subject_expr_rule()
5410         p->error_indicator = 1;  in subject_expr_rule()
5413     if (p->error_indicator) {  in subject_expr_rule()
5414         p->level--;  in subject_expr_rule()
5418     int _mark = p->mark;  in subject_expr_rule()
5419     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in subject_expr_rule()
5420         p->error_indicator = 1;  in subject_expr_rule()
5421         p->level--;  in subject_expr_rule()
5424     int _start_lineno = p->tokens[_mark]->lineno;  in subject_expr_rule()
5426     int _start_col_offset = p->tokens[_mark]->col_offset;  in subject_expr_rule()
5429         if (p->error_indicator) {  in subject_expr_rule()
5430             p->level--;  in subject_expr_rule()
5433 …D(fprintf(stderr, "%*c> subject_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_exp…  in subject_expr_rule()
5438             (value = star_named_expression_rule(p))  // star_named_expression  in subject_expr_rule()
5440             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in subject_expr_rule()
5442 …         (values = star_named_expressions_rule(p), !p->error_indicator)  // star_named_expressions?  in subject_expr_rule()
5445 …D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sta…  in subject_expr_rule()
5446             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in subject_expr_rule()
5448                 p->level--;  in subject_expr_rule()
5451             int _end_lineno = _token->end_lineno;  in subject_expr_rule()
5453             int _end_col_offset = _token->end_col_offset;  in subject_expr_rule()
5455 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq * , _PyPegen_seq_insert_in_front ( p , value , values …  in subject_expr_rule()
5457                 p->error_indicator = 1;  in subject_expr_rule()
5458                 p->level--;  in subject_expr_rule()
5463         p->mark = _mark;  in subject_expr_rule()
5464         D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ',  in subject_expr_rule()
5465 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_express…  in subject_expr_rule()
5468         if (p->error_indicator) {  in subject_expr_rule()
5469             p->level--;  in subject_expr_rule()
5472 …D(fprintf(stderr, "%*c> subject_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expressi…  in subject_expr_rule()
5475             (named_expression_var = named_expression_rule(p))  // named_expression  in subject_expr_rule()
5478 …D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "nam…  in subject_expr_rule()
5482         p->mark = _mark;  in subject_expr_rule()
5483         D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ',  in subject_expr_rule()
5484                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));  in subject_expr_rule()
5488     p->level--;  in subject_expr_rule()
5494 case_block_rule(Parser *p)  in case_block_rule()  argument
5496     if (p->level++ == MAXSTACK) {  in case_block_rule()
5497         p->error_indicator = 1;  in case_block_rule()
5500     if (p->error_indicator) {  in case_block_rule()
5501         p->level--;  in case_block_rule()
5505     int _mark = p->mark;  in case_block_rule()
5506     if (p->call_invalid_rules) { // invalid_case_block  in case_block_rule()
5507         if (p->error_indicator) {  in case_block_rule()
5508             p->level--;  in case_block_rule()
5511 …D(fprintf(stderr, "%*c> case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_case_blo…  in case_block_rule()
5514             (invalid_case_block_var = invalid_case_block_rule(p))  // invalid_case_block  in case_block_rule()
5517 …D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval…  in case_block_rule()
5521         p->mark = _mark;  in case_block_rule()
5522         D(fprintf(stderr, "%*c%s case_block[%d-%d]: %s failed!\n", p->level, ' ',  in case_block_rule()
5523                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_case_block"));  in case_block_rule()
5526         if (p->error_indicator) {  in case_block_rule()
5527             p->level--;  in case_block_rule()
5530 …D(fprintf(stderr, "%*c> case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\" pattern…  in case_block_rule()
5537             (_keyword = _PyPegen_expect_soft_keyword(p, "case"))  // soft_keyword='"case"'  in case_block_rule()
5539             (pattern = patterns_rule(p))  // patterns  in case_block_rule()
5541             (guard = guard_rule(p), !p->error_indicator)  // guard?  in case_block_rule()
5543             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in case_block_rule()
5545             (body = block_rule(p))  // block  in case_block_rule()
5548 …D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"cas…  in case_block_rule()
5549             _res = _PyAST_match_case ( pattern , guard , body , p -> arena );  in case_block_rule()
5551                 p->error_indicator = 1;  in case_block_rule()
5552                 p->level--;  in case_block_rule()
5557         p->mark = _mark;  in case_block_rule()
5558         D(fprintf(stderr, "%*c%s case_block[%d-%d]: %s failed!\n", p->level, ' ',  in case_block_rule()
5559 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? ':' block"));  in case_block_rule()
5563     p->level--;  in case_block_rule()
5569 guard_rule(Parser *p)  in guard_rule()  argument
5571     if (p->level++ == MAXSTACK) {  in guard_rule()
5572         p->error_indicator = 1;  in guard_rule()
5575     if (p->error_indicator) {  in guard_rule()
5576         p->level--;  in guard_rule()
5580     int _mark = p->mark;  in guard_rule()
5582         if (p->error_indicator) {  in guard_rule()
5583             p->level--;  in guard_rule()
5586 …D(fprintf(stderr, "%*c> guard[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression…  in guard_rule()
5590             (_keyword = _PyPegen_expect_token(p, 510))  // token='if'  in guard_rule()
5592             (guard = named_expression_rule(p))  // named_expression  in guard_rule()
5595 …D(fprintf(stderr, "%*c+ guard[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named…  in guard_rule()
5598                 p->error_indicator = 1;  in guard_rule()
5599                 p->level--;  in guard_rule()
5604         p->mark = _mark;  in guard_rule()
5605         D(fprintf(stderr, "%*c%s guard[%d-%d]: %s failed!\n", p->level, ' ',  in guard_rule()
5606                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression"));  in guard_rule()
5610     p->level--;  in guard_rule()
5616 patterns_rule(Parser *p)  in patterns_rule()  argument
5618     if (p->level++ == MAXSTACK) {  in patterns_rule()
5619         p->error_indicator = 1;  in patterns_rule()
5622     if (p->error_indicator) {  in patterns_rule()
5623         p->level--;  in patterns_rule()
5627     int _mark = p->mark;  in patterns_rule()
5628     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in patterns_rule()
5629         p->error_indicator = 1;  in patterns_rule()
5630         p->level--;  in patterns_rule()
5633     int _start_lineno = p->tokens[_mark]->lineno;  in patterns_rule()
5635     int _start_col_offset = p->tokens[_mark]->col_offset;  in patterns_rule()
5638         if (p->error_indicator) {  in patterns_rule()
5639             p->level--;  in patterns_rule()
5642 …D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "open_sequence_patt…  in patterns_rule()
5645             (patterns = (asdl_pattern_seq*)open_sequence_pattern_rule(p))  // open_sequence_pattern  in patterns_rule()
5648 …D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "open_se…  in patterns_rule()
5649             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in patterns_rule()
5651                 p->level--;  in patterns_rule()
5654             int _end_lineno = _token->end_lineno;  in patterns_rule()
5656             int _end_col_offset = _token->end_col_offset;  in patterns_rule()
5660                 p->error_indicator = 1;  in patterns_rule()
5661                 p->level--;  in patterns_rule()
5666         p->mark = _mark;  in patterns_rule()
5667         D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ',  in patterns_rule()
5668                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "open_sequence_pattern"));  in patterns_rule()
5671         if (p->error_indicator) {  in patterns_rule()
5672             p->level--;  in patterns_rule()
5675         D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern"));  in patterns_rule()
5678             (pattern_var = pattern_rule(p))  // pattern  in patterns_rule()
5681 …D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern…  in patterns_rule()
5685         p->mark = _mark;  in patterns_rule()
5686         D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ',  in patterns_rule()
5687                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern"));  in patterns_rule()
5691     p->level--;  in patterns_rule()
5697 pattern_rule(Parser *p)  in pattern_rule()  argument
5699     if (p->level++ == MAXSTACK) {  in pattern_rule()
5700         p->error_indicator = 1;  in pattern_rule()
5703     if (p->error_indicator) {  in pattern_rule()
5704         p->level--;  in pattern_rule()
5708     int _mark = p->mark;  in pattern_rule()
5710         if (p->error_indicator) {  in pattern_rule()
5711             p->level--;  in pattern_rule()
5714 …      D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "as_pattern"));  in pattern_rule()
5717             (as_pattern_var = as_pattern_rule(p))  // as_pattern  in pattern_rule()
5720 …D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "as_patte…  in pattern_rule()
5724         p->mark = _mark;  in pattern_rule()
5725         D(fprintf(stderr, "%*c%s pattern[%d-%d]: %s failed!\n", p->level, ' ',  in pattern_rule()
5726                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "as_pattern"));  in pattern_rule()
5729         if (p->error_indicator) {  in pattern_rule()
5730             p->level--;  in pattern_rule()
5733 …      D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern"));  in pattern_rule()
5736             (or_pattern_var = or_pattern_rule(p))  // or_pattern  in pattern_rule()
5739 …D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_patte…  in pattern_rule()
5743         p->mark = _mark;  in pattern_rule()
5744         D(fprintf(stderr, "%*c%s pattern[%d-%d]: %s failed!\n", p->level, ' ',  in pattern_rule()
5745                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern"));  in pattern_rule()
5749     p->level--;  in pattern_rule()
5755 as_pattern_rule(Parser *p)  in as_pattern_rule()  argument
5757     if (p->level++ == MAXSTACK) {  in as_pattern_rule()
5758         p->error_indicator = 1;  in as_pattern_rule()
5761     if (p->error_indicator) {  in as_pattern_rule()
5762         p->level--;  in as_pattern_rule()
5766     int _mark = p->mark;  in as_pattern_rule()
5767     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in as_pattern_rule()
5768         p->error_indicator = 1;  in as_pattern_rule()
5769         p->level--;  in as_pattern_rule()
5772     int _start_lineno = p->tokens[_mark]->lineno;  in as_pattern_rule()
5774     int _start_col_offset = p->tokens[_mark]->col_offset;  in as_pattern_rule()
5777         if (p->error_indicator) {  in as_pattern_rule()
5778             p->level--;  in as_pattern_rule()
5781 …D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' …  in as_pattern_rule()
5786             (pattern = or_pattern_rule(p))  // or_pattern  in as_pattern_rule()
5788             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in as_pattern_rule()
5790             (target = pattern_capture_target_rule(p))  // pattern_capture_target  in as_pattern_rule()
5793 …D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pa…  in as_pattern_rule()
5794             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in as_pattern_rule()
5796                 p->level--;  in as_pattern_rule()
5799             int _end_lineno = _token->end_lineno;  in as_pattern_rule()
5801             int _end_col_offset = _token->end_col_offset;  in as_pattern_rule()
5803             _res = _PyAST_MatchAs ( pattern , target -> v . Name . id , EXTRA );  in as_pattern_rule()
5805                 p->error_indicator = 1;  in as_pattern_rule()
5806                 p->level--;  in as_pattern_rule()
5811         p->mark = _mark;  in as_pattern_rule()
5812         D(fprintf(stderr, "%*c%s as_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in as_pattern_rule()
5813 …   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' pattern_capture_target"));  in as_pattern_rule()
5815     if (p->call_invalid_rules) { // invalid_as_pattern  in as_pattern_rule()
5816         if (p->error_indicator) {  in as_pattern_rule()
5817             p->level--;  in as_pattern_rule()
5820 …D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_as_patte…  in as_pattern_rule()
5823             (invalid_as_pattern_var = invalid_as_pattern_rule(p))  // invalid_as_pattern  in as_pattern_rule()
5826 …D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval…  in as_pattern_rule()
5830         p->mark = _mark;  in as_pattern_rule()
5831         D(fprintf(stderr, "%*c%s as_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in as_pattern_rule()
5832                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_as_pattern"));  in as_pattern_rule()
5836     p->level--;  in as_pattern_rule()
5842 or_pattern_rule(Parser *p)  in or_pattern_rule()  argument
5844     if (p->level++ == MAXSTACK) {  in or_pattern_rule()
5845         p->error_indicator = 1;  in or_pattern_rule()
5848     if (p->error_indicator) {  in or_pattern_rule()
5849         p->level--;  in or_pattern_rule()
5853     int _mark = p->mark;  in or_pattern_rule()
5854     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in or_pattern_rule()
5855         p->error_indicator = 1;  in or_pattern_rule()
5856         p->level--;  in or_pattern_rule()
5859     int _start_lineno = p->tokens[_mark]->lineno;  in or_pattern_rule()
5861     int _start_col_offset = p->tokens[_mark]->col_offset;  in or_pattern_rule()
5864         if (p->error_indicator) {  in or_pattern_rule()
5865             p->level--;  in or_pattern_rule()
5868 …D(fprintf(stderr, "%*c> or_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|'.closed_patte…  in or_pattern_rule()
5871             (patterns = (asdl_pattern_seq*)_gather_51_rule(p))  // '|'.closed_pattern+  in or_pattern_rule()
5874 …D(fprintf(stderr, "%*c+ or_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|'.c…  in or_pattern_rule()
5875             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in or_pattern_rule()
5877                 p->level--;  in or_pattern_rule()
5880             int _end_lineno = _token->end_lineno;  in or_pattern_rule()
5882             int _end_col_offset = _token->end_col_offset;  in or_pattern_rule()
5886                 p->error_indicator = 1;  in or_pattern_rule()
5887                 p->level--;  in or_pattern_rule()
5892         p->mark = _mark;  in or_pattern_rule()
5893         D(fprintf(stderr, "%*c%s or_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in or_pattern_rule()
5894                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|'.closed_pattern+"));  in or_pattern_rule()
5898     p->level--;  in or_pattern_rule()
5912 closed_pattern_rule(Parser *p)  in closed_pattern_rule()  argument
5914     if (p->level++ == MAXSTACK) {  in closed_pattern_rule()
5915         p->error_indicator = 1;  in closed_pattern_rule()
5918     if (p->error_indicator) {  in closed_pattern_rule()
5919         p->level--;  in closed_pattern_rule()
5923     int _mark = p->mark;  in closed_pattern_rule()
5925         if (p->error_indicator) {  in closed_pattern_rule()
5926             p->level--;  in closed_pattern_rule()
5929 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_patt…  in closed_pattern_rule()
5932             (literal_pattern_var = literal_pattern_rule(p))  // literal_pattern  in closed_pattern_rule()
5935 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "l…  in closed_pattern_rule()
5939         p->mark = _mark;  in closed_pattern_rule()
5940         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in closed_pattern_rule()
5941                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_pattern"));  in closed_pattern_rule()
5944         if (p->error_indicator) {  in closed_pattern_rule()
5945             p->level--;  in closed_pattern_rule()
5948 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "capture_patt…  in closed_pattern_rule()
5951             (capture_pattern_var = capture_pattern_rule(p))  // capture_pattern  in closed_pattern_rule()
5954 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "c…  in closed_pattern_rule()
5958         p->mark = _mark;  in closed_pattern_rule()
5959         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in closed_pattern_rule()
5960                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "capture_pattern"));  in closed_pattern_rule()
5963         if (p->error_indicator) {  in closed_pattern_rule()
5964             p->level--;  in closed_pattern_rule()
5967 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "wildcard_pat…  in closed_pattern_rule()
5970             (wildcard_pattern_var = wildcard_pattern_rule(p))  // wildcard_pattern  in closed_pattern_rule()
5973 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "w…  in closed_pattern_rule()
5977         p->mark = _mark;  in closed_pattern_rule()
5978         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in closed_pattern_rule()
5979                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "wildcard_pattern"));  in closed_pattern_rule()
5982         if (p->error_indicator) {  in closed_pattern_rule()
5983             p->level--;  in closed_pattern_rule()
5986 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "value_patter…  in closed_pattern_rule()
5989             (value_pattern_var = value_pattern_rule(p))  // value_pattern  in closed_pattern_rule()
5992 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "v…  in closed_pattern_rule()
5996         p->mark = _mark;  in closed_pattern_rule()
5997         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in closed_pattern_rule()
5998                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "value_pattern"));  in closed_pattern_rule()
6001         if (p->error_indicator) {  in closed_pattern_rule()
6002             p->level--;  in closed_pattern_rule()
6005 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group_patter…  in closed_pattern_rule()
6008             (group_pattern_var = group_pattern_rule(p))  // group_pattern  in closed_pattern_rule()
6011 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "g…  in closed_pattern_rule()
6015         p->mark = _mark;  in closed_pattern_rule()
6016         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in closed_pattern_rule()
6017                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group_pattern"));  in closed_pattern_rule()
6020         if (p->error_indicator) {  in closed_pattern_rule()
6021             p->level--;  in closed_pattern_rule()
6024 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sequence_pat…  in closed_pattern_rule()
6027             (sequence_pattern_var = sequence_pattern_rule(p))  // sequence_pattern  in closed_pattern_rule()
6030 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s…  in closed_pattern_rule()
6034         p->mark = _mark;  in closed_pattern_rule()
6035         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in closed_pattern_rule()
6036                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sequence_pattern"));  in closed_pattern_rule()
6039         if (p->error_indicator) {  in closed_pattern_rule()
6040             p->level--;  in closed_pattern_rule()
6043 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "mapping_patt…  in closed_pattern_rule()
6046             (mapping_pattern_var = mapping_pattern_rule(p))  // mapping_pattern  in closed_pattern_rule()
6049 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "m…  in closed_pattern_rule()
6053         p->mark = _mark;  in closed_pattern_rule()
6054         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in closed_pattern_rule()
6055                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "mapping_pattern"));  in closed_pattern_rule()
6058         if (p->error_indicator) {  in closed_pattern_rule()
6059             p->level--;  in closed_pattern_rule()
6062 …D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_patter…  in closed_pattern_rule()
6065             (class_pattern_var = class_pattern_rule(p))  // class_pattern  in closed_pattern_rule()
6068 …D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "c…  in closed_pattern_rule()
6072         p->mark = _mark;  in closed_pattern_rule()
6073         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in closed_pattern_rule()
6074                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_pattern"));  in closed_pattern_rule()
6078     p->level--;  in closed_pattern_rule()
6083 //     | signed_number !('+' | '-')
6090 literal_pattern_rule(Parser *p)  in literal_pattern_rule()  argument
6092     if (p->level++ == MAXSTACK) {  in literal_pattern_rule()
6093         p->error_indicator = 1;  in literal_pattern_rule()
6096     if (p->error_indicator) {  in literal_pattern_rule()
6097         p->level--;  in literal_pattern_rule()
6101     int _mark = p->mark;  in literal_pattern_rule()
6102     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in literal_pattern_rule()
6103         p->error_indicator = 1;  in literal_pattern_rule()
6104         p->level--;  in literal_pattern_rule()
6107     int _start_lineno = p->tokens[_mark]->lineno;  in literal_pattern_rule()
6109     int _start_col_offset = p->tokens[_mark]->col_offset;  in literal_pattern_rule()
6111     { // signed_number !('+' | '-')  in literal_pattern_rule()
6112         if (p->error_indicator) {  in literal_pattern_rule()
6113             p->level--;  in literal_pattern_rule()
6116 …D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_numb…  in literal_pattern_rule()
6119             (value = signed_number_rule(p))  // signed_number  in literal_pattern_rule()
6121             _PyPegen_lookahead(0, _tmp_53_rule, p)  in literal_pattern_rule()
6124 …ntf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed…  in literal_pattern_rule()
6125             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in literal_pattern_rule()
6127                 p->level--;  in literal_pattern_rule()
6130             int _end_lineno = _token->end_lineno;  in literal_pattern_rule()
6132             int _end_col_offset = _token->end_col_offset;  in literal_pattern_rule()
6136                 p->error_indicator = 1;  in literal_pattern_rule()
6137                 p->level--;  in literal_pattern_rule()
6142         p->mark = _mark;  in literal_pattern_rule()
6143         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in literal_pattern_rule()
6144 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')"));  in literal_pattern_rule()
6147         if (p->error_indicator) {  in literal_pattern_rule()
6148             p->level--;  in literal_pattern_rule()
6151 …D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_num…  in literal_pattern_rule()
6154             (value = complex_number_rule(p))  // complex_number  in literal_pattern_rule()
6157 …D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in literal_pattern_rule()
6158             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in literal_pattern_rule()
6160                 p->level--;  in literal_pattern_rule()
6163             int _end_lineno = _token->end_lineno;  in literal_pattern_rule()
6165             int _end_col_offset = _token->end_col_offset;  in literal_pattern_rule()
6169                 p->error_indicator = 1;  in literal_pattern_rule()
6170                 p->level--;  in literal_pattern_rule()
6175         p->mark = _mark;  in literal_pattern_rule()
6176         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in literal_pattern_rule()
6177                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number"));  in literal_pattern_rule()
6180         if (p->error_indicator) {  in literal_pattern_rule()
6181             p->level--;  in literal_pattern_rule()
6184 … D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings"));  in literal_pattern_rule()
6187             (value = strings_rule(p))  // strings  in literal_pattern_rule()
6190 …D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in literal_pattern_rule()
6191             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in literal_pattern_rule()
6193                 p->level--;  in literal_pattern_rule()
6196             int _end_lineno = _token->end_lineno;  in literal_pattern_rule()
6198             int _end_col_offset = _token->end_col_offset;  in literal_pattern_rule()
6202                 p->error_indicator = 1;  in literal_pattern_rule()
6203                 p->level--;  in literal_pattern_rule()
6208         p->mark = _mark;  in literal_pattern_rule()
6209         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in literal_pattern_rule()
6210                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings"));  in literal_pattern_rule()
6213         if (p->error_indicator) {  in literal_pattern_rule()
6214             p->level--;  in literal_pattern_rule()
6217 …  D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));  in literal_pattern_rule()
6220             (_keyword = _PyPegen_expect_token(p, 523))  // token='None'  in literal_pattern_rule()
6223 …D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in literal_pattern_rule()
6224             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in literal_pattern_rule()
6226                 p->level--;  in literal_pattern_rule()
6229             int _end_lineno = _token->end_lineno;  in literal_pattern_rule()
6231             int _end_col_offset = _token->end_col_offset;  in literal_pattern_rule()
6235                 p->error_indicator = 1;  in literal_pattern_rule()
6236                 p->level--;  in literal_pattern_rule()
6241         p->mark = _mark;  in literal_pattern_rule()
6242         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in literal_pattern_rule()
6243                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));  in literal_pattern_rule()
6246         if (p->error_indicator) {  in literal_pattern_rule()
6247             p->level--;  in literal_pattern_rule()
6250 …  D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));  in literal_pattern_rule()
6253             (_keyword = _PyPegen_expect_token(p, 524))  // token='True'  in literal_pattern_rule()
6256 …D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in literal_pattern_rule()
6257             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in literal_pattern_rule()
6259                 p->level--;  in literal_pattern_rule()
6262             int _end_lineno = _token->end_lineno;  in literal_pattern_rule()
6264             int _end_col_offset = _token->end_col_offset;  in literal_pattern_rule()
6268                 p->error_indicator = 1;  in literal_pattern_rule()
6269                 p->level--;  in literal_pattern_rule()
6274         p->mark = _mark;  in literal_pattern_rule()
6275         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in literal_pattern_rule()
6276                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));  in literal_pattern_rule()
6279         if (p->error_indicator) {  in literal_pattern_rule()
6280             p->level--;  in literal_pattern_rule()
6283 … D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));  in literal_pattern_rule()
6286             (_keyword = _PyPegen_expect_token(p, 525))  // token='False'  in literal_pattern_rule()
6289 …D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in literal_pattern_rule()
6290             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in literal_pattern_rule()
6292                 p->level--;  in literal_pattern_rule()
6295             int _end_lineno = _token->end_lineno;  in literal_pattern_rule()
6297             int _end_col_offset = _token->end_col_offset;  in literal_pattern_rule()
6301                 p->error_indicator = 1;  in literal_pattern_rule()
6302                 p->level--;  in literal_pattern_rule()
6307         p->mark = _mark;  in literal_pattern_rule()
6308         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in literal_pattern_rule()
6309                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));  in literal_pattern_rule()
6313     p->level--;  in literal_pattern_rule()
6318 //     | signed_number !('+' | '-')
6325 literal_expr_rule(Parser *p)  in literal_expr_rule()  argument
6327     if (p->level++ == MAXSTACK) {  in literal_expr_rule()
6328         p->error_indicator = 1;  in literal_expr_rule()
6331     if (p->error_indicator) {  in literal_expr_rule()
6332         p->level--;  in literal_expr_rule()
6336     int _mark = p->mark;  in literal_expr_rule()
6337     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in literal_expr_rule()
6338         p->error_indicator = 1;  in literal_expr_rule()
6339         p->level--;  in literal_expr_rule()
6342     int _start_lineno = p->tokens[_mark]->lineno;  in literal_expr_rule()
6344     int _start_col_offset = p->tokens[_mark]->col_offset;  in literal_expr_rule()
6346     { // signed_number !('+' | '-')  in literal_expr_rule()
6347         if (p->error_indicator) {  in literal_expr_rule()
6348             p->level--;  in literal_expr_rule()
6351 …D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number …  in literal_expr_rule()
6354             (signed_number_var = signed_number_rule(p))  // signed_number  in literal_expr_rule()
6356             _PyPegen_lookahead(0, _tmp_54_rule, p)  in literal_expr_rule()
6359 …printf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed…  in literal_expr_rule()
6363         p->mark = _mark;  in literal_expr_rule()
6364         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',  in literal_expr_rule()
6365 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')"));  in literal_expr_rule()
6368         if (p->error_indicator) {  in literal_expr_rule()
6369             p->level--;  in literal_expr_rule()
6372 …D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_number…  in literal_expr_rule()
6375             (complex_number_var = complex_number_rule(p))  // complex_number  in literal_expr_rule()
6378 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "com…  in literal_expr_rule()
6382         p->mark = _mark;  in literal_expr_rule()
6383         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',  in literal_expr_rule()
6384                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number"));  in literal_expr_rule()
6387         if (p->error_indicator) {  in literal_expr_rule()
6388             p->level--;  in literal_expr_rule()
6391 …    D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings"));  in literal_expr_rule()
6394             (strings_var = strings_rule(p))  // strings  in literal_expr_rule()
6397 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "str…  in literal_expr_rule()
6401         p->mark = _mark;  in literal_expr_rule()
6402         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',  in literal_expr_rule()
6403                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings"));  in literal_expr_rule()
6406         if (p->error_indicator) {  in literal_expr_rule()
6407             p->level--;  in literal_expr_rule()
6410 …     D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));  in literal_expr_rule()
6413             (_keyword = _PyPegen_expect_token(p, 523))  // token='None'  in literal_expr_rule()
6416 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'No…  in literal_expr_rule()
6417             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in literal_expr_rule()
6419                 p->level--;  in literal_expr_rule()
6422             int _end_lineno = _token->end_lineno;  in literal_expr_rule()
6424             int _end_col_offset = _token->end_col_offset;  in literal_expr_rule()
6428                 p->error_indicator = 1;  in literal_expr_rule()
6429                 p->level--;  in literal_expr_rule()
6434         p->mark = _mark;  in literal_expr_rule()
6435         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',  in literal_expr_rule()
6436                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));  in literal_expr_rule()
6439         if (p->error_indicator) {  in literal_expr_rule()
6440             p->level--;  in literal_expr_rule()
6443 …     D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));  in literal_expr_rule()
6446             (_keyword = _PyPegen_expect_token(p, 524))  // token='True'  in literal_expr_rule()
6449 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'Tr…  in literal_expr_rule()
6450             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in literal_expr_rule()
6452                 p->level--;  in literal_expr_rule()
6455             int _end_lineno = _token->end_lineno;  in literal_expr_rule()
6457             int _end_col_offset = _token->end_col_offset;  in literal_expr_rule()
6461                 p->error_indicator = 1;  in literal_expr_rule()
6462                 p->level--;  in literal_expr_rule()
6467         p->mark = _mark;  in literal_expr_rule()
6468         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',  in literal_expr_rule()
6469                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));  in literal_expr_rule()
6472         if (p->error_indicator) {  in literal_expr_rule()
6473             p->level--;  in literal_expr_rule()
6476 …    D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));  in literal_expr_rule()
6479             (_keyword = _PyPegen_expect_token(p, 525))  // token='False'  in literal_expr_rule()
6482 …D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'Fa…  in literal_expr_rule()
6483             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in literal_expr_rule()
6485                 p->level--;  in literal_expr_rule()
6488             int _end_lineno = _token->end_lineno;  in literal_expr_rule()
6490             int _end_col_offset = _token->end_col_offset;  in literal_expr_rule()
6494                 p->error_indicator = 1;  in literal_expr_rule()
6495                 p->level--;  in literal_expr_rule()
6500         p->mark = _mark;  in literal_expr_rule()
6501         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',  in literal_expr_rule()
6502                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));  in literal_expr_rule()
6506     p->level--;  in literal_expr_rule()
6512 //     | signed_real_number '-' imaginary_number
6514 complex_number_rule(Parser *p)  in complex_number_rule()  argument
6516     if (p->level++ == MAXSTACK) {  in complex_number_rule()
6517         p->error_indicator = 1;  in complex_number_rule()
6520     if (p->error_indicator) {  in complex_number_rule()
6521         p->level--;  in complex_number_rule()
6525     int _mark = p->mark;  in complex_number_rule()
6526     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in complex_number_rule()
6527         p->error_indicator = 1;  in complex_number_rule()
6528         p->level--;  in complex_number_rule()
6531     int _start_lineno = p->tokens[_mark]->lineno;  in complex_number_rule()
6533     int _start_col_offset = p->tokens[_mark]->col_offset;  in complex_number_rule()
6536         if (p->error_indicator) {  in complex_number_rule()
6537             p->level--;  in complex_number_rule()
6540 …D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_real_…  in complex_number_rule()
6545             (real = signed_real_number_rule(p))  // signed_real_number  in complex_number_rule()
6547             (_literal = _PyPegen_expect_token(p, 14))  // token='+'  in complex_number_rule()
6549             (imag = imaginary_number_rule(p))  // imaginary_number  in complex_number_rule()
6552 …D(fprintf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "s…  in complex_number_rule()
6553             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in complex_number_rule()
6555                 p->level--;  in complex_number_rule()
6558             int _end_lineno = _token->end_lineno;  in complex_number_rule()
6560             int _end_col_offset = _token->end_col_offset;  in complex_number_rule()
6564                 p->error_indicator = 1;  in complex_number_rule()
6565                 p->level--;  in complex_number_rule()
6570         p->mark = _mark;  in complex_number_rule()
6571         D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ',  in complex_number_rule()
6572 …  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_real_number '+' imaginary_number"));  in complex_number_rule()
6574     { // signed_real_number '-' imaginary_number  in complex_number_rule()
6575         if (p->error_indicator) {  in complex_number_rule()
6576             p->level--;  in complex_number_rule()
6579 …D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_real_…  in complex_number_rule()
6584             (real = signed_real_number_rule(p))  // signed_real_number  in complex_number_rule()
6586             (_literal = _PyPegen_expect_token(p, 15))  // token='-'  in complex_number_rule()
6588             (imag = imaginary_number_rule(p))  // imaginary_number  in complex_number_rule()
6591 …printf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sign…  in complex_number_rule()
6592             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in complex_number_rule()
6594                 p->level--;  in complex_number_rule()
6597             int _end_lineno = _token->end_lineno;  in complex_number_rule()
6599             int _end_col_offset = _token->end_col_offset;  in complex_number_rule()
6603                 p->error_indicator = 1;  in complex_number_rule()
6604                 p->level--;  in complex_number_rule()
6609         p->mark = _mark;  in complex_number_rule()
6610         D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ',  in complex_number_rule()
6611 …  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_real_number '-' imaginary_number"));  in complex_number_rule()
6615     p->level--;  in complex_number_rule()
6619 // signed_number: NUMBER | '-' NUMBER
6621 signed_number_rule(Parser *p)  in signed_number_rule()  argument
6623     if (p->level++ == MAXSTACK) {  in signed_number_rule()
6624         p->error_indicator = 1;  in signed_number_rule()
6627     if (p->error_indicator) {  in signed_number_rule()
6628         p->level--;  in signed_number_rule()
6632     int _mark = p->mark;  in signed_number_rule()
6633     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in signed_number_rule()
6634         p->error_indicator = 1;  in signed_number_rule()
6635         p->level--;  in signed_number_rule()
6638     int _start_lineno = p->tokens[_mark]->lineno;  in signed_number_rule()
6640     int _start_col_offset = p->tokens[_mark]->col_offset;  in signed_number_rule()
6643         if (p->error_indicator) {  in signed_number_rule()
6644             p->level--;  in signed_number_rule()
6647 …    D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));  in signed_number_rule()
6650             (number_var = _PyPegen_number_token(p))  // NUMBER  in signed_number_rule()
6653 …D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NU…  in signed_number_rule()
6657         p->mark = _mark;  in signed_number_rule()
6658         D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ',  in signed_number_rule()
6659                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));  in signed_number_rule()
6661     { // '-' NUMBER  in signed_number_rule()
6662         if (p->error_indicator) {  in signed_number_rule()
6663             p->level--;  in signed_number_rule()
6666 …D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' NUMBER"));  in signed_number_rule()
6670             (_literal = _PyPegen_expect_token(p, 15))  // token='-'  in signed_number_rule()
6672             (number = _PyPegen_number_token(p))  // NUMBER  in signed_number_rule()
6675 …D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-…  in signed_number_rule()
6676             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in signed_number_rule()
6678                 p->level--;  in signed_number_rule()
6681             int _end_lineno = _token->end_lineno;  in signed_number_rule()
6683             int _end_col_offset = _token->end_col_offset;  in signed_number_rule()
6687                 p->error_indicator = 1;  in signed_number_rule()
6688                 p->level--;  in signed_number_rule()
6693         p->mark = _mark;  in signed_number_rule()
6694         D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ',  in signed_number_rule()
6695                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' NUMBER"));  in signed_number_rule()
6699     p->level--;  in signed_number_rule()
6703 // signed_real_number: real_number | '-' real_number
6705 signed_real_number_rule(Parser *p)  in signed_real_number_rule()  argument
6707     if (p->level++ == MAXSTACK) {  in signed_real_number_rule()
6708         p->error_indicator = 1;  in signed_real_number_rule()
6711     if (p->error_indicator) {  in signed_real_number_rule()
6712         p->level--;  in signed_real_number_rule()
6716     int _mark = p->mark;  in signed_real_number_rule()
6717     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in signed_real_number_rule()
6718         p->error_indicator = 1;  in signed_real_number_rule()
6719         p->level--;  in signed_real_number_rule()
6722     int _start_lineno = p->tokens[_mark]->lineno;  in signed_real_number_rule()
6724     int _start_col_offset = p->tokens[_mark]->col_offset;  in signed_real_number_rule()
6727         if (p->error_indicator) {  in signed_real_number_rule()
6728             p->level--;  in signed_real_number_rule()
6731 …D(fprintf(stderr, "%*c> signed_real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "real_num…  in signed_real_number_rule()
6734             (real_number_var = real_number_rule(p))  // real_number  in signed_real_number_rule()
6737 …D(fprintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in signed_real_number_rule()
6741         p->mark = _mark;  in signed_real_number_rule()
6742         D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ',  in signed_real_number_rule()
6743                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "real_number"));  in signed_real_number_rule()
6745     { // '-' real_number  in signed_real_number_rule()
6746         if (p->error_indicator) {  in signed_real_number_rule()
6747             p->level--;  in signed_real_number_rule()
6750 …D(fprintf(stderr, "%*c> signed_real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' real…  in signed_real_number_rule()
6754             (_literal = _PyPegen_expect_token(p, 15))  // token='-'  in signed_real_number_rule()
6756             (real = real_number_rule(p))  // real_number  in signed_real_number_rule()
6759 …D(fprintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in signed_real_number_rule()
6760             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in signed_real_number_rule()
6762                 p->level--;  in signed_real_number_rule()
6765             int _end_lineno = _token->end_lineno;  in signed_real_number_rule()
6767             int _end_col_offset = _token->end_col_offset;  in signed_real_number_rule()
6771                 p->error_indicator = 1;  in signed_real_number_rule()
6772                 p->level--;  in signed_real_number_rule()
6777         p->mark = _mark;  in signed_real_number_rule()
6778         D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ',  in signed_real_number_rule()
6779                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' real_number"));  in signed_real_number_rule()
6783     p->level--;  in signed_real_number_rule()
6789 real_number_rule(Parser *p)  in real_number_rule()  argument
6791     if (p->level++ == MAXSTACK) {  in real_number_rule()
6792         p->error_indicator = 1;  in real_number_rule()
6795     if (p->error_indicator) {  in real_number_rule()
6796         p->level--;  in real_number_rule()
6800     int _mark = p->mark;  in real_number_rule()
6802         if (p->error_indicator) {  in real_number_rule()
6803             p->level--;  in real_number_rule()
6806 …      D(fprintf(stderr, "%*c> real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));  in real_number_rule()
6809             (real = _PyPegen_number_token(p))  // NUMBER  in real_number_rule()
6812 …D(fprintf(stderr, "%*c+ real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMB…  in real_number_rule()
6813             _res = _PyPegen_ensure_real ( p , real );  in real_number_rule()
6815                 p->error_indicator = 1;  in real_number_rule()
6816                 p->level--;  in real_number_rule()
6821         p->mark = _mark;  in real_number_rule()
6822         D(fprintf(stderr, "%*c%s real_number[%d-%d]: %s failed!\n", p->level, ' ',  in real_number_rule()
6823                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));  in real_number_rule()
6827     p->level--;  in real_number_rule()
6833 imaginary_number_rule(Parser *p)  in imaginary_number_rule()  argument
6835     if (p->level++ == MAXSTACK) {  in imaginary_number_rule()
6836         p->error_indicator = 1;  in imaginary_number_rule()
6839     if (p->error_indicator) {  in imaginary_number_rule()
6840         p->level--;  in imaginary_number_rule()
6844     int _mark = p->mark;  in imaginary_number_rule()
6846         if (p->error_indicator) {  in imaginary_number_rule()
6847             p->level--;  in imaginary_number_rule()
6850 … D(fprintf(stderr, "%*c> imaginary_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));  in imaginary_number_rule()
6853             (imag = _PyPegen_number_token(p))  // NUMBER  in imaginary_number_rule()
6856 …D(fprintf(stderr, "%*c+ imaginary_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in imaginary_number_rule()
6857             _res = _PyPegen_ensure_imaginary ( p , imag );  in imaginary_number_rule()
6859                 p->error_indicator = 1;  in imaginary_number_rule()
6860                 p->level--;  in imaginary_number_rule()
6865         p->mark = _mark;  in imaginary_number_rule()
6866         D(fprintf(stderr, "%*c%s imaginary_number[%d-%d]: %s failed!\n", p->level, ' ',  in imaginary_number_rule()
6867                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));  in imaginary_number_rule()
6871     p->level--;  in imaginary_number_rule()
6877 capture_pattern_rule(Parser *p)  in capture_pattern_rule()  argument
6879     if (p->level++ == MAXSTACK) {  in capture_pattern_rule()
6880         p->error_indicator = 1;  in capture_pattern_rule()
6883     if (p->error_indicator) {  in capture_pattern_rule()
6884         p->level--;  in capture_pattern_rule()
6888     int _mark = p->mark;  in capture_pattern_rule()
6889     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in capture_pattern_rule()
6890         p->error_indicator = 1;  in capture_pattern_rule()
6891         p->level--;  in capture_pattern_rule()
6894     int _start_lineno = p->tokens[_mark]->lineno;  in capture_pattern_rule()
6896     int _start_col_offset = p->tokens[_mark]->col_offset;  in capture_pattern_rule()
6899         if (p->error_indicator) {  in capture_pattern_rule()
6900             p->level--;  in capture_pattern_rule()
6903 …D(fprintf(stderr, "%*c> capture_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern_cap…  in capture_pattern_rule()
6906             (target = pattern_capture_target_rule(p))  // pattern_capture_target  in capture_pattern_rule()
6909 …D(fprintf(stderr, "%*c+ capture_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in capture_pattern_rule()
6910             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in capture_pattern_rule()
6912                 p->level--;  in capture_pattern_rule()
6915             int _end_lineno = _token->end_lineno;  in capture_pattern_rule()
6917             int _end_col_offset = _token->end_col_offset;  in capture_pattern_rule()
6919             _res = _PyAST_MatchAs ( NULL , target -> v . Name . id , EXTRA );  in capture_pattern_rule()
6921                 p->error_indicator = 1;  in capture_pattern_rule()
6922                 p->level--;  in capture_pattern_rule()
6927         p->mark = _mark;  in capture_pattern_rule()
6928         D(fprintf(stderr, "%*c%s capture_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in capture_pattern_rule()
6929                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern_capture_target"));  in capture_pattern_rule()
6933     p->level--;  in capture_pattern_rule()
6939 pattern_capture_target_rule(Parser *p)  in pattern_capture_target_rule()  argument
6941     if (p->level++ == MAXSTACK) {  in pattern_capture_target_rule()
6942         p->error_indicator = 1;  in pattern_capture_target_rule()
6945     if (p->error_indicator) {  in pattern_capture_target_rule()
6946         p->level--;  in pattern_capture_target_rule()
6950     int _mark = p->mark;  in pattern_capture_target_rule()
6952         if (p->error_indicator) {  in pattern_capture_target_rule()
6953             p->level--;  in pattern_capture_target_rule()
6956 …D(fprintf(stderr, "%*c> pattern_capture_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!\"_…  in pattern_capture_target_rule()
6959             _PyPegen_lookahead_with_string(0, _PyPegen_expect_soft_keyword, p, "_")  in pattern_capture_target_rule()
6961             (name = _PyPegen_name_token(p))  // NAME  in pattern_capture_target_rule()
6963             _PyPegen_lookahead(0, _tmp_55_rule, p)  in pattern_capture_target_rule()
6966 …D(fprintf(stderr, "%*c+ pattern_capture_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->…  in pattern_capture_target_rule()
6967             _res = _PyPegen_set_expr_context ( p , name , Store );  in pattern_capture_target_rule()
6969                 p->error_indicator = 1;  in pattern_capture_target_rule()
6970                 p->level--;  in pattern_capture_target_rule()
6975         p->mark = _mark;  in pattern_capture_target_rule()
6976         D(fprintf(stderr, "%*c%s pattern_capture_target[%d-%d]: %s failed!\n", p->level, ' ',  in pattern_capture_target_rule()
6977 …           p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')"));  in pattern_capture_target_rule()
6981     p->level--;  in pattern_capture_target_rule()
6987 wildcard_pattern_rule(Parser *p)  in wildcard_pattern_rule()  argument
6989     if (p->level++ == MAXSTACK) {  in wildcard_pattern_rule()
6990         p->error_indicator = 1;  in wildcard_pattern_rule()
6993     if (p->error_indicator) {  in wildcard_pattern_rule()
6994         p->level--;  in wildcard_pattern_rule()
6998     int _mark = p->mark;  in wildcard_pattern_rule()
6999     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in wildcard_pattern_rule()
7000         p->error_indicator = 1;  in wildcard_pattern_rule()
7001         p->level--;  in wildcard_pattern_rule()
7004     int _start_lineno = p->tokens[_mark]->lineno;  in wildcard_pattern_rule()
7006     int _start_col_offset = p->tokens[_mark]->col_offset;  in wildcard_pattern_rule()
7009         if (p->error_indicator) {  in wildcard_pattern_rule()
7010             p->level--;  in wildcard_pattern_rule()
7013 …  D(fprintf(stderr, "%*c> wildcard_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"_\""));  in wildcard_pattern_rule()
7016             (_keyword = _PyPegen_expect_soft_keyword(p, "_"))  // soft_keyword='"_"'  in wildcard_pattern_rule()
7019 …D(fprintf(stderr, "%*c+ wildcard_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in wildcard_pattern_rule()
7020             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in wildcard_pattern_rule()
7022                 p->level--;  in wildcard_pattern_rule()
7025             int _end_lineno = _token->end_lineno;  in wildcard_pattern_rule()
7027             int _end_col_offset = _token->end_col_offset;  in wildcard_pattern_rule()
7031                 p->error_indicator = 1;  in wildcard_pattern_rule()
7032                 p->level--;  in wildcard_pattern_rule()
7037         p->mark = _mark;  in wildcard_pattern_rule()
7038         D(fprintf(stderr, "%*c%s wildcard_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in wildcard_pattern_rule()
7039                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"_\""));  in wildcard_pattern_rule()
7043     p->level--;  in wildcard_pattern_rule()
7049 value_pattern_rule(Parser *p)  in value_pattern_rule()  argument
7051     if (p->level++ == MAXSTACK) {  in value_pattern_rule()
7052         p->error_indicator = 1;  in value_pattern_rule()
7055     if (p->error_indicator) {  in value_pattern_rule()
7056         p->level--;  in value_pattern_rule()
7060     int _mark = p->mark;  in value_pattern_rule()
7061     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in value_pattern_rule()
7062         p->error_indicator = 1;  in value_pattern_rule()
7063         p->level--;  in value_pattern_rule()
7066     int _start_lineno = p->tokens[_mark]->lineno;  in value_pattern_rule()
7068     int _start_col_offset = p->tokens[_mark]->col_offset;  in value_pattern_rule()
7071         if (p->error_indicator) {  in value_pattern_rule()
7072             p->level--;  in value_pattern_rule()
7075 …D(fprintf(stderr, "%*c> value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr !('.' | …  in value_pattern_rule()
7078             (attr = attr_rule(p))  // attr  in value_pattern_rule()
7080             _PyPegen_lookahead(0, _tmp_56_rule, p)  in value_pattern_rule()
7083 …D(fprintf(stderr, "%*c+ value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "at…  in value_pattern_rule()
7084             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in value_pattern_rule()
7086                 p->level--;  in value_pattern_rule()
7089             int _end_lineno = _token->end_lineno;  in value_pattern_rule()
7091             int _end_col_offset = _token->end_col_offset;  in value_pattern_rule()
7095                 p->error_indicator = 1;  in value_pattern_rule()
7096                 p->level--;  in value_pattern_rule()
7101         p->mark = _mark;  in value_pattern_rule()
7102         D(fprintf(stderr, "%*c%s value_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in value_pattern_rule()
7103                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr !('.' | '(' | '=')"));  in value_pattern_rule()
7107     p->level--;  in value_pattern_rule()
7111 // Left-recursive
7115 attr_rule(Parser *p)  in attr_rule()  argument
7117     if (p->level++ == MAXSTACK) {  in attr_rule()
7118         p->error_indicator = 1;  in attr_rule()
7122     if (_PyPegen_is_memoized(p, attr_type, &_res)) {  in attr_rule()
7123         p->level--;  in attr_rule()
7126     int _mark = p->mark;  in attr_rule()
7127     int _resmark = p->mark;  in attr_rule()
7129         int tmpvar_1 = _PyPegen_update_memo(p, _mark, attr_type, _res);  in attr_rule()
7131             p->level--;  in attr_rule()
7134         p->mark = _mark;  in attr_rule()
7135         void *_raw = attr_raw(p);  in attr_rule()
7136         if (p->error_indicator) {  in attr_rule()
7137             p->level--;  in attr_rule()
7140         if (_raw == NULL || p->mark <= _resmark)  in attr_rule()
7142         _resmark = p->mark;  in attr_rule()
7145     p->mark = _resmark;  in attr_rule()
7146     p->level--;  in attr_rule()
7150 attr_raw(Parser *p)  in attr_raw()  argument
7152     if (p->level++ == MAXSTACK) {  in attr_raw()
7153         p->error_indicator = 1;  in attr_raw()
7156     if (p->error_indicator) {  in attr_raw()
7157         p->level--;  in attr_raw()
7161     int _mark = p->mark;  in attr_raw()
7162     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in attr_raw()
7163         p->error_indicator = 1;  in attr_raw()
7164         p->level--;  in attr_raw()
7167     int _start_lineno = p->tokens[_mark]->lineno;  in attr_raw()
7169     int _start_col_offset = p->tokens[_mark]->col_offset;  in attr_raw()
7172         if (p->error_indicator) {  in attr_raw()
7173             p->level--;  in attr_raw()
7176 …D(fprintf(stderr, "%*c> attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '.' NAME"…  in attr_raw()
7181             (value = name_or_attr_rule(p))  // name_or_attr  in attr_raw()
7183             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in attr_raw()
7185             (attr = _PyPegen_name_token(p))  // NAME  in attr_raw()
7188 …D(fprintf(stderr, "%*c+ attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_att…  in attr_raw()
7189             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in attr_raw()
7191                 p->level--;  in attr_raw()
7194             int _end_lineno = _token->end_lineno;  in attr_raw()
7196             int _end_col_offset = _token->end_col_offset;  in attr_raw()
7198             _res = _PyAST_Attribute ( value , attr -> v . Name . id , Load , EXTRA );  in attr_raw()
7200                 p->error_indicator = 1;  in attr_raw()
7201                 p->level--;  in attr_raw()
7206         p->mark = _mark;  in attr_raw()
7207         D(fprintf(stderr, "%*c%s attr[%d-%d]: %s failed!\n", p->level, ' ',  in attr_raw()
7208                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '.' NAME"));  in attr_raw()
7212     p->level--;  in attr_raw()
7216 // Left-recursive
7219 name_or_attr_rule(Parser *p)  in name_or_attr_rule()  argument
7221     if (p->level++ == MAXSTACK) {  in name_or_attr_rule()
7222         p->error_indicator = 1;  in name_or_attr_rule()
7225     if (p->error_indicator) {  in name_or_attr_rule()
7226         p->level--;  in name_or_attr_rule()
7230     int _mark = p->mark;  in name_or_attr_rule()
7232         if (p->error_indicator) {  in name_or_attr_rule()
7233             p->level--;  in name_or_attr_rule()
7236         D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr"));  in name_or_attr_rule()
7239             (attr_var = attr_rule(p))  // attr  in name_or_attr_rule()
7242 …D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "att…  in name_or_attr_rule()
7246         p->mark = _mark;  in name_or_attr_rule()
7247         D(fprintf(stderr, "%*c%s name_or_attr[%d-%d]: %s failed!\n", p->level, ' ',  in name_or_attr_rule()
7248                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr"));  in name_or_attr_rule()
7251         if (p->error_indicator) {  in name_or_attr_rule()
7252             p->level--;  in name_or_attr_rule()
7255         D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));  in name_or_attr_rule()
7258             (name_var = _PyPegen_name_token(p))  // NAME  in name_or_attr_rule()
7261 …D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAM…  in name_or_attr_rule()
7265         p->mark = _mark;  in name_or_attr_rule()
7266         D(fprintf(stderr, "%*c%s name_or_attr[%d-%d]: %s failed!\n", p->level, ' ',  in name_or_attr_rule()
7267                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));  in name_or_attr_rule()
7271     p->level--;  in name_or_attr_rule()
7277 group_pattern_rule(Parser *p)  in group_pattern_rule()  argument
7279     if (p->level++ == MAXSTACK) {  in group_pattern_rule()
7280         p->error_indicator = 1;  in group_pattern_rule()
7283     if (p->error_indicator) {  in group_pattern_rule()
7284         p->level--;  in group_pattern_rule()
7288     int _mark = p->mark;  in group_pattern_rule()
7290         if (p->error_indicator) {  in group_pattern_rule()
7291             p->level--;  in group_pattern_rule()
7294 …D(fprintf(stderr, "%*c> group_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' pattern '…  in group_pattern_rule()
7299             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in group_pattern_rule()
7301             (pattern = pattern_rule(p))  // pattern  in group_pattern_rule()
7303             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in group_pattern_rule()
7306 …D(fprintf(stderr, "%*c+ group_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(…  in group_pattern_rule()
7309                 p->error_indicator = 1;  in group_pattern_rule()
7310                 p->level--;  in group_pattern_rule()
7315         p->mark = _mark;  in group_pattern_rule()
7316         D(fprintf(stderr, "%*c%s group_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in group_pattern_rule()
7317                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' pattern ')'"));  in group_pattern_rule()
7321     p->level--;  in group_pattern_rule()
7327 sequence_pattern_rule(Parser *p)  in sequence_pattern_rule()  argument
7329     if (p->level++ == MAXSTACK) {  in sequence_pattern_rule()
7330         p->error_indicator = 1;  in sequence_pattern_rule()
7333     if (p->error_indicator) {  in sequence_pattern_rule()
7334         p->level--;  in sequence_pattern_rule()
7338     int _mark = p->mark;  in sequence_pattern_rule()
7339     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in sequence_pattern_rule()
7340         p->error_indicator = 1;  in sequence_pattern_rule()
7341         p->level--;  in sequence_pattern_rule()
7344     int _start_lineno = p->tokens[_mark]->lineno;  in sequence_pattern_rule()
7346     int _start_col_offset = p->tokens[_mark]->col_offset;  in sequence_pattern_rule()
7349         if (p->error_indicator) {  in sequence_pattern_rule()
7350             p->level--;  in sequence_pattern_rule()
7353 …D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' maybe_…  in sequence_pattern_rule()
7358             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in sequence_pattern_rule()
7360 …       (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator)  // maybe_sequence_pattern?  in sequence_pattern_rule()
7362             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in sequence_pattern_rule()
7365 …D(fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in sequence_pattern_rule()
7366             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in sequence_pattern_rule()
7368                 p->level--;  in sequence_pattern_rule()
7371             int _end_lineno = _token->end_lineno;  in sequence_pattern_rule()
7373             int _end_col_offset = _token->end_col_offset;  in sequence_pattern_rule()
7377                 p->error_indicator = 1;  in sequence_pattern_rule()
7378                 p->level--;  in sequence_pattern_rule()
7383         p->mark = _mark;  in sequence_pattern_rule()
7384         D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in sequence_pattern_rule()
7385 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' maybe_sequence_pattern? ']'"));  in sequence_pattern_rule()
7388         if (p->error_indicator) {  in sequence_pattern_rule()
7389             p->level--;  in sequence_pattern_rule()
7392 …D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' open_s…  in sequence_pattern_rule()
7397             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in sequence_pattern_rule()
7399 …         (patterns = open_sequence_pattern_rule(p), !p->error_indicator)  // open_sequence_pattern?  in sequence_pattern_rule()
7401             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in sequence_pattern_rule()
7404 …D(fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in sequence_pattern_rule()
7405             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in sequence_pattern_rule()
7407                 p->level--;  in sequence_pattern_rule()
7410             int _end_lineno = _token->end_lineno;  in sequence_pattern_rule()
7412             int _end_col_offset = _token->end_col_offset;  in sequence_pattern_rule()
7416                 p->error_indicator = 1;  in sequence_pattern_rule()
7417                 p->level--;  in sequence_pattern_rule()
7422         p->mark = _mark;  in sequence_pattern_rule()
7423         D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in sequence_pattern_rule()
7424 …           p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' open_sequence_pattern? ')'"));  in sequence_pattern_rule()
7428     p->level--;  in sequence_pattern_rule()
7434 open_sequence_pattern_rule(Parser *p)  in open_sequence_pattern_rule()  argument
7436     if (p->level++ == MAXSTACK) {  in open_sequence_pattern_rule()
7437         p->error_indicator = 1;  in open_sequence_pattern_rule()
7440     if (p->error_indicator) {  in open_sequence_pattern_rule()
7441         p->level--;  in open_sequence_pattern_rule()
7445     int _mark = p->mark;  in open_sequence_pattern_rule()
7447         if (p->error_indicator) {  in open_sequence_pattern_rule()
7448             p->level--;  in open_sequence_pattern_rule()
7451 …D(fprintf(stderr, "%*c> open_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe…  in open_sequence_pattern_rule()
7456             (pattern = maybe_star_pattern_rule(p))  // maybe_star_pattern  in open_sequence_pattern_rule()
7458             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in open_sequence_pattern_rule()
7460 …       (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator)  // maybe_sequence_pattern?  in open_sequence_pattern_rule()
7463 …D(fprintf(stderr, "%*c+ open_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in open_sequence_pattern_rule()
7464             _res = _PyPegen_seq_insert_in_front ( p , pattern , patterns );  in open_sequence_pattern_rule()
7466                 p->error_indicator = 1;  in open_sequence_pattern_rule()
7467                 p->level--;  in open_sequence_pattern_rule()
7472         p->mark = _mark;  in open_sequence_pattern_rule()
7473         D(fprintf(stderr, "%*c%s open_sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in open_sequence_pattern_rule()
7474 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_patter…  in open_sequence_pattern_rule()
7478     p->level--;  in open_sequence_pattern_rule()
7484 maybe_sequence_pattern_rule(Parser *p)  in maybe_sequence_pattern_rule()  argument
7486     if (p->level++ == MAXSTACK) {  in maybe_sequence_pattern_rule()
7487         p->error_indicator = 1;  in maybe_sequence_pattern_rule()
7490     if (p->error_indicator) {  in maybe_sequence_pattern_rule()
7491         p->level--;  in maybe_sequence_pattern_rule()
7495     int _mark = p->mark;  in maybe_sequence_pattern_rule()
7497         if (p->error_indicator) {  in maybe_sequence_pattern_rule()
7498             p->level--;  in maybe_sequence_pattern_rule()
7501 …D(fprintf(stderr, "%*c> maybe_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.…  in maybe_sequence_pattern_rule()
7506             (patterns = _gather_57_rule(p))  // ','.maybe_star_pattern+  in maybe_sequence_pattern_rule()
7508             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in maybe_sequence_pattern_rule()
7511 …D(fprintf(stderr, "%*c+ maybe_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->…  in maybe_sequence_pattern_rule()
7514                 p->error_indicator = 1;  in maybe_sequence_pattern_rule()
7515                 p->level--;  in maybe_sequence_pattern_rule()
7520         p->mark = _mark;  in maybe_sequence_pattern_rule()
7521         D(fprintf(stderr, "%*c%s maybe_sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in maybe_sequence_pattern_rule()
7522 …             p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.maybe_star_pattern+ ','?"));  in maybe_sequence_pattern_rule()
7526     p->level--;  in maybe_sequence_pattern_rule()
7532 maybe_star_pattern_rule(Parser *p)  in maybe_star_pattern_rule()  argument
7534     if (p->level++ == MAXSTACK) {  in maybe_star_pattern_rule()
7535         p->error_indicator = 1;  in maybe_star_pattern_rule()
7538     if (p->error_indicator) {  in maybe_star_pattern_rule()
7539         p->level--;  in maybe_star_pattern_rule()
7543     int _mark = p->mark;  in maybe_star_pattern_rule()
7545         if (p->error_indicator) {  in maybe_star_pattern_rule()
7546             p->level--;  in maybe_star_pattern_rule()
7549 …D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_pat…  in maybe_star_pattern_rule()
7552             (star_pattern_var = star_pattern_rule(p))  // star_pattern  in maybe_star_pattern_rule()
7555 …D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in maybe_star_pattern_rule()
7559         p->mark = _mark;  in maybe_star_pattern_rule()
7560         D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in maybe_star_pattern_rule()
7561                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_pattern"));  in maybe_star_pattern_rule()
7564         if (p->error_indicator) {  in maybe_star_pattern_rule()
7565             p->level--;  in maybe_star_pattern_rule()
7568 …D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern"…  in maybe_star_pattern_rule()
7571             (pattern_var = pattern_rule(p))  // pattern  in maybe_star_pattern_rule()
7574 …D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in maybe_star_pattern_rule()
7578         p->mark = _mark;  in maybe_star_pattern_rule()
7579         D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in maybe_star_pattern_rule()
7580                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern"));  in maybe_star_pattern_rule()
7584     p->level--;  in maybe_star_pattern_rule()
7590 star_pattern_rule(Parser *p)  in star_pattern_rule()  argument
7592     if (p->level++ == MAXSTACK) {  in star_pattern_rule()
7593         p->error_indicator = 1;  in star_pattern_rule()
7596     if (p->error_indicator) {  in star_pattern_rule()
7597         p->level--;  in star_pattern_rule()
7601     int _mark = p->mark;  in star_pattern_rule()
7602     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in star_pattern_rule()
7603         p->error_indicator = 1;  in star_pattern_rule()
7604         p->level--;  in star_pattern_rule()
7607     int _start_lineno = p->tokens[_mark]->lineno;  in star_pattern_rule()
7609     int _start_col_offset = p->tokens[_mark]->col_offset;  in star_pattern_rule()
7612         if (p->error_indicator) {  in star_pattern_rule()
7613             p->level--;  in star_pattern_rule()
7616 …D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' pattern_ca…  in star_pattern_rule()
7620             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in star_pattern_rule()
7622             (target = pattern_capture_target_rule(p))  // pattern_capture_target  in star_pattern_rule()
7625 …D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'…  in star_pattern_rule()
7626             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_pattern_rule()
7628                 p->level--;  in star_pattern_rule()
7631             int _end_lineno = _token->end_lineno;  in star_pattern_rule()
7633             int _end_col_offset = _token->end_col_offset;  in star_pattern_rule()
7635             _res = _PyAST_MatchStar ( target -> v . Name . id , EXTRA );  in star_pattern_rule()
7637                 p->error_indicator = 1;  in star_pattern_rule()
7638                 p->level--;  in star_pattern_rule()
7643         p->mark = _mark;  in star_pattern_rule()
7644         D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in star_pattern_rule()
7645 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' pattern_capture_target"));  in star_pattern_rule()
7648         if (p->error_indicator) {  in star_pattern_rule()
7649             p->level--;  in star_pattern_rule()
7652 …D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' wildcard_p…  in star_pattern_rule()
7656             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in star_pattern_rule()
7658             (wildcard_pattern_var = wildcard_pattern_rule(p))  // wildcard_pattern  in star_pattern_rule()
7661 …D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'…  in star_pattern_rule()
7662             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_pattern_rule()
7664                 p->level--;  in star_pattern_rule()
7667             int _end_lineno = _token->end_lineno;  in star_pattern_rule()
7669             int _end_col_offset = _token->end_col_offset;  in star_pattern_rule()
7673                 p->error_indicator = 1;  in star_pattern_rule()
7674                 p->level--;  in star_pattern_rule()
7679         p->mark = _mark;  in star_pattern_rule()
7680         D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in star_pattern_rule()
7681                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' wildcard_pattern"));  in star_pattern_rule()
7685     p->level--;  in star_pattern_rule()
7695 mapping_pattern_rule(Parser *p)  in mapping_pattern_rule()  argument
7697     if (p->level++ == MAXSTACK) {  in mapping_pattern_rule()
7698         p->error_indicator = 1;  in mapping_pattern_rule()
7701     if (p->error_indicator) {  in mapping_pattern_rule()
7702         p->level--;  in mapping_pattern_rule()
7706     int _mark = p->mark;  in mapping_pattern_rule()
7707     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in mapping_pattern_rule()
7708         p->error_indicator = 1;  in mapping_pattern_rule()
7709         p->level--;  in mapping_pattern_rule()
7712     int _start_lineno = p->tokens[_mark]->lineno;  in mapping_pattern_rule()
7714     int _start_col_offset = p->tokens[_mark]->col_offset;  in mapping_pattern_rule()
7717         if (p->error_indicator) {  in mapping_pattern_rule()
7718             p->level--;  in mapping_pattern_rule()
7721 … D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'"));  in mapping_pattern_rule()
7725             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in mapping_pattern_rule()
7727             (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'  in mapping_pattern_rule()
7730 …D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in mapping_pattern_rule()
7731             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in mapping_pattern_rule()
7733                 p->level--;  in mapping_pattern_rule()
7736             int _end_lineno = _token->end_lineno;  in mapping_pattern_rule()
7738             int _end_col_offset = _token->end_col_offset;  in mapping_pattern_rule()
7742                 p->error_indicator = 1;  in mapping_pattern_rule()
7743                 p->level--;  in mapping_pattern_rule()
7748         p->mark = _mark;  in mapping_pattern_rule()
7749         D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in mapping_pattern_rule()
7750                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '}'"));  in mapping_pattern_rule()
7753         if (p->error_indicator) {  in mapping_pattern_rule()
7754             p->level--;  in mapping_pattern_rule()
7757 …D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_…  in mapping_pattern_rule()
7764             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in mapping_pattern_rule()
7766             (rest = double_star_pattern_rule(p))  // double_star_pattern  in mapping_pattern_rule()
7768             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in mapping_pattern_rule()
7770             (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'  in mapping_pattern_rule()
7773 …D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in mapping_pattern_rule()
7774             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in mapping_pattern_rule()
7776                 p->level--;  in mapping_pattern_rule()
7779             int _end_lineno = _token->end_lineno;  in mapping_pattern_rule()
7781             int _end_col_offset = _token->end_col_offset;  in mapping_pattern_rule()
7783             _res = _PyAST_MatchMapping ( NULL , NULL , rest -> v . Name . id , EXTRA );  in mapping_pattern_rule()
7785                 p->error_indicator = 1;  in mapping_pattern_rule()
7786                 p->level--;  in mapping_pattern_rule()
7791         p->mark = _mark;  in mapping_pattern_rule()
7792         D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in mapping_pattern_rule()
7793 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_star_pattern ','? '}'"));  in mapping_pattern_rule()
7796         if (p->error_indicator) {  in mapping_pattern_rule()
7797             p->level--;  in mapping_pattern_rule()
7800 …D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_p…  in mapping_pattern_rule()
7809             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in mapping_pattern_rule()
7811             (items = items_pattern_rule(p))  // items_pattern  in mapping_pattern_rule()
7813             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in mapping_pattern_rule()
7815             (rest = double_star_pattern_rule(p))  // double_star_pattern  in mapping_pattern_rule()
7817             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in mapping_pattern_rule()
7819             (_literal_2 = _PyPegen_expect_token(p, 26))  // token='}'  in mapping_pattern_rule()
7822 …D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in mapping_pattern_rule()
7823             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in mapping_pattern_rule()
7825                 p->level--;  in mapping_pattern_rule()
7828             int _end_lineno = _token->end_lineno;  in mapping_pattern_rule()
7830             int _end_col_offset = _token->end_col_offset;  in mapping_pattern_rule()
7832 … , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq * , _PyPegen_get_patterns …  in mapping_pattern_rule()
7834                 p->error_indicator = 1;  in mapping_pattern_rule()
7835                 p->level--;  in mapping_pattern_rule()
7840         p->mark = _mark;  in mapping_pattern_rule()
7841         D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in mapping_pattern_rule()
7842 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ',' double_star_pattern ',…  in mapping_pattern_rule()
7845         if (p->error_indicator) {  in mapping_pattern_rule()
7846             p->level--;  in mapping_pattern_rule()
7849 …D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_p…  in mapping_pattern_rule()
7856             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in mapping_pattern_rule()
7858             (items = items_pattern_rule(p))  // items_pattern  in mapping_pattern_rule()
7860             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in mapping_pattern_rule()
7862             (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'  in mapping_pattern_rule()
7865 …D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in mapping_pattern_rule()
7866             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in mapping_pattern_rule()
7868                 p->level--;  in mapping_pattern_rule()
7871             int _end_lineno = _token->end_lineno;  in mapping_pattern_rule()
7873             int _end_col_offset = _token->end_col_offset;  in mapping_pattern_rule()
7875 …expr_seq * , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq * , _PyPegen_get…  in mapping_pattern_rule()
7877                 p->error_indicator = 1;  in mapping_pattern_rule()
7878                 p->level--;  in mapping_pattern_rule()
7883         p->mark = _mark;  in mapping_pattern_rule()
7884         D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in mapping_pattern_rule()
7885 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ','? '}'"));  in mapping_pattern_rule()
7889     p->level--;  in mapping_pattern_rule()
7895 items_pattern_rule(Parser *p)  in items_pattern_rule()  argument
7897     if (p->level++ == MAXSTACK) {  in items_pattern_rule()
7898         p->error_indicator = 1;  in items_pattern_rule()
7901     if (p->error_indicator) {  in items_pattern_rule()
7902         p->level--;  in items_pattern_rule()
7906     int _mark = p->mark;  in items_pattern_rule()
7908         if (p->error_indicator) {  in items_pattern_rule()
7909             p->level--;  in items_pattern_rule()
7912 …D(fprintf(stderr, "%*c> items_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.key_value…  in items_pattern_rule()
7915             (_gather_59_var = _gather_59_rule(p))  // ','.key_value_pattern+  in items_pattern_rule()
7918 …D(fprintf(stderr, "%*c+ items_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',…  in items_pattern_rule()
7922         p->mark = _mark;  in items_pattern_rule()
7923         D(fprintf(stderr, "%*c%s items_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in items_pattern_rule()
7924                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.key_value_pattern+"));  in items_pattern_rule()
7928     p->level--;  in items_pattern_rule()
7934 key_value_pattern_rule(Parser *p)  in key_value_pattern_rule()  argument
7936     if (p->level++ == MAXSTACK) {  in key_value_pattern_rule()
7937         p->error_indicator = 1;  in key_value_pattern_rule()
7940     if (p->error_indicator) {  in key_value_pattern_rule()
7941         p->level--;  in key_value_pattern_rule()
7945     int _mark = p->mark;  in key_value_pattern_rule()
7947         if (p->error_indicator) {  in key_value_pattern_rule()
7948             p->level--;  in key_value_pattern_rule()
7951 …D(fprintf(stderr, "%*c> key_value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(literal_…  in key_value_pattern_rule()
7956             (key = _tmp_61_rule(p))  // literal_expr | attr  in key_value_pattern_rule()
7958             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in key_value_pattern_rule()
7960             (pattern = pattern_rule(p))  // pattern  in key_value_pattern_rule()
7963 …D(fprintf(stderr, "%*c+ key_value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in key_value_pattern_rule()
7964             _res = _PyPegen_key_pattern_pair ( p , key , pattern );  in key_value_pattern_rule()
7966                 p->error_indicator = 1;  in key_value_pattern_rule()
7967                 p->level--;  in key_value_pattern_rule()
7972         p->mark = _mark;  in key_value_pattern_rule()
7973         D(fprintf(stderr, "%*c%s key_value_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in key_value_pattern_rule()
7974 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(literal_expr | attr) ':' pattern"));  in key_value_pattern_rule()
7978     p->level--;  in key_value_pattern_rule()
7984 double_star_pattern_rule(Parser *p)  in double_star_pattern_rule()  argument
7986     if (p->level++ == MAXSTACK) {  in double_star_pattern_rule()
7987         p->error_indicator = 1;  in double_star_pattern_rule()
7990     if (p->error_indicator) {  in double_star_pattern_rule()
7991         p->level--;  in double_star_pattern_rule()
7995     int _mark = p->mark;  in double_star_pattern_rule()
7997         if (p->error_indicator) {  in double_star_pattern_rule()
7998             p->level--;  in double_star_pattern_rule()
8001 …D(fprintf(stderr, "%*c> double_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' pa…  in double_star_pattern_rule()
8005             (_literal = _PyPegen_expect_token(p, 35))  // token='**'  in double_star_pattern_rule()
8007             (target = pattern_capture_target_rule(p))  // pattern_capture_target  in double_star_pattern_rule()
8010 …D(fprintf(stderr, "%*c+ double_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in double_star_pattern_rule()
8013                 p->error_indicator = 1;  in double_star_pattern_rule()
8014                 p->level--;  in double_star_pattern_rule()
8019         p->mark = _mark;  in double_star_pattern_rule()
8020         D(fprintf(stderr, "%*c%s double_star_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in double_star_pattern_rule()
8021 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' pattern_capture_target"));  in double_star_pattern_rule()
8025     p->level--;  in double_star_pattern_rule()
8036 class_pattern_rule(Parser *p)  in class_pattern_rule()  argument
8038     if (p->level++ == MAXSTACK) {  in class_pattern_rule()
8039         p->error_indicator = 1;  in class_pattern_rule()
8042     if (p->error_indicator) {  in class_pattern_rule()
8043         p->level--;  in class_pattern_rule()
8047     int _mark = p->mark;  in class_pattern_rule()
8048     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in class_pattern_rule()
8049         p->error_indicator = 1;  in class_pattern_rule()
8050         p->level--;  in class_pattern_rule()
8053     int _start_lineno = p->tokens[_mark]->lineno;  in class_pattern_rule()
8055     int _start_col_offset = p->tokens[_mark]->col_offset;  in class_pattern_rule()
8058         if (p->error_indicator) {  in class_pattern_rule()
8059             p->level--;  in class_pattern_rule()
8062 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr …  in class_pattern_rule()
8067             (cls = name_or_attr_rule(p))  // name_or_attr  in class_pattern_rule()
8069             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in class_pattern_rule()
8071             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in class_pattern_rule()
8074 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "na…  in class_pattern_rule()
8075             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in class_pattern_rule()
8077                 p->level--;  in class_pattern_rule()
8080             int _end_lineno = _token->end_lineno;  in class_pattern_rule()
8082             int _end_col_offset = _token->end_col_offset;  in class_pattern_rule()
8086                 p->error_indicator = 1;  in class_pattern_rule()
8087                 p->level--;  in class_pattern_rule()
8092         p->mark = _mark;  in class_pattern_rule()
8093         D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in class_pattern_rule()
8094                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' ')'"));  in class_pattern_rule()
8097         if (p->error_indicator) {  in class_pattern_rule()
8098             p->level--;  in class_pattern_rule()
8101 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr …  in class_pattern_rule()
8109             (cls = name_or_attr_rule(p))  // name_or_attr  in class_pattern_rule()
8111             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in class_pattern_rule()
8113             (patterns = positional_patterns_rule(p))  // positional_patterns  in class_pattern_rule()
8115             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in class_pattern_rule()
8117             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in class_pattern_rule()
8120 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "na…  in class_pattern_rule()
8121             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in class_pattern_rule()
8123                 p->level--;  in class_pattern_rule()
8126             int _end_lineno = _token->end_lineno;  in class_pattern_rule()
8128             int _end_col_offset = _token->end_col_offset;  in class_pattern_rule()
8132                 p->error_indicator = 1;  in class_pattern_rule()
8133                 p->level--;  in class_pattern_rule()
8138         p->mark = _mark;  in class_pattern_rule()
8139         D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in class_pattern_rule()
8140 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' positional_patterns ','? ')…  in class_pattern_rule()
8143         if (p->error_indicator) {  in class_pattern_rule()
8144             p->level--;  in class_pattern_rule()
8147 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr …  in class_pattern_rule()
8155             (cls = name_or_attr_rule(p))  // name_or_attr  in class_pattern_rule()
8157             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in class_pattern_rule()
8159             (keywords = keyword_patterns_rule(p))  // keyword_patterns  in class_pattern_rule()
8161             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in class_pattern_rule()
8163             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in class_pattern_rule()
8166 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "na…  in class_pattern_rule()
8167             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in class_pattern_rule()
8169                 p->level--;  in class_pattern_rule()
8172             int _end_lineno = _token->end_lineno;  in class_pattern_rule()
8174             int _end_col_offset = _token->end_col_offset;  in class_pattern_rule()
8176 …to_ids ( p , CHECK ( asdl_expr_seq * , _PyPegen_get_pattern_keys ( p , keywords ) ) ) ) , CHECK ( …  in class_pattern_rule()
8178                 p->error_indicator = 1;  in class_pattern_rule()
8179                 p->level--;  in class_pattern_rule()
8184         p->mark = _mark;  in class_pattern_rule()
8185         D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in class_pattern_rule()
8186 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' keyword_patterns ','? ')'")…  in class_pattern_rule()
8189         if (p->error_indicator) {  in class_pattern_rule()
8190             p->level--;  in class_pattern_rule()
8193 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr …  in class_pattern_rule()
8203             (cls = name_or_attr_rule(p))  // name_or_attr  in class_pattern_rule()
8205             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in class_pattern_rule()
8207             (patterns = positional_patterns_rule(p))  // positional_patterns  in class_pattern_rule()
8209             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in class_pattern_rule()
8211             (keywords = keyword_patterns_rule(p))  // keyword_patterns  in class_pattern_rule()
8213             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in class_pattern_rule()
8215             (_literal_2 = _PyPegen_expect_token(p, 8))  // token=')'  in class_pattern_rule()
8218 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "na…  in class_pattern_rule()
8219             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in class_pattern_rule()
8221                 p->level--;  in class_pattern_rule()
8224             int _end_lineno = _token->end_lineno;  in class_pattern_rule()
8226             int _end_col_offset = _token->end_col_offset;  in class_pattern_rule()
8228 …to_ids ( p , CHECK ( asdl_expr_seq * , _PyPegen_get_pattern_keys ( p , keywords ) ) ) ) , CHECK ( …  in class_pattern_rule()
8230                 p->error_indicator = 1;  in class_pattern_rule()
8231                 p->level--;  in class_pattern_rule()
8236         p->mark = _mark;  in class_pattern_rule()
8237         D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in class_pattern_rule()
8238 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' positional_patterns ',' key…  in class_pattern_rule()
8240     if (p->call_invalid_rules) { // invalid_class_pattern  in class_pattern_rule()
8241         if (p->error_indicator) {  in class_pattern_rule()
8242             p->level--;  in class_pattern_rule()
8245 …D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_class…  in class_pattern_rule()
8248             (invalid_class_pattern_var = invalid_class_pattern_rule(p))  // invalid_class_pattern  in class_pattern_rule()
8251 …D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in…  in class_pattern_rule()
8255         p->mark = _mark;  in class_pattern_rule()
8256         D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in class_pattern_rule()
8257                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_class_pattern"));  in class_pattern_rule()
8261     p->level--;  in class_pattern_rule()
8267 positional_patterns_rule(Parser *p)  in positional_patterns_rule()  argument
8269     if (p->level++ == MAXSTACK) {  in positional_patterns_rule()
8270         p->error_indicator = 1;  in positional_patterns_rule()
8273     if (p->error_indicator) {  in positional_patterns_rule()
8274         p->level--;  in positional_patterns_rule()
8278     int _mark = p->mark;  in positional_patterns_rule()
8280         if (p->error_indicator) {  in positional_patterns_rule()
8281             p->level--;  in positional_patterns_rule()
8284 …D(fprintf(stderr, "%*c> positional_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.pat…  in positional_patterns_rule()
8287             (args = (asdl_pattern_seq*)_gather_62_rule(p))  // ','.pattern+  in positional_patterns_rule()
8290 …D(fprintf(stderr, "%*c+ positional_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in positional_patterns_rule()
8293                 p->error_indicator = 1;  in positional_patterns_rule()
8294                 p->level--;  in positional_patterns_rule()
8299         p->mark = _mark;  in positional_patterns_rule()
8300         D(fprintf(stderr, "%*c%s positional_patterns[%d-%d]: %s failed!\n", p->level, ' ',  in positional_patterns_rule()
8301                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.pattern+"));  in positional_patterns_rule()
8305     p->level--;  in positional_patterns_rule()
8311 keyword_patterns_rule(Parser *p)  in keyword_patterns_rule()  argument
8313     if (p->level++ == MAXSTACK) {  in keyword_patterns_rule()
8314         p->error_indicator = 1;  in keyword_patterns_rule()
8317     if (p->error_indicator) {  in keyword_patterns_rule()
8318         p->level--;  in keyword_patterns_rule()
8322     int _mark = p->mark;  in keyword_patterns_rule()
8324         if (p->error_indicator) {  in keyword_patterns_rule()
8325             p->level--;  in keyword_patterns_rule()
8328 …D(fprintf(stderr, "%*c> keyword_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.keywor…  in keyword_patterns_rule()
8331             (_gather_64_var = _gather_64_rule(p))  // ','.keyword_pattern+  in keyword_patterns_rule()
8334 …D(fprintf(stderr, "%*c+ keyword_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in keyword_patterns_rule()
8338         p->mark = _mark;  in keyword_patterns_rule()
8339         D(fprintf(stderr, "%*c%s keyword_patterns[%d-%d]: %s failed!\n", p->level, ' ',  in keyword_patterns_rule()
8340                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.keyword_pattern+"));  in keyword_patterns_rule()
8344     p->level--;  in keyword_patterns_rule()
8350 keyword_pattern_rule(Parser *p)  in keyword_pattern_rule()  argument
8352     if (p->level++ == MAXSTACK) {  in keyword_pattern_rule()
8353         p->error_indicator = 1;  in keyword_pattern_rule()
8356     if (p->error_indicator) {  in keyword_pattern_rule()
8357         p->level--;  in keyword_pattern_rule()
8361     int _mark = p->mark;  in keyword_pattern_rule()
8363         if (p->error_indicator) {  in keyword_pattern_rule()
8364             p->level--;  in keyword_pattern_rule()
8367 …D(fprintf(stderr, "%*c> keyword_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' pa…  in keyword_pattern_rule()
8372             (arg = _PyPegen_name_token(p))  // NAME  in keyword_pattern_rule()
8374             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in keyword_pattern_rule()
8376             (value = pattern_rule(p))  // pattern  in keyword_pattern_rule()
8379 …D(fprintf(stderr, "%*c+ keyword_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in keyword_pattern_rule()
8380             _res = _PyPegen_key_pattern_pair ( p , arg , value );  in keyword_pattern_rule()
8382                 p->error_indicator = 1;  in keyword_pattern_rule()
8383                 p->level--;  in keyword_pattern_rule()
8388         p->mark = _mark;  in keyword_pattern_rule()
8389         D(fprintf(stderr, "%*c%s keyword_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in keyword_pattern_rule()
8390                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' pattern"));  in keyword_pattern_rule()
8394     p->level--;  in keyword_pattern_rule()
8400 return_stmt_rule(Parser *p)  in return_stmt_rule()  argument
8402     if (p->level++ == MAXSTACK) {  in return_stmt_rule()
8403         p->error_indicator = 1;  in return_stmt_rule()
8406     if (p->error_indicator) {  in return_stmt_rule()
8407         p->level--;  in return_stmt_rule()
8411     int _mark = p->mark;  in return_stmt_rule()
8412     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in return_stmt_rule()
8413         p->error_indicator = 1;  in return_stmt_rule()
8414         p->level--;  in return_stmt_rule()
8417     int _start_lineno = p->tokens[_mark]->lineno;  in return_stmt_rule()
8419     int _start_col_offset = p->tokens[_mark]->col_offset;  in return_stmt_rule()
8422         if (p->error_indicator) {  in return_stmt_rule()
8423             p->level--;  in return_stmt_rule()
8426 …D(fprintf(stderr, "%*c> return_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'return' star_e…  in return_stmt_rule()
8430             (_keyword = _PyPegen_expect_token(p, 500))  // token='return'  in return_stmt_rule()
8432             (a = star_expressions_rule(p), !p->error_indicator)  // star_expressions?  in return_stmt_rule()
8435 …D(fprintf(stderr, "%*c+ return_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'ret…  in return_stmt_rule()
8436             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in return_stmt_rule()
8438                 p->level--;  in return_stmt_rule()
8441             int _end_lineno = _token->end_lineno;  in return_stmt_rule()
8443             int _end_col_offset = _token->end_col_offset;  in return_stmt_rule()
8447                 p->error_indicator = 1;  in return_stmt_rule()
8448                 p->level--;  in return_stmt_rule()
8453         p->mark = _mark;  in return_stmt_rule()
8454         D(fprintf(stderr, "%*c%s return_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in return_stmt_rule()
8455 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'return' star_expressions?"));  in return_stmt_rule()
8459     p->level--;  in return_stmt_rule()
8465 raise_stmt_rule(Parser *p)  in raise_stmt_rule()  argument
8467     if (p->level++ == MAXSTACK) {  in raise_stmt_rule()
8468         p->error_indicator = 1;  in raise_stmt_rule()
8471     if (p->error_indicator) {  in raise_stmt_rule()
8472         p->level--;  in raise_stmt_rule()
8476     int _mark = p->mark;  in raise_stmt_rule()
8477     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in raise_stmt_rule()
8478         p->error_indicator = 1;  in raise_stmt_rule()
8479         p->level--;  in raise_stmt_rule()
8482     int _start_lineno = p->tokens[_mark]->lineno;  in raise_stmt_rule()
8484     int _start_col_offset = p->tokens[_mark]->col_offset;  in raise_stmt_rule()
8487         if (p->error_indicator) {  in raise_stmt_rule()
8488             p->level--;  in raise_stmt_rule()
8491 …D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise' expressi…  in raise_stmt_rule()
8496             (_keyword = _PyPegen_expect_token(p, 501))  // token='raise'  in raise_stmt_rule()
8498             (a = expression_rule(p))  // expression  in raise_stmt_rule()
8500             (b = _tmp_66_rule(p), !p->error_indicator)  // ['from' expression]  in raise_stmt_rule()
8503 …D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'rais…  in raise_stmt_rule()
8504             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in raise_stmt_rule()
8506                 p->level--;  in raise_stmt_rule()
8509             int _end_lineno = _token->end_lineno;  in raise_stmt_rule()
8511             int _end_col_offset = _token->end_col_offset;  in raise_stmt_rule()
8515                 p->error_indicator = 1;  in raise_stmt_rule()
8516                 p->level--;  in raise_stmt_rule()
8521         p->mark = _mark;  in raise_stmt_rule()
8522         D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in raise_stmt_rule()
8523 …   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise' expression ['from' expression]"));  in raise_stmt_rule()
8526         if (p->error_indicator) {  in raise_stmt_rule()
8527             p->level--;  in raise_stmt_rule()
8530 …      D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'"));  in raise_stmt_rule()
8533             (_keyword = _PyPegen_expect_token(p, 501))  // token='raise'  in raise_stmt_rule()
8536 …D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'rais…  in raise_stmt_rule()
8537             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in raise_stmt_rule()
8539                 p->level--;  in raise_stmt_rule()
8542             int _end_lineno = _token->end_lineno;  in raise_stmt_rule()
8544             int _end_col_offset = _token->end_col_offset;  in raise_stmt_rule()
8548                 p->error_indicator = 1;  in raise_stmt_rule()
8549                 p->level--;  in raise_stmt_rule()
8554         p->mark = _mark;  in raise_stmt_rule()
8555         D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in raise_stmt_rule()
8556                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise'"));  in raise_stmt_rule()
8560     p->level--;  in raise_stmt_rule()
8566 function_def_rule(Parser *p)  in function_def_rule()  argument
8568     if (p->level++ == MAXSTACK) {  in function_def_rule()
8569         p->error_indicator = 1;  in function_def_rule()
8572     if (p->error_indicator) {  in function_def_rule()
8573         p->level--;  in function_def_rule()
8577     int _mark = p->mark;  in function_def_rule()
8579         if (p->error_indicator) {  in function_def_rule()
8580             p->level--;  in function_def_rule()
8583 …D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators fun…  in function_def_rule()
8587             (d = decorators_rule(p))  // decorators  in function_def_rule()
8589             (f = function_def_raw_rule(p))  // function_def_raw  in function_def_rule()
8592 …D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dec…  in function_def_rule()
8593             _res = _PyPegen_function_def_decorators ( p , d , f );  in function_def_rule()
8595                 p->error_indicator = 1;  in function_def_rule()
8596                 p->level--;  in function_def_rule()
8601         p->mark = _mark;  in function_def_rule()
8602         D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ',  in function_def_rule()
8603 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators function_def_raw"));  in function_def_rule()
8606         if (p->error_indicator) {  in function_def_rule()
8607             p->level--;  in function_def_rule()
8610 …D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "function_def_r…  in function_def_rule()
8613             (function_def_raw_var = function_def_raw_rule(p))  // function_def_raw  in function_def_rule()
8616 …D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fun…  in function_def_rule()
8620         p->mark = _mark;  in function_def_rule()
8621         D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ',  in function_def_rule()
8622                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "function_def_raw"));  in function_def_rule()
8626     p->level--;  in function_def_rule()
8632 //     | 'def' NAME '(' params? ')' ['->' expression] &&':' func_type_comment? block
8633 //     | ASYNC 'def' NAME '(' params? ')' ['->' expression] &&':' func_type_comment? block
8635 function_def_raw_rule(Parser *p)  in function_def_raw_rule()  argument
8637     if (p->level++ == MAXSTACK) {  in function_def_raw_rule()
8638         p->error_indicator = 1;  in function_def_raw_rule()
8641     if (p->error_indicator) {  in function_def_raw_rule()
8642         p->level--;  in function_def_raw_rule()
8646     int _mark = p->mark;  in function_def_raw_rule()
8647     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in function_def_raw_rule()
8648         p->error_indicator = 1;  in function_def_raw_rule()
8649         p->level--;  in function_def_raw_rule()
8652     int _start_lineno = p->tokens[_mark]->lineno;  in function_def_raw_rule()
8654     int _start_col_offset = p->tokens[_mark]->col_offset;  in function_def_raw_rule()
8656     if (p->call_invalid_rules) { // invalid_def_raw  in function_def_raw_rule()
8657         if (p->error_indicator) {  in function_def_raw_rule()
8658             p->level--;  in function_def_raw_rule()
8661 …D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_de…  in function_def_raw_rule()
8664             (invalid_def_raw_var = invalid_def_raw_rule(p))  // invalid_def_raw  in function_def_raw_rule()
8667 …D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in function_def_raw_rule()
8671         p->mark = _mark;  in function_def_raw_rule()
8672         D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',  in function_def_raw_rule()
8673                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_def_raw"));  in function_def_raw_rule()
8675     { // 'def' NAME '(' params? ')' ['->' expression] &&':' func_type_comment? block  in function_def_raw_rule()
8676         if (p->error_indicator) {  in function_def_raw_rule()
8677             p->level--;  in function_def_raw_rule()
8680 …rintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def' NAME '('…  in function_def_raw_rule()
8691             (_keyword = _PyPegen_expect_token(p, 526))  // token='def'  in function_def_raw_rule()
8693             (n = _PyPegen_name_token(p))  // NAME  in function_def_raw_rule()
8695             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in function_def_raw_rule()
8697             (params = params_rule(p), !p->error_indicator)  // params?  in function_def_raw_rule()
8699             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in function_def_raw_rule()
8701             (a = _tmp_67_rule(p), !p->error_indicator)  // ['->' expression]  in function_def_raw_rule()
8703             (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in function_def_raw_rule()
8705             (tc = func_type_comment_rule(p), !p->error_indicator)  // func_type_comment?  in function_def_raw_rule()
8707             (b = block_rule(p))  // block  in function_def_raw_rule()
8710 …stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def' NAM…  in function_def_raw_rule()
8711             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in function_def_raw_rule()
8713                 p->level--;  in function_def_raw_rule()
8716             int _end_lineno = _token->end_lineno;  in function_def_raw_rule()
8718             int _end_col_offset = _token->end_col_offset;  in function_def_raw_rule()
8720 …nDef ( n -> v . Name . id , ( params ) ? params : CHECK ( arguments_ty , _PyPegen_empty_arguments …  in function_def_raw_rule()
8722                 p->error_indicator = 1;  in function_def_raw_rule()
8723                 p->level--;  in function_def_raw_rule()
8728         p->mark = _mark;  in function_def_raw_rule()
8729         D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',  in function_def_raw_rule()
8730 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def' NAME '(' params? ')' ['->' expression]…  in function_def_raw_rule()
8732     { // ASYNC 'def' NAME '(' params? ')' ['->' expression] &&':' func_type_comment? block  in function_def_raw_rule()
8733         if (p->error_indicator) {  in function_def_raw_rule()
8734             p->level--;  in function_def_raw_rule()
8737 …tf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' NAME …  in function_def_raw_rule()
8749             (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'  in function_def_raw_rule()
8751             (_keyword = _PyPegen_expect_token(p, 526))  // token='def'  in function_def_raw_rule()
8753             (n = _PyPegen_name_token(p))  // NAME  in function_def_raw_rule()
8755             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in function_def_raw_rule()
8757             (params = params_rule(p), !p->error_indicator)  // params?  in function_def_raw_rule()
8759             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in function_def_raw_rule()
8761             (a = _tmp_68_rule(p), !p->error_indicator)  // ['->' expression]  in function_def_raw_rule()
8763             (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in function_def_raw_rule()
8765             (tc = func_type_comment_rule(p), !p->error_indicator)  // func_type_comment?  in function_def_raw_rule()
8767             (b = block_rule(p))  // block  in function_def_raw_rule()
8770 …err, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' …  in function_def_raw_rule()
8771             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in function_def_raw_rule()
8773                 p->level--;  in function_def_raw_rule()
8776             int _end_lineno = _token->end_lineno;  in function_def_raw_rule()
8778             int _end_col_offset = _token->end_col_offset;  in function_def_raw_rule()
8780 …nDef ( n -> v . Name . id , ( params ) ? params : CHECK ( arguments_ty , _PyPegen_empty_arguments …  in function_def_raw_rule()
8782                 p->error_indicator = 1;  in function_def_raw_rule()
8783                 p->level--;  in function_def_raw_rule()
8788         p->mark = _mark;  in function_def_raw_rule()
8789         D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',  in function_def_raw_rule()
8790 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'def' NAME '(' params? ')' ['->' expre…  in function_def_raw_rule()
8794     p->level--;  in function_def_raw_rule()
8803 func_type_comment_rule(Parser *p)  in func_type_comment_rule()  argument
8805     if (p->level++ == MAXSTACK) {  in func_type_comment_rule()
8806         p->error_indicator = 1;  in func_type_comment_rule()
8809     if (p->error_indicator) {  in func_type_comment_rule()
8810         p->level--;  in func_type_comment_rule()
8814     int _mark = p->mark;  in func_type_comment_rule()
8816         if (p->error_indicator) {  in func_type_comment_rule()
8817             p->level--;  in func_type_comment_rule()
8820 …D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE T…  in func_type_comment_rule()
8824             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in func_type_comment_rule()
8826             (t = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'  in func_type_comment_rule()
8828             _PyPegen_lookahead(1, _tmp_69_rule, p)  in func_type_comment_rule()
8831 …D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in func_type_comment_rule()
8834                 p->error_indicator = 1;  in func_type_comment_rule()
8835                 p->level--;  in func_type_comment_rule()
8840         p->mark = _mark;  in func_type_comment_rule()
8841         D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',  in func_type_comment_rule()
8842 …   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)"));  in func_type_comment_rule()
8844     if (p->call_invalid_rules) { // invalid_double_type_comments  in func_type_comment_rule()
8845         if (p->error_indicator) {  in func_type_comment_rule()
8846             p->level--;  in func_type_comment_rule()
8849 …D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_d…  in func_type_comment_rule()
8852 …(invalid_double_type_comments_var = invalid_double_type_comments_rule(p))  // invalid_double_type_…  in func_type_comment_rule()
8855 …D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in func_type_comment_rule()
8859         p->mark = _mark;  in func_type_comment_rule()
8860         D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',  in func_type_comment_rule()
8861 …             p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_double_type_comments"));  in func_type_comment_rule()
8864         if (p->error_indicator) {  in func_type_comment_rule()
8865             p->level--;  in func_type_comment_rule()
8868 …D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMM…  in func_type_comment_rule()
8871             (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'  in func_type_comment_rule()
8874 …D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in func_type_comment_rule()
8878         p->mark = _mark;  in func_type_comment_rule()
8879         D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',  in func_type_comment_rule()
8880                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT"));  in func_type_comment_rule()
8884     p->level--;  in func_type_comment_rule()
8890 params_rule(Parser *p)  in params_rule()  argument
8892     if (p->level++ == MAXSTACK) {  in params_rule()
8893         p->error_indicator = 1;  in params_rule()
8896     if (p->error_indicator) {  in params_rule()
8897         p->level--;  in params_rule()
8901     int _mark = p->mark;  in params_rule()
8902     if (p->call_invalid_rules) { // invalid_parameters  in params_rule()
8903         if (p->error_indicator) {  in params_rule()
8904             p->level--;  in params_rule()
8907 …D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_parameters")…  in params_rule()
8910             (invalid_parameters_var = invalid_parameters_rule(p))  // invalid_parameters  in params_rule()
8913 …D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_p…  in params_rule()
8917         p->mark = _mark;  in params_rule()
8918         D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ',  in params_rule()
8919                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_parameters"));  in params_rule()
8922         if (p->error_indicator) {  in params_rule()
8923             p->level--;  in params_rule()
8926         D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "parameters"));  in params_rule()
8929             (parameters_var = parameters_rule(p))  // parameters  in params_rule()
8932 …D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "parameter…  in params_rule()
8936         p->mark = _mark;  in params_rule()
8937         D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ',  in params_rule()
8938                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "parameters"));  in params_rule()
8942     p->level--;  in params_rule()
8953 parameters_rule(Parser *p)  in parameters_rule()  argument
8955     if (p->level++ == MAXSTACK) {  in parameters_rule()
8956         p->error_indicator = 1;  in parameters_rule()
8959     if (p->error_indicator) {  in parameters_rule()
8960         p->level--;  in parameters_rule()
8964     int _mark = p->mark;  in parameters_rule()
8966         if (p->error_indicator) {  in parameters_rule()
8967             p->level--;  in parameters_rule()
8970 …D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default…  in parameters_rule()
8976             (a = slash_no_default_rule(p))  // slash_no_default  in parameters_rule()
8978             (b = (asdl_arg_seq*)_loop0_70_rule(p))  // param_no_default*  in parameters_rule()
8980             (c = _loop0_71_rule(p))  // param_with_default*  in parameters_rule()
8982             (d = star_etc_rule(p), !p->error_indicator)  // star_etc?  in parameters_rule()
8985 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash…  in parameters_rule()
8986             _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );  in parameters_rule()
8988                 p->error_indicator = 1;  in parameters_rule()
8989                 p->level--;  in parameters_rule()
8994         p->mark = _mark;  in parameters_rule()
8995         D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',  in parameters_rule()
8996 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default param_no_default* param_wit…  in parameters_rule()
8999         if (p->error_indicator) {  in parameters_rule()
9000             p->level--;  in parameters_rule()
9003 …D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_defau…  in parameters_rule()
9008             (a = slash_with_default_rule(p))  // slash_with_default  in parameters_rule()
9010             (b = _loop0_72_rule(p))  // param_with_default*  in parameters_rule()
9012             (c = star_etc_rule(p), !p->error_indicator)  // star_etc?  in parameters_rule()
9015 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash…  in parameters_rule()
9016             _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );  in parameters_rule()
9018                 p->error_indicator = 1;  in parameters_rule()
9019                 p->level--;  in parameters_rule()
9024         p->mark = _mark;  in parameters_rule()
9025         D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',  in parameters_rule()
9026 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default param_with_default* star_…  in parameters_rule()
9029         if (p->error_indicator) {  in parameters_rule()
9030             p->level--;  in parameters_rule()
9033 …D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default…  in parameters_rule()
9038             (a = (asdl_arg_seq*)_loop1_73_rule(p))  // param_no_default+  in parameters_rule()
9040             (b = _loop0_74_rule(p))  // param_with_default*  in parameters_rule()
9042             (c = star_etc_rule(p), !p->error_indicator)  // star_etc?  in parameters_rule()
9045 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param…  in parameters_rule()
9046             _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );  in parameters_rule()
9048                 p->error_indicator = 1;  in parameters_rule()
9049                 p->level--;  in parameters_rule()
9054         p->mark = _mark;  in parameters_rule()
9055         D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',  in parameters_rule()
9056 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ param_with_default* star_e…  in parameters_rule()
9059         if (p->error_indicator) {  in parameters_rule()
9060             p->level--;  in parameters_rule()
9063 …D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defau…  in parameters_rule()
9067             (a = _loop1_75_rule(p))  // param_with_default+  in parameters_rule()
9069             (b = star_etc_rule(p), !p->error_indicator)  // star_etc?  in parameters_rule()
9072 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param…  in parameters_rule()
9073             _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );  in parameters_rule()
9075                 p->error_indicator = 1;  in parameters_rule()
9076                 p->level--;  in parameters_rule()
9081         p->mark = _mark;  in parameters_rule()
9082         D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',  in parameters_rule()
9083 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+ star_etc?"));  in parameters_rule()
9086         if (p->error_indicator) {  in parameters_rule()
9087             p->level--;  in parameters_rule()
9090 …     D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_etc"));  in parameters_rule()
9093             (a = star_etc_rule(p))  // star_etc  in parameters_rule()
9096 …D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_…  in parameters_rule()
9097             _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );  in parameters_rule()
9099                 p->error_indicator = 1;  in parameters_rule()
9100                 p->level--;  in parameters_rule()
9105         p->mark = _mark;  in parameters_rule()
9106         D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',  in parameters_rule()
9107                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_etc"));  in parameters_rule()
9111     p->level--;  in parameters_rule()
9117 slash_no_default_rule(Parser *p)  in slash_no_default_rule()  argument
9119     if (p->level++ == MAXSTACK) {  in slash_no_default_rule()
9120         p->error_indicator = 1;  in slash_no_default_rule()
9123     if (p->error_indicator) {  in slash_no_default_rule()
9124         p->level--;  in slash_no_default_rule()
9128     int _mark = p->mark;  in slash_no_default_rule()
9130         if (p->error_indicator) {  in slash_no_default_rule()
9131             p->level--;  in slash_no_default_rule()
9134 …D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_d…  in slash_no_default_rule()
9139             (a = (asdl_arg_seq*)_loop1_76_rule(p))  // param_no_default+  in slash_no_default_rule()
9141             (_literal = _PyPegen_expect_token(p, 17))  // token='/'  in slash_no_default_rule()
9143             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in slash_no_default_rule()
9146 …D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in slash_no_default_rule()
9149                 p->error_indicator = 1;  in slash_no_default_rule()
9150                 p->level--;  in slash_no_default_rule()
9155         p->mark = _mark;  in slash_no_default_rule()
9156         D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',  in slash_no_default_rule()
9157 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' ','"));  in slash_no_default_rule()
9160         if (p->error_indicator) {  in slash_no_default_rule()
9161             p->level--;  in slash_no_default_rule()
9164 …D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_d…  in slash_no_default_rule()
9168             (a = (asdl_arg_seq*)_loop1_77_rule(p))  // param_no_default+  in slash_no_default_rule()
9170             (_literal = _PyPegen_expect_token(p, 17))  // token='/'  in slash_no_default_rule()
9172             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'  in slash_no_default_rule()
9175 …D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in slash_no_default_rule()
9178                 p->error_indicator = 1;  in slash_no_default_rule()
9179                 p->level--;  in slash_no_default_rule()
9184         p->mark = _mark;  in slash_no_default_rule()
9185         D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',  in slash_no_default_rule()
9186 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' &')'"));  in slash_no_default_rule()
9190     p->level--;  in slash_no_default_rule()
9198 slash_with_default_rule(Parser *p)  in slash_with_default_rule()  argument
9200     if (p->level++ == MAXSTACK) {  in slash_with_default_rule()
9201         p->error_indicator = 1;  in slash_with_default_rule()
9204     if (p->error_indicator) {  in slash_with_default_rule()
9205         p->level--;  in slash_with_default_rule()
9209     int _mark = p->mark;  in slash_with_default_rule()
9211         if (p->error_indicator) {  in slash_with_default_rule()
9212             p->level--;  in slash_with_default_rule()
9215 …D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no…  in slash_with_default_rule()
9221             (a = _loop0_78_rule(p))  // param_no_default*  in slash_with_default_rule()
9223             (b = _loop1_79_rule(p))  // param_with_default+  in slash_with_default_rule()
9225             (_literal = _PyPegen_expect_token(p, 17))  // token='/'  in slash_with_default_rule()
9227             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in slash_with_default_rule()
9230 …D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in slash_with_default_rule()
9231             _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq * ) a , b );  in slash_with_default_rule()
9233                 p->error_indicator = 1;  in slash_with_default_rule()
9234                 p->level--;  in slash_with_default_rule()
9239         p->mark = _mark;  in slash_with_default_rule()
9240         D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',  in slash_with_default_rule()
9241 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' ',…  in slash_with_default_rule()
9244         if (p->error_indicator) {  in slash_with_default_rule()
9245             p->level--;  in slash_with_default_rule()
9248 …D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no…  in slash_with_default_rule()
9253             (a = _loop0_80_rule(p))  // param_no_default*  in slash_with_default_rule()
9255             (b = _loop1_81_rule(p))  // param_with_default+  in slash_with_default_rule()
9257             (_literal = _PyPegen_expect_token(p, 17))  // token='/'  in slash_with_default_rule()
9259             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'  in slash_with_default_rule()
9262 …D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in slash_with_default_rule()
9263             _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq * ) a , b );  in slash_with_default_rule()
9265                 p->error_indicator = 1;  in slash_with_default_rule()
9266                 p->level--;  in slash_with_default_rule()
9271         p->mark = _mark;  in slash_with_default_rule()
9272         D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',  in slash_with_default_rule()
9273 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' &'…  in slash_with_default_rule()
9277     p->level--;  in slash_with_default_rule()
9287 star_etc_rule(Parser *p)  in star_etc_rule()  argument
9289     if (p->level++ == MAXSTACK) {  in star_etc_rule()
9290         p->error_indicator = 1;  in star_etc_rule()
9293     if (p->error_indicator) {  in star_etc_rule()
9294         p->level--;  in star_etc_rule()
9298     int _mark = p->mark;  in star_etc_rule()
9300         if (p->error_indicator) {  in star_etc_rule()
9301             p->level--;  in star_etc_rule()
9304 …D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_defau…  in star_etc_rule()
9310             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in star_etc_rule()
9312             (a = param_no_default_rule(p))  // param_no_default  in star_etc_rule()
9314             (b = _loop0_82_rule(p))  // param_maybe_default*  in star_etc_rule()
9316             (c = kwds_rule(p), !p->error_indicator)  // kwds?  in star_etc_rule()
9319 …D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' par…  in star_etc_rule()
9320             _res = _PyPegen_star_etc ( p , a , b , c );  in star_etc_rule()
9322                 p->error_indicator = 1;  in star_etc_rule()
9323                 p->level--;  in star_etc_rule()
9328         p->mark = _mark;  in star_etc_rule()
9329         D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in star_etc_rule()
9330 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default param_maybe_default* kw…  in star_etc_rule()
9333         if (p->error_indicator) {  in star_etc_rule()
9334             p->level--;  in star_etc_rule()
9337 …D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' param_mayb…  in star_etc_rule()
9343             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in star_etc_rule()
9345             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in star_etc_rule()
9347             (b = _loop1_83_rule(p))  // param_maybe_default+  in star_etc_rule()
9349             (c = kwds_rule(p), !p->error_indicator)  // kwds?  in star_etc_rule()
9352 …D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ','…  in star_etc_rule()
9353             _res = _PyPegen_star_etc ( p , NULL , b , c );  in star_etc_rule()
9355                 p->error_indicator = 1;  in star_etc_rule()
9356                 p->level--;  in star_etc_rule()
9361         p->mark = _mark;  in star_etc_rule()
9362         D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in star_etc_rule()
9363 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));  in star_etc_rule()
9366         if (p->error_indicator) {  in star_etc_rule()
9367             p->level--;  in star_etc_rule()
9370         D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwds"));  in star_etc_rule()
9373             (a = kwds_rule(p))  // kwds  in star_etc_rule()
9376 …D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwds"));  in star_etc_rule()
9377             _res = _PyPegen_star_etc ( p , NULL , NULL , a );  in star_etc_rule()
9379                 p->error_indicator = 1;  in star_etc_rule()
9380                 p->level--;  in star_etc_rule()
9385         p->mark = _mark;  in star_etc_rule()
9386         D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in star_etc_rule()
9387                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwds"));  in star_etc_rule()
9389     if (p->call_invalid_rules) { // invalid_star_etc  in star_etc_rule()
9390         if (p->error_indicator) {  in star_etc_rule()
9391             p->level--;  in star_etc_rule()
9394 …D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_star_etc")…  in star_etc_rule()
9397             (invalid_star_etc_var = invalid_star_etc_rule(p))  // invalid_star_etc  in star_etc_rule()
9400 …D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid…  in star_etc_rule()
9404         p->mark = _mark;  in star_etc_rule()
9405         D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in star_etc_rule()
9406                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_star_etc"));  in star_etc_rule()
9410     p->level--;  in star_etc_rule()
9416 kwds_rule(Parser *p)  in kwds_rule()  argument
9418     if (p->level++ == MAXSTACK) {  in kwds_rule()
9419         p->error_indicator = 1;  in kwds_rule()
9422     if (p->error_indicator) {  in kwds_rule()
9423         p->level--;  in kwds_rule()
9427     int _mark = p->mark;  in kwds_rule()
9429         if (p->error_indicator) {  in kwds_rule()
9430             p->level--;  in kwds_rule()
9433 …D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param_no_default"…  in kwds_rule()
9437             (_literal = _PyPegen_expect_token(p, 35))  // token='**'  in kwds_rule()
9439             (a = param_no_default_rule(p))  // param_no_default  in kwds_rule()
9442 …D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param_…  in kwds_rule()
9445                 p->error_indicator = 1;  in kwds_rule()
9446                 p->level--;  in kwds_rule()
9451         p->mark = _mark;  in kwds_rule()
9452         D(fprintf(stderr, "%*c%s kwds[%d-%d]: %s failed!\n", p->level, ' ',  in kwds_rule()
9453                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param_no_default"));  in kwds_rule()
9457     p->level--;  in kwds_rule()
9463 param_no_default_rule(Parser *p)  in param_no_default_rule()  argument
9465     if (p->level++ == MAXSTACK) {  in param_no_default_rule()
9466         p->error_indicator = 1;  in param_no_default_rule()
9469     if (p->error_indicator) {  in param_no_default_rule()
9470         p->level--;  in param_no_default_rule()
9474     int _mark = p->mark;  in param_no_default_rule()
9476         if (p->error_indicator) {  in param_no_default_rule()
9477             p->level--;  in param_no_default_rule()
9480 …D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param ',' …  in param_no_default_rule()
9485             (a = param_rule(p))  // param  in param_no_default_rule()
9487             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in param_no_default_rule()
9489             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in param_no_default_rule()
9492 …D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in param_no_default_rule()
9493             _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );  in param_no_default_rule()
9495                 p->error_indicator = 1;  in param_no_default_rule()
9496                 p->level--;  in param_no_default_rule()
9501         p->mark = _mark;  in param_no_default_rule()
9502         D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ',  in param_no_default_rule()
9503                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param ',' TYPE_COMMENT?"));  in param_no_default_rule()
9506         if (p->error_indicator) {  in param_no_default_rule()
9507             p->level--;  in param_no_default_rule()
9510 …D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param TYPE…  in param_no_default_rule()
9514             (a = param_rule(p))  // param  in param_no_default_rule()
9516             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in param_no_default_rule()
9518             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'  in param_no_default_rule()
9521 …D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in param_no_default_rule()
9522             _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );  in param_no_default_rule()
9524                 p->error_indicator = 1;  in param_no_default_rule()
9525                 p->level--;  in param_no_default_rule()
9530         p->mark = _mark;  in param_no_default_rule()
9531         D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ',  in param_no_default_rule()
9532                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param TYPE_COMMENT? &')'"));  in param_no_default_rule()
9536     p->level--;  in param_no_default_rule()
9542 param_with_default_rule(Parser *p)  in param_with_default_rule()  argument
9544     if (p->level++ == MAXSTACK) {  in param_with_default_rule()
9545         p->error_indicator = 1;  in param_with_default_rule()
9548     if (p->error_indicator) {  in param_with_default_rule()
9549         p->level--;  in param_with_default_rule()
9553     int _mark = p->mark;  in param_with_default_rule()
9555         if (p->error_indicator) {  in param_with_default_rule()
9556             p->level--;  in param_with_default_rule()
9559 …D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param de…  in param_with_default_rule()
9565             (a = param_rule(p))  // param  in param_with_default_rule()
9567             (c = default_rule(p))  // default  in param_with_default_rule()
9569             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in param_with_default_rule()
9571             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in param_with_default_rule()
9574 …D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in param_with_default_rule()
9575             _res = _PyPegen_name_default_pair ( p , a , c , tc );  in param_with_default_rule()
9577                 p->error_indicator = 1;  in param_with_default_rule()
9578                 p->level--;  in param_with_default_rule()
9583         p->mark = _mark;  in param_with_default_rule()
9584         D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ',  in param_with_default_rule()
9585 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default ',' TYPE_COMMENT?"));  in param_with_default_rule()
9588         if (p->error_indicator) {  in param_with_default_rule()
9589             p->level--;  in param_with_default_rule()
9592 …D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param de…  in param_with_default_rule()
9597             (a = param_rule(p))  // param  in param_with_default_rule()
9599             (c = default_rule(p))  // default  in param_with_default_rule()
9601             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in param_with_default_rule()
9603             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'  in param_with_default_rule()
9606 …D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in param_with_default_rule()
9607             _res = _PyPegen_name_default_pair ( p , a , c , tc );  in param_with_default_rule()
9609                 p->error_indicator = 1;  in param_with_default_rule()
9610                 p->level--;  in param_with_default_rule()
9615         p->mark = _mark;  in param_with_default_rule()
9616         D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ',  in param_with_default_rule()
9617 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default TYPE_COMMENT? &')'"));  in param_with_default_rule()
9621     p->level--;  in param_with_default_rule()
9629 param_maybe_default_rule(Parser *p)  in param_maybe_default_rule()  argument
9631     if (p->level++ == MAXSTACK) {  in param_maybe_default_rule()
9632         p->error_indicator = 1;  in param_maybe_default_rule()
9635     if (p->error_indicator) {  in param_maybe_default_rule()
9636         p->level--;  in param_maybe_default_rule()
9640     int _mark = p->mark;  in param_maybe_default_rule()
9642         if (p->error_indicator) {  in param_maybe_default_rule()
9643             p->level--;  in param_maybe_default_rule()
9646 …D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param d…  in param_maybe_default_rule()
9652             (a = param_rule(p))  // param  in param_maybe_default_rule()
9654             (c = default_rule(p), !p->error_indicator)  // default?  in param_maybe_default_rule()
9656             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in param_maybe_default_rule()
9658             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in param_maybe_default_rule()
9661 …D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in param_maybe_default_rule()
9662             _res = _PyPegen_name_default_pair ( p , a , c , tc );  in param_maybe_default_rule()
9664                 p->error_indicator = 1;  in param_maybe_default_rule()
9665                 p->level--;  in param_maybe_default_rule()
9670         p->mark = _mark;  in param_maybe_default_rule()
9671         D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',  in param_maybe_default_rule()
9672 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? ',' TYPE_COMMENT?"));  in param_maybe_default_rule()
9675         if (p->error_indicator) {  in param_maybe_default_rule()
9676             p->level--;  in param_maybe_default_rule()
9679 …D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param d…  in param_maybe_default_rule()
9684             (a = param_rule(p))  // param  in param_maybe_default_rule()
9686             (c = default_rule(p), !p->error_indicator)  // default?  in param_maybe_default_rule()
9688             (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?  in param_maybe_default_rule()
9690             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'  in param_maybe_default_rule()
9693 …D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in param_maybe_default_rule()
9694             _res = _PyPegen_name_default_pair ( p , a , c , tc );  in param_maybe_default_rule()
9696                 p->error_indicator = 1;  in param_maybe_default_rule()
9697                 p->level--;  in param_maybe_default_rule()
9702         p->mark = _mark;  in param_maybe_default_rule()
9703         D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',  in param_maybe_default_rule()
9704 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? TYPE_COMMENT? &')'"));  in param_maybe_default_rule()
9708     p->level--;  in param_maybe_default_rule()
9714 param_rule(Parser *p)  in param_rule()  argument
9716     if (p->level++ == MAXSTACK) {  in param_rule()
9717         p->error_indicator = 1;  in param_rule()
9720     if (p->error_indicator) {  in param_rule()
9721         p->level--;  in param_rule()
9725     int _mark = p->mark;  in param_rule()
9726     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in param_rule()
9727         p->error_indicator = 1;  in param_rule()
9728         p->level--;  in param_rule()
9731     int _start_lineno = p->tokens[_mark]->lineno;  in param_rule()
9733     int _start_col_offset = p->tokens[_mark]->col_offset;  in param_rule()
9736         if (p->error_indicator) {  in param_rule()
9737             p->level--;  in param_rule()
9740 …  D(fprintf(stderr, "%*c> param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));  in param_rule()
9744             (a = _PyPegen_name_token(p))  // NAME  in param_rule()
9746             (b = annotation_rule(p), !p->error_indicator)  // annotation?  in param_rule()
9749 …D(fprintf(stderr, "%*c+ param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME annot…  in param_rule()
9750             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in param_rule()
9752                 p->level--;  in param_rule()
9755             int _end_lineno = _token->end_lineno;  in param_rule()
9757             int _end_col_offset = _token->end_col_offset;  in param_rule()
9759             _res = _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA );  in param_rule()
9761                 p->error_indicator = 1;  in param_rule()
9762                 p->level--;  in param_rule()
9767         p->mark = _mark;  in param_rule()
9768         D(fprintf(stderr, "%*c%s param[%d-%d]: %s failed!\n", p->level, ' ',  in param_rule()
9769                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME annotation?"));  in param_rule()
9773     p->level--;  in param_rule()
9779 annotation_rule(Parser *p)  in annotation_rule()  argument
9781     if (p->level++ == MAXSTACK) {  in annotation_rule()
9782         p->error_indicator = 1;  in annotation_rule()
9785     if (p->error_indicator) {  in annotation_rule()
9786         p->level--;  in annotation_rule()
9790     int _mark = p->mark;  in annotation_rule()
9792         if (p->error_indicator) {  in annotation_rule()
9793             p->level--;  in annotation_rule()
9796 …D(fprintf(stderr, "%*c> annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression")…  in annotation_rule()
9800             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in annotation_rule()
9802             (a = expression_rule(p))  // expression  in annotation_rule()
9805 …D(fprintf(stderr, "%*c+ annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' e…  in annotation_rule()
9808                 p->error_indicator = 1;  in annotation_rule()
9809                 p->level--;  in annotation_rule()
9814         p->mark = _mark;  in annotation_rule()
9815         D(fprintf(stderr, "%*c%s annotation[%d-%d]: %s failed!\n", p->level, ' ',  in annotation_rule()
9816                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression"));  in annotation_rule()
9820     p->level--;  in annotation_rule()
9826 default_rule(Parser *p)  in default_rule()  argument
9828     if (p->level++ == MAXSTACK) {  in default_rule()
9829         p->error_indicator = 1;  in default_rule()
9832     if (p->error_indicator) {  in default_rule()
9833         p->level--;  in default_rule()
9837     int _mark = p->mark;  in default_rule()
9839         if (p->error_indicator) {  in default_rule()
9840             p->level--;  in default_rule()
9843 …  D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' expression"));  in default_rule()
9847             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in default_rule()
9849             (a = expression_rule(p))  // expression  in default_rule()
9852 …D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' expr…  in default_rule()
9855                 p->error_indicator = 1;  in default_rule()
9856                 p->level--;  in default_rule()
9861         p->mark = _mark;  in default_rule()
9862         D(fprintf(stderr, "%*c%s default[%d-%d]: %s failed!\n", p->level, ' ',  in default_rule()
9863                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' expression"));  in default_rule()
9867     p->level--;  in default_rule()
9873 decorators_rule(Parser *p)  in decorators_rule()  argument
9875     if (p->level++ == MAXSTACK) {  in decorators_rule()
9876         p->error_indicator = 1;  in decorators_rule()
9879     if (p->error_indicator) {  in decorators_rule()
9880         p->level--;  in decorators_rule()
9884     int _mark = p->mark;  in decorators_rule()
9886         if (p->error_indicator) {  in decorators_rule()
9887             p->level--;  in decorators_rule()
9890 …D(fprintf(stderr, "%*c> decorators[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(('@' named_expr…  in decorators_rule()
9893             (a = (asdl_expr_seq*)_loop1_84_rule(p))  // (('@' named_expression NEWLINE))+  in decorators_rule()
9896 …D(fprintf(stderr, "%*c+ decorators[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(('@'…  in decorators_rule()
9899                 p->error_indicator = 1;  in decorators_rule()
9900                 p->level--;  in decorators_rule()
9905         p->mark = _mark;  in decorators_rule()
9906         D(fprintf(stderr, "%*c%s decorators[%d-%d]: %s failed!\n", p->level, ' ',  in decorators_rule()
9907 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(('@' named_expression NEWLINE))+"));  in decorators_rule()
9911     p->level--;  in decorators_rule()
9917 class_def_rule(Parser *p)  in class_def_rule()  argument
9919     if (p->level++ == MAXSTACK) {  in class_def_rule()
9920         p->error_indicator = 1;  in class_def_rule()
9923     if (p->error_indicator) {  in class_def_rule()
9924         p->level--;  in class_def_rule()
9928     int _mark = p->mark;  in class_def_rule()
9930         if (p->error_indicator) {  in class_def_rule()
9931             p->level--;  in class_def_rule()
9934 …D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators class_…  in class_def_rule()
9938             (a = decorators_rule(p))  // decorators  in class_def_rule()
9940             (b = class_def_raw_rule(p))  // class_def_raw  in class_def_rule()
9943 …D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decora…  in class_def_rule()
9944             _res = _PyPegen_class_def_decorators ( p , a , b );  in class_def_rule()
9946                 p->error_indicator = 1;  in class_def_rule()
9947                 p->level--;  in class_def_rule()
9952         p->mark = _mark;  in class_def_rule()
9953         D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ',  in class_def_rule()
9954                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators class_def_raw"));  in class_def_rule()
9957         if (p->error_indicator) {  in class_def_rule()
9958             p->level--;  in class_def_rule()
9961 … D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_def_raw"));  in class_def_rule()
9964             (class_def_raw_var = class_def_raw_rule(p))  // class_def_raw  in class_def_rule()
9967 …D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_…  in class_def_rule()
9971         p->mark = _mark;  in class_def_rule()
9972         D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ',  in class_def_rule()
9973                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_def_raw"));  in class_def_rule()
9977     p->level--;  in class_def_rule()
9983 class_def_raw_rule(Parser *p)  in class_def_raw_rule()  argument
9985     if (p->level++ == MAXSTACK) {  in class_def_raw_rule()
9986         p->error_indicator = 1;  in class_def_raw_rule()
9989     if (p->error_indicator) {  in class_def_raw_rule()
9990         p->level--;  in class_def_raw_rule()
9994     int _mark = p->mark;  in class_def_raw_rule()
9995     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in class_def_raw_rule()
9996         p->error_indicator = 1;  in class_def_raw_rule()
9997         p->level--;  in class_def_raw_rule()
10000     int _start_lineno = p->tokens[_mark]->lineno;  in class_def_raw_rule()
10002     int _start_col_offset = p->tokens[_mark]->col_offset;  in class_def_raw_rule()
10004     if (p->call_invalid_rules) { // invalid_class_def_raw  in class_def_raw_rule()
10005         if (p->error_indicator) {  in class_def_raw_rule()
10006             p->level--;  in class_def_raw_rule()
10009 …D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_class…  in class_def_raw_rule()
10012             (invalid_class_def_raw_var = invalid_class_def_raw_rule(p))  // invalid_class_def_raw  in class_def_raw_rule()
10015 …D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in…  in class_def_raw_rule()
10019         p->mark = _mark;  in class_def_raw_rule()
10020         D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ',  in class_def_raw_rule()
10021                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_class_def_raw"));  in class_def_raw_rule()
10024         if (p->error_indicator) {  in class_def_raw_rule()
10025             p->level--;  in class_def_raw_rule()
10028 …D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME …  in class_def_raw_rule()
10035             (_keyword = _PyPegen_expect_token(p, 527))  // token='class'  in class_def_raw_rule()
10037             (a = _PyPegen_name_token(p))  // NAME  in class_def_raw_rule()
10039             (b = _tmp_85_rule(p), !p->error_indicator)  // ['(' arguments? ')']  in class_def_raw_rule()
10041             (_literal = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in class_def_raw_rule()
10043             (c = block_rule(p))  // block  in class_def_raw_rule()
10046 …D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'c…  in class_def_raw_rule()
10047             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in class_def_raw_rule()
10049                 p->level--;  in class_def_raw_rule()
10052             int _end_lineno = _token->end_lineno;  in class_def_raw_rule()
10054             int _end_col_offset = _token->end_col_offset;  in class_def_raw_rule()
10056 …res = _PyAST_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL ,…  in class_def_raw_rule()
10058                 p->error_indicator = 1;  in class_def_raw_rule()
10059                 p->level--;  in class_def_raw_rule()
10064         p->mark = _mark;  in class_def_raw_rule()
10065         D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ',  in class_def_raw_rule()
10066 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] &&':' bloc…  in class_def_raw_rule()
10070     p->level--;  in class_def_raw_rule()
10076 block_rule(Parser *p)  in block_rule()  argument
10078     if (p->level++ == MAXSTACK) {  in block_rule()
10079         p->error_indicator = 1;  in block_rule()
10082     if (p->error_indicator) {  in block_rule()
10083         p->level--;  in block_rule()
10087     if (_PyPegen_is_memoized(p, block_type, &_res)) {  in block_rule()
10088         p->level--;  in block_rule()
10091     int _mark = p->mark;  in block_rule()
10093         if (p->error_indicator) {  in block_rule()
10094             p->level--;  in block_rule()
10097 …D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statem…  in block_rule()
10103             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in block_rule()
10105             (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT'  in block_rule()
10107             (a = statements_rule(p))  // statements  in block_rule()
10109             (dedent_var = _PyPegen_expect_token(p, DEDENT))  // token='DEDENT'  in block_rule()
10112 …D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE IN…  in block_rule()
10115                 p->error_indicator = 1;  in block_rule()
10116                 p->level--;  in block_rule()
10121         p->mark = _mark;  in block_rule()
10122         D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',  in block_rule()
10123 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT statements DEDENT"));  in block_rule()
10126         if (p->error_indicator) {  in block_rule()
10127             p->level--;  in block_rule()
10130 …      D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts"));  in block_rule()
10133             (simple_stmts_var = simple_stmts_rule(p))  // simple_stmts  in block_rule()
10136 …D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stm…  in block_rule()
10140         p->mark = _mark;  in block_rule()
10141         D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',  in block_rule()
10142                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts"));  in block_rule()
10144     if (p->call_invalid_rules) { // invalid_block  in block_rule()
10145         if (p->error_indicator) {  in block_rule()
10146             p->level--;  in block_rule()
10149 …     D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_block"));  in block_rule()
10152             (invalid_block_var = invalid_block_rule(p))  // invalid_block  in block_rule()
10155 …D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_bl…  in block_rule()
10159         p->mark = _mark;  in block_rule()
10160         D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',  in block_rule()
10161                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_block"));  in block_rule()
10165     _PyPegen_insert_memo(p, _mark, block_type, _res);  in block_rule()
10166     p->level--;  in block_rule()
10175 star_expressions_rule(Parser *p)  in star_expressions_rule()  argument
10177     if (p->level++ == MAXSTACK) {  in star_expressions_rule()
10178         p->error_indicator = 1;  in star_expressions_rule()
10181     if (p->error_indicator) {  in star_expressions_rule()
10182         p->level--;  in star_expressions_rule()
10186     int _mark = p->mark;  in star_expressions_rule()
10187     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in star_expressions_rule()
10188         p->error_indicator = 1;  in star_expressions_rule()
10189         p->level--;  in star_expressions_rule()
10192     int _start_lineno = p->tokens[_mark]->lineno;  in star_expressions_rule()
10194     int _start_col_offset = p->tokens[_mark]->col_offset;  in star_expressions_rule()
10197         if (p->error_indicator) {  in star_expressions_rule()
10198             p->level--;  in star_expressions_rule()
10201 …D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expre…  in star_expressions_rule()
10207             (a = star_expression_rule(p))  // star_expression  in star_expressions_rule()
10209             (b = _loop1_86_rule(p))  // ((',' star_expression))+  in star_expressions_rule()
10211             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in star_expressions_rule()
10214 …D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in star_expressions_rule()
10215             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_expressions_rule()
10217                 p->level--;  in star_expressions_rule()
10220             int _end_lineno = _token->end_lineno;  in star_expressions_rule()
10222             int _end_col_offset = _token->end_col_offset;  in star_expressions_rule()
10224 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq * , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Loa…  in star_expressions_rule()
10226                 p->error_indicator = 1;  in star_expressions_rule()
10227                 p->level--;  in star_expressions_rule()
10232         p->mark = _mark;  in star_expressions_rule()
10233         D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in star_expressions_rule()
10234 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ((',' star_expression))+ ','…  in star_expressions_rule()
10237         if (p->error_indicator) {  in star_expressions_rule()
10238             p->level--;  in star_expressions_rule()
10241 …D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expre…  in star_expressions_rule()
10245             (a = star_expression_rule(p))  // star_expression  in star_expressions_rule()
10247             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in star_expressions_rule()
10250 …D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in star_expressions_rule()
10251             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_expressions_rule()
10253                 p->level--;  in star_expressions_rule()
10256             int _end_lineno = _token->end_lineno;  in star_expressions_rule()
10258             int _end_col_offset = _token->end_col_offset;  in star_expressions_rule()
10260 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq * , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA …  in star_expressions_rule()
10262                 p->error_indicator = 1;  in star_expressions_rule()
10263                 p->level--;  in star_expressions_rule()
10268         p->mark = _mark;  in star_expressions_rule()
10269         D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in star_expressions_rule()
10270                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ','"));  in star_expressions_rule()
10273         if (p->error_indicator) {  in star_expressions_rule()
10274             p->level--;  in star_expressions_rule()
10277 …D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expre…  in star_expressions_rule()
10280             (star_expression_var = star_expression_rule(p))  // star_expression  in star_expressions_rule()
10283 …D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in star_expressions_rule()
10287         p->mark = _mark;  in star_expressions_rule()
10288         D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in star_expressions_rule()
10289                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression"));  in star_expressions_rule()
10293     p->level--;  in star_expressions_rule()
10299 star_expression_rule(Parser *p)  in star_expression_rule()  argument
10301     if (p->level++ == MAXSTACK) {  in star_expression_rule()
10302         p->error_indicator = 1;  in star_expression_rule()
10305     if (p->error_indicator) {  in star_expression_rule()
10306         p->level--;  in star_expression_rule()
10310     if (_PyPegen_is_memoized(p, star_expression_type, &_res)) {  in star_expression_rule()
10311         p->level--;  in star_expression_rule()
10314     int _mark = p->mark;  in star_expression_rule()
10315     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in star_expression_rule()
10316         p->error_indicator = 1;  in star_expression_rule()
10317         p->level--;  in star_expression_rule()
10320     int _start_lineno = p->tokens[_mark]->lineno;  in star_expression_rule()
10322     int _start_col_offset = p->tokens[_mark]->col_offset;  in star_expression_rule()
10325         if (p->error_indicator) {  in star_expression_rule()
10326             p->level--;  in star_expression_rule()
10329 …D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise…  in star_expression_rule()
10333             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in star_expression_rule()
10335             (a = bitwise_or_rule(p))  // bitwise_or  in star_expression_rule()
10338 …D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in star_expression_rule()
10339             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_expression_rule()
10341                 p->level--;  in star_expression_rule()
10344             int _end_lineno = _token->end_lineno;  in star_expression_rule()
10346             int _end_col_offset = _token->end_col_offset;  in star_expression_rule()
10350                 p->error_indicator = 1;  in star_expression_rule()
10351                 p->level--;  in star_expression_rule()
10356         p->mark = _mark;  in star_expression_rule()
10357         D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ',  in star_expression_rule()
10358                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or"));  in star_expression_rule()
10361         if (p->error_indicator) {  in star_expression_rule()
10362             p->level--;  in star_expression_rule()
10365 …D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"…  in star_expression_rule()
10368             (expression_var = expression_rule(p))  // expression  in star_expression_rule()
10371 …D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in star_expression_rule()
10375         p->mark = _mark;  in star_expression_rule()
10376         D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ',  in star_expression_rule()
10377                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));  in star_expression_rule()
10381     _PyPegen_insert_memo(p, _mark, star_expression_type, _res);  in star_expression_rule()
10382     p->level--;  in star_expression_rule()
10388 star_named_expressions_rule(Parser *p)  in star_named_expressions_rule()  argument
10390     if (p->level++ == MAXSTACK) {  in star_named_expressions_rule()
10391         p->error_indicator = 1;  in star_named_expressions_rule()
10394     if (p->error_indicator) {  in star_named_expressions_rule()
10395         p->level--;  in star_named_expressions_rule()
10399     int _mark = p->mark;  in star_named_expressions_rule()
10401         if (p->error_indicator) {  in star_named_expressions_rule()
10402             p->level--;  in star_named_expressions_rule()
10405 …D(fprintf(stderr, "%*c> star_named_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.…  in star_named_expressions_rule()
10410             (a = (asdl_expr_seq*)_gather_87_rule(p))  // ','.star_named_expression+  in star_named_expressions_rule()
10412             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in star_named_expressions_rule()
10415 …D(fprintf(stderr, "%*c+ star_named_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->…  in star_named_expressions_rule()
10418                 p->error_indicator = 1;  in star_named_expressions_rule()
10419                 p->level--;  in star_named_expressions_rule()
10424         p->mark = _mark;  in star_named_expressions_rule()
10425         D(fprintf(stderr, "%*c%s star_named_expressions[%d-%d]: %s failed!\n", p->level, ' ',  in star_named_expressions_rule()
10426 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_named_expression+ ','?"));  in star_named_expressions_rule()
10430     p->level--;  in star_named_expressions_rule()
10436 star_named_expression_rule(Parser *p)  in star_named_expression_rule()  argument
10438     if (p->level++ == MAXSTACK) {  in star_named_expression_rule()
10439         p->error_indicator = 1;  in star_named_expression_rule()
10442     if (p->error_indicator) {  in star_named_expression_rule()
10443         p->level--;  in star_named_expression_rule()
10447     int _mark = p->mark;  in star_named_expression_rule()
10448     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in star_named_expression_rule()
10449         p->error_indicator = 1;  in star_named_expression_rule()
10450         p->level--;  in star_named_expression_rule()
10453     int _start_lineno = p->tokens[_mark]->lineno;  in star_named_expression_rule()
10455     int _start_col_offset = p->tokens[_mark]->col_offset;  in star_named_expression_rule()
10458         if (p->error_indicator) {  in star_named_expression_rule()
10459             p->level--;  in star_named_expression_rule()
10462 …D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' b…  in star_named_expression_rule()
10466             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in star_named_expression_rule()
10468             (a = bitwise_or_rule(p))  // bitwise_or  in star_named_expression_rule()
10471 …D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in star_named_expression_rule()
10472             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_named_expression_rule()
10474                 p->level--;  in star_named_expression_rule()
10477             int _end_lineno = _token->end_lineno;  in star_named_expression_rule()
10479             int _end_col_offset = _token->end_col_offset;  in star_named_expression_rule()
10483                 p->error_indicator = 1;  in star_named_expression_rule()
10484                 p->level--;  in star_named_expression_rule()
10489         p->mark = _mark;  in star_named_expression_rule()
10490         D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ',  in star_named_expression_rule()
10491                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or"));  in star_named_expression_rule()
10494         if (p->error_indicator) {  in star_named_expression_rule()
10495             p->level--;  in star_named_expression_rule()
10498 …D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named…  in star_named_expression_rule()
10501             (named_expression_var = named_expression_rule(p))  // named_expression  in star_named_expression_rule()
10504 …D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in star_named_expression_rule()
10508         p->mark = _mark;  in star_named_expression_rule()
10509         D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ',  in star_named_expression_rule()
10510                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));  in star_named_expression_rule()
10514     p->level--;  in star_named_expression_rule()
10520 assignment_expression_rule(Parser *p)  in assignment_expression_rule()  argument
10522     if (p->level++ == MAXSTACK) {  in assignment_expression_rule()
10523         p->error_indicator = 1;  in assignment_expression_rule()
10526     if (p->error_indicator) {  in assignment_expression_rule()
10527         p->level--;  in assignment_expression_rule()
10531     int _mark = p->mark;  in assignment_expression_rule()
10532     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in assignment_expression_rule()
10533         p->error_indicator = 1;  in assignment_expression_rule()
10534         p->level--;  in assignment_expression_rule()
10537     int _start_lineno = p->tokens[_mark]->lineno;  in assignment_expression_rule()
10539     int _start_col_offset = p->tokens[_mark]->col_offset;  in assignment_expression_rule()
10542         if (p->error_indicator) {  in assignment_expression_rule()
10543             p->level--;  in assignment_expression_rule()
10546 …D(fprintf(stderr, "%*c> assignment_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME …  in assignment_expression_rule()
10552             (a = _PyPegen_name_token(p))  // NAME  in assignment_expression_rule()
10554             (_literal = _PyPegen_expect_token(p, 53))  // token=':='  in assignment_expression_rule()
10558             (b = expression_rule(p))  // expression  in assignment_expression_rule()
10561 …D(fprintf(stderr, "%*c+ assignment_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in assignment_expression_rule()
10562             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in assignment_expression_rule()
10564                 p->level--;  in assignment_expression_rule()
10567             int _end_lineno = _token->end_lineno;  in assignment_expression_rule()
10569             int _end_col_offset = _token->end_col_offset;  in assignment_expression_rule()
10571 …_res = _PyAST_NamedExpr ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b , EX…  in assignment_expression_rule()
10573                 p->error_indicator = 1;  in assignment_expression_rule()
10574                 p->level--;  in assignment_expression_rule()
10579         p->mark = _mark;  in assignment_expression_rule()
10580         D(fprintf(stderr, "%*c%s assignment_expression[%d-%d]: %s failed!\n", p->level, ' ',  in assignment_expression_rule()
10581                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':=' ~ expression"));  in assignment_expression_rule()
10583             p->level--;  in assignment_expression_rule()
10589     p->level--;  in assignment_expression_rule()
10595 named_expression_rule(Parser *p)  in named_expression_rule()  argument
10597     if (p->level++ == MAXSTACK) {  in named_expression_rule()
10598         p->error_indicator = 1;  in named_expression_rule()
10601     if (p->error_indicator) {  in named_expression_rule()
10602         p->level--;  in named_expression_rule()
10606     int _mark = p->mark;  in named_expression_rule()
10608         if (p->error_indicator) {  in named_expression_rule()
10609             p->level--;  in named_expression_rule()
10612 …D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment…  in named_expression_rule()
10615             (assignment_expression_var = assignment_expression_rule(p))  // assignment_expression  in named_expression_rule()
10618 …D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in named_expression_rule()
10622         p->mark = _mark;  in named_expression_rule()
10623         D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',  in named_expression_rule()
10624                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));  in named_expression_rule()
10626     if (p->call_invalid_rules) { // invalid_named_expression  in named_expression_rule()
10627         if (p->error_indicator) {  in named_expression_rule()
10628             p->level--;  in named_expression_rule()
10631 …D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_na…  in named_expression_rule()
10634 …     (invalid_named_expression_var = invalid_named_expression_rule(p))  // invalid_named_expression  in named_expression_rule()
10637 …D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in named_expression_rule()
10641         p->mark = _mark;  in named_expression_rule()
10642         D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',  in named_expression_rule()
10643                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_named_expression"));  in named_expression_rule()
10646         if (p->error_indicator) {  in named_expression_rule()
10647             p->level--;  in named_expression_rule()
10650 …D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression…  in named_expression_rule()
10653             (expression_var = expression_rule(p))  // expression  in named_expression_rule()
10655             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)  // token=':='  in named_expression_rule()
10658 …D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in named_expression_rule()
10662         p->mark = _mark;  in named_expression_rule()
10663         D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',  in named_expression_rule()
10664                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='"));  in named_expression_rule()
10668     p->level--;  in named_expression_rule()
10674 annotated_rhs_rule(Parser *p)  in annotated_rhs_rule()  argument
10676     if (p->level++ == MAXSTACK) {  in annotated_rhs_rule()
10677         p->error_indicator = 1;  in annotated_rhs_rule()
10680     if (p->error_indicator) {  in annotated_rhs_rule()
10681         p->level--;  in annotated_rhs_rule()
10685     int _mark = p->mark;  in annotated_rhs_rule()
10687         if (p->error_indicator) {  in annotated_rhs_rule()
10688             p->level--;  in annotated_rhs_rule()
10691 …D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));  in annotated_rhs_rule()
10694             (yield_expr_var = yield_expr_rule(p))  // yield_expr  in annotated_rhs_rule()
10697 …D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yi…  in annotated_rhs_rule()
10701         p->mark = _mark;  in annotated_rhs_rule()
10702         D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ',  in annotated_rhs_rule()
10703                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));  in annotated_rhs_rule()
10706         if (p->error_indicator) {  in annotated_rhs_rule()
10707             p->level--;  in annotated_rhs_rule()
10710 …D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressi…  in annotated_rhs_rule()
10713             (star_expressions_var = star_expressions_rule(p))  // star_expressions  in annotated_rhs_rule()
10716 …D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "st…  in annotated_rhs_rule()
10720         p->mark = _mark;  in annotated_rhs_rule()
10721         D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ',  in annotated_rhs_rule()
10722                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));  in annotated_rhs_rule()
10726     p->level--;  in annotated_rhs_rule()
10732 expressions_rule(Parser *p)  in expressions_rule()  argument
10734     if (p->level++ == MAXSTACK) {  in expressions_rule()
10735         p->error_indicator = 1;  in expressions_rule()
10738     if (p->error_indicator) {  in expressions_rule()
10739         p->level--;  in expressions_rule()
10743     int _mark = p->mark;  in expressions_rule()
10744     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in expressions_rule()
10745         p->error_indicator = 1;  in expressions_rule()
10746         p->level--;  in expressions_rule()
10749     int _start_lineno = p->tokens[_mark]->lineno;  in expressions_rule()
10751     int _start_col_offset = p->tokens[_mark]->col_offset;  in expressions_rule()
10754         if (p->error_indicator) {  in expressions_rule()
10755             p->level--;  in expressions_rule()
10758 …D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ((',…  in expressions_rule()
10764             (a = expression_rule(p))  // expression  in expressions_rule()
10766             (b = _loop1_89_rule(p))  // ((',' expression))+  in expressions_rule()
10768             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in expressions_rule()
10771 …D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr…  in expressions_rule()
10772             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in expressions_rule()
10774                 p->level--;  in expressions_rule()
10777             int _end_lineno = _token->end_lineno;  in expressions_rule()
10779             int _end_col_offset = _token->end_col_offset;  in expressions_rule()
10781 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq * , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Loa…  in expressions_rule()
10783                 p->error_indicator = 1;  in expressions_rule()
10784                 p->level--;  in expressions_rule()
10789         p->mark = _mark;  in expressions_rule()
10790         D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ',  in expressions_rule()
10791 …      p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ((',' expression))+ ','?"));  in expressions_rule()
10794         if (p->error_indicator) {  in expressions_rule()
10795             p->level--;  in expressions_rule()
10798 …D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ','"…  in expressions_rule()
10802             (a = expression_rule(p))  // expression  in expressions_rule()
10804             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in expressions_rule()
10807 …D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr…  in expressions_rule()
10808             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in expressions_rule()
10810                 p->level--;  in expressions_rule()
10813             int _end_lineno = _token->end_lineno;  in expressions_rule()
10815             int _end_col_offset = _token->end_col_offset;  in expressions_rule()
10817 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq * , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA …  in expressions_rule()
10819                 p->error_indicator = 1;  in expressions_rule()
10820                 p->level--;  in expressions_rule()
10825         p->mark = _mark;  in expressions_rule()
10826         D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ',  in expressions_rule()
10827                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ','"));  in expressions_rule()
10830         if (p->error_indicator) {  in expressions_rule()
10831             p->level--;  in expressions_rule()
10834 …  D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));  in expressions_rule()
10837             (expression_var = expression_rule(p))  // expression  in expressions_rule()
10840 …D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expr…  in expressions_rule()
10844         p->mark = _mark;  in expressions_rule()
10845         D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ',  in expressions_rule()
10846                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));  in expressions_rule()
10850     p->level--;  in expressions_rule()
10861 expression_rule(Parser *p)  in expression_rule()  argument
10863     if (p->level++ == MAXSTACK) {  in expression_rule()
10864         p->error_indicator = 1;  in expression_rule()
10867     if (p->error_indicator) {  in expression_rule()
10868         p->level--;  in expression_rule()
10872     if (_PyPegen_is_memoized(p, expression_type, &_res)) {  in expression_rule()
10873         p->level--;  in expression_rule()
10876     int _mark = p->mark;  in expression_rule()
10877     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in expression_rule()
10878         p->error_indicator = 1;  in expression_rule()
10879         p->level--;  in expression_rule()
10882     int _start_lineno = p->tokens[_mark]->lineno;  in expression_rule()
10884     int _start_col_offset = p->tokens[_mark]->col_offset;  in expression_rule()
10886     if (p->call_invalid_rules) { // invalid_expression  in expression_rule()
10887         if (p->error_indicator) {  in expression_rule()
10888             p->level--;  in expression_rule()
10891 …D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_expressi…  in expression_rule()
10894             (invalid_expression_var = invalid_expression_rule(p))  // invalid_expression  in expression_rule()
10897 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval…  in expression_rule()
10901         p->mark = _mark;  in expression_rule()
10902         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',  in expression_rule()
10903                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_expression"));  in expression_rule()
10905     if (p->call_invalid_rules) { // invalid_legacy_expression  in expression_rule()
10906         if (p->error_indicator) {  in expression_rule()
10907             p->level--;  in expression_rule()
10910 …D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_legacy_e…  in expression_rule()
10913 …  (invalid_legacy_expression_var = invalid_legacy_expression_rule(p))  // invalid_legacy_expression  in expression_rule()
10916 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inval…  in expression_rule()
10920         p->mark = _mark;  in expression_rule()
10921         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',  in expression_rule()
10922 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_legacy_expression"));  in expression_rule()
10925         if (p->error_indicator) {  in expression_rule()
10926             p->level--;  in expression_rule()
10929 …D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if'…  in expression_rule()
10936             (a = disjunction_rule(p))  // disjunction  in expression_rule()
10938             (_keyword = _PyPegen_expect_token(p, 510))  // token='if'  in expression_rule()
10940             (b = disjunction_rule(p))  // disjunction  in expression_rule()
10942             (_keyword_1 = _PyPegen_expect_token(p, 516))  // token='else'  in expression_rule()
10944             (c = expression_rule(p))  // expression  in expression_rule()
10947 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disju…  in expression_rule()
10948             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in expression_rule()
10950                 p->level--;  in expression_rule()
10953             int _end_lineno = _token->end_lineno;  in expression_rule()
10955             int _end_col_offset = _token->end_col_offset;  in expression_rule()
10959                 p->error_indicator = 1;  in expression_rule()
10960                 p->level--;  in expression_rule()
10965         p->mark = _mark;  in expression_rule()
10966         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',  in expression_rule()
10967 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expressi…  in expression_rule()
10970         if (p->error_indicator) {  in expression_rule()
10971             p->level--;  in expression_rule()
10974 …  D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction"));  in expression_rule()
10977             (disjunction_var = disjunction_rule(p))  // disjunction  in expression_rule()
10980 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disju…  in expression_rule()
10984         p->mark = _mark;  in expression_rule()
10985         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',  in expression_rule()
10986                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction"));  in expression_rule()
10989         if (p->error_indicator) {  in expression_rule()
10990             p->level--;  in expression_rule()
10993 …      D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef"));  in expression_rule()
10996             (lambdef_var = lambdef_rule(p))  // lambdef  in expression_rule()
10999 …D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambd…  in expression_rule()
11003         p->mark = _mark;  in expression_rule()
11004         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',  in expression_rule()
11005                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef"));  in expression_rule()
11009     _PyPegen_insert_memo(p, _mark, expression_type, _res);  in expression_rule()
11010     p->level--;  in expression_rule()
11016 lambdef_rule(Parser *p)  in lambdef_rule()  argument
11018     if (p->level++ == MAXSTACK) {  in lambdef_rule()
11019         p->error_indicator = 1;  in lambdef_rule()
11022     if (p->error_indicator) {  in lambdef_rule()
11023         p->level--;  in lambdef_rule()
11027     int _mark = p->mark;  in lambdef_rule()
11028     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in lambdef_rule()
11029         p->error_indicator = 1;  in lambdef_rule()
11030         p->level--;  in lambdef_rule()
11033     int _start_lineno = p->tokens[_mark]->lineno;  in lambdef_rule()
11035     int _start_col_offset = p->tokens[_mark]->col_offset;  in lambdef_rule()
11038         if (p->error_indicator) {  in lambdef_rule()
11039             p->level--;  in lambdef_rule()
11042 …D(fprintf(stderr, "%*c> lambdef[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_par…  in lambdef_rule()
11048             (_keyword = _PyPegen_expect_token(p, 528))  // token='lambda'  in lambdef_rule()
11050             (a = lambda_params_rule(p), !p->error_indicator)  // lambda_params?  in lambdef_rule()
11052             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in lambdef_rule()
11054             (b = expression_rule(p))  // expression  in lambdef_rule()
11057 …D(fprintf(stderr, "%*c+ lambdef[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda'…  in lambdef_rule()
11058             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in lambdef_rule()
11060                 p->level--;  in lambdef_rule()
11063             int _end_lineno = _token->end_lineno;  in lambdef_rule()
11065             int _end_col_offset = _token->end_col_offset;  in lambdef_rule()
11067 …_res = _PyAST_Lambda ( ( a ) ? a : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , E…  in lambdef_rule()
11069                 p->error_indicator = 1;  in lambdef_rule()
11070                 p->level--;  in lambdef_rule()
11075         p->mark = _mark;  in lambdef_rule()
11076         D(fprintf(stderr, "%*c%s lambdef[%d-%d]: %s failed!\n", p->level, ' ',  in lambdef_rule()
11077 …   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' expression"));  in lambdef_rule()
11081     p->level--;  in lambdef_rule()
11087 lambda_params_rule(Parser *p)  in lambda_params_rule()  argument
11089     if (p->level++ == MAXSTACK) {  in lambda_params_rule()
11090         p->error_indicator = 1;  in lambda_params_rule()
11093     if (p->error_indicator) {  in lambda_params_rule()
11094         p->level--;  in lambda_params_rule()
11098     int _mark = p->mark;  in lambda_params_rule()
11099     if (p->call_invalid_rules) { // invalid_lambda_parameters  in lambda_params_rule()
11100         if (p->error_indicator) {  in lambda_params_rule()
11101             p->level--;  in lambda_params_rule()
11104 …D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambd…  in lambda_params_rule()
11107 …  (invalid_lambda_parameters_var = invalid_lambda_parameters_rule(p))  // invalid_lambda_parameters  in lambda_params_rule()
11110 …D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in…  in lambda_params_rule()
11114         p->mark = _mark;  in lambda_params_rule()
11115         D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_params_rule()
11116 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_parameters"));  in lambda_params_rule()
11119         if (p->error_indicator) {  in lambda_params_rule()
11120             p->level--;  in lambda_params_rule()
11123 …D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_parame…  in lambda_params_rule()
11126             (lambda_parameters_var = lambda_parameters_rule(p))  // lambda_parameters  in lambda_params_rule()
11129 …D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "la…  in lambda_params_rule()
11133         p->mark = _mark;  in lambda_params_rule()
11134         D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_params_rule()
11135                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_parameters"));  in lambda_params_rule()
11139     p->level--;  in lambda_params_rule()
11150 lambda_parameters_rule(Parser *p)  in lambda_parameters_rule()  argument
11152     if (p->level++ == MAXSTACK) {  in lambda_parameters_rule()
11153         p->error_indicator = 1;  in lambda_parameters_rule()
11156     if (p->error_indicator) {  in lambda_parameters_rule()
11157         p->level--;  in lambda_parameters_rule()
11161     int _mark = p->mark;  in lambda_parameters_rule()
11163         if (p->error_indicator) {  in lambda_parameters_rule()
11164             p->level--;  in lambda_parameters_rule()
11167 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_sl…  in lambda_parameters_rule()
11173             (a = lambda_slash_no_default_rule(p))  // lambda_slash_no_default  in lambda_parameters_rule()
11175             (b = (asdl_arg_seq*)_loop0_90_rule(p))  // lambda_param_no_default*  in lambda_parameters_rule()
11177             (c = _loop0_91_rule(p))  // lambda_param_with_default*  in lambda_parameters_rule()
11179             (d = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc?  in lambda_parameters_rule()
11182 …D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in lambda_parameters_rule()
11183             _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );  in lambda_parameters_rule()
11185                 p->error_indicator = 1;  in lambda_parameters_rule()
11186                 p->level--;  in lambda_parameters_rule()
11191         p->mark = _mark;  in lambda_parameters_rule()
11192         D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_parameters_rule()
11193 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default lambda_param_no_defa…  in lambda_parameters_rule()
11196         if (p->error_indicator) {  in lambda_parameters_rule()
11197             p->level--;  in lambda_parameters_rule()
11200 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_sl…  in lambda_parameters_rule()
11205             (a = lambda_slash_with_default_rule(p))  // lambda_slash_with_default  in lambda_parameters_rule()
11207             (b = _loop0_92_rule(p))  // lambda_param_with_default*  in lambda_parameters_rule()
11209             (c = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc?  in lambda_parameters_rule()
11212 …D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in lambda_parameters_rule()
11213             _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );  in lambda_parameters_rule()
11215                 p->error_indicator = 1;  in lambda_parameters_rule()
11216                 p->level--;  in lambda_parameters_rule()
11221         p->mark = _mark;  in lambda_parameters_rule()
11222         D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_parameters_rule()
11223 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default lambda_param_with_…  in lambda_parameters_rule()
11226         if (p->error_indicator) {  in lambda_parameters_rule()
11227             p->level--;  in lambda_parameters_rule()
11230 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_pa…  in lambda_parameters_rule()
11235             (a = (asdl_arg_seq*)_loop1_93_rule(p))  // lambda_param_no_default+  in lambda_parameters_rule()
11237             (b = _loop0_94_rule(p))  // lambda_param_with_default*  in lambda_parameters_rule()
11239             (c = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc?  in lambda_parameters_rule()
11242 …D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in lambda_parameters_rule()
11243             _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );  in lambda_parameters_rule()
11245                 p->error_indicator = 1;  in lambda_parameters_rule()
11246                 p->level--;  in lambda_parameters_rule()
11251         p->mark = _mark;  in lambda_parameters_rule()
11252         D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_parameters_rule()
11253 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ lambda_param_with_d…  in lambda_parameters_rule()
11256         if (p->error_indicator) {  in lambda_parameters_rule()
11257             p->level--;  in lambda_parameters_rule()
11260 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_pa…  in lambda_parameters_rule()
11264             (a = _loop1_95_rule(p))  // lambda_param_with_default+  in lambda_parameters_rule()
11266             (b = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc?  in lambda_parameters_rule()
11269 …D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in lambda_parameters_rule()
11270             _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );  in lambda_parameters_rule()
11272                 p->error_indicator = 1;  in lambda_parameters_rule()
11273                 p->level--;  in lambda_parameters_rule()
11278         p->mark = _mark;  in lambda_parameters_rule()
11279         D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_parameters_rule()
11280 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?"…  in lambda_parameters_rule()
11283         if (p->error_indicator) {  in lambda_parameters_rule()
11284             p->level--;  in lambda_parameters_rule()
11287 …D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_st…  in lambda_parameters_rule()
11290             (a = lambda_star_etc_rule(p))  // lambda_star_etc  in lambda_parameters_rule()
11293 …D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in lambda_parameters_rule()
11294             _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );  in lambda_parameters_rule()
11296                 p->error_indicator = 1;  in lambda_parameters_rule()
11297                 p->level--;  in lambda_parameters_rule()
11302         p->mark = _mark;  in lambda_parameters_rule()
11303         D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_parameters_rule()
11304                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_star_etc"));  in lambda_parameters_rule()
11308     p->level--;  in lambda_parameters_rule()
11316 lambda_slash_no_default_rule(Parser *p)  in lambda_slash_no_default_rule()  argument
11318     if (p->level++ == MAXSTACK) {  in lambda_slash_no_default_rule()
11319         p->error_indicator = 1;  in lambda_slash_no_default_rule()
11322     if (p->error_indicator) {  in lambda_slash_no_default_rule()
11323         p->level--;  in lambda_slash_no_default_rule()
11327     int _mark = p->mark;  in lambda_slash_no_default_rule()
11329         if (p->error_indicator) {  in lambda_slash_no_default_rule()
11330             p->level--;  in lambda_slash_no_default_rule()
11333 …D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lam…  in lambda_slash_no_default_rule()
11338             (a = (asdl_arg_seq*)_loop1_96_rule(p))  // lambda_param_no_default+  in lambda_slash_no_default_rule()
11340             (_literal = _PyPegen_expect_token(p, 17))  // token='/'  in lambda_slash_no_default_rule()
11342             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in lambda_slash_no_default_rule()
11345 …D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p-…  in lambda_slash_no_default_rule()
11348                 p->error_indicator = 1;  in lambda_slash_no_default_rule()
11349                 p->level--;  in lambda_slash_no_default_rule()
11354         p->mark = _mark;  in lambda_slash_no_default_rule()
11355         D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_slash_no_default_rule()
11356 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' ','"));  in lambda_slash_no_default_rule()
11359         if (p->error_indicator) {  in lambda_slash_no_default_rule()
11360             p->level--;  in lambda_slash_no_default_rule()
11363 …D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lam…  in lambda_slash_no_default_rule()
11367             (a = (asdl_arg_seq*)_loop1_97_rule(p))  // lambda_param_no_default+  in lambda_slash_no_default_rule()
11369             (_literal = _PyPegen_expect_token(p, 17))  // token='/'  in lambda_slash_no_default_rule()
11371             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'  in lambda_slash_no_default_rule()
11374 …D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p-…  in lambda_slash_no_default_rule()
11377                 p->error_indicator = 1;  in lambda_slash_no_default_rule()
11378                 p->level--;  in lambda_slash_no_default_rule()
11383         p->mark = _mark;  in lambda_slash_no_default_rule()
11384         D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_slash_no_default_rule()
11385 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' &':'"));  in lambda_slash_no_default_rule()
11389     p->level--;  in lambda_slash_no_default_rule()
11397 lambda_slash_with_default_rule(Parser *p)  in lambda_slash_with_default_rule()  argument
11399     if (p->level++ == MAXSTACK) {  in lambda_slash_with_default_rule()
11400         p->error_indicator = 1;  in lambda_slash_with_default_rule()
11403     if (p->error_indicator) {  in lambda_slash_with_default_rule()
11404         p->level--;  in lambda_slash_with_default_rule()
11408     int _mark = p->mark;  in lambda_slash_with_default_rule()
11410         if (p->error_indicator) {  in lambda_slash_with_default_rule()
11411             p->level--;  in lambda_slash_with_default_rule()
11414 …D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l…  in lambda_slash_with_default_rule()
11420             (a = _loop0_98_rule(p))  // lambda_param_no_default*  in lambda_slash_with_default_rule()
11422             (b = _loop1_99_rule(p))  // lambda_param_with_default+  in lambda_slash_with_default_rule()
11424             (_literal = _PyPegen_expect_token(p, 17))  // token='/'  in lambda_slash_with_default_rule()
11426             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in lambda_slash_with_default_rule()
11429 …D(fprintf(stderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in lambda_slash_with_default_rule()
11430             _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq * ) a , b );  in lambda_slash_with_default_rule()
11432                 p->error_indicator = 1;  in lambda_slash_with_default_rule()
11433                 p->level--;  in lambda_slash_with_default_rule()
11438         p->mark = _mark;  in lambda_slash_with_default_rule()
11439         D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_slash_with_default_rule()
11440 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_d…  in lambda_slash_with_default_rule()
11443         if (p->error_indicator) {  in lambda_slash_with_default_rule()
11444             p->level--;  in lambda_slash_with_default_rule()
11447 …D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l…  in lambda_slash_with_default_rule()
11452             (a = _loop0_100_rule(p))  // lambda_param_no_default*  in lambda_slash_with_default_rule()
11454             (b = _loop1_101_rule(p))  // lambda_param_with_default+  in lambda_slash_with_default_rule()
11456             (_literal = _PyPegen_expect_token(p, 17))  // token='/'  in lambda_slash_with_default_rule()
11458             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'  in lambda_slash_with_default_rule()
11461 …D(fprintf(stderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in lambda_slash_with_default_rule()
11462             _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq * ) a , b );  in lambda_slash_with_default_rule()
11464                 p->error_indicator = 1;  in lambda_slash_with_default_rule()
11465                 p->level--;  in lambda_slash_with_default_rule()
11470         p->mark = _mark;  in lambda_slash_with_default_rule()
11471         D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_slash_with_default_rule()
11472 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_d…  in lambda_slash_with_default_rule()
11476     p->level--;  in lambda_slash_with_default_rule()
11486 lambda_star_etc_rule(Parser *p)  in lambda_star_etc_rule()  argument
11488     if (p->level++ == MAXSTACK) {  in lambda_star_etc_rule()
11489         p->error_indicator = 1;  in lambda_star_etc_rule()
11492     if (p->error_indicator) {  in lambda_star_etc_rule()
11493         p->level--;  in lambda_star_etc_rule()
11497     int _mark = p->mark;  in lambda_star_etc_rule()
11499         if (p->error_indicator) {  in lambda_star_etc_rule()
11500             p->level--;  in lambda_star_etc_rule()
11503 …D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' lambda_…  in lambda_star_etc_rule()
11509             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in lambda_star_etc_rule()
11511             (a = lambda_param_no_default_rule(p))  // lambda_param_no_default  in lambda_star_etc_rule()
11513             (b = _loop0_102_rule(p))  // lambda_param_maybe_default*  in lambda_star_etc_rule()
11515             (c = lambda_kwds_rule(p), !p->error_indicator)  // lambda_kwds?  in lambda_star_etc_rule()
11518 …D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in lambda_star_etc_rule()
11519             _res = _PyPegen_star_etc ( p , a , b , c );  in lambda_star_etc_rule()
11521                 p->error_indicator = 1;  in lambda_star_etc_rule()
11522                 p->level--;  in lambda_star_etc_rule()
11527         p->mark = _mark;  in lambda_star_etc_rule()
11528         D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_star_etc_rule()
11529 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' lambda_param_no_default lambda_param_may…  in lambda_star_etc_rule()
11532         if (p->error_indicator) {  in lambda_star_etc_rule()
11533             p->level--;  in lambda_star_etc_rule()
11536 …D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' lam…  in lambda_star_etc_rule()
11542             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in lambda_star_etc_rule()
11544             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in lambda_star_etc_rule()
11546             (b = _loop1_103_rule(p))  // lambda_param_maybe_default+  in lambda_star_etc_rule()
11548             (c = lambda_kwds_rule(p), !p->error_indicator)  // lambda_kwds?  in lambda_star_etc_rule()
11551 …D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in lambda_star_etc_rule()
11552             _res = _PyPegen_star_etc ( p , NULL , b , c );  in lambda_star_etc_rule()
11554                 p->error_indicator = 1;  in lambda_star_etc_rule()
11555                 p->level--;  in lambda_star_etc_rule()
11560         p->mark = _mark;  in lambda_star_etc_rule()
11561         D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_star_etc_rule()
11562 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_k…  in lambda_star_etc_rule()
11565         if (p->error_indicator) {  in lambda_star_etc_rule()
11566             p->level--;  in lambda_star_etc_rule()
11569 …D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_kwds…  in lambda_star_etc_rule()
11572             (a = lambda_kwds_rule(p))  // lambda_kwds  in lambda_star_etc_rule()
11575 …D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in lambda_star_etc_rule()
11576             _res = _PyPegen_star_etc ( p , NULL , NULL , a );  in lambda_star_etc_rule()
11578                 p->error_indicator = 1;  in lambda_star_etc_rule()
11579                 p->level--;  in lambda_star_etc_rule()
11584         p->mark = _mark;  in lambda_star_etc_rule()
11585         D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_star_etc_rule()
11586                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_kwds"));  in lambda_star_etc_rule()
11588     if (p->call_invalid_rules) { // invalid_lambda_star_etc  in lambda_star_etc_rule()
11589         if (p->error_indicator) {  in lambda_star_etc_rule()
11590             p->level--;  in lambda_star_etc_rule()
11593 …D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lam…  in lambda_star_etc_rule()
11596 …        (invalid_lambda_star_etc_var = invalid_lambda_star_etc_rule(p))  // invalid_lambda_star_etc  in lambda_star_etc_rule()
11599 …D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in lambda_star_etc_rule()
11603         p->mark = _mark;  in lambda_star_etc_rule()
11604         D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_star_etc_rule()
11605                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_star_etc"));  in lambda_star_etc_rule()
11609     p->level--;  in lambda_star_etc_rule()
11615 lambda_kwds_rule(Parser *p)  in lambda_kwds_rule()  argument
11617     if (p->level++ == MAXSTACK) {  in lambda_kwds_rule()
11618         p->error_indicator = 1;  in lambda_kwds_rule()
11621     if (p->error_indicator) {  in lambda_kwds_rule()
11622         p->level--;  in lambda_kwds_rule()
11626     int _mark = p->mark;  in lambda_kwds_rule()
11628         if (p->error_indicator) {  in lambda_kwds_rule()
11629             p->level--;  in lambda_kwds_rule()
11632 …D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_par…  in lambda_kwds_rule()
11636             (_literal = _PyPegen_expect_token(p, 35))  // token='**'  in lambda_kwds_rule()
11638             (a = lambda_param_no_default_rule(p))  // lambda_param_no_default  in lambda_kwds_rule()
11641 …D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'…  in lambda_kwds_rule()
11644                 p->error_indicator = 1;  in lambda_kwds_rule()
11645                 p->level--;  in lambda_kwds_rule()
11650         p->mark = _mark;  in lambda_kwds_rule()
11651         D(fprintf(stderr, "%*c%s lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_kwds_rule()
11652 …             p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param_no_default"));  in lambda_kwds_rule()
11656     p->level--;  in lambda_kwds_rule()
11662 lambda_param_no_default_rule(Parser *p)  in lambda_param_no_default_rule()  argument
11664     if (p->level++ == MAXSTACK) {  in lambda_param_no_default_rule()
11665         p->error_indicator = 1;  in lambda_param_no_default_rule()
11668     if (p->error_indicator) {  in lambda_param_no_default_rule()
11669         p->level--;  in lambda_param_no_default_rule()
11673     int _mark = p->mark;  in lambda_param_no_default_rule()
11675         if (p->error_indicator) {  in lambda_param_no_default_rule()
11676             p->level--;  in lambda_param_no_default_rule()
11679 …D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lam…  in lambda_param_no_default_rule()
11683             (a = lambda_param_rule(p))  // lambda_param  in lambda_param_no_default_rule()
11685             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in lambda_param_no_default_rule()
11688 …D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p-…  in lambda_param_no_default_rule()
11691                 p->error_indicator = 1;  in lambda_param_no_default_rule()
11692                 p->level--;  in lambda_param_no_default_rule()
11697         p->mark = _mark;  in lambda_param_no_default_rule()
11698         D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_param_no_default_rule()
11699                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param ','"));  in lambda_param_no_default_rule()
11702         if (p->error_indicator) {  in lambda_param_no_default_rule()
11703             p->level--;  in lambda_param_no_default_rule()
11706 …D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lam…  in lambda_param_no_default_rule()
11709             (a = lambda_param_rule(p))  // lambda_param  in lambda_param_no_default_rule()
11711             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'  in lambda_param_no_default_rule()
11714 …D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p-…  in lambda_param_no_default_rule()
11717                 p->error_indicator = 1;  in lambda_param_no_default_rule()
11718                 p->level--;  in lambda_param_no_default_rule()
11723         p->mark = _mark;  in lambda_param_no_default_rule()
11724         D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_param_no_default_rule()
11725                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param &':'"));  in lambda_param_no_default_rule()
11729     p->level--;  in lambda_param_no_default_rule()
11735 lambda_param_with_default_rule(Parser *p)  in lambda_param_with_default_rule()  argument
11737     if (p->level++ == MAXSTACK) {  in lambda_param_with_default_rule()
11738         p->error_indicator = 1;  in lambda_param_with_default_rule()
11741     if (p->error_indicator) {  in lambda_param_with_default_rule()
11742         p->level--;  in lambda_param_with_default_rule()
11746     int _mark = p->mark;  in lambda_param_with_default_rule()
11748         if (p->error_indicator) {  in lambda_param_with_default_rule()
11749             p->level--;  in lambda_param_with_default_rule()
11752 …D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l…  in lambda_param_with_default_rule()
11757             (a = lambda_param_rule(p))  // lambda_param  in lambda_param_with_default_rule()
11759             (c = default_rule(p))  // default  in lambda_param_with_default_rule()
11761             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in lambda_param_with_default_rule()
11764 …D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in lambda_param_with_default_rule()
11765             _res = _PyPegen_name_default_pair ( p , a , c , NULL );  in lambda_param_with_default_rule()
11767                 p->error_indicator = 1;  in lambda_param_with_default_rule()
11768                 p->level--;  in lambda_param_with_default_rule()
11773         p->mark = _mark;  in lambda_param_with_default_rule()
11774         D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_param_with_default_rule()
11775                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default ','"));  in lambda_param_with_default_rule()
11778         if (p->error_indicator) {  in lambda_param_with_default_rule()
11779             p->level--;  in lambda_param_with_default_rule()
11782 …D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l…  in lambda_param_with_default_rule()
11786             (a = lambda_param_rule(p))  // lambda_param  in lambda_param_with_default_rule()
11788             (c = default_rule(p))  // default  in lambda_param_with_default_rule()
11790             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'  in lambda_param_with_default_rule()
11793 …D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in lambda_param_with_default_rule()
11794             _res = _PyPegen_name_default_pair ( p , a , c , NULL );  in lambda_param_with_default_rule()
11796                 p->error_indicator = 1;  in lambda_param_with_default_rule()
11797                 p->level--;  in lambda_param_with_default_rule()
11802         p->mark = _mark;  in lambda_param_with_default_rule()
11803         D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_param_with_default_rule()
11804 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default &':'"));  in lambda_param_with_default_rule()
11808     p->level--;  in lambda_param_with_default_rule()
11814 lambda_param_maybe_default_rule(Parser *p)  in lambda_param_maybe_default_rule()  argument
11816     if (p->level++ == MAXSTACK) {  in lambda_param_maybe_default_rule()
11817         p->error_indicator = 1;  in lambda_param_maybe_default_rule()
11820     if (p->error_indicator) {  in lambda_param_maybe_default_rule()
11821         p->level--;  in lambda_param_maybe_default_rule()
11825     int _mark = p->mark;  in lambda_param_maybe_default_rule()
11827         if (p->error_indicator) {  in lambda_param_maybe_default_rule()
11828             p->level--;  in lambda_param_maybe_default_rule()
11831 …D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in lambda_param_maybe_default_rule()
11836             (a = lambda_param_rule(p))  // lambda_param  in lambda_param_maybe_default_rule()
11838             (c = default_rule(p), !p->error_indicator)  // default?  in lambda_param_maybe_default_rule()
11840             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in lambda_param_maybe_default_rule()
11843 …(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in lambda_param_maybe_default_rule()
11844             _res = _PyPegen_name_default_pair ( p , a , c , NULL );  in lambda_param_maybe_default_rule()
11846                 p->error_indicator = 1;  in lambda_param_maybe_default_rule()
11847                 p->level--;  in lambda_param_maybe_default_rule()
11852         p->mark = _mark;  in lambda_param_maybe_default_rule()
11853         D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_param_maybe_default_rule()
11854 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? ','"));  in lambda_param_maybe_default_rule()
11857         if (p->error_indicator) {  in lambda_param_maybe_default_rule()
11858             p->level--;  in lambda_param_maybe_default_rule()
11861 …D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in lambda_param_maybe_default_rule()
11865             (a = lambda_param_rule(p))  // lambda_param  in lambda_param_maybe_default_rule()
11867             (c = default_rule(p), !p->error_indicator)  // default?  in lambda_param_maybe_default_rule()
11869             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'  in lambda_param_maybe_default_rule()
11872 …(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in lambda_param_maybe_default_rule()
11873             _res = _PyPegen_name_default_pair ( p , a , c , NULL );  in lambda_param_maybe_default_rule()
11875                 p->error_indicator = 1;  in lambda_param_maybe_default_rule()
11876                 p->level--;  in lambda_param_maybe_default_rule()
11881         p->mark = _mark;  in lambda_param_maybe_default_rule()
11882         D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_param_maybe_default_rule()
11883 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? &':'"));  in lambda_param_maybe_default_rule()
11887     p->level--;  in lambda_param_maybe_default_rule()
11893 lambda_param_rule(Parser *p)  in lambda_param_rule()  argument
11895     if (p->level++ == MAXSTACK) {  in lambda_param_rule()
11896         p->error_indicator = 1;  in lambda_param_rule()
11899     if (p->error_indicator) {  in lambda_param_rule()
11900         p->level--;  in lambda_param_rule()
11904     int _mark = p->mark;  in lambda_param_rule()
11905     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in lambda_param_rule()
11906         p->error_indicator = 1;  in lambda_param_rule()
11907         p->level--;  in lambda_param_rule()
11910     int _start_lineno = p->tokens[_mark]->lineno;  in lambda_param_rule()
11912     int _start_col_offset = p->tokens[_mark]->col_offset;  in lambda_param_rule()
11915         if (p->error_indicator) {  in lambda_param_rule()
11916             p->level--;  in lambda_param_rule()
11919         D(fprintf(stderr, "%*c> lambda_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));  in lambda_param_rule()
11922             (a = _PyPegen_name_token(p))  // NAME  in lambda_param_rule()
11925 …D(fprintf(stderr, "%*c+ lambda_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAM…  in lambda_param_rule()
11926             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in lambda_param_rule()
11928                 p->level--;  in lambda_param_rule()
11931             int _end_lineno = _token->end_lineno;  in lambda_param_rule()
11933             int _end_col_offset = _token->end_col_offset;  in lambda_param_rule()
11935             _res = _PyAST_arg ( a -> v . Name . id , NULL , NULL , EXTRA );  in lambda_param_rule()
11937                 p->error_indicator = 1;  in lambda_param_rule()
11938                 p->level--;  in lambda_param_rule()
11943         p->mark = _mark;  in lambda_param_rule()
11944         D(fprintf(stderr, "%*c%s lambda_param[%d-%d]: %s failed!\n", p->level, ' ',  in lambda_param_rule()
11945                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));  in lambda_param_rule()
11949     p->level--;  in lambda_param_rule()
11955 disjunction_rule(Parser *p)  in disjunction_rule()  argument
11957     if (p->level++ == MAXSTACK) {  in disjunction_rule()
11958         p->error_indicator = 1;  in disjunction_rule()
11961     if (p->error_indicator) {  in disjunction_rule()
11962         p->level--;  in disjunction_rule()
11966     if (_PyPegen_is_memoized(p, disjunction_type, &_res)) {  in disjunction_rule()
11967         p->level--;  in disjunction_rule()
11970     int _mark = p->mark;  in disjunction_rule()
11971     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in disjunction_rule()
11972         p->error_indicator = 1;  in disjunction_rule()
11973         p->level--;  in disjunction_rule()
11976     int _start_lineno = p->tokens[_mark]->lineno;  in disjunction_rule()
11978     int _start_col_offset = p->tokens[_mark]->col_offset;  in disjunction_rule()
11981         if (p->error_indicator) {  in disjunction_rule()
11982             p->level--;  in disjunction_rule()
11985 …D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction (('…  in disjunction_rule()
11989             (a = conjunction_rule(p))  // conjunction  in disjunction_rule()
11991             (b = _loop1_104_rule(p))  // (('or' conjunction))+  in disjunction_rule()
11994 …D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conj…  in disjunction_rule()
11995             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in disjunction_rule()
11997                 p->level--;  in disjunction_rule()
12000             int _end_lineno = _token->end_lineno;  in disjunction_rule()
12002             int _end_col_offset = _token->end_col_offset;  in disjunction_rule()
12004 …_res = _PyAST_BoolOp ( Or , CHECK ( asdl_expr_seq * , _PyPegen_seq_insert_in_front ( p , a , b ) )…  in disjunction_rule()
12006                 p->error_indicator = 1;  in disjunction_rule()
12007                 p->level--;  in disjunction_rule()
12012         p->mark = _mark;  in disjunction_rule()
12013         D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ',  in disjunction_rule()
12014 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction (('or' conjunction))+"));  in disjunction_rule()
12017         if (p->error_indicator) {  in disjunction_rule()
12018             p->level--;  in disjunction_rule()
12021 … D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction"));  in disjunction_rule()
12024             (conjunction_var = conjunction_rule(p))  // conjunction  in disjunction_rule()
12027 …D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conj…  in disjunction_rule()
12031         p->mark = _mark;  in disjunction_rule()
12032         D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ',  in disjunction_rule()
12033                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction"));  in disjunction_rule()
12037     _PyPegen_insert_memo(p, _mark, disjunction_type, _res);  in disjunction_rule()
12038     p->level--;  in disjunction_rule()
12044 conjunction_rule(Parser *p)  in conjunction_rule()  argument
12046     if (p->level++ == MAXSTACK) {  in conjunction_rule()
12047         p->error_indicator = 1;  in conjunction_rule()
12050     if (p->error_indicator) {  in conjunction_rule()
12051         p->level--;  in conjunction_rule()
12055     if (_PyPegen_is_memoized(p, conjunction_type, &_res)) {  in conjunction_rule()
12056         p->level--;  in conjunction_rule()
12059     int _mark = p->mark;  in conjunction_rule()
12060     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in conjunction_rule()
12061         p->error_indicator = 1;  in conjunction_rule()
12062         p->level--;  in conjunction_rule()
12065     int _start_lineno = p->tokens[_mark]->lineno;  in conjunction_rule()
12067     int _start_col_offset = p->tokens[_mark]->col_offset;  in conjunction_rule()
12070         if (p->error_indicator) {  in conjunction_rule()
12071             p->level--;  in conjunction_rule()
12074 …D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion (('an…  in conjunction_rule()
12078             (a = inversion_rule(p))  // inversion  in conjunction_rule()
12080             (b = _loop1_105_rule(p))  // (('and' inversion))+  in conjunction_rule()
12083 …D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inve…  in conjunction_rule()
12084             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in conjunction_rule()
12086                 p->level--;  in conjunction_rule()
12089             int _end_lineno = _token->end_lineno;  in conjunction_rule()
12091             int _end_col_offset = _token->end_col_offset;  in conjunction_rule()
12093 …_res = _PyAST_BoolOp ( And , CHECK ( asdl_expr_seq * , _PyPegen_seq_insert_in_front ( p , a , b ) …  in conjunction_rule()
12095                 p->error_indicator = 1;  in conjunction_rule()
12096                 p->level--;  in conjunction_rule()
12101         p->mark = _mark;  in conjunction_rule()
12102         D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ',  in conjunction_rule()
12103 …           p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion (('and' inversion))+"));  in conjunction_rule()
12106         if (p->error_indicator) {  in conjunction_rule()
12107             p->level--;  in conjunction_rule()
12110 …   D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion"));  in conjunction_rule()
12113             (inversion_var = inversion_rule(p))  // inversion  in conjunction_rule()
12116 …D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inve…  in conjunction_rule()
12120         p->mark = _mark;  in conjunction_rule()
12121         D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ',  in conjunction_rule()
12122                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion"));  in conjunction_rule()
12126     _PyPegen_insert_memo(p, _mark, conjunction_type, _res);  in conjunction_rule()
12127     p->level--;  in conjunction_rule()
12133 inversion_rule(Parser *p)  in inversion_rule()  argument
12135     if (p->level++ == MAXSTACK) {  in inversion_rule()
12136         p->error_indicator = 1;  in inversion_rule()
12139     if (p->error_indicator) {  in inversion_rule()
12140         p->level--;  in inversion_rule()
12144     if (_PyPegen_is_memoized(p, inversion_type, &_res)) {  in inversion_rule()
12145         p->level--;  in inversion_rule()
12148     int _mark = p->mark;  in inversion_rule()
12149     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in inversion_rule()
12150         p->error_indicator = 1;  in inversion_rule()
12151         p->level--;  in inversion_rule()
12154     int _start_lineno = p->tokens[_mark]->lineno;  in inversion_rule()
12156     int _start_col_offset = p->tokens[_mark]->col_offset;  in inversion_rule()
12159         if (p->error_indicator) {  in inversion_rule()
12160             p->level--;  in inversion_rule()
12163 …D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' inversion")…  in inversion_rule()
12167             (_keyword = _PyPegen_expect_token(p, 529))  // token='not'  in inversion_rule()
12169             (a = inversion_rule(p))  // inversion  in inversion_rule()
12172 …D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' …  in inversion_rule()
12173             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in inversion_rule()
12175                 p->level--;  in inversion_rule()
12178             int _end_lineno = _token->end_lineno;  in inversion_rule()
12180             int _end_col_offset = _token->end_col_offset;  in inversion_rule()
12184                 p->error_indicator = 1;  in inversion_rule()
12185                 p->level--;  in inversion_rule()
12190         p->mark = _mark;  in inversion_rule()
12191         D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ',  in inversion_rule()
12192                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' inversion"));  in inversion_rule()
12195         if (p->error_indicator) {  in inversion_rule()
12196             p->level--;  in inversion_rule()
12199 …    D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "comparison"));  in inversion_rule()
12202             (comparison_var = comparison_rule(p))  // comparison  in inversion_rule()
12205 …D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compar…  in inversion_rule()
12209         p->mark = _mark;  in inversion_rule()
12210         D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ',  in inversion_rule()
12211                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "comparison"));  in inversion_rule()
12215     _PyPegen_insert_memo(p, _mark, inversion_type, _res);  in inversion_rule()
12216     p->level--;  in inversion_rule()
12222 comparison_rule(Parser *p)  in comparison_rule()  argument
12224     if (p->level++ == MAXSTACK) {  in comparison_rule()
12225         p->error_indicator = 1;  in comparison_rule()
12228     if (p->error_indicator) {  in comparison_rule()
12229         p->level--;  in comparison_rule()
12233     int _mark = p->mark;  in comparison_rule()
12234     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in comparison_rule()
12235         p->error_indicator = 1;  in comparison_rule()
12236         p->level--;  in comparison_rule()
12239     int _start_lineno = p->tokens[_mark]->lineno;  in comparison_rule()
12241     int _start_col_offset = p->tokens[_mark]->col_offset;  in comparison_rule()
12244         if (p->error_indicator) {  in comparison_rule()
12245             p->level--;  in comparison_rule()
12248 …D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or compa…  in comparison_rule()
12252             (a = bitwise_or_rule(p))  // bitwise_or  in comparison_rule()
12254             (b = _loop1_106_rule(p))  // compare_op_bitwise_or_pair+  in comparison_rule()
12257 …D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwi…  in comparison_rule()
12258             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in comparison_rule()
12260                 p->level--;  in comparison_rule()
12263             int _end_lineno = _token->end_lineno;  in comparison_rule()
12265             int _end_col_offset = _token->end_col_offset;  in comparison_rule()
12267 …HECK ( asdl_int_seq * , _PyPegen_get_cmpops ( p , b ) ) , CHECK ( asdl_expr_seq * , _PyPegen_get_e…  in comparison_rule()
12269                 p->error_indicator = 1;  in comparison_rule()
12270                 p->level--;  in comparison_rule()
12275         p->mark = _mark;  in comparison_rule()
12276         D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ',  in comparison_rule()
12277 …   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));  in comparison_rule()
12280         if (p->error_indicator) {  in comparison_rule()
12281             p->level--;  in comparison_rule()
12284 …   D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or"));  in comparison_rule()
12287             (bitwise_or_var = bitwise_or_rule(p))  // bitwise_or  in comparison_rule()
12290 …D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwi…  in comparison_rule()
12294         p->mark = _mark;  in comparison_rule()
12295         D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ',  in comparison_rule()
12296                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or"));  in comparison_rule()
12300     p->level--;  in comparison_rule()
12316 compare_op_bitwise_or_pair_rule(Parser *p)  in compare_op_bitwise_or_pair_rule()  argument
12318     if (p->level++ == MAXSTACK) {  in compare_op_bitwise_or_pair_rule()
12319         p->error_indicator = 1;  in compare_op_bitwise_or_pair_rule()
12322     if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12323         p->level--;  in compare_op_bitwise_or_pair_rule()
12327     int _mark = p->mark;  in compare_op_bitwise_or_pair_rule()
12329         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12330             p->level--;  in compare_op_bitwise_or_pair_rule()
12333 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12336             (eq_bitwise_or_var = eq_bitwise_or_rule(p))  // eq_bitwise_or  in compare_op_bitwise_or_pair_rule()
12339 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12343         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12344         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12345                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "eq_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12348         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12349             p->level--;  in compare_op_bitwise_or_pair_rule()
12352 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12355             (noteq_bitwise_or_var = noteq_bitwise_or_rule(p))  // noteq_bitwise_or  in compare_op_bitwise_or_pair_rule()
12358 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12362         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12363         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12364                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "noteq_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12367         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12368             p->level--;  in compare_op_bitwise_or_pair_rule()
12371 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12374             (lte_bitwise_or_var = lte_bitwise_or_rule(p))  // lte_bitwise_or  in compare_op_bitwise_or_pair_rule()
12377 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12381         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12382         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12383                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lte_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12386         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12387             p->level--;  in compare_op_bitwise_or_pair_rule()
12390 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12393             (lt_bitwise_or_var = lt_bitwise_or_rule(p))  // lt_bitwise_or  in compare_op_bitwise_or_pair_rule()
12396 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12400         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12401         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12402                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lt_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12405         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12406             p->level--;  in compare_op_bitwise_or_pair_rule()
12409 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12412             (gte_bitwise_or_var = gte_bitwise_or_rule(p))  // gte_bitwise_or  in compare_op_bitwise_or_pair_rule()
12415 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12419         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12420         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12421                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gte_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12424         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12425             p->level--;  in compare_op_bitwise_or_pair_rule()
12428 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12431             (gt_bitwise_or_var = gt_bitwise_or_rule(p))  // gt_bitwise_or  in compare_op_bitwise_or_pair_rule()
12434 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12438         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12439         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12440                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gt_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12443         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12444             p->level--;  in compare_op_bitwise_or_pair_rule()
12447 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12450             (notin_bitwise_or_var = notin_bitwise_or_rule(p))  // notin_bitwise_or  in compare_op_bitwise_or_pair_rule()
12453 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12457         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12458         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12459                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "notin_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12462         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12463             p->level--;  in compare_op_bitwise_or_pair_rule()
12466 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12469             (in_bitwise_or_var = in_bitwise_or_rule(p))  // in_bitwise_or  in compare_op_bitwise_or_pair_rule()
12472 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12476         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12477         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12478                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "in_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12481         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12482             p->level--;  in compare_op_bitwise_or_pair_rule()
12485 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12488             (isnot_bitwise_or_var = isnot_bitwise_or_rule(p))  // isnot_bitwise_or  in compare_op_bitwise_or_pair_rule()
12491 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12495         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12496         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12497                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "isnot_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12500         if (p->error_indicator) {  in compare_op_bitwise_or_pair_rule()
12501             p->level--;  in compare_op_bitwise_or_pair_rule()
12504 …D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in compare_op_bitwise_or_pair_rule()
12507             (is_bitwise_or_var = is_bitwise_or_rule(p))  // is_bitwise_or  in compare_op_bitwise_or_pair_rule()
12510 …(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in compare_op_bitwise_or_pair_rule()
12514         p->mark = _mark;  in compare_op_bitwise_or_pair_rule()
12515         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',  in compare_op_bitwise_or_pair_rule()
12516                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "is_bitwise_or"));  in compare_op_bitwise_or_pair_rule()
12520     p->level--;  in compare_op_bitwise_or_pair_rule()
12526 eq_bitwise_or_rule(Parser *p)  in eq_bitwise_or_rule()  argument
12528     if (p->level++ == MAXSTACK) {  in eq_bitwise_or_rule()
12529         p->error_indicator = 1;  in eq_bitwise_or_rule()
12532     if (p->error_indicator) {  in eq_bitwise_or_rule()
12533         p->level--;  in eq_bitwise_or_rule()
12537     int _mark = p->mark;  in eq_bitwise_or_rule()
12539         if (p->error_indicator) {  in eq_bitwise_or_rule()
12540             p->level--;  in eq_bitwise_or_rule()
12543 …D(fprintf(stderr, "%*c> eq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'==' bitwise_…  in eq_bitwise_or_rule()
12547             (_literal = _PyPegen_expect_token(p, 27))  // token='=='  in eq_bitwise_or_rule()
12549             (a = bitwise_or_rule(p))  // bitwise_or  in eq_bitwise_or_rule()
12552 …D(fprintf(stderr, "%*c+ eq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=…  in eq_bitwise_or_rule()
12553             _res = _PyPegen_cmpop_expr_pair ( p , Eq , a );  in eq_bitwise_or_rule()
12555                 p->error_indicator = 1;  in eq_bitwise_or_rule()
12556                 p->level--;  in eq_bitwise_or_rule()
12561         p->mark = _mark;  in eq_bitwise_or_rule()
12562         D(fprintf(stderr, "%*c%s eq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in eq_bitwise_or_rule()
12563                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'==' bitwise_or"));  in eq_bitwise_or_rule()
12567     p->level--;  in eq_bitwise_or_rule()
12573 noteq_bitwise_or_rule(Parser *p)  in noteq_bitwise_or_rule()  argument
12575     if (p->level++ == MAXSTACK) {  in noteq_bitwise_or_rule()
12576         p->error_indicator = 1;  in noteq_bitwise_or_rule()
12579     if (p->error_indicator) {  in noteq_bitwise_or_rule()
12580         p->level--;  in noteq_bitwise_or_rule()
12584     int _mark = p->mark;  in noteq_bitwise_or_rule()
12586         if (p->error_indicator) {  in noteq_bitwise_or_rule()
12587             p->level--;  in noteq_bitwise_or_rule()
12590 …D(fprintf(stderr, "%*c> noteq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('!=') bit…  in noteq_bitwise_or_rule()
12594             (_tmp_107_var = _tmp_107_rule(p))  // '!='  in noteq_bitwise_or_rule()
12596             (a = bitwise_or_rule(p))  // bitwise_or  in noteq_bitwise_or_rule()
12599 …D(fprintf(stderr, "%*c+ noteq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in noteq_bitwise_or_rule()
12600             _res = _PyPegen_cmpop_expr_pair ( p , NotEq , a );  in noteq_bitwise_or_rule()
12602                 p->error_indicator = 1;  in noteq_bitwise_or_rule()
12603                 p->level--;  in noteq_bitwise_or_rule()
12608         p->mark = _mark;  in noteq_bitwise_or_rule()
12609         D(fprintf(stderr, "%*c%s noteq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in noteq_bitwise_or_rule()
12610                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('!=') bitwise_or"));  in noteq_bitwise_or_rule()
12614     p->level--;  in noteq_bitwise_or_rule()
12620 lte_bitwise_or_rule(Parser *p)  in lte_bitwise_or_rule()  argument
12622     if (p->level++ == MAXSTACK) {  in lte_bitwise_or_rule()
12623         p->error_indicator = 1;  in lte_bitwise_or_rule()
12626     if (p->error_indicator) {  in lte_bitwise_or_rule()
12627         p->level--;  in lte_bitwise_or_rule()
12631     int _mark = p->mark;  in lte_bitwise_or_rule()
12633         if (p->error_indicator) {  in lte_bitwise_or_rule()
12634             p->level--;  in lte_bitwise_or_rule()
12637 …D(fprintf(stderr, "%*c> lte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<=' bitwise…  in lte_bitwise_or_rule()
12641             (_literal = _PyPegen_expect_token(p, 29))  // token='<='  in lte_bitwise_or_rule()
12643             (a = bitwise_or_rule(p))  // bitwise_or  in lte_bitwise_or_rule()
12646 …D(fprintf(stderr, "%*c+ lte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'…  in lte_bitwise_or_rule()
12647             _res = _PyPegen_cmpop_expr_pair ( p , LtE , a );  in lte_bitwise_or_rule()
12649                 p->error_indicator = 1;  in lte_bitwise_or_rule()
12650                 p->level--;  in lte_bitwise_or_rule()
12655         p->mark = _mark;  in lte_bitwise_or_rule()
12656         D(fprintf(stderr, "%*c%s lte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in lte_bitwise_or_rule()
12657                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<=' bitwise_or"));  in lte_bitwise_or_rule()
12661     p->level--;  in lte_bitwise_or_rule()
12667 lt_bitwise_or_rule(Parser *p)  in lt_bitwise_or_rule()  argument
12669     if (p->level++ == MAXSTACK) {  in lt_bitwise_or_rule()
12670         p->error_indicator = 1;  in lt_bitwise_or_rule()
12673     if (p->error_indicator) {  in lt_bitwise_or_rule()
12674         p->level--;  in lt_bitwise_or_rule()
12678     int _mark = p->mark;  in lt_bitwise_or_rule()
12680         if (p->error_indicator) {  in lt_bitwise_or_rule()
12681             p->level--;  in lt_bitwise_or_rule()
12684 …D(fprintf(stderr, "%*c> lt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<' bitwise_o…  in lt_bitwise_or_rule()
12688             (_literal = _PyPegen_expect_token(p, 20))  // token='<'  in lt_bitwise_or_rule()
12690             (a = bitwise_or_rule(p))  // bitwise_or  in lt_bitwise_or_rule()
12693 …D(fprintf(stderr, "%*c+ lt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<…  in lt_bitwise_or_rule()
12694             _res = _PyPegen_cmpop_expr_pair ( p , Lt , a );  in lt_bitwise_or_rule()
12696                 p->error_indicator = 1;  in lt_bitwise_or_rule()
12697                 p->level--;  in lt_bitwise_or_rule()
12702         p->mark = _mark;  in lt_bitwise_or_rule()
12703         D(fprintf(stderr, "%*c%s lt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in lt_bitwise_or_rule()
12704                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<' bitwise_or"));  in lt_bitwise_or_rule()
12708     p->level--;  in lt_bitwise_or_rule()
12714 gte_bitwise_or_rule(Parser *p)  in gte_bitwise_or_rule()  argument
12716     if (p->level++ == MAXSTACK) {  in gte_bitwise_or_rule()
12717         p->error_indicator = 1;  in gte_bitwise_or_rule()
12720     if (p->error_indicator) {  in gte_bitwise_or_rule()
12721         p->level--;  in gte_bitwise_or_rule()
12725     int _mark = p->mark;  in gte_bitwise_or_rule()
12727         if (p->error_indicator) {  in gte_bitwise_or_rule()
12728             p->level--;  in gte_bitwise_or_rule()
12731 …D(fprintf(stderr, "%*c> gte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>=' bitwise…  in gte_bitwise_or_rule()
12735             (_literal = _PyPegen_expect_token(p, 30))  // token='>='  in gte_bitwise_or_rule()
12737             (a = bitwise_or_rule(p))  // bitwise_or  in gte_bitwise_or_rule()
12740 …D(fprintf(stderr, "%*c+ gte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'…  in gte_bitwise_or_rule()
12741             _res = _PyPegen_cmpop_expr_pair ( p , GtE , a );  in gte_bitwise_or_rule()
12743                 p->error_indicator = 1;  in gte_bitwise_or_rule()
12744                 p->level--;  in gte_bitwise_or_rule()
12749         p->mark = _mark;  in gte_bitwise_or_rule()
12750         D(fprintf(stderr, "%*c%s gte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in gte_bitwise_or_rule()
12751                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>=' bitwise_or"));  in gte_bitwise_or_rule()
12755     p->level--;  in gte_bitwise_or_rule()
12761 gt_bitwise_or_rule(Parser *p)  in gt_bitwise_or_rule()  argument
12763     if (p->level++ == MAXSTACK) {  in gt_bitwise_or_rule()
12764         p->error_indicator = 1;  in gt_bitwise_or_rule()
12767     if (p->error_indicator) {  in gt_bitwise_or_rule()
12768         p->level--;  in gt_bitwise_or_rule()
12772     int _mark = p->mark;  in gt_bitwise_or_rule()
12774         if (p->error_indicator) {  in gt_bitwise_or_rule()
12775             p->level--;  in gt_bitwise_or_rule()
12778 …D(fprintf(stderr, "%*c> gt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>' bitwise_o…  in gt_bitwise_or_rule()
12782             (_literal = _PyPegen_expect_token(p, 21))  // token='>'  in gt_bitwise_or_rule()
12784             (a = bitwise_or_rule(p))  // bitwise_or  in gt_bitwise_or_rule()
12787 …D(fprintf(stderr, "%*c+ gt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>…  in gt_bitwise_or_rule()
12788             _res = _PyPegen_cmpop_expr_pair ( p , Gt , a );  in gt_bitwise_or_rule()
12790                 p->error_indicator = 1;  in gt_bitwise_or_rule()
12791                 p->level--;  in gt_bitwise_or_rule()
12796         p->mark = _mark;  in gt_bitwise_or_rule()
12797         D(fprintf(stderr, "%*c%s gt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in gt_bitwise_or_rule()
12798                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>' bitwise_or"));  in gt_bitwise_or_rule()
12802     p->level--;  in gt_bitwise_or_rule()
12808 notin_bitwise_or_rule(Parser *p)  in notin_bitwise_or_rule()  argument
12810     if (p->level++ == MAXSTACK) {  in notin_bitwise_or_rule()
12811         p->error_indicator = 1;  in notin_bitwise_or_rule()
12814     if (p->error_indicator) {  in notin_bitwise_or_rule()
12815         p->level--;  in notin_bitwise_or_rule()
12819     int _mark = p->mark;  in notin_bitwise_or_rule()
12821         if (p->error_indicator) {  in notin_bitwise_or_rule()
12822             p->level--;  in notin_bitwise_or_rule()
12825 …D(fprintf(stderr, "%*c> notin_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' 'in'…  in notin_bitwise_or_rule()
12830             (_keyword = _PyPegen_expect_token(p, 529))  // token='not'  in notin_bitwise_or_rule()
12832             (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'  in notin_bitwise_or_rule()
12834             (a = bitwise_or_rule(p))  // bitwise_or  in notin_bitwise_or_rule()
12837 …D(fprintf(stderr, "%*c+ notin_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in notin_bitwise_or_rule()
12838             _res = _PyPegen_cmpop_expr_pair ( p , NotIn , a );  in notin_bitwise_or_rule()
12840                 p->error_indicator = 1;  in notin_bitwise_or_rule()
12841                 p->level--;  in notin_bitwise_or_rule()
12846         p->mark = _mark;  in notin_bitwise_or_rule()
12847         D(fprintf(stderr, "%*c%s notin_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in notin_bitwise_or_rule()
12848                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' 'in' bitwise_or"));  in notin_bitwise_or_rule()
12852     p->level--;  in notin_bitwise_or_rule()
12858 in_bitwise_or_rule(Parser *p)  in in_bitwise_or_rule()  argument
12860     if (p->level++ == MAXSTACK) {  in in_bitwise_or_rule()
12861         p->error_indicator = 1;  in in_bitwise_or_rule()
12864     if (p->error_indicator) {  in in_bitwise_or_rule()
12865         p->level--;  in in_bitwise_or_rule()
12869     int _mark = p->mark;  in in_bitwise_or_rule()
12871         if (p->error_indicator) {  in in_bitwise_or_rule()
12872             p->level--;  in in_bitwise_or_rule()
12875 …D(fprintf(stderr, "%*c> in_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'in' bitwise_…  in in_bitwise_or_rule()
12879             (_keyword = _PyPegen_expect_token(p, 518))  // token='in'  in in_bitwise_or_rule()
12881             (a = bitwise_or_rule(p))  // bitwise_or  in in_bitwise_or_rule()
12884 …D(fprintf(stderr, "%*c+ in_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'i…  in in_bitwise_or_rule()
12885             _res = _PyPegen_cmpop_expr_pair ( p , In , a );  in in_bitwise_or_rule()
12887                 p->error_indicator = 1;  in in_bitwise_or_rule()
12888                 p->level--;  in in_bitwise_or_rule()
12893         p->mark = _mark;  in in_bitwise_or_rule()
12894         D(fprintf(stderr, "%*c%s in_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in in_bitwise_or_rule()
12895                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'in' bitwise_or"));  in in_bitwise_or_rule()
12899     p->level--;  in in_bitwise_or_rule()
12905 isnot_bitwise_or_rule(Parser *p)  in isnot_bitwise_or_rule()  argument
12907     if (p->level++ == MAXSTACK) {  in isnot_bitwise_or_rule()
12908         p->error_indicator = 1;  in isnot_bitwise_or_rule()
12911     if (p->error_indicator) {  in isnot_bitwise_or_rule()
12912         p->level--;  in isnot_bitwise_or_rule()
12916     int _mark = p->mark;  in isnot_bitwise_or_rule()
12918         if (p->error_indicator) {  in isnot_bitwise_or_rule()
12919             p->level--;  in isnot_bitwise_or_rule()
12922 …D(fprintf(stderr, "%*c> isnot_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' 'not'…  in isnot_bitwise_or_rule()
12927             (_keyword = _PyPegen_expect_token(p, 530))  // token='is'  in isnot_bitwise_or_rule()
12929             (_keyword_1 = _PyPegen_expect_token(p, 529))  // token='not'  in isnot_bitwise_or_rule()
12931             (a = bitwise_or_rule(p))  // bitwise_or  in isnot_bitwise_or_rule()
12934 …D(fprintf(stderr, "%*c+ isnot_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in isnot_bitwise_or_rule()
12935             _res = _PyPegen_cmpop_expr_pair ( p , IsNot , a );  in isnot_bitwise_or_rule()
12937                 p->error_indicator = 1;  in isnot_bitwise_or_rule()
12938                 p->level--;  in isnot_bitwise_or_rule()
12943         p->mark = _mark;  in isnot_bitwise_or_rule()
12944         D(fprintf(stderr, "%*c%s isnot_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in isnot_bitwise_or_rule()
12945                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' 'not' bitwise_or"));  in isnot_bitwise_or_rule()
12949     p->level--;  in isnot_bitwise_or_rule()
12955 is_bitwise_or_rule(Parser *p)  in is_bitwise_or_rule()  argument
12957     if (p->level++ == MAXSTACK) {  in is_bitwise_or_rule()
12958         p->error_indicator = 1;  in is_bitwise_or_rule()
12961     if (p->error_indicator) {  in is_bitwise_or_rule()
12962         p->level--;  in is_bitwise_or_rule()
12966     int _mark = p->mark;  in is_bitwise_or_rule()
12968         if (p->error_indicator) {  in is_bitwise_or_rule()
12969             p->level--;  in is_bitwise_or_rule()
12972 …D(fprintf(stderr, "%*c> is_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' bitwise_…  in is_bitwise_or_rule()
12976             (_keyword = _PyPegen_expect_token(p, 530))  // token='is'  in is_bitwise_or_rule()
12978             (a = bitwise_or_rule(p))  // bitwise_or  in is_bitwise_or_rule()
12981 …D(fprintf(stderr, "%*c+ is_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'i…  in is_bitwise_or_rule()
12982             _res = _PyPegen_cmpop_expr_pair ( p , Is , a );  in is_bitwise_or_rule()
12984                 p->error_indicator = 1;  in is_bitwise_or_rule()
12985                 p->level--;  in is_bitwise_or_rule()
12990         p->mark = _mark;  in is_bitwise_or_rule()
12991         D(fprintf(stderr, "%*c%s is_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in is_bitwise_or_rule()
12992                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' bitwise_or"));  in is_bitwise_or_rule()
12996     p->level--;  in is_bitwise_or_rule()
13000 // Left-recursive
13004 bitwise_or_rule(Parser *p)  in bitwise_or_rule()  argument
13006     if (p->level++ == MAXSTACK) {  in bitwise_or_rule()
13007         p->error_indicator = 1;  in bitwise_or_rule()
13011     if (_PyPegen_is_memoized(p, bitwise_or_type, &_res)) {  in bitwise_or_rule()
13012         p->level--;  in bitwise_or_rule()
13015     int _mark = p->mark;  in bitwise_or_rule()
13016     int _resmark = p->mark;  in bitwise_or_rule()
13018         int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwise_or_type, _res);  in bitwise_or_rule()
13020             p->level--;  in bitwise_or_rule()
13023         p->mark = _mark;  in bitwise_or_rule()
13024         void *_raw = bitwise_or_raw(p);  in bitwise_or_rule()
13025         if (p->error_indicator) {  in bitwise_or_rule()
13026             p->level--;  in bitwise_or_rule()
13029         if (_raw == NULL || p->mark <= _resmark)  in bitwise_or_rule()
13031         _resmark = p->mark;  in bitwise_or_rule()
13034     p->mark = _resmark;  in bitwise_or_rule()
13035     p->level--;  in bitwise_or_rule()
13039 bitwise_or_raw(Parser *p)  in bitwise_or_raw()  argument
13041     if (p->level++ == MAXSTACK) {  in bitwise_or_raw()
13042         p->error_indicator = 1;  in bitwise_or_raw()
13045     if (p->error_indicator) {  in bitwise_or_raw()
13046         p->level--;  in bitwise_or_raw()
13050     int _mark = p->mark;  in bitwise_or_raw()
13051     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in bitwise_or_raw()
13052         p->error_indicator = 1;  in bitwise_or_raw()
13053         p->level--;  in bitwise_or_raw()
13056     int _start_lineno = p->tokens[_mark]->lineno;  in bitwise_or_raw()
13058     int _start_col_offset = p->tokens[_mark]->col_offset;  in bitwise_or_raw()
13061         if (p->error_indicator) {  in bitwise_or_raw()
13062             p->level--;  in bitwise_or_raw()
13065 …D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' b…  in bitwise_or_raw()
13070             (a = bitwise_or_rule(p))  // bitwise_or  in bitwise_or_raw()
13072             (_literal = _PyPegen_expect_token(p, 18))  // token='|'  in bitwise_or_raw()
13074             (b = bitwise_xor_rule(p))  // bitwise_xor  in bitwise_or_raw()
13077 …D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwi…  in bitwise_or_raw()
13078             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in bitwise_or_raw()
13080                 p->level--;  in bitwise_or_raw()
13083             int _end_lineno = _token->end_lineno;  in bitwise_or_raw()
13085             int _end_col_offset = _token->end_col_offset;  in bitwise_or_raw()
13089                 p->error_indicator = 1;  in bitwise_or_raw()
13090                 p->level--;  in bitwise_or_raw()
13095         p->mark = _mark;  in bitwise_or_raw()
13096         D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in bitwise_or_raw()
13097 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or '|' bitwise_xor"));  in bitwise_or_raw()
13100         if (p->error_indicator) {  in bitwise_or_raw()
13101             p->level--;  in bitwise_or_raw()
13104 …  D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor"));  in bitwise_or_raw()
13107             (bitwise_xor_var = bitwise_xor_rule(p))  // bitwise_xor  in bitwise_or_raw()
13110 …D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwi…  in bitwise_or_raw()
13114         p->mark = _mark;  in bitwise_or_raw()
13115         D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',  in bitwise_or_raw()
13116                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor"));  in bitwise_or_raw()
13120     p->level--;  in bitwise_or_raw()
13124 // Left-recursive
13128 bitwise_xor_rule(Parser *p)  in bitwise_xor_rule()  argument
13130     if (p->level++ == MAXSTACK) {  in bitwise_xor_rule()
13131         p->error_indicator = 1;  in bitwise_xor_rule()
13135     if (_PyPegen_is_memoized(p, bitwise_xor_type, &_res)) {  in bitwise_xor_rule()
13136         p->level--;  in bitwise_xor_rule()
13139     int _mark = p->mark;  in bitwise_xor_rule()
13140     int _resmark = p->mark;  in bitwise_xor_rule()
13142         int tmpvar_3 = _PyPegen_update_memo(p, _mark, bitwise_xor_type, _res);  in bitwise_xor_rule()
13144             p->level--;  in bitwise_xor_rule()
13147         p->mark = _mark;  in bitwise_xor_rule()
13148         void *_raw = bitwise_xor_raw(p);  in bitwise_xor_rule()
13149         if (p->error_indicator) {  in bitwise_xor_rule()
13150             p->level--;  in bitwise_xor_rule()
13153         if (_raw == NULL || p->mark <= _resmark)  in bitwise_xor_rule()
13155         _resmark = p->mark;  in bitwise_xor_rule()
13158     p->mark = _resmark;  in bitwise_xor_rule()
13159     p->level--;  in bitwise_xor_rule()
13163 bitwise_xor_raw(Parser *p)  in bitwise_xor_raw()  argument
13165     if (p->level++ == MAXSTACK) {  in bitwise_xor_raw()
13166         p->error_indicator = 1;  in bitwise_xor_raw()
13169     if (p->error_indicator) {  in bitwise_xor_raw()
13170         p->level--;  in bitwise_xor_raw()
13174     int _mark = p->mark;  in bitwise_xor_raw()
13175     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in bitwise_xor_raw()
13176         p->error_indicator = 1;  in bitwise_xor_raw()
13177         p->level--;  in bitwise_xor_raw()
13180     int _start_lineno = p->tokens[_mark]->lineno;  in bitwise_xor_raw()
13182     int _start_col_offset = p->tokens[_mark]->col_offset;  in bitwise_xor_raw()
13185         if (p->error_indicator) {  in bitwise_xor_raw()
13186             p->level--;  in bitwise_xor_raw()
13189 …D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^'…  in bitwise_xor_raw()
13194             (a = bitwise_xor_rule(p))  // bitwise_xor  in bitwise_xor_raw()
13196             (_literal = _PyPegen_expect_token(p, 32))  // token='^'  in bitwise_xor_raw()
13198             (b = bitwise_and_rule(p))  // bitwise_and  in bitwise_xor_raw()
13201 …D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitw…  in bitwise_xor_raw()
13202             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in bitwise_xor_raw()
13204                 p->level--;  in bitwise_xor_raw()
13207             int _end_lineno = _token->end_lineno;  in bitwise_xor_raw()
13209             int _end_col_offset = _token->end_col_offset;  in bitwise_xor_raw()
13213                 p->error_indicator = 1;  in bitwise_xor_raw()
13214                 p->level--;  in bitwise_xor_raw()
13219         p->mark = _mark;  in bitwise_xor_raw()
13220         D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ',  in bitwise_xor_raw()
13221 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor '^' bitwise_and"));  in bitwise_xor_raw()
13224         if (p->error_indicator) {  in bitwise_xor_raw()
13225             p->level--;  in bitwise_xor_raw()
13228 … D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and"));  in bitwise_xor_raw()
13231             (bitwise_and_var = bitwise_and_rule(p))  // bitwise_and  in bitwise_xor_raw()
13234 …D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitw…  in bitwise_xor_raw()
13238         p->mark = _mark;  in bitwise_xor_raw()
13239         D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ',  in bitwise_xor_raw()
13240                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and"));  in bitwise_xor_raw()
13244     p->level--;  in bitwise_xor_raw()
13248 // Left-recursive
13252 bitwise_and_rule(Parser *p)  in bitwise_and_rule()  argument
13254     if (p->level++ == MAXSTACK) {  in bitwise_and_rule()
13255         p->error_indicator = 1;  in bitwise_and_rule()
13259     if (_PyPegen_is_memoized(p, bitwise_and_type, &_res)) {  in bitwise_and_rule()
13260         p->level--;  in bitwise_and_rule()
13263     int _mark = p->mark;  in bitwise_and_rule()
13264     int _resmark = p->mark;  in bitwise_and_rule()
13266         int tmpvar_4 = _PyPegen_update_memo(p, _mark, bitwise_and_type, _res);  in bitwise_and_rule()
13268             p->level--;  in bitwise_and_rule()
13271         p->mark = _mark;  in bitwise_and_rule()
13272         void *_raw = bitwise_and_raw(p);  in bitwise_and_rule()
13273         if (p->error_indicator) {  in bitwise_and_rule()
13274             p->level--;  in bitwise_and_rule()
13277         if (_raw == NULL || p->mark <= _resmark)  in bitwise_and_rule()
13279         _resmark = p->mark;  in bitwise_and_rule()
13282     p->mark = _resmark;  in bitwise_and_rule()
13283     p->level--;  in bitwise_and_rule()
13287 bitwise_and_raw(Parser *p)  in bitwise_and_raw()  argument
13289     if (p->level++ == MAXSTACK) {  in bitwise_and_raw()
13290         p->error_indicator = 1;  in bitwise_and_raw()
13293     if (p->error_indicator) {  in bitwise_and_raw()
13294         p->level--;  in bitwise_and_raw()
13298     int _mark = p->mark;  in bitwise_and_raw()
13299     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in bitwise_and_raw()
13300         p->error_indicator = 1;  in bitwise_and_raw()
13301         p->level--;  in bitwise_and_raw()
13304     int _start_lineno = p->tokens[_mark]->lineno;  in bitwise_and_raw()
13306     int _start_col_offset = p->tokens[_mark]->col_offset;  in bitwise_and_raw()
13309         if (p->error_indicator) {  in bitwise_and_raw()
13310             p->level--;  in bitwise_and_raw()
13313 …D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and '&'…  in bitwise_and_raw()
13318             (a = bitwise_and_rule(p))  // bitwise_and  in bitwise_and_raw()
13320             (_literal = _PyPegen_expect_token(p, 19))  // token='&'  in bitwise_and_raw()
13322             (b = shift_expr_rule(p))  // shift_expr  in bitwise_and_raw()
13325 …D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitw…  in bitwise_and_raw()
13326             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in bitwise_and_raw()
13328                 p->level--;  in bitwise_and_raw()
13331             int _end_lineno = _token->end_lineno;  in bitwise_and_raw()
13333             int _end_col_offset = _token->end_col_offset;  in bitwise_and_raw()
13337                 p->error_indicator = 1;  in bitwise_and_raw()
13338                 p->level--;  in bitwise_and_raw()
13343         p->mark = _mark;  in bitwise_and_raw()
13344         D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ',  in bitwise_and_raw()
13345 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and '&' shift_expr"));  in bitwise_and_raw()
13348         if (p->error_indicator) {  in bitwise_and_raw()
13349             p->level--;  in bitwise_and_raw()
13352 …  D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr"));  in bitwise_and_raw()
13355             (shift_expr_var = shift_expr_rule(p))  // shift_expr  in bitwise_and_raw()
13358 …D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shif…  in bitwise_and_raw()
13362         p->mark = _mark;  in bitwise_and_raw()
13363         D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ',  in bitwise_and_raw()
13364                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr"));  in bitwise_and_raw()
13368     p->level--;  in bitwise_and_raw()
13372 // Left-recursive
13376 shift_expr_rule(Parser *p)  in shift_expr_rule()  argument
13378     if (p->level++ == MAXSTACK) {  in shift_expr_rule()
13379         p->error_indicator = 1;  in shift_expr_rule()
13383     if (_PyPegen_is_memoized(p, shift_expr_type, &_res)) {  in shift_expr_rule()
13384         p->level--;  in shift_expr_rule()
13387     int _mark = p->mark;  in shift_expr_rule()
13388     int _resmark = p->mark;  in shift_expr_rule()
13390         int tmpvar_5 = _PyPegen_update_memo(p, _mark, shift_expr_type, _res);  in shift_expr_rule()
13392             p->level--;  in shift_expr_rule()
13395         p->mark = _mark;  in shift_expr_rule()
13396         void *_raw = shift_expr_raw(p);  in shift_expr_rule()
13397         if (p->error_indicator) {  in shift_expr_rule()
13398             p->level--;  in shift_expr_rule()
13401         if (_raw == NULL || p->mark <= _resmark)  in shift_expr_rule()
13403         _resmark = p->mark;  in shift_expr_rule()
13406     p->mark = _resmark;  in shift_expr_rule()
13407     p->level--;  in shift_expr_rule()
13411 shift_expr_raw(Parser *p)  in shift_expr_raw()  argument
13413     if (p->level++ == MAXSTACK) {  in shift_expr_raw()
13414         p->error_indicator = 1;  in shift_expr_raw()
13417     if (p->error_indicator) {  in shift_expr_raw()
13418         p->level--;  in shift_expr_raw()
13422     int _mark = p->mark;  in shift_expr_raw()
13423     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in shift_expr_raw()
13424         p->error_indicator = 1;  in shift_expr_raw()
13425         p->level--;  in shift_expr_raw()
13428     int _start_lineno = p->tokens[_mark]->lineno;  in shift_expr_raw()
13430     int _start_col_offset = p->tokens[_mark]->col_offset;  in shift_expr_raw()
13433         if (p->error_indicator) {  in shift_expr_raw()
13434             p->level--;  in shift_expr_raw()
13437 …D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' …  in shift_expr_raw()
13442             (a = shift_expr_rule(p))  // shift_expr  in shift_expr_raw()
13444             (_literal = _PyPegen_expect_token(p, 33))  // token='<<'  in shift_expr_raw()
13446             (b = sum_rule(p))  // sum  in shift_expr_raw()
13449 …D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift…  in shift_expr_raw()
13450             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in shift_expr_raw()
13452                 p->level--;  in shift_expr_raw()
13455             int _end_lineno = _token->end_lineno;  in shift_expr_raw()
13457             int _end_col_offset = _token->end_col_offset;  in shift_expr_raw()
13461                 p->error_indicator = 1;  in shift_expr_raw()
13462                 p->level--;  in shift_expr_raw()
13467         p->mark = _mark;  in shift_expr_raw()
13468         D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',  in shift_expr_raw()
13469                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '<<' sum"));  in shift_expr_raw()
13472         if (p->error_indicator) {  in shift_expr_raw()
13473             p->level--;  in shift_expr_raw()
13476 …D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' …  in shift_expr_raw()
13481             (a = shift_expr_rule(p))  // shift_expr  in shift_expr_raw()
13483             (_literal = _PyPegen_expect_token(p, 34))  // token='>>'  in shift_expr_raw()
13485             (b = sum_rule(p))  // sum  in shift_expr_raw()
13488 …D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift…  in shift_expr_raw()
13489             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in shift_expr_raw()
13491                 p->level--;  in shift_expr_raw()
13494             int _end_lineno = _token->end_lineno;  in shift_expr_raw()
13496             int _end_col_offset = _token->end_col_offset;  in shift_expr_raw()
13500                 p->error_indicator = 1;  in shift_expr_raw()
13501                 p->level--;  in shift_expr_raw()
13506         p->mark = _mark;  in shift_expr_raw()
13507         D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',  in shift_expr_raw()
13508                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '>>' sum"));  in shift_expr_raw()
13511         if (p->error_indicator) {  in shift_expr_raw()
13512             p->level--;  in shift_expr_raw()
13515         D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum"));  in shift_expr_raw()
13518             (sum_var = sum_rule(p))  // sum  in shift_expr_raw()
13521 …D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum")…  in shift_expr_raw()
13525         p->mark = _mark;  in shift_expr_raw()
13526         D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',  in shift_expr_raw()
13527                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum"));  in shift_expr_raw()
13531     p->level--;  in shift_expr_raw()
13535 // Left-recursive
13536 // sum: sum '+' term | sum '-' term | term
13539 sum_rule(Parser *p)  in sum_rule()  argument
13541     if (p->level++ == MAXSTACK) {  in sum_rule()
13542         p->error_indicator = 1;  in sum_rule()
13546     if (_PyPegen_is_memoized(p, sum_type, &_res)) {  in sum_rule()
13547         p->level--;  in sum_rule()
13550     int _mark = p->mark;  in sum_rule()
13551     int _resmark = p->mark;  in sum_rule()
13553         int tmpvar_6 = _PyPegen_update_memo(p, _mark, sum_type, _res);  in sum_rule()
13555             p->level--;  in sum_rule()
13558         p->mark = _mark;  in sum_rule()
13559         void *_raw = sum_raw(p);  in sum_rule()
13560         if (p->error_indicator) {  in sum_rule()
13561             p->level--;  in sum_rule()
13564         if (_raw == NULL || p->mark <= _resmark)  in sum_rule()
13566         _resmark = p->mark;  in sum_rule()
13569     p->mark = _resmark;  in sum_rule()
13570     p->level--;  in sum_rule()
13574 sum_raw(Parser *p)  in sum_raw()  argument
13576     if (p->level++ == MAXSTACK) {  in sum_raw()
13577         p->error_indicator = 1;  in sum_raw()
13580     if (p->error_indicator) {  in sum_raw()
13581         p->level--;  in sum_raw()
13585     int _mark = p->mark;  in sum_raw()
13586     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in sum_raw()
13587         p->error_indicator = 1;  in sum_raw()
13588         p->level--;  in sum_raw()
13591     int _start_lineno = p->tokens[_mark]->lineno;  in sum_raw()
13593     int _start_col_offset = p->tokens[_mark]->col_offset;  in sum_raw()
13596         if (p->error_indicator) {  in sum_raw()
13597             p->level--;  in sum_raw()
13600         D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '+' term"));  in sum_raw()
13605             (a = sum_rule(p))  // sum  in sum_raw()
13607             (_literal = _PyPegen_expect_token(p, 14))  // token='+'  in sum_raw()
13609             (b = term_rule(p))  // term  in sum_raw()
13612 …D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '+' term…  in sum_raw()
13613             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in sum_raw()
13615                 p->level--;  in sum_raw()
13618             int _end_lineno = _token->end_lineno;  in sum_raw()
13620             int _end_col_offset = _token->end_col_offset;  in sum_raw()
13624                 p->error_indicator = 1;  in sum_raw()
13625                 p->level--;  in sum_raw()
13630         p->mark = _mark;  in sum_raw()
13631         D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',  in sum_raw()
13632                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '+' term"));  in sum_raw()
13634     { // sum '-' term  in sum_raw()
13635         if (p->error_indicator) {  in sum_raw()
13636             p->level--;  in sum_raw()
13639         D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '-' term"));  in sum_raw()
13644             (a = sum_rule(p))  // sum  in sum_raw()
13646             (_literal = _PyPegen_expect_token(p, 15))  // token='-'  in sum_raw()
13648             (b = term_rule(p))  // term  in sum_raw()
13651 …D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '-' term…  in sum_raw()
13652             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in sum_raw()
13654                 p->level--;  in sum_raw()
13657             int _end_lineno = _token->end_lineno;  in sum_raw()
13659             int _end_col_offset = _token->end_col_offset;  in sum_raw()
13663                 p->error_indicator = 1;  in sum_raw()
13664                 p->level--;  in sum_raw()
13669         p->mark = _mark;  in sum_raw()
13670         D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',  in sum_raw()
13671                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '-' term"));  in sum_raw()
13674         if (p->error_indicator) {  in sum_raw()
13675             p->level--;  in sum_raw()
13678         D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term"));  in sum_raw()
13681             (term_var = term_rule(p))  // term  in sum_raw()
13684 …     D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term"));  in sum_raw()
13688         p->mark = _mark;  in sum_raw()
13689         D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',  in sum_raw()
13690                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term"));  in sum_raw()
13694     p->level--;  in sum_raw()
13698 // Left-recursive
13708 term_rule(Parser *p)  in term_rule()  argument
13710     if (p->level++ == MAXSTACK) {  in term_rule()
13711         p->error_indicator = 1;  in term_rule()
13715     if (_PyPegen_is_memoized(p, term_type, &_res)) {  in term_rule()
13716         p->level--;  in term_rule()
13719     int _mark = p->mark;  in term_rule()
13720     int _resmark = p->mark;  in term_rule()
13722         int tmpvar_7 = _PyPegen_update_memo(p, _mark, term_type, _res);  in term_rule()
13724             p->level--;  in term_rule()
13727         p->mark = _mark;  in term_rule()
13728         void *_raw = term_raw(p);  in term_rule()
13729         if (p->error_indicator) {  in term_rule()
13730             p->level--;  in term_rule()
13733         if (_raw == NULL || p->mark <= _resmark)  in term_rule()
13735         _resmark = p->mark;  in term_rule()
13738     p->mark = _resmark;  in term_rule()
13739     p->level--;  in term_rule()
13743 term_raw(Parser *p)  in term_raw()  argument
13745     if (p->level++ == MAXSTACK) {  in term_raw()
13746         p->error_indicator = 1;  in term_raw()
13749     if (p->error_indicator) {  in term_raw()
13750         p->level--;  in term_raw()
13754     int _mark = p->mark;  in term_raw()
13755     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in term_raw()
13756         p->error_indicator = 1;  in term_raw()
13757         p->level--;  in term_raw()
13760     int _start_lineno = p->tokens[_mark]->lineno;  in term_raw()
13762     int _start_col_offset = p->tokens[_mark]->col_offset;  in term_raw()
13765         if (p->error_indicator) {  in term_raw()
13766             p->level--;  in term_raw()
13769 …    D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '*' factor"));  in term_raw()
13774             (a = term_rule(p))  // term  in term_raw()
13776             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in term_raw()
13778             (b = factor_rule(p))  // factor  in term_raw()
13781 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '*' fa…  in term_raw()
13782             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in term_raw()
13784                 p->level--;  in term_raw()
13787             int _end_lineno = _token->end_lineno;  in term_raw()
13789             int _end_col_offset = _token->end_col_offset;  in term_raw()
13793                 p->error_indicator = 1;  in term_raw()
13794                 p->level--;  in term_raw()
13799         p->mark = _mark;  in term_raw()
13800         D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',  in term_raw()
13801                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '*' factor"));  in term_raw()
13804         if (p->error_indicator) {  in term_raw()
13805             p->level--;  in term_raw()
13808 …    D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '/' factor"));  in term_raw()
13813             (a = term_rule(p))  // term  in term_raw()
13815             (_literal = _PyPegen_expect_token(p, 17))  // token='/'  in term_raw()
13817             (b = factor_rule(p))  // factor  in term_raw()
13820 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '/' fa…  in term_raw()
13821             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in term_raw()
13823                 p->level--;  in term_raw()
13826             int _end_lineno = _token->end_lineno;  in term_raw()
13828             int _end_col_offset = _token->end_col_offset;  in term_raw()
13832                 p->error_indicator = 1;  in term_raw()
13833                 p->level--;  in term_raw()
13838         p->mark = _mark;  in term_raw()
13839         D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',  in term_raw()
13840                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '/' factor"));  in term_raw()
13843         if (p->error_indicator) {  in term_raw()
13844             p->level--;  in term_raw()
13847 …   D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '//' factor"));  in term_raw()
13852             (a = term_rule(p))  // term  in term_raw()
13854             (_literal = _PyPegen_expect_token(p, 47))  // token='//'  in term_raw()
13856             (b = factor_rule(p))  // factor  in term_raw()
13859 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '//' f…  in term_raw()
13860             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in term_raw()
13862                 p->level--;  in term_raw()
13865             int _end_lineno = _token->end_lineno;  in term_raw()
13867             int _end_col_offset = _token->end_col_offset;  in term_raw()
13871                 p->error_indicator = 1;  in term_raw()
13872                 p->level--;  in term_raw()
13877         p->mark = _mark;  in term_raw()
13878         D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',  in term_raw()
13879                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '//' factor"));  in term_raw()
13882         if (p->error_indicator) {  in term_raw()
13883             p->level--;  in term_raw()
13886 …    D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '%' factor"));  in term_raw()
13891             (a = term_rule(p))  // term  in term_raw()
13893             (_literal = _PyPegen_expect_token(p, 24))  // token='%'  in term_raw()
13895             (b = factor_rule(p))  // factor  in term_raw()
13898 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '%' fa…  in term_raw()
13899             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in term_raw()
13901                 p->level--;  in term_raw()
13904             int _end_lineno = _token->end_lineno;  in term_raw()
13906             int _end_col_offset = _token->end_col_offset;  in term_raw()
13910                 p->error_indicator = 1;  in term_raw()
13911                 p->level--;  in term_raw()
13916         p->mark = _mark;  in term_raw()
13917         D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',  in term_raw()
13918                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '%' factor"));  in term_raw()
13921         if (p->error_indicator) {  in term_raw()
13922             p->level--;  in term_raw()
13925 …    D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '@' factor"));  in term_raw()
13930             (a = term_rule(p))  // term  in term_raw()
13932             (_literal = _PyPegen_expect_token(p, 49))  // token='@'  in term_raw()
13934             (b = factor_rule(p))  // factor  in term_raw()
13937 …D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '@' fa…  in term_raw()
13938             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in term_raw()
13940                 p->level--;  in term_raw()
13943             int _end_lineno = _token->end_lineno;  in term_raw()
13945             int _end_col_offset = _token->end_col_offset;  in term_raw()
13949                 p->error_indicator = 1;  in term_raw()
13950                 p->level--;  in term_raw()
13955         p->mark = _mark;  in term_raw()
13956         D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',  in term_raw()
13957                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '@' factor"));  in term_raw()
13960         if (p->error_indicator) {  in term_raw()
13961             p->level--;  in term_raw()
13964         D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "factor"));  in term_raw()
13967             (factor_var = factor_rule(p))  // factor  in term_raw()
13970 …  D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "factor"));  in term_raw()
13974         p->mark = _mark;  in term_raw()
13975         D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',  in term_raw()
13976                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "factor"));  in term_raw()
13980     p->level--;  in term_raw()
13984 // factor: '+' factor | '-' factor | '~' factor | power
13986 factor_rule(Parser *p)  in factor_rule()  argument
13988     if (p->level++ == MAXSTACK) {  in factor_rule()
13989         p->error_indicator = 1;  in factor_rule()
13992     if (p->error_indicator) {  in factor_rule()
13993         p->level--;  in factor_rule()
13997     if (_PyPegen_is_memoized(p, factor_type, &_res)) {  in factor_rule()
13998         p->level--;  in factor_rule()
14001     int _mark = p->mark;  in factor_rule()
14002     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in factor_rule()
14003         p->error_indicator = 1;  in factor_rule()
14004         p->level--;  in factor_rule()
14007     int _start_lineno = p->tokens[_mark]->lineno;  in factor_rule()
14009     int _start_col_offset = p->tokens[_mark]->col_offset;  in factor_rule()
14012         if (p->error_indicator) {  in factor_rule()
14013             p->level--;  in factor_rule()
14016         D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+' factor"));  in factor_rule()
14020             (_literal = _PyPegen_expect_token(p, 14))  // token='+'  in factor_rule()
14022             (a = factor_rule(p))  // factor  in factor_rule()
14025 …D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+' facto…  in factor_rule()
14026             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in factor_rule()
14028                 p->level--;  in factor_rule()
14031             int _end_lineno = _token->end_lineno;  in factor_rule()
14033             int _end_col_offset = _token->end_col_offset;  in factor_rule()
14037                 p->error_indicator = 1;  in factor_rule()
14038                 p->level--;  in factor_rule()
14043         p->mark = _mark;  in factor_rule()
14044         D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',  in factor_rule()
14045                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' factor"));  in factor_rule()
14047     { // '-' factor  in factor_rule()
14048         if (p->error_indicator) {  in factor_rule()
14049             p->level--;  in factor_rule()
14052         D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' factor"));  in factor_rule()
14056             (_literal = _PyPegen_expect_token(p, 15))  // token='-'  in factor_rule()
14058             (a = factor_rule(p))  // factor  in factor_rule()
14061 …D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' facto…  in factor_rule()
14062             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in factor_rule()
14064                 p->level--;  in factor_rule()
14067             int _end_lineno = _token->end_lineno;  in factor_rule()
14069             int _end_col_offset = _token->end_col_offset;  in factor_rule()
14073                 p->error_indicator = 1;  in factor_rule()
14074                 p->level--;  in factor_rule()
14079         p->mark = _mark;  in factor_rule()
14080         D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',  in factor_rule()
14081                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' factor"));  in factor_rule()
14084         if (p->error_indicator) {  in factor_rule()
14085             p->level--;  in factor_rule()
14088         D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~' factor"));  in factor_rule()
14092             (_literal = _PyPegen_expect_token(p, 31))  // token='~'  in factor_rule()
14094             (a = factor_rule(p))  // factor  in factor_rule()
14097 …D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~' facto…  in factor_rule()
14098             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in factor_rule()
14100                 p->level--;  in factor_rule()
14103             int _end_lineno = _token->end_lineno;  in factor_rule()
14105             int _end_col_offset = _token->end_col_offset;  in factor_rule()
14109                 p->error_indicator = 1;  in factor_rule()
14110                 p->level--;  in factor_rule()
14115         p->mark = _mark;  in factor_rule()
14116         D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',  in factor_rule()
14117                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~' factor"));  in factor_rule()
14120         if (p->error_indicator) {  in factor_rule()
14121             p->level--;  in factor_rule()
14124         D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "power"));  in factor_rule()
14127             (power_var = power_rule(p))  // power  in factor_rule()
14130 … D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "power"));  in factor_rule()
14134         p->mark = _mark;  in factor_rule()
14135         D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',  in factor_rule()
14136                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "power"));  in factor_rule()
14140     _PyPegen_insert_memo(p, _mark, factor_type, _res);  in factor_rule()
14141     p->level--;  in factor_rule()
14147 power_rule(Parser *p)  in power_rule()  argument
14149     if (p->level++ == MAXSTACK) {  in power_rule()
14150         p->error_indicator = 1;  in power_rule()
14153     if (p->error_indicator) {  in power_rule()
14154         p->level--;  in power_rule()
14158     int _mark = p->mark;  in power_rule()
14159     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in power_rule()
14160         p->error_indicator = 1;  in power_rule()
14161         p->level--;  in power_rule()
14164     int _start_lineno = p->tokens[_mark]->lineno;  in power_rule()
14166     int _start_col_offset = p->tokens[_mark]->col_offset;  in power_rule()
14169         if (p->error_indicator) {  in power_rule()
14170             p->level--;  in power_rule()
14173 …D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary '**' fa…  in power_rule()
14178             (a = await_primary_rule(p))  // await_primary  in power_rule()
14180             (_literal = _PyPegen_expect_token(p, 35))  // token='**'  in power_rule()
14182             (b = factor_rule(p))  // factor  in power_rule()
14185 …D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_prim…  in power_rule()
14186             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in power_rule()
14188                 p->level--;  in power_rule()
14191             int _end_lineno = _token->end_lineno;  in power_rule()
14193             int _end_col_offset = _token->end_col_offset;  in power_rule()
14197                 p->error_indicator = 1;  in power_rule()
14198                 p->level--;  in power_rule()
14203         p->mark = _mark;  in power_rule()
14204         D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ',  in power_rule()
14205 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary '**' factor"));  in power_rule()
14208         if (p->error_indicator) {  in power_rule()
14209             p->level--;  in power_rule()
14212 …     D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary"));  in power_rule()
14215             (await_primary_var = await_primary_rule(p))  // await_primary  in power_rule()
14218 …D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_prim…  in power_rule()
14222         p->mark = _mark;  in power_rule()
14223         D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ',  in power_rule()
14224                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary"));  in power_rule()
14228     p->level--;  in power_rule()
14234 await_primary_rule(Parser *p)  in await_primary_rule()  argument
14236     if (p->level++ == MAXSTACK) {  in await_primary_rule()
14237         p->error_indicator = 1;  in await_primary_rule()
14240     if (p->error_indicator) {  in await_primary_rule()
14241         p->level--;  in await_primary_rule()
14245     if (_PyPegen_is_memoized(p, await_primary_type, &_res)) {  in await_primary_rule()
14246         p->level--;  in await_primary_rule()
14249     int _mark = p->mark;  in await_primary_rule()
14250     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in await_primary_rule()
14251         p->error_indicator = 1;  in await_primary_rule()
14252         p->level--;  in await_primary_rule()
14255     int _start_lineno = p->tokens[_mark]->lineno;  in await_primary_rule()
14257     int _start_col_offset = p->tokens[_mark]->col_offset;  in await_primary_rule()
14260         if (p->error_indicator) {  in await_primary_rule()
14261             p->level--;  in await_primary_rule()
14264 …D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AWAIT primary…  in await_primary_rule()
14268             (await_var = _PyPegen_expect_token(p, AWAIT))  // token='AWAIT'  in await_primary_rule()
14270             (a = primary_rule(p))  // primary  in await_primary_rule()
14273 …D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AW…  in await_primary_rule()
14274             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in await_primary_rule()
14276                 p->level--;  in await_primary_rule()
14279             int _end_lineno = _token->end_lineno;  in await_primary_rule()
14281             int _end_col_offset = _token->end_col_offset;  in await_primary_rule()
14285                 p->error_indicator = 1;  in await_primary_rule()
14286                 p->level--;  in await_primary_rule()
14291         p->mark = _mark;  in await_primary_rule()
14292         D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ',  in await_primary_rule()
14293                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "AWAIT primary"));  in await_primary_rule()
14296         if (p->error_indicator) {  in await_primary_rule()
14297             p->level--;  in await_primary_rule()
14300 …   D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary"));  in await_primary_rule()
14303             (primary_var = primary_rule(p))  // primary  in await_primary_rule()
14306 …D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pr…  in await_primary_rule()
14310         p->mark = _mark;  in await_primary_rule()
14311         D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ',  in await_primary_rule()
14312                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary"));  in await_primary_rule()
14316     _PyPegen_insert_memo(p, _mark, await_primary_type, _res);  in await_primary_rule()
14317     p->level--;  in await_primary_rule()
14321 // Left-recursive
14330 primary_rule(Parser *p)  in primary_rule()  argument
14332     if (p->level++ == MAXSTACK) {  in primary_rule()
14333         p->error_indicator = 1;  in primary_rule()
14337     if (_PyPegen_is_memoized(p, primary_type, &_res)) {  in primary_rule()
14338         p->level--;  in primary_rule()
14341     int _mark = p->mark;  in primary_rule()
14342     int _resmark = p->mark;  in primary_rule()
14344         int tmpvar_8 = _PyPegen_update_memo(p, _mark, primary_type, _res);  in primary_rule()
14346             p->level--;  in primary_rule()
14349         p->mark = _mark;  in primary_rule()
14350         void *_raw = primary_raw(p);  in primary_rule()
14351         if (p->error_indicator) {  in primary_rule()
14352             p->level--;  in primary_rule()
14355         if (_raw == NULL || p->mark <= _resmark)  in primary_rule()
14357         _resmark = p->mark;  in primary_rule()
14360     p->mark = _resmark;  in primary_rule()
14361     p->level--;  in primary_rule()
14365 primary_raw(Parser *p)  in primary_raw()  argument
14367     if (p->level++ == MAXSTACK) {  in primary_raw()
14368         p->error_indicator = 1;  in primary_raw()
14371     if (p->error_indicator) {  in primary_raw()
14372         p->level--;  in primary_raw()
14376     int _mark = p->mark;  in primary_raw()
14377     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in primary_raw()
14378         p->error_indicator = 1;  in primary_raw()
14379         p->level--;  in primary_raw()
14382     int _start_lineno = p->tokens[_mark]->lineno;  in primary_raw()
14384     int _start_col_offset = p->tokens[_mark]->col_offset;  in primary_raw()
14387         if (p->error_indicator) {  in primary_raw()
14388             p->level--;  in primary_raw()
14391 …D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '.' NAME"));  in primary_raw()
14396             (a = primary_rule(p))  // primary  in primary_raw()
14398             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in primary_raw()
14400             (b = _PyPegen_name_token(p))  // NAME  in primary_raw()
14403 …D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary …  in primary_raw()
14404             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in primary_raw()
14406                 p->level--;  in primary_raw()
14409             int _end_lineno = _token->end_lineno;  in primary_raw()
14411             int _end_col_offset = _token->end_col_offset;  in primary_raw()
14413             _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA );  in primary_raw()
14415                 p->error_indicator = 1;  in primary_raw()
14416                 p->level--;  in primary_raw()
14421         p->mark = _mark;  in primary_raw()
14422         D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',  in primary_raw()
14423                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '.' NAME"));  in primary_raw()
14426         if (p->error_indicator) {  in primary_raw()
14427             p->level--;  in primary_raw()
14430 …  D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary genexp"));  in primary_raw()
14434             (a = primary_rule(p))  // primary  in primary_raw()
14436             (b = genexp_rule(p))  // genexp  in primary_raw()
14439 …D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary …  in primary_raw()
14440             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in primary_raw()
14442                 p->level--;  in primary_raw()
14445             int _end_lineno = _token->end_lineno;  in primary_raw()
14447             int _end_col_offset = _token->end_col_offset;  in primary_raw()
14449 … a , CHECK ( asdl_expr_seq * , ( asdl_expr_seq * ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXT…  in primary_raw()
14451                 p->error_indicator = 1;  in primary_raw()
14452                 p->level--;  in primary_raw()
14457         p->mark = _mark;  in primary_raw()
14458         D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',  in primary_raw()
14459                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary genexp"));  in primary_raw()
14462         if (p->error_indicator) {  in primary_raw()
14463             p->level--;  in primary_raw()
14466 …D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '(' argumen…  in primary_raw()
14472             (a = primary_rule(p))  // primary  in primary_raw()
14474             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in primary_raw()
14476             (b = arguments_rule(p), !p->error_indicator)  // arguments?  in primary_raw()
14478             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in primary_raw()
14481 …D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary …  in primary_raw()
14482             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in primary_raw()
14484                 p->level--;  in primary_raw()
14487             int _end_lineno = _token->end_lineno;  in primary_raw()
14489             int _end_col_offset = _token->end_col_offset;  in primary_raw()
14491 …es = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty )…  in primary_raw()
14493                 p->error_indicator = 1;  in primary_raw()
14494                 p->level--;  in primary_raw()
14499         p->mark = _mark;  in primary_raw()
14500         D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',  in primary_raw()
14501 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '(' arguments? ')'"));  in primary_raw()
14504         if (p->error_indicator) {  in primary_raw()
14505             p->level--;  in primary_raw()
14508 …D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '[' slices …  in primary_raw()
14514             (a = primary_rule(p))  // primary  in primary_raw()
14516             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in primary_raw()
14518             (b = slices_rule(p))  // slices  in primary_raw()
14520             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in primary_raw()
14523 …D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary …  in primary_raw()
14524             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in primary_raw()
14526                 p->level--;  in primary_raw()
14529             int _end_lineno = _token->end_lineno;  in primary_raw()
14531             int _end_col_offset = _token->end_col_offset;  in primary_raw()
14535                 p->error_indicator = 1;  in primary_raw()
14536                 p->level--;  in primary_raw()
14541         p->mark = _mark;  in primary_raw()
14542         D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',  in primary_raw()
14543                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '[' slices ']'"));  in primary_raw()
14546         if (p->error_indicator) {  in primary_raw()
14547             p->level--;  in primary_raw()
14550         D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom"));  in primary_raw()
14553             (atom_var = atom_rule(p))  // atom  in primary_raw()
14556 … D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom"));  in primary_raw()
14560         p->mark = _mark;  in primary_raw()
14561         D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',  in primary_raw()
14562                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom"));  in primary_raw()
14566     p->level--;  in primary_raw()
14572 slices_rule(Parser *p)  in slices_rule()  argument
14574     if (p->level++ == MAXSTACK) {  in slices_rule()
14575         p->error_indicator = 1;  in slices_rule()
14578     if (p->error_indicator) {  in slices_rule()
14579         p->level--;  in slices_rule()
14583     int _mark = p->mark;  in slices_rule()
14584     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in slices_rule()
14585         p->error_indicator = 1;  in slices_rule()
14586         p->level--;  in slices_rule()
14589     int _start_lineno = p->tokens[_mark]->lineno;  in slices_rule()
14591     int _start_col_offset = p->tokens[_mark]->col_offset;  in slices_rule()
14594         if (p->error_indicator) {  in slices_rule()
14595             p->level--;  in slices_rule()
14598         D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice !','"));  in slices_rule()
14601             (a = slice_rule(p))  // slice  in slices_rule()
14603             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)  // token=','  in slices_rule()
14606 …D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice !',…  in slices_rule()
14609                 p->error_indicator = 1;  in slices_rule()
14610                 p->level--;  in slices_rule()
14615         p->mark = _mark;  in slices_rule()
14616         D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ',  in slices_rule()
14617                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice !','"));  in slices_rule()
14620         if (p->error_indicator) {  in slices_rule()
14621             p->level--;  in slices_rule()
14624 …  D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.slice+ ','?"));  in slices_rule()
14629             (a = (asdl_expr_seq*)_gather_108_rule(p))  // ','.slice+  in slices_rule()
14631             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in slices_rule()
14634 …D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.slice…  in slices_rule()
14635             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in slices_rule()
14637                 p->level--;  in slices_rule()
14640             int _end_lineno = _token->end_lineno;  in slices_rule()
14642             int _end_col_offset = _token->end_col_offset;  in slices_rule()
14646                 p->error_indicator = 1;  in slices_rule()
14647                 p->level--;  in slices_rule()
14652         p->mark = _mark;  in slices_rule()
14653         D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ',  in slices_rule()
14654                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.slice+ ','?"));  in slices_rule()
14658     p->level--;  in slices_rule()
14664 slice_rule(Parser *p)  in slice_rule()  argument
14666     if (p->level++ == MAXSTACK) {  in slice_rule()
14667         p->error_indicator = 1;  in slice_rule()
14670     if (p->error_indicator) {  in slice_rule()
14671         p->level--;  in slice_rule()
14675     int _mark = p->mark;  in slice_rule()
14676     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in slice_rule()
14677         p->error_indicator = 1;  in slice_rule()
14678         p->level--;  in slice_rule()
14681     int _start_lineno = p->tokens[_mark]->lineno;  in slice_rule()
14683     int _start_col_offset = p->tokens[_mark]->col_offset;  in slice_rule()
14686         if (p->error_indicator) {  in slice_rule()
14687             p->level--;  in slice_rule()
14690 …D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression? ':' expre…  in slice_rule()
14696             (a = expression_rule(p), !p->error_indicator)  // expression?  in slice_rule()
14698             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in slice_rule()
14700             (b = expression_rule(p), !p->error_indicator)  // expression?  in slice_rule()
14702             (c = _tmp_110_rule(p), !p->error_indicator)  // [':' expression?]  in slice_rule()
14705 …D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression…  in slice_rule()
14706             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in slice_rule()
14708                 p->level--;  in slice_rule()
14711             int _end_lineno = _token->end_lineno;  in slice_rule()
14713             int _end_col_offset = _token->end_col_offset;  in slice_rule()
14717                 p->error_indicator = 1;  in slice_rule()
14718                 p->level--;  in slice_rule()
14723         p->mark = _mark;  in slice_rule()
14724         D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',  in slice_rule()
14725 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?…  in slice_rule()
14728         if (p->error_indicator) {  in slice_rule()
14729             p->level--;  in slice_rule()
14732 …  D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));  in slice_rule()
14735             (a = named_expression_rule(p))  // named_expression  in slice_rule()
14738 …D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expr…  in slice_rule()
14741                 p->error_indicator = 1;  in slice_rule()
14742                 p->level--;  in slice_rule()
14747         p->mark = _mark;  in slice_rule()
14748         D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',  in slice_rule()
14749                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));  in slice_rule()
14753     p->level--;  in slice_rule()
14769 atom_rule(Parser *p)  in atom_rule()  argument
14771     if (p->level++ == MAXSTACK) {  in atom_rule()
14772         p->error_indicator = 1;  in atom_rule()
14775     if (p->error_indicator) {  in atom_rule()
14776         p->level--;  in atom_rule()
14780     int _mark = p->mark;  in atom_rule()
14781     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in atom_rule()
14782         p->error_indicator = 1;  in atom_rule()
14783         p->level--;  in atom_rule()
14786     int _start_lineno = p->tokens[_mark]->lineno;  in atom_rule()
14788     int _start_col_offset = p->tokens[_mark]->col_offset;  in atom_rule()
14791         if (p->error_indicator) {  in atom_rule()
14792             p->level--;  in atom_rule()
14795         D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));  in atom_rule()
14798             (name_var = _PyPegen_name_token(p))  // NAME  in atom_rule()
14801 …    D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));  in atom_rule()
14805         p->mark = _mark;  in atom_rule()
14806         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
14807                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));  in atom_rule()
14810         if (p->error_indicator) {  in atom_rule()
14811             p->level--;  in atom_rule()
14814         D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));  in atom_rule()
14817             (_keyword = _PyPegen_expect_token(p, 524))  // token='True'  in atom_rule()
14820 …  D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));  in atom_rule()
14821             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in atom_rule()
14823                 p->level--;  in atom_rule()
14826             int _end_lineno = _token->end_lineno;  in atom_rule()
14828             int _end_col_offset = _token->end_col_offset;  in atom_rule()
14832                 p->error_indicator = 1;  in atom_rule()
14833                 p->level--;  in atom_rule()
14838         p->mark = _mark;  in atom_rule()
14839         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
14840                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));  in atom_rule()
14843         if (p->error_indicator) {  in atom_rule()
14844             p->level--;  in atom_rule()
14847         D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));  in atom_rule()
14850             (_keyword = _PyPegen_expect_token(p, 525))  // token='False'  in atom_rule()
14853 … D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));  in atom_rule()
14854             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in atom_rule()
14856                 p->level--;  in atom_rule()
14859             int _end_lineno = _token->end_lineno;  in atom_rule()
14861             int _end_col_offset = _token->end_col_offset;  in atom_rule()
14865                 p->error_indicator = 1;  in atom_rule()
14866                 p->level--;  in atom_rule()
14871         p->mark = _mark;  in atom_rule()
14872         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
14873                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));  in atom_rule()
14876         if (p->error_indicator) {  in atom_rule()
14877             p->level--;  in atom_rule()
14880         D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));  in atom_rule()
14883             (_keyword = _PyPegen_expect_token(p, 523))  // token='None'  in atom_rule()
14886 …  D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));  in atom_rule()
14887             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in atom_rule()
14889                 p->level--;  in atom_rule()
14892             int _end_lineno = _token->end_lineno;  in atom_rule()
14894             int _end_col_offset = _token->end_col_offset;  in atom_rule()
14898                 p->error_indicator = 1;  in atom_rule()
14899                 p->level--;  in atom_rule()
14904         p->mark = _mark;  in atom_rule()
14905         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
14906                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));  in atom_rule()
14909         if (p->error_indicator) {  in atom_rule()
14910             p->level--;  in atom_rule()
14913 …    D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&STRING strings"));  in atom_rule()
14916             _PyPegen_lookahead(1, _PyPegen_string_token, p)  in atom_rule()
14918             (strings_var = strings_rule(p))  // strings  in atom_rule()
14921 …D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&STRING str…  in atom_rule()
14925         p->mark = _mark;  in atom_rule()
14926         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
14927                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&STRING strings"));  in atom_rule()
14930         if (p->error_indicator) {  in atom_rule()
14931             p->level--;  in atom_rule()
14934         D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));  in atom_rule()
14937             (number_var = _PyPegen_number_token(p))  // NUMBER  in atom_rule()
14940 …  D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));  in atom_rule()
14944         p->mark = _mark;  in atom_rule()
14945         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
14946                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));  in atom_rule()
14949         if (p->error_indicator) {  in atom_rule()
14950             p->level--;  in atom_rule()
14953 …D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | …  in atom_rule()
14956             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7)  // token='('  in atom_rule()
14958             (_tmp_111_var = _tmp_111_rule(p))  // tuple | group | genexp  in atom_rule()
14961 …D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (tuple…  in atom_rule()
14965         p->mark = _mark;  in atom_rule()
14966         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
14967 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (tuple | group | genexp)"));  in atom_rule()
14970         if (p->error_indicator) {  in atom_rule()
14971             p->level--;  in atom_rule()
14974 …D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)…  in atom_rule()
14977             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9)  // token='['  in atom_rule()
14979             (_tmp_112_var = _tmp_112_rule(p))  // list | listcomp  in atom_rule()
14982 …D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (list …  in atom_rule()
14986         p->mark = _mark;  in atom_rule()
14987         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
14988                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (list | listcomp)"));  in atom_rule()
14991         if (p->error_indicator) {  in atom_rule()
14992             p->level--;  in atom_rule()
14995 …D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dic…  in atom_rule()
14998             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25)  // token='{'  in atom_rule()
15000             (_tmp_113_var = _tmp_113_rule(p))  // dict | set | dictcomp | setcomp  in atom_rule()
15003 …D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dict …  in atom_rule()
15007         p->mark = _mark;  in atom_rule()
15008         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
15009 …   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));  in atom_rule()
15012         if (p->error_indicator) {  in atom_rule()
15013             p->level--;  in atom_rule()
15016         D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));  in atom_rule()
15019             (_literal = _PyPegen_expect_token(p, 52))  // token='...'  in atom_rule()
15022 …   D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));  in atom_rule()
15023             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in atom_rule()
15025                 p->level--;  in atom_rule()
15028             int _end_lineno = _token->end_lineno;  in atom_rule()
15030             int _end_col_offset = _token->end_col_offset;  in atom_rule()
15034                 p->error_indicator = 1;  in atom_rule()
15035                 p->level--;  in atom_rule()
15040         p->mark = _mark;  in atom_rule()
15041         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',  in atom_rule()
15042                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));  in atom_rule()
15046     p->level--;  in atom_rule()
15052 strings_rule(Parser *p)  in strings_rule()  argument
15054     if (p->level++ == MAXSTACK) {  in strings_rule()
15055         p->error_indicator = 1;  in strings_rule()
15058     if (p->error_indicator) {  in strings_rule()
15059         p->level--;  in strings_rule()
15063     if (_PyPegen_is_memoized(p, strings_type, &_res)) {  in strings_rule()
15064         p->level--;  in strings_rule()
15067     int _mark = p->mark;  in strings_rule()
15069         if (p->error_indicator) {  in strings_rule()
15070             p->level--;  in strings_rule()
15073         D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING+"));  in strings_rule()
15076             (a = _loop1_114_rule(p))  // STRING+  in strings_rule()
15079 …D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "STRING+"…  in strings_rule()
15080             _res = _PyPegen_concatenate_strings ( p , a );  in strings_rule()
15082                 p->error_indicator = 1;  in strings_rule()
15083                 p->level--;  in strings_rule()
15088         p->mark = _mark;  in strings_rule()
15089         D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ',  in strings_rule()
15090                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING+"));  in strings_rule()
15094     _PyPegen_insert_memo(p, _mark, strings_type, _res);  in strings_rule()
15095     p->level--;  in strings_rule()
15101 list_rule(Parser *p)  in list_rule()  argument
15103     if (p->level++ == MAXSTACK) {  in list_rule()
15104         p->error_indicator = 1;  in list_rule()
15107     if (p->error_indicator) {  in list_rule()
15108         p->level--;  in list_rule()
15112     int _mark = p->mark;  in list_rule()
15113     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in list_rule()
15114         p->error_indicator = 1;  in list_rule()
15115         p->level--;  in list_rule()
15118     int _start_lineno = p->tokens[_mark]->lineno;  in list_rule()
15120     int _start_col_offset = p->tokens[_mark]->col_offset;  in list_rule()
15123         if (p->error_indicator) {  in list_rule()
15124             p->level--;  in list_rule()
15127 …D(fprintf(stderr, "%*c> list[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_express…  in list_rule()
15132             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in list_rule()
15134             (a = star_named_expressions_rule(p), !p->error_indicator)  // star_named_expressions?  in list_rule()
15136             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in list_rule()
15139 …D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_na…  in list_rule()
15140             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in list_rule()
15142                 p->level--;  in list_rule()
15145             int _end_lineno = _token->end_lineno;  in list_rule()
15147             int _end_col_offset = _token->end_col_offset;  in list_rule()
15151                 p->error_indicator = 1;  in list_rule()
15152                 p->level--;  in list_rule()
15157         p->mark = _mark;  in list_rule()
15158         D(fprintf(stderr, "%*c%s list[%d-%d]: %s failed!\n", p->level, ' ',  in list_rule()
15159 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_named_expressions? ']'"));  in list_rule()
15163     p->level--;  in list_rule()
15169 listcomp_rule(Parser *p)  in listcomp_rule()  argument
15171     if (p->level++ == MAXSTACK) {  in listcomp_rule()
15172         p->error_indicator = 1;  in listcomp_rule()
15175     if (p->error_indicator) {  in listcomp_rule()
15176         p->level--;  in listcomp_rule()
15180     int _mark = p->mark;  in listcomp_rule()
15181     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in listcomp_rule()
15182         p->error_indicator = 1;  in listcomp_rule()
15183         p->level--;  in listcomp_rule()
15186     int _start_lineno = p->tokens[_mark]->lineno;  in listcomp_rule()
15188     int _start_col_offset = p->tokens[_mark]->col_offset;  in listcomp_rule()
15191         if (p->error_indicator) {  in listcomp_rule()
15192             p->level--;  in listcomp_rule()
15195 …D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' named_expressi…  in listcomp_rule()
15201             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in listcomp_rule()
15203             (a = named_expression_rule(p))  // named_expression  in listcomp_rule()
15205             (b = for_if_clauses_rule(p))  // for_if_clauses  in listcomp_rule()
15207             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in listcomp_rule()
15210 …D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' nam…  in listcomp_rule()
15211             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in listcomp_rule()
15213                 p->level--;  in listcomp_rule()
15216             int _end_lineno = _token->end_lineno;  in listcomp_rule()
15218             int _end_col_offset = _token->end_col_offset;  in listcomp_rule()
15222                 p->error_indicator = 1;  in listcomp_rule()
15223                 p->level--;  in listcomp_rule()
15228         p->mark = _mark;  in listcomp_rule()
15229         D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ',  in listcomp_rule()
15230 …  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' named_expression for_if_clauses ']'"));  in listcomp_rule()
15232     if (p->call_invalid_rules) { // invalid_comprehension  in listcomp_rule()
15233         if (p->error_indicator) {  in listcomp_rule()
15234             p->level--;  in listcomp_rule()
15237 …D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehens…  in listcomp_rule()
15240             (invalid_comprehension_var = invalid_comprehension_rule(p))  // invalid_comprehension  in listcomp_rule()
15243 …D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid…  in listcomp_rule()
15247         p->mark = _mark;  in listcomp_rule()
15248         D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ',  in listcomp_rule()
15249                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension"));  in listcomp_rule()
15253     p->level--;  in listcomp_rule()
15259 tuple_rule(Parser *p)  in tuple_rule()  argument
15261     if (p->level++ == MAXSTACK) {  in tuple_rule()
15262         p->error_indicator = 1;  in tuple_rule()
15265     if (p->error_indicator) {  in tuple_rule()
15266         p->level--;  in tuple_rule()
15270     int _mark = p->mark;  in tuple_rule()
15271     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in tuple_rule()
15272         p->error_indicator = 1;  in tuple_rule()
15273         p->level--;  in tuple_rule()
15276     int _start_lineno = p->tokens[_mark]->lineno;  in tuple_rule()
15278     int _start_col_offset = p->tokens[_mark]->col_offset;  in tuple_rule()
15281         if (p->error_indicator) {  in tuple_rule()
15282             p->level--;  in tuple_rule()
15285 …D(fprintf(stderr, "%*c> tuple[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expre…  in tuple_rule()
15290             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in tuple_rule()
15292 …(a = _tmp_115_rule(p), !p->error_indicator)  // [star_named_expression ',' star_named_expressions?]  in tuple_rule()
15294             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in tuple_rule()
15297 …D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_…  in tuple_rule()
15298             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in tuple_rule()
15300                 p->level--;  in tuple_rule()
15303             int _end_lineno = _token->end_lineno;  in tuple_rule()
15305             int _end_col_offset = _token->end_col_offset;  in tuple_rule()
15309                 p->error_indicator = 1;  in tuple_rule()
15310                 p->level--;  in tuple_rule()
15315         p->mark = _mark;  in tuple_rule()
15316         D(fprintf(stderr, "%*c%s tuple[%d-%d]: %s failed!\n", p->level, ' ',  in tuple_rule()
15317 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' [star_named_expression ',' star_named_ex…  in tuple_rule()
15321     p->level--;  in tuple_rule()
15327 group_rule(Parser *p)  in group_rule()  argument
15329     if (p->level++ == MAXSTACK) {  in group_rule()
15330         p->error_indicator = 1;  in group_rule()
15333     if (p->error_indicator) {  in group_rule()
15334         p->level--;  in group_rule()
15338     int _mark = p->mark;  in group_rule()
15340         if (p->error_indicator) {  in group_rule()
15341             p->level--;  in group_rule()
15344 …D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | nam…  in group_rule()
15349             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in group_rule()
15351             (a = _tmp_116_rule(p))  // yield_expr | named_expression  in group_rule()
15353             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in group_rule()
15356 …D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (yield…  in group_rule()
15359                 p->error_indicator = 1;  in group_rule()
15360                 p->level--;  in group_rule()
15365         p->mark = _mark;  in group_rule()
15366         D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ',  in group_rule()
15367 …  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));  in group_rule()
15369     if (p->call_invalid_rules) { // invalid_group  in group_rule()
15370         if (p->error_indicator) {  in group_rule()
15371             p->level--;  in group_rule()
15374 …     D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_group"));  in group_rule()
15377             (invalid_group_var = invalid_group_rule(p))  // invalid_group  in group_rule()
15380 …D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_gr…  in group_rule()
15384         p->mark = _mark;  in group_rule()
15385         D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ',  in group_rule()
15386                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_group"));  in group_rule()
15390     p->level--;  in group_rule()
15398 genexp_rule(Parser *p)  in genexp_rule()  argument
15400     if (p->level++ == MAXSTACK) {  in genexp_rule()
15401         p->error_indicator = 1;  in genexp_rule()
15404     if (p->error_indicator) {  in genexp_rule()
15405         p->level--;  in genexp_rule()
15409     int _mark = p->mark;  in genexp_rule()
15410     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in genexp_rule()
15411         p->error_indicator = 1;  in genexp_rule()
15412         p->level--;  in genexp_rule()
15415     int _start_lineno = p->tokens[_mark]->lineno;  in genexp_rule()
15417     int _start_col_offset = p->tokens[_mark]->col_offset;  in genexp_rule()
15420         if (p->error_indicator) {  in genexp_rule()
15421             p->level--;  in genexp_rule()
15424 …D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expr…  in genexp_rule()
15430             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in genexp_rule()
15432             (a = _tmp_117_rule(p))  // assignment_expression | expression !':='  in genexp_rule()
15434             (b = for_if_clauses_rule(p))  // for_if_clauses  in genexp_rule()
15436             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in genexp_rule()
15439 …D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (assi…  in genexp_rule()
15440             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in genexp_rule()
15442                 p->level--;  in genexp_rule()
15445             int _end_lineno = _token->end_lineno;  in genexp_rule()
15447             int _end_col_offset = _token->end_col_offset;  in genexp_rule()
15451                 p->error_indicator = 1;  in genexp_rule()
15452                 p->level--;  in genexp_rule()
15457         p->mark = _mark;  in genexp_rule()
15458         D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ',  in genexp_rule()
15459 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (assignment_expression | expression !':=…  in genexp_rule()
15461     if (p->call_invalid_rules) { // invalid_comprehension  in genexp_rule()
15462         if (p->error_indicator) {  in genexp_rule()
15463             p->level--;  in genexp_rule()
15466 …D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehensio…  in genexp_rule()
15469             (invalid_comprehension_var = invalid_comprehension_rule(p))  // invalid_comprehension  in genexp_rule()
15472 …D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_c…  in genexp_rule()
15476         p->mark = _mark;  in genexp_rule()
15477         D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ',  in genexp_rule()
15478                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension"));  in genexp_rule()
15482     p->level--;  in genexp_rule()
15488 set_rule(Parser *p)  in set_rule()  argument
15490     if (p->level++ == MAXSTACK) {  in set_rule()
15491         p->error_indicator = 1;  in set_rule()
15494     if (p->error_indicator) {  in set_rule()
15495         p->level--;  in set_rule()
15499     int _mark = p->mark;  in set_rule()
15500     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in set_rule()
15501         p->error_indicator = 1;  in set_rule()
15502         p->level--;  in set_rule()
15505     int _start_lineno = p->tokens[_mark]->lineno;  in set_rule()
15507     int _start_col_offset = p->tokens[_mark]->col_offset;  in set_rule()
15510         if (p->error_indicator) {  in set_rule()
15511             p->level--;  in set_rule()
15514 …D(fprintf(stderr, "%*c> set[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressi…  in set_rule()
15519             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in set_rule()
15521             (a = star_named_expressions_rule(p))  // star_named_expressions  in set_rule()
15523             (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'  in set_rule()
15526 …D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_nam…  in set_rule()
15527             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in set_rule()
15529                 p->level--;  in set_rule()
15532             int _end_lineno = _token->end_lineno;  in set_rule()
15534             int _end_col_offset = _token->end_col_offset;  in set_rule()
15538                 p->error_indicator = 1;  in set_rule()
15539                 p->level--;  in set_rule()
15544         p->mark = _mark;  in set_rule()
15545         D(fprintf(stderr, "%*c%s set[%d-%d]: %s failed!\n", p->level, ' ',  in set_rule()
15546 …           p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' star_named_expressions '}'"));  in set_rule()
15550     p->level--;  in set_rule()
15556 setcomp_rule(Parser *p)  in setcomp_rule()  argument
15558     if (p->level++ == MAXSTACK) {  in setcomp_rule()
15559         p->error_indicator = 1;  in setcomp_rule()
15562     if (p->error_indicator) {  in setcomp_rule()
15563         p->level--;  in setcomp_rule()
15567     int _mark = p->mark;  in setcomp_rule()
15568     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in setcomp_rule()
15569         p->error_indicator = 1;  in setcomp_rule()
15570         p->level--;  in setcomp_rule()
15573     int _start_lineno = p->tokens[_mark]->lineno;  in setcomp_rule()
15575     int _start_col_offset = p->tokens[_mark]->col_offset;  in setcomp_rule()
15578         if (p->error_indicator) {  in setcomp_rule()
15579             p->level--;  in setcomp_rule()
15582 …D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' named_expressio…  in setcomp_rule()
15588             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in setcomp_rule()
15590             (a = named_expression_rule(p))  // named_expression  in setcomp_rule()
15592             (b = for_if_clauses_rule(p))  // for_if_clauses  in setcomp_rule()
15594             (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'  in setcomp_rule()
15597 …D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' name…  in setcomp_rule()
15598             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in setcomp_rule()
15600                 p->level--;  in setcomp_rule()
15603             int _end_lineno = _token->end_lineno;  in setcomp_rule()
15605             int _end_col_offset = _token->end_col_offset;  in setcomp_rule()
15609                 p->error_indicator = 1;  in setcomp_rule()
15610                 p->level--;  in setcomp_rule()
15615         p->mark = _mark;  in setcomp_rule()
15616         D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ',  in setcomp_rule()
15617 …  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' named_expression for_if_clauses '}'"));  in setcomp_rule()
15619     if (p->call_invalid_rules) { // invalid_comprehension  in setcomp_rule()
15620         if (p->error_indicator) {  in setcomp_rule()
15621             p->level--;  in setcomp_rule()
15624 …D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehensi…  in setcomp_rule()
15627             (invalid_comprehension_var = invalid_comprehension_rule(p))  // invalid_comprehension  in setcomp_rule()
15630 …D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_…  in setcomp_rule()
15634         p->mark = _mark;  in setcomp_rule()
15635         D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ',  in setcomp_rule()
15636                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension"));  in setcomp_rule()
15640     p->level--;  in setcomp_rule()
15646 dict_rule(Parser *p)  in dict_rule()  argument
15648     if (p->level++ == MAXSTACK) {  in dict_rule()
15649         p->error_indicator = 1;  in dict_rule()
15652     if (p->error_indicator) {  in dict_rule()
15653         p->level--;  in dict_rule()
15657     int _mark = p->mark;  in dict_rule()
15658     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in dict_rule()
15659         p->error_indicator = 1;  in dict_rule()
15660         p->level--;  in dict_rule()
15663     int _start_lineno = p->tokens[_mark]->lineno;  in dict_rule()
15665     int _start_col_offset = p->tokens[_mark]->col_offset;  in dict_rule()
15668         if (p->error_indicator) {  in dict_rule()
15669             p->level--;  in dict_rule()
15672 …D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvp…  in dict_rule()
15677             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in dict_rule()
15679             (a = double_starred_kvpairs_rule(p), !p->error_indicator)  // double_starred_kvpairs?  in dict_rule()
15681             (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'  in dict_rule()
15684 …D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_…  in dict_rule()
15685             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in dict_rule()
15687                 p->level--;  in dict_rule()
15690             int _end_lineno = _token->end_lineno;  in dict_rule()
15692             int _end_col_offset = _token->end_col_offset;  in dict_rule()
15694 …CHECK ( asdl_expr_seq * , _PyPegen_get_keys ( p , a ) ) , CHECK ( asdl_expr_seq * , _PyPegen_get_v…  in dict_rule()
15696                 p->error_indicator = 1;  in dict_rule()
15697                 p->level--;  in dict_rule()
15702         p->mark = _mark;  in dict_rule()
15703         D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ',  in dict_rule()
15704 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_starred_kvpairs? '}'"));  in dict_rule()
15707         if (p->error_indicator) {  in dict_rule()
15708             p->level--;  in dict_rule()
15711 …D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' invalid_double_sta…  in dict_rule()
15716             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in dict_rule()
15718 …(invalid_double_starred_kvpairs_var = invalid_double_starred_kvpairs_rule(p))  // invalid_double_s…  in dict_rule()
15720             (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'  in dict_rule()
15723 …D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' invalid…  in dict_rule()
15724             _res = _PyPegen_dummy_name(p, _literal, invalid_double_starred_kvpairs_var, _literal_1);  in dict_rule()
15727         p->mark = _mark;  in dict_rule()
15728         D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ',  in dict_rule()
15729 …   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' invalid_double_starred_kvpairs '}'"));  in dict_rule()
15733     p->level--;  in dict_rule()
15739 dictcomp_rule(Parser *p)  in dictcomp_rule()  argument
15741     if (p->level++ == MAXSTACK) {  in dictcomp_rule()
15742         p->error_indicator = 1;  in dictcomp_rule()
15745     if (p->error_indicator) {  in dictcomp_rule()
15746         p->level--;  in dictcomp_rule()
15750     int _mark = p->mark;  in dictcomp_rule()
15751     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in dictcomp_rule()
15752         p->error_indicator = 1;  in dictcomp_rule()
15753         p->level--;  in dictcomp_rule()
15756     int _start_lineno = p->tokens[_mark]->lineno;  in dictcomp_rule()
15758     int _start_col_offset = p->tokens[_mark]->col_offset;  in dictcomp_rule()
15761         if (p->error_indicator) {  in dictcomp_rule()
15762             p->level--;  in dictcomp_rule()
15765 …D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_…  in dictcomp_rule()
15771             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in dictcomp_rule()
15773             (a = kvpair_rule(p))  // kvpair  in dictcomp_rule()
15775             (b = for_if_clauses_rule(p))  // for_if_clauses  in dictcomp_rule()
15777             (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'  in dictcomp_rule()
15780 …D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' kvp…  in dictcomp_rule()
15781             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in dictcomp_rule()
15783                 p->level--;  in dictcomp_rule()
15786             int _end_lineno = _token->end_lineno;  in dictcomp_rule()
15788             int _end_col_offset = _token->end_col_offset;  in dictcomp_rule()
15790             _res = _PyAST_DictComp ( a -> key , a -> value , b , EXTRA );  in dictcomp_rule()
15792                 p->error_indicator = 1;  in dictcomp_rule()
15793                 p->level--;  in dictcomp_rule()
15798         p->mark = _mark;  in dictcomp_rule()
15799         D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ',  in dictcomp_rule()
15800 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' kvpair for_if_clauses '}'"));  in dictcomp_rule()
15802     if (p->call_invalid_rules) { // invalid_dict_comprehension  in dictcomp_rule()
15803         if (p->error_indicator) {  in dictcomp_rule()
15804             p->level--;  in dictcomp_rule()
15807 …D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_dict_compr…  in dictcomp_rule()
15810 …(invalid_dict_comprehension_var = invalid_dict_comprehension_rule(p))  // invalid_dict_comprehensi…  in dictcomp_rule()
15813 …D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid…  in dictcomp_rule()
15817         p->mark = _mark;  in dictcomp_rule()
15818         D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ',  in dictcomp_rule()
15819 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_dict_comprehension"));  in dictcomp_rule()
15823     p->level--;  in dictcomp_rule()
15829 double_starred_kvpairs_rule(Parser *p)  in double_starred_kvpairs_rule()  argument
15831     if (p->level++ == MAXSTACK) {  in double_starred_kvpairs_rule()
15832         p->error_indicator = 1;  in double_starred_kvpairs_rule()
15835     if (p->error_indicator) {  in double_starred_kvpairs_rule()
15836         p->level--;  in double_starred_kvpairs_rule()
15840     int _mark = p->mark;  in double_starred_kvpairs_rule()
15842         if (p->error_indicator) {  in double_starred_kvpairs_rule()
15843             p->level--;  in double_starred_kvpairs_rule()
15846 …D(fprintf(stderr, "%*c> double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.…  in double_starred_kvpairs_rule()
15851             (a = _gather_118_rule(p))  // ','.double_starred_kvpair+  in double_starred_kvpairs_rule()
15853             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in double_starred_kvpairs_rule()
15856 …D(fprintf(stderr, "%*c+ double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->…  in double_starred_kvpairs_rule()
15859                 p->error_indicator = 1;  in double_starred_kvpairs_rule()
15860                 p->level--;  in double_starred_kvpairs_rule()
15865         p->mark = _mark;  in double_starred_kvpairs_rule()
15866         D(fprintf(stderr, "%*c%s double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',  in double_starred_kvpairs_rule()
15867 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ','?"));  in double_starred_kvpairs_rule()
15871     p->level--;  in double_starred_kvpairs_rule()
15877 double_starred_kvpair_rule(Parser *p)  in double_starred_kvpair_rule()  argument
15879     if (p->level++ == MAXSTACK) {  in double_starred_kvpair_rule()
15880         p->error_indicator = 1;  in double_starred_kvpair_rule()
15883     if (p->error_indicator) {  in double_starred_kvpair_rule()
15884         p->level--;  in double_starred_kvpair_rule()
15888     int _mark = p->mark;  in double_starred_kvpair_rule()
15890         if (p->error_indicator) {  in double_starred_kvpair_rule()
15891             p->level--;  in double_starred_kvpair_rule()
15894 …D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' …  in double_starred_kvpair_rule()
15898             (_literal = _PyPegen_expect_token(p, 35))  // token='**'  in double_starred_kvpair_rule()
15900             (a = bitwise_or_rule(p))  // bitwise_or  in double_starred_kvpair_rule()
15903 …D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in double_starred_kvpair_rule()
15904             _res = _PyPegen_key_value_pair ( p , NULL , a );  in double_starred_kvpair_rule()
15906                 p->error_indicator = 1;  in double_starred_kvpair_rule()
15907                 p->level--;  in double_starred_kvpair_rule()
15912         p->mark = _mark;  in double_starred_kvpair_rule()
15913         D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ',  in double_starred_kvpair_rule()
15914                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or"));  in double_starred_kvpair_rule()
15917         if (p->error_indicator) {  in double_starred_kvpair_rule()
15918             p->level--;  in double_starred_kvpair_rule()
15921 …D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kvpai…  in double_starred_kvpair_rule()
15924             (kvpair_var = kvpair_rule(p))  // kvpair  in double_starred_kvpair_rule()
15927 …D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in double_starred_kvpair_rule()
15931         p->mark = _mark;  in double_starred_kvpair_rule()
15932         D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ',  in double_starred_kvpair_rule()
15933                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kvpair"));  in double_starred_kvpair_rule()
15937     p->level--;  in double_starred_kvpair_rule()
15943 kvpair_rule(Parser *p)  in kvpair_rule()  argument
15945     if (p->level++ == MAXSTACK) {  in kvpair_rule()
15946         p->error_indicator = 1;  in kvpair_rule()
15949     if (p->error_indicator) {  in kvpair_rule()
15950         p->level--;  in kvpair_rule()
15954     int _mark = p->mark;  in kvpair_rule()
15956         if (p->error_indicator) {  in kvpair_rule()
15957             p->level--;  in kvpair_rule()
15960 …D(fprintf(stderr, "%*c> kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expre…  in kvpair_rule()
15965             (a = expression_rule(p))  // expression  in kvpair_rule()
15967             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in kvpair_rule()
15969             (b = expression_rule(p))  // expression  in kvpair_rule()
15972 …D(fprintf(stderr, "%*c+ kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressio…  in kvpair_rule()
15973             _res = _PyPegen_key_value_pair ( p , a , b );  in kvpair_rule()
15975                 p->error_indicator = 1;  in kvpair_rule()
15976                 p->level--;  in kvpair_rule()
15981         p->mark = _mark;  in kvpair_rule()
15982         D(fprintf(stderr, "%*c%s kvpair[%d-%d]: %s failed!\n", p->level, ' ',  in kvpair_rule()
15983 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression"));  in kvpair_rule()
15987     p->level--;  in kvpair_rule()
15993 for_if_clauses_rule(Parser *p)  in for_if_clauses_rule()  argument
15995     if (p->level++ == MAXSTACK) {  in for_if_clauses_rule()
15996         p->error_indicator = 1;  in for_if_clauses_rule()
15999     if (p->error_indicator) {  in for_if_clauses_rule()
16000         p->level--;  in for_if_clauses_rule()
16004     int _mark = p->mark;  in for_if_clauses_rule()
16006         if (p->error_indicator) {  in for_if_clauses_rule()
16007             p->level--;  in for_if_clauses_rule()
16010 …D(fprintf(stderr, "%*c> for_if_clauses[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_claus…  in for_if_clauses_rule()
16013             (a = (asdl_comprehension_seq*)_loop1_120_rule(p))  // for_if_clause+  in for_if_clauses_rule()
16016 …D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "f…  in for_if_clauses_rule()
16019                 p->error_indicator = 1;  in for_if_clauses_rule()
16020                 p->level--;  in for_if_clauses_rule()
16025         p->mark = _mark;  in for_if_clauses_rule()
16026         D(fprintf(stderr, "%*c%s for_if_clauses[%d-%d]: %s failed!\n", p->level, ' ',  in for_if_clauses_rule()
16027                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause+"));  in for_if_clauses_rule()
16031     p->level--;  in for_if_clauses_rule()
16040 for_if_clause_rule(Parser *p)  in for_if_clause_rule()  argument
16042     if (p->level++ == MAXSTACK) {  in for_if_clause_rule()
16043         p->error_indicator = 1;  in for_if_clause_rule()
16046     if (p->error_indicator) {  in for_if_clause_rule()
16047         p->level--;  in for_if_clause_rule()
16051     int _mark = p->mark;  in for_if_clause_rule()
16053         if (p->error_indicator) {  in for_if_clause_rule()
16054             p->level--;  in for_if_clause_rule()
16057 …D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' s…  in for_if_clause_rule()
16066             (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'  in for_if_clause_rule()
16068             (_keyword = _PyPegen_expect_token(p, 517))  // token='for'  in for_if_clause_rule()
16070             (a = star_targets_rule(p))  // star_targets  in for_if_clause_rule()
16072             (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'  in for_if_clause_rule()
16076             (b = disjunction_rule(p))  // disjunction  in for_if_clause_rule()
16078             (c = (asdl_expr_seq*)_loop0_121_rule(p))  // (('if' disjunction))*  in for_if_clause_rule()
16081 …D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AS…  in for_if_clause_rule()
16082 …ension_ty , 6 , "Async comprehensions are" , _PyAST_comprehension ( a , b , c , 1 , p -> arena ) );  in for_if_clause_rule()
16084                 p->error_indicator = 1;  in for_if_clause_rule()
16085                 p->level--;  in for_if_clause_rule()
16090         p->mark = _mark;  in for_if_clause_rule()
16091         D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',  in for_if_clause_rule()
16092 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction …  in for_if_clause_rule()
16094             p->level--;  in for_if_clause_rule()
16099         if (p->error_indicator) {  in for_if_clause_rule()
16100             p->level--;  in for_if_clause_rule()
16103 …D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_ta…  in for_if_clause_rule()
16111             (_keyword = _PyPegen_expect_token(p, 517))  // token='for'  in for_if_clause_rule()
16113             (a = star_targets_rule(p))  // star_targets  in for_if_clause_rule()
16115             (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'  in for_if_clause_rule()
16119             (b = disjunction_rule(p))  // disjunction  in for_if_clause_rule()
16121             (c = (asdl_expr_seq*)_loop0_122_rule(p))  // (('if' disjunction))*  in for_if_clause_rule()
16124 …D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f…  in for_if_clause_rule()
16125             _res = _PyAST_comprehension ( a , b , c , 0 , p -> arena );  in for_if_clause_rule()
16127                 p->error_indicator = 1;  in for_if_clause_rule()
16128                 p->level--;  in for_if_clause_rule()
16133         p->mark = _mark;  in for_if_clause_rule()
16134         D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',  in for_if_clause_rule()
16135 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if'…  in for_if_clause_rule()
16137             p->level--;  in for_if_clause_rule()
16141     if (p->call_invalid_rules) { // invalid_for_target  in for_if_clause_rule()
16142         if (p->error_indicator) {  in for_if_clause_rule()
16143             p->level--;  in for_if_clause_rule()
16146 …D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_t…  in for_if_clause_rule()
16149             (invalid_for_target_var = invalid_for_target_rule(p))  // invalid_for_target  in for_if_clause_rule()
16152 …D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in…  in for_if_clause_rule()
16156         p->mark = _mark;  in for_if_clause_rule()
16157         D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',  in for_if_clause_rule()
16158                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target"));  in for_if_clause_rule()
16162     p->level--;  in for_if_clause_rule()
16168 yield_expr_rule(Parser *p)  in yield_expr_rule()  argument
16170     if (p->level++ == MAXSTACK) {  in yield_expr_rule()
16171         p->error_indicator = 1;  in yield_expr_rule()
16174     if (p->error_indicator) {  in yield_expr_rule()
16175         p->level--;  in yield_expr_rule()
16179     int _mark = p->mark;  in yield_expr_rule()
16180     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in yield_expr_rule()
16181         p->error_indicator = 1;  in yield_expr_rule()
16182         p->level--;  in yield_expr_rule()
16185     int _start_lineno = p->tokens[_mark]->lineno;  in yield_expr_rule()
16187     int _start_col_offset = p->tokens[_mark]->col_offset;  in yield_expr_rule()
16190         if (p->error_indicator) {  in yield_expr_rule()
16191             p->level--;  in yield_expr_rule()
16194 …D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' 'from' e…  in yield_expr_rule()
16199             (_keyword = _PyPegen_expect_token(p, 504))  // token='yield'  in yield_expr_rule()
16201             (_keyword_1 = _PyPegen_expect_token(p, 514))  // token='from'  in yield_expr_rule()
16203             (a = expression_rule(p))  // expression  in yield_expr_rule()
16206 …D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yiel…  in yield_expr_rule()
16207             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in yield_expr_rule()
16209                 p->level--;  in yield_expr_rule()
16212             int _end_lineno = _token->end_lineno;  in yield_expr_rule()
16214             int _end_col_offset = _token->end_col_offset;  in yield_expr_rule()
16218                 p->error_indicator = 1;  in yield_expr_rule()
16219                 p->level--;  in yield_expr_rule()
16224         p->mark = _mark;  in yield_expr_rule()
16225         D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ',  in yield_expr_rule()
16226 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' 'from' expression"));  in yield_expr_rule()
16229         if (p->error_indicator) {  in yield_expr_rule()
16230             p->level--;  in yield_expr_rule()
16233 …D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' star_exp…  in yield_expr_rule()
16237             (_keyword = _PyPegen_expect_token(p, 504))  // token='yield'  in yield_expr_rule()
16239             (a = star_expressions_rule(p), !p->error_indicator)  // star_expressions?  in yield_expr_rule()
16242 …D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yiel…  in yield_expr_rule()
16243             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in yield_expr_rule()
16245                 p->level--;  in yield_expr_rule()
16248             int _end_lineno = _token->end_lineno;  in yield_expr_rule()
16250             int _end_col_offset = _token->end_col_offset;  in yield_expr_rule()
16254                 p->error_indicator = 1;  in yield_expr_rule()
16255                 p->level--;  in yield_expr_rule()
16260         p->mark = _mark;  in yield_expr_rule()
16261         D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ',  in yield_expr_rule()
16262 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' star_expressions?"));  in yield_expr_rule()
16266     p->level--;  in yield_expr_rule()
16272 arguments_rule(Parser *p)  in arguments_rule()  argument
16274     if (p->level++ == MAXSTACK) {  in arguments_rule()
16275         p->error_indicator = 1;  in arguments_rule()
16278     if (p->error_indicator) {  in arguments_rule()
16279         p->level--;  in arguments_rule()
16283     if (_PyPegen_is_memoized(p, arguments_type, &_res)) {  in arguments_rule()
16284         p->level--;  in arguments_rule()
16287     int _mark = p->mark;  in arguments_rule()
16289         if (p->error_indicator) {  in arguments_rule()
16290             p->level--;  in arguments_rule()
16293 …D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','? &')'"));  in arguments_rule()
16298             (a = args_rule(p))  // args  in arguments_rule()
16300             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in arguments_rule()
16302             _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'  in arguments_rule()
16305 …D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args '…  in arguments_rule()
16308                 p->error_indicator = 1;  in arguments_rule()
16309                 p->level--;  in arguments_rule()
16314         p->mark = _mark;  in arguments_rule()
16315         D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ',  in arguments_rule()
16316                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','? &')'"));  in arguments_rule()
16318     if (p->call_invalid_rules) { // invalid_arguments  in arguments_rule()
16319         if (p->error_indicator) {  in arguments_rule()
16320             p->level--;  in arguments_rule()
16323 …D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_arguments…  in arguments_rule()
16326             (invalid_arguments_var = invalid_arguments_rule(p))  // invalid_arguments  in arguments_rule()
16329 …D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invali…  in arguments_rule()
16333         p->mark = _mark;  in arguments_rule()
16334         D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ',  in arguments_rule()
16335                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_arguments"));  in arguments_rule()
16339     _PyPegen_insert_memo(p, _mark, arguments_type, _res);  in arguments_rule()
16340     p->level--;  in arguments_rule()
16348 args_rule(Parser *p)  in args_rule()  argument
16350     if (p->level++ == MAXSTACK) {  in args_rule()
16351         p->error_indicator = 1;  in args_rule()
16354     if (p->error_indicator) {  in args_rule()
16355         p->level--;  in args_rule()
16359     int _mark = p->mark;  in args_rule()
16360     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in args_rule()
16361         p->error_indicator = 1;  in args_rule()
16362         p->level--;  in args_rule()
16365     int _start_lineno = p->tokens[_mark]->lineno;  in args_rule()
16367     int _start_col_offset = p->tokens[_mark]->col_offset;  in args_rule()
16370         if (p->error_indicator) {  in args_rule()
16371             p->level--;  in args_rule()
16374 …D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expressio…  in args_rule()
16378 …(a = (asdl_expr_seq*)_gather_123_rule(p))  // ','.(starred_expression | (assignment_expression | e…  in args_rule()
16380             (b = _tmp_125_rule(p), !p->error_indicator)  // [',' kwargs]  in args_rule()
16383 …D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starre…  in args_rule()
16384             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in args_rule()
16386                 p->level--;  in args_rule()
16389             int _end_lineno = _token->end_lineno;  in args_rule()
16391             int _end_col_offset = _token->end_col_offset;  in args_rule()
16393             _res = _PyPegen_collect_call_seqs ( p , a , b , EXTRA );  in args_rule()
16395                 p->error_indicator = 1;  in args_rule()
16396                 p->level--;  in args_rule()
16401         p->mark = _mark;  in args_rule()
16402         D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ',  in args_rule()
16403 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expres…  in args_rule()
16406         if (p->error_indicator) {  in args_rule()
16407             p->level--;  in args_rule()
16410         D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs"));  in args_rule()
16413             (a = kwargs_rule(p))  // kwargs  in args_rule()
16416 …  D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs"));  in args_rule()
16417             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in args_rule()
16419                 p->level--;  in args_rule()
16422             int _end_lineno = _token->end_lineno;  in args_rule()
16424             int _end_col_offset = _token->end_col_offset;  in args_rule()
16426 …p ) , CHECK_NULL_ALLOWED ( asdl_expr_seq * , _PyPegen_seq_extract_starred_exprs ( p , a ) ) , CHEC…  in args_rule()
16428                 p->error_indicator = 1;  in args_rule()
16429                 p->level--;  in args_rule()
16434         p->mark = _mark;  in args_rule()
16435         D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ',  in args_rule()
16436                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs"));  in args_rule()
16440     p->level--;  in args_rule()
16449 kwargs_rule(Parser *p)  in kwargs_rule()  argument
16451     if (p->level++ == MAXSTACK) {  in kwargs_rule()
16452         p->error_indicator = 1;  in kwargs_rule()
16455     if (p->error_indicator) {  in kwargs_rule()
16456         p->level--;  in kwargs_rule()
16460     int _mark = p->mark;  in kwargs_rule()
16462         if (p->error_indicator) {  in kwargs_rule()
16463             p->level--;  in kwargs_rule()
16466 …D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred…  in kwargs_rule()
16471             (a = _gather_126_rule(p))  // ','.kwarg_or_starred+  in kwargs_rule()
16473             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in kwargs_rule()
16475             (b = _gather_128_rule(p))  // ','.kwarg_or_double_starred+  in kwargs_rule()
16478 …D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg…  in kwargs_rule()
16479             _res = _PyPegen_join_sequences ( p , a , b );  in kwargs_rule()
16481                 p->error_indicator = 1;  in kwargs_rule()
16482                 p->level--;  in kwargs_rule()
16487         p->mark = _mark;  in kwargs_rule()
16488         D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ',  in kwargs_rule()
16489 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_doubl…  in kwargs_rule()
16492         if (p->error_indicator) {  in kwargs_rule()
16493             p->level--;  in kwargs_rule()
16496 …D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred…  in kwargs_rule()
16499             (_gather_130_var = _gather_130_rule(p))  // ','.kwarg_or_starred+  in kwargs_rule()
16502 …D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg…  in kwargs_rule()
16506         p->mark = _mark;  in kwargs_rule()
16507         D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ',  in kwargs_rule()
16508                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+"));  in kwargs_rule()
16511         if (p->error_indicator) {  in kwargs_rule()
16512             p->level--;  in kwargs_rule()
16515 …D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_…  in kwargs_rule()
16518             (_gather_132_var = _gather_132_rule(p))  // ','.kwarg_or_double_starred+  in kwargs_rule()
16521 …D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg…  in kwargs_rule()
16525         p->mark = _mark;  in kwargs_rule()
16526         D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ',  in kwargs_rule()
16527 …             p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_double_starred+"));  in kwargs_rule()
16531     p->level--;  in kwargs_rule()
16537 starred_expression_rule(Parser *p)  in starred_expression_rule()  argument
16539     if (p->level++ == MAXSTACK) {  in starred_expression_rule()
16540         p->error_indicator = 1;  in starred_expression_rule()
16543     if (p->error_indicator) {  in starred_expression_rule()
16544         p->level--;  in starred_expression_rule()
16548     int _mark = p->mark;  in starred_expression_rule()
16549     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in starred_expression_rule()
16550         p->error_indicator = 1;  in starred_expression_rule()
16551         p->level--;  in starred_expression_rule()
16554     int _start_lineno = p->tokens[_mark]->lineno;  in starred_expression_rule()
16556     int _start_col_offset = p->tokens[_mark]->col_offset;  in starred_expression_rule()
16559         if (p->error_indicator) {  in starred_expression_rule()
16560             p->level--;  in starred_expression_rule()
16563 …D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expr…  in starred_expression_rule()
16567             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in starred_expression_rule()
16569             (a = expression_rule(p))  // expression  in starred_expression_rule()
16572 …D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in starred_expression_rule()
16573             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in starred_expression_rule()
16575                 p->level--;  in starred_expression_rule()
16578             int _end_lineno = _token->end_lineno;  in starred_expression_rule()
16580             int _end_col_offset = _token->end_col_offset;  in starred_expression_rule()
16584                 p->error_indicator = 1;  in starred_expression_rule()
16585                 p->level--;  in starred_expression_rule()
16590         p->mark = _mark;  in starred_expression_rule()
16591         D(fprintf(stderr, "%*c%s starred_expression[%d-%d]: %s failed!\n", p->level, ' ',  in starred_expression_rule()
16592                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression"));  in starred_expression_rule()
16596     p->level--;  in starred_expression_rule()
16602 kwarg_or_starred_rule(Parser *p)  in kwarg_or_starred_rule()  argument
16604     if (p->level++ == MAXSTACK) {  in kwarg_or_starred_rule()
16605         p->error_indicator = 1;  in kwarg_or_starred_rule()
16608     if (p->error_indicator) {  in kwarg_or_starred_rule()
16609         p->level--;  in kwarg_or_starred_rule()
16613     int _mark = p->mark;  in kwarg_or_starred_rule()
16614     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in kwarg_or_starred_rule()
16615         p->error_indicator = 1;  in kwarg_or_starred_rule()
16616         p->level--;  in kwarg_or_starred_rule()
16619     int _start_lineno = p->tokens[_mark]->lineno;  in kwarg_or_starred_rule()
16621     int _start_col_offset = p->tokens[_mark]->col_offset;  in kwarg_or_starred_rule()
16623     if (p->call_invalid_rules) { // invalid_kwarg  in kwarg_or_starred_rule()
16624         if (p->error_indicator) {  in kwarg_or_starred_rule()
16625             p->level--;  in kwarg_or_starred_rule()
16628 …D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kw…  in kwarg_or_starred_rule()
16631             (invalid_kwarg_var = invalid_kwarg_rule(p))  // invalid_kwarg  in kwarg_or_starred_rule()
16634 …D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in kwarg_or_starred_rule()
16638         p->mark = _mark;  in kwarg_or_starred_rule()
16639         D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',  in kwarg_or_starred_rule()
16640                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg"));  in kwarg_or_starred_rule()
16643         if (p->error_indicator) {  in kwarg_or_starred_rule()
16644             p->level--;  in kwarg_or_starred_rule()
16647 …D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' e…  in kwarg_or_starred_rule()
16652             (a = _PyPegen_name_token(p))  // NAME  in kwarg_or_starred_rule()
16654             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in kwarg_or_starred_rule()
16656             (b = expression_rule(p))  // expression  in kwarg_or_starred_rule()
16659 …D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in kwarg_or_starred_rule()
16660             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in kwarg_or_starred_rule()
16662                 p->level--;  in kwarg_or_starred_rule()
16665             int _end_lineno = _token->end_lineno;  in kwarg_or_starred_rule()
16667             int _end_col_offset = _token->end_col_offset;  in kwarg_or_starred_rule()
16669 …_res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id …  in kwarg_or_starred_rule()
16671                 p->error_indicator = 1;  in kwarg_or_starred_rule()
16672                 p->level--;  in kwarg_or_starred_rule()
16677         p->mark = _mark;  in kwarg_or_starred_rule()
16678         D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',  in kwarg_or_starred_rule()
16679                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression"));  in kwarg_or_starred_rule()
16682         if (p->error_indicator) {  in kwarg_or_starred_rule()
16683             p->level--;  in kwarg_or_starred_rule()
16686 …D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_ex…  in kwarg_or_starred_rule()
16689             (a = starred_expression_rule(p))  // starred_expression  in kwarg_or_starred_rule()
16692 …D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in kwarg_or_starred_rule()
16693             _res = _PyPegen_keyword_or_starred ( p , a , 0 );  in kwarg_or_starred_rule()
16695                 p->error_indicator = 1;  in kwarg_or_starred_rule()
16696                 p->level--;  in kwarg_or_starred_rule()
16701         p->mark = _mark;  in kwarg_or_starred_rule()
16702         D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',  in kwarg_or_starred_rule()
16703                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));  in kwarg_or_starred_rule()
16707     p->level--;  in kwarg_or_starred_rule()
16713 kwarg_or_double_starred_rule(Parser *p)  in kwarg_or_double_starred_rule()  argument
16715     if (p->level++ == MAXSTACK) {  in kwarg_or_double_starred_rule()
16716         p->error_indicator = 1;  in kwarg_or_double_starred_rule()
16719     if (p->error_indicator) {  in kwarg_or_double_starred_rule()
16720         p->level--;  in kwarg_or_double_starred_rule()
16724     int _mark = p->mark;  in kwarg_or_double_starred_rule()
16725     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in kwarg_or_double_starred_rule()
16726         p->error_indicator = 1;  in kwarg_or_double_starred_rule()
16727         p->level--;  in kwarg_or_double_starred_rule()
16730     int _start_lineno = p->tokens[_mark]->lineno;  in kwarg_or_double_starred_rule()
16732     int _start_col_offset = p->tokens[_mark]->col_offset;  in kwarg_or_double_starred_rule()
16734     if (p->call_invalid_rules) { // invalid_kwarg  in kwarg_or_double_starred_rule()
16735         if (p->error_indicator) {  in kwarg_or_double_starred_rule()
16736             p->level--;  in kwarg_or_double_starred_rule()
16739 …D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inv…  in kwarg_or_double_starred_rule()
16742             (invalid_kwarg_var = invalid_kwarg_rule(p))  // invalid_kwarg  in kwarg_or_double_starred_rule()
16745 …D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p-…  in kwarg_or_double_starred_rule()
16749         p->mark = _mark;  in kwarg_or_double_starred_rule()
16750         D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ',  in kwarg_or_double_starred_rule()
16751                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg"));  in kwarg_or_double_starred_rule()
16754         if (p->error_indicator) {  in kwarg_or_double_starred_rule()
16755             p->level--;  in kwarg_or_double_starred_rule()
16758 …D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAM…  in kwarg_or_double_starred_rule()
16763             (a = _PyPegen_name_token(p))  // NAME  in kwarg_or_double_starred_rule()
16765             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in kwarg_or_double_starred_rule()
16767             (b = expression_rule(p))  // expression  in kwarg_or_double_starred_rule()
16770 …D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p-…  in kwarg_or_double_starred_rule()
16771             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in kwarg_or_double_starred_rule()
16773                 p->level--;  in kwarg_or_double_starred_rule()
16776             int _end_lineno = _token->end_lineno;  in kwarg_or_double_starred_rule()
16778             int _end_col_offset = _token->end_col_offset;  in kwarg_or_double_starred_rule()
16780 …_res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id …  in kwarg_or_double_starred_rule()
16782                 p->error_indicator = 1;  in kwarg_or_double_starred_rule()
16783                 p->level--;  in kwarg_or_double_starred_rule()
16788         p->mark = _mark;  in kwarg_or_double_starred_rule()
16789         D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ',  in kwarg_or_double_starred_rule()
16790                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression"));  in kwarg_or_double_starred_rule()
16793         if (p->error_indicator) {  in kwarg_or_double_starred_rule()
16794             p->level--;  in kwarg_or_double_starred_rule()
16797 …D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**…  in kwarg_or_double_starred_rule()
16801             (_literal = _PyPegen_expect_token(p, 35))  // token='**'  in kwarg_or_double_starred_rule()
16803             (a = expression_rule(p))  // expression  in kwarg_or_double_starred_rule()
16806 …D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p-…  in kwarg_or_double_starred_rule()
16807             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in kwarg_or_double_starred_rule()
16809                 p->level--;  in kwarg_or_double_starred_rule()
16812             int _end_lineno = _token->end_lineno;  in kwarg_or_double_starred_rule()
16814             int _end_col_offset = _token->end_col_offset;  in kwarg_or_double_starred_rule()
16816 …_res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( NULL , a , EXTRA ) …  in kwarg_or_double_starred_rule()
16818                 p->error_indicator = 1;  in kwarg_or_double_starred_rule()
16819                 p->level--;  in kwarg_or_double_starred_rule()
16824         p->mark = _mark;  in kwarg_or_double_starred_rule()
16825         D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ',  in kwarg_or_double_starred_rule()
16826                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression"));  in kwarg_or_double_starred_rule()
16830     p->level--;  in kwarg_or_double_starred_rule()
16836 star_targets_rule(Parser *p)  in star_targets_rule()  argument
16838     if (p->level++ == MAXSTACK) {  in star_targets_rule()
16839         p->error_indicator = 1;  in star_targets_rule()
16842     if (p->error_indicator) {  in star_targets_rule()
16843         p->level--;  in star_targets_rule()
16847     int _mark = p->mark;  in star_targets_rule()
16848     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in star_targets_rule()
16849         p->error_indicator = 1;  in star_targets_rule()
16850         p->level--;  in star_targets_rule()
16853     int _start_lineno = p->tokens[_mark]->lineno;  in star_targets_rule()
16855     int _start_col_offset = p->tokens[_mark]->col_offset;  in star_targets_rule()
16858         if (p->error_indicator) {  in star_targets_rule()
16859             p->level--;  in star_targets_rule()
16862 …D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target !'…  in star_targets_rule()
16865             (a = star_target_rule(p))  // star_target  in star_targets_rule()
16867             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)  // token=','  in star_targets_rule()
16870 …D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sta…  in star_targets_rule()
16873                 p->error_indicator = 1;  in star_targets_rule()
16874                 p->level--;  in star_targets_rule()
16879         p->mark = _mark;  in star_targets_rule()
16880         D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ',  in star_targets_rule()
16881                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target !','"));  in star_targets_rule()
16884         if (p->error_indicator) {  in star_targets_rule()
16885             p->level--;  in star_targets_rule()
16888 …D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((…  in star_targets_rule()
16894             (a = star_target_rule(p))  // star_target  in star_targets_rule()
16896             (b = _loop0_134_rule(p))  // ((',' star_target))*  in star_targets_rule()
16898             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in star_targets_rule()
16901 …D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sta…  in star_targets_rule()
16902             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_targets_rule()
16904                 p->level--;  in star_targets_rule()
16907             int _end_lineno = _token->end_lineno;  in star_targets_rule()
16909             int _end_col_offset = _token->end_col_offset;  in star_targets_rule()
16911 …_res = _PyAST_Tuple ( CHECK ( asdl_expr_seq * , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Sto…  in star_targets_rule()
16913                 p->error_indicator = 1;  in star_targets_rule()
16914                 p->level--;  in star_targets_rule()
16919         p->mark = _mark;  in star_targets_rule()
16920         D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ',  in star_targets_rule()
16921 …    p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))* ','?"));  in star_targets_rule()
16925     p->level--;  in star_targets_rule()
16931 star_targets_list_seq_rule(Parser *p)  in star_targets_list_seq_rule()  argument
16933     if (p->level++ == MAXSTACK) {  in star_targets_list_seq_rule()
16934         p->error_indicator = 1;  in star_targets_list_seq_rule()
16937     if (p->error_indicator) {  in star_targets_list_seq_rule()
16938         p->level--;  in star_targets_list_seq_rule()
16942     int _mark = p->mark;  in star_targets_list_seq_rule()
16944         if (p->error_indicator) {  in star_targets_list_seq_rule()
16945             p->level--;  in star_targets_list_seq_rule()
16948 …D(fprintf(stderr, "%*c> star_targets_list_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.s…  in star_targets_list_seq_rule()
16953             (a = (asdl_expr_seq*)_gather_135_rule(p))  // ','.star_target+  in star_targets_list_seq_rule()
16955             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in star_targets_list_seq_rule()
16958 …D(fprintf(stderr, "%*c+ star_targets_list_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in star_targets_list_seq_rule()
16961                 p->error_indicator = 1;  in star_targets_list_seq_rule()
16962                 p->level--;  in star_targets_list_seq_rule()
16967         p->mark = _mark;  in star_targets_list_seq_rule()
16968         D(fprintf(stderr, "%*c%s star_targets_list_seq[%d-%d]: %s failed!\n", p->level, ' ',  in star_targets_list_seq_rule()
16969                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_target+ ','?"));  in star_targets_list_seq_rule()
16973     p->level--;  in star_targets_list_seq_rule()
16979 star_targets_tuple_seq_rule(Parser *p)  in star_targets_tuple_seq_rule()  argument
16981     if (p->level++ == MAXSTACK) {  in star_targets_tuple_seq_rule()
16982         p->error_indicator = 1;  in star_targets_tuple_seq_rule()
16985     if (p->error_indicator) {  in star_targets_tuple_seq_rule()
16986         p->level--;  in star_targets_tuple_seq_rule()
16990     int _mark = p->mark;  in star_targets_tuple_seq_rule()
16992         if (p->error_indicator) {  in star_targets_tuple_seq_rule()
16993             p->level--;  in star_targets_tuple_seq_rule()
16996 …D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star…  in star_targets_tuple_seq_rule()
17002             (a = star_target_rule(p))  // star_target  in star_targets_tuple_seq_rule()
17004             (b = _loop1_137_rule(p))  // ((',' star_target))+  in star_targets_tuple_seq_rule()
17006             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in star_targets_tuple_seq_rule()
17009 …D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->…  in star_targets_tuple_seq_rule()
17010             _res = ( asdl_expr_seq * ) _PyPegen_seq_insert_in_front ( p , a , b );  in star_targets_tuple_seq_rule()
17012                 p->error_indicator = 1;  in star_targets_tuple_seq_rule()
17013                 p->level--;  in star_targets_tuple_seq_rule()
17018         p->mark = _mark;  in star_targets_tuple_seq_rule()
17019         D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ',  in star_targets_tuple_seq_rule()
17020 …    p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))+ ','?"));  in star_targets_tuple_seq_rule()
17023         if (p->error_indicator) {  in star_targets_tuple_seq_rule()
17024             p->level--;  in star_targets_tuple_seq_rule()
17027 …D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star…  in star_targets_tuple_seq_rule()
17031             (a = star_target_rule(p))  // star_target  in star_targets_tuple_seq_rule()
17033             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in star_targets_tuple_seq_rule()
17036 …D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->…  in star_targets_tuple_seq_rule()
17037             _res = ( asdl_expr_seq * ) _PyPegen_singleton_seq ( p , a );  in star_targets_tuple_seq_rule()
17039                 p->error_indicator = 1;  in star_targets_tuple_seq_rule()
17040                 p->level--;  in star_targets_tuple_seq_rule()
17045         p->mark = _mark;  in star_targets_tuple_seq_rule()
17046         D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ',  in star_targets_tuple_seq_rule()
17047                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ','"));  in star_targets_tuple_seq_rule()
17051     p->level--;  in star_targets_tuple_seq_rule()
17057 star_target_rule(Parser *p)  in star_target_rule()  argument
17059     if (p->level++ == MAXSTACK) {  in star_target_rule()
17060         p->error_indicator = 1;  in star_target_rule()
17063     if (p->error_indicator) {  in star_target_rule()
17064         p->level--;  in star_target_rule()
17068     if (_PyPegen_is_memoized(p, star_target_type, &_res)) {  in star_target_rule()
17069         p->level--;  in star_target_rule()
17072     int _mark = p->mark;  in star_target_rule()
17073     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in star_target_rule()
17074         p->error_indicator = 1;  in star_target_rule()
17075         p->level--;  in star_target_rule()
17078     int _start_lineno = p->tokens[_mark]->lineno;  in star_target_rule()
17080     int _start_col_offset = p->tokens[_mark]->col_offset;  in star_target_rule()
17083         if (p->error_indicator) {  in star_target_rule()
17084             p->level--;  in star_target_rule()
17087 …D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_…  in star_target_rule()
17091             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in star_target_rule()
17093             (a = _tmp_138_rule(p))  // !'*' star_target  in star_target_rule()
17096 …D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' …  in star_target_rule()
17097             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_target_rule()
17099                 p->level--;  in star_target_rule()
17102             int _end_lineno = _token->end_lineno;  in star_target_rule()
17104             int _end_col_offset = _token->end_col_offset;  in star_target_rule()
17106 …_res = _PyAST_Starred ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , Store , …  in star_target_rule()
17108                 p->error_indicator = 1;  in star_target_rule()
17109                 p->level--;  in star_target_rule()
17114         p->mark = _mark;  in star_target_rule()
17115         D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ',  in star_target_rule()
17116                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (!'*' star_target)"));  in star_target_rule()
17119         if (p->error_indicator) {  in star_target_rule()
17120             p->level--;  in star_target_rule()
17123 …D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "target_with_sta…  in star_target_rule()
17126             (target_with_star_atom_var = target_with_star_atom_rule(p))  // target_with_star_atom  in star_target_rule()
17129 …D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "targ…  in star_target_rule()
17133         p->mark = _mark;  in star_target_rule()
17134         D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ',  in star_target_rule()
17135                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "target_with_star_atom"));  in star_target_rule()
17139     _PyPegen_insert_memo(p, _mark, star_target_type, _res);  in star_target_rule()
17140     p->level--;  in star_target_rule()
17149 target_with_star_atom_rule(Parser *p)  in target_with_star_atom_rule()  argument
17151     if (p->level++ == MAXSTACK) {  in target_with_star_atom_rule()
17152         p->error_indicator = 1;  in target_with_star_atom_rule()
17155     if (p->error_indicator) {  in target_with_star_atom_rule()
17156         p->level--;  in target_with_star_atom_rule()
17160     if (_PyPegen_is_memoized(p, target_with_star_atom_type, &_res)) {  in target_with_star_atom_rule()
17161         p->level--;  in target_with_star_atom_rule()
17164     int _mark = p->mark;  in target_with_star_atom_rule()
17165     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in target_with_star_atom_rule()
17166         p->error_indicator = 1;  in target_with_star_atom_rule()
17167         p->level--;  in target_with_star_atom_rule()
17170     int _start_lineno = p->tokens[_mark]->lineno;  in target_with_star_atom_rule()
17172     int _start_col_offset = p->tokens[_mark]->col_offset;  in target_with_star_atom_rule()
17175         if (p->error_indicator) {  in target_with_star_atom_rule()
17176             p->level--;  in target_with_star_atom_rule()
17179 …D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_pri…  in target_with_star_atom_rule()
17184             (a = t_primary_rule(p))  // t_primary  in target_with_star_atom_rule()
17186             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in target_with_star_atom_rule()
17188             (b = _PyPegen_name_token(p))  // NAME  in target_with_star_atom_rule()
17190             _PyPegen_lookahead(0, t_lookahead_rule, p)  in target_with_star_atom_rule()
17193 …D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in target_with_star_atom_rule()
17194             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in target_with_star_atom_rule()
17196                 p->level--;  in target_with_star_atom_rule()
17199             int _end_lineno = _token->end_lineno;  in target_with_star_atom_rule()
17201             int _end_col_offset = _token->end_col_offset;  in target_with_star_atom_rule()
17203             _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA );  in target_with_star_atom_rule()
17205                 p->error_indicator = 1;  in target_with_star_atom_rule()
17206                 p->level--;  in target_with_star_atom_rule()
17211         p->mark = _mark;  in target_with_star_atom_rule()
17212         D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ',  in target_with_star_atom_rule()
17213 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead"));  in target_with_star_atom_rule()
17216         if (p->error_indicator) {  in target_with_star_atom_rule()
17217             p->level--;  in target_with_star_atom_rule()
17220 …D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_pri…  in target_with_star_atom_rule()
17226             (a = t_primary_rule(p))  // t_primary  in target_with_star_atom_rule()
17228             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in target_with_star_atom_rule()
17230             (b = slices_rule(p))  // slices  in target_with_star_atom_rule()
17232             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in target_with_star_atom_rule()
17234             _PyPegen_lookahead(0, t_lookahead_rule, p)  in target_with_star_atom_rule()
17237 …D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in target_with_star_atom_rule()
17238             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in target_with_star_atom_rule()
17240                 p->level--;  in target_with_star_atom_rule()
17243             int _end_lineno = _token->end_lineno;  in target_with_star_atom_rule()
17245             int _end_col_offset = _token->end_col_offset;  in target_with_star_atom_rule()
17249                 p->error_indicator = 1;  in target_with_star_atom_rule()
17250                 p->level--;  in target_with_star_atom_rule()
17255         p->mark = _mark;  in target_with_star_atom_rule()
17256         D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ',  in target_with_star_atom_rule()
17257 …    p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));  in target_with_star_atom_rule()
17260         if (p->error_indicator) {  in target_with_star_atom_rule()
17261             p->level--;  in target_with_star_atom_rule()
17264 …D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_…  in target_with_star_atom_rule()
17267             (star_atom_var = star_atom_rule(p))  // star_atom  in target_with_star_atom_rule()
17270 …D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in target_with_star_atom_rule()
17274         p->mark = _mark;  in target_with_star_atom_rule()
17275         D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ',  in target_with_star_atom_rule()
17276                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_atom"));  in target_with_star_atom_rule()
17280     _PyPegen_insert_memo(p, _mark, target_with_star_atom_type, _res);  in target_with_star_atom_rule()
17281     p->level--;  in target_with_star_atom_rule()
17291 star_atom_rule(Parser *p)  in star_atom_rule()  argument
17293     if (p->level++ == MAXSTACK) {  in star_atom_rule()
17294         p->error_indicator = 1;  in star_atom_rule()
17297     if (p->error_indicator) {  in star_atom_rule()
17298         p->level--;  in star_atom_rule()
17302     int _mark = p->mark;  in star_atom_rule()
17303     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in star_atom_rule()
17304         p->error_indicator = 1;  in star_atom_rule()
17305         p->level--;  in star_atom_rule()
17308     int _start_lineno = p->tokens[_mark]->lineno;  in star_atom_rule()
17310     int _start_col_offset = p->tokens[_mark]->col_offset;  in star_atom_rule()
17313         if (p->error_indicator) {  in star_atom_rule()
17314             p->level--;  in star_atom_rule()
17317         D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));  in star_atom_rule()
17320             (a = _PyPegen_name_token(p))  // NAME  in star_atom_rule()
17323 …D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")…  in star_atom_rule()
17324             _res = _PyPegen_set_expr_context ( p , a , Store );  in star_atom_rule()
17326                 p->error_indicator = 1;  in star_atom_rule()
17327                 p->level--;  in star_atom_rule()
17332         p->mark = _mark;  in star_atom_rule()
17333         D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',  in star_atom_rule()
17334                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));  in star_atom_rule()
17337         if (p->error_indicator) {  in star_atom_rule()
17338             p->level--;  in star_atom_rule()
17341 …D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' target_with_s…  in star_atom_rule()
17346             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in star_atom_rule()
17348             (a = target_with_star_atom_rule(p))  // target_with_star_atom  in star_atom_rule()
17350             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in star_atom_rule()
17353 …D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' ta…  in star_atom_rule()
17354             _res = _PyPegen_set_expr_context ( p , a , Store );  in star_atom_rule()
17356                 p->error_indicator = 1;  in star_atom_rule()
17357                 p->level--;  in star_atom_rule()
17362         p->mark = _mark;  in star_atom_rule()
17363         D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',  in star_atom_rule()
17364 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' target_with_star_atom ')'"));  in star_atom_rule()
17367         if (p->error_indicator) {  in star_atom_rule()
17368             p->level--;  in star_atom_rule()
17371 …D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' star_targets_…  in star_atom_rule()
17376             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in star_atom_rule()
17378             (a = star_targets_tuple_seq_rule(p), !p->error_indicator)  // star_targets_tuple_seq?  in star_atom_rule()
17380             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in star_atom_rule()
17383 …D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' st…  in star_atom_rule()
17384             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_atom_rule()
17386                 p->level--;  in star_atom_rule()
17389             int _end_lineno = _token->end_lineno;  in star_atom_rule()
17391             int _end_col_offset = _token->end_col_offset;  in star_atom_rule()
17395                 p->error_indicator = 1;  in star_atom_rule()
17396                 p->level--;  in star_atom_rule()
17401         p->mark = _mark;  in star_atom_rule()
17402         D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',  in star_atom_rule()
17403 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));  in star_atom_rule()
17406         if (p->error_indicator) {  in star_atom_rule()
17407             p->level--;  in star_atom_rule()
17410 …D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_targets_…  in star_atom_rule()
17415             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in star_atom_rule()
17417             (a = star_targets_list_seq_rule(p), !p->error_indicator)  // star_targets_list_seq?  in star_atom_rule()
17419             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in star_atom_rule()
17422 …D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' st…  in star_atom_rule()
17423             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in star_atom_rule()
17425                 p->level--;  in star_atom_rule()
17428             int _end_lineno = _token->end_lineno;  in star_atom_rule()
17430             int _end_col_offset = _token->end_col_offset;  in star_atom_rule()
17434                 p->error_indicator = 1;  in star_atom_rule()
17435                 p->level--;  in star_atom_rule()
17440         p->mark = _mark;  in star_atom_rule()
17441         D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',  in star_atom_rule()
17442 …           p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_targets_list_seq? ']'"));  in star_atom_rule()
17446     p->level--;  in star_atom_rule()
17452 single_target_rule(Parser *p)  in single_target_rule()  argument
17454     if (p->level++ == MAXSTACK) {  in single_target_rule()
17455         p->error_indicator = 1;  in single_target_rule()
17458     if (p->error_indicator) {  in single_target_rule()
17459         p->level--;  in single_target_rule()
17463     int _mark = p->mark;  in single_target_rule()
17465         if (p->error_indicator) {  in single_target_rule()
17466             p->level--;  in single_target_rule()
17469 …D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscr…  in single_target_rule()
17472 …(single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p))  // single_sub…  in single_target_rule()
17475 …D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "si…  in single_target_rule()
17479         p->mark = _mark;  in single_target_rule()
17480         D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ',  in single_target_rule()
17481 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target"));  in single_target_rule()
17484         if (p->error_indicator) {  in single_target_rule()
17485             p->level--;  in single_target_rule()
17488 …      D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));  in single_target_rule()
17491             (a = _PyPegen_name_token(p))  // NAME  in single_target_rule()
17494 …D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NA…  in single_target_rule()
17495             _res = _PyPegen_set_expr_context ( p , a , Store );  in single_target_rule()
17497                 p->error_indicator = 1;  in single_target_rule()
17498                 p->level--;  in single_target_rule()
17503         p->mark = _mark;  in single_target_rule()
17504         D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ',  in single_target_rule()
17505                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));  in single_target_rule()
17508         if (p->error_indicator) {  in single_target_rule()
17509             p->level--;  in single_target_rule()
17512 …D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_ta…  in single_target_rule()
17517             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in single_target_rule()
17519             (a = single_target_rule(p))  // single_target  in single_target_rule()
17521             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in single_target_rule()
17524 …D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(…  in single_target_rule()
17527                 p->error_indicator = 1;  in single_target_rule()
17528                 p->level--;  in single_target_rule()
17533         p->mark = _mark;  in single_target_rule()
17534         D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ',  in single_target_rule()
17535                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'"));  in single_target_rule()
17539     p->level--;  in single_target_rule()
17547 single_subscript_attribute_target_rule(Parser *p)  in single_subscript_attribute_target_rule()  argument
17549     if (p->level++ == MAXSTACK) {  in single_subscript_attribute_target_rule()
17550         p->error_indicator = 1;  in single_subscript_attribute_target_rule()
17553     if (p->error_indicator) {  in single_subscript_attribute_target_rule()
17554         p->level--;  in single_subscript_attribute_target_rule()
17558     int _mark = p->mark;  in single_subscript_attribute_target_rule()
17559     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in single_subscript_attribute_target_rule()
17560         p->error_indicator = 1;  in single_subscript_attribute_target_rule()
17561         p->level--;  in single_subscript_attribute_target_rule()
17564     int _start_lineno = p->tokens[_mark]->lineno;  in single_subscript_attribute_target_rule()
17566     int _start_col_offset = p->tokens[_mark]->col_offset;  in single_subscript_attribute_target_rule()
17569         if (p->error_indicator) {  in single_subscript_attribute_target_rule()
17570             p->level--;  in single_subscript_attribute_target_rule()
17573 …fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->ma…  in single_subscript_attribute_target_rule()
17578             (a = t_primary_rule(p))  // t_primary  in single_subscript_attribute_target_rule()
17580             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in single_subscript_attribute_target_rule()
17582             (b = _PyPegen_name_token(p))  // NAME  in single_subscript_attribute_target_rule()
17584             _PyPegen_lookahead(0, t_lookahead_rule, p)  in single_subscript_attribute_target_rule()
17587 …f(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in single_subscript_attribute_target_rule()
17588             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in single_subscript_attribute_target_rule()
17590                 p->level--;  in single_subscript_attribute_target_rule()
17593             int _end_lineno = _token->end_lineno;  in single_subscript_attribute_target_rule()
17595             int _end_col_offset = _token->end_col_offset;  in single_subscript_attribute_target_rule()
17597             _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA );  in single_subscript_attribute_target_rule()
17599                 p->error_indicator = 1;  in single_subscript_attribute_target_rule()
17600                 p->level--;  in single_subscript_attribute_target_rule()
17605         p->mark = _mark;  in single_subscript_attribute_target_rule()
17606 …   D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ',  in single_subscript_attribute_target_rule()
17607 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead"));  in single_subscript_attribute_target_rule()
17610         if (p->error_indicator) {  in single_subscript_attribute_target_rule()
17611             p->level--;  in single_subscript_attribute_target_rule()
17614 …fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->ma…  in single_subscript_attribute_target_rule()
17620             (a = t_primary_rule(p))  // t_primary  in single_subscript_attribute_target_rule()
17622             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in single_subscript_attribute_target_rule()
17624             (b = slices_rule(p))  // slices  in single_subscript_attribute_target_rule()
17626             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in single_subscript_attribute_target_rule()
17628             _PyPegen_lookahead(0, t_lookahead_rule, p)  in single_subscript_attribute_target_rule()
17631 …f(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in single_subscript_attribute_target_rule()
17632             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in single_subscript_attribute_target_rule()
17634                 p->level--;  in single_subscript_attribute_target_rule()
17637             int _end_lineno = _token->end_lineno;  in single_subscript_attribute_target_rule()
17639             int _end_col_offset = _token->end_col_offset;  in single_subscript_attribute_target_rule()
17643                 p->error_indicator = 1;  in single_subscript_attribute_target_rule()
17644                 p->level--;  in single_subscript_attribute_target_rule()
17649         p->mark = _mark;  in single_subscript_attribute_target_rule()
17650 …   D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ',  in single_subscript_attribute_target_rule()
17651 …    p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));  in single_subscript_attribute_target_rule()
17655     p->level--;  in single_subscript_attribute_target_rule()
17661 del_targets_rule(Parser *p)  in del_targets_rule()  argument
17663     if (p->level++ == MAXSTACK) {  in del_targets_rule()
17664         p->error_indicator = 1;  in del_targets_rule()
17667     if (p->error_indicator) {  in del_targets_rule()
17668         p->level--;  in del_targets_rule()
17672     int _mark = p->mark;  in del_targets_rule()
17674         if (p->error_indicator) {  in del_targets_rule()
17675             p->level--;  in del_targets_rule()
17678 …D(fprintf(stderr, "%*c> del_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.del_target+…  in del_targets_rule()
17683             (a = (asdl_expr_seq*)_gather_139_rule(p))  // ','.del_target+  in del_targets_rule()
17685             (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in del_targets_rule()
17688 …D(fprintf(stderr, "%*c+ del_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.…  in del_targets_rule()
17691                 p->error_indicator = 1;  in del_targets_rule()
17692                 p->level--;  in del_targets_rule()
17697         p->mark = _mark;  in del_targets_rule()
17698         D(fprintf(stderr, "%*c%s del_targets[%d-%d]: %s failed!\n", p->level, ' ',  in del_targets_rule()
17699                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.del_target+ ','?"));  in del_targets_rule()
17703     p->level--;  in del_targets_rule()
17712 del_target_rule(Parser *p)  in del_target_rule()  argument
17714     if (p->level++ == MAXSTACK) {  in del_target_rule()
17715         p->error_indicator = 1;  in del_target_rule()
17718     if (p->error_indicator) {  in del_target_rule()
17719         p->level--;  in del_target_rule()
17723     if (_PyPegen_is_memoized(p, del_target_type, &_res)) {  in del_target_rule()
17724         p->level--;  in del_target_rule()
17727     int _mark = p->mark;  in del_target_rule()
17728     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in del_target_rule()
17729         p->error_indicator = 1;  in del_target_rule()
17730         p->level--;  in del_target_rule()
17733     int _start_lineno = p->tokens[_mark]->lineno;  in del_target_rule()
17735     int _start_col_offset = p->tokens[_mark]->col_offset;  in del_target_rule()
17738         if (p->error_indicator) {  in del_target_rule()
17739             p->level--;  in del_target_rule()
17742 …D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NA…  in del_target_rule()
17747             (a = t_primary_rule(p))  // t_primary  in del_target_rule()
17749             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in del_target_rule()
17751             (b = _PyPegen_name_token(p))  // NAME  in del_target_rule()
17753             _PyPegen_lookahead(0, t_lookahead_rule, p)  in del_target_rule()
17756 …D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_pri…  in del_target_rule()
17757             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in del_target_rule()
17759                 p->level--;  in del_target_rule()
17762             int _end_lineno = _token->end_lineno;  in del_target_rule()
17764             int _end_col_offset = _token->end_col_offset;  in del_target_rule()
17766             _res = _PyAST_Attribute ( a , b -> v . Name . id , Del , EXTRA );  in del_target_rule()
17768                 p->error_indicator = 1;  in del_target_rule()
17769                 p->level--;  in del_target_rule()
17774         p->mark = _mark;  in del_target_rule()
17775         D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ',  in del_target_rule()
17776 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead"));  in del_target_rule()
17779         if (p->error_indicator) {  in del_target_rule()
17780             p->level--;  in del_target_rule()
17783 …D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' sl…  in del_target_rule()
17789             (a = t_primary_rule(p))  // t_primary  in del_target_rule()
17791             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in del_target_rule()
17793             (b = slices_rule(p))  // slices  in del_target_rule()
17795             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in del_target_rule()
17797             _PyPegen_lookahead(0, t_lookahead_rule, p)  in del_target_rule()
17800 …D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_pri…  in del_target_rule()
17801             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in del_target_rule()
17803                 p->level--;  in del_target_rule()
17806             int _end_lineno = _token->end_lineno;  in del_target_rule()
17808             int _end_col_offset = _token->end_col_offset;  in del_target_rule()
17812                 p->error_indicator = 1;  in del_target_rule()
17813                 p->level--;  in del_target_rule()
17818         p->mark = _mark;  in del_target_rule()
17819         D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ',  in del_target_rule()
17820 …    p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));  in del_target_rule()
17823         if (p->error_indicator) {  in del_target_rule()
17824             p->level--;  in del_target_rule()
17827 …   D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_t_atom"));  in del_target_rule()
17830             (del_t_atom_var = del_t_atom_rule(p))  // del_t_atom  in del_target_rule()
17833 …D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_t…  in del_target_rule()
17837         p->mark = _mark;  in del_target_rule()
17838         D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ',  in del_target_rule()
17839                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_t_atom"));  in del_target_rule()
17843     _PyPegen_insert_memo(p, _mark, del_target_type, _res);  in del_target_rule()
17844     p->level--;  in del_target_rule()
17850 del_t_atom_rule(Parser *p)  in del_t_atom_rule()  argument
17852     if (p->level++ == MAXSTACK) {  in del_t_atom_rule()
17853         p->error_indicator = 1;  in del_t_atom_rule()
17856     if (p->error_indicator) {  in del_t_atom_rule()
17857         p->level--;  in del_t_atom_rule()
17861     int _mark = p->mark;  in del_t_atom_rule()
17862     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in del_t_atom_rule()
17863         p->error_indicator = 1;  in del_t_atom_rule()
17864         p->level--;  in del_t_atom_rule()
17867     int _start_lineno = p->tokens[_mark]->lineno;  in del_t_atom_rule()
17869     int _start_col_offset = p->tokens[_mark]->col_offset;  in del_t_atom_rule()
17872         if (p->error_indicator) {  in del_t_atom_rule()
17873             p->level--;  in del_t_atom_rule()
17876         D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));  in del_t_atom_rule()
17879             (a = _PyPegen_name_token(p))  // NAME  in del_t_atom_rule()
17882 …D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"…  in del_t_atom_rule()
17883             _res = _PyPegen_set_expr_context ( p , a , Del );  in del_t_atom_rule()
17885                 p->error_indicator = 1;  in del_t_atom_rule()
17886                 p->level--;  in del_t_atom_rule()
17891         p->mark = _mark;  in del_t_atom_rule()
17892         D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',  in del_t_atom_rule()
17893                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));  in del_t_atom_rule()
17896         if (p->error_indicator) {  in del_t_atom_rule()
17897             p->level--;  in del_t_atom_rule()
17900 …D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_target '…  in del_t_atom_rule()
17905             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in del_t_atom_rule()
17907             (a = del_target_rule(p))  // del_target  in del_t_atom_rule()
17909             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in del_t_atom_rule()
17912 …D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' d…  in del_t_atom_rule()
17913             _res = _PyPegen_set_expr_context ( p , a , Del );  in del_t_atom_rule()
17915                 p->error_indicator = 1;  in del_t_atom_rule()
17916                 p->level--;  in del_t_atom_rule()
17921         p->mark = _mark;  in del_t_atom_rule()
17922         D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',  in del_t_atom_rule()
17923                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_target ')'"));  in del_t_atom_rule()
17926         if (p->error_indicator) {  in del_t_atom_rule()
17927             p->level--;  in del_t_atom_rule()
17930 …D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_targets?…  in del_t_atom_rule()
17935             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in del_t_atom_rule()
17937             (a = del_targets_rule(p), !p->error_indicator)  // del_targets?  in del_t_atom_rule()
17939             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in del_t_atom_rule()
17942 …D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' d…  in del_t_atom_rule()
17943             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in del_t_atom_rule()
17945                 p->level--;  in del_t_atom_rule()
17948             int _end_lineno = _token->end_lineno;  in del_t_atom_rule()
17950             int _end_col_offset = _token->end_col_offset;  in del_t_atom_rule()
17954                 p->error_indicator = 1;  in del_t_atom_rule()
17955                 p->level--;  in del_t_atom_rule()
17960         p->mark = _mark;  in del_t_atom_rule()
17961         D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',  in del_t_atom_rule()
17962                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_targets? ')'"));  in del_t_atom_rule()
17965         if (p->error_indicator) {  in del_t_atom_rule()
17966             p->level--;  in del_t_atom_rule()
17969 …D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' del_targets?…  in del_t_atom_rule()
17974             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in del_t_atom_rule()
17976             (a = del_targets_rule(p), !p->error_indicator)  // del_targets?  in del_t_atom_rule()
17978             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in del_t_atom_rule()
17981 …D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' d…  in del_t_atom_rule()
17982             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in del_t_atom_rule()
17984                 p->level--;  in del_t_atom_rule()
17987             int _end_lineno = _token->end_lineno;  in del_t_atom_rule()
17989             int _end_col_offset = _token->end_col_offset;  in del_t_atom_rule()
17993                 p->error_indicator = 1;  in del_t_atom_rule()
17994                 p->level--;  in del_t_atom_rule()
17999         p->mark = _mark;  in del_t_atom_rule()
18000         D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',  in del_t_atom_rule()
18001                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' del_targets? ']'"));  in del_t_atom_rule()
18005     p->level--;  in del_t_atom_rule()
18009 // Left-recursive
18018 t_primary_rule(Parser *p)  in t_primary_rule()  argument
18020     if (p->level++ == MAXSTACK) {  in t_primary_rule()
18021         p->error_indicator = 1;  in t_primary_rule()
18025     if (_PyPegen_is_memoized(p, t_primary_type, &_res)) {  in t_primary_rule()
18026         p->level--;  in t_primary_rule()
18029     int _mark = p->mark;  in t_primary_rule()
18030     int _resmark = p->mark;  in t_primary_rule()
18032         int tmpvar_9 = _PyPegen_update_memo(p, _mark, t_primary_type, _res);  in t_primary_rule()
18034             p->level--;  in t_primary_rule()
18037         p->mark = _mark;  in t_primary_rule()
18038         void *_raw = t_primary_raw(p);  in t_primary_rule()
18039         if (p->error_indicator) {  in t_primary_rule()
18040             p->level--;  in t_primary_rule()
18043         if (_raw == NULL || p->mark <= _resmark)  in t_primary_rule()
18045         _resmark = p->mark;  in t_primary_rule()
18048     p->mark = _resmark;  in t_primary_rule()
18049     p->level--;  in t_primary_rule()
18053 t_primary_raw(Parser *p)  in t_primary_raw()  argument
18055     if (p->level++ == MAXSTACK) {  in t_primary_raw()
18056         p->error_indicator = 1;  in t_primary_raw()
18059     if (p->error_indicator) {  in t_primary_raw()
18060         p->level--;  in t_primary_raw()
18064     int _mark = p->mark;  in t_primary_raw()
18065     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in t_primary_raw()
18066         p->error_indicator = 1;  in t_primary_raw()
18067         p->level--;  in t_primary_raw()
18070     int _start_lineno = p->tokens[_mark]->lineno;  in t_primary_raw()
18072     int _start_col_offset = p->tokens[_mark]->col_offset;  in t_primary_raw()
18075         if (p->error_indicator) {  in t_primary_raw()
18076             p->level--;  in t_primary_raw()
18079 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAM…  in t_primary_raw()
18084             (a = t_primary_rule(p))  // t_primary  in t_primary_raw()
18086             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in t_primary_raw()
18088             (b = _PyPegen_name_token(p))  // NAME  in t_primary_raw()
18090             _PyPegen_lookahead(1, t_lookahead_rule, p)  in t_primary_raw()
18093 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_prim…  in t_primary_raw()
18094             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in t_primary_raw()
18096                 p->level--;  in t_primary_raw()
18099             int _end_lineno = _token->end_lineno;  in t_primary_raw()
18101             int _end_col_offset = _token->end_col_offset;  in t_primary_raw()
18103             _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA );  in t_primary_raw()
18105                 p->error_indicator = 1;  in t_primary_raw()
18106                 p->level--;  in t_primary_raw()
18111         p->mark = _mark;  in t_primary_raw()
18112         D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',  in t_primary_raw()
18113 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME &t_lookahead"));  in t_primary_raw()
18116         if (p->error_indicator) {  in t_primary_raw()
18117             p->level--;  in t_primary_raw()
18120 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' sli…  in t_primary_raw()
18126             (a = t_primary_rule(p))  // t_primary  in t_primary_raw()
18128             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in t_primary_raw()
18130             (b = slices_rule(p))  // slices  in t_primary_raw()
18132             (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'  in t_primary_raw()
18134             _PyPegen_lookahead(1, t_lookahead_rule, p)  in t_primary_raw()
18137 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_prim…  in t_primary_raw()
18138             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in t_primary_raw()
18140                 p->level--;  in t_primary_raw()
18143             int _end_lineno = _token->end_lineno;  in t_primary_raw()
18145             int _end_col_offset = _token->end_col_offset;  in t_primary_raw()
18149                 p->error_indicator = 1;  in t_primary_raw()
18150                 p->level--;  in t_primary_raw()
18155         p->mark = _mark;  in t_primary_raw()
18156         D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',  in t_primary_raw()
18157 …    p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));  in t_primary_raw()
18160         if (p->error_indicator) {  in t_primary_raw()
18161             p->level--;  in t_primary_raw()
18164 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary genexp …  in t_primary_raw()
18168             (a = t_primary_rule(p))  // t_primary  in t_primary_raw()
18170             (b = genexp_rule(p))  // genexp  in t_primary_raw()
18172             _PyPegen_lookahead(1, t_lookahead_rule, p)  in t_primary_raw()
18175 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_prim…  in t_primary_raw()
18176             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in t_primary_raw()
18178                 p->level--;  in t_primary_raw()
18181             int _end_lineno = _token->end_lineno;  in t_primary_raw()
18183             int _end_col_offset = _token->end_col_offset;  in t_primary_raw()
18185 … a , CHECK ( asdl_expr_seq * , ( asdl_expr_seq * ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXT…  in t_primary_raw()
18187                 p->error_indicator = 1;  in t_primary_raw()
18188                 p->level--;  in t_primary_raw()
18193         p->mark = _mark;  in t_primary_raw()
18194         D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',  in t_primary_raw()
18195 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary genexp &t_lookahead"));  in t_primary_raw()
18198         if (p->error_indicator) {  in t_primary_raw()
18199             p->level--;  in t_primary_raw()
18202 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '(' arg…  in t_primary_raw()
18208             (a = t_primary_rule(p))  // t_primary  in t_primary_raw()
18210             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in t_primary_raw()
18212             (b = arguments_rule(p), !p->error_indicator)  // arguments?  in t_primary_raw()
18214             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in t_primary_raw()
18216             _PyPegen_lookahead(1, t_lookahead_rule, p)  in t_primary_raw()
18219 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_prim…  in t_primary_raw()
18220             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in t_primary_raw()
18222                 p->level--;  in t_primary_raw()
18225             int _end_lineno = _token->end_lineno;  in t_primary_raw()
18227             int _end_col_offset = _token->end_col_offset;  in t_primary_raw()
18229 …es = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty )…  in t_primary_raw()
18231                 p->error_indicator = 1;  in t_primary_raw()
18232                 p->level--;  in t_primary_raw()
18237         p->mark = _mark;  in t_primary_raw()
18238         D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',  in t_primary_raw()
18239 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));  in t_primary_raw()
18242         if (p->error_indicator) {  in t_primary_raw()
18243             p->level--;  in t_primary_raw()
18246 …D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead…  in t_primary_raw()
18249             (a = atom_rule(p))  // atom  in t_primary_raw()
18251             _PyPegen_lookahead(1, t_lookahead_rule, p)  in t_primary_raw()
18254 …D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom &…  in t_primary_raw()
18257                 p->error_indicator = 1;  in t_primary_raw()
18258                 p->level--;  in t_primary_raw()
18263         p->mark = _mark;  in t_primary_raw()
18264         D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',  in t_primary_raw()
18265                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom &t_lookahead"));  in t_primary_raw()
18269     p->level--;  in t_primary_raw()
18275 t_lookahead_rule(Parser *p)  in t_lookahead_rule()  argument
18277     if (p->level++ == MAXSTACK) {  in t_lookahead_rule()
18278         p->error_indicator = 1;  in t_lookahead_rule()
18281     if (p->error_indicator) {  in t_lookahead_rule()
18282         p->level--;  in t_lookahead_rule()
18286     int _mark = p->mark;  in t_lookahead_rule()
18288         if (p->error_indicator) {  in t_lookahead_rule()
18289             p->level--;  in t_lookahead_rule()
18292         D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));  in t_lookahead_rule()
18295             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in t_lookahead_rule()
18298 …D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"…  in t_lookahead_rule()
18302         p->mark = _mark;  in t_lookahead_rule()
18303         D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',  in t_lookahead_rule()
18304                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));  in t_lookahead_rule()
18307         if (p->error_indicator) {  in t_lookahead_rule()
18308             p->level--;  in t_lookahead_rule()
18311         D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));  in t_lookahead_rule()
18314             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in t_lookahead_rule()
18317 …D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"…  in t_lookahead_rule()
18321         p->mark = _mark;  in t_lookahead_rule()
18322         D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',  in t_lookahead_rule()
18323                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));  in t_lookahead_rule()
18326         if (p->error_indicator) {  in t_lookahead_rule()
18327             p->level--;  in t_lookahead_rule()
18330         D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));  in t_lookahead_rule()
18333             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in t_lookahead_rule()
18336 …D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"…  in t_lookahead_rule()
18340         p->mark = _mark;  in t_lookahead_rule()
18341         D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',  in t_lookahead_rule()
18342                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));  in t_lookahead_rule()
18346     p->level--;  in t_lookahead_rule()
18358 invalid_arguments_rule(Parser *p)  in invalid_arguments_rule()  argument
18360     if (p->level++ == MAXSTACK) {  in invalid_arguments_rule()
18361         p->error_indicator = 1;  in invalid_arguments_rule()
18364     if (p->error_indicator) {  in invalid_arguments_rule()
18365         p->level--;  in invalid_arguments_rule()
18369     int _mark = p->mark;  in invalid_arguments_rule()
18371         if (p->error_indicator) {  in invalid_arguments_rule()
18372             p->level--;  in invalid_arguments_rule()
18375 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' …  in invalid_arguments_rule()
18380             (a = args_rule(p))  // args  in invalid_arguments_rule()
18382             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_arguments_rule()
18384             (_literal_1 = _PyPegen_expect_token(p, 16))  // token='*'  in invalid_arguments_rule()
18387 …D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_arguments_rule()
18390                 p->error_indicator = 1;  in invalid_arguments_rule()
18391                 p->level--;  in invalid_arguments_rule()
18396         p->mark = _mark;  in invalid_arguments_rule()
18397         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_arguments_rule()
18398                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' '*'"));  in invalid_arguments_rule()
18401         if (p->error_indicator) {  in invalid_arguments_rule()
18402             p->level--;  in invalid_arguments_rule()
18405 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressio…  in invalid_arguments_rule()
18412             (a = expression_rule(p))  // expression  in invalid_arguments_rule()
18414             (b = for_if_clauses_rule(p))  // for_if_clauses  in invalid_arguments_rule()
18416             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_arguments_rule()
18418 …          (_opt_var = _tmp_141_rule(p), !p->error_indicator)  // [args | expression for_if_clauses]  in invalid_arguments_rule()
18421 …D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_arguments_rule()
18422 …E_SYNTAX_ERROR_KNOWN_RANGE ( a , PyPegen_last_item ( b , comprehension_ty ) -> target , "Generator…  in invalid_arguments_rule()
18424                 p->error_indicator = 1;  in invalid_arguments_rule()
18425                 p->level--;  in invalid_arguments_rule()
18430         p->mark = _mark;  in invalid_arguments_rule()
18431         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_arguments_rule()
18432 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses ',' [args | expres…  in invalid_arguments_rule()
18435         if (p->error_indicator) {  in invalid_arguments_rule()
18436             p->level--;  in invalid_arguments_rule()
18439 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' …  in invalid_arguments_rule()
18445             (a = _PyPegen_name_token(p))  // NAME  in invalid_arguments_rule()
18447             (b = _PyPegen_expect_token(p, 22))  // token='='  in invalid_arguments_rule()
18449             (expression_var = expression_rule(p))  // expression  in invalid_arguments_rule()
18451             (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses  in invalid_arguments_rule()
18454 …D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_arguments_rule()
18457                 p->error_indicator = 1;  in invalid_arguments_rule()
18458                 p->level--;  in invalid_arguments_rule()
18463         p->mark = _mark;  in invalid_arguments_rule()
18464         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_arguments_rule()
18465 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses"));  in invalid_arguments_rule()
18468         if (p->error_indicator) {  in invalid_arguments_rule()
18469             p->level--;  in invalid_arguments_rule()
18472 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args for_…  in invalid_arguments_rule()
18476             (a = args_rule(p))  // args  in invalid_arguments_rule()
18478             (b = for_if_clauses_rule(p))  // for_if_clauses  in invalid_arguments_rule()
18481 …D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_arguments_rule()
18482             _res = _PyPegen_nonparen_genexp_in_call ( p , a , b );  in invalid_arguments_rule()
18484                 p->error_indicator = 1;  in invalid_arguments_rule()
18485                 p->level--;  in invalid_arguments_rule()
18490         p->mark = _mark;  in invalid_arguments_rule()
18491         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_arguments_rule()
18492                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args for_if_clauses"));  in invalid_arguments_rule()
18495         if (p->error_indicator) {  in invalid_arguments_rule()
18496             p->level--;  in invalid_arguments_rule()
18499 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' …  in invalid_arguments_rule()
18505             (args_var = args_rule(p))  // args  in invalid_arguments_rule()
18507             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_arguments_rule()
18509             (a = expression_rule(p))  // expression  in invalid_arguments_rule()
18511             (b = for_if_clauses_rule(p))  // for_if_clauses  in invalid_arguments_rule()
18514 …D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_arguments_rule()
18515 …_res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , asdl_seq_GET ( b , b -> size - 1 ) -> target , "Genera…  in invalid_arguments_rule()
18517                 p->error_indicator = 1;  in invalid_arguments_rule()
18518                 p->level--;  in invalid_arguments_rule()
18523         p->mark = _mark;  in invalid_arguments_rule()
18524         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_arguments_rule()
18525 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' expression for_if_clauses"));  in invalid_arguments_rule()
18528         if (p->error_indicator) {  in invalid_arguments_rule()
18529             p->level--;  in invalid_arguments_rule()
18532 …D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' …  in invalid_arguments_rule()
18537             (a = args_rule(p))  // args  in invalid_arguments_rule()
18539             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_arguments_rule()
18541             (args_var = args_rule(p))  // args  in invalid_arguments_rule()
18544 …D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_arguments_rule()
18545             _res = _PyPegen_arguments_parsing_error ( p , a );  in invalid_arguments_rule()
18547                 p->error_indicator = 1;  in invalid_arguments_rule()
18548                 p->level--;  in invalid_arguments_rule()
18553         p->mark = _mark;  in invalid_arguments_rule()
18554         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_arguments_rule()
18555                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' args"));  in invalid_arguments_rule()
18559     p->level--;  in invalid_arguments_rule()
18568 invalid_kwarg_rule(Parser *p)  in invalid_kwarg_rule()  argument
18570     if (p->level++ == MAXSTACK) {  in invalid_kwarg_rule()
18571         p->error_indicator = 1;  in invalid_kwarg_rule()
18574     if (p->error_indicator) {  in invalid_kwarg_rule()
18575         p->level--;  in invalid_kwarg_rule()
18579     int _mark = p->mark;  in invalid_kwarg_rule()
18581         if (p->error_indicator) {  in invalid_kwarg_rule()
18582             p->level--;  in invalid_kwarg_rule()
18585 …D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('True' | 'Fa…  in invalid_kwarg_rule()
18589             (a = (Token*)_tmp_142_rule(p))  // 'True' | 'False' | 'None'  in invalid_kwarg_rule()
18591             (b = _PyPegen_expect_token(p, 22))  // token='='  in invalid_kwarg_rule()
18594 …D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('…  in invalid_kwarg_rule()
18595 …AISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to %s" , PyBytes_AS_STRING ( a -> bytes ) );  in invalid_kwarg_rule()
18597                 p->error_indicator = 1;  in invalid_kwarg_rule()
18598                 p->level--;  in invalid_kwarg_rule()
18603         p->mark = _mark;  in invalid_kwarg_rule()
18604         D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_kwarg_rule()
18605 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('True' | 'False' | 'None') '='"));  in invalid_kwarg_rule()
18608         if (p->error_indicator) {  in invalid_kwarg_rule()
18609             p->level--;  in invalid_kwarg_rule()
18612 …D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expr…  in invalid_kwarg_rule()
18618             (a = _PyPegen_name_token(p))  // NAME  in invalid_kwarg_rule()
18620             (b = _PyPegen_expect_token(p, 22))  // token='='  in invalid_kwarg_rule()
18622             (expression_var = expression_rule(p))  // expression  in invalid_kwarg_rule()
18624             (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses  in invalid_kwarg_rule()
18627 …D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NA…  in invalid_kwarg_rule()
18630                 p->error_indicator = 1;  in invalid_kwarg_rule()
18631                 p->level--;  in invalid_kwarg_rule()
18636         p->mark = _mark;  in invalid_kwarg_rule()
18637         D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_kwarg_rule()
18638 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses"));  in invalid_kwarg_rule()
18641         if (p->error_indicator) {  in invalid_kwarg_rule()
18642             p->level--;  in invalid_kwarg_rule()
18645 …D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME '=') e…  in invalid_kwarg_rule()
18649             _PyPegen_lookahead(0, _tmp_143_rule, p)  in invalid_kwarg_rule()
18651             (a = expression_rule(p))  // expression  in invalid_kwarg_rule()
18653             (b = _PyPegen_expect_token(p, 22))  // token='='  in invalid_kwarg_rule()
18656 …D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(…  in invalid_kwarg_rule()
18659                 p->error_indicator = 1;  in invalid_kwarg_rule()
18660                 p->level--;  in invalid_kwarg_rule()
18665         p->mark = _mark;  in invalid_kwarg_rule()
18666         D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_kwarg_rule()
18667 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME '=') expression '='"));  in invalid_kwarg_rule()
18671     p->level--;  in invalid_kwarg_rule()
18680 expression_without_invalid_rule(Parser *p)  in expression_without_invalid_rule()  argument
18682     int _prev_call_invalid = p->call_invalid_rules;  in expression_without_invalid_rule()
18683     p->call_invalid_rules = 0;  in expression_without_invalid_rule()
18684     if (p->level++ == MAXSTACK) {  in expression_without_invalid_rule()
18685         p->error_indicator = 1;  in expression_without_invalid_rule()
18688     if (p->error_indicator) {  in expression_without_invalid_rule()
18689         p->call_invalid_rules = _prev_call_invalid;  in expression_without_invalid_rule()
18690         p->level--;  in expression_without_invalid_rule()
18694     int _mark = p->mark;  in expression_without_invalid_rule()
18695     if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {  in expression_without_invalid_rule()
18696         p->error_indicator = 1;  in expression_without_invalid_rule()
18697         p->call_invalid_rules = _prev_call_invalid;  in expression_without_invalid_rule()
18698         p->level--;  in expression_without_invalid_rule()
18701     int _start_lineno = p->tokens[_mark]->lineno;  in expression_without_invalid_rule()
18703     int _start_col_offset = p->tokens[_mark]->col_offset;  in expression_without_invalid_rule()
18706         if (p->error_indicator) {  in expression_without_invalid_rule()
18707             p->call_invalid_rules = _prev_call_invalid;  in expression_without_invalid_rule()
18708             p->level--;  in expression_without_invalid_rule()
18711 …D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in expression_without_invalid_rule()
18718             (a = disjunction_rule(p))  // disjunction  in expression_without_invalid_rule()
18720             (_keyword = _PyPegen_expect_token(p, 510))  // token='if'  in expression_without_invalid_rule()
18722             (b = disjunction_rule(p))  // disjunction  in expression_without_invalid_rule()
18724             (_keyword_1 = _PyPegen_expect_token(p, 516))  // token='else'  in expression_without_invalid_rule()
18726             (c = expression_rule(p))  // expression  in expression_without_invalid_rule()
18729 …(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in expression_without_invalid_rule()
18730             Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);  in expression_without_invalid_rule()
18732                 p->call_invalid_rules = _prev_call_invalid;  in expression_without_invalid_rule()
18733                 p->level--;  in expression_without_invalid_rule()
18736             int _end_lineno = _token->end_lineno;  in expression_without_invalid_rule()
18738             int _end_col_offset = _token->end_col_offset;  in expression_without_invalid_rule()
18742                 p->error_indicator = 1;  in expression_without_invalid_rule()
18743                 p->call_invalid_rules = _prev_call_invalid;  in expression_without_invalid_rule()
18744                 p->level--;  in expression_without_invalid_rule()
18749         p->mark = _mark;  in expression_without_invalid_rule()
18750         D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ',  in expression_without_invalid_rule()
18751 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expressi…  in expression_without_invalid_rule()
18754         if (p->error_indicator) {  in expression_without_invalid_rule()
18755             p->call_invalid_rules = _prev_call_invalid;  in expression_without_invalid_rule()
18756             p->level--;  in expression_without_invalid_rule()
18759 …D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in expression_without_invalid_rule()
18762             (disjunction_var = disjunction_rule(p))  // disjunction  in expression_without_invalid_rule()
18765 …(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in expression_without_invalid_rule()
18769         p->mark = _mark;  in expression_without_invalid_rule()
18770         D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ',  in expression_without_invalid_rule()
18771                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction"));  in expression_without_invalid_rule()
18774         if (p->error_indicator) {  in expression_without_invalid_rule()
18775             p->call_invalid_rules = _prev_call_invalid;  in expression_without_invalid_rule()
18776             p->level--;  in expression_without_invalid_rule()
18779 …D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in expression_without_invalid_rule()
18782             (lambdef_var = lambdef_rule(p))  // lambdef  in expression_without_invalid_rule()
18785 …(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in expression_without_invalid_rule()
18789         p->mark = _mark;  in expression_without_invalid_rule()
18790         D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ',  in expression_without_invalid_rule()
18791                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef"));  in expression_without_invalid_rule()
18795     p->call_invalid_rules = _prev_call_invalid;  in expression_without_invalid_rule()
18796     p->level--;  in expression_without_invalid_rule()
18802 invalid_legacy_expression_rule(Parser *p)  in invalid_legacy_expression_rule()  argument
18804     if (p->level++ == MAXSTACK) {  in invalid_legacy_expression_rule()
18805         p->error_indicator = 1;  in invalid_legacy_expression_rule()
18808     if (p->error_indicator) {  in invalid_legacy_expression_rule()
18809         p->level--;  in invalid_legacy_expression_rule()
18813     int _mark = p->mark;  in invalid_legacy_expression_rule()
18815         if (p->error_indicator) {  in invalid_legacy_expression_rule()
18816             p->level--;  in invalid_legacy_expression_rule()
18819 …D(fprintf(stderr, "%*c> invalid_legacy_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "N…  in invalid_legacy_expression_rule()
18823             (a = _PyPegen_name_token(p))  // NAME  in invalid_legacy_expression_rule()
18825             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 7)  // token='('  in invalid_legacy_expression_rule()
18827             (b = star_expressions_rule(p))  // star_expressions  in invalid_legacy_expression_rule()
18830 …D(fprintf(stderr, "%*c+ invalid_legacy_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_legacy_expression_rule()
18831 …stmt ( p , a ) ? RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Missing parentheses in call to '%U'. Di…  in invalid_legacy_expression_rule()
18833                 p->error_indicator = 1;  in invalid_legacy_expression_rule()
18834                 p->level--;  in invalid_legacy_expression_rule()
18839         p->mark = _mark;  in invalid_legacy_expression_rule()
18840         D(fprintf(stderr, "%*c%s invalid_legacy_expression[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_legacy_expression_rule()
18841 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME !'(' star_expressions"));  in invalid_legacy_expression_rule()
18845     p->level--;  in invalid_legacy_expression_rule()
18853 invalid_expression_rule(Parser *p)  in invalid_expression_rule()  argument
18855     if (p->level++ == MAXSTACK) {  in invalid_expression_rule()
18856         p->error_indicator = 1;  in invalid_expression_rule()
18859     if (p->error_indicator) {  in invalid_expression_rule()
18860         p->level--;  in invalid_expression_rule()
18864     int _mark = p->mark;  in invalid_expression_rule()
18866         if (p->error_indicator) {  in invalid_expression_rule()
18867             p->level--;  in invalid_expression_rule()
18870 …D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME S…  in invalid_expression_rule()
18874             _PyPegen_lookahead(0, _tmp_144_rule, p)  in invalid_expression_rule()
18876             (a = disjunction_rule(p))  // disjunction  in invalid_expression_rule()
18878             (b = expression_without_invalid_rule(p))  // expression_without_invalid  in invalid_expression_rule()
18881 …D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_expression_rule()
18882 …_res = _PyPegen_check_legacy_stmt ( p , a ) ? NULL : p -> tokens [ p -> mark - 1 ] -> level == 0 ?…  in invalid_expression_rule()
18884                 p->error_indicator = 1;  in invalid_expression_rule()
18885                 p->level--;  in invalid_expression_rule()
18890         p->mark = _mark;  in invalid_expression_rule()
18891         D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_expression_rule()
18892 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction ex…  in invalid_expression_rule()
18895         if (p->error_indicator) {  in invalid_expression_rule()
18896             p->level--;  in invalid_expression_rule()
18899 …D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunct…  in invalid_expression_rule()
18904             (a = disjunction_rule(p))  // disjunction  in invalid_expression_rule()
18906             (_keyword = _PyPegen_expect_token(p, 510))  // token='if'  in invalid_expression_rule()
18908             (b = disjunction_rule(p))  // disjunction  in invalid_expression_rule()
18910             _PyPegen_lookahead(0, _tmp_145_rule, p)  in invalid_expression_rule()
18913 …D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_expression_rule()
18916                 p->error_indicator = 1;  in invalid_expression_rule()
18917                 p->level--;  in invalid_expression_rule()
18922         p->mark = _mark;  in invalid_expression_rule()
18923         D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_expression_rule()
18924 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')…  in invalid_expression_rule()
18928     p->level--;  in invalid_expression_rule()
18937 invalid_named_expression_rule(Parser *p)  in invalid_named_expression_rule()  argument
18939     if (p->level++ == MAXSTACK) {  in invalid_named_expression_rule()
18940         p->error_indicator = 1;  in invalid_named_expression_rule()
18943     if (p->error_indicator) {  in invalid_named_expression_rule()
18944         p->level--;  in invalid_named_expression_rule()
18948     if (_PyPegen_is_memoized(p, invalid_named_expression_type, &_res)) {  in invalid_named_expression_rule()
18949         p->level--;  in invalid_named_expression_rule()
18952     int _mark = p->mark;  in invalid_named_expression_rule()
18954         if (p->error_indicator) {  in invalid_named_expression_rule()
18955             p->level--;  in invalid_named_expression_rule()
18958 …D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ex…  in invalid_named_expression_rule()
18963             (a = expression_rule(p))  // expression  in invalid_named_expression_rule()
18965             (_literal = _PyPegen_expect_token(p, 53))  // token=':='  in invalid_named_expression_rule()
18967             (expression_var = expression_rule(p))  // expression  in invalid_named_expression_rule()
18970 …D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p…  in invalid_named_expression_rule()
18973                 p->error_indicator = 1;  in invalid_named_expression_rule()
18974                 p->level--;  in invalid_named_expression_rule()
18979         p->mark = _mark;  in invalid_named_expression_rule()
18980         D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_named_expression_rule()
18981 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':=' expression"));  in invalid_named_expression_rule()
18984         if (p->error_indicator) {  in invalid_named_expression_rule()
18985             p->level--;  in invalid_named_expression_rule()
18988 …D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NA…  in invalid_named_expression_rule()
18993             (a = _PyPegen_name_token(p))  // NAME  in invalid_named_expression_rule()
18995             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in invalid_named_expression_rule()
18997             (b = bitwise_or_rule(p))  // bitwise_or  in invalid_named_expression_rule()
18999             _PyPegen_lookahead(0, _tmp_146_rule, p)  in invalid_named_expression_rule()
19002 …D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p…  in invalid_named_expression_rule()
19005                 p->error_indicator = 1;  in invalid_named_expression_rule()
19006                 p->level--;  in invalid_named_expression_rule()
19011         p->mark = _mark;  in invalid_named_expression_rule()
19012         D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_named_expression_rule()
19013 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')"));  in invalid_named_expression_rule()
19016         if (p->error_indicator) {  in invalid_named_expression_rule()
19017             p->level--;  in invalid_named_expression_rule()
19020 …D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(…  in invalid_named_expression_rule()
19025             _PyPegen_lookahead(0, _tmp_147_rule, p)  in invalid_named_expression_rule()
19027             (a = bitwise_or_rule(p))  // bitwise_or  in invalid_named_expression_rule()
19029             (b = _PyPegen_expect_token(p, 22))  // token='='  in invalid_named_expression_rule()
19031             (bitwise_or_var = bitwise_or_rule(p))  // bitwise_or  in invalid_named_expression_rule()
19033             _PyPegen_lookahead(0, _tmp_148_rule, p)  in invalid_named_expression_rule()
19036 …D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p…  in invalid_named_expression_rule()
19039                 p->error_indicator = 1;  in invalid_named_expression_rule()
19040                 p->level--;  in invalid_named_expression_rule()
19045         p->mark = _mark;  in invalid_named_expression_rule()
19046         D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_named_expression_rule()
19047 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(list | tuple | genexp | 'True' | 'None' | …  in invalid_named_expression_rule()
19051     _PyPegen_insert_memo(p, _mark, invalid_named_expression_type, _res);  in invalid_named_expression_rule()
19052     p->level--;  in invalid_named_expression_rule()
19064 invalid_assignment_rule(Parser *p)  in invalid_assignment_rule()  argument
19066     if (p->level++ == MAXSTACK) {  in invalid_assignment_rule()
19067         p->error_indicator = 1;  in invalid_assignment_rule()
19070     if (p->error_indicator) {  in invalid_assignment_rule()
19071         p->level--;  in invalid_assignment_rule()
19075     int _mark = p->mark;  in invalid_assignment_rule()
19077         if (p->error_indicator) {  in invalid_assignment_rule()
19078             p->level--;  in invalid_assignment_rule()
19081 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_…  in invalid_assignment_rule()
19086             (a = invalid_ann_assign_target_rule(p))  // invalid_ann_assign_target  in invalid_assignment_rule()
19088             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_assignment_rule()
19090             (expression_var = expression_rule(p))  // expression  in invalid_assignment_rule()
19093 …D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_assignment_rule()
19096                 p->error_indicator = 1;  in invalid_assignment_rule()
19097                 p->level--;  in invalid_assignment_rule()
19102         p->mark = _mark;  in invalid_assignment_rule()
19103         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_assignment_rule()
19104 … p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_ann_assign_target ':' expression"));  in invalid_assignment_rule()
19107         if (p->error_indicator) {  in invalid_assignment_rule()
19108             p->level--;  in invalid_assignment_rule()
19111 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_nam…  in invalid_assignment_rule()
19118             (a = star_named_expression_rule(p))  // star_named_expression  in invalid_assignment_rule()
19120             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_assignment_rule()
19122             (_loop0_149_var = _loop0_149_rule(p))  // star_named_expressions*  in invalid_assignment_rule()
19124             (_literal_1 = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_assignment_rule()
19126             (expression_var = expression_rule(p))  // expression  in invalid_assignment_rule()
19129 …D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_assignment_rule()
19132                 p->error_indicator = 1;  in invalid_assignment_rule()
19133                 p->level--;  in invalid_assignment_rule()
19138         p->mark = _mark;  in invalid_assignment_rule()
19139         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_assignment_rule()
19140 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_express…  in invalid_assignment_rule()
19143         if (p->error_indicator) {  in invalid_assignment_rule()
19144             p->level--;  in invalid_assignment_rule()
19147 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressi…  in invalid_assignment_rule()
19152             (a = expression_rule(p))  // expression  in invalid_assignment_rule()
19154             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_assignment_rule()
19156             (expression_var = expression_rule(p))  // expression  in invalid_assignment_rule()
19159 …D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_assignment_rule()
19162                 p->error_indicator = 1;  in invalid_assignment_rule()
19163                 p->level--;  in invalid_assignment_rule()
19168         p->mark = _mark;  in invalid_assignment_rule()
19169         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_assignment_rule()
19170 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression"));  in invalid_assignment_rule()
19173         if (p->error_indicator) {  in invalid_assignment_rule()
19174             p->level--;  in invalid_assignment_rule()
19177 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_t…  in invalid_assignment_rule()
19182             (_loop0_150_var = _loop0_150_rule(p))  // ((star_targets '='))*  in invalid_assignment_rule()
19184             (a = star_expressions_rule(p))  // star_expressions  in invalid_assignment_rule()
19186             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in invalid_assignment_rule()
19189 …D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_assignment_rule()
19192                 p->error_indicator = 1;  in invalid_assignment_rule()
19193                 p->level--;  in invalid_assignment_rule()
19198         p->mark = _mark;  in invalid_assignment_rule()
19199         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_assignment_rule()
19200 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* star_expressions '='")…  in invalid_assignment_rule()
19203         if (p->error_indicator) {  in invalid_assignment_rule()
19204             p->level--;  in invalid_assignment_rule()
19207 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_t…  in invalid_assignment_rule()
19212             (_loop0_151_var = _loop0_151_rule(p))  // ((star_targets '='))*  in invalid_assignment_rule()
19214             (a = yield_expr_rule(p))  // yield_expr  in invalid_assignment_rule()
19216             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in invalid_assignment_rule()
19219 …D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_assignment_rule()
19222                 p->error_indicator = 1;  in invalid_assignment_rule()
19223                 p->level--;  in invalid_assignment_rule()
19228         p->mark = _mark;  in invalid_assignment_rule()
19229         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_assignment_rule()
19230 …     p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* yield_expr '='"));  in invalid_assignment_rule()
19233         if (p->error_indicator) {  in invalid_assignment_rule()
19234             p->level--;  in invalid_assignment_rule()
19237 …D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_exp…  in invalid_assignment_rule()
19242             (a = star_expressions_rule(p))  // star_expressions  in invalid_assignment_rule()
19244             (augassign_var = augassign_rule(p))  // augassign  in invalid_assignment_rule()
19246             (_tmp_152_var = _tmp_152_rule(p))  // yield_expr | star_expressions  in invalid_assignment_rule()
19249 …D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_assignment_rule()
19252                 p->error_indicator = 1;  in invalid_assignment_rule()
19253                 p->level--;  in invalid_assignment_rule()
19258         p->mark = _mark;  in invalid_assignment_rule()
19259         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_assignment_rule()
19260 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions augassign (yield_expr | sta…  in invalid_assignment_rule()
19264     p->level--;  in invalid_assignment_rule()
19270 invalid_ann_assign_target_rule(Parser *p)  in invalid_ann_assign_target_rule()  argument
19272     if (p->level++ == MAXSTACK) {  in invalid_ann_assign_target_rule()
19273         p->error_indicator = 1;  in invalid_ann_assign_target_rule()
19276     if (p->error_indicator) {  in invalid_ann_assign_target_rule()
19277         p->level--;  in invalid_ann_assign_target_rule()
19281     int _mark = p->mark;  in invalid_ann_assign_target_rule()
19283         if (p->error_indicator) {  in invalid_ann_assign_target_rule()
19284             p->level--;  in invalid_ann_assign_target_rule()
19287 …D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l…  in invalid_ann_assign_target_rule()
19290             (list_var = list_rule(p))  // list  in invalid_ann_assign_target_rule()
19293 …D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_ann_assign_target_rule()
19297         p->mark = _mark;  in invalid_ann_assign_target_rule()
19298         D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_ann_assign_target_rule()
19299                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));  in invalid_ann_assign_target_rule()
19302         if (p->error_indicator) {  in invalid_ann_assign_target_rule()
19303             p->level--;  in invalid_ann_assign_target_rule()
19306 …D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t…  in invalid_ann_assign_target_rule()
19309             (tuple_var = tuple_rule(p))  // tuple  in invalid_ann_assign_target_rule()
19312 …D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_ann_assign_target_rule()
19316         p->mark = _mark;  in invalid_ann_assign_target_rule()
19317         D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_ann_assign_target_rule()
19318                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));  in invalid_ann_assign_target_rule()
19321         if (p->error_indicator) {  in invalid_ann_assign_target_rule()
19322             p->level--;  in invalid_ann_assign_target_rule()
19325 …D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'…  in invalid_ann_assign_target_rule()
19330             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in invalid_ann_assign_target_rule()
19332             (a = invalid_ann_assign_target_rule(p))  // invalid_ann_assign_target  in invalid_ann_assign_target_rule()
19334             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in invalid_ann_assign_target_rule()
19337 …D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_ann_assign_target_rule()
19340                 p->error_indicator = 1;  in invalid_ann_assign_target_rule()
19341                 p->level--;  in invalid_ann_assign_target_rule()
19346         p->mark = _mark;  in invalid_ann_assign_target_rule()
19347         D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_ann_assign_target_rule()
19348 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' invalid_ann_assign_target ')'"));  in invalid_ann_assign_target_rule()
19352     p->level--;  in invalid_ann_assign_target_rule()
19358 invalid_del_stmt_rule(Parser *p)  in invalid_del_stmt_rule()  argument
19360     if (p->level++ == MAXSTACK) {  in invalid_del_stmt_rule()
19361         p->error_indicator = 1;  in invalid_del_stmt_rule()
19364     if (p->error_indicator) {  in invalid_del_stmt_rule()
19365         p->level--;  in invalid_del_stmt_rule()
19369     int _mark = p->mark;  in invalid_del_stmt_rule()
19371         if (p->error_indicator) {  in invalid_del_stmt_rule()
19372             p->level--;  in invalid_del_stmt_rule()
19375 …D(fprintf(stderr, "%*c> invalid_del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' star…  in invalid_del_stmt_rule()
19379             (_keyword = _PyPegen_expect_token(p, 503))  // token='del'  in invalid_del_stmt_rule()
19381             (a = star_expressions_rule(p))  // star_expressions  in invalid_del_stmt_rule()
19384 …D(fprintf(stderr, "%*c+ invalid_del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in invalid_del_stmt_rule()
19387                 p->error_indicator = 1;  in invalid_del_stmt_rule()
19388                 p->level--;  in invalid_del_stmt_rule()
19393         p->mark = _mark;  in invalid_del_stmt_rule()
19394         D(fprintf(stderr, "%*c%s invalid_del_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_del_stmt_rule()
19395                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' star_expressions"));  in invalid_del_stmt_rule()
19399     p->level--;  in invalid_del_stmt_rule()
19405 invalid_block_rule(Parser *p)  in invalid_block_rule()  argument
19407     if (p->level++ == MAXSTACK) {  in invalid_block_rule()
19408         p->error_indicator = 1;  in invalid_block_rule()
19411     if (p->error_indicator) {  in invalid_block_rule()
19412         p->level--;  in invalid_block_rule()
19416     int _mark = p->mark;  in invalid_block_rule()
19418         if (p->error_indicator) {  in invalid_block_rule()
19419             p->level--;  in invalid_block_rule()
19422 …D(fprintf(stderr, "%*c> invalid_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDE…  in invalid_block_rule()
19425             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_block_rule()
19427             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_block_rule()
19430 …D(fprintf(stderr, "%*c+ invalid_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NE…  in invalid_block_rule()
19433                 p->error_indicator = 1;  in invalid_block_rule()
19434                 p->level--;  in invalid_block_rule()
19439         p->mark = _mark;  in invalid_block_rule()
19440         D(fprintf(stderr, "%*c%s invalid_block[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_block_rule()
19441                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE !INDENT"));  in invalid_block_rule()
19445     p->level--;  in invalid_block_rule()
19454 invalid_comprehension_rule(Parser *p)  in invalid_comprehension_rule()  argument
19456     if (p->level++ == MAXSTACK) {  in invalid_comprehension_rule()
19457         p->error_indicator = 1;  in invalid_comprehension_rule()
19460     if (p->error_indicator) {  in invalid_comprehension_rule()
19461         p->level--;  in invalid_comprehension_rule()
19465     int _mark = p->mark;  in invalid_comprehension_rule()
19467         if (p->error_indicator) {  in invalid_comprehension_rule()
19468             p->level--;  in invalid_comprehension_rule()
19471 …D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' …  in invalid_comprehension_rule()
19476             (_tmp_153_var = _tmp_153_rule(p))  // '[' | '(' | '{'  in invalid_comprehension_rule()
19478             (a = starred_expression_rule(p))  // starred_expression  in invalid_comprehension_rule()
19480             (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses  in invalid_comprehension_rule()
19483 …D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in invalid_comprehension_rule()
19486                 p->error_indicator = 1;  in invalid_comprehension_rule()
19487                 p->level--;  in invalid_comprehension_rule()
19492         p->mark = _mark;  in invalid_comprehension_rule()
19493         D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_comprehension_rule()
19494 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_…  in invalid_comprehension_rule()
19497         if (p->error_indicator) {  in invalid_comprehension_rule()
19498             p->level--;  in invalid_comprehension_rule()
19501 …D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' …  in invalid_comprehension_rule()
19508             (_tmp_154_var = _tmp_154_rule(p))  // '[' | '{'  in invalid_comprehension_rule()
19510             (a = star_named_expression_rule(p))  // star_named_expression  in invalid_comprehension_rule()
19512             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_comprehension_rule()
19514             (b = star_named_expressions_rule(p))  // star_named_expressions  in invalid_comprehension_rule()
19516             (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses  in invalid_comprehension_rule()
19519 …D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in invalid_comprehension_rule()
19522                 p->error_indicator = 1;  in invalid_comprehension_rule()
19523                 p->level--;  in invalid_comprehension_rule()
19528         p->mark = _mark;  in invalid_comprehension_rule()
19529         D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_comprehension_rule()
19530 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' star_n…  in invalid_comprehension_rule()
19533         if (p->error_indicator) {  in invalid_comprehension_rule()
19534             p->level--;  in invalid_comprehension_rule()
19537 …D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' …  in invalid_comprehension_rule()
19543             (_tmp_155_var = _tmp_155_rule(p))  // '[' | '{'  in invalid_comprehension_rule()
19545             (a = star_named_expression_rule(p))  // star_named_expression  in invalid_comprehension_rule()
19547             (b = _PyPegen_expect_token(p, 12))  // token=','  in invalid_comprehension_rule()
19549             (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses  in invalid_comprehension_rule()
19552 …D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in invalid_comprehension_rule()
19555                 p->error_indicator = 1;  in invalid_comprehension_rule()
19556                 p->level--;  in invalid_comprehension_rule()
19561         p->mark = _mark;  in invalid_comprehension_rule()
19562         D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_comprehension_rule()
19563 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' for_if…  in invalid_comprehension_rule()
19567     p->level--;  in invalid_comprehension_rule()
19573 invalid_dict_comprehension_rule(Parser *p)  in invalid_dict_comprehension_rule()  argument
19575     if (p->level++ == MAXSTACK) {  in invalid_dict_comprehension_rule()
19576         p->error_indicator = 1;  in invalid_dict_comprehension_rule()
19579     if (p->error_indicator) {  in invalid_dict_comprehension_rule()
19580         p->level--;  in invalid_dict_comprehension_rule()
19584     int _mark = p->mark;  in invalid_dict_comprehension_rule()
19586         if (p->error_indicator) {  in invalid_dict_comprehension_rule()
19587             p->level--;  in invalid_dict_comprehension_rule()
19590 …D(fprintf(stderr, "%*c> invalid_dict_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in invalid_dict_comprehension_rule()
19597             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in invalid_dict_comprehension_rule()
19599             (a = _PyPegen_expect_token(p, 35))  // token='**'  in invalid_dict_comprehension_rule()
19601             (bitwise_or_var = bitwise_or_rule(p))  // bitwise_or  in invalid_dict_comprehension_rule()
19603             (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses  in invalid_dict_comprehension_rule()
19605             (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'  in invalid_dict_comprehension_rule()
19608 …(fprintf(stderr, "%*c+ invalid_dict_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_dict_comprehension_rule()
19611                 p->error_indicator = 1;  in invalid_dict_comprehension_rule()
19612                 p->level--;  in invalid_dict_comprehension_rule()
19617         p->mark = _mark;  in invalid_dict_comprehension_rule()
19618         D(fprintf(stderr, "%*c%s invalid_dict_comprehension[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_dict_comprehension_rule()
19619 …   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'"));  in invalid_dict_comprehension_rule()
19623     p->level--;  in invalid_dict_comprehension_rule()
19629 invalid_parameters_rule(Parser *p)  in invalid_parameters_rule()  argument
19631     if (p->level++ == MAXSTACK) {  in invalid_parameters_rule()
19632         p->error_indicator = 1;  in invalid_parameters_rule()
19635     if (p->error_indicator) {  in invalid_parameters_rule()
19636         p->level--;  in invalid_parameters_rule()
19640     int _mark = p->mark;  in invalid_parameters_rule()
19642         if (p->error_indicator) {  in invalid_parameters_rule()
19643             p->level--;  in invalid_parameters_rule()
19646 …D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no…  in invalid_parameters_rule()
19651             (_loop0_156_var = _loop0_156_rule(p))  // param_no_default*  in invalid_parameters_rule()
19653 …  (invalid_parameters_helper_var = invalid_parameters_helper_rule(p))  // invalid_parameters_helper  in invalid_parameters_rule()
19655             (a = param_no_default_rule(p))  // param_no_default  in invalid_parameters_rule()
19658 …D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_parameters_rule()
19659 …  _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "non-default argument follows default argument" );  in invalid_parameters_rule()
19661                 p->error_indicator = 1;  in invalid_parameters_rule()
19662                 p->level--;  in invalid_parameters_rule()
19667         p->mark = _mark;  in invalid_parameters_rule()
19668         D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_parameters_rule()
19669 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* invalid_parameters_helper …  in invalid_parameters_rule()
19673     p->level--;  in invalid_parameters_rule()
19679 invalid_parameters_helper_rule(Parser *p)  in invalid_parameters_helper_rule()  argument
19681     if (p->level++ == MAXSTACK) {  in invalid_parameters_helper_rule()
19682         p->error_indicator = 1;  in invalid_parameters_helper_rule()
19685     if (p->error_indicator) {  in invalid_parameters_helper_rule()
19686         p->level--;  in invalid_parameters_helper_rule()
19690     int _mark = p->mark;  in invalid_parameters_helper_rule()
19692         if (p->error_indicator) {  in invalid_parameters_helper_rule()
19693             p->level--;  in invalid_parameters_helper_rule()
19696 …D(fprintf(stderr, "%*c> invalid_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "s…  in invalid_parameters_helper_rule()
19699             (a = slash_with_default_rule(p))  // slash_with_default  in invalid_parameters_helper_rule()
19702 …D(fprintf(stderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_parameters_helper_rule()
19703             _res = _PyPegen_singleton_seq ( p , a );  in invalid_parameters_helper_rule()
19705                 p->error_indicator = 1;  in invalid_parameters_helper_rule()
19706                 p->level--;  in invalid_parameters_helper_rule()
19711         p->mark = _mark;  in invalid_parameters_helper_rule()
19712         D(fprintf(stderr, "%*c%s invalid_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_parameters_helper_rule()
19713                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default"));  in invalid_parameters_helper_rule()
19716         if (p->error_indicator) {  in invalid_parameters_helper_rule()
19717             p->level--;  in invalid_parameters_helper_rule()
19720 …D(fprintf(stderr, "%*c> invalid_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "p…  in invalid_parameters_helper_rule()
19723             (_loop1_157_var = _loop1_157_rule(p))  // param_with_default+  in invalid_parameters_helper_rule()
19726 …D(fprintf(stderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_parameters_helper_rule()
19730         p->mark = _mark;  in invalid_parameters_helper_rule()
19731         D(fprintf(stderr, "%*c%s invalid_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_parameters_helper_rule()
19732                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+"));  in invalid_parameters_helper_rule()
19736     p->level--;  in invalid_parameters_helper_rule()
19743 invalid_lambda_parameters_rule(Parser *p)  in invalid_lambda_parameters_rule()  argument
19745     if (p->level++ == MAXSTACK) {  in invalid_lambda_parameters_rule()
19746         p->error_indicator = 1;  in invalid_lambda_parameters_rule()
19749     if (p->error_indicator) {  in invalid_lambda_parameters_rule()
19750         p->level--;  in invalid_lambda_parameters_rule()
19754     int _mark = p->mark;  in invalid_lambda_parameters_rule()
19756         if (p->error_indicator) {  in invalid_lambda_parameters_rule()
19757             p->level--;  in invalid_lambda_parameters_rule()
19760 …D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "l…  in invalid_lambda_parameters_rule()
19765             (_loop0_158_var = _loop0_158_rule(p))  // lambda_param_no_default*  in invalid_lambda_parameters_rule()
19767 …(invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p))  // invalid_lamb…  in invalid_lambda_parameters_rule()
19769             (a = lambda_param_no_default_rule(p))  // lambda_param_no_default  in invalid_lambda_parameters_rule()
19772 …D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_lambda_parameters_rule()
19773 …  _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "non-default argument follows default argument" );  in invalid_lambda_parameters_rule()
19775                 p->error_indicator = 1;  in invalid_lambda_parameters_rule()
19776                 p->level--;  in invalid_lambda_parameters_rule()
19781         p->mark = _mark;  in invalid_lambda_parameters_rule()
19782         D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_lambda_parameters_rule()
19783 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* invalid_lambda_para…  in invalid_lambda_parameters_rule()
19787     p->level--;  in invalid_lambda_parameters_rule()
19795 invalid_lambda_parameters_helper_rule(Parser *p)  in invalid_lambda_parameters_helper_rule()  argument
19797     if (p->level++ == MAXSTACK) {  in invalid_lambda_parameters_helper_rule()
19798         p->error_indicator = 1;  in invalid_lambda_parameters_helper_rule()
19801     if (p->error_indicator) {  in invalid_lambda_parameters_helper_rule()
19802         p->level--;  in invalid_lambda_parameters_helper_rule()
19806     int _mark = p->mark;  in invalid_lambda_parameters_helper_rule()
19808         if (p->error_indicator) {  in invalid_lambda_parameters_helper_rule()
19809             p->level--;  in invalid_lambda_parameters_helper_rule()
19812 …(fprintf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->ma…  in invalid_lambda_parameters_helper_rule()
19815             (a = lambda_slash_with_default_rule(p))  // lambda_slash_with_default  in invalid_lambda_parameters_helper_rule()
19818 …tf(stderr, "%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_lambda_parameters_helper_rule()
19819             _res = _PyPegen_singleton_seq ( p , a );  in invalid_lambda_parameters_helper_rule()
19821                 p->error_indicator = 1;  in invalid_lambda_parameters_helper_rule()
19822                 p->level--;  in invalid_lambda_parameters_helper_rule()
19827         p->mark = _mark;  in invalid_lambda_parameters_helper_rule()
19828 …    D(fprintf(stderr, "%*c%s invalid_lambda_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_lambda_parameters_helper_rule()
19829 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default"));  in invalid_lambda_parameters_helper_rule()
19832         if (p->error_indicator) {  in invalid_lambda_parameters_helper_rule()
19833             p->level--;  in invalid_lambda_parameters_helper_rule()
19836 …(fprintf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->ma…  in invalid_lambda_parameters_helper_rule()
19839             (_loop1_159_var = _loop1_159_rule(p))  // lambda_param_with_default+  in invalid_lambda_parameters_helper_rule()
19842 …tf(stderr, "%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_lambda_parameters_helper_rule()
19846         p->mark = _mark;  in invalid_lambda_parameters_helper_rule()
19847 …    D(fprintf(stderr, "%*c%s invalid_lambda_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_lambda_parameters_helper_rule()
19848 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+"));  in invalid_lambda_parameters_helper_rule()
19852     p->level--;  in invalid_lambda_parameters_helper_rule()
19858 invalid_star_etc_rule(Parser *p)  in invalid_star_etc_rule()  argument
19860     if (p->level++ == MAXSTACK) {  in invalid_star_etc_rule()
19861         p->error_indicator = 1;  in invalid_star_etc_rule()
19864     if (p->error_indicator) {  in invalid_star_etc_rule()
19865         p->level--;  in invalid_star_etc_rule()
19869     int _mark = p->mark;  in invalid_star_etc_rule()
19871         if (p->error_indicator) {  in invalid_star_etc_rule()
19872             p->level--;  in invalid_star_etc_rule()
19875 …D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (')' |…  in invalid_star_etc_rule()
19879             (a = _PyPegen_expect_token(p, 16))  // token='*'  in invalid_star_etc_rule()
19881             (_tmp_160_var = _tmp_160_rule(p))  // ')' | ',' (')' | '**')  in invalid_star_etc_rule()
19884 …D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in invalid_star_etc_rule()
19887                 p->error_indicator = 1;  in invalid_star_etc_rule()
19888                 p->level--;  in invalid_star_etc_rule()
19893         p->mark = _mark;  in invalid_star_etc_rule()
19894         D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_star_etc_rule()
19895 …             p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (')' | ',' (')' | '**'))"));  in invalid_star_etc_rule()
19898         if (p->error_indicator) {  in invalid_star_etc_rule()
19899             p->level--;  in invalid_star_etc_rule()
19902 …D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' TY…  in invalid_star_etc_rule()
19907             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in invalid_star_etc_rule()
19909             (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','  in invalid_star_etc_rule()
19911             (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'  in invalid_star_etc_rule()
19914 …D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in invalid_star_etc_rule()
19917                 p->error_indicator = 1;  in invalid_star_etc_rule()
19918                 p->level--;  in invalid_star_etc_rule()
19923         p->mark = _mark;  in invalid_star_etc_rule()
19924         D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_star_etc_rule()
19925                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' TYPE_COMMENT"));  in invalid_star_etc_rule()
19929     p->level--;  in invalid_star_etc_rule()
19935 invalid_lambda_star_etc_rule(Parser *p)  in invalid_lambda_star_etc_rule()  argument
19937     if (p->level++ == MAXSTACK) {  in invalid_lambda_star_etc_rule()
19938         p->error_indicator = 1;  in invalid_lambda_star_etc_rule()
19941     if (p->error_indicator) {  in invalid_lambda_star_etc_rule()
19942         p->level--;  in invalid_lambda_star_etc_rule()
19946     int _mark = p->mark;  in invalid_lambda_star_etc_rule()
19948         if (p->error_indicator) {  in invalid_lambda_star_etc_rule()
19949             p->level--;  in invalid_lambda_star_etc_rule()
19952 …D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'…  in invalid_lambda_star_etc_rule()
19956             (_literal = _PyPegen_expect_token(p, 16))  // token='*'  in invalid_lambda_star_etc_rule()
19958             (_tmp_161_var = _tmp_161_rule(p))  // ':' | ',' (':' | '**')  in invalid_lambda_star_etc_rule()
19961 …D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p-…  in invalid_lambda_star_etc_rule()
19964                 p->error_indicator = 1;  in invalid_lambda_star_etc_rule()
19965                 p->level--;  in invalid_lambda_star_etc_rule()
19970         p->mark = _mark;  in invalid_lambda_star_etc_rule()
19971         D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_lambda_star_etc_rule()
19972 …             p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (':' | ',' (':' | '**'))"));  in invalid_lambda_star_etc_rule()
19976     p->level--;  in invalid_lambda_star_etc_rule()
19982 invalid_double_type_comments_rule(Parser *p)  in invalid_double_type_comments_rule()  argument
19984     if (p->level++ == MAXSTACK) {  in invalid_double_type_comments_rule()
19985         p->error_indicator = 1;  in invalid_double_type_comments_rule()
19988     if (p->error_indicator) {  in invalid_double_type_comments_rule()
19989         p->level--;  in invalid_double_type_comments_rule()
19993     int _mark = p->mark;  in invalid_double_type_comments_rule()
19995         if (p->error_indicator) {  in invalid_double_type_comments_rule()
19996             p->level--;  in invalid_double_type_comments_rule()
19999 …D(fprintf(stderr, "%*c> invalid_double_type_comments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark,…  in invalid_double_type_comments_rule()
20006             (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'  in invalid_double_type_comments_rule()
20008             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_double_type_comments_rule()
20010             (type_comment_var_1 = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'  in invalid_double_type_comments_rule()
20012             (newline_var_1 = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_double_type_comments_rule()
20014             (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT'  in invalid_double_type_comments_rule()
20017 …printf(stderr, "%*c+ invalid_double_type_comments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_double_type_comments_rule()
20020                 p->error_indicator = 1;  in invalid_double_type_comments_rule()
20021                 p->level--;  in invalid_double_type_comments_rule()
20026         p->mark = _mark;  in invalid_double_type_comments_rule()
20027         D(fprintf(stderr, "%*c%s invalid_double_type_comments[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_double_type_comments_rule()
20028 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE IN…  in invalid_double_type_comments_rule()
20032     p->level--;  in invalid_double_type_comments_rule()
20038 invalid_with_item_rule(Parser *p)  in invalid_with_item_rule()  argument
20040     if (p->level++ == MAXSTACK) {  in invalid_with_item_rule()
20041         p->error_indicator = 1;  in invalid_with_item_rule()
20044     if (p->error_indicator) {  in invalid_with_item_rule()
20045         p->level--;  in invalid_with_item_rule()
20049     int _mark = p->mark;  in invalid_with_item_rule()
20051         if (p->error_indicator) {  in invalid_with_item_rule()
20052             p->level--;  in invalid_with_item_rule()
20055 …D(fprintf(stderr, "%*c> invalid_with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressio…  in invalid_with_item_rule()
20060             (expression_var = expression_rule(p))  // expression  in invalid_with_item_rule()
20062             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in invalid_with_item_rule()
20064             (a = expression_rule(p))  // expression  in invalid_with_item_rule()
20066             _PyPegen_lookahead(1, _tmp_162_rule, p)  in invalid_with_item_rule()
20069 …D(fprintf(stderr, "%*c+ invalid_with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_with_item_rule()
20072                 p->error_indicator = 1;  in invalid_with_item_rule()
20073                 p->level--;  in invalid_with_item_rule()
20078         p->mark = _mark;  in invalid_with_item_rule()
20079         D(fprintf(stderr, "%*c%s invalid_with_item[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_with_item_rule()
20080 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' expression &(',' | ')' | ':'…  in invalid_with_item_rule()
20084     p->level--;  in invalid_with_item_rule()
20090 invalid_for_target_rule(Parser *p)  in invalid_for_target_rule()  argument
20092     if (p->level++ == MAXSTACK) {  in invalid_for_target_rule()
20093         p->error_indicator = 1;  in invalid_for_target_rule()
20096     if (p->error_indicator) {  in invalid_for_target_rule()
20097         p->level--;  in invalid_for_target_rule()
20101     int _mark = p->mark;  in invalid_for_target_rule()
20103         if (p->error_indicator) {  in invalid_for_target_rule()
20104             p->level--;  in invalid_for_target_rule()
20107 …D(fprintf(stderr, "%*c> invalid_for_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? '…  in invalid_for_target_rule()
20113             (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator)  // ASYNC?  in invalid_for_target_rule()
20115             (_keyword = _PyPegen_expect_token(p, 517))  // token='for'  in invalid_for_target_rule()
20117             (a = star_expressions_rule(p))  // star_expressions  in invalid_for_target_rule()
20120 …D(fprintf(stderr, "%*c+ invalid_for_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_for_target_rule()
20123                 p->error_indicator = 1;  in invalid_for_target_rule()
20124                 p->level--;  in invalid_for_target_rule()
20129         p->mark = _mark;  in invalid_for_target_rule()
20130         D(fprintf(stderr, "%*c%s invalid_for_target[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_for_target_rule()
20131 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_expressions"));  in invalid_for_target_rule()
20135     p->level--;  in invalid_for_target_rule()
20141 invalid_group_rule(Parser *p)  in invalid_group_rule()  argument
20143     if (p->level++ == MAXSTACK) {  in invalid_group_rule()
20144         p->error_indicator = 1;  in invalid_group_rule()
20147     if (p->error_indicator) {  in invalid_group_rule()
20148         p->level--;  in invalid_group_rule()
20152     int _mark = p->mark;  in invalid_group_rule()
20154         if (p->error_indicator) {  in invalid_group_rule()
20155             p->level--;  in invalid_group_rule()
20158 …D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' starred_e…  in invalid_group_rule()
20163             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in invalid_group_rule()
20165             (a = starred_expression_rule(p))  // starred_expression  in invalid_group_rule()
20167             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in invalid_group_rule()
20170 …D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(…  in invalid_group_rule()
20173                 p->error_indicator = 1;  in invalid_group_rule()
20174                 p->level--;  in invalid_group_rule()
20179         p->mark = _mark;  in invalid_group_rule()
20180         D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_group_rule()
20181 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' starred_expression ')'"));  in invalid_group_rule()
20184         if (p->error_indicator) {  in invalid_group_rule()
20185             p->level--;  in invalid_group_rule()
20188 …D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' '**' expr…  in invalid_group_rule()
20194             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in invalid_group_rule()
20196             (a = _PyPegen_expect_token(p, 35))  // token='**'  in invalid_group_rule()
20198             (expression_var = expression_rule(p))  // expression  in invalid_group_rule()
20200             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in invalid_group_rule()
20203 …D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(…  in invalid_group_rule()
20206                 p->error_indicator = 1;  in invalid_group_rule()
20207                 p->level--;  in invalid_group_rule()
20212         p->mark = _mark;  in invalid_group_rule()
20213         D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_group_rule()
20214                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' '**' expression ')'"));  in invalid_group_rule()
20218     p->level--;  in invalid_group_rule()
20224 invalid_import_from_targets_rule(Parser *p)  in invalid_import_from_targets_rule()  argument
20226     if (p->level++ == MAXSTACK) {  in invalid_import_from_targets_rule()
20227         p->error_indicator = 1;  in invalid_import_from_targets_rule()
20230     if (p->error_indicator) {  in invalid_import_from_targets_rule()
20231         p->level--;  in invalid_import_from_targets_rule()
20235     int _mark = p->mark;  in invalid_import_from_targets_rule()
20237         if (p->error_indicator) {  in invalid_import_from_targets_rule()
20238             p->level--;  in invalid_import_from_targets_rule()
20241 …D(fprintf(stderr, "%*c> invalid_import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, …  in invalid_import_from_targets_rule()
20246             (import_from_as_names_var = import_from_as_names_rule(p))  // import_from_as_names  in invalid_import_from_targets_rule()
20248             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_import_from_targets_rule()
20250             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_import_from_targets_rule()
20253 …fprintf(stderr, "%*c+ invalid_import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_import_from_targets_rule()
20256                 p->error_indicator = 1;  in invalid_import_from_targets_rule()
20257                 p->level--;  in invalid_import_from_targets_rule()
20262         p->mark = _mark;  in invalid_import_from_targets_rule()
20263         D(fprintf(stderr, "%*c%s invalid_import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_import_from_targets_rule()
20264 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names ',' NEWLINE"));  in invalid_import_from_targets_rule()
20268     p->level--;  in invalid_import_from_targets_rule()
20276 invalid_with_stmt_rule(Parser *p)  in invalid_with_stmt_rule()  argument
20278     if (p->level++ == MAXSTACK) {  in invalid_with_stmt_rule()
20279         p->error_indicator = 1;  in invalid_with_stmt_rule()
20282     if (p->error_indicator) {  in invalid_with_stmt_rule()
20283         p->level--;  in invalid_with_stmt_rule()
20287     int _mark = p->mark;  in invalid_with_stmt_rule()
20289         if (p->error_indicator) {  in invalid_with_stmt_rule()
20290             p->level--;  in invalid_with_stmt_rule()
20293 …D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'w…  in invalid_with_stmt_rule()
20300             (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator)  // ASYNC?  in invalid_with_stmt_rule()
20302             (_keyword = _PyPegen_expect_token(p, 519))  // token='with'  in invalid_with_stmt_rule()
20304             (_gather_163_var = _gather_163_rule(p))  // ','.(expression ['as' star_target])+  in invalid_with_stmt_rule()
20306             (_literal = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in invalid_with_stmt_rule()
20309 …D(fprintf(stderr, "%*c+ invalid_with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_with_stmt_rule()
20310             _res = _PyPegen_dummy_name(p, _opt_var, _keyword, _gather_163_var, _literal);  in invalid_with_stmt_rule()
20313         p->mark = _mark;  in invalid_with_stmt_rule()
20314         D(fprintf(stderr, "%*c%s invalid_with_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_with_stmt_rule()
20315 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_tar…  in invalid_with_stmt_rule()
20318         if (p->error_indicator) {  in invalid_with_stmt_rule()
20319             p->level--;  in invalid_with_stmt_rule()
20322 …D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'w…  in invalid_with_stmt_rule()
20333             (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator)  // ASYNC?  in invalid_with_stmt_rule()
20335             (_keyword = _PyPegen_expect_token(p, 519))  // token='with'  in invalid_with_stmt_rule()
20337             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in invalid_with_stmt_rule()
20339             (_gather_165_var = _gather_165_rule(p))  // ','.(expressions ['as' star_target])+  in invalid_with_stmt_rule()
20341             (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in invalid_with_stmt_rule()
20343             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in invalid_with_stmt_rule()
20345             (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":"))  // forced_token=':'  in invalid_with_stmt_rule()
20348 …D(fprintf(stderr, "%*c+ invalid_with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_with_stmt_rule()
20349 …_res = _PyPegen_dummy_name(p, _opt_var, _keyword, _literal, _gather_165_var, _opt_var_1, _literal_…  in invalid_with_stmt_rule()
20352         p->mark = _mark;  in invalid_with_stmt_rule()
20353         D(fprintf(stderr, "%*c%s invalid_with_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_with_stmt_rule()
20354 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' sta…  in invalid_with_stmt_rule()
20358     p->level--;  in invalid_with_stmt_rule()
20366 invalid_with_stmt_indent_rule(Parser *p)  in invalid_with_stmt_indent_rule()  argument
20368     if (p->level++ == MAXSTACK) {  in invalid_with_stmt_indent_rule()
20369         p->error_indicator = 1;  in invalid_with_stmt_indent_rule()
20372     if (p->error_indicator) {  in invalid_with_stmt_indent_rule()
20373         p->level--;  in invalid_with_stmt_indent_rule()
20377     int _mark = p->mark;  in invalid_with_stmt_indent_rule()
20379         if (p->error_indicator) {  in invalid_with_stmt_indent_rule()
20380             p->level--;  in invalid_with_stmt_indent_rule()
20383 …D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AS…  in invalid_with_stmt_indent_rule()
20391             (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator)  // ASYNC?  in invalid_with_stmt_indent_rule()
20393             (a = _PyPegen_expect_token(p, 519))  // token='with'  in invalid_with_stmt_indent_rule()
20395             (_gather_167_var = _gather_167_rule(p))  // ','.(expression ['as' star_target])+  in invalid_with_stmt_indent_rule()
20397             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_with_stmt_indent_rule()
20399             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_with_stmt_indent_rule()
20401             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_with_stmt_indent_rule()
20404 …D(fprintf(stderr, "%*c+ invalid_with_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p…  in invalid_with_stmt_indent_rule()
20405 …INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno );  in invalid_with_stmt_indent_rule()
20407                 p->error_indicator = 1;  in invalid_with_stmt_indent_rule()
20408                 p->level--;  in invalid_with_stmt_indent_rule()
20413         p->mark = _mark;  in invalid_with_stmt_indent_rule()
20414         D(fprintf(stderr, "%*c%s invalid_with_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_with_stmt_indent_rule()
20415 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_tar…  in invalid_with_stmt_indent_rule()
20418         if (p->error_indicator) {  in invalid_with_stmt_indent_rule()
20419             p->level--;  in invalid_with_stmt_indent_rule()
20422 …D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AS…  in invalid_with_stmt_indent_rule()
20434             (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator)  // ASYNC?  in invalid_with_stmt_indent_rule()
20436             (a = _PyPegen_expect_token(p, 519))  // token='with'  in invalid_with_stmt_indent_rule()
20438             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in invalid_with_stmt_indent_rule()
20440             (_gather_169_var = _gather_169_rule(p))  // ','.(expressions ['as' star_target])+  in invalid_with_stmt_indent_rule()
20442             (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?  in invalid_with_stmt_indent_rule()
20444             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in invalid_with_stmt_indent_rule()
20446             (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_with_stmt_indent_rule()
20448             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_with_stmt_indent_rule()
20450             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_with_stmt_indent_rule()
20453 …D(fprintf(stderr, "%*c+ invalid_with_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p…  in invalid_with_stmt_indent_rule()
20454 …INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno );  in invalid_with_stmt_indent_rule()
20456                 p->error_indicator = 1;  in invalid_with_stmt_indent_rule()
20457                 p->level--;  in invalid_with_stmt_indent_rule()
20462         p->mark = _mark;  in invalid_with_stmt_indent_rule()
20463         D(fprintf(stderr, "%*c%s invalid_with_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_with_stmt_indent_rule()
20464 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' sta…  in invalid_with_stmt_indent_rule()
20468     p->level--;  in invalid_with_stmt_indent_rule()
20474 invalid_try_stmt_rule(Parser *p)  in invalid_try_stmt_rule()  argument
20476     if (p->level++ == MAXSTACK) {  in invalid_try_stmt_rule()
20477         p->error_indicator = 1;  in invalid_try_stmt_rule()
20480     if (p->error_indicator) {  in invalid_try_stmt_rule()
20481         p->level--;  in invalid_try_stmt_rule()
20485     int _mark = p->mark;  in invalid_try_stmt_rule()
20487         if (p->error_indicator) {  in invalid_try_stmt_rule()
20488             p->level--;  in invalid_try_stmt_rule()
20491 …D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' …  in invalid_try_stmt_rule()
20496             (a = _PyPegen_expect_token(p, 511))  // token='try'  in invalid_try_stmt_rule()
20498             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_try_stmt_rule()
20500             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_try_stmt_rule()
20502             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_try_stmt_rule()
20505 …D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in invalid_try_stmt_rule()
20506 …_INDENTATION_ERROR ( "expected an indented block after 'try' statement on line %d" , a -> lineno );  in invalid_try_stmt_rule()
20508                 p->error_indicator = 1;  in invalid_try_stmt_rule()
20509                 p->level--;  in invalid_try_stmt_rule()
20514         p->mark = _mark;  in invalid_try_stmt_rule()
20515         D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_try_stmt_rule()
20516 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' NEWLINE !INDENT"));  in invalid_try_stmt_rule()
20519         if (p->error_indicator) {  in invalid_try_stmt_rule()
20520             p->level--;  in invalid_try_stmt_rule()
20523 …D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' …  in invalid_try_stmt_rule()
20528             (_keyword = _PyPegen_expect_token(p, 511))  // token='try'  in invalid_try_stmt_rule()
20530             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_try_stmt_rule()
20532             (block_var = block_rule(p))  // block  in invalid_try_stmt_rule()
20534             _PyPegen_lookahead(0, _tmp_171_rule, p)  in invalid_try_stmt_rule()
20537 …D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in invalid_try_stmt_rule()
20540                 p->error_indicator = 1;  in invalid_try_stmt_rule()
20541                 p->level--;  in invalid_try_stmt_rule()
20546         p->mark = _mark;  in invalid_try_stmt_rule()
20547         D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_try_stmt_rule()
20548 …  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block !('except' | 'finally')"));  in invalid_try_stmt_rule()
20552     p->level--;  in invalid_try_stmt_rule()
20561 invalid_except_stmt_rule(Parser *p)  in invalid_except_stmt_rule()  argument
20563     if (p->level++ == MAXSTACK) {  in invalid_except_stmt_rule()
20564         p->error_indicator = 1;  in invalid_except_stmt_rule()
20567     if (p->error_indicator) {  in invalid_except_stmt_rule()
20568         p->level--;  in invalid_except_stmt_rule()
20572     int _mark = p->mark;  in invalid_except_stmt_rule()
20574         if (p->error_indicator) {  in invalid_except_stmt_rule()
20575             p->level--;  in invalid_except_stmt_rule()
20578 …D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except…  in invalid_except_stmt_rule()
20587             (_keyword = _PyPegen_expect_token(p, 521))  // token='except'  in invalid_except_stmt_rule()
20589             (a = expression_rule(p))  // expression  in invalid_except_stmt_rule()
20591             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_except_stmt_rule()
20593             (expressions_var = expressions_rule(p))  // expressions  in invalid_except_stmt_rule()
20595             (_opt_var = _tmp_172_rule(p), !p->error_indicator)  // ['as' NAME]  in invalid_except_stmt_rule()
20597             (_literal_1 = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_except_stmt_rule()
20600 …D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in invalid_except_stmt_rule()
20603                 p->error_indicator = 1;  in invalid_except_stmt_rule()
20604                 p->level--;  in invalid_except_stmt_rule()
20609         p->mark = _mark;  in invalid_except_stmt_rule()
20610         D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_except_stmt_rule()
20611 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ',' expressions ['as' NA…  in invalid_except_stmt_rule()
20614         if (p->error_indicator) {  in invalid_except_stmt_rule()
20615             p->level--;  in invalid_except_stmt_rule()
20618 …D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except…  in invalid_except_stmt_rule()
20625             (a = _PyPegen_expect_token(p, 521))  // token='except'  in invalid_except_stmt_rule()
20627             (expression_var = expression_rule(p))  // expression  in invalid_except_stmt_rule()
20629             (_opt_var = _tmp_173_rule(p), !p->error_indicator)  // ['as' NAME]  in invalid_except_stmt_rule()
20631             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_except_stmt_rule()
20634 …D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in invalid_except_stmt_rule()
20637                 p->error_indicator = 1;  in invalid_except_stmt_rule()
20638                 p->level--;  in invalid_except_stmt_rule()
20643         p->mark = _mark;  in invalid_except_stmt_rule()
20644         D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_except_stmt_rule()
20645 …  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] NEWLINE"));  in invalid_except_stmt_rule()
20648         if (p->error_indicator) {  in invalid_except_stmt_rule()
20649             p->level--;  in invalid_except_stmt_rule()
20652 …D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except…  in invalid_except_stmt_rule()
20656             (a = _PyPegen_expect_token(p, 521))  // token='except'  in invalid_except_stmt_rule()
20658             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_except_stmt_rule()
20661 …D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mar…  in invalid_except_stmt_rule()
20664                 p->error_indicator = 1;  in invalid_except_stmt_rule()
20665                 p->level--;  in invalid_except_stmt_rule()
20670         p->mark = _mark;  in invalid_except_stmt_rule()
20671         D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_except_stmt_rule()
20672                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' NEWLINE"));  in invalid_except_stmt_rule()
20676     p->level--;  in invalid_except_stmt_rule()
20682 invalid_finally_stmt_rule(Parser *p)  in invalid_finally_stmt_rule()  argument
20684     if (p->level++ == MAXSTACK) {  in invalid_finally_stmt_rule()
20685         p->error_indicator = 1;  in invalid_finally_stmt_rule()
20688     if (p->error_indicator) {  in invalid_finally_stmt_rule()
20689         p->level--;  in invalid_finally_stmt_rule()
20693     int _mark = p->mark;  in invalid_finally_stmt_rule()
20695         if (p->error_indicator) {  in invalid_finally_stmt_rule()
20696             p->level--;  in invalid_finally_stmt_rule()
20699 …D(fprintf(stderr, "%*c> invalid_finally_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'final…  in invalid_finally_stmt_rule()
20704             (a = _PyPegen_expect_token(p, 522))  // token='finally'  in invalid_finally_stmt_rule()
20706             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_finally_stmt_rule()
20708             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_finally_stmt_rule()
20710             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_finally_stmt_rule()
20713 …D(fprintf(stderr, "%*c+ invalid_finally_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->ma…  in invalid_finally_stmt_rule()
20714 …ENTATION_ERROR ( "expected an indented block after 'finally' statement on line %d" , a -> lineno );  in invalid_finally_stmt_rule()
20716                 p->error_indicator = 1;  in invalid_finally_stmt_rule()
20717                 p->level--;  in invalid_finally_stmt_rule()
20722         p->mark = _mark;  in invalid_finally_stmt_rule()
20723         D(fprintf(stderr, "%*c%s invalid_finally_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_finally_stmt_rule()
20724 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' ':' NEWLINE !INDENT"));  in invalid_finally_stmt_rule()
20728     p->level--;  in invalid_finally_stmt_rule()
20736 invalid_except_stmt_indent_rule(Parser *p)  in invalid_except_stmt_indent_rule()  argument
20738     if (p->level++ == MAXSTACK) {  in invalid_except_stmt_indent_rule()
20739         p->error_indicator = 1;  in invalid_except_stmt_indent_rule()
20742     if (p->error_indicator) {  in invalid_except_stmt_indent_rule()
20743         p->level--;  in invalid_except_stmt_indent_rule()
20747     int _mark = p->mark;  in invalid_except_stmt_indent_rule()
20749         if (p->error_indicator) {  in invalid_except_stmt_indent_rule()
20750             p->level--;  in invalid_except_stmt_indent_rule()
20753 …D(fprintf(stderr, "%*c> invalid_except_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in invalid_except_stmt_indent_rule()
20761             (a = _PyPegen_expect_token(p, 521))  // token='except'  in invalid_except_stmt_indent_rule()
20763             (expression_var = expression_rule(p))  // expression  in invalid_except_stmt_indent_rule()
20765             (_opt_var = _tmp_174_rule(p), !p->error_indicator)  // ['as' NAME]  in invalid_except_stmt_indent_rule()
20767             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_except_stmt_indent_rule()
20769             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_except_stmt_indent_rule()
20771             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_except_stmt_indent_rule()
20774 …(fprintf(stderr, "%*c+ invalid_except_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_except_stmt_indent_rule()
20775 …DENTATION_ERROR ( "expected an indented block after 'except' statement on line %d" , a -> lineno );  in invalid_except_stmt_indent_rule()
20777                 p->error_indicator = 1;  in invalid_except_stmt_indent_rule()
20778                 p->level--;  in invalid_except_stmt_indent_rule()
20783         p->mark = _mark;  in invalid_except_stmt_indent_rule()
20784         D(fprintf(stderr, "%*c%s invalid_except_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_except_stmt_indent_rule()
20785 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' NEWLINE …  in invalid_except_stmt_indent_rule()
20788         if (p->error_indicator) {  in invalid_except_stmt_indent_rule()
20789             p->level--;  in invalid_except_stmt_indent_rule()
20792 …D(fprintf(stderr, "%*c> invalid_except_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "…  in invalid_except_stmt_indent_rule()
20797             (a = _PyPegen_expect_token(p, 521))  // token='except'  in invalid_except_stmt_indent_rule()
20799             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_except_stmt_indent_rule()
20801             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_except_stmt_indent_rule()
20803             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_except_stmt_indent_rule()
20806 …(fprintf(stderr, "%*c+ invalid_except_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_except_stmt_indent_rule()
20807 …AISE_SYNTAX_ERROR ( "expected an indented block after except statement on line %d" , a -> lineno );  in invalid_except_stmt_indent_rule()
20809                 p->error_indicator = 1;  in invalid_except_stmt_indent_rule()
20810                 p->level--;  in invalid_except_stmt_indent_rule()
20815         p->mark = _mark;  in invalid_except_stmt_indent_rule()
20816         D(fprintf(stderr, "%*c%s invalid_except_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_except_stmt_indent_rule()
20817 …             p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' NEWLINE !INDENT"));  in invalid_except_stmt_indent_rule()
20821     p->level--;  in invalid_except_stmt_indent_rule()
20829 invalid_match_stmt_rule(Parser *p)  in invalid_match_stmt_rule()  argument
20831     if (p->level++ == MAXSTACK) {  in invalid_match_stmt_rule()
20832         p->error_indicator = 1;  in invalid_match_stmt_rule()
20835     if (p->error_indicator) {  in invalid_match_stmt_rule()
20836         p->level--;  in invalid_match_stmt_rule()
20840     int _mark = p->mark;  in invalid_match_stmt_rule()
20842         if (p->error_indicator) {  in invalid_match_stmt_rule()
20843             p->level--;  in invalid_match_stmt_rule()
20846 …D(fprintf(stderr, "%*c> invalid_match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\…  in invalid_match_stmt_rule()
20850             (_keyword = _PyPegen_expect_soft_keyword(p, "match"))  // soft_keyword='"match"'  in invalid_match_stmt_rule()
20852             (subject_expr_var = subject_expr_rule(p))  // subject_expr  in invalid_match_stmt_rule()
20854             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 11)  // token=':'  in invalid_match_stmt_rule()
20857 …D(fprintf(stderr, "%*c+ invalid_match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_match_stmt_rule()
20860                 p->error_indicator = 1;  in invalid_match_stmt_rule()
20861                 p->level--;  in invalid_match_stmt_rule()
20866         p->mark = _mark;  in invalid_match_stmt_rule()
20867         D(fprintf(stderr, "%*c%s invalid_match_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_match_stmt_rule()
20868 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr !':'"));  in invalid_match_stmt_rule()
20871         if (p->error_indicator) {  in invalid_match_stmt_rule()
20872             p->level--;  in invalid_match_stmt_rule()
20875 …D(fprintf(stderr, "%*c> invalid_match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\…  in invalid_match_stmt_rule()
20881             (a = _PyPegen_expect_soft_keyword(p, "match"))  // soft_keyword='"match"'  in invalid_match_stmt_rule()
20883             (subject = subject_expr_rule(p))  // subject_expr  in invalid_match_stmt_rule()
20885             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_match_stmt_rule()
20887             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_match_stmt_rule()
20889             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_match_stmt_rule()
20892 …D(fprintf(stderr, "%*c+ invalid_match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_match_stmt_rule()
20893 …NDENTATION_ERROR ( "expected an indented block after 'match' statement on line %d" , a -> lineno );  in invalid_match_stmt_rule()
20895                 p->error_indicator = 1;  in invalid_match_stmt_rule()
20896                 p->level--;  in invalid_match_stmt_rule()
20901         p->mark = _mark;  in invalid_match_stmt_rule()
20902         D(fprintf(stderr, "%*c%s invalid_match_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_match_stmt_rule()
20903 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr ':' NEWLINE !INDENT")…  in invalid_match_stmt_rule()
20907     p->level--;  in invalid_match_stmt_rule()
20915 invalid_case_block_rule(Parser *p)  in invalid_case_block_rule()  argument
20917     if (p->level++ == MAXSTACK) {  in invalid_case_block_rule()
20918         p->error_indicator = 1;  in invalid_case_block_rule()
20921     if (p->error_indicator) {  in invalid_case_block_rule()
20922         p->level--;  in invalid_case_block_rule()
20926     int _mark = p->mark;  in invalid_case_block_rule()
20928         if (p->error_indicator) {  in invalid_case_block_rule()
20929             p->level--;  in invalid_case_block_rule()
20932 …D(fprintf(stderr, "%*c> invalid_case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\"…  in invalid_case_block_rule()
20938             (_keyword = _PyPegen_expect_soft_keyword(p, "case"))  // soft_keyword='"case"'  in invalid_case_block_rule()
20940             (patterns_var = patterns_rule(p))  // patterns  in invalid_case_block_rule()
20942             (_opt_var = guard_rule(p), !p->error_indicator)  // guard?  in invalid_case_block_rule()
20944             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 11)  // token=':'  in invalid_case_block_rule()
20947 …D(fprintf(stderr, "%*c+ invalid_case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_case_block_rule()
20950                 p->error_indicator = 1;  in invalid_case_block_rule()
20951                 p->level--;  in invalid_case_block_rule()
20956         p->mark = _mark;  in invalid_case_block_rule()
20957         D(fprintf(stderr, "%*c%s invalid_case_block[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_case_block_rule()
20958 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? !':'"));  in invalid_case_block_rule()
20961         if (p->error_indicator) {  in invalid_case_block_rule()
20962             p->level--;  in invalid_case_block_rule()
20965 …D(fprintf(stderr, "%*c> invalid_case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\"…  in invalid_case_block_rule()
20973             (a = _PyPegen_expect_soft_keyword(p, "case"))  // soft_keyword='"case"'  in invalid_case_block_rule()
20975             (patterns_var = patterns_rule(p))  // patterns  in invalid_case_block_rule()
20977             (_opt_var = guard_rule(p), !p->error_indicator)  // guard?  in invalid_case_block_rule()
20979             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_case_block_rule()
20981             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_case_block_rule()
20983             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_case_block_rule()
20986 …D(fprintf(stderr, "%*c+ invalid_case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_case_block_rule()
20987 …INDENTATION_ERROR ( "expected an indented block after 'case' statement on line %d" , a -> lineno );  in invalid_case_block_rule()
20989                 p->error_indicator = 1;  in invalid_case_block_rule()
20990                 p->level--;  in invalid_case_block_rule()
20995         p->mark = _mark;  in invalid_case_block_rule()
20996         D(fprintf(stderr, "%*c%s invalid_case_block[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_case_block_rule()
20997 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? ':' NEWLINE !INDENT…  in invalid_case_block_rule()
21001     p->level--;  in invalid_case_block_rule()
21007 invalid_as_pattern_rule(Parser *p)  in invalid_as_pattern_rule()  argument
21009     if (p->level++ == MAXSTACK) {  in invalid_as_pattern_rule()
21010         p->error_indicator = 1;  in invalid_as_pattern_rule()
21013     if (p->error_indicator) {  in invalid_as_pattern_rule()
21014         p->level--;  in invalid_as_pattern_rule()
21018     int _mark = p->mark;  in invalid_as_pattern_rule()
21020         if (p->error_indicator) {  in invalid_as_pattern_rule()
21021             p->level--;  in invalid_as_pattern_rule()
21024 …D(fprintf(stderr, "%*c> invalid_as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_patte…  in invalid_as_pattern_rule()
21029             (or_pattern_var = or_pattern_rule(p))  // or_pattern  in invalid_as_pattern_rule()
21031             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in invalid_as_pattern_rule()
21033             (a = _PyPegen_expect_soft_keyword(p, "_"))  // soft_keyword='"_"'  in invalid_as_pattern_rule()
21036 …D(fprintf(stderr, "%*c+ invalid_as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_as_pattern_rule()
21039                 p->error_indicator = 1;  in invalid_as_pattern_rule()
21040                 p->level--;  in invalid_as_pattern_rule()
21045         p->mark = _mark;  in invalid_as_pattern_rule()
21046         D(fprintf(stderr, "%*c%s invalid_as_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_as_pattern_rule()
21047                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' \"_\""));  in invalid_as_pattern_rule()
21050         if (p->error_indicator) {  in invalid_as_pattern_rule()
21051             p->level--;  in invalid_as_pattern_rule()
21054 …D(fprintf(stderr, "%*c> invalid_as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_patte…  in invalid_as_pattern_rule()
21059             (or_pattern_var = or_pattern_rule(p))  // or_pattern  in invalid_as_pattern_rule()
21061             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in invalid_as_pattern_rule()
21063             _PyPegen_lookahead_with_name(0, _PyPegen_name_token, p)  in invalid_as_pattern_rule()
21065             (a = expression_rule(p))  // expression  in invalid_as_pattern_rule()
21068 …D(fprintf(stderr, "%*c+ invalid_as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_as_pattern_rule()
21071                 p->error_indicator = 1;  in invalid_as_pattern_rule()
21072                 p->level--;  in invalid_as_pattern_rule()
21077         p->mark = _mark;  in invalid_as_pattern_rule()
21078         D(fprintf(stderr, "%*c%s invalid_as_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_as_pattern_rule()
21079 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' !NAME expression"));  in invalid_as_pattern_rule()
21083     p->level--;  in invalid_as_pattern_rule()
21089 invalid_class_pattern_rule(Parser *p)  in invalid_class_pattern_rule()  argument
21091     if (p->level++ == MAXSTACK) {  in invalid_class_pattern_rule()
21092         p->error_indicator = 1;  in invalid_class_pattern_rule()
21095     if (p->error_indicator) {  in invalid_class_pattern_rule()
21096         p->level--;  in invalid_class_pattern_rule()
21100     int _mark = p->mark;  in invalid_class_pattern_rule()
21102         if (p->error_indicator) {  in invalid_class_pattern_rule()
21103             p->level--;  in invalid_class_pattern_rule()
21106 …D(fprintf(stderr, "%*c> invalid_class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_…  in invalid_class_pattern_rule()
21111             (name_or_attr_var = name_or_attr_rule(p))  // name_or_attr  in invalid_class_pattern_rule()
21113             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in invalid_class_pattern_rule()
21115             (a = invalid_class_argument_pattern_rule(p))  // invalid_class_argument_pattern  in invalid_class_pattern_rule()
21118 …D(fprintf(stderr, "%*c+ invalid_class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in invalid_class_pattern_rule()
21121                 p->error_indicator = 1;  in invalid_class_pattern_rule()
21122                 p->level--;  in invalid_class_pattern_rule()
21127         p->mark = _mark;  in invalid_class_pattern_rule()
21128         D(fprintf(stderr, "%*c%s invalid_class_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_class_pattern_rule()
21129 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' invalid_class_argument_patt…  in invalid_class_pattern_rule()
21133     p->level--;  in invalid_class_pattern_rule()
21140 invalid_class_argument_pattern_rule(Parser *p)  in invalid_class_argument_pattern_rule()  argument
21142     if (p->level++ == MAXSTACK) {  in invalid_class_argument_pattern_rule()
21143         p->error_indicator = 1;  in invalid_class_argument_pattern_rule()
21146     if (p->error_indicator) {  in invalid_class_argument_pattern_rule()
21147         p->level--;  in invalid_class_argument_pattern_rule()
21151     int _mark = p->mark;  in invalid_class_argument_pattern_rule()
21153         if (p->error_indicator) {  in invalid_class_argument_pattern_rule()
21154             p->level--;  in invalid_class_argument_pattern_rule()
21157 …D(fprintf(stderr, "%*c> invalid_class_argument_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mar…  in invalid_class_argument_pattern_rule()
21164             (_opt_var = _tmp_175_rule(p), !p->error_indicator)  // [positional_patterns ',']  in invalid_class_argument_pattern_rule()
21166             (keyword_patterns_var = keyword_patterns_rule(p))  // keyword_patterns  in invalid_class_argument_pattern_rule()
21168             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_class_argument_pattern_rule()
21170             (a = positional_patterns_rule(p))  // positional_patterns  in invalid_class_argument_pattern_rule()
21173 …intf(stderr, "%*c+ invalid_class_argument_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_class_argument_pattern_rule()
21176                 p->error_indicator = 1;  in invalid_class_argument_pattern_rule()
21177                 p->level--;  in invalid_class_argument_pattern_rule()
21182         p->mark = _mark;  in invalid_class_argument_pattern_rule()
21183 …      D(fprintf(stderr, "%*c%s invalid_class_argument_pattern[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_class_argument_pattern_rule()
21184 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[positional_patterns ','] keyword_patterns '…  in invalid_class_argument_pattern_rule()
21188     p->level--;  in invalid_class_argument_pattern_rule()
21196 invalid_if_stmt_rule(Parser *p)  in invalid_if_stmt_rule()  argument
21198     if (p->level++ == MAXSTACK) {  in invalid_if_stmt_rule()
21199         p->error_indicator = 1;  in invalid_if_stmt_rule()
21202     if (p->error_indicator) {  in invalid_if_stmt_rule()
21203         p->level--;  in invalid_if_stmt_rule()
21207     int _mark = p->mark;  in invalid_if_stmt_rule()
21209         if (p->error_indicator) {  in invalid_if_stmt_rule()
21210             p->level--;  in invalid_if_stmt_rule()
21213 …D(fprintf(stderr, "%*c> invalid_if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_…  in invalid_if_stmt_rule()
21218             (_keyword = _PyPegen_expect_token(p, 510))  // token='if'  in invalid_if_stmt_rule()
21220             (named_expression_var = named_expression_rule(p))  // named_expression  in invalid_if_stmt_rule()
21222             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_if_stmt_rule()
21225 …D(fprintf(stderr, "%*c+ invalid_if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in invalid_if_stmt_rule()
21228                 p->error_indicator = 1;  in invalid_if_stmt_rule()
21229                 p->level--;  in invalid_if_stmt_rule()
21234         p->mark = _mark;  in invalid_if_stmt_rule()
21235         D(fprintf(stderr, "%*c%s invalid_if_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_if_stmt_rule()
21236 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression NEWLINE"));  in invalid_if_stmt_rule()
21239         if (p->error_indicator) {  in invalid_if_stmt_rule()
21240             p->level--;  in invalid_if_stmt_rule()
21243 …D(fprintf(stderr, "%*c> invalid_if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_…  in invalid_if_stmt_rule()
21249             (a = _PyPegen_expect_token(p, 510))  // token='if'  in invalid_if_stmt_rule()
21251             (a_1 = named_expression_rule(p))  // named_expression  in invalid_if_stmt_rule()
21253             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_if_stmt_rule()
21255             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_if_stmt_rule()
21257             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_if_stmt_rule()
21260 …D(fprintf(stderr, "%*c+ invalid_if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "…  in invalid_if_stmt_rule()
21261 …E_INDENTATION_ERROR ( "expected an indented block after 'if' statement on line %d" , a -> lineno );  in invalid_if_stmt_rule()
21263                 p->error_indicator = 1;  in invalid_if_stmt_rule()
21264                 p->level--;  in invalid_if_stmt_rule()
21269         p->mark = _mark;  in invalid_if_stmt_rule()
21270         D(fprintf(stderr, "%*c%s invalid_if_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_if_stmt_rule()
21271 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' NEWLINE !INDENT"));  in invalid_if_stmt_rule()
21275     p->level--;  in invalid_if_stmt_rule()
21283 invalid_elif_stmt_rule(Parser *p)  in invalid_elif_stmt_rule()  argument
21285     if (p->level++ == MAXSTACK) {  in invalid_elif_stmt_rule()
21286         p->error_indicator = 1;  in invalid_elif_stmt_rule()
21289     if (p->error_indicator) {  in invalid_elif_stmt_rule()
21290         p->level--;  in invalid_elif_stmt_rule()
21294     int _mark = p->mark;  in invalid_elif_stmt_rule()
21296         if (p->error_indicator) {  in invalid_elif_stmt_rule()
21297             p->level--;  in invalid_elif_stmt_rule()
21300 …D(fprintf(stderr, "%*c> invalid_elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' na…  in invalid_elif_stmt_rule()
21305             (_keyword = _PyPegen_expect_token(p, 515))  // token='elif'  in invalid_elif_stmt_rule()
21307             (named_expression_var = named_expression_rule(p))  // named_expression  in invalid_elif_stmt_rule()
21309             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_elif_stmt_rule()
21312 …D(fprintf(stderr, "%*c+ invalid_elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_elif_stmt_rule()
21315                 p->error_indicator = 1;  in invalid_elif_stmt_rule()
21316                 p->level--;  in invalid_elif_stmt_rule()
21321         p->mark = _mark;  in invalid_elif_stmt_rule()
21322         D(fprintf(stderr, "%*c%s invalid_elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_elif_stmt_rule()
21323 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression NEWLINE"));  in invalid_elif_stmt_rule()
21326         if (p->error_indicator) {  in invalid_elif_stmt_rule()
21327             p->level--;  in invalid_elif_stmt_rule()
21330 …D(fprintf(stderr, "%*c> invalid_elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' na…  in invalid_elif_stmt_rule()
21336             (a = _PyPegen_expect_token(p, 515))  // token='elif'  in invalid_elif_stmt_rule()
21338             (named_expression_var = named_expression_rule(p))  // named_expression  in invalid_elif_stmt_rule()
21340             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_elif_stmt_rule()
21342             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_elif_stmt_rule()
21344             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_elif_stmt_rule()
21347 …D(fprintf(stderr, "%*c+ invalid_elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_elif_stmt_rule()
21348 …INDENTATION_ERROR ( "expected an indented block after 'elif' statement on line %d" , a -> lineno );  in invalid_elif_stmt_rule()
21350                 p->error_indicator = 1;  in invalid_elif_stmt_rule()
21351                 p->level--;  in invalid_elif_stmt_rule()
21356         p->mark = _mark;  in invalid_elif_stmt_rule()
21357         D(fprintf(stderr, "%*c%s invalid_elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_elif_stmt_rule()
21358 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' NEWLINE !INDENT"…  in invalid_elif_stmt_rule()
21362     p->level--;  in invalid_elif_stmt_rule()
21368 invalid_else_stmt_rule(Parser *p)  in invalid_else_stmt_rule()  argument
21370     if (p->level++ == MAXSTACK) {  in invalid_else_stmt_rule()
21371         p->error_indicator = 1;  in invalid_else_stmt_rule()
21374     if (p->error_indicator) {  in invalid_else_stmt_rule()
21375         p->level--;  in invalid_else_stmt_rule()
21379     int _mark = p->mark;  in invalid_else_stmt_rule()
21381         if (p->error_indicator) {  in invalid_else_stmt_rule()
21382             p->level--;  in invalid_else_stmt_rule()
21385 …D(fprintf(stderr, "%*c> invalid_else_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' ':…  in invalid_else_stmt_rule()
21390             (a = _PyPegen_expect_token(p, 516))  // token='else'  in invalid_else_stmt_rule()
21392             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_else_stmt_rule()
21394             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_else_stmt_rule()
21396             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_else_stmt_rule()
21399 …D(fprintf(stderr, "%*c+ invalid_else_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark,…  in invalid_else_stmt_rule()
21400 …INDENTATION_ERROR ( "expected an indented block after 'else' statement on line %d" , a -> lineno );  in invalid_else_stmt_rule()
21402                 p->error_indicator = 1;  in invalid_else_stmt_rule()
21403                 p->level--;  in invalid_else_stmt_rule()
21408         p->mark = _mark;  in invalid_else_stmt_rule()
21409         D(fprintf(stderr, "%*c%s invalid_else_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_else_stmt_rule()
21410 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' ':' NEWLINE !INDENT"));  in invalid_else_stmt_rule()
21414     p->level--;  in invalid_else_stmt_rule()
21422 invalid_while_stmt_rule(Parser *p)  in invalid_while_stmt_rule()  argument
21424     if (p->level++ == MAXSTACK) {  in invalid_while_stmt_rule()
21425         p->error_indicator = 1;  in invalid_while_stmt_rule()
21428     if (p->error_indicator) {  in invalid_while_stmt_rule()
21429         p->level--;  in invalid_while_stmt_rule()
21433     int _mark = p->mark;  in invalid_while_stmt_rule()
21435         if (p->error_indicator) {  in invalid_while_stmt_rule()
21436             p->level--;  in invalid_while_stmt_rule()
21439 …D(fprintf(stderr, "%*c> invalid_while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' …  in invalid_while_stmt_rule()
21444             (_keyword = _PyPegen_expect_token(p, 512))  // token='while'  in invalid_while_stmt_rule()
21446             (named_expression_var = named_expression_rule(p))  // named_expression  in invalid_while_stmt_rule()
21448             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_while_stmt_rule()
21451 …D(fprintf(stderr, "%*c+ invalid_while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_while_stmt_rule()
21454                 p->error_indicator = 1;  in invalid_while_stmt_rule()
21455                 p->level--;  in invalid_while_stmt_rule()
21460         p->mark = _mark;  in invalid_while_stmt_rule()
21461         D(fprintf(stderr, "%*c%s invalid_while_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_while_stmt_rule()
21462 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression NEWLINE"));  in invalid_while_stmt_rule()
21465         if (p->error_indicator) {  in invalid_while_stmt_rule()
21466             p->level--;  in invalid_while_stmt_rule()
21469 …D(fprintf(stderr, "%*c> invalid_while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' …  in invalid_while_stmt_rule()
21475             (a = _PyPegen_expect_token(p, 512))  // token='while'  in invalid_while_stmt_rule()
21477             (named_expression_var = named_expression_rule(p))  // named_expression  in invalid_while_stmt_rule()
21479             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_while_stmt_rule()
21481             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_while_stmt_rule()
21483             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_while_stmt_rule()
21486 …D(fprintf(stderr, "%*c+ invalid_while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark…  in invalid_while_stmt_rule()
21487 …NDENTATION_ERROR ( "expected an indented block after 'while' statement on line %d" , a -> lineno );  in invalid_while_stmt_rule()
21489                 p->error_indicator = 1;  in invalid_while_stmt_rule()
21490                 p->level--;  in invalid_while_stmt_rule()
21495         p->mark = _mark;  in invalid_while_stmt_rule()
21496         D(fprintf(stderr, "%*c%s invalid_while_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_while_stmt_rule()
21497 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' NEWLINE !INDENT…  in invalid_while_stmt_rule()
21501     p->level--;  in invalid_while_stmt_rule()
21507 invalid_for_stmt_rule(Parser *p)  in invalid_for_stmt_rule()  argument
21509     if (p->level++ == MAXSTACK) {  in invalid_for_stmt_rule()
21510         p->error_indicator = 1;  in invalid_for_stmt_rule()
21513     if (p->error_indicator) {  in invalid_for_stmt_rule()
21514         p->level--;  in invalid_for_stmt_rule()
21518     int _mark = p->mark;  in invalid_for_stmt_rule()
21520         if (p->error_indicator) {  in invalid_for_stmt_rule()
21521             p->level--;  in invalid_for_stmt_rule()
21524 …D(fprintf(stderr, "%*c> invalid_for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'fo…  in invalid_for_stmt_rule()
21534             (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator)  // ASYNC?  in invalid_for_stmt_rule()
21536             (a = _PyPegen_expect_token(p, 517))  // token='for'  in invalid_for_stmt_rule()
21538             (star_targets_var = star_targets_rule(p))  // star_targets  in invalid_for_stmt_rule()
21540             (_keyword = _PyPegen_expect_token(p, 518))  // token='in'  in invalid_for_stmt_rule()
21542             (star_expressions_var = star_expressions_rule(p))  // star_expressions  in invalid_for_stmt_rule()
21544             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_for_stmt_rule()
21546             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_for_stmt_rule()
21548             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_for_stmt_rule()
21551 …D(fprintf(stderr, "%*c+ invalid_for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, …  in invalid_for_stmt_rule()
21552 …_INDENTATION_ERROR ( "expected an indented block after 'for' statement on line %d" , a -> lineno );  in invalid_for_stmt_rule()
21554                 p->error_indicator = 1;  in invalid_for_stmt_rule()
21555                 p->level--;  in invalid_for_stmt_rule()
21560         p->mark = _mark;  in invalid_for_stmt_rule()
21561         D(fprintf(stderr, "%*c%s invalid_for_stmt[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_for_stmt_rule()
21562 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_targets 'in' star_expressi…  in invalid_for_stmt_rule()
21566     p->level--;  in invalid_for_stmt_rule()
21571 //     | ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT
21573 invalid_def_raw_rule(Parser *p)  in invalid_def_raw_rule()  argument
21575     if (p->level++ == MAXSTACK) {  in invalid_def_raw_rule()
21576         p->error_indicator = 1;  in invalid_def_raw_rule()
21579     if (p->error_indicator) {  in invalid_def_raw_rule()
21580         p->level--;  in invalid_def_raw_rule()
21584     int _mark = p->mark;  in invalid_def_raw_rule()
21585     { // ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT  in invalid_def_raw_rule()
21586         if (p->error_indicator) {  in invalid_def_raw_rule()
21587             p->level--;  in invalid_def_raw_rule()
21590 …tf(stderr, "%*c> invalid_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'def' NAME …  in invalid_def_raw_rule()
21604             (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator)  // ASYNC?  in invalid_def_raw_rule()
21606             (a = _PyPegen_expect_token(p, 526))  // token='def'  in invalid_def_raw_rule()
21608             (name_var = _PyPegen_name_token(p))  // NAME  in invalid_def_raw_rule()
21610             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in invalid_def_raw_rule()
21612             (_opt_var_1 = params_rule(p), !p->error_indicator)  // params?  in invalid_def_raw_rule()
21614             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in invalid_def_raw_rule()
21616             (_opt_var_2 = _tmp_176_rule(p), !p->error_indicator)  // ['->' expression]  in invalid_def_raw_rule()
21618             (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_def_raw_rule()
21620             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_def_raw_rule()
21622             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_def_raw_rule()
21625 …derr, "%*c+ invalid_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'def'…  in invalid_def_raw_rule()
21626 …ENTATION_ERROR ( "expected an indented block after function definition on line %d" , a -> lineno );  in invalid_def_raw_rule()
21628                 p->error_indicator = 1;  in invalid_def_raw_rule()
21629                 p->level--;  in invalid_def_raw_rule()
21634         p->mark = _mark;  in invalid_def_raw_rule()
21635         D(fprintf(stderr, "%*c%s invalid_def_raw[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_def_raw_rule()
21636 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'def' NAME '(' params? ')' ['->' expr…  in invalid_def_raw_rule()
21640     p->level--;  in invalid_def_raw_rule()
21646 invalid_class_def_raw_rule(Parser *p)  in invalid_class_def_raw_rule()  argument
21648     if (p->level++ == MAXSTACK) {  in invalid_class_def_raw_rule()
21649         p->error_indicator = 1;  in invalid_class_def_raw_rule()
21652     if (p->error_indicator) {  in invalid_class_def_raw_rule()
21653         p->level--;  in invalid_class_def_raw_rule()
21657     int _mark = p->mark;  in invalid_class_def_raw_rule()
21659         if (p->error_indicator) {  in invalid_class_def_raw_rule()
21660             p->level--;  in invalid_class_def_raw_rule()
21663 …D(fprintf(stderr, "%*c> invalid_class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'clas…  in invalid_class_def_raw_rule()
21671             (a = _PyPegen_expect_token(p, 527))  // token='class'  in invalid_class_def_raw_rule()
21673             (name_var = _PyPegen_name_token(p))  // NAME  in invalid_class_def_raw_rule()
21675             (_opt_var = _tmp_177_rule(p), !p->error_indicator)  // ['(' arguments? ')']  in invalid_class_def_raw_rule()
21677             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_class_def_raw_rule()
21679             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in invalid_class_def_raw_rule()
21681             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT  in invalid_class_def_raw_rule()
21684 …D(fprintf(stderr, "%*c+ invalid_class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->m…  in invalid_class_def_raw_rule()
21685 …INDENTATION_ERROR ( "expected an indented block after class definition on line %d" , a -> lineno );  in invalid_class_def_raw_rule()
21687                 p->error_indicator = 1;  in invalid_class_def_raw_rule()
21688                 p->level--;  in invalid_class_def_raw_rule()
21693         p->mark = _mark;  in invalid_class_def_raw_rule()
21694         D(fprintf(stderr, "%*c%s invalid_class_def_raw[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_class_def_raw_rule()
21695 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' NEWLIN…  in invalid_class_def_raw_rule()
21699     p->level--;  in invalid_class_def_raw_rule()
21708 invalid_double_starred_kvpairs_rule(Parser *p)  in invalid_double_starred_kvpairs_rule()  argument
21710     if (p->level++ == MAXSTACK) {  in invalid_double_starred_kvpairs_rule()
21711         p->error_indicator = 1;  in invalid_double_starred_kvpairs_rule()
21714     if (p->error_indicator) {  in invalid_double_starred_kvpairs_rule()
21715         p->level--;  in invalid_double_starred_kvpairs_rule()
21719     int _mark = p->mark;  in invalid_double_starred_kvpairs_rule()
21721         if (p->error_indicator) {  in invalid_double_starred_kvpairs_rule()
21722             p->level--;  in invalid_double_starred_kvpairs_rule()
21725 …D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mar…  in invalid_double_starred_kvpairs_rule()
21730             (_gather_178_var = _gather_178_rule(p))  // ','.double_starred_kvpair+  in invalid_double_starred_kvpairs_rule()
21732             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in invalid_double_starred_kvpairs_rule()
21734             (invalid_kvpair_var = invalid_kvpair_rule(p))  // invalid_kvpair  in invalid_double_starred_kvpairs_rule()
21737 …intf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_double_starred_kvpairs_rule()
21738             _res = _PyPegen_dummy_name(p, _gather_178_var, _literal, invalid_kvpair_var);  in invalid_double_starred_kvpairs_rule()
21741         p->mark = _mark;  in invalid_double_starred_kvpairs_rule()
21742 …      D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_double_starred_kvpairs_rule()
21743 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpai…  in invalid_double_starred_kvpairs_rule()
21746         if (p->error_indicator) {  in invalid_double_starred_kvpairs_rule()
21747             p->level--;  in invalid_double_starred_kvpairs_rule()
21750 …D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mar…  in invalid_double_starred_kvpairs_rule()
21756             (expression_var = expression_rule(p))  // expression  in invalid_double_starred_kvpairs_rule()
21758             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_double_starred_kvpairs_rule()
21760             (a = _PyPegen_expect_token(p, 16))  // token='*'  in invalid_double_starred_kvpairs_rule()
21762             (bitwise_or_var = bitwise_or_rule(p))  // bitwise_or  in invalid_double_starred_kvpairs_rule()
21765 …intf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_double_starred_kvpairs_rule()
21768                 p->error_indicator = 1;  in invalid_double_starred_kvpairs_rule()
21769                 p->level--;  in invalid_double_starred_kvpairs_rule()
21774         p->mark = _mark;  in invalid_double_starred_kvpairs_rule()
21775 …      D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_double_starred_kvpairs_rule()
21776 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or"));  in invalid_double_starred_kvpairs_rule()
21779         if (p->error_indicator) {  in invalid_double_starred_kvpairs_rule()
21780             p->level--;  in invalid_double_starred_kvpairs_rule()
21783 …D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mar…  in invalid_double_starred_kvpairs_rule()
21787             (expression_var = expression_rule(p))  // expression  in invalid_double_starred_kvpairs_rule()
21789             (a = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_double_starred_kvpairs_rule()
21791             _PyPegen_lookahead(1, _tmp_180_rule, p)  in invalid_double_starred_kvpairs_rule()
21794 …intf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, …  in invalid_double_starred_kvpairs_rule()
21797                 p->error_indicator = 1;  in invalid_double_starred_kvpairs_rule()
21798                 p->level--;  in invalid_double_starred_kvpairs_rule()
21803         p->mark = _mark;  in invalid_double_starred_kvpairs_rule()
21804 …      D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_double_starred_kvpairs_rule()
21805 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' &('}' | ',')"));  in invalid_double_starred_kvpairs_rule()
21809     p->level--;  in invalid_double_starred_kvpairs_rule()
21815 invalid_kvpair_rule(Parser *p)  in invalid_kvpair_rule()  argument
21817     if (p->level++ == MAXSTACK) {  in invalid_kvpair_rule()
21818         p->error_indicator = 1;  in invalid_kvpair_rule()
21821     if (p->error_indicator) {  in invalid_kvpair_rule()
21822         p->level--;  in invalid_kvpair_rule()
21826     int _mark = p->mark;  in invalid_kvpair_rule()
21828         if (p->error_indicator) {  in invalid_kvpair_rule()
21829             p->level--;  in invalid_kvpair_rule()
21832 …D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !…  in invalid_kvpair_rule()
21835             (a = expression_rule(p))  // expression  in invalid_kvpair_rule()
21837             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 11)  // token=(':')  in invalid_kvpair_rule()
21840 …D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e…  in invalid_kvpair_rule()
21841 …res = RAISE_ERROR_KNOWN_LOCATION ( p , PyExc_SyntaxError , a -> lineno , a -> end_col_offset - 1 ,…  in invalid_kvpair_rule()
21843                 p->error_indicator = 1;  in invalid_kvpair_rule()
21844                 p->level--;  in invalid_kvpair_rule()
21849         p->mark = _mark;  in invalid_kvpair_rule()
21850         D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_kvpair_rule()
21851                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !(':')"));  in invalid_kvpair_rule()
21854         if (p->error_indicator) {  in invalid_kvpair_rule()
21855             p->level--;  in invalid_kvpair_rule()
21858 …D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression '…  in invalid_kvpair_rule()
21864             (expression_var = expression_rule(p))  // expression  in invalid_kvpair_rule()
21866             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_kvpair_rule()
21868             (a = _PyPegen_expect_token(p, 16))  // token='*'  in invalid_kvpair_rule()
21870             (bitwise_or_var = bitwise_or_rule(p))  // bitwise_or  in invalid_kvpair_rule()
21873 …D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e…  in invalid_kvpair_rule()
21876                 p->error_indicator = 1;  in invalid_kvpair_rule()
21877                 p->level--;  in invalid_kvpair_rule()
21882         p->mark = _mark;  in invalid_kvpair_rule()
21883         D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_kvpair_rule()
21884 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or"));  in invalid_kvpair_rule()
21887         if (p->error_indicator) {  in invalid_kvpair_rule()
21888             p->level--;  in invalid_kvpair_rule()
21891 …D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression '…  in invalid_kvpair_rule()
21895             (expression_var = expression_rule(p))  // expression  in invalid_kvpair_rule()
21897             (a = _PyPegen_expect_token(p, 11))  // token=':'  in invalid_kvpair_rule()
21900 …D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "e…  in invalid_kvpair_rule()
21903                 p->error_indicator = 1;  in invalid_kvpair_rule()
21904                 p->level--;  in invalid_kvpair_rule()
21909         p->mark = _mark;  in invalid_kvpair_rule()
21910         D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ',  in invalid_kvpair_rule()
21911                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':'"));  in invalid_kvpair_rule()
21915     p->level--;  in invalid_kvpair_rule()
21921 _loop0_1_rule(Parser *p)  in _loop0_1_rule()  argument
21923     if (p->level++ == MAXSTACK) {  in _loop0_1_rule()
21924         p->error_indicator = 1;  in _loop0_1_rule()
21927     if (p->error_indicator) {  in _loop0_1_rule()
21928         p->level--;  in _loop0_1_rule()
21932     int _mark = p->mark;  in _loop0_1_rule()
21933     int _start_mark = p->mark;  in _loop0_1_rule()
21936         p->error_indicator = 1;  in _loop0_1_rule()
21938         p->level--;  in _loop0_1_rule()
21944         if (p->error_indicator) {  in _loop0_1_rule()
21945             p->level--;  in _loop0_1_rule()
21948         D(fprintf(stderr, "%*c> _loop0_1[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));  in _loop0_1_rule()
21951             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in _loop0_1_rule()
21959                     p->error_indicator = 1;  in _loop0_1_rule()
21961                     p->level--;  in _loop0_1_rule()
21967             _mark = p->mark;  in _loop0_1_rule()
21969         p->mark = _mark;  in _loop0_1_rule()
21970         D(fprintf(stderr, "%*c%s _loop0_1[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_1_rule()
21971                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));  in _loop0_1_rule()
21973     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_1_rule()
21976         p->error_indicator = 1;  in _loop0_1_rule()
21978         p->level--;  in _loop0_1_rule()
21983     _PyPegen_insert_memo(p, _start_mark, _loop0_1_type, _seq);  in _loop0_1_rule()
21984     p->level--;  in _loop0_1_rule()
21990 _loop0_2_rule(Parser *p)  in _loop0_2_rule()  argument
21992     if (p->level++ == MAXSTACK) {  in _loop0_2_rule()
21993         p->error_indicator = 1;  in _loop0_2_rule()
21996     if (p->error_indicator) {  in _loop0_2_rule()
21997         p->level--;  in _loop0_2_rule()
22001     int _mark = p->mark;  in _loop0_2_rule()
22002     int _start_mark = p->mark;  in _loop0_2_rule()
22005         p->error_indicator = 1;  in _loop0_2_rule()
22007         p->level--;  in _loop0_2_rule()
22013         if (p->error_indicator) {  in _loop0_2_rule()
22014             p->level--;  in _loop0_2_rule()
22017         D(fprintf(stderr, "%*c> _loop0_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));  in _loop0_2_rule()
22020             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in _loop0_2_rule()
22028                     p->error_indicator = 1;  in _loop0_2_rule()
22030                     p->level--;  in _loop0_2_rule()
22036             _mark = p->mark;  in _loop0_2_rule()
22038         p->mark = _mark;  in _loop0_2_rule()
22039         D(fprintf(stderr, "%*c%s _loop0_2[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_2_rule()
22040                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));  in _loop0_2_rule()
22042     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_2_rule()
22045         p->error_indicator = 1;  in _loop0_2_rule()
22047         p->level--;  in _loop0_2_rule()
22052     _PyPegen_insert_memo(p, _start_mark, _loop0_2_type, _seq);  in _loop0_2_rule()
22053     p->level--;  in _loop0_2_rule()
22059 _loop0_4_rule(Parser *p)  in _loop0_4_rule()  argument
22061     if (p->level++ == MAXSTACK) {  in _loop0_4_rule()
22062         p->error_indicator = 1;  in _loop0_4_rule()
22065     if (p->error_indicator) {  in _loop0_4_rule()
22066         p->level--;  in _loop0_4_rule()
22070     int _mark = p->mark;  in _loop0_4_rule()
22071     int _start_mark = p->mark;  in _loop0_4_rule()
22074         p->error_indicator = 1;  in _loop0_4_rule()
22076         p->level--;  in _loop0_4_rule()
22082         if (p->error_indicator) {  in _loop0_4_rule()
22083             p->level--;  in _loop0_4_rule()
22086 … D(fprintf(stderr, "%*c> _loop0_4[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));  in _loop0_4_rule()
22090             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_4_rule()
22092             (elem = expression_rule(p))  // expression  in _loop0_4_rule()
22097                 p->error_indicator = 1;  in _loop0_4_rule()
22099                 p->level--;  in _loop0_4_rule()
22106                     p->error_indicator = 1;  in _loop0_4_rule()
22108                     p->level--;  in _loop0_4_rule()
22114             _mark = p->mark;  in _loop0_4_rule()
22116         p->mark = _mark;  in _loop0_4_rule()
22117         D(fprintf(stderr, "%*c%s _loop0_4[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_4_rule()
22118                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));  in _loop0_4_rule()
22120     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_4_rule()
22123         p->error_indicator = 1;  in _loop0_4_rule()
22125         p->level--;  in _loop0_4_rule()
22130     _PyPegen_insert_memo(p, _start_mark, _loop0_4_type, _seq);  in _loop0_4_rule()
22131     p->level--;  in _loop0_4_rule()
22137 _gather_3_rule(Parser *p)  in _gather_3_rule()  argument
22139     if (p->level++ == MAXSTACK) {  in _gather_3_rule()
22140         p->error_indicator = 1;  in _gather_3_rule()
22143     if (p->error_indicator) {  in _gather_3_rule()
22144         p->level--;  in _gather_3_rule()
22148     int _mark = p->mark;  in _gather_3_rule()
22150         if (p->error_indicator) {  in _gather_3_rule()
22151             p->level--;  in _gather_3_rule()
22154 …D(fprintf(stderr, "%*c> _gather_3[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0…  in _gather_3_rule()
22158             (elem = expression_rule(p))  // expression  in _gather_3_rule()
22160             (seq = _loop0_4_rule(p))  // _loop0_4  in _gather_3_rule()
22163 …D(fprintf(stderr, "%*c+ _gather_3[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expres…  in _gather_3_rule()
22164             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_3_rule()
22167         p->mark = _mark;  in _gather_3_rule()
22168         D(fprintf(stderr, "%*c%s _gather_3[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_3_rule()
22169                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_4"));  in _gather_3_rule()
22173     p->level--;  in _gather_3_rule()
22179 _loop0_6_rule(Parser *p)  in _loop0_6_rule()  argument
22181     if (p->level++ == MAXSTACK) {  in _loop0_6_rule()
22182         p->error_indicator = 1;  in _loop0_6_rule()
22185     if (p->error_indicator) {  in _loop0_6_rule()
22186         p->level--;  in _loop0_6_rule()
22190     int _mark = p->mark;  in _loop0_6_rule()
22191     int _start_mark = p->mark;  in _loop0_6_rule()
22194         p->error_indicator = 1;  in _loop0_6_rule()
22196         p->level--;  in _loop0_6_rule()
22202         if (p->error_indicator) {  in _loop0_6_rule()
22203             p->level--;  in _loop0_6_rule()
22206 … D(fprintf(stderr, "%*c> _loop0_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));  in _loop0_6_rule()
22210             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_6_rule()
22212             (elem = expression_rule(p))  // expression  in _loop0_6_rule()
22217                 p->error_indicator = 1;  in _loop0_6_rule()
22219                 p->level--;  in _loop0_6_rule()
22226                     p->error_indicator = 1;  in _loop0_6_rule()
22228                     p->level--;  in _loop0_6_rule()
22234             _mark = p->mark;  in _loop0_6_rule()
22236         p->mark = _mark;  in _loop0_6_rule()
22237         D(fprintf(stderr, "%*c%s _loop0_6[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_6_rule()
22238                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));  in _loop0_6_rule()
22240     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_6_rule()
22243         p->error_indicator = 1;  in _loop0_6_rule()
22245         p->level--;  in _loop0_6_rule()
22250     _PyPegen_insert_memo(p, _start_mark, _loop0_6_type, _seq);  in _loop0_6_rule()
22251     p->level--;  in _loop0_6_rule()
22257 _gather_5_rule(Parser *p)  in _gather_5_rule()  argument
22259     if (p->level++ == MAXSTACK) {  in _gather_5_rule()
22260         p->error_indicator = 1;  in _gather_5_rule()
22263     if (p->error_indicator) {  in _gather_5_rule()
22264         p->level--;  in _gather_5_rule()
22268     int _mark = p->mark;  in _gather_5_rule()
22270         if (p->error_indicator) {  in _gather_5_rule()
22271             p->level--;  in _gather_5_rule()
22274 …D(fprintf(stderr, "%*c> _gather_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0…  in _gather_5_rule()
22278             (elem = expression_rule(p))  // expression  in _gather_5_rule()
22280             (seq = _loop0_6_rule(p))  // _loop0_6  in _gather_5_rule()
22283 …D(fprintf(stderr, "%*c+ _gather_5[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expres…  in _gather_5_rule()
22284             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_5_rule()
22287         p->mark = _mark;  in _gather_5_rule()
22288         D(fprintf(stderr, "%*c%s _gather_5[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_5_rule()
22289                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_6"));  in _gather_5_rule()
22293     p->level--;  in _gather_5_rule()
22299 _loop0_8_rule(Parser *p)  in _loop0_8_rule()  argument
22301     if (p->level++ == MAXSTACK) {  in _loop0_8_rule()
22302         p->error_indicator = 1;  in _loop0_8_rule()
22305     if (p->error_indicator) {  in _loop0_8_rule()
22306         p->level--;  in _loop0_8_rule()
22310     int _mark = p->mark;  in _loop0_8_rule()
22311     int _start_mark = p->mark;  in _loop0_8_rule()
22314         p->error_indicator = 1;  in _loop0_8_rule()
22316         p->level--;  in _loop0_8_rule()
22322         if (p->error_indicator) {  in _loop0_8_rule()
22323             p->level--;  in _loop0_8_rule()
22326 … D(fprintf(stderr, "%*c> _loop0_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));  in _loop0_8_rule()
22330             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_8_rule()
22332             (elem = expression_rule(p))  // expression  in _loop0_8_rule()
22337                 p->error_indicator = 1;  in _loop0_8_rule()
22339                 p->level--;  in _loop0_8_rule()
22346                     p->error_indicator = 1;  in _loop0_8_rule()
22348                     p->level--;  in _loop0_8_rule()
22354             _mark = p->mark;  in _loop0_8_rule()
22356         p->mark = _mark;  in _loop0_8_rule()
22357         D(fprintf(stderr, "%*c%s _loop0_8[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_8_rule()
22358                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));  in _loop0_8_rule()
22360     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_8_rule()
22363         p->error_indicator = 1;  in _loop0_8_rule()
22365         p->level--;  in _loop0_8_rule()
22370     _PyPegen_insert_memo(p, _start_mark, _loop0_8_type, _seq);  in _loop0_8_rule()
22371     p->level--;  in _loop0_8_rule()
22377 _gather_7_rule(Parser *p)  in _gather_7_rule()  argument
22379     if (p->level++ == MAXSTACK) {  in _gather_7_rule()
22380         p->error_indicator = 1;  in _gather_7_rule()
22383     if (p->error_indicator) {  in _gather_7_rule()
22384         p->level--;  in _gather_7_rule()
22388     int _mark = p->mark;  in _gather_7_rule()
22390         if (p->error_indicator) {  in _gather_7_rule()
22391             p->level--;  in _gather_7_rule()
22394 …D(fprintf(stderr, "%*c> _gather_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0…  in _gather_7_rule()
22398             (elem = expression_rule(p))  // expression  in _gather_7_rule()
22400             (seq = _loop0_8_rule(p))  // _loop0_8  in _gather_7_rule()
22403 …D(fprintf(stderr, "%*c+ _gather_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expres…  in _gather_7_rule()
22404             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_7_rule()
22407         p->mark = _mark;  in _gather_7_rule()
22408         D(fprintf(stderr, "%*c%s _gather_7[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_7_rule()
22409                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_8"));  in _gather_7_rule()
22413     p->level--;  in _gather_7_rule()
22419 _loop0_10_rule(Parser *p)  in _loop0_10_rule()  argument
22421     if (p->level++ == MAXSTACK) {  in _loop0_10_rule()
22422         p->error_indicator = 1;  in _loop0_10_rule()
22425     if (p->error_indicator) {  in _loop0_10_rule()
22426         p->level--;  in _loop0_10_rule()
22430     int _mark = p->mark;  in _loop0_10_rule()
22431     int _start_mark = p->mark;  in _loop0_10_rule()
22434         p->error_indicator = 1;  in _loop0_10_rule()
22436         p->level--;  in _loop0_10_rule()
22442         if (p->error_indicator) {  in _loop0_10_rule()
22443             p->level--;  in _loop0_10_rule()
22446 …D(fprintf(stderr, "%*c> _loop0_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));  in _loop0_10_rule()
22450             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_10_rule()
22452             (elem = expression_rule(p))  // expression  in _loop0_10_rule()
22457                 p->error_indicator = 1;  in _loop0_10_rule()
22459                 p->level--;  in _loop0_10_rule()
22466                     p->error_indicator = 1;  in _loop0_10_rule()
22468                     p->level--;  in _loop0_10_rule()
22474             _mark = p->mark;  in _loop0_10_rule()
22476         p->mark = _mark;  in _loop0_10_rule()
22477         D(fprintf(stderr, "%*c%s _loop0_10[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_10_rule()
22478                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));  in _loop0_10_rule()
22480     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_10_rule()
22483         p->error_indicator = 1;  in _loop0_10_rule()
22485         p->level--;  in _loop0_10_rule()
22490     _PyPegen_insert_memo(p, _start_mark, _loop0_10_type, _seq);  in _loop0_10_rule()
22491     p->level--;  in _loop0_10_rule()
22497 _gather_9_rule(Parser *p)  in _gather_9_rule()  argument
22499     if (p->level++ == MAXSTACK) {  in _gather_9_rule()
22500         p->error_indicator = 1;  in _gather_9_rule()
22503     if (p->error_indicator) {  in _gather_9_rule()
22504         p->level--;  in _gather_9_rule()
22508     int _mark = p->mark;  in _gather_9_rule()
22510         if (p->error_indicator) {  in _gather_9_rule()
22511             p->level--;  in _gather_9_rule()
22514 …D(fprintf(stderr, "%*c> _gather_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0…  in _gather_9_rule()
22518             (elem = expression_rule(p))  // expression  in _gather_9_rule()
22520             (seq = _loop0_10_rule(p))  // _loop0_10  in _gather_9_rule()
22523 …D(fprintf(stderr, "%*c+ _gather_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expres…  in _gather_9_rule()
22524             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_9_rule()
22527         p->mark = _mark;  in _gather_9_rule()
22528         D(fprintf(stderr, "%*c%s _gather_9[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_9_rule()
22529                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_10"));  in _gather_9_rule()
22533     p->level--;  in _gather_9_rule()
22539 _loop1_11_rule(Parser *p)  in _loop1_11_rule()  argument
22541     if (p->level++ == MAXSTACK) {  in _loop1_11_rule()
22542         p->error_indicator = 1;  in _loop1_11_rule()
22545     if (p->error_indicator) {  in _loop1_11_rule()
22546         p->level--;  in _loop1_11_rule()
22550     int _mark = p->mark;  in _loop1_11_rule()
22551     int _start_mark = p->mark;  in _loop1_11_rule()
22554         p->error_indicator = 1;  in _loop1_11_rule()
22556         p->level--;  in _loop1_11_rule()
22562         if (p->error_indicator) {  in _loop1_11_rule()
22563             p->level--;  in _loop1_11_rule()
22566 …     D(fprintf(stderr, "%*c> _loop1_11[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement"));  in _loop1_11_rule()
22569             (statement_var = statement_rule(p))  // statement  in _loop1_11_rule()
22577                     p->error_indicator = 1;  in _loop1_11_rule()
22579                     p->level--;  in _loop1_11_rule()
22585             _mark = p->mark;  in _loop1_11_rule()
22587         p->mark = _mark;  in _loop1_11_rule()
22588         D(fprintf(stderr, "%*c%s _loop1_11[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_11_rule()
22589                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement"));  in _loop1_11_rule()
22591     if (_n == 0 || p->error_indicator) {  in _loop1_11_rule()
22593         p->level--;  in _loop1_11_rule()
22596     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_11_rule()
22599         p->error_indicator = 1;  in _loop1_11_rule()
22601         p->level--;  in _loop1_11_rule()
22606     _PyPegen_insert_memo(p, _start_mark, _loop1_11_type, _seq);  in _loop1_11_rule()
22607     p->level--;  in _loop1_11_rule()
22613 _loop0_13_rule(Parser *p)  in _loop0_13_rule()  argument
22615     if (p->level++ == MAXSTACK) {  in _loop0_13_rule()
22616         p->error_indicator = 1;  in _loop0_13_rule()
22619     if (p->error_indicator) {  in _loop0_13_rule()
22620         p->level--;  in _loop0_13_rule()
22624     int _mark = p->mark;  in _loop0_13_rule()
22625     int _start_mark = p->mark;  in _loop0_13_rule()
22628         p->error_indicator = 1;  in _loop0_13_rule()
22630         p->level--;  in _loop0_13_rule()
22636         if (p->error_indicator) {  in _loop0_13_rule()
22637             p->level--;  in _loop0_13_rule()
22640 …D(fprintf(stderr, "%*c> _loop0_13[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';' simple_stmt")…  in _loop0_13_rule()
22644             (_literal = _PyPegen_expect_token(p, 13))  // token=';'  in _loop0_13_rule()
22646             (elem = simple_stmt_rule(p))  // simple_stmt  in _loop0_13_rule()
22651                 p->error_indicator = 1;  in _loop0_13_rule()
22653                 p->level--;  in _loop0_13_rule()
22660                     p->error_indicator = 1;  in _loop0_13_rule()
22662                     p->level--;  in _loop0_13_rule()
22668             _mark = p->mark;  in _loop0_13_rule()
22670         p->mark = _mark;  in _loop0_13_rule()
22671         D(fprintf(stderr, "%*c%s _loop0_13[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_13_rule()
22672                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';' simple_stmt"));  in _loop0_13_rule()
22674     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_13_rule()
22677         p->error_indicator = 1;  in _loop0_13_rule()
22679         p->level--;  in _loop0_13_rule()
22684     _PyPegen_insert_memo(p, _start_mark, _loop0_13_type, _seq);  in _loop0_13_rule()
22685     p->level--;  in _loop0_13_rule()
22691 _gather_12_rule(Parser *p)  in _gather_12_rule()  argument
22693     if (p->level++ == MAXSTACK) {  in _gather_12_rule()
22694         p->error_indicator = 1;  in _gather_12_rule()
22697     if (p->error_indicator) {  in _gather_12_rule()
22698         p->level--;  in _gather_12_rule()
22702     int _mark = p->mark;  in _gather_12_rule()
22704         if (p->error_indicator) {  in _gather_12_rule()
22705             p->level--;  in _gather_12_rule()
22708 …D(fprintf(stderr, "%*c> _gather_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt _loo…  in _gather_12_rule()
22712             (elem = simple_stmt_rule(p))  // simple_stmt  in _gather_12_rule()
22714             (seq = _loop0_13_rule(p))  // _loop0_13  in _gather_12_rule()
22717 …D(fprintf(stderr, "%*c+ _gather_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simpl…  in _gather_12_rule()
22718             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_12_rule()
22721         p->mark = _mark;  in _gather_12_rule()
22722         D(fprintf(stderr, "%*c%s _gather_12[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_12_rule()
22723                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt _loop0_13"));  in _gather_12_rule()
22727     p->level--;  in _gather_12_rule()
22733 _tmp_14_rule(Parser *p)  in _tmp_14_rule()  argument
22735     if (p->level++ == MAXSTACK) {  in _tmp_14_rule()
22736         p->error_indicator = 1;  in _tmp_14_rule()
22739     if (p->error_indicator) {  in _tmp_14_rule()
22740         p->level--;  in _tmp_14_rule()
22744     int _mark = p->mark;  in _tmp_14_rule()
22746         if (p->error_indicator) {  in _tmp_14_rule()
22747             p->level--;  in _tmp_14_rule()
22750         D(fprintf(stderr, "%*c> _tmp_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'"));  in _tmp_14_rule()
22753             (_keyword = _PyPegen_expect_token(p, 513))  // token='import'  in _tmp_14_rule()
22756 …D(fprintf(stderr, "%*c+ _tmp_14[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'…  in _tmp_14_rule()
22760         p->mark = _mark;  in _tmp_14_rule()
22761         D(fprintf(stderr, "%*c%s _tmp_14[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_14_rule()
22762                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import'"));  in _tmp_14_rule()
22765         if (p->error_indicator) {  in _tmp_14_rule()
22766             p->level--;  in _tmp_14_rule()
22769         D(fprintf(stderr, "%*c> _tmp_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'"));  in _tmp_14_rule()
22772             (_keyword = _PyPegen_expect_token(p, 514))  // token='from'  in _tmp_14_rule()
22775 …D(fprintf(stderr, "%*c+ _tmp_14[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'")…  in _tmp_14_rule()
22779         p->mark = _mark;  in _tmp_14_rule()
22780         D(fprintf(stderr, "%*c%s _tmp_14[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_14_rule()
22781                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from'"));  in _tmp_14_rule()
22785     p->level--;  in _tmp_14_rule()
22791 _tmp_15_rule(Parser *p)  in _tmp_15_rule()  argument
22793     if (p->level++ == MAXSTACK) {  in _tmp_15_rule()
22794         p->error_indicator = 1;  in _tmp_15_rule()
22797     if (p->error_indicator) {  in _tmp_15_rule()
22798         p->level--;  in _tmp_15_rule()
22802     int _mark = p->mark;  in _tmp_15_rule()
22804         if (p->error_indicator) {  in _tmp_15_rule()
22805             p->level--;  in _tmp_15_rule()
22808         D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'"));  in _tmp_15_rule()
22811             (_keyword = _PyPegen_expect_token(p, 526))  // token='def'  in _tmp_15_rule()
22814 …D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'"));  in _tmp_15_rule()
22818         p->mark = _mark;  in _tmp_15_rule()
22819         D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_15_rule()
22820                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def'"));  in _tmp_15_rule()
22823         if (p->error_indicator) {  in _tmp_15_rule()
22824             p->level--;  in _tmp_15_rule()
22827         D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));  in _tmp_15_rule()
22830             (_literal = _PyPegen_expect_token(p, 49))  // token='@'  in _tmp_15_rule()
22833 …  D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));  in _tmp_15_rule()
22837         p->mark = _mark;  in _tmp_15_rule()
22838         D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_15_rule()
22839                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));  in _tmp_15_rule()
22842         if (p->error_indicator) {  in _tmp_15_rule()
22843             p->level--;  in _tmp_15_rule()
22846         D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));  in _tmp_15_rule()
22849             (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'  in _tmp_15_rule()
22852 …D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));  in _tmp_15_rule()
22856         p->mark = _mark;  in _tmp_15_rule()
22857         D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_15_rule()
22858                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC"));  in _tmp_15_rule()
22862     p->level--;  in _tmp_15_rule()
22868 _tmp_16_rule(Parser *p)  in _tmp_16_rule()  argument
22870     if (p->level++ == MAXSTACK) {  in _tmp_16_rule()
22871         p->error_indicator = 1;  in _tmp_16_rule()
22874     if (p->error_indicator) {  in _tmp_16_rule()
22875         p->level--;  in _tmp_16_rule()
22879     int _mark = p->mark;  in _tmp_16_rule()
22881         if (p->error_indicator) {  in _tmp_16_rule()
22882             p->level--;  in _tmp_16_rule()
22885         D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'"));  in _tmp_16_rule()
22888             (_keyword = _PyPegen_expect_token(p, 527))  // token='class'  in _tmp_16_rule()
22891 …D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'"…  in _tmp_16_rule()
22895         p->mark = _mark;  in _tmp_16_rule()
22896         D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_16_rule()
22897                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class'"));  in _tmp_16_rule()
22900         if (p->error_indicator) {  in _tmp_16_rule()
22901             p->level--;  in _tmp_16_rule()
22904         D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));  in _tmp_16_rule()
22907             (_literal = _PyPegen_expect_token(p, 49))  // token='@'  in _tmp_16_rule()
22910 …  D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));  in _tmp_16_rule()
22914         p->mark = _mark;  in _tmp_16_rule()
22915         D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_16_rule()
22916                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));  in _tmp_16_rule()
22920     p->level--;  in _tmp_16_rule()
22926 _tmp_17_rule(Parser *p)  in _tmp_17_rule()  argument
22928     if (p->level++ == MAXSTACK) {  in _tmp_17_rule()
22929         p->error_indicator = 1;  in _tmp_17_rule()
22932     if (p->error_indicator) {  in _tmp_17_rule()
22933         p->level--;  in _tmp_17_rule()
22937     int _mark = p->mark;  in _tmp_17_rule()
22939         if (p->error_indicator) {  in _tmp_17_rule()
22940             p->level--;  in _tmp_17_rule()
22943         D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'"));  in _tmp_17_rule()
22946             (_keyword = _PyPegen_expect_token(p, 519))  // token='with'  in _tmp_17_rule()
22949 …D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'")…  in _tmp_17_rule()
22953         p->mark = _mark;  in _tmp_17_rule()
22954         D(fprintf(stderr, "%*c%s _tmp_17[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_17_rule()
22955                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with'"));  in _tmp_17_rule()
22958         if (p->error_indicator) {  in _tmp_17_rule()
22959             p->level--;  in _tmp_17_rule()
22962         D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));  in _tmp_17_rule()
22965             (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'  in _tmp_17_rule()
22968 …D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));  in _tmp_17_rule()
22972         p->mark = _mark;  in _tmp_17_rule()
22973         D(fprintf(stderr, "%*c%s _tmp_17[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_17_rule()
22974                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC"));  in _tmp_17_rule()
22978     p->level--;  in _tmp_17_rule()
22984 _tmp_18_rule(Parser *p)  in _tmp_18_rule()  argument
22986     if (p->level++ == MAXSTACK) {  in _tmp_18_rule()
22987         p->error_indicator = 1;  in _tmp_18_rule()
22990     if (p->error_indicator) {  in _tmp_18_rule()
22991         p->level--;  in _tmp_18_rule()
22995     int _mark = p->mark;  in _tmp_18_rule()
22997         if (p->error_indicator) {  in _tmp_18_rule()
22998             p->level--;  in _tmp_18_rule()
23001         D(fprintf(stderr, "%*c> _tmp_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'"));  in _tmp_18_rule()
23004             (_keyword = _PyPegen_expect_token(p, 517))  // token='for'  in _tmp_18_rule()
23007 …D(fprintf(stderr, "%*c+ _tmp_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'"));  in _tmp_18_rule()
23011         p->mark = _mark;  in _tmp_18_rule()
23012         D(fprintf(stderr, "%*c%s _tmp_18[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_18_rule()
23013                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for'"));  in _tmp_18_rule()
23016         if (p->error_indicator) {  in _tmp_18_rule()
23017             p->level--;  in _tmp_18_rule()
23020         D(fprintf(stderr, "%*c> _tmp_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));  in _tmp_18_rule()
23023             (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'  in _tmp_18_rule()
23026 …D(fprintf(stderr, "%*c+ _tmp_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));  in _tmp_18_rule()
23030         p->mark = _mark;  in _tmp_18_rule()
23031         D(fprintf(stderr, "%*c%s _tmp_18[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_18_rule()
23032                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC"));  in _tmp_18_rule()
23036     p->level--;  in _tmp_18_rule()
23042 _tmp_19_rule(Parser *p)  in _tmp_19_rule()  argument
23044     if (p->level++ == MAXSTACK) {  in _tmp_19_rule()
23045         p->error_indicator = 1;  in _tmp_19_rule()
23048     if (p->error_indicator) {  in _tmp_19_rule()
23049         p->level--;  in _tmp_19_rule()
23053     int _mark = p->mark;  in _tmp_19_rule()
23055         if (p->error_indicator) {  in _tmp_19_rule()
23056             p->level--;  in _tmp_19_rule()
23059 …D(fprintf(stderr, "%*c> _tmp_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")…  in _tmp_19_rule()
23063             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_19_rule()
23065             (d = annotated_rhs_rule(p))  // annotated_rhs  in _tmp_19_rule()
23068 …D(fprintf(stderr, "%*c+ _tmp_19[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' anno…  in _tmp_19_rule()
23071                 p->error_indicator = 1;  in _tmp_19_rule()
23072                 p->level--;  in _tmp_19_rule()
23077         p->mark = _mark;  in _tmp_19_rule()
23078         D(fprintf(stderr, "%*c%s _tmp_19[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_19_rule()
23079                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs"));  in _tmp_19_rule()
23083     p->level--;  in _tmp_19_rule()
23089 _tmp_20_rule(Parser *p)  in _tmp_20_rule()  argument
23091     if (p->level++ == MAXSTACK) {  in _tmp_20_rule()
23092         p->error_indicator = 1;  in _tmp_20_rule()
23095     if (p->error_indicator) {  in _tmp_20_rule()
23096         p->level--;  in _tmp_20_rule()
23100     int _mark = p->mark;  in _tmp_20_rule()
23102         if (p->error_indicator) {  in _tmp_20_rule()
23103             p->level--;  in _tmp_20_rule()
23106 …D(fprintf(stderr, "%*c> _tmp_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target '…  in _tmp_20_rule()
23111             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in _tmp_20_rule()
23113             (b = single_target_rule(p))  // single_target  in _tmp_20_rule()
23115             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in _tmp_20_rule()
23118 …D(fprintf(stderr, "%*c+ _tmp_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' sing…  in _tmp_20_rule()
23121                 p->error_indicator = 1;  in _tmp_20_rule()
23122                 p->level--;  in _tmp_20_rule()
23127         p->mark = _mark;  in _tmp_20_rule()
23128         D(fprintf(stderr, "%*c%s _tmp_20[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_20_rule()
23129                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'"));  in _tmp_20_rule()
23132         if (p->error_indicator) {  in _tmp_20_rule()
23133             p->level--;  in _tmp_20_rule()
23136 …D(fprintf(stderr, "%*c> _tmp_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_at…  in _tmp_20_rule()
23139 …(single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p))  // single_sub…  in _tmp_20_rule()
23142 …D(fprintf(stderr, "%*c+ _tmp_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_s…  in _tmp_20_rule()
23146         p->mark = _mark;  in _tmp_20_rule()
23147         D(fprintf(stderr, "%*c%s _tmp_20[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_20_rule()
23148 …        p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target"));  in _tmp_20_rule()
23152     p->level--;  in _tmp_20_rule()
23158 _tmp_21_rule(Parser *p)  in _tmp_21_rule()  argument
23160     if (p->level++ == MAXSTACK) {  in _tmp_21_rule()
23161         p->error_indicator = 1;  in _tmp_21_rule()
23164     if (p->error_indicator) {  in _tmp_21_rule()
23165         p->level--;  in _tmp_21_rule()
23169     int _mark = p->mark;  in _tmp_21_rule()
23171         if (p->error_indicator) {  in _tmp_21_rule()
23172             p->level--;  in _tmp_21_rule()
23175 …D(fprintf(stderr, "%*c> _tmp_21[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")…  in _tmp_21_rule()
23179             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_21_rule()
23181             (d = annotated_rhs_rule(p))  // annotated_rhs  in _tmp_21_rule()
23184 …D(fprintf(stderr, "%*c+ _tmp_21[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' anno…  in _tmp_21_rule()
23187                 p->error_indicator = 1;  in _tmp_21_rule()
23188                 p->level--;  in _tmp_21_rule()
23193         p->mark = _mark;  in _tmp_21_rule()
23194         D(fprintf(stderr, "%*c%s _tmp_21[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_21_rule()
23195                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs"));  in _tmp_21_rule()
23199     p->level--;  in _tmp_21_rule()
23205 _loop1_22_rule(Parser *p)  in _loop1_22_rule()  argument
23207     if (p->level++ == MAXSTACK) {  in _loop1_22_rule()
23208         p->error_indicator = 1;  in _loop1_22_rule()
23211     if (p->error_indicator) {  in _loop1_22_rule()
23212         p->level--;  in _loop1_22_rule()
23216     int _mark = p->mark;  in _loop1_22_rule()
23217     int _start_mark = p->mark;  in _loop1_22_rule()
23220         p->error_indicator = 1;  in _loop1_22_rule()
23222         p->level--;  in _loop1_22_rule()
23228         if (p->error_indicator) {  in _loop1_22_rule()
23229             p->level--;  in _loop1_22_rule()
23232 …D(fprintf(stderr, "%*c> _loop1_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '='…  in _loop1_22_rule()
23235             (_tmp_181_var = _tmp_181_rule(p))  // star_targets '='  in _loop1_22_rule()
23243                     p->error_indicator = 1;  in _loop1_22_rule()
23245                     p->level--;  in _loop1_22_rule()
23251             _mark = p->mark;  in _loop1_22_rule()
23253         p->mark = _mark;  in _loop1_22_rule()
23254         D(fprintf(stderr, "%*c%s _loop1_22[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_22_rule()
23255                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')"));  in _loop1_22_rule()
23257     if (_n == 0 || p->error_indicator) {  in _loop1_22_rule()
23259         p->level--;  in _loop1_22_rule()
23262     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_22_rule()
23265         p->error_indicator = 1;  in _loop1_22_rule()
23267         p->level--;  in _loop1_22_rule()
23272     _PyPegen_insert_memo(p, _start_mark, _loop1_22_type, _seq);  in _loop1_22_rule()
23273     p->level--;  in _loop1_22_rule()
23279 _tmp_23_rule(Parser *p)  in _tmp_23_rule()  argument
23281     if (p->level++ == MAXSTACK) {  in _tmp_23_rule()
23282         p->error_indicator = 1;  in _tmp_23_rule()
23285     if (p->error_indicator) {  in _tmp_23_rule()
23286         p->level--;  in _tmp_23_rule()
23290     int _mark = p->mark;  in _tmp_23_rule()
23292         if (p->error_indicator) {  in _tmp_23_rule()
23293             p->level--;  in _tmp_23_rule()
23296 …      D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));  in _tmp_23_rule()
23299             (yield_expr_var = yield_expr_rule(p))  // yield_expr  in _tmp_23_rule()
23302 …D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_ex…  in _tmp_23_rule()
23306         p->mark = _mark;  in _tmp_23_rule()
23307         D(fprintf(stderr, "%*c%s _tmp_23[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_23_rule()
23308                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));  in _tmp_23_rule()
23311         if (p->error_indicator) {  in _tmp_23_rule()
23312             p->level--;  in _tmp_23_rule()
23315 …D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));  in _tmp_23_rule()
23318             (star_expressions_var = star_expressions_rule(p))  // star_expressions  in _tmp_23_rule()
23321 …D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_exp…  in _tmp_23_rule()
23325         p->mark = _mark;  in _tmp_23_rule()
23326         D(fprintf(stderr, "%*c%s _tmp_23[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_23_rule()
23327                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));  in _tmp_23_rule()
23331     p->level--;  in _tmp_23_rule()
23337 _tmp_24_rule(Parser *p)  in _tmp_24_rule()  argument
23339     if (p->level++ == MAXSTACK) {  in _tmp_24_rule()
23340         p->error_indicator = 1;  in _tmp_24_rule()
23343     if (p->error_indicator) {  in _tmp_24_rule()
23344         p->level--;  in _tmp_24_rule()
23348     int _mark = p->mark;  in _tmp_24_rule()
23350         if (p->error_indicator) {  in _tmp_24_rule()
23351             p->level--;  in _tmp_24_rule()
23354 …      D(fprintf(stderr, "%*c> _tmp_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));  in _tmp_24_rule()
23357             (yield_expr_var = yield_expr_rule(p))  // yield_expr  in _tmp_24_rule()
23360 …D(fprintf(stderr, "%*c+ _tmp_24[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_ex…  in _tmp_24_rule()
23364         p->mark = _mark;  in _tmp_24_rule()
23365         D(fprintf(stderr, "%*c%s _tmp_24[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_24_rule()
23366                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));  in _tmp_24_rule()
23369         if (p->error_indicator) {  in _tmp_24_rule()
23370             p->level--;  in _tmp_24_rule()
23373 …D(fprintf(stderr, "%*c> _tmp_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));  in _tmp_24_rule()
23376             (star_expressions_var = star_expressions_rule(p))  // star_expressions  in _tmp_24_rule()
23379 …D(fprintf(stderr, "%*c+ _tmp_24[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_exp…  in _tmp_24_rule()
23383         p->mark = _mark;  in _tmp_24_rule()
23384         D(fprintf(stderr, "%*c%s _tmp_24[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_24_rule()
23385                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));  in _tmp_24_rule()
23389     p->level--;  in _tmp_24_rule()
23395 _loop0_26_rule(Parser *p)  in _loop0_26_rule()  argument
23397     if (p->level++ == MAXSTACK) {  in _loop0_26_rule()
23398         p->error_indicator = 1;  in _loop0_26_rule()
23401     if (p->error_indicator) {  in _loop0_26_rule()
23402         p->level--;  in _loop0_26_rule()
23406     int _mark = p->mark;  in _loop0_26_rule()
23407     int _start_mark = p->mark;  in _loop0_26_rule()
23410         p->error_indicator = 1;  in _loop0_26_rule()
23412         p->level--;  in _loop0_26_rule()
23418         if (p->error_indicator) {  in _loop0_26_rule()
23419             p->level--;  in _loop0_26_rule()
23422 …      D(fprintf(stderr, "%*c> _loop0_26[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));  in _loop0_26_rule()
23426             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_26_rule()
23428             (elem = _PyPegen_name_token(p))  // NAME  in _loop0_26_rule()
23433                 p->error_indicator = 1;  in _loop0_26_rule()
23435                 p->level--;  in _loop0_26_rule()
23442                     p->error_indicator = 1;  in _loop0_26_rule()
23444                     p->level--;  in _loop0_26_rule()
23450             _mark = p->mark;  in _loop0_26_rule()
23452         p->mark = _mark;  in _loop0_26_rule()
23453         D(fprintf(stderr, "%*c%s _loop0_26[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_26_rule()
23454                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME"));  in _loop0_26_rule()
23456     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_26_rule()
23459         p->error_indicator = 1;  in _loop0_26_rule()
23461         p->level--;  in _loop0_26_rule()
23466     _PyPegen_insert_memo(p, _start_mark, _loop0_26_type, _seq);  in _loop0_26_rule()
23467     p->level--;  in _loop0_26_rule()
23473 _gather_25_rule(Parser *p)  in _gather_25_rule()  argument
23475     if (p->level++ == MAXSTACK) {  in _gather_25_rule()
23476         p->error_indicator = 1;  in _gather_25_rule()
23479     if (p->error_indicator) {  in _gather_25_rule()
23480         p->level--;  in _gather_25_rule()
23484     int _mark = p->mark;  in _gather_25_rule()
23486         if (p->error_indicator) {  in _gather_25_rule()
23487             p->level--;  in _gather_25_rule()
23490 …D(fprintf(stderr, "%*c> _gather_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_26")…  in _gather_25_rule()
23494             (elem = _PyPegen_name_token(p))  // NAME  in _gather_25_rule()
23496             (seq = _loop0_26_rule(p))  // _loop0_26  in _gather_25_rule()
23499 …D(fprintf(stderr, "%*c+ _gather_25[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME …  in _gather_25_rule()
23500             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_25_rule()
23503         p->mark = _mark;  in _gather_25_rule()
23504         D(fprintf(stderr, "%*c%s _gather_25[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_25_rule()
23505                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_26"));  in _gather_25_rule()
23509     p->level--;  in _gather_25_rule()
23515 _loop0_28_rule(Parser *p)  in _loop0_28_rule()  argument
23517     if (p->level++ == MAXSTACK) {  in _loop0_28_rule()
23518         p->error_indicator = 1;  in _loop0_28_rule()
23521     if (p->error_indicator) {  in _loop0_28_rule()
23522         p->level--;  in _loop0_28_rule()
23526     int _mark = p->mark;  in _loop0_28_rule()
23527     int _start_mark = p->mark;  in _loop0_28_rule()
23530         p->error_indicator = 1;  in _loop0_28_rule()
23532         p->level--;  in _loop0_28_rule()
23538         if (p->error_indicator) {  in _loop0_28_rule()
23539             p->level--;  in _loop0_28_rule()
23542 …      D(fprintf(stderr, "%*c> _loop0_28[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));  in _loop0_28_rule()
23546             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_28_rule()
23548             (elem = _PyPegen_name_token(p))  // NAME  in _loop0_28_rule()
23553                 p->error_indicator = 1;  in _loop0_28_rule()
23555                 p->level--;  in _loop0_28_rule()
23562                     p->error_indicator = 1;  in _loop0_28_rule()
23564                     p->level--;  in _loop0_28_rule()
23570             _mark = p->mark;  in _loop0_28_rule()
23572         p->mark = _mark;  in _loop0_28_rule()
23573         D(fprintf(stderr, "%*c%s _loop0_28[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_28_rule()
23574                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME"));  in _loop0_28_rule()
23576     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_28_rule()
23579         p->error_indicator = 1;  in _loop0_28_rule()
23581         p->level--;  in _loop0_28_rule()
23586     _PyPegen_insert_memo(p, _start_mark, _loop0_28_type, _seq);  in _loop0_28_rule()
23587     p->level--;  in _loop0_28_rule()
23593 _gather_27_rule(Parser *p)  in _gather_27_rule()  argument
23595     if (p->level++ == MAXSTACK) {  in _gather_27_rule()
23596         p->error_indicator = 1;  in _gather_27_rule()
23599     if (p->error_indicator) {  in _gather_27_rule()
23600         p->level--;  in _gather_27_rule()
23604     int _mark = p->mark;  in _gather_27_rule()
23606         if (p->error_indicator) {  in _gather_27_rule()
23607             p->level--;  in _gather_27_rule()
23610 …D(fprintf(stderr, "%*c> _gather_27[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_28")…  in _gather_27_rule()
23614             (elem = _PyPegen_name_token(p))  // NAME  in _gather_27_rule()
23616             (seq = _loop0_28_rule(p))  // _loop0_28  in _gather_27_rule()
23619 …D(fprintf(stderr, "%*c+ _gather_27[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME …  in _gather_27_rule()
23620             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_27_rule()
23623         p->mark = _mark;  in _gather_27_rule()
23624         D(fprintf(stderr, "%*c%s _gather_27[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_27_rule()
23625                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_28"));  in _gather_27_rule()
23629     p->level--;  in _gather_27_rule()
23635 _tmp_29_rule(Parser *p)  in _tmp_29_rule()  argument
23637     if (p->level++ == MAXSTACK) {  in _tmp_29_rule()
23638         p->error_indicator = 1;  in _tmp_29_rule()
23641     if (p->error_indicator) {  in _tmp_29_rule()
23642         p->level--;  in _tmp_29_rule()
23646     int _mark = p->mark;  in _tmp_29_rule()
23648         if (p->error_indicator) {  in _tmp_29_rule()
23649             p->level--;  in _tmp_29_rule()
23652 …  D(fprintf(stderr, "%*c> _tmp_29[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));  in _tmp_29_rule()
23656             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_29_rule()
23658             (z = expression_rule(p))  // expression  in _tmp_29_rule()
23661 …D(fprintf(stderr, "%*c+ _tmp_29[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expr…  in _tmp_29_rule()
23664                 p->error_indicator = 1;  in _tmp_29_rule()
23665                 p->level--;  in _tmp_29_rule()
23670         p->mark = _mark;  in _tmp_29_rule()
23671         D(fprintf(stderr, "%*c%s _tmp_29[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_29_rule()
23672                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));  in _tmp_29_rule()
23676     p->level--;  in _tmp_29_rule()
23682 _tmp_30_rule(Parser *p)  in _tmp_30_rule()  argument
23684     if (p->level++ == MAXSTACK) {  in _tmp_30_rule()
23685         p->error_indicator = 1;  in _tmp_30_rule()
23688     if (p->error_indicator) {  in _tmp_30_rule()
23689         p->level--;  in _tmp_30_rule()
23693     int _mark = p->mark;  in _tmp_30_rule()
23695         if (p->error_indicator) {  in _tmp_30_rule()
23696             p->level--;  in _tmp_30_rule()
23699         D(fprintf(stderr, "%*c> _tmp_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'"));  in _tmp_30_rule()
23702             (_literal = _PyPegen_expect_token(p, 13))  // token=';'  in _tmp_30_rule()
23705 …  D(fprintf(stderr, "%*c+ _tmp_30[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'"));  in _tmp_30_rule()
23709         p->mark = _mark;  in _tmp_30_rule()
23710         D(fprintf(stderr, "%*c%s _tmp_30[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_30_rule()
23711                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'"));  in _tmp_30_rule()
23714         if (p->error_indicator) {  in _tmp_30_rule()
23715             p->level--;  in _tmp_30_rule()
23718         D(fprintf(stderr, "%*c> _tmp_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));  in _tmp_30_rule()
23721             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in _tmp_30_rule()
23724 …D(fprintf(stderr, "%*c+ _tmp_30[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"…  in _tmp_30_rule()
23728         p->mark = _mark;  in _tmp_30_rule()
23729         D(fprintf(stderr, "%*c%s _tmp_30[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_30_rule()
23730                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));  in _tmp_30_rule()
23734     p->level--;  in _tmp_30_rule()
23740 _loop0_31_rule(Parser *p)  in _loop0_31_rule()  argument
23742     if (p->level++ == MAXSTACK) {  in _loop0_31_rule()
23743         p->error_indicator = 1;  in _loop0_31_rule()
23746     if (p->error_indicator) {  in _loop0_31_rule()
23747         p->level--;  in _loop0_31_rule()
23751     int _mark = p->mark;  in _loop0_31_rule()
23752     int _start_mark = p->mark;  in _loop0_31_rule()
23755         p->error_indicator = 1;  in _loop0_31_rule()
23757         p->level--;  in _loop0_31_rule()
23763         if (p->error_indicator) {  in _loop0_31_rule()
23764             p->level--;  in _loop0_31_rule()
23767 … D(fprintf(stderr, "%*c> _loop0_31[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));  in _loop0_31_rule()
23770             (_tmp_182_var = _tmp_182_rule(p))  // '.' | '...'  in _loop0_31_rule()
23778                     p->error_indicator = 1;  in _loop0_31_rule()
23780                     p->level--;  in _loop0_31_rule()
23786             _mark = p->mark;  in _loop0_31_rule()
23788         p->mark = _mark;  in _loop0_31_rule()
23789         D(fprintf(stderr, "%*c%s _loop0_31[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_31_rule()
23790                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')"));  in _loop0_31_rule()
23792     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_31_rule()
23795         p->error_indicator = 1;  in _loop0_31_rule()
23797         p->level--;  in _loop0_31_rule()
23802     _PyPegen_insert_memo(p, _start_mark, _loop0_31_type, _seq);  in _loop0_31_rule()
23803     p->level--;  in _loop0_31_rule()
23809 _loop1_32_rule(Parser *p)  in _loop1_32_rule()  argument
23811     if (p->level++ == MAXSTACK) {  in _loop1_32_rule()
23812         p->error_indicator = 1;  in _loop1_32_rule()
23815     if (p->error_indicator) {  in _loop1_32_rule()
23816         p->level--;  in _loop1_32_rule()
23820     int _mark = p->mark;  in _loop1_32_rule()
23821     int _start_mark = p->mark;  in _loop1_32_rule()
23824         p->error_indicator = 1;  in _loop1_32_rule()
23826         p->level--;  in _loop1_32_rule()
23832         if (p->error_indicator) {  in _loop1_32_rule()
23833             p->level--;  in _loop1_32_rule()
23836 … D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));  in _loop1_32_rule()
23839             (_tmp_183_var = _tmp_183_rule(p))  // '.' | '...'  in _loop1_32_rule()
23847                     p->error_indicator = 1;  in _loop1_32_rule()
23849                     p->level--;  in _loop1_32_rule()
23855             _mark = p->mark;  in _loop1_32_rule()
23857         p->mark = _mark;  in _loop1_32_rule()
23858         D(fprintf(stderr, "%*c%s _loop1_32[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_32_rule()
23859                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')"));  in _loop1_32_rule()
23861     if (_n == 0 || p->error_indicator) {  in _loop1_32_rule()
23863         p->level--;  in _loop1_32_rule()
23866     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_32_rule()
23869         p->error_indicator = 1;  in _loop1_32_rule()
23871         p->level--;  in _loop1_32_rule()
23876     _PyPegen_insert_memo(p, _start_mark, _loop1_32_type, _seq);  in _loop1_32_rule()
23877     p->level--;  in _loop1_32_rule()
23883 _loop0_34_rule(Parser *p)  in _loop0_34_rule()  argument
23885     if (p->level++ == MAXSTACK) {  in _loop0_34_rule()
23886         p->error_indicator = 1;  in _loop0_34_rule()
23889     if (p->error_indicator) {  in _loop0_34_rule()
23890         p->level--;  in _loop0_34_rule()
23894     int _mark = p->mark;  in _loop0_34_rule()
23895     int _start_mark = p->mark;  in _loop0_34_rule()
23898         p->error_indicator = 1;  in _loop0_34_rule()
23900         p->level--;  in _loop0_34_rule()
23906         if (p->error_indicator) {  in _loop0_34_rule()
23907             p->level--;  in _loop0_34_rule()
23910 …D(fprintf(stderr, "%*c> _loop0_34[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' import_from_a…  in _loop0_34_rule()
23914             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_34_rule()
23916             (elem = import_from_as_name_rule(p))  // import_from_as_name  in _loop0_34_rule()
23921                 p->error_indicator = 1;  in _loop0_34_rule()
23923                 p->level--;  in _loop0_34_rule()
23930                     p->error_indicator = 1;  in _loop0_34_rule()
23932                     p->level--;  in _loop0_34_rule()
23938             _mark = p->mark;  in _loop0_34_rule()
23940         p->mark = _mark;  in _loop0_34_rule()
23941         D(fprintf(stderr, "%*c%s _loop0_34[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_34_rule()
23942                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' import_from_as_name"));  in _loop0_34_rule()
23944     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_34_rule()
23947         p->error_indicator = 1;  in _loop0_34_rule()
23949         p->level--;  in _loop0_34_rule()
23954     _PyPegen_insert_memo(p, _start_mark, _loop0_34_type, _seq);  in _loop0_34_rule()
23955     p->level--;  in _loop0_34_rule()
23961 _gather_33_rule(Parser *p)  in _gather_33_rule()  argument
23963     if (p->level++ == MAXSTACK) {  in _gather_33_rule()
23964         p->error_indicator = 1;  in _gather_33_rule()
23967     if (p->error_indicator) {  in _gather_33_rule()
23968         p->level--;  in _gather_33_rule()
23972     int _mark = p->mark;  in _gather_33_rule()
23974         if (p->error_indicator) {  in _gather_33_rule()
23975             p->level--;  in _gather_33_rule()
23978 …D(fprintf(stderr, "%*c> _gather_33[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_n…  in _gather_33_rule()
23982             (elem = import_from_as_name_rule(p))  // import_from_as_name  in _gather_33_rule()
23984             (seq = _loop0_34_rule(p))  // _loop0_34  in _gather_33_rule()
23987 …D(fprintf(stderr, "%*c+ _gather_33[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "impor…  in _gather_33_rule()
23988             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_33_rule()
23991         p->mark = _mark;  in _gather_33_rule()
23992         D(fprintf(stderr, "%*c%s _gather_33[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_33_rule()
23993 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_name _loop0_34"));  in _gather_33_rule()
23997     p->level--;  in _gather_33_rule()
24003 _tmp_35_rule(Parser *p)  in _tmp_35_rule()  argument
24005     if (p->level++ == MAXSTACK) {  in _tmp_35_rule()
24006         p->error_indicator = 1;  in _tmp_35_rule()
24009     if (p->error_indicator) {  in _tmp_35_rule()
24010         p->level--;  in _tmp_35_rule()
24014     int _mark = p->mark;  in _tmp_35_rule()
24016         if (p->error_indicator) {  in _tmp_35_rule()
24017             p->level--;  in _tmp_35_rule()
24020         D(fprintf(stderr, "%*c> _tmp_35[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));  in _tmp_35_rule()
24024             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_35_rule()
24026             (z = _PyPegen_name_token(p))  // NAME  in _tmp_35_rule()
24029 …D(fprintf(stderr, "%*c+ _tmp_35[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAM…  in _tmp_35_rule()
24032                 p->error_indicator = 1;  in _tmp_35_rule()
24033                 p->level--;  in _tmp_35_rule()
24038         p->mark = _mark;  in _tmp_35_rule()
24039         D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_35_rule()
24040                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));  in _tmp_35_rule()
24044     p->level--;  in _tmp_35_rule()
24050 _loop0_37_rule(Parser *p)  in _loop0_37_rule()  argument
24052     if (p->level++ == MAXSTACK) {  in _loop0_37_rule()
24053         p->error_indicator = 1;  in _loop0_37_rule()
24056     if (p->error_indicator) {  in _loop0_37_rule()
24057         p->level--;  in _loop0_37_rule()
24061     int _mark = p->mark;  in _loop0_37_rule()
24062     int _start_mark = p->mark;  in _loop0_37_rule()
24065         p->error_indicator = 1;  in _loop0_37_rule()
24067         p->level--;  in _loop0_37_rule()
24073         if (p->error_indicator) {  in _loop0_37_rule()
24074             p->level--;  in _loop0_37_rule()
24077 …D(fprintf(stderr, "%*c> _loop0_37[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_as_nam…  in _loop0_37_rule()
24081             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_37_rule()
24083             (elem = dotted_as_name_rule(p))  // dotted_as_name  in _loop0_37_rule()
24088                 p->error_indicator = 1;  in _loop0_37_rule()
24090                 p->level--;  in _loop0_37_rule()
24097                     p->error_indicator = 1;  in _loop0_37_rule()
24099                     p->level--;  in _loop0_37_rule()
24105             _mark = p->mark;  in _loop0_37_rule()
24107         p->mark = _mark;  in _loop0_37_rule()
24108         D(fprintf(stderr, "%*c%s _loop0_37[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_37_rule()
24109                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' dotted_as_name"));  in _loop0_37_rule()
24111     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_37_rule()
24114         p->error_indicator = 1;  in _loop0_37_rule()
24116         p->level--;  in _loop0_37_rule()
24121     _PyPegen_insert_memo(p, _start_mark, _loop0_37_type, _seq);  in _loop0_37_rule()
24122     p->level--;  in _loop0_37_rule()
24128 _gather_36_rule(Parser *p)  in _gather_36_rule()  argument
24130     if (p->level++ == MAXSTACK) {  in _gather_36_rule()
24131         p->error_indicator = 1;  in _gather_36_rule()
24134     if (p->error_indicator) {  in _gather_36_rule()
24135         p->level--;  in _gather_36_rule()
24139     int _mark = p->mark;  in _gather_36_rule()
24141         if (p->error_indicator) {  in _gather_36_rule()
24142             p->level--;  in _gather_36_rule()
24145 …D(fprintf(stderr, "%*c> _gather_36[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_as_name _…  in _gather_36_rule()
24149             (elem = dotted_as_name_rule(p))  // dotted_as_name  in _gather_36_rule()
24151             (seq = _loop0_37_rule(p))  // _loop0_37  in _gather_36_rule()
24154 …D(fprintf(stderr, "%*c+ _gather_36[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotte…  in _gather_36_rule()
24155             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_36_rule()
24158         p->mark = _mark;  in _gather_36_rule()
24159         D(fprintf(stderr, "%*c%s _gather_36[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_36_rule()
24160                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_as_name _loop0_37"));  in _gather_36_rule()
24164     p->level--;  in _gather_36_rule()
24170 _tmp_38_rule(Parser *p)  in _tmp_38_rule()  argument
24172     if (p->level++ == MAXSTACK) {  in _tmp_38_rule()
24173         p->error_indicator = 1;  in _tmp_38_rule()
24176     if (p->error_indicator) {  in _tmp_38_rule()
24177         p->level--;  in _tmp_38_rule()
24181     int _mark = p->mark;  in _tmp_38_rule()
24183         if (p->error_indicator) {  in _tmp_38_rule()
24184             p->level--;  in _tmp_38_rule()
24187         D(fprintf(stderr, "%*c> _tmp_38[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));  in _tmp_38_rule()
24191             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_38_rule()
24193             (z = _PyPegen_name_token(p))  // NAME  in _tmp_38_rule()
24196 …D(fprintf(stderr, "%*c+ _tmp_38[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAM…  in _tmp_38_rule()
24199                 p->error_indicator = 1;  in _tmp_38_rule()
24200                 p->level--;  in _tmp_38_rule()
24205         p->mark = _mark;  in _tmp_38_rule()
24206         D(fprintf(stderr, "%*c%s _tmp_38[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_38_rule()
24207                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));  in _tmp_38_rule()
24211     p->level--;  in _tmp_38_rule()
24217 _loop0_40_rule(Parser *p)  in _loop0_40_rule()  argument
24219     if (p->level++ == MAXSTACK) {  in _loop0_40_rule()
24220         p->error_indicator = 1;  in _loop0_40_rule()
24223     if (p->error_indicator) {  in _loop0_40_rule()
24224         p->level--;  in _loop0_40_rule()
24228     int _mark = p->mark;  in _loop0_40_rule()
24229     int _start_mark = p->mark;  in _loop0_40_rule()
24232         p->error_indicator = 1;  in _loop0_40_rule()
24234         p->level--;  in _loop0_40_rule()
24240         if (p->error_indicator) {  in _loop0_40_rule()
24241             p->level--;  in _loop0_40_rule()
24244 … D(fprintf(stderr, "%*c> _loop0_40[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));  in _loop0_40_rule()
24248             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_40_rule()
24250             (elem = with_item_rule(p))  // with_item  in _loop0_40_rule()
24255                 p->error_indicator = 1;  in _loop0_40_rule()
24257                 p->level--;  in _loop0_40_rule()
24264                     p->error_indicator = 1;  in _loop0_40_rule()
24266                     p->level--;  in _loop0_40_rule()
24272             _mark = p->mark;  in _loop0_40_rule()
24274         p->mark = _mark;  in _loop0_40_rule()
24275         D(fprintf(stderr, "%*c%s _loop0_40[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_40_rule()
24276                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));  in _loop0_40_rule()
24278     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_40_rule()
24281         p->error_indicator = 1;  in _loop0_40_rule()
24283         p->level--;  in _loop0_40_rule()
24288     _PyPegen_insert_memo(p, _start_mark, _loop0_40_type, _seq);  in _loop0_40_rule()
24289     p->level--;  in _loop0_40_rule()
24295 _gather_39_rule(Parser *p)  in _gather_39_rule()  argument
24297     if (p->level++ == MAXSTACK) {  in _gather_39_rule()
24298         p->error_indicator = 1;  in _gather_39_rule()
24301     if (p->error_indicator) {  in _gather_39_rule()
24302         p->level--;  in _gather_39_rule()
24306     int _mark = p->mark;  in _gather_39_rule()
24308         if (p->error_indicator) {  in _gather_39_rule()
24309             p->level--;  in _gather_39_rule()
24312 …D(fprintf(stderr, "%*c> _gather_39[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0…  in _gather_39_rule()
24316             (elem = with_item_rule(p))  // with_item  in _gather_39_rule()
24318             (seq = _loop0_40_rule(p))  // _loop0_40  in _gather_39_rule()
24321 …D(fprintf(stderr, "%*c+ _gather_39[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_…  in _gather_39_rule()
24322             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_39_rule()
24325         p->mark = _mark;  in _gather_39_rule()
24326         D(fprintf(stderr, "%*c%s _gather_39[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_39_rule()
24327                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_40"));  in _gather_39_rule()
24331     p->level--;  in _gather_39_rule()
24337 _loop0_42_rule(Parser *p)  in _loop0_42_rule()  argument
24339     if (p->level++ == MAXSTACK) {  in _loop0_42_rule()
24340         p->error_indicator = 1;  in _loop0_42_rule()
24343     if (p->error_indicator) {  in _loop0_42_rule()
24344         p->level--;  in _loop0_42_rule()
24348     int _mark = p->mark;  in _loop0_42_rule()
24349     int _start_mark = p->mark;  in _loop0_42_rule()
24352         p->error_indicator = 1;  in _loop0_42_rule()
24354         p->level--;  in _loop0_42_rule()
24360         if (p->error_indicator) {  in _loop0_42_rule()
24361             p->level--;  in _loop0_42_rule()
24364 … D(fprintf(stderr, "%*c> _loop0_42[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));  in _loop0_42_rule()
24368             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_42_rule()
24370             (elem = with_item_rule(p))  // with_item  in _loop0_42_rule()
24375                 p->error_indicator = 1;  in _loop0_42_rule()
24377                 p->level--;  in _loop0_42_rule()
24384                     p->error_indicator = 1;  in _loop0_42_rule()
24386                     p->level--;  in _loop0_42_rule()
24392             _mark = p->mark;  in _loop0_42_rule()
24394         p->mark = _mark;  in _loop0_42_rule()
24395         D(fprintf(stderr, "%*c%s _loop0_42[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_42_rule()
24396                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));  in _loop0_42_rule()
24398     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_42_rule()
24401         p->error_indicator = 1;  in _loop0_42_rule()
24403         p->level--;  in _loop0_42_rule()
24408     _PyPegen_insert_memo(p, _start_mark, _loop0_42_type, _seq);  in _loop0_42_rule()
24409     p->level--;  in _loop0_42_rule()
24415 _gather_41_rule(Parser *p)  in _gather_41_rule()  argument
24417     if (p->level++ == MAXSTACK) {  in _gather_41_rule()
24418         p->error_indicator = 1;  in _gather_41_rule()
24421     if (p->error_indicator) {  in _gather_41_rule()
24422         p->level--;  in _gather_41_rule()
24426     int _mark = p->mark;  in _gather_41_rule()
24428         if (p->error_indicator) {  in _gather_41_rule()
24429             p->level--;  in _gather_41_rule()
24432 …D(fprintf(stderr, "%*c> _gather_41[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0…  in _gather_41_rule()
24436             (elem = with_item_rule(p))  // with_item  in _gather_41_rule()
24438             (seq = _loop0_42_rule(p))  // _loop0_42  in _gather_41_rule()
24441 …D(fprintf(stderr, "%*c+ _gather_41[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_…  in _gather_41_rule()
24442             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_41_rule()
24445         p->mark = _mark;  in _gather_41_rule()
24446         D(fprintf(stderr, "%*c%s _gather_41[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_41_rule()
24447                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_42"));  in _gather_41_rule()
24451     p->level--;  in _gather_41_rule()
24457 _loop0_44_rule(Parser *p)  in _loop0_44_rule()  argument
24459     if (p->level++ == MAXSTACK) {  in _loop0_44_rule()
24460         p->error_indicator = 1;  in _loop0_44_rule()
24463     if (p->error_indicator) {  in _loop0_44_rule()
24464         p->level--;  in _loop0_44_rule()
24468     int _mark = p->mark;  in _loop0_44_rule()
24469     int _start_mark = p->mark;  in _loop0_44_rule()
24472         p->error_indicator = 1;  in _loop0_44_rule()
24474         p->level--;  in _loop0_44_rule()
24480         if (p->error_indicator) {  in _loop0_44_rule()
24481             p->level--;  in _loop0_44_rule()
24484 … D(fprintf(stderr, "%*c> _loop0_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));  in _loop0_44_rule()
24488             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_44_rule()
24490             (elem = with_item_rule(p))  // with_item  in _loop0_44_rule()
24495                 p->error_indicator = 1;  in _loop0_44_rule()
24497                 p->level--;  in _loop0_44_rule()
24504                     p->error_indicator = 1;  in _loop0_44_rule()
24506                     p->level--;  in _loop0_44_rule()
24512             _mark = p->mark;  in _loop0_44_rule()
24514         p->mark = _mark;  in _loop0_44_rule()
24515         D(fprintf(stderr, "%*c%s _loop0_44[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_44_rule()
24516                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));  in _loop0_44_rule()
24518     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_44_rule()
24521         p->error_indicator = 1;  in _loop0_44_rule()
24523         p->level--;  in _loop0_44_rule()
24528     _PyPegen_insert_memo(p, _start_mark, _loop0_44_type, _seq);  in _loop0_44_rule()
24529     p->level--;  in _loop0_44_rule()
24535 _gather_43_rule(Parser *p)  in _gather_43_rule()  argument
24537     if (p->level++ == MAXSTACK) {  in _gather_43_rule()
24538         p->error_indicator = 1;  in _gather_43_rule()
24541     if (p->error_indicator) {  in _gather_43_rule()
24542         p->level--;  in _gather_43_rule()
24546     int _mark = p->mark;  in _gather_43_rule()
24548         if (p->error_indicator) {  in _gather_43_rule()
24549             p->level--;  in _gather_43_rule()
24552 …D(fprintf(stderr, "%*c> _gather_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0…  in _gather_43_rule()
24556             (elem = with_item_rule(p))  // with_item  in _gather_43_rule()
24558             (seq = _loop0_44_rule(p))  // _loop0_44  in _gather_43_rule()
24561 …D(fprintf(stderr, "%*c+ _gather_43[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_…  in _gather_43_rule()
24562             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_43_rule()
24565         p->mark = _mark;  in _gather_43_rule()
24566         D(fprintf(stderr, "%*c%s _gather_43[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_43_rule()
24567                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_44"));  in _gather_43_rule()
24571     p->level--;  in _gather_43_rule()
24577 _loop0_46_rule(Parser *p)  in _loop0_46_rule()  argument
24579     if (p->level++ == MAXSTACK) {  in _loop0_46_rule()
24580         p->error_indicator = 1;  in _loop0_46_rule()
24583     if (p->error_indicator) {  in _loop0_46_rule()
24584         p->level--;  in _loop0_46_rule()
24588     int _mark = p->mark;  in _loop0_46_rule()
24589     int _start_mark = p->mark;  in _loop0_46_rule()
24592         p->error_indicator = 1;  in _loop0_46_rule()
24594         p->level--;  in _loop0_46_rule()
24600         if (p->error_indicator) {  in _loop0_46_rule()
24601             p->level--;  in _loop0_46_rule()
24604 … D(fprintf(stderr, "%*c> _loop0_46[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));  in _loop0_46_rule()
24608             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_46_rule()
24610             (elem = with_item_rule(p))  // with_item  in _loop0_46_rule()
24615                 p->error_indicator = 1;  in _loop0_46_rule()
24617                 p->level--;  in _loop0_46_rule()
24624                     p->error_indicator = 1;  in _loop0_46_rule()
24626                     p->level--;  in _loop0_46_rule()
24632             _mark = p->mark;  in _loop0_46_rule()
24634         p->mark = _mark;  in _loop0_46_rule()
24635         D(fprintf(stderr, "%*c%s _loop0_46[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_46_rule()
24636                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));  in _loop0_46_rule()
24638     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_46_rule()
24641         p->error_indicator = 1;  in _loop0_46_rule()
24643         p->level--;  in _loop0_46_rule()
24648     _PyPegen_insert_memo(p, _start_mark, _loop0_46_type, _seq);  in _loop0_46_rule()
24649     p->level--;  in _loop0_46_rule()
24655 _gather_45_rule(Parser *p)  in _gather_45_rule()  argument
24657     if (p->level++ == MAXSTACK) {  in _gather_45_rule()
24658         p->error_indicator = 1;  in _gather_45_rule()
24661     if (p->error_indicator) {  in _gather_45_rule()
24662         p->level--;  in _gather_45_rule()
24666     int _mark = p->mark;  in _gather_45_rule()
24668         if (p->error_indicator) {  in _gather_45_rule()
24669             p->level--;  in _gather_45_rule()
24672 …D(fprintf(stderr, "%*c> _gather_45[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0…  in _gather_45_rule()
24676             (elem = with_item_rule(p))  // with_item  in _gather_45_rule()
24678             (seq = _loop0_46_rule(p))  // _loop0_46  in _gather_45_rule()
24681 …D(fprintf(stderr, "%*c+ _gather_45[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_…  in _gather_45_rule()
24682             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_45_rule()
24685         p->mark = _mark;  in _gather_45_rule()
24686         D(fprintf(stderr, "%*c%s _gather_45[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_45_rule()
24687                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_46"));  in _gather_45_rule()
24691     p->level--;  in _gather_45_rule()
24697 _tmp_47_rule(Parser *p)  in _tmp_47_rule()  argument
24699     if (p->level++ == MAXSTACK) {  in _tmp_47_rule()
24700         p->error_indicator = 1;  in _tmp_47_rule()
24703     if (p->error_indicator) {  in _tmp_47_rule()
24704         p->level--;  in _tmp_47_rule()
24708     int _mark = p->mark;  in _tmp_47_rule()
24710         if (p->error_indicator) {  in _tmp_47_rule()
24711             p->level--;  in _tmp_47_rule()
24714         D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));  in _tmp_47_rule()
24717             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_47_rule()
24720 …  D(fprintf(stderr, "%*c+ _tmp_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));  in _tmp_47_rule()
24724         p->mark = _mark;  in _tmp_47_rule()
24725         D(fprintf(stderr, "%*c%s _tmp_47[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_47_rule()
24726                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));  in _tmp_47_rule()
24729         if (p->error_indicator) {  in _tmp_47_rule()
24730             p->level--;  in _tmp_47_rule()
24733         D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));  in _tmp_47_rule()
24736             (_literal = _PyPegen_expect_token(p, 8))  // token=')'  in _tmp_47_rule()
24739 …  D(fprintf(stderr, "%*c+ _tmp_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));  in _tmp_47_rule()
24743         p->mark = _mark;  in _tmp_47_rule()
24744         D(fprintf(stderr, "%*c%s _tmp_47[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_47_rule()
24745                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));  in _tmp_47_rule()
24748         if (p->error_indicator) {  in _tmp_47_rule()
24749             p->level--;  in _tmp_47_rule()
24752         D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_47_rule()
24755             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in _tmp_47_rule()
24758 …  D(fprintf(stderr, "%*c+ _tmp_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_47_rule()
24762         p->mark = _mark;  in _tmp_47_rule()
24763         D(fprintf(stderr, "%*c%s _tmp_47[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_47_rule()
24764                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));  in _tmp_47_rule()
24768     p->level--;  in _tmp_47_rule()
24774 _loop1_48_rule(Parser *p)  in _loop1_48_rule()  argument
24776     if (p->level++ == MAXSTACK) {  in _loop1_48_rule()
24777         p->error_indicator = 1;  in _loop1_48_rule()
24780     if (p->error_indicator) {  in _loop1_48_rule()
24781         p->level--;  in _loop1_48_rule()
24785     int _mark = p->mark;  in _loop1_48_rule()
24786     int _start_mark = p->mark;  in _loop1_48_rule()
24789         p->error_indicator = 1;  in _loop1_48_rule()
24791         p->level--;  in _loop1_48_rule()
24797         if (p->error_indicator) {  in _loop1_48_rule()
24798             p->level--;  in _loop1_48_rule()
24801 …  D(fprintf(stderr, "%*c> _loop1_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block"));  in _loop1_48_rule()
24804             (except_block_var = except_block_rule(p))  // except_block  in _loop1_48_rule()
24812                     p->error_indicator = 1;  in _loop1_48_rule()
24814                     p->level--;  in _loop1_48_rule()
24820             _mark = p->mark;  in _loop1_48_rule()
24822         p->mark = _mark;  in _loop1_48_rule()
24823         D(fprintf(stderr, "%*c%s _loop1_48[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_48_rule()
24824                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block"));  in _loop1_48_rule()
24826     if (_n == 0 || p->error_indicator) {  in _loop1_48_rule()
24828         p->level--;  in _loop1_48_rule()
24831     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_48_rule()
24834         p->error_indicator = 1;  in _loop1_48_rule()
24836         p->level--;  in _loop1_48_rule()
24841     _PyPegen_insert_memo(p, _start_mark, _loop1_48_type, _seq);  in _loop1_48_rule()
24842     p->level--;  in _loop1_48_rule()
24848 _tmp_49_rule(Parser *p)  in _tmp_49_rule()  argument
24850     if (p->level++ == MAXSTACK) {  in _tmp_49_rule()
24851         p->error_indicator = 1;  in _tmp_49_rule()
24854     if (p->error_indicator) {  in _tmp_49_rule()
24855         p->level--;  in _tmp_49_rule()
24859     int _mark = p->mark;  in _tmp_49_rule()
24861         if (p->error_indicator) {  in _tmp_49_rule()
24862             p->level--;  in _tmp_49_rule()
24865         D(fprintf(stderr, "%*c> _tmp_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));  in _tmp_49_rule()
24869             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_49_rule()
24871             (z = _PyPegen_name_token(p))  // NAME  in _tmp_49_rule()
24874 …D(fprintf(stderr, "%*c+ _tmp_49[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAM…  in _tmp_49_rule()
24877                 p->error_indicator = 1;  in _tmp_49_rule()
24878                 p->level--;  in _tmp_49_rule()
24883         p->mark = _mark;  in _tmp_49_rule()
24884         D(fprintf(stderr, "%*c%s _tmp_49[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_49_rule()
24885                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));  in _tmp_49_rule()
24889     p->level--;  in _tmp_49_rule()
24895 _loop1_50_rule(Parser *p)  in _loop1_50_rule()  argument
24897     if (p->level++ == MAXSTACK) {  in _loop1_50_rule()
24898         p->error_indicator = 1;  in _loop1_50_rule()
24901     if (p->error_indicator) {  in _loop1_50_rule()
24902         p->level--;  in _loop1_50_rule()
24906     int _mark = p->mark;  in _loop1_50_rule()
24907     int _start_mark = p->mark;  in _loop1_50_rule()
24910         p->error_indicator = 1;  in _loop1_50_rule()
24912         p->level--;  in _loop1_50_rule()
24918         if (p->error_indicator) {  in _loop1_50_rule()
24919             p->level--;  in _loop1_50_rule()
24922 …    D(fprintf(stderr, "%*c> _loop1_50[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "case_block"));  in _loop1_50_rule()
24925             (case_block_var = case_block_rule(p))  // case_block  in _loop1_50_rule()
24933                     p->error_indicator = 1;  in _loop1_50_rule()
24935                     p->level--;  in _loop1_50_rule()
24941             _mark = p->mark;  in _loop1_50_rule()
24943         p->mark = _mark;  in _loop1_50_rule()
24944         D(fprintf(stderr, "%*c%s _loop1_50[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_50_rule()
24945                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "case_block"));  in _loop1_50_rule()
24947     if (_n == 0 || p->error_indicator) {  in _loop1_50_rule()
24949         p->level--;  in _loop1_50_rule()
24952     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_50_rule()
24955         p->error_indicator = 1;  in _loop1_50_rule()
24957         p->level--;  in _loop1_50_rule()
24962     _PyPegen_insert_memo(p, _start_mark, _loop1_50_type, _seq);  in _loop1_50_rule()
24963     p->level--;  in _loop1_50_rule()
24969 _loop0_52_rule(Parser *p)  in _loop0_52_rule()  argument
24971     if (p->level++ == MAXSTACK) {  in _loop0_52_rule()
24972         p->error_indicator = 1;  in _loop0_52_rule()
24975     if (p->error_indicator) {  in _loop0_52_rule()
24976         p->level--;  in _loop0_52_rule()
24980     int _mark = p->mark;  in _loop0_52_rule()
24981     int _start_mark = p->mark;  in _loop0_52_rule()
24984         p->error_indicator = 1;  in _loop0_52_rule()
24986         p->level--;  in _loop0_52_rule()
24992         if (p->error_indicator) {  in _loop0_52_rule()
24993             p->level--;  in _loop0_52_rule()
24996 …D(fprintf(stderr, "%*c> _loop0_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|' closed_patter…  in _loop0_52_rule()
25000             (_literal = _PyPegen_expect_token(p, 18))  // token='|'  in _loop0_52_rule()
25002             (elem = closed_pattern_rule(p))  // closed_pattern  in _loop0_52_rule()
25007                 p->error_indicator = 1;  in _loop0_52_rule()
25009                 p->level--;  in _loop0_52_rule()
25016                     p->error_indicator = 1;  in _loop0_52_rule()
25018                     p->level--;  in _loop0_52_rule()
25024             _mark = p->mark;  in _loop0_52_rule()
25026         p->mark = _mark;  in _loop0_52_rule()
25027         D(fprintf(stderr, "%*c%s _loop0_52[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_52_rule()
25028                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|' closed_pattern"));  in _loop0_52_rule()
25030     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_52_rule()
25033         p->error_indicator = 1;  in _loop0_52_rule()
25035         p->level--;  in _loop0_52_rule()
25040     _PyPegen_insert_memo(p, _start_mark, _loop0_52_type, _seq);  in _loop0_52_rule()
25041     p->level--;  in _loop0_52_rule()
25047 _gather_51_rule(Parser *p)  in _gather_51_rule()  argument
25049     if (p->level++ == MAXSTACK) {  in _gather_51_rule()
25050         p->error_indicator = 1;  in _gather_51_rule()
25053     if (p->error_indicator) {  in _gather_51_rule()
25054         p->level--;  in _gather_51_rule()
25058     int _mark = p->mark;  in _gather_51_rule()
25060         if (p->error_indicator) {  in _gather_51_rule()
25061             p->level--;  in _gather_51_rule()
25064 …D(fprintf(stderr, "%*c> _gather_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "closed_pattern _…  in _gather_51_rule()
25068             (elem = closed_pattern_rule(p))  // closed_pattern  in _gather_51_rule()
25070             (seq = _loop0_52_rule(p))  // _loop0_52  in _gather_51_rule()
25073 …D(fprintf(stderr, "%*c+ _gather_51[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "close…  in _gather_51_rule()
25074             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_51_rule()
25077         p->mark = _mark;  in _gather_51_rule()
25078         D(fprintf(stderr, "%*c%s _gather_51[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_51_rule()
25079                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "closed_pattern _loop0_52"));  in _gather_51_rule()
25083     p->level--;  in _gather_51_rule()
25087 // _tmp_53: '+' | '-'
25089 _tmp_53_rule(Parser *p)  in _tmp_53_rule()  argument
25091     if (p->level++ == MAXSTACK) {  in _tmp_53_rule()
25092         p->error_indicator = 1;  in _tmp_53_rule()
25095     if (p->error_indicator) {  in _tmp_53_rule()
25096         p->level--;  in _tmp_53_rule()
25100     int _mark = p->mark;  in _tmp_53_rule()
25102         if (p->error_indicator) {  in _tmp_53_rule()
25103             p->level--;  in _tmp_53_rule()
25106         D(fprintf(stderr, "%*c> _tmp_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'"));  in _tmp_53_rule()
25109             (_literal = _PyPegen_expect_token(p, 14))  // token='+'  in _tmp_53_rule()
25112 …  D(fprintf(stderr, "%*c+ _tmp_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'"));  in _tmp_53_rule()
25116         p->mark = _mark;  in _tmp_53_rule()
25117         D(fprintf(stderr, "%*c%s _tmp_53[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_53_rule()
25118                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'"));  in _tmp_53_rule()
25120     { // '-'  in _tmp_53_rule()
25121         if (p->error_indicator) {  in _tmp_53_rule()
25122             p->level--;  in _tmp_53_rule()
25125         D(fprintf(stderr, "%*c> _tmp_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'"));  in _tmp_53_rule()
25128             (_literal = _PyPegen_expect_token(p, 15))  // token='-'  in _tmp_53_rule()
25131 …  D(fprintf(stderr, "%*c+ _tmp_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'"));  in _tmp_53_rule()
25135         p->mark = _mark;  in _tmp_53_rule()
25136         D(fprintf(stderr, "%*c%s _tmp_53[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_53_rule()
25137                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'"));  in _tmp_53_rule()
25141     p->level--;  in _tmp_53_rule()
25145 // _tmp_54: '+' | '-'
25147 _tmp_54_rule(Parser *p)  in _tmp_54_rule()  argument
25149     if (p->level++ == MAXSTACK) {  in _tmp_54_rule()
25150         p->error_indicator = 1;  in _tmp_54_rule()
25153     if (p->error_indicator) {  in _tmp_54_rule()
25154         p->level--;  in _tmp_54_rule()
25158     int _mark = p->mark;  in _tmp_54_rule()
25160         if (p->error_indicator) {  in _tmp_54_rule()
25161             p->level--;  in _tmp_54_rule()
25164         D(fprintf(stderr, "%*c> _tmp_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'"));  in _tmp_54_rule()
25167             (_literal = _PyPegen_expect_token(p, 14))  // token='+'  in _tmp_54_rule()
25170 …  D(fprintf(stderr, "%*c+ _tmp_54[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'"));  in _tmp_54_rule()
25174         p->mark = _mark;  in _tmp_54_rule()
25175         D(fprintf(stderr, "%*c%s _tmp_54[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_54_rule()
25176                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'"));  in _tmp_54_rule()
25178     { // '-'  in _tmp_54_rule()
25179         if (p->error_indicator) {  in _tmp_54_rule()
25180             p->level--;  in _tmp_54_rule()
25183         D(fprintf(stderr, "%*c> _tmp_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'"));  in _tmp_54_rule()
25186             (_literal = _PyPegen_expect_token(p, 15))  // token='-'  in _tmp_54_rule()
25189 …  D(fprintf(stderr, "%*c+ _tmp_54[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'"));  in _tmp_54_rule()
25193         p->mark = _mark;  in _tmp_54_rule()
25194         D(fprintf(stderr, "%*c%s _tmp_54[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_54_rule()
25195                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'"));  in _tmp_54_rule()
25199     p->level--;  in _tmp_54_rule()
25205 _tmp_55_rule(Parser *p)  in _tmp_55_rule()  argument
25207     if (p->level++ == MAXSTACK) {  in _tmp_55_rule()
25208         p->error_indicator = 1;  in _tmp_55_rule()
25211     if (p->error_indicator) {  in _tmp_55_rule()
25212         p->level--;  in _tmp_55_rule()
25216     int _mark = p->mark;  in _tmp_55_rule()
25218         if (p->error_indicator) {  in _tmp_55_rule()
25219             p->level--;  in _tmp_55_rule()
25222         D(fprintf(stderr, "%*c> _tmp_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));  in _tmp_55_rule()
25225             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in _tmp_55_rule()
25228 …  D(fprintf(stderr, "%*c+ _tmp_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));  in _tmp_55_rule()
25232         p->mark = _mark;  in _tmp_55_rule()
25233         D(fprintf(stderr, "%*c%s _tmp_55[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_55_rule()
25234                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));  in _tmp_55_rule()
25237         if (p->error_indicator) {  in _tmp_55_rule()
25238             p->level--;  in _tmp_55_rule()
25241         D(fprintf(stderr, "%*c> _tmp_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));  in _tmp_55_rule()
25244             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in _tmp_55_rule()
25247 …  D(fprintf(stderr, "%*c+ _tmp_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));  in _tmp_55_rule()
25251         p->mark = _mark;  in _tmp_55_rule()
25252         D(fprintf(stderr, "%*c%s _tmp_55[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_55_rule()
25253                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));  in _tmp_55_rule()
25256         if (p->error_indicator) {  in _tmp_55_rule()
25257             p->level--;  in _tmp_55_rule()
25260         D(fprintf(stderr, "%*c> _tmp_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));  in _tmp_55_rule()
25263             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_55_rule()
25266 …  D(fprintf(stderr, "%*c+ _tmp_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));  in _tmp_55_rule()
25270         p->mark = _mark;  in _tmp_55_rule()
25271         D(fprintf(stderr, "%*c%s _tmp_55[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_55_rule()
25272                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));  in _tmp_55_rule()
25276     p->level--;  in _tmp_55_rule()
25282 _tmp_56_rule(Parser *p)  in _tmp_56_rule()  argument
25284     if (p->level++ == MAXSTACK) {  in _tmp_56_rule()
25285         p->error_indicator = 1;  in _tmp_56_rule()
25288     if (p->error_indicator) {  in _tmp_56_rule()
25289         p->level--;  in _tmp_56_rule()
25293     int _mark = p->mark;  in _tmp_56_rule()
25295         if (p->error_indicator) {  in _tmp_56_rule()
25296             p->level--;  in _tmp_56_rule()
25299         D(fprintf(stderr, "%*c> _tmp_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));  in _tmp_56_rule()
25302             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in _tmp_56_rule()
25305 …  D(fprintf(stderr, "%*c+ _tmp_56[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));  in _tmp_56_rule()
25309         p->mark = _mark;  in _tmp_56_rule()
25310         D(fprintf(stderr, "%*c%s _tmp_56[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_56_rule()
25311                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));  in _tmp_56_rule()
25314         if (p->error_indicator) {  in _tmp_56_rule()
25315             p->level--;  in _tmp_56_rule()
25318         D(fprintf(stderr, "%*c> _tmp_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));  in _tmp_56_rule()
25321             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in _tmp_56_rule()
25324 …  D(fprintf(stderr, "%*c+ _tmp_56[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));  in _tmp_56_rule()
25328         p->mark = _mark;  in _tmp_56_rule()
25329         D(fprintf(stderr, "%*c%s _tmp_56[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_56_rule()
25330                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));  in _tmp_56_rule()
25333         if (p->error_indicator) {  in _tmp_56_rule()
25334             p->level--;  in _tmp_56_rule()
25337         D(fprintf(stderr, "%*c> _tmp_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));  in _tmp_56_rule()
25340             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_56_rule()
25343 …  D(fprintf(stderr, "%*c+ _tmp_56[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));  in _tmp_56_rule()
25347         p->mark = _mark;  in _tmp_56_rule()
25348         D(fprintf(stderr, "%*c%s _tmp_56[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_56_rule()
25349                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));  in _tmp_56_rule()
25353     p->level--;  in _tmp_56_rule()
25359 _loop0_58_rule(Parser *p)  in _loop0_58_rule()  argument
25361     if (p->level++ == MAXSTACK) {  in _loop0_58_rule()
25362         p->error_indicator = 1;  in _loop0_58_rule()
25365     if (p->error_indicator) {  in _loop0_58_rule()
25366         p->level--;  in _loop0_58_rule()
25370     int _mark = p->mark;  in _loop0_58_rule()
25371     int _start_mark = p->mark;  in _loop0_58_rule()
25374         p->error_indicator = 1;  in _loop0_58_rule()
25376         p->level--;  in _loop0_58_rule()
25382         if (p->error_indicator) {  in _loop0_58_rule()
25383             p->level--;  in _loop0_58_rule()
25386 …D(fprintf(stderr, "%*c> _loop0_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' maybe_star_pa…  in _loop0_58_rule()
25390             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_58_rule()
25392             (elem = maybe_star_pattern_rule(p))  // maybe_star_pattern  in _loop0_58_rule()
25397                 p->error_indicator = 1;  in _loop0_58_rule()
25399                 p->level--;  in _loop0_58_rule()
25406                     p->error_indicator = 1;  in _loop0_58_rule()
25408                     p->level--;  in _loop0_58_rule()
25414             _mark = p->mark;  in _loop0_58_rule()
25416         p->mark = _mark;  in _loop0_58_rule()
25417         D(fprintf(stderr, "%*c%s _loop0_58[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_58_rule()
25418                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' maybe_star_pattern"));  in _loop0_58_rule()
25420     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_58_rule()
25423         p->error_indicator = 1;  in _loop0_58_rule()
25425         p->level--;  in _loop0_58_rule()
25430     _PyPegen_insert_memo(p, _start_mark, _loop0_58_type, _seq);  in _loop0_58_rule()
25431     p->level--;  in _loop0_58_rule()
25437 _gather_57_rule(Parser *p)  in _gather_57_rule()  argument
25439     if (p->level++ == MAXSTACK) {  in _gather_57_rule()
25440         p->error_indicator = 1;  in _gather_57_rule()
25443     if (p->error_indicator) {  in _gather_57_rule()
25444         p->level--;  in _gather_57_rule()
25448     int _mark = p->mark;  in _gather_57_rule()
25450         if (p->error_indicator) {  in _gather_57_rule()
25451             p->level--;  in _gather_57_rule()
25454 …D(fprintf(stderr, "%*c> _gather_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_patte…  in _gather_57_rule()
25458             (elem = maybe_star_pattern_rule(p))  // maybe_star_pattern  in _gather_57_rule()
25460             (seq = _loop0_58_rule(p))  // _loop0_58  in _gather_57_rule()
25463 …D(fprintf(stderr, "%*c+ _gather_57[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe…  in _gather_57_rule()
25464             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_57_rule()
25467         p->mark = _mark;  in _gather_57_rule()
25468         D(fprintf(stderr, "%*c%s _gather_57[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_57_rule()
25469 …             p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern _loop0_58"));  in _gather_57_rule()
25473     p->level--;  in _gather_57_rule()
25479 _loop0_60_rule(Parser *p)  in _loop0_60_rule()  argument
25481     if (p->level++ == MAXSTACK) {  in _loop0_60_rule()
25482         p->error_indicator = 1;  in _loop0_60_rule()
25485     if (p->error_indicator) {  in _loop0_60_rule()
25486         p->level--;  in _loop0_60_rule()
25490     int _mark = p->mark;  in _loop0_60_rule()
25491     int _start_mark = p->mark;  in _loop0_60_rule()
25494         p->error_indicator = 1;  in _loop0_60_rule()
25496         p->level--;  in _loop0_60_rule()
25502         if (p->error_indicator) {  in _loop0_60_rule()
25503             p->level--;  in _loop0_60_rule()
25506 …D(fprintf(stderr, "%*c> _loop0_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' key_value_pat…  in _loop0_60_rule()
25510             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_60_rule()
25512             (elem = key_value_pattern_rule(p))  // key_value_pattern  in _loop0_60_rule()
25517                 p->error_indicator = 1;  in _loop0_60_rule()
25519                 p->level--;  in _loop0_60_rule()
25526                     p->error_indicator = 1;  in _loop0_60_rule()
25528                     p->level--;  in _loop0_60_rule()
25534             _mark = p->mark;  in _loop0_60_rule()
25536         p->mark = _mark;  in _loop0_60_rule()
25537         D(fprintf(stderr, "%*c%s _loop0_60[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_60_rule()
25538                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' key_value_pattern"));  in _loop0_60_rule()
25540     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_60_rule()
25543         p->error_indicator = 1;  in _loop0_60_rule()
25545         p->level--;  in _loop0_60_rule()
25550     _PyPegen_insert_memo(p, _start_mark, _loop0_60_type, _seq);  in _loop0_60_rule()
25551     p->level--;  in _loop0_60_rule()
25557 _gather_59_rule(Parser *p)  in _gather_59_rule()  argument
25559     if (p->level++ == MAXSTACK) {  in _gather_59_rule()
25560         p->error_indicator = 1;  in _gather_59_rule()
25563     if (p->error_indicator) {  in _gather_59_rule()
25564         p->level--;  in _gather_59_rule()
25568     int _mark = p->mark;  in _gather_59_rule()
25570         if (p->error_indicator) {  in _gather_59_rule()
25571             p->level--;  in _gather_59_rule()
25574 …D(fprintf(stderr, "%*c> _gather_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "key_value_patter…  in _gather_59_rule()
25578             (elem = key_value_pattern_rule(p))  // key_value_pattern  in _gather_59_rule()
25580             (seq = _loop0_60_rule(p))  // _loop0_60  in _gather_59_rule()
25583 …D(fprintf(stderr, "%*c+ _gather_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "key_v…  in _gather_59_rule()
25584             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_59_rule()
25587         p->mark = _mark;  in _gather_59_rule()
25588         D(fprintf(stderr, "%*c%s _gather_59[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_59_rule()
25589 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "key_value_pattern _loop0_60"));  in _gather_59_rule()
25593     p->level--;  in _gather_59_rule()
25599 _tmp_61_rule(Parser *p)  in _tmp_61_rule()  argument
25601     if (p->level++ == MAXSTACK) {  in _tmp_61_rule()
25602         p->error_indicator = 1;  in _tmp_61_rule()
25605     if (p->error_indicator) {  in _tmp_61_rule()
25606         p->level--;  in _tmp_61_rule()
25610     int _mark = p->mark;  in _tmp_61_rule()
25612         if (p->error_indicator) {  in _tmp_61_rule()
25613             p->level--;  in _tmp_61_rule()
25616 …    D(fprintf(stderr, "%*c> _tmp_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_expr"));  in _tmp_61_rule()
25619             (literal_expr_var = literal_expr_rule(p))  // literal_expr  in _tmp_61_rule()
25622 …D(fprintf(stderr, "%*c+ _tmp_61[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_…  in _tmp_61_rule()
25626         p->mark = _mark;  in _tmp_61_rule()
25627         D(fprintf(stderr, "%*c%s _tmp_61[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_61_rule()
25628                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_expr"));  in _tmp_61_rule()
25631         if (p->error_indicator) {  in _tmp_61_rule()
25632             p->level--;  in _tmp_61_rule()
25635         D(fprintf(stderr, "%*c> _tmp_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr"));  in _tmp_61_rule()
25638             (attr_var = attr_rule(p))  // attr  in _tmp_61_rule()
25641 … D(fprintf(stderr, "%*c+ _tmp_61[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr"));  in _tmp_61_rule()
25645         p->mark = _mark;  in _tmp_61_rule()
25646         D(fprintf(stderr, "%*c%s _tmp_61[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_61_rule()
25647                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr"));  in _tmp_61_rule()
25651     p->level--;  in _tmp_61_rule()
25657 _loop0_63_rule(Parser *p)  in _loop0_63_rule()  argument
25659     if (p->level++ == MAXSTACK) {  in _loop0_63_rule()
25660         p->error_indicator = 1;  in _loop0_63_rule()
25663     if (p->error_indicator) {  in _loop0_63_rule()
25664         p->level--;  in _loop0_63_rule()
25668     int _mark = p->mark;  in _loop0_63_rule()
25669     int _start_mark = p->mark;  in _loop0_63_rule()
25672         p->error_indicator = 1;  in _loop0_63_rule()
25674         p->level--;  in _loop0_63_rule()
25680         if (p->error_indicator) {  in _loop0_63_rule()
25681             p->level--;  in _loop0_63_rule()
25684 …   D(fprintf(stderr, "%*c> _loop0_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' pattern"));  in _loop0_63_rule()
25688             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_63_rule()
25690             (elem = pattern_rule(p))  // pattern  in _loop0_63_rule()
25695                 p->error_indicator = 1;  in _loop0_63_rule()
25697                 p->level--;  in _loop0_63_rule()
25704                     p->error_indicator = 1;  in _loop0_63_rule()
25706                     p->level--;  in _loop0_63_rule()
25712             _mark = p->mark;  in _loop0_63_rule()
25714         p->mark = _mark;  in _loop0_63_rule()
25715         D(fprintf(stderr, "%*c%s _loop0_63[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_63_rule()
25716                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' pattern"));  in _loop0_63_rule()
25718     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_63_rule()
25721         p->error_indicator = 1;  in _loop0_63_rule()
25723         p->level--;  in _loop0_63_rule()
25728     _PyPegen_insert_memo(p, _start_mark, _loop0_63_type, _seq);  in _loop0_63_rule()
25729     p->level--;  in _loop0_63_rule()
25735 _gather_62_rule(Parser *p)  in _gather_62_rule()  argument
25737     if (p->level++ == MAXSTACK) {  in _gather_62_rule()
25738         p->error_indicator = 1;  in _gather_62_rule()
25741     if (p->error_indicator) {  in _gather_62_rule()
25742         p->level--;  in _gather_62_rule()
25746     int _mark = p->mark;  in _gather_62_rule()
25748         if (p->error_indicator) {  in _gather_62_rule()
25749             p->level--;  in _gather_62_rule()
25752 …D(fprintf(stderr, "%*c> _gather_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern _loop0_6…  in _gather_62_rule()
25756             (elem = pattern_rule(p))  // pattern  in _gather_62_rule()
25758             (seq = _loop0_63_rule(p))  // _loop0_63  in _gather_62_rule()
25761 …D(fprintf(stderr, "%*c+ _gather_62[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "patte…  in _gather_62_rule()
25762             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_62_rule()
25765         p->mark = _mark;  in _gather_62_rule()
25766         D(fprintf(stderr, "%*c%s _gather_62[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_62_rule()
25767                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern _loop0_63"));  in _gather_62_rule()
25771     p->level--;  in _gather_62_rule()
25777 _loop0_65_rule(Parser *p)  in _loop0_65_rule()  argument
25779     if (p->level++ == MAXSTACK) {  in _loop0_65_rule()
25780         p->error_indicator = 1;  in _loop0_65_rule()
25783     if (p->error_indicator) {  in _loop0_65_rule()
25784         p->level--;  in _loop0_65_rule()
25788     int _mark = p->mark;  in _loop0_65_rule()
25789     int _start_mark = p->mark;  in _loop0_65_rule()
25792         p->error_indicator = 1;  in _loop0_65_rule()
25794         p->level--;  in _loop0_65_rule()
25800         if (p->error_indicator) {  in _loop0_65_rule()
25801             p->level--;  in _loop0_65_rule()
25804 …D(fprintf(stderr, "%*c> _loop0_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' keyword_patte…  in _loop0_65_rule()
25808             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_65_rule()
25810             (elem = keyword_pattern_rule(p))  // keyword_pattern  in _loop0_65_rule()
25815                 p->error_indicator = 1;  in _loop0_65_rule()
25817                 p->level--;  in _loop0_65_rule()
25824                     p->error_indicator = 1;  in _loop0_65_rule()
25826                     p->level--;  in _loop0_65_rule()
25832             _mark = p->mark;  in _loop0_65_rule()
25834         p->mark = _mark;  in _loop0_65_rule()
25835         D(fprintf(stderr, "%*c%s _loop0_65[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_65_rule()
25836                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' keyword_pattern"));  in _loop0_65_rule()
25838     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_65_rule()
25841         p->error_indicator = 1;  in _loop0_65_rule()
25843         p->level--;  in _loop0_65_rule()
25848     _PyPegen_insert_memo(p, _start_mark, _loop0_65_type, _seq);  in _loop0_65_rule()
25849     p->level--;  in _loop0_65_rule()
25855 _gather_64_rule(Parser *p)  in _gather_64_rule()  argument
25857     if (p->level++ == MAXSTACK) {  in _gather_64_rule()
25858         p->error_indicator = 1;  in _gather_64_rule()
25861     if (p->error_indicator) {  in _gather_64_rule()
25862         p->level--;  in _gather_64_rule()
25866     int _mark = p->mark;  in _gather_64_rule()
25868         if (p->error_indicator) {  in _gather_64_rule()
25869             p->level--;  in _gather_64_rule()
25872 …D(fprintf(stderr, "%*c> _gather_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "keyword_pattern …  in _gather_64_rule()
25876             (elem = keyword_pattern_rule(p))  // keyword_pattern  in _gather_64_rule()
25878             (seq = _loop0_65_rule(p))  // _loop0_65  in _gather_64_rule()
25881 …D(fprintf(stderr, "%*c+ _gather_64[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "keywo…  in _gather_64_rule()
25882             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_64_rule()
25885         p->mark = _mark;  in _gather_64_rule()
25886         D(fprintf(stderr, "%*c%s _gather_64[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_64_rule()
25887 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "keyword_pattern _loop0_65"));  in _gather_64_rule()
25891     p->level--;  in _gather_64_rule()
25897 _tmp_66_rule(Parser *p)  in _tmp_66_rule()  argument
25899     if (p->level++ == MAXSTACK) {  in _tmp_66_rule()
25900         p->error_indicator = 1;  in _tmp_66_rule()
25903     if (p->error_indicator) {  in _tmp_66_rule()
25904         p->level--;  in _tmp_66_rule()
25908     int _mark = p->mark;  in _tmp_66_rule()
25910         if (p->error_indicator) {  in _tmp_66_rule()
25911             p->level--;  in _tmp_66_rule()
25914 …D(fprintf(stderr, "%*c> _tmp_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' expression")…  in _tmp_66_rule()
25918             (_keyword = _PyPegen_expect_token(p, 514))  // token='from'  in _tmp_66_rule()
25920             (z = expression_rule(p))  // expression  in _tmp_66_rule()
25923 …D(fprintf(stderr, "%*c+ _tmp_66[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' e…  in _tmp_66_rule()
25926                 p->error_indicator = 1;  in _tmp_66_rule()
25927                 p->level--;  in _tmp_66_rule()
25932         p->mark = _mark;  in _tmp_66_rule()
25933         D(fprintf(stderr, "%*c%s _tmp_66[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_66_rule()
25934                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' expression"));  in _tmp_66_rule()
25938     p->level--;  in _tmp_66_rule()
25942 // _tmp_67: '->' expression
25944 _tmp_67_rule(Parser *p)  in _tmp_67_rule()  argument
25946     if (p->level++ == MAXSTACK) {  in _tmp_67_rule()
25947         p->error_indicator = 1;  in _tmp_67_rule()
25950     if (p->error_indicator) {  in _tmp_67_rule()
25951         p->level--;  in _tmp_67_rule()
25955     int _mark = p->mark;  in _tmp_67_rule()
25956     { // '->' expression  in _tmp_67_rule()
25957         if (p->error_indicator) {  in _tmp_67_rule()
25958             p->level--;  in _tmp_67_rule()
25961 … D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));  in _tmp_67_rule()
25965             (_literal = _PyPegen_expect_token(p, 51))  // token='->'  in _tmp_67_rule()
25967             (z = expression_rule(p))  // expression  in _tmp_67_rule()
25970 …D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' exp…  in _tmp_67_rule()
25973                 p->error_indicator = 1;  in _tmp_67_rule()
25974                 p->level--;  in _tmp_67_rule()
25979         p->mark = _mark;  in _tmp_67_rule()
25980         D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_67_rule()
25981                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression"));  in _tmp_67_rule()
25985     p->level--;  in _tmp_67_rule()
25989 // _tmp_68: '->' expression
25991 _tmp_68_rule(Parser *p)  in _tmp_68_rule()  argument
25993     if (p->level++ == MAXSTACK) {  in _tmp_68_rule()
25994         p->error_indicator = 1;  in _tmp_68_rule()
25997     if (p->error_indicator) {  in _tmp_68_rule()
25998         p->level--;  in _tmp_68_rule()
26002     int _mark = p->mark;  in _tmp_68_rule()
26003     { // '->' expression  in _tmp_68_rule()
26004         if (p->error_indicator) {  in _tmp_68_rule()
26005             p->level--;  in _tmp_68_rule()
26008 … D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));  in _tmp_68_rule()
26012             (_literal = _PyPegen_expect_token(p, 51))  // token='->'  in _tmp_68_rule()
26014             (z = expression_rule(p))  // expression  in _tmp_68_rule()
26017 …D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' exp…  in _tmp_68_rule()
26020                 p->error_indicator = 1;  in _tmp_68_rule()
26021                 p->level--;  in _tmp_68_rule()
26026         p->mark = _mark;  in _tmp_68_rule()
26027         D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_68_rule()
26028                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression"));  in _tmp_68_rule()
26032     p->level--;  in _tmp_68_rule()
26038 _tmp_69_rule(Parser *p)  in _tmp_69_rule()  argument
26040     if (p->level++ == MAXSTACK) {  in _tmp_69_rule()
26041         p->error_indicator = 1;  in _tmp_69_rule()
26044     if (p->error_indicator) {  in _tmp_69_rule()
26045         p->level--;  in _tmp_69_rule()
26049     int _mark = p->mark;  in _tmp_69_rule()
26051         if (p->error_indicator) {  in _tmp_69_rule()
26052             p->level--;  in _tmp_69_rule()
26055 …  D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT"));  in _tmp_69_rule()
26059             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in _tmp_69_rule()
26061             (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT'  in _tmp_69_rule()
26064 …D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE …  in _tmp_69_rule()
26065             _res = _PyPegen_dummy_name(p, newline_var, indent_var);  in _tmp_69_rule()
26068         p->mark = _mark;  in _tmp_69_rule()
26069         D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_69_rule()
26070                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT"));  in _tmp_69_rule()
26074     p->level--;  in _tmp_69_rule()
26080 _loop0_70_rule(Parser *p)  in _loop0_70_rule()  argument
26082     if (p->level++ == MAXSTACK) {  in _loop0_70_rule()
26083         p->error_indicator = 1;  in _loop0_70_rule()
26086     if (p->error_indicator) {  in _loop0_70_rule()
26087         p->level--;  in _loop0_70_rule()
26091     int _mark = p->mark;  in _loop0_70_rule()
26092     int _start_mark = p->mark;  in _loop0_70_rule()
26095         p->error_indicator = 1;  in _loop0_70_rule()
26097         p->level--;  in _loop0_70_rule()
26103         if (p->error_indicator) {  in _loop0_70_rule()
26104             p->level--;  in _loop0_70_rule()
26107 …D(fprintf(stderr, "%*c> _loop0_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"…  in _loop0_70_rule()
26110             (param_no_default_var = param_no_default_rule(p))  // param_no_default  in _loop0_70_rule()
26118                     p->error_indicator = 1;  in _loop0_70_rule()
26120                     p->level--;  in _loop0_70_rule()
26126             _mark = p->mark;  in _loop0_70_rule()
26128         p->mark = _mark;  in _loop0_70_rule()
26129         D(fprintf(stderr, "%*c%s _loop0_70[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_70_rule()
26130                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));  in _loop0_70_rule()
26132     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_70_rule()
26135         p->error_indicator = 1;  in _loop0_70_rule()
26137         p->level--;  in _loop0_70_rule()
26142     _PyPegen_insert_memo(p, _start_mark, _loop0_70_type, _seq);  in _loop0_70_rule()
26143     p->level--;  in _loop0_70_rule()
26149 _loop0_71_rule(Parser *p)  in _loop0_71_rule()  argument
26151     if (p->level++ == MAXSTACK) {  in _loop0_71_rule()
26152         p->error_indicator = 1;  in _loop0_71_rule()
26155     if (p->error_indicator) {  in _loop0_71_rule()
26156         p->level--;  in _loop0_71_rule()
26160     int _mark = p->mark;  in _loop0_71_rule()
26161     int _start_mark = p->mark;  in _loop0_71_rule()
26164         p->error_indicator = 1;  in _loop0_71_rule()
26166         p->level--;  in _loop0_71_rule()
26172         if (p->error_indicator) {  in _loop0_71_rule()
26173             p->level--;  in _loop0_71_rule()
26176 …D(fprintf(stderr, "%*c> _loop0_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul…  in _loop0_71_rule()
26179             (param_with_default_var = param_with_default_rule(p))  // param_with_default  in _loop0_71_rule()
26187                     p->error_indicator = 1;  in _loop0_71_rule()
26189                     p->level--;  in _loop0_71_rule()
26195             _mark = p->mark;  in _loop0_71_rule()
26197         p->mark = _mark;  in _loop0_71_rule()
26198         D(fprintf(stderr, "%*c%s _loop0_71[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_71_rule()
26199                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));  in _loop0_71_rule()
26201     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_71_rule()
26204         p->error_indicator = 1;  in _loop0_71_rule()
26206         p->level--;  in _loop0_71_rule()
26211     _PyPegen_insert_memo(p, _start_mark, _loop0_71_type, _seq);  in _loop0_71_rule()
26212     p->level--;  in _loop0_71_rule()
26218 _loop0_72_rule(Parser *p)  in _loop0_72_rule()  argument
26220     if (p->level++ == MAXSTACK) {  in _loop0_72_rule()
26221         p->error_indicator = 1;  in _loop0_72_rule()
26224     if (p->error_indicator) {  in _loop0_72_rule()
26225         p->level--;  in _loop0_72_rule()
26229     int _mark = p->mark;  in _loop0_72_rule()
26230     int _start_mark = p->mark;  in _loop0_72_rule()
26233         p->error_indicator = 1;  in _loop0_72_rule()
26235         p->level--;  in _loop0_72_rule()
26241         if (p->error_indicator) {  in _loop0_72_rule()
26242             p->level--;  in _loop0_72_rule()
26245 …D(fprintf(stderr, "%*c> _loop0_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul…  in _loop0_72_rule()
26248             (param_with_default_var = param_with_default_rule(p))  // param_with_default  in _loop0_72_rule()
26256                     p->error_indicator = 1;  in _loop0_72_rule()
26258                     p->level--;  in _loop0_72_rule()
26264             _mark = p->mark;  in _loop0_72_rule()
26266         p->mark = _mark;  in _loop0_72_rule()
26267         D(fprintf(stderr, "%*c%s _loop0_72[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_72_rule()
26268                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));  in _loop0_72_rule()
26270     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_72_rule()
26273         p->error_indicator = 1;  in _loop0_72_rule()
26275         p->level--;  in _loop0_72_rule()
26280     _PyPegen_insert_memo(p, _start_mark, _loop0_72_type, _seq);  in _loop0_72_rule()
26281     p->level--;  in _loop0_72_rule()
26287 _loop1_73_rule(Parser *p)  in _loop1_73_rule()  argument
26289     if (p->level++ == MAXSTACK) {  in _loop1_73_rule()
26290         p->error_indicator = 1;  in _loop1_73_rule()
26293     if (p->error_indicator) {  in _loop1_73_rule()
26294         p->level--;  in _loop1_73_rule()
26298     int _mark = p->mark;  in _loop1_73_rule()
26299     int _start_mark = p->mark;  in _loop1_73_rule()
26302         p->error_indicator = 1;  in _loop1_73_rule()
26304         p->level--;  in _loop1_73_rule()
26310         if (p->error_indicator) {  in _loop1_73_rule()
26311             p->level--;  in _loop1_73_rule()
26314 …D(fprintf(stderr, "%*c> _loop1_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"…  in _loop1_73_rule()
26317             (param_no_default_var = param_no_default_rule(p))  // param_no_default  in _loop1_73_rule()
26325                     p->error_indicator = 1;  in _loop1_73_rule()
26327                     p->level--;  in _loop1_73_rule()
26333             _mark = p->mark;  in _loop1_73_rule()
26335         p->mark = _mark;  in _loop1_73_rule()
26336         D(fprintf(stderr, "%*c%s _loop1_73[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_73_rule()
26337                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));  in _loop1_73_rule()
26339     if (_n == 0 || p->error_indicator) {  in _loop1_73_rule()
26341         p->level--;  in _loop1_73_rule()
26344     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_73_rule()
26347         p->error_indicator = 1;  in _loop1_73_rule()
26349         p->level--;  in _loop1_73_rule()
26354     _PyPegen_insert_memo(p, _start_mark, _loop1_73_type, _seq);  in _loop1_73_rule()
26355     p->level--;  in _loop1_73_rule()
26361 _loop0_74_rule(Parser *p)  in _loop0_74_rule()  argument
26363     if (p->level++ == MAXSTACK) {  in _loop0_74_rule()
26364         p->error_indicator = 1;  in _loop0_74_rule()
26367     if (p->error_indicator) {  in _loop0_74_rule()
26368         p->level--;  in _loop0_74_rule()
26372     int _mark = p->mark;  in _loop0_74_rule()
26373     int _start_mark = p->mark;  in _loop0_74_rule()
26376         p->error_indicator = 1;  in _loop0_74_rule()
26378         p->level--;  in _loop0_74_rule()
26384         if (p->error_indicator) {  in _loop0_74_rule()
26385             p->level--;  in _loop0_74_rule()
26388 …D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul…  in _loop0_74_rule()
26391             (param_with_default_var = param_with_default_rule(p))  // param_with_default  in _loop0_74_rule()
26399                     p->error_indicator = 1;  in _loop0_74_rule()
26401                     p->level--;  in _loop0_74_rule()
26407             _mark = p->mark;  in _loop0_74_rule()
26409         p->mark = _mark;  in _loop0_74_rule()
26410         D(fprintf(stderr, "%*c%s _loop0_74[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_74_rule()
26411                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));  in _loop0_74_rule()
26413     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_74_rule()
26416         p->error_indicator = 1;  in _loop0_74_rule()
26418         p->level--;  in _loop0_74_rule()
26423     _PyPegen_insert_memo(p, _start_mark, _loop0_74_type, _seq);  in _loop0_74_rule()
26424     p->level--;  in _loop0_74_rule()
26430 _loop1_75_rule(Parser *p)  in _loop1_75_rule()  argument
26432     if (p->level++ == MAXSTACK) {  in _loop1_75_rule()
26433         p->error_indicator = 1;  in _loop1_75_rule()
26436     if (p->error_indicator) {  in _loop1_75_rule()
26437         p->level--;  in _loop1_75_rule()
26441     int _mark = p->mark;  in _loop1_75_rule()
26442     int _start_mark = p->mark;  in _loop1_75_rule()
26445         p->error_indicator = 1;  in _loop1_75_rule()
26447         p->level--;  in _loop1_75_rule()
26453         if (p->error_indicator) {  in _loop1_75_rule()
26454             p->level--;  in _loop1_75_rule()
26457 …D(fprintf(stderr, "%*c> _loop1_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul…  in _loop1_75_rule()
26460             (param_with_default_var = param_with_default_rule(p))  // param_with_default  in _loop1_75_rule()
26468                     p->error_indicator = 1;  in _loop1_75_rule()
26470                     p->level--;  in _loop1_75_rule()
26476             _mark = p->mark;  in _loop1_75_rule()
26478         p->mark = _mark;  in _loop1_75_rule()
26479         D(fprintf(stderr, "%*c%s _loop1_75[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_75_rule()
26480                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));  in _loop1_75_rule()
26482     if (_n == 0 || p->error_indicator) {  in _loop1_75_rule()
26484         p->level--;  in _loop1_75_rule()
26487     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_75_rule()
26490         p->error_indicator = 1;  in _loop1_75_rule()
26492         p->level--;  in _loop1_75_rule()
26497     _PyPegen_insert_memo(p, _start_mark, _loop1_75_type, _seq);  in _loop1_75_rule()
26498     p->level--;  in _loop1_75_rule()
26504 _loop1_76_rule(Parser *p)  in _loop1_76_rule()  argument
26506     if (p->level++ == MAXSTACK) {  in _loop1_76_rule()
26507         p->error_indicator = 1;  in _loop1_76_rule()
26510     if (p->error_indicator) {  in _loop1_76_rule()
26511         p->level--;  in _loop1_76_rule()
26515     int _mark = p->mark;  in _loop1_76_rule()
26516     int _start_mark = p->mark;  in _loop1_76_rule()
26519         p->error_indicator = 1;  in _loop1_76_rule()
26521         p->level--;  in _loop1_76_rule()
26527         if (p->error_indicator) {  in _loop1_76_rule()
26528             p->level--;  in _loop1_76_rule()
26531 …D(fprintf(stderr, "%*c> _loop1_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"…  in _loop1_76_rule()
26534             (param_no_default_var = param_no_default_rule(p))  // param_no_default  in _loop1_76_rule()
26542                     p->error_indicator = 1;  in _loop1_76_rule()
26544                     p->level--;  in _loop1_76_rule()
26550             _mark = p->mark;  in _loop1_76_rule()
26552         p->mark = _mark;  in _loop1_76_rule()
26553         D(fprintf(stderr, "%*c%s _loop1_76[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_76_rule()
26554                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));  in _loop1_76_rule()
26556     if (_n == 0 || p->error_indicator) {  in _loop1_76_rule()
26558         p->level--;  in _loop1_76_rule()
26561     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_76_rule()
26564         p->error_indicator = 1;  in _loop1_76_rule()
26566         p->level--;  in _loop1_76_rule()
26571     _PyPegen_insert_memo(p, _start_mark, _loop1_76_type, _seq);  in _loop1_76_rule()
26572     p->level--;  in _loop1_76_rule()
26578 _loop1_77_rule(Parser *p)  in _loop1_77_rule()  argument
26580     if (p->level++ == MAXSTACK) {  in _loop1_77_rule()
26581         p->error_indicator = 1;  in _loop1_77_rule()
26584     if (p->error_indicator) {  in _loop1_77_rule()
26585         p->level--;  in _loop1_77_rule()
26589     int _mark = p->mark;  in _loop1_77_rule()
26590     int _start_mark = p->mark;  in _loop1_77_rule()
26593         p->error_indicator = 1;  in _loop1_77_rule()
26595         p->level--;  in _loop1_77_rule()
26601         if (p->error_indicator) {  in _loop1_77_rule()
26602             p->level--;  in _loop1_77_rule()
26605 …D(fprintf(stderr, "%*c> _loop1_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"…  in _loop1_77_rule()
26608             (param_no_default_var = param_no_default_rule(p))  // param_no_default  in _loop1_77_rule()
26616                     p->error_indicator = 1;  in _loop1_77_rule()
26618                     p->level--;  in _loop1_77_rule()
26624             _mark = p->mark;  in _loop1_77_rule()
26626         p->mark = _mark;  in _loop1_77_rule()
26627         D(fprintf(stderr, "%*c%s _loop1_77[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_77_rule()
26628                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));  in _loop1_77_rule()
26630     if (_n == 0 || p->error_indicator) {  in _loop1_77_rule()
26632         p->level--;  in _loop1_77_rule()
26635     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_77_rule()
26638         p->error_indicator = 1;  in _loop1_77_rule()
26640         p->level--;  in _loop1_77_rule()
26645     _PyPegen_insert_memo(p, _start_mark, _loop1_77_type, _seq);  in _loop1_77_rule()
26646     p->level--;  in _loop1_77_rule()
26652 _loop0_78_rule(Parser *p)  in _loop0_78_rule()  argument
26654     if (p->level++ == MAXSTACK) {  in _loop0_78_rule()
26655         p->error_indicator = 1;  in _loop0_78_rule()
26658     if (p->error_indicator) {  in _loop0_78_rule()
26659         p->level--;  in _loop0_78_rule()
26663     int _mark = p->mark;  in _loop0_78_rule()
26664     int _start_mark = p->mark;  in _loop0_78_rule()
26667         p->error_indicator = 1;  in _loop0_78_rule()
26669         p->level--;  in _loop0_78_rule()
26675         if (p->error_indicator) {  in _loop0_78_rule()
26676             p->level--;  in _loop0_78_rule()
26679 …D(fprintf(stderr, "%*c> _loop0_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"…  in _loop0_78_rule()
26682             (param_no_default_var = param_no_default_rule(p))  // param_no_default  in _loop0_78_rule()
26690                     p->error_indicator = 1;  in _loop0_78_rule()
26692                     p->level--;  in _loop0_78_rule()
26698             _mark = p->mark;  in _loop0_78_rule()
26700         p->mark = _mark;  in _loop0_78_rule()
26701         D(fprintf(stderr, "%*c%s _loop0_78[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_78_rule()
26702                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));  in _loop0_78_rule()
26704     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_78_rule()
26707         p->error_indicator = 1;  in _loop0_78_rule()
26709         p->level--;  in _loop0_78_rule()
26714     _PyPegen_insert_memo(p, _start_mark, _loop0_78_type, _seq);  in _loop0_78_rule()
26715     p->level--;  in _loop0_78_rule()
26721 _loop1_79_rule(Parser *p)  in _loop1_79_rule()  argument
26723     if (p->level++ == MAXSTACK) {  in _loop1_79_rule()
26724         p->error_indicator = 1;  in _loop1_79_rule()
26727     if (p->error_indicator) {  in _loop1_79_rule()
26728         p->level--;  in _loop1_79_rule()
26732     int _mark = p->mark;  in _loop1_79_rule()
26733     int _start_mark = p->mark;  in _loop1_79_rule()
26736         p->error_indicator = 1;  in _loop1_79_rule()
26738         p->level--;  in _loop1_79_rule()
26744         if (p->error_indicator) {  in _loop1_79_rule()
26745             p->level--;  in _loop1_79_rule()
26748 …D(fprintf(stderr, "%*c> _loop1_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul…  in _loop1_79_rule()
26751             (param_with_default_var = param_with_default_rule(p))  // param_with_default  in _loop1_79_rule()
26759                     p->error_indicator = 1;  in _loop1_79_rule()
26761                     p->level--;  in _loop1_79_rule()
26767             _mark = p->mark;  in _loop1_79_rule()
26769         p->mark = _mark;  in _loop1_79_rule()
26770         D(fprintf(stderr, "%*c%s _loop1_79[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_79_rule()
26771                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));  in _loop1_79_rule()
26773     if (_n == 0 || p->error_indicator) {  in _loop1_79_rule()
26775         p->level--;  in _loop1_79_rule()
26778     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_79_rule()
26781         p->error_indicator = 1;  in _loop1_79_rule()
26783         p->level--;  in _loop1_79_rule()
26788     _PyPegen_insert_memo(p, _start_mark, _loop1_79_type, _seq);  in _loop1_79_rule()
26789     p->level--;  in _loop1_79_rule()
26795 _loop0_80_rule(Parser *p)  in _loop0_80_rule()  argument
26797     if (p->level++ == MAXSTACK) {  in _loop0_80_rule()
26798         p->error_indicator = 1;  in _loop0_80_rule()
26801     if (p->error_indicator) {  in _loop0_80_rule()
26802         p->level--;  in _loop0_80_rule()
26806     int _mark = p->mark;  in _loop0_80_rule()
26807     int _start_mark = p->mark;  in _loop0_80_rule()
26810         p->error_indicator = 1;  in _loop0_80_rule()
26812         p->level--;  in _loop0_80_rule()
26818         if (p->error_indicator) {  in _loop0_80_rule()
26819             p->level--;  in _loop0_80_rule()
26822 …D(fprintf(stderr, "%*c> _loop0_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"…  in _loop0_80_rule()
26825             (param_no_default_var = param_no_default_rule(p))  // param_no_default  in _loop0_80_rule()
26833                     p->error_indicator = 1;  in _loop0_80_rule()
26835                     p->level--;  in _loop0_80_rule()
26841             _mark = p->mark;  in _loop0_80_rule()
26843         p->mark = _mark;  in _loop0_80_rule()
26844         D(fprintf(stderr, "%*c%s _loop0_80[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_80_rule()
26845                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));  in _loop0_80_rule()
26847     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_80_rule()
26850         p->error_indicator = 1;  in _loop0_80_rule()
26852         p->level--;  in _loop0_80_rule()
26857     _PyPegen_insert_memo(p, _start_mark, _loop0_80_type, _seq);  in _loop0_80_rule()
26858     p->level--;  in _loop0_80_rule()
26864 _loop1_81_rule(Parser *p)  in _loop1_81_rule()  argument
26866     if (p->level++ == MAXSTACK) {  in _loop1_81_rule()
26867         p->error_indicator = 1;  in _loop1_81_rule()
26870     if (p->error_indicator) {  in _loop1_81_rule()
26871         p->level--;  in _loop1_81_rule()
26875     int _mark = p->mark;  in _loop1_81_rule()
26876     int _start_mark = p->mark;  in _loop1_81_rule()
26879         p->error_indicator = 1;  in _loop1_81_rule()
26881         p->level--;  in _loop1_81_rule()
26887         if (p->error_indicator) {  in _loop1_81_rule()
26888             p->level--;  in _loop1_81_rule()
26891 …D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defaul…  in _loop1_81_rule()
26894             (param_with_default_var = param_with_default_rule(p))  // param_with_default  in _loop1_81_rule()
26902                     p->error_indicator = 1;  in _loop1_81_rule()
26904                     p->level--;  in _loop1_81_rule()
26910             _mark = p->mark;  in _loop1_81_rule()
26912         p->mark = _mark;  in _loop1_81_rule()
26913         D(fprintf(stderr, "%*c%s _loop1_81[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_81_rule()
26914                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));  in _loop1_81_rule()
26916     if (_n == 0 || p->error_indicator) {  in _loop1_81_rule()
26918         p->level--;  in _loop1_81_rule()
26921     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_81_rule()
26924         p->error_indicator = 1;  in _loop1_81_rule()
26926         p->level--;  in _loop1_81_rule()
26931     _PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq);  in _loop1_81_rule()
26932     p->level--;  in _loop1_81_rule()
26938 _loop0_82_rule(Parser *p)  in _loop0_82_rule()  argument
26940     if (p->level++ == MAXSTACK) {  in _loop0_82_rule()
26941         p->error_indicator = 1;  in _loop0_82_rule()
26944     if (p->error_indicator) {  in _loop0_82_rule()
26945         p->level--;  in _loop0_82_rule()
26949     int _mark = p->mark;  in _loop0_82_rule()
26950     int _start_mark = p->mark;  in _loop0_82_rule()
26953         p->error_indicator = 1;  in _loop0_82_rule()
26955         p->level--;  in _loop0_82_rule()
26961         if (p->error_indicator) {  in _loop0_82_rule()
26962             p->level--;  in _loop0_82_rule()
26965 …D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defau…  in _loop0_82_rule()
26968             (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default  in _loop0_82_rule()
26976                     p->error_indicator = 1;  in _loop0_82_rule()
26978                     p->level--;  in _loop0_82_rule()
26984             _mark = p->mark;  in _loop0_82_rule()
26986         p->mark = _mark;  in _loop0_82_rule()
26987         D(fprintf(stderr, "%*c%s _loop0_82[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_82_rule()
26988                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));  in _loop0_82_rule()
26990     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_82_rule()
26993         p->error_indicator = 1;  in _loop0_82_rule()
26995         p->level--;  in _loop0_82_rule()
27000     _PyPegen_insert_memo(p, _start_mark, _loop0_82_type, _seq);  in _loop0_82_rule()
27001     p->level--;  in _loop0_82_rule()
27007 _loop1_83_rule(Parser *p)  in _loop1_83_rule()  argument
27009     if (p->level++ == MAXSTACK) {  in _loop1_83_rule()
27010         p->error_indicator = 1;  in _loop1_83_rule()
27013     if (p->error_indicator) {  in _loop1_83_rule()
27014         p->level--;  in _loop1_83_rule()
27018     int _mark = p->mark;  in _loop1_83_rule()
27019     int _start_mark = p->mark;  in _loop1_83_rule()
27022         p->error_indicator = 1;  in _loop1_83_rule()
27024         p->level--;  in _loop1_83_rule()
27030         if (p->error_indicator) {  in _loop1_83_rule()
27031             p->level--;  in _loop1_83_rule()
27034 …D(fprintf(stderr, "%*c> _loop1_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_defau…  in _loop1_83_rule()
27037             (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default  in _loop1_83_rule()
27045                     p->error_indicator = 1;  in _loop1_83_rule()
27047                     p->level--;  in _loop1_83_rule()
27053             _mark = p->mark;  in _loop1_83_rule()
27055         p->mark = _mark;  in _loop1_83_rule()
27056         D(fprintf(stderr, "%*c%s _loop1_83[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_83_rule()
27057                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));  in _loop1_83_rule()
27059     if (_n == 0 || p->error_indicator) {  in _loop1_83_rule()
27061         p->level--;  in _loop1_83_rule()
27064     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_83_rule()
27067         p->error_indicator = 1;  in _loop1_83_rule()
27069         p->level--;  in _loop1_83_rule()
27074     _PyPegen_insert_memo(p, _start_mark, _loop1_83_type, _seq);  in _loop1_83_rule()
27075     p->level--;  in _loop1_83_rule()
27081 _loop1_84_rule(Parser *p)  in _loop1_84_rule()  argument
27083     if (p->level++ == MAXSTACK) {  in _loop1_84_rule()
27084         p->error_indicator = 1;  in _loop1_84_rule()
27087     if (p->error_indicator) {  in _loop1_84_rule()
27088         p->level--;  in _loop1_84_rule()
27092     int _mark = p->mark;  in _loop1_84_rule()
27093     int _start_mark = p->mark;  in _loop1_84_rule()
27096         p->error_indicator = 1;  in _loop1_84_rule()
27098         p->level--;  in _loop1_84_rule()
27104         if (p->error_indicator) {  in _loop1_84_rule()
27105             p->level--;  in _loop1_84_rule()
27108 …D(fprintf(stderr, "%*c> _loop1_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expres…  in _loop1_84_rule()
27111             (_tmp_184_var = _tmp_184_rule(p))  // '@' named_expression NEWLINE  in _loop1_84_rule()
27119                     p->error_indicator = 1;  in _loop1_84_rule()
27121                     p->level--;  in _loop1_84_rule()
27127             _mark = p->mark;  in _loop1_84_rule()
27129         p->mark = _mark;  in _loop1_84_rule()
27130         D(fprintf(stderr, "%*c%s _loop1_84[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_84_rule()
27131 …           p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('@' named_expression NEWLINE)"));  in _loop1_84_rule()
27133     if (_n == 0 || p->error_indicator) {  in _loop1_84_rule()
27135         p->level--;  in _loop1_84_rule()
27138     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_84_rule()
27141         p->error_indicator = 1;  in _loop1_84_rule()
27143         p->level--;  in _loop1_84_rule()
27148     _PyPegen_insert_memo(p, _start_mark, _loop1_84_type, _seq);  in _loop1_84_rule()
27149     p->level--;  in _loop1_84_rule()
27155 _tmp_85_rule(Parser *p)  in _tmp_85_rule()  argument
27157     if (p->level++ == MAXSTACK) {  in _tmp_85_rule()
27158         p->error_indicator = 1;  in _tmp_85_rule()
27161     if (p->error_indicator) {  in _tmp_85_rule()
27162         p->level--;  in _tmp_85_rule()
27166     int _mark = p->mark;  in _tmp_85_rule()
27168         if (p->error_indicator) {  in _tmp_85_rule()
27169             p->level--;  in _tmp_85_rule()
27172 …D(fprintf(stderr, "%*c> _tmp_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"…  in _tmp_85_rule()
27177             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in _tmp_85_rule()
27179             (z = arguments_rule(p), !p->error_indicator)  // arguments?  in _tmp_85_rule()
27181             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in _tmp_85_rule()
27184 …D(fprintf(stderr, "%*c+ _tmp_85[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' argu…  in _tmp_85_rule()
27187                 p->error_indicator = 1;  in _tmp_85_rule()
27188                 p->level--;  in _tmp_85_rule()
27193         p->mark = _mark;  in _tmp_85_rule()
27194         D(fprintf(stderr, "%*c%s _tmp_85[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_85_rule()
27195                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'"));  in _tmp_85_rule()
27199     p->level--;  in _tmp_85_rule()
27205 _loop1_86_rule(Parser *p)  in _loop1_86_rule()  argument
27207     if (p->level++ == MAXSTACK) {  in _loop1_86_rule()
27208         p->error_indicator = 1;  in _loop1_86_rule()
27211     if (p->error_indicator) {  in _loop1_86_rule()
27212         p->level--;  in _loop1_86_rule()
27216     int _mark = p->mark;  in _loop1_86_rule()
27217     int _start_mark = p->mark;  in _loop1_86_rule()
27220         p->error_indicator = 1;  in _loop1_86_rule()
27222         p->level--;  in _loop1_86_rule()
27228         if (p->error_indicator) {  in _loop1_86_rule()
27229             p->level--;  in _loop1_86_rule()
27232 …D(fprintf(stderr, "%*c> _loop1_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_express…  in _loop1_86_rule()
27235             (_tmp_185_var = _tmp_185_rule(p))  // ',' star_expression  in _loop1_86_rule()
27243                     p->error_indicator = 1;  in _loop1_86_rule()
27245                     p->level--;  in _loop1_86_rule()
27251             _mark = p->mark;  in _loop1_86_rule()
27253         p->mark = _mark;  in _loop1_86_rule()
27254         D(fprintf(stderr, "%*c%s _loop1_86[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_86_rule()
27255                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_expression)"));  in _loop1_86_rule()
27257     if (_n == 0 || p->error_indicator) {  in _loop1_86_rule()
27259         p->level--;  in _loop1_86_rule()
27262     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_86_rule()
27265         p->error_indicator = 1;  in _loop1_86_rule()
27267         p->level--;  in _loop1_86_rule()
27272     _PyPegen_insert_memo(p, _start_mark, _loop1_86_type, _seq);  in _loop1_86_rule()
27273     p->level--;  in _loop1_86_rule()
27279 _loop0_88_rule(Parser *p)  in _loop0_88_rule()  argument
27281     if (p->level++ == MAXSTACK) {  in _loop0_88_rule()
27282         p->error_indicator = 1;  in _loop0_88_rule()
27285     if (p->error_indicator) {  in _loop0_88_rule()
27286         p->level--;  in _loop0_88_rule()
27290     int _mark = p->mark;  in _loop0_88_rule()
27291     int _start_mark = p->mark;  in _loop0_88_rule()
27294         p->error_indicator = 1;  in _loop0_88_rule()
27296         p->level--;  in _loop0_88_rule()
27302         if (p->error_indicator) {  in _loop0_88_rule()
27303             p->level--;  in _loop0_88_rule()
27306 …D(fprintf(stderr, "%*c> _loop0_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_ex…  in _loop0_88_rule()
27310             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_88_rule()
27312             (elem = star_named_expression_rule(p))  // star_named_expression  in _loop0_88_rule()
27317                 p->error_indicator = 1;  in _loop0_88_rule()
27319                 p->level--;  in _loop0_88_rule()
27326                     p->error_indicator = 1;  in _loop0_88_rule()
27328                     p->level--;  in _loop0_88_rule()
27334             _mark = p->mark;  in _loop0_88_rule()
27336         p->mark = _mark;  in _loop0_88_rule()
27337         D(fprintf(stderr, "%*c%s _loop0_88[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_88_rule()
27338 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_named_expression"));  in _loop0_88_rule()
27340     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_88_rule()
27343         p->error_indicator = 1;  in _loop0_88_rule()
27345         p->level--;  in _loop0_88_rule()
27350     _PyPegen_insert_memo(p, _start_mark, _loop0_88_type, _seq);  in _loop0_88_rule()
27351     p->level--;  in _loop0_88_rule()
27357 _gather_87_rule(Parser *p)  in _gather_87_rule()  argument
27359     if (p->level++ == MAXSTACK) {  in _gather_87_rule()
27360         p->error_indicator = 1;  in _gather_87_rule()
27363     if (p->error_indicator) {  in _gather_87_rule()
27364         p->level--;  in _gather_87_rule()
27368     int _mark = p->mark;  in _gather_87_rule()
27370         if (p->error_indicator) {  in _gather_87_rule()
27371             p->level--;  in _gather_87_rule()
27374 …D(fprintf(stderr, "%*c> _gather_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expre…  in _gather_87_rule()
27378             (elem = star_named_expression_rule(p))  // star_named_expression  in _gather_87_rule()
27380             (seq = _loop0_88_rule(p))  // _loop0_88  in _gather_87_rule()
27383 …D(fprintf(stderr, "%*c+ _gather_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_…  in _gather_87_rule()
27384             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_87_rule()
27387         p->mark = _mark;  in _gather_87_rule()
27388         D(fprintf(stderr, "%*c%s _gather_87[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_87_rule()
27389 …          p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression _loop0_88"));  in _gather_87_rule()
27393     p->level--;  in _gather_87_rule()
27399 _loop1_89_rule(Parser *p)  in _loop1_89_rule()  argument
27401     if (p->level++ == MAXSTACK) {  in _loop1_89_rule()
27402         p->error_indicator = 1;  in _loop1_89_rule()
27405     if (p->error_indicator) {  in _loop1_89_rule()
27406         p->level--;  in _loop1_89_rule()
27410     int _mark = p->mark;  in _loop1_89_rule()
27411     int _start_mark = p->mark;  in _loop1_89_rule()
27414         p->error_indicator = 1;  in _loop1_89_rule()
27416         p->level--;  in _loop1_89_rule()
27422         if (p->error_indicator) {  in _loop1_89_rule()
27423             p->level--;  in _loop1_89_rule()
27426 …D(fprintf(stderr, "%*c> _loop1_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)"…  in _loop1_89_rule()
27429             (_tmp_186_var = _tmp_186_rule(p))  // ',' expression  in _loop1_89_rule()
27437                     p->error_indicator = 1;  in _loop1_89_rule()
27439                     p->level--;  in _loop1_89_rule()
27445             _mark = p->mark;  in _loop1_89_rule()
27447         p->mark = _mark;  in _loop1_89_rule()
27448         D(fprintf(stderr, "%*c%s _loop1_89[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_89_rule()
27449                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' expression)"));  in _loop1_89_rule()
27451     if (_n == 0 || p->error_indicator) {  in _loop1_89_rule()
27453         p->level--;  in _loop1_89_rule()
27456     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_89_rule()
27459         p->error_indicator = 1;  in _loop1_89_rule()
27461         p->level--;  in _loop1_89_rule()
27466     _PyPegen_insert_memo(p, _start_mark, _loop1_89_type, _seq);  in _loop1_89_rule()
27467     p->level--;  in _loop1_89_rule()
27473 _loop0_90_rule(Parser *p)  in _loop0_90_rule()  argument
27475     if (p->level++ == MAXSTACK) {  in _loop0_90_rule()
27476         p->error_indicator = 1;  in _loop0_90_rule()
27479     if (p->error_indicator) {  in _loop0_90_rule()
27480         p->level--;  in _loop0_90_rule()
27484     int _mark = p->mark;  in _loop0_90_rule()
27485     int _start_mark = p->mark;  in _loop0_90_rule()
27488         p->error_indicator = 1;  in _loop0_90_rule()
27490         p->level--;  in _loop0_90_rule()
27496         if (p->error_indicator) {  in _loop0_90_rule()
27497             p->level--;  in _loop0_90_rule()
27500 …D(fprintf(stderr, "%*c> _loop0_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_d…  in _loop0_90_rule()
27503 …        (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default  in _loop0_90_rule()
27511                     p->error_indicator = 1;  in _loop0_90_rule()
27513                     p->level--;  in _loop0_90_rule()
27519             _mark = p->mark;  in _loop0_90_rule()
27521         p->mark = _mark;  in _loop0_90_rule()
27522         D(fprintf(stderr, "%*c%s _loop0_90[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_90_rule()
27523                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));  in _loop0_90_rule()
27525     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_90_rule()
27528         p->error_indicator = 1;  in _loop0_90_rule()
27530         p->level--;  in _loop0_90_rule()
27535     _PyPegen_insert_memo(p, _start_mark, _loop0_90_type, _seq);  in _loop0_90_rule()
27536     p->level--;  in _loop0_90_rule()
27542 _loop0_91_rule(Parser *p)  in _loop0_91_rule()  argument
27544     if (p->level++ == MAXSTACK) {  in _loop0_91_rule()
27545         p->error_indicator = 1;  in _loop0_91_rule()
27548     if (p->error_indicator) {  in _loop0_91_rule()
27549         p->level--;  in _loop0_91_rule()
27553     int _mark = p->mark;  in _loop0_91_rule()
27554     int _start_mark = p->mark;  in _loop0_91_rule()
27557         p->error_indicator = 1;  in _loop0_91_rule()
27559         p->level--;  in _loop0_91_rule()
27565         if (p->error_indicator) {  in _loop0_91_rule()
27566             p->level--;  in _loop0_91_rule()
27569 …D(fprintf(stderr, "%*c> _loop0_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with…  in _loop0_91_rule()
27572 …  (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default  in _loop0_91_rule()
27580                     p->error_indicator = 1;  in _loop0_91_rule()
27582                     p->level--;  in _loop0_91_rule()
27588             _mark = p->mark;  in _loop0_91_rule()
27590         p->mark = _mark;  in _loop0_91_rule()
27591         D(fprintf(stderr, "%*c%s _loop0_91[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_91_rule()
27592 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));  in _loop0_91_rule()
27594     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_91_rule()
27597         p->error_indicator = 1;  in _loop0_91_rule()
27599         p->level--;  in _loop0_91_rule()
27604     _PyPegen_insert_memo(p, _start_mark, _loop0_91_type, _seq);  in _loop0_91_rule()
27605     p->level--;  in _loop0_91_rule()
27611 _loop0_92_rule(Parser *p)  in _loop0_92_rule()  argument
27613     if (p->level++ == MAXSTACK) {  in _loop0_92_rule()
27614         p->error_indicator = 1;  in _loop0_92_rule()
27617     if (p->error_indicator) {  in _loop0_92_rule()
27618         p->level--;  in _loop0_92_rule()
27622     int _mark = p->mark;  in _loop0_92_rule()
27623     int _start_mark = p->mark;  in _loop0_92_rule()
27626         p->error_indicator = 1;  in _loop0_92_rule()
27628         p->level--;  in _loop0_92_rule()
27634         if (p->error_indicator) {  in _loop0_92_rule()
27635             p->level--;  in _loop0_92_rule()
27638 …D(fprintf(stderr, "%*c> _loop0_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with…  in _loop0_92_rule()
27641 …  (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default  in _loop0_92_rule()
27649                     p->error_indicator = 1;  in _loop0_92_rule()
27651                     p->level--;  in _loop0_92_rule()
27657             _mark = p->mark;  in _loop0_92_rule()
27659         p->mark = _mark;  in _loop0_92_rule()
27660         D(fprintf(stderr, "%*c%s _loop0_92[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_92_rule()
27661 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));  in _loop0_92_rule()
27663     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_92_rule()
27666         p->error_indicator = 1;  in _loop0_92_rule()
27668         p->level--;  in _loop0_92_rule()
27673     _PyPegen_insert_memo(p, _start_mark, _loop0_92_type, _seq);  in _loop0_92_rule()
27674     p->level--;  in _loop0_92_rule()
27680 _loop1_93_rule(Parser *p)  in _loop1_93_rule()  argument
27682     if (p->level++ == MAXSTACK) {  in _loop1_93_rule()
27683         p->error_indicator = 1;  in _loop1_93_rule()
27686     if (p->error_indicator) {  in _loop1_93_rule()
27687         p->level--;  in _loop1_93_rule()
27691     int _mark = p->mark;  in _loop1_93_rule()
27692     int _start_mark = p->mark;  in _loop1_93_rule()
27695         p->error_indicator = 1;  in _loop1_93_rule()
27697         p->level--;  in _loop1_93_rule()
27703         if (p->error_indicator) {  in _loop1_93_rule()
27704             p->level--;  in _loop1_93_rule()
27707 …D(fprintf(stderr, "%*c> _loop1_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_d…  in _loop1_93_rule()
27710 …        (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default  in _loop1_93_rule()
27718                     p->error_indicator = 1;  in _loop1_93_rule()
27720                     p->level--;  in _loop1_93_rule()
27726             _mark = p->mark;  in _loop1_93_rule()
27728         p->mark = _mark;  in _loop1_93_rule()
27729         D(fprintf(stderr, "%*c%s _loop1_93[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_93_rule()
27730                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));  in _loop1_93_rule()
27732     if (_n == 0 || p->error_indicator) {  in _loop1_93_rule()
27734         p->level--;  in _loop1_93_rule()
27737     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_93_rule()
27740         p->error_indicator = 1;  in _loop1_93_rule()
27742         p->level--;  in _loop1_93_rule()
27747     _PyPegen_insert_memo(p, _start_mark, _loop1_93_type, _seq);  in _loop1_93_rule()
27748     p->level--;  in _loop1_93_rule()
27754 _loop0_94_rule(Parser *p)  in _loop0_94_rule()  argument
27756     if (p->level++ == MAXSTACK) {  in _loop0_94_rule()
27757         p->error_indicator = 1;  in _loop0_94_rule()
27760     if (p->error_indicator) {  in _loop0_94_rule()
27761         p->level--;  in _loop0_94_rule()
27765     int _mark = p->mark;  in _loop0_94_rule()
27766     int _start_mark = p->mark;  in _loop0_94_rule()
27769         p->error_indicator = 1;  in _loop0_94_rule()
27771         p->level--;  in _loop0_94_rule()
27777         if (p->error_indicator) {  in _loop0_94_rule()
27778             p->level--;  in _loop0_94_rule()
27781 …D(fprintf(stderr, "%*c> _loop0_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with…  in _loop0_94_rule()
27784 …  (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default  in _loop0_94_rule()
27792                     p->error_indicator = 1;  in _loop0_94_rule()
27794                     p->level--;  in _loop0_94_rule()
27800             _mark = p->mark;  in _loop0_94_rule()
27802         p->mark = _mark;  in _loop0_94_rule()
27803         D(fprintf(stderr, "%*c%s _loop0_94[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_94_rule()
27804 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));  in _loop0_94_rule()
27806     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_94_rule()
27809         p->error_indicator = 1;  in _loop0_94_rule()
27811         p->level--;  in _loop0_94_rule()
27816     _PyPegen_insert_memo(p, _start_mark, _loop0_94_type, _seq);  in _loop0_94_rule()
27817     p->level--;  in _loop0_94_rule()
27823 _loop1_95_rule(Parser *p)  in _loop1_95_rule()  argument
27825     if (p->level++ == MAXSTACK) {  in _loop1_95_rule()
27826         p->error_indicator = 1;  in _loop1_95_rule()
27829     if (p->error_indicator) {  in _loop1_95_rule()
27830         p->level--;  in _loop1_95_rule()
27834     int _mark = p->mark;  in _loop1_95_rule()
27835     int _start_mark = p->mark;  in _loop1_95_rule()
27838         p->error_indicator = 1;  in _loop1_95_rule()
27840         p->level--;  in _loop1_95_rule()
27846         if (p->error_indicator) {  in _loop1_95_rule()
27847             p->level--;  in _loop1_95_rule()
27850 …D(fprintf(stderr, "%*c> _loop1_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with…  in _loop1_95_rule()
27853 …  (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default  in _loop1_95_rule()
27861                     p->error_indicator = 1;  in _loop1_95_rule()
27863                     p->level--;  in _loop1_95_rule()
27869             _mark = p->mark;  in _loop1_95_rule()
27871         p->mark = _mark;  in _loop1_95_rule()
27872         D(fprintf(stderr, "%*c%s _loop1_95[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_95_rule()
27873 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));  in _loop1_95_rule()
27875     if (_n == 0 || p->error_indicator) {  in _loop1_95_rule()
27877         p->level--;  in _loop1_95_rule()
27880     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_95_rule()
27883         p->error_indicator = 1;  in _loop1_95_rule()
27885         p->level--;  in _loop1_95_rule()
27890     _PyPegen_insert_memo(p, _start_mark, _loop1_95_type, _seq);  in _loop1_95_rule()
27891     p->level--;  in _loop1_95_rule()
27897 _loop1_96_rule(Parser *p)  in _loop1_96_rule()  argument
27899     if (p->level++ == MAXSTACK) {  in _loop1_96_rule()
27900         p->error_indicator = 1;  in _loop1_96_rule()
27903     if (p->error_indicator) {  in _loop1_96_rule()
27904         p->level--;  in _loop1_96_rule()
27908     int _mark = p->mark;  in _loop1_96_rule()
27909     int _start_mark = p->mark;  in _loop1_96_rule()
27912         p->error_indicator = 1;  in _loop1_96_rule()
27914         p->level--;  in _loop1_96_rule()
27920         if (p->error_indicator) {  in _loop1_96_rule()
27921             p->level--;  in _loop1_96_rule()
27924 …D(fprintf(stderr, "%*c> _loop1_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_d…  in _loop1_96_rule()
27927 …        (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default  in _loop1_96_rule()
27935                     p->error_indicator = 1;  in _loop1_96_rule()
27937                     p->level--;  in _loop1_96_rule()
27943             _mark = p->mark;  in _loop1_96_rule()
27945         p->mark = _mark;  in _loop1_96_rule()
27946         D(fprintf(stderr, "%*c%s _loop1_96[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_96_rule()
27947                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));  in _loop1_96_rule()
27949     if (_n == 0 || p->error_indicator) {  in _loop1_96_rule()
27951         p->level--;  in _loop1_96_rule()
27954     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_96_rule()
27957         p->error_indicator = 1;  in _loop1_96_rule()
27959         p->level--;  in _loop1_96_rule()
27964     _PyPegen_insert_memo(p, _start_mark, _loop1_96_type, _seq);  in _loop1_96_rule()
27965     p->level--;  in _loop1_96_rule()
27971 _loop1_97_rule(Parser *p)  in _loop1_97_rule()  argument
27973     if (p->level++ == MAXSTACK) {  in _loop1_97_rule()
27974         p->error_indicator = 1;  in _loop1_97_rule()
27977     if (p->error_indicator) {  in _loop1_97_rule()
27978         p->level--;  in _loop1_97_rule()
27982     int _mark = p->mark;  in _loop1_97_rule()
27983     int _start_mark = p->mark;  in _loop1_97_rule()
27986         p->error_indicator = 1;  in _loop1_97_rule()
27988         p->level--;  in _loop1_97_rule()
27994         if (p->error_indicator) {  in _loop1_97_rule()
27995             p->level--;  in _loop1_97_rule()
27998 …D(fprintf(stderr, "%*c> _loop1_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_d…  in _loop1_97_rule()
28001 …        (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default  in _loop1_97_rule()
28009                     p->error_indicator = 1;  in _loop1_97_rule()
28011                     p->level--;  in _loop1_97_rule()
28017             _mark = p->mark;  in _loop1_97_rule()
28019         p->mark = _mark;  in _loop1_97_rule()
28020         D(fprintf(stderr, "%*c%s _loop1_97[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_97_rule()
28021                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));  in _loop1_97_rule()
28023     if (_n == 0 || p->error_indicator) {  in _loop1_97_rule()
28025         p->level--;  in _loop1_97_rule()
28028     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_97_rule()
28031         p->error_indicator = 1;  in _loop1_97_rule()
28033         p->level--;  in _loop1_97_rule()
28038     _PyPegen_insert_memo(p, _start_mark, _loop1_97_type, _seq);  in _loop1_97_rule()
28039     p->level--;  in _loop1_97_rule()
28045 _loop0_98_rule(Parser *p)  in _loop0_98_rule()  argument
28047     if (p->level++ == MAXSTACK) {  in _loop0_98_rule()
28048         p->error_indicator = 1;  in _loop0_98_rule()
28051     if (p->error_indicator) {  in _loop0_98_rule()
28052         p->level--;  in _loop0_98_rule()
28056     int _mark = p->mark;  in _loop0_98_rule()
28057     int _start_mark = p->mark;  in _loop0_98_rule()
28060         p->error_indicator = 1;  in _loop0_98_rule()
28062         p->level--;  in _loop0_98_rule()
28068         if (p->error_indicator) {  in _loop0_98_rule()
28069             p->level--;  in _loop0_98_rule()
28072 …D(fprintf(stderr, "%*c> _loop0_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_d…  in _loop0_98_rule()
28075 …        (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default  in _loop0_98_rule()
28083                     p->error_indicator = 1;  in _loop0_98_rule()
28085                     p->level--;  in _loop0_98_rule()
28091             _mark = p->mark;  in _loop0_98_rule()
28093         p->mark = _mark;  in _loop0_98_rule()
28094         D(fprintf(stderr, "%*c%s _loop0_98[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_98_rule()
28095                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));  in _loop0_98_rule()
28097     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_98_rule()
28100         p->error_indicator = 1;  in _loop0_98_rule()
28102         p->level--;  in _loop0_98_rule()
28107     _PyPegen_insert_memo(p, _start_mark, _loop0_98_type, _seq);  in _loop0_98_rule()
28108     p->level--;  in _loop0_98_rule()
28114 _loop1_99_rule(Parser *p)  in _loop1_99_rule()  argument
28116     if (p->level++ == MAXSTACK) {  in _loop1_99_rule()
28117         p->error_indicator = 1;  in _loop1_99_rule()
28120     if (p->error_indicator) {  in _loop1_99_rule()
28121         p->level--;  in _loop1_99_rule()
28125     int _mark = p->mark;  in _loop1_99_rule()
28126     int _start_mark = p->mark;  in _loop1_99_rule()
28129         p->error_indicator = 1;  in _loop1_99_rule()
28131         p->level--;  in _loop1_99_rule()
28137         if (p->error_indicator) {  in _loop1_99_rule()
28138             p->level--;  in _loop1_99_rule()
28141 …D(fprintf(stderr, "%*c> _loop1_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with…  in _loop1_99_rule()
28144 …  (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default  in _loop1_99_rule()
28152                     p->error_indicator = 1;  in _loop1_99_rule()
28154                     p->level--;  in _loop1_99_rule()
28160             _mark = p->mark;  in _loop1_99_rule()
28162         p->mark = _mark;  in _loop1_99_rule()
28163         D(fprintf(stderr, "%*c%s _loop1_99[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_99_rule()
28164 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));  in _loop1_99_rule()
28166     if (_n == 0 || p->error_indicator) {  in _loop1_99_rule()
28168         p->level--;  in _loop1_99_rule()
28171     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_99_rule()
28174         p->error_indicator = 1;  in _loop1_99_rule()
28176         p->level--;  in _loop1_99_rule()
28181     _PyPegen_insert_memo(p, _start_mark, _loop1_99_type, _seq);  in _loop1_99_rule()
28182     p->level--;  in _loop1_99_rule()
28188 _loop0_100_rule(Parser *p)  in _loop0_100_rule()  argument
28190     if (p->level++ == MAXSTACK) {  in _loop0_100_rule()
28191         p->error_indicator = 1;  in _loop0_100_rule()
28194     if (p->error_indicator) {  in _loop0_100_rule()
28195         p->level--;  in _loop0_100_rule()
28199     int _mark = p->mark;  in _loop0_100_rule()
28200     int _start_mark = p->mark;  in _loop0_100_rule()
28203         p->error_indicator = 1;  in _loop0_100_rule()
28205         p->level--;  in _loop0_100_rule()
28211         if (p->error_indicator) {  in _loop0_100_rule()
28212             p->level--;  in _loop0_100_rule()
28215 …D(fprintf(stderr, "%*c> _loop0_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_…  in _loop0_100_rule()
28218 …        (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default  in _loop0_100_rule()
28226                     p->error_indicator = 1;  in _loop0_100_rule()
28228                     p->level--;  in _loop0_100_rule()
28234             _mark = p->mark;  in _loop0_100_rule()
28236         p->mark = _mark;  in _loop0_100_rule()
28237         D(fprintf(stderr, "%*c%s _loop0_100[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_100_rule()
28238                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));  in _loop0_100_rule()
28240     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_100_rule()
28243         p->error_indicator = 1;  in _loop0_100_rule()
28245         p->level--;  in _loop0_100_rule()
28250     _PyPegen_insert_memo(p, _start_mark, _loop0_100_type, _seq);  in _loop0_100_rule()
28251     p->level--;  in _loop0_100_rule()
28257 _loop1_101_rule(Parser *p)  in _loop1_101_rule()  argument
28259     if (p->level++ == MAXSTACK) {  in _loop1_101_rule()
28260         p->error_indicator = 1;  in _loop1_101_rule()
28263     if (p->error_indicator) {  in _loop1_101_rule()
28264         p->level--;  in _loop1_101_rule()
28268     int _mark = p->mark;  in _loop1_101_rule()
28269     int _start_mark = p->mark;  in _loop1_101_rule()
28272         p->error_indicator = 1;  in _loop1_101_rule()
28274         p->level--;  in _loop1_101_rule()
28280         if (p->error_indicator) {  in _loop1_101_rule()
28281             p->level--;  in _loop1_101_rule()
28284 …D(fprintf(stderr, "%*c> _loop1_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_wit…  in _loop1_101_rule()
28287 …  (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default  in _loop1_101_rule()
28295                     p->error_indicator = 1;  in _loop1_101_rule()
28297                     p->level--;  in _loop1_101_rule()
28303             _mark = p->mark;  in _loop1_101_rule()
28305         p->mark = _mark;  in _loop1_101_rule()
28306         D(fprintf(stderr, "%*c%s _loop1_101[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_101_rule()
28307 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));  in _loop1_101_rule()
28309     if (_n == 0 || p->error_indicator) {  in _loop1_101_rule()
28311         p->level--;  in _loop1_101_rule()
28314     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_101_rule()
28317         p->error_indicator = 1;  in _loop1_101_rule()
28319         p->level--;  in _loop1_101_rule()
28324     _PyPegen_insert_memo(p, _start_mark, _loop1_101_type, _seq);  in _loop1_101_rule()
28325     p->level--;  in _loop1_101_rule()
28331 _loop0_102_rule(Parser *p)  in _loop0_102_rule()  argument
28333     if (p->level++ == MAXSTACK) {  in _loop0_102_rule()
28334         p->error_indicator = 1;  in _loop0_102_rule()
28337     if (p->error_indicator) {  in _loop0_102_rule()
28338         p->level--;  in _loop0_102_rule()
28342     int _mark = p->mark;  in _loop0_102_rule()
28343     int _start_mark = p->mark;  in _loop0_102_rule()
28346         p->error_indicator = 1;  in _loop0_102_rule()
28348         p->level--;  in _loop0_102_rule()
28354         if (p->error_indicator) {  in _loop0_102_rule()
28355             p->level--;  in _loop0_102_rule()
28358 …D(fprintf(stderr, "%*c> _loop0_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_may…  in _loop0_102_rule()
28361 …(lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_defau…  in _loop0_102_rule()
28369                     p->error_indicator = 1;  in _loop0_102_rule()
28371                     p->level--;  in _loop0_102_rule()
28377             _mark = p->mark;  in _loop0_102_rule()
28379         p->mark = _mark;  in _loop0_102_rule()
28380         D(fprintf(stderr, "%*c%s _loop0_102[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_102_rule()
28381 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));  in _loop0_102_rule()
28383     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_102_rule()
28386         p->error_indicator = 1;  in _loop0_102_rule()
28388         p->level--;  in _loop0_102_rule()
28393     _PyPegen_insert_memo(p, _start_mark, _loop0_102_type, _seq);  in _loop0_102_rule()
28394     p->level--;  in _loop0_102_rule()
28400 _loop1_103_rule(Parser *p)  in _loop1_103_rule()  argument
28402     if (p->level++ == MAXSTACK) {  in _loop1_103_rule()
28403         p->error_indicator = 1;  in _loop1_103_rule()
28406     if (p->error_indicator) {  in _loop1_103_rule()
28407         p->level--;  in _loop1_103_rule()
28411     int _mark = p->mark;  in _loop1_103_rule()
28412     int _start_mark = p->mark;  in _loop1_103_rule()
28415         p->error_indicator = 1;  in _loop1_103_rule()
28417         p->level--;  in _loop1_103_rule()
28423         if (p->error_indicator) {  in _loop1_103_rule()
28424             p->level--;  in _loop1_103_rule()
28427 …D(fprintf(stderr, "%*c> _loop1_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_may…  in _loop1_103_rule()
28430 …(lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_defau…  in _loop1_103_rule()
28438                     p->error_indicator = 1;  in _loop1_103_rule()
28440                     p->level--;  in _loop1_103_rule()
28446             _mark = p->mark;  in _loop1_103_rule()
28448         p->mark = _mark;  in _loop1_103_rule()
28449         D(fprintf(stderr, "%*c%s _loop1_103[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_103_rule()
28450 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));  in _loop1_103_rule()
28452     if (_n == 0 || p->error_indicator) {  in _loop1_103_rule()
28454         p->level--;  in _loop1_103_rule()
28457     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_103_rule()
28460         p->error_indicator = 1;  in _loop1_103_rule()
28462         p->level--;  in _loop1_103_rule()
28467     _PyPegen_insert_memo(p, _start_mark, _loop1_103_type, _seq);  in _loop1_103_rule()
28468     p->level--;  in _loop1_103_rule()
28474 _loop1_104_rule(Parser *p)  in _loop1_104_rule()  argument
28476     if (p->level++ == MAXSTACK) {  in _loop1_104_rule()
28477         p->error_indicator = 1;  in _loop1_104_rule()
28480     if (p->error_indicator) {  in _loop1_104_rule()
28481         p->level--;  in _loop1_104_rule()
28485     int _mark = p->mark;  in _loop1_104_rule()
28486     int _start_mark = p->mark;  in _loop1_104_rule()
28489         p->error_indicator = 1;  in _loop1_104_rule()
28491         p->level--;  in _loop1_104_rule()
28497         if (p->error_indicator) {  in _loop1_104_rule()
28498             p->level--;  in _loop1_104_rule()
28501 …D(fprintf(stderr, "%*c> _loop1_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunctio…  in _loop1_104_rule()
28504             (_tmp_187_var = _tmp_187_rule(p))  // 'or' conjunction  in _loop1_104_rule()
28512                     p->error_indicator = 1;  in _loop1_104_rule()
28514                     p->level--;  in _loop1_104_rule()
28520             _mark = p->mark;  in _loop1_104_rule()
28522         p->mark = _mark;  in _loop1_104_rule()
28523         D(fprintf(stderr, "%*c%s _loop1_104[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_104_rule()
28524                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('or' conjunction)"));  in _loop1_104_rule()
28526     if (_n == 0 || p->error_indicator) {  in _loop1_104_rule()
28528         p->level--;  in _loop1_104_rule()
28531     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_104_rule()
28534         p->error_indicator = 1;  in _loop1_104_rule()
28536         p->level--;  in _loop1_104_rule()
28541     _PyPegen_insert_memo(p, _start_mark, _loop1_104_type, _seq);  in _loop1_104_rule()
28542     p->level--;  in _loop1_104_rule()
28548 _loop1_105_rule(Parser *p)  in _loop1_105_rule()  argument
28550     if (p->level++ == MAXSTACK) {  in _loop1_105_rule()
28551         p->error_indicator = 1;  in _loop1_105_rule()
28554     if (p->error_indicator) {  in _loop1_105_rule()
28555         p->level--;  in _loop1_105_rule()
28559     int _mark = p->mark;  in _loop1_105_rule()
28560     int _start_mark = p->mark;  in _loop1_105_rule()
28563         p->error_indicator = 1;  in _loop1_105_rule()
28565         p->level--;  in _loop1_105_rule()
28571         if (p->error_indicator) {  in _loop1_105_rule()
28572             p->level--;  in _loop1_105_rule()
28575 …D(fprintf(stderr, "%*c> _loop1_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion…  in _loop1_105_rule()
28578             (_tmp_188_var = _tmp_188_rule(p))  // 'and' inversion  in _loop1_105_rule()
28586                     p->error_indicator = 1;  in _loop1_105_rule()
28588                     p->level--;  in _loop1_105_rule()
28594             _mark = p->mark;  in _loop1_105_rule()
28596         p->mark = _mark;  in _loop1_105_rule()
28597         D(fprintf(stderr, "%*c%s _loop1_105[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_105_rule()
28598                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('and' inversion)"));  in _loop1_105_rule()
28600     if (_n == 0 || p->error_indicator) {  in _loop1_105_rule()
28602         p->level--;  in _loop1_105_rule()
28605     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_105_rule()
28608         p->error_indicator = 1;  in _loop1_105_rule()
28610         p->level--;  in _loop1_105_rule()
28615     _PyPegen_insert_memo(p, _start_mark, _loop1_105_type, _seq);  in _loop1_105_rule()
28616     p->level--;  in _loop1_105_rule()
28622 _loop1_106_rule(Parser *p)  in _loop1_106_rule()  argument
28624     if (p->level++ == MAXSTACK) {  in _loop1_106_rule()
28625         p->error_indicator = 1;  in _loop1_106_rule()
28628     if (p->error_indicator) {  in _loop1_106_rule()
28629         p->level--;  in _loop1_106_rule()
28633     int _mark = p->mark;  in _loop1_106_rule()
28634     int _start_mark = p->mark;  in _loop1_106_rule()
28637         p->error_indicator = 1;  in _loop1_106_rule()
28639         p->level--;  in _loop1_106_rule()
28645         if (p->error_indicator) {  in _loop1_106_rule()
28646             p->level--;  in _loop1_106_rule()
28649 …D(fprintf(stderr, "%*c> _loop1_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwi…  in _loop1_106_rule()
28652 …(compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p))  // compare_op_bitwise_or_pa…  in _loop1_106_rule()
28660                     p->error_indicator = 1;  in _loop1_106_rule()
28662                     p->level--;  in _loop1_106_rule()
28668             _mark = p->mark;  in _loop1_106_rule()
28670         p->mark = _mark;  in _loop1_106_rule()
28671         D(fprintf(stderr, "%*c%s _loop1_106[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_106_rule()
28672 …               p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compare_op_bitwise_or_pair"));  in _loop1_106_rule()
28674     if (_n == 0 || p->error_indicator) {  in _loop1_106_rule()
28676         p->level--;  in _loop1_106_rule()
28679     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_106_rule()
28682         p->error_indicator = 1;  in _loop1_106_rule()
28684         p->level--;  in _loop1_106_rule()
28689     _PyPegen_insert_memo(p, _start_mark, _loop1_106_type, _seq);  in _loop1_106_rule()
28690     p->level--;  in _loop1_106_rule()
28696 _tmp_107_rule(Parser *p)  in _tmp_107_rule()  argument
28698     if (p->level++ == MAXSTACK) {  in _tmp_107_rule()
28699         p->error_indicator = 1;  in _tmp_107_rule()
28702     if (p->error_indicator) {  in _tmp_107_rule()
28703         p->level--;  in _tmp_107_rule()
28707     int _mark = p->mark;  in _tmp_107_rule()
28709         if (p->error_indicator) {  in _tmp_107_rule()
28710             p->level--;  in _tmp_107_rule()
28713         D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='"));  in _tmp_107_rule()
28716             (tok = _PyPegen_expect_token(p, 28))  // token='!='  in _tmp_107_rule()
28719 …D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='"));  in _tmp_107_rule()
28720             _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok;  in _tmp_107_rule()
28722                 p->error_indicator = 1;  in _tmp_107_rule()
28723                 p->level--;  in _tmp_107_rule()
28728         p->mark = _mark;  in _tmp_107_rule()
28729         D(fprintf(stderr, "%*c%s _tmp_107[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_107_rule()
28730                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!='"));  in _tmp_107_rule()
28734     p->level--;  in _tmp_107_rule()
28740 _loop0_109_rule(Parser *p)  in _loop0_109_rule()  argument
28742     if (p->level++ == MAXSTACK) {  in _loop0_109_rule()
28743         p->error_indicator = 1;  in _loop0_109_rule()
28746     if (p->error_indicator) {  in _loop0_109_rule()
28747         p->level--;  in _loop0_109_rule()
28751     int _mark = p->mark;  in _loop0_109_rule()
28752     int _start_mark = p->mark;  in _loop0_109_rule()
28755         p->error_indicator = 1;  in _loop0_109_rule()
28757         p->level--;  in _loop0_109_rule()
28763         if (p->error_indicator) {  in _loop0_109_rule()
28764             p->level--;  in _loop0_109_rule()
28767 …    D(fprintf(stderr, "%*c> _loop0_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' slice"));  in _loop0_109_rule()
28771             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_109_rule()
28773             (elem = slice_rule(p))  // slice  in _loop0_109_rule()
28778                 p->error_indicator = 1;  in _loop0_109_rule()
28780                 p->level--;  in _loop0_109_rule()
28787                     p->error_indicator = 1;  in _loop0_109_rule()
28789                     p->level--;  in _loop0_109_rule()
28795             _mark = p->mark;  in _loop0_109_rule()
28797         p->mark = _mark;  in _loop0_109_rule()
28798         D(fprintf(stderr, "%*c%s _loop0_109[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_109_rule()
28799                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' slice"));  in _loop0_109_rule()
28801     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_109_rule()
28804         p->error_indicator = 1;  in _loop0_109_rule()
28806         p->level--;  in _loop0_109_rule()
28811     _PyPegen_insert_memo(p, _start_mark, _loop0_109_type, _seq);  in _loop0_109_rule()
28812     p->level--;  in _loop0_109_rule()
28818 _gather_108_rule(Parser *p)  in _gather_108_rule()  argument
28820     if (p->level++ == MAXSTACK) {  in _gather_108_rule()
28821         p->error_indicator = 1;  in _gather_108_rule()
28824     if (p->error_indicator) {  in _gather_108_rule()
28825         p->level--;  in _gather_108_rule()
28829     int _mark = p->mark;  in _gather_108_rule()
28831         if (p->error_indicator) {  in _gather_108_rule()
28832             p->level--;  in _gather_108_rule()
28835 …D(fprintf(stderr, "%*c> _gather_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice _loop0_10…  in _gather_108_rule()
28839             (elem = slice_rule(p))  // slice  in _gather_108_rule()
28841             (seq = _loop0_109_rule(p))  // _loop0_109  in _gather_108_rule()
28844 …D(fprintf(stderr, "%*c+ _gather_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slic…  in _gather_108_rule()
28845             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_108_rule()
28848         p->mark = _mark;  in _gather_108_rule()
28849         D(fprintf(stderr, "%*c%s _gather_108[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_108_rule()
28850                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice _loop0_109"));  in _gather_108_rule()
28854     p->level--;  in _gather_108_rule()
28860 _tmp_110_rule(Parser *p)  in _tmp_110_rule()  argument
28862     if (p->level++ == MAXSTACK) {  in _tmp_110_rule()
28863         p->error_indicator = 1;  in _tmp_110_rule()
28866     if (p->error_indicator) {  in _tmp_110_rule()
28867         p->level--;  in _tmp_110_rule()
28871     int _mark = p->mark;  in _tmp_110_rule()
28873         if (p->error_indicator) {  in _tmp_110_rule()
28874             p->level--;  in _tmp_110_rule()
28877 …D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?"));  in _tmp_110_rule()
28881             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in _tmp_110_rule()
28883             (d = expression_rule(p), !p->error_indicator)  // expression?  in _tmp_110_rule()
28886 …D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' exp…  in _tmp_110_rule()
28889                 p->error_indicator = 1;  in _tmp_110_rule()
28890                 p->level--;  in _tmp_110_rule()
28895         p->mark = _mark;  in _tmp_110_rule()
28896         D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_110_rule()
28897                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression?"));  in _tmp_110_rule()
28901     p->level--;  in _tmp_110_rule()
28907 _tmp_111_rule(Parser *p)  in _tmp_111_rule()  argument
28909     if (p->level++ == MAXSTACK) {  in _tmp_111_rule()
28910         p->error_indicator = 1;  in _tmp_111_rule()
28913     if (p->error_indicator) {  in _tmp_111_rule()
28914         p->level--;  in _tmp_111_rule()
28918     int _mark = p->mark;  in _tmp_111_rule()
28920         if (p->error_indicator) {  in _tmp_111_rule()
28921             p->level--;  in _tmp_111_rule()
28924         D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));  in _tmp_111_rule()
28927             (tuple_var = tuple_rule(p))  // tuple  in _tmp_111_rule()
28930 …D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")…  in _tmp_111_rule()
28934         p->mark = _mark;  in _tmp_111_rule()
28935         D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_111_rule()
28936                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));  in _tmp_111_rule()
28939         if (p->error_indicator) {  in _tmp_111_rule()
28940             p->level--;  in _tmp_111_rule()
28943         D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group"));  in _tmp_111_rule()
28946             (group_var = group_rule(p))  // group  in _tmp_111_rule()
28949 …D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group")…  in _tmp_111_rule()
28953         p->mark = _mark;  in _tmp_111_rule()
28954         D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_111_rule()
28955                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group"));  in _tmp_111_rule()
28958         if (p->error_indicator) {  in _tmp_111_rule()
28959             p->level--;  in _tmp_111_rule()
28962         D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp"));  in _tmp_111_rule()
28965             (genexp_var = genexp_rule(p))  // genexp  in _tmp_111_rule()
28968 …D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp"…  in _tmp_111_rule()
28972         p->mark = _mark;  in _tmp_111_rule()
28973         D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_111_rule()
28974                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp"));  in _tmp_111_rule()
28978     p->level--;  in _tmp_111_rule()
28984 _tmp_112_rule(Parser *p)  in _tmp_112_rule()  argument
28986     if (p->level++ == MAXSTACK) {  in _tmp_112_rule()
28987         p->error_indicator = 1;  in _tmp_112_rule()
28990     if (p->error_indicator) {  in _tmp_112_rule()
28991         p->level--;  in _tmp_112_rule()
28995     int _mark = p->mark;  in _tmp_112_rule()
28997         if (p->error_indicator) {  in _tmp_112_rule()
28998             p->level--;  in _tmp_112_rule()
29001         D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));  in _tmp_112_rule()
29004             (list_var = list_rule(p))  // list  in _tmp_112_rule()
29007 …D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));  in _tmp_112_rule()
29011         p->mark = _mark;  in _tmp_112_rule()
29012         D(fprintf(stderr, "%*c%s _tmp_112[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_112_rule()
29013                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));  in _tmp_112_rule()
29016         if (p->error_indicator) {  in _tmp_112_rule()
29017             p->level--;  in _tmp_112_rule()
29020         D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp"));  in _tmp_112_rule()
29023             (listcomp_var = listcomp_rule(p))  // listcomp  in _tmp_112_rule()
29026 …D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcom…  in _tmp_112_rule()
29030         p->mark = _mark;  in _tmp_112_rule()
29031         D(fprintf(stderr, "%*c%s _tmp_112[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_112_rule()
29032                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp"));  in _tmp_112_rule()
29036     p->level--;  in _tmp_112_rule()
29042 _tmp_113_rule(Parser *p)  in _tmp_113_rule()  argument
29044     if (p->level++ == MAXSTACK) {  in _tmp_113_rule()
29045         p->error_indicator = 1;  in _tmp_113_rule()
29048     if (p->error_indicator) {  in _tmp_113_rule()
29049         p->level--;  in _tmp_113_rule()
29053     int _mark = p->mark;  in _tmp_113_rule()
29055         if (p->error_indicator) {  in _tmp_113_rule()
29056             p->level--;  in _tmp_113_rule()
29059         D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict"));  in _tmp_113_rule()
29062             (dict_var = dict_rule(p))  // dict  in _tmp_113_rule()
29065 …D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict"));  in _tmp_113_rule()
29069         p->mark = _mark;  in _tmp_113_rule()
29070         D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_113_rule()
29071                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict"));  in _tmp_113_rule()
29074         if (p->error_indicator) {  in _tmp_113_rule()
29075             p->level--;  in _tmp_113_rule()
29078         D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set"));  in _tmp_113_rule()
29081             (set_var = set_rule(p))  // set  in _tmp_113_rule()
29084 … D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set"));  in _tmp_113_rule()
29088         p->mark = _mark;  in _tmp_113_rule()
29089         D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_113_rule()
29090                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "set"));  in _tmp_113_rule()
29093         if (p->error_indicator) {  in _tmp_113_rule()
29094             p->level--;  in _tmp_113_rule()
29097         D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp"));  in _tmp_113_rule()
29100             (dictcomp_var = dictcomp_rule(p))  // dictcomp  in _tmp_113_rule()
29103 …D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcom…  in _tmp_113_rule()
29107         p->mark = _mark;  in _tmp_113_rule()
29108         D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_113_rule()
29109                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp"));  in _tmp_113_rule()
29112         if (p->error_indicator) {  in _tmp_113_rule()
29113             p->level--;  in _tmp_113_rule()
29116         D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp"));  in _tmp_113_rule()
29119             (setcomp_var = setcomp_rule(p))  // setcomp  in _tmp_113_rule()
29122 …D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp…  in _tmp_113_rule()
29126         p->mark = _mark;  in _tmp_113_rule()
29127         D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_113_rule()
29128                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp"));  in _tmp_113_rule()
29132     p->level--;  in _tmp_113_rule()
29138 _loop1_114_rule(Parser *p)  in _loop1_114_rule()  argument
29140     if (p->level++ == MAXSTACK) {  in _loop1_114_rule()
29141         p->error_indicator = 1;  in _loop1_114_rule()
29144     if (p->error_indicator) {  in _loop1_114_rule()
29145         p->level--;  in _loop1_114_rule()
29149     int _mark = p->mark;  in _loop1_114_rule()
29150     int _start_mark = p->mark;  in _loop1_114_rule()
29153         p->error_indicator = 1;  in _loop1_114_rule()
29155         p->level--;  in _loop1_114_rule()
29161         if (p->error_indicator) {  in _loop1_114_rule()
29162             p->level--;  in _loop1_114_rule()
29165         D(fprintf(stderr, "%*c> _loop1_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING"));  in _loop1_114_rule()
29168             (string_var = _PyPegen_string_token(p))  // STRING  in _loop1_114_rule()
29176                     p->error_indicator = 1;  in _loop1_114_rule()
29178                     p->level--;  in _loop1_114_rule()
29184             _mark = p->mark;  in _loop1_114_rule()
29186         p->mark = _mark;  in _loop1_114_rule()
29187         D(fprintf(stderr, "%*c%s _loop1_114[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_114_rule()
29188                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING"));  in _loop1_114_rule()
29190     if (_n == 0 || p->error_indicator) {  in _loop1_114_rule()
29192         p->level--;  in _loop1_114_rule()
29195     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_114_rule()
29198         p->error_indicator = 1;  in _loop1_114_rule()
29200         p->level--;  in _loop1_114_rule()
29205     _PyPegen_insert_memo(p, _start_mark, _loop1_114_type, _seq);  in _loop1_114_rule()
29206     p->level--;  in _loop1_114_rule()
29212 _tmp_115_rule(Parser *p)  in _tmp_115_rule()  argument
29214     if (p->level++ == MAXSTACK) {  in _tmp_115_rule()
29215         p->error_indicator = 1;  in _tmp_115_rule()
29218     if (p->error_indicator) {  in _tmp_115_rule()
29219         p->level--;  in _tmp_115_rule()
29223     int _mark = p->mark;  in _tmp_115_rule()
29225         if (p->error_indicator) {  in _tmp_115_rule()
29226             p->level--;  in _tmp_115_rule()
29229 …D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_express…  in _tmp_115_rule()
29234             (y = star_named_expression_rule(p))  // star_named_expression  in _tmp_115_rule()
29236             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_115_rule()
29238             (z = star_named_expressions_rule(p), !p->error_indicator)  // star_named_expressions?  in _tmp_115_rule()
29241 …D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_na…  in _tmp_115_rule()
29242             _res = _PyPegen_seq_insert_in_front ( p , y , z );  in _tmp_115_rule()
29244                 p->error_indicator = 1;  in _tmp_115_rule()
29245                 p->level--;  in _tmp_115_rule()
29250         p->mark = _mark;  in _tmp_115_rule()
29251         D(fprintf(stderr, "%*c%s _tmp_115[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_115_rule()
29252 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_express…  in _tmp_115_rule()
29256     p->level--;  in _tmp_115_rule()
29262 _tmp_116_rule(Parser *p)  in _tmp_116_rule()  argument
29264     if (p->level++ == MAXSTACK) {  in _tmp_116_rule()
29265         p->error_indicator = 1;  in _tmp_116_rule()
29268     if (p->error_indicator) {  in _tmp_116_rule()
29269         p->level--;  in _tmp_116_rule()
29273     int _mark = p->mark;  in _tmp_116_rule()
29275         if (p->error_indicator) {  in _tmp_116_rule()
29276             p->level--;  in _tmp_116_rule()
29279 …     D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));  in _tmp_116_rule()
29282             (yield_expr_var = yield_expr_rule(p))  // yield_expr  in _tmp_116_rule()
29285 …D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_e…  in _tmp_116_rule()
29289         p->mark = _mark;  in _tmp_116_rule()
29290         D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_116_rule()
29291                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));  in _tmp_116_rule()
29294         if (p->error_indicator) {  in _tmp_116_rule()
29295             p->level--;  in _tmp_116_rule()
29298 …D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")…  in _tmp_116_rule()
29301             (named_expression_var = named_expression_rule(p))  // named_expression  in _tmp_116_rule()
29304 …D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_e…  in _tmp_116_rule()
29308         p->mark = _mark;  in _tmp_116_rule()
29309         D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_116_rule()
29310                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));  in _tmp_116_rule()
29314     p->level--;  in _tmp_116_rule()
29320 _tmp_117_rule(Parser *p)  in _tmp_117_rule()  argument
29322     if (p->level++ == MAXSTACK) {  in _tmp_117_rule()
29323         p->error_indicator = 1;  in _tmp_117_rule()
29326     if (p->error_indicator) {  in _tmp_117_rule()
29327         p->level--;  in _tmp_117_rule()
29331     int _mark = p->mark;  in _tmp_117_rule()
29333         if (p->error_indicator) {  in _tmp_117_rule()
29334             p->level--;  in _tmp_117_rule()
29337 …D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_express…  in _tmp_117_rule()
29340             (assignment_expression_var = assignment_expression_rule(p))  // assignment_expression  in _tmp_117_rule()
29343 …D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignm…  in _tmp_117_rule()
29347         p->mark = _mark;  in _tmp_117_rule()
29348         D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_117_rule()
29349                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));  in _tmp_117_rule()
29352         if (p->error_indicator) {  in _tmp_117_rule()
29353             p->level--;  in _tmp_117_rule()
29356 …D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")…  in _tmp_117_rule()
29359             (expression_var = expression_rule(p))  // expression  in _tmp_117_rule()
29361             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)  // token=':='  in _tmp_117_rule()
29364 …D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express…  in _tmp_117_rule()
29368         p->mark = _mark;  in _tmp_117_rule()
29369         D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_117_rule()
29370                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='"));  in _tmp_117_rule()
29374     p->level--;  in _tmp_117_rule()
29380 _loop0_119_rule(Parser *p)  in _loop0_119_rule()  argument
29382     if (p->level++ == MAXSTACK) {  in _loop0_119_rule()
29383         p->error_indicator = 1;  in _loop0_119_rule()
29386     if (p->error_indicator) {  in _loop0_119_rule()
29387         p->level--;  in _loop0_119_rule()
29391     int _mark = p->mark;  in _loop0_119_rule()
29392     int _start_mark = p->mark;  in _loop0_119_rule()
29395         p->error_indicator = 1;  in _loop0_119_rule()
29397         p->level--;  in _loop0_119_rule()
29403         if (p->error_indicator) {  in _loop0_119_rule()
29404             p->level--;  in _loop0_119_rule()
29407 …D(fprintf(stderr, "%*c> _loop0_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starr…  in _loop0_119_rule()
29411             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_119_rule()
29413             (elem = double_starred_kvpair_rule(p))  // double_starred_kvpair  in _loop0_119_rule()
29418                 p->error_indicator = 1;  in _loop0_119_rule()
29420                 p->level--;  in _loop0_119_rule()
29427                     p->error_indicator = 1;  in _loop0_119_rule()
29429                     p->level--;  in _loop0_119_rule()
29435             _mark = p->mark;  in _loop0_119_rule()
29437         p->mark = _mark;  in _loop0_119_rule()
29438         D(fprintf(stderr, "%*c%s _loop0_119[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_119_rule()
29439 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair"));  in _loop0_119_rule()
29441     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_119_rule()
29444         p->error_indicator = 1;  in _loop0_119_rule()
29446         p->level--;  in _loop0_119_rule()
29451     _PyPegen_insert_memo(p, _start_mark, _loop0_119_type, _seq);  in _loop0_119_rule()
29452     p->level--;  in _loop0_119_rule()
29458 _gather_118_rule(Parser *p)  in _gather_118_rule()  argument
29460     if (p->level++ == MAXSTACK) {  in _gather_118_rule()
29461         p->error_indicator = 1;  in _gather_118_rule()
29464     if (p->error_indicator) {  in _gather_118_rule()
29465         p->level--;  in _gather_118_rule()
29469     int _mark = p->mark;  in _gather_118_rule()
29471         if (p->error_indicator) {  in _gather_118_rule()
29472             p->level--;  in _gather_118_rule()
29475 …D(fprintf(stderr, "%*c> _gather_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_…  in _gather_118_rule()
29479             (elem = double_starred_kvpair_rule(p))  // double_starred_kvpair  in _gather_118_rule()
29481             (seq = _loop0_119_rule(p))  // _loop0_119  in _gather_118_rule()
29484 …D(fprintf(stderr, "%*c+ _gather_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "doub…  in _gather_118_rule()
29485             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_118_rule()
29488         p->mark = _mark;  in _gather_118_rule()
29489         D(fprintf(stderr, "%*c%s _gather_118[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_118_rule()
29490 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_119"));  in _gather_118_rule()
29494     p->level--;  in _gather_118_rule()
29500 _loop1_120_rule(Parser *p)  in _loop1_120_rule()  argument
29502     if (p->level++ == MAXSTACK) {  in _loop1_120_rule()
29503         p->error_indicator = 1;  in _loop1_120_rule()
29506     if (p->error_indicator) {  in _loop1_120_rule()
29507         p->level--;  in _loop1_120_rule()
29511     int _mark = p->mark;  in _loop1_120_rule()
29512     int _start_mark = p->mark;  in _loop1_120_rule()
29515         p->error_indicator = 1;  in _loop1_120_rule()
29517         p->level--;  in _loop1_120_rule()
29523         if (p->error_indicator) {  in _loop1_120_rule()
29524             p->level--;  in _loop1_120_rule()
29527 …D(fprintf(stderr, "%*c> _loop1_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause"));  in _loop1_120_rule()
29530             (for_if_clause_var = for_if_clause_rule(p))  // for_if_clause  in _loop1_120_rule()
29538                     p->error_indicator = 1;  in _loop1_120_rule()
29540                     p->level--;  in _loop1_120_rule()
29546             _mark = p->mark;  in _loop1_120_rule()
29548         p->mark = _mark;  in _loop1_120_rule()
29549         D(fprintf(stderr, "%*c%s _loop1_120[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_120_rule()
29550                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause"));  in _loop1_120_rule()
29552     if (_n == 0 || p->error_indicator) {  in _loop1_120_rule()
29554         p->level--;  in _loop1_120_rule()
29557     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_120_rule()
29560         p->error_indicator = 1;  in _loop1_120_rule()
29562         p->level--;  in _loop1_120_rule()
29567     _PyPegen_insert_memo(p, _start_mark, _loop1_120_type, _seq);  in _loop1_120_rule()
29568     p->level--;  in _loop1_120_rule()
29574 _loop0_121_rule(Parser *p)  in _loop0_121_rule()  argument
29576     if (p->level++ == MAXSTACK) {  in _loop0_121_rule()
29577         p->error_indicator = 1;  in _loop0_121_rule()
29580     if (p->error_indicator) {  in _loop0_121_rule()
29581         p->level--;  in _loop0_121_rule()
29585     int _mark = p->mark;  in _loop0_121_rule()
29586     int _start_mark = p->mark;  in _loop0_121_rule()
29589         p->error_indicator = 1;  in _loop0_121_rule()
29591         p->level--;  in _loop0_121_rule()
29597         if (p->error_indicator) {  in _loop0_121_rule()
29598             p->level--;  in _loop0_121_rule()
29601 …D(fprintf(stderr, "%*c> _loop0_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunctio…  in _loop0_121_rule()
29604             (_tmp_189_var = _tmp_189_rule(p))  // 'if' disjunction  in _loop0_121_rule()
29612                     p->error_indicator = 1;  in _loop0_121_rule()
29614                     p->level--;  in _loop0_121_rule()
29620             _mark = p->mark;  in _loop0_121_rule()
29622         p->mark = _mark;  in _loop0_121_rule()
29623         D(fprintf(stderr, "%*c%s _loop0_121[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_121_rule()
29624                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)"));  in _loop0_121_rule()
29626     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_121_rule()
29629         p->error_indicator = 1;  in _loop0_121_rule()
29631         p->level--;  in _loop0_121_rule()
29636     _PyPegen_insert_memo(p, _start_mark, _loop0_121_type, _seq);  in _loop0_121_rule()
29637     p->level--;  in _loop0_121_rule()
29643 _loop0_122_rule(Parser *p)  in _loop0_122_rule()  argument
29645     if (p->level++ == MAXSTACK) {  in _loop0_122_rule()
29646         p->error_indicator = 1;  in _loop0_122_rule()
29649     if (p->error_indicator) {  in _loop0_122_rule()
29650         p->level--;  in _loop0_122_rule()
29654     int _mark = p->mark;  in _loop0_122_rule()
29655     int _start_mark = p->mark;  in _loop0_122_rule()
29658         p->error_indicator = 1;  in _loop0_122_rule()
29660         p->level--;  in _loop0_122_rule()
29666         if (p->error_indicator) {  in _loop0_122_rule()
29667             p->level--;  in _loop0_122_rule()
29670 …D(fprintf(stderr, "%*c> _loop0_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunctio…  in _loop0_122_rule()
29673             (_tmp_190_var = _tmp_190_rule(p))  // 'if' disjunction  in _loop0_122_rule()
29681                     p->error_indicator = 1;  in _loop0_122_rule()
29683                     p->level--;  in _loop0_122_rule()
29689             _mark = p->mark;  in _loop0_122_rule()
29691         p->mark = _mark;  in _loop0_122_rule()
29692         D(fprintf(stderr, "%*c%s _loop0_122[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_122_rule()
29693                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)"));  in _loop0_122_rule()
29695     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_122_rule()
29698         p->error_indicator = 1;  in _loop0_122_rule()
29700         p->level--;  in _loop0_122_rule()
29705     _PyPegen_insert_memo(p, _start_mark, _loop0_122_type, _seq);  in _loop0_122_rule()
29706     p->level--;  in _loop0_122_rule()
29712 _loop0_124_rule(Parser *p)  in _loop0_124_rule()  argument
29714     if (p->level++ == MAXSTACK) {  in _loop0_124_rule()
29715         p->error_indicator = 1;  in _loop0_124_rule()
29718     if (p->error_indicator) {  in _loop0_124_rule()
29719         p->level--;  in _loop0_124_rule()
29723     int _mark = p->mark;  in _loop0_124_rule()
29724     int _start_mark = p->mark;  in _loop0_124_rule()
29727         p->error_indicator = 1;  in _loop0_124_rule()
29729         p->level--;  in _loop0_124_rule()
29735         if (p->error_indicator) {  in _loop0_124_rule()
29736             p->level--;  in _loop0_124_rule()
29739 …D(fprintf(stderr, "%*c> _loop0_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_exp…  in _loop0_124_rule()
29743             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_124_rule()
29745 … (elem = _tmp_191_rule(p))  // starred_expression | (assignment_expression | expression !':=') !'='  in _loop0_124_rule()
29750                 p->error_indicator = 1;  in _loop0_124_rule()
29752                 p->level--;  in _loop0_124_rule()
29759                     p->error_indicator = 1;  in _loop0_124_rule()
29761                     p->level--;  in _loop0_124_rule()
29767             _mark = p->mark;  in _loop0_124_rule()
29769         p->mark = _mark;  in _loop0_124_rule()
29770         D(fprintf(stderr, "%*c%s _loop0_124[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_124_rule()
29771 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression | (assignment_expres…  in _loop0_124_rule()
29773     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_124_rule()
29776         p->error_indicator = 1;  in _loop0_124_rule()
29778         p->level--;  in _loop0_124_rule()
29783     _PyPegen_insert_memo(p, _start_mark, _loop0_124_type, _seq);  in _loop0_124_rule()
29784     p->level--;  in _loop0_124_rule()
29791 _gather_123_rule(Parser *p)  in _gather_123_rule()  argument
29793     if (p->level++ == MAXSTACK) {  in _gather_123_rule()
29794         p->error_indicator = 1;  in _gather_123_rule()
29797     if (p->error_indicator) {  in _gather_123_rule()
29798         p->level--;  in _gather_123_rule()
29802     int _mark = p->mark;  in _gather_123_rule()
29804         if (p->error_indicator) {  in _gather_123_rule()
29805             p->level--;  in _gather_123_rule()
29808 …D(fprintf(stderr, "%*c> _gather_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expres…  in _gather_123_rule()
29812 … (elem = _tmp_191_rule(p))  // starred_expression | (assignment_expression | expression !':=') !'='  in _gather_123_rule()
29814             (seq = _loop0_124_rule(p))  // _loop0_124  in _gather_123_rule()
29817 …D(fprintf(stderr, "%*c+ _gather_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(sta…  in _gather_123_rule()
29818             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_123_rule()
29821         p->mark = _mark;  in _gather_123_rule()
29822         D(fprintf(stderr, "%*c%s _gather_123[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_123_rule()
29823 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression…  in _gather_123_rule()
29827     p->level--;  in _gather_123_rule()
29833 _tmp_125_rule(Parser *p)  in _tmp_125_rule()  argument
29835     if (p->level++ == MAXSTACK) {  in _tmp_125_rule()
29836         p->error_indicator = 1;  in _tmp_125_rule()
29839     if (p->error_indicator) {  in _tmp_125_rule()
29840         p->level--;  in _tmp_125_rule()
29844     int _mark = p->mark;  in _tmp_125_rule()
29846         if (p->error_indicator) {  in _tmp_125_rule()
29847             p->level--;  in _tmp_125_rule()
29850 …     D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs"));  in _tmp_125_rule()
29854             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_125_rule()
29856             (k = kwargs_rule(p))  // kwargs  in _tmp_125_rule()
29859 …D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwa…  in _tmp_125_rule()
29862                 p->error_indicator = 1;  in _tmp_125_rule()
29863                 p->level--;  in _tmp_125_rule()
29868         p->mark = _mark;  in _tmp_125_rule()
29869         D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_125_rule()
29870                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs"));  in _tmp_125_rule()
29874     p->level--;  in _tmp_125_rule()
29880 _loop0_127_rule(Parser *p)  in _loop0_127_rule()  argument
29882     if (p->level++ == MAXSTACK) {  in _loop0_127_rule()
29883         p->error_indicator = 1;  in _loop0_127_rule()
29886     if (p->error_indicator) {  in _loop0_127_rule()
29887         p->level--;  in _loop0_127_rule()
29891     int _mark = p->mark;  in _loop0_127_rule()
29892     int _start_mark = p->mark;  in _loop0_127_rule()
29895         p->error_indicator = 1;  in _loop0_127_rule()
29897         p->level--;  in _loop0_127_rule()
29903         if (p->error_indicator) {  in _loop0_127_rule()
29904             p->level--;  in _loop0_127_rule()
29907 …D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_sta…  in _loop0_127_rule()
29911             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_127_rule()
29913             (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred  in _loop0_127_rule()
29918                 p->error_indicator = 1;  in _loop0_127_rule()
29920                 p->level--;  in _loop0_127_rule()
29927                     p->error_indicator = 1;  in _loop0_127_rule()
29929                     p->level--;  in _loop0_127_rule()
29935             _mark = p->mark;  in _loop0_127_rule()
29937         p->mark = _mark;  in _loop0_127_rule()
29938         D(fprintf(stderr, "%*c%s _loop0_127[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_127_rule()
29939                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred"));  in _loop0_127_rule()
29941     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_127_rule()
29944         p->error_indicator = 1;  in _loop0_127_rule()
29946         p->level--;  in _loop0_127_rule()
29951     _PyPegen_insert_memo(p, _start_mark, _loop0_127_type, _seq);  in _loop0_127_rule()
29952     p->level--;  in _loop0_127_rule()
29958 _gather_126_rule(Parser *p)  in _gather_126_rule()  argument
29960     if (p->level++ == MAXSTACK) {  in _gather_126_rule()
29961         p->error_indicator = 1;  in _gather_126_rule()
29964     if (p->error_indicator) {  in _gather_126_rule()
29965         p->level--;  in _gather_126_rule()
29969     int _mark = p->mark;  in _gather_126_rule()
29971         if (p->error_indicator) {  in _gather_126_rule()
29972             p->level--;  in _gather_126_rule()
29975 …D(fprintf(stderr, "%*c> _gather_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starre…  in _gather_126_rule()
29979             (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred  in _gather_126_rule()
29981             (seq = _loop0_127_rule(p))  // _loop0_127  in _gather_126_rule()
29984 …D(fprintf(stderr, "%*c+ _gather_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwar…  in _gather_126_rule()
29985             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_126_rule()
29988         p->mark = _mark;  in _gather_126_rule()
29989         D(fprintf(stderr, "%*c%s _gather_126[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_126_rule()
29990 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_127"));  in _gather_126_rule()
29994     p->level--;  in _gather_126_rule()
30000 _loop0_129_rule(Parser *p)  in _loop0_129_rule()  argument
30002     if (p->level++ == MAXSTACK) {  in _loop0_129_rule()
30003         p->error_indicator = 1;  in _loop0_129_rule()
30006     if (p->error_indicator) {  in _loop0_129_rule()
30007         p->level--;  in _loop0_129_rule()
30011     int _mark = p->mark;  in _loop0_129_rule()
30012     int _start_mark = p->mark;  in _loop0_129_rule()
30015         p->error_indicator = 1;  in _loop0_129_rule()
30017         p->level--;  in _loop0_129_rule()
30023         if (p->error_indicator) {  in _loop0_129_rule()
30024             p->level--;  in _loop0_129_rule()
30027 …D(fprintf(stderr, "%*c> _loop0_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_dou…  in _loop0_129_rule()
30031             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_129_rule()
30033             (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred  in _loop0_129_rule()
30038                 p->error_indicator = 1;  in _loop0_129_rule()
30040                 p->level--;  in _loop0_129_rule()
30047                     p->error_indicator = 1;  in _loop0_129_rule()
30049                     p->level--;  in _loop0_129_rule()
30055             _mark = p->mark;  in _loop0_129_rule()
30057         p->mark = _mark;  in _loop0_129_rule()
30058         D(fprintf(stderr, "%*c%s _loop0_129[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_129_rule()
30059 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred"));  in _loop0_129_rule()
30061     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_129_rule()
30064         p->error_indicator = 1;  in _loop0_129_rule()
30066         p->level--;  in _loop0_129_rule()
30071     _PyPegen_insert_memo(p, _start_mark, _loop0_129_type, _seq);  in _loop0_129_rule()
30072     p->level--;  in _loop0_129_rule()
30078 _gather_128_rule(Parser *p)  in _gather_128_rule()  argument
30080     if (p->level++ == MAXSTACK) {  in _gather_128_rule()
30081         p->error_indicator = 1;  in _gather_128_rule()
30084     if (p->error_indicator) {  in _gather_128_rule()
30085         p->level--;  in _gather_128_rule()
30089     int _mark = p->mark;  in _gather_128_rule()
30091         if (p->error_indicator) {  in _gather_128_rule()
30092             p->level--;  in _gather_128_rule()
30095 …D(fprintf(stderr, "%*c> _gather_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double…  in _gather_128_rule()
30099             (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred  in _gather_128_rule()
30101             (seq = _loop0_129_rule(p))  // _loop0_129  in _gather_128_rule()
30104 …D(fprintf(stderr, "%*c+ _gather_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwar…  in _gather_128_rule()
30105             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_128_rule()
30108         p->mark = _mark;  in _gather_128_rule()
30109         D(fprintf(stderr, "%*c%s _gather_128[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_128_rule()
30110 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_129"));  in _gather_128_rule()
30114     p->level--;  in _gather_128_rule()
30120 _loop0_131_rule(Parser *p)  in _loop0_131_rule()  argument
30122     if (p->level++ == MAXSTACK) {  in _loop0_131_rule()
30123         p->error_indicator = 1;  in _loop0_131_rule()
30126     if (p->error_indicator) {  in _loop0_131_rule()
30127         p->level--;  in _loop0_131_rule()
30131     int _mark = p->mark;  in _loop0_131_rule()
30132     int _start_mark = p->mark;  in _loop0_131_rule()
30135         p->error_indicator = 1;  in _loop0_131_rule()
30137         p->level--;  in _loop0_131_rule()
30143         if (p->error_indicator) {  in _loop0_131_rule()
30144             p->level--;  in _loop0_131_rule()
30147 …D(fprintf(stderr, "%*c> _loop0_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_sta…  in _loop0_131_rule()
30151             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_131_rule()
30153             (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred  in _loop0_131_rule()
30158                 p->error_indicator = 1;  in _loop0_131_rule()
30160                 p->level--;  in _loop0_131_rule()
30167                     p->error_indicator = 1;  in _loop0_131_rule()
30169                     p->level--;  in _loop0_131_rule()
30175             _mark = p->mark;  in _loop0_131_rule()
30177         p->mark = _mark;  in _loop0_131_rule()
30178         D(fprintf(stderr, "%*c%s _loop0_131[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_131_rule()
30179                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred"));  in _loop0_131_rule()
30181     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_131_rule()
30184         p->error_indicator = 1;  in _loop0_131_rule()
30186         p->level--;  in _loop0_131_rule()
30191     _PyPegen_insert_memo(p, _start_mark, _loop0_131_type, _seq);  in _loop0_131_rule()
30192     p->level--;  in _loop0_131_rule()
30198 _gather_130_rule(Parser *p)  in _gather_130_rule()  argument
30200     if (p->level++ == MAXSTACK) {  in _gather_130_rule()
30201         p->error_indicator = 1;  in _gather_130_rule()
30204     if (p->error_indicator) {  in _gather_130_rule()
30205         p->level--;  in _gather_130_rule()
30209     int _mark = p->mark;  in _gather_130_rule()
30211         if (p->error_indicator) {  in _gather_130_rule()
30212             p->level--;  in _gather_130_rule()
30215 …D(fprintf(stderr, "%*c> _gather_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starre…  in _gather_130_rule()
30219             (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred  in _gather_130_rule()
30221             (seq = _loop0_131_rule(p))  // _loop0_131  in _gather_130_rule()
30224 …D(fprintf(stderr, "%*c+ _gather_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwar…  in _gather_130_rule()
30225             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_130_rule()
30228         p->mark = _mark;  in _gather_130_rule()
30229         D(fprintf(stderr, "%*c%s _gather_130[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_130_rule()
30230 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_131"));  in _gather_130_rule()
30234     p->level--;  in _gather_130_rule()
30240 _loop0_133_rule(Parser *p)  in _loop0_133_rule()  argument
30242     if (p->level++ == MAXSTACK) {  in _loop0_133_rule()
30243         p->error_indicator = 1;  in _loop0_133_rule()
30246     if (p->error_indicator) {  in _loop0_133_rule()
30247         p->level--;  in _loop0_133_rule()
30251     int _mark = p->mark;  in _loop0_133_rule()
30252     int _start_mark = p->mark;  in _loop0_133_rule()
30255         p->error_indicator = 1;  in _loop0_133_rule()
30257         p->level--;  in _loop0_133_rule()
30263         if (p->error_indicator) {  in _loop0_133_rule()
30264             p->level--;  in _loop0_133_rule()
30267 …D(fprintf(stderr, "%*c> _loop0_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_dou…  in _loop0_133_rule()
30271             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_133_rule()
30273             (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred  in _loop0_133_rule()
30278                 p->error_indicator = 1;  in _loop0_133_rule()
30280                 p->level--;  in _loop0_133_rule()
30287                     p->error_indicator = 1;  in _loop0_133_rule()
30289                     p->level--;  in _loop0_133_rule()
30295             _mark = p->mark;  in _loop0_133_rule()
30297         p->mark = _mark;  in _loop0_133_rule()
30298         D(fprintf(stderr, "%*c%s _loop0_133[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_133_rule()
30299 …              p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred"));  in _loop0_133_rule()
30301     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_133_rule()
30304         p->error_indicator = 1;  in _loop0_133_rule()
30306         p->level--;  in _loop0_133_rule()
30311     _PyPegen_insert_memo(p, _start_mark, _loop0_133_type, _seq);  in _loop0_133_rule()
30312     p->level--;  in _loop0_133_rule()
30318 _gather_132_rule(Parser *p)  in _gather_132_rule()  argument
30320     if (p->level++ == MAXSTACK) {  in _gather_132_rule()
30321         p->error_indicator = 1;  in _gather_132_rule()
30324     if (p->error_indicator) {  in _gather_132_rule()
30325         p->level--;  in _gather_132_rule()
30329     int _mark = p->mark;  in _gather_132_rule()
30331         if (p->error_indicator) {  in _gather_132_rule()
30332             p->level--;  in _gather_132_rule()
30335 …D(fprintf(stderr, "%*c> _gather_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double…  in _gather_132_rule()
30339             (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred  in _gather_132_rule()
30341             (seq = _loop0_133_rule(p))  // _loop0_133  in _gather_132_rule()
30344 …D(fprintf(stderr, "%*c+ _gather_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwar…  in _gather_132_rule()
30345             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_132_rule()
30348         p->mark = _mark;  in _gather_132_rule()
30349         D(fprintf(stderr, "%*c%s _gather_132[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_132_rule()
30350 …       p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_133"));  in _gather_132_rule()
30354     p->level--;  in _gather_132_rule()
30360 _loop0_134_rule(Parser *p)  in _loop0_134_rule()  argument
30362     if (p->level++ == MAXSTACK) {  in _loop0_134_rule()
30363         p->error_indicator = 1;  in _loop0_134_rule()
30366     if (p->error_indicator) {  in _loop0_134_rule()
30367         p->level--;  in _loop0_134_rule()
30371     int _mark = p->mark;  in _loop0_134_rule()
30372     int _start_mark = p->mark;  in _loop0_134_rule()
30375         p->error_indicator = 1;  in _loop0_134_rule()
30377         p->level--;  in _loop0_134_rule()
30383         if (p->error_indicator) {  in _loop0_134_rule()
30384             p->level--;  in _loop0_134_rule()
30387 …D(fprintf(stderr, "%*c> _loop0_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target…  in _loop0_134_rule()
30390             (_tmp_192_var = _tmp_192_rule(p))  // ',' star_target  in _loop0_134_rule()
30398                     p->error_indicator = 1;  in _loop0_134_rule()
30400                     p->level--;  in _loop0_134_rule()
30406             _mark = p->mark;  in _loop0_134_rule()
30408         p->mark = _mark;  in _loop0_134_rule()
30409         D(fprintf(stderr, "%*c%s _loop0_134[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_134_rule()
30410                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)"));  in _loop0_134_rule()
30412     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_134_rule()
30415         p->error_indicator = 1;  in _loop0_134_rule()
30417         p->level--;  in _loop0_134_rule()
30422     _PyPegen_insert_memo(p, _start_mark, _loop0_134_type, _seq);  in _loop0_134_rule()
30423     p->level--;  in _loop0_134_rule()
30429 _loop0_136_rule(Parser *p)  in _loop0_136_rule()  argument
30431     if (p->level++ == MAXSTACK) {  in _loop0_136_rule()
30432         p->error_indicator = 1;  in _loop0_136_rule()
30435     if (p->error_indicator) {  in _loop0_136_rule()
30436         p->level--;  in _loop0_136_rule()
30440     int _mark = p->mark;  in _loop0_136_rule()
30441     int _start_mark = p->mark;  in _loop0_136_rule()
30444         p->error_indicator = 1;  in _loop0_136_rule()
30446         p->level--;  in _loop0_136_rule()
30452         if (p->error_indicator) {  in _loop0_136_rule()
30453             p->level--;  in _loop0_136_rule()
30456 …D(fprintf(stderr, "%*c> _loop0_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"…  in _loop0_136_rule()
30460             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_136_rule()
30462             (elem = star_target_rule(p))  // star_target  in _loop0_136_rule()
30467                 p->error_indicator = 1;  in _loop0_136_rule()
30469                 p->level--;  in _loop0_136_rule()
30476                     p->error_indicator = 1;  in _loop0_136_rule()
30478                     p->level--;  in _loop0_136_rule()
30484             _mark = p->mark;  in _loop0_136_rule()
30486         p->mark = _mark;  in _loop0_136_rule()
30487         D(fprintf(stderr, "%*c%s _loop0_136[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_136_rule()
30488                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target"));  in _loop0_136_rule()
30490     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_136_rule()
30493         p->error_indicator = 1;  in _loop0_136_rule()
30495         p->level--;  in _loop0_136_rule()
30500     _PyPegen_insert_memo(p, _start_mark, _loop0_136_type, _seq);  in _loop0_136_rule()
30501     p->level--;  in _loop0_136_rule()
30507 _gather_135_rule(Parser *p)  in _gather_135_rule()  argument
30509     if (p->level++ == MAXSTACK) {  in _gather_135_rule()
30510         p->error_indicator = 1;  in _gather_135_rule()
30513     if (p->error_indicator) {  in _gather_135_rule()
30514         p->level--;  in _gather_135_rule()
30518     int _mark = p->mark;  in _gather_135_rule()
30520         if (p->error_indicator) {  in _gather_135_rule()
30521             p->level--;  in _gather_135_rule()
30524 …D(fprintf(stderr, "%*c> _gather_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _lo…  in _gather_135_rule()
30528             (elem = star_target_rule(p))  // star_target  in _gather_135_rule()
30530             (seq = _loop0_136_rule(p))  // _loop0_136  in _gather_135_rule()
30533 …D(fprintf(stderr, "%*c+ _gather_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star…  in _gather_135_rule()
30534             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_135_rule()
30537         p->mark = _mark;  in _gather_135_rule()
30538         D(fprintf(stderr, "%*c%s _gather_135[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_135_rule()
30539                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_136"));  in _gather_135_rule()
30543     p->level--;  in _gather_135_rule()
30549 _loop1_137_rule(Parser *p)  in _loop1_137_rule()  argument
30551     if (p->level++ == MAXSTACK) {  in _loop1_137_rule()
30552         p->error_indicator = 1;  in _loop1_137_rule()
30555     if (p->error_indicator) {  in _loop1_137_rule()
30556         p->level--;  in _loop1_137_rule()
30560     int _mark = p->mark;  in _loop1_137_rule()
30561     int _start_mark = p->mark;  in _loop1_137_rule()
30564         p->error_indicator = 1;  in _loop1_137_rule()
30566         p->level--;  in _loop1_137_rule()
30572         if (p->error_indicator) {  in _loop1_137_rule()
30573             p->level--;  in _loop1_137_rule()
30576 …D(fprintf(stderr, "%*c> _loop1_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target…  in _loop1_137_rule()
30579             (_tmp_193_var = _tmp_193_rule(p))  // ',' star_target  in _loop1_137_rule()
30587                     p->error_indicator = 1;  in _loop1_137_rule()
30589                     p->level--;  in _loop1_137_rule()
30595             _mark = p->mark;  in _loop1_137_rule()
30597         p->mark = _mark;  in _loop1_137_rule()
30598         D(fprintf(stderr, "%*c%s _loop1_137[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_137_rule()
30599                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)"));  in _loop1_137_rule()
30601     if (_n == 0 || p->error_indicator) {  in _loop1_137_rule()
30603         p->level--;  in _loop1_137_rule()
30606     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_137_rule()
30609         p->error_indicator = 1;  in _loop1_137_rule()
30611         p->level--;  in _loop1_137_rule()
30616     _PyPegen_insert_memo(p, _start_mark, _loop1_137_type, _seq);  in _loop1_137_rule()
30617     p->level--;  in _loop1_137_rule()
30623 _tmp_138_rule(Parser *p)  in _tmp_138_rule()  argument
30625     if (p->level++ == MAXSTACK) {  in _tmp_138_rule()
30626         p->error_indicator = 1;  in _tmp_138_rule()
30629     if (p->error_indicator) {  in _tmp_138_rule()
30630         p->level--;  in _tmp_138_rule()
30634     int _mark = p->mark;  in _tmp_138_rule()
30636         if (p->error_indicator) {  in _tmp_138_rule()
30637             p->level--;  in _tmp_138_rule()
30640 …D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")…  in _tmp_138_rule()
30643             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16)  // token='*'  in _tmp_138_rule()
30645             (star_target_var = star_target_rule(p))  // star_target  in _tmp_138_rule()
30648 …D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' st…  in _tmp_138_rule()
30652         p->mark = _mark;  in _tmp_138_rule()
30653         D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_138_rule()
30654                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target"));  in _tmp_138_rule()
30658     p->level--;  in _tmp_138_rule()
30664 _loop0_140_rule(Parser *p)  in _loop0_140_rule()  argument
30666     if (p->level++ == MAXSTACK) {  in _loop0_140_rule()
30667         p->error_indicator = 1;  in _loop0_140_rule()
30670     if (p->error_indicator) {  in _loop0_140_rule()
30671         p->level--;  in _loop0_140_rule()
30675     int _mark = p->mark;  in _loop0_140_rule()
30676     int _start_mark = p->mark;  in _loop0_140_rule()
30679         p->error_indicator = 1;  in _loop0_140_rule()
30681         p->level--;  in _loop0_140_rule()
30687         if (p->error_indicator) {  in _loop0_140_rule()
30688             p->level--;  in _loop0_140_rule()
30691 …D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")…  in _loop0_140_rule()
30695             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_140_rule()
30697             (elem = del_target_rule(p))  // del_target  in _loop0_140_rule()
30702                 p->error_indicator = 1;  in _loop0_140_rule()
30704                 p->level--;  in _loop0_140_rule()
30711                     p->error_indicator = 1;  in _loop0_140_rule()
30713                     p->level--;  in _loop0_140_rule()
30719             _mark = p->mark;  in _loop0_140_rule()
30721         p->mark = _mark;  in _loop0_140_rule()
30722         D(fprintf(stderr, "%*c%s _loop0_140[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_140_rule()
30723                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' del_target"));  in _loop0_140_rule()
30725     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_140_rule()
30728         p->error_indicator = 1;  in _loop0_140_rule()
30730         p->level--;  in _loop0_140_rule()
30735     _PyPegen_insert_memo(p, _start_mark, _loop0_140_type, _seq);  in _loop0_140_rule()
30736     p->level--;  in _loop0_140_rule()
30742 _gather_139_rule(Parser *p)  in _gather_139_rule()  argument
30744     if (p->level++ == MAXSTACK) {  in _gather_139_rule()
30745         p->error_indicator = 1;  in _gather_139_rule()
30748     if (p->error_indicator) {  in _gather_139_rule()
30749         p->level--;  in _gather_139_rule()
30753     int _mark = p->mark;  in _gather_139_rule()
30755         if (p->error_indicator) {  in _gather_139_rule()
30756             p->level--;  in _gather_139_rule()
30759 …D(fprintf(stderr, "%*c> _gather_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loo…  in _gather_139_rule()
30763             (elem = del_target_rule(p))  // del_target  in _gather_139_rule()
30765             (seq = _loop0_140_rule(p))  // _loop0_140  in _gather_139_rule()
30768 …D(fprintf(stderr, "%*c+ _gather_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_…  in _gather_139_rule()
30769             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_139_rule()
30772         p->mark = _mark;  in _gather_139_rule()
30773         D(fprintf(stderr, "%*c%s _gather_139[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_139_rule()
30774                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_140"));  in _gather_139_rule()
30778     p->level--;  in _gather_139_rule()
30784 _tmp_141_rule(Parser *p)  in _tmp_141_rule()  argument
30786     if (p->level++ == MAXSTACK) {  in _tmp_141_rule()
30787         p->error_indicator = 1;  in _tmp_141_rule()
30790     if (p->error_indicator) {  in _tmp_141_rule()
30791         p->level--;  in _tmp_141_rule()
30795     int _mark = p->mark;  in _tmp_141_rule()
30797         if (p->error_indicator) {  in _tmp_141_rule()
30798             p->level--;  in _tmp_141_rule()
30801         D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args"));  in _tmp_141_rule()
30804             (args_var = args_rule(p))  // args  in _tmp_141_rule()
30807 …D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args"));  in _tmp_141_rule()
30811         p->mark = _mark;  in _tmp_141_rule()
30812         D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_141_rule()
30813                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args"));  in _tmp_141_rule()
30816         if (p->error_indicator) {  in _tmp_141_rule()
30817             p->level--;  in _tmp_141_rule()
30820 …D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_…  in _tmp_141_rule()
30824             (expression_var = expression_rule(p))  // expression  in _tmp_141_rule()
30826             (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses  in _tmp_141_rule()
30829 …D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express…  in _tmp_141_rule()
30830             _res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var);  in _tmp_141_rule()
30833         p->mark = _mark;  in _tmp_141_rule()
30834         D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_141_rule()
30835 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses"));  in _tmp_141_rule()
30839     p->level--;  in _tmp_141_rule()
30845 _tmp_142_rule(Parser *p)  in _tmp_142_rule()  argument
30847     if (p->level++ == MAXSTACK) {  in _tmp_142_rule()
30848         p->error_indicator = 1;  in _tmp_142_rule()
30851     if (p->error_indicator) {  in _tmp_142_rule()
30852         p->level--;  in _tmp_142_rule()
30856     int _mark = p->mark;  in _tmp_142_rule()
30858         if (p->error_indicator) {  in _tmp_142_rule()
30859             p->level--;  in _tmp_142_rule()
30862         D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));  in _tmp_142_rule()
30865             (_keyword = _PyPegen_expect_token(p, 524))  // token='True'  in _tmp_142_rule()
30868 …D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"…  in _tmp_142_rule()
30872         p->mark = _mark;  in _tmp_142_rule()
30873         D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_142_rule()
30874                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));  in _tmp_142_rule()
30877         if (p->error_indicator) {  in _tmp_142_rule()
30878             p->level--;  in _tmp_142_rule()
30881         D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));  in _tmp_142_rule()
30884             (_keyword = _PyPegen_expect_token(p, 525))  // token='False'  in _tmp_142_rule()
30887 …D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'…  in _tmp_142_rule()
30891         p->mark = _mark;  in _tmp_142_rule()
30892         D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_142_rule()
30893                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));  in _tmp_142_rule()
30896         if (p->error_indicator) {  in _tmp_142_rule()
30897             p->level--;  in _tmp_142_rule()
30900         D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));  in _tmp_142_rule()
30903             (_keyword = _PyPegen_expect_token(p, 523))  // token='None'  in _tmp_142_rule()
30906 …D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"…  in _tmp_142_rule()
30910         p->mark = _mark;  in _tmp_142_rule()
30911         D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_142_rule()
30912                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));  in _tmp_142_rule()
30916     p->level--;  in _tmp_142_rule()
30922 _tmp_143_rule(Parser *p)  in _tmp_143_rule()  argument
30924     if (p->level++ == MAXSTACK) {  in _tmp_143_rule()
30925         p->error_indicator = 1;  in _tmp_143_rule()
30928     if (p->error_indicator) {  in _tmp_143_rule()
30929         p->level--;  in _tmp_143_rule()
30933     int _mark = p->mark;  in _tmp_143_rule()
30935         if (p->error_indicator) {  in _tmp_143_rule()
30936             p->level--;  in _tmp_143_rule()
30939         D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='"));  in _tmp_143_rule()
30943             (name_var = _PyPegen_name_token(p))  // NAME  in _tmp_143_rule()
30945             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_143_rule()
30948 …D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=…  in _tmp_143_rule()
30949             _res = _PyPegen_dummy_name(p, name_var, _literal);  in _tmp_143_rule()
30952         p->mark = _mark;  in _tmp_143_rule()
30953         D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_143_rule()
30954                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '='"));  in _tmp_143_rule()
30958     p->level--;  in _tmp_143_rule()
30964 _tmp_144_rule(Parser *p)  in _tmp_144_rule()  argument
30966     if (p->level++ == MAXSTACK) {  in _tmp_144_rule()
30967         p->error_indicator = 1;  in _tmp_144_rule()
30970     if (p->error_indicator) {  in _tmp_144_rule()
30971         p->level--;  in _tmp_144_rule()
30975     int _mark = p->mark;  in _tmp_144_rule()
30977         if (p->error_indicator) {  in _tmp_144_rule()
30978             p->level--;  in _tmp_144_rule()
30981 …    D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING"));  in _tmp_144_rule()
30985             (name_var = _PyPegen_name_token(p))  // NAME  in _tmp_144_rule()
30987             (string_var = _PyPegen_string_token(p))  // STRING  in _tmp_144_rule()
30990 …D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ST…  in _tmp_144_rule()
30991             _res = _PyPegen_dummy_name(p, name_var, string_var);  in _tmp_144_rule()
30994         p->mark = _mark;  in _tmp_144_rule()
30995         D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_144_rule()
30996                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME STRING"));  in _tmp_144_rule()
30999         if (p->error_indicator) {  in _tmp_144_rule()
31000             p->level--;  in _tmp_144_rule()
31003 …   D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD"));  in _tmp_144_rule()
31006             (soft_keyword_var = _PyPegen_soft_keyword_token(p))  // SOFT_KEYWORD  in _tmp_144_rule()
31009 …D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KE…  in _tmp_144_rule()
31013         p->mark = _mark;  in _tmp_144_rule()
31014         D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_144_rule()
31015                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "SOFT_KEYWORD"));  in _tmp_144_rule()
31019     p->level--;  in _tmp_144_rule()
31025 _tmp_145_rule(Parser *p)  in _tmp_145_rule()  argument
31027     if (p->level++ == MAXSTACK) {  in _tmp_145_rule()
31028         p->error_indicator = 1;  in _tmp_145_rule()
31031     if (p->error_indicator) {  in _tmp_145_rule()
31032         p->level--;  in _tmp_145_rule()
31036     int _mark = p->mark;  in _tmp_145_rule()
31038         if (p->error_indicator) {  in _tmp_145_rule()
31039             p->level--;  in _tmp_145_rule()
31042         D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'"));  in _tmp_145_rule()
31045             (_keyword = _PyPegen_expect_token(p, 516))  // token='else'  in _tmp_145_rule()
31048 …D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'"…  in _tmp_145_rule()
31052         p->mark = _mark;  in _tmp_145_rule()
31053         D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_145_rule()
31054                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else'"));  in _tmp_145_rule()
31057         if (p->error_indicator) {  in _tmp_145_rule()
31058             p->level--;  in _tmp_145_rule()
31061         D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_145_rule()
31064             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in _tmp_145_rule()
31067 … D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_145_rule()
31071         p->mark = _mark;  in _tmp_145_rule()
31072         D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_145_rule()
31073                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));  in _tmp_145_rule()
31077     p->level--;  in _tmp_145_rule()
31083 _tmp_146_rule(Parser *p)  in _tmp_146_rule()  argument
31085     if (p->level++ == MAXSTACK) {  in _tmp_146_rule()
31086         p->error_indicator = 1;  in _tmp_146_rule()
31089     if (p->error_indicator) {  in _tmp_146_rule()
31090         p->level--;  in _tmp_146_rule()
31094     int _mark = p->mark;  in _tmp_146_rule()
31096         if (p->error_indicator) {  in _tmp_146_rule()
31097             p->level--;  in _tmp_146_rule()
31100         D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));  in _tmp_146_rule()
31103             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_146_rule()
31106 … D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));  in _tmp_146_rule()
31110         p->mark = _mark;  in _tmp_146_rule()
31111         D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_146_rule()
31112                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));  in _tmp_146_rule()
31115         if (p->error_indicator) {  in _tmp_146_rule()
31116             p->level--;  in _tmp_146_rule()
31119         D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='"));  in _tmp_146_rule()
31122             (_literal = _PyPegen_expect_token(p, 53))  // token=':='  in _tmp_146_rule()
31125 …D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='"));  in _tmp_146_rule()
31129         p->mark = _mark;  in _tmp_146_rule()
31130         D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_146_rule()
31131                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='"));  in _tmp_146_rule()
31135     p->level--;  in _tmp_146_rule()
31141 _tmp_147_rule(Parser *p)  in _tmp_147_rule()  argument
31143     if (p->level++ == MAXSTACK) {  in _tmp_147_rule()
31144         p->error_indicator = 1;  in _tmp_147_rule()
31147     if (p->error_indicator) {  in _tmp_147_rule()
31148         p->level--;  in _tmp_147_rule()
31152     int _mark = p->mark;  in _tmp_147_rule()
31154         if (p->error_indicator) {  in _tmp_147_rule()
31155             p->level--;  in _tmp_147_rule()
31158         D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));  in _tmp_147_rule()
31161             (list_var = list_rule(p))  // list  in _tmp_147_rule()
31164 …D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));  in _tmp_147_rule()
31168         p->mark = _mark;  in _tmp_147_rule()
31169         D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_147_rule()
31170                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));  in _tmp_147_rule()
31173         if (p->error_indicator) {  in _tmp_147_rule()
31174             p->level--;  in _tmp_147_rule()
31177         D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));  in _tmp_147_rule()
31180             (tuple_var = tuple_rule(p))  // tuple  in _tmp_147_rule()
31183 …D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")…  in _tmp_147_rule()
31187         p->mark = _mark;  in _tmp_147_rule()
31188         D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_147_rule()
31189                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));  in _tmp_147_rule()
31192         if (p->error_indicator) {  in _tmp_147_rule()
31193             p->level--;  in _tmp_147_rule()
31196         D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp"));  in _tmp_147_rule()
31199             (genexp_var = genexp_rule(p))  // genexp  in _tmp_147_rule()
31202 …D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp"…  in _tmp_147_rule()
31206         p->mark = _mark;  in _tmp_147_rule()
31207         D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_147_rule()
31208                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp"));  in _tmp_147_rule()
31211         if (p->error_indicator) {  in _tmp_147_rule()
31212             p->level--;  in _tmp_147_rule()
31215         D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));  in _tmp_147_rule()
31218             (_keyword = _PyPegen_expect_token(p, 524))  // token='True'  in _tmp_147_rule()
31221 …D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"…  in _tmp_147_rule()
31225         p->mark = _mark;  in _tmp_147_rule()
31226         D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_147_rule()
31227                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));  in _tmp_147_rule()
31230         if (p->error_indicator) {  in _tmp_147_rule()
31231             p->level--;  in _tmp_147_rule()
31234         D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));  in _tmp_147_rule()
31237             (_keyword = _PyPegen_expect_token(p, 523))  // token='None'  in _tmp_147_rule()
31240 …D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"…  in _tmp_147_rule()
31244         p->mark = _mark;  in _tmp_147_rule()
31245         D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_147_rule()
31246                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));  in _tmp_147_rule()
31249         if (p->error_indicator) {  in _tmp_147_rule()
31250             p->level--;  in _tmp_147_rule()
31253         D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));  in _tmp_147_rule()
31256             (_keyword = _PyPegen_expect_token(p, 525))  // token='False'  in _tmp_147_rule()
31259 …D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'…  in _tmp_147_rule()
31263         p->mark = _mark;  in _tmp_147_rule()
31264         D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_147_rule()
31265                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));  in _tmp_147_rule()
31269     p->level--;  in _tmp_147_rule()
31275 _tmp_148_rule(Parser *p)  in _tmp_148_rule()  argument
31277     if (p->level++ == MAXSTACK) {  in _tmp_148_rule()
31278         p->error_indicator = 1;  in _tmp_148_rule()
31281     if (p->error_indicator) {  in _tmp_148_rule()
31282         p->level--;  in _tmp_148_rule()
31286     int _mark = p->mark;  in _tmp_148_rule()
31288         if (p->error_indicator) {  in _tmp_148_rule()
31289             p->level--;  in _tmp_148_rule()
31292         D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));  in _tmp_148_rule()
31295             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_148_rule()
31298 … D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));  in _tmp_148_rule()
31302         p->mark = _mark;  in _tmp_148_rule()
31303         D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_148_rule()
31304                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));  in _tmp_148_rule()
31307         if (p->error_indicator) {  in _tmp_148_rule()
31308             p->level--;  in _tmp_148_rule()
31311         D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='"));  in _tmp_148_rule()
31314             (_literal = _PyPegen_expect_token(p, 53))  // token=':='  in _tmp_148_rule()
31317 …D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='"));  in _tmp_148_rule()
31321         p->mark = _mark;  in _tmp_148_rule()
31322         D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_148_rule()
31323                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='"));  in _tmp_148_rule()
31327     p->level--;  in _tmp_148_rule()
31333 _loop0_149_rule(Parser *p)  in _loop0_149_rule()  argument
31335     if (p->level++ == MAXSTACK) {  in _loop0_149_rule()
31336         p->error_indicator = 1;  in _loop0_149_rule()
31339     if (p->error_indicator) {  in _loop0_149_rule()
31340         p->level--;  in _loop0_149_rule()
31344     int _mark = p->mark;  in _loop0_149_rule()
31345     int _start_mark = p->mark;  in _loop0_149_rule()
31348         p->error_indicator = 1;  in _loop0_149_rule()
31350         p->level--;  in _loop0_149_rule()
31356         if (p->error_indicator) {  in _loop0_149_rule()
31357             p->level--;  in _loop0_149_rule()
31360 …D(fprintf(stderr, "%*c> _loop0_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expre…  in _loop0_149_rule()
31363             (star_named_expressions_var = star_named_expressions_rule(p))  // star_named_expressions  in _loop0_149_rule()
31371                     p->error_indicator = 1;  in _loop0_149_rule()
31373                     p->level--;  in _loop0_149_rule()
31379             _mark = p->mark;  in _loop0_149_rule()
31381         p->mark = _mark;  in _loop0_149_rule()
31382         D(fprintf(stderr, "%*c%s _loop0_149[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_149_rule()
31383                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expressions"));  in _loop0_149_rule()
31385     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_149_rule()
31388         p->error_indicator = 1;  in _loop0_149_rule()
31390         p->level--;  in _loop0_149_rule()
31395     _PyPegen_insert_memo(p, _start_mark, _loop0_149_type, _seq);  in _loop0_149_rule()
31396     p->level--;  in _loop0_149_rule()
31402 _loop0_150_rule(Parser *p)  in _loop0_150_rule()  argument
31404     if (p->level++ == MAXSTACK) {  in _loop0_150_rule()
31405         p->error_indicator = 1;  in _loop0_150_rule()
31408     if (p->error_indicator) {  in _loop0_150_rule()
31409         p->level--;  in _loop0_150_rule()
31413     int _mark = p->mark;  in _loop0_150_rule()
31414     int _start_mark = p->mark;  in _loop0_150_rule()
31417         p->error_indicator = 1;  in _loop0_150_rule()
31419         p->level--;  in _loop0_150_rule()
31425         if (p->error_indicator) {  in _loop0_150_rule()
31426             p->level--;  in _loop0_150_rule()
31429 …D(fprintf(stderr, "%*c> _loop0_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=…  in _loop0_150_rule()
31432             (_tmp_194_var = _tmp_194_rule(p))  // star_targets '='  in _loop0_150_rule()
31440                     p->error_indicator = 1;  in _loop0_150_rule()
31442                     p->level--;  in _loop0_150_rule()
31448             _mark = p->mark;  in _loop0_150_rule()
31450         p->mark = _mark;  in _loop0_150_rule()
31451         D(fprintf(stderr, "%*c%s _loop0_150[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_150_rule()
31452                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')"));  in _loop0_150_rule()
31454     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_150_rule()
31457         p->error_indicator = 1;  in _loop0_150_rule()
31459         p->level--;  in _loop0_150_rule()
31464     _PyPegen_insert_memo(p, _start_mark, _loop0_150_type, _seq);  in _loop0_150_rule()
31465     p->level--;  in _loop0_150_rule()
31471 _loop0_151_rule(Parser *p)  in _loop0_151_rule()  argument
31473     if (p->level++ == MAXSTACK) {  in _loop0_151_rule()
31474         p->error_indicator = 1;  in _loop0_151_rule()
31477     if (p->error_indicator) {  in _loop0_151_rule()
31478         p->level--;  in _loop0_151_rule()
31482     int _mark = p->mark;  in _loop0_151_rule()
31483     int _start_mark = p->mark;  in _loop0_151_rule()
31486         p->error_indicator = 1;  in _loop0_151_rule()
31488         p->level--;  in _loop0_151_rule()
31494         if (p->error_indicator) {  in _loop0_151_rule()
31495             p->level--;  in _loop0_151_rule()
31498 …D(fprintf(stderr, "%*c> _loop0_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=…  in _loop0_151_rule()
31501             (_tmp_195_var = _tmp_195_rule(p))  // star_targets '='  in _loop0_151_rule()
31509                     p->error_indicator = 1;  in _loop0_151_rule()
31511                     p->level--;  in _loop0_151_rule()
31517             _mark = p->mark;  in _loop0_151_rule()
31519         p->mark = _mark;  in _loop0_151_rule()
31520         D(fprintf(stderr, "%*c%s _loop0_151[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_151_rule()
31521                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')"));  in _loop0_151_rule()
31523     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_151_rule()
31526         p->error_indicator = 1;  in _loop0_151_rule()
31528         p->level--;  in _loop0_151_rule()
31533     _PyPegen_insert_memo(p, _start_mark, _loop0_151_type, _seq);  in _loop0_151_rule()
31534     p->level--;  in _loop0_151_rule()
31540 _tmp_152_rule(Parser *p)  in _tmp_152_rule()  argument
31542     if (p->level++ == MAXSTACK) {  in _tmp_152_rule()
31543         p->error_indicator = 1;  in _tmp_152_rule()
31546     if (p->error_indicator) {  in _tmp_152_rule()
31547         p->level--;  in _tmp_152_rule()
31551     int _mark = p->mark;  in _tmp_152_rule()
31553         if (p->error_indicator) {  in _tmp_152_rule()
31554             p->level--;  in _tmp_152_rule()
31557 …     D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));  in _tmp_152_rule()
31560             (yield_expr_var = yield_expr_rule(p))  // yield_expr  in _tmp_152_rule()
31563 …D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_e…  in _tmp_152_rule()
31567         p->mark = _mark;  in _tmp_152_rule()
31568         D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_152_rule()
31569                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));  in _tmp_152_rule()
31572         if (p->error_indicator) {  in _tmp_152_rule()
31573             p->level--;  in _tmp_152_rule()
31576 …D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")…  in _tmp_152_rule()
31579             (star_expressions_var = star_expressions_rule(p))  // star_expressions  in _tmp_152_rule()
31582 …D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_ex…  in _tmp_152_rule()
31586         p->mark = _mark;  in _tmp_152_rule()
31587         D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_152_rule()
31588                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));  in _tmp_152_rule()
31592     p->level--;  in _tmp_152_rule()
31598 _tmp_153_rule(Parser *p)  in _tmp_153_rule()  argument
31600     if (p->level++ == MAXSTACK) {  in _tmp_153_rule()
31601         p->error_indicator = 1;  in _tmp_153_rule()
31604     if (p->error_indicator) {  in _tmp_153_rule()
31605         p->level--;  in _tmp_153_rule()
31609     int _mark = p->mark;  in _tmp_153_rule()
31611         if (p->error_indicator) {  in _tmp_153_rule()
31612             p->level--;  in _tmp_153_rule()
31615         D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));  in _tmp_153_rule()
31618             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in _tmp_153_rule()
31621 … D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));  in _tmp_153_rule()
31625         p->mark = _mark;  in _tmp_153_rule()
31626         D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_153_rule()
31627                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));  in _tmp_153_rule()
31630         if (p->error_indicator) {  in _tmp_153_rule()
31631             p->level--;  in _tmp_153_rule()
31634         D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));  in _tmp_153_rule()
31637             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in _tmp_153_rule()
31640 … D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));  in _tmp_153_rule()
31644         p->mark = _mark;  in _tmp_153_rule()
31645         D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_153_rule()
31646                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));  in _tmp_153_rule()
31649         if (p->error_indicator) {  in _tmp_153_rule()
31650             p->level--;  in _tmp_153_rule()
31653         D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));  in _tmp_153_rule()
31656             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in _tmp_153_rule()
31659 … D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));  in _tmp_153_rule()
31663         p->mark = _mark;  in _tmp_153_rule()
31664         D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_153_rule()
31665                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'"));  in _tmp_153_rule()
31669     p->level--;  in _tmp_153_rule()
31675 _tmp_154_rule(Parser *p)  in _tmp_154_rule()  argument
31677     if (p->level++ == MAXSTACK) {  in _tmp_154_rule()
31678         p->error_indicator = 1;  in _tmp_154_rule()
31681     if (p->error_indicator) {  in _tmp_154_rule()
31682         p->level--;  in _tmp_154_rule()
31686     int _mark = p->mark;  in _tmp_154_rule()
31688         if (p->error_indicator) {  in _tmp_154_rule()
31689             p->level--;  in _tmp_154_rule()
31692         D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));  in _tmp_154_rule()
31695             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in _tmp_154_rule()
31698 … D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));  in _tmp_154_rule()
31702         p->mark = _mark;  in _tmp_154_rule()
31703         D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_154_rule()
31704                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));  in _tmp_154_rule()
31707         if (p->error_indicator) {  in _tmp_154_rule()
31708             p->level--;  in _tmp_154_rule()
31711         D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));  in _tmp_154_rule()
31714             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in _tmp_154_rule()
31717 … D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));  in _tmp_154_rule()
31721         p->mark = _mark;  in _tmp_154_rule()
31722         D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_154_rule()
31723                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'"));  in _tmp_154_rule()
31727     p->level--;  in _tmp_154_rule()
31733 _tmp_155_rule(Parser *p)  in _tmp_155_rule()  argument
31735     if (p->level++ == MAXSTACK) {  in _tmp_155_rule()
31736         p->error_indicator = 1;  in _tmp_155_rule()
31739     if (p->error_indicator) {  in _tmp_155_rule()
31740         p->level--;  in _tmp_155_rule()
31744     int _mark = p->mark;  in _tmp_155_rule()
31746         if (p->error_indicator) {  in _tmp_155_rule()
31747             p->level--;  in _tmp_155_rule()
31750         D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));  in _tmp_155_rule()
31753             (_literal = _PyPegen_expect_token(p, 9))  // token='['  in _tmp_155_rule()
31756 … D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));  in _tmp_155_rule()
31760         p->mark = _mark;  in _tmp_155_rule()
31761         D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_155_rule()
31762                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));  in _tmp_155_rule()
31765         if (p->error_indicator) {  in _tmp_155_rule()
31766             p->level--;  in _tmp_155_rule()
31769         D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));  in _tmp_155_rule()
31772             (_literal = _PyPegen_expect_token(p, 25))  // token='{'  in _tmp_155_rule()
31775 … D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));  in _tmp_155_rule()
31779         p->mark = _mark;  in _tmp_155_rule()
31780         D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_155_rule()
31781                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'"));  in _tmp_155_rule()
31785     p->level--;  in _tmp_155_rule()
31791 _loop0_156_rule(Parser *p)  in _loop0_156_rule()  argument
31793     if (p->level++ == MAXSTACK) {  in _loop0_156_rule()
31794         p->error_indicator = 1;  in _loop0_156_rule()
31797     if (p->error_indicator) {  in _loop0_156_rule()
31798         p->level--;  in _loop0_156_rule()
31802     int _mark = p->mark;  in _loop0_156_rule()
31803     int _start_mark = p->mark;  in _loop0_156_rule()
31806         p->error_indicator = 1;  in _loop0_156_rule()
31808         p->level--;  in _loop0_156_rule()
31814         if (p->error_indicator) {  in _loop0_156_rule()
31815             p->level--;  in _loop0_156_rule()
31818 …D(fprintf(stderr, "%*c> _loop0_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default…  in _loop0_156_rule()
31821             (param_no_default_var = param_no_default_rule(p))  // param_no_default  in _loop0_156_rule()
31829                     p->error_indicator = 1;  in _loop0_156_rule()
31831                     p->level--;  in _loop0_156_rule()
31837             _mark = p->mark;  in _loop0_156_rule()
31839         p->mark = _mark;  in _loop0_156_rule()
31840         D(fprintf(stderr, "%*c%s _loop0_156[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_156_rule()
31841                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));  in _loop0_156_rule()
31843     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_156_rule()
31846         p->error_indicator = 1;  in _loop0_156_rule()
31848         p->level--;  in _loop0_156_rule()
31853     _PyPegen_insert_memo(p, _start_mark, _loop0_156_type, _seq);  in _loop0_156_rule()
31854     p->level--;  in _loop0_156_rule()
31860 _loop1_157_rule(Parser *p)  in _loop1_157_rule()  argument
31862     if (p->level++ == MAXSTACK) {  in _loop1_157_rule()
31863         p->error_indicator = 1;  in _loop1_157_rule()
31866     if (p->error_indicator) {  in _loop1_157_rule()
31867         p->level--;  in _loop1_157_rule()
31871     int _mark = p->mark;  in _loop1_157_rule()
31872     int _start_mark = p->mark;  in _loop1_157_rule()
31875         p->error_indicator = 1;  in _loop1_157_rule()
31877         p->level--;  in _loop1_157_rule()
31883         if (p->error_indicator) {  in _loop1_157_rule()
31884             p->level--;  in _loop1_157_rule()
31887 …D(fprintf(stderr, "%*c> _loop1_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_defau…  in _loop1_157_rule()
31890             (param_with_default_var = param_with_default_rule(p))  // param_with_default  in _loop1_157_rule()
31898                     p->error_indicator = 1;  in _loop1_157_rule()
31900                     p->level--;  in _loop1_157_rule()
31906             _mark = p->mark;  in _loop1_157_rule()
31908         p->mark = _mark;  in _loop1_157_rule()
31909         D(fprintf(stderr, "%*c%s _loop1_157[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_157_rule()
31910                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));  in _loop1_157_rule()
31912     if (_n == 0 || p->error_indicator) {  in _loop1_157_rule()
31914         p->level--;  in _loop1_157_rule()
31917     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_157_rule()
31920         p->error_indicator = 1;  in _loop1_157_rule()
31922         p->level--;  in _loop1_157_rule()
31927     _PyPegen_insert_memo(p, _start_mark, _loop1_157_type, _seq);  in _loop1_157_rule()
31928     p->level--;  in _loop1_157_rule()
31934 _loop0_158_rule(Parser *p)  in _loop0_158_rule()  argument
31936     if (p->level++ == MAXSTACK) {  in _loop0_158_rule()
31937         p->error_indicator = 1;  in _loop0_158_rule()
31940     if (p->error_indicator) {  in _loop0_158_rule()
31941         p->level--;  in _loop0_158_rule()
31945     int _mark = p->mark;  in _loop0_158_rule()
31946     int _start_mark = p->mark;  in _loop0_158_rule()
31949         p->error_indicator = 1;  in _loop0_158_rule()
31951         p->level--;  in _loop0_158_rule()
31957         if (p->error_indicator) {  in _loop0_158_rule()
31958             p->level--;  in _loop0_158_rule()
31961 …D(fprintf(stderr, "%*c> _loop0_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_…  in _loop0_158_rule()
31964 …        (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default  in _loop0_158_rule()
31972                     p->error_indicator = 1;  in _loop0_158_rule()
31974                     p->level--;  in _loop0_158_rule()
31980             _mark = p->mark;  in _loop0_158_rule()
31982         p->mark = _mark;  in _loop0_158_rule()
31983         D(fprintf(stderr, "%*c%s _loop0_158[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_158_rule()
31984                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));  in _loop0_158_rule()
31986     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_158_rule()
31989         p->error_indicator = 1;  in _loop0_158_rule()
31991         p->level--;  in _loop0_158_rule()
31996     _PyPegen_insert_memo(p, _start_mark, _loop0_158_type, _seq);  in _loop0_158_rule()
31997     p->level--;  in _loop0_158_rule()
32003 _loop1_159_rule(Parser *p)  in _loop1_159_rule()  argument
32005     if (p->level++ == MAXSTACK) {  in _loop1_159_rule()
32006         p->error_indicator = 1;  in _loop1_159_rule()
32009     if (p->error_indicator) {  in _loop1_159_rule()
32010         p->level--;  in _loop1_159_rule()
32014     int _mark = p->mark;  in _loop1_159_rule()
32015     int _start_mark = p->mark;  in _loop1_159_rule()
32018         p->error_indicator = 1;  in _loop1_159_rule()
32020         p->level--;  in _loop1_159_rule()
32026         if (p->error_indicator) {  in _loop1_159_rule()
32027             p->level--;  in _loop1_159_rule()
32030 …D(fprintf(stderr, "%*c> _loop1_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_wit…  in _loop1_159_rule()
32033 …  (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default  in _loop1_159_rule()
32041                     p->error_indicator = 1;  in _loop1_159_rule()
32043                     p->level--;  in _loop1_159_rule()
32049             _mark = p->mark;  in _loop1_159_rule()
32051         p->mark = _mark;  in _loop1_159_rule()
32052         D(fprintf(stderr, "%*c%s _loop1_159[%d-%d]: %s failed!\n", p->level, ' ',  in _loop1_159_rule()
32053 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));  in _loop1_159_rule()
32055     if (_n == 0 || p->error_indicator) {  in _loop1_159_rule()
32057         p->level--;  in _loop1_159_rule()
32060     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop1_159_rule()
32063         p->error_indicator = 1;  in _loop1_159_rule()
32065         p->level--;  in _loop1_159_rule()
32070     _PyPegen_insert_memo(p, _start_mark, _loop1_159_type, _seq);  in _loop1_159_rule()
32071     p->level--;  in _loop1_159_rule()
32077 _tmp_160_rule(Parser *p)  in _tmp_160_rule()  argument
32079     if (p->level++ == MAXSTACK) {  in _tmp_160_rule()
32080         p->error_indicator = 1;  in _tmp_160_rule()
32083     if (p->error_indicator) {  in _tmp_160_rule()
32084         p->level--;  in _tmp_160_rule()
32088     int _mark = p->mark;  in _tmp_160_rule()
32090         if (p->error_indicator) {  in _tmp_160_rule()
32091             p->level--;  in _tmp_160_rule()
32094         D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));  in _tmp_160_rule()
32097             (_literal = _PyPegen_expect_token(p, 8))  // token=')'  in _tmp_160_rule()
32100 … D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));  in _tmp_160_rule()
32104         p->mark = _mark;  in _tmp_160_rule()
32105         D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_160_rule()
32106                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));  in _tmp_160_rule()
32109         if (p->error_indicator) {  in _tmp_160_rule()
32110             p->level--;  in _tmp_160_rule()
32113 …D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")…  in _tmp_160_rule()
32117             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_160_rule()
32119             (_tmp_196_var = _tmp_196_rule(p))  // ')' | '**'  in _tmp_160_rule()
32122 …D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')…  in _tmp_160_rule()
32123             _res = _PyPegen_dummy_name(p, _literal, _tmp_196_var);  in _tmp_160_rule()
32126         p->mark = _mark;  in _tmp_160_rule()
32127         D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_160_rule()
32128                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')"));  in _tmp_160_rule()
32132     p->level--;  in _tmp_160_rule()
32138 _tmp_161_rule(Parser *p)  in _tmp_161_rule()  argument
32140     if (p->level++ == MAXSTACK) {  in _tmp_161_rule()
32141         p->error_indicator = 1;  in _tmp_161_rule()
32144     if (p->error_indicator) {  in _tmp_161_rule()
32145         p->level--;  in _tmp_161_rule()
32149     int _mark = p->mark;  in _tmp_161_rule()
32151         if (p->error_indicator) {  in _tmp_161_rule()
32152             p->level--;  in _tmp_161_rule()
32155         D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_161_rule()
32158             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in _tmp_161_rule()
32161 … D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_161_rule()
32165         p->mark = _mark;  in _tmp_161_rule()
32166         D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_161_rule()
32167                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));  in _tmp_161_rule()
32170         if (p->error_indicator) {  in _tmp_161_rule()
32171             p->level--;  in _tmp_161_rule()
32174 …D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")…  in _tmp_161_rule()
32178             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_161_rule()
32180             (_tmp_197_var = _tmp_197_rule(p))  // ':' | '**'  in _tmp_161_rule()
32183 …D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':…  in _tmp_161_rule()
32184             _res = _PyPegen_dummy_name(p, _literal, _tmp_197_var);  in _tmp_161_rule()
32187         p->mark = _mark;  in _tmp_161_rule()
32188         D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_161_rule()
32189                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')"));  in _tmp_161_rule()
32193     p->level--;  in _tmp_161_rule()
32199 _tmp_162_rule(Parser *p)  in _tmp_162_rule()  argument
32201     if (p->level++ == MAXSTACK) {  in _tmp_162_rule()
32202         p->error_indicator = 1;  in _tmp_162_rule()
32205     if (p->error_indicator) {  in _tmp_162_rule()
32206         p->level--;  in _tmp_162_rule()
32210     int _mark = p->mark;  in _tmp_162_rule()
32212         if (p->error_indicator) {  in _tmp_162_rule()
32213             p->level--;  in _tmp_162_rule()
32216         D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));  in _tmp_162_rule()
32219             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_162_rule()
32222 … D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));  in _tmp_162_rule()
32226         p->mark = _mark;  in _tmp_162_rule()
32227         D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_162_rule()
32228                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));  in _tmp_162_rule()
32231         if (p->error_indicator) {  in _tmp_162_rule()
32232             p->level--;  in _tmp_162_rule()
32235         D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));  in _tmp_162_rule()
32238             (_literal = _PyPegen_expect_token(p, 8))  // token=')'  in _tmp_162_rule()
32241 … D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));  in _tmp_162_rule()
32245         p->mark = _mark;  in _tmp_162_rule()
32246         D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_162_rule()
32247                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));  in _tmp_162_rule()
32250         if (p->error_indicator) {  in _tmp_162_rule()
32251             p->level--;  in _tmp_162_rule()
32254         D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_162_rule()
32257             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in _tmp_162_rule()
32260 … D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_162_rule()
32264         p->mark = _mark;  in _tmp_162_rule()
32265         D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_162_rule()
32266                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));  in _tmp_162_rule()
32270     p->level--;  in _tmp_162_rule()
32276 _loop0_164_rule(Parser *p)  in _loop0_164_rule()  argument
32278     if (p->level++ == MAXSTACK) {  in _loop0_164_rule()
32279         p->error_indicator = 1;  in _loop0_164_rule()
32282     if (p->error_indicator) {  in _loop0_164_rule()
32283         p->level--;  in _loop0_164_rule()
32287     int _mark = p->mark;  in _loop0_164_rule()
32288     int _start_mark = p->mark;  in _loop0_164_rule()
32291         p->error_indicator = 1;  in _loop0_164_rule()
32293         p->level--;  in _loop0_164_rule()
32299         if (p->error_indicator) {  in _loop0_164_rule()
32300             p->level--;  in _loop0_164_rule()
32303 …D(fprintf(stderr, "%*c> _loop0_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression …  in _loop0_164_rule()
32307             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_164_rule()
32309             (elem = _tmp_198_rule(p))  // expression ['as' star_target]  in _loop0_164_rule()
32314                 p->error_indicator = 1;  in _loop0_164_rule()
32316                 p->level--;  in _loop0_164_rule()
32323                     p->error_indicator = 1;  in _loop0_164_rule()
32325                     p->level--;  in _loop0_164_rule()
32331             _mark = p->mark;  in _loop0_164_rule()
32333         p->mark = _mark;  in _loop0_164_rule()
32334         D(fprintf(stderr, "%*c%s _loop0_164[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_164_rule()
32335 …      p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])"));  in _loop0_164_rule()
32337     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_164_rule()
32340         p->error_indicator = 1;  in _loop0_164_rule()
32342         p->level--;  in _loop0_164_rule()
32347     _PyPegen_insert_memo(p, _start_mark, _loop0_164_type, _seq);  in _loop0_164_rule()
32348     p->level--;  in _loop0_164_rule()
32354 _gather_163_rule(Parser *p)  in _gather_163_rule()  argument
32356     if (p->level++ == MAXSTACK) {  in _gather_163_rule()
32357         p->error_indicator = 1;  in _gather_163_rule()
32360     if (p->error_indicator) {  in _gather_163_rule()
32361         p->level--;  in _gather_163_rule()
32365     int _mark = p->mark;  in _gather_163_rule()
32367         if (p->error_indicator) {  in _gather_163_rule()
32368             p->level--;  in _gather_163_rule()
32371 …D(fprintf(stderr, "%*c> _gather_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['a…  in _gather_163_rule()
32375             (elem = _tmp_198_rule(p))  // expression ['as' star_target]  in _gather_163_rule()
32377             (seq = _loop0_164_rule(p))  // _loop0_164  in _gather_163_rule()
32380 …D(fprintf(stderr, "%*c+ _gather_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(exp…  in _gather_163_rule()
32381             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_163_rule()
32384         p->mark = _mark;  in _gather_163_rule()
32385         D(fprintf(stderr, "%*c%s _gather_163[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_163_rule()
32386 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_164")…  in _gather_163_rule()
32390     p->level--;  in _gather_163_rule()
32396 _loop0_166_rule(Parser *p)  in _loop0_166_rule()  argument
32398     if (p->level++ == MAXSTACK) {  in _loop0_166_rule()
32399         p->error_indicator = 1;  in _loop0_166_rule()
32402     if (p->error_indicator) {  in _loop0_166_rule()
32403         p->level--;  in _loop0_166_rule()
32407     int _mark = p->mark;  in _loop0_166_rule()
32408     int _start_mark = p->mark;  in _loop0_166_rule()
32411         p->error_indicator = 1;  in _loop0_166_rule()
32413         p->level--;  in _loop0_166_rule()
32419         if (p->error_indicator) {  in _loop0_166_rule()
32420             p->level--;  in _loop0_166_rule()
32423 …D(fprintf(stderr, "%*c> _loop0_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions…  in _loop0_166_rule()
32427             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_166_rule()
32429             (elem = _tmp_199_rule(p))  // expressions ['as' star_target]  in _loop0_166_rule()
32434                 p->error_indicator = 1;  in _loop0_166_rule()
32436                 p->level--;  in _loop0_166_rule()
32443                     p->error_indicator = 1;  in _loop0_166_rule()
32445                     p->level--;  in _loop0_166_rule()
32451             _mark = p->mark;  in _loop0_166_rule()
32453         p->mark = _mark;  in _loop0_166_rule()
32454         D(fprintf(stderr, "%*c%s _loop0_166[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_166_rule()
32455 …     p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])"));  in _loop0_166_rule()
32457     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_166_rule()
32460         p->error_indicator = 1;  in _loop0_166_rule()
32462         p->level--;  in _loop0_166_rule()
32467     _PyPegen_insert_memo(p, _start_mark, _loop0_166_type, _seq);  in _loop0_166_rule()
32468     p->level--;  in _loop0_166_rule()
32474 _gather_165_rule(Parser *p)  in _gather_165_rule()  argument
32476     if (p->level++ == MAXSTACK) {  in _gather_165_rule()
32477         p->error_indicator = 1;  in _gather_165_rule()
32480     if (p->error_indicator) {  in _gather_165_rule()
32481         p->level--;  in _gather_165_rule()
32485     int _mark = p->mark;  in _gather_165_rule()
32487         if (p->error_indicator) {  in _gather_165_rule()
32488             p->level--;  in _gather_165_rule()
32491 …D(fprintf(stderr, "%*c> _gather_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['…  in _gather_165_rule()
32495             (elem = _tmp_199_rule(p))  // expressions ['as' star_target]  in _gather_165_rule()
32497             (seq = _loop0_166_rule(p))  // _loop0_166  in _gather_165_rule()
32500 …D(fprintf(stderr, "%*c+ _gather_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(exp…  in _gather_165_rule()
32501             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_165_rule()
32504         p->mark = _mark;  in _gather_165_rule()
32505         D(fprintf(stderr, "%*c%s _gather_165[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_165_rule()
32506 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_166"…  in _gather_165_rule()
32510     p->level--;  in _gather_165_rule()
32516 _loop0_168_rule(Parser *p)  in _loop0_168_rule()  argument
32518     if (p->level++ == MAXSTACK) {  in _loop0_168_rule()
32519         p->error_indicator = 1;  in _loop0_168_rule()
32522     if (p->error_indicator) {  in _loop0_168_rule()
32523         p->level--;  in _loop0_168_rule()
32527     int _mark = p->mark;  in _loop0_168_rule()
32528     int _start_mark = p->mark;  in _loop0_168_rule()
32531         p->error_indicator = 1;  in _loop0_168_rule()
32533         p->level--;  in _loop0_168_rule()
32539         if (p->error_indicator) {  in _loop0_168_rule()
32540             p->level--;  in _loop0_168_rule()
32543 …D(fprintf(stderr, "%*c> _loop0_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression …  in _loop0_168_rule()
32547             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_168_rule()
32549             (elem = _tmp_200_rule(p))  // expression ['as' star_target]  in _loop0_168_rule()
32554                 p->error_indicator = 1;  in _loop0_168_rule()
32556                 p->level--;  in _loop0_168_rule()
32563                     p->error_indicator = 1;  in _loop0_168_rule()
32565                     p->level--;  in _loop0_168_rule()
32571             _mark = p->mark;  in _loop0_168_rule()
32573         p->mark = _mark;  in _loop0_168_rule()
32574         D(fprintf(stderr, "%*c%s _loop0_168[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_168_rule()
32575 …      p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])"));  in _loop0_168_rule()
32577     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_168_rule()
32580         p->error_indicator = 1;  in _loop0_168_rule()
32582         p->level--;  in _loop0_168_rule()
32587     _PyPegen_insert_memo(p, _start_mark, _loop0_168_type, _seq);  in _loop0_168_rule()
32588     p->level--;  in _loop0_168_rule()
32594 _gather_167_rule(Parser *p)  in _gather_167_rule()  argument
32596     if (p->level++ == MAXSTACK) {  in _gather_167_rule()
32597         p->error_indicator = 1;  in _gather_167_rule()
32600     if (p->error_indicator) {  in _gather_167_rule()
32601         p->level--;  in _gather_167_rule()
32605     int _mark = p->mark;  in _gather_167_rule()
32607         if (p->error_indicator) {  in _gather_167_rule()
32608             p->level--;  in _gather_167_rule()
32611 …D(fprintf(stderr, "%*c> _gather_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['a…  in _gather_167_rule()
32615             (elem = _tmp_200_rule(p))  // expression ['as' star_target]  in _gather_167_rule()
32617             (seq = _loop0_168_rule(p))  // _loop0_168  in _gather_167_rule()
32620 …D(fprintf(stderr, "%*c+ _gather_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(exp…  in _gather_167_rule()
32621             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_167_rule()
32624         p->mark = _mark;  in _gather_167_rule()
32625         D(fprintf(stderr, "%*c%s _gather_167[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_167_rule()
32626 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_168")…  in _gather_167_rule()
32630     p->level--;  in _gather_167_rule()
32636 _loop0_170_rule(Parser *p)  in _loop0_170_rule()  argument
32638     if (p->level++ == MAXSTACK) {  in _loop0_170_rule()
32639         p->error_indicator = 1;  in _loop0_170_rule()
32642     if (p->error_indicator) {  in _loop0_170_rule()
32643         p->level--;  in _loop0_170_rule()
32647     int _mark = p->mark;  in _loop0_170_rule()
32648     int _start_mark = p->mark;  in _loop0_170_rule()
32651         p->error_indicator = 1;  in _loop0_170_rule()
32653         p->level--;  in _loop0_170_rule()
32659         if (p->error_indicator) {  in _loop0_170_rule()
32660             p->level--;  in _loop0_170_rule()
32663 …D(fprintf(stderr, "%*c> _loop0_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions…  in _loop0_170_rule()
32667             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_170_rule()
32669             (elem = _tmp_201_rule(p))  // expressions ['as' star_target]  in _loop0_170_rule()
32674                 p->error_indicator = 1;  in _loop0_170_rule()
32676                 p->level--;  in _loop0_170_rule()
32683                     p->error_indicator = 1;  in _loop0_170_rule()
32685                     p->level--;  in _loop0_170_rule()
32691             _mark = p->mark;  in _loop0_170_rule()
32693         p->mark = _mark;  in _loop0_170_rule()
32694         D(fprintf(stderr, "%*c%s _loop0_170[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_170_rule()
32695 …     p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])"));  in _loop0_170_rule()
32697     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_170_rule()
32700         p->error_indicator = 1;  in _loop0_170_rule()
32702         p->level--;  in _loop0_170_rule()
32707     _PyPegen_insert_memo(p, _start_mark, _loop0_170_type, _seq);  in _loop0_170_rule()
32708     p->level--;  in _loop0_170_rule()
32714 _gather_169_rule(Parser *p)  in _gather_169_rule()  argument
32716     if (p->level++ == MAXSTACK) {  in _gather_169_rule()
32717         p->error_indicator = 1;  in _gather_169_rule()
32720     if (p->error_indicator) {  in _gather_169_rule()
32721         p->level--;  in _gather_169_rule()
32725     int _mark = p->mark;  in _gather_169_rule()
32727         if (p->error_indicator) {  in _gather_169_rule()
32728             p->level--;  in _gather_169_rule()
32731 …D(fprintf(stderr, "%*c> _gather_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['…  in _gather_169_rule()
32735             (elem = _tmp_201_rule(p))  // expressions ['as' star_target]  in _gather_169_rule()
32737             (seq = _loop0_170_rule(p))  // _loop0_170  in _gather_169_rule()
32740 …D(fprintf(stderr, "%*c+ _gather_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(exp…  in _gather_169_rule()
32741             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_169_rule()
32744         p->mark = _mark;  in _gather_169_rule()
32745         D(fprintf(stderr, "%*c%s _gather_169[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_169_rule()
32746 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_170"…  in _gather_169_rule()
32750     p->level--;  in _gather_169_rule()
32756 _tmp_171_rule(Parser *p)  in _tmp_171_rule()  argument
32758     if (p->level++ == MAXSTACK) {  in _tmp_171_rule()
32759         p->error_indicator = 1;  in _tmp_171_rule()
32762     if (p->error_indicator) {  in _tmp_171_rule()
32763         p->level--;  in _tmp_171_rule()
32767     int _mark = p->mark;  in _tmp_171_rule()
32769         if (p->error_indicator) {  in _tmp_171_rule()
32770             p->level--;  in _tmp_171_rule()
32773         D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'"));  in _tmp_171_rule()
32776             (_keyword = _PyPegen_expect_token(p, 521))  // token='except'  in _tmp_171_rule()
32779 …D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except…  in _tmp_171_rule()
32783         p->mark = _mark;  in _tmp_171_rule()
32784         D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_171_rule()
32785                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'"));  in _tmp_171_rule()
32788         if (p->error_indicator) {  in _tmp_171_rule()
32789             p->level--;  in _tmp_171_rule()
32792 …      D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'"));  in _tmp_171_rule()
32795             (_keyword = _PyPegen_expect_token(p, 522))  // token='finally'  in _tmp_171_rule()
32798 …D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finall…  in _tmp_171_rule()
32802         p->mark = _mark;  in _tmp_171_rule()
32803         D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_171_rule()
32804                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'"));  in _tmp_171_rule()
32808     p->level--;  in _tmp_171_rule()
32814 _tmp_172_rule(Parser *p)  in _tmp_172_rule()  argument
32816     if (p->level++ == MAXSTACK) {  in _tmp_172_rule()
32817         p->error_indicator = 1;  in _tmp_172_rule()
32820     if (p->error_indicator) {  in _tmp_172_rule()
32821         p->level--;  in _tmp_172_rule()
32825     int _mark = p->mark;  in _tmp_172_rule()
32827         if (p->error_indicator) {  in _tmp_172_rule()
32828             p->level--;  in _tmp_172_rule()
32831 …      D(fprintf(stderr, "%*c> _tmp_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));  in _tmp_172_rule()
32835             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_172_rule()
32837             (name_var = _PyPegen_name_token(p))  // NAME  in _tmp_172_rule()
32840 …D(fprintf(stderr, "%*c+ _tmp_172[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NA…  in _tmp_172_rule()
32841             _res = _PyPegen_dummy_name(p, _keyword, name_var);  in _tmp_172_rule()
32844         p->mark = _mark;  in _tmp_172_rule()
32845         D(fprintf(stderr, "%*c%s _tmp_172[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_172_rule()
32846                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));  in _tmp_172_rule()
32850     p->level--;  in _tmp_172_rule()
32856 _tmp_173_rule(Parser *p)  in _tmp_173_rule()  argument
32858     if (p->level++ == MAXSTACK) {  in _tmp_173_rule()
32859         p->error_indicator = 1;  in _tmp_173_rule()
32862     if (p->error_indicator) {  in _tmp_173_rule()
32863         p->level--;  in _tmp_173_rule()
32867     int _mark = p->mark;  in _tmp_173_rule()
32869         if (p->error_indicator) {  in _tmp_173_rule()
32870             p->level--;  in _tmp_173_rule()
32873 …      D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));  in _tmp_173_rule()
32877             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_173_rule()
32879             (name_var = _PyPegen_name_token(p))  // NAME  in _tmp_173_rule()
32882 …D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NA…  in _tmp_173_rule()
32883             _res = _PyPegen_dummy_name(p, _keyword, name_var);  in _tmp_173_rule()
32886         p->mark = _mark;  in _tmp_173_rule()
32887         D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_173_rule()
32888                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));  in _tmp_173_rule()
32892     p->level--;  in _tmp_173_rule()
32898 _tmp_174_rule(Parser *p)  in _tmp_174_rule()  argument
32900     if (p->level++ == MAXSTACK) {  in _tmp_174_rule()
32901         p->error_indicator = 1;  in _tmp_174_rule()
32904     if (p->error_indicator) {  in _tmp_174_rule()
32905         p->level--;  in _tmp_174_rule()
32909     int _mark = p->mark;  in _tmp_174_rule()
32911         if (p->error_indicator) {  in _tmp_174_rule()
32912             p->level--;  in _tmp_174_rule()
32915 …      D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));  in _tmp_174_rule()
32919             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_174_rule()
32921             (name_var = _PyPegen_name_token(p))  // NAME  in _tmp_174_rule()
32924 …D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NA…  in _tmp_174_rule()
32925             _res = _PyPegen_dummy_name(p, _keyword, name_var);  in _tmp_174_rule()
32928         p->mark = _mark;  in _tmp_174_rule()
32929         D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_174_rule()
32930                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));  in _tmp_174_rule()
32934     p->level--;  in _tmp_174_rule()
32940 _tmp_175_rule(Parser *p)  in _tmp_175_rule()  argument
32942     if (p->level++ == MAXSTACK) {  in _tmp_175_rule()
32943         p->error_indicator = 1;  in _tmp_175_rule()
32946     if (p->error_indicator) {  in _tmp_175_rule()
32947         p->level--;  in _tmp_175_rule()
32951     int _mark = p->mark;  in _tmp_175_rule()
32953         if (p->error_indicator) {  in _tmp_175_rule()
32954             p->level--;  in _tmp_175_rule()
32957 …D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_pattern…  in _tmp_175_rule()
32961             (positional_patterns_var = positional_patterns_rule(p))  // positional_patterns  in _tmp_175_rule()
32963             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_175_rule()
32966 …D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positio…  in _tmp_175_rule()
32967             _res = _PyPegen_dummy_name(p, positional_patterns_var, _literal);  in _tmp_175_rule()
32970         p->mark = _mark;  in _tmp_175_rule()
32971         D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_175_rule()
32972                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','"));  in _tmp_175_rule()
32976     p->level--;  in _tmp_175_rule()
32980 // _tmp_176: '->' expression
32982 _tmp_176_rule(Parser *p)  in _tmp_176_rule()  argument
32984     if (p->level++ == MAXSTACK) {  in _tmp_176_rule()
32985         p->error_indicator = 1;  in _tmp_176_rule()
32988     if (p->error_indicator) {  in _tmp_176_rule()
32989         p->level--;  in _tmp_176_rule()
32993     int _mark = p->mark;  in _tmp_176_rule()
32994     { // '->' expression  in _tmp_176_rule()
32995         if (p->error_indicator) {  in _tmp_176_rule()
32996             p->level--;  in _tmp_176_rule()
32999 …D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));  in _tmp_176_rule()
33003             (_literal = _PyPegen_expect_token(p, 51))  // token='->'  in _tmp_176_rule()
33005             (expression_var = expression_rule(p))  // expression  in _tmp_176_rule()
33008 …D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' ex…  in _tmp_176_rule()
33009             _res = _PyPegen_dummy_name(p, _literal, expression_var);  in _tmp_176_rule()
33012         p->mark = _mark;  in _tmp_176_rule()
33013         D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_176_rule()
33014                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression"));  in _tmp_176_rule()
33018     p->level--;  in _tmp_176_rule()
33024 _tmp_177_rule(Parser *p)  in _tmp_177_rule()  argument
33026     if (p->level++ == MAXSTACK) {  in _tmp_177_rule()
33027         p->error_indicator = 1;  in _tmp_177_rule()
33030     if (p->error_indicator) {  in _tmp_177_rule()
33031         p->level--;  in _tmp_177_rule()
33035     int _mark = p->mark;  in _tmp_177_rule()
33037         if (p->error_indicator) {  in _tmp_177_rule()
33038             p->level--;  in _tmp_177_rule()
33041 …D(fprintf(stderr, "%*c> _tmp_177[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'…  in _tmp_177_rule()
33047             (_literal = _PyPegen_expect_token(p, 7))  // token='('  in _tmp_177_rule()
33049             (_opt_var = arguments_rule(p), !p->error_indicator)  // arguments?  in _tmp_177_rule()
33051             (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'  in _tmp_177_rule()
33054 …D(fprintf(stderr, "%*c+ _tmp_177[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arg…  in _tmp_177_rule()
33055             _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1);  in _tmp_177_rule()
33058         p->mark = _mark;  in _tmp_177_rule()
33059         D(fprintf(stderr, "%*c%s _tmp_177[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_177_rule()
33060                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'"));  in _tmp_177_rule()
33064     p->level--;  in _tmp_177_rule()
33070 _loop0_179_rule(Parser *p)  in _loop0_179_rule()  argument
33072     if (p->level++ == MAXSTACK) {  in _loop0_179_rule()
33073         p->error_indicator = 1;  in _loop0_179_rule()
33076     if (p->error_indicator) {  in _loop0_179_rule()
33077         p->level--;  in _loop0_179_rule()
33081     int _mark = p->mark;  in _loop0_179_rule()
33082     int _start_mark = p->mark;  in _loop0_179_rule()
33085         p->error_indicator = 1;  in _loop0_179_rule()
33087         p->level--;  in _loop0_179_rule()
33093         if (p->error_indicator) {  in _loop0_179_rule()
33094             p->level--;  in _loop0_179_rule()
33097 …D(fprintf(stderr, "%*c> _loop0_179[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starr…  in _loop0_179_rule()
33101             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _loop0_179_rule()
33103             (elem = double_starred_kvpair_rule(p))  // double_starred_kvpair  in _loop0_179_rule()
33108                 p->error_indicator = 1;  in _loop0_179_rule()
33110                 p->level--;  in _loop0_179_rule()
33117                     p->error_indicator = 1;  in _loop0_179_rule()
33119                     p->level--;  in _loop0_179_rule()
33125             _mark = p->mark;  in _loop0_179_rule()
33127         p->mark = _mark;  in _loop0_179_rule()
33128         D(fprintf(stderr, "%*c%s _loop0_179[%d-%d]: %s failed!\n", p->level, ' ',  in _loop0_179_rule()
33129 …                p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair"));  in _loop0_179_rule()
33131     asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);  in _loop0_179_rule()
33134         p->error_indicator = 1;  in _loop0_179_rule()
33136         p->level--;  in _loop0_179_rule()
33141     _PyPegen_insert_memo(p, _start_mark, _loop0_179_type, _seq);  in _loop0_179_rule()
33142     p->level--;  in _loop0_179_rule()
33148 _gather_178_rule(Parser *p)  in _gather_178_rule()  argument
33150     if (p->level++ == MAXSTACK) {  in _gather_178_rule()
33151         p->error_indicator = 1;  in _gather_178_rule()
33154     if (p->error_indicator) {  in _gather_178_rule()
33155         p->level--;  in _gather_178_rule()
33159     int _mark = p->mark;  in _gather_178_rule()
33161         if (p->error_indicator) {  in _gather_178_rule()
33162             p->level--;  in _gather_178_rule()
33165 …D(fprintf(stderr, "%*c> _gather_178[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_…  in _gather_178_rule()
33169             (elem = double_starred_kvpair_rule(p))  // double_starred_kvpair  in _gather_178_rule()
33171             (seq = _loop0_179_rule(p))  // _loop0_179  in _gather_178_rule()
33174 …D(fprintf(stderr, "%*c+ _gather_178[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "doub…  in _gather_178_rule()
33175             _res = _PyPegen_seq_insert_in_front(p, elem, seq);  in _gather_178_rule()
33178         p->mark = _mark;  in _gather_178_rule()
33179         D(fprintf(stderr, "%*c%s _gather_178[%d-%d]: %s failed!\n", p->level, ' ',  in _gather_178_rule()
33180 …         p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_179"));  in _gather_178_rule()
33184     p->level--;  in _gather_178_rule()
33190 _tmp_180_rule(Parser *p)  in _tmp_180_rule()  argument
33192     if (p->level++ == MAXSTACK) {  in _tmp_180_rule()
33193         p->error_indicator = 1;  in _tmp_180_rule()
33196     if (p->error_indicator) {  in _tmp_180_rule()
33197         p->level--;  in _tmp_180_rule()
33201     int _mark = p->mark;  in _tmp_180_rule()
33203         if (p->error_indicator) {  in _tmp_180_rule()
33204             p->level--;  in _tmp_180_rule()
33207         D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));  in _tmp_180_rule()
33210             (_literal = _PyPegen_expect_token(p, 26))  // token='}'  in _tmp_180_rule()
33213 … D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'"));  in _tmp_180_rule()
33217         p->mark = _mark;  in _tmp_180_rule()
33218         D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_180_rule()
33219                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));  in _tmp_180_rule()
33222         if (p->error_indicator) {  in _tmp_180_rule()
33223             p->level--;  in _tmp_180_rule()
33226         D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));  in _tmp_180_rule()
33229             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_180_rule()
33232 … D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));  in _tmp_180_rule()
33236         p->mark = _mark;  in _tmp_180_rule()
33237         D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_180_rule()
33238                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));  in _tmp_180_rule()
33242     p->level--;  in _tmp_180_rule()
33248 _tmp_181_rule(Parser *p)  in _tmp_181_rule()  argument
33250     if (p->level++ == MAXSTACK) {  in _tmp_181_rule()
33251         p->error_indicator = 1;  in _tmp_181_rule()
33254     if (p->error_indicator) {  in _tmp_181_rule()
33255         p->level--;  in _tmp_181_rule()
33259     int _mark = p->mark;  in _tmp_181_rule()
33261         if (p->error_indicator) {  in _tmp_181_rule()
33262             p->level--;  in _tmp_181_rule()
33265 …D(fprintf(stderr, "%*c> _tmp_181[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")…  in _tmp_181_rule()
33269             (z = star_targets_rule(p))  // star_targets  in _tmp_181_rule()
33271             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_181_rule()
33274 …D(fprintf(stderr, "%*c+ _tmp_181[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_ta…  in _tmp_181_rule()
33277                 p->error_indicator = 1;  in _tmp_181_rule()
33278                 p->level--;  in _tmp_181_rule()
33283         p->mark = _mark;  in _tmp_181_rule()
33284         D(fprintf(stderr, "%*c%s _tmp_181[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_181_rule()
33285                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='"));  in _tmp_181_rule()
33289     p->level--;  in _tmp_181_rule()
33295 _tmp_182_rule(Parser *p)  in _tmp_182_rule()  argument
33297     if (p->level++ == MAXSTACK) {  in _tmp_182_rule()
33298         p->error_indicator = 1;  in _tmp_182_rule()
33301     if (p->error_indicator) {  in _tmp_182_rule()
33302         p->level--;  in _tmp_182_rule()
33306     int _mark = p->mark;  in _tmp_182_rule()
33308         if (p->error_indicator) {  in _tmp_182_rule()
33309             p->level--;  in _tmp_182_rule()
33312         D(fprintf(stderr, "%*c> _tmp_182[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));  in _tmp_182_rule()
33315             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in _tmp_182_rule()
33318 … D(fprintf(stderr, "%*c+ _tmp_182[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));  in _tmp_182_rule()
33322         p->mark = _mark;  in _tmp_182_rule()
33323         D(fprintf(stderr, "%*c%s _tmp_182[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_182_rule()
33324                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));  in _tmp_182_rule()
33327         if (p->error_indicator) {  in _tmp_182_rule()
33328             p->level--;  in _tmp_182_rule()
33331         D(fprintf(stderr, "%*c> _tmp_182[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));  in _tmp_182_rule()
33334             (_literal = _PyPegen_expect_token(p, 52))  // token='...'  in _tmp_182_rule()
33337 …D(fprintf(stderr, "%*c+ _tmp_182[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")…  in _tmp_182_rule()
33341         p->mark = _mark;  in _tmp_182_rule()
33342         D(fprintf(stderr, "%*c%s _tmp_182[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_182_rule()
33343                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));  in _tmp_182_rule()
33347     p->level--;  in _tmp_182_rule()
33353 _tmp_183_rule(Parser *p)  in _tmp_183_rule()  argument
33355     if (p->level++ == MAXSTACK) {  in _tmp_183_rule()
33356         p->error_indicator = 1;  in _tmp_183_rule()
33359     if (p->error_indicator) {  in _tmp_183_rule()
33360         p->level--;  in _tmp_183_rule()
33364     int _mark = p->mark;  in _tmp_183_rule()
33366         if (p->error_indicator) {  in _tmp_183_rule()
33367             p->level--;  in _tmp_183_rule()
33370         D(fprintf(stderr, "%*c> _tmp_183[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));  in _tmp_183_rule()
33373             (_literal = _PyPegen_expect_token(p, 23))  // token='.'  in _tmp_183_rule()
33376 … D(fprintf(stderr, "%*c+ _tmp_183[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));  in _tmp_183_rule()
33380         p->mark = _mark;  in _tmp_183_rule()
33381         D(fprintf(stderr, "%*c%s _tmp_183[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_183_rule()
33382                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));  in _tmp_183_rule()
33385         if (p->error_indicator) {  in _tmp_183_rule()
33386             p->level--;  in _tmp_183_rule()
33389         D(fprintf(stderr, "%*c> _tmp_183[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));  in _tmp_183_rule()
33392             (_literal = _PyPegen_expect_token(p, 52))  // token='...'  in _tmp_183_rule()
33395 …D(fprintf(stderr, "%*c+ _tmp_183[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")…  in _tmp_183_rule()
33399         p->mark = _mark;  in _tmp_183_rule()
33400         D(fprintf(stderr, "%*c%s _tmp_183[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_183_rule()
33401                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));  in _tmp_183_rule()
33405     p->level--;  in _tmp_183_rule()
33411 _tmp_184_rule(Parser *p)  in _tmp_184_rule()  argument
33413     if (p->level++ == MAXSTACK) {  in _tmp_184_rule()
33414         p->error_indicator = 1;  in _tmp_184_rule()
33417     if (p->error_indicator) {  in _tmp_184_rule()
33418         p->level--;  in _tmp_184_rule()
33422     int _mark = p->mark;  in _tmp_184_rule()
33424         if (p->error_indicator) {  in _tmp_184_rule()
33425             p->level--;  in _tmp_184_rule()
33428 …D(fprintf(stderr, "%*c> _tmp_184[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expressi…  in _tmp_184_rule()
33433             (_literal = _PyPegen_expect_token(p, 49))  // token='@'  in _tmp_184_rule()
33435             (f = named_expression_rule(p))  // named_expression  in _tmp_184_rule()
33437             (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'  in _tmp_184_rule()
33440 …D(fprintf(stderr, "%*c+ _tmp_184[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' nam…  in _tmp_184_rule()
33443                 p->error_indicator = 1;  in _tmp_184_rule()
33444                 p->level--;  in _tmp_184_rule()
33449         p->mark = _mark;  in _tmp_184_rule()
33450         D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_184_rule()
33451 …             p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@' named_expression NEWLINE"));  in _tmp_184_rule()
33455     p->level--;  in _tmp_184_rule()
33461 _tmp_185_rule(Parser *p)  in _tmp_185_rule()  argument
33463     if (p->level++ == MAXSTACK) {  in _tmp_185_rule()
33464         p->error_indicator = 1;  in _tmp_185_rule()
33467     if (p->error_indicator) {  in _tmp_185_rule()
33468         p->level--;  in _tmp_185_rule()
33472     int _mark = p->mark;  in _tmp_185_rule()
33474         if (p->error_indicator) {  in _tmp_185_rule()
33475             p->level--;  in _tmp_185_rule()
33478 …D(fprintf(stderr, "%*c> _tmp_185[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expressio…  in _tmp_185_rule()
33482             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_185_rule()
33484             (c = star_expression_rule(p))  // star_expression  in _tmp_185_rule()
33487 …D(fprintf(stderr, "%*c+ _tmp_185[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' sta…  in _tmp_185_rule()
33490                 p->error_indicator = 1;  in _tmp_185_rule()
33491                 p->level--;  in _tmp_185_rule()
33496         p->mark = _mark;  in _tmp_185_rule()
33497         D(fprintf(stderr, "%*c%s _tmp_185[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_185_rule()
33498                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_expression"));  in _tmp_185_rule()
33502     p->level--;  in _tmp_185_rule()
33508 _tmp_186_rule(Parser *p)  in _tmp_186_rule()  argument
33510     if (p->level++ == MAXSTACK) {  in _tmp_186_rule()
33511         p->error_indicator = 1;  in _tmp_186_rule()
33514     if (p->error_indicator) {  in _tmp_186_rule()
33515         p->level--;  in _tmp_186_rule()
33519     int _mark = p->mark;  in _tmp_186_rule()
33521         if (p->error_indicator) {  in _tmp_186_rule()
33522             p->level--;  in _tmp_186_rule()
33525 … D(fprintf(stderr, "%*c> _tmp_186[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));  in _tmp_186_rule()
33529             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_186_rule()
33531             (c = expression_rule(p))  // expression  in _tmp_186_rule()
33534 …D(fprintf(stderr, "%*c+ _tmp_186[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' exp…  in _tmp_186_rule()
33537                 p->error_indicator = 1;  in _tmp_186_rule()
33538                 p->level--;  in _tmp_186_rule()
33543         p->mark = _mark;  in _tmp_186_rule()
33544         D(fprintf(stderr, "%*c%s _tmp_186[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_186_rule()
33545                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));  in _tmp_186_rule()
33549     p->level--;  in _tmp_186_rule()
33555 _tmp_187_rule(Parser *p)  in _tmp_187_rule()  argument
33557     if (p->level++ == MAXSTACK) {  in _tmp_187_rule()
33558         p->error_indicator = 1;  in _tmp_187_rule()
33561     if (p->error_indicator) {  in _tmp_187_rule()
33562         p->level--;  in _tmp_187_rule()
33566     int _mark = p->mark;  in _tmp_187_rule()
33568         if (p->error_indicator) {  in _tmp_187_rule()
33569             p->level--;  in _tmp_187_rule()
33572 …D(fprintf(stderr, "%*c> _tmp_187[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")…  in _tmp_187_rule()
33576             (_keyword = _PyPegen_expect_token(p, 531))  // token='or'  in _tmp_187_rule()
33578             (c = conjunction_rule(p))  // conjunction  in _tmp_187_rule()
33581 …D(fprintf(stderr, "%*c+ _tmp_187[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' co…  in _tmp_187_rule()
33584                 p->error_indicator = 1;  in _tmp_187_rule()
33585                 p->level--;  in _tmp_187_rule()
33590         p->mark = _mark;  in _tmp_187_rule()
33591         D(fprintf(stderr, "%*c%s _tmp_187[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_187_rule()
33592                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'or' conjunction"));  in _tmp_187_rule()
33596     p->level--;  in _tmp_187_rule()
33602 _tmp_188_rule(Parser *p)  in _tmp_188_rule()  argument
33604     if (p->level++ == MAXSTACK) {  in _tmp_188_rule()
33605         p->error_indicator = 1;  in _tmp_188_rule()
33608     if (p->error_indicator) {  in _tmp_188_rule()
33609         p->level--;  in _tmp_188_rule()
33613     int _mark = p->mark;  in _tmp_188_rule()
33615         if (p->error_indicator) {  in _tmp_188_rule()
33616             p->level--;  in _tmp_188_rule()
33619 …D(fprintf(stderr, "%*c> _tmp_188[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion"));  in _tmp_188_rule()
33623             (_keyword = _PyPegen_expect_token(p, 532))  // token='and'  in _tmp_188_rule()
33625             (c = inversion_rule(p))  // inversion  in _tmp_188_rule()
33628 …D(fprintf(stderr, "%*c+ _tmp_188[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' i…  in _tmp_188_rule()
33631                 p->error_indicator = 1;  in _tmp_188_rule()
33632                 p->level--;  in _tmp_188_rule()
33637         p->mark = _mark;  in _tmp_188_rule()
33638         D(fprintf(stderr, "%*c%s _tmp_188[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_188_rule()
33639                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'and' inversion"));  in _tmp_188_rule()
33643     p->level--;  in _tmp_188_rule()
33649 _tmp_189_rule(Parser *p)  in _tmp_189_rule()  argument
33651     if (p->level++ == MAXSTACK) {  in _tmp_189_rule()
33652         p->error_indicator = 1;  in _tmp_189_rule()
33655     if (p->error_indicator) {  in _tmp_189_rule()
33656         p->level--;  in _tmp_189_rule()
33660     int _mark = p->mark;  in _tmp_189_rule()
33662         if (p->error_indicator) {  in _tmp_189_rule()
33663             p->level--;  in _tmp_189_rule()
33666 …D(fprintf(stderr, "%*c> _tmp_189[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")…  in _tmp_189_rule()
33670             (_keyword = _PyPegen_expect_token(p, 510))  // token='if'  in _tmp_189_rule()
33672             (z = disjunction_rule(p))  // disjunction  in _tmp_189_rule()
33675 …D(fprintf(stderr, "%*c+ _tmp_189[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' di…  in _tmp_189_rule()
33678                 p->error_indicator = 1;  in _tmp_189_rule()
33679                 p->level--;  in _tmp_189_rule()
33684         p->mark = _mark;  in _tmp_189_rule()
33685         D(fprintf(stderr, "%*c%s _tmp_189[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_189_rule()
33686                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction"));  in _tmp_189_rule()
33690     p->level--;  in _tmp_189_rule()
33696 _tmp_190_rule(Parser *p)  in _tmp_190_rule()  argument
33698     if (p->level++ == MAXSTACK) {  in _tmp_190_rule()
33699         p->error_indicator = 1;  in _tmp_190_rule()
33702     if (p->error_indicator) {  in _tmp_190_rule()
33703         p->level--;  in _tmp_190_rule()
33707     int _mark = p->mark;  in _tmp_190_rule()
33709         if (p->error_indicator) {  in _tmp_190_rule()
33710             p->level--;  in _tmp_190_rule()
33713 …D(fprintf(stderr, "%*c> _tmp_190[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")…  in _tmp_190_rule()
33717             (_keyword = _PyPegen_expect_token(p, 510))  // token='if'  in _tmp_190_rule()
33719             (z = disjunction_rule(p))  // disjunction  in _tmp_190_rule()
33722 …D(fprintf(stderr, "%*c+ _tmp_190[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' di…  in _tmp_190_rule()
33725                 p->error_indicator = 1;  in _tmp_190_rule()
33726                 p->level--;  in _tmp_190_rule()
33731         p->mark = _mark;  in _tmp_190_rule()
33732         D(fprintf(stderr, "%*c%s _tmp_190[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_190_rule()
33733                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction"));  in _tmp_190_rule()
33737     p->level--;  in _tmp_190_rule()
33743 _tmp_191_rule(Parser *p)  in _tmp_191_rule()  argument
33745     if (p->level++ == MAXSTACK) {  in _tmp_191_rule()
33746         p->error_indicator = 1;  in _tmp_191_rule()
33749     if (p->error_indicator) {  in _tmp_191_rule()
33750         p->level--;  in _tmp_191_rule()
33754     int _mark = p->mark;  in _tmp_191_rule()
33756         if (p->error_indicator) {  in _tmp_191_rule()
33757             p->level--;  in _tmp_191_rule()
33760 …D(fprintf(stderr, "%*c> _tmp_191[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression…  in _tmp_191_rule()
33763             (starred_expression_var = starred_expression_rule(p))  // starred_expression  in _tmp_191_rule()
33766 …D(fprintf(stderr, "%*c+ _tmp_191[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred…  in _tmp_191_rule()
33770         p->mark = _mark;  in _tmp_191_rule()
33771         D(fprintf(stderr, "%*c%s _tmp_191[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_191_rule()
33772                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));  in _tmp_191_rule()
33775         if (p->error_indicator) {  in _tmp_191_rule()
33776             p->level--;  in _tmp_191_rule()
33779 …D(fprintf(stderr, "%*c> _tmp_191[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expres…  in _tmp_191_rule()
33782             (_tmp_202_var = _tmp_202_rule(p))  // assignment_expression | expression !':='  in _tmp_191_rule()
33784             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)  // token='='  in _tmp_191_rule()
33787 …D(fprintf(stderr, "%*c+ _tmp_191[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assign…  in _tmp_191_rule()
33791         p->mark = _mark;  in _tmp_191_rule()
33792         D(fprintf(stderr, "%*c%s _tmp_191[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_191_rule()
33793 …p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !…  in _tmp_191_rule()
33797     p->level--;  in _tmp_191_rule()
33803 _tmp_192_rule(Parser *p)  in _tmp_192_rule()  argument
33805     if (p->level++ == MAXSTACK) {  in _tmp_192_rule()
33806         p->error_indicator = 1;  in _tmp_192_rule()
33809     if (p->error_indicator) {  in _tmp_192_rule()
33810         p->level--;  in _tmp_192_rule()
33814     int _mark = p->mark;  in _tmp_192_rule()
33816         if (p->error_indicator) {  in _tmp_192_rule()
33817             p->level--;  in _tmp_192_rule()
33820 …D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));  in _tmp_192_rule()
33824             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_192_rule()
33826             (c = star_target_rule(p))  // star_target  in _tmp_192_rule()
33829 …D(fprintf(stderr, "%*c+ _tmp_192[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' sta…  in _tmp_192_rule()
33832                 p->error_indicator = 1;  in _tmp_192_rule()
33833                 p->level--;  in _tmp_192_rule()
33838         p->mark = _mark;  in _tmp_192_rule()
33839         D(fprintf(stderr, "%*c%s _tmp_192[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_192_rule()
33840                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target"));  in _tmp_192_rule()
33844     p->level--;  in _tmp_192_rule()
33850 _tmp_193_rule(Parser *p)  in _tmp_193_rule()  argument
33852     if (p->level++ == MAXSTACK) {  in _tmp_193_rule()
33853         p->error_indicator = 1;  in _tmp_193_rule()
33856     if (p->error_indicator) {  in _tmp_193_rule()
33857         p->level--;  in _tmp_193_rule()
33861     int _mark = p->mark;  in _tmp_193_rule()
33863         if (p->error_indicator) {  in _tmp_193_rule()
33864             p->level--;  in _tmp_193_rule()
33867 …D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));  in _tmp_193_rule()
33871             (_literal = _PyPegen_expect_token(p, 12))  // token=','  in _tmp_193_rule()
33873             (c = star_target_rule(p))  // star_target  in _tmp_193_rule()
33876 …D(fprintf(stderr, "%*c+ _tmp_193[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' sta…  in _tmp_193_rule()
33879                 p->error_indicator = 1;  in _tmp_193_rule()
33880                 p->level--;  in _tmp_193_rule()
33885         p->mark = _mark;  in _tmp_193_rule()
33886         D(fprintf(stderr, "%*c%s _tmp_193[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_193_rule()
33887                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target"));  in _tmp_193_rule()
33891     p->level--;  in _tmp_193_rule()
33897 _tmp_194_rule(Parser *p)  in _tmp_194_rule()  argument
33899     if (p->level++ == MAXSTACK) {  in _tmp_194_rule()
33900         p->error_indicator = 1;  in _tmp_194_rule()
33903     if (p->error_indicator) {  in _tmp_194_rule()
33904         p->level--;  in _tmp_194_rule()
33908     int _mark = p->mark;  in _tmp_194_rule()
33910         if (p->error_indicator) {  in _tmp_194_rule()
33911             p->level--;  in _tmp_194_rule()
33914 …D(fprintf(stderr, "%*c> _tmp_194[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")…  in _tmp_194_rule()
33918             (star_targets_var = star_targets_rule(p))  // star_targets  in _tmp_194_rule()
33920             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_194_rule()
33923 …D(fprintf(stderr, "%*c+ _tmp_194[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_ta…  in _tmp_194_rule()
33924             _res = _PyPegen_dummy_name(p, star_targets_var, _literal);  in _tmp_194_rule()
33927         p->mark = _mark;  in _tmp_194_rule()
33928         D(fprintf(stderr, "%*c%s _tmp_194[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_194_rule()
33929                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='"));  in _tmp_194_rule()
33933     p->level--;  in _tmp_194_rule()
33939 _tmp_195_rule(Parser *p)  in _tmp_195_rule()  argument
33941     if (p->level++ == MAXSTACK) {  in _tmp_195_rule()
33942         p->error_indicator = 1;  in _tmp_195_rule()
33945     if (p->error_indicator) {  in _tmp_195_rule()
33946         p->level--;  in _tmp_195_rule()
33950     int _mark = p->mark;  in _tmp_195_rule()
33952         if (p->error_indicator) {  in _tmp_195_rule()
33953             p->level--;  in _tmp_195_rule()
33956 …D(fprintf(stderr, "%*c> _tmp_195[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")…  in _tmp_195_rule()
33960             (star_targets_var = star_targets_rule(p))  // star_targets  in _tmp_195_rule()
33962             (_literal = _PyPegen_expect_token(p, 22))  // token='='  in _tmp_195_rule()
33965 …D(fprintf(stderr, "%*c+ _tmp_195[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_ta…  in _tmp_195_rule()
33966             _res = _PyPegen_dummy_name(p, star_targets_var, _literal);  in _tmp_195_rule()
33969         p->mark = _mark;  in _tmp_195_rule()
33970         D(fprintf(stderr, "%*c%s _tmp_195[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_195_rule()
33971                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='"));  in _tmp_195_rule()
33975     p->level--;  in _tmp_195_rule()
33981 _tmp_196_rule(Parser *p)  in _tmp_196_rule()  argument
33983     if (p->level++ == MAXSTACK) {  in _tmp_196_rule()
33984         p->error_indicator = 1;  in _tmp_196_rule()
33987     if (p->error_indicator) {  in _tmp_196_rule()
33988         p->level--;  in _tmp_196_rule()
33992     int _mark = p->mark;  in _tmp_196_rule()
33994         if (p->error_indicator) {  in _tmp_196_rule()
33995             p->level--;  in _tmp_196_rule()
33998         D(fprintf(stderr, "%*c> _tmp_196[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));  in _tmp_196_rule()
34001             (_literal = _PyPegen_expect_token(p, 8))  // token=')'  in _tmp_196_rule()
34004 … D(fprintf(stderr, "%*c+ _tmp_196[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));  in _tmp_196_rule()
34008         p->mark = _mark;  in _tmp_196_rule()
34009         D(fprintf(stderr, "%*c%s _tmp_196[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_196_rule()
34010                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));  in _tmp_196_rule()
34013         if (p->error_indicator) {  in _tmp_196_rule()
34014             p->level--;  in _tmp_196_rule()
34017         D(fprintf(stderr, "%*c> _tmp_196[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));  in _tmp_196_rule()
34020             (_literal = _PyPegen_expect_token(p, 35))  // token='**'  in _tmp_196_rule()
34023 …D(fprintf(stderr, "%*c+ _tmp_196[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'"));  in _tmp_196_rule()
34027         p->mark = _mark;  in _tmp_196_rule()
34028         D(fprintf(stderr, "%*c%s _tmp_196[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_196_rule()
34029                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));  in _tmp_196_rule()
34033     p->level--;  in _tmp_196_rule()
34039 _tmp_197_rule(Parser *p)  in _tmp_197_rule()  argument
34041     if (p->level++ == MAXSTACK) {  in _tmp_197_rule()
34042         p->error_indicator = 1;  in _tmp_197_rule()
34045     if (p->error_indicator) {  in _tmp_197_rule()
34046         p->level--;  in _tmp_197_rule()
34050     int _mark = p->mark;  in _tmp_197_rule()
34052         if (p->error_indicator) {  in _tmp_197_rule()
34053             p->level--;  in _tmp_197_rule()
34056         D(fprintf(stderr, "%*c> _tmp_197[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_197_rule()
34059             (_literal = _PyPegen_expect_token(p, 11))  // token=':'  in _tmp_197_rule()
34062 … D(fprintf(stderr, "%*c+ _tmp_197[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));  in _tmp_197_rule()
34066         p->mark = _mark;  in _tmp_197_rule()
34067         D(fprintf(stderr, "%*c%s _tmp_197[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_197_rule()
34068                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));  in _tmp_197_rule()
34071         if (p->error_indicator) {  in _tmp_197_rule()
34072             p->level--;  in _tmp_197_rule()
34075         D(fprintf(stderr, "%*c> _tmp_197[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));  in _tmp_197_rule()
34078             (_literal = _PyPegen_expect_token(p, 35))  // token='**'  in _tmp_197_rule()
34081 …D(fprintf(stderr, "%*c+ _tmp_197[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'"));  in _tmp_197_rule()
34085         p->mark = _mark;  in _tmp_197_rule()
34086         D(fprintf(stderr, "%*c%s _tmp_197[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_197_rule()
34087                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));  in _tmp_197_rule()
34091     p->level--;  in _tmp_197_rule()
34097 _tmp_198_rule(Parser *p)  in _tmp_198_rule()  argument
34099     if (p->level++ == MAXSTACK) {  in _tmp_198_rule()
34100         p->error_indicator = 1;  in _tmp_198_rule()
34103     if (p->error_indicator) {  in _tmp_198_rule()
34104         p->level--;  in _tmp_198_rule()
34108     int _mark = p->mark;  in _tmp_198_rule()
34110         if (p->error_indicator) {  in _tmp_198_rule()
34111             p->level--;  in _tmp_198_rule()
34114 …D(fprintf(stderr, "%*c> _tmp_198[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' s…  in _tmp_198_rule()
34119             (expression_var = expression_rule(p))  // expression  in _tmp_198_rule()
34121             (_opt_var = _tmp_203_rule(p), !p->error_indicator)  // ['as' star_target]  in _tmp_198_rule()
34124 …D(fprintf(stderr, "%*c+ _tmp_198[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express…  in _tmp_198_rule()
34125             _res = _PyPegen_dummy_name(p, expression_var, _opt_var);  in _tmp_198_rule()
34128         p->mark = _mark;  in _tmp_198_rule()
34129         D(fprintf(stderr, "%*c%s _tmp_198[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_198_rule()
34130 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]"));  in _tmp_198_rule()
34134     p->level--;  in _tmp_198_rule()
34140 _tmp_199_rule(Parser *p)  in _tmp_199_rule()  argument
34142     if (p->level++ == MAXSTACK) {  in _tmp_199_rule()
34143         p->error_indicator = 1;  in _tmp_199_rule()
34146     if (p->error_indicator) {  in _tmp_199_rule()
34147         p->level--;  in _tmp_199_rule()
34151     int _mark = p->mark;  in _tmp_199_rule()
34153         if (p->error_indicator) {  in _tmp_199_rule()
34154             p->level--;  in _tmp_199_rule()
34157 …D(fprintf(stderr, "%*c> _tmp_199[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' …  in _tmp_199_rule()
34162             (expressions_var = expressions_rule(p))  // expressions  in _tmp_199_rule()
34164             (_opt_var = _tmp_204_rule(p), !p->error_indicator)  // ['as' star_target]  in _tmp_199_rule()
34167 …D(fprintf(stderr, "%*c+ _tmp_199[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express…  in _tmp_199_rule()
34168             _res = _PyPegen_dummy_name(p, expressions_var, _opt_var);  in _tmp_199_rule()
34171         p->mark = _mark;  in _tmp_199_rule()
34172         D(fprintf(stderr, "%*c%s _tmp_199[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_199_rule()
34173 …           p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]"));  in _tmp_199_rule()
34177     p->level--;  in _tmp_199_rule()
34183 _tmp_200_rule(Parser *p)  in _tmp_200_rule()  argument
34185     if (p->level++ == MAXSTACK) {  in _tmp_200_rule()
34186         p->error_indicator = 1;  in _tmp_200_rule()
34189     if (p->error_indicator) {  in _tmp_200_rule()
34190         p->level--;  in _tmp_200_rule()
34194     int _mark = p->mark;  in _tmp_200_rule()
34196         if (p->error_indicator) {  in _tmp_200_rule()
34197             p->level--;  in _tmp_200_rule()
34200 …D(fprintf(stderr, "%*c> _tmp_200[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' s…  in _tmp_200_rule()
34205             (expression_var = expression_rule(p))  // expression  in _tmp_200_rule()
34207             (_opt_var = _tmp_205_rule(p), !p->error_indicator)  // ['as' star_target]  in _tmp_200_rule()
34210 …D(fprintf(stderr, "%*c+ _tmp_200[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express…  in _tmp_200_rule()
34211             _res = _PyPegen_dummy_name(p, expression_var, _opt_var);  in _tmp_200_rule()
34214         p->mark = _mark;  in _tmp_200_rule()
34215         D(fprintf(stderr, "%*c%s _tmp_200[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_200_rule()
34216 …            p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]"));  in _tmp_200_rule()
34220     p->level--;  in _tmp_200_rule()
34226 _tmp_201_rule(Parser *p)  in _tmp_201_rule()  argument
34228     if (p->level++ == MAXSTACK) {  in _tmp_201_rule()
34229         p->error_indicator = 1;  in _tmp_201_rule()
34232     if (p->error_indicator) {  in _tmp_201_rule()
34233         p->level--;  in _tmp_201_rule()
34237     int _mark = p->mark;  in _tmp_201_rule()
34239         if (p->error_indicator) {  in _tmp_201_rule()
34240             p->level--;  in _tmp_201_rule()
34243 …D(fprintf(stderr, "%*c> _tmp_201[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' …  in _tmp_201_rule()
34248             (expressions_var = expressions_rule(p))  // expressions  in _tmp_201_rule()
34250             (_opt_var = _tmp_206_rule(p), !p->error_indicator)  // ['as' star_target]  in _tmp_201_rule()
34253 …D(fprintf(stderr, "%*c+ _tmp_201[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express…  in _tmp_201_rule()
34254             _res = _PyPegen_dummy_name(p, expressions_var, _opt_var);  in _tmp_201_rule()
34257         p->mark = _mark;  in _tmp_201_rule()
34258         D(fprintf(stderr, "%*c%s _tmp_201[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_201_rule()
34259 …           p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]"));  in _tmp_201_rule()
34263     p->level--;  in _tmp_201_rule()
34269 _tmp_202_rule(Parser *p)  in _tmp_202_rule()  argument
34271     if (p->level++ == MAXSTACK) {  in _tmp_202_rule()
34272         p->error_indicator = 1;  in _tmp_202_rule()
34275     if (p->error_indicator) {  in _tmp_202_rule()
34276         p->level--;  in _tmp_202_rule()
34280     int _mark = p->mark;  in _tmp_202_rule()
34282         if (p->error_indicator) {  in _tmp_202_rule()
34283             p->level--;  in _tmp_202_rule()
34286 …D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_express…  in _tmp_202_rule()
34289             (assignment_expression_var = assignment_expression_rule(p))  // assignment_expression  in _tmp_202_rule()
34292 …D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignm…  in _tmp_202_rule()
34296         p->mark = _mark;  in _tmp_202_rule()
34297         D(fprintf(stderr, "%*c%s _tmp_202[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_202_rule()
34298                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));  in _tmp_202_rule()
34301         if (p->error_indicator) {  in _tmp_202_rule()
34302             p->level--;  in _tmp_202_rule()
34305 …D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")…  in _tmp_202_rule()
34308             (expression_var = expression_rule(p))  // expression  in _tmp_202_rule()
34310             _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)  // token=':='  in _tmp_202_rule()
34313 …D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "express…  in _tmp_202_rule()
34317         p->mark = _mark;  in _tmp_202_rule()
34318         D(fprintf(stderr, "%*c%s _tmp_202[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_202_rule()
34319                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='"));  in _tmp_202_rule()
34323     p->level--;  in _tmp_202_rule()
34329 _tmp_203_rule(Parser *p)  in _tmp_203_rule()  argument
34331     if (p->level++ == MAXSTACK) {  in _tmp_203_rule()
34332         p->error_indicator = 1;  in _tmp_203_rule()
34335     if (p->error_indicator) {  in _tmp_203_rule()
34336         p->level--;  in _tmp_203_rule()
34340     int _mark = p->mark;  in _tmp_203_rule()
34342         if (p->error_indicator) {  in _tmp_203_rule()
34343             p->level--;  in _tmp_203_rule()
34346 …D(fprintf(stderr, "%*c> _tmp_203[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")…  in _tmp_203_rule()
34350             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_203_rule()
34352             (star_target_var = star_target_rule(p))  // star_target  in _tmp_203_rule()
34355 …D(fprintf(stderr, "%*c+ _tmp_203[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' st…  in _tmp_203_rule()
34356             _res = _PyPegen_dummy_name(p, _keyword, star_target_var);  in _tmp_203_rule()
34359         p->mark = _mark;  in _tmp_203_rule()
34360         D(fprintf(stderr, "%*c%s _tmp_203[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_203_rule()
34361                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target"));  in _tmp_203_rule()
34365     p->level--;  in _tmp_203_rule()
34371 _tmp_204_rule(Parser *p)  in _tmp_204_rule()  argument
34373     if (p->level++ == MAXSTACK) {  in _tmp_204_rule()
34374         p->error_indicator = 1;  in _tmp_204_rule()
34377     if (p->error_indicator) {  in _tmp_204_rule()
34378         p->level--;  in _tmp_204_rule()
34382     int _mark = p->mark;  in _tmp_204_rule()
34384         if (p->error_indicator) {  in _tmp_204_rule()
34385             p->level--;  in _tmp_204_rule()
34388 …D(fprintf(stderr, "%*c> _tmp_204[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")…  in _tmp_204_rule()
34392             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_204_rule()
34394             (star_target_var = star_target_rule(p))  // star_target  in _tmp_204_rule()
34397 …D(fprintf(stderr, "%*c+ _tmp_204[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' st…  in _tmp_204_rule()
34398             _res = _PyPegen_dummy_name(p, _keyword, star_target_var);  in _tmp_204_rule()
34401         p->mark = _mark;  in _tmp_204_rule()
34402         D(fprintf(stderr, "%*c%s _tmp_204[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_204_rule()
34403                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target"));  in _tmp_204_rule()
34407     p->level--;  in _tmp_204_rule()
34413 _tmp_205_rule(Parser *p)  in _tmp_205_rule()  argument
34415     if (p->level++ == MAXSTACK) {  in _tmp_205_rule()
34416         p->error_indicator = 1;  in _tmp_205_rule()
34419     if (p->error_indicator) {  in _tmp_205_rule()
34420         p->level--;  in _tmp_205_rule()
34424     int _mark = p->mark;  in _tmp_205_rule()
34426         if (p->error_indicator) {  in _tmp_205_rule()
34427             p->level--;  in _tmp_205_rule()
34430 …D(fprintf(stderr, "%*c> _tmp_205[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")…  in _tmp_205_rule()
34434             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_205_rule()
34436             (star_target_var = star_target_rule(p))  // star_target  in _tmp_205_rule()
34439 …D(fprintf(stderr, "%*c+ _tmp_205[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' st…  in _tmp_205_rule()
34440             _res = _PyPegen_dummy_name(p, _keyword, star_target_var);  in _tmp_205_rule()
34443         p->mark = _mark;  in _tmp_205_rule()
34444         D(fprintf(stderr, "%*c%s _tmp_205[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_205_rule()
34445                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target"));  in _tmp_205_rule()
34449     p->level--;  in _tmp_205_rule()
34455 _tmp_206_rule(Parser *p)  in _tmp_206_rule()  argument
34457     if (p->level++ == MAXSTACK) {  in _tmp_206_rule()
34458         p->error_indicator = 1;  in _tmp_206_rule()
34461     if (p->error_indicator) {  in _tmp_206_rule()
34462         p->level--;  in _tmp_206_rule()
34466     int _mark = p->mark;  in _tmp_206_rule()
34468         if (p->error_indicator) {  in _tmp_206_rule()
34469             p->level--;  in _tmp_206_rule()
34472 …D(fprintf(stderr, "%*c> _tmp_206[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")…  in _tmp_206_rule()
34476             (_keyword = _PyPegen_expect_token(p, 520))  // token='as'  in _tmp_206_rule()
34478             (star_target_var = star_target_rule(p))  // star_target  in _tmp_206_rule()
34481 …D(fprintf(stderr, "%*c+ _tmp_206[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' st…  in _tmp_206_rule()
34482             _res = _PyPegen_dummy_name(p, _keyword, star_target_var);  in _tmp_206_rule()
34485         p->mark = _mark;  in _tmp_206_rule()
34486         D(fprintf(stderr, "%*c%s _tmp_206[%d-%d]: %s failed!\n", p->level, ' ',  in _tmp_206_rule()
34487                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target"));  in _tmp_206_rule()
34491     p->level--;  in _tmp_206_rule()
34496 _PyPegen_parse(Parser *p)  in _PyPegen_parse()  argument
34499     p->keywords = reserved_keywords;  in _PyPegen_parse()
34500     p->n_keyword_lists = n_keyword_lists;  in _PyPegen_parse()
34501     p->soft_keywords = soft_keywords;  in _PyPegen_parse()
34505     if (p->start_rule == Py_file_input) {  in _PyPegen_parse()
34506         result = file_rule(p);  in _PyPegen_parse()
34507     } else if (p->start_rule == Py_single_input) {  in _PyPegen_parse()
34508         result = interactive_rule(p);  in _PyPegen_parse()
34509     } else if (p->start_rule == Py_eval_input) {  in _PyPegen_parse()
34510         result = eval_rule(p);  in _PyPegen_parse()
34511     } else if (p->start_rule == Py_func_type_input) {  in _PyPegen_parse()
34512         result = func_type_rule(p);  in _PyPegen_parse()
34513     } else if (p->start_rule == Py_fstring_input) {  in _PyPegen_parse()
34514         result = fstring_rule(p);  in _PyPegen_parse()