
    AVhq                        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ddd	      Z$ejJ                  ejL                   ed      d>de#e!e$f   de#e!e$f   de#e!e$f   fd                     Z'  ed       ejP                  e'            Z)e'jT                  jV                  Z,de#e!e$f   de#e!e$f   de#e!e$f   fd Z- ed!dddddddd	      Z.ejJ                  ejL                   ed"      d>de#e!e.f   de#e!e.f   de#e!e.f   fd#                     Z/  ed$       ejP                  e/            Z0e/jT                  jV                  Z1de#e!e.f   de#e!e.f   de#e!e.f   fd%Z2 ed&dddddddd	      Z3ejJ                  ejL                   ed'      d>de#e!e3f   de#e!e3f   de#e!e3f   fd(                     Z4  ed)       ejP                  e4            Z5e4jT                  jV                  Z6de#e!e3f   de#e!e3f   de#e!e3f   fd*Z7 ed+dddddddd	      Z8ejJ                  ejL                   ed,      d>de#e!e8f   de#e!e8f   fd-                     Z9  ed.       ejP                  e9            Z:e9jT                  jV                  Z;de#e!e8f   de#e!e8f   fd/Z< ed0dddddddd	      Z=ejJ                  ejL                   ed1      d>de#e!e=f   de#e!e=f   de#e!e=f   fd2                     Z>  ed3       ejP                  e>            Z?e>jT                  jV                  Z@de#e!e=f   de#e!e=f   de#e!e=f   fd4ZA ed5dddddddd	      ZBd>de#e!eBf   de#e!ej                  f   fd6ZD  ed7       ejP                  eD            ZEde#e!eBf   de#e!ej                  f   fd8ZF ed9dddddddd	      ZGejJ                  ejL                   ed:      d>de#e!eGf   de#e!eGf   de#e!eGf   fd;                     ZH  ed<       ejP                  eH            ZIeHjT                  jV                  ZJde#e!eGf   de#e!eGf   de#e!eGf   fd=ZKy)?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_BitwiseAnd_Tz_atypes.Int16z_atypes.Int32z_atypes.Int64z_atypes.Int8z_atypes.UInt16z_atypes.UInt32z_atypes.UInt64z_atypes.UInt8zbitwise.bitwise_andxyreturnc           
      L   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$ 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  Elementwise computes the bitwise AND of `x` and `y`.

  The result will have those bits set, that are set in both `x` and `y`. The
  computation is performed on the underlying representations of `x` and `y`.

  For example:

  ```python
  import tensorflow as tf
  from tensorflow.python.ops import bitwise_ops
  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
                tf.uint8, tf.uint16, tf.uint32, tf.uint64]

  for dtype in dtype_list:
    lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
    exp = tf.constant([0, 0, 3, 10], dtype=tf.float32)

    res = bitwise_ops.bitwise_and(lhs, rhs)
    tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE
  ```

  Args:
    x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
    y: A `Tensor`. Must have the same type as `x`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `x`.
  
BitwiseAndNnamectx r   r   r   T)_contextr   _thread_local_datais_eagerr   TFE_Py_FastPathExecute_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException_dispatcher_for_bitwise_andNotImplementedbitwise_and_eager_fallback_SymbolicException	TypeError
ValueError	_dispatchr   bitwise_anddictOpDispatcherNOT_SUPPORTED_op_def_library_apply_op_helper_executemust_record_gradient_get_attr_typeinputsrecord_gradientr   r   r   _ctxtld_resulte__op_outputs_attrs_inputs_flats               U/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/gen_bitwise_ops.pyr/   r/      (   D 
			0h..0$#\\11lD!Q(gn, *	
AttGn$n	
)::QT+Aq#x QK'""$3%%c*+F::LlFG5('	.W && -
##At,,## 
+a-g		&'
QTt% %## 
z" ""TA6g 
	..<<	<  Z	  
  
