§
    9²¸j¼º  ã                  ó˜
  — U d Z ddlmZ ddlZddlZddlZddlmZmZ ddl	m
Z
 ddlmZmZ ddl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mZmZmZmZmZ  e¦   «         rddlZddl m!Z! ddl"m#Z# ddl$m%Z%  e¦   «         rddl&Z&ddl'm(Z( ddl)m*Z+ erddl,m-Z-  e¦   «         r
ddl'm.Z.m/Z/m0Z0  ej1        e2¦  «        Z3 G d„ de¦  «        Z4e
d„ ¦   «         Z5d‚d„Z6 edd¦  «        d „ ¦   «         Z7 edd!d"¦  «        d#„ ¦   «         Z8 edd$¦  «        d%„ ¦   «         Z9 edd&¦  «        d'„ ¦   «         Z: edd(¦  «        d)„ ¦   «         Z; edd*¦  «        d+„ ¦   «         Z< edd,¦  «        d-„ ¦   «         Z=dƒd0„Z> edd1d2¦  «        d3„ ¦   «         Z? edd4d5¦  «        d6„ ¦   «         Z@ edd7d8¦  «        d9„ ¦   «         ZA edd:d;d<¦  «        d=„ ¦   «         ZB edd>d?¦  «        d@„ ¦   «         ZC eddA¦  «        dB„ ¦   «         ZD eddC¦  «        dD„ ¦   «         ZE eddE¦  «        dF„ ¦   «         ZF eddG¦  «        dH„ ¦   «         ZG eddI¦  «        dJ„ ¦   «         ZH eddK¦  «        dL„ ¦   «         ZI eddM¦  «        dN„ ¦   «         ZJ eddO¦  «        dP„ ¦   «         ZK eddQ¦  «        dR„ ¦   «         ZL eMejN        ejO        ejP        ejQ        ejR        ejS        h¦  «        ZT ed¦  «        d„dX„¦   «         ZU ed¦  «        d„dY„¦   «         ZV ed¦  «        d„dZ„¦   «         ZW ed¦  «        d„d[„¦   «         ZX eY¦   «         ZZ e¦   «         r~eZ [                    ej\        j]        j^        j_        ej\        j]        j^        j`        ej\        j]        ja        j_        ej\        j]        jb        j_        ej\        j]        jc        j_        h¦  «          ed¦  «        d„d\„¦   «         Zd ed¦  «        d„d]„¦   «         Ze ed¦  «        d„d^„¦   «         Zf ed¦  «        d„d_„¦   «         Zgejh        d…da„¦   «         Zi ed¦  «        d„db„¦   «         Zj ed¦  «        d„dc„¦   «         Zk ed¦  «        d„dd„¦   «         Zld†dh„Zm	 d‡dˆdm„Znd‰dŠdq„Zod‹dŒdu„Zpd‹dv„Zqdw„ Zrdx„ Zsi Ztdyeudz<    e¦   «         r¶et [                    ej\        j]        jv        j_        eoej\        j]        jw        j_        enej\        j]        jx        j_        epej\        jy        jz        j_        epej\        j]        j{        j|        eqej\        j]        j}        j~        esej\        j]        j}        j        esej€        eri¦  «         d�d~„Z�e�gZ‚dŽd�„ZƒdS )�uX  ONNX exporter.

Extends `DynamoExporter` with five extra stages that convert an `ExportedProgram`
into an ONNX model via `torch.onnx.export`:

1. **Torch patches** (`_PATCHES["onnx"]` via `apply_patches("onnx")`): reversibly
   monkey-patch `torch` ops at tracing time so `torch.export` and `torch.onnx.export`
   emit ONNX-lowerable patterns. Reverted on exit.
2. **ONNX patches** (`_PATCHES["onnx"]` via `apply_patches("onnx")`): reversibly
   hook `torch.onnx` internals â€” specifically `_prepare_exported_program_for_export`,
   so the FX node fixes (stage 3) run again right after `run_decompositions`.
   Same registry as stage 1, installed by the same `apply_patches` call.
3. **FX node fixes** (`_FX_NODE_FIXES["onnx"]` via `apply_fx_node_fixes("onnx", gm)`):
   per-node in-place rewrites on the `GraphModule` to drop or replace nodes ONNX
   can't lower (alias, in-place ops, dead comparisons, `_assert_*`, â€¦). Triggered
   both directly after `torch.export` and indirectly via the stage 2 hook.
4. **ONNX translations** (`_ONNX_TRANSLATION_TABLE`): custom onnxscript functions
   passed as `custom_translation_table` that override the default torchlib
   lowering for specific aten ops where it's buggy or missing.
5. **ONNX IR fixes** (`_IR_FIXES` via `apply_onnx_ir_fixes`): post-export in-place
   fixes on the `ONNXProgram` IR for ORT compatibility.
é    )ÚannotationsN)ÚMutableMappingÚSequence)Úcontextmanager)ÚTYPE_CHECKINGÚAnyé   )Úlogging)Úis_onnxscript_availableÚis_torch_availableé   )Ú
OnnxConfig)ÚDynamoExporter)Úapply_fx_node_fixesÚapply_patchesÚduplicate_leaf_tensorsÚget_leaf_tensorsÚregister_fx_node_fixÚregister_patch)ÚExportedProgram)ÚONNXProgram)Úmasking_utils)Úaten_index_put)Úopset18)ÚPreTrainedModel)ÚBOOLÚINT64ÚTRealc                  ó8   ‡ — e Zd ZdZg d¢ZddddœZdˆ fd„Zˆ xZS )ÚOnnxExporteraÚ  Exporter that converts a [`PreTrainedModel`] to an ONNX `ONNXProgram`.

    Example:

    ```python
    >>> from transformers.exporters.exporter_onnx import OnnxExporter, OnnxConfig

    >>> exporter = OnnxExporter()
    >>> onnx_program = exporter.export(model, inputs, config=OnnxConfig(dynamic=True))
    >>> outputs = onnx_program(**inputs)  # run in-memory
    >>> exporter.export(model, inputs, config=OnnxConfig(output_path="model.onnx"))  # save to disk
    ```
    )ÚtorchÚonnxÚ
onnxscriptz2.12.0z1.21.0z0.7.0Úmodelr   Úsample_inputsúMutableMapping[str, Any]ÚconfigúOnnxConfig | dict[str, Any]Úreturnr   c                óÜ  •— t          |t          ¦  «        rt          di |¤Ž}n5t          |¦  «        t          urt	          dt          |¦  «        › �¦  «        ‚t          |¦  «        5 \  }}t          d¦  «        5  t          ¦   «                              |||¬¦  «        }t          ||¦  «        \  }}t          d|j        ¦  «         t          j                             |d|j        ||t          j        t          |¦  «        ¦  «        t"          |j        |j        |j        |j        ¬¦  «        }d d d ¦  «         n# 1 swxY w Y   d d d ¦  «         n# 1 swxY w Y   t-          |¦  «         |S )Nz1Expected config to be an OnnxConfig or dict, got r"   )r'   © )
ÚargsÚfÚinput_namesÚoutput_namesÚkwargsÚcustom_translation_tableÚopset_versionÚexternal_dataÚexport_paramsÚoptimize)Ú
isinstanceÚdictr   ÚtypeÚ	TypeErrorÚpatch_model_outputsr   ÚsuperÚexportÚdisambiguate_io_namesr   Úgraph_moduler!   r"   Úoutput_pathÚcopyÚdeepcopyÚ_ONNX_TRANSLATION_TABLEr2   r3   r4   r5   Úapply_onnx_ir_fixes)	Úselfr$   r%   r'   Úinputs_namesÚoutputs_namesÚexported_programÚonnx_programÚ	__class__s	           €út/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/transformers/exporters/exporter_onnx.pyr<   zOnnxExporter.exporti   sß  ø€ õ �f�dÑ#Ô#ð 	`ÝÐ)Ð) &Ð)Ð)ˆFˆFÝ�&‰\Œ\¥Ð+Ð+ÝÐ^ÕPTÐU[ÑP\ÔP\Ð^Ð^Ñ_Ô_Ð_å  Ñ'Ô'ð 	Ñ+H¨L¸-Í-ÐX^ÑJ_ÔJ_ð 	ð 	Ý05±´·²¸uÀmÐ\b°Ñ0cÔ0cÐÝ*?ÀÈmÑ*\Ô*\Ñ'ˆL˜-Ý Ð(8Ô(EÑFÔFÐFÝ(-¬
×(9Ò(9Ø ØØÔ$Ø(Ø*Ý”}¥T¨-Ñ%8Ô%8Ñ9Ô9Ý)@Ø$Ô2Ø$Ô2Ø$Ô2Øœð ):ñ )ô )ˆLð		ð 	ð 	ñ 	ô 	ð 	ð 	ð 	ð 	ð 	ð 	øøøð 	ð 	ð 	ð 	ð 	ð 	ð 	ñ 	ô 	ð 	ð 	ð 	ð 	ð 	ð 	øøøð 	ð 	ð 	ð 	õ$ 	˜LÑ)Ô)Ð)ØÐs7   Á(EÁ;B4D;Ä/EÄ;D?	Ä?EÅD?	ÅEÅEÅE)r$   r   r%   r&   r'   r(   r)   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Úrequired_packagesÚtested_versionsr<   Ú__classcell__)rI   s   @rJ   r    r    W   sd   ø€ € € € € ðð ð 8Ð7Ð7ÐØ (°(È'ÐRÐR€Oðð ð ð ð ð ð ð ð ð ó    r    c              #  óª   ‡‡‡K  — g Šg Š| j         Št          j        ‰¦  «        ˆˆˆfd„¦   «         }	 || _         ‰‰fV — ‰| _         dS # ‰| _         w xY w)z×Wrap `model.forward` to return a flat `dict[str, Tensor]` with duplicated outputs,
    and capture the input/output tensor names from the traced forward in the yielded
    `(inputs_names, outputs_names)` lists.
    c            	     ó  •— t          t           ‰| i |¤Ž¦  «        ¦  «        }‰                     t          |¦  «                             ¦   «         ¦  «         ‰                     |                     ¦   «         ¦  «         |S ©N)r   r   ÚextendÚkeys)r,   r0   ÚoutputsrE   Úoriginal_forwardrF   s      €€€rJ   Úpatched_forwardz,patch_model_outputs.<locals>.patched_forward™   su   ø€ å"Õ#9Ð:JÐ:JÈDÐ:[ÐTZÐ:[Ð:[Ñ#\Ô#\Ñ]Ô]ˆØ×ÒÕ,¨VÑ4Ô4×9Ò9Ñ;Ô;Ñ<Ô<Ð<Ø×Ò˜WŸ\š\™^œ^Ñ,Ô,Ð,ØˆrR   N)ÚforwardÚ	functoolsÚwraps)r$   rZ   rE   rY   rF   s     @@@rJ   r:   r:   Ž   s’   øøøè è € ð !€LØ!€MØ”}Ðå„_Ð%Ñ&Ô&ðð ð ð ð ð ñ 'Ô&ðð)Ø'ˆŒØ˜MÐ)Ð)Ð)Ð)à(ˆŒˆˆøÐ(ˆŒÐ(Ð(Ð(Ð(s   ³A	 Á		ArE   ú	list[str]rF   r)   útuple[list[str], list[str]]c                óÚ   — t          | ¦  «                             t          |¦  «        ¦  «        D ]8}d|› �| |                      |¦  «        <   d|› �||                     |¦  «        <   Œ9| |fS )zEPrefix any name that appears in both lists with `input.` / `output.`.zinput.zoutput.)ÚsetÚintersectionÚindex)rE   rF   Únames      rJ   r=   r=   §   s}   € å�LÑ!Ô!×.Ò.­s°=Ñ/AÔ/AÑBÔBð Dð DˆØ1@¸$°°ˆ�\×'Ò'¨Ñ-Ô-Ñ.Ø3C¸TÐ3CÐ3Cˆ�m×)Ò)¨$Ñ/Ô/Ñ0Ð0Ø˜Ð&Ð&rR   r"   ztorch.wherec                ó   ‡ — dˆ fd„	}|S )z,Normalize dtypes and scalars in torch.where.Nc                óŒ  •— t          |t          j        ¦  «        rEt          |t          j        ¦  «        r+|j        |j        k    r|                     |j        ¦  «        }n»t          |t          j        ¦  «        rDt          |t
          t          t          f¦  «        r"t          j        ||j        |j	        ¬¦  «        }n]t          |t          j        ¦  «        rCt          |t
          t          t          f¦  «        r!t          j        ||j        |j	        ¬¦  «        }|€|€ ‰| ¦  «        S |€ ‰| |¦  «        S  ‰| ||¦  «        S )N©ÚdtypeÚdevice)
