U
    •Ê¹j�  ã                   @   sä  d dl Z d dlZd dlmZ d dlmZmZmZmZm	Z	 d dl
m  mZ d dlm  mZ d dlm  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.m/Z/ d d	l0m1Z1m2Z2m3Z3 e%e4e4ee5 d
œdd„Z6e%eee5 ee5 f dœdd„Z7e%ee5 dœdd„Z8e%ee5 dœdd„Z9e%ee5 dœdd„Z:e%ee5 dœdd„Z;e%ee5 dœdd„Z<edd�G dd„ dƒƒZ=edd�G dd„ de=ƒƒZ>dS ) é    N)Ú	dataclass)ÚListÚLiteralÚOptionalÚTupleÚUnion)Ú	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)ÚSelectiveBuilder)Úassert_neverÚmapMaybeÚTarget)Úbackend_indexÚper_operator_headersÚrocmÚreturnc                 C   s”   |rdg}ndg}| j tjtjfkr0| d¡ n`| j tjkrX|rL| d¡ q�| d¡ n8| j tjkrp| d¡ n |r†|ddd	d
g7 }n
| 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/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>)Údispatch_keyr   ÚCPUÚMetaÚappendÚCUDAÚMPS)r%   r&   r'   Úheaders© r0   úb/var/www/html/bwave/python/venv/lib/python3.8/site-packages/torchgen/dest/register_dispatch_key.pyÚgen_registration_headers*   s(    ü
r2   )r%   r(   c                 C   sl   d }d }| j tjtjtjtjfkrFt| j ƒ ¡ }d|› �}d|› �}n| j tjtj	tj
fkrdd}d}||fS )Nzat::detail::empty_zat::detail::empty_strided_z	at::emptyzat::empty_strided)r)   r   r+   r*   r-   r.   ÚstrÚlowerÚ&CompositeExplicitAutogradNonFunctionalZQuantizedCPUZQuantizedCUDA)r%   Ú
empty_implÚempty_strided_implÚdispatchr0   r0   r1   Úgen_empty_impl_namesJ   s&    ü
ýr9   c              	   C   sN   | j tjkrd}nd}t| ƒ\}}|d kr.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+   r9   )r%   Zempty_optionsr6   r7   r0   r0   r1   Úgen_create_out_helperd   s     ýýûýÿr;   c                 C   s&   t | ƒ\}}|d krg S d|› d�gS )Nz²
c10::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 c10::nullopt;
}
)r9   )r%   Ú_r7   r0   r0   r1   Úgen_maybe_create_proxy_helper{   s    ÿýÿýr=   c                 C   s   | 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   r5   ©r%   r0   r0   r1   Úgen_resize_out_helper�   s    ÿr?   c                 C   s   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");
}
r0   r>   r0   r0   r1   Úgen_check_inplace_helper«   s    ÿr@   c                 C   s   t | ƒt| ƒt| ƒt| ƒ•S ©N)r;   r?   r@   r=   r>   r0   r0   r1   Úgen_registration_helpersÂ   s
    ürB   T)Úfrozenc                   @   s  e Zd ZU eed< eeej eej	 eej
 eej f ed< eed< eed< eed< ee ed< eed< eeee eedœd	d
„ƒZeeeef ee dœdd„ƒZeeeef dœdd„Zeee ee dœdd„Zeee dœdd„Zdeee ee dœdd„ZdS )ÚRegisterDispatchKeyr%   ÚtargetÚselectorr'   ÚsymintÚclass_method_nameÚskip_dispatcher_op_registration)ÚtypeÚargsÚmethod_namer(   c              	   C   sR   | t jkrdS d}|d7 }|D ].}|j ¡ r|d|j› d|› d|j› d�7 }q|S )Nú  // No device check
z/c10::optional<Device> common_device = nullopt;
z9(void)common_device; // Suppress unused variable warning
z<
  c10::impl::check_and_update_common_device(common_device, z, "z", "z");)r   ZNoCheckrJ   Úis_tensor_likeÚname)rJ   rK   rL   Údevice_checkÚargr0   r0   r1   Úgen_device_check   s    

ÿÿÿz$RegisterDispatchKey.gen_device_check©Úfr(   c                    sn   t |tƒr<|‰ ˆ jrˆ ˆ ¡S tt‡ ‡fdd„ˆ  ¡ ƒƒS n.t |tƒrbˆ |¡}|d kr\g S |gS t	|ƒ d S )Nc                    s   ˆ  | ˆ ¡S rA   ©Úgen_unstructured©rT   ©ÚgÚselfr0   r1   Ú<lambda>  ó    z.RegisterDispatchKey.__call__.<locals>.<lambda>)
Ú
isinstancer   Ú
structuredÚgen_structuredÚlistr#   Ú	functionsr   rV   r"   )rZ   rT   Úrr0   rX   r1   Ú__call__  s    

ÿ

zRegisterDispatchKey.__call__c                 C   s,   t j|jd| jj› d|jjj› d�| jd�S )NÚwrapper_r<   ©ÚprefixrG   )r   Zfrom_schemaÚfuncr%   r)   rO   Zoverload_namerG   )rZ   rT   r0   r0   r1   Úwrapper_kernel_sig"  s
    ýz&RegisterDispatchKey.wrapper_kernel_sig)rT   rY   r(   c                    s²  |d krd S |j  ¡ }|tjkr&d‰ n|tjkr6d‰ ntdƒ‚|  |¡}| ¡ }|› d�‰t 	|¡}t
|ƒdkr®d ‡ ‡fdd„t|ƒD ƒ¡}| ¡  ¡ › d	d
 |¡› d�}nžt
|ƒdkrÞ|d }	ˆ › d	ˆ› d
|	› d�}|	}nnt
|j jjƒdksôt‚d}|j jjd }
|
j ¡ �r4dˆ› dˆ › d	ˆ› d|
j› d�	}nˆ › d	ˆ› d
|
j› d�}|  |j¡}| ¡ }|j|d�› dˆ› d| ¡ › d	d
 dd„ t| ¡ | ¡ ƒD ƒ¡› d|› d|› d�S )Nzat::_copy_fromzat::_copy_from_and_resizez1gen_out_inplace_wrapper called on a functional opZ_tmpé   z
  c              	   3   s.   | ]&\}}ˆ › d |› dˆ› d|› d�V  qdS )z
(std::get<z>(z), ú);Nr0   )Ú.0ÚiÚret_name©Zcopy_opZfunc_resr0   r1   Ú	<genexpr>?  s   ÿz>RegisterDispatchKey.gen_out_inplace_wrapper.<locals>.<genexpr>ú(ú, ú)r   rj   Ú z    for (int64_t i = 0; i < z.size(); ++i) {
        z[i], z[i]);
    }©rO   z
 {
  auto z = c                 s   s   | ]}|j V  qd S rA   ©Úexpr©rk   Úer0   r0   r1   ro   Y  s     z);
  ú

  return ú;
}
)rg   Úkindr   ÚinplaceÚoutÚAssertionErrorrh   rO   ÚcppÚreturn_namesÚlenÚjoinÚ	enumerateÚreturns_typeÚcpp_typeÚ	argumentsrJ   Zis_list_likeÚ
functionalÚdefnr   )rZ   rT   rY   ÚkÚsigrO   r€   ZupdatesÚreturnsrm   Úout_argZfunctional_sigZwrapper_namer0   rn   r1   Úgen_out_inplace_wrapper,  sb    





þ ÿþÿþ

ÿþþ þýüz+RegisterDispatchKey.gen_out_inplace_wrapper)rY   r(   c              	      sº   ˆj  ˆ ¡}ˆj jtjkr2ˆj  ˆ j¡r‚tdƒ‚nPˆj jtjkrXˆj  ˆ j¡r‚tdƒ‚n*|d ksf|j	s‚t
t‡ ‡fdd„ˆ  ¡ ƒƒS tˆj ˆjˆjˆjˆjˆjˆjˆ ƒ}t
t|jˆ  ¡ ƒƒS )NzqDo not explicitly specify Meta dispatch key on structured functions, they will be automatically generated for youz†Do not explicitly specify CompositeExplicitAutograd dispatch key on structured functions, they will be automatically generated for youc                    s   ˆ  | ˆ ¡S rA   rU   rW   rX   r0   r1   r[   o  r\   z4RegisterDispatchKey.gen_structured.<locals>.<lambda>)r%   Ú
get_kernelr)   r   r+   Ú
has_kernelr}   r~   r5   r^   r`   r#   ra   ÚStructuredRegisterDispatchKeyrE   rF   r'   rG   rH   rI   Úgen_one)rZ   rY   ÚmetadataZstructured_genr0   rX   r1   r_   _  s2    ÿÿÿÿø
z"RegisterDispatchKey.gen_structuredNc                    sj  t |ƒ��V d}d}| j |¡sŒ| jjtjkrZ|j ¡ tj	krZ|j
sZt|jjƒdkrZd}n2| jjs~|d k	r~t||| jƒr~d}nW 5 Q R £ d S |jr W 5 Q R £ d S | jtjkrÆ| j |¡sÆW 5 Q R £ d S |  |¡‰ ˆ  ¡ }ˆ  ¡  ¡ }ˆ  ¡ }d dd„ |D ƒ¡}tj|ddd�}	| jtjk�r\d}
|	j| jd	�D ]}|
d
|  ¡ › d�7 }
�q0|
W  5 Q R £ S | jtj!k�r´t"t#dœ‡ fdd„}d}
|	j| jd	�D ]}|
||ƒ7 }
�q�|
W  5 Q R £ S | jtj$k�rö|�r|jjj%d k	�sÜt&‚|jjj%j'j}d|› d|› d|› d|› d|› d�W  5 Q R £ S |�r8|  (||¡W  5 Q R £ S | j )|¡}|d k�r\W 5 Q R £ d S | j*d k�r||j+› d|j,› �}n|j+› d| j*› d|j,› �}t-|| jƒ}d dd„ t.ˆ  ¡ | ¡ dd�D ƒ¡}d}| jj/�rt0 1|jjj2|jjj3¡}t4 5|j6t7|ƒ|¡}d}|j/�rº| jj/�rºt8dd„ |jjj9D ƒƒ}|�rTd}t:| jjƒ�rºd|› �}nf|jjj%d k	�rr|jjj%j'gng }t0 1||jjj2|jjj3¡}t;dd„ |D ƒd ƒ}|d k	�rºd|› d�}d |› d|› d|› d!|› d"|› d#|› d|› d$�W  5 Q R £ S | jtjk�rR|j�s| j<�r"W 5 Q R £ d S d%|› d&�}d'|jj› d(|› d)�W  5 Q R £ S n
t=| jƒ W 5 Q R X d S )*NFri   Trq   c                 s   s   | ]}|  ¡ V  qd S rA   )rˆ   ©rk   Úar0   r0   r1   ro   ¥  s     z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>©ÚmethodZfallback_bindingrs   ©rG   ú
TORCH_API ú;
©Úcpp_sigr(   c                    s>   d|   ¡ › dˆ  ¡ › dd dd„ t|  ¡ ˆ  ¡ ƒD ƒ¡› d�S )NÚ
ú
 {
return rp   rq   c                 s   s   | ]}|j V  qd S rA   ru   rw   r0   r0   r1   ro   ·  s     zNRegisterDispatchKey.gen_unstructured.<locals>.generate_defn.<locals>.<genexpr>ú);
}
©rˆ   rO   r‚   r   r†   ©r›   ©rŠ   r0   r1   Úgenerate_defn´  s    ÿþ þz;RegisterDispatchKey.gen_unstructured.<locals>.generate_defnrœ   ú rp   z") {
  TORCH_CHECK_NOT_IMPLEMENTED(z[.is_meta(),
    "Cannot inplace into non-meta tensor with meta tensor argument");
  return rz   z::c                 s   s   | ]}|j V  qd S rA   ru   rw   r0   r0   r1   ro   Ü  s   ÿ©r–   rM   z// DeviceGuard omittedc                 s   s   | ]}t |tƒV  qd S rA   )r]   r    r“   r0   r0   r1   ro   ï  s   ÿz=
  const DeviceGuard device_guard(device_or_default(device));z globalContext().lazyInitCUDA();
