
    AVh	                    L   d Z ddlZddlmZ ddlmZ ddlmZ ddlm	Z
 ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZm Z m!Z! ddl"m#Z#  edddddd      Z$dde#e!e$f   de#e!e$f   de%de%de#e!e$f   f
dZ&  ed       ejN                  e&            Z(de#e!e$f   de#e!e$f   de%de%de#e!e$f   f
dZ) eddd      Z*dd e#e!e*f   de#e!e*f   fd!Z+  ed"       ejN                  e+            Z,d e#e!e*f   de#e!e*f   fd#Z- ed$dd      Z.dd%e#e!e.f   d&e#e!e.f   de#e!e.f   fd'Z/  ed(       ejN                  e/            Z0d%e#e!e.f   d&e#e!e.f   de#e!e.f   fd)Z1 ed*dddd      Z2dd e#e!e2f   de#e!e2f   fd+Z3  ed,       ejN                  e3            Z4d e#e!e2f   de#e!e2f   fd-Z5 ed.dd      Z6dd e#e!e6f   de%de#e!e6f   fd/Z7  ed0       ejN                  e7            Z8d e#e!e6f   de%de#e!e6f   fd1Z9 ed2dd      Z:dde#e!e:f   de#e!e:f   de%de#e!e:f   fd3Z;  ed4       ejN                  e;            Z<de#e!e:f   de#e!e:f   de%de#e!e:f   fd5Z= ed6dd      Z>dde#e!e>f   de#e!e>f   d7e#e!ej~                  f   d8e%de#e!e>f   f
d9Z@  ed:       ejN                  e@            ZAde#e!e>f   de#e!e>f   d7e#e!ej~                  f   d8e%de#e!e>f   f
d;ZB ed<dd      ZCdde#e!eCf   de#e!eCf   de%de%de#e!eCf   f
d=ZD  ed>       ejN                  eD            ZEde#e!eCf   de#e!eCf   de%de%de#e!eCf   f
d?ZF ed@dd      ZGdd e#e!eGf   de#e!eGf   fdAZH  edB       ejN                  eH            ZId e#e!eGf   de#e!eGf   fdCZJ ej                  dDdEdFg      ZL edGdd      ZMdd e#e!eMf   dHe%fdIZN  edJ       ejN                  eN            ZOd e#e!eMf   dHe%fdKZP ej                  dLg dM      ZQ edNdddd      ZRdd e#e!eRf   dOe%dPe%fdQZS  edR       ejN                  eS            ZTd e#e!eRf   dOe%dPe%fdSZU edTddddd      ZVej                  ej                   edUdUdVgW       edV      dd e#e!eVf   de#e!eVf   fdX                            ZY  edY       ejN                  eY            ZZeYj                  j                  Z]d e#e!eVf   de#e!eVf   fdZZ^ ed[ddd      Z_dd%e#e!e_f   d&e#e!e_f   de#e!e_f   fd\Z`  ed]       ejN                  e`            Zad%e#e!e_f   d&e#e!e_f   de#e!e_f   fd^Zb ej                  d_dEdFg      Zc ed`dddd      Zd edadd      Zedd e#e!edf   dbeedHe%fdcZf  edd       ejN                  ef            Zgd e#e!edf   dbeedHe%fdeZh edf Ziddge#e e!   eif   dhejde#e!eif   fdiZk  edj       ejN                  ek            Zldge#e e!   eif   dhejde#e!eif   fdkZm ej                  dldmdng      Zn edoddddd      Zodd e#e!eof   fdpZp  edq       ejN                  ep            Zqd e#e!eof   fdrZr ej                  dsdtdug      Zs edvddddd      Zt edwdxdy      Zuej                  ej                   edz      ej                  dfd e#e!etf   d{eufd|                     Zw  ed}       ejN                  ew            Zxewj                  j                  Zyd e#e!etf   d{eufd~Zz edddddd      Z{ej                  ej                   edddgW       ed      dd e#e!e{f   de#e!e{f   fd                            Z|  ed       ejN                  e|            Z}e|j                  j                  Z~d e#e!e{f   de#e!e{f   fdZ edddddd      Zdd e#e!ef   de#e!ef   fdZ  ed       ejN                  e            Zd e#e!ef   de#e!ef   fdZ edddddd      Zej                  ej                   edddgW       ed      dd e#e!ef   de%de#e!ef   fd                            Z  ed       ejN                  e            Zej                  j                  Zd e#e!ef   de%de#e!ef   fdZ eddd      Zdd e#e!ef   de#e!ef   fdZ  ed       ejN                  e            Zd e#e!ef   de#e!ef   fdZ edddddd      Zej                  ej                   edddgW       ed      dde#e!ef   de#e!ef   de%de#e!ef   fd                            Z  ed       ejN                  e            Zej                  j                  Zde#e!ef   de#e!ef   de%de#e!ef   fdZ edddddd      Zdde#e!ef   de#e!ef   d7e#e!ej~                  f   d8e%de#e!ef   f
dZ  ed       ejN                  e            Zde#e!ef   de#e!ef   d7e#e!ej~                  f   d8e%de#e!ef   f
dZ edddddd      Zej                  ej                   edd      dd e#e!ef   de#e!ef   fd                     Z  ed       ejN                  e            Zej                  j                  Zd e#e!ef   de#e!ef   fdZ eddddddd      Zdde#e!ef   de#e!ef   de%de%de#e!ef   f
dZ  ed       ejN                  e            Zde#e!ef   de#e!ef   de%de%de#e!ef   f
dZ ej                  dddg      Z edddddd      Zej                  ej                   edddgW       ed      dd e#e!ef   dPe%fd                            Z  ed       ejN                  e            Zej                  j                  Zd e#e!ef   dPe%fdZ edddd      Zdd e#e!ef   de#e!ef   fdZ  ed       ejN                  e            Zd e#e!ef   de#e!ef   fdZ ej                  ddEdFg      Z edddddd      Zdd e#e!ef   dHe%fdZ  ed       ejN                  e            Zd e#e!ef   dHe%fdZ ej                  dg dM      Z edddddd      Zdd e#e!ef   dOe%dPe%fdZ  ed       ejN                  e            Zd e#e!ef   dOe%dPe%fdZ eddddd      Zdde#e!ef   de#e!ef   de#e!ef   de#e!ef   de#e!ef   f
dÄZ  edī       ejN                  e            Zde#e!ef   de#e!ef   de#e!ef   de#e!ef   de#e!ef   f
dńZ eddddd      Zdde#e!ef   de#e!ef   de%de%de#e!ef   f
dʄZ  ed˫       ejN                  e            Zde#e!ef   de#e!ef   de%de%de#e!ef   f
d̄Zy)zUPython wrappers around TensorFlow ops.

This file is MACHINE GENERATED! Do not edit.
    N)
pywrap_tfe)context)core)execute)dtypes)annotation_types)op_def_registry)ops)op_def_library)deprecated_endpoints)dispatch)	tf_export)TypeVarListAny)	AnnotatedTV_BandedTriangularSolve_T_atypes.Complex128_atypes.Complex64_atypes.Float32_atypes.Float64_atypes.Halfmatrixrhsloweradjointreturnc                 B   t         j                   xs t        j                         }|j                  }|j                  r 	 t	        j
                  |d|| |d|d|	      }|S |d}t        j                  |d      }|d}t        j                  |d      }t        j                   d| ||||      \  }	}	}
}|dd }t        j"                         rYd|
j%                  d      d|
j%                  d      d	|
j'                  d	      f}|
j(                  }t        j*                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||||      S # t        j                  $ r Y >w xY w)
a  TODO: add doc.

  Args:
    matrix: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
    rhs: A `Tensor`. Must have the same type as `matrix`.
    lower: An optional `bool`. Defaults to `True`.
    adjoint: An optional `bool`. Defaults to `False`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `matrix`.
  BandedTriangularSolver   r   Nr   r   namectxTFr   r   r   r   r!   T)_contextr   _thread_local_datais_eagerr   TFE_Py_FastPathExecute_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException&banded_triangular_solve_eager_fallback_SymbolicException_execute	make_bool_op_def_library_apply_op_helpermust_record_gradient_get_attr_bool_get_attr_typeinputsrecord_gradientr   r   r   r   r!   _ctxtld_resulte__op_outputs_attrs_inputs_flats                 T/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/gen_linalg_ops.pybanded_triangular_solverD      s    
			0h..0$#\\11%tVS'57g n ]E


UG
,%_Gw	2''88Cu)0t=!QX QK'""$s))'2I  +S#2D2DS2IKF::Lvw@('	.7 && -
##At,,## 
3
#UG$DJ J## 
0    D+ +E2>EE21E26F FFzraw_ops.BandedTriangularSolvec           	         |d}t        j                  |d      }|d}t        j                  |d      }t        j                  | |g|t        j                  t        j
                  t        j                  t        j                  t        j                  g      \  }}|\  } }| |g}d|d|d|f}	t        j                  dd||	||      }
t        j                         rt        j                  d	||	|
       |
\  }
|
S )
NTr   Fr   r$   s   BandedTriangularSolve   r7   attrsr"   r!   r   r0   r1   args_to_matching_eager_dtypesfloat64float32half	complex64
complex128r   r4   r8   r   r   r   r   r!   r"   _attr_T	_inputs_TrB   rA   r<   s              rC   r.   r.   P   s   
]E


UG
,%_Gw	2'66}cGOO]d]l]lnunznz  }D  }N  }N  PW  Pb  Pb  Le  f'9-63#,UIwW=&5q#)s?'""$vw@('	.    TV_BatchCholesky_Tinputc                 ~   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d||       }|S t        j                  d| |      \  }}}}|dd }t        j                          r7d|j#                  d      f}	|j$                  }
t        j&                  d|
|	|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||      S # t        j                  $ r Y w xY w)TODO: add doc.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  BatchCholeskyNr!   r"   rW   r!   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   batch_cholesky_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   rW   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s              rC   batch_choleskyr_   f   s7    
			0h..0$#\\11otU,gn (88u41!QXQK'""$3%%c*+F::Lvw8('	.' && -
##At,,## 
*
d& &## 
0    C D C;;DDD& &D<;D<zraw_ops.BatchCholeskyc                     t        j                  | g|t        j                  t        j                  g      \  }\  } | g}d|f}t        j
                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   BatchCholeskyrG   rH   rZ   r0   rK   rL   rM   rN   r   r4   r8   rW   r!   r"   rS   rB   rA   r<   s          rC   r]   r]      s    55ugsW__V]VeVeDhi'8E,>&-q#)s?'""$vw8('	.rU   TV_BatchCholeskyGrad_Tlgradc                    t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| |      }|S t        j                  d| ||      \  }}}}	|	dd }t        j                          r7d|j#                  d      f}
