+
    Bi                        ^ RI t ^ RIt^ RIt^ RIt^ RIt^ RIt^ RIHt ^ RIH	t	 ^ RIH
t
 R t]! 4        ]
P                  ! R4       ]
P                  ! R4      ;_uu_ 4        ^ RIHtHt ^ RIHt ^ RIt^ R	IHtHt ^ RIt^ RIt^ RItRRR4       R
 tR t ! R R]P8                  4      t ! R R]P8                  4      t ! R R]P8                  4      t] R8X  d   ]PB                  ! 4        R# R#   + '       g   i     Lq; i)    N)StringIO)support)
test_toolsc                     \         P                  R 8w  d   R# \        P                  P	                  \        P                  P	                  \
        4      4      p \        P                  P                  V 4      ^ ,          p\        P                  P                  \        P                  ! 4       4      ^ ,          pW8w  d   \        P                  ! RV RV R24      hR# )win32Nz`the current working directory and the Python source code directory have different mount drives (z and ))
sysplatformospathdirname__file__	splitrootgetcwdunittestSkipTest)ROOT
root_drive	cwd_drives      0/usr/lib/python3.14/test/test_generated_cases.pyskip_if_different_mount_drivesr      s    
||w77??277??845D""4(+J!!"))+.q1I {%
|1.
 	
     cases_generator)analyze_forest	StackItem)CWriter)LocalStackc                      \         P                  ^8  d   \        P                  ! 4       # \         P                  ! 4       # )   )r   verbose
contextlibnullcontextcaptured_stderr r   r   handle_stderrr&   +   s,    %%''&&((r   c                     \         P                  ! V R 4      p. pVP                  4       ;p'       d   VP                  V4       K+  V# )ztest.c)parserParser
definitionappend)srcpnodesnodes   &   r   	parse_srcr0   2   s9    c8$AE,,.
 $
 TLr   c                   &   a  ] tR t^:t o R tRtV tR# )TestEffectsc                   \        4       p\        R RR4      ;p\        RRR4      ;p\        RRR4      ;p.p\        R RR4      \        RRR4      \        R	RR4      .p\        P                  ! 4       pVP	                  WG4       VP	                  W74       VP	                  W'4       V F(  pVP                  \        P                  ! V4      4       K*  	  V P                  VP                  P                  4       R
4       V P                  VP                  P                  4       R4       V P                  VP                  P                  4       R4       R# )xN1yopargzzoparg*2bzoparg*4cz-1 - oparg - oparg*20z1 - oparg - oparg*2 + oparg*4)r   r   r   nullpoppushr   	undefinedassertEqualbase_offsetto_cphysical_sp
logical_sp)	selfstackr4   r6   r8   inputsoutputsr<   outs	   &        r   test_effect_sizesTestEffects.test_effect_sizes;   s   3c**A3g..A3i00A
 c4%c4+c4%

 ||~		!		!		!CJJus+, **//13IJ**//137))..02QRr   r%   N)__name__
__module____qualname____firstlineno__rJ   __static_attributes____classdictcell__)__classdict__s   @r   r2   r2   :   s     S Sr   r2   c                     a a ] tR t^Rt oV3R lV 3R lltV3R lV 3R lltV3R lR ltR tR tR	 t	R
 t
R tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR  t R! t!R" t"R# t#R$ t$R% t%R& t&R' t'R( t(R) t)R* t*R+ t+R, t,R- t-R. t.R/ t/R0 t0R1 t1R2 t2R3 t3R4 t4R5 t5R6 t6R7 t7R8 t8R9 t9R: t:R; t;R< t<R= t=R> t>R? t?R@t@VtAV ;tB# )ATestGeneratedCasesc                   < V ^8  d   QhRR/#    returnNr%   )formatrR   s   "r   __annotate__TestGeneratedCases.__annotate__S   s     	R 	Rt 	Rr   c                <  < \         SV `  4        R V n        \        P                  ! 4       V n        \        P                  P                  V P
                  R4      V n	        \        P                  P                  V P
                  R4      V n
        \        P                  P                  V P
                  R4      V n        \        P                  P                  V P
                  R4      V n        \        P                  P                  V P
                  R4      V n        R # )N	input.txt
output.txtzmetadata.txtzpymetadata.txtzexecutor.txt)supersetUpmaxDifftempfile
gettempdirtemp_dirr   r   jointemp_input_filenametemp_output_filenametemp_metadata_filenametemp_pymetadata_filenametemp_executor_filenamerE   	__class__s   &r   r`   TestGeneratedCases.setUpS   s     ++-#%77<<{#K $&GGLL$M!&(ggll4==.&Q#(*T]]DT(U%&(ggll4==.&Q#r   c                   < V ^8  d   QhRR/# rV   r%   )rY   rR   s   "r   rZ   r[   ^   s      $ r   c                   < V P                   V P                  V P                  V P                  V P                  3 F  p \
        P                  ! V4       K  	  \        SV `!  4        R #     K3  ; iN)	rf   rg   rh   ri   rj   r   remover_   tearDownrE   filenamerl   s   & r   rr   TestGeneratedCases.tearDown^   sd    $$%%''))''
