
    pi                       d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl	m
Z
mZmZmZ ddlmZmZmZmZmZmZ ddlmZ ddlmZ dd	lmZmZmZmZ dd
lmZ erddl m!Z! eejD                   G d d                    Z#eejD                   G d d                    Z$ejJ                  dk\  rdejH                  de$fdZ&n4ejJ                  dk\  rdejH                  de$fdZ&ndejH                  de$fdZ& G d d      Z'ejJ                  dk\  r	de(de)fdZ*nejJ                  dk\  r	de(de)fdZ*nde(fdZ*de'ddde(dee+   d ee   d!ee$   de$f
d"Z,d!e$de$fd#Z-d!e$de)fd$Z.dd%ed&e)de$fd'Z/de$fd(Z0d)e+de1e$   fd*Z2d+ee$e1e$   f   de1e$   fd,Z3d+ee$e1e$   f   de1e$   fd-Z4d.e+d/e)de1e$   fd0Z5d.e+de1e$   fd1Z6de(de$fd2Z7d!e$de$fd3Z8d)e+de1e$   fd4Z9	 dd5ee+   d6ee+   d7e)de1e$   fd8Z:de+de1e$   fd9Z;d:e+de1e$   fd;Z<d<ede1e$   fd=Z=	 dd>e+d?e+de>e1e+   ee+e+gdf   f   fd@Z?dAe+de>e1e+   ee+e+gdf   ee+gdf   f   fdBZ@d)e+de1e+   fdCZAdAe+de>e1e+   eedD   e+gdf   f   fdEZBeejD                   G dF dG                    ZCd)e+de1e+   fdHZDdIee+   de+fdJZEdKe1eC   ddfdLZFdMeGde1eC   fdNZHdKe1eC   deGfdOZIdPe1e$   dQe+de>eGeGf   fdRZJdSeKe+e$f   dTe+dee$   fdUZLdPe
e$   ddfdVZM eNej                        ZPdWe$ddfdXZQdPe1e$   dYe+de$fdZZRdPe1e$   ddfd[ZSd\eGdPe1e$   ddfd]ZTdPe1e$   de1eC   fd^ZUdKe1e#   d_eKe$e+f   ddfd`ZVdPe1e$   ddfdaZWdPe1e$   ddfdbZXdPe1e$   ddfdcZYdde$dee1e$   de1e$   fdfZZdPe1e$   de1e$   fdgZ[dPe1e$   ddfdhZ\dPe1e$   ddfdiZ]djdkdldmZ^dPe1e$   ddfdnZ_dPe1e$   ddfdoZ`dPe1e$   ddfdpZadqej                  dPe1e$   ddfdrZcdPe1e$   de+fdsZddte$de+fduZedPee$   ddfdvZfdPee$   ddfdwZgdxeGde(fdyZhdqej                  ddfdzZi eNej                        Zk eNej                        Zm eNej                        Zo eNej                        Zqd{eKe(ef   d%ede+fd|Zr	 ddPe1e$   d{eKe(ef   d}eed~ef      ddfdZsdPe1e$   ddfdZtej                  de1e(   fd       Zv	 ddqej                  dee1e$   eKe(ef   ged   f   de)de>ej                  ed   f   fdZwdPe1e$   de1e(   d{eKe(ef   de>e1e$   ej                  f   fdZxdPee$   deddfdZyddqej                  de)de1e$   fdZzdPee$   de1e$   fdZ{ej                  	 ddqej                  de)dee$   fd       Z| ej                         Z~dde(de)de(fdZdqej                  de)fdZ	 	 	 dded~ef   deeeef      de)de)de1e$   f
dZy)a  
This module provides utilities for analyzing, transforming and manipulating Python bytecode.
It includes functionality for:
- Converting between different bytecode formats and versions
- Virtualizing jumps and managing jump targets
- Handling exception tables and their entries
- Managing instruction offsets and extended arguments
- Providing a clean API for bytecode modification and transformation
- Supporting Python version-specific bytecode features
- Generating bytecode from template functions

The module is designed to work across different Python versions (3.7+) and handles
version-specific bytecode differences transparently.
    N)IterableIteratorMappingSequence)AnyCallablecastOptionalTYPE_CHECKINGUnion   )dataclass_slots   )config)get_indexofpropagate_line_numsremove_extra_line_numsstacksize_analysis)is_safe_constant)DynamoTracerOutputc                   \    e Zd ZU ded<   ded<   ded<   eed<   eed<   defdZd	edefd
Z	y)InstructionExnTabEntryInstructionstartendtargetdepthlastireturnc                     d| j                   j                          d| j                  j                          d| j                  j                          d| j                   d| j
                   dS )NzInstructionExnTabEntry(start=z, end=z	, target=z, depth=z, lasti=))r   short_inst_reprr   r   r   r   selfs    g/opt/services/ai/voice_agent/venv/lib/python3.12/site-packages/torch/_dynamo/bytecode_transformation.py__repr__zInstructionExnTabEntry.__repr__3   sl    +DJJ,F,F,H+I J88++-. /kk1134 5ZZLA7	
    oc                 (   t        |t              sy| j                  |j                  u xrh | j                  |j                  u xrN | j                  |j                  u xr4 | j
                  |j
                  k(  xr | j                  |j                  k(  S NF)
isinstancer   r   r   r   r   r   )r$   r(   s     r%   __eq__zInstructionExnTabEntry.__eq__;   s}    !34JJ!''! &AEE!&qxx'& 

agg%& 

agg%	
r'   N)
__name__
__module____qualname____annotations__intboolstrr&   objectr,    r'   r%   r   r   *   s?     	JK
# 
	
 	
4 	
r'   r   c                       e Zd ZU dZeed<   eed<   ee   ed<   eed<   dZ	ee   ed<   dZ
ee   ed<   d	Zeed
<   dZed   ed<   dZed    ed<   dZee   ed<   dZee   ed<   defdZdedefdZdefdZddZy)r   z$A mutable version of dis.InstructionopcodeopnameargargvalNoffsetstarts_lineFis_jump_targetdis.Positions	positionsr   exn_tab_entryargreprr   c                     t        |       S Nidr#   s    r%   __hash__zInstruction.__hash__Y   s    $xr'   otherc                 0    t        |       t        |      k(  S rC   rD   r$   rG   s     r%   r,   zInstruction.__eq__\   s    $x2e9$$r'   c                 <    d| j                    d| j                   dS )NzInstruction(opname=z	, offset=r!   )r8   r;   r#   s    r%   r"   zInstruction.short_inst_repr_   s    $T[[M4;;-qIIr'   c                 H    |j                   | _         |j                  | _        y rC   )r<   r?   rI   s     r%   copy_positionszInstruction.copy_positionsb   s     ,,r'   )rG   r   r   N)r-   r.   r/   __doc__r1   r0   r3   r
   r   r;   r<   r=   r2   r?   r   r@   r   rA   rF   r4   r,   r"   rL   r5   r'   r%   r   r   G   s     /KK	#K FHSM !%K#% ND +/Ix(/&*FH]#*6:M823:!GXc]!# %F %t %J J)r'   r         ir   c           
          t        | j                  | j                  | j                  | j                  | j
                  | j                  | j                  | j                        S rC   )	r   r7   r8   r9   r:   r;   line_numberr=   r?   rQ   s    r%   convert_instructionrU   i   I    HHHHEEHHHHMMKK	
 		
r'   rO      c           
          t        | j                  | j                  | j                  | j                  | j
                  | j                  | j                  | j                        S rC   )	r   r7   r8   r9   r:   r;   r<   r=   r?   rT   s    r%   rU   rU   w   rV   r'   c           
          t        | j                  | j                  | j                  | j                  | j
                  | j                  | j                  d       S rC   )r   r7   r8   r9   r:   r;   r<   r=   rT   s    r%   rU   rU      sE    HHHHEEHHHHMM	
 		