|j$                  }t        j&                  d||
|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||      S # t        j                  $ r Y w xY w)a  TODO: add doc.

  Args:
    l: A `Tensor`. Must be one of the following types: `float32`, `float64`.
    grad: A `Tensor`. Must have the same type as `l`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `l`.
  BatchCholeskyGradNr[   re   rf   r!   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   "batch_cholesky_grad_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   re   rf   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s               rC   batch_cholesky_gradrl      s>    
			0h..0$#\\11!4D2gn (88qt$8!QXQK'""$3%%c*+F::L\67<('	.' && -
##At,,## 
/
T$( (## 
0    C D"C==DDD) )D?>D?zraw_ops.BatchCholeskyGradc                 *   t        j                  | |g|t        j                  t        j                  g      \  }}|\  } }| |g}d|f}t        j
                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   BatchCholeskyGradrG   rH   rh   )r0   rK   rL   rN   rM   r   r4   r8   	re   rf   r!   r"   rS   rT   rB   rA   r<   s	            rC   rj   rj      s    664y#Y`YhYhGkl'9)1dT,>&11\#)s?'""$\67<('	.rU   TV_BatchMatrixDeterminant_Tc                 ~   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d||       }|S t        j                  d| |      \  }}}}|dd }t        j                          r7d|j#                  d      f}	|j$                  }
t        j&                  d|
|	|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||      S # t        j                  $ r Y w xY w)zTODO: add doc.

  Args:
    input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `complex64`, `complex128`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  BatchMatrixDeterminantNr[   r\   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   'batch_matrix_determinant_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   r^   s              rC   batch_matrix_determinantrt      s9    
			0h..0$#\\11&e5gn (88 D:!QXQK'""$3%%c*+F::L ,A('	.' && -
##At,,## 
4
d& &## 
r`   zraw_ops.BatchMatrixDeterminantc                 \   t        j                  | g|t        j                  t        j                  t        j
                  t        j                  g      \  }\  } | g}d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   BatchMatrixDeterminantrG   rH   rr   )
r0   rK   rL   rN   rM   rP   rQ   r   r4   r8   rc   s          rC   rs   rs     s    55ugsW__V]VeVegngxgx  {B  {M  {M  EP  Q'8E,>&6$0C"&(' ""$ ,A('	.rU   TV_BatchMatrixInverse_Tc                    t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| d|      }|S |d}t        j                  |d      }t        j                   d| ||      \  }}}}	|	dd }t        j"                         rHd|j%                  d      d|j'                  d      f}
|j(                  }t        j*                  d||
|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||      S # t        j                  $ r Y w xY w)a
  TODO: add doc.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`.
    adjoint: An optional `bool`. Defaults to `False`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  BatchMatrixInverser   Nr   r!   r"   FrW   r   r!   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   #batch_matrix_inverse_eager_fallbackr/   r0   r1   r2   r3   r4   r5   r6   r7   r8   rW   r   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s               rC   batch_matrix_inverser}     sp    
			0h..0$#\\11"D%GEgn _Gw	2''88E7G!QXQK'""$++I6  %'F::LlFG=('	./ && -
##At,,## 
0
t7 7## 
s0    C; ;ED))EEE E,+E,zraw_ops.BatchMatrixInversec                 X   |d}t        j                  |d      }t        j                  | g|t        j                  t        j
                  g      \  }\  } | g}d|d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )NFr   r$   s   BatchMatrixInverserG   rH   rx   	r0   r1   rK   rL   rM   rN   r   r4   r8   rW   r   r!   r"   rS   rB   rA   r<   s           rC   r{   r{   ?  s    _Gw	2'55ugsW__V]VeVeDhi'8E,wW-&2Al#)s?'""$lFG=('	.rU   TV_BatchMatrixSolve_Tc           	         t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| |d|      }|S |d}t        j                  |d      }t        j                   d| |||      \  }}}	}
|
dd }t        j"                         rHd|	j%                  d      d|	j'                  d      f}|	j(                  }t        j*                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||||      S # t        j                  $ r Y w xY w)aF  TODO: add doc.

  Args:
    matrix: A `Tensor`. Must be one of the following types: `float64`, `float32`.
    rhs: A `Tensor`. Must have the same type as `matrix`.
    adjoint: An optional `bool`. Defaults to `False`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `matrix`.
  BatchMatrixSolver   Nry   Fr   r   r   r!   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   !batch_matrix_solve_eager_fallbackr/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r   r   r   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s                rC   batch_matrix_solver   Q  sx    
			0h..0$#\\11 $YIgn _Gw	2''886sG!%'!QX QK'""$++I6  %'F::LL&';('	.1 && -
##At,,## 
.
#wTt= =## 
s0    C= =ED++EEE E/.E/zraw_ops.BatchMatrixSolvec                 b   |d}t        j                  |d      }t        j                  | |g|t        j                  t        j
                  g      \  }}|\  } }| |g}d|d|f}t        j                  dd||||      }	t        j                         rt        j                  d|||	       |	\  }	|	S )NFr   r$   s   BatchMatrixSolverG   rH   r   r   
r   r   r   r!   r"   rS   rT   rB   rA   r<   s
             rC   r   r     s    _Gw	2'66}cGOO]d]l]lKop'9-63#,wW-&0!L#)s?'""$L&';('	.rU   TV_BatchMatrixSolveLs_Tl2_regularizerfastc           
         t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| ||d|      }|S |d}t        j                  |d      }t        j                   d| ||||      \  }	}	}
}|dd }t        j"                         rHd|
j%                  d      d|
j'                  d      f}|
j(                  }t        j*                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||||      S # t        j                  $ r Y w xY w)at  TODO: add doc.

  Args:
    matrix: A `Tensor`. Must be one of the following types: `float64`, `float32`.
    rhs: A `Tensor`. Must have the same type as `matrix`.
    l2_regularizer: A `Tensor` of type `float64`.
    fast: An optional `bool`. Defaults to `True`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `matrix`.
  BatchMatrixSolveLsr   Nr   r!   r"   Tr   r   r   r   r!   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   $batch_matrix_solve_ls_eager_fallbackr/   r0   r1   r2   r3   r4   r6   r5   r7   r8   r   r   r   r   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s                 rC   batch_matrix_solve_lsr     s    
			0h..0$#\\11"D&#~vg n 
\D			D&	)$'88V-;$#')!QX QK'""$3%%c*F  (*F::LlFG=('	.3 && -
##At,,## 
1
#~DtG G## 
0    C? ?ED--EE
E E21E2zraw_ops.BatchMatrixSolveLsc                    |d}t        j                  |d      }t        j                  | |g|t        j                  t        j
                  g      \  }}|\  } }t        j                  |t        j                        }| ||g}d|d|f}	t        j                  dd||	||      }
t        j                         rt        j                  d||	|
       |
\  }
|
S )NTr   r$   s   BatchMatrixSolveLsrG   rH   r   )r0   r1   rK   rL   rM   rN   r+   convert_to_tensorr   r4   r8   r   r   r   r   r!   r"   rS   rT   rB   rA   r<   s              rC   r   r     s    	\D			D&	)$66}cGOO]d]l]lKop'9-63)).'//J.#~.,&$'&2Al#)s?'""$lFG=('	.rU   TV_BatchMatrixTriangularSolve_Tc                 B   t         j                   xs t        j                         }|j                  }|j                  r 	 t	        j
                  |d|| |d|d|	      }|S |d}t        j                  |d      }|d}t        j                  |d      }t        j                   d| ||||      \  }	}	}
}|dd }t        j"                         rYd|
j%                  d      d|
j%                  d      d	|
j'                  d	      f}|
j(                  }t        j*                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||||      S # t        j                  $ r Y >w xY w)
ay  TODO: add doc.

  Args:
    matrix: A `Tensor`. Must be one of the following types: `float64`, `float32`.
    rhs: A `Tensor`. Must have the same type as `matrix`.
    lower: An optional `bool`. Defaults to `True`.
    adjoint: An optional `bool`. Defaults to `False`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `matrix`.
  BatchMatrixTriangularSolver   r   Nr    TFr#   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   ,batch_matrix_triangular_solve_eager_fallbackr/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   s                 rC   batch_matrix_triangular_solver     s    
			0h..0$#\\11*D&#w7g n ]E


UG
,%_Gw	2''88$VE.5DB!QX QK'""$s))'2I  +S#2D2DS2IKF::L$lFGE('	.7 && -
##At,,## 
9
#UG$DJ J## 
rE   z"raw_ops.BatchMatrixTriangularSolvec                    |d}t        j                  |d      }|d}t        j                  |d      }t        j                  | |g|t        j                  t        j
                  g      \  }}|\  } }| |g}d|d|d|f}	t        j                  dd||	||      }
t        j                         rt        j                  d	||	|
       |
\  }
|
S )
NTr   Fr   r$   s   BatchMatrixTriangularSolverG   rH   r   r   rR   s              rC   r   r     s    
]E


UG
,%_Gw	2'66}cGOO]d]l]lKop'9-63#,UIwW=&:A$0C"&(' ""$$lFGE('	.rU   TV_BatchSelfAdjointEig_Tc                 ~   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d||       }|S t        j                  d| |      \  }}}}|dd }t        j                          r7d|j#                  d      f}	|j$                  }
t        j&                  d|
|	|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||      S # t        j                  $ r Y w xY w)rY   BatchSelfAdjointEigNr[   r\   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   %batch_self_adjoint_eig_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   r^   s              rC   batch_self_adjoint_eigr   '  s8    
			0h..0$#\\11#T52gn (88U7!QXQK'""$3%%c*+F::L|VW>('	.' && -
##At,,## 
2
d& &## 
r`   zraw_ops.BatchSelfAdjointEigc                     t        j                  | g|t        j                  t        j                  g      \  }\  } | g}d|f}t        j
                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   BatchSelfAdjointEigrG   rH   r   rb   rc   s          rC   r   r   P  s    55ugsW__V]VeVeDhi'8E,>&3Q|#)s?'""$|VW>('	.rU   BatchSelfAdjointEigV2r=   vTV_BatchSelfAdjointEigV2_T	compute_vc                 *   t         j                   xs t        j                         }|j                  }|j                  r2	 t	        j
                  |d|| d|      }t        j                  |      }|S |d}t        j                   |d      }t#        j$                  d| ||      \  }}}}	|	dd }t        j&                         rHd|j)                  d      d|j+                  d      f}
|j,                  }t        j.                  d||
|       t        j                  |      }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||      S # t        j                  $ r Y  w xY w)ah  TODO: add doc.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`.
    compute_v: An optional `bool`. Defaults to `True`.
    name: A name for the operation (optional).

  Returns:
    A tuple of `Tensor` objects (e, v).

    e: A `Tensor`. Has the same type as `input`.
    v: A `Tensor`. Has the same type as `input`.
  r   r   Nr   r!   r"   TrW   r   r!   r$   )r%   r   r&   r'   r   r(   _BatchSelfAdjointEigV2Output_maker)   r*   r+   r,   r-   (batch_self_adjoint_eig_v2_eager_fallbackr/   r0   r1   r2   r3   r4   r5   r6   r7   r8   rW   r   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s               rC   batch_self_adjoint_eig_v2r   c  s    
			0h..0$#\\11%tUKLg,227;gn I  K8)'88u	N!QXQK'""$3--k:C  %'F::Lvw@(..w7'	./ && -
