
    %Vji                    4   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j"         G d d                                  Z#eej"         G d d                                  Z$ej%        dk    rdej$        de$fdZ&n&ej%        dk    rdej$        de$fdZ&ndej$        de$fdZ& G d d          Z'ej%        dk    r	de(de)fdZ*nej%        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+d0e)de1e$         fd1Z5d/e+de1e$         fd2Z6de(de$fd3Z7d!e$de$fd4Z8d*e+de1e$         fd5Z9	 dd7ee+         d8ee+         d9e)de1e$         fd:Z:de+de1e$         fd;Z;d<e+de1e$         fd=Z<d>ede1e$         fd?Z=	 dd@e+dAe+de>e1e+         ee+e+gdf         f         fdBZ?dCe+de>e1e+         ee+e+gdf         ee+gdf         f         fdDZ@d*e+de1e+         fdEZAdCe+de>e1e+         eedF         e+gdf         f         fdGZBeej"         G dH dI                                  ZCd*e+de1e+         fdJZDdKee+         de+fdLZEdMe1eC         ddfdNZFdOeGde1eC         fdPZHdMe1eC         deGfdQZIdRe1e$         dSe+de>eGeGf         fdTZJdUeKe+e$f         dVe+dee$         fdWZLdRe
e$         ddfdXZM eNejO                  ZPdYe$ddfdZZQdRe1e$         d[e+de$fd\ZRdRe1e$         ddfd]ZSd^eGdRe1e$         ddfd_ZTdRe1e$         de1eC         fd`ZUdMe1e#         daeKe$e+f         ddfdbZVdRe1e$         ddfdcZWdRe1e$         ddfddZXdRe1e$         ddfdeZYdfe$dge1e$         de1e$         fdhZZdRe1e$         de1e$         fdiZ[dRe1e$         ddfdjZ\dRe1e$         ddfdkZ]dldmdndoZ^dRe1e$         ddfdpZ_dRe1e$         ddfdqZ`dRe1e$         ddfdrZadsejb        dRe1e$         ddfdtZcdRe1e$         de+fduZddve$de+fdwZedRee$         ddfdxZfdRee$         ddfdyZgdzeGde(fd{Zhdsejb        ddfd|Zi eNejj                  Zk eNejl                  Zm eNejn                  Zo eNejp                  Zqd}eKe(ef         d&ede+fd~Zr	 ddRe1e$         d}eKe(ef         deedef                  ddfdZsdRe1e$         ddfdZteju        de1e(         fd            Zv	 ddsejb        dee1e$         eKe(ef         ged         f         de)de>ejb        ed         f         fdZwdRe1e$         de1e(         d}eKe(ef         de>e1e$         ejb        f         fdZxdRee$         deddfdZyddsejb        de)de1e$         fdZzdRee$         de1e$         fdZ{eju        	 ddsejb        de)dee$         fd            Z| ej}                    Z~dde(de)de(fdZdsejb        de)fdZ	 	 	 ddedef         deeeef                  de)de)de1e$         f
dZdS )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	dS )InstructionExnTabEntryInstructionstartendtargetdepthlastireturnc                     d| j                                          d| j                                         d| 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    _/root/voice-cloning/.venv/lib/python3.11/site-packages/torch/_dynamo/bytecode_transformation.py__repr__zInstructionExnTabEntry.__repr__3   s    7DJ,F,F,H,H 7 78++--7 7k11337 7 Z7 7 *.7 7 7	
    oc                     t          |t                    sdS | j        |j        u o;| j        |j        u o-| j        |j        u o| j        |j        k    o| j        |j        k    S NF)