r'   c                       e Zd ZdefdZy)_NotProvidedr   c                      y)Nr\   r5   r#   s    r%   r&   z_NotProvided.__repr__   s    r'   N)r-   r.   r/   r3   r&   r5   r'   r%   r\   r\      s    # r'   r\   rO      namec                 
    | dv S )N)	LOAD_ATTRLOAD_GLOBALLOAD_SUPER_ATTRr5   r`   s    r%   inst_has_op_bitsrf      s    FFFr'   c                     | dk(  S )Nrc   r5   re   s    r%   rf   rf      s    }$$r'   c                      yr*   r5   re   s    r%   rf   rf      s    r'   )r9   r:   r   r9   r:   r   c                    t        |       r|t        d      |%d}n"|du|t        uz   |duz   }|dkD  rt        d      |t        |t              st        d      t        t        j                  |    | |||      S )a  
    At most one of `arg`, `argval`, and `target` can be not None/_NotProvided.
    This is to prevent ambiguity, e.g. does
        create_instruction("LOAD_CONST", 5)
    mean load the constant at co_consts[5], or load the constant 5?

    If `arg` is not provided, it will be computed during assembly from
    `argval` or `target`.

    Bits in the args of instructions LOAD_GLOBAL, LOAD_ATTR (3.12+), and LOAD_SUPER_ATTR
    modify the behavior of the instruction. In this case, we allow both `arg`
    and `argval` to be set. The value of `arg` here is expected to be the value of
    the op bits and the true value of `arg` will be computed during assembly.
    If `arg` is not set, the bits are assumed to be 0.
    Nz*target cannot be specified for instructionr   r   z@only one of arg, argval, and target can be not None/_NotProvidedz#instruction arg must be int or None)r7   r8   r9   r:   r   )rf   RuntimeErrorr\   r+   r1   r   disopmap)r`   r9   r:   r   cnts        r%   create_instructionrn      s    0 KLL;C$6#=>&PTBTU7R  z#s3@AAyytVF r'   c                 J    t         j                  dk\  rdnd}t        ||       S )NrW   JUMP_FORWARDJUMP_ABSOLUTEr   sysversion_inforn   )r   insts     r%   create_jump_absoluterw      s#     --8>oDd622r'   c                     | j                   dv S )N)rp   rq   )r8   rr   s    r%   is_jump_absolutery      s    =====r'   valcheckedc                 J    |rt        |       s
J d|         t        d|       S )z
    In general we should only create `LOAD_CONST` for immutable objects, but
    sometimes it's convenient _and safe_ for Dynamo create `LOAD_CONST` for
    mutable objects. In such cases, use `checked=False`.
    zunsafe constant 
LOAD_CONSTr:   )r   rn   )rz   r{   s     r%   create_load_constr      s/     $>(8&>>$l377r'   c                  X    t         j                  dk\  rt        dd      S t        d      S )NrW   COPYr   r9   DUP_TOPrs   r5   r'   r%   create_dup_topr      s(    
7"!&a00i((r'   nc                    | dk  rg S t         j                  dk\  r&t        | dd      D cg c]  }t        d|       c}S t         j                  dk  r>| dk\  r9	 t        d|       t        d	|       t        d| dz
        t        d	| dz
        gS | d
k  rt        dg d| dz
     z         gS t        d|       gS c c}w )a  
    Returns a "simple" sequence of instructions that rotates TOS to the n-th
    position in the stack. For Python < 3.11, returns a single ROT_*
    instruction. If no such instruction exists, an error is raised and the
    caller is expected to generate an equivalent sequence of instructions.
    For Python >= 3.11, any rotation can be expressed as a simple sequence of
    swaps.
    r   rW   SWAPr   rO   
      BUILD_TUPLEUNPACK_SEQUENCE   ROT_)TWOTHREEFOURr   ROT_N)rt   ru   rangern   )r   rQ   s     r%   create_rot_nr      s     	Av	
7" <AAr?Ka"6q1KK '!a1f	 }!40a8}!a%80a!e<	
 	
 	Av"6,DQU,K#KLMMwA.//) Ls   B<inst_or_instsc                    t        | t              r| gnt        | t              sJ | dt        dt        ffd}dt        ddffd}t
        j                  dk\  r;t        d   j                        r |d      s
 |d       S t        d      gz   S t
        j                  d	k\  r_t        d   j                        r |d      s
 |d       S d
   j                  dk(  r |d
      s
 |d
       S t        d      gz   S t
        j                  dk\  r9t        d
   j                        r |d
      s
 |d
       S t        d      gz   S )a  
    Appends or prepends a PUSH_NULL instruction to `inst_or_insts`,
    depending on Python version. Used when you know that
    `inst_or_insts` generates a callable that will be called.

    NOTE: Assumes `inst_or_insts` is a single instruction or sequence of
    instructions that pushes exactly 1 object to the stack that is to
    be called. It is important that you include ALL instructions that
    construct the callable - not just the first instruction/a prefix.

    Will attempt to use the NULL push bit for instructions
    with such bits (LOAD_GLOBAL 3.11+, LOAD_ATTR 3.12+, LOAD_SUPER_ATTR).
    In this case, instructions WILL be modified.
    idxr   c                 P    |    j                   J |    j                   dz  dk(  S Nr   r   r   instss    r%   inst_has_bit_setz'add_push_null.<locals>.inst_has_bit_set*  s/    Sz~~)))Sz~~!Q&&r'   Nc                 X    |    j                   J |    xj                   dz  c_         y r   r   r   s    r%   set_inst_bitz#add_push_null.<locals>.set_inst_bit.  s)    Sz~~)))c
!r'   rN   r   	PUSH_NULLr^   r   rc   rW   )
r+   r   listr1   r2   rt   ru   rf   r8   rn   )r   r   r   r   s      @r%   add_push_nullr     su   " --$1?-...'c 'd '# $  7"E"I,,-6Fr6J & L# /<==E" L! 
		W	$ E"I,,-6Fr6J L 1X__-6Fq6IO L (45=E L 
		W	$E!HOO,5Ea5HO L (45=ELr'   c                    t        | t              r| g}nt        | t              sJ | }t        j                  dk  r|S t        j                  dk\  rdnd}||   j
                  dk(  r@||   j                  J ||   j                  dz  dk(  r||   xj                  dz  c_        |S t        j                  dk\  r|t        d      gz   }|S t        d      g|z   }|S )zLike add_push_null, but the low bit of LOAD_ATTR/LOAD_SUPER_ATTR
    is not set, due to an expected CALL_FUNCTION_EX instruction.
    rW   rN   r   r   rc   r   r   )r+   r   r   rt   ru   r8   r9   rn   )r   r   r   s      r%   add_push_null_call_function_exr   N  s     --$1?-...