##At,,## 
5
94T; ;## 
0    0D! !E(4EE('E(,E; ;FFzraw_ops.BatchSelfAdjointEigV2c                 z   |d}t        j                  |d      }t        j                  | g|t        j                  t        j
                  g      \  }\  } | g}d|d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       t        j                  |      }|S )NTr   r$   s   BatchSelfAdjointEigV2   rH   r   )r0   r1   rK   rL   rM   rN   r   r4   r8   r   r   rW   r   r!   r"   rS   rB   rA   r<   s           rC   r   r     s    I  K8)55ugsW__V]VeVeDhi'8E,C1&5q#)s?'""$vw@(..w7'	.rU   BatchSvd)sur   TV_BatchSvd_T
compute_uvfull_matricesc           
         t         j                   xs t        j                         }|j                  }|j                  r4	 t	        j
                  |d|| d|d|      }t        j                  |      }|S |d}t        j                   |d      }|d}t        j                   |d      }t#        j$                  d| |||      \  }}}	}
|
dd }t        j&                         rYd|	j)                  d      d|	j)                  d      d	|	j+                  d	      f}|	j,                  }t        j.                  d|||       t        j                  |      }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||||      S # t        j                  $ r Y Mw xY w)
a  TODO: add doc.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `complex64`, `complex128`.
    compute_uv: An optional `bool`. Defaults to `True`.
    full_matrices: An optional `bool`. Defaults to `False`.
    name: A name for the operation (optional).

  Returns:
    A tuple of `Tensor` objects (s, u, v).

    s: A `Tensor`. Has the same type as `input`.
    u: A `Tensor`. Has the same type as `input`.
    v: A `Tensor`. Has the same type as `input`.
  r   r   r   Nr   r   r!   r"   TFrW   r   r   r!   r$   )r%   r   r&   r'   r   r(   _BatchSvdOutputr   r)   r*   r+   r,   r-   batch_svd_eager_fallbackr/   r0   r1   r2   r3   r4   r5   r6   r7   r8   rW   r   r   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s                rC   	batch_svdr     s     
			0h..0$#\\	11j$|Z(g  %%g.gn J!!*l;*M$$]OD-'88%J"/d<!QX QK'""$C..|<o  13  %'F ::LL&'3!!'*'	.; && -
##At,,## 
%
Jm  ## 
0    2E F"E==FFF* *G Gzraw_ops.BatchSvdc                    |d}t        j                  |d      }|d}t        j                  |d      }t        j                  | g|t        j                  t        j
                  t        j                  t        j                  g      \  }\  } | g}d|d|d|f}t        j                  dd||||      }t        j                         rt        j                  d	|||       t        j                  |      }|S )
NTr   Fr   r$   s   BatchSvd   rH   r   )r0   r1   rK   rL   rM   rN   rP   rQ   r   r4   r8   r   r   	rW   r   r   r!   r"   rS   rB   rA   r<   s	            rC   r   r     s    J!!*l;*M$$]OD-55ugsW__V]VeVegngxgx  {B  {M  {M  EP  Q'8E,*o}c	&[!L#)s?'""$L&'3!!'*'	.rU   TV_Cholesky_Tzlinalg.choleskycholesky)v1c           	      >   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d||       }|S t        | |fd      }|t        ur|S 	 t/        j0                  d| |      \  }}}}|dd }t3        j4                         r7d|j7                  d      f}	|j8                  }
t3        j:                  d|
|	|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |fd      }|t        ur|S t        | ||      S # t        j                  $ r Y t        t         f$ rH t#        j$                  t&        dt)        | |            }|t"        j*                  j,                  ur|cY S  w xY w# t        t         f$ rH t#        j$                  t&        dt)        | |            }|t"        j*                  j,                  ur|cY S  w xY w)a  Computes the Cholesky decomposition of one or more square matrices.

  The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
  form square matrices.

  The input has to be symmetric and positive definite. Only the lower-triangular
  part of the input will be used for this operation. The upper-triangular part
  will not be read.

  The output is a tensor of the same shape as the input
  containing the Cholesky decompositions for all input submatrices `[..., :, :]`.

  **Note**: The gradient computation on GPU is faster for large matrices but
  not for large batch dimensions when the submatrices are small. In this
  case it might be faster to use the CPU.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
      Shape is `[..., M, M]`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  CholeskyNr[    r\   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   _dispatcher_for_choleskyNotImplementedcholesky_eager_fallbackr/   	TypeError
ValueError	_dispatchr   r   dictOpDispatcherNOT_SUPPORTEDr2   r3   r0   r4   r6   r7   r8   r^   s              rC   r   r     s   : 
			0h..0$#\\11j$'gn, '	Gn$n	
)::%d,Aq#x QK'""$3%%c*+F::LL&'3('	.W && -
##At,,## 
($.$ g		&$
d& &## 
z" ""b$U6g 
	..<<	<  Z	  
  
B5t4
G i,,:::n	
P    C& 3G &D-9DD-,D-1E 	E G,AG GAHHzraw_ops.Choleskyc           	      z   t        j                  | g|t        j                  t        j                  t        j
                  t        j                  t        j                  g      \  }\  } | g}d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   CholeskyrG   rH   r   r0   rK   rL   rM   rN   rO   rP   rQ   r   r4   r8   rc   s          rC   r   r   Q  s    55ugsW__V]VeVegngsgsu|  vG  vG  IP  I[  I[  E^  _'8E,>&[!L#)s?'""$L&'3('	.rU   TV_CholeskyGrad_Tc                    t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| |      }|S t        j                  d| ||      \  }}}}	|	dd }t        j                          r7d|j#                  d      f}