c                 s   s    | ]}|j  ¡ r|j› V  qd S rA   )rJ   rN   rO   r“   r0   r0   r1   ro     s   
þz1const OptionalDeviceGuard device_guard(device_of(ú));znamespace {

z) {
  z

  ry   z);
}

} // anonymous namespace
z	TORCH_FN(rr   úm.impl("z",
z);
)>r   r%   r�   r)   r   r+   rg   r{   r   r|   Zhas_composite_kernelr�   r‹   Zuse_out_as_primaryr   Úmanual_kernel_registrationrE   r$   ÚREGISTRATIONrF   Úis_native_function_selectedrh   rO   r„   r…   r†   r‚   r   Úfrom_native_functionÚNAMESPACED_DECLARATIONÚ
signaturesrG   ÚdeclÚNAMESPACED_DEFINITIONr   r3   ÚANONYMOUS_DEFINITIONÚself_argr~   Úargumentr�   rŽ   rH   Úcpp_namespaceÚkernelr   r   Údevice_guardÚ	itertoolsÚchainr}   Úflat_positionalrD   rR   rP   r`   ÚanyZnon_outr   ÚnextrI   r"   )rZ   rT   rY   Zinplace_metaZgets_out_inplace_wrapperrO   r„   rK   Úargs_strÚcpp_sig_groupÚresultr›   r¢   Zself_arg_namer’   Z	impl_nameZ
kernel_sigZargs_exprs_strrP   Údevice_check_argsr´   Zhas_tensor_optionsr°   Zcandidate_argsZ	device_ofÚpayloadr0   r¡   r1   rV   |  s   ÿþûø
ÿþý
ÿ
þ
  ÿÿÿÿþþ	

  ÿþ
 ÿ  ÿþÿ
ÿýýþú
ýýýüúùù$z$RegisterDispatchKey.gen_unstructured)N)Ú__name__Ú
__module__Ú__qualname__r   Ú__annotations__r   r   r$   r¯   r®   r«   r¨   r!   Úboolr   r3   Ústaticmethodr   r   r   rR   r   r   r   rc   r   r   rh   r�   r_   rV   r0   r0   r0   r1   rD   Ý   sF   
ýÿ	  þ
þ þ3 ÿ þrD   c                   @   s€   e Zd ZU eed< eeeedœdd„Zeeedœdd„Z	eee
edœd	d
„Zeeeeeedœdd„Zeeee dœdd„ƒZdS )r�   rY   )r‰   Úparent_classÚgenerate_superr(   c                    sP   |r|› d�‰nd‰t tt dœ‡ ‡‡fdd„}d|ddd	�› d|d
dd	�› d�S )NzE::set_output_raw_strided(output_idx, sizes, strides, options, names);rs   )rO   Úmaybe_create_proxyr(   c              	      s0   d| › dt  ˆ ˆ |¡d¡› dt  ˆ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)rO   rÇ   ©r‰   rZ   Zset_output_superr0   r1   Úgen_set_output_functionC  s    ÿû
õz]StructuredRegisterDispatchKey.gen_class_set_output_functions.<locals>.gen_set_output_functionrœ   ZstridedT)rÇ   Zraw_stridedF)r3   rÃ   )rZ   r‰   rÅ   rÆ   rÎ   r0   rÍ   r1   Úgen_class_set_output_functions;  s    
ÿ
þz<StructuredRegisterDispatchKey.gen_class_set_output_functions)r‰   rÇ   r(   c                 C   sÔ   | j jtjtjtjfkr&d}|d }nd }}|r8d}nd}|tjkrt| j jtjtj	tjtjtjfksjt
‚|› d�S |tjkrŒ|› d|› �S |tjkr¤|› d|› �S |tjks¸|tjkrÈt
|› d�ƒ‚nt|ƒ d S )	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œ   rs   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.   r5   r   r‡   r+   r*   r~   r|   r}   ÚmutableÚscratchr"   )rZ   r‰   rÇ   Zmaybe_set_guardZmaybe_set_guard_lineZcreate_proxyr0   r0   r1   rÌ   X  sB    ý	

û


ý
ýÿz7StructuredRegisterDispatchKey.gen_class_set_output_body)r‰   Ú
class_namer‹   r(   c                 C   s¢   |t jkrdS |t jkr"|› d�S |t jkrrd dd„ t|ƒD ƒ¡}d dd„ t|ƒD ƒ¡}|› d|› d|› d	�S |t jks†|t jkr–t|› d
�ƒ‚nt	|ƒ d S )Nrs   z,(Tensor& self) : outputs_{std::ref(self)} {}rq   c                 s   s   | ]}d |› �V  qdS )zTensor& outNr0   ©rk   rl   r0   r0   r1   ro   ™  s     z?StructuredRegisterDispatchKey.gen_class_ctor.<locals>.<genexpr>c                 s   s   | ]}d |› d�V  qdS )zstd::ref(outrr   Nr0   rÔ   r0   r0   r1   ro   š  s     rp   z) : outputs_{ z } {}rÐ   )
r   r‡   r|   r}   r‚   ÚrangerÑ   rÒ   r~   r"   )rZ   r‰   rÓ   r‹   Úout_argsZout_refsr0   r0   r1   Úgen_class_ctor’  s    



ÿz,StructuredRegisterDispatchKey.gen_class_ctor)rT   r‰   rÓ   rÅ   rÆ   r(   c                C   sV  |t jkrd}d}d}nN|t jkr@d}d}dt|jjƒ› d�}n&|t jkrfd}d}dt|jjƒ› d�}| jjt	j
kr†| jr€d}	q²d	}	n,| jjt	jkršd
}	n| jjt	jkr®d
}	nd}	d}
|  ||t|jjƒ¡}d|› d|› d�t ||
¡› t |  |||¡|
¡› dd|› d�dd|› dt|jjƒ› d�t ||
¡› t |	|
¡› df
}d dd„ |D ƒ¡S )NZTensorzoutputs_[output_idx]rs   zstd::reference_wrapper<Tensor>zaproxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get()z"std::array<c10::optional<Tensor>, z> proxy_outputs_;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<rq   z> outputs_;z};rœ   c                 s   s   | ]}|r|V  qd S rA   r0   )rk   Úliner0   r0   r1   ro   ×  s      z:StructuredRegisterDispatchKey.gen_class.<locals>.<genexpr>)r   r‡   r|   r�   rg   r‹   r}   r%   r)   r   r-   r'   r5   r.   r×   rÊ   rË   rÏ   r‚   )rZ   rT   r‰   rÓ   rÅ   rÆ   Úoutput_typeZoutput_valueZproxy_fieldZguard_fieldrË   Zclass_ctor_strÚlinesr0   r0   r1   Ú	gen_class£  sL    	


ÿÿ
öz'StructuredRegisterDispatchKey.gen_classrS   c               
      s@  |j r
t‚| jtjkr&| j |¡s&d S | jjt	j
krH|j ¡ tjkrHd S tj|ddd�}| j |¡}t|jd| jj› d�|d k	o†| ¡ d�‰ | jtjkrÈd}|j| jd�D ]}|d| ¡ › d	�7 }qª|S | jtjk�rttd
œ‡ fdd„}d}|j| jd�D ]}|||ƒ7 }� qü|S | jtjk�r|j ¡ }g }tˆ  ¡ ƒ}	| jjt	jk�rzdt  | j!¡› d|j › �}
dt  | j!¡› �}n€| jjt	j
k�r¸dt  | j!¡› d|j › �}
dt  | j!¡› �}nB| j | j!¡}|d k	�sÔt‚d|j"› d|j › �}
|j#› d|j"› �}| jj$�r:t% &|jjj|jjj'¡}| (t) *|j+t|ƒˆ   ¡ ¡¡ |tj,k�rX| (|
› d�¡ nZ|tj-k�rv| (|
› d�¡ n<|tjk�r²d .dd„ |jjjD ƒ¡}| (|
› d|› d�¡ d .dd„ t/|	t0 1| j!¡dd�D ƒ¡}| j!jj2�r^| (d|› d�¡ | j!jj2j3 4¡ | j!jj2j5f•}|D ]8}|D ],}|	 (t6d|j › �t0j7||j d�d�¡ �q �q| (d¡ n| (d |› d�¡ t0 8| j!¡}t9|ƒD ]n\}}t:t;t<ƒƒ|j=j>k�s¦t‚|tjk�rÀd!|› d"�}nd#|› d$�}|	 (t6|t?|j=j t@t;t<ƒƒƒd�¡ �q„| jjt	j
k�rftj| j!jd|jAd�}| B¡ }|  ¡ }d .d%d„ t/|	| ¡ dd�D ƒ¡}| (d&|› d'|› d�¡ nH| jjt	jk�r®d .d(d„ t/|	t0 C| j!¡dd�D ƒ¡}| (d)|› d�¡ |tjk�sÆ|tj-k�rütDtE|jjFƒƒD ]$}| (d*|› d+|› d,|› d-�¡ �qÖ|tj,k�rNtE|jjFƒd.k�r d/}n,d .d0d„ tDtE|jjFƒƒD ƒ¡}d1|› d"�}nh|tj-k�r`d2}nV|tjk�r¶tE|jjFƒd.k�r�|jjjd3 j }n&d .d4d„ |jjjD ƒ¡}d5|› d"�}| (d6|› d7�¡ d8 .|¡}| jG|||
|| j!jjHd k	d9�› d:ˆ  I¡ › d;|› d<�S | jtjk�r.d=|jj › d>ˆ   ¡ › d?�S tJ| jƒ d S d S )@NFr•   rd   r<   re   rs   r—   r˜   r™   rš   c                    s>   d|   ¡ › dˆ  ¡ › dd dd„ t|  ¡ ˆ  ¡ ƒD ƒ¡› d�S )Nrœ   r�   rp   rq   c                 s   s   | ]}|j V  qd S rA   ru   rw   r0   r0   r1   ro     s     zOStructuredRegisterDispatchKey.gen_one.<locals>.generate_defn.<locals>.<genexpr>rž   rŸ   r    r¡   r0   r1   r¢     s    ÿþ þz<StructuredRegisterDispatchKey.gen_one.<locals>.generate_defnZstructured_Z_meta_zat::meta::structured_Z_default_backend_z::structured_z op;z
 op(self);rq   c                 s   s   | ]}|j V  qd S rA   rt   r“   r0   r0   r1   ro   G  s     z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>z op(rj   c                 s   s   | ]}|j V  qd S rA   ru   rw   r0   r0   r1   ro   L  s   ÿr¤   zauto precompute = op.meta(zprecompute.)Zbinds)rv   rJ   z(void)precompute;zop.meta(zop.maybe_get_output(rr   zop.outputs_[ú]c                 s   s   | ]}|j V  qd S rA   ru   rw   r0   r0   r1   ro   ’  s   ÿzat::rp   c                 s   s   | ]}|j V  qd S rA   ru   rw   r0   r0   r1   ro   ¢  s   ÿzop.impl(zif (op.proxy_outputs_[z].has_value()) op.outputs_[z!].get().copy_(*op.proxy_outputs_[z]);ri   zstd::move(op.outputs_[0])c                 s   s   | ]}d |› d�V  qdS )zstd::move(op.outputs_[z])Nr0   rÔ   r0   r0   r1   ro   ¸  s   ÿzstd::make_tuple(rZ   r   c                 s   s   | ]}|j V  qd S rA   rt   r“   r0   r0   r1   ro   Ã  s     zstd::forward_as_tuple(zreturn ú;rœ   )rÓ   rÅ   rÆ   z