H		(#
 	s   A))A.c                &   < V ^8  d   QhRS[ RS[ /# )rW   inputexpectedstr)rY   rR   s   "r   rZ   r[   l   s     ; ;C ;3 ;r   c                @   \        V P                  R 4      ;_uu_ 4       pVP                  \        P                  4       VP                  V4       VP                  \        P
                  4       VP                  4        RRR4       \        4       ;_uu_ 4        \        P                  ! V P                  .V P                  R4       RRR4       \        V P                  4      ;_uu_ 4       pVP                  4       pVP                  \        P                  4      w  rgVP                  \        P                  4      w  rV	P                  \        P                  4      w  rjV
P                  \        P                   4      w  rVP#                  4       R,           VP#                  4       ,           pRRR4       V P%                  XP#                  4       VP#                  4       4       R#   + '       g   i     ELo; i  + '       g   i     EL;; i  + '       g   i     Lh; i)w+NFz


        )openrf   writer(   BEGIN_MARKER
END_MARKERflushr&   tier1_generatorgenerate_tier1_from_filesrg   readsplitINSTRUCTION_START_MARKERINSTRUCTION_END_MARKERLABEL_START_MARKERLABEL_END_MARKERstripr@   )rE   rw   rx   
temp_inputtemp_outputlines_restinstructions labels_with_prelude_and_postludelabels_with_postludelabelsactuals   &&&          r   run_cases_test!TestGeneratedCases.run_cases_testl   sr   $**D11ZV001U#V../	 2 __55))*D,E,Eu 
 $++,,$$&Ekk/"J"JKGA=AZZHnHn=o:L&F&L&L_MoMo&p#A,22?3S3STIF!'')N:V\\^KF - 	)9:' 211 __
 -,s%   A G%.G9,CH%G6	9H
	H	c                0    R pRpV P                  W4       R# )z<
        inst(OP, (--)) {
            SPAM();
        }
    a+  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            SPAM();
            DISPATCH();
        }
    Nr   rE   rw   outputs   &  r   test_inst_no_args$TestGeneratedCases.test_inst_no_args   s     
 	E*r   c                0    R pRpV P                  W4       R# )z`
        inst(OP, (value --)) {
            SPAM(value);
            DEAD(value);
        }
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef value;
            value = stack_pointer[-1];
            SPAM(value);
            stack_pointer += -1;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_inst_one_pop$TestGeneratedCases.test_inst_one_pop        " 	E*r   c                0    R pRpV P                  W4       R# )zF
        inst(OP, (-- res)) {
            res = SPAM();
        }
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef res;
            res = SPAM();
            stack_pointer[0] = res;
            stack_pointer += 1;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_inst_one_push%TestGeneratedCases.test_inst_one_push   s     
" 	E*r   c                0    R pRpV P                  W4       R# )zj
        inst(OP, (value -- res)) {
            res = SPAM(value);
            DEAD(value);
        }
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef value;
            _PyStackRef res;
            value = stack_pointer[-1];
            res = SPAM(value);
            stack_pointer[-1] = res;
            DISPATCH();
        }
    Nr   r   s   &  r   test_inst_one_push_one_pop-TestGeneratedCases.test_inst_one_push_one_pop   r   r   c                0    R pRpV P                  W4       R# )zy
        inst(OP, (left, right -- res)) {
            res = SPAM(left, right);
            INPUTS_DEAD();

        }
    aT  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef left;
            _PyStackRef right;
            _PyStackRef res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            res = SPAM(left, right);
            stack_pointer[-2] = res;
            stack_pointer += -1;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_binary_op!TestGeneratedCases.test_binary_op   s     * 	E*r   c                0    R pRpV P                  W4       R# )z
        inst(OP, (left, right -- left, result)) {
            result = SPAM(left, right);
            INPUTS_DEAD();
        }
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef left;
            _PyStackRef right;
            _PyStackRef result;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            result = SPAM(left, right);
            stack_pointer[-1] = result;
            DISPATCH();
        }
    Nr   r   s   &  r   test_overlapTestGeneratedCases.test_overlap  s     & 	E*r   c                0    R pRpV P                  W4       R# )a  
        inst(OP1, (arg -- res)) {
            DEAD(arg);
            res = Py_None;
        }
        inst(OP3, (arg -- res)) {
            DEAD(arg);
            DEOPT_IF(xxx);
            res = Py_None;
        }
        family(OP1, INLINE_CACHE_ENTRIES_OP1) = { OP3 };
    a  
        TARGET(OP1) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP1;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP1);
            PREDICTED_OP1:;
            _PyStackRef arg;
            _PyStackRef res;
            arg = stack_pointer[-1];
            res = Py_None;
            stack_pointer[-1] = res;
            DISPATCH();
        }

        TARGET(OP3) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP3;
            (void)(opcode);
            #endif
            _Py_CODEUNIT* const this_instr = next_instr;
            (void)this_instr;
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP3);
            static_assert(INLINE_CACHE_ENTRIES_OP1 == 0, "incorrect cache size");
            _PyStackRef arg;
            _PyStackRef res;
            arg = stack_pointer[-1];
            if (xxx) {
                UPDATE_MISS_STATS(OP1);
                assert(_PyOpcode_Deopt[opcode] == (OP1));
                JUMP_TO_PREDICTED(OP1);
            }
            res = Py_None;
            stack_pointer[-1] = res;
            DISPATCH();
        }
    Nr   r   s   &  r   test_predictions#TestGeneratedCases.test_predictions  s!    )T 	E*r   c                0    R pRpV P                  W4       R# )a%  
        inst(A, (arg -- res)) {
            DEAD(arg);
            SYNC_SP();
            escaping_call();
            res = Py_None;
        }
        inst(B, (arg -- res)) {
            DEAD(arg);
            res = Py_None;
            SYNC_SP();
            escaping_call();
        }
    a$  
        TARGET(A) {
            #if Py_TAIL_CALL_INTERP
            int opcode = A;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(A);
            _PyStackRef arg;
            _PyStackRef res;
            arg = stack_pointer[-1];
            stack_pointer += -1;
            assert(WITHIN_STACK_BOUNDS());
            _PyFrame_SetStackPointer(frame, stack_pointer);
            escaping_call();
            stack_pointer = _PyFrame_GetStackPointer(frame);
            res = Py_None;
            stack_pointer[0] = res;
            stack_pointer += 1;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }

        TARGET(B) {
            #if Py_TAIL_CALL_INTERP
            int opcode = B;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(B);
            _PyStackRef arg;
            _PyStackRef res;
            arg = stack_pointer[-1];
            res = Py_None;
            stack_pointer[-1] = res;
            _PyFrame_SetStackPointer(frame, stack_pointer);
            escaping_call();
            stack_pointer = _PyFrame_GetStackPointer(frame);
            DISPATCH();
        }
    Nr   r   s   &  r   test_sync_spTestGeneratedCases.test_sync_spX  s!    *V 	E*r   c                    R pRpV P                  \        4      ;_uu_ 4        V P                  W4       RRR4       R#   + '       g   i     R# ; i)z
        inst(OP, (arg1 -- out)) {
            if (arg1)
                out = 0;
            else {
                out = 1;
            }
        }
         NassertRaisesSyntaxErrorr   r   s   &  r   test_pep7_condition&TestGeneratedCases.test_pep7_condition  s>     {++. ,+++	   >A	c                0    R pRpV P                  W4       R# )zD
        inst(OP, (--)) {
            ERROR_IF(cond);
        }
    c  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            if (cond) {
                JUMP_TO_LABEL(error);
            }
            DISPATCH();
        }
    Nr   r   s   &  r   test_error_if_plain&TestGeneratedCases.test_error_if_plain       
 	E*r   c                0    R pRpV P                  W4       R# )zV
        inst(OP, (--)) {
            ERROR_IF(cond);  // Comment is ok
        }
    r   Nr   r   s   &  r    test_error_if_plain_with_comment3TestGeneratedCases.test_error_if_plain_with_comment  r   r   c                0    R pRpV P                  W4       R# )z
        inst(OP, (left, right -- res)) {
            SPAM(left, right);
            INPUTS_DEAD();
            ERROR_IF(cond);
            res = 0;
        }
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef left;
            _PyStackRef right;
            _PyStackRef res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            SPAM(left, right);
            if (cond) {
                JUMP_TO_LABEL(pop_2_error);
            }
            res = 0;
            stack_pointer[-2] = res;
            stack_pointer += -1;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_error_if_pop$TestGeneratedCases.test_error_if_pop  s     2 	E*r   c                0    R pRpV P                  W4       R# )z
        inst(OP, (left, right -- res)) {
            res = SPAM(left, right);
            INPUTS_DEAD();
            ERROR_IF(cond);
        }
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef left;
            _PyStackRef right;
            _PyStackRef res;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            res = SPAM(left, right);
            if (cond) {
                JUMP_TO_LABEL(pop_2_error);
            }
            stack_pointer[-2] = res;
            stack_pointer += -1;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_error_if_pop_with_result0TestGeneratedCases.test_error_if_pop_with_result  s     0 	E*r   c                0    R pRpV P                  W4       R# )z[
        inst(OP, (counter/1, extra/2, value --)) {
            DEAD(value);
        }
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            _Py_CODEUNIT* const this_instr = next_instr;
            (void)this_instr;
            frame->instr_ptr = next_instr;
            next_instr += 4;
            INSTRUCTION_STATS(OP);
            _PyStackRef value;
            value = stack_pointer[-1];
            uint16_t counter = read_u16(&this_instr[1].cache);
            (void)counter;
            uint32_t extra = read_u32(&this_instr[2].cache);
            (void)extra;
            stack_pointer += -1;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_cache_effect$TestGeneratedCases.test_cache_effect  s     