r6   r!   ÚTensorrh   ÚtoÚintÚfloatÚboolÚtensorri   )Ú	conditionÚxÚyÚoriginals      €rJ   Úpatchz_patch_where.<locals>.patch»   s%  ø€ Ý�a�œÑ&Ô&ð 	@­:°a½¼Ñ+FÔ+Fð 	@È1Ì7ÐVWÔV]ÒK]ÐK]Ø—’�Q”W‘”ˆAˆAÝ˜�5œ<Ñ(Ô(ð 	@­Z¸½CÅÍÐ;MÑ-NÔ-Nð 	@Ý”˜Q a¤g°a´hÐ?Ñ?Ô?ˆAˆAÝ˜�5œ<Ñ(Ô(ð 	@­Z¸½CÅÍÐ;MÑ-NÔ-Nð 	@Ý”˜Q a¤g°a´hÐ?Ñ?Ô?ˆAØˆ9˜˜Ø�8˜IÑ&Ô&Ð&ØˆYØ�8˜I qÑ)Ô)Ð)à�8˜I q¨!Ñ,Ô,Ð,rR   ©NNr+   ©rs   rt   s   ` rJ   Ú_patch_whererw   ·   s(   ø€ ð-ð -ð -ð -ð -ð -ð €LrR   ztorch.unsqueezeztorch.Tensor.unsqueezec                ó   ‡ — ˆ fd„}|S )z+Support complex tensors in torch.unsqueeze.c                ó²   •— t          j        | ¦  «        r7 ‰| j        |¦  «        } ‰| j        |¦  «        }t          j        ||¦  «        S  ‰| |¦  «        S rU   )r!   Ú
is_complexÚrealÚimagÚcomplex)Úself_or_inputÚdimr{   r|   rs   s       €rJ   rt   z_patch_unsqueeze.<locals>.patchÐ   sb   ø€ ÝÔ˜MÑ*Ô*ð 	-Ø�8˜MÔ.°Ñ4Ô4ˆDØ�8˜MÔ.°Ñ4Ô4ˆDÝ”=  tÑ,Ô,Ð,Øˆx˜ sÑ+Ô+Ð+rR   r+   rv   s   ` rJ   Ú_patch_unsqueezer€   Ì   s#   ø€ ð,ð ,ð ,ð ,ð ,ð €LrR   z/transformers.masking_utils._vmap_expansion_sdpac                ó   — d„ }|S )z;Replace vmap-based mask expansion with broadcast expansion.c                ó   ‡ — ˆ fd„}|S )Nc                óÄ   •— t          j        | |||¦  «        } ‰|Ž                      | j        d         |j        d         |j        d         |j        d         ¦  «        }|S ©Nr   )r   Ú_non_vmap_expansion_sdpaÚexpandÚshape)Úbatch_arangeÚhead_arangeÚq_arangeÚ	kv_arangeÚ
brodcastedÚresultÚmask_functions         €rJ   Ú	_expandedzA_patch_broadcast_mask_expansion.<locals>.patch.<locals>._expandedß   sh   ø€ Ý&Ô?ÀÈkÐ[cÐenÑoÔoˆJØ"�] JÐ/×6Ò6ØÔ" 1Ô% {Ô'8¸Ô';¸X¼^ÈAÔ=NÐPYÔP_Ð`aÔPbñô ˆFð ˆMrR   r+   )rŽ   r�   s   ` rJ   rt   z._patch_broadcast_mask_expansion.<locals>.patchÞ   s$   ø€ ð	ð 	ð 	ð 	ð 	ð ÐrR   r+   )Ú	_originalrt   s     rJ   Ú_patch_broadcast_mask_expansionr‘   Ú   s   € ðð ð ð €LrR   ztorch.nn.RMSNorm.forwardc                ó   ‡ — ˆ fd„}|S )zAUse non-fused RMS normalization when elementwise_affine is False.c                ó&  •— | j         s~|                     t          j        ¦  «                             d¦  «                             dd¬¦  «        }|t          j        || j        z   ¦  «        z                       |j        ¦  «        S  ‰| |¦  «        S )Nr	   éÿÿÿÿT)Úkeepdim)	Úelementwise_affinerk   r!   Úfloat32ÚpowÚmeanÚrsqrtÚepsrh   )rD   rq   Úvariancers   s      €rJ   rt   z&_patch_rms_norm_forward.<locals>.patchï   s�   ø€ ØÔ&ð 	FØ—t’t�EœMÑ*Ô*×.Ò.¨qÑ1Ô1×6Ò6°rÀ4Ð6ÑHÔHˆHØ�œ H¨t¬xÑ$7Ñ8Ô8Ñ8×<Ò<¸Q¼WÑEÔEÐEØˆx˜˜aÑ Ô Ð rR   r+   rv   s   ` rJ   Ú_patch_rms_norm_forwardr�   ë   s#   ø€ ð!ð !ð !ð !ð !ð €LrR   ztorch.randpermc                óB   — t           j        t           j        ddddœd„}|S )uT   Implement randperm via argsort(rand(n)) â€” no ONNX decomposition for aten.randperm.NF)rh   Úlayoutri   Ú
pin_memoryÚ	generatorc               óx   — t          j        t          j        | |¬¦  «        ¦  «                             |¦  «        S )N©ri   )r!   ÚargsortÚrandrk   )Únrh   rŸ   ri   r    r¡   s         rJ   rt   z_patch_randperm.<locals>.patchü   s/   € ÝŒ}�UœZ¨°&Ð9Ñ9Ô9Ñ:Ô:×=Ò=¸eÑDÔDÐDrR   )r!   Úint64Ústridedrv   s     rJ   Ú_patch_randpermr©   ø   s:   € õ  œ+­e¬mÀDÐUZÐfjð Eð Eð Eð Eð Eð €LrR   ztorch.histcc                ó   — dddœd„}|S )u~  Replace `torch.histc` with a statically-shaped, deterministic equivalent.

    The default torchlib `aten_histc` translation rejects integer input (`torch.histc only
    works on float`), and the obvious workaround â€” casting to float â€” calls `_histc_cuda`
    which has no deterministic implementation on CUDA. `bincount`'s output is an unbacked
    SymInt under torch.export and trips downstream meta-shape guards (e.g. grouped_mm's
    `offs` size check). Pre-allocating `torch.zeros(bins)` + `scatter_add_` keeps the output
    shape pinned to `bins` (a Python int), and `scatter_add_` is deterministic on integer
    indices.
    éd   r   N)Úoutc               óø  — |                       d¦  «        }||cxk    rdk    rPn nM|                     ¦   «                              ¦   «         }|                     ¦   «                              ¦   «         }nPt	          j        t          |¦  «        |j        ¬¦  «        }t	          j        t          |¦  «        |j        ¬¦  «        }||z
  |z  }|                     ¦   «         |z
  |z                       ¦   «                              d|dz
  ¦  «        }	|  	                    ¦   «         r| j
        nt          j        }
t	          j        ||
| j        ¬¦  «        }|                     d|	t	          j        |	|
¬¦  «        ¦  «        S )Nr”   r   r£   r   rg   ©rh   )ÚreshapeÚminrm   Úmaxr!   ro   ri   ÚlongÚclamp_Úis_floating_pointrh   ÚzerosÚscatter_add_Ú	ones_like)ÚinputÚbinsr°   r±   r¬   ÚflatÚmin_valÚmax_valÚ	bin_widthÚidxÚ	out_dtypeÚcountss               rJ   rt   z_patch_histc.<locals>.patch  s;  € Ø�}Š}˜RÑ Ô ˆØ�#ˆ?ˆ?Š?ˆ?˜Š?ˆ?ˆ?ˆ?ˆ?Ø—h’h‘j”j×&Ò&Ñ(Ô(ˆGØ—h’h‘j”j×&Ò&Ñ(Ô(ˆGˆGå”l¥5¨¡:¤:°d´kÐBÑBÔBˆGÝ”l¥5¨¡:¤:°d´kÐBÑBÔBˆGØ˜wÑ&¨$Ñ.ˆ	Ø—
’
‘”˜wÑ&¨)Ñ3×9Ò9Ñ;Ô;×BÒBÀ1ÀdÈQÁhÑOÔOˆØ#(×#:Ò#:Ñ#<Ô#<ÐM�E”K�KÅ%Ä+ˆ	Ý”˜T¨¸5¼<ÐHÑHÔHˆØ×"Ò" 1 c­5¬?¸3ÀiÐ+PÑ+PÔ+PÑQÔQÐQrR   )r«   r   r   r+   rv   s     rJ   Ú_patch_histcrÁ     s/   € ðR°Dð Rð Rð Rð Rð Rð €LrR   z4onnxscript.onnx_opset._impl.opset13.Opset13.Constantc                ó   ‡ — ˆ fd„}|S )u	  Substitute `op.Constant(value_ints=[])` with an explicit empty INT64 tensor.

    Upstream onnxscript's `aten_index_put` does `op.Constant(value_ints=none_indices)`
    where `none_indices` can be empty (when every input dim has an advanced index).
    `onnx_ir` then logs an ambiguous-type warning because an empty Python list has no
    derivable element type. Swap the empty-`value_ints` call for `value=ir.tensor([], INT64)`
    â€” semantically identical, no ambiguity. Drop once onnxscript fixes the call site.
    c                óâ   •— |                      d¦  «        g k    rJ|                     d¦  «         t          j        t	          j        g t          j        ¬¦  «        ¦  «        |d<    ‰| g|¢R i |¤ŽS )NÚ
value_intsr®   Úvalue)ÚgetÚpopÚonnx_irro   ÚnpÚarrayr§   )rD   r,   r0   rs   s      €rJ   rt   z&_patch_opset13_constant.<locals>.patch+  sp   ø€ Ø�:Š:�lÑ#Ô# rÒ)Ð)Ø�JŠJ�|Ñ$Ô$Ð$Ý%œn­R¬X°bÅÄÐ-IÑ-IÔ-IÑJÔJˆF�7‰OØˆx˜Ð.˜tÐ.Ð.Ð. vÐ.Ð.Ð.rR   r+   rv   s   ` rJ   Ú_patch_opset13_constantrË      s#   ø€ ð/ð /ð /ð /ð /ð €LrR   ÚmodeÚstrc               ó   ‡— ˆfd„}|S )zFDecompose cummax/cummin via triangular-mask reduction (O(N^2) memory).c                óÈ  •— | j         |         }|                      |d¦  «        } |                     d¦  «        j        g |j         d d…         ¢|‘|‘R Ž }t	          j        ||t          j        | j        ¬¦  «                             ¦   «         }| j	        t          j        k    r‰
dk    }n™|  
                    ¦   «         rC‰
