Ë
    g^(hsP  ã                   ót  — d dl Z d dlZd dlmZmZmZ d dlZd dlmc m	c m
c mZ d dlmc m	c mZ d dlm	Z	 d dlmZmZ d dlmZ d dlmZ d dlmZ d dlmZ dd	lmZmZ ej<                  j                  Z G d
„ de j@                  «      Z!dededede"e#e$e   f   de%e!e!f   f
d„Z&dedede"e#e$e   f   dee%eejN                  e(f   eejN                  e)f   f      fd„Z*dededefd„Z+dedede)fd„Z,dede-e)   fd„Z.dedede#fd„Z/dede#defd„Z0deddfd„Z1d„ Z2e2dejN                  dejN                  dejN                  fd„«       Z3e2dejN                  dejN                  dejN                  fd„«       Z4e2dejN                  dejN                  dejN                  fd „«       Z5dede6fd!„Z7deded"e)defd#„Z8y)$é    N)ÚCallableÚOptionalÚUnion)ÚFakeQuantizeBaseÚObserverBase)Ú_is_activation_post_process)Úgetattr_from_fqn)ÚGraphModule)ÚNodeé   )ÚNSNodeTargetTypeÚNSResultsTypec                   ó¶   — e Zd Z ej                  «       Z ej                  «       Z ej                  «       Z ej                  «       Z ej                  «       Z	y)ÚNodeInputOrOutputTypeN)
Ú__name__Ú
__module__Ú__qualname__ÚenumÚautoÚFP32ÚINT8ÚFP16ÚUNKNOWNÚFP32_OR_INT8© ó    úR/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/torch/ao/ns/fx/utils.pyr   r      sE   „ Øˆ4�9‰9‹;€DØˆ4�9‰9‹;€DØˆ4�9‰9‹;€DØˆd�i‰i‹k€Gð
 �4—9‘9“;�Lr   r   ÚnodeÚgmÚ