, 	E*r   c                0    R pRpV P                  W4       R# )zj
        label(somewhere) {
        }

        inst(OP, (--)) {
            goto somewhere;
        }
    aS  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            JUMP_TO_LABEL(somewhere);
        }

        LABEL(somewhere)
        {
        }
    Nr   r   s   &  r   test_suppress_dispatch)TestGeneratedCases.test_suppress_dispatch5  s       	E*r   c                0    R pRpV P                  W4       R# )a  
        inst(OP1, (counter/1, left, right -- left, right)) {
            op1(left, right);
        }
        op(OP2, (extra/2, arg2, left, right -- res)) {
            res = op2(arg2, left, right);
            INPUTS_DEAD();
        }
        macro(OP) = OP1 + cache/2 + OP2;
        inst(OP3, (unused/5, arg2, left, right -- res)) {
            res = op3(arg2, left, right);
            INPUTS_DEAD();
        }
        family(OP, INLINE_CACHE_ENTRIES_OP) = { OP3 };
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 6;
            INSTRUCTION_STATS(OP);
            PREDICTED_OP:;
            _Py_CODEUNIT* const this_instr = next_instr - 6;
            (void)this_instr;
            _PyStackRef left;
            _PyStackRef right;
            _PyStackRef arg2;
            _PyStackRef res;
            // _OP1
            {
                right = stack_pointer[-1];
                left = stack_pointer[-2];
                uint16_t counter = read_u16(&this_instr[1].cache);
                (void)counter;
                _PyFrame_SetStackPointer(frame, stack_pointer);
                op1(left, right);
                stack_pointer = _PyFrame_GetStackPointer(frame);
            }
            /* Skip 2 cache entries */
            // OP2
            {
                arg2 = stack_pointer[-3];
                uint32_t extra = read_u32(&this_instr[4].cache);
                (void)extra;
                _PyFrame_SetStackPointer(frame, stack_pointer);
                res = op2(arg2, left, right);
                stack_pointer = _PyFrame_GetStackPointer(frame);
            }
            stack_pointer[-3] = res;
            stack_pointer += -2;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }

        TARGET(OP1) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP1;
            (void)(opcode);
            #endif
            _Py_CODEUNIT* const this_instr = next_instr;
            (void)this_instr;
            frame->instr_ptr = next_instr;
            next_instr += 2;
            INSTRUCTION_STATS(OP1);
            _PyStackRef left;
            _PyStackRef right;
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            uint16_t counter = read_u16(&this_instr[1].cache);
            (void)counter;
            _PyFrame_SetStackPointer(frame, stack_pointer);
            op1(left, right);
            stack_pointer = _PyFrame_GetStackPointer(frame);
            DISPATCH();
        }

        TARGET(OP3) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP3;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 6;
            INSTRUCTION_STATS(OP3);
            static_assert(INLINE_CACHE_ENTRIES_OP == 5, "incorrect cache size");
            _PyStackRef arg2;
            _PyStackRef left;
            _PyStackRef right;
            _PyStackRef res;
            /* Skip 5 cache entries */
            right = stack_pointer[-1];
            left = stack_pointer[-2];
            arg2 = stack_pointer[-3];
            _PyFrame_SetStackPointer(frame, stack_pointer);
            res = op3(arg2, left, right);
            stack_pointer = _PyFrame_GetStackPointer(frame);
            stack_pointer[-3] = res;
            stack_pointer += -2;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_macro_instruction)TestGeneratedCases.test_macro_instructionP  s"    Yt 	E*r   c                0    R pRpV P                  W4       R# )zM
        inst(OP, (unused/1, unused/2 --)) {
            body;
        }
    au  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 4;
            INSTRUCTION_STATS(OP);
            /* Skip 1 cache entry */
            /* Skip 2 cache entries */
            body;
            DISPATCH();
        }
    Nr   r   s   &  r   test_unused_caches%TestGeneratedCases.test_unused_caches  r   r   c                0    R pRpV P                  W4       R# )zq
        pseudo(OP, (in -- out1, out2)) = {
            OP1,
        };

        inst(OP1, (--)) {
        }
      
        TARGET(OP1) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP1;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP1);
            DISPATCH();
        }
    Nr   r   s   &  r    test_pseudo_instruction_no_flags3TestGeneratedCases.test_pseudo_instruction_no_flags        	E*r   c                0    R pRpV P                  W4       R# )z
        pseudo(OP, (in1, in2 --), (HAS_ARG, HAS_JUMP)) = {
            OP1,
        };

        inst(OP1, (--)) {
        }
    r   Nr   r   s   &  r   "test_pseudo_instruction_with_flags5TestGeneratedCases.test_pseudo_instruction_with_flags  r   r   c                0    R pRpV P                  W4       R# )z
        pseudo(OP, (in -- out1, out2)) = [
            OP1, OP2
        ];

        inst(OP1, (--)) {
        }

        inst(OP2, (--)) {
        }
    a0  
        TARGET(OP1) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP1;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP1);
            DISPATCH();
        }

        TARGET(OP2) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP2;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP2);
            DISPATCH();
        }
    Nr   r   s   &  r   #test_pseudo_instruction_as_sequence6TestGeneratedCases.test_pseudo_instruction_as_sequence  s     