|j$                  }t        j&                  d||
|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||      S # t        j                  $ r Y w xY w)a#  Computes the reverse mode backpropagated gradient of the Cholesky algorithm.

  For an explanation see "Differentiation of the Cholesky algorithm" by
  Iain Murray http://arxiv.org/abs/1602.07527.

  Args:
    l: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
      Output of batch Cholesky algorithm l = cholesky(A). Shape is `[..., M, M]`.
      Algorithm depends only on lower triangular part of the innermost matrices of
      this tensor.
    grad: A `Tensor`. Must have the same type as `l`.
      df/dl where f is some scalar function. Shape is `[..., M, M]`.
      Algorithm depends only on lower triangular part of the innermost matrices of
      this tensor.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `l`.
  CholeskyGradNr[   ri   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   cholesky_grad_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   rk   s               rC   cholesky_gradr   `  s=   ( 
			0h..0$#\\11ndAt-gn (88!$T3!QXQK'""$3%%c*+F::Lfg7('	.' && -
##At,,## 
)
T$( (## 
rm   zraw_ops.CholeskyGradc                 H   t        j                  | |g|t        j                  t        j                  t        j
                  g      \  }}|\  } }| |g}d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   CholeskyGradrG   rH   r   )	r0   rK   rL   rO   rN   rM   r   r4   r8   ro   s	            rC   r   r     s    664y#V]VeVegngvgvGyz'9)1dT,>&_a#)s?'""$fg7('	.rU   EigTV_Eig_TTV_Eig_ToutToutc           
         t         j                   xs t        j                         }|j                  }|j                  r4	 t	        j
                  |d|| d|d|      }t        j                  |      }|S t        j                   |d      }|d}t        j"                  |d      }t%        j&                  d| |||      \  }}}	}
|
dd }t        j(                         rYd|	j+                  d      d|	j-                  d      d|	j-                  d      f}|	j.                  }t        j0                  d|||       t        j                  |      }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||||      S # t        j                  $ r Y Iw xY w)	a  Computes the eigen decomposition of one or more square matrices.

  Computes the eigenvalues and (optionally) right eigenvectors of each inner matrix in
  `input` such that `input[..., :, :] = v[..., :, :] * diag(e[..., :])`. The eigenvalues
  are sorted in non-decreasing order.

  ```python
  # a is a tensor.
  # e is a tensor of eigenvalues.
  # v is a tensor of eigenvectors.
  e, v = eig(a)
  e = eig(a, compute_v=False)
  ```

  Args:
    input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `complex64`, `complex128`.
      `Tensor` input of shape `[N, N]`.
    Tout: A `tf.DType` from: `tf.complex64, tf.complex128`.
    compute_v: An optional `bool`. Defaults to `True`.
      If `True` then eigenvectors will be computed and returned in `v`.
      Otherwise, only the eigenvalues will be computed.
    name: A name for the operation (optional).

  Returns:
    A tuple of `Tensor` objects (e, v).

    e: A `Tensor` of type `Tout`.
    v: A `Tensor` of type `Tout`.
  r   r   r   N)r   r   r!   r"   T)rW   r   r   r!   r$   )r%   r   r&   r'   r   r(   
_EigOutputr   r)   r*   r+   r,   r-   eig_eager_fallbackr/   r0   	make_typer1   r2   r3   r4   r5   r6   r7   r8   )rW   r   r   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s                rC   eigr     s   < 
			0h..0$#\\11eT5+y&$Hg  )gn 
		D&	)$I  K8)'88UG!QXQK'""$3--k:C  %vs/A/A&/IKF::L|VW.W%'	.1 && -
##At,,## 

94dF F## 
s0    2E FE99FFF& &F=<F=zraw_ops.Eigc                    t        j                  |d      }|d}t        j                  |d      }t        j                  | g|t        j
                  t        j                  t        j                  t        j                  g      \  }\  } | g}d|d|d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       t        j                  |      }|S )	Nr   Tr   r$   s   Eigr   rH   r   )r0   r   r1   rK   rL   rN   rM   rP   rQ   r   r4   r8   r   r   )	rW   r   r   r!   r"   rS   rB   rA   r<   s	            rC   r   r     s    			D&	)$I  K8)55ugsW__V]VeVegngxgx  {B  {M  {M  EP  Q'8E,C&$?&VQ|6!$41'""$|VW.W%'	.rU   ) TV_Einsum_T_atypes.BFloat16z_atypes.Boolr   r   z_atypes.Float16r   r   z_atypes.Float8e4m3b11fnuzz_atypes.Float8e4m3fnz_atypes.Float8e4m3fnuzz_atypes.Float8e5m2z_atypes.Float8e5m2fnuzr   z_atypes.Int16_atypes.Int32z_atypes.Int4_atypes.Int64z_atypes.Int8z_atypes.QInt16z_atypes.QInt32z_atypes.QInt8z_atypes.QUInt16z_atypes.QUInt8z_atypes.Resourcez_atypes.Stringz_atypes.UInt16z_atypes.UInt32z_atypes.UInt4z_atypes.UInt64z_atypes.UInt8z_atypes.Variantr7   equationc                 V   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| d|      }|S t        | t        t        f      st!        d| z        t#        |       }t%        j&                  |d      }t)        j*                  d| ||      \  }}}	}
|
dd }t%        j,                         rYd|	j/                  d      d|	j1                  d      d|	j3                  d      f}|	j4                  }t%        j6                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||      S # t        j                  $ r Y Kw xY w)	a  Tensor contraction according to Einstein summation convention.

  Implements generalized Tensor contraction and reduction. Each input Tensor must
  have a corresponding input subscript appearing in the comma-separated left-hand
  side of the equation. The right-hand side of the equation consists of the
  output subscript. The input subscripts and the output subscript should consist
  of zero or more named axis labels and at most one ellipsis (`...`).

  The named axis labels may be any single character other than those having
  special meaning, namely `,.->`. The behavior of this Op is undefined if it
  receives an ill-formatted equation; since the validation is done at
  graph-building time, we omit format validation checks at runtime.

  Note: This Op is *not* intended to be called by the user; instead users should
  call `tf.einsum` directly. It is a hidden Op used by `tf.einsum`.

  Operations are applied to the input(s) according to the following rules:

   (a) Generalized Diagonals: For input dimensions corresponding to axis labels
       appearing more than once in the same input subscript, we take the
       generalized (`k`-dimensional) diagonal.
       For example, in the equation `iii->i` with input shape `[3, 3, 3]`, the
       generalized diagonal would consist of `3` elements at indices `(0, 0, 0)`,
       `(1, 1, 1)` and `(2, 2, 2)` to create a Tensor of shape `[3]`.

   (b) Reduction: Axes corresponding to labels appearing only in one input
       subscript but not in the output subscript are summed over prior to Tensor
       contraction.
       For example, in the equation `ab,bc->b`, the axis labels `a` and `c` are
       the reduction axis labels.

   (c) Batch Dimensions: Axes corresponding to labels appearing in each of the
       input subscripts and also in the output subscript make up the batch
       dimensions in Tensor contraction. Unnamed axis labels corresponding to
       ellipsis (`...`) also correspond to batch dimensions.
       For example, for the equation denoting batch matrix multiplication,
       `bij,bjk->bik`, the axis label `b` corresponds to a batch dimension.

   (d) Contraction: In case of binary einsum, axes corresponding to labels
       appearing in two different inputs (and not in the output) are contracted
       against each other.
       Considering the batch matrix multiplication equation again
       (`bij,bjk->bik`), the contracted axis label is `j`.

   (e) Expand Diagonal: If the output subscripts contain repeated (explicit) axis
       labels, the opposite operation of (a) is applied. For example, in the
       equation `i->iii`, and input shape `[3]`, the output of shape `[3, 3, 3]`
       are all zeros, except for the (generalized) diagonal which is populated
       with values from the input.
       Note: This operation is not supported by `np.einsum` or `tf.einsum`; it is
       provided to enable computing the symbolic gradient of `tf.einsum`.

  The output subscripts must contain only labels appearing in at least one of the
  input subscripts. Furthermore, all dimensions mapping to the same axis label
  must be equal.

  Any of the input and output subscripts may contain at most a single ellipsis
  (`...`). These ellipsis are mapped against dimensions not corresponding to any
  named axis label. If two inputs contain ellipsis, then they are broadcasted
  according to standard NumPy broadcasting
  [rules](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html).

  The broadcasted dimensions are placed in the corresponding location of the
  ellipsis in the output subscript. If the broadcasted dimensions are non-empty
  and the output subscripts do not contain ellipsis, then an InvalidArgument error
  is raised.

  @compatibility(numpy)
  Similar to [`numpy.einsum`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.einsum.html).

  Comparison with `numpy.einsum`:

   * This Op only supports unary and binary forms of `numpy.einsum`.
   * This Op does not support implicit form. (i.e. equations without `->`).
   * This Op also supports repeated indices in the output subscript, which is not
     supported by `numpy.einsum`.
  @end_compatibility

  Args:
    inputs: A list of at least 1 `Tensor` objects with the same type.
      List of 1 or 2 Tensors.
    equation: A `string`.
      String describing the Einstein Summation operation; in the format of np.einsum.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `inputs`.
  Einsumr   N)r   r!   r"   ;Expected list for 'inputs' argument to 'einsum' Op, not %r.)r7   r   r!   Nr$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   einsum_eager_fallbackr/   
isinstancelisttupler   lenr0   make_strr2   r3   r4   get_attr_get_attr_intr6   r7   r8   )r7   r   r!   r:   r;   r<   r=   _attr_Nr>   r?   r@   rA   rB   s                rC   einsumr     s   r 
			0h..0$#\\11hfj(<gn 
FT5M	*
	!'	() ) K'x4('88(?!QXQK'""$#,,z2C$c3+=+=c+BDF::L,1('	.5 && -
##At,,## 
"
8$D: :## 
s0    D7 7E>
E%%E>=E>F F('F(zraw_ops.Einsumc                    t        | t        t        f      st        d| z        t	        |       }t        j                  |d      }t        j                  t        |       |g       \  }} t        |       }d|d|d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )	Nr   r   r   r$   s   EinsumrG   rH   r   )r   r   r   r   r   r0   r   rK   r   r4   r8   )	r7   r   r!   r"   r   rS   rB   rA   r<   s	            rC   r   r   }  s    	FT5M	*
	!'	() ) K'x4(33DL#rJ/'6f,#wW=&Y,f!$41'""$,1('	.rU   LogMatrixDeterminantsignlog_abs_determinantTV_LogMatrixDeterminant_Tc                    t         j                   xs t        j                         }|j                  }|j                  r0	 t	        j
                  |d||       }t        j                  |      }|S t        j                   d| |      \  }}}}|dd }t#        j$                         r7d|j'                  d      f}	|j(                  }
t#        j*                  d|
|	|       t        j                  |      }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||      S # t        j                  $ r Y w xY w)a  Computes the sign and the log of the absolute value of the determinant of

  one or more square matrices.

  The input is a tensor of shape `[N, M, M]` whose inner-most 2 dimensions
  form square matrices. The outputs are two tensors containing the signs and
  absolute values of the log determinants for all N input submatrices
  `[..., :, :]` such that `determinant = sign*exp(log_abs_determinant)`.
  The `log_abs_determinant` is computed as `det(P)*sum(log(diag(LU)))` where `LU`
  is the `LU` decomposition of the input and `P` is the corresponding
  permutation matrix.

  Args:
    input: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `complex64`, `complex128`.
      Shape is `[N, M, M]`.
    name: A name for the operation (optional).

  Returns:
    A tuple of `Tensor` objects (sign, log_abs_determinant).

    sign: A `Tensor`. Has the same type as `input`.
    log_abs_determinant: A `Tensor`. Has the same type as `input`.
  r   Nr[   r\   r$   )r%   r   r&   r'   r   r(   _LogMatrixDeterminantOutputr   r)   r*   r+   r,   r-   %log_matrix_determinant_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   r^   s              rC   log_matrix_determinantr    sQ   0 
			0h..0$#\\11$dE3g+11':gn (88e$8!QXQK'""$3%%c*+F::Lfg?'--g6'	.' && -
##At,,## 
2
d& &## 
s0    .C3 3D:D!!D:9D:>E E"!E"zraw_ops.LogMatrixDeterminantc           	         t        j                  | g|t        j                  t        j                  t        j
                  t        j                  t        j                  g      \  }\  } | g}d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       t        j                  |      }|S )Nr$   s   LogMatrixDeterminantr   rH   r   )r0   rK   rL   rO   rN   rM   rP   rQ   r   r4   r8   r   r   rc   s          rC   r  r    s    55ugsW\\SZSbSbdkdsdsu|  vG  vG  IP  I[  I[  E^  _'8E,>&4a#)s?'""$fg?'--g6'	.rU   LulupTV_Lu_TTV_Lu_output_idx_typer   r   z	linalg.luoutput_idx_typec           
         t         j                   xs t        j                         }|j                  }|j                  r2	 t	        j
                  |d|| d|      }t        j                  |      }|S t        | ||fd      }|t        ur|S |t2        j4                  }t7        j8                  |d      }	 t;        j<                  d| ||      \  }}}}	|	dd }t7        j>                         rHd|jA                  d      d|jA                  d      f}
|jB                  }t7        jD                  d||
|       t        j                  |      }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||fd      }|t        ur|S t        | |||      S # t        j                   $ r Y Ht"        t$        f$ rI t'        j(                  t*        dt-        | ||            }|t&        j.                  j0                  ur|cY S  w xY w# t"        t$        f$ rI t'        j(                  t*        dt-        | ||            }|t&        j.                  j0                  ur|cY S  w xY w)a  Computes the LU decomposition of one or more square matrices.

  The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
  form square matrices.

  The input has to be invertible.

  The output consists of two tensors LU and P containing the LU decomposition
  of all input submatrices `[..., :, :]`. LU encodes the lower triangular and
  upper triangular factors.

  For each input submatrix of shape `[M, M]`, L is a lower triangular matrix of
  shape `[M, M]` with unit diagonal whose entries correspond to the strictly lower
  triangular part of LU. U is a upper triangular matrix of shape `[M, M]` whose
  entries correspond to the upper triangular part, including the diagonal, of LU.

  P represents a permutation matrix encoded as a list of indices each between `0`
  and `M-1`, inclusive. If P_mat denotes the permutation matrix corresponding to
  P, then the L, U and P satisfies P_mat * input = L * U.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
      A tensor of shape `[..., M, M]` whose inner-most 2 dimensions form matrices of
      size `[M, M]`.
    output_idx_type: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int32`.
    name: A name for the operation (optional).

  Returns:
    A tuple of `Tensor` objects (lu, p).

    lu: A `Tensor`. Has the same type as `input`.
    p: A `Tensor` of type `output_idx_type`.
  r  r	  N)r	  r!   r"   r   )rW   r	  r!   r$   )#r%   r   r&   r'   r   r(   	_LuOutputr   r)   r*   r+   r,   r-   _dispatcher_for_lur   lu_eager_fallbackr/   r   r   r   r   r  r   r   r   rL   int32r0   r   r2   r3   r4   r6   r7   r8   )rW   r	  r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s               rC   r  r    s   J 
			0h..0$#\\11dD%!2OEg(gn. !	'/Gn$nmmO&&8IJ/

)::E?GAq#x QK'""$3%%c*,=  !235F::LlFG-OOG$'	.c && -
##At,,## 
"/4
)41g		&
tG G## 
z" ""Duo"$g 
	..<<	<( Z	  
  
b$UO "
G i,,:::n	
sP    0E	 3H, 	FE77FFF< -F< <H)AH)'H),AJJz
raw_ops.Luc           	         |t         j                  }t        j                  |d      }t        j                  | g|t         j
                  t         j                  t         j                  t         j                  t         j                  g      \  }\  } | g}d|d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       t        j                  |      }|S )Nr	  r$   s   Lur   rH   r  )rL   r  r0   r   rK   rM   rN   rO   rP   rQ   r   r4   r8   r  r   )rW   r	  r!   r"   rS   rB   rA   r<   s           rC   r  r  F  s    mmO&&8IJ/55ugsW__V]VeVegngsgsu|  vG  vG  IP  I[  I[  E^  _'8E,+_=&UAl&!$41'""$lFG-OOG$'	.rU   TV_MatrixDeterminant_Tz