'!  G+"CSzM)Sz~~))):>>A"#JNNaNL
7"+K899 L $K01E9Lr'   nargs	push_nullc                    t         j                  dk\  rg }|rQ|j                  t        d             t         j                  dk\  r| dz   n| dz   }|j	                  t        |             t         j                  dk  r|j                  t        d|              |j                  t        d	|              |S t        d
|       gS )aS  
    Creates a sequence of instructions that makes a function call.

    `push_null` is used in Python 3.11+ only. It is used in codegen when
    a function call is intended to be made with the NULL + fn convention,
    and we know that the NULL has not been pushed yet. We will push a
    NULL and rotate it to the correct position immediately before making
    the function call.

    `push_null` should be True if no NULL is pushed for the callable.
    Conversely, `push_null` should be False if a NULL was pushed for the callable.
    Prefer using `push_null=False` when possible since we will not need to rotate
    NULL to the right place, which is less efficient.

    Generally, you should codegen a function by using `add_push_null` then
    `create_call_function` with `push_null=False`.

    Example of when to set push_null False:

    insts = [
        create_instruction("LOAD_GLOBAL", argval="torch"),
        create_instruction("LOAD_ATTR", argval="nn"),
        create_instruction("LOAD_ATTR", argval="functional"),
        create_instruction("LOAD_ATTR", argval="relu"),
    ]
    insts = add_push_null(insts)
    insts.append(create_instruction("LOAD_FAST", argval="x"))
    insts.extend(create_call_function(1, False))

    Example of when to set push_null True:

    insts = [create_instruction("LOAD_FAST", x)]
    for should_wrap, wrapper_name in wrappers:
        if should_wrap:
            insts.extend([
                create_instruction("LOAD_GLOBAL", argval="wrapper1"),
                create_instruction("SWAP", arg=2),
                *create_call_function(1, True),
            )
    rW   r   rN   r   r   r^   PRECALLr   CALLCALL_FUNCTION)rt   ru   appendrn   extendr   )r   r   outputrotss       r%   create_call_functionr   l  s    R 7"MM,[9: # 0 0G ;519DMM,t,-g%MM,YEBC(U;<E:;;r'   c                     t         j                  dk\  rt        d|       gS t         j                  dk\  rt        d|       t        d|       gS t        d|       gS )Nr^   r   r   rW   r   CALL_METHODrs   )r   s    r%   create_call_methodr     s^    
7""6u566
7"ye4v51
 	
 }%899r'   c                 ^    t         j                  dk\  rt        dd|       S t        d|       S )Nr^   rb   r   )r9   r:   LOAD_METHODr~   rs   re   s    r%   create_load_methodr     s,    
7"!+1TBBmD99r'   c                 J    t         j                  dk\  rdnd}t        ||       S )NrW   BEFORE_WITH
SETUP_WITHrr   rs   )r   r8   s     r%   create_setup_withr     s#    !..'9]|FfV44r'   c                    t         j                  dk\  rt        d|       gS | dk(  rg S | dk(  rt        d      gS | dk(  rt        d      t        d      gS 	 t        d	| dz
        t        d
      t        dd      t        d      t        d      t        d
      t        d      t        dd      t        d      t        d
      t        d      gt	        d      t        d      t        d| dz
        S )NrW   r   r   r   r   ROT_TWOrO   	ROT_THREE
BUILD_LISTr   r}   r   r~   BINARY_SUBSCRSTORE_SUBSCRreverser   POP_TOPr   )rt   ru   rn   r   r   )r   s    r%   create_swapr     s   
7""6q122Av		
a"9-..	
a";/1CI1NOO& 	<QU39%<3?+;'9%;'<3>*9%9% 
A	 	9% 	,!a%8 r'   r   r   storec                     t         j                  dk\  r&|rdnd}t        |       t        |      t        |      gS |rdnd}t        |       t        |      t        dd      t        |      gS )	zQ
    BINARY_SLICE and STORE_SLICE (if `set` is True) for all Python versions
    r^   STORE_SLICEBINARY_SLICEr   r   BUILD_SLICEr   r   )rt   ru   r   rn   )r   r   r   	inst_names       r%   create_binary_slicer     st     7"%*M	e$c"y)
 	
 ',N	e$c"}!4y)	
 	
r'   c                     t         j                  dk\  rt        d|       gS g t        |       t	               t        | dz         t        d      S )NrW   r   r   r   r   )rt   ru   rn   r   r   rT   s    r%   create_copyr     sb    
7""6q122	Q 
QU	 
Q	 r'   r   c                     g t        t        dt                    t        | t        j
                  dk\  rdndz         t        dd      t        d      S )Nr}   r~   rW   r   r   Fr   )r   rn   printr   rt   ru   r   )r   s    r%   create_print_on_stackr     sb    	),uE	F	U3#3#3w#>aAF	G 
a	' 	9%	 r'   valuec                     g t        t        dt                    t        d|       t        dd      t        d      S )Nr}   r~   r   Fr   )r   rn   r   r   )r   s    r%   create_print_valuer     sP    	),uE	F<6 
a	' 	9%	 r'   linenobytenoc                 j     t         j                  dk  sJ g dt        dt        ddf fd}|fS )z
    Used to create typing.CodeType.co_lnotab
    See https://github.com/python/cpython/blob/main/Objects/lnotab_notes.txt
    This is the internal format of the line number table if Python < 3.10
    r   
lineno_new
byteno_newr   Nc                     |k7  s| k7  rkt        dt        |z
  d            }t        dt        | z
  d            }|dk7  s|dk7  sJ |z  |z  j                  ||dz  f       |k7  rd| k7  rjy y )Nr      i   maxminr   )r   r   byte_offsetline_offsetr   r   lnotabs       r%   updatezlnotab_writer.<locals>.update/  s    F"jF&:aZ&%8#!>?KdC
V(;S$ABK!#{a'777k!Fk!FMM;d(:;< F"jF&:r'   rt   ru   r1   )r   r   r   r   s   `` @r%   lnotab_writerr   $  sD     g%%%F=3 =C =D = 6>r'   first_linenoc                     t         j                  dk\  rt         j                  dk  sJ g | dddt        dt        ddffdd	t        d
t        ddffd}dt        ddffd}||fS )z
    Used to create typing.CodeType.co_linetable
    See https://github.com/python/cpython/blob/main/Objects/lnotab_notes.txt
    This is the internal format of the line number table for Python 3.10
    r   rW   r   byteno_deltalineno_deltar   Nc                     | dk7  s|dk7  ret        dt        | d            }t        dt        |d            }|dk7  s|dk7  sJ | |z  } ||z  }j                  ||dz  f       | dk7  r^|dk7  rdy y )Nr      ir   r   r   )r   r   r   r   	linetables       r%   _updatez%linetable_310_writer.<locals>._updateJ  s    a<1#4a\3!78KdCc$:;K!#{a'777K'LK'Lk;+=>? a<1#4r'   r   r   c                 4    |z
  }| |       | z
  | y rC   r5   )r   r   r   r   r   r   r   s      r%   r   z$linetable_310_writer.<locals>.updateS  s+    !F*l+!F*r'   total_bytesc                      | z
         y rC   r5   )r   r   r   r   s    r%   r   z!linetable_310_writer.<locals>.end[  s    f$l3r'   r   )r   r   r   r   r   r   r   r   s      @@@@@r%   linetable_310_writerr   <  s     w&3+;+;g+EEEIFLF@c @ @ @3 C D  4 4 4 fc!!r'   c                     | dk\  sJ | dz  g}| dz  } | dkD  r,|dxx   dz  cc<   |j                  | dz         | dz  } | dkD  r,|S )z~
    6-bit chunk encoding of an unsigned integer
    See https://github.com/python/cpython/blob/3.11/Objects/locations.md
    r   ?      r   @   )r   )r   bs     r%   encode_varintr   a  s`    
 6M6	
RA!GA
a%	"	R	a a% Hr'   r>   c                 p    t         j                  dk\  sJ g | dt        d   dt        ddffd}|fS )z
    Used to create typing.CodeType.co_linetable
    See https://github.com/python/cpython/blob/3.11/Objects/locations.md
    This is the internal format of the line number table for Python 3.11
    rW   r?   r>   	inst_sizer   Nc                       r j                   nd }dt        dt        dd f fd}|d}n|z
  }||dkD  r ||d       |dz  }|dkD  r |||       y )Ndeltasizer   c                    d|cxk  rdk  sJ  J d}r~j                   rj                  fj                  Zj                  Nj	                  d|z   dz
         j                  j                   z
  j                  dz   j                  dz   f}nj	                  d|z   dz
         | dk  r
|  dz  dz  } n| dz  } j                  t        |              |D ]  }j                  t        |              y )Nr      r5      r      )r   
end_lineno
col_offsetend_col_offsetr   r   r   )r   r   other_varintsr   r   r?   s       r%   r   z5linetable_311_writer.<locals>.update.<locals>._update  s   t=q= = = .0M$$0((4((4,,8  !4q!89 ((9+;+;;((1,,,q0!   !4q!89qy &Q!+!]512" 3  q!123r'   r   r   )r   r1   )r?   r   r   r   r   r   r   s   `    r%   r   z$linetable_311_writer.<locals>.update|  sx    )2Y%%
	33 	3c 	3d 	3@ L%.LF!mL!$NI !m 	i(r'   )rt   ru   r
   r1   )r   r   r   r   s     @@r%   linetable_311_writerr  p  sP     w&&&IF,)(?3 ,) ,) ,)\ fr'   c                   @    e Zd ZU eed<   eed<   eed<   eed<   eed<   y)ExceptionTableEntryr   r   r   r   r   N)r-   r.   r/   r1   r0   r2   r5   r'   r%   r  r    s     J	HKJKr'   r  c                     | dk\  sJ | dz  g}| dz  } | dkD  r|j                  | dz         | dz  } | dkD  r|j                          t        t        |      dz
        D ]  }||xx   dz  cc<    |S )zR
    Similar to `encode_varint`, but the 6-bit chunks are ordered in reverse.
    r   r   r   r   r   )r   r   r   len)r   r   rQ   s      r%   encode_exception_table_varintr    s     6M6	