. 	E*r   c                0    R pRpV P                  W4       R# )z
        inst(OP, (below, values[oparg*2], above --)) {
            SPAM(values, oparg);
            DEAD(below);
            DEAD(values);
            DEAD(above);
        }
    ax  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef below;
            _PyStackRef *values;
            _PyStackRef above;
            above = stack_pointer[-1];
            values = &stack_pointer[-1 - oparg*2];
            below = stack_pointer[-2 - oparg*2];
            SPAM(values, oparg);
            stack_pointer += -2 - oparg*2;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_array_input#TestGeneratedCases.test_array_input'  s     * 	E*r   c                0    R pRpV P                  W4       R# )z
        inst(OP, (unused, unused -- below, values[oparg*3], above)) {
            SPAM(values, oparg);
            below = 0;
            above = 0;
        }
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef below;
            _PyStackRef *values;
            _PyStackRef above;
            values = &stack_pointer[-1];
            SPAM(values, oparg);
            below = 0;
            above = 0;
            stack_pointer[-2] = below;
            stack_pointer[-1 + oparg*3] = above;
            stack_pointer += oparg*3;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_array_output$TestGeneratedCases.test_array_outputG       . 	E*r   c                0    R pRpV P                  W4       R# )z
        inst(OP, (values[oparg] -- values[oparg], above)) {
            SPAM(values, oparg);
            above = 0;
        }
    a-  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef *values;
            _PyStackRef above;
            values = &stack_pointer[-oparg];
            SPAM(values, oparg);
            above = 0;
            stack_pointer[0] = above;
            stack_pointer += 1;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_array_input_output*TestGeneratedCases.test_array_input_outputh  s     ( 	E*r   c                0    R pRpV P                  W4       R# )z
        inst(OP, (extra, values[oparg] --)) {
            DEAD(extra);
            DEAD(values);
            ERROR_IF(oparg == 0);
        }
    a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef extra;
            _PyStackRef *values;
            values = &stack_pointer[-oparg];
            extra = stack_pointer[-1 - oparg];
            if (oparg == 0) {
                stack_pointer += -1 - oparg;
                assert(WITHIN_STACK_BOUNDS());
                JUMP_TO_LABEL(error);
            }
            stack_pointer += -1 - oparg;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
    Nr   r   s   &  r   test_array_error_if&TestGeneratedCases.test_array_error_if  r   r   c                0    R pRpV P                  W4       R# )z
        op(A, (-- val1)) {
            val1 = SPAM();
        }
        op(B, (-- val2)) {
            val2 = SPAM();
        }
        macro(M) = A + B;
        a  
        TARGET(M) {
            #if Py_TAIL_CALL_INTERP
            int opcode = M;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(M);
            _PyStackRef val1;
            _PyStackRef val2;
            // A
            {
                val1 = SPAM();
            }
            // B
            {
                val2 = SPAM();
            }
            stack_pointer[0] = val1;
            stack_pointer[1] = val2;
            stack_pointer += 2;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
        Nr   r   s   &  r   test_macro_push_push'TestGeneratedCases.test_macro_push_push  s     4 	E*r   c                0    R pRpV P                  W4       R# )z{
        inst(OP, (--)) {
            spam;
        }
        override inst(OP, (--)) {
            ham;
        }
        ,  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            ham;
            DISPATCH();
        }
        Nr   r   s   &  r   test_override_inst%TestGeneratedCases.test_override_inst  s      	E*r   c                0    R pRpV P                  W4       R# )z
        op(OP, (--)) {
            spam;
        }
        macro(M) = OP;
        override op(OP, (--)) {
            ham;
        }
        a)  
        TARGET(M) {
            #if Py_TAIL_CALL_INTERP
            int opcode = M;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(M);
            ham;
            DISPATCH();
        }
        Nr   r   s   &  r   test_override_op#TestGeneratedCases.test_override_op  s      	E*r   c                0    R pRpV P                  W4       R# )zB
        pure inst(OP, (--)) {
            ham;
        }
        r   Nr   r   s   &  r   test_annotated_inst&TestGeneratedCases.test_annotated_inst  s     
 	E*r   c                V    R pRpV P                  W4       RpV P                  W4       R# )zZ
        pure op(OP, (--)) {
            SPAM();
        }
        macro(M) = OP;
        a,  
        TARGET(M) {
            #if Py_TAIL_CALL_INTERP
            int opcode = M;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(M);
            SPAM();
            DISPATCH();
        }
        zp
        pure register specializing op(OP, (--)) {
            SPAM();
        }
        macro(M) = OP;
        Nr   r   s   &  r   test_annotated_op$TestGeneratedCases.test_annotated_op  s7     	E* 	E*r   c                    R pRpV P                  \        4      ;_uu_ 4        V P                  W4       RRR4       R#   + '       g   i     R# ; i)zi
        pure op(OP, (arg1 -- out)) {
            DEOPT_IF(1);
            EXIT_IF(1);
        }
        r   Nr   r   s   &  r   test_deopt_and_exit&TestGeneratedCases.test_deopt_and_exit0  s>     {++. ,+++r   c                0    R pRpV P                  W4       R# )zn
        inst(OP, (arg[1] -- out[1])) {
            out[0] = arg[0];
            DEAD(arg);
        }
        a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef *arg;
            _PyStackRef *out;
            arg = &stack_pointer[-1];
            out = &stack_pointer[-1];
            out[0] = arg[0];
            DISPATCH();
        }
        Nr   r   s   &  r   test_array_of_one$TestGeneratedCases.test_array_of_one;       " 	E*r   c                0    R pRpV P                  W4       R# )zr
        inst(OP, (arg: _PyStackRef * -- out)) {
            out = *arg;
            DEAD(arg);
        }
        a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef *arg;
            _PyStackRef out;
            arg = (_PyStackRef *)stack_pointer[-1].bits;
            out = *arg;
            stack_pointer[-1] = out;
            DISPATCH();
        }
        Nr   r   s   &  r   test_pointer_to_stackref+TestGeneratedCases.test_pointer_to_stackrefU  r  r   c                    R pRpV P                  \        4      ;_uu_ 4        V P                  W4       RRR4       R#   + '       g   i     R# ; i)z
        op(FIRST, (arg1 -- out)) {
            out = arg1;
        }

        op(SECOND, (unused -- unused)) {
        }

        macro(BOTH) = FIRST + SECOND;
        	
        Nr   r   s   &  r   test_unused_cached_value+TestGeneratedCases.test_unused_cached_valueo  s>    	{++. ,+++r   c                0    R pRpV P                  W4       R# )zQ
        op(OP, (named -- named)) {
        }

        macro(INST) = OP;
        a"  
        TARGET(INST) {
            #if Py_TAIL_CALL_INTERP
            int opcode = INST;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(INST);
            DISPATCH();
        }

        Nr   r   s   &  r   test_unused_named_values+TestGeneratedCases.test_unused_named_values  s      	E*r   c                0    R pRpV P                  W4       R# )z
        op(FIRST, (w -- w)) {
            USE(w);
        }

        op(SECOND, (x -- x)) {
        }

        op(THIRD, (y -- y)) {
            USE(y);
        }

        macro(TEST) = FIRST + SECOND + THIRD;
        aY  
        TARGET(TEST) {
            #if Py_TAIL_CALL_INTERP
            int opcode = TEST;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(TEST);
            _PyStackRef w;
            _PyStackRef y;
            // FIRST
            {
                w = stack_pointer[-1];
                USE(w);
            }
            // SECOND
            {
            }
            // THIRD
            {
                y = w;
                USE(y);
            }
            DISPATCH();
        }
        Nr   r   s   &  r   test_used_unused_used(TestGeneratedCases.test_used_unused_used       6 	E*r   c                0    R pRpV P                  W4       R# )z
        op(FIRST, (w -- w)) {
        }

        op(SECOND, (x -- x)) {
            USE(x);
        }

        op(THIRD, (y -- y)) {
            USE(y);
        }

        macro(TEST) = FIRST + SECOND + THIRD;
        aY  
        TARGET(TEST) {
            #if Py_TAIL_CALL_INTERP
            int opcode = TEST;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(TEST);
            _PyStackRef x;
            _PyStackRef y;
            // FIRST
            {
            }
            // SECOND
            {
                x = stack_pointer[-1];
                USE(x);
            }
            // THIRD
            {
                y = x;
                USE(y);
            }
            DISPATCH();
        }
        Nr   r   s   &  r   test_unused_used_used(TestGeneratedCases.test_unused_used_used  r  r   c                0    R pRpV P                  W4       R# )z
        op(FIRST, ( -- a, b)) {
            a = 0;
            b = 1;
        }

        op(SECOND, (a, b -- )) {
            USE(a, b);
            INPUTS_DEAD();
        }

        macro(TEST) = FIRST + flush + SECOND;
        a  
        TARGET(TEST) {
            #if Py_TAIL_CALL_INTERP
            int opcode = TEST;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(TEST);
            _PyStackRef a;
            _PyStackRef b;
            // FIRST
            {
                a = 0;
                b = 1;
            }
            // flush
            stack_pointer[0] = a;
            stack_pointer[1] = b;
            stack_pointer += 2;
            assert(WITHIN_STACK_BOUNDS());
            // SECOND
            {
                USE(a, b);
            }
            stack_pointer += -2;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
        Nr   r   s   &  r   
test_flushTestGeneratedCases.test_flush  s     < 	E*r   c                0    R pRpV P                  W4       R# )a_  
        op(FIRST, (x, y -- a, b)) {
            a = x;
            DEAD(x);
            b = y;
            DEAD(y);
        }

        op(SECOND, (a, b -- a, b)) {
        }

        op(THIRD, (j, k --)) {
            INPUTS_DEAD(); // Mark j and k as used
            ERROR_IF(cond);
        }

        macro(TEST) = FIRST + SECOND + THIRD;
        aG  
        TARGET(TEST) {
            #if Py_TAIL_CALL_INTERP
            int opcode = TEST;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(TEST);
            _PyStackRef x;
            _PyStackRef y;
            _PyStackRef a;
            _PyStackRef b;
            // FIRST
            {
                y = stack_pointer[-1];
                x = stack_pointer[-2];
                a = x;
                b = y;
            }
            // SECOND
            {
            }
            // THIRD
            {
                if (cond) {
                    JUMP_TO_LABEL(pop_2_error);
                }
            }
            stack_pointer += -2;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
        Nr   r   s   &  r   test_pop_on_error_peeks*TestGeneratedCases.test_pop_on_error_peeks  s!    $!D 	E*r   c                0    R pRpV P                  W4       R# )z
        op(FIRST, ( -- a)) {
            a = 1;
        }

        op(SECOND, (a -- a, b)) {
            b = 1;
            ERROR_IF(cond);
        }

        macro(TEST) = FIRST + SECOND;
        a~  
        TARGET(TEST) {
            #if Py_TAIL_CALL_INTERP
            int opcode = TEST;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(TEST);
            _PyStackRef a;
            _PyStackRef b;
            // FIRST
            {
                a = 1;
            }
            // SECOND
            {
                b = 1;
                if (cond) {
                    stack_pointer[0] = a;
                    stack_pointer[1] = b;
                    stack_pointer += 2;
                    assert(WITHIN_STACK_BOUNDS());
                    JUMP_TO_LABEL(error);
                }
            }
            stack_pointer[0] = a;
            stack_pointer[1] = b;
            stack_pointer += 2;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
        Nr   r   s   &  r   test_push_then_error'TestGeneratedCases.test_push_then_errorS  s!     B 	E*r   c                0    R pRpV P                  W4       R# )z
        inst(OP1, ( --)) {
            ERROR_IF(true);
        }
        inst(OP2, ( --)) {
            ERROR_IF(1);
        }
        aH  
        TARGET(OP1) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP1;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP1);
            JUMP_TO_LABEL(error);
        }

        TARGET(OP2) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP2;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP2);
            JUMP_TO_LABEL(error);
        }
        Nr   r   s   &  r   test_error_if_true%TestGeneratedCases.test_error_if_true  s     . 	E*r   c                    R pRpV P                  \        4      ;_uu_ 4        V P                  W4       RRR4       R#   + '       g   i     R# ; i)z
        op(FIRST, ( -- a)) {
            a = 1;
        }

        op(SECOND, (a[1] -- b)) {
            b = 1;
        }

        macro(TEST) = FIRST + SECOND;
        r  Nr   r   s   &  r   test_scalar_array_inconsistency2TestGeneratedCases.test_scalar_array_inconsistency  >    
{++. ,+++r   c                    R pRpV P                  \        4      ;_uu_ 4        V P                  W4       RRR4       R#   + '       g   i     R# ; i)z
        op(FIRST, ( -- a[2])) {
            a[0] = 1;
        }

        op(SECOND, (a[1] -- b)) {
            b = 1;
        }

        macro(TEST) = FIRST + SECOND;
        r  Nr   r   s   &  r   test_array_size_inconsistency0TestGeneratedCases.test_array_size_inconsistency  r$  r   c                0    R pRpV P                  W4       R# )z~
        inst(BALANCED, ( -- )) {
            SAVE_STACK();
            code();
            RELOAD_STACK();
        }
        a  
        TARGET(BALANCED) {
            #if Py_TAIL_CALL_INTERP
            int opcode = BALANCED;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(BALANCED);
            _PyFrame_SetStackPointer(frame, stack_pointer);
            code();
            stack_pointer = _PyFrame_GetStackPointer(frame);
            DISPATCH();
        }
        Nr   r   s   &  r   test_stack_save_reload)TestGeneratedCases.test_stack_save_reload  s      	E*r   c                0    R pRpV P                  W4       R# )zj
        inst(BALANCED, ( -- )) {
            SAVE_STACK();
            RELOAD_STACK();
        }
        a-  
        TARGET(BALANCED) {
            #if Py_TAIL_CALL_INTERP
            int opcode = BALANCED;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(BALANCED);
            DISPATCH();
        }
        Nr   r   s   &  r   test_stack_save_reload_paired0TestGeneratedCases.test_stack_save_reload_paired  s      	E*r   c                    R pRpV P                  \        4      ;_uu_ 4        V P                  W4       RRR4       R#   + '       g   i     R# ; i)zP
        inst(BALANCED, ( -- )) {
            RELOAD_STACK();
        }
        a  
        TARGET(BALANCED) {
            #if Py_TAIL_CALL_INTERP
            int opcode = BALANCED;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(BALANCED);
            _PyFrame_SetStackPointer(frame, stack_pointer);
            stack_pointer = _PyFrame_GetStackPointer(frame);
            DISPATCH();
        }
        Nr   r   s   &  r   test_stack_reload_only)TestGeneratedCases.test_stack_reload_only   s@     {++. ,+++r   c                    R pRpV P                  \        4      ;_uu_ 4        V P                  W4       RRR4       R#   + '       g   i     R# ; i)zN
        inst(BALANCED, ( -- )) {
            SAVE_STACK();
        }
        a  
        TARGET(BALANCED) {
            #if Py_TAIL_CALL_INTERP
            int opcode = BALANCED;
            (void)(opcode);
            #endif
            _Py_CODEUNIT* const this_instr = next_instr;
            (void)this_instr;
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(BALANCED);
            _PyFrame_SetStackPointer(frame, stack_pointer);
            stack_pointer = _PyFrame_GetStackPointer(frame);
            DISPATCH();
        }
        Nr   r   s   &  r   test_stack_save_only'TestGeneratedCases.test_stack_save_only  s@      {++. ,+++r   c                    R pRpV P                  W4       RpRpV P                  \        R4      ;_uu_ 4        V P                  W4       RRR4       R#   + '       g   i     R# ; i)za
        inst(OP, (--)) {
            frame->return_offset = INSTRUCTION_SIZE;
        }
        aB  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            frame->return_offset = 1 ;
            DISPATCH();
        }
        z
        inst(OP, (--)) {
            frame->return_offset = INSTRUCTION_SIZE;
        }
        macro(OP2) = unused/1 + OP;
        r   z!All instructions containing a uopN)r   assertRaisesRegexr   r   s   &  r   test_instruction_size_macro.TestGeneratedCases.test_instruction_size_macro4  s`     	E* ##K1TUU. VUUUs   AA%	c                0    R pRpV P                  W4       R# )z
        inst(OP, (--)) {
            #ifdef Py_GIL_DISABLED
            escaping_call();
            #else
            another_escaping_call();
            #endif
            yet_another_escaping_call();
        }
        a9  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            #ifdef Py_GIL_DISABLED
            _PyFrame_SetStackPointer(frame, stack_pointer);
            escaping_call();
            stack_pointer = _PyFrame_GetStackPointer(frame);
            #else
            _PyFrame_SetStackPointer(frame, stack_pointer);
            another_escaping_call();
            stack_pointer = _PyFrame_GetStackPointer(frame);
            #endif
            _PyFrame_SetStackPointer(frame, stack_pointer);
            yet_another_escaping_call();
            stack_pointer = _PyFrame_GetStackPointer(frame);
            DISPATCH();
        }
        Nr   r   s   &  r   !test_escaping_call_next_to_cmacro4TestGeneratedCases.test_escaping_call_next_to_cmacroW  s     	0 	E*r   c                0    R pRpV P                  W4       R# )a?  
        inst(OP, (-- out1, out2)) {
            PyObject *obj = SPAM();
            #ifdef Py_GIL_DISABLED
            out1 = PyStackRef_FromPyObjectNew(obj);
            #else
            out1 = PyStackRef_FromPyObjectNew(obj);
            #endif
            out2 = PyStackRef_FromPyObjectNew(obj);
        }
        a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef out1;
            _PyStackRef out2;
            PyObject *obj = SPAM();
            #ifdef Py_GIL_DISABLED
            out1 = PyStackRef_FromPyObjectNew(obj);
            #else
            out1 = PyStackRef_FromPyObjectNew(obj);
            #endif
            out2 = PyStackRef_FromPyObjectNew(obj);
            stack_pointer[0] = out1;
            stack_pointer[1] = out2;
            stack_pointer += 2;
            assert(WITHIN_STACK_BOUNDS());
            DISPATCH();
        }
        Nr   r   s   &  r   /test_pystackref_frompyobject_new_next_to_cmacroBTestGeneratedCases.test_pystackref_frompyobject_new_next_to_cmacro|  s     
2 	E*r   c                   R pV P                  \        4      ;_uu_ 4        V P                  VR4       RRR4       RpV P                  \        4      ;_uu_ 4        V P                  VR4       RRR4       RpV P                  \        4      ;_uu_ 4        V P                  VR4       RRR4       R#   + '       g   i     L; i  + '       g   i     L_; i  + '       g   i     R# ; i)zU
        inst(OP, ( -- )) {
            DEOPT_IF(escaping_call());
        }
        r   NzT
        inst(OP, ( -- )) {
            EXIT_IF(escaping_call());
        }
        zU
        inst(OP, ( -- )) {
            ERROR_IF(escaping_call());
        }
        r   rE   rw   s   & r   *test_no_escaping_calls_in_branching_macros=TestGeneratedCases.test_no_escaping_calls_in_branching_macros  s    
 {++r* ,
 {++r* ,
 {++r* ,+! ,+ ,+ ,++s#   B1CC1C	C	C(	c                    R pV P                  \        4      ;_uu_ 4        V P                  VR4       RRR4       R#   + '       g   i     R# ; i)z
        inst(OP, (a, b -- c)) {
            c = b;
            PyStackRef_CLOSE(a);
            PyStackRef_CLOSE(b);
        }
        r   Nr   r?  s   & r   test_kill_in_wrong_order+TestGeneratedCases.test_kill_in_wrong_order  s;     {++r* ,+++s	   =A	c                0    R pRpV P                  W4       R# )a  
        label(other_label) {
        }

        label(other_label2) {
        }

        label(my_label) {
            // Comment
            do_thing();
            if (complex) {
                goto other_label;
            }
            goto other_label2;
        }
        a  
        LABEL(other_label)
        {
        }

        LABEL(other_label2)
        {
        }

        LABEL(my_label)
        {
            _PyFrame_SetStackPointer(frame, stack_pointer);
            do_thing();
            stack_pointer = _PyFrame_GetStackPointer(frame);
            if (complex) {
                JUMP_TO_LABEL(other_label);
            }
            JUMP_TO_LABEL(other_label2);
        }
        Nr   r   s   &  r   test_complex_label%TestGeneratedCases.test_complex_label  s     "( 	E*r   c                0    R pRpV P                  W4       R# )z
        spilled label(one) {
            RELOAD_STACK();
            goto two;
        }

        label(two) {
            SAVE_STACK();
            goto one;
        }
        a  
        LABEL(one)
        {
            stack_pointer = _PyFrame_GetStackPointer(frame);
            JUMP_TO_LABEL(two);
        }

        LABEL(two)
        {
            _PyFrame_SetStackPointer(frame, stack_pointer);
            JUMP_TO_LABEL(one);
        }
        Nr   r   s   &  r   test_spilled_label%TestGeneratedCases.test_spilled_label  s     
 	E*r   c                @   R pRpV P                  \        R4      ;_uu_ 4        V P                  VR4       RRR4       V P                  \        R4      ;_uu_ 4        V P                  VR4       RRR4       R#   + '       g   i     LK; i  + '       g   i     R# ; i)zf
        spilled label(one) {
            goto two;
        }

        label(two) {
        }
        zf
        spilled label(one) {
        }

        label(two) {
            goto one;
        }
        z
.*reload.*r   Nz	.*spill.*)r5  r   r   )rE   input1input2s   &  r   test_incorrect_spills(TestGeneratedCases.test_incorrect_spills  sx     ##K>>+ ?##K==+ >= ?>===s   A9B9B		B	c                0    R pRpV P                  W4       R# )z
        label(my_label_1) {
            // Comment
            do_thing1();
            goto my_label_2;
        }

        label(my_label_2) {
            // Comment
            do_thing2();
            goto my_label_1;
        }
        a  
        LABEL(my_label_1)
        {
            _PyFrame_SetStackPointer(frame, stack_pointer);
            do_thing1();
            stack_pointer = _PyFrame_GetStackPointer(frame);
            JUMP_TO_LABEL(my_label_2);
        }

        LABEL(my_label_2)
        {
            _PyFrame_SetStackPointer(frame, stack_pointer);
            do_thing2();
            stack_pointer = _PyFrame_GetStackPointer(frame);
            JUMP_TO_LABEL(my_label_1);
        }
        Nr   r   s   &  r   test_multiple_labels'TestGeneratedCases.test_multiple_labels%  s     " 	E*r   c                0    R pRpV P                  W4       R# )zF
        inst(OP, (in -- in)) {
            in = 0;
        }
        a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef in;
            in = stack_pointer[-1];
            in = 0;
            stack_pointer[-1] = in;
            DISPATCH();
        }
        Nr   r   s   &  r   test_reassigning_live_inputs/TestGeneratedCases.test_reassigning_live_inputsG  s       	E*r   c                0    R pRpV P                  W4       R# )z
        inst(OP, (in -- )) {
            temp = use(in);
            DEAD(in);
            in = temp;
            PyStackRef_CLOSE(in);
        }
        a  
        TARGET(OP) {
            #if Py_TAIL_CALL_INTERP
            int opcode = OP;
            (void)(opcode);
            #endif
            frame->instr_ptr = next_instr;
            next_instr += 1;
            INSTRUCTION_STATS(OP);
            _PyStackRef in;
            in = stack_pointer[-1];
            _PyFrame_SetStackPointer(frame, stack_pointer);
            temp = use(in);
            stack_pointer = _PyFrame_GetStackPointer(frame);
            in = temp;
            stack_pointer += -1;
            assert(WITHIN_STACK_BOUNDS());
            _PyFrame_SetStackPointer(frame, stack_pointer);
            PyStackRef_CLOSE(in);
            stack_pointer = _PyFrame_GetStackPointer(frame);
            DISPATCH();
        }
        Nr   r   s   &  r   test_reassigning_dead_inputs/TestGeneratedCases.test_reassigning_dead_inputs`  s     . 	E*r   )ra   rd   rj   rf   rh   rg   ri   )CrL   rM   rN   rO   r`   rr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r	  r  r  r  r  r  r  r  r"  r&  r)  r,  r/  r2  r6  r9  r<  r@  rC  rF  rI  rN  rQ  rT  rW  rP   rQ   __classcell__rl   rR   s   @@r   rT   rT   R   s]    	R 	R ; ;,+*+4+2+4+>+87+r:+z/+.+."+H +D+<+6j+X+.+.+.#+L+@+B+:+B$+L+0+2+*+<	/+4+4/ +,*+X*+X,+\6+p0+d!+F/&/&+6+./2/6!/F#+J%+N+4	+&+P+:,0 +D+2 +  +r   rT   c                      a a ] tR tRt oV3R lV 3R lltV3R lV 3R lltV3R lR ltR tR	 tR
 t	R t
RtVtV ;t# )TestGeneratedAbstractCasesi  c                   < V ^8  d   QhRR/# rV   r%   )rY   rR   s   "r   rZ   'TestGeneratedAbstractCases.__annotate__  s     N Nt Nr   c                  < \         SV `  4        R V n        \        P                  ! 4       V n        \        P                  P                  V P
                  R4      V n	        \        P                  P                  V P
                  R4      V n
        \        P                  P                  V P
                  R4      V n        R # )Nr]   z