logger_clsÚnode_type_to_io_type_mapÚreturnc                 ó„  ‡— |d   }|d   }|d   }|d   }|d   }|d   }	|d   }
|d   }| j                   d	k(  rì| j                  |v r t        j                  t        j                  fS | j                  |v r t        j                  t        j                  fS | j                  |v r t        j
                  t        j
                  fS | j                  |v r4t        | |d
«      }t        |t        «      sJ ‚t        ||||«      \  }}||fS t        j                  t        j                  fS | j                   dk(  �r0| j                   dk(  sJ ‚t        | j                  t        «      sJ ‚t        || j                  «      Št        ˆfd„|
D «       «      }t        ‰|t        t        f«      s|r4t        | |d
«      }t        |t        «      sJ ‚t        ||||«      \  }}||fS t        ˆfd„|D «       «      }t        ˆfd„|	D «       «      }|r t        j                  t        j                  fS |r t        j
                  t        j
                  fS t        j                  t        j                  fS | j                   dk(  �r-| j                  dk(  rBt        | |d
«      }t        |t        «      sJ ‚t        ||||«      \  }}|t        j                  fS | j                  dk(  rkt        | |d
«      }t        |t        «      sJ ‚t        ||||«      \  }}t        | |d«      }|t         j"                  u s
J |› d�«       ‚|t        j                  fS | j                  |v r4t        | |d
«      }t        |t        «      sJ ‚t        ||||«      \  }}||fS t        j                  t        j                  fS t        j                  t        j                  fS )NÚfuns_io_type_fp32Úfuns_io_type_fp16Úfuns_io_type_int8Úfuns_io_type_fp32_or_int8Úmods_io_type_fp32Úmods_io_type_int8Úmods_io_type_fp32_or_int8Úmeths_io_type_fp32_or_int8Úcall_functionr   Úcall_modulec              3   ó6   •K  — | ]  }t        ‰|«      –— Œ y ­w©N©Ú
isinstance©Ú.0Útarget_typeÚmods     €r   ú	<genexpr>z7get_node_first_input_and_output_type.<locals>.<genexpr>N   s   øè ø€ ò 1
Ø-8ŒJ�s˜K×(ñ1
ùó   ƒc              3   ó6   •K  — | ]  }t        ‰|«      –— Œ y ­wr/   r0   r2   s     €r   r6   z7get_node_first_input_and_output_type.<locals>.<genexpr>`   ó   øè ø€ ò )
Ø-8ŒJ�s˜K×(ñ)
ùr7   c              3   ó6   •K  — | ]  }t        ‰|«      –— Œ y ­wr/   r0   r2   s     €r   r6   z7get_node_first_input_and_output_type.<locals>.<genexpr>c   r9   r7   Úcall_methodÚ
dequantizeÚtor   z handling needs to be added)ÚopÚtargetr   r   r   r   Úget_normalized_nth_inputr1   r   Ú$get_node_first_input_and_output_typer   Ústrr	   Úanyr   r   ÚtorchÚfloat16)r   r   r    r!   ÚFUNS_IO_TYPE_FP32ÚFUNS_IO_TYPE_FP16ÚFUNS_IO_TYPE_INT8ÚFUNS_IO_TYPE_FP32_OR_INT8ÚMODS_IO_TYPE_FP32ÚMODS_IO_TYPE_INT8ÚMODS_IO_TYPE_FP32_OR_INT8ÚMETHS_IO_TYPE_FP32_OR_INT8Ú	first_argÚ_prev_node_input_typeÚprev_node_output_typeÚ"is_known_fp32_or_int8_input_moduleÚis_known_fp32_input_moduleÚis_known_int8_input_moduleÚ	prev_nodeÚcur_node_dtype_targetr5   s                       @r   rA   rA   &   s  ø€ ð 1Ð1DÑEÐØ0Ð1DÑEÐØ0Ð1DÑEÐØ 8Ð9TÑ UÐØ0Ð1DÑEÐØ0Ð1DÑEÐØ 8Ð9TÑ UÐØ!9Ð:VÑ!WÐà‡w�w�/Ò!Ø�;‰;Ð+Ñ+Ü)×.Ñ.Ô0E×0JÑ0JÐKÐKØ�;‰;Ð+Ñ+Ü)×.Ñ.Ô0E×0JÑ0JÐKÐKØ�[‰[Ð-Ñ-Ü)×.Ñ.Ô0E×0JÑ0JÐKÐKØ�[‰[Ð5Ñ5Ü0°°r¸1Ó=ˆIÜ˜i¬Ô.Ð.Ð.ô 5Ø˜2˜zÐ+CóñØ%Ø%ð *Ð+@ÐAÐAä)×1Ñ1Ô3H×3PÑ3PÐQÐQà	�‰�MÓ	!Ø�w‰w˜-Ò'Ð'Ð'Ü˜$Ÿ+™+¤sÔ+Ð+Ð+Ü˜r 4§;¡;Ó/ˆÜ-0ó 1
Ø<Uô1
ó .
Ð*ô �s˜Z¬Ô7GÐHÔIÙ1ô 1°°r¸1Ó=ˆIÜ˜i¬Ô.Ð.Ð.ô 5Ø˜2˜zÐ+CóñØ%Ø%ð *Ð+@ÐAÐAÜ%(ó )
Ø<Mô)
ó &
Ð"ô &)ó )
Ø<Mô)
ó &
Ð"ñ &Ü)×.Ñ.Ô0E×0JÑ0JÐKÐKÙ'Ü)×.Ñ.Ô0E×0JÑ0JÐKÐKä)×1Ñ1Ô3H×3PÑ3PÐQÐQà	�‰�MÓ	!Ø�;‰;˜,Ò&ô 1°°r¸1Ó=ˆIÜ˜i¬Ô.Ð.Ð.ô 5Ø˜2˜zÐ+CóñØ%Ø%ð *Ô+@×+EÑ+EÐFÐFà�[‰[˜DÒ ô
 1°°r¸1Ó=ˆIÜ˜i¬Ô.Ð.Ð.ô 5Ø˜2˜zÐ+CóñØ%Ø%ô
 %=¸TÀ2ÀqÓ$IÐ!à%¬¯©Ñ6ðEà'Ð(Ð(CÐDóEØ6ð *Ô+@×+EÑ+EÐFÐFà�[‰[Ð6Ñ6Ü0°°r¸1Ó=ˆIÜ˜i¬Ô.Ð.Ð.ô 5Ø˜2˜zÐ+CóñØ%Ø%ð *Ð+@ÐAÐAä%×-Ñ-Ô/D×/LÑ/LÐMÐMä%×-Ñ-Ô/D×/LÑ/LÐMÐMr   c                 óN  ‡— t        | |d«      }t        |t        «      sy|d   }d„ }|j                  dk(  r~|j                  t
        j                  k(  r |||dd«      S |j                  t        j                  t        j                  t        j                  t        j                  fv r |||dd«      S y|j                  d	k(  �rát        |j                  t        «      sJ ‚t        ||j                  «      Št        ‰t        j                  t        j                   t        j"                  t$        j&                  t        j(                  t        j*                  t        j,                  t        j.                  t        j0                  t        j2                  t        j4                  t        j6                  t        j8                  t        j:                  t        j<                  t        j>                  t        j@                  t        jB                  t$        jD                  t$        jF                  t$        jH                  t$        j&                  t$        jJ                  t$        jL                  f«      r‰jN                  ‰jP                  fS tS        ˆfd
„|D «       «      }|rtU        |||«      S y)z{
    Returns the qparams (scale, zero_point) of the first input to `node`,
    if they can be inferred from the graph.
    r   Nr*   c                 óF  — t        | ||«      }t        | ||«      }t        |t        «      rt        |j                  t        «      sJ ‚t        |t        «      rt        |j                  t        «      sJ ‚t        ||j                  «      }t        ||j                  «      }||fS r/   )r@   r1   r   r?   rB   r	   )r   r   Úscale_arg_idxÚ
zp_arg_idxÚ
scale_nodeÚzp_nodeÚ	scale_objÚzp_objs           r   Ú _get_scale_zp_from_function_argsz@get_node_input_qparams.<locals>._get_scale_zp_from_function_args±   s‡   € Ü-¨d°B¸ÓFˆ
Ü*¨4°°ZÓ@ˆÜ˜*¤dÔ+´
¸:×;LÑ;LÌcÔ0RÐRÐRÜ˜'¤4Ô(¬Z¸¿¹ÌÔ-LÐLÐLÜ$ R¨×):Ñ):Ó;ˆ	Ü! " g§n¡nÓ5ˆØ˜6Ð"Ð"r   r,   r   é   é   r-   c              3   ó6   •K  — | ]  }t        ‰|«      –— Œ y ­wr/   r0   )r3   r4   Ú
module_objs     €r   r6   z)get_node_input_qparams.<locals>.<genexpr>è   s   øè ø€ ò 1
Ø4?ŒJ�z ;×/ñ1
ùr7   )+r@   r1   r   r>   r?   rD   Úquantize_per_tensorÚtoqÚaddÚadd_reluÚmulÚmul_relurB   r	   ÚnnqÚLinearÚConv1dÚConv2dÚnniqÚ
ConvReLU2dÚConv3dÚBatchNorm2dÚBatchNorm3dÚConvTranspose1dÚConvTranspose2dÚELUÚ	GroupNormÚInstanceNorm1dÚInstanceNorm2dÚInstanceNorm3dÚ	LayerNormÚ	HardswishÚ	LeakyReLUÚReLU6ÚBNReLU2dÚBNReLU3dÚ
ConvReLU1dÚ
ConvReLU3dÚ
LinearReLUÚscaleÚ
zero_pointrC   Úget_node_input_qparams)r   r   r!   rT   rL   r^   rQ   rb   s          @r   r„   r„   ¡   sà  ø€ ô )¨¨r°1Ó5€Iä�i¤Ô&Øà 8Ð9TÑ UÐò#ð ‡|�|�Ò&à×Ñœu×8Ñ8Ò8Ù3°I¸rÀ1ÀaÓHÐHØ×Ñ¤#§'¡'¬3¯<©<¼¿¹Ä#Ç,Á,Ð!OÑOÙ3°I¸rÀ1ÀaÓHÐHàð 
�‰˜Ó	&ä˜)×*Ñ*¬CÔ0Ð0Ð0Ü% b¨)×*:Ñ*:Ó;ˆ
ÜØä—
‘
Ü—
‘
Ü—
‘
Ü—‘Ü—
‘
Ü—‘Ü—‘Ü×#Ñ#Ü×#Ñ#Ü—‘Ü—‘Ü×"Ñ"Ü×"Ñ"Ü×"Ñ"Ü—‘Ü—‘Ü—‘Ü—	‘	Ü—‘Ü—‘Ü—‘Ü—‘Ü—‘Ü—‘ð1ô
ð: ×$Ñ$ j×&;Ñ&;Ð<Ð<ä-0ó 1
ØC\ô1
ó .
Ð*ñ .Ü)¨)°RÐ9QÓRÐRàr   c                 ó   — | j                   dk(  rît        || j                  «      }t        |«      rÍt	        | j
                  «      dk(  sJ ‚t        | j
                  d   t        «      sJ ‚| j
                  d   } t        | j                  t        «      sJ ‚t        || j                  «      }t        |«      rHt	        | j
                  «      dk(  sJ ‚t        | j
                  d   t        «      sJ ‚| j
                  d   } | S )a‡  
    If node is not an observer, returns it.  If node is an observer,
    navigates up the graph and returns the first parent which is not an
    observer.  For example,

    graph: (node_non_obs), node = node_non_obs : returns node_non_obs
    graph: (node_non_obs -> obs0), node = obs0 : returns node_non_obs
    graph: (node_non_obs -> obs0 -> fq0), node = fq0 : returns node_non_obs
    r-   r   r   )	r>   r	   r?   r   ÚlenÚargsr1   r   rB   ©r   r   Únode_objs      r   Úreturn_first_non_observer_noderŠ   ñ   sÏ   € ð ‡w�w�-ÒÜ# B¨¯©Ó4ˆÜ& xÔ0Ü�t—y‘y“> QÒ&Ð&Ð&Ü˜dŸi™i¨™l¬DÔ1Ð1Ð1Ø—9‘9˜Q‘<ˆDä˜dŸk™k¬3Ô/Ð/Ð/Ü'¨¨D¯K©KÓ8ˆHÜ*¨8Ô4Ü˜4Ÿ9™9“~¨Ò*Ð*Ð*Ü! $§)¡)¨A¡,´Ô5Ð5Ð5Ø—y‘y ‘|�Ø€Kr   c                 ó„   — | j                   dk(  r1t        || j                  «      }t        |t        j
                  «      ryy)aO  
    Assumes that all non-param args occur first. Returns the number of
    non-param args expected for a node.  For example, for

      F.linear(x, weight, bias)

    Returns 1, because x is a non-param arg and weight and bias are params.
    For

      lstm_mod(x, hid)

    Returns 2, because both x and hid are non-param args.
    r-   r_   r   )r>   r	   r?   r1   ÚnnÚLSTMrˆ   s      r   Úget_number_of_non_param_argsrŽ     s6   € ð" ‡w�w�-ÒÜ# B¨¯©Ó4ˆÜ�h¤§¡Ô(Øð r   c                 ó  — t        | j                  «      dk(  rg S | j                  dk(  rØ| j                  t        j
                  t        j                  j                  j
                  t        j
                  fv sO| j                  t        j                  t        j                  j                  j                  t        j                  fv r:t        d«      D �cg c]$  }t        | j                  |   «      t        k(  sŒ#|‘Œ& }}|S dgS c c}w )a-  
    Returns the indices of args of the node which we should attach
    loggers to, if input logging is enabled.

    For example,
    * for (x + y), returns [0, 1]
    * for (1 + y), returns [1]
    * for (x + 1), returns [0]
    * for (linear(x, w, b)) returns [0]
    * by default, returns [0]
    r   r,   r_   )r†   r‡   r>   r?   rD   re   ÚopsÚ	quantizedÚoperatorrg   ÚrangeÚtyper   )r   ÚiÚresults      r   Ú get_arg_indices_of_inputs_to_logr—   (  s¸   € ô ˆ4�9‰9ƒ~˜ÒØˆ	Ø‡w�w�/Ò!à�‰œŸ	™	¤5§9¡9×#6Ñ#6×#:Ñ#:¼H¿L¹LÐIÑIØ�;‰;œ5Ÿ9™9¤e§i¡i×&9Ñ&9×&=Ñ&=¼x¿|¹|ÐLÑLä" 1›XÖD˜¬¨d¯i©i¸©lÓ);¼tÓ)C’!ÐDˆÐDØˆØˆ3€Jùò Es   Ã$DÃ:Dc                 ó  — d}| j                   dv r!t        j                  | j                  «      }|S | j                   dk(  rGt	        | j                  t
        «      sJ ‚t        || j                  «      }t        j                  |«      }|S )zˆ
    Returns a string representation of the type of the function or module
    pointed to by this node, or '' for other node types.
    Ú )r,   r;   r-   )r>   rD   Útypenamer?   r1   rB   r	   )r   r   r4   Ú
target_mods       r   Úget_target_type_strrœ   @  sv   € ð
 €KØ‡w�wÐ2Ñ2Ü—n‘n T§[¡[Ó1ˆð
 Ðð	 
�‰�MÒ	!Ü˜$Ÿ+™+¤sÔ+Ð+Ð+Ü% b¨$¯+©+Ó6ˆ
Ü—n‘n ZÓ0ˆØÐr   ÚresultsÚ
model_namec                 óè   — i }| j                  «       D ]\  \  }}d}|j                  «       D ]5  }|j                  «       D ]   \  }}||k(  rt        |«      sJ ‚|d   d   }Œ!Œ" Œ7 |�|||<   ŒX|||<   Œ^ |S )a	  
    Rekeys the layer name of a results dictionary to use node names
    from `model_name`.

    For example, transforms

        {'base_op_1_0': {'node_output': {'model_a':
          [{'ref_node_name': 'linear1', ...}]}}}

    into

        {'linear1': {'node_output': {'model_a':
          [{'ref_node_name': 'linear1', ...}]}}}

    Note: we cannot use these node names directly because they are not
    guaranteed to be consistent across models. This is why we extract
    the results first and rekey afterwards.
    Nr   Úref_node_name)ÚitemsÚvaluesr†   )	r�   rž   Únew_resultsÚold_layer_nameÚresult_type_to_resultsÚnew_layer_nameÚmodel_name_to_resultsÚcur_model_nameÚlist_of_resultss	            r   Ú'rekey_logger_info_on_node_name_of_modelrª   O  s­   € ð, €KØ29·-±-³/ò AÑ.ˆÐ.ØˆØ%;×%BÑ%BÓ%Dò 	Ð!Ø3H×3NÑ3NÓ3Pò Ñ/� Ø! ZÒ/Ü˜Ô/Ð/Ð/Ø%4°QÑ%7¸Ñ%H‘Nàñð	ð Ð%Ø*@ˆK˜Ò'à*@ˆK˜Ò'ðAð Ðr   c                 ó¸  — d}| j                  «       D ]L  }|j                  «       D ]6  }|j                  «       D ]   \  }}t        |«      dkD  sŒ|d   d   €Œ|} n  n  n |rw| j                  «       D ]c  }|j                  «       D ]N  }||   }|j                  «       D ]4  \  }}||k(  rŒt        t        |«      «      D ]  }||   d   }|||   d<   Œ Œ6 ŒP Œe yy)ay  
    If `fqn` entries are filled in for one of the models in `results`, copies
    them over to any models which do not have them filled out.

    A common use case benefitting from this is comparing a model prepared by
    quantization to a quantized model. In this case, the model prepared by
    quantization would have `fqn` entries, and the quantized model would not.
    Nr   Úfqn)r¢   r¡   r†   r“   )	r�   Úmodel_name_with_fqnsr¥   r§   rž   Úmodel_resultsÚref_model_resultsr•   r¬   s	            r   Úmaybe_add_missing_fqnsr°   v  s-  € ð  ÐØ")§.¡.Ó"2ò ÐØ%;×%BÑ%BÓ%Dò 	Ð!Ø-B×-HÑ-HÓ-Jò Ñ)�
˜MÜ�}Ó%¨Ó)Ø$ QÑ'¨Ñ.Ñ:Ø/9Ð,Ùð	ñ
 ð	ñ 	ðñ Ø&-§n¡nÓ&6ò 	6Ð"Ø)?×)FÑ)FÓ)Hò 6Ð%Ø$9Ð:NÑ$OÐ!Ø1F×1LÑ1LÓ1Nò 6Ñ-�J Ø!Ð%9Ò9Ø Ü"¤3 }Ó#5Ó6ò 6˜Ø/°Ñ2°5Ñ9˜Ø25˜ aÑ(¨Ò/ñ6ñ6ñ6ñ	6ð r   c                 ó   ‡ ‡— ˆ ˆfd„Š‰S )Nc                  óf  •— | ^}}}t        |t        «      rt        |t        «      s t        |t        «      rFt        |t        «      r6g }t        ||«      D ]#  \  }}||g|¢­}|j	                   ‰
|i |¤Ž«       Œ% |S t        |t
        j                  «      rRt        |t
        j                  «      r8|j                  r|j                  «       }|j                  r|j                  «       }|j                  t
        j                  k7  s|j                  t
        j                  k7  ry ||g|¢­} ‰	|i |¤ŽS r/   )r1   ÚtupleÚlistÚzipÚappendrD   ÚTensorÚis_quantizedr<   ÚdtypeÚfloat)r‡   ÚkwargsÚa0Úa1Úa_otherr�   Úel0Úel1Únew_argsÚfÚinners            €€r   rÃ   zGmaybe_dequantize_first_two_tensor_args_and_handle_tuples.<locals>.inner™  s  ø€ ØÐˆˆB�ä�rœ5Ô!¤j°´UÔ&;Ü�rœ4Ô ¤Z°´DÔ%9àˆGÜ  B›Kò ;‘��SØ Ð/ wÑ/�Ø—‘™u hÐ9°&Ñ9Õ:ð;ð ˆNä˜œEŸL™LÔ)¬j¸¼U¿\¹\Ô.JØ�ŠØ—]‘]“_�Ø�ŠØ—]‘]“_�ð �8‰8”u—{‘{Ò" b§h¡h´%·+±+Ò&=Øà˜Ð%˜WÑ%ˆÙ�(Ð%˜fÑ%Ð%r   r   )rÂ   rÃ   s   `@r   Ú8maybe_dequantize_first_two_tensor_args_and_handle_tuplesrÄ   ˜  s   ù€ õ&ð2 €Lr   ÚxÚyc                 ó’   — t        j                  | «      }t        j                  | |z
  «      }dt        j                  ||z  «      z  S )zµ
    Computes the SQNR between `x` and `y`.

    Args:
        x: Tensor or tuple of tensors
        y: Tensor or tuple of tensors

    Return:
        float or tuple of floats
    é   )rD   ÚnormÚlog10)rÅ   rÆ   ÚPsÚPns       r   Úcompute_sqnrrÍ   µ  s;   € ô 