linalg.detmatrix_determinantc           	      >   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d||       }|S t        | |fd      }|t        ur|S 	 t/        j0                  d| |      \  }}}}|dd }t3        j4                         r7d|j7                  d      f}	|j8                  }
t3        j:                  d|
|	|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |fd      }|t        ur|S t        | ||      S # t        j                  $ r Y t        t         f$ rH t#        j$                  t&        dt)        | |            }|t"        j*                  j,                  ur|cY S  w xY w# t        t         f$ rH t#        j$                  t&        dt)        | |            }|t"        j*                  j,                  ur|cY S  w xY w)a  Computes the determinant of one or more square matrices.

  The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
  form square matrices. The output is a tensor containing the determinants
  for all input submatrices `[..., :, :]`.

  Args:
    input: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `complex64`, `complex128`.
      Shape is `[..., M, M]`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  MatrixDeterminantNr[   r   r\   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   "_dispatcher_for_matrix_determinantr   !matrix_determinant_eager_fallbackr/   r   r   r   r   r  r   r   r   r2   r3   r0   r4   r6   r7   r8   r^   s              rC   r  r  X  s   & 
			0h..0$#\\11!40gn, 1	Gn$n	
)::5t5Aq#x QK'""$3%%c*+F::L\67<('	.W && -
##At,,## 
2$.$ g		&.
d& &## 
z" ""Du4$@g 
	..<<	<  Z	  
  
b$U">
G i,,:::n	
r   zraw_ops.MatrixDeterminantc           	      z   t        j                  | g|t        j                  t        j                  t        j
                  t        j                  t        j                  g      \  }\  } | g}d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   MatrixDeterminantrG   rH   r  )r0   rK   rL   rO   rN   rM   rP   rQ   r   r4   r8   rc   s          rC   r  r    s    55ugsW\\SZSbSbdkdsdsu|  vG  vG  IP  I[  I[  E^  _'8E,>&11\#)s?'""$\67<('	.rU   TV_MatrixExponential_Tc                 ~   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d||       }|S t        j                  d| |      \  }}}}|dd }t        j                          r7d|j#                  d      f}	|j$                  }
t        j&                  d|
|	|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||      S # t        j                  $ r Y w xY w)a,  Deprecated, use python implementation tf.linalg.matrix_exponential.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  MatrixExponentialNr[   r\   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   !matrix_exponential_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   r^   s              rC   matrix_exponentialr    s8    
			0h..0$#\\11!40gn (885t5!QXQK'""$3%%c*+F::L\67<('	.' && -
##At,,## 
.
d& &## 
r`   zraw_ops.MatrixExponentialc           	      z   t        j                  | g|t        j                  t        j                  t        j
                  t        j                  t        j                  g      \  }\  } | g}d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   MatrixExponentialrG   rH   r  r   rc   s          rC   r  r    s    55ugsW__V]VeVegngsgsu|  vG  vG  IP  I[  I[  E^  _'8E,>&11\#)s?'""$\67<('	.rU   TV_MatrixInverse_Tz
linalg.invmatrix_inversec           
         t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| d|      }|S t        | ||fd      }|t        ur|S |d}t/        j0                  |d      }	 t3        j4                  d| ||      \  }}}}	|	dd }t/        j6                         rHd|j9                  d      d|j;                  d      f}
|j<                  }t/        j>                  d||
|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||fd      }|t        ur|S t        | |||      S # t        j                  $ r Y )t        t         f$ rI t#        j$                  t&        dt)        | ||            }|t"        j*                  j,                  ur|cY S  w xY w# t        t         f$ rI t#        j$                  t&        dt)        | ||            }|t"        j*                  j,                  ur|cY S  w xY w)	a  Computes the inverse of one or more square invertible matrices or their adjoints (conjugate transposes).

  
  The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
  form square matrices. The output is a tensor of the same shape as the input
  containing the inverse for all input submatrices `[..., :, :]`.

  The op uses LU decomposition with partial pivoting to compute the inverses.

  If a matrix is not invertible there is no guarantee what the op does. It
  may detect the condition and raise an exception or it may simply return a
  garbage result.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
      Shape is `[..., M, M]`.
    adjoint: An optional `bool`. Defaults to `False`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  MatrixInverser   Nry   r   rz   Fr$   ) r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   _dispatcher_for_matrix_inverser   matrix_inverse_eager_fallbackr/   r   r   r   r   r  r   r   r   r0   r1   r2   r3   r4   r5   r6   r7   r8   r|   s               rC   r  r    s[   6 
			0h..0$#\\11otUIw@gn, -	'Gn$n_Gw	2'	
)::ugDBAq#x QK'""$++I6  %'F::Lvw8('	._ && -
##At,,## 
.'4
!4)g		&*
t7 7## 
z" ""B5' Mg 
	..<<	<& Z	  
  
"ddK
G i,,:::n	
sP    D G8 E(EEE F 9F G5AG53G58AIIzraw_ops.MatrixInversec           	         |d}t        j                  |d      }t        j                  | g|t        j                  t        j
                  t        j                  t        j                  t        j                  g      \  }\  } | g}d|d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )NFr   r$   s   MatrixInverserG   rH   r   rJ   r   s           rC   r"  r"  A  s    _Gw	2'55ugsW__V]VeVegngsgsu|  vG  vG  IP  I[  I[  E^  _'8E,wW-&-q#)s?'""$vw8('	.rU   TV_MatrixLogarithm_Tc                 ~   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d||       }|S t        j                  d| |      \  }}}}|dd }t        j                          r7d|j#                  d      f}	|j$                  }
t        j&                  d|
|	|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||      S # t        j                  $ r Y w xY w)a  Computes the matrix logarithm of one or more square matrices:

  
  \\(log(exp(A)) = A\\)

  This op is only defined for complex matrices. If A is positive-definite and
  real, then casting to a complex matrix, taking the logarithm and casting back
  to a real matrix will give the correct result.

  This function computes the matrix logarithm using the Schur-Parlett algorithm.
  Details of the algorithm can be found in Section 11.6.2 of:
  Nicholas J. Higham, Functions of Matrices: Theory and Computation, SIAM 2008.
  ISBN 978-0-898716-46-7.

  The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
  form square matrices. The output is a tensor of the same shape as the input
  containing the exponential for all input submatrices `[..., :, :]`.

  Args:
    input: A `Tensor`. Must be one of the following types: `complex64`, `complex128`.
      Shape is `[..., M, M]`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  MatrixLogarithmNr[   r\   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   matrix_logarithm_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   r^   s              rC   matrix_logarithmr(  S  s8   6 
			0h..0$#\\11u.gn (88T3!QXQK'""$3%%c*+F::L<:('	.' && -
##At,,## 
,
d& &## 
r`   zraw_ops.MatrixLogarithmc                     t        j                  | g|t        j                  t        j                  g      \  }\  } | g}d|f}t        j
                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   MatrixLogarithmrG   rH   r&  )r0   rK   rL   rP   rQ   r   r4   r8   rc   s          rC   r'  r'    s    55ugsWEVEVX_XjXjDmn'8E,>&/<#)s?'""$<:('	.rU   TV_MatrixSolve_Tzlinalg.solvematrix_solvec                    t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| |d|      }|S t        | |||fd      }|t        ur|S |d}t/        j0                  |d      }	 t3        j4                  d| |||      \  }}}	}
|
dd }t/        j6                         rHd|	j9                  d      d|	j;                  d      f}|	j<                  }t/        j>                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||fd      }|t        ur|S t        | ||||      S # t        j                  $ r Y ,t        t         f$ rJ t#        j$                  t&        dt)        | |||            }|t"        j*                  j,                  ur|cY S  w xY w# t        t         f$ rJ t#        j$                  t&        dt)        | |||            }|t"        j*                  j,                  ur|cY S  w xY w)	a  Solves systems of linear equations.

  `Matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
  form square matrices. `Rhs` is a tensor of shape `[..., M, K]`. The `output` is
  a tensor shape `[..., M, K]`.  If `adjoint` is `False` then each output matrix
  satisfies `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
  If `adjoint` is `True` then each output matrix satisfies
  `adjoint(matrix[..., :, :]) * output[..., :, :] = rhs[..., :, :]`.

  Args:
    matrix: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
      Shape is `[..., M, M]`.
    rhs: A `Tensor`. Must have the same type as `matrix`.
      Shape is `[..., M, K]`.
    adjoint: An optional `bool`. Defaults to `False`.
      Boolean indicating whether to solve with `matrix` or its (block-wise)
      adjoint.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `matrix`.
  MatrixSolver   Nry   r   r   Fr$   ) r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   _dispatcher_for_matrix_solver   matrix_solve_eager_fallbackr/   r   r   r   r   r+  r   r   r   r0   r1   r2   r3   r4   r5   r6   r7   r8   r   s                rC   r+  r+    so   6 
			0h..0$#\\11mT63	7Dgn. +	gt%t-Gn$n_Gw	2'

)::f#wTKAq#x QK'""$++I6  %'F::L|VW6('	.c && -
##At,,## 
,3
'/g		&(
#wTt= =## 
z" """d&c7(,.g 
	..<<	<( Z	  
  
DC&*,
G i,,:::n	
sP    D G> E+EEE#F =F G;#AG;9G;>AIIzraw_ops.MatrixSolvec           	         |d}t        j                  |d      }t        j                  | |g|t        j                  t        j
                  t        j                  t        j                  t        j                  g      \  }}|\  } }| |g}d|d|f}t        j                  dd||||      }	t        j                         rt        j                  d|||	       |	\  }	|	S )NFr   r$   s   MatrixSolverG   rH   r-  rJ   r   s
             rC   r/  r/    s    _Gw	2'66}cGOO]d]l]lnunznz  }D  }N  }N  PW  Pb  Pb  Le  f'9-63#,wW-&^Q|#)s?'""$|VW6('	.rU   TV_MatrixSolveLs_Tc           
         t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| ||d|      }|S |d}t        j                  |d      }t        j                   d| ||||      \  }	}	}
}|dd }t        j"                         rHd|
j%                  d      d|
j'                  d      f}|
j(                  }t        j*                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||||      S # t        j                  $ r Y w xY w)a	  Solves one or more linear least-squares problems.

  `matrix` is a tensor of shape `[..., M, N]` whose inner-most 2 dimensions
  form real or complex matrices of size `[M, N]`. `Rhs` is a tensor of the same
  type as `matrix` and shape `[..., M, K]`.
  The output is a tensor shape `[..., N, K]` where each output matrix solves
  each of the equations
  `matrix[..., :, :]` * `output[..., :, :]` = `rhs[..., :, :]`
  in the least squares sense.

  We use the following notation for (complex) matrix and right-hand sides
  in the batch:

  `matrix`=\\(A \in \mathbb{C}^{m \times n}\\),
  `rhs`=\\(B  \in \mathbb{C}^{m \times k}\\),
  `output`=\\(X  \in \mathbb{C}^{n \times k}\\),
  `l2_regularizer`=\\(\lambda \in \mathbb{R}\\).

  If `fast` is `True`, then the solution is computed by solving the normal
  equations using Cholesky decomposition. Specifically, if \\(m \ge n\\) then
  \\(X = (A^H A + \lambda I)^{-1} A^H B\\), which solves the least-squares
  problem \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k} } ||A Z - B||_F^2 + \lambda ||Z||_F^2\\).
  If \\(m \lt n\\) then `output` is computed as
  \\(X = A^H (A A^H + \lambda I)^{-1} B\\), which (for \\(\lambda = 0\\)) is the
  minimum-norm solution to the under-determined linear system, i.e.
  \\(X = \mathrm{argmin}_{Z \in \mathbb{C}^{n \times k} } ||Z||_F^2 \\),
  subject to \\(A Z = B\\). Notice that the fast path is only numerically stable
  when \\(A\\) is numerically full rank and has a condition number
  \\(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon_{mach} } }\\) or \\(\lambda\\) is
  sufficiently large.

  If `fast` is `False` an algorithm based on the numerically robust complete
  orthogonal decomposition is used. This computes the minimum-norm
  least-squares solution, even when \\(A\\) is rank deficient. This path is
  typically 6-7 times slower than the fast path. If `fast` is `False` then
  `l2_regularizer` is ignored.

  Args:
    matrix: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
      Shape is `[..., M, N]`.
    rhs: A `Tensor`. Must have the same type as `matrix`.
      Shape is `[..., M, K]`.
    l2_regularizer: A `Tensor` of type `float64`. Scalar tensor.

      @compatibility(numpy)
      Equivalent to np.linalg.lstsq
      @end_compatibility
    fast: An optional `bool`. Defaults to `True`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `matrix`.
  MatrixSolveLsr   Nr   Tr   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   matrix_solve_ls_eager_fallbackr/   r0   r1   r2   r3   r4   r6   r5   r7   r8   r   s                 rC   matrix_solve_lsr5    s   l 
			0h..0$#\\11otVS.&g n 