RA!GA
a%	R	a a% IIK3q6A: 	!
Hr'   
bytes_iterc                 l    t        |       }|dz  }|dz  r|dz  }t        |       }||dz  z  }|dz  r|S )z5
    Inverse of `encode_exception_table_varint`.
    r   r   r   )next)r  r   rz   s      r%   decode_exception_table_varintr    sN     	ZA
b&C
b&	q2v b& Jr'   tabc                    t        t        |       dz
        D ]j  }| |   j                  | |   j                  k  rH| |   j                  | |dz      j                  k  r&| |dz      j                  | |dz      j                  k  rjJ  y)z
    Verifies that a list of ExceptionTableEntries will make a well-formed
    jump table: entries are non-empty, sorted, and do not overlap.
    r   N)r   r  r   r   )r  rQ   s     r%   check_exception_tabler    s    
 3s8a<  
FLLCFJJ&A

SQZ---AE
  CAJNN2	
3
r'   exntabc           	      6   t        |       }g }	 	 t        |      dz  }t        |      dz  }||z   dz
  }t        |      dz  }t        |      }|dz	  }t        |dz        }	|j                  t	        |||||	             o# t
        $ r t        |       |cY S w xY w)z
    Parse the exception table according to
    https://github.com/python/cpython/blob/3.11/Objects/exception_handling_notes.txt
    r   r   )iterr  r2   r   r  StopIterationr  )
r  exntab_iterr  r   lengthr   r   dlr   r   s
             r%   parse_exception_tabler    s    
 v,K
C1+>BE2;?!CF&.1$C2;?!CF.{;B!GEaLEJJ*5#vueLM   c"
s   A0A? ?BBc                    g }| D ]  }t        |j                  dz        }|dxx   dz  cc<   |j                  |       |j                  |j                  z
  dz   }|j                  t        |dz               |j                  t        |j                  dz               |j
                  dz  |j                  z   }|j                  t        |              t        |      S )zd
    Inverse of parse_exception_table - encodes list of exception
    table entries into bytes.
    r   r      r   )r  r   r   r   r   r   r   bytes)r  r   entryfirst_entryr  r  s         r%   assemble_exception_tabler    s    
 	A 43EKK14DEA& 	U[[(1,	.v{;<	.u||q/@ABkkQ%++-	.r234 8Or'   instructionsfirstlinenoc                    g }t         j                  dk\  rt        |      \  }}d}t        |       D ]  \  }}|j                  dk(  r=d}|dz  }dD ]0  }	| ||	z      j                  dk7  s| ||	z      j
                  |_         n nt        |      dz  |z   }d} ||j
                  |       d}|j                  xs d}
|j                  |j                  |
dz  f       t        t        |      dz  dz
        D ]  }|j                  d         nt         j                  d	k  rt        |      \  }}nt        |      \  }}}| D ]Z  }|j                   ||j                  t        |             |j                  xs d}
|j                  |j                  |
dz  f       \ t         j                  d	k\  r t        |             t        |      t        |      fS )
z)Do the opposite of dis.get_instructions()rW   r   EXTENDED_ARGr   r   r   rO   r   r   )r   r   r   )rt   ru   r  	enumerater8   r?   instruction_sizer9   r   r7   r   r   r   r<   r  r  )r  r  coder   update_linenonum_extrQ   rv   r   jr9   _r   s                r%   assembler)  	  s   D
7" 4[ A . 	$GAt{{n,	1" A#AE*11^C)5a!e)<)F)F
 -T2a7'A	$..)4G((-aCKKcDj12+D1Q6:; $F#$!	$& g%$1+$>!FM)=k)J&FM3  	3D+d..D	:((-aCKKcDj12		3 w&D	N;f%%r'   offset_to_instr;   c                 l    dD ]/  }| ||z      j                   t        j                  k7  s'| ||z      c S  y)zU
    Get the instruction located at a given offset, accounting for EXTENDED_ARGs
    )r   r   r   r   Nr7   rk   r   )r*  r;   r   s      r%   _get_instruction_by_offsetr-  3  sD      .&1*%,,0@0@@!&1*--. r'   c                    | D ci c]  }|j                   |j                   | }}| D ]V  }|j                  t        j                  v s|j                  t        j                  v s<t        ||j                        |_        X yc c}w )z9Replace jump targets with pointers to make editing easierN)r;   r7   rk   hasjabshasjrelr-  r:   r   )r  rv   jump_targetss      r%   virtualize_jumpsr2  ?  sy     '3"dkk6MTL   P;;#++%)C4\4;;ODKP	s
   BBinstructionc                    t         j                  dk  rt        d      d| j                  v r"| j                  j	                  dd      | _        n;d| j                  v r"| j                  j	                  dd      | _        nt        d      t        j                  | j                     | _        | j                  t        v sJ y )NrW   z+Cannot flip jump direction in Python < 3.11FORWARDBACKWARDz-Instruction is not a forward or backward jump)
rt   ru   rj   r8   replaceAttributeErrorrk   rl   r7   
_REL_JUMPS)r3  s    r%   flip_jump_directionr:  M  s    
'!HIIK&&&(//77	:N	{))	)(//77
INLMM;#5#56K+++r'   r   c                     | |   }dD ]5  }||k\  r,| ||z
     j                   t        j                  k(  r	| ||z
     }4 |S  |S )zp
    i.e. get the first EXTENDED_ARG instruction (if any) when targeting
    instructions[idx] with a jump.
    r!  r,  )r  r   r   r;   s       r%   _get_instruction_frontr<  Z  s]    
 #F &=\#,7>>#BRBRR!#,/FM
 Mr'   c           	      F   t        t        j                        j                  t        t        j                              }| D ]  }|j
                  |v s|j
                  t        j                  vs/|j                  "|j                  j                  |j                  J |j                  j                  |j                  k  r9t        j                  dk  rt        d      d|j                  v st        |       t        j                  dk\  sd|j                  v st        |        t        |        t        |       }| D ]Y  }|j
                  |v s|j                  J t        | ||j                           }|j
                  t        j                  v rat        j                  dk  r|j                  |_        nt        j                  dk  rt#        |j                  dz        |_        nt        d      |j                  |j                  J t%        t#        |j                  |j                  z
  t'        |      z
              |_        t        j                  dk\  r|xj                   dz  c_        |j                  |_        d	|j                   |_        \ y)