z {
rÉ   r¦   z", TORCH_FN(r¥   )Kr§   r~   rE   r$   r¨   rF   r©   r%   r)   r   r5   rg   r{   r   r}   r   rª   rŽ   r   Zsupports_symintr«   r¬   rG   r­   r®   r   r3   r¯   r`   r†   r+   ÚmetarO   rY   r³   r²   r´   rµ   r¶   r·   r,   rD   rR   rP   r‡   r|   r‚   r   r^   Zmeta_argumentsZprecomputedÚreplaceÚvaluesÚaddr   Zargument_typeZout_argumentsrƒ   r   r	   r   ZnctyperJ   r   r   Zmanual_cpp_bindingZmost_faithful_signatureZimpl_argumentsrÕ   r�   r‹   rÛ   Zstructured_inheritsrˆ   r"   ) rZ   rT   r»   Úkernr¼   r›   r¢   r‰   Zsig_bodyÚcontextrÓ   rÅ   r’   r½   Zout_args_strZ
meta_exprsZprecomputed_valuesZprecomputed_elemsrQ   rÖ   rl   rŒ   rv   Zout_sig_groupZout_sigZapi_nameZ	out_exprsZ
impl_exprsZret_exprÚmovedÚrefsZsig_body_strr0   r¡   r1   r‘   Ù  sR   

ÿ
þÿÿý  ÿý
ÿÿ
 ÿ  ÿÿ
 
 ÿþ
þ
þÿ	 
ÿûÿÿÿ  ÿ
þ
 
 ÿþÿ
þ
 üÿø	÷
z%StructuredRegisterDispatchKey.gen_oneN)r¿   rÀ   rÁ   r   rÂ   r   r3   rÃ   rÏ   rÌ   Úintr×   r   rÛ   r   r   r‘   r0   r0   r0   r1   r�   7  s"   
  þ:ø6r�   )?rµ   rÊ   Údataclassesr   Útypingr   r   r   r   r   Ztorchgen.api.cppÚapir   Ztorchgen.api.metarÞ   Ztorchgen.api.structuredr^   Ztorchgen.api.translater   Ztorchgen.api.typesr	   r
   r   r   r   r   r   r   r   r   r   r   Ztorchgen.contextr   r   Ztorchgen.modelr   r   r   r   r   r   r   r   r   r    Z!torchgen.selective_build.selectorr!   Ztorchgen.utilsr"   r#   r$   rÃ   r3   r2   r9   r;   r=   r?   r@   rB   rD   r�   r0   r0   r0   r1   Ú<module>   s>   80ü!þ  [