\D			D&	)$'88C(6TN!QX QK'""$3%%c*F  (*F::Lvw8('	.1 && -
##At,,## 
+
#~DtG G## 
r   zraw_ops.MatrixSolveLsc           	         |d}t        j                  |d      }t        j                  | |g|t        j                  t        j
                  t        j                  t        j                  t        j                  g      \  }}|\  } }t        j                  |t        j                        }| ||g}d|d|f}	t        j                  dd||	||      }
t        j                         rt        j                  d||	|
       |
\  }
|
S )NTr   r$   s   MatrixSolveLsrG   rH   r3  )r0   r1   rK   rL   rM   rN   rO   rP   rQ   r+   r   r   r4   r8   r   s              rC   r4  r4  c  s   	\D			D&	)$66}cGOO]d]l]lnunznz  }D  }N  }N  PW  Pb  Pb  Le  f'9-63)).'//J.#~.,&$'&-q#)s?'""$vw8('	.rU   TV_MatrixSquareRoot_Tzlinalg.sqrtmmatrix_square_rootc           	      >   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d||       }|S t        | |fd      }|t        ur|S 	 t/        j0                  d| |      \  }}}}|dd }t3        j4                         r7d|j7                  d      f}	|j8                  }
t3        j:                  d|
|	|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |fd      }|t        ur|S t        | ||      S # t        j                  $ r Y t        t         f$ rH t#        j$                  t&        dt)        | |            }|t"        j*                  j,                  ur|cY S  w xY w# t        t         f$ rH t#        j$                  t&        dt)        | |            }|t"        j*                  j,                  ur|cY S  w xY w)ag  Computes the matrix square root of one or more square matrices:

  matmul(sqrtm(A), sqrtm(A)) = A

  The input matrix should be invertible. If the input matrix is real, it should
  have no eigenvalues which are real and negative (pairs of complex conjugate
  eigenvalues are allowed).

  The matrix square root is computed by first reducing the matrix to
  quasi-triangular form with the real Schur decomposition. The square root
  of the quasi-triangular matrix is then computed directly. Details of
  the algorithm can be found in: Nicholas J. Higham, "Computing real
  square roots of a real matrix", Linear Algebra Appl., 1987.

  The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
  form square matrices. The output is a tensor of the same shape as the input
  containing the matrix square root for all input submatrices `[..., :, :]`.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
      Shape is `[..., M, M]`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  MatrixSquareRootNr[   r   r\   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   "_dispatcher_for_matrix_square_rootr   !matrix_square_root_eager_fallbackr/   r   r   r   r   r8  r   r   r   r2   r3   r0   r4   r6   r7   r8   r^   s              rC   r8  r8  w  s   < 
			0h..0$#\\11 $/gn, 1	Gn$n	
)::%d4Aq#x QK'""$3%%c*+F::LL&';('	.W && -
##At,,## 
2$.$ g		&.
d& &## 
z" ""Du4$@g 
	..<<	<  Z	  
  
b$U">
G i,,:::n	
r   zraw_ops.MatrixSquareRootc           	      z   t        j                  | g|t        j                  t        j                  t        j
                  t        j                  t        j                  g      \  }\  } | g}d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   MatrixSquareRootrG   rH   r:  r   rc   s          rC   r<  r<    s    55ugsW__V]VeVegngsgsu|  vG  vG  IP  I[  I[  E^  _'8E,>&0!L#)s?'""$L&';('	.rU   TV_MatrixTriangularSolve_Tr   c                 B   t         j                   xs t        j                         }|j                  }|j                  r 	 t	        j
                  |d|| |d|d|	      }|S |d}t        j                  |d      }|d}t        j                  |d      }t        j                   d| ||||      \  }	}	}
}|dd }t        j"                         rYd|
j%                  d      d|
j%                  d      d	|
j'                  d	      f}|
j(                  }t        j*                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||||      S # t        j                  $ r Y >w xY w)
a	  Solves systems of linear equations with upper or lower triangular matrices by backsubstitution.

  
  `matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
  square matrices. If `lower` is `True` then the strictly upper triangular part
  of each inner-most matrix is assumed to be zero and not accessed.
  If `lower` is False then the strictly lower triangular part of each inner-most
  matrix is assumed to be zero and not accessed.
  `rhs` is a tensor of shape `[..., M, N]`.

  The output is a tensor of shape `[..., M, N]`. If `adjoint` is
  `True` then the innermost matrices in `output` satisfy matrix equations
  `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
  If `adjoint` is `False` then the strictly then the  innermost matrices in
  `output` satisfy matrix equations
  `adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`.

  Note, the batch shapes for the inputs only need to broadcast.

  Example:
  ```python

  a = tf.constant([[3,  0,  0,  0],
                   [2,  1,  0,  0],
                   [1,  0,  1,  0],
                   [1,  1,  1,  1]], dtype=tf.float32)

  b = tf.constant([[4],
                   [2],
                   [4],
                   [2]], dtype=tf.float32)

  x = tf.linalg.triangular_solve(a, b, lower=True)
  x
  # <tf.Tensor: shape=(4, 1), dtype=float32, numpy=
  # array([[ 1.3333334 ],
  #        [-0.66666675],
  #        [ 2.6666665 ],
  #        [-1.3333331 ]], dtype=float32)>

  # in python3 one can use `a@x`
  tf.matmul(a, x)
  # <tf.Tensor: shape=(4, 1), dtype=float32, numpy=
  # array([[4.       ],
  #        [2.       ],
  #        [4.       ],
  #        [1.9999999]], dtype=float32)>
  ```

  Args:
    matrix: A `Tensor`. Must be one of the following types: `bfloat16`, `float64`, `float32`, `half`, `complex64`, `complex128`.
      Shape is `[..., M, M]`.
    rhs: A `Tensor`. Must have the same type as `matrix`.
      Shape is `[..., M, K]`.
    lower: An optional `bool`. Defaults to `True`.
      Boolean indicating whether the innermost matrices in `matrix` are
      lower or upper triangular.
    adjoint: An optional `bool`. Defaults to `False`.
      Boolean indicating whether to solve with `matrix` or its (block-wise)
               adjoint.

      @compatibility(numpy)
      Equivalent to scipy.linalg.solve_triangular
      @end_compatibility
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `matrix`.
  MatrixTriangularSolver   r   Nr    TFr#   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   &matrix_triangular_solve_eager_fallbackr/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   s                 rC   matrix_triangular_solverB    s   L 
			0h..0$#\\11%tVS'57g n ]E


UG
,%_Gw	2''88Cu)0t=!QX QK'""$s))'2I  +S#2D2DS2IKF::Lvw@('	.7 && -
##At,,## 
3
#UG$DJ J## 
rE   zraw_ops.MatrixTriangularSolvec           
         |d}t        j                  |d      }|d}t        j                  |d      }t        j                  | |g|t        j                  t        j
                  t        j                  t        j                  t        j                  t        j                  g      \  }}|\  } }| |g}d|d|d|f}	t        j                  dd||	||      }
t        j                         rt        j                  d	||	|
       |
\  }
|
S )
NTr   Fr   r$   s   MatrixTriangularSolverG   rH   r@  )r0   r1   rK   rL   bfloat16rM   rN   rO   rP   rQ   r   r4   r8   rR   s              rC   rA  rA  J  s*   
]E


UG
,%_Gw	2'66}cGL\L\^e^m^movo~o~  AH  AM  AM  OV  O`  O`  bi  bt  bt  Lw  x'9-63#,UIwW=&5q#)s?'""$vw@('	.rU   QrqrTV_Qr_Tz	linalg.qrqrc           
         t         j                   xs t        j                         }|j                  }|j                  r2	 t	        j
                  |d|| d|      }t        j                  |      }|S t        | ||fd      }|t        ur|S |d}t3        j4                  |d      }	 t7        j8                  d| ||      \  }}}}	|	dd }t3        j:                         rHd|j=                  d      d|j?                  d      f}
|j@                  }t3        jB                  d||
|       t        j                  |      }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||fd      }|t        ur|S t        | |||      S # t        j                   $ r Y :t"        t$        f$ rI t'        j(                  t*        dt-        | ||            }|t&        j.                  j0                  ur|cY S  w xY w# t"        t$        f$ rI t'        j(                  t*        dt-        | ||            }|t&        j.                  j0                  ur|cY S  w xY w)	a  Computes the QR decompositions of one or more matrices.

  Computes the QR decomposition of each inner matrix in `tensor` such that
  `tensor[..., :, :] = q[..., :, :] * r[..., :,:])`

  Currently, the gradient for the QR decomposition is well-defined only when
  the first `P` columns of the inner matrix are linearly independent, where
  `P` is the minimum of `M` and `N`, the 2 inner-most dimmensions of `tensor`.

  ```python
  # a is a tensor.
  # q is a tensor of orthonormal matrices.
  # r is a tensor of upper triangular matrices.
  q, r = qr(a)
  q_full, r_full = qr(a, full_matrices=True)
  ```

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
      A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
      form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
    full_matrices: An optional `bool`. Defaults to `False`.
      If true, compute full-sized `q` and `r`. If false
      (the default), compute only the leading `P` columns of `q`.
    name: A name for the operation (optional).

  Returns:
    A tuple of `Tensor` objects (q, r).

    q: A `Tensor`. Has the same type as `input`.
    r: A `Tensor`. Has the same type as `input`.
  rE  r   N)r   r!   r"   r   )rW   r   r!   Fr$   )"r%   r   r&   r'   r   r(   	_QrOutputr   r)   r*   r+   r,   r-   _dispatcher_for_qrr   qr_eager_fallbackr/   r   r   r   r   rI  r   r   r   r0   r1   r2   r3   r4   r5   r6   r7   r8   )rW   r   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s               rC   rI  rI  d  st   J 
			0h..0$#\\11dD%-Ag(gn, !	t%t-Gn$nM$$]OD-	
)::ETCAq#x QK'""$s11/BC  %'F::LlFG-OOG$'	._ && -
##At,,## 
"-
'/g		&
}4TC C## 
z" ""DuMMg 
	..<<	<& Z	  
  