input2.txtr^   )r_   r`   ra   rb   rc   rd   r   r   re   rf   temp_input2_filenamerg   rk   s   &r   r`    TestGeneratedAbstractCases.setUp  st     ++-#%77<<{#K $&GGLL$M!$&GGLL$M!r   c                   < V ^8  d   QhRR/# rV   r%   )rY   rR   s   "r   rZ   r^    s     
 
$ 
r   c                   < V P                   V P                  V P                  3 F  p \        P                  ! V4       K  	  \
        SV `  4        R #     K3  ; irp   )rf   r`  rg   r   rq   r_   rr   rs   s   & r   rr   #TestGeneratedAbstractCases.tearDown  sR    $$%%%%
H
		(#
 	s   AAc                ,   < V ^8  d   QhRS[ RS[ RS[ /# )rW   rw   rM  rx   ry   )rY   rR   s   "r   rZ   r^    s"     ; ;C ; ; ;r   c                .   \        V P                  R 4      ;_uu_ 4       pVP                  \        P                  4       VP                  V4       VP                  \        P
                  4       VP                  4        RRR4       \        V P                  R 4      ;_uu_ 4       pVP                  \        P                  4       VP                  V4       VP                  \        P
                  4       VP                  4        RRR4       \        4       ;_uu_ 4        \        P                  ! V P                  V P                  .V P                  4       RRR4       \        V P                  4      ;_uu_ 4       pVP                  4       pV'       d2   V^ ,          P                  R4      '       d   VP                  ^ 4       K9  V'       d2   VR,          P                  R4      '       d   VP                  R4       K9  RRR4       RP                  X4      pV P!                  VP#                  4       VP#                  4       4       R#   + '       g   i     EL; i  + '       g   i     EL`; i  + '       g   i     EL"; i  + '       g   i     L; i)r|   Nr   )z// #z    #
)rg  rh  )r}   rf   r~   r(   r   r   r   r`  r&   optimizer_generator"generate_tier2_abstract_from_filesrg   	readlines
startswithr=   re   r@   r   )rE   rw   rM  rx   r   r   r   r   s   &&&&    r   r   )TestGeneratedAbstractCases.run_cases_test  s   $**D11ZV001U#V../	 2 $++T22jV001V$V../	 3 __BB))4+D+DE))  $++,,))+EE!H//0KLL		!E"I00==		" - )9:3 211 322 __ -,s=   A I%A I8I0<J8J1JI	I-	0J	J	c                6    R pRpRpV P                  WV4       R# )zC
        pure op(OP, (--)) {
            SPAM();
        }
        zC
        pure op(OP, (--)) {
            eggs();
        }
        zM
        case OP: {
            eggs();
            break;
        }
        Nr   rE   rw   rM  r   s   &   r   test_overridden_abstract3TestGeneratedAbstractCases.test_overridden_abstract  s)    

 	E62r   c                6    R pRpRpV P                  WV4       R# )z
        pure op(OP, (arg1 -- out)) {
            out = SPAM(arg1);
        }
        op(OP2, (arg1 -- out)) {
            out = EGGS(arg1);
        }
        zQ
        op(OP, (arg1 -- out)) {
            out = EGGS(arg1);
        }
        a  
        case OP: {
            JitOptSymbol *arg1;
            JitOptSymbol *out;
            arg1 = stack_pointer[-1];
            out = EGGS(arg1);
            stack_pointer[-1] = out;
            break;
        }

        case OP2: {
            JitOptSymbol *out;
            out = sym_new_not_null(ctx);
            stack_pointer[-1] = out;
            break;
        }
       Nr   rp  s   &   r   test_overridden_abstract_args8TestGeneratedAbstractCases.test_overridden_abstract_args  s)    
" 	E62r   c                6    R pRpRpV P                  WV4       R# )z
        pure op(OP, (arg1 -- out)) {
            out = SPAM(arg1);
        }

        pure op(OP2, (arg1 -- out)) {
        }

        zQ
        pure op(OP2, (arg1 -- out)) {
            out = NULL;
        }
        a4  
        case OP: {
            JitOptSymbol *out;
            out = sym_new_not_null(ctx);
            stack_pointer[-1] = out;
            break;
        }

        case OP2: {
            JitOptSymbol *out;
            out = NULL;
            stack_pointer[-1] = out;
            break;
        }
        Nr   rp  s   &   r   test_no_overridden_case2TestGeneratedAbstractCases.test_no_overridden_case  s)    
 	E62r   c                    R pRpRpV P                  \        R4      ;_uu_ 4        V P                  WV4       RRR4       R#   + '       g   i     R# ; i)zL
        pure op(OP, (arg1 -- out)) {
            SPAM();
        }
        z;
        pure op(OTHER, (arg1 -- out)) {
        }
        r  zAll abstract uopsN)r5  AssertionErrorr   rp  s   &   r   test_missing_override_failure8TestGeneratedAbstractCases.test_missing_override_failure	  sK    
##N4GHHv6 IHHHs   AA	)ra   rd   r`  rf   rg   )rL   rM   rN   rO   r`   rr   r   rq  rt  rw  r{  rP   rQ   rY  rZ  s   @@r   r\  r\    s@     N N
 
; ;83&3B3@7 7r   r\  __main__)"r"   r   rer	   rb   r   ior   testr   r   r   skip_if_missingimports_under_toolanalyzerr   r   cwriterr   r(   rF   r   r   r   opcode_metadata_generatorrj  r&   r0   TestCaser2   rT   r\  rL   mainr%   r   r   <module>r     s     	 	 
     
       , -""#4552"$ 6)S(## S0n+** n+b9S7!2!2 S7l zMMO q? 65s   !'C11D	