�‰�A‹€BÜ	�‰�A˜‘EÓ	€BØ”—‘˜B ™GÓ$Ñ$Ð$r   c                 ó|   — t        j                  | |z
  dz  j                  «       | dz  j                  «       z  «      S )zÄ
    Computes the normalized L2 error between `x` and `y`.

    Args:
        x: Tensor or tuple of tensors
        y: Tensor or tuple of tensors

    Return:
        float or tuple of floats
    r_   )rD   ÚsqrtÚsum©rÅ   rÆ   s     r   Úcompute_normalized_l2_errorrÒ   Æ  s3   € ô �:‰:˜˜A™ !‘|×(Ñ(Ó*¨a°©d¯Z©Z«\Ñ9Ó:Ð:r   c                 óž   — | j                  dd«      } |j                  dd«      }t        j                  j                  j	                  | |«      S )zÂ
    Computes the cosine similarity between `x` and `y`.

    Args:
        x: Tensor or tuple of tensors
        y: Tensor or tuple of tensors

    Return:
        float or tuple of floats
    r   éÿÿÿÿ)ÚreshaperD   rŒ   Ú
functionalÚcosine_similarityrÑ   s     r   Úcompute_cosine_similarityrØ   Õ  sA   € ð 	
�	‰	�!�RÓ€AØ	�	‰	�!�RÓ€AÜ�8‰8×Ñ×0Ñ0°°AÓ6Ð6r   c                 óô   — | j                   dk(  ri| j                  t        j                  t        j                  t
        j                  t
        j                  t        j                  t        j                  fv ryy)Nr,   FT)r>   r?   rD   re   rg   r’   ÚcatÚstack)r   s    r   Úop_type_supports_shadowingrÜ   é  sQ   € Ø‡w�w�/Ò!Ø�;‰;Ü�I‰IÜ�I‰IÜ�L‰LÜ�L‰LÜ�I‰IÜ�K‰Kð