b$U-dK
G i,,:::n	
sP    0D; %H ;FE))FFF. F. .HAHHAI64I6z
raw_ops.Qrc           	         |d}t        j                  |d      }t        j                  | g|t        j                  t        j
                  t        j                  t        j                  t        j                  g      \  }\  } | g}d|d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       t        j                  |      }|S )NFr   r$   s   Qrr   rH   rE  )r0   r1   rK   rL   rM   rN   rO   rP   rQ   r   r4   r8   rK  r   )rW   r   r!   r"   rS   rB   rA   r<   s           rC   rM  rM    s    M$$]OD-55ugsW__V]VeVegngsgsu|  vG  vG  IP  I[  I[  E^  _'8E,]C9&UAl&!$41'""$lFG-OOG$'	.rU   TV_SelfAdjointEig_Tc                 ~   t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d||       }|S t        j                  d| |      \  }}}}|dd }t        j                          r7d|j#                  d      f}	|j$                  }
t        j&                  d|
|	|       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||      S # t        j                  $ r Y w xY w)a  Computes the Eigen Decomposition of a batch of square self-adjoint matrices.

  The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
  form square matrices, with the same constraints as the single matrix
  SelfAdjointEig.

  The result is a [..., M+1, M] matrix with [..., 0,:] containing the
  eigenvalues, and subsequent [...,1:, :] containing the eigenvectors. The eigenvalues
  are sorted in non-decreasing order.

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`.
      Shape is `[..., M, M]`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `input`.
  SelfAdjointEigNr[   r\   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   self_adjoint_eig_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   r^   s              rC   self_adjoint_eigrS    s8   & 
			0h..0$#\\11e-gn (88D2!QXQK'""$3%%c*+F::L,9('	.' && -
##At,,## 
,
d& &## 
r`   zraw_ops.SelfAdjointEigc                 >   t        j                  | g|t        j                  t        j                  t        j
                  g      \  }\  } | g}d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       |\  }|S )Nr$   s   SelfAdjointEigrG   rH   rQ  )	r0   rK   rL   rM   rN   rO   r   r4   r8   rc   s          rC   rR  rR  
	  s    55ugsW__V]VeVegngsgsDvw'8E,>&.,#)s?'""$,9('	.rU   SelfAdjointEigV2TV_SelfAdjointEigV2_Tc                 *   t         j                   xs t        j                         }|j                  }|j                  r2	 t	        j
                  |d|| d|      }t        j                  |      }|S |d}t        j                   |d      }t#        j$                  d| ||      \  }}}}	|	dd }t        j&                         rHd|j)                  d      d|j+                  d      f}
|j,                  }t        j.                  d||
|       t        j                  |      }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||      S # t        j                  $ r Y  w xY w)a  Computes the eigen decomposition of one or more square self-adjoint matrices.

  Computes the eigenvalues and (optionally) eigenvectors of each inner matrix in
  `input` such that `input[..., :, :] = v[..., :, :] * diag(e[..., :])`. The eigenvalues
  are sorted in non-decreasing order.

  ```python
  # a is a tensor.
  # e is a tensor of eigenvalues.
  # v is a tensor of eigenvectors.
  e, v = self_adjoint_eig(a)
  e = self_adjoint_eig(a, compute_v=False)
  ```

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
      `Tensor` input of shape `[N, N]`.
    compute_v: An optional `bool`. Defaults to `True`.
      If `True` then eigenvectors will be computed and returned in `v`.
      Otherwise, only the eigenvalues will be computed.
    name: A name for the operation (optional).

  Returns:
    A tuple of `Tensor` objects (e, v).

    e: A `Tensor`. Has the same type as `input`.
    v: A `Tensor`. Has the same type as `input`.
  rU  r   Nr   Tr   r$   )r%   r   r&   r'   r   r(   _SelfAdjointEigV2Outputr   r)   r*   r+   r,   r-   "self_adjoint_eig_v2_eager_fallbackr/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r   s               rC   self_adjoint_eig_v2rZ  	  s   : 
			0h..0$#\\11 ${IGg'--g6gn I  K8)'88%94I!QXQK'""$3--k:C  %'F::LL&';#))'2'	./ && -
##At,,## 
/
94T; ;## 
r   zraw_ops.SelfAdjointEigV2c           	         |d}t        j                  |d      }t        j                  | g|t        j                  t        j
                  t        j                  t        j                  t        j                  g      \  }\  } | g}d|d|f}t        j                  dd||||      }t        j                         rt        j                  d|||       t        j                  |      }|S )NTr   r$   s   SelfAdjointEigV2r   rH   rU  )r0   r1   rK   rL   rM   rN   rO   rP   rQ   r   r4   r8   rX  r   r   s           rC   rY  rY  ^	  s    I  K8)55ugsW__V]VeVegngsgsu|  vG  vG  IP  I[  I[  E^  _'8E,C1&0!L#)s?'""$L&';#))'2'	.rU   SvdTV_Svd_Tc           
         t         j                   xs t        j                         }|j                  }|j                  r4	 t	        j
                  |d|| d|d|      }t        j                  |      }|S |d}t        j                   |d      }|d}t        j                   |d      }t#        j$                  d| |||      \  }}}	}
|
dd }t        j&                         rYd|	j)                  d      d|	j)                  d      d	|	j+                  d	      f}|	j,                  }t        j.                  d|||       t        j                  |      }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | ||||      S # t        j                  $ r Y Mw xY w)
a  Computes the singular value decompositions of one or more matrices.

  Computes the SVD of each inner matrix in `input` such that
  `input[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :, :])`

  ```python
  # a is a tensor containing a batch of matrices.
  # s is a tensor of singular values for each matrix.
  # u is the tensor containing the left singular vectors for each matrix.
  # v is the tensor containing the right singular vectors for each matrix.
  s, u, v = svd(a)
  s, _, _ = svd(a, compute_uv=False)
  ```

  Args:
    input: A `Tensor`. Must be one of the following types: `float64`, `float32`, `half`, `complex64`, `complex128`.
      A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
      form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
    compute_uv: An optional `bool`. Defaults to `True`.
      If true, left and right singular vectors will be
      computed and returned in `u` and `v`, respectively.
      If false, `u` and `v` are not set and should never referenced.
    full_matrices: An optional `bool`. Defaults to `False`.
      If true, compute full-sized `u` and `v`. If false
      (the default), compute only the leading `P` singular vectors.
      Ignored if `compute_uv` is `False`.
    name: A name for the operation (optional).

  Returns:
    A tuple of `Tensor` objects (s, u, v).

    s: A `Tensor`. Has the same type as `input`.
    u: A `Tensor`. Has the same type as `input`.
    v: A `Tensor`. Has the same type as `input`.
  r\  r   r   Nr   TFr   r$   )r%   r   r&   r'   r   r(   
_SvdOutputr   r)   r*   r+   r,   r-   svd_eager_fallbackr/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r   s                rC   svdra  t	  s   H 
			0h..0$#\\	11eT5,
Og   )gn J!!*l;*M$$]OD-'88Uz*7!QX QK'""$C..|<o  13  %'F ::L|VW.W%'	.; && -
##At,,## 

Jm  ## 
r   zraw_ops.Svdc           	         |d}t        j                  |d      }|d}t        j                  |d      }t        j                  | g|t        j                  t        j
                  t        j                  t        j                  t        j                  g      \  }\  } | g}d|d|d|f}t        j                  dd||||      }t        j                         rt        j                  d	|||       t        j                  |      }|S )
NTr   Fr   r$   s   Svdr   rH   r\  )r0   r1   rK   rL   rM   rN   rO   rP   rQ   r   r4   r8   r_  r   r   s	            rC   r`  r`  	  s   J!!*l;*M$$]OD-55ugsW__V]VeVegngsgsu|  vG  vG  IP  I[  I[  E^  _'8E,*o}c	&VQ|6!$41'""$|VW.W%'	.rU   TV_TridiagonalMatMul_T	superdiagmaindiagsubdiagc           	         t         j                   xs t        j                         }|j                  }|j                  r	 t	        j
                  |d|| |||      }|S t        j                  d| ||||      \  }	}	}
}|dd }t        j                          r7d|
j#                  d      f}|
j$                  }t        j&                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||||      S # t        j                  $ r Y w xY w)a8  Calculate product with tridiagonal matrix.

  Calculates product of two matrices, where left matrix is a tridiagonal matrix.

  Args:
    superdiag: A `Tensor`. Must be one of the following types: `float64`, `float32`, `complex64`, `complex128`.
      Tensor of shape `[..., 1, M]`, representing superdiagonals of
      tri-diagonal matrices to the left of multiplication. Last element is ignored.
    maindiag: A `Tensor`. Must have the same type as `superdiag`.
      Tensor of shape `[..., 1, M]`, representing main diagonals of tri-diagonal
      matrices to the left of multiplication.
    subdiag: A `Tensor`. Must have the same type as `superdiag`.
      Tensor of shape `[..., 1, M]`, representing subdiagonals of tri-diagonal
      matrices to the left of multiplication. First element is ignored.
    rhs: A `Tensor`. Must have the same type as `superdiag`.
      Tensor of shape `[..., M, N]`, representing MxN matrices to the right of
      multiplication.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `superdiag`.
  TridiagonalMatMulNr[   )rd  re  rf  r   r!   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-   "tridiagonal_mat_mul_eager_fallbackr/   r2   r3   r0   r4   r6   r7   r8   )rd  re  rf  r   r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s                 rC   tridiagonal_mat_mulrj  	  sQ   . 
			0h..0$#\\11!4HgsLgn (88y8%,#DB!QX QK'""$3%%c*+F::L\67<('	.) && -
##At,,## 
/
Xw$DB B## 
s0    C D&DDDD/ /EEzraw_ops.TridiagonalMatMulc                 r   t        j                  | |||g|t        j                  t        j                  t        j
                  t        j                  g      \  }}|\  } }}}| |||g}d|f}	t        j                  dd||	||      }
t        j                         rt        j                  d||	|
       |