isinstancer   r   r   r   r   r   )r$   r(   s     r%   __eq__zInstructionExnTabEntry.__eq__;   ss    !344 	5J!'! &AE!&qx'& 
ag%& 
ag%	
r'   N)
__name__
__module____qualname____annotations__intboolstrr&   objectr,    r'   r%   r   r   *   s          	JJJKKK
# 
 
 
 
	
 	
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dS )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    $xxr'   otherc                 B    t          |           t          |          k    S rC   rD   r$   rG   s     r%   r,   zInstruction.__eq__\   s    $xx2e99$$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    IT[II4;IIIIr'   c                 6    |j         | _         |j        | _        d S 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   sF         /.KKKKKK	#KKK FHSM   !%K#%%% ND   +/Ix(///&*FH]#***6:M823:::!GXc]!!!#    %F %t % % % %J J J 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   =    HHEHHMK	
 	
 		
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    t          | j        | j        | j        | j        | j        | j        | j        d           S rC   )r   r7   r8   r9   r:   r;   r<   r=   rT   s    r%   rU   rU      s;    HHEHHM	
 	
 		
r'   c                       e Zd ZdefdZdS )_NotProvidedr   c                     dS )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                     dS r*   r5   re   s    r%   rf   rf      s    ur'   )r9   r:   r   r9   r:   r   c                0   t          |           r|t          d          |d}n(|du|t          uz   |duz   }|dk    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L;C$6#=>&PTBTU77R   z#s33@AAAytVF   r'   c                 L    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8>>oDd62222r'   c                     | j         dv S )N)rp   rq   )r8   rr   s    r%   is_jump_absolutery      s    ====r'   Tvalcheckedc                 `    |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      sD      ?$$>>&>&>&>>>$l37777r'   c                  b    t           j        dk    rt          dd          S t          d          S )NrW   COPYr   r9   DUP_TOPrs   r5   r'   r%   create_dup_topr      s1    
7""!&a0000i(((r'   nc                    | dk    rg S t           j        dk    rd t          | dd          D             S t           j        dk     rO| dk    rI	 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 )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   c                 0    g | ]}t          d |          S )SWAPr   )rn   .0rQ   s     r%   
<listcomp>z create_rot_n.<locals>.<listcomp>   s&    KKKa"6q111KKKr'   rO   
      BUILD_TUPLEr   UNPACK_SEQUENCE   ROT_)TWOTHREEFOURr   ROT_N)rt   ru   rangern   r   s    r%   create_rot_nr      s     	Avv	
7"" LK5Ar??KKKK '!!a1ff	 }!4440a888}!a%8880a!e<<<	
 	
 	Avv"6,D,D,DQU,K#KLLMMwA...//r'   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    rEt          d         j                  r |d          s |d           nt          d          gz   nt
          j        d	k    rmt          d         j                  r |d          s |d           nd
         j        dk    r |d
          s |d
           nht          d          gz   nTt
          j        dk    rDt          d
         j                  r |d
          s |d
           n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                 J    |          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                 R    |          j         J |          xj         dz  c_         d S 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     s   " --- $1?-.....'c 'd ' ' ' ' ' '# $       7""E"I,-- 	>6F6Fr6J6J 	> L/<<==EE		W	$	$ E"I,-- 	>6F6Fr6J6J 	>L1X_--6F6Fq6I6I-LOOOO'445=EE		W	$	$E!HO,, 	>5E5Ea5H5H 	>LOOOO'4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   }n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   Nr   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NNL
7""+K8899#K001E9Lr'   nargs	push_nullc                    t           j        dk    rg }|r^|                    t          d                     t           j        dk    r| dz   n| dz   }|                    t          |                     t           j        dk     r$|                    t          d|                      |                    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9::: # 0G ; ;5199DMM,t,,---g%%MM,YEBBBCC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     sv    
7"""6u55566
7""ye444v5111
 	
 }%88899r'   c                 h    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     s8    
7""!+1TBBBBmD9999r'   c                 L    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9]]|FfV4444r'   c                 z   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     sP   
7"""6q11122Avv		
a"9--..	
a";//1CI1N1NOO& 	<QU3339%%<333?++;''9%%;''<333>**9%%9%% 
A		 	9%% 	,!a%888 r'   Fr   r   storec                 
   t           j        dk    r2|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     s     7""%*>MM	e$$c""y))
 	
 ',@NN	e$$c""}!44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     sr    
7"""6q11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     sv    	),uEEE	F	F	U3#3w#>#>aaAF	G	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     se    	),uEEE	F	F<666 
a	'	' 	9%%	 r'   linenobytenoc                 h     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                 $   |k    s| k    rt          dt          |z
  d                    }t          dt          | z
  d                    }|dk    s|dk    sJ |z  |z                      ||dz  f           |k    z| k    d S d S )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$ABBK!##{a'7'7'77k!Fk!FMM;d(:;<<< F""jF&:&:&:&:&:&:r'   rt   ru   r1   )r   r   r   r   s   `` @r%   lnotab_writerr   $  si     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k    s|dk    r|t          dt          | d                    }t          dt          |d                    }|dk    s|dk    sJ | |z  } ||z  }                    ||dz  f           | dk    t|dk    zd S d S )Nr      ir   r   r   )r   r   r   r   	linetables       r%   _updatez%linetable_310_writer.<locals>._updateJ  s    a<1#4#4a\3!7!788KdCc$:$:;;K!##{a'7'7'77K'LK'Lk;+=>??? a<1#4#4#4#4#4#4r'   r   r   c                 <    |z
  }| |           | z
  | d S rC   r5   )r   r   r   r   r   r   r   s      r%   r   z$linetable_310_writer.<locals>.updateS  s7    !F*l+++!F*r'   total_bytesc                 &     | z
             d S rC   r5   )r   r   r   r   s    r%   r   z!linetable_310_writer.<locals>.end[  s     f$l33333r'   r   )r   r   r   r   r   r   r   r   s      @@@@@r%   linetable_310_writerr   <  s    w&&3+;g+E+E+EEIFLF@c @ @ @ @ @ @ @ @3 C D         4 4 4 4 4 4 4 4 4 4 fc!!r'   c                     | dk    sJ | dz  g}| dz  } | dk    r3|dxx         dz  cc<   |                     | dz             | dz  } | dk    3|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  st    
 6666	
RA!GA
a%%	"	R	a a%% Hr'   r>   c                 t    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k    r ||d           |dz  }|dk     |||           d S )Ndeltasizer   c                    d|cxk     rdk    sn J d}rZj         Sj        Lj        Ej        >                    d|z   dz
             j        j         z
  j        dz   j        dz   f}n                    d|z   dz
             | dk     r
|  dz  dz  } n| dz  }                     t          |                      |D ]$}                    t          |                     %d S )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  s6   t====q====== .0M:$0(4(4,8  !4q!8999 (9+;;(1,,q0!   !4q!8999qyy &Q!+!]511222" 3 3  q!1!122223 3r'   r   r   )r   r1   )r?   r   r   r   r   r   r   s   `    r%   r   z$linetable_311_writer.<locals>.update|  s    )2<Y%%
	33 	3c 	3d 	3 	3 	3 	3 	3 	3 	3@ LL%.LF!mmGL!$$$NI !mm 	i(((((r'   )rt   ru   r
   r1   )r   r   r   r   s     @@r%   linetable_311_writerr  p  so     w&&&&IF,)(?3 ,) ,) ,) ,) ,) ,) ,) ,) ,)\ fr'   c                   B    e Zd ZU eed<   eed<   eed<   eed<   eed<   dS )ExceptionTableEntryr   r   r   r   r   N)r-   r.   r/   r1   r0   r2   r5   r'   r%   r	  r	    s?          JJJ	HHHKKKJJJKKKKKr'   r	  c                 
   | dk    sJ | dz  g}| dz  } | dk    r#|                     | dz             | dz  } | dk    #|                                 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     6666	
RA!GA
a%%	R	a a%% IIKKK3q66A:  	!
Hr'   
bytes_iterc                 z    t          |           }|dz  }|dz  r!|dz  }t          |           }||dz  z  }|dz  !|S )z5
    Inverse of `encode_exception_table_varint`.
    r   r   r   )next)r  r   rz   s      r%   decode_exception_table_varintr    s^     	ZA
b&C
b& 	q2v b&  Jr'   tabc                    t          t          |           dz
            D ]a}| |         j        | |         j        k    rA| |         j        | |dz            j        k     r"| |dz            j        | |dz            j        k    sJ bdS )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    
 3s88a<   
 
FLCFJ&&A
SQZ---AE
 CAJN22232	
 
r'   exntabc           	         t          |           }g }	 	 t          |          dz  }t          |          dz  }||z   dz
  }t          |          dz  }t          |          }|dz	  }t          |dz            }	|                    t	          |||||	                     # 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
    Tr   r   )iterr  r2   r   r	  StopIterationr  )
r  exntab_iterr  r   lengthr   r   dlr   r   s
             r%   parse_exception_tabler    s    
 v,,K
C	N1+>>BE2;??!CF&.1$C2;??!CF.{;;B!GEaLLEJJ*5#vueLLMMM	N    c"""