zJFill in args for virtualized jump target after instructions may have movedNrW   z*Got negative jump offset for Python < 3.11r5  r6  r   r   z+Python 3.11+ should not have absolute jumpszto )setrk   r/  unionr0  r7   r   r;   rt   ru   rj   r8   r:  update_offsetsr   r<  r9   r1   absr#  r:   rA   )r  jumpsrv   indexofr   s        r%   devirtualize_jumpsrD  h  s   ""3s{{#34E  2;;%{{#++-KK+**6/0 ;;%%3'''1*+WXX DKK/+D1 ''72zT[[7P+D1#2( < ,'G  1;;%;;***+L'$++:NOF{{ckk)##g-%}}DH%%/  #6==1#45DH&'TUU }}0T[[5LLL36Ft6LLM ##w.HHNH --DK 0DL/1r'   exn_tab_bytesc                 B  	
 t        |       }|D ci c]  }t        t        |j                        | c}	t	        	j                               
dt        |      	 dt        t        t        f   f	
fd} |       \  }}|D ]  }|j                  J |j                  |j                  kD  r$ |       \  }}|j                  |j                  kD  r$|j                  |j                  k\  sht        j                  |      |_         yc c}w # t        $ r Y yw xY w)zDReplace exception table entries with pointers to make editing easierr   r   c                  v   t              } t              k  r8   | j                  k  r&dz  t              k  r   | j                  k  r&dkD  sJ dz
     }t        t	        | j
                        t	        |      t	        | j                        | j                  | j                        }| |fS )Nr   r   )	r
  r  r   r   r-  r   r   r   r   )r  
end_offset
inst_entryend_offset_idxexn_tab_iterr*  offsetss      r%   stepz(virtualize_exception_table.<locals>.step  s    &E W-'.2IUYY2V!# W-'.2IUYY2V "A%%% !!34J/*>5;;G*>:F*>5<<HJ *$$r'   N)r  r	   r1   r;   sortedkeysr  tupler  r   r   r   copyr@   r  )rE  r  exn_tabrv   rM  r  rI  rJ  rK  r*  rL  s          @@@@r%   virtualize_exception_tablerS    s	    $M2G?KLtd3,d2LN^((*+GN=L 	%e/1GGH 	% 	%, !Fz  	;D;;***++		)$(F!z ++		){{ekk)%)YYz%:"	;; MF  s$   "D A5D D 0D 	DDc           	      0   i t        |       }| D ]  }|j                  st        | ||j                  j                           j                  }|J t        t        |j                  j                  j                        t        |j                  j                        z   dz
  }|J t        | ||j                  j                           j                  }|J ||f}||j                  j                  |j                  j                  f}|v r
|   |k(  sJ ||<    t        j                         d       }dg g dfd}	|D ]  }r&d   d   |d   k  r |	        rd   d   |d   k  rrod   d   |d   cxk  r|d   cxk  rd   d   k  sJ  J t        d   d         }
|
|d   k  r(j                  t!        |
|d   dz
  gd              |d   j                  |        r
 |	        r
t#               S )	zMCompute exception table in list format from instructions with exn_tab_entriesr   c                     | d   | d    fS Nr   r   r5   ts    r%   <lambda>z)compute_exception_table.<locals>.<lambda>  s    1!u r'   keyr   c                      rQj                         } | d   k  r8j                  t        t        | d         | d   g|            | d   dz   yyy)zT
        Pop the key_stack and append an exception table entry if possible.
        r   r   r   N)popr   r  r   )r[  exn_dictrR  	key_stacknextis    r%   r]  z$compute_exception_table.<locals>.pop  se    
 --/CA'CFE(:CFSXc]S A
	  r'   r   r   )r   N)r   r@   r<  r   r;   r	   r1   r   r#  r   r   r   rN  rO  r   r   r  r  )r  rC  rv   r   r   r   r[  rz   keys_sortedr]  leftr^  rR  r_  r`  s              @@@@r%   compute_exception_tablerc    sh    >@H,'G  *gd&8&8&>&>?f  $$$ S$,,00778"4#5#5#9#9:; 
 ?"?+gd&8&8&?&?@f  %%%#,C4--33T5G5G5M5MNCh}+++HSM- < .EFKE')I)+G# #  IbM!,s1v5E IbM!,s1v5R=#s1vKQK9R=;KKKKKKuimA./Dc!f}'c!fqjS8IbM;RS FE  '"Nr'   rC  c                 *   g }| D ]  }||j                      ||j                     f}|r/|d   d   |d   k  r!|j                          |r|d   d   |d   k  r!|r(|d   d   |d   cxk  r|d   cxk  r|d   d   k  sJ  J |j                  |        y)z
    Checks `tab` is a properly sorted list of nested InstructionExnTabEntry's,
    i.e. no entries partially overlap.
    "Properly sorted" means entries are sorted by increasing starts, then
    decreasing ends.
    r   r   r   N)r   r   r]  r   )r  rC  entry_stackr  r[  s        r%   !check_inst_exn_tab_entries_nestedrf    s     *,K  u{{#WUYY%78k"oa03q69OO k"oa03q69r?1%QO3q6O[_Q=OOOOOO3 r'   c                    t        |       }i }| D ]h  }|j                  s||j                  j                     ||j                  j                     f}||v r|j                  ||   k(  sJ |j                  ||<   j t	        |j                         d       D cg c]  }||   	 }}t        ||       |D ]M  }t        ||j                     ||j                     dz         D ]  }t        j                  |      | |   _        ! O yc c}w )z~
    Copies exception table entries to all instructions in an entry's range.
    Supports nested exception table entries.
    c                     | d   | d    fS rV  r5   rW  s    r%   rY  z2propagate_inst_exn_table_entries.<locals>.<lambda><  s    adQqTE] r'   rZ  r   N)	r   r@   r   r   rN  rO  rf  r   rQ  )r  rC  entriesrv   r[  sorted_entriesr  rQ   s           r%    propagate_inst_exn_table_entriesrk  +  s   
 ,'G=?G .**001**../C g~))WS\999--GCL. !'w||~;R SN  &ng>   =wu{{+WUYY-?!-CD 	=A,0IIe,<LO)	==s   Dc                    t        |       }t               }t        |       D ]  \  }}|j                  st        j
                  dk\  sJ t        |j                        |vsJ |j                  t        |j                               |j                  }|j                  |v sJ |j                  |v sJ |j                  |v sJ ||j                     |cxk  r||j                     k  rJ  J  y)aJ  
    Checks that exn_tab_entries of instructions are valid.
    An entry's start, end, and target must be in instructions.
    Instructions with an exn_tab_entry are located within
    the entry's start and end instructions.
    Instructions do not share exn_tab_entries.

    Implicitly checks for no duplicate instructions.
    rW   N)r   r>  r"  r@   rt   ru   rE   addr   r   r   )r  rC  exn_tab_entry_setrQ   rv   r  s         r%    check_inst_exn_tab_entries_validro  F  s     ,'G\* 	C4##w...d(()1BBBB!!"T%7%7"89&&E;;')))99'''<<7***5;;'1B		0BBBBBB	Cr'   c                 p    | D cg c]"  }|j                   t        j                  k7  s!|$ c}| d d  y c c}w rC   r,  )r  rQ   s     r%   strip_extended_argsrq  ^  s*    ".OQ!((c>N>N2NqOLOOs   "33old_inst	new_instsc                    | j                   r:| j                   j                  | u r"t        |      dkD  r|d   | j                   _        |dd  D ]7  }t        j                  | j                         |_         | j                  |_        9 |d   j
                  | _        |d   j                  | _        |d   j                  | _        |d   j                  | _        |d   j                  | _	        | g|dd  z   S )Nr   r   r   )