r4!qt4
G i,,:::n	
P    C) 5G )D0<DD0/D04E E G1AGGAH#!H#zraw_ops.BitwiseAndc                    t        j                  | |g|t        j                  t        j                  t        j
                  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
   BitwiseAnd   r8   attrsr   r   r   r5   args_to_matching_eager_dtypesint8int16int32int64uint8uint16uint32uint64r   r6   r9   	r   r   r   r   _attr_T	_inputs_TrC   rB   r=   s	            rD   r*   r*   u      661vsW\\SZS`S`biboboqxq~q~  AH  AN  AN  PW  P^  P^  `g  `n  `n  pw  p~  p~  EA  B'9&1aQ,>&]Al#)s?'""$lFG5('	.    TV_BitwiseOr_Tzbitwise.bitwise_orc           
      L   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$ 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  Elementwise computes the bitwise OR of `x` and `y`.

  The result will have those bits set, that are set in `x`, `y` or both. The
  computation is performed on the underlying representations of `x` and `y`.

  For example:

  ```python
  import tensorflow as tf
  from tensorflow.python.ops import bitwise_ops
  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
                tf.uint8, tf.uint16, tf.uint32, tf.uint64]

  for dtype in dtype_list:
    lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
    exp = tf.constant([5, 5, 7, 15], dtype=tf.float32)

    res = bitwise_ops.bitwise_or(lhs, rhs)
    tf.assert_equal(tf.cast(res,  tf.float32), exp)  # TRUE
  ```

  Args:
    x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
    y: A `Tensor`. Must have the same type as `x`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `x`.
  	BitwiseOrNr   r   r   r   )r   r   r    r!   r   r"   r#   r$   r%   r&   r'   _dispatcher_for_bitwise_orr)   bitwise_or_eager_fallbackr+   r,   r-   r.   r   
bitwise_orr0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   s               rD   r`   r`      s(   D 
			0h..0$#\\11k4A'gn, )	
AttGn$n	
)::qAD*Aq#x QK'""$3%%c*+F::L\674('	.W && -
##At,,## 
*a-g		&&
QTt% %## 
z" ""D15g 
	..<<	<  Z	  
  
b$ad3
G i,,:::n	
rF   zraw_ops.BitwiseOrc                    t        j                  | |g|t        j                  t        j                  t        j
                  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	   BitwiseOrrH   rI   r]   rK   rV   s	            rD   r_   r_         661vsW\\SZS`S`biboboqxq~q~  AH  AN  AN  PW  P^  P^  `g  `n  `n  pw  p~  p~  EA  B'9&1aQ,>&\1\#)s?'""$\674('	.rZ   TV_BitwiseXor_Tzbitwise.bitwise_xorc           
      L   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$ 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  Elementwise computes the bitwise XOR of `x` and `y`.

  The result will have those bits set, that are different in `x` and `y`. The
  computation is performed on the underlying representations of `x` and `y`.

  For example:

  ```python
  import tensorflow as tf
  from tensorflow.python.ops import bitwise_ops
  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
                tf.uint8, tf.uint16, tf.uint32, tf.uint64]

  for dtype in dtype_list:
    lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
    exp = tf.constant([5, 5, 4, 5],  dtype=tf.float32)

    res = bitwise_ops.bitwise_xor(lhs, rhs)
    tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE
  ```

  Args:
    x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
    y: A `Tensor`. Must have the same type as `x`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `x`.
  
BitwiseXorNr   r   r   r   )r   r   r    r!   r   r"   r#   r$   r%   r&   r'   _dispatcher_for_bitwise_xorr)   bitwise_xor_eager_fallbackr+   r,   r-   r.   r   bitwise_xorr0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   s               rD   rh   rh      rE   rF   zraw_ops.BitwiseXorc                    t        j                  | |g|t        j                  t        j                  t        j
                  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
   BitwiseXorrH   rI   re   rK   rV   s	            rD   rg   rg   I  rY   rZ   TV_Invert_Tzbitwise.invertc           	      >   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:  Invert (flip) each bit of supported types; for example, type `uint8` value 01010101 becomes 10101010.

  Flip each bit of supported types.  For example, type `int8` (decimal 2) binary 00000010 becomes (decimal -3) binary 11111101.
  This operation is performed on each element of the tensor argument `x`.

  Example:
  ```python
  import tensorflow as tf
  from tensorflow.python.ops import bitwise_ops

  # flip 2 (00000010) to -3 (11111101)
  tf.assert_equal(-3, bitwise_ops.invert(2))

  dtype_list = [dtypes.int8, dtypes.int16, dtypes.int32, dtypes.int64,
                dtypes.uint8, dtypes.uint16, dtypes.uint32, dtypes.uint64]

  inputs = [0, 5, 3, 14]
  for dtype in dtype_list:
    # Because of issues with negative numbers, let's test this indirectly.
    # 1. invert(a) and a = 0
    # 2. invert(a) or a = invert(0)
    input_tensor = tf.constant([0, 5, 3, 14], dtype=dtype)
    not_a_and_a, not_a_or_a, not_0 = [bitwise_ops.bitwise_and(
                                        input_tensor, bitwise_ops.invert(input_tensor)),
                                      bitwise_ops.bitwise_or(
                                        input_tensor, bitwise_ops.invert(input_tensor)),
                                      bitwise_ops.invert(
                                        tf.constant(0, dtype=dtype))]

    expected = tf.constant([0, 0, 0, 0], dtype=tf.float32)
    tf.assert_equal(tf.cast(not_a_and_a, tf.float32), expected)

    expected = tf.cast([not_0] * 4, tf.float32)
    tf.assert_equal(tf.cast(not_a_or_a, tf.float32), expected)

    # For unsigned dtypes let's also check the result directly.
    if dtype.is_unsigned:
      inverted = bitwise_ops.invert(input_tensor)
      expected = tf.constant([dtype.max - x for x in inputs], dtype=tf.float32)
      tf.assert_equal(tf.cast(inverted, tf.float32), tf.cast(expected, tf.float32))
  ```

  Args:
    x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `x`.
  InvertNr   r   r   r   r   )r   r   r    r!   r   r"   r#   r$   r%   r&   r'   _dispatcher_for_invertr)   invert_eager_fallbackr+   r,   r-   r.   r   invertr0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r   r   r;   r<   r=   r>   r?   r@   rA   rB   rC   s              rD   rp   rp   Y  s   j 
			0h..0$#\\11ha!gn, %	