\  }
|
S )Nr$   s   TridiagonalMatMulrG   rH   rh  )
r0   rK   rL   rM   rN   rP   rQ   r   r4   r8   )rd  re  rf  r   r!   r"   rS   rT   rB   rA   r<   s              rC   ri  ri  
  s    66	8WVY7Z\_bibqbqsz  tC  tC  EL  EV  EV  X_  Xj  Xj  bm  n'9(1%9hXw4,>&11\#)s?'""$\67<('	.rU   TV_TridiagonalSolve_T	diagonalspartial_pivotingperturb_singularc                 B   t         j                   xs t        j                         }|j                  }|j                  r 	 t	        j
                  |d|| |d|d|	      }|S |d}t        j                  |d      }|d}t        j                  |d      }t        j                   d| ||||      \  }	}	}
}|dd }t        j"                         rYd|
j%                  d      d|
j%                  d      d	|
j'                  d	      f}|
j(                  }t        j*                  d|||       |\  }|S # t        j                  $ r }t        j                  ||       Y d}~nd}~wt        j                  $ r Y nw xY w	 t        | |||||      S # t        j                  $ r Y >w xY w)
ao  Solves tridiagonal systems of equations.

    Solves tridiagonal systems of equations.
    Supports batch dimensions and multiple right-hand sides per each left-hand
    side.
    On CPU, solution is computed via Gaussian elimination with or without partial
    pivoting, depending on `partial_pivoting` attribute. On GPU, Nvidia's cuSPARSE
    library is used: https://docs.nvidia.com/cuda/cusparse/index.html#gtsv
    Partial pivoting is not yet supported by XLA backends.

  Args:
    diagonals: A `Tensor`. Must be one of the following types: `float64`, `float32`, `complex64`, `complex128`.
      Tensor of shape `[..., 3, M]` whose innermost 2 dimensions represent the
      tridiagonal matrices with three rows being the superdiagonal, diagonals, and
      subdiagonals, in order. The last element of the superdiagonal and the first
      element of the subdiagonal is ignored.
    rhs: A `Tensor`. Must have the same type as `diagonals`.
      Tensor of shape `[..., M, K]`, representing K right-hand sides per each
      left-hand side.
    partial_pivoting: An optional `bool`. Defaults to `True`.
      Whether to apply partial pivoting. Partial pivoting makes the procedure more
      stable, but slower.
    perturb_singular: An optional `bool`. Defaults to `False`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `diagonals`.
  TridiagonalSolvern  ro  N)rn  ro  r!   r"   TF)rm  r   rn  ro  r!   r$   )r%   r   r&   r'   r   r(   r)   r*   r+   r,   r-    tridiagonal_solve_eager_fallbackr/   r0   r1   r2   r3   r4   r5   r6   r7   r8   )rm  r   rn  ro  r!   r:   r;   r<   r=   r>   r?   r@   rA   rB   s                 rC   tridiagonal_solvers   
  s   : 
			0h..0$#\\11 $	38J,.>@g n ''(8:LM''(8:LM'88iS-=-=DJ!QX QK'""$ #"4"45G"H #"4"45G"H#  %'F ::LL&';('	.= && -
##At,,## 
-
S+;+$DB B ## 
rE   zraw_ops.TridiagonalSolvec                    |d}t        j                  |d      }|d}t        j                  |d      }t        j                  | |g|t        j                  t        j
                  t        j                  t        j                  g      \  }}|\  } }| |g}d|d|d|f}	t        j                  dd||	||      }
t        j                         rt        j                  d	||	|
       |
\  }
|
S )
NTrn  Fro  r$   s   TridiagonalSolverG   rH   rq  )r0   r1   rK   rL   rM   rN   rP   rQ   r   r4   r8   )rm  r   rn  ro  r!   r"   rS   rT   rB   rA   r<   s              rC   rr  rr  h
  s   ''(8:LM''(8:LM66	37Gw`g`o`oqx  rC  rC  EL  EW  EW  OZ  ['99cS!, 02DC"&0!L#)s?'""$L&';('	.rU   )TFN)N)FN)TN)__doc__collectionstensorflow.pythonr   tensorflow.python.eagerr   r%   r   r)   r   r0   tensorflow.python.frameworkr   rL   tensorflow.security.fuzzing.pyr   _atypesr	   _op_def_registryr
   r+   r   r2   "tensorflow.python.util.deprecationr   tensorflow.python.utilr   r    tensorflow.python.util.tf_exportr   typingr   r   r   typing_extensionsr   r   boolrD   	to_raw_opr   r.   rV   r_   rZ   r]   rd   rl   rh   rj   rp   rt   rr   rs   rv   r}   rx   r{   r   r   r   r   r   Float64r   r   r   r   r   r   r   r   r   r   r   
namedtupler   r   r   r   r   r   r   r   r   r   r   add_fallback_dispatch_listadd_type_based_api_dispatcherr   r   _tf_type_based_dispatcherDispatchr   r   r   r   r   r   r   r   r   r   r   r   r   strr   r   r   r   r   r  r   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r!  r"  r$  r(  r&  r'  r*  r+  r-  r.  r/  r1  r5  r3  r4  r7  r8  r:  r;  r<  r>  rB  r@  rA  rK  rH  rI  rE  rL  rM  rO  rS  rQ  rR  rX  rV  rZ  rU  rY  r_  r]  ra  r\  r`  rc  rj  rh  ri  rl  rs  rq  rr  r   rU   rC   <module>r     s  
  6 7 1 7 9 F K 3 I C 8 6 % % '$%ACWYln  BS  Uc  d 0Ic3M.M$N 0U^_bd~_~U 0  HL 0  [_ 0  u~  B  D^  ^  u_ 0d C	"AB>4>>RiCjk 9SB\=\3] dmnq  tN  oN  eO   X\   gk   {D  EH  Jd  Ed  {e ( 13DFWX $)C);$;< $IVY[mVmLn $L 3	12>4>>.3QR
38J3J)K 
[dehj|e|[} 
 !!9;LN_` %9S*@%@A %SVXnSnIo %  @I  JM  Oe  Je  @f %N ;I9:>4>>J];^_ )C9O4O*P Xabeg}b}X~   OX  Y\  ^t  Yt  Ou  &&CEY[n  qB  DU  V $Ic3N.N$O $_hil  oJ  jJ  `K $L E#CD^T^^TlEmn 9SB]=]3^ nwx{  ~Y  yY  oZ  "";=NPab )	#/F*F G )QU )ktux  {R  vR  lS )V =Y;<^T^^L`=ab y>U9U/V ae u~  @C  E\  @\  v]     79JL]^ +y.C)CD +9UXZoUoKp +z~ +  U^  _b  dy  _y  Uz +Z 9978HZ9[\ i=R8R.S Zcdgi~d~Z   KO   _h  il  nC  iC  _D " "";=NPab .)C1H,H"I .PYZ]_vZvPw .  JS  TW  Y`  Yh  Yh  Th  Ji .  pt .  IR  SV  Xo  So  Ip .` =Y;<^T^^La=bc 3@W;W1X _hil  oF  jF  `G   Yb  cf  ho  hw  hw  cw  Yx   @D   T]  ^a  cz  ^z  T{ $ #**KM^`q"r 0)C9X4X*Y 0`ijm  pO  kO  aP 0  X\ 0  ko 0  EN  OR  Ts  Os  Et 0d MY'KL^T^^\yMz{ 3HgCg9h oxy|  ^  z^  p_   hl   w{   KT  UX  Zy  Uy  Kz * ##=?PRcd $)C1I,I"J $Zcdg  jB  eB  [C $L ?i =>~t~~Nd?ef 
3@X;X1Y 
irsv  yQ  tQ  jR 
  6{55#J  
 %%ACTVgh -Ys4N/N%O -[_ -^ C	"AB>4>>RkClm IcC]>]4^ ko  )+((
 )=?RTegxy6YsM12 6t 6X\ 6p )9'(	)BCIc=.@$A t dh ( )=?RTegx  {I  J
%%
((
"3Z!@Aj!KIc=01 K3P]K]A^ K " B ) &KZ )9'()AB#==FF 
9S--?#@ 
PYZ]_lZlPm 
 /1BDUWef .Ys$556 .iM^H^>_ .oxy|  P  zP  pQ .` 1y/01NOIc3D.D$E YWZ\mWmMn   H  IL  N_  I_  `  $[##	#J

 :35HJ[]nom%9;NO>yh' >{ >d >@ i~t~~c23iX6 k VZ "   z	z9T#Y34 z zS\]`bm]mSn zx 
%#	$^T^^F%;	<)DI{,B"C s bkloq|l|b} $ 5k44"#% 
 $$?AUWjl}  @Q  Sa  b 3)C1J,J"K 3j Ay!?@PfAgh 
3@Y;Y1Z 
 #K""	3K	
 )13FHY[ln|
} 7/Z 
%%
((
;MT]]ae [iW% [7L [  ) &[z Y|^T^^B/011:: YsG|4 G\   !!9;OQdfw  zK  M[  \ 
%%
((
<\+?@A*+Ai-C(CD AT]^acy^yTz A , B ) &AF ;I9:>4>>J\;]^ %7%Q%Q%Z%Z "
Ys<R7R-S 
clmp  sI  nI  dJ 
 !!9;OQdfw  zK  M[  \ $i-C(CD $T]^acy^yTz $L ;I9:>4>>J\;]^ 
Ys<R7R-S 
clmp  sI  nI  dJ 
 13GI\^o  rC  ES  T 
%%
((
<\+;<=&'M)C);$;< Md M`ijm  pB  kB  aC M ( > ) &M^ 3	12>4>>.3QR!/!I!I!R!R 38J3J)K VZ jstw  zL  uL  kM   57KM`a 5Ic+?&?@ 5PYZ]_sZsPt 5n 7)56~t~~FV7WX
9S:N5N+O 
_hil  oC  jC  `D 
 -/CEXZkm~  AO  P 
%%
((
>~~>?n%O3(8#89 O	#O_J_@` Ojn O  EN  OR  Td  Od  Ee O & @ ) &Ob /i-.~t~~l/KL+EENN 	#7G2G(H yY\^nYnOo z~   OX  Y\  ^n  Yn  Oo " 13GI\^o  rC  ES  T VIc+=&=> VYsTfOfEg V  zC  DG  IP  IX  IX  DX  zY V  `d V  yB  CF  HZ  CZ  y[ Vp 3	12>4>>/3RS9S:L5L+M T]^acu^uTv   IR  SV  X_  Xg  Xg  Sg  Ih   pt   DM  NQ  Se  Ne  Df $   79MObdu  xI  KY  Z 
%%
((
>/0Mi-B(BC MS\]`bw]wSx M 1 ) &M^ 9978HZ9[\ %7%Q%Q%Z%Z "
Ys<Q7Q-R 
bklo  rG  mG  cH 
 %%ACUWk  nA  CT  Vg  iw  x iIc3M.M$N iU^_bd~_~U i  HL i  [_ i  u~  B  D^  ^  u_ iV C	"AB>4>>RiCjk 9SB\=\3] dmnq  tN  oN  eO   X\   gk   {D  EH  Jd  Ed  {e & #K""#J	
 )13FHY[ln|
}
%%
((
;K./dXiW% XT X  0 ) &Xt Y|^T^^B/011:: YsG|4 T   35FHY[ij -Ic+>&>? -yY\^qYqOr -^ 534^T^^DT5UV
9S:M5M+N 
^ghk  nA  iA  _B 
 1+00#J 
   79MObdu  xI  KY  Z <y.C)CD <PT <| 9978H[9\] i=R8R.S `d  $[##	

 :35HJ[]np~Jyh' JD JT JX i~t~~c23iX6 D Y] ( !!9;OQdfw  zK  L 29S2H-H#I 2U^_bdz_zU{ 2  GP  QT  Vl  Ql  Gm 2  t}  ~A  CY  ~Y  tZ 2  js  tw  yO  tO  jP 2h ;I9:>4>>J];^_ )CAW<W2X dmnq  tJ  oJ  eK   V_  `c  e{  `{  V|   CL  MP  Rh  Mh  Ci   yB  CF  H^  C^  y_    79MObdu  xI  J C30E+E!F CYWZ\qWqMr C  FJ C  bf C  |E  FI  K`  F`  |a CJ 9978HY9Z[ 	#?T:T0U \efi  lA  gA  ]B   VZ   nr   BK  LO  Qf  Lf  Bg rU   