r@   r   r  rQ  r?   r7   r8   r9   r:   r   )rr  rs  rv   s      r%   overwrite_instructionru  g  s    
 	""&&(2	NQ%.r]"!" ,!YYx'='=>!++,  l))HOl))HOQ<##HLl))HOl))HO:	!"%%r'   c                     t         j                  dk  sJ ddd}| D ]G  }|j                  |v s||j                     |_        t        j                  |j                     |_        I | S )zFLOAD_METHOD puts a NULL on the stack which causes issues, so remove itrW   rb   r   )r   r   )rt   ru   r8   rk   rl   r7   )r  rewritesrv   s      r%   remove_load_call_methodrx  ~  sg    g%%%*?KH 1;;(""4;;/DK))DKK0DK1 r'   c                    g }| D ]  }d|j                   v rt        dt        d|j                   v             }|j                  |_        t
        j                  dk  r(t        d|j                   v rdnd|j                  	      }nt        d
|j                  	      }t        dd       ||g}|j                  t        ||             |j                  |        || d d  y )N_NONEIS_OPNOTr   r^   r5  POP_JUMP_FORWARD_IF_TRUEPOP_JUMP_BACKWARD_IF_TRUErr   POP_JUMP_IF_TRUEr}   r~   )r8   rn   r1   r9   r:   rt   ru   r   r   ru  r   )r  rs  rv   is_opjump_opreplace_instss         r%   remove_jump_if_noner    s    I #dkk!&wC8L4MNE 99EL'), %3 38;; --?T #<=M
 24GHT"3#4  LOr'   c                    g }| D ]  }|j                  |       |j                  dv s#t        |j                  j                  dd            }|j                  r)|j                  j
                  |u r||j                  _        t        j                  |j                        |_        |j                  |_        t        j                  d   |_
        d|_        d|_        d|_        |j                  |        || d d  y )N)r   r   SLICESUBSCRr   r   )r   r8   rn   r7  r@   r   rQ  r?   rk   rl   r7   r9   r:   )r  rs  rv   subscr_insts       r%   remove_binary_store_slicer    s    I *;;99,T[[-@-@(-STK!!d&8&8&<&<&D)4""&(,		$2D2D(EK%$(NNK!))M2DK'DKDHDK[)*  LOr'   )	LOAD_FASTr  )
STORE_FASTr  )r  r  )LOAD_FAST_LOAD_FASTSTORE_FAST_STORE_FASTSTORE_FAST_LOAD_FASTc                    g }| D ]  }|j                   t        v r[t        |j                      \  }}|j                  \  }}t        ||      t        ||      g}|j	                  t        ||             p|j                  |        || d d  y )Nr~   )r8   FUSED_INSTSr:   rn   r   ru  r   )r  rs  rv   inst0inst1argval0argval1r  s           r%   remove_fused_load_storer    s    I #;;+%&t{{3LE5#{{GW #59"59M 24GHT"#  LOr'   c                     g }| D ]k  }d|j                   v rJt        dd      t        |j                   |j                        g}|j                  t	        ||             [|j                  |       m || d d  y )NRETURNNOPGRAPH_BREAK_IF_LEAFr~   )r8   rn   r:   r   ru  r   )r  rs  rv   r  s       r%   $add_graph_break_if_leaf_instructionsr    sw    I #t{{""51FG"4;;t{{CM 24GHT"#  LOr'   c                    g }t        | | dd        D ]$  \  }}|j                  dk(  r|j                  dk(  r|j                  j                  d      rt	        t        |             D ]  }| |   j                  |u r
|| |   _        | |   j                  s.| |   j                  j                  |u r|| |   j                  _        | |   j                  j                  |u r|| |   j                  _	        | |   j                  j                  |u s|| |   j                  _         |j                  |       ' |j                  | d          || d d  y )Nr   r  r  r  r   )zipr8   r:   
startswithr   r  r   r@   r   r   r   )r  rs  rv   	next_instrQ   s        r%   'remove_graph_break_if_leaf_instructionsr    sK   I|\!"-=> #iKK5 44  ++H5 3|,- I?))T1-6LO*?00 $A44::dB>GQ55;#A4488D@<EQ559#A44;;tC?HQ55<I T")#* \"%&LOr'   r$  c                 x   | j                   xs d| j                  xs dz   }t        | j                        syg }t	        |      D ]m  \  }}|j                  |       |j                  dk(  s(|j                  dk(  s8||dz      }|j                  dk(  sPt        j                  dk\  r|j                  dk(  sYt        j                  d	k\  r"t        j                  dk  r|j                  d
k(  s$t        j                  d	k  s|j                  dk(  sd|v sJ |j                  t        dd             | j                  d   }||v r|j                  t        d|             n|j                  t        d|             d|_        d|_        |j                  d
k(  sX||dz      }d|_        d|_        p ||dd y)z3convert super() with no args into explicit arg formr5   Nrc   superr   r   r^   r   rW   r   r   	__class__
LOAD_DEREFr~   r  r   )co_cellvarsco_freevarsr  co_varnamesr"  r   r8   r:   r9   rt   ru   rn   )	r$  r  cell_and_freer   r   rv   r`  	first_var	call_insts	            r%   explicit_superr    s   %%+0@0@0FBGMt F|, )	Td;;-'DKK7,B q)EyyA~!!W,1G$$/((72	1$$w.5<<?3R"m3330kRS ,,Q/	-MM"4\)"TUMM"4["ST	 <<9, ,S1W 5I$%IM'(I$5)8 LOr'   c                    g dt         ddffd}| D ]  }|j                  t        j                  k(  r	d|_        na|j                  r|j                  dkD  r |d       j                  t        d|j                  d	z	  
             j                  t        d|j                  dz	  
             j                  t        d|j                  dz	  
             n|j                  rj|j                  dkD  r[ |d       j                  t        d|j                  dz	  
             j                  t        d|j                  dz	  
             nL|j                  r@|j                  dkD  r1 |d       j                  t        d|j                  dz	  
             j                  |        t              t        |       z
  }|dk\  sJ | dd |S )z,Fill in correct argvals for EXTENDED_ARG opsr   r   Nc                     t        |       D ]6  }sd   j                  t        j                  k(  s'j	                          8 y )Nr   )r   r7   rk   r   r]  )r   r(  r   s     r%   maybe_pop_nz&fix_extended_args.<locals>.maybe_pop_n)  s9    q 	A&*++s/?/??

	r'   r   i rO   r      r      r   i  r   r   r   )r1   r7   rk   r   r9   r   rn   r  )r  r  rv   addedr   s       @r%   fix_extended_argsr  %  sr    "Fs t 
  ;;#***DHXX$((X-NMM,^RPQMM,^RPQMM,^QOPXX$((V+NMM,^RPQMM,^QOPXX$((T/NMM,^QOPd!$ K#l++EA::LOLr'   rv   c                     dd l }t        j                  dk\  r=d|j                  j                  j
                  j                  | j                     dz   z  S y)Nr   rW   r   r   )torchrt   ru   _C_dynamo