D
DGn$n	
)::AD"Aq#x QK'""$3%%c*+F::L,1('	.W && -
##At,,## 
&d*dg		&"
$D" "## 
z" ""Bqt,g 
	..<<	<  Z	  
  
"dQT*
G i,,:::n	
sP    C& 3G &D-9DD-,D-1E 	E G,AG GAHHzraw_ops.Invertc                    t        j                  | g|t        j                  t        j                  t        j
                  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   InvertrH   rI   rl   rK   r   r   r   rW   rC   rB   r=   s          rD   ro   ro     s    111#sW\\7==ZaZgZgipivivx  yF  yF  HO  HV  HV  X_  Xf  Xf  ho  hv  hv  =y  z-'4A,>&Y,f!$41'""$,1('	.rZ   TV_LeftShift_Tzbitwise.left_shiftc           
      L   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$ 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)ak  Elementwise computes the bitwise left-shift of `x` and `y`.

  If `y` is negative, or greater than or equal to the width of `x` in bits the
  result is implementation defined.

  Example:

  ```python
  import tensorflow as tf
  from tensorflow.python.ops import bitwise_ops
  import numpy as np
  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64]

  for dtype in dtype_list:
    lhs = tf.constant([-1, -5, -3, -14], dtype=dtype)
    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)

    left_shift_result = bitwise_ops.left_shift(lhs, rhs)

    print(left_shift_result)

  # This will print:
  # tf.Tensor([ -32   -5 -128    0], shape=(4,), dtype=int8)
  # tf.Tensor([   -32     -5   -384 -28672], shape=(4,), dtype=int16)
  # tf.Tensor([   -32     -5   -384 -28672], shape=(4,), dtype=int32)
  # tf.Tensor([   -32     -5   -384 -28672], shape=(4,), dtype=int64)

  lhs = np.array([-2, 64, 101, 32], dtype=np.int8)
  rhs = np.array([-1, -5, -3, -14], dtype=np.int8)
  bitwise_ops.left_shift(lhs, rhs)
  # <tf.Tensor: shape=(4,), dtype=int8, numpy=array([ -2,  64, 101,  32], dtype=int8)>
  ```

  Args:
    x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
    y: A `Tensor`. Must have the same type as `x`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `x`.
  	LeftShiftNr   r   r   r   )r   r   r    r!   r   r"   r#   r$   r%   r&   r'   _dispatcher_for_left_shiftr)   left_shift_eager_fallbackr+   r,   r-   r.   r   