s   BB B=<B=c                    g }| D ]}t          |j        dz            }|dxx         dz  cc<   |                    |           |j        |j        z
  dz   }|                    t          |dz                       |                    t          |j        dz                       |j        dz  |j        z   }|                    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 43EK14DEEA& 	U[(1,	.v{;;<<<	.u|q/@AABBBkQ%+-	.r22333388Or'   instructionsfirstlinenoc                    g }t           j        dk    rt          |          \  }}d}t          |           D ]\  }}|j        dk    r8d}|dz  }dD ]-}	| ||	z            j        dk    r| ||	z            j        |_         n.nt          |          dz  |z   }d} ||j        |           d}|j        pd}
|                    |j	        |
dz  f           t          t          |          dz  dz
            D ]}|                    d           nt           j        d	k     rt          |          \  }}nt          |          \  }}}| D ]O}|j         ||j        t          |                     |j        pd}
|                    |j	        |
dz  f           Pt           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 A .. 	$ 	$GAt{n,,	1"  A#AE*1^CC)5a!e)<)F D -T22a7'A	M$.)444G(-aCKKcDj1222+D11Q6:;; $ $F####$!	$& g%%$1+$>$>!FMM)=k)J)J&FM3  	3 	3D+d.D		:::(-aCKKcDj12222w&&CD		NNN;;f%%r'   offset_to_instr;   c                 f    dD ]-}| ||z            j         t          j        k    r| ||z            c S .dS )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_offsetr2  3  sM      . .&1*%,0@@@!&1*---- A4r'   c                     d | D             }| D ]B}|j         t          j        v s|j         t          j        v rt	          ||j                  |_        CdS )z9Replace jump targets with pointers to make editing easierc                 ,    i | ]}|j         	|j         |S rC   )r;   r   rv   s     r%   
<dictcomp>z$virtualize_jumps.<locals>.<dictcomp>A  s*       "dk6MT6M6M6Mr'   N)r7   rk   hasjabshasjrelr2  r:   r   )r"  jump_targetsrv   s      r%   virtualize_jumpsr:  ?  sp     &2  L  P P;#+%%)C)C4\4;OODKP Pr'   instructionc                 b   t           j        dk     rt          d          d| j        v r!| j                            dd          | _        n9d| j        v r!| j                            dd          | _        nt          d          t          j        | j                 | _        | j        t          v sJ d S )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)r;  s    r%   flip_jump_directionrB  M  s    
'!!HIIIK&&&(/77	:NN	{)	)	)(/77
INNLMMM;#56K++++++r'   r   c                     | |         }dD ]2}||k    r*| ||z
           j         t          j        k    r| ||z
           }2 |S )zp
    i.e. get the first EXTENDED_ARG instruction (if any) when targeting
    instructions[idx] with a jump.
    r&  r1  )r"  r   r   r;   s       r%   _get_instruction_frontrD  Z  sW    
 #F  &==\#,7>#BRRR!#,/FFMr'   c           	         t          t          j                                      t          t          j                            }| D ]}|j        |v r|j        t          j        vr|j        |j        j        |j        J |j        j        |j        k     r8t          j	        dk     rt          d          d|j        v rt          |           t          j	        dk    rd|j        v rt          |           t          |            t          |           }| D ]&}|j        |v r|j        J t          | ||j                           }|j        t          j        v rYt          j	        dk     r|j        |_        nt          j	        dk     rt#          |j        dz            |_        n}t          d          |j        |j        J t%          t#          |j        |j        z
  t'          |          z
                      |_        t          j	        dk    r|xj        dz  c_        |j        |_        d	|j         |_        (dS )