eval_framepy_opcode_cachesr7   )rv   r  s     r%   r#  r#  F  sF    
7"EHH$$//@@MPQQRRr'   c                 T    d}| D ]!  }|j                   |k(  sJ |t        |      z  }# y Nr   r;   r#  r  r;   rv   s      r%   check_offsetsr  N  s8    F ){{f$$$"4(()r'   c                 @    d}| D ]  }||_         |t        |      z  } y r  r  r  s      r%   r@  r@  U  s-    F )"4(()r'   argsc            	      N   t        t        t        t        |                   }|gt	        |       z   t        | d   | d         D cg c]  \  }}t        ||k7         c}}gz   D cg c]  }dj                  d |D               }}ddj                  |      z   S c c}}w c c}w )Nr    c              3   $   K   | ]  }|d  
 yw)03Nr5   ).0xs     r%   	<genexpr>zdebug_bytes.<locals>.<genexpr>_  s     (qAb6(s   zbytes mismatch

)r   r   mapr  r   r  r1   join)r  indexar   r9   results         r%   debug_bytesr  \  s    #c#tn%&E 7
t*$'R$r($;<DAqCQK<
=> 	(C((F  		& 111 =	s   B'B"c                     t        | d d      \  }}| j                  |j                  k(  s%J t        | j                  |j                               | j                  |j                  k(  s%J t        | j                  |j                               y)z<Make sure our assembler produces same bytes as we start withc                      y rC   r5   )r  ys     r%   rY  zdebug_checks.<locals>.<lambda>j  s    r'   T)safeN)transform_code_objectco_coder  	co_lnotab)r$  doder(  s      r%   debug_checksr  h  si    #D*;$GGD!<<4<<'PT\\4<<)PP'>>T^^+X[-XX+r'   code_optionsc                 |    t        | d         D ]  \  }}||u s|c S  | dxx   |fz  cc<   t        | d         dz
  S )N	co_constsr   )r"  r  )r  rz   rQ   vs       r%   get_const_indexr  u  sV    ,{34 1
 !8H #'|K()A--r'   varname_from_oparg.c                 @
   	
 t        d         D ci c]  \  }}||
 c}}dt        dt        ffd}t        j                  dk  rO|J t        d         D ci c]  \  }}||
 c}}t        d   d   z         D ci c]  \  }}||
 c}}	njt        |      sJ i }t        j                         D ]  }	  ||      }|||<    d   D ci c]  }|||   
 c}d   d   z   D ci c]  }|||   
 c}	t        t                     D ]  
dt        f
 fd	} 
   j                  d
k(  r 
   j                  t        usJ t        j                  dk\  rS 
   j                  J  | 
   j                        dz  t!        t         
   j                        dz  z    
   _         | 
   j                         
   _         
   j                  dk(  r 
   j                  t        usJ t        j                  dk\  rT 
   j                  J  | 
   j                        dz  t!        t         
   j                        dz  z    
   _        N | 
   j                         
   _        m 
   j                  dk(  rn 
   j                  J  
   j                  t        usJ  | 
   j                        dz  t!        t         
   j                        dz  z   dz    
   _         
   j                  t"        v rt        j                  dk\  sJ t%         
   j                  t&              sJ t         
   j                        dk(  sJ t'        	fd 
   j                  D              }|d   dz  |d   dz  z    
   _         
   j(                  t*        v re |       st        j                  dk\  r- 
   j                  vr	 
   j                      
   _         
   j                      
   _        
 
   j(                  t,        v r( |       s( | 
   j                         
   _        G 
   j(                  t.        v r% |       se	 
   j                      
   _         
   j(                  t0        v s 
   j                  t3         
   j                        }|dk\  sJ | 
   _         y c c}}w c c}}w c c}}w # t        $ r Y  >w xY wc c}w c c}w )Nco_namesr`   r   c                     	 |    }|S # t         $ r= t              x}| <   g d   | d<   t        d         t              k(  sJ Y |S w xY w)Nr  )KeyErrorr  )r`   r   r  namess     r%   get_name_indexz fix_vars.<locals>.get_name_index  su    	?+C 
  	? #E
*C%+'Hj)A'H4'HL$|J/0CJ>>>
	?s   
 AAArW   r  r  r  c                  .        j                   t        uS rC   )r:   r\   )rQ   r  s   r%   should_compute_argz$fix_vars.<locals>.should_compute_arg  s    ?))==r'   rc   r   r   rb   r^   rd   rN   c              3   :   K   | ]  }|v r|   n|     y wrC   r5   )r  r`   	freenamesvarnamess     r%   r  zfix_vars.<locals>.<genexpr>  s-       #'("2	$Gs   r   r      )r"  r3   r1   rt   ru   callable	itertoolscount
IndexErrorr   r  r2   r8   r:   r\   r9   r	   r  r+   rP  r7   	HAS_LOCALHAS_NAMEHAS_FREE	HAS_CONSTr  )r  r  r  r   r`   r  allnamesr  	arg_tupler  rQ   r  r  s   ``       @@@@r%   fix_varsr    sM    )2,z2J(KL93T3YLES S  '!!)))/8m9T/UV)#tD#IV ']+l=.II
T #I
	 *+++??$ 	C)#.!$	 6B-5PQTD(4.(Q %]3l=6QQ
 (4. 
	 3|$% C*	>D 	> ?!!]2?))===7*#A**666'5l1o6L6L'MQR'Rl1o112Q6'Q# '5\!_5K5K&LQ#!_##{2?))===7*#A**666'5l1o6L6L'MQR'Rl1o112Q6'Q# '5\!_5K5K&LQ#!_##'88?&&222?))===  Q 6 671<\!_001A57 O
 !_##{2##w...l1o44e<<<|A--.!333 (O22 I $-Q<1#419J"KLO!_##y0!#$$/$Q..h> +4LO4J4J*KLO'*2<?3I3I*JLO'!_##x/!#&4\!_5K5K&LQ#!_##x/!#&/Q0F0F&GQ#!_##y0 A""*%lLO4J4JKaxx&)Q#GC*G M W
  Q
s/   S3$S9S?TT8T	TTc                     | D ]t  }|j                   t        us|j                  t        v s7|j                  t        v s%|j                  t
        v s|j                  t        v s_|j                  dvsnd |_        v y )N)rc   rb   rd   )	r:   r\   r7   r  r  r  r  r8   r9   )r  rv   s     r%   clear_instruction_argsr    sc      KK|+y(;;(*;;(*;;)+#RRDHr'   c                     dg} | j                  d       | j                  g d       t        j                  dk\  r| j                  d       | j                  d       t        j                  dk\  r| j                  d       n| j                  d	       t        j                  dk\  r| j                  d
       | j                  ddg       | S )Nco_argcountco_posonlyargcount)
co_kwonlyargcount
co_nlocalsco_stacksizeco_flagsr  r  r  r  co_filenameco_namerW   co_qualnameco_firstlinenor   co_linetabler  co_exceptiontabler  r  )r   r   rt   ru   )rO  s    r%   get_code_keysr    s    
 ?DKK$%KK	
 7"M"KK !
7"N#K 
7"'(KK	
 Kr'   transformationsr   r  c                     t               }|D ci c]  }|t        | |       }}t        |d         |d   k(  sJ t        | |      }t	        |        |||      }t        |||      \  }}	|	|fS c c}w )Nr  r  )r  getattrr  cleaned_instructionsr   clean_and_assemble_instructions)
r$  r  r  rO  kr  r  tracer_outputr(  bytecodes
             r%   r  r  )  s     ?D156AAwtQ''6L6|M*+|L/IIII'd3L%#L,?M1,lSKAx]"" 7s   A/rO  c                    t        |        t        |        t        |d         |d<   d }t        j                  dk\  r/t        j                  |D cg c]  }||   	 c} }|j                  }t        | ||       d}|r-t        |        t        |        t        t        |             }|r-t        |        t        | |d         \  }}t        j                  dk  r||d<   n||d	<   ||d
<   t        |       |d<   t!        |      dhz
  t!        |j#                               dhz
  k(  sJ t        j                  dk\  rt%        t'        |             |d<   | t        j                  |D cg c]  }||   	 c} fS c c}w c c}w )Nr  r  rW   )r  Tr  r   r  r   r  r  r  r  )r  ro  r  rt   ru   typesCodeType_varname_from_opargr  r@  rD  r2   r  r   r)  r   r>  rO  r  rc  )	r  rO  r  r  r  tmp_codedirtyr
  r   s	            r%   r  r  =  s    ,L9$\2!$\-%@!AL
7">>T#BLO#BC%99\<<NOE
|$<(&|45	  <(l;K.LMHf
'!$*[!'-^$&L#5l#CL t9,--\5F5F5H1IM 2    7",D#L1-
() 4)Ha,q/)HIII9 $C8 *Is   E7&E<
constsc                 Z    | D ]&  }|j                   dk(  s||j                     |_        ( y )NKW_NAMES)r8   r9   r:   )r  r  rv   s      r%   populate_kw_names_argvalr  g  s-     +;;*$ *DK+r'   c                 0    t        | |      }t        |      S rC   )_cached_cleaned_instructions_clone_instructionsr$  r  r  s      r%   r  r  o  s    /d;L |,,r'   c                 V   | D cg c]  }t        |j                  |j                  |j                  |j                  |j
                  |j                  |j                  |j                  |j                  |j                  |j                         }}t        t        | |            }d |d <   |D ]t  }||j                     |_	        |j                  x}s&t        ||j                     ||j                      ||j                     |j"                  |j$                        |_
        v |S c c}w rC   )r   r7   r8   r9   r:   r;   r<   r=   r?   r   r@   rA   dictr  r   r   r   r   r   )r  rQ   copiedremapr  s        r%   r  r  w  s
   "   	HHHHEEHHHHMMKKHHOOII	
F " \6*+EE$K 	?OO#5#4ekk"eii ell#AO	 M?s   B
D&c                    t        t        t        t        j                  |                   }t        |       t        |       t        j                  dk\  r,t        || j                         t        | j                  |       t        |       t        |       |st        j                  dk  rt        |       t        j                  dk  rt!        | |       t        j                  dk\  rGt#        |       t        j                  dk\  rt%        |       t        j                  dk\  rt'        |       t(        j*                  rt-        |       t        j                  dk\  rt/        |       t1        |       |S )NrW   r^   rN   )r   r  rU   rk   get_instructionsr   r  rt   ru   r  r  rS  r  r2  rq  rx  r  r  r  r  r   &debug_force_graph_break_on_leaf_returnr  r@  rD  r  s      r%   r  r    s    /1E1Ed1KLML%,
7" t~~>"4#9#9<H\"%g%#L1g%4.w&-7*),77*'5880>
7"|$<(r'   	with_uuidc                     |  dt        t               }|r*|dt        j                          j	                  dd      z  }|S )Nr(  -)r
  _unique_id_counteruuiduuid4r7  )r`   r   rets      r%   	unique_idr'    sE    F!D+,-