left_shiftr0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   s               rD   ry   ry     s(   Z 
			0h..0$#\\11k4A'gn, )	
AttGn$n	
)::qAD*Aq#x QK'""$3%%c*+F::L\674('	.W && -
##At,,## 
*a-g		&&
QTt% %## 
z" ""D15g 
	..<<	<  Z	  
  
b$ad3
G i,,:::n	
rF   zraw_ops.LeftShiftc                    t        j                  | |g|t        j                  t        j                  t        j
                  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	   LeftShiftrH   rI   rv   rK   rV   s	            rD   rx   rx   :  rb   rZ   TV_PopulationCount_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)ax  Computes element-wise population count (a.k.a. popcount, bitsum, bitcount).

  For each entry in `x`, calculates the number of `1` (on) bits in the binary
  representation of that entry.

  **NOTE**: It is more efficient to first `tf.bitcast` your tensors into
  `int32` or `int64` and perform the bitcount on the result, than to feed in
  8- or 16-bit inputs and then aggregate the resulting counts.

  Args:
    x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `uint8`.
  PopulationCountNr   rm   r   )r   r   r    r!   r   r"   r#   r$   r%   r&   r'   population_count_eager_fallbackr+   r3   r4   r5   r6   r7   r8   r9   rq   s              rD   population_countr   J  s8   " 
			0h..0$#\\11q*gn (88QT+!QXQK'""$3%%c*+F::L<:('	.' && -
##At,,## 
,
$D" "## 
s0    C D C;;DDD& &D<;D<zraw_ops.PopulationCountc                    t        j                  | g|t        j                  t        j                  t        j
                  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   PopulationCountrH   rI   r}   rK   rs   s          rD   r~   r~   z  s    111#sW\\7==ZaZgZgipivivx  yF  yF  HO  HV  HV  X_  Xf  Xf  ho  hv  hv  =y  z-'4A,>&/<#)s?'""$<:('	.rZ   TV_RightShift_Tzbitwise.right_shiftc           
      L   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$ 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  Elementwise computes the bitwise right-shift of `x` and `y`.

  Performs a logical shift for unsigned integer types, and an arithmetic shift
  for signed integer types.

  If `y` is negative, or greater than or equal to than the width of `x` in bits
  the result is implementation defined.

  Example:

  ```python
  import tensorflow as tf
  from tensorflow.python.ops import bitwise_ops
  import numpy as np
  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64]

  for dtype in dtype_list:
    lhs = tf.constant([-1, -5, -3, -14], dtype=dtype)
    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)

    right_shift_result = bitwise_ops.right_shift(lhs, rhs)

    print(right_shift_result)

  # This will print:
  # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int8)
  # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int16)
  # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int32)
  # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int64)

  lhs = np.array([-2, 64, 101, 32], dtype=np.int8)
  rhs = np.array([-1, -5, -3, -14], dtype=np.int8)
  bitwise_ops.right_shift(lhs, rhs)
  # <tf.Tensor: shape=(4,), dtype=int8, numpy=array([ -2,  64, 101,  32], dtype=int8)>
  ```

  Args:
    x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
    y: A `Tensor`. Must have the same type as `x`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `x`.
  