zJFill in args for virtualized jump target after instructions may have movedNrW   z*Got negative jump offset for Python < 3.11r=  r>  r   r   z+Python 3.11+ should not have absolute jumpszto )setrk   r7  unionr8  r7   r   r;   rt   ru   rj   r8   rB  update_offsetsr   rD  r9   r1   absr(  r:   rA   )r"  jumpsrv   indexofr   s        r%   devirtualize_jumpsrL  h  s=   ""3s{#3#344E  2 2;%{#+--K+*6//0 ;%33''11*+WXXX DK//+D111 '722zT[7P7P+D111 <   ,''G  1 1;%;***+L'$+:NOOF{ck))#g--%}DHH%//  #6=1#455DHH&'TUUU }0T[5L5LL36Ft6L6LLMM  #w..HHNHH -DK000DL/1 1r'   exn_tab_bytesc                   	
 t          |           }d |D             	t          	                                          
dt          |          	 dt          t
          t          f         f	
fd} |            \  }}|D ]a}|j        J |j        |j        k    r |            \  }}|j        |j        k    |j        |j	        k    rt          j
        |          |_        bdS # t          $ r Y dS w xY w)zDReplace exception table entries with pointers to make editing easierc                 D    i | ]}t          t          |j                  |S r5   )r	   r1   r;   r5  s     r%   r6  z.virtualize_exception_table.<locals>.<dictcomp>  s&    LLLtd3,,dLLLr'   r   r   c                     t                    } t                    k     r:         | j        k    r)dz  t                    k     r         | j        k    )dk    sJ dz
           }t          t	          | j                  t	          |          t	          | j                  | j        | j                  }| |fS )Nr   r   )	r  r  r   r   r2  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--'.2IUY2V2V!# W--'.2IUY2V2V "A%%%% !!34J/*>5;GG*>:FF*>5<HH J *$$r'   N)r  sortedkeysr  tupler	  r   r;   r   r   copyr@   r  )rM  r"  exn_tabrV  r  rR  rv   rS  rT  r/  rU  s          @@@@r%   virtualize_exception_tabler\    sE    $M22GLL|LLLN^((**++GN==L 	%e/1GGH 	% 	% 	% 	% 	% 	% 	% 	% 	%, !DFFz  	; 	;D;***+	))$(DFF!z +	)){ek))%)Yz%:%:"	; 	;    s   BC( (