dk    rt	          j        | j	        ¦  «        j        nt	          j        | j	        ¦  «        j        }nB‰
dk    rt	          j        | j	        ¦  «        j        nt	          j        | j	        ¦  «        j        }t	          j        d|| j	        | j        ¬¦  «        }t	          j        |||¦  «        }‰
dk    r|                     d¬¦  «        n|                     d¬¦  «        }	|	j                             d|¦  «        |	j                             d|¦  «        fS )Nr”   éþÿÿÿrg   r±   r+   ©r   )r‡   ÚmovedimÚ	unsqueezer†   r!   Úonesrn   ri   Útrilrh   r´   Úfinfor°   r±   ÚiinfoÚfullÚwhereÚvaluesÚindices)r¸   r   r¦   rq   Úx_gridÚincludeÚfill_valÚfillÚmaskedr¬   rÌ   s             €rJ   rt   z&_patch_cummax_or_cummin.<locals>.patch7  s¡  ø€ ØŒK˜ÔˆØ�MŠM˜#˜rÑ"Ô"ˆØ'�—’˜R‘”Ô'Ð<¨¬°°"°¬Ð<°qÐ<¸!Ð<Ð<Ð<ˆÝ”*˜Q ­¬¸E¼LÐIÑIÔI×NÒNÑPÔPˆØŒ;�%œ*Ò$Ð$Ø˜u’}ˆHˆHØ×$Ò$Ñ&Ô&ð 	gØ7;¸u²}°}•u”{ 5¤;Ñ/Ô/Ô3Ð3Í%Ì+ÐV[ÔVaÑJbÔJbÔJfˆHˆHà7;¸u²}°}•u”{ 5¤;Ñ/Ô/Ô3Ð3Í%Ì+ÐV[ÔVaÑJbÔJbÔJfˆHÝŒz˜"˜h¨e¬kÀ%Ä,ÐOÑOÔOˆÝ”˜W f¨dÑ3Ô3ˆØ$(¨E¢M Mˆf�jŠj˜RˆjÑ Ô Ð °v·z²zÀb°zÑ7IÔ7IˆØŒz×!Ò! " cÑ*Ô*¨C¬K×,?Ò,?ÀÀCÑ,HÔ,HÐHÐHrR   r+   )rs   rÌ   rt   s    ` rJ   Ú_patch_cummax_or_cumminrá   4  s(   ø€ ðIð Ið Ið Ið Ið  €LrR   ztorch.cummaxztorch.Tensor.cummaxc                ó$   — t          | d¬¦  «        S )Nr±   ©rÌ   ©rá   ©rs   s    rJ   Ú_patch_cummaxræ   J  ó   € å" 8°%Ð8Ñ8Ô8Ð8rR   ztorch.cumminztorch.Tensor.cumminc                ó$   — t          | d¬¦  «        S )Nr°   rã   rä   rå   s    rJ   Ú_patch_cumminré   O  rç   rR   ztorch.chunkztorch.Tensor.chunkc                ó   ‡ — dˆ fd„	}|S )u8  Lower `chunk` via `narrow` (â†’ ONNX `Slice`) under dynamic shapes.

    `torch.chunk` lowers to an ONNX `SplitToSequence` whose split length is a symbolic floordiv of the
    (dynamic) axis size; onnx_ir's `InlinePass` rejects that graph (e.g. diffllama's differential
    attention splitting the head axis). Narrow-based slicing produces plain `Slice` ops instead, which
    lower and inline cleanly. Only rewrites when the split axis is dynamic â€” a static axis lets torch's
    own `chunk` lowering (fixed split sizes) through, which onnxscript handles fine.
    r   c                óZ  •— |                       |¦  «        }t          |t          j        ¦  «        s ‰	| ||¦  «        S ||z   dz
  |z  }g d}}t	          |¦  «        D ]A}||dz
  k    r||z
  n|}|                     |                      |||¦  «        ¦  «         ||z   }ŒBt          |¦  «        S )Nr   r   )Úsizer6   r!   ÚSymIntÚrangeÚappendÚnarrowÚtuple)
r¸   Úchunksr   ÚtotalÚ
chunk_sizeÚsplitsÚstartÚiÚlengthrs   s
            €rJ   rt   z_patch_chunk.<locals>.patch_  sÀ   ø€ Ø—