ñ 
ð Ør   Úidxc                 óD  — 	 | j                  |d¬«      }|�P|\  }}t        |«      t        |«      z   |kD  sJ ‚|t        |«      k  r||   S t        |j                  «       «      |   S t        | j                  «      t        | j
                  «      z   |kD  sJ ‚|t        | j                  «      k  r| j                  |   S |t        | j                  «      z   }t        | j
                  j                  «       «      |   S # t        $ rš t        | j                  «      t        | j
                  «      z   |kD  sJ ‚|t        | j                  «      k  r| j                  |   cY S |t        | j                  «      z   }t        | j
                  j                  «       «      |   cY S w xY w)zu
    Given a node, gets the n'th input to that node, normalizing
    args and kwargs to the best of its ability.
    T)Únormalize_to_only_use_kwargs)Únormalized_argumentsr†   r´   r¢   r‡   r»   ÚRuntimeError)r   r   rÝ   Únorm_args_and_kwargsÚ	norm_argsÚnorm_kwargsÚ
kwargs_idxs          r   r@   r@   ø  st  € ð
:Ø#×8Ñ8Ø¨Tð  9ó  
Ðð  Ð+Ø%9Ñ"ˆI�{Ü�y“>¤C¨Ó$4Ñ4°sÒ:Ð:Ð:Ø”S˜“^Ò#Ø  ‘~Ð%ô ˜K×.Ñ.Ó0Ó1°#Ñ6Ð6ä�t—y‘y“>¤C¨¯©Ó$4Ñ4°sÒ:Ð:Ð:Ø”S˜Ÿ™“^Ò#Ø—y‘y ‘~Ð%à ¤3 t§y¡y£>Ñ1�
Ü˜DŸK™K×.Ñ.Ó0Ó1°*Ñ=Ð=øÜò 	:ô �4—9‘9‹~¤ D§K¡KÓ 0Ñ0°3Ò6Ð6Ð6Ø”�T—Y‘Y“ÒØ—9‘9˜S‘>Ò!àœs 4§9¡9›~Ñ-ˆJÜ˜Ÿ™×*Ñ*Ó,Ó-¨jÑ9Ò9ð	:ús,   ‚AC< ÁC< Á'AC< Â>=C< Ã<A FÅ>FÆF)9r   r’   Útypingr   r   r   rD   Útorch.ao.nn.intrinsic.quantizedÚaorŒ   Ú	intrinsicr‘   rm   Útorch.ao.nn.quantizedri   Útorch.nnÚtorch.ao.quantizationr   r   Útorch.ao.quantization.observerr   Útorch.ao.quantization.utilsr	   Útorch.fxr
   Útorch.fx.graphr   Úns_typesr   r   r�   rd   ÚEnumr   ÚdictrB   Úsetr³   rA   r·   rº   Úintr„   rŠ   rŽ   r´   r—   rœ   rª   r°   rÄ   rÍ   rÒ   rØ   ÚboolrÜ   r@   r   r   r   ú<module>r÷      s™  ðó Û ß ,Ñ ,ã ß .Ö .ß #Ó #Ý ß @Ý FÝ 8Ý  Ý ç 5ð ‡i�i×Ñ€ô
	˜DŸI™Iô 	ðxNØ
ðxNàðxNð ðxNð # 3¨Ð,<Ñ(=Ð#=Ñ>ð	xNð
 Ð Ð"7Ð7Ñ8óxNðvMØ
ðMàðMð # 3¨Ð,<Ñ(=Ð#=Ñ>ðMð ˆe�E˜%Ÿ,™,¨Ð-Ñ.°°e·l±lÀCÐ6GÑ0HÐHÑIÑJó	Mð`Ø
ðàðð 
óð:Ø
ðàðð 	óð4¨4ð °D¸±Ió ð0˜dð ¨ð ¸ó ð$Øð$àð$ð ó$ðN6 Mð 6°dó 6òDð: :ð%�E—L‘Lð % U§\¡\ð %°e·l±lò %ó :ð%ð  :ð; 5§<¡<ð ;°E·L±Lð ;ÀUÇ\Á\ò ;ó :ð;ð :ð7 §¡ð 7°%·,±,ð 7À5Ç<Á<ò 7ó :ð7ð& Tð ¨dó ð!: 4ð !:¨[ð !:¸sð !:Àtô !:r   