C65C6c           	      v   i t          |           }| D ]}|j        rt          | ||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                                          d           }dg g d
fd}	|D ]}r<d         d	         |d         k     r$ |	             rd         d	         |d         k     $rd         d         |d         cxk    r|d	         cxk    rd         d	         k    sn J t          d         d                   }
|
|d         k     r6                    t!          |
|d         dz
  gd                  R             |d                             |           r |	             t#                     S )zMCompute exception table in list format from instructions with exn_tab_entriesNr   c                 $    | d         | d          fS Nr   r   r5   ts    r%   <lambda>z)compute_exception_table.<locals>.<lambda>  s    1!u r'   keyr   r   c                      rn                                 } | d         k    rP                    t          t          | d                   | d         g|          R             | d         dz   dS dS dS )zT
        Pop the key_stack and append an exception table entry if possible.
        r   r   r   N)popr   r	  r   )rd  exn_dictr[  	key_stacknextis    r%   rf  z$compute_exception_table.<locals>.pop  s    
  	#--//CA'CFE(:(:CFSXc]SSS   A
	# 	#r'   r   r   )r   N)r   r@   rD  r   r;   r	   r1   r   r(  r   r   r   rW  rX  r   r   r	  r  )r"  rK  rv   r   r   r   rd  rz   keys_sortedrf  leftrg  r[  rh  ri  s              @@@@r%   compute_exception_tablerl    s    >@H,''G     	 *gd&8&>?   $$$ S$,0788"4#5#9::; 
 ???+gd&8&?@   %%%#,C4-3T5G5MNCh}++++HSM .E.EFFFKE')I)+G# # # # # # # # #    	IbM!,s1v55CEEE  	IbM!,s1v55 	R=#s1vKKKKQKKKK9R=;KKKKKKKuimA.//Dc!f}}'c!fqjS8IbM;RSSS   FE
   '"""Nr'   rK  c                 ~   g }| D ]}||j                  ||j                 f}|rF|d         d         |d         k     r.|                                 |r|d         d         |d         k     .|r<|d         d         |d         cxk    r|d         cxk    r|d         d         k    sn J |                    |           dS )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   rf  r   )r  rK  entry_stackr  rd  s        r%   !check_inst_exn_tab_entries_nestedro    s     *,K    u{#WUY%78 	k"oa03q699OO  	k"oa03q699 	Pr?1%QOOOO3q6OOOO[_Q=OOOOOOO3   r'   c                    t          |           }i | D ]N}|j        rE||j        j                 ||j        j                 f}|v r|j        |         k    sJ |j        |<   Ofdt	                                          d           D             }t          ||           |D ]M}t          ||j                 ||j                 dz             D ]!}t          j        |          | |         _        "NdS )z~
    Copies exception table entries to all instructions in an entry's range.
    Supports nested exception table entries.
    c                      g | ]
}|         S r5   r5   )r   rd  entriess     r%   r   z4propagate_inst_exn_table_entries.<locals>.<listcomp>;  s*         r'   c                 $    | d         | d          fS r_  r5   r`  s    r%   rb  z2propagate_inst_exn_table_entries.<locals>.<lambda><  s    adQqTE] r'   rc  r   N)	r   r@   r   r   rW  rX  ro  r   rZ  )r"  rK  rv   rd  sorted_entriesr  rQ   rr  s          @r%    propagate_inst_exn_table_entriesru  +  s<   
 ,''G=?G . . 	.*01*./C g~~)WS\9999-GCL    &w||~~;R;R S S S  N &ng>>>   = =wu{+WUY-?!-CDD 	= 	=A,0Ie,<,<LO))	== =r'   c                    t          |           }t                      }t          |           D ]\  }}|j        rt          j        dk    sJ t          |j                  |vsJ |                    t          |j                             |j        }|j        |v sJ |j	        |v sJ |j
        |v sJ ||j                 |cxk    r||j	                 k    sn J dS )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   rF  r'  r@   rt   ru   rE   addr   r   r   )r"  rK  exn_tab_entry_setrQ   rv   r  s         r%    check_inst_exn_tab_entries_validry  F  s    ,''G\** 	C 	C4 	C#w....d())1BBBBB!!"T%7"8"8999&E;'))))9''''<7****5;'1BBBB	0BBBBBBB	C 	Cr'   c                 (    d | D             | d d <   d S )Nc                 <    g | ]}|j         t          j        k    |S r5   r1  r   s     r%   r   z'strip_extended_args.<locals>.<listcomp>_  s'    OOOQ!(c>N2N2Nq2N2N2Nr'   r5   )r"  s    r%   strip_extended_argsr|  ^  s!    OO,OOOLOOOr'   old_inst	new_instsc                    | j         r3| j         j        | u r%t          |          dk    r|d         | j         _        |dd          D ],}t          j        | j                   |_         | j        |_        -|d         j        | _        |d         j        | _        |d         j        | _        |d         j        | _        |d         j	        | _	        | g|dd          z   S )Nr   r   r   )
r@   r   r  rZ  r?   r7   r8   r9   r:   r   )r}  r~  rv   s      r%   overwrite_instructionr  g  s    
 	3"&(22	NNQ%.r]"!"" , ,!Yx'=>>!+l)HOl)HOQ<#HLl)HOl)HO:	!""%%r'   c                     t           j        dk     sJ ddd}| D ]9}|j        |v r.||j                 |_        t          j        |j                 |_        :| 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_methodr  ~  sd    g%%%%*?KKH 1 1;("""4;/DK)DK0DK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}|                    t          ||                     |
                    |           || d d <   d S )N_NONEIS_OPNOTr   r^   r=  POP_JUMP_FORWARD_IF_TRUEPOP_JUMP_BACKWARD_IF_TRUErr   POP_JUMP_IF_TRUEr}   r~   )r8   rn   r1   r9   r:   rt   ru   r   r   r  r   )r"  r~  rv   is_opjump_opreplace_instss         r%   remove_jump_if_noner    s   I # #dk!!&wC8L4M4MNNNE 9EL')), %33 328;   --?TTT #<===M
 24GGHHHHT""""LOOOr'   c                    g }| D ]}|                     |           |j        dv rt          |j                            dd                    }|j        r|j        j        |u r||j        _        t          j        |j                  |_        |j        |_        t          j	        d         |_
        d|_        d|_        d|_        |                     |           || d d <   d S )N)r   r   SLICESUBSCRr   r   )r   r8   rn   r?  r@   r   rZ  r?   rk   rl   r7   r9   r:   )r"  r~  rv   subscr_insts       r%   remove_binary_store_slicer    s    I * *;999,T[-@-@(-S-STTK! 5d&8&<&D&D)4"&(,	$2D(E(EK%$(NK!)M2DK'DKDHDK[)))LOOOr'   )	LOAD_FASTr  )
STORE_FASTr  )r  r  )LOAD_FAST_LOAD_FASTSTORE_FAST_STORE_FASTSTORE_FAST_LOAD_FASTc                 2   g }| D ]}|j         t          v ret          |j                  \  }}|j        \  }}t          ||          t          ||          g}|                    t          ||                     u|                    |           || d d <   d S )Nr~   )r8   FUSED_INSTSr:   rn   r   r  r   )r"  r~  rv   inst0inst1argval0argval1r  s           r%   remove_fused_load_storer    s    I # #;+%%&t{3LE5#{GW #5999"5999M 24GGHHHHT""""LOOOr'   c                     g }| D ]p}d|j         v rPt          dd          t          |j         |j                  g}|                    t	          ||                     [|                    |           q|| d d <   d S )NRETURNNOPGRAPH_BREAK_IF_LEAFr~   )r8   rn   r:   r   r  r   )r"  r~  rv   r  s       r%   $add_graph_break_if_leaf_instructionsr    s    I # #t{"""51FGGG"4;t{CCCM 24GGHHHHT""""LOOOr'   c                    g }t          | | dd                    D ]\  }}|j        dk    r|j        dk    r|j                            d          rt	          t          |                     D ]}| |         j        |u r|| |         _        | |         j        rr| |         j        j        |u r|| |         j        _        | |         j        j	        |u r|| |         j        _	        | |         j        j        |u r|| |         j        _        |
                    |           |
                    | d                    || d d <   d S )Nr   r  r  r  r   )zipr8   r:   
startswithr   r  r   r@   r   r   r   )r"  r~  rv   	next_instrQ   s        r%   'remove_graph_break_if_leaf_instructionsr    sj   I|\!""-=>> # #iK5  444 ++H55 5 3|,,-- I I?)T11-6LO*?0 I $A4:dBB>GQ5;#A48D@@<EQ59#A4;tCC?HQ5<I T""""\"%&&&LOOOr'   r)  c                 N   | j         pd| j        pdz   }t          | j                  sdS g }t	          |          D ]a\  }}|                    |           |j        dk    r:|j        dk    r.||dz            }|j        dk    rt          j
        dk    r|j        dk    sFt          j
        d	k    rt          j
        dk     r|j        d
k    st          j
        d	k     r|j        dk    rd|v sJ |                    t          dd                     | j        d         }||v r%|                    t          d|                     n$|                    t          d|                     d|_        d|_        |j        d
k    r||dz            }d|_        d|_        c||dd<   dS )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   ri  	first_var	call_insts	            r%   explicit_superr    s   %+0@0FBGMt   F|,, ) )	Td;-''DK7,B,B q)EyA~~!W,,1G1G$//(722	11$w..5<?3R3R"m33330kRRRSSS ,Q/	--MM"4\)"T"T"TUUUUMM"4["S"S"STTT	 <9,, ,S1W 5I$%IM'(I$LOOOr'   c                    g dt           ddffd}| D ]}|j        t          j        k    r	d|_        na|j        r|j        dk    r |d                               t          d|j        d	z	  
                                         t          d|j        dz	  
                                         t          d|j        dz	  
                     n|j        ro|j        dk    rd |d                               t          d|j        dz	  
                                         t          d|j        dz	  
                     nI|j        rB|j        dk    r7 |d                               t          d|j        dz	  
                                         |           t                    t          |           z
  }|dk    sJ | dd<   |S )z,Fill in correct argvals for EXTENDED_ARG opsr   r   Nc                     t          |           D ]3}r/d         j        t          j        k    r                                 4d S )Nr   )r   r7   rk   r%  rf  )r   r-  r   s     r%   maybe_pop_nz&fix_extended_args.<locals>.maybe_pop_n)  sL    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  %  s    "Fs t      
   ;#***DHHX 	Q$(X--KNNNMM,^RPPPQQQMM,^RPPPQQQMM,^QOOOPPPPX 	Q$(V++KNNNMM,^RPPPQQQMM,^QOOOPPPPX 	Q$(T//KNNNMM,^QOOOPPPdKK#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 dS )Nr   rW   r   r   )torchrt   ru   _C_dynamo
eval_framepy_opcode_cachesr7   )rv   r  s     r%   r(  r(  F  sA    LLL
7""EH$/@MPQQRR1r'   c                 R    d}| D ]!}|j         |k    sJ |t          |          z  }"d S Nr   r;   r(  r"  r;   rv   s      r%   check_offsetsr  N  sH    F ) ){f$$$$"4((() )r'   c                 F    d}| D ]}||_         |t          |          z  }d S r  r  r  s      r%   rH  rH  U  s<    F ) )"4((() )r'   argsc                     t          t          t          t          |                               }d |gt	          |           z   d t          | d         | d                   D             gz   D             }dd                    |          z   S )Nc                 L    g | ]!}d                      d |D                       "S ) c              3      K   | ]}|d V  	dS )03Nr5   )r   xs     r%   	<genexpr>z)debug_bytes.<locals>.<listcomp>.<genexpr>_  s&      ((qA((((((r'   )join)r   r9   s     r%   r   zdebug_bytes.<locals>.<listcomp>^  sC        	((C(((((  r'   c                 :    g | ]\  }}t          ||k              S r5   )r1   )r   ar   s      r%   r   zdebug_bytes.<locals>.<listcomp>b  s&    <<<DAqCQKK<<<r'   r   zbytes mismatch

)r   r   mapr  r   r  r  )r  indexresults      r%   debug_bytesr  \  s    #c#tnn%%&&E 7
t**<<CR$r($;$;<<<
=>  F 		& 1 111r'   c                     t          | d d          \  }}| j        |j        k    s"J t          | j        |j                              | j        |j        k    s"J t          | j        |j                              dS )z<Make sure our assembler produces same bytes as we start withc                     d S rC   r5   )r  ys     r%   rb  zdebug_checks.<locals>.<lambda>j  s    t r'   T)safeN)transform_code_objectco_coder  	co_lnotab)r)  doder-  s      r%   debug_checksr  h  sz    #D*;*;$GGGGD!<4<'''T\4<)P)P'''>T^+++[-X-X+++++r'   code_optionsc                     t          | d                   D ]\  }}||u r|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  sq    ,{344  1
 !88HHH #'|K())A--r'   varname_from_oparg.c                 X
   	
 d t          d                   D             dt          dt          ffd}t          j        dk     rL|J d t          d                   D             d	 t          d
         d         z             D             	n|t          |          sJ i t          j                    D ]$}	  ||          }||<   # t          $ r Y  nw xY wfdd         D             fdd
         d         z   D             	t          t                               D ]
dt          f
 fd} 
         j        dk    r 
         j        t          usJ t          j        dk    rX 
         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    rY 
         j        J  | 
         j                  dz  t!          t           
         j                  dz  z    
         _        R | 
         j                   
         _        u 
         j        dk    rr 
         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 ri |            r]t          j        dk    r/ 
         j        vr 	 
         j                  
         _         
         j                  
         _        ( 
         j        t,          v r- |            r! | 
         j                   
         _        i 
         j        t.          v r* |            r	 
         j                  
         _         
         j        t0          v r= 
         j        0t3           
         j                  }|dk    sJ | 
         _        d S )Nc                     i | ]\  }}||	S r5   r5   r   r   r`   s      r%   r6  zfix_vars.<locals>.<dictcomp>  s    LLL93T3LLLr'   co_namesr`   r   c                     	 |          }n\# t           $ rO t                    x}| <   g d         | R d<   t          d                   t                    k    sJ Y nw xY w|S )Nr  )KeyErrorr  )r`   r   r  namess     r%   get_name_indexz fix_vars.<locals>.get_name_index  s    	?+CC 	? 	? 	? #E

*C%+'Hj)A'H4'H'HL$|J/00CJJ>>>>>>		?
 
s    AA%$A%rW   c                     i | ]\  }}||	S r5   r5   r  s      r%   r6  zfix_vars.<locals>.<dictcomp>  s    VVV)#tD#VVVr'   r  c                     i | ]\  }}||	S r5   r5   r  s      r%   r6  zfix_vars.<locals>.<dictcomp>  s.     
 
 
T #
 
 
r'   r  r  c                 "    i | ]}||         S r5   r5   r   r`   allnamess     r%   r6  zfix_vars.<locals>.<dictcomp>  s    QQQTD(4.QQQr'   c                 "    i | ]}||         S r5   r5   r  s     r%   r6  zfix_vars.<locals>.<dictcomp>  s/     
 
 
 (4.
 
 
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|         V  d S rC   r5   )r   r`   	freenamesvarnamess     r%   r  zfix_vars.<locals>.<genexpr>  sM         #'("2"2	$     r'   r   r      )r'  r3   r1   rt   ru   callable	itertoolscount
IndexErrorr   r  r2   r8   r:   r\   r9   r	   r  r+   rY  r7   	HAS_LOCALHAS_NAMEHAS_FREE	HAS_CONSTr  )r"  r  r  r  r   r`   r  	arg_tupler  r  rQ   r  r  s   ``      @@@@@r%   fix_varsr    s    ML	,z2J(K(KLLLES S        '!!!)))VVym9T/U/UVVV
 
&]+l=.II 
 
 
		 *+++++?$$ 	 	C))#..!$   QQQQ\-5PQQQ
 
 
 
$]3l=6QQ
 
 
	 3|$$%% C* C*	>D 	> 	> 	> 	> 	> 	> 	> ?!]22?)====7**#A*666'5~l1o6L'M'MQR'Rl1o122Q6'Q## '5n\!_5K&L&LQ##!_#{22?)====7**#A*666'5~l1o6L'M'MQR'Rl1o122Q6'Q## '5n\!_5K&L&LQ##!_#'888?&222?)====  Q 6771<\!_011A57 O
 !_#{22#w....l1o4e<<<<<|A-..!3333     (O2    I $-Q<1#419J"KLO!_#y00!!## K$//$Q.h>> +4LO4J*KLO''*2<?3I*JLO'!_#x//!!## M&4n\!_5K&L&LQ#!_#x//!!## H&/Q0F&GQ#!_#y00 A"*%lLO4JKKaxxxx&)Q#GC* C*s   C
C C c                     | D ]X}|j         t          urH|j        t          v s*|j        t          v s|j        t
          v s|j        t          v r|j        dvrd |_        Yd S )N)rc   rb   rd   )	r:   r\   r7   r   r  r  r  r8   r9   )r"  rv   s     r%   clear_instruction_argsr    st       K|++y((;(**;(**;)++#RRRDH r'   c                     dg} |                      d           |                     g d           t          j        dk    r|                      d           |                      d           t          j        dk    r|                      d           n|                      d	           t          j        dk    r|                      d
           |                     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   )rX  s    r%   get_code_keysr    s    
 ?DKK$%%%KK	
 	
 	
   7""M"""KK !!!
7""N####K   
7""'(((KK	
   Kr'   transformationsr   r  c                     t                      } fd|D             }t          |d                   |d         k    sJ t           |          }t          |            |||          }t	          |||          \  }}||fS )Nc                 2    i | ]}|t          |          S r5   )getattr)r   kr)  s     r%   r6  z)transform_code_object.<locals>.<dictcomp>1  s%    666AAwtQ''666r'   r  r  )r  r  cleaned_instructionsr   clean_and_assemble_instructions)	r)  r  r  rX  r  r"  tracer_outputr-  bytecodes	   `        r%   r  r  )  s     ??D6666666L|M*++|L/IIIII'd33L%%%#OL,??M1,lSSKAx]""r'   rX  c                 <   t          |            t          |            t          d                   d<   d }t          j        dk    r!t          j        fd|D              }|j        }t          | |           d}|r<t          |            t          |            t          t          |                     }|<t          |            t          | d                   \  }}t          j        dk     r|d	<   n|d
<   |d<   t          |           d<   t!          |          dhz
  t!                                                    dhz
  k    sJ t          j        dk    rt%          t'          |                     d<   | t          j        fd|D              fS )Nr  r  rW   c                      g | ]
}|         S r5   r5   r   r  r  s     r%   r   z3clean_and_assemble_instructions.<locals>.<listcomp>H  s    #B#B#BLO#B#B#Br'   )r  Tr  r   r  r  r  r  r
  r  c                      g | ]
}|         S r5   r5   r!  s     r%   r   z3clean_and_assemble_instructions.<locals>.<listcomp>d  s    )H)H)Ha,q/)H)H)Hr'   )r  ry  r  rt   ru   typesCodeType_varname_from_opargr  rH  rL  r2   r  r   r.  r   rF  rX  r!  rl  )r"  rX  r  r  tmp_codedirtyr  r   s     `     r%   r  r  =  s    ,L999$\222!$\-%@!A!AL
7"">#B#B#B#BT#B#B#BC%9\<<NOOOOE
 6|$$$<(((&|4455	  6 <(((l;K.LMMHf
'!!$*[!!'-^$&L#5l#C#CL t99,--\5F5F5H5H1I1IM 2     7"",D#L11-
 -
() )H)H)H)H4)H)H)HIIIr'   constsc                 J    | D ]}|j         dk    r||j                 |_         d S )NKW_NAMES)r8   r9   r:   )r"  r(  rv   s      r%   populate_kw_names_argvalr+  g  s7     + +;*$$ *DK+ +r'   c                 @    t          | |          }t          |          S rC   )_cached_cleaned_instructions_clone_instructionsr)  r  r"  s      r%   r  r  o  s!    /d;;L |,,,r'   c                 (   d | D             }t          t          | |                    }d |d <   |D ]`}||j                 |_        |j        x}rCt	          ||j                 ||j                 ||j                 |j        |j                  |_        a|S )Nc                     g | ]R}t          |j        |j        |j        |j        |j        |j        |j        |j        |j	        |j
        |j                  SS r5   )r   r7   r8   r9   r:   r;   r<   r=   r?   r   r@   rA   r   s     r%   r   z'_clone_instructions.<locals>.<listcomp>z  sl         	HHEHHMKHOI	
 	
  r'   )	dictr  r   r@   r   r   r   r   r   )r"  copiedremaprQ   r  s        r%   r.  r.  w  s        F" \6**++EE$K 	 	?O#5 	4ek"ei el# AO Mr'   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    rMt#          |           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  r\  r  r:  r|  r  r  r  r  r  r   &debug_force_graph_break_on_leaf_returnr  rH  rL  r/  s      r%   r-  r-    sq    /1Ed1K1KLLMML%%%,
7"" t~>>>"4#9<HHH\"""%%% ?g%%#L111g%%4...w&&---7**),7777**'5558 	?0>>>
7""|$$$<(((r'   	with_uuidc                     |  dt          t                     }|r-|dt          j                                         dd          z  }|S )Nr-  -)r  _unique_id_counteruuiduuid4r?  )r`   r8  rets      r%   	unique_idr?    sT    
.
.D+,,
.
.C 4!4:<<!!))#s333Jr'   c                 "    d}| j         |z  dk    S )N    r   )r  )r)  co_generators     r%   is_generatorrC    s    LML(A--r'   fnvarname_mapnoreturnnoprefixc                    t          | j                  }t          |           |r/t          |          D ]\  }}|j        dk    r||dz   d         } n |D ]-}d|_        d|_        |r|j        |v r||j                 |_        .|rt          j	        dk    rg }|D ]x}|j        dk    rVt          j        d         |_        d|_        |                    |           |                    t          d                     c|                    |           y|}g }|D ]"}|j        dk    r|                    |           #t          |          dk    r&|d         |d	         u r|                    d	           nt          |          dk    r|d	         |d	         u r_d
|d	         _        t          j        d
         |d	         _        d|d	         _        t$          |d	         _        |                    d	           n"|                    t          d
                     |D ]S}t'          |d	                   }	|	j        |_        |	j        |_        |	j        |_        |	j        |_        |	j        |_        T|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  rf  r9   r\   rw   r   )
rD  rE  rF  rG  r   rQ   rv   r~  returns	jump_insts
             r%   bytecode_from_templaterO    s   N !--E5!!!  '' 	 	GAt{h&&a!egg '  3 3   	34;+55%dk2DK ,/w&&I + +;.00"%)L"9DK".DK$$T***$$%7%G%GHHHH$$T****E 	% 	%D{n,,t$$$w<<1uRy!8!8IIbMMMM\\A RyGBK''#(b	 #&9U#3b	  $b	#/b	 B/66777   / / 1r;;	'.'.$='.'.Lr'   )T)F)r   rC   )NTT)rM   rZ  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   rY  r   r   r   r  r	  r  r  r  r  r  r!  r.  r2  r2  r:  rF  r8  rA  rB  rD  rL  r\  rl  ro  ru  ry  r|  r  r  r  r  r  r  r  r  r$  r  r  r(  r  rH  r  r  haslocalr   hasnamer  hasfreer  hasconstr  r  r  r  	lru_cacher  r  r  r+  r  r.  r-  r  r;  r?  rC  rO  r5   r'   r%   <module>r_     s         



         



   A A A A A A A A A A A A F F F F F F F F F F F F F F F F 3 3 3 3 3 3                  $ # # # # #  1000000 
 
 
 
 
 
 
  
6 ) ) ) ) ) ) )  )< w

s 

; 

 

 

 

 

 	  

s 

; 

 

 

 

 



s 

; 

 

 

 

       
 wGs Gt G G G G G 	  %s %t % % % % %
s     ($(' ' '
' 
#' SM	'
 [!' ' ' ' 'V3 3 3 3 3 3
>[ >T > > > >8 83 8 8 8 8 8 8) ) ) ) )$0C $0D- $0 $0 $0 $0N8d;&7788	+8 8 8 8vd;&778	+   <4< 4< 4<k9J 4< 4< 4< 4<n:c :d;&7 : : : ::S :[ : : : :5k 5k 5 5 5 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 P P P S

,[ 
,T 
, 
, 
, 
,k):      41T+%6 414 41 41 41 41n))(,[(9)	) ) ) )XJ{#J	
J J J JZ 	$	% 04[#5E0F 	       &=43D = = = = =6C43D C C C C C0Pd;&7 PD P P P 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 	2 	2 	2Yu~ Y$ Y Y Y Y C	3s{3s{C		.$sCx. 	.s 	.s 	. 	. 	. 	. 8<l* l*{#l*sCx.l* !#s(!34l* 
	l* l* 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en,-'J 'J 'J 'JT+8K+@ +# +RV + + + +- -u~ -T -d;FW - - - -"h{&; "[@Q " " " "J ', 
. $k   > %Y_&&  C D S    .u~ .$ . . . . 04	f fcf'#s(+,f f 	f
 
+f f f f f fr'   