’
˜3‘”ˆÝ˜%¥¤Ñ.Ô.ð 	0Ø�8˜E 6¨3Ñ/Ô/Ð/ð ˜f‘n qÑ(¨VÑ3ˆ
Ø˜A�ˆÝ�v‘”ð 	'ð 	'ˆAØ()¨V°a©Zª¨�e˜e‘m�m¸ZˆFØ�MŠM˜%Ÿ,š, s¨E°6Ñ:Ô:Ñ;Ô;Ð;Ø˜JÑ&ˆEˆEÝ�V‰}Œ}ÐrR   )r   r+   rv   s   ` rJ   Ú_patch_chunkrù   T  s(   ø€ ðð ð ð ð ð ð" €LrR   ztorch.reshapeztorch.Tensor.reshapeztorch.Tensor.viewc                ó   ‡ — ˆ fd„}|S )u*  Materialise a non-contiguous input before `reshape`/`view`.

    `reshape`/`view` on a permuted/non-contiguous tensor lowers to `aten.view`, which torch.export
    rejects (`Cannot view a tensor with shape ... and strides ... as ...`) because the ONNX optimizer
    folds away a plain `aten.contiguous`. Cloning to contiguous first is semantically a no-op â€” a
    contiguous view holds the same data reshaped â€” and only copies when the view would otherwise fail
    (e.g. WavLM's gated relative-position attention does `permute(...).view(...)`).
    c                ó¸   •— t          | t          j        ¦  «        r4|                      ¦   «         s |                      t          j        ¬¦  «        }  ‰| g|¢R i |¤ŽS )N)Úmemory_format)r6   r!   rj   Úis_contiguousÚcloneÚcontiguous_format)r¸   r‡   r0   rs   s      €rJ   rt   z_patch_reshape.<locals>.patch~  sb   ø€ Ý�e�Uœ\Ñ*Ô*ð 	G°5×3FÒ3FÑ3HÔ3Hð 	GØ—K’K­eÔ.E�KÑFÔFˆEØˆx˜Ð0 Ð0Ð0Ð0¨Ð0Ð0Ð0rR   r+   rv   s   ` rJ   Ú_patch_reshaper   s  s#   ø€ ð1ð 1ð 1ð 1ð 1ð
 €LrR   z	torch.expztorch.Tensor.expc                ó   ‡ — ˆ fd„}|S )u�   Lower `exp` on complex tensors via Euler â€” onnxscript has no dispatch for `aten.exp` on
    complex inputs. Real inputs hit the original path.c                óô   •— t          j        | ¦  «        rY ‰| j        ¦  «        }t          j        || j                             ¦   «         z  || j                             ¦   «         z  ¦  «        S  ‰| ¦  «        S rU   )r!   rz   r{   r}   r|   ÚcosÚsin)r¸   Ú	magnituders   s     €rJ   rt   z_patch_exp.<locals>.patch‹  sj   ø€ ÝÔ˜EÑ"Ô"ð 	]Ø ˜ ¤Ñ,Ô,ˆIÝ”= ¨U¬Z¯^ª^Ñ-=Ô-=Ñ!=¸yÈ5Ì:Ï>Ê>ÑK[ÔK[Ñ?[Ñ\Ô\Ð\Øˆx˜‰ŒÐrR   r+   rv   s   ` rJ   Ú
_patch_expr  †  s#   ø€ ð
ð ð ð ð ð €LrR   ztorch.fft.irfftc                ó   — dd„}|S )uY  Replace `irfft` with `ifft` over the conjugate-mirrored input â€” ORT's `DFT` op rejects the
    `is_onesided=1`/`inverse=1` combination that torch's `irfft` lowers to. Mirroring restores the
    full spectrum so the inverse path uses two-sided DFT, which ORT accepts. Assumes even `n`
    (which is the common case for STFT-based audio codecs).Nr”   c                óv  — |€d| j         |         dz
  z  }t          d ¦  «        g| j        z  }t          dd¦  «        ||<   t          j        | | t          |¦  «                                      |g¬¦  «                             ¦   «         g|¬¦  «        }t          j         	                    ||||¬¦  «        j
        S )Nr	   r   r”   )ÚdimsrÑ   )r¦   r   Únorm)r‡   ÚsliceÚndimr!   Úcatrñ   ÚflipÚconjÚfftÚifftr{   )r¸   r¦   r   r
  ÚslcrØ   s         rJ   rt   z_patch_irfft.<locals>.patch›  s¥   € Øˆ9Ø�U”[ Ô%¨Ñ)Ñ*ˆAÝ�T‰{Œ{ˆm˜eœjÑ(ˆÝ˜˜B‘<”<ˆˆC‰ÝŒy˜% ¥u¨S¡z¤zÔ!2×!7Ò!7¸c¸UÐ!7Ñ!CÔ!C×!HÒ!HÑ!JÔ!JÐKÐQTÐUÑUÔUˆÝŒy�~Š~˜d a¨S°tˆ~Ñ<Ô<ÔAÐArR   )Nr”   Nr+   rv   s     rJ   Ú_patch_irfftr  ”  s!   € ðBð Bð Bð Bð €LrR   ztorch.bucketizec                ó   — dddœd„}|S )zUVectorized bucketize avoiding scalar-constant tensors that cause alias/detach issues.F)Ú	out_int32Úrightc               ó’  — |                      ¦   «         dk    rCt          j        | t          j        ¬¦  «        }|r|                     t          j        ¦  «        n|S |r||                      d¦  «        k    }n||                      d¦  «        k     }|                     d¦  «        }|r|                     t          j        ¦  «        n|S )Nr   r®   r”   )Únumelr!   Ú
zeros_liker§   rk   Úint32rÓ   Úsum)r¸   Ú
boundariesr  r  r�   Úmasks         rJ   rt   z_patch_bucketize.<locals>.patchª  s±   € Ø×ÒÑÔ Ò"Ð"ÝÔ% eµ5´;Ð?Ñ?Ô?ˆFØ-6ÐB�6—9’9�Uœ[Ñ)Ô)Ð)¸FÐBØð 	4Ø §¢°Ñ!4Ô!4Ò4ˆDˆDà §¢°Ñ 3Ô 3Ò3ˆDØ—’˜"‘”ˆØ)2Ð>ˆv�yŠy�œÑ%Ô%Ð%¸Ð>rR   r+   rv   s     rJ   Ú_patch_bucketizer  ¦  s)   € ð /4¸5ð 	?ð 	?ð 	?ð 	?ð 	?ð €LrR   ztorch.searchsortedc                ó   — ddddddœd„}|S )uG  Decompose searchsorted via broadcast comparison + sum â€” no ONNX op for searchsorted.

    For sorted inputs the insertion index equals the count of elements satisfying
    the comparison (< for left, <= for right). This is O(N*M) instead of the
    real binary-search O(M log N) but only uses ops with ONNX translations.
    FN)r  r  Úsider¬   Úsorterc               ó8  — |�|dk    }|r-|                       d¦  «        |                      d¦  «        k    }n,|                       d¦  «        |                      d¦  «        k     }|                     d¦  «        }|r|                     t          j        ¦  «        n|S )Nr  r”   rÐ   )rÓ   r  rk   r!   r  )	Úsorted_sequencerÚ   r  r  r   r¬   r!  r  r�   s	            rJ   rt   z"_patch_searchsorted.<locals>.patchÁ  s•   € ØÐØ˜G’OˆEØð 	HØ"×,Ò,¨RÑ0Ô0°F×4DÒ4DÀRÑ4HÔ4HÒHˆDˆDà"×,Ò,¨RÑ0Ô0°6×3CÒ3CÀBÑ3GÔ3GÒGˆDØ—’˜"‘”ˆØ)2Ð>ˆv�yŠy�œÑ%Ô%Ð%¸Ð>rR   r+   rv   s     rJ   Ú_patch_searchsortedr$  ¸  s1   € ð 5:ÀÈTÐW[Ðdhð ?ð ?ð ?ð ?ð ?ð €LrR   z
torch.fullc                ó   ‡ — ddœˆ fd„
}|S )z`Force dtype=torch.long when fill_value is int and no dtype specified (ONNX defaults to float32).Nr®   c                óÀ   •— | €R|                      dt          |¦  «        dk    r|d         nd ¦  «        }t          |t          ¦  «        rt          j        }  ‰|d| i|¤ŽS )NÚ
fill_valuer   rh   )rÆ   Úlenr6   rl   r!   r²   )rh   r,   r0   r'  rs   s       €rJ   rt   z_patch_full.<locals>.patchÒ  se   ø€ Øˆ=àŸš L½SÀ¹Y¼YÈº]¸]°$°q´'°'ÐPTÑUÔUˆJÝ˜*¥cÑ*Ô*ð #Ýœ
�Øˆx˜Ð5 UÐ5¨fÐ5Ð5Ð5rR   r+   rv   s   ` rJ   Ú_patch_fullr)  Î  s2   ø€ ð  ð 6ð 6ð 6ð 6ð 6ð 6ð 6ð €LrR   ztorch.masked.meanc                ó   — ddddœd„}|S )zCManual masked mean: avoids sum/int_count Div type mismatch in ONNX.NF)r   r•   rh   c               ó  — |                      ¦   «         }|                     |d¬¦  «                             d¬¦  «        }| |z                       ||¬¦  «        |r|n|                     ¦   «         z  }|�|                     |¦  «        n|S )NT©r   r•   ç      ð?©r°   )rm   r  ÚclampÚsqueezerk   )r¸   r  r   r•   rh   Ú
mask_floatr¦   r�   s           rJ   rt   z!_patch_masked_mean.<locals>.patchá  s‰   € Ø—Z’Z‘\”\ˆ
Ø�NŠN˜s¨DˆNÑ1Ô1×7Ò7¸CÐ7Ñ@Ô@ˆØ˜*Ñ$×)Ò)¨c¸7Ð)ÑCÔCÈGÐGdÀqÀqÐYZ×YbÒYbÑYdÔYdÑeˆØ#(Ð#4ˆv�yŠy˜ÑÔÐ¸&Ð@rR   r+   rv   s     rJ   Ú_patch_masked_meanr2  Ý  s0   € ð #'°¸Tð Að Að Að Að Að €LrR   ztorch.masked.varc                ó   — ddddœd„}|S )zBManual masked var: avoids sum/int_count Div type mismatch in ONNX.NFT)r   r•   Úunbiasedc               óŠ  — |                      ¦   «         }|                     |d¬¦  «                             d¬¦  «        }| |z                       |d¬¦  «        |z  }| |z
                       d¦  «        |z                       ||¬¦  «        }|r|dz
  n|}	|s|	                     ¦   «         }	||	                     d¬¦  «        z  S )NTr,  r-  r.  r	   )rm   r  r/  r˜   r0  )
r¸   r  r   r•   r4  r1  r¦   r™   ÚvarÚdenoms
             rJ   rt   z _patch_masked_var.<locals>.patchî  sÆ   € Ø—Z’Z‘\”\ˆ
Ø�NŠN˜s¨DˆNÑ1Ô1×7Ò7¸CÐ7Ñ@Ô@ˆØ˜
Ñ"×'Ò'¨C¸Ð'Ñ>Ô>ÀÑBˆØ˜‘×!Ò! !Ñ$Ô$ zÑ1×6Ò6¸3ÈÐ6ÑPÔPˆØ%Ð,��S‘�¨1ˆØð 	$Ø—M’M‘O”OˆEØ�U—[’[ S�[Ñ)Ô)Ñ)Ð)rR   r+   rv   s     rJ   Ú_patch_masked_varr8  ê  s+   € ð #'°Àð *ð *ð *ð *ð *ð €LrR   ztorch.Tensor.masked_scatterc                ó   — d„ }|S )zPCumsum-gather-where strategy for masked_scatter (avoids ScatterND ORT failures).c                ó   — |                      | ¦  «        }|                     d¦  «        }|                     t          j        ¦  «                             d¦  «        dz
                       d¬¦  «        }|                     d¦  «        |         }t          j        |||                      d¦  «        ¦  «                             | j        ¦  «        S )Nr”   r   r   r.  )	Ú	expand_asr¯   rk   r!   r§   Úcumsumr/  rÙ   r‡   )rD   r  ÚsourceÚ	flat_maskÚ	positionsÚgathereds         rJ   rt   z$_patch_masked_scatter.<locals>.patchÿ  s¡   € Ø�~Š~˜dÑ#Ô#ˆØ—L’L Ñ$Ô$ˆ	Ø—\’\¥%¤+Ñ.Ô.×5Ò5°aÑ8Ô8¸1Ñ<×CÒCÈÐCÑJÔJˆ	Ø—>’> "Ñ%Ô% iÔ0ˆÝŒ{˜9 h°·²¸RÑ0@Ô0@ÑAÔA×IÒIÈ$Ì*ÑUÔUÐUrR   r+   rv   s     rJ   Ú_patch_masked_scatterrA  û  s   € ðVð Vð Vð €LrR   z
torch.rollc                ó   ‡ — dˆ fd„	}|S )a  Replace `torch.roll(input, shifts, dims)` with explicit `narrow + cat` shifts.

    `torch.roll`'s torch.export lowering emits a `Shape(start, end)` op that can resolve to an
    empty INT64 result; the downstream `Slice` then has mismatched `axes` and `ends` lengths
    and ORT rejects the graph with `ShapeInferenceError` (seen in Gemma4-Unified Vision2Text,
    where roll is composed with an in-place scatter `[..., 0] = value`). The explicit form is
    bit-exact and traces to plain Slice + Concat nodes.
    Nc                óN  •— t          |t          ¦  «        rt          |t          ¦  «        r|f}|f}net          |t          t          f¦  «        r<t          |t          t          f¦  «        r t	          |¦  «        t	          |¦  «        k    s ‰	| ||¦  «        S | }t          ||¦  «        D ]z\  }}|                     |¦  «        }|dk    r||z  nd}|dk    rŒ.|                     |||z
  |¦  «        }|                     |d||z
  ¦  «        }t          j	        ||g|¬¦  «        }Œ{|S )Nr   rÑ   )
r6   rl   rñ   Úlistr(  Úziprì   rð   r!   r  )
r¸   Úshiftsr	  r¬   Úshiftr   rø   ÚfrontÚbackrs   s
            €rJ   rt   z_patch_roll.<locals>.patch  s7  ø€ Ý�f�cÑ"Ô"ð 	1¥z°$½Ñ'<Ô'<ð 	1Ø�YˆFØ�7ˆDˆDÝ˜V¥e­T ]Ñ3Ô3ð 	1½
À4Í%ÕQUÈÑ8WÔ8Wð 	1Õ\_Ð`fÑ\gÔ\gÕknÐosÑktÔktÒ\tÐ\tØ�8˜E 6¨4Ñ0Ô0Ð0àˆÝ˜f dÑ+Ô+ð 	4ð 	4‰JˆE�3Ø—X’X˜c‘]”]ˆFØ&,¨q¢j j�E˜F‘N�N°aˆEØ˜ŠzˆzØØ—J’J˜s F¨U¡N°EÑ:Ô:ˆEØ—:’:˜c 1 f¨u¡nÑ5Ô5ˆDÝ”)˜U D˜M¨sÐ3Ñ3Ô3ˆCˆCØˆ
rR   rU   r+   rv   s   ` rJ   Ú_patch_rollrJ  	  s(   ø€ ðð ð ð ð ð ð$ €LrR   zHtorch.onnx._internal.exporter._core._prepare_exported_program_for_exportc                ó   ‡ — ˆ fd„}|S )aò  Run the FX node fixes immediately after the ONNX internal decomposition step.

    `torch.onnx.export` internally calls `run_decompositions` with the ONNX
    decomposition table, which can introduce new symbolic-guard nodes (e.g.
    `operator.le(sym_size, int_oo)`). These overflow during ONNX translation.
    Wrapping the prepare step lets us apply our FX fixes immediately after.

    <Tip warning={true}>

    This hooks `torch.onnx._internal.exporter._core._prepare_exported_program_for_export`,
    a private PyTorch API. It may break on PyTorch version upgrades. If it does,
    find the new entry point in `torch/onnx/_internal/exporter/_core.py`
    where `ExportedProgram.run_decompositions` is called and hook there instead.

    </Tip>
    c               óL   •—  ‰| |¬¦  «        }t          d|j        ¦  «         |S )N)Úregistryr"   )r   r>   )ÚeprM  r�   rs   s      €rJ   rt   z(_patch_prepare_for_export.<locals>.patchD  s/   ø€ Ø�˜" xÐ0Ñ0Ô0ˆÝ˜F FÔ$7Ñ8Ô8Ð8ØˆrR   r+   rv   s   ` rJ   Ú_patch_prepare_for_exportrO  1  s#   ø€ ð&ð ð ð ð ð
 €LrR   Úgmútorch.fx.GraphModuleÚnodeútorch.fx.Nodern   c                óp  — |j         t          vrdS t          |j        ¦  «        dk    r| j                             |¦  «         dS t          d„ |j        D ¦   «         ¦  «        rS	  |j         |j        Ž }n# t          $ r Y dS w xY w| 	                    |¦  «         | j                             |¦  «         dS dS )u.  Erase or constant-fold comparison nodes involving symbolic infinities.

    torch.export emits guards like ``%le_3 = operator.le(sym_size, int_oo)`` where
    ``int_oo`` is a sympy ``IntInfinity`` object.  The ONNX translator tries to lower it
    to a C long and overflows.  Two cases handled:

    * No users â†’ erase the node outright (PyTorch DCE skips Python callables).
    * Any arg is a non-FX-Node constant (e.g. ``int_oo``) â†’ evaluate the comparison at
      graph-construction time, replace all uses with the Python bool result, and erase.
    Fr   Tc              3  óV   K  — | ]$}t          |t          j        j        ¦  «         V — Œ%d S rU   )r6   r!   ÚfxÚNode)Ú.0Úas     rJ   ú	<genexpr>z'_fix_dead_comparison.<locals>.<genexpr>h  s3   è è € Ð
?Ð
?°�z˜!�UœXœ]Ñ+Ô+Ð+Ð
?Ð
?Ð
?Ð
?Ð
?Ð
?rR   )
ÚtargetÚ_COMPARISON_OPSr(  ÚusersÚgraphÚ
erase_nodeÚanyr,   Ú	ExceptionÚreplace_all_uses_with)rP  rR  r�   s      rJ   Ú_fix_dead_comparisonrc  V  sÒ   € ð „{�/Ð)Ð)ØˆuÝ
ˆ4Œ:�„˜!ÒÐØ
Œ×Ò˜DÑ!Ô!Ð!Øˆtå
Ð
?Ð
?°T´YÐ
?Ñ
?Ô
?Ñ?Ô?ð ð	Ø �T”[ $¤)Ð,ˆFˆFøÝð 	ð 	ð 	Ø�5�5ð	øøøà×"Ò" 6Ñ*Ô*Ð*Ø
Œ×Ò˜DÑ!Ô!Ð!ØˆtØˆ5s   Á$A4 Á4
BÂBc                óÂ   — |j         t          j        j        j        j        urdS |                     |j        d         ¦  «         | j         	                    |¦  «         dS )zHReplace alias(x) -> x to break the alias -> detach_ -> index_put_ chain.Fr   T)
r[  r!   ÚopsÚatenÚaliasÚdefaultrb  r,   r^  r_  ©rP  rR  s     rJ   Ú
_fix_aliasrj  s  sU   € ð „{�%œ)œ.Ô.Ô6Ð6Ð6ØˆuØ×Ò˜tœy¨œ|Ñ,Ô,Ð,Ø„H×Ò˜ÑÔÐØˆ4rR   c                ó�  — |j         t          j        j        j        j        urdS | j                             |¦  «        5  | j                             t          j        j        j	        j        |j
        |j        ¬¦  «        }ddd¦  «         n# 1 swxY w Y   |                     |¦  «         | j                             |¦  «         dS )z2Replace in-place detach_ with out-of-place detach.F©r,   r0   NT)r[  r!   re  rf  Údetach_rh  r^  Úinserting_beforeÚcall_functionÚdetachr,   r0   rb  r_  ©rP  rR  Únews      rJ   Ú_fix_detach_inplacers  }  s÷   € ð „{�%œ)œ.Ô0Ô8Ð8Ð8ØˆuØ	Œ×	"Ò	" 4Ñ	(Ô	(ð hð hØŒh×$Ò$¥U¤Y¤^Ô%:Ô%BÈÌÐ[_Ô[fÐ$ÑgÔgˆðhð hð hñ hô hð hð hð hð hð hð høøøð hð hð hð hà×Ò˜sÑ#Ô#Ð#Ø„H×Ò˜ÑÔÐØˆ4ó   ¿ABÂBÂBc                ó�  — |j         t          j        j        j        j        urdS | j                             |¦  «        5  | j                             t          j        j        j	        j        |j
        |j        ¬¦  «        }ddd¦  «         n# 1 swxY w Y   |                     |¦  «         | j                             |¦  «         dS )z8Replace in-place index_put_ with out-of-place index_put.Frl  NT)r[  r!   re  rf  Ú
index_put_rh  r^  rn  ro  Ú	index_putr,   r0   rb  r_  rq  s      rJ   Ú_fix_index_put_inplacerx  ‰  s÷   € ð „{�%œ)œ.Ô3Ô;Ð;Ð;ØˆuØ	Œ×	"Ò	" 4Ñ	(Ô	(ð kð kØŒh×$Ò$¥U¤Y¤^Ô%=Ô%EÈDÌIÐ^bÔ^iÐ$ÑjÔjˆðkð kð kñ kô kð kð kð kð kð kð køøøð kð kð kð kà×Ò˜sÑ#Ô#Ð#Ø„H×Ò˜ÑÔÐØˆ4rt  c                óZ   — |j         t          vrdS | j                             |¦  «         dS )zFErase assertion / shape-constraint nodes that have no ONNX equivalent.FT)r[  Ú_ASSERTION_OPSr^  r_  ri  s     rJ   Ú_fix_assertionr{  ¢  s1   € ð „{�.Ð(Ð(ØˆuØ„H×Ò˜ÑÔÐØˆ4rR   c                óî  — |j         t          j        j        j        j        urdS | j                             |¦  «        5  |j        d         }|j        d         }| j         	                    t          j        j        j
        j        |df¬¦  «        }| j         	                    t          j        j        j
        j        |df¬¦  «        }| j         	                    t          j        j        j        j        ||f¬¦  «        }| j         	                    t          j        j        j        j        |t          j        f¬¦  «        }| j         	                    t          j        j        j        j        ||f¬¦  «        }| j         	                    t          j        j        j        j        |||f¬¦  «        }	ddd¦  «         n# 1 swxY w Y   |                     |	¦  «         | j                             |¦  «         dS )z=Replace in-place fill_diagonal_ with out-of-place equivalent.Fr   r   ©r,   NT)r[  r!   re  rf  Úfill_diagonal_rh  r^  rn  r,   ro  Úsym_sizerl   Úeyerk   rh   rn   Ú	full_likerÙ   rD   rb  r_  )
rP  rR  Ú
tensor_argr'  ÚrowsÚcolsr€  Úeye_boolÚfill_tensorrr  s
             rJ   Ú_fix_fill_diagonal_inplacer‡  «  sà  € ð „{�%œ)œ.Ô7Ô?Ð?Ð?ØˆuØ	Œ×	"Ò	" 4Ñ	(Ô	(ð 	jð 	jØ”Y˜q”\ˆ
Ø”Y˜q”\ˆ
àŒx×%Ò%¥e¤i¤nÔ&=Ô&AÈÐUVÈÐ%ÑXÔXˆØŒx×%Ò%¥e¤i¤nÔ&=Ô&AÈÐUVÈÐ%ÑXÔXˆØŒh×$Ò$¥U¤Y¤^Ô%7Ô%?ÀtÈTÀlÐ$ÑSÔSˆØ”8×)Ò)­%¬)¬.Ô*;Ô*AÈÍeÌjÐHYÐ)ÑZÔZˆØ”h×,Ò,­U¬Y¬^Ô-EÔ-MÐU_ÐakÐTlÐ,ÑmÔmˆØŒh×$Ò$¥U¤Y¤^Ô%9Ô%>ÀhÐP[Ð]gÐEhÐ$ÑiÔiˆð	jð 	jð 	jñ 	jô 	jð 	jð 	jð 	jð 	jð 	jð 	jøøøð 	jð 	jð 	jð 	jð 	×Ò˜sÑ#Ô#Ð#Ø„H×Ò˜ÑÔÐØˆ4s   ¿E0F;Æ;F?ÇF?c                ó�  — |j         t          j        j        j        j        urdS | j                             |¦  «        5  | j                             t          j        j        j	        j        |j
        |j        ¬¦  «        }ddd¦  «         n# 1 swxY w Y   |                     |¦  «         | j                             |¦  «         dS )z.Replace in-place triu_ with out-of-place triu.Frl  NT)r[  r!   re  rf  Útriu_rh  r^  rn  ro  Útriur,   r0   rb  r_  rq  s      rJ   Ú_fix_triu_inplacer‹  ¿  s÷   € ð „{�%œ)œ.Ô.Ô6Ð6Ð6ØˆuØ	Œ×	"Ò	" 4Ñ	(Ô	(ð fð fØŒh×$Ò$¥U¤Y¤^Ô%8Ô%@ÀtÄyÐY]ÔYdÐ$ÑeÔeˆðfð fð fñ fô fð fð fð fð fð fð føøøð fð fð fð fà×Ò˜sÑ#Ô#Ð#Ø„H×Ò˜ÑÔÐØˆ4rt  c                ó6  — |j         t          j        j        j        j        urdS |j        d         }t          |j        ¦  «        dk    r|j        d         nd}t          |j        ¦  «        dk    r|j        d         nd}| j         	                    |¦  «        5  | j         
                    t          j        j        j        j        |||f¬¦  «        }ddd¦  «         n# 1 swxY w Y   |                     |¦  «         | j                             |¦  «         dS )	zMReplace aten.sort.stable with aten.sort.default (which has ONNX translation).Fr   r	   r”   é   r}  NT)r[  r!   re  rf  ÚsortÚstabler,   r(  r^  rn  ro  rh  rb  r_  )rP  rR  Úself_argr   Ú
descendingrr  s         rJ   Ú_fix_sort_stabler’  Ë  sE  € ð „{�%œ)œ.Ô-Ô4Ð4Ð4ØˆuØŒy˜Œ|€HÝ˜dœi™.œ.¨1Ò,Ð,ˆ$Œ)�AŒ,ˆ,°"€CÝ!$ T¤Y¡¤°!Ò!3Ð!3�”˜1”�¸€JØ	Œ×	"Ò	" 4Ñ	(Ô	(ð dð dØŒh×$Ò$¥U¤Y¤^Ô%8Ô%@ÈÐRUÐWaÐGbÐ$ÑcÔcˆðdð dð dñ dô dð dð dð dð dð dð døøøð dð dð dð dà×Ò˜sÑ#Ô#Ð#Ø„H×Ò˜ÑÔÐØˆ4s   Â9CÃC#Ã&C#Ú	frozensetc                 ó$  — t          t          j        j        j        j        t          j        j        j        j        t          j        j        j        j        t          j        j        j        j        t          j        j        j        j        h¦  «        S )u#  Ops where a Python float meeting an integral tensor needs the tensor promoted first.

    Named for torch 2.13, where the mishandling appeared, but applied on every version: both rewrites are
    semantics-preserving â€” a cast to the dtype the op already produces, and an overload swap with the same
    meaning â€” so gating them on a version would add a branch that changes nothing except which torch the
    path is exercised on.

    `sub`/`rsub` and `mul` are what the affected models spell (`1.0 - attention_mask`, `mask * 2.0`); both
    overloads appear, since decomposition rewrites `.Tensor` to `.Scalar` when the operand is a constant.

    Resolved on first use rather than at import: this module is importable without torch, and naming an
    `OpOverload` at module scope breaks that.
    )	r“  r!   re  rf  ÚrsubÚScalarÚsubrj   Úmulr+   rR   rJ   Ú_integral_scalar_promotion_opsr™  Ú  s\   € õ åŒIŒNÔÔ&ÝŒIŒNÔÔ%ÝŒIŒNÔÔ%ÝŒIŒNÔÔ%ÝŒIŒNÔÔ%ð	
ñô ð rR   c                óú  — |j         t          ¦   «         vrdS t          |j        ¦  «        dk     rdS |j        d         |j        d         }}t	          |t
          j        j        ¦  «        rt	          |t          ¦  «        sdS |j	         
                    d¦  «        |j	         
                    d¦  «        }}|�|€dS |j        j        s|j        j        sdS | j                             |¦  «        5  | j                             t
          j        j        j        j        |fd|j        i¬¦  «        }ddd¦  «         n# 1 swxY w Y   |j	                             |j	        ¦  «         |                     ||¦  «         d	S )
uv  Promote an integral tensor before it meets a Python float, which torch 2.13 mishandles.

    Two torch 2.13 regressions have the same shape â€” a float scalar against an *integral* tensor, whose
    promotion the export pipeline no longer gets right:

    - `1.0 - int_mask` (`aten.rsub.Scalar`) crashes the decomposition pass (pytorch/pytorch#194381),
    - `int_mask * 2.0` (`aten.mul.Tensor`, `aten.mul.Scalar` after decomposition) reaches translation with
      no ONNX decomposition registered for it (pytorch/pytorch#194382).

    Both go away once the tensor is already the dtype the op produces: `1.0 - float_tensor` and
    `float_tensor * 2.0` export fine on the same torch. So rather than rewriting the op â€” which would mean
    building the constant as a tensor and picking the right overload â€” cast its tensor operand up front and
    leave the op alone. The cast's value is the op's own output for these elementwise cases (same shape,
    the promoted dtype), so it carries `node.meta` unchanged.

    Self-limiting: once the operand is floating point the predicate no longer matches, so the walk cannot
    revisit it.
    Fr	   r   r   ÚvalNrh   rl  T)r[  r™  r(  r,   r6   r!   rV  rW  rm   ÚmetarÆ   rh   r´   r^  rn  ro  re  rf  Ú_to_copyrh  ÚupdateÚreplace_input_with)rP  rR  r‚  Ú
scalar_argÚoperandr�   Úpromoteds          rJ   Ú!_fix_integral_tensor_float_scalarr£  ô  s¡  € ð( „{Õ8Ñ:Ô:Ð:Ð:ØˆuÝ
ˆ4Œ9�~„~˜ÒÐØˆuØ!œY qœ\¨4¬9°Q¬<�
€Jå�j¥%¤(¤-Ñ0Ô0ð ½
À:ÍuÑ8UÔ8Uð ØˆuØ ”o×)Ò)¨%Ñ0Ô0°$´)·-²-ÀÑ2FÔ2FˆV€GØ€˜&˜.ØˆuØ„}Ô&ð ¨f¬lÔ.Lð ØˆuØ	Œ×	"Ò	" 4Ñ	(Ô	(ð 
ð 
Ø”8×)Ò)ÝŒIŒNÔ#Ô+°:°-ÈÐRXÔR^ÐH_ð *ñ 
ô 
ˆð
ð 
ð 
ñ 
ô 
ð 
ð 
ð 
ð 
ð 
ð 
øøøð 
ð 
ð 
ð 
ð „M×Ò˜œÑ#Ô#Ð#Ø×Ò˜J¨Ñ1Ô1Ð1Øˆ4s   Ã0?D;Ä;D?ÅD?c                ó  — |j         t          j        j        j        j        urdS t          |j        ¦  «        dk     s*t          |j        d         t          j	        j
        ¦  «        sdS |j        d         j                             d¦  «        }t          |t          j        t          j        t          j        t          j        f¦  «        sdS | j                             |¦  «        5  | j                             t          j        j        j        j        |j        ¬¦  «        }ddd¦  «         n# 1 swxY w Y   |j                             |j        ¦  «         |                     |¦  «         | j                             |¦  «         dS )uÔ  Rewrite `mul.Scalar` to `mul.Tensor` when its 'scalar' is a graph node.

    The other half of pytorch/pytorch#194382: torchlib registers no real-valued `aten.mul.Scalar`
    translation at all, and decomposition also produces that overload with a *symbolic* second operand â€” a
    division result rather than a literal (`mul.Scalar(x, %truediv_1)`) â€” which the promotion fix above
    cannot address, since there is no Python constant to promote against. `mul.Tensor` has the two-operand
    translation, which is the same rewrite `_fix_remainder_scalar` makes for the same reason.

    That operand is a `SymFloat`, not a tensor: across the affected families every one of the 33 sites is
    an `operator.truediv` result. `mul.Tensor`'s translation takes a symbolic scalar there â€” it becomes a
    graph value like any other â€” so the rewrite is sound, but the guard below names both accepted forms
    rather than trusting that a `Node` implies a tensor. Anything else (a nested list, an unbacked value
    with no `val`) is left as `mul.Scalar` to fail visibly in translation instead of silently here.

    Reached because the FX fixes run a second time right after `run_decompositions`, where this overload
    appears.
    Fr	   r   r›  r}  NT)r[  r!   re  rf  r˜  r–  r(  r,   r6   rV  rW  rœ  rÆ   rj   ÚSymFloatrí   ÚSymBoolr^  rn  ro  rž  rb  r_  )rP  rR  Úotherrr  s       rJ   Ú_fix_mul_scalar_symbolicr¨    s|  € ð& „{�%œ)œ.Ô,Ô3Ð3Ð3ØˆuÝ
ˆ4Œ9�~„~˜ÒÐ¥¨D¬I°a¬L½%¼(¼-Ñ!HÔ!HÐØˆuØŒI�aŒLÔ×!Ò! %Ñ(Ô(€EÝ�e�eœl­E¬N½E¼LÍ%Ì-ÐXÑYÔYð ØˆuØ	Œ×	"Ò	" 4Ñ	(Ô	(ð Pð PØŒh×$Ò$¥U¤Y¤^Ô%7Ô%>ÀTÄYÐ$ÑOÔOˆðPð Pð Pñ Pô Pð Pð Pð Pð Pð Pð Pøøøð Pð Pð Pð Pà„H‡O‚O�D”IÑÔÐØ×Ò˜sÑ#Ô#Ð#Ø„H×Ò˜ÑÔÐØˆ4s   Ã&;D-Ä-D1Ä4D1c                ó  — |j         t          j        j        j        j        urdS t          |j        ¦  «        dk     s*t          |j        d         t          j	        j
        ¦  «        sdS | j                             |¦  «        5  | j                             t          j        j        j        j        |j        ¬¦  «        }ddd¦  «         n# 1 swxY w Y   |                     |¦  «         | j                             |¦  «         dS )aµ  Rewrite remainder.Scalar to remainder.Tensor when the 'scalar' arg is actually a tensor.

    After decomposition the second operand of ``aten.remainder.Scalar`` can be a graph
    node (SymbolicTensor) rather than a Python scalar.  The ONNX torchlib translation for
    ``remainder.Scalar`` calls ``int()`` on it and crashes.  Rewriting to
    ``remainder.Tensor`` uses the two-tensor ONNX translation which handles this correctly.
    Fr	   r   r}  NT)r[  r!   re  rf  Ú	remainderr–  r(  r,   r6   rV  rW  r^  rn  ro  rj   rb  r_  rq  s      rJ   Ú_fix_remainder_scalarr«  @  s"  € ð „{�%œ)œ.Ô2Ô9Ð9Ð9ØˆuÝ
ˆ4Œ9�~„~˜ÒÐ¥¨D¬I°a¬L½%¼(¼-Ñ!HÔ!HÐØˆuØ	Œ×	"Ò	" 4Ñ	(Ô	(ð Vð VØŒh×$Ò$¥U¤Y¤^Ô%=Ô%DÈ4Ì9Ð$ÑUÔUˆðVð Vð Vñ Vô Vð Vð Vð Vð Vð Vð Vøøøð Vð Vð Vð Và×Ò˜sÑ#Ô#Ð#Ø„H×Ò˜ÑÔÐØˆ4s   Â;C
Ã
CÃCrÚ   r   rD   c                ó¬  — | j         �1|j         �*t          | j         ¦  «        t          |j         ¦  «        k    rdS t          |j         ¦  «        t          | j         ¦  «        z
  }t          | j         |j         |d…         ¦  «        D ]M\  }}	 t          |¦  «        t          |¦  «        }}n# t          t
          f$ r Y  dS w xY w|dk    r	||k    r dS ŒNdS )u™  Static-shape check: does ``values.shape`` broadcast against ``self.shape``?

    Returns ``True`` only when every dim of ``values`` is statically known and either
    equals the corresponding (right-aligned) dim of ``self`` or is ``1``. Used to dispatch
    `_aten_index_put` between the broadcast and flat-gather paths â€” bailing on dynamic /
    unknown dims keeps us on the safe flat-gather fallback.
    NFr   T)r‡   r(  rE  rl   r9   Ú
ValueError)rÚ   rD   ÚoffsetÚv_dimÚs_dims        rJ   Ú_values_broadcast_to_selfr±  Z  sÝ   € ð „|Ð˜tœzÐ1µS¸¼Ñ5FÔ5FÍÈTÌZÉÌÒ5XÐ5XØˆuÝ�”‰_Œ_�s 6¤<Ñ0Ô0Ñ0€FÝ˜FœL¨$¬*°V°W°WÔ*=Ñ>Ô>ð ð ‰ˆˆuð	Ý˜u™:œ:¥s¨5¡z¤z�5ˆEˆEøÝ�:Ð&ð 	ð 	ð 	Ø�5�5�5ð	øøøà�AŠ:ˆ:˜% 5š.˜.Ø�5�5øØˆ4s   ÂB+Â+CÃ CFrÛ   úSequence[INT64 | BOOL | None]Ú
accumulatec                ó  — |d         }|duo2t          t          |dd¦  «        dd¦  «        t          j        j        k    }|st	          | |||¦  «        S t          t          | j        ¦  «        t          |j        ¦  «        z
  ¦  «        D ]+}t          j	        |t          j
        dg¬¦  «        ¦  «        }Œ,t          j        |t          j        | ¦  «        ¦  «        }t          || ¦  «        r=t          j        |t          j        | ¦  «        ¦  «        }t          j        ||| ¦  «        S t          j        |t          j
        dg¬¦  «        ¦  «        }	t          j        |	d¬¦  «        }
t          j        |
t          j
        dg¬¦  «        ¦  «        }t          j        t          j        |t          j
        d	g¬¦  «        ¦  «        t          j
        dg¬¦  «        ¦  «        }t          j        |t          j
        dg¬¦  «        ¦  «        }t          j        ||¦  «        }t          j        | t          j
        dg¬¦  «        ¦  «        }t          j        |	||¦  «        }t          j        |t          j        | ¦  «        ¦  «        S )
uä  Bool-mask index_put with two paths; delegates non-bool-mask cases to torchlib.

    For `self[bool_mask] = values`, PyTorch supports two distinct shapes for ``values``:
    1. Broadcasts against ``self.shape`` (e.g. scalar `tensor[~mask] = 0`) â€” handled by
       `Expand(values, Shape(self)) + Where(mask, expanded, self)`.
    2. Equals ``bool_mask.sum()`` along its first dim, with remaining dims matching
       ``self`` (e.g. `inputs_embeds[image_mask] = image_features_flat`) â€” handled by
       the flat cumulative-count-Gather + Where trick.

    Path 1 is correct only when broadcast-compatibility can be statically verified â€” for
    dynamic shapes we fall through to path 2, which is also torchlib's default behaviour.
    r   Nr8   rh   r”   ©rÄ   é   ©rk   r   )ÚgetattrrÈ   ÚDataTyper   r   rî   r(  r‡   ÚopÚ	UnsqueezeÚConstantÚExpandÚShaper±  ÚWhereÚReshapeÚCastÚCumSumÚClipÚSubÚGather)rD   rÛ   rÚ   r³  Ú	bool_maskÚis_boolÚ_Úexpanded_maskÚexpanded_valuesr>  Úflat_mask_intÚcsr?  Úflat_valuesr@  Ú	flat_selfr�   s                    rJ   Ú_aten_index_putrÏ  o  s  € ð$ ˜”
€Ià˜ÐÐs¥'­'°)¸VÀTÑ*JÔ*JÈGÐUYÑ"ZÔ"ZÕ^eÔ^nÔ^sÒ"sð ð ð AÝ˜d G¨V°ZÑ@Ô@Ð@Ý•3�t”z‘?”?¥S¨¬Ñ%9Ô%9Ñ9Ñ:Ô:ð Jð JˆÝ”L ­B¬KÀBÀ4Ð,HÑ,HÔ,HÑIÔIˆ	ˆ	Ý”I˜i­¬°$©¬Ñ8Ô8€MÝ  ¨Ñ.Ô.ð >Ýœ) F­B¬H°T©N¬NÑ;Ô;ˆÝŒx˜ ¸Ñ=Ô=Ð=Ý”
˜=­"¬+À"ÀÐ*FÑ*FÔ*FÑGÔG€IÝ”G˜I¨!Ð,Ñ,Ô,€MÝ	Œ�=¥"¤+¸!¸Ð"=Ñ"=Ô"=Ñ	>Ô	>€BÝ”�œ˜r¥2¤;¸1¸#Ð#>Ñ#>Ô#>Ñ?Ô?ÅÄÐYZÐX[ÐA\ÑA\ÔA\Ñ]Ô]€IÝ”*˜V¥R¤[¸R¸DÐ%AÑ%AÔ%AÑBÔB€KÝŒy˜ iÑ0Ô0€HÝ”
˜4¥¤¸¸Ð!=Ñ!=Ô!=Ñ>Ô>€IÝŒX�i ¨9Ñ5Ô5€FÝŒ:�f�bœh t™nœnÑ-Ô-Ð-rR   r   Ú	minlengthrl   c                óà  — t          j        dg¬¦  «        }t          j        t          j        | d¬¦  «        t          j        dg¬¦  «        ¦  «        }t          j        ||¦  «        }|dk    r)t          j        |t          j        |g¬¦  «        ¦  «        }t          j        | |t          j        ddg¬¦  «        d¬¦  «        }t          j        |t          j        dg¬¦  «        d¬¦  «        S )a  ONNX implementation of `torch.bincount`: count occurrences of non-negative ints.

    No native ONNX op. We use `OneHot(self, depth=max+1, values=[0,1])` then `ReduceSum`
    along the input axis. Weights are unused (splinter's only caller passes none).
    r   rµ  r   )Úkeepdimsr”   ©Úaxis)rº  r¼  r»  Ú	ReduceMaxÚAddÚMaxÚOneHotÚ	ReduceSum)rD   ÚweightsrÐ  Úoner¼   ÚdepthÚone_hots          rJ   Ú_aten_bincountrÞ  ˜  sÒ   € õ Œ+ ! Ð
%Ñ
%Ô
%€CÝŒl�2œ<¨°qÐ9Ñ9Ô9½2¼;ÐSTÐRUÐ;VÑ;VÔ;VÑWÔW€GÝŒF�7˜CÑ Ô €EØ�1‚}€}Ý”�u�bœk°i°[ÐAÑAÔAÑBÔBˆÝŒi˜˜e¥R¤[¸QÀ¸FÐ%CÑ%CÔ%CÈ"ÐMÑMÔM€GÝŒ<˜¥¤¸¸Ð!<Ñ!<Ô!<ÀqÐIÑIÔIÐIrR   Úmat_aÚmat_bÚoffsc           	     ó˜  — |j         d         }t          |t          ¦  «        st          d¦  «        ‚t	          j        |d¬¦  «        }t	          j        dg¬¦  «        }t	          j        dg¬¦  «        }g }	|}
t          |¦  «        D ]³}t	          j        |g¬¦  «        }t	          j        |dz   g¬¦  «        }t	          j        ||||¦  «        }t	          j        | |
||¦  «        }t	          j	        t	          j        ||||¦  «        |¦  «        }|	 
                    t	          j        ||¦  «        ¦  «         |}
Œ´t	          j        |	ddiŽS )uZ  ONNX implementation of `aten._grouped_mm.default`.

    `_grouped_mm(mat_a: (M, K), mat_b: (G, K, N), offs: (G,))` computes `out[r] =
    mat_a[r] @ mat_b[group(r)]` where rows are sorted by group and `offs` holds the
    cumulative end index per group.

    Per-group `Slice + MatMul + Concat`. `G` (number of experts) is static for any
    concrete model, so unroll at translation time: emit one `Slice + MatMul` triple
    per group and a final `Concat`. Avoids the `(M, K, N)` materialisation a naive
    `weight[group_idx]` gather would emit â€” peak memory is `O(MÂ·N + max(n_g)Â·K + KÂ·N)`.
    r   zW_aten_grouped_mm: number of experts (mat_b.shape[0]) must be static at translation timer¶  r·  rµ  r   rÔ  )r‡   r6   rl   r­  rº  rÁ  r¼  rî   ÚSliceÚSqueezerï   ÚMatMulÚConcat)rß  rà  rá  Úbiasr¿   ÚGÚoffs_i64Úaxes_0Úzero_1drX   Úprev_endÚgÚg_loÚg_hiÚendÚa_gÚw_gs                    rJ   Ú_aten_grouped_mmró  §  s=  € ð 	Œ�AŒ€AÝ�a�ÑÔð tÝÐrÑsÔsÐsåŒw�t Ð"Ñ"Ô"€HÝŒ[ Q CÐ(Ñ(Ô(€FÝŒk a SÐ)Ñ)Ô)€Gà€GØ€HÝ�1‰XŒXð ð ˆÝŒ{ q cÐ*Ñ*Ô*ˆÝŒ{ q¨1¡u gÐ.Ñ.Ô.ˆÝŒh�x  t¨VÑ4Ô4ˆÝŒh�u˜h¨¨VÑ4Ô4ˆÝŒj�œ %¨¨t°VÑ<Ô<¸fÑEÔEˆØ�Š•r”y  cÑ*Ô*Ñ+Ô+Ð+ØˆˆåŒ9�gÐ& AÐ&Ð&Ð&rR   c           	     ór  — |�€#t          j        | t          j        dg¬¦  «        ¦  «        }t          j        |t          j        dg¬¦  «        ¦  «        }t	          |t
          ¦  «        rt          j        d|g¬¦  «        }nht          j        t          j        |d¬¦  «        t          j        dg¬¦  «        ¦  «        }t          j        t          j        dg¬¦  «        |d¬¦  «        }t          j        t          j        ||¦  «        t          j        dg¬¦  «        ¦  «        S t          | j
        ¦  «        }||z   |z  }	t          j        | t          j        |	dz   g¬¦  «        ¦  «        }t	          |t
          ¦  «        r'dg|dz   z  }
||
|	dz   <   t          j        |
¬¦  «        }nŒt          j        t          j        |d¬¦  «        t          j        dg¬¦  «        ¦  «        }t          j        t          j        dg|	dz   z  ¬¦  «        |t          j        dg||	z
  dz
  z  ¬¦  «        d¬¦  «        }t          j        ||¦  «        }t          j        t          j        | d|	¬	¦  «        t          j        dg¬¦  «        t          j        | |	dz   ¬
¦  «        d¬¦  «        }t          j        ||¦  «        S )a‰  ONNX implementation of `aten.repeat_interleave.self_int`.

    Torchlib's translation raises on `dim is None` and broadcasts incorrectly for the
    1-D + symbolic-repeats case (its tile shape is `[r, 1]` instead of `[1, r]`). We
    always rewrite: flatten when `dim is None`, then `Unsqueeze + Tile + Reshape` along
    the chosen axis. Handles both Python-int and 0-D-tensor `repeats`.
    Nr”   rµ  r   r¶  r·  r   rÓ  )rö   rð  )rö   )rº  rÀ  r¼  r»  r6   rl   rÁ  ræ  ÚTiler(  r‡   r¾  )rD   Úrepeatsr   Úoutput_sizerº   ÚunsqÚ
tile_shapeÚrÚ	self_rankÚpos_dimÚtilesÚtiledÚfinal_shapes                rJ   Ú _aten_repeat_interleave_self_intr   É  s{  € ð �{ÝŒz˜$¥¤¸°tÐ <Ñ <Ô <Ñ=Ô=ˆÝŒ|˜D¥"¤+¸!¸Ð"=Ñ"=Ô"=Ñ>Ô>ˆÝ�g�sÑ#Ô#ð 	KÝœ°°G°Ð=Ñ=Ô=ˆJˆJå”
�2œ7 7¨qÐ1Ñ1Ô1µ2´;È2È$Ð3OÑ3OÔ3OÑPÔPˆAÝœ¥2¤;¸1¸#Ð#>Ñ#>Ô#>ÀÈÐJÑJÔJˆJÝŒz�"œ' $¨
Ñ3Ô3µR´[ÈRÈDÐ5QÑ5QÔ5QÑRÔRÐRå�D”J‘”€IØ�Y‰ )Ñ+€GÝŒ<˜�bœk°gÀ±k°]ÐCÑCÔCÑDÔD€DÝ�'�3ÑÔð 
Ø��y 1‘}Ñ%ˆØ$ˆˆg˜‰kÑÝ”[¨EÐ2Ñ2Ô2ˆ
ˆ
åŒJ•r”w˜w¨1Ð-Ñ-Ô-­r¬{ÀrÀdÐ/KÑ/KÔ/KÑLÔLˆÝ”YÝŒK A 3¨'°A©+Ñ#6Ð7Ñ7Ô7ØÝŒK A 3¨)°gÑ*=ÀÑ*AÑ#BÐCÑCÔCØð	
ñ 
ô 
ˆ
õ ŒG�D˜*Ñ%Ô%€EÝ”)Ý
Œ�˜Q GÐ,Ñ,Ô,Ý
Œ ˜tÐ$Ñ$Ô$Ý
Œ�˜W q™[Ð)Ñ)Ô)Øð	ñ ô €Kõ Œ:�e˜[Ñ)Ô)Ð)rR   c           
     óü  — t          j        t          j        t          j        t          j        | ¦  «        t          j        |¦  «        ¦  «        ¦  «        t          j        t          j        | |¦  «        t          j        j	        j
        ¬¦  «        ¦  «        }t          | d¦  «        r| j        j
        n|j        j
        }t          j        t          j        | |¦  «        t          j        ||¬¦  «        ¦  «        S )u2  Correct floor division (toward -inf) for signed integer SymInts.

    Torchlib's `operator_floordiv` translation only handles positive operands (plain `Div`,
    which truncates). For signed ints â€” including SymInt shape arithmetic â€” apply the
    offset correction `floor(a/b) = trunc(a/b) - (sign(a) != sign(b) AND a mod b != 0)`,
    matching `aten_floor_divide`. Without this, the Python ceil-div idiom `-(-x // y)`
    produces `1 + trunc((y - 1 - x) / y)` instead of `ceil(x / y)`, which silently breaks
    any shape arithmetic that crosses zero.
    r·  rh   )rº  ÚAndÚNotÚEqualÚSignrÁ  ÚModrÈ   r¹  r   rÅ   Úhasattrrh   rÄ  ÚDiv)rD   r§  r®  rh   s       rJ   Ú_operator_floordivr	  ô  s·   € õ ŒVÝ
Œ�rŒx�œ ™œ¥r¤w¨u¡~¤~Ñ6Ô6Ñ7Ô7Ý
Œ•”�t˜UÑ#Ô#­Ô(8Ô(=Ô(CÐDÑDÔDñô €Fõ !(¨¨gÑ 6Ô 6ÐMˆDŒJÔÐ¸E¼KÔ<M€EÝŒ6•"”&˜˜uÑ%Ô%¥r¤w¨v¸%Ð'@Ñ'@Ô'@ÑAÔAÐArR   c                ó¶  — | j         t          j        j        k    r•t	          |t
          t          t          f¦  «        rt          |¦  «        n%t          |j         	                    ¦   «         ¦  «        }|rt          j        | |¦  «        S t          j        | t          j        |¦  «        ¦  «        S t          j        || ¦  «        }t          j        ||| ¦  «        S )u“  ONNX implementation of `aten.masked_fill.{Scalar,Tensor}`.

    Upstream torchlib lowers this to `Where(mask, value, self)`. ORT's CPU EP has no
    `Where(16)` kernel for BOOL inputs, so when `self` is BOOL we rewrite the op using
    boolean primitives: `masked_fill(self, mask, True)` â†’ `self | mask`,
    `masked_fill(self, mask, False)` â†’ `self & ~mask`. Non-bool `self` keeps the default.
    )rh   rÈ   r¹  r   r6   rn   rl   rm   Úconst_valueÚnumpyrº  ÚOrr  r  ÚCastLiker¿  )rD   r  rÅ   Ú	fill_trueÚ
value_casts        rJ   Ú_aten_masked_fillr    s­   € ð „z•WÔ%Ô*Ò*Ð*Ý#-¨eµd½CÅÐ5GÑ#HÔ#HÐm•D˜‘K”K�KÍdÐSXÔSd×SjÒSjÑSlÔSlÑNmÔNmˆ	Øð 	%Ý”5˜˜tÑ$Ô$Ð$ÝŒv�d�BœF 4™LœLÑ)Ô)Ð)Ý”˜U DÑ)Ô)€JÝŒ8�D˜* dÑ+Ô+Ð+rR   zdict[Any, Any]rB   Ú
graph_likeúonnx_ir.GraphÚNonec                ó¾   — t          |                      ¦   «         ¦  «        D ]:}|j        dk    r-t          j        dt          j        j        d¦  «        |j        d<   Œ;dS )zASet sorted=1 on TopK nodes (ORT CUDA EP rejects TopK without it).ÚTopKÚsortedr   N)rD  Ú	all_nodesÚop_typerÈ   ÚAttrÚAttributeTypeÚINTÚ
attributes)r  Úir_nodes     rJ   Ú_fix_ir_topk_sortedr  3  sc   € å˜
×,Ò,Ñ.Ô.Ñ/Ô/ð `ð `ˆØŒ?˜fÒ$Ð$Ý+2¬<¸Å'ÔBWÔB[Ð]^Ñ+_Ô+_ˆGÔ˜xÑ(øð`ð `rR   rH   r   c                ó�   — | j         j        g| j         j                             ¦   «         ¢}t          D ]}|D ]} ||¦  «         ŒŒdS )zNApply each `(graph_like) -> None` IR fix to the main graph and every function.N)r$   r^  Ú	functionsrÚ   Ú	_IR_FIXES)rH   ÚgraphsÚfixr^  s       rJ   rC   rC   ?  sc   € àÔ Ô&ÐO¨Ô);Ô)E×)LÒ)LÑ)NÔ)NÐO€FÝð ð ˆØð 	ð 	ˆEØˆC�‰JŒJˆJˆJð	ðð rR   )rE   r^   rF   r^   r)   r_   )rÌ   rÍ   )rP  rQ  rR  rS  r)   rn   )r)   r“  )rÚ   r   rD   r   r)   rn   )F)
rD   r   rÛ   r²  rÚ   r   r³  rn   r)   r   r„   )rD   r   rÐ  rl   r)   r   ru   )rß  r   rà  r   rá  r   r)   r   )r  r  r)   r  )rH   r   r)   r  )„rN   Ú
__future__r   r@   r\   ÚoperatorÚcollections.abcr   r   Ú
contextlibr   Útypingr   r   r  rÉ   Úutilsr
   Úutils.import_utilsr   r   Úconfigsr   Úexporter_dynamor   r   r   r   r   r   r   r!   Útorch.exportr   Ú
torch.onnxr   Ú r   rÈ   Ú+onnxscript.function_libs.torch_lib.ops.corer   Úonnxscript.onnx_opsetr   rº  Úmodeling_utilsr   r   r   r   Ú
get_loggerÚ__file__Úloggerr    r:   r=   rw   r€   r‘   r�   r©   rÁ   rË   rá   ræ   ré   rù   r   r  r  r  r$  r)  r2  r8  rA  rJ  rO  r“  ÚleÚltÚgeÚgtÚeqÚner\  rc  rj  rs  rx  ra   rz  rž  re  rf  Ú_assert_asyncrh  ÚmsgÚ_assert_scalarÚ_assert_tensor_metadataÚsym_constrain_range_for_sizer{  r‡  r‹  r’  Úcacher™  r£  r¨  r«  r±  rÏ  rÞ  ró  r   r	  r  rB   Ú__annotations__Úbincountrw  Ú_grouped_mmÚtransformersÚgrouped_mm_fallbackÚrepeat_interleaveÚself_intÚmasked_fillr–  rj   Úfloordivr  r"  rC   r+   rR   rJ   ú<module>rL     sP
  ðð ð ð ð. #Ð "Ð "Ð "Ð "Ð "à €€€Ø Ð Ð Ð Ø €€€Ø 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4Ð 4Ø %Ð %Ð %Ð %Ð %Ð %Ø %Ð %Ð %Ð %Ð %Ð %Ð %Ð %à Ð Ð Ð à Ð Ð Ð Ð Ð Ø LÐ LÐ LÐ LÐ LÐ LÐ LÐ LØ Ð Ð Ð Ð Ð Ø +Ð +Ð +Ð +Ð +Ð +ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ÐÑÔð !Ø€L€L€LØ,Ð,Ð,Ð,Ð,Ð,Ø&Ð&Ð&Ð&Ð&Ð&à Ð Ð Ð Ð Ð ð ÐÑÔð 4Ø€N€N€NØJÐJÐJÐJÐJÐJØ3Ð3Ð3Ð3Ð3Ð3àð SØ0Ð0Ð0Ð0Ð0Ð0àÐÑ Ô ð SØRÐRÐRÐRÐRÐRÐRÐRÐRÐRð 
ˆÔ	˜HÑ	%Ô	%€ð0ð 0ð 0ð 0ð 0�>ñ 0ô 0ð 0ðn ð)ð )ñ „ð)ð0'ð 'ð 'ð 'ð  €�˜Ñ&Ô&ðð ñ 'Ô&ðð( €�Ð)Ð+CÑDÔDð
ð 
ñ EÔDð
ð €�ÐIÑJÔJðð ñ KÔJðð  €�Ð2Ñ3Ô3ð	ð 	ñ 4Ô3ð	ð €�Ð(Ñ)Ô)ðð ñ *Ô)ðð €�˜Ñ&Ô&ðð ñ 'Ô&ðð: €�ÐNÑOÔOðð ñ PÔOðð&ð ð ð ð, €�˜Ð(=Ñ>Ô>ð9ð 9ñ ?Ô>ð9ð €�˜Ð(=Ñ>Ô>ð9ð 9ñ ?Ô>ð9ð €�˜Ð';Ñ<Ô<ðð ñ =Ô<ðð< €�˜Ð)?ÐATÑUÔUðð ñ VÔUðð$ €�˜Ð%7Ñ8Ô8ð
ð 
ñ 9Ô8ð
ð €�Ð)Ñ*Ô*ðð ñ +Ô*ðð" €�Ð)Ñ*Ô*ðð ñ +Ô*ðð" €�Ð,Ñ-Ô-ðð ñ .Ô-ðð* €�˜Ñ%Ô%ðð ñ &Ô%ðð €�Ð+Ñ,Ô,ð	ð 	ñ -Ô,ð	ð €�Ð*Ñ+Ô+ðð ñ ,Ô+ðð  €�Ð5Ñ6Ô6ð
ð 
ñ 7Ô6ð
ð €�˜Ñ%Ô%ðð ñ &Ô%ððN €�ÐbÑcÔcðð ñ dÔcððB �)˜Xœ[¨(¬+°x´{ÀHÄKÐQYÔQ\Ð^fÔ^iÐjÑkÔk€ð Ð�fÑÔðð ð ñ Ôðð8 Ð�fÑÔðð ð ñ Ôðð Ð�fÑÔðð ð ñ Ôðð Ð�fÑÔðð ð ñ Ôðð �‘”€ØÐÑÔð 	Ø×ÒàŒIŒNÔ(Ô0ØŒIŒNÔ(Ô,ØŒIŒNÔ)Ô1ØŒIŒNÔ2Ô:ØŒIŒNÔ7Ô?ð	
ñô ð ð Ð�fÑÔðð ð ñ Ôðð Ð�fÑÔðð ð ñ Ôðð& Ð�fÑÔðð ð ñ Ôðð Ð�fÑÔðð ð ñ Ôðð „ðð ð ñ „ðð2 Ð�fÑÔð&ð &ð &ñ Ôð&ðR Ð�fÑÔðð ð ñ ÔððB Ð�fÑÔðð ð ñ Ôðð2ð ð ð ð2 ð	&.ð &.ð &.ð &.ð &.ðRJð Jð Jð Jð Jð'ð 'ð 'ð 'ð 'ðD(*ð (*ð (*ð (*ðVBð Bð Bð$,ð ,ð ,ð" +-Ð Ð ,Ð ,Ð ,Ñ ,ØÐÑÔð Ø×"Ò"àŒIŒNÔ#Ô+¨^ØŒIŒNÔ$Ô,¨oØŒIŒNÔ&Ô.Ð0@ØŒIÔ"Ô6Ô>Ð@PØŒIŒNÔ,Ô5Ð7WØŒIŒNÔ&Ô-Ð/@ØŒIŒNÔ&Ô-Ð/@ØÔÐ1ð		
ñô ð ð4`ð `ð `ð `ð ð€	ð
ð ð ð ð ð rR   