RightShiftNr   r   r   r   )r   r   r    r!   r   r"   r#   r$   r%   r&   r'   _dispatcher_for_right_shiftr)   right_shift_eager_fallbackr+   r,   r-   r.   r   right_shiftr0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   s               rD   r   r     s(   ` 
			0h..0$#\\11lD!Q(gn, *	
AttGn$n	
)::QT+Aq#x QK'""$3%%c*+F::LlFG5('	.W && -
##At,,## 
+a-g		&'
QTt% %## 
z" ""TA6g 
	..<<	<  Z	  
  
r4!qt4
G i,,:::n	
rF   zraw_ops.RightShiftc                    t        j                  | |g|t        j                  t        j                  t        j
                  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
   RightShiftrH   rI   r   rK   rV   s	            rD   r   r     rY   rZ   )N)L__doc__collectionstensorflow.pythonr   tensorflow.python.eagerr   r   r   r#   r   r5   tensorflow.python.frameworkr   rM   tensorflow.security.fuzzing.pyr   _atypesr	   _op_def_registryr
   r%   r   r3   "tensorflow.python.util.deprecationr   tensorflow.python.utilr   r.    tensorflow.python.util.tf_exportr   typingr   r   r   typing_extensionsr   r   add_fallback_dispatch_listadd_type_based_api_dispatcherr/   	to_raw_opr   _tf_type_based_dispatcherDispatchr(   r*   r[   r`   r]   r^   r_   rc   rh   re   rf   rg   rj   rp   rl   rn   ro   rt   ry   rv   rw   rx   r{   UInt8r   r}   r~   r   r   r   r   r   r   rZ   rD   <module>r      s  
  6 7 1 7 9 F K 3 I C 8 6 % % '+_o`n  qA  CS  Ue  gv  w
%%
((
 !Q9S/12 QyoAU7V Qfops  vE  qE  gF Q " ) &Qf -Y+,^T^^K-HI
)CCLL )C,@"A iPSUdPdFe u~  @C  ET  @T  vU  )?O_^ln~  AQ  Sc  et  u
%%
((
 Q)C/0 QYsN?R5S Qclmp  sA  nA  dB Q ! ) &Qf +I)*>4>>*+EF	'AAJJ 3+>!? IcSaNaDb r{|  BP  }P  sQ  +_o`n  qA  CS  Ue  gv  w
%%
((
 !Q9S/12 QyoAU7V Qfops  vE  qE  gF Q " ) &Qf -Y+,^T^^K-HI
)CCLL )C,@"A iPSUdPdFe u~  @C  ET  @T  vU  m_oXfhx  {K  M]  _n  o
%%
((
di[() d3CS9T d  ) &dL 
%#	$^T^^F%;	<99BB 
YsK'78 
	RUWbRbHc 
 )?O_^ln~  AQ  Sc  et  u
%%
((
 \)C/0 \YsN?R5S \clmp  sA  nA  dB \ ! ) &\| +I)*>4>>*+EF	'AAJJ 3+>!? IcSaNaDb r{|  BP  }P  sQ  5Yhjx  {K  M]  _o  q@  A +	#';";< +IVY[b[h[hVhLi +Z 7)56~t~~FV7WX
y6J1J'K 
[dehjqjwjwew[x 
 +_o`n  qA  CS  Ue  gv  w
%%
((
 !_9S/12 _yoAU7V _fops  vE  qE  gF _ " ) &_B -Y+,^T^^K-HI
)CCLL )C,@"A iPSUdPdFe u~  @C  ET  @T  vU rZ   