.C4::<.!))#s33Jr'   c                 *    d}| j                   |z  dkD  S )N    r   )r  )r$  co_generators     r%   is_generatorr+    s    LMML(A--r'   fnvarname_mapnoreturnnoprefixc                    t        | j                        }t        |       |r,t        |      D ]  \  }}|j                  dk(  s||dz   d } n |D ]6  }d|_        d|_        |s|j                  |v s#||j                     |_        8 |rt        j                  dk\  rvg }|D ]m  }|j                  dk(  rKt        j                  d   |_        d|_        |j                  |       |j                  t        d             ]|j                  |       o |}g }|D ]#  }|j                  dk(  s|j                  |       % t        |      dk(  r|d   |d	   u r|j!                  d	       |S t        |      dkD  r|d	   |d	   u rOd
|d	   _        t        j                  d
   |d	   _        d|d	   _        t$        |d	   _        |j!                  d	       n|j                  t        d
             |D ]e  }t'        |d	         }	|	j                  |_        |	j                  |_        |	j"                  |_        |	j                  |_        |	j(                  |_        g |S )a  Generates bytecode from a template function `fn` for use in
    dynamo bytecode generation.

    For example, we can generate Python-version-independent bytecode
    for looping through a dictionary and copying the values to a new dictionary.

    def template(d1, d2):
        for k, v in d1.items():
            d2[k] = v


    or a try block:

    def template():
        try:
            dummy1
        except:
            dummy2
            raise
        dummy3

    Args:
        fn: a function template to generate bytecode from
        varname_map: a mapping of `fn`'s varnames to new names. This
            map will be applied to the generated bytecode's varnames.
            For example, local variables in `fn` can be replaced with
            new names that are generated by `OutputGraph.new_var`.
        noreturn: remove all RETURN_* bytecodes and replace them with a jump
            to the end of the bytecode. NOTE: any items pushed to the stack
            for return WILL remain on the stack! Append a POP_TOP if you don't want
            that item to be present.
        noprefix: remove prefix bytecodes (all bytecode before the first RESUME, inclusive).
    RESUMEr   Nr^   RETURN_CONSTr}   RETURN_VALUEr   r   r  )r  __code__r  r"  r8   r<   r?   r:   rt   ru   rk   rl   r7   r   rn   r  r]  r9   r\   rw   r   )
r,  r-  r.  r/  r   rQ   rv   rs  returns	jump_insts
             r%   bytecode_from_templater7    sL   N !-E5! ' 	GAt{{h&a!eg	
  3  4;;+5%dkk2DK3 w&I +;;.0"%))L"9DK".DK$$T*$$%7%GH$$T*+ E 	%D{{n,t$	% w<1uRy!8IIbM0 L/ \A RyGBK'#(b	 #&99U#3b	  $b	#/b	 B/67   / 1r;	'..'..$=='..'../ Lr'   )T)F)r   rC   )NTT)rM   rQ  dataclassesrk   	functoolsr  rt   r  r$  collections.abcr   r   r   r   typingr   r   r	   r
   r   r   utils._backport_slotsr    r   bytecode_analysisr   r   r   r   utilsr   output_graphr   	dataclassr   r   ru   rU   r\   r3   r2   rf   r1   rn   rw   ry   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rP  r   r   r   r  r  r  r  r  r  r  r  r)  r  r-  r2  r>  r0  r9  r:  r<  rD  rS  rc  rf  rk  ro  rq  ru  rx  r  r  r  r  r  r  r  r  r  r#  r  r@  r  r  haslocalr  hasnamer  hasfreer  hasconstr  r  r  r  	lru_cacher  r  r  r  r  r  r  r  r#  r'  r+  r7  r5   r'   r%   <module>rG     s
     
   
   A A F F 3   $ 0 
 
  
6 ) )  )< w

s 

; 

 	 

s 

; 



s 

; 

 
 wGs Gt G 	 %s %t %
s  ($('
' 
#' SM	'
 [!' 'V3 3 3
>[ >T >83 8 8 8) )$0C $0D- $0N8d;&7788	+8vd;&778	+<4< 4< 4<k9J 4<n:c :d;&7 ::S :[ :5k 5k 5
+3 +4, +^ =B
C=
'}
59
	+
.3 4, $ k): c d;&7   !
49hSz4/0010""""
49hSz4/0(C5$;2GGH""JS T#Y ::
49h 93?EFFG:z    S T#Y  
hsm 
 


t$78 

T 

% D1D,E ,$':";  $'&4, '&3 '&5PUCV '&T	k)*	47	k	P8K#8 PT P 

,[ 
,T 
,k):   41T+%6 414 41n))(,[(9)	)XJ{#J	
JZ 	$	% 04[#5E0F 	 &=43D = =6C43D C C0Pd;&7 PD P&&&*;&7&	+&.${*; [@Q  d;&7  D  > D,=  $  * 697 ${*;    & tK7H  T   ${:K  PT  6# #tK7H #T #LD$5 # B; 3 ) 5 )$ ))+!6 )4 )	2u 	2 	2Yu~~ Y$ Y 	s{{s{{		.$sCx. 	.s 	.s 	. 8<l*{#l*sCx.l* !#s(!34l* 
	l*^k): t " $tCy $ $X #
..#	k	DcN+X6J-KK#
 # 5>>8$899:#('J{#'J+/9'JDHcN'J
4enn,-'JT+8K+@ +# +RV +-u~~ -T -d;FW -"h{&; "[@Q "J ',
.. $k > %Y__& C D S .u~~ .$ . 04	fcf'#s(+,f f 	f
 
+fr'   