
    i                       d dl mZ d dl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c mZ d dlmc mZ d dlmc mZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZm Z  d dl!m"Z"m#Z# d d	l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. d d
l/m0Z0m1Z1 erd dl2m3Z3 	 	 	 	 	 	 	 	 ddZ4	 	 	 	 ddZ5ddZ6ddZ7ddZ8ddZ9ddZ: ed       G d d             Z; ed       G d de;             Z<y)    )annotationsN)	dataclass)LiteralTYPE_CHECKING)assert_never)	translate)	BaseCTypeBindingConstRefCTypeCppSignatureCppSignatureGroupDispatcherSignatureExprkernel_signatureMutRefCType
NamedCTypeNativeSignaturetensorT)method_with_native_functionnative_function_manager)
ArgumentBackendIndexDeviceCheckTypeDispatchKey"gets_generated_out_inplace_wrapperis_cuda_dispatch_keyNativeFunctionNativeFunctionsGroup
SchemaKindTensorOptionsArguments)mapMaybeTarget)SelectiveBuilderc                   |rdg}ndg}| j                   t        j                  t        j                  fv r|j	                  d       n| j                   t        j
                  k(  r&|r|j	                  d       n|j	                  d       n| j                   t        j                  k(  r|j	                  d       ny| j                   t        j                  k(  r|j	                  d       nJ| j                   t        j                  k(  r|j	                  d       n|r|g d	z  }n|j	                  d
       |j	                  d       |S )Nz'#include <ATen/ops/as_strided_native.h>z!#include <ATen/NativeFunctions.h>z#include <ATen/EmptyTensor.h>z!#include <ATen/hip/EmptyTensor.h>z"#include <ATen/cuda/EmptyTensor.h>z!#include <ATen/mps/EmptyTensor.h>z!#include <ATen/xpu/EmptyTensor.h>z)#include <ATen/native/mtia/EmptyTensor.h>)z#include <ATen/ops/empty.h>z##include <ATen/ops/empty_strided.h>z+#include <ATen/ops/_copy_from_and_resize.h>z #include <ATen/ops/_copy_from.h>z#include <ATen/Functions.h>z#include <c10/macros/Macros.h>)	dispatch_keyr   CPUMetaappendCUDAMPSXPUMTIA)backend_indexper_operator_headersrocmheaderss       ]/var/www/html/engine/venv/lib/python3.12/site-packages/torchgen/dest/register_dispatch_key.pygen_registration_headersr2   /   s   
 <=67!!koo{7G7G%HH67		#	#{'7'7	7NN>?NN?@		#	#{	6:;		#	#{	6:;		#	#{'7'7	7BC	 
 	
 	45NN34N    c                   d }d }| j                   t        j                  t        j                  t        j                  t        j
                  t        j                  t        j                  fv r1t        | j                         j                         }d| }d| }||fS | j                   t        j                  t        j                  t        j                  t        j                  fv rd}d}||fS )Nzat::detail::empty_zat::detail::empty_strided_z	at::emptyzat::empty_strided)r%   r   r'   r&   r)   r*   r+   r,   strlower&CompositeExplicitAutogradNonFunctionalQuantizedCPUQuantizedCUDA)r-   
empty_implempty_strided_impldispatchs       r1   gen_empty_impl_namesr=   U   s     J!!&  }11288:)(4
9(D ))) 
	#	#::  !!	( 
 !
0)))r3   c           	         | j                   t        j                  k(  rd}nd}t        |       \  }}|g S d| d| d| d| d	gS )Nzoptions.device(at::kMeta)optionsz
Tensor create_out(IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  if (strides.empty()) {
      return z(sizes, z);
  } else {
      return z(sizes, strides, z	);
  }
}
)r%   r   r'   r=   )r-   empty_optionsr:   r;   s       r1   gen_create_out_helperrA   r   st    !![%5%553!%9-%H"J"	 \- 1 !!2=/ B	
 
r3   c                4    t        |       \  }}|g S d| dgS )Nz
std::optional<Tensor> maybe_create_proxy(const Tensor &out, IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  if (out.strides() != strides) {
    return z8(sizes, strides, options);
  }
  return std::nullopt;
}
)r=   )r-   _r;   s      r1   gen_maybe_create_proxy_helperrD      sE    0?A % 	   	
r3   c                F    | j                   t        j                  k(  rg S dgS )Na  
void resize_out(const Tensor &out, IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  TORCH_CHECK(options.dtype() == out.dtype(),
      "Expected out tensor to have dtype ", options.dtype(), ", but got ", out.dtype(), " instead");
  TORCH_CHECK(options.device() == out.device(),
      "Expected out tensor to have device ", options.device(), ", but got ", out.device(), " instead");
  const bool resized = at::native::resize_output(out, sizes);
  // Only restride if a resize occurred; otherwise we ignore the (advisory)
  // strides from the meta function and directly use the output tensor's
  // preexisting strides
  if (resized) {
    if (!strides.empty()) {
      TORCH_INTERNAL_ASSERT(!options.memory_format_opt().has_value());
      // TODO: avoid the redispatch here
      out.as_strided_(sizes, strides);
    } else if (options.memory_format_opt().has_value()) {
      out.unsafeGetTensorImpl()->empty_tensor_restride(*options.memory_format_opt());
    }
  }
}
)r%   r   r7   r-   s    r1   gen_resize_out_helperrG      s,    !![%W%WW 		 r3   c                    dgS )Na  
void check_inplace(const Tensor &self, IntArrayRef sizes, const TensorOptions &options) {
  // These checks are needed on those operators that:
  //   1) don't use 'TensorIterator' (e.g. 'addmm' and 'baddbmm')
  //   2) have particular typing rules (e.g. 'cumsum' and 'cumprod')
  // For other operators (e.g. 'add'), 'TensorIterator' already checks
  // these things separately.
  TORCH_CHECK(options.dtype() == self.dtype(),
      "Bad in-place call: ",
      "input tensor dtype ", self.dtype(), " and output tensor dtype ", options.dtype(), " should match");
  TORCH_CHECK(options.device() == self.device(),
      "Bad in-place call: ",
      "input tensor device ", self.device(), " and output tensor device ", options.device(), " should match");
  TORCH_CHECK(sizes == self.sizes(),
      "Bad in-place call: ",
      "input tensor size ", self.sizes(), " and output tensor size ", sizes, " should match");
}
 rF   s    r1   gen_check_inplace_helperrJ      s    	 r3   c                d    dgt        |       t        |       t        |       t        |       dS )Nz?C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED("-Wunused-function")zC10_DIAGNOSTIC_POP())rA   rG   rJ   rD   rF   s    r1   gen_registration_helpersrL      sS    I	}	- 
}	- 
"-	0	
 
'}	5 	 r3   T)frozenc                      e Zd ZU ded<   ded<   ded<   ded<   ded	<   d
ed<   ded<   e	 	 	 	 	 	 	 	 dd       Zedd       Z	 	 	 	 ddZ	 	 	 	 	 	 ddZ	ddZ
	 d	 	 	 	 	 ddZy)RegisterDispatchKeyr   r-   zvLiteral[Target.ANONYMOUS_DEFINITION, Target.NAMESPACED_DEFINITION, Target.NAMESPACED_DECLARATION, Target.REGISTRATION]targetr#   selectorboolr/   symint
str | Noneclass_method_nameskip_dispatcher_op_registrationc           	         | t         j                  k(  ryd}|dz  }|D ]@  }|j                  j                         s|d|j                   d| d|j                   dz  }B |S )N  // No device check
z4std::optional<Device> common_device = std::nullopt;
z9(void)common_device; // Suppress unused variable warning
z<
  c10::impl::check_and_update_common_device(common_device, z, "z", "z");)r   NoChecktypeis_tensor_likename)rZ   argsmethod_namedevice_checkargs        r1   gen_device_checkz$RegisterDispatchKey.gen_device_check  s     ?***+NTT 	jCxx&&( %<<?HH:SUYZ]ZbZbYccf!j j	j
 r3   c                    t        |t              rF|j                  r j                        S t	        t         fdj                                     S t        |t              r j                  |      }|g S |gS t        |       y )Nc                (    j                  |       S Ngen_unstructuredfgselfs    r1   <lambda>z.RegisterDispatchKey.__call__.<locals>.<lambda>*  s    t'<'<Q'B r3   )

isinstancer   
structuredgen_structuredlistr!   	functionsr   rf   r   )rj   rh   rri   s   `  @r1   __call__zRegisterDispatchKey.__call__   s    a-.&'A ||**1--BAKKMR  >*%%a(A2++Or3   c                    t        j                  |j                  d| j                  j                   d|j                  j
                  j                   d| j                        S )Nwrapper_rC   prefixrS   )r   from_schemafuncr-   r%   r\   overload_namerS   )rj   rh   s     r1   wrapper_kernel_sigz&RegisterDispatchKey.wrapper_kernel_sig2  sT     #..FFd00==>a@Y@Y?ZZ[\;;
 	
r3   c                   |y |j                   j                         }|t        j                  u rdn |t        j                  u rdnt        d      | j                  |      }|j                         }| dt        j                  |      }t        |      dkD  rXdj                  fdt        |      D              }|j                         j                          dd	j                  |       d
}nt        |      dk(  r|d   }	 d d	|	 d}|	}nt        |j                   j                  j                        dk(  sJ d}|j                   j                  j                  d   }
|
j                   j#                         rd d d d|
j                   d	}n d d	|
j                   d}| j                  |j$                        }|j                         }|j'                  |       d d|j                          dd	j                  d t)        |j                         |j                               D               d| d| dS )Nzat::_copy_fromzat::_copy_from_and_resizez1gen_out_inplace_wrapper called on a functional op_tmp   z
  c           	   3  @   K   | ]  \  }} d | d d| d  yw)z
(std::get<z>(z), );NrI   ).0iret_namecopy_opfunc_ress      r1   	<genexpr>z>RegisterDispatchKey.gen_out_inplace_wrapper.<locals>.<genexpr>O  s6      "Ax ):aS8*CzD"s   (, )r   r    z    for (int64_t i = 0; i < z.size(); ++i) {
        z[i], z[i]);
    }r\   z
 {
  auto z = c              3  4   K   | ]  }|j                     y wrd   exprr   es     r1   r   z>RegisterDispatchKey.gen_out_inplace_wrapper.<locals>.<genexpr>i  s     6~!qvv6~   z);
  

  return ;
}
)rx   kindr   inplaceoutAssertionErrorrz   r\   cppreturn_nameslenjoin	enumeratereturns_typecpp_type	argumentsrZ   is_list_like
functionaldefnr   )rj   rh   ri   ksigr\   r   updatesreturnsr   out_argfunctional_sigwrapper_namer   r   s                @@r1   gen_out_inplace_wrapperz+RegisterDispatchKey.gen_out_inplace_wrapper<  sU    9FFKKM
"""&G*.. 1G !TUU%%a(xxzV4=''*|q kk "#,\#:" G ))+4467q<9P8QQRSG!##AH 	8*Bxj;GGqvv''++,111Gff&&**1-G||((*%J '			8*E',, 0

 %IQxj7<<.C00>xxz |  z^((*+1TYY6~yQTQ^Q^Q`bpbzbzb|G}6~-~, @
) 

 	 	r3   c           
          j                   j                        } j                   j                  t        j                  k(  r, j                   j                  j                        rJ d        j                   j                  t        j                  k(  r, j                   j                  j                        r<J d       ||j                  s't        t         fdj                                     S t         j                    j                   j                   j                   j                    j"                   j$                        }t        t        |j&                  j                                     S )NzqDo not explicitly specify Meta dispatch key on structured functions, they will be automatically generated for youzDo not explicitly specify CompositeExplicitAutograd dispatch key on structured functions, they will be automatically generated for youc                (    j                  |       S rd   re   rg   s    r1   rk   z4RegisterDispatchKey.gen_structured.<locals>.<lambda>  s    4+@+@A+F r3   )r-   
get_kernelr%   r   r'   
has_kernelr   r7   rm   ro   r!   rp   StructuredRegisterDispatchKeyrP   rQ   r/   rS   rU   rV   gen_one)rj   ri   metadatastructured_gens   ``  r1   rn   z"RegisterDispatchKey.gen_structuredo  s8   %%003**k.>.>>))44QUU; J;
 ++AAB ))44QUU; J; X%8%8!FVWW6KKMMIIKK""00	
 H^33Q[[]CDDr3   Nc                   t        |      5  d}d}| j                  j                  |      s| j                  j                  t        j
                  k(  r[|j                  j                         t        j                  u r1|j                  s%t        |j                  j                        dk(  rd}n<| j                  j                  s|t        ||| j                        rd}n
	 d d d        y |j                  r
	 d d d        y | j                   t"        j$                  u r%| j&                  j)                  |      s
	 d d d        y | j+                  |      j-                         }j/                         j1                         }j3                         }dj5                  d |D              }t7        j8                  |dd      }	| j                   t"        j:                  u rEd}
|	j=                  | j>                        D ]  }|
d	|jA                          d
z  }
 |
cd d d        S | j                   t"        jB                  u r?d'fd}d}
|	j=                  | j>                        D ]  }|
 ||      z  }
 |
cd d d        S | j                   t"        jD                  u rL|rq|j                  j2                  jF                  J |j                  j2                  jF                  jH                  j,                  }d| d| d| d| d| dcd d d        S |r| jK                  ||      cd d d        S | j                  jM                  |      }|
	 d d d        y | jN                  |jP                   d|jR                   }n(|jP                   d| jN                   d|jR                   }tU        || j                        }dj5                  d tW        j3                         |j3                         d      D              }d}| j                  jX                  r|t[        j\                  |j                  j2                  j^                  |j                  j2                  j`                        }tb        je                  |jf                  ti        |      |      }d}|jX                  r+| j                  jX                  rtk        d |j                  j2                  jl                  D              }|r'd}to        | j                  j                        rd| }n|j                  j2                  jF                  +|j                  j2                  jF                  jH                  gng }t[        j\                  ||j                  j2                  j^                  |j                  j2                  j`                        }tq        d |D        d       }|d| d}d| d| d| d| d| d | d| d!cd d d        S | j                   t"        j$                  u rN|j                  s| jr                  r
	 d d d        y d"| d#}d$|j                  j,                   d%| d&cd d d        S tu        | j                          	 d d d        y # 1 sw Y   y xY w)(NFr}   Tr   c              3  <   K   | ]  }|j                           y wrd   )r   r   as     r1   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  s      8a 8   methodfallback_bindingr   rS   
TORCH_API ;
c                    d| j                          dj                          ddj                  d t        | j	                         j	                               D               dS )N

 {
return r   r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   zNRegisterDispatchKey.gen_unstructured.<locals>.generate_defn.<locals>.<genexpr>       _!qvv_r   );
}
r   r\   r   r   r   cpp_sigr   s    r1   generate_defnz;RegisterDispatchKey.gen_unstructured.<locals>.generate_defn  s`       
|1TYY_y9J9J9Lcmmo/^__` a r3   r    r   z") {
  TORCH_CHECK_NOT_IMPLEMENTED(z[.is_meta(),
    "Cannot inplace into non-meta tensor with meta tensor argument");
  return r   z::c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  s      + FF+r   r   rX   z// DeviceGuard omittedc              3  <   K   | ]  }t        |t                y wrd   )rl   r    r   s     r1   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  s       - #1&<=-r   z=
  const DeviceGuard device_guard(device_or_default(device));z7globalContext().lazyInitDevice(c10::DeviceType::CUDA);
c              3  j   K   | ]+  }|j                   j                         r|j                    - y wrd   )rZ   r[   r\   r   s     r1   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  s0      $%#$66#8#8#: $%66(s   13z1const OptionalDeviceGuard device_guard(device_of());znamespace {

z) {
  z

  r   z);
}

} // anonymous namespace
z	TORCH_FN(r   m.impl("z",
z);
r   r   returnr5   );r   r-   r   r%   r   r'   rx   r   r   r   has_composite_kernelr   r   use_out_as_primaryr   manual_kernel_registrationrP   r"   REGISTRATIONrQ   is_native_function_selectedrz   r\   r   r   r   r   r   from_native_functionNAMESPACED_DECLARATION
signaturesrS   declNAMESPACED_DEFINITIONANONYMOUS_DEFINITIONself_argargumentr   r   rU   cpp_namespacekernelr   r   device_guard	itertoolschainr   flat_positionalrO   ra   r_   ro   anynon_outr   nextrV   r   )rj   rh   ri   inplace_metagets_out_inplace_wrapperr\   r   r]   args_strcpp_sig_groupresultr   r   self_arg_namer   	impl_name
kernel_sigargs_exprs_strr_   device_check_argsr   has_tensor_optionsr   candidate_args	device_ofpayloadr   s                             @r1   rf   z$RegisterDispatchKey.gen_unstructured  sF    %Q' l	* L',$%%003&&33{7G7GG););; .. '1,#'L**==:1aASAST 04,/l	* l	*0 ++3l	* l	*8 v222AA!D?l	* l	*B ))!,C88:D++-668L==?Dyy 84 88H .BB%%M
 {{f;;;,77t{{7K ?G
7<<>*:#>>F?el	* l	*f  < << ,77t{{7K 5GmG44F5l	* l	*B  ; ;;66++44@@@$%FF$4$4$=$=$F$F$K$KM avQxj !,o .

 	Ol	* l	*` ,771=cl	* l	*f  --88;#kl	* l	*l ))1#+#9#9":"X__<M NI#+#9#9":"T=S=S<TTVW_WfWfVg hI-a1C1CD
!% +&)=)=)?+ "  8%%22(1((,,aff.>.>.N.N)% $7#G#G->(?$L  8>>d&8&8&E&E), -!"!1!1!9!9- *& *(@ 00B0B0O0OP-efres+tL  !vv//88D VV--66??@!# !
 *3$FF,,00FF,,<<* %))7
 !%	 %0-^_h^iil+mL avQxj !. . 

An% &ql	* l	*J  3 33//43W3WOl	* l	*R !*$q1G%affkk]$witDUl	* l	*X T[[)Yl	* l	* l	*sR   CY/+Y/8Y/CY/"AY/=BY/Y/*Y/JY/&5Y/$"Y/Y//Y8)rZ   r   r]   zlist[Argument]r^   r5   r   r5   )rh   z%NativeFunctionsGroup | NativeFunctionr   	list[str])rh   r   r   z%NativeSignature | DispatcherSignature)rh   r   ri   zNativeFunctionsGroup | Noner   rT   )ri   r   r   r   rd   )__name__
__module____qualname____annotations__staticmethodra   r   rr   rz   r   rn   rf   rI   r3   r1   rO   rO      s       J
 L "! &*)%3BE	  ! !"

	.
11$?1	1fE< CGo*o*$?o*	o*r3   rO   c                  r    e Zd ZU ded<   	 	 	 	 	 	 	 	 d	dZd
dZddZ	 	 	 	 	 	 	 	 	 	 	 	 ddZedd       Z	y)r   r   ri   c                ^     |r| dndd
 fd}d |dd       d |dd	       dS )NzE::set_output_raw_strided(output_idx, sizes, strides, options, names);r   c           	         d|  dt        j                  j                  |      d       dt        j                  d       dS )Nz
void set_output_z|(
    int64_t output_idx, IntArrayRef sizes, IntArrayRef strides,
    TensorOptions options, DimnameList names
) override {
    z
    if (!names.empty()) {
      namedinference::propagate_names(outputs_[output_idx], names);
    }
    // super must happen after, so that downstream can use maybe_get_output
    // to retrieve the output

}
)textwrapindentgen_class_set_output_body)r\   maybe_create_proxyr   rj   set_output_supers     r1   gen_set_output_functionz]StructuredRegisterDispatchKey.gen_class_set_output_functions.<locals>.gen_set_output_functionQ  s\      
//3EFO P Q 
!6* + , r3   r   stridedT)r  raw_stridedF)r\   r5   r  rR   r   r5   rI   )rj   r   parent_classgenerate_superr  r  s   ``   @r1   gen_class_set_output_functionsz<StructuredRegisterDispatchKey.gen_class_set_output_functionsI  sU     "./tu!	 t< = >5A B C 	r3   c                   | j                   j                  t        j                  t        j                  t        j
                  t        j                  fv rd}|dz   }ndx}}|rd}nd}|t        j                  u r| j                   j                  t        j                  t        j                  t        j                  t        j                  t        j
                  t        j                  t        j                  fv sJ | dS |t        j                  u r| d| S |t        j                  u r| d| S |t        j                  u s|t        j                  u rt!        | d      t#        |       y )	Na  
auto current_device = guard_.current_device();
if (C10_UNLIKELY(current_device.has_value())) {
  TORCH_INTERNAL_ASSERT(*current_device == options.device(),
    "structured kernels don't support multi-device outputs");
} else {
  guard_.reset_device(options.device());
}
r   r   z
auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options);
if (C10_UNLIKELY(maybe_proxy.has_value())) {
    proxy_outputs_[output_idx] = std::move(maybe_proxy).value();
}
z<
outputs_[output_idx] = create_out(sizes, strides, options);zS
const auto& out = outputs_[output_idx].get();
check_inplace(out, sizes, options);
zY
const auto& out = outputs_[output_idx].get();
resize_out(out, sizes, strides, options);
1 structured operators are currently not supported)r-   r%   r   r)   r*   r+   r7   r   r   r'   r&   r,   r   r   mutablescratchr   r   )rj   r   r  maybe_set_guardmaybe_set_guard_linecreate_proxys         r1   r  z7StructuredRegisterDispatchKey.gen_class_set_output_bodyf  s~   **OOOO>>	/
 
O $3T#9 577 ?L L
%%%%%22      BB7    -- .< ? ?*$$$,- .   *.. ,- .   *$$$Z-?-?(? #FG  Or3   c                   |t         j                  u ry|t         j                  u r| dS |t         j                  u rMdj	                  d t        |      D              }dj	                  d t        |      D              }| d| d| dS |t         j                  u s|t         j                  u rt        | d	      t        |       y )
Nr   z,(Tensor& self) : outputs_{std::ref(self)} {}r   c              3  &   K   | ]	  }d |   yw)zTensor& outNrI   r   r   s     r1   r   z?StructuredRegisterDispatchKey.gen_class_ctor.<locals>.<genexpr>  s      Kq;qc!2 Ks   c              3  (   K   | ]
  }d | d  yw)zstd::ref(outr   NrI   r  s     r1   r   z?StructuredRegisterDispatchKey.gen_class_ctor.<locals>.<genexpr>  s      M<s!!4 M   r   z) : outputs_{ z } {}r  )
r   r   r   r   r   ranger  r  r   r   )rj   r   
class_namer   out_argsout_refss         r1   gen_class_ctorz,StructuredRegisterDispatchKey.gen_class_ctor  s    
%%%*$$$ \!QRR*.. yy KE'N KKHyy MeGn MMH \8*OH:XNN*$$$Z-?-?(? #FG  Or3   c                  |t         j                  u rd}d}d}n|t         j                  u r(d}d}dt        |j                  j
                         d}nH|t         j                  u r(d}d}dt        |j                  j
                         d}nt        d|       | j                  j                  t        j                  k(  r| j                  rd	}	nd
}	n| j                  j                  t        j                  k(  rd}	n| j                  j                  t        j                  k(  rd}	nV| j                  j                  t        j                  k(  rd}	n,| j                  j                  t        j                   k(  rd}	nd}	d}
| j#                  ||t        |j                  j
                              }d| d| dt%        j&                  ||
       t%        j&                  | j)                  |||      |
       dd| ddd| dt        |j                  j
                         dt%        j&                  ||
       t%        j&                  |	|
       df
}dj+                  d |D              S )NTensorzoutputs_[output_idx]r   zstd::reference_wrapper<Tensor>zaproxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get()z$std::array<::std::optional<Tensor>, z> proxy_outputs_;zUnsupported SchemaKind z4c10::hip::OptionalHIPGuardMasqueradingAsCUDA guard_;z$c10::cuda::OptionalCUDAGuard guard_;z c10::OptionalDeviceGuard guard_;r   zstruct z final : public z {zA    const Tensor& maybe_get_output(int64_t output_idx) override {z      return r   z    }z    std::array<r   z> outputs_;z};r   c              3  &   K   | ]	  }|s|  y wrd   rI   )r   lines     r1   r   z:StructuredRegisterDispatchKey.gen_class.<locals>.<genexpr>  s     8$48s   )r   r   r   r   rx   r   r   RuntimeErrorr-   r%   r   r)   r/   r7   r*   r+   r,   r  r   r   r	  r   )rj   rh   r   r  r  r  output_typeoutput_valueproxy_fieldguard_fieldr   class_ctor_strliness                r1   	gen_classz'StructuredRegisterDispatchKey.gen_class  s+    
%%%"K1LK*$$$:K~L@QVV^^AT@UUfgK*.. :K~L@QVV^^AT@UUfgK!8<==**k.>.>>yyTD++AAB =K,,?<K,,?<K,,0@0@@<KK,,Q
C<OPj\!1,sC~v67tBB1lTbceklmOL>-k]"S-@,AM{F34{F34
 yy8%888r3   c                   |j                   rJ | j                  t        j                  u r| j                  j                  |      sy | j                  j                  t        j                  k(  r+|j                  j                         t        j                  u ry t        j                  |dd      }| j                  j!                  |      }t#        |j                  d| j                  j                   d|d uxr |j%                               | j                  t        j&                  u r<d}|j)                  | j*                        D ]  }|d|j-                          d	z  } |S | j                  t        j.                  u r6d<fd
}d}|j)                  | j*                        D ]  }| ||      z  } |S | j                  t        j0                  u r&|j                  j                         }g }t3        j5                               }	| j                  j                  t        j6                  u rRdt9        j:                  | j<                         d|j:                   }
dt9        j:                  | j<                         }n| j                  j                  t        j                  u rRdt9        j:                  | j<                         d|j:                   }
dt9        j:                  | j<                         }n`| j                  j!                  | j<                        }|J d|j>                   d|j:                   }
|j@                   d|j>                   }| j                  jB                  rtE        jF                  |j                  j4                  j                  |j                  j4                  jH                        }|jK                  tL        jO                  |jP                  t3        |      j;                                      |t        jR                  u r|jK                  |
 d       n|t        jT                  u r|jK                  |
 d       n_|t        j                  u rMdjW                  d |j                  j4                  j                  D              }|jK                  |
 d| d       djW                  d tY        |	t[        j\                  | j<                        d      D              }| j<                  j                  j^                  r|jK                  d| d       g | j<                  j                  j^                  j`                  jc                         | j<                  j                  j^                  jd                  }|D ]  }|	jg                  d |D                |jK                  d       n|jK                  d| d       t[        jh                  | j<                        }tk        |      D ]  \  }}tm        to        tp                    |jr                  jt                  k(  sJ |t        j                  u rd| d}nd| d}|	jK                  tw        |ty        |jr                  j:                  t{        to        tp                                         | j                  j                  t        j                  k(  rt        j                  | j<                  j                  d|j|                        }|j                         }|j;                         }djW                  d! tY        |	|j5                         d      D              }|jK                  d"| d#| d       n}| j                  j                  t        j6                  k7  rVdjW                  d$ tY        |	t[        j                  | j<                        d      D              }|jK                  d%| d       |t        j                  u s|t        jT                  u rHt        t        |j                  j                              D ]  }|jK                  d&| d'| d(| d)        |t        jR                  u rjt        |j                  j                        d*k(  rd+}ndjW                  d, t        t        |j                  j                              D              }d-| d}n|t        jT                  u rd.}n|t        j                  u rt        |j                  j                        d*k(  r.|j                  j4                  j                  d/   j:                  }n<djW                  d0 |j                  j4                  j                  D              }d1| d}|jK                  d2 d3       d4jW                  |      }| j                  |||
|| j<                  j                  j                  d u5       d6j                          d7| d8S | j                  t        j                  u r+d9|j                  j:                   d:j;                          d;S t        | j                         y )=NFr   rt   rC   ru   r   r   r   r   c                    d| j                          dj                          ddj                  d t        | j	                         j	                               D               dS )Nr   r   r   r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   zOStructuredRegisterDispatchKey.gen_one.<locals>.generate_defn.<locals>.<genexpr>,  r   r   r   r   r   s    r1   r   z<StructuredRegisterDispatchKey.gen_one.<locals>.generate_defn)  s`      
|1TYY_y9J9J9Lcmmo/^__` a r3   structured__meta_zat::meta::structured__default_backend_z::structured_z op;z
 op(self);r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>_  s     (NA(Nr   z op(r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>d  s      # #r   r   zauto precompute = op.meta(c              3     K   | ]=  }t        d |j                   t        j                  ||j                               ? yw)zprecompute.)bindsr   rZ   N)r   r\   rm   argument_type)r   r`   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>y  sF      #
  	 #.sxxj!9!+!9!9#SXX!N #s   AAz(void)precompute;zop.meta(zop.maybe_get_output(r   zop.outputs_[]r1  c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s      & FF&r   zat::r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s      ' FF'r   zop.impl(zif (op.proxy_outputs_[z].has_value()) op.outputs_[z!].get().copy_(*op.proxy_outputs_[z]);r}   zstd::move(op.outputs_[0])c              3  (   K   | ]
  }d | d  yw)zstd::move(op.outputs_[z])NrI   r  s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s!      & 126&r  zstd::make_tuple(rj   r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s     $JQVV$Jr   zstd::forward_as_tuple(zreturn ;r   )r  r  r  z

z {
r   r   z", TORCH_FN(r   r   )Hr   rP   r"   r   rQ   r   r-   r%   r   r7   rx   r   r   r   r   r   r   r   supports_symintr   r   rS   r   r   r   ro   r   r'   metar\   ri   r   r   r   r   r   r   r(   rO   ra   r_   r   r   r   r   rm   meta_argumentsprecomputedreplacevaluesaddextendout_argumentsr   r   r	   r   nctyperZ   r   r   r   manual_cpp_bindingmost_faithful_signatureimpl_argumentsr  r   r   r&  structured_inheritsr   r   ) rj   rh   r   kernr   r   r   r   sig_bodycontextr  r  r   r   out_args_str
meta_exprsprecomputed_valuesprecomputed_elemsr  r   r   r   out_sig_groupout_sigapi_name	out_exprs
impl_exprsret_exprmovedrefssig_body_strr   s                                   @r1   r   z%StructuredRegisterDispatchKey.gen_one  s   //// KK6...MM==a@ ++AAB/  *>>ee

 !!,,Q/FFd00==>a@t#>(<(<(>
 ;;&777F(334;;3G ;Jw||~&6c::;M[[F888 F(334;;3G 1-001M[[F777A H -1,AG !!..+2B2BB*499TVV+<*=VAFF8L
!6tyy7H6IJ""//EEF  +499TVV+<*==NqvvhW
!6tyy7H6IJ--88@+++*8??*;1QVVHE
"*"8"8!9xFWX!!..$-OOFF$$((!&&*:*:*J*J%! '88->(? J))):,d 34j(((:,j 9:jnn$#yy(N9I9I9M9M(NN:,d<. CD  #"Z66tvv>u# J vvzz%% "<ZL KL
&VVZZ++33::<&FFJJ**..&" *< %NN #
 $5#   34(:,b 9: "//7H'1 
7$Yw%78GNN<O<OOOO
&1!A6D)!A.D! (#NN//Yw=O1P
. ""//EEF !2 F FFFJJuq?S?S! (??A"<<> II &&w0A0A0CER& 	 $xj)B ?@##00K4D4DD!YY '&!:!:466!B5' 
 (:,b 9: JNN"a:+=+=&=s166>>23 AOO03NqcQrstruuxy J)))qvv~~&!+:H II &!&s166>>':!;& E "2%:Hj(((!jnn$qvv~~&!+ vv//33A6;;H99$JQVV5E5E5I5I$JJD!7vQ?HOOghZq1299X.L )!-#'66::#A#A#M       [[F///affkk],sxxzl#FF%r3   N)r   r   r  r5   r  rR   r   r5   )r   r   r  rR   r   r5   )r   r   r  r5   r   intr   r5   )rh   r   r   r   r  r5   r  r5   r  rR   r   r5   )rh   r   r   rT   )
r   r   r   r   r	  r  r  r&  r   r   rI   r3   r1   r   r   E  s    +.@D	:9z";9;9 ;9
 ;9 ;9 ;9 
;9z !F !Fr3   r   )r-   r   r.   rR   r/   rR   r   r   )r-   r   r   ztuple[str | None, str | None])r-   r   r   r   )=
__future__r   r   r   dataclassesr   typingr   r   typing_extensionsr   torchgen.api.cppapir   torchgen.api.metar:  torchgen.api.structuredrm   torchgen.api.translater   torchgen.api.typesr	   r
   r   r   r   r   r   r   r   r   r   r   torchgen.contextr   r   torchgen.modelr   r   r   r   r   r   r   r   r   r    torchgen.utilsr!   r"   !torchgen.selective_build.selectorr#   r2   r=   rA   rD   rG   rJ   rL   rO   r   rI   r3   r1   <module>rf     s    "   ! ) *       , , ,    R   , B### # 	#L**"*:.$<.: $M* M* M*n
 $r$7 r rr3   