Add files using upload-large-folder tool

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/batch_ops.py

@@ -0,0 +1,123 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Operations for automatic batching and unbatching."""
+from tensorflow.python.eager import def_function
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor
+from tensorflow.python.ops import gen_batch_ops
+# pylint: disable=wildcard-import
+from tensorflow.python.ops.gen_batch_ops import *
+# pylint: enable=wildcard-import
+from tensorflow.python.util import nest
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export("nondifferentiable_batch_function")
+def batch_function(num_batch_threads,
+                   max_batch_size,
+                   batch_timeout_micros,
+                   allowed_batch_sizes=None,
+                   max_enqueued_batches=10,
+                   autograph=True,
+                   enable_large_batch_splitting=True):
+  """Batches the computation done by the decorated function.
+
+  So, for example, in the following code
+
+  ```python
+  @batch_function(1, 2, 3)
+  def layer(a):
+    return tf.matmul(a, a)
+
+  b = layer(w)
+  ```
+
+  if more than one session.run call is simultaneously trying to compute `b`
+  the values of `w` will be gathered, non-deterministically concatenated
+  along the first axis, and only one thread will run the computation. See the
+  documentation of the `Batch` op for more details.
+
+  Assumes that all arguments of the decorated function are Tensors which will
+  be batched along their first dimension.
+
+  SparseTensor is not supported. The return value of the decorated function
+  must be a Tensor or a list/tuple of Tensors.
+
+  Args:
+    num_batch_threads: Number of scheduling threads for processing batches
+     of work. Determines the number of batches processed in parallel.
+    max_batch_size: Batch sizes will never be bigger than this.
+    batch_timeout_micros: Maximum number of microseconds to wait before
+     outputting an incomplete batch.
+    allowed_batch_sizes: Optional list of allowed batch sizes. If left empty,
+     does nothing. Otherwise, supplies a list of batch sizes, causing the op
+     to pad batches up to one of those sizes. The entries must increase
+     monotonically, and the final entry must equal max_batch_size.
+    max_enqueued_batches: The maximum depth of the batch queue. Defaults to 10.
+    autograph: Whether to use autograph to compile python and eager style code
+     for efficient graph-mode execution.
+    enable_large_batch_splitting: The value of this option doesn't affect
+     processing output given the same input; it affects implementation details
+     as stated below: 1. Improve batching efficiency by eliminating unnecessary
+     adding. 2.`max_batch_size` specifies the limit of input and
+     `allowed_batch_sizes` specifies the limit of a task to be processed. API
+     user can give an input of size 128 when 'max_execution_batch_size'
+     is 32 -> implementation can split input of 128 into 4 x 32, schedule
+     concurrent processing, and then return concatenated results corresponding
+     to 128.
+
+  Returns:
+    The decorated function will return the unbatched computation output Tensors.
+  """
+
+  def decorator(fn):  # pylint: disable=missing-docstring
+
+    def decorated(*args):  # pylint: disable=missing-docstring
+
+      @def_function.function(autograph=autograph)
+      def computation(*computation_args):
+        return fn(*computation_args)
+
+      computation = computation.get_concrete_function(*[
+          tensor.TensorSpec(
+              dtype=x.dtype, shape=x.shape, name="batch_" + str(i))
+          for i, x in enumerate(args)
+      ])
+
+      with ops.name_scope("batch") as name:
+        for a in args:
+          if not isinstance(a, tensor.Tensor):
+            raise ValueError("All arguments to functions decorated with "
+                             "`batch_function`  are supposed to be Tensors; "
+                             f"found {a!r}.")
+        outputs = gen_batch_ops.batch_function(
+            num_batch_threads=num_batch_threads,
+            max_batch_size=max_batch_size,
+            batch_timeout_micros=batch_timeout_micros,
+            allowed_batch_sizes=allowed_batch_sizes,
+            max_enqueued_batches=max_enqueued_batches,
+            shared_name=name,
+            enable_large_batch_splitting=enable_large_batch_splitting,
+            f=computation,
+            in_tensors=list(args),
+            captured_tensors=computation.captured_inputs,
+            Tout=[o.dtype for o in computation.outputs])
+        return nest.pack_sequence_as(
+            computation.structured_outputs, outputs, expand_composites=True)
+
+    return decorated
+
+  return decorator

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/bitwise_ops.py

@@ -0,0 +1,33 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Operations for manipulating the binary representations of integers.
+
+API docstring: tensorflow.bitwise
+"""
+
+from tensorflow.python.framework import ops
+# go/tf-wildcard-import
+# pylint: disable=wildcard-import
+from tensorflow.python.ops.gen_bitwise_ops import *
+# pylint: enable=wildcard-import
+
+ops.NotDifferentiable("BitwiseAnd")
+ops.NotDifferentiable("BitwiseOr")
+ops.NotDifferentiable("BitwiseXor")
+ops.NotDifferentiable("Invert")
+ops.NotDifferentiable("PopulationCount")
+ops.NotDifferentiable("LeftShift")
+ops.NotDifferentiable("RightShift")

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/composite_tensor_ops.py

@@ -0,0 +1,118 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =============================================================================
+"""Operations for ExtensionTypes (aka Composite Tensors)."""
+
+from tensorflow.core.protobuf import composite_tensor_variant_pb2
+from tensorflow.python.framework import composite_tensor
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor
+from tensorflow.python.ops import gen_composite_tensor_ops
+from tensorflow.python.saved_model import nested_structure_coder
+from tensorflow.python.util import nest
+
+
+def composite_tensor_to_variants(value, type_spec=None, name=None):
+  """Encodes `value` as a scalar variant tensor.
+
+  Args:
+    value: The `ExtensionType` value to encode.
+    type_spec: Information about the value's type that should be included in the
+      encoding.
+    name: Optional name for the operation.
+
+  Returns:
+    A Tensor with shape=`()` and dtype=`tf.variant`.
+
+  Raises:
+    ValueError: If `type_spec` is not compatible with `value`.
+  """
+  if not isinstance(value, composite_tensor.CompositeTensor):
+    raise TypeError("Expected `value` to be a CompositeTensor. "
+                    f"Received {type(value)}.")
+
+  if type_spec is None:
+    type_spec = value._type_spec  # pylint: disable=protected-access
+  if not type_spec.is_compatible_with(value):
+    raise ValueError(f"`type_spec` {type_spec} is not compatible with `value` "
+                     f"{value!r}.")
+  metadata = composite_tensor_variant_pb2.CompositeTensorVariantMetadata()
+  metadata.type_spec_proto.CopyFrom(
+      nested_structure_coder.encode_structure(type_spec).type_spec_value)
+
+  return gen_composite_tensor_ops.CompositeTensorVariantFromComponents(
+      components=nest.flatten(value, expand_composites=True),
+      metadata=metadata.SerializeToString(),
+      name=name)
+
+
+def composite_tensor_from_variant(encoded, type_spec, name=None):
+  """Returns the `ExtensionType` value encoded by a variant scalar tensor.
+
+  Args:
+    encoded: A Tensor returned by `composite_tensor_to_variants`.
+    type_spec: The `TypeSpec` of the original value.  This is used to determine
+      the number and types of the component tensors that comprise the decoded
+      value.  Must be compatible with the `TypeSpec` serilized in `encoded`.
+    name: Optional name for the operation.
+
+  Returns:
+    An `ExtensionType` value that is compatible with `TypeSpec`.
+
+  Raises:
+    TypeError: If `encoded` is not a Tensor with dtype=variant.
+    InvalidArgumentError: If `encoded` is not compatible with `type_spec`.
+  """
+  if not isinstance(encoded, tensor.Tensor):
+    raise TypeError(f"Expected `encoded` to be a Tensor, got {encoded!r}.")
+  if encoded.dtype != dtypes.variant:
+    raise TypeError("Expected `encoded` to have dtype=variant, got "
+                    f"{encoded!r}.")
+  encoded.shape.assert_is_compatible_with(())
+
+  metadata = composite_tensor_variant_pb2.CompositeTensorVariantMetadata()
+  metadata.type_spec_proto.CopyFrom(
+      nested_structure_coder.encode_structure(type_spec).type_spec_value)
+
+  component_dtypes = [
+      t.dtype for t in nest.flatten(type_spec, expand_composites=True)
+  ]
+
+  components = gen_composite_tensor_ops.CompositeTensorVariantToComponents(
+      encoded=encoded,
+      metadata=metadata.SerializeToString(),
+      Tcomponents=component_dtypes,
+      name=name)
+  return nest.pack_sequence_as(type_spec, components, expand_composites=True)
+
+
+@ops.RegisterGradient("CompositeTensorVariantFromComponents")
+def _composite_tensor_to_variants_grad(op, grad):
+  return gen_composite_tensor_ops.CompositeTensorVariantToComponents(
+      encoded=grad,
+      metadata=op.get_attr("metadata"),
+      Tcomponents=op.get_attr("Tcomponents"))
+
+
+@ops.RegisterGradient("CompositeTensorVariantToComponents")
+def _composite_tensor_from_variant_grad(op, *grad):
+  assert len(grad) == len(op.outputs)
+  # `components` is `op.outputs`, but with any tensors for which we're
+  # taking the gradient replaced by the corresponding value from `grad`.
+  components = [
+      op.outputs[i] if grad[i] is None else grad[i] for i in range(len(grad))
+  ]
+  return gen_composite_tensor_ops.CompositeTensorVariantFromComponents(
+      components=components, metadata=op.get_attr("metadata"))

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/control_flow_assert.py

@@ -0,0 +1,130 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Assert functions for Control Flow Operations."""
+
+from tensorflow.python.eager import context
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import errors
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import cond
+from tensorflow.python.ops import gen_control_flow_ops
+from tensorflow.python.ops import gen_logging_ops
+from tensorflow.python.ops import gen_math_ops
+from tensorflow.python.util import dispatch
+from tensorflow.python.util import tf_should_use
+from tensorflow.python.util.tf_export import tf_export
+
+
+def _summarize_eager(tensor, summarize=None):
+  """Returns a summarized string representation of eager `tensor`.
+
+  Args:
+    tensor: EagerTensor to summarize
+    summarize: Include these many first elements of `array`
+  """
+  # Emulate the behavior of Tensor::SummarizeValue()
+  if summarize is None:
+    summarize = 3
+  elif summarize < 0:
+    summarize = array_ops.size(tensor)
+
+  # reshape((-1,)) is the fastest way to get a flat array view
+  if tensor._rank():  # pylint: disable=protected-access
+    flat = tensor.numpy().reshape((-1,))
+    lst = [str(x) for x in flat[:summarize]]
+    if len(lst) < flat.size:
+      lst.append("...")
+  else:
+    # tensor.numpy() returns a scalar for zero dimensional arrays
+    if gen_math_ops.not_equal(summarize, 0):
+      lst = [str(tensor.numpy())]
+    else:
+      lst = []
+
+  return ", ".join(lst)
+
+
+# Assert and Print are special symbols in python, so we must
+# use an upper-case version of them.
+@tf_export("debugging.Assert", "Assert")
+@dispatch.add_dispatch_support
+@tf_should_use.should_use_result
+def Assert(condition, data, summarize=None, name=None):
+  """Asserts that the given condition is true.
+
+  If `condition` evaluates to false, print the list of tensors in `data`.
+  `summarize` determines how many entries of the tensors to print.
+
+  Args:
+    condition: The condition to evaluate.
+    data: The tensors to print out when condition is false.
+    summarize: Print this many entries of each tensor.
+    name: A name for this operation (optional).
+
+  Returns:
+    assert_op: An `Operation` that, when executed, raises a
+    `tf.errors.InvalidArgumentError` if `condition` is not true.
+    @compatibility(eager)
+    returns None
+    @end_compatibility
+
+  Raises:
+    @compatibility(TF1)
+    When in TF V1 mode (that is, outside `tf.function`) Assert needs a control
+    dependency on the output to ensure the assertion executes:
+
+  ```python
+  # Ensure maximum element of x is smaller or equal to 1
+  assert_op = tf.Assert(tf.less_equal(tf.reduce_max(x), 1.), [x])
+  with tf.control_dependencies([assert_op]):
+    ... code using x ...
+  ```
+
+    @end_compatibility
+  """
+  if context.executing_eagerly():
+    if not condition:
+      xs = ops.convert_n_to_tensor(data)
+      data_str = [_summarize_eager(x, summarize) for x in xs]
+      raise errors.InvalidArgumentError(
+          node_def=None,
+          op=None,
+          message="Expected '%s' to be true. Summarized data: %s" %
+          (condition, "\n".join(data_str)))
+    return
+
+  with ops.name_scope(name, "Assert", [condition, data]) as name:
+    xs = ops.convert_n_to_tensor(data)
+    if all(x.dtype in {dtypes.string, dtypes.int32} for x in xs):
+      # As a simple heuristic, we assume that string and int32 are
+      # on host to avoid the need to use cond. If it is not case,
+      # we will pay the price copying the tensor to host memory.
+      return gen_logging_ops._assert(condition, data, summarize, name="Assert")  # pylint: disable=protected-access
+    else:
+      condition = ops.convert_to_tensor(condition, name="Condition")
+
+      def true_assert():
+        return gen_logging_ops._assert(  # pylint: disable=protected-access
+            condition, data, summarize, name="Assert")
+
+      guarded_assert = cond.cond(
+          condition,
+          gen_control_flow_ops.no_op,
+          true_assert,
+          name="AssertGuard")
+      if context.executing_eagerly():
+        return
+      return guarded_assert.op

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/control_flow_ops.py

@@ -0,0 +1,2256 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Control Flow Operations.
+
+See the [autograph](https://www.tensorflow.org/guide/autograph) guide.
+"""
+# pylint: disable=g-bad-name
+import abc
+
+from tensorflow.core.framework import attr_value_pb2
+from tensorflow.core.protobuf import control_flow_pb2
+from tensorflow.python.eager import context
+from tensorflow.python.framework import composite_tensor
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import indexed_slices
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor as tensor_lib
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.framework import tensor_util
+from tensorflow.python.framework import type_spec
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import control_flow_util as util
+from tensorflow.python.ops import gen_array_ops
+from tensorflow.python.ops import gen_control_flow_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import tensor_array_ops
+# go/tf-wildcard-import
+# pylint: disable=wildcard-import,undefined-variable
+from tensorflow.python.ops.gen_control_flow_ops import *
+# pylint: enable=wildcard-import
+from tensorflow.python.util import compat
+from tensorflow.python.util import dispatch
+from tensorflow.python.util import nest
+from tensorflow.python.util import variable_utils
+from tensorflow.python.util.tf_export import tf_export
+
+
+# We override the 'tuple' for a control flow op, so we keep python's
+# existing 'tuple' for later use in this module.
+_basetuple = tuple
+
+
+# pylint: disable=protected-access
+
+
+def _Identity(tensor, name=None):
+  """Return a tensor with the same shape and contents as the input tensor.
+
+  Args:
+    tensor: A Tensor.
+    name: A name for this operation (optional).
+
+  Returns:
+    A Tensor with the same type and value as the input Tensor.
+  """
+  tensor = ops.internal_convert_to_tensor_or_composite(tensor, as_ref=True)
+  # TODO(b/246438937): Remove this when we expand ResourceVariables into
+  # dt_resource tensors.
+  tensor = variable_utils.convert_variables_to_tensors(tensor)
+  if isinstance(tensor, tensor_lib.Tensor):
+    if tensor.dtype._is_ref_dtype:  # pylint: disable=protected-access
+      return gen_array_ops.ref_identity(tensor, name=name)
+    else:
+      return array_ops.identity(tensor, name=name)
+  elif isinstance(tensor, composite_tensor.CompositeTensor):
+    return nest.map_structure(_Identity, tensor, expand_composites=True)
+  else:
+    raise TypeError("'tensor' must be a Tensor or CompositeTensor. "
+                    f"Received: {type(tensor)}.")
+
+
+def _NextIteration(tensor, name=None):
+  tensor = ops.internal_convert_to_tensor_or_composite(tensor, as_ref=True)
+  if isinstance(tensor, tensor_lib.Tensor):
+    if tensor.dtype._is_ref_dtype:  # pylint: disable=protected-access
+      return ref_next_iteration(tensor, name=name)
+    else:
+      return next_iteration(tensor, name=name)
+  elif isinstance(tensor, composite_tensor.CompositeTensor):
+    return nest.map_structure(_NextIteration, tensor, expand_composites=True)
+  else:
+    raise TypeError("'tensor' must be a Tensor or CompositeTensor. "
+                    f"Received: {type(tensor)}.")
+
+
+def _Enter(tensor,
+           frame_name,
+           is_constant=False,
+           parallel_iterations=10,
+           use_ref=True,
+           use_input_shape=True,
+           name=None):
+  """Creates or finds a child frame, and makes `tensor` available to it.
+
+  The unique `frame_name` is used by the `Executor` to identify frames. If
+  `is_constant` is true, `tensor` is a constant in the child frame; otherwise
+  it may be changed in the child frame. At most `parallel_iterations`
+  iterations are run in parallel in the child frame.
+
+  Args:
+    tensor: The tensor to be made available to the child frame.
+    frame_name: The name of the child frame.
+    is_constant: If true, the output is constant within the child frame.
+    parallel_iterations: The number of iterations allowed to run in parallel.
+    use_ref: If true, use ref_enter if tensor is of ref type.
+    use_input_shape: If true, set the result's shape based on tensor's shape.
+    name: A name for this operation (optional).
+
+  Returns:
+    The same tensor as `tensor`.
+
+  Raises:
+    ValueError: If any tensor in `tensor` has a less specific shape
+      than its corresponding shape in `shape_invariant`.
+  """
+  tensor = ops.internal_convert_to_tensor_or_composite(tensor, as_ref=True)
+  if isinstance(tensor, tensor_lib.Tensor):
+    if tensor.dtype._is_ref_dtype and use_ref:  # pylint: disable=protected-access
+      result = gen_control_flow_ops.ref_enter(
+          tensor, frame_name, is_constant, parallel_iterations, name=name)
+    else:
+      result = gen_control_flow_ops.enter(
+          tensor, frame_name, is_constant, parallel_iterations, name=name)
+    if use_input_shape:
+      result.set_shape(tensor.get_shape())
+    return result
+  elif isinstance(tensor, composite_tensor.CompositeTensor):
+
+    def enter_component(t):
+      return _Enter(t, frame_name, is_constant, parallel_iterations, use_ref,
+                    use_input_shape)
+
+    return nest.map_structure(enter_component, tensor, expand_composites=True)
+  else:
+    raise TypeError("'tensor' must be a Tensor or CompositeTensor. "
+                    f"Received: {type(tensor)}.")
+
+
+def exit(tensor, name=None):  # pylint: disable=redefined-builtin
+  """Exits the current frame to its parent frame.
+
+  Exit makes its input `tensor` available to the parent frame.
+
+  Args:
+    tensor: The tensor to be made available to the parent frame.
+    name: A name for this operation (optional).
+
+  Returns:
+    The same tensor as `tensor`.
+  """
+  tensor = ops.internal_convert_to_tensor_or_composite(tensor, as_ref=True)
+  if isinstance(tensor, tensor_lib.Tensor):
+    if tensor.dtype._is_ref_dtype:  # pylint: disable=protected-access
+      return gen_control_flow_ops.ref_exit(tensor, name)
+    else:
+      return gen_control_flow_ops._exit(tensor, name)
+  elif isinstance(tensor, composite_tensor.CompositeTensor):
+    return nest.map_structure(exit, tensor, expand_composites=True)
+  else:
+    raise TypeError("'tensor' must be a Tensor or CompositeTensor. "
+                    f"Received: {type(tensor)}.")
+
+
+def switch(data, pred, dtype=None, name=None):
+  """Forwards `data` to an output determined by `pred`.
+
+  If `pred` is false, the `data` input is forwarded to the first output.
+  Otherwise, the data goes to the second output.
+
+  This op handles `Tensor`s and `IndexedSlices`.
+
+  Args:
+    data: The tensor to be forwarded to the appropriate output.
+    pred: A scalar that specifies which output port will receive data.
+    dtype: Optional element type for the returned tensor. If missing, the type
+      is inferred from the type of `value`.
+    name: A name for this operation (optional).
+
+  Returns:
+    `(output_false, output_true)`: If `pred` is true, data will be forwarded
+    to `output_true`, otherwise it goes to `output_false`.
+  """
+  with ops.name_scope(name, "Switch", [data, pred]) as name:
+    data = ops.internal_convert_to_tensor_or_composite(
+        data, dtype=dtype, name="data", as_ref=True)
+    pred = ops.convert_to_tensor(pred, name="pred")
+    if isinstance(data, tensor_lib.Tensor):
+      return gen_control_flow_ops.switch(data, pred, name=name)
+    else:
+      if not isinstance(data, composite_tensor.CompositeTensor):
+        raise TypeError(
+            "'data' must be a Tensor or CompositeTensor. "
+            f"Received: {type(data)}.")
+      tensors = nest.flatten(data, expand_composites=True)
+      mapped = [gen_control_flow_ops.switch(tensor, pred) for tensor in tensors]
+      mapped_f, mapped_t = zip(*mapped)
+      return (nest.pack_sequence_as(data, mapped_f, expand_composites=True),
+              nest.pack_sequence_as(data, mapped_t, expand_composites=True))
+
+
+def _SwitchRefOrTensor(data, pred, name="Switch"):
+  """Forwards `data` to an output determined by `pred`.
+
+  If `pred` is false, the `data` input is forwarded to the first output.
+  Otherwise, the data goes to the second output.
+
+  This op handles `Tensor`s and `IndexedSlices`.
+
+  Args:
+    data: The tensor to be forwarded to the appropriate output.
+    pred: A scalar that specifies which output port will receive data.
+    name: A name for this operation (optional).
+
+  Returns:
+    `(output_false, output_true)`: If `pred` is true, data will be forwarded to
+    `output_true`, otherwise it goes to `output_false`.
+
+  Raises:
+    TypeError: if data is not a Tensor or IndexedSlices
+  """
+  data = ops.convert_to_tensor_or_composite(data, name="data")
+  # NOTE(vrv): ops.colocate_with(data, ignore_existing=True) below
+  # addresses the following scenario.
+  #
+  # Assume you execute Optimizer.apply_gradients() in a branch of a cond().
+  #
+  # 1. The update op is created inside a `with ops.colocate(var):` block
+  #
+  # 2. Some tensor `data` is captured and a switch is created in a
+  #    `with ops.colocate_with(data):` block.
+  #
+  # with ops.colocate_with(var):
+  #  with ops.colocate_with(data):
+  #    op = ...
+  #
+  # var and data may be pinned to different devices, so we want to ops
+  # created within ops.colocate_with(data) to ignore the existing stack.
+  with ops.colocate_with(data, ignore_existing=True):
+    if isinstance(data, tensor_lib.Tensor):
+      if data.dtype._is_ref_dtype:  # pylint: disable=protected-access
+        return ref_switch(data, pred, name=name)
+    return switch(data, pred, name=name)
+
+
+def merge(inputs, name=None):
+  """Returns the value of an available element of `inputs`.
+
+  This op tests each of the tensors in `inputs` in turn to determine if any of
+  them is available. If it finds an available tensor, it returns it and its
+  index in `inputs`.
+
+  It is an error if more than one tensor in `inputs` is available. If no tensor
+  in `inputs` is available, the returned tensor and index are not set.
+
+  This op handles both `Tensor`s and `IndexedSlices`. If inputs has a mix of
+  `Tensor`s and `IndexedSlices`, all inputs are converted to IndexedSlices
+  before merging.
+
+  Args:
+    inputs: The input tensors, at most one of which is available.
+    name: A name for this operation (optional).
+
+  Returns:
+    A tuple containing the chosen input tensor and its index in `inputs`.
+
+  Raises:
+    ValueError: If any of the inputs is None, or inputs are IndexedSlices and
+      some but not all have a dense_shape property.
+  """
+  if any(inp is None for inp in inputs):
+    raise ValueError("At least one of the merge inputs is None: %s" % inputs)
+  with ops.name_scope(name, "Merge", inputs) as name:
+    inputs = [
+        ops.internal_convert_to_tensor_or_composite(inp, as_ref=True)
+        for inp in inputs
+    ]
+    if all(isinstance(v, tensor_lib.Tensor) for v in inputs):
+      if all(v.dtype._is_ref_dtype for v in inputs):  # pylint: disable=protected-access
+        return gen_control_flow_ops.ref_merge(inputs, name)
+      else:
+        return gen_control_flow_ops.merge(inputs, name)
+    else:
+      # If there is a mix of tensors and indexed slices, then convert the
+      # tensors to indexed slices.
+      if all(
+          isinstance(v, (indexed_slices.IndexedSlices, tensor_lib.Tensor))
+          for v in inputs):
+        inputs = math_ops._as_indexed_slices_list(inputs, optimize=False)
+
+      for v in inputs:
+        if not isinstance(v, composite_tensor.CompositeTensor):
+          raise TypeError("Type %s not supported" % type(v))
+
+      for v in inputs[1:]:
+        nest.assert_same_structure(inputs[0], v, expand_composites=True)
+
+      flat_inputs = [nest.flatten(v, expand_composites=True) for v in inputs]
+      merged_results = [
+          gen_control_flow_ops.merge(component)
+          for component in zip(*flat_inputs)
+      ]
+      flat_merged = [tensor for (tensor, _) in merged_results]
+      chosen_index = merged_results[0][1]
+      merged_inputs = nest.pack_sequence_as(
+          inputs[0], flat_merged, expand_composites=True)
+      return (merged_inputs, chosen_index)
+
+
+def _convert_tensorarray_to_flow(tensor_or_tensor_array):
+  if isinstance(tensor_or_tensor_array, tensor_array_ops.TensorArray):
+    return tensor_or_tensor_array.flow
+  else:
+    return tensor_or_tensor_array
+
+
+def _convert_flow_to_tensorarray(tensor_or_tensor_array, tensor_or_flow):
+  if isinstance(tensor_or_tensor_array, tensor_array_ops.TensorArray):
+    return tensor_array_ops.build_ta_with_new_flow(tensor_or_tensor_array,
+                                                   tensor_or_flow)
+  else:
+    return tensor_or_flow
+
+
+def _convert_to_tensor_or_composite_or_tensorarray(var):
+  if isinstance(var, tensor_array_ops.TensorArray):
+    return var
+  return ops.convert_to_tensor_or_composite(var)
+
+
+# TODO(xjun): replace this with is_subtype_of after it is landed.
+def _ShapeLessThanOrEqual(shape1, shape2):
+  if shape2.dims is None:
+    return True
+  if shape1.ndims != shape2.ndims:
+    return False
+  for dim1, dim2 in zip(shape1.dims, shape2.dims):
+    if dim2.value is not None and dim1.value != dim2.value:
+      return False
+  return True
+
+
+def _shape_invariant_to_type_spec(var, shape=None):
+  """Converts a shape invariant to a TypeSpec.
+
+  If `var` is a TensorArray, it will first be converted to its flow.
+
+  Args:
+    var: The tensor, tensor array or composite tensor whose shape is described
+      by the shape invariant.
+    shape: A `TypeSpec` or `TensorShape`.  If `shape` is already a `TypeSpec`,
+      then it is simply returned as-is.
+
+  Returns:
+    A `TypeSpec` for `var`, consistent with the given shape.
+
+  Raises:
+    TypeError: If `shape` is a TypeSpec and not compatible with `var`.
+    TypeError: If `shape` is not None, a TypeSpec, or a TensorShape.
+    TypeError: If `shape` is a TensorShape, `var` is a CompositeTensor, and
+      `var` doesn't implement the `_shape_invariant_to_type_spec` method.
+  """
+  var = _convert_tensorarray_to_flow(var)
+  if shape is None:
+    return type_spec.type_spec_from_value(var)
+  elif isinstance(shape, type_spec.TypeSpec):
+    if not shape.is_compatible_with(var):
+      raise TypeError("TypeSpec %r is not compatible with %r" % (shape, var))
+    return shape
+  elif not isinstance(shape, tensor_shape.TensorShape):
+    raise TypeError(
+        "'shape' must be one of TypeSpec, TensorShape or None. "
+        f"Received: {type(shape)}")
+
+  if isinstance(var, tensor_lib.Tensor):
+    return tensor_lib.TensorSpec(shape, var.dtype)
+  else:
+    try:
+      return var._shape_invariant_to_type_spec(shape)  # pylint: disable=protected-access
+    except NotImplementedError as e:
+      raise TypeError(
+          f"To describe or constrain a {type(var).__name__}, use a "
+          f"{type(var._type_spec).__name__} instead of a TensorShape.") from e  # pylint: disable=protected-access
+
+
+def _EnforceShapeInvariant(merge_var, next_var):
+  """Check if the shapes of the loops variables are invariants.
+
+  Args:
+    merge_var: The tensor representing the initial values of the loop
+      variables.
+    next_var: The tensor representing the values of the loop variables
+      after one loop iteration.
+
+  Raises:
+    ValueError: If any tensor in `merge_var` has a more specific shape than
+      its corresponding tensor in `next_var`.
+  """
+  if isinstance(merge_var, tensor_lib.Tensor):
+    m_shape = merge_var.get_shape()
+    n_shape = next_var.get_shape()
+    if not _ShapeLessThanOrEqual(n_shape, m_shape):
+      enter = merge_var.op.inputs[0].op
+      assert util.IsLoopEnter(enter)
+      input_t = enter.inputs[0]
+      raise ValueError(
+          "Input tensor '%s' enters the loop with shape %s, but has shape %s "
+          "after one iteration. To allow the shape to vary across iterations, "
+          "use the `shape_invariants` argument of tf.while_loop to specify a "
+          "less-specific shape." % (input_t.name, input_t.shape, n_shape))
+  else:
+    raise TypeError("'merge_var' must be a Tensor. "
+                    f"Received: {type(merge_var)}.")
+
+
+def _AddNextAndBackEdge(m, v, enforce_shape_invariant=True):
+  """Add NextIteration and back edge from v to m."""
+  if isinstance(m, tensor_lib.Tensor):
+    v = ops.convert_to_tensor(v)
+    v = _NextIteration(v)
+    if enforce_shape_invariant:
+      # Make sure the shapes of loop outputs are correct. We do this before
+      # calling _update_input, which will raise a less-helpful error message if
+      # the types don't match.
+      # TODO(skyewm): call this for other cases below (needs testing)
+      _EnforceShapeInvariant(m, v)
+    m.op._update_input(1, v)  # pylint: disable=protected-access
+  elif isinstance(m, composite_tensor.CompositeTensor):
+    # pylint: disable=protected-access
+    def update_component(m_component, v_component):
+      m_component.op._update_input(1, v_component)
+
+    if isinstance(m, indexed_slices.IndexedSlices):
+      v = math_ops._as_indexed_slices(v, optimize=False)
+    # pylint: enable=protected-access
+    v = _NextIteration(v)
+    return nest.map_structure(update_component, m, v, expand_composites=True)
+  else:
+    raise TypeError("'m' must be a Tensor or CompositeTensor. "
+                    f"Received: {type(m)}.")
+  return v
+
+
+class ControlFlowContext(metaclass=abc.ABCMeta):
+  """The base class for control flow context.
+
+  The usage pattern is a sequence of (Enter, Exit) followed by a final
+  ExitResult.
+
+  We maintain the following state for control flow contexts during graph
+  construction:
+   1. graph has _control_flow_context: the current context used to
+      construct new nodes. Changed by ctxt.Enter() and ctxt.Exit()
+   2. op has _control_flow_context: the context to which the op belongs.
+      Set at the time the op is created. Immutable.
+   3. A ControlFlowContext has _outer_context: the context in which this
+      context is created. Set at the time a context is created. Immutable.
+   4. A ControlFlowContext has _context_stack.
+      Pushed and popped by ctxt.Enter() and ctxt.Exit()
+  """
+
+  def __init__(self, values_def=None, import_scope=None):
+    self._nested_contexts = []
+    self._outer_context = ops.get_default_graph()._get_control_flow_context()
+    if self._outer_context:
+      self._outer_context._nested_contexts.append(self)  # pylint: disable=protected-access
+    self._context_stack = []
+    if values_def:
+      self._init_values_from_proto(values_def, import_scope=import_scope)
+    else:
+      # The names of tensors that have been already seen in this context.
+      self._values = set()
+      # The keys are the names of tensors referenced by but external to this
+      # context. Each value is the Tensor that should be used by this context to
+      # access the key value (e.g. a switch output guarding a cond input value).
+      self._external_values = {}
+
+  def _init_values_from_proto(self, values_def, import_scope=None):
+    """Initializes values and external_values from `ValuesDef` protocol buffer.
+
+    Args:
+      values_def: `ValuesDef` protocol buffer.
+      import_scope: Optional `string`. Name scope to add.
+    """
+    assert isinstance(values_def, control_flow_pb2.ValuesDef)
+    self._values = set(
+        ops.prepend_name_scope(value, import_scope)
+        for value in values_def.values)
+    g = ops.get_default_graph()
+    self._external_values = {}
+    for k, v in values_def.external_values.items():
+      k = ops.prepend_name_scope(k, import_scope)
+      self._external_values[k] = g.as_graph_element(
+          ops.prepend_name_scope(v, import_scope))
+    op_names = set([
+        op.split(":")[0]
+        for op in self._values - set(self._external_values.keys())
+    ])
+    for op in op_names:
+      # pylint: disable=protected-access
+      g.as_graph_element(op)._set_control_flow_context(self)
+      # pylint: enable=protected-access
+
+  @property
+  def name(self):
+    return self._name
+
+  @property
+  def outer_context(self):
+    """Return the context containing this context."""
+    return self._outer_context
+
+  @property
+  def grad_state(self):
+    raise NotImplementedError("Abstract method")
+
+  @property
+  def back_prop(self):
+    raise NotImplementedError("Abstract method")
+
+  @abc.abstractmethod
+  def to_control_flow_context_def(self, context_def, export_scope=None):
+    """Serializes this into `context_def`.
+
+    Args:
+      context_def: a `ControlFlowContextDef` protocol buffer.
+      export_scope: Optional `string`. Name scope to remove.
+    """
+    raise NotImplementedError("Abstract method")
+
+  def _to_values_def(self, export_scope=None):
+    """Converts the values to a `ValuesDef` protocol buffer.
+
+    Args:
+      export_scope: Optional `string`. Name scope to remove.
+
+    Returns:
+      A `ValuesDef` protocol buffer.
+    """
+    values_def = control_flow_pb2.ValuesDef()
+    values_def.values.extend(
+        [ops.strip_name_scope(v, export_scope) for v in sorted(self._values)])
+    for k, v in self._external_values.items():
+      k = ops.strip_name_scope(k, export_scope)
+      values_def.external_values[k] = ops.strip_name_scope(v.name, export_scope)
+    return values_def
+
+  def AddName(self, name):
+    self._values.add(name)
+
+  # pylint: disable=protected-access
+  def Enter(self):
+    """Enter this control flow context."""
+    graph = ops.get_default_graph()
+    self._context_stack.append(graph._get_control_flow_context())
+    graph._set_control_flow_context(self)
+
+  def Exit(self):
+    """Exit this control flow context."""
+    graph = ops.get_default_graph()
+    last_context = self._context_stack.pop()
+    graph._set_control_flow_context(last_context)
+
+  def EnterGradientColocation(self, op: ops.Operation, gradient_uid):
+    """Start building a gradient colocated with an op."""
+    if self._outer_context:
+      self._outer_context.EnterGradientColocation(op, gradient_uid)
+
+  def ExitGradientColocation(self, op: ops.Operation, gradient_uid):
+    """Start building a gradient colocated with an op."""
+    if self._outer_context:
+      self._outer_context.ExitGradientColocation(op, gradient_uid)
+
+  def ExitResult(self, result):
+    """Make a list of tensors available in the outer context."""
+    if self._outer_context:
+      def fn(x):
+        self._outer_context.AddName(x.name)
+        return x
+      nest.map_structure(fn, result, expand_composites=True)
+
+  def GetWhileContext(self):
+    """Return the while context containing this context."""
+    if self._outer_context:
+      return self._outer_context.GetWhileContext()
+    return None
+
+  def _RemoveExternalControlEdges(self, op: ops.Operation):
+    """Remove any external control dependency on this op."""
+    while_ctxt = self.GetWhileContext()
+    # A control input of `op` is internal if it is in the same while
+    # loop context as the enclosing while loop context of self.
+    if while_ctxt is None:
+      internal_control_inputs, external_control_inputs = op.control_inputs, []
+    else:
+      internal_control_inputs, external_control_inputs = [], []
+      for x in op.control_inputs:
+        ctxt = util.GetOutputContext(x)
+        if ctxt is not None and ctxt.GetWhileContext() == while_ctxt:
+          internal_control_inputs.append(x)
+        else:
+          external_control_inputs.append(x)
+    if len(internal_control_inputs) != len(op.control_inputs):
+      # TODO(mdan): perhaps there should be a replace_control_inputs()
+      op._remove_all_control_inputs()
+      op._add_control_inputs(internal_control_inputs)
+    return internal_control_inputs, external_control_inputs
+
+  # pylint: enable=protected-access
+
+  def AddInnerOp(self, op: ops.Operation):
+    """Notifies a scope about an operator added to an inner scope."""
+    if self._outer_context:
+      self._outer_context.AddInnerOp(op)
+
+  def GetControlPivot(self):
+    """Returns the pivot node for this context, or None."""
+    return None
+
+  def IsWhileContext(self):
+    return False
+
+  def IsCondContext(self):
+    return False
+
+  def IsXLAContext(self):
+    return False
+
+  def __str__(self):
+    return self.name
+
+
+class CondContext(ControlFlowContext):
+  """The context for the conditional construct."""
+
+  def __init__(self,
+               pred=None,
+               pivot=None,
+               branch=None,
+               name="cond_text",
+               context_def=None,
+               import_scope=None):
+    """Creates a `CondContext`.
+
+    Args:
+      pred: The `boolean` tensor for the conditional predicate.
+      pivot: The predicate tensor in this branch.
+      branch: 0 or 1 representing this branch.
+      name: Name of the `CondContext` python object.
+      context_def: Optional `ContextDef` protocol buffer to initialize the
+        `CondContext` object from.
+      import_scope: Optional `string`. Name scope to add. Only used when
+        initialing from protocol buffer.
+    """
+    self._name = ops.get_default_graph().unique_name(name)
+
+    if context_def:
+      self._init_from_proto(context_def, import_scope=import_scope)
+    else:
+      # Initializes the default fields.
+      ControlFlowContext.__init__(self)
+      self._pred = pred  # The boolean tensor for the cond predicate
+      self._pivot = pivot  # The predicate tensor in this branch
+      self._branch = branch  # 0 or 1 representing this branch
+
+      # Values considered to have been already seen in this context. pred is not
+      # included in this context.
+      self._values.add(pred.name)
+      self._external_values[pred.name] = pred
+      self._values.add(pivot.name)
+      pivot.op._set_control_flow_context(self)  # pylint: disable=protected-access
+
+  def _init_from_proto(self, context_def, import_scope=None):
+    """Creates a new `CondContext` from protocol buffer.
+
+    Args:
+      context_def: `CondContextDef` protocol buffer.
+      import_scope: Optional `string`. Name scope to add.
+    """
+    assert isinstance(context_def, control_flow_pb2.CondContextDef)
+    # Create from context_def.
+    g = ops.get_default_graph()
+    self._name = ops.prepend_name_scope(context_def.context_name, import_scope)
+    self._pred = g.as_graph_element(
+        ops.prepend_name_scope(context_def.pred_name, import_scope))
+    self._pivot = g.as_graph_element(
+        ops.prepend_name_scope(context_def.pivot_name, import_scope))
+    self._branch = context_def.branch
+    super(CondContext, self).__init__(
+        values_def=context_def.values_def, import_scope=import_scope)
+
+  @property
+  def pred(self):
+    return self._pred
+
+  @property
+  def pivot(self):
+    return self._pivot
+
+  @property
+  def branch(self):
+    return self._branch
+
+  @property
+  def grad_state(self):
+    if self.GetWhileContext():
+      return self.GetWhileContext().grad_state
+    return None
+
+  @property
+  def back_prop(self):
+    if self.GetWhileContext():
+      return self.GetWhileContext().back_prop
+    return False
+
+  def GetControlPivot(self):
+    return self._pivot
+
+  def to_proto(self, export_scope=None):
+    """Converts a `CondContext` to a `CondContextDef` protocol buffer.
+
+    Args:
+      export_scope: Optional `string`. Name scope to remove.
+
+    Returns:
+      A `CondContextDef` protocol buffer.
+    """
+    if (export_scope is None or self.name.startswith(export_scope)):
+      context_def = control_flow_pb2.CondContextDef()
+      context_def.context_name = ops.strip_name_scope(self.name, export_scope)
+      context_def.pred_name = ops.strip_name_scope(self._pred.name,
+                                                   export_scope)
+      context_def.pivot_name = ops.strip_name_scope(self._pivot.name,
+                                                    export_scope)
+      context_def.branch = self._branch
+      context_def.values_def.MergeFrom(
+          super(CondContext, self)._to_values_def(export_scope))
+      for nested in self._nested_contexts:
+        nested_def = context_def.nested_contexts.add()
+        nested.to_control_flow_context_def(nested_def)
+
+      return context_def
+    else:
+      return None
+
+  @staticmethod
+  def from_proto(context_def, import_scope=None):
+    """Returns a `CondContext` object created from `context_def`."""
+    ret = CondContext(context_def=context_def, import_scope=import_scope)
+
+    ret.Enter()
+    for nested_def in context_def.nested_contexts:
+      from_control_flow_context_def(nested_def, import_scope=import_scope)
+    ret.Exit()
+    return ret
+
+  def to_control_flow_context_def(self, context_def, export_scope=None):
+    context_def.cond_ctxt.CopyFrom(self.to_proto(export_scope=export_scope))
+
+  def AddValue(self, val):
+    """Add `val` to the current context and its outer context recursively."""
+    if val.name in self._values:
+      # Use the real value if it comes from outer context. This is needed in
+      # particular for nested conds.
+      result = self._external_values.get(val.name)
+      result = val if result is None else result
+    else:
+      result = val
+      self._values.add(val.name)
+      if self._outer_context:
+        result = self._outer_context.AddValue(val)
+        self._values.add(result.name)
+        self._external_values[result.name] = result
+      with ops.control_dependencies(None):
+        result = _SwitchRefOrTensor(result, self._pred)[self._branch]
+        if self._outer_context:
+          self._outer_context.AddInnerOp(result.op)
+
+      result.op.graph.prevent_fetching(result.op)
+      # pylint: disable=protected-access
+      result.op._set_control_flow_context(self)
+      # pylint: enable=protected-access
+
+      # Mark Switch output as seen by this context and any outer contexts,
+      # just like what we do for normal op outputs in _AddOpInternal() below.
+      ctxt = self
+      while ctxt is not None:
+        # pylint: disable=protected-access
+        ctxt._values.add(result.name)
+        ctxt = ctxt._outer_context
+        # pylint: enable=protected-access
+
+      self._external_values[val.name] = result
+    return result
+
+  def AddOp(self, op: ops.Operation):
+    self._AddOpInternal(op)
+
+  def _AddOpInternal(self, op: ops.Operation):
+    """Add `op` to the current context."""
+    if not op.inputs:
+      # If we're in a while loop, remove any control inputs from outside the
+      # loop.
+      self._RemoveExternalControlEdges(op)
+
+      if not any(
+          util.OpInContext(input_op, self) for input_op in op.control_inputs):
+        # pylint: disable=protected-access
+        op._add_control_input(self._pivot.op)
+        # pylint: enable=protected-access
+    else:
+      # Make each input to 'op' available in this CondContext. If an input is
+      # already part of this context there's nothing to do, but if it's
+      # external, AddValue() will handle adding the appropriate Switch node and
+      # other bookkeeping.
+      for index in range(len(op.inputs)):
+        x = op.inputs[index]
+        if op.type == "Merge" and x.op.type == "NextIteration":
+          # Edge case: if we're importing a while loop inside this CondContext,
+          # AddValue() will not correctly handle the NextIteration inputs to
+          # Merge node. The problem is that the NextIteration should also be
+          # part of this context, but if we're importing it won't have been
+          # processed and added to the context yet, so AddValue() will try to
+          # add a Switch which results in an invalid graph. Instead, we use the
+          # NextIteration input as-is here, and it will eventually be added to
+          # the context via AddOp().
+          real_x = x
+        else:
+          real_x = self.AddValue(x)
+        if real_x != x:
+          # pylint: disable=protected-access
+          op._update_input(index, real_x)
+          # pylint: enable=protected-access
+      # Remove any external control dependency on this op.
+      self._RemoveExternalControlEdges(op)
+      # pylint: disable=protected-access
+      if op.graph._is_function(op.type) or op.type == "SymbolicGradient":
+        op._add_control_input(self._pivot.op)
+      # pylint: enable=protected-access
+
+    # Mark op's outputs as seen by this context and any outer contexts.
+    output_names = [x.name for x in op.outputs]
+    ctxt = self
+    while ctxt is not None:
+      # pylint: disable=protected-access
+      ctxt._values.update(output_names)
+      ctxt = ctxt._outer_context
+      # pylint: enable=protected-access
+
+    if self._outer_context or not util.IsLoopExit(op):
+      op.graph.prevent_fetching(op)
+
+    if self._outer_context:
+      self._outer_context.AddInnerOp(op)
+
+  def _ProcessOutputTensor(self, val):
+    """Process an output tensor of a conditional branch."""
+    real_val = val
+    if val.name not in self._values:
+      # Handle the special case of lambda: x
+      self._values.add(val.name)
+      if self._outer_context:
+        real_val = self._outer_context.AddValue(val)
+        self._values.add(real_val.name)
+        self._external_values[real_val.name] = real_val
+      real_val = _SwitchRefOrTensor(real_val, self._pred)[self._branch]
+      self._external_values[val.name] = real_val
+    else:
+      external_val = self._external_values.get(val.name)
+      if external_val is not None:
+        real_val = external_val
+    return real_val
+
+  def _BuildCondTensor(self, v):
+    if isinstance(v, ops.Operation):
+      # Use pivot as the proxy for this op.
+      return with_dependencies([v], self._pivot)
+    else:
+      v = nest.map_structure(
+          _convert_tensorarray_to_flow, v, expand_composites=True)
+      return self._ProcessOutputTensor(ops.convert_to_tensor(v))
+
+  def BuildCondBranch(self, fn):
+    """Add the subgraph defined by fn() to the graph."""
+    pre_summaries = ops.get_collection(ops.GraphKeys._SUMMARY_COLLECTION)  # pylint: disable=protected-access
+    original_result = fn()
+    post_summaries = ops.get_collection(ops.GraphKeys._SUMMARY_COLLECTION)  # pylint: disable=protected-access
+    if len(post_summaries) > len(pre_summaries):
+      new_summaries = post_summaries[len(pre_summaries):]
+      summary_ref = ops.get_collection_ref(ops.GraphKeys._SUMMARY_COLLECTION)  # pylint: disable=protected-access
+      summary_ref[:] = pre_summaries
+      with ops.control_dependencies(new_summaries):
+        if original_result is None:
+          return no_op(), None
+        elif not isinstance(original_result, ops.Operation):
+          original_result = variable_utils.convert_variables_to_tensors(
+              original_result)
+          original_result = nest.map_structure(
+              array_ops.identity, original_result, expand_composites=True)
+    if original_result is None:
+      return None, None
+
+    original_result = variable_utils.convert_variables_to_tensors(
+        original_result)
+    result = nest.map_structure(
+        self._BuildCondTensor, original_result, expand_composites=True)
+    if not isinstance(result, (list, _basetuple)):
+      result = [result]
+    return original_result, result
+
+  def IsCondContext(self):
+    return True
+
+
+# pylint: enable=g-doc-args
+# pylint: enable=redefined-outer-name
+
+
+def _resource_safe_shape(t):
+  """Returns the shape of t or the variable it points to."""
+  if t.dtype == dtypes.resource:
+    while t.op.inputs:
+      t = t.op.inputs[0]
+    return tensor_shape.TensorShape(t.op.get_attr("shape"))
+  return array_ops.shape_internal(t, optimize=False)
+
+
+# TODO(yuanbyu): Consider having a unified notion of context for
+# not only conditionals and loops but also control dependency and
+# subgraphs.
+class WhileContext(ControlFlowContext):
+  """The context for the loop construct."""
+
+  def __init__(self,
+               maximum_iterations=None,
+               parallel_iterations=10,
+               back_prop=True,
+               swap_memory=False,
+               name="while_context",
+               grad_state=None,
+               context_def=None,
+               import_scope=None):
+    """"Creates a `WhileContext`.
+
+    Args:
+      maximum_iterations: Optional upper bound on number of loop iterations.
+      parallel_iterations: The number of iterations allowed to run in parallel.
+      back_prop: Whether backprop is enabled for this while loop.
+      swap_memory: Whether GPU-CPU memory swap is enabled for this loop.
+      name: Optional name prefix for the returned tensors.
+      grad_state: The gradient loop state.
+      context_def: Optional `WhileContextDef` protocol buffer to initialize the
+        `Whilecontext` python object from.
+      import_scope: Optional `string`. Name scope to add. Only used when
+        initialing from protocol buffer.
+    """
+    if context_def:
+      self._init_from_proto(context_def, import_scope=import_scope)
+    else:
+      ControlFlowContext.__init__(self)
+      self._init_from_args(maximum_iterations, parallel_iterations, back_prop,
+                           swap_memory, name)
+    # The gradient loop state.
+    self._grad_state = grad_state
+
+  def _init_from_args(self, maximum_iterations, parallel_iterations, back_prop,
+                      swap_memory, name):
+    """Creates a new `WhileContext` from arguments.
+
+    Args:
+      maximum_iterations: Optional upper bound on number of loop iterations.
+      parallel_iterations: The number of iterations allowed to run in parallel.
+      back_prop: Whether backprop is enabled for this while loop.
+      swap_memory: Whether GPU-CPU memory swap is enabled for this loop.
+      name: Optional name prefix for the returned tensors.
+
+    Raises:
+      ValueError: If `parallel_iterations` has invalid value.
+    """
+    if not isinstance(parallel_iterations, int) or (parallel_iterations <= 0):
+      raise ValueError("'parallel_iterations' must be a positive integer: "
+                       "%s" % parallel_iterations)
+    self._name = ops.get_default_graph().unique_name(name)
+    self._maximum_iterations = maximum_iterations
+    self._parallel_iterations = parallel_iterations
+    self._back_prop = back_prop
+    self._swap_memory = swap_memory
+    # We use this node to control constants created by the pred lambda.
+    self._pivot_for_pred = None
+    # We use this node to control constants created by the body lambda.
+    self._pivot_for_body = None
+    # The boolean tensor for loop termination condition. Used in code
+    # generation for gradient computation
+    self._pivot = None
+    # The list of exit tensors for loop variables.
+    self._loop_exits = []
+    # The list of enter tensors for loop variables.
+    self._loop_enters = []
+    self._graph = ops.get_default_graph()
+
+  def _init_from_proto(self, context_def, import_scope=None):
+    """Creates a new `WhileContext` from protocol buffer.
+
+    Args:
+      context_def: `WhileContextDef` protocol buffer.
+      import_scope: Optional `string`. Name scope to add.
+    """
+    assert isinstance(context_def, control_flow_pb2.WhileContextDef)
+    # Create from context_def.
+    g = ops.get_default_graph()
+    self._name = ops.prepend_name_scope(context_def.context_name, import_scope)
+    if context_def.maximum_iterations_name:
+      self._maximum_iterations = g.as_graph_element(
+          ops.prepend_name_scope(context_def.maximum_iterations_name,
+                                 import_scope))
+    else:
+      self._maximum_iterations = None
+    self._parallel_iterations = context_def.parallel_iterations
+    self._back_prop = context_def.back_prop
+    self._swap_memory = context_def.swap_memory
+    self._pivot_for_pred = g.as_graph_element(
+        ops.prepend_name_scope(context_def.pivot_for_pred_name, import_scope))
+    # We use this node to control constants created by the body lambda.
+    self._pivot_for_body = g.as_graph_element(
+        ops.prepend_name_scope(context_def.pivot_for_body_name, import_scope))
+    # The boolean tensor for loop termination condition. Used in code
+    # generation for gradient computation.
+    self._pivot = g.as_graph_element(
+        ops.prepend_name_scope(context_def.pivot_name, import_scope))
+    # The list of exit tensors for loop variables.
+    self._loop_exits = [
+        g.as_graph_element(ops.prepend_name_scope(exit_name, import_scope))
+        for exit_name in context_def.loop_exit_names
+    ]
+    # The list of enter tensors for loop variables.
+    self._loop_enters = [
+        g.as_graph_element(ops.prepend_name_scope(enter_name, import_scope))
+        for enter_name in context_def.loop_enter_names
+    ]
+    super(WhileContext, self).__init__(
+        values_def=context_def.values_def, import_scope=import_scope)
+
+    # import_scope causes self.name to be different from the original serialized
+    # context's name. Rewrite "frame_name" attrs with the new name.
+    if import_scope:
+      for tensor_name in self._values:
+        op = g.as_graph_element(tensor_name).op
+        if util.IsLoopEnter(op):
+          # pylint: disable=protected-access
+          op._set_attr("frame_name",
+                       attr_value_pb2.AttrValue(s=compat.as_bytes(self.name)))
+          # pylint: enable=protected-access
+    self._graph = ops.get_default_graph()
+
+  @property
+  def maximum_iterations(self):
+    """The maximum number of iterations that will be executed."""
+    return self._maximum_iterations
+
+  @property
+  def parallel_iterations(self):
+    """The number of iterations allowed to run in parallel."""
+    return self._parallel_iterations
+
+  @property
+  def back_prop(self):
+    """True iff backprop is enabled for this while loop."""
+    return self._back_prop
+
+  @property
+  def swap_memory(self):
+    """True iff GPU-CPU memory swap is enabled for this while loop."""
+    return self._swap_memory
+
+  @property
+  def pivot(self):
+    """The boolean tensor representing the loop termination condition."""
+    return self._pivot
+
+  @property
+  def loop_enters(self):
+    """The list of enter tensors for loop variables."""
+    return self._loop_enters
+
+  @property
+  def loop_exits(self):
+    """The list of exit tensors for loop variables."""
+    return self._loop_exits
+
+  @property
+  def grad_state(self):
+    """The gradient loop state."""
+    return self._grad_state
+
+  def to_proto(self, export_scope=None):
+    """Converts a `WhileContext` to a `WhileContextDef` protocol buffer.
+
+    Args:
+      export_scope: Optional `string`. Name scope to remove.
+
+    Returns:
+      A `WhileContextDef` protocol buffer.
+    """
+    if (export_scope is None or self.name.startswith(export_scope)):
+      context_def = control_flow_pb2.WhileContextDef()
+      context_def.context_name = ops.strip_name_scope(self.name, export_scope)
+      context_def.parallel_iterations = self._parallel_iterations
+      if self._maximum_iterations is not None:
+        context_def.maximum_iterations_name = ops.strip_name_scope(
+            self._maximum_iterations.name, export_scope)
+      context_def.back_prop = self._back_prop
+      context_def.swap_memory = self._swap_memory
+      context_def.pivot_for_pred_name = ops.strip_name_scope(
+          self._pivot_for_pred.name, export_scope)
+      context_def.pivot_for_body_name = ops.strip_name_scope(
+          self._pivot_for_body.name, export_scope)
+      context_def.pivot_name = ops.strip_name_scope(self._pivot.name,
+                                                    export_scope)
+      context_def.loop_exit_names.extend([
+          ops.strip_name_scope(l.name, export_scope) for l in self._loop_exits
+      ])
+      context_def.loop_enter_names.extend([
+          ops.strip_name_scope(l.name, export_scope) for l in self._loop_enters
+      ])
+      context_def.values_def.MergeFrom(
+          super(WhileContext, self)._to_values_def(export_scope=export_scope))
+      for nested in self._nested_contexts:
+        nested_def = context_def.nested_contexts.add()
+        nested.to_control_flow_context_def(nested_def)
+
+      return context_def
+    else:
+      return None
+
+  def to_control_flow_context_def(self, context_def, export_scope=None):
+    context_def.while_ctxt.CopyFrom(self.to_proto(export_scope=export_scope))
+
+  @staticmethod
+  def from_proto(context_def, import_scope=None):
+    """Returns a `WhileContext` object created from `context_def`.
+
+    Args:
+      context_def: A `WhileContextDef` protocol buffer.
+      import_scope: Optional `string`. Name scope to add.
+
+    Returns:
+      A `WhileContext` Python object.
+    """
+    ret = WhileContext(context_def=context_def, import_scope=import_scope)
+    ret.Enter()
+    for nested_def in context_def.nested_contexts:
+      from_control_flow_context_def(nested_def, import_scope=import_scope)
+    ret.Exit()
+    return ret
+
+  def GetWhileContext(self):
+    return self
+
+  def GetControlPivot(self):
+    if self._pivot_for_body is not None:
+      return self._pivot_for_body
+    return self._pivot_for_pred
+
+  def AddValue(self, val):
+    """Add `val` to the current context and its outer context recursively."""
+    result = val
+    new_value = val.name not in self._values
+    # Don't treat ops in this context as new values. Usually all known values
+    # are in self._values, except when we're importing a while loop inside this
+    # WhileContext. Since there's a cycle in this case, `val` may be part of the
+    # imported while loop but not yet processed by this context and added to
+    # self._values in _AddOpInternal. We only want to process external input
+    # tensors to the while loop here.
+    new_value &= val.op._control_flow_context is not self  # pylint: disable=protected-access
+    if new_value:
+      self._values.add(val.name)
+
+      # If we are in a grad context and val is from its forward context,
+      # use GetRealValue(), which adds the logic to save the history of
+      # val in forward.
+      grad_ctxt = ops.get_default_graph()._get_control_flow_context()
+      if grad_ctxt:
+        grad_ctxt = grad_ctxt.GetWhileContext()
+        if grad_ctxt.grad_state:
+          forward_ctxt = util.GetWhileContext(val.op)
+          if util.IsLoopExit(val.op):
+            forward_ctxt = forward_ctxt.outer_context
+            if forward_ctxt:
+              forward_ctxt = forward_ctxt.GetWhileContext()
+          if forward_ctxt == grad_ctxt.grad_state.forward_context:
+            real_val = grad_ctxt.grad_state.GetRealValue(val)
+            self._external_values[val.name] = real_val
+            return real_val
+
+      if self._outer_context is not None:
+        result = self._outer_context.AddValue(val)
+      # Create an Enter to make `result` known to this loop context.
+      with ops.control_dependencies(None):
+        enter = _Enter(
+            result,
+            self._name,
+            is_constant=True,
+            parallel_iterations=self._parallel_iterations)
+        enter.graph.prevent_feeding(enter)
+        if self._outer_context:
+          self._outer_context.AddInnerOp(enter.op)
+      # Fix the control inputs and control flow context of these enter ops.
+      self._FixControlInputsAndContext([enter])
+
+      # Add `enter` in this context.
+      self._values.add(enter.name)
+      self._external_values[val.name] = enter
+      result = enter
+    else:
+      actual_val = self._external_values.get(val.name)
+      if actual_val is not None:
+        result = actual_val
+    return result
+
+  def AddOp(self, op: ops.Operation):
+    """Add `op` to the current context."""
+    # For a reduction op, if op is in a grad context and its input is from
+    # its forward context, moving op to the forward context means we would
+    # store the tensor after the reduction as opposed to the tensor before
+    # reduction, and therefore could significantly reduce memory consumption.
+    # For now, we do this only for a few ops.
+    #
+    # If in XLA context, do not move constant ops to forward pass as pushing to
+    # and popping from a stack removes the constant property of an op and breaks
+    # XLA compilation, which requires certain inputs to be constant for certain
+    # ops.
+    if not util.IsInXLAContext(op) and op.type in {"Shape", "Size", "Rank"}:
+      grad_ctxt = ops.get_default_graph()._get_control_flow_context()
+      if grad_ctxt:
+        grad_ctxt = grad_ctxt.GetWhileContext()
+        if grad_ctxt.grad_state:
+          op_input_forward_ctxt = util.GetWhileContext(op.inputs[0].op)
+          if op_input_forward_ctxt == grad_ctxt.grad_state.forward_context:
+            op_input_ctxt = op.inputs[0].op._get_control_flow_context()
+            op._set_control_flow_context(op_input_ctxt)
+            op_input_ctxt._AddOpInternal(op)
+            return
+    self._AddOpInternal(op)
+
+  #  pylint: disable=g-doc-args
+  def _AddOpInternal(self, op: ops.Operation):
+    """Add `op` to the current context.
+
+    We move any external control dependencies of the op to the loop pivot, to
+    ensure they get executed.
+    """
+    # This is needed to prevent frame mismatch errors where there are Const
+    # nodes inside tf.function in v1 while_loop and inlining is turned on.
+    if op.type in ["PartitionedCall", "StatefulPartitionedCall"]:
+      op._add_control_input(self.GetControlPivot().op)  # pylint: disable=protected-access
+    if not op.inputs:
+      # Remove any external control dependency on this op
+      control_inputs, external_inputs = self._RemoveExternalControlEdges(op)
+      # Add a control edge from the control pivot to this op.
+      if not control_inputs:
+        # pylint: disable=protected-access
+        op._add_control_input(self.GetControlPivot().op)
+        # pylint: enable=protected-access
+      for x in op.outputs:
+        self._values.add(x.name)
+    else:
+      for index in range(len(op.inputs)):
+        x = op.inputs[index]
+        real_x = self.AddValue(x)
+        if real_x != x:
+          op._update_input(index, real_x)  # pylint: disable=protected-access
+      # Remove any external control dependency on this op.
+      _, external_inputs = self._RemoveExternalControlEdges(op)
+      # Add a control dependency to prevent loop invariants from
+      # enabling ops that should not be executed.
+      self._MaybeAddControlDependency(op)
+      for x in op.outputs:
+        self._values.add(x.name)
+    if external_inputs:
+      # Use an identity to pull control inputs as data inputs. Note that we
+      # ignore ops which don't have outputs. TODO(apassos): fix that
+      with ops.control_dependencies(None):
+        self.Enter()
+        external_inputs = [
+            array_ops.identity(x.outputs[0]).op
+            for x in external_inputs
+            if x.outputs
+        ]
+        self.Exit()
+      op._add_control_inputs(external_inputs)  # pylint: disable=protected-access
+    if self._outer_context or not util.IsLoopExit(op):
+      op.graph.prevent_fetching(op)
+      for x in op.outputs:
+        op.graph.prevent_feeding(x)
+
+    if self._outer_context:
+      self._outer_context.AddInnerOp(op)
+
+  def _MaybeAddControlDependency(self, op: ops.Operation):
+    """Add a control input to the op if it only depends on loop invariants."""
+
+    def _IsOpFree(op):
+      """Determines if `op` needs a control dependency."""
+      if op.control_inputs:
+        return False
+      # pylint: disable=protected-access
+      if op.graph._is_function(op.type) or op.type == "SymbolicGradient":
+        return True
+      # pylint: enable=protected-access
+      for x in op.inputs:
+        if not util.IsLoopConstantEnter(x.op):
+          return False
+      return True
+
+    if _IsOpFree(op):
+      # pylint: disable=protected-access
+      op._add_control_input(self.GetControlPivot().op)
+      # pylint: enable=protected-access
+
+  def AddForwardLoopCounter(self, outer_grad_state):
+    """Adds a loop that counts the number of iterations.
+
+    This is added to the forward loop at the time when we start to
+    create the loop for backprop gradient computation. Called in
+    the outer context of this forward context.
+
+    The pseudocode is:
+      `n = 0; while (_pivot) { n++; }`
+
+    Note that a control dependency is added to `n` to ensure the correct
+    execution order of stack push ops.
+
+    Args:
+      outer_grad_state: The outer grad state. None if not nested.
+
+    Returns:
+      The number of iterations taken by the forward loop and the loop index.
+    """
+    n = constant_op.constant(0, name="f_count")
+    if outer_grad_state is not None:
+      # Force the stack pushes of i-th execution of an inner loop to be ordered
+      # before the pushes of (i+1)-th execution of the same inner loop.
+      outer_add_op = outer_grad_state.forward_index.op.inputs[0].op
+      n.op._add_control_input(outer_add_op)  # pylint: disable=protected-access
+
+    self.Enter()
+    self.AddName(n.name)
+    enter_n = _Enter(
+        n,
+        self._name,
+        is_constant=False,
+        parallel_iterations=self._parallel_iterations,
+        name="f_count")
+    self.loop_enters.append(enter_n)
+
+    merge_n = merge([enter_n, enter_n])[0]
+    switch_n = switch(merge_n, self._pivot)
+
+    index = math_ops.add(switch_n[1], 1)
+    next_n = _NextIteration(index)
+    merge_n.op._update_input(1, next_n)
+
+    total_iterations = exit(switch_n[0], name="f_count")
+    self.loop_exits.append(total_iterations)
+    self.ExitResult([total_iterations])
+    self.Exit()
+    return total_iterations, next_n
+
+  def AddBackpropLoopCounter(self, count, outer_grad_state):
+    """Add the backprop loop that controls the iterations.
+
+    This is added to the backprop loop. It is used to control the loop
+    termination of the backprop loop. Called in the outer context of
+    this grad context.
+
+    The pseudocode is:
+      `n = count; while (n >= 1) { n--; }`
+
+    Note that a control dependency is added to `final_zero` to ensure the
+    correct execution order of stack pop ops.
+
+    Args:
+      count: The number of iterations for backprop.
+      outer_grad_state: The outer grad state. None if not nested.
+
+    Returns:
+      The loop index.
+    """
+    in_separate_functions = count.graph is not ops.get_default_graph()
+    if in_separate_functions:
+      # Brings the count into this graph
+      count = array_ops.identity(count)
+    else:
+      # TODO(apassos) XLA expects this constant to be created outside the loop,
+      # so doing that for now.
+      one = constant_op.constant(1, name="b_count")
+
+    self.Enter()
+    self.AddName(count.name)
+    enter_count = _Enter(
+        count,
+        self._name,
+        is_constant=False,
+        parallel_iterations=self._parallel_iterations,
+        name="b_count")
+    self.loop_enters.append(enter_count)
+
+    merge_count = merge([enter_count, enter_count])[0]
+    self._pivot_for_pred = merge_count
+
+    if in_separate_functions:
+      one = constant_op.constant(1, name="b_count")
+    pred = math_ops.greater_equal(merge_count, one)
+    self._pivot = loop_cond(pred, name="b_count")
+    switch_count = switch(merge_count, self._pivot)
+
+    index = math_ops.subtract(switch_count[1], one)
+    self._pivot_for_body = index
+    next_count = _NextIteration(index)
+    merge_count.op._update_input(1, next_count)
+
+    final_zero = exit(switch_count[0], name="b_count")
+    self.loop_exits.append(final_zero)
+    if outer_grad_state is not None:
+      # Force the stack pops of i-th execution of an inner loop to be ordered
+      # before the pops of (i+1)-th execution of the same inner loop.
+      # pylint: disable=protected-access
+      outer_grad_state.grad_sync._add_control_input(final_zero.op)
+      # pylint: enable=protected-access
+
+    self.ExitResult([final_zero])
+    self.Exit()
+    return next_count
+
+  def AddBackpropAccumulator(self, op: ops.Operation, grad):
+    """Add an accumulation loop for every loop invariant.
+
+    This is added to the backprop loop. It is used to accumulate partial
+    gradients within each loop iteration. Called when in the gradient while
+    context.
+
+    The pseudocode is:
+      ```
+      acc = 0.0;
+      while (_pivot) {
+        acc += grad;
+      }
+      ```
+
+    Args:
+      op: The Enter op for a loop invariant.
+      grad: The partial gradient of an iteration for a loop invariant.
+
+    Returns:
+      The gradient for a loop invariant.
+    """
+    self.Exit()
+    # Create a zeros tensor with the right shape for acc. If we don't
+    # know the full shape statically, we will have to get the shape
+    # dynamically from the forward inference. Getting the shape right
+    # for the zeros is only needed for the base case when the loop exits
+    # without running any iterations.
+    shape = grad.get_shape()
+    if shape.is_fully_defined():
+      if self.outer_context:
+        self.outer_context.Enter()
+      acc = constant_op.constant(0, grad.dtype, shape=shape, name="b_acc")
+      if self.outer_context:
+        self.outer_context.Exit()
+    else:
+      value = op.inputs[0]
+      if (isinstance(self.outer_context, WhileContext) and
+          self.outer_context.grad_state is not None):
+        # We are in a nested while loop.
+        forward_ctxt = self.grad_state.forward_context
+        forward_ctxt.outer_context.Enter()
+        zeros_shape = array_ops.shape_internal(value, optimize=False)
+        forward_ctxt.outer_context.Exit()
+        outer_grad_state = self.grad_state.outer_grad_state
+        history_zeros_shape = outer_grad_state.AddForwardAccumulator(
+            zeros_shape)
+        self.outer_context.Enter()
+        real_shape = outer_grad_state.AddBackpropAccumulatedValue(
+            history_zeros_shape, zeros_shape)
+        acc = array_ops.zeros(real_shape, grad.dtype)
+        self.outer_context.Exit()
+      else:
+        if self.outer_context:
+          self.outer_context.Enter()
+        zeros_shape = array_ops.shape_internal(value, optimize=False)
+        acc = array_ops.zeros(zeros_shape, grad.dtype)
+        if self.outer_context:
+          self.outer_context.Exit()
+
+    self.Enter()
+    self.AddName(acc.name)
+    enter_acc = _Enter(
+        acc,
+        self._name,
+        is_constant=False,
+        parallel_iterations=self._parallel_iterations,
+        name="b_acc")
+    self.loop_enters.append(enter_acc)
+
+    merge_acc = merge([enter_acc, enter_acc], name="b_acc")[0]
+    switch_acc_false, switch_acc_true = switch(merge_acc, self._pivot)
+
+    add_acc = math_ops.add(switch_acc_true, grad)
+    next_acc = _NextIteration(add_acc)
+    merge_acc.op._update_input(1, next_acc)  # pylint: disable=protected-access
+
+    result_acc = exit(switch_acc_false, name="b_acc")
+    self.loop_exits.append(result_acc)
+    self.ExitResult([result_acc])
+    return result_acc
+
+  def AddBackpropIndexedSlicesAccumulator(self, op: ops.Operation, grad):
+    """This is used for accumulating gradients that are IndexedSlices.
+
+    This is essentially the equivalent of AddBackpropAccumulator but optimized
+    for things like updating embeddings from within a while loop.
+
+    Args:
+      op: The Enter op for a loop invariant.
+      grad: The partial gradients represented as an IndexedSlices.
+
+    Returns:
+      The accumulated IndexedSlices gradient of the loop invariant.
+    """
+    values = grad.values
+    indices = grad.indices
+    dense_shape = grad.dense_shape
+
+    self.Exit()
+    if self.outer_context:
+      self.outer_context.Enter()
+    if values.get_shape().is_fully_defined():
+      values_shape = tensor_shape.TensorShape([tensor_shape.Dimension(1)] +
+                                              values.get_shape().dims[1:])
+      if self.outer_context:
+        self.outer_context.Enter()
+      values_acc = constant_op.constant(
+          0, values.dtype, shape=values_shape, name="b_acc")
+      if self.outer_context:
+        self.outer_context.Exit()
+    else:
+      values_shape = _resource_safe_shape(op.inputs[0])[1:]
+      values_shape = array_ops.concat([[1], values_shape], 0)
+      values_acc = array_ops.zeros(values_shape, dtype=values.dtype)
+    indices_acc = constant_op.constant([0], indices.dtype)
+    shape_acc = None
+    if dense_shape is not None:
+      if dense_shape.get_shape().is_fully_defined():
+        if self.outer_context:
+          self.outer_context.Enter()
+        shape_acc = constant_op.constant(
+            0, dense_shape.dtype, shape=dense_shape.get_shape())
+        if self.outer_context:
+          self.outer_context.Exit()
+      else:
+        shape_acc = array_ops.zeros_like(
+            array_ops.shape_internal(
+                op.inputs[0], optimize=False, out_type=dense_shape.dtype),
+            optimize=False)
+
+    if self.outer_context:
+      self.outer_context.Exit()
+
+    self.Enter()
+    self.AddName(values_acc.name)
+    self.AddName(indices_acc.name)
+    init_acc = [indices_acc, values_acc]
+    if shape_acc is not None:
+      self.AddName(shape_acc.name)
+      init_acc.append(shape_acc)
+
+    # Set use_input_shape=False since the accumulator tensors will grow in
+    # size. If use_input_shape=True, the _update_input call below will result in
+    # incompatible shapes.
+    enter_acc = [
+        _Enter(
+            x,
+            self._name,
+            is_constant=False,
+            parallel_iterations=self._parallel_iterations,
+            use_input_shape=False,
+            name="b_acc") for x in init_acc
+    ]
+    # Manually set appropriate partial shapes.
+    enter_acc[0].set_shape([None])
+    if values_acc.shape.dims is not None:
+      enter_acc[1].set_shape([None] + values_acc.shape.as_list()[1:])
+    self.loop_enters.extend(enter_acc)
+
+    merge_acc = [merge([x, x], name="b_acc")[0] for x in enter_acc]
+    switch_acc = [switch(x, self._pivot) for x in merge_acc]
+
+    # The actual accumulation.
+    acc_indexed_slices = [
+        array_ops.concat([xa[1], xv], 0)
+        for xa, xv in zip(switch_acc[:2], [indices, values])
+    ]
+    if shape_acc is not None:
+      # For the shape we just keep the maximum
+      acc_indexed_slices.append(math_ops.maximum(dense_shape, switch_acc[2][1]))
+
+    next_acc = [_NextIteration(x) for x in acc_indexed_slices]
+    for xm, xn in zip(merge_acc, next_acc):
+      xm.op._update_input(1, xn)  # pylint: disable=protected-access
+
+    exit_acc = [exit(x[0], name="b_acc") for x in switch_acc]
+    self.loop_exits.extend(exit_acc)
+
+    self.ExitResult(exit_acc)
+    return indexed_slices.IndexedSlices(
+        indices=exit_acc[0],
+        values=exit_acc[1],
+        dense_shape=exit_acc[2] if shape_acc is not None else None)
+
+  def _InitializeValues(self, values):
+    """Makes the values known to this context."""
+    self._values = set()
+    for x in values:
+      if isinstance(x, tensor_lib.Tensor):
+        self._values.add(x.name)
+      else:
+        raise TypeError("'values' must be a list of Tensors. "
+                        f"Received: {type(x)}.")
+
+  def _BuildLoop(self, pred, body, flat_orig_loop_vars, flat_loop_vars,
+                 loop_vars_signature):
+    """Core: Add the loop termination condition and body to the graph."""
+    flat_shape_invariants = nest.map_structure(
+        lambda spec: spec.shape,
+        nest.flatten(loop_vars_signature, expand_composites=True))
+
+    # Let the context know the loop variables so the loop variables
+    # would be added in the outer contexts properly.
+    self._InitializeValues(flat_loop_vars)
+    if self._outer_context:
+      real_vars = [self._outer_context.AddValue(x) for x in flat_loop_vars]
+    else:
+      real_vars = flat_loop_vars
+
+    enter_vars = []
+    with ops.control_dependencies(None):
+      for real_var, shape_invariant in zip(real_vars, flat_shape_invariants):
+        enter_var = _Enter(
+            real_var,
+            self._name,
+            is_constant=False,
+            parallel_iterations=self._parallel_iterations,
+            use_input_shape=False)
+
+        if _ShapeLessThanOrEqual(real_var.get_shape(), shape_invariant):
+          enter_var.set_shape(shape_invariant)
+        else:
+          raise ValueError(
+              f"The shape invariant specified for {real_var.name} is not "
+              "compatible with the initial shape of the loop variable. It "
+              f"enters the loop with shape {real_var.get_shape()}, but the "
+              f"specified shape invariant is {shape_invariant}.")
+
+        enter_var.graph.prevent_feeding(enter_var)
+        if self._outer_context:
+          self._outer_context.AddInnerOp(enter_var.op)
+        enter_vars.append(enter_var)
+
+    # Finds the closest enclosing non-None control pivot.
+    outer_context = self._outer_context
+    control_pivot = None
+    while outer_context is not None and control_pivot is None:
+      control_pivot = outer_context.GetControlPivot()
+      # pylint: disable=protected-access
+      outer_context = outer_context._outer_context
+      # pylint: enable=protected-access
+
+    if control_pivot is not None:
+      for var in enter_vars:
+        if util.IsLoopConstantEnter(var.op.inputs[0].op):
+          # pylint: disable=protected-access
+          var.op._add_control_input(control_pivot.op)
+          # pylint: enable=protected-access
+
+    # Fix the control inputs and control flow context of these enter ops.
+    self._FixControlInputsAndContext(enter_vars)
+    self._InitializeValues(enter_vars)
+    self._loop_enters = enter_vars
+
+    merge_vars = [merge([x, x])[0] for x in enter_vars]
+    self._pivot_for_pred = merge_vars[0]
+
+    merge_vars_with_tensorarrays = nest.map_structure(
+        _convert_flow_to_tensorarray, flat_orig_loop_vars, merge_vars)
+    # Build the graph for pred.
+    packed_vars = nest.pack_sequence_as(
+        structure=loop_vars_signature,
+        flat_sequence=merge_vars_with_tensorarrays,
+        expand_composites=True)
+    c = ops.convert_to_tensor(pred(*packed_vars))
+    self._pivot = loop_cond(c, name="LoopCond")
+    switch_vars = [_SwitchRefOrTensor(x, self._pivot) for x in merge_vars]
+
+    # Build the graph for body.
+    vars_for_body = [_Identity(x[1]) for x in switch_vars]
+    self._pivot_for_body = vars_for_body[0]
+    # Convert TensorArray flow variables inside the context back into
+    # their associated TensorArrays for calling the body.
+    vars_for_body_with_tensorarrays = nest.map_structure(
+        _convert_flow_to_tensorarray, flat_orig_loop_vars, vars_for_body)
+    packed_vars_for_body = nest.pack_sequence_as(
+        structure=loop_vars_signature,
+        flat_sequence=vars_for_body_with_tensorarrays,
+        expand_composites=True)
+    pre_summaries = ops.get_collection(ops.GraphKeys._SUMMARY_COLLECTION)  # pylint: disable=protected-access
+    body_result = body(*packed_vars_for_body)
+    post_summaries = ops.get_collection(ops.GraphKeys._SUMMARY_COLLECTION)  # pylint: disable=protected-access
+    if not nest.is_nested(body_result):
+      body_result = [body_result]
+    if len(post_summaries) > len(pre_summaries):
+      new_summaries = post_summaries[len(pre_summaries):]
+      summary_ref = ops.get_collection_ref(ops.GraphKeys._SUMMARY_COLLECTION)  # pylint: disable=protected-access
+      summary_ref[:] = pre_summaries
+      with ops.control_dependencies(new_summaries):
+
+        def map_fn(x):
+          # TODO(apassos) figure out how to trigger with tensor arrays as well
+          if isinstance(x, tensor_array_ops.TensorArray):
+            return x
+          return array_ops.identity(x)
+
+        body_result = nest.map_structure(
+            map_fn, body_result, expand_composites=True)
+
+    body_result = variable_utils.convert_variables_to_tensors(body_result)
+    # Compare the structure types of input and output of body.
+    # For backwards compatibility, the first layer is forced to a list
+    # during this comparison, because inputs are typically lists and
+    # outputs of the body are typically tuples.
+    nest.assert_same_structure(
+        list(packed_vars_for_body), list(body_result), expand_composites=True)
+
+    # Store body_result to keep track of TensorArrays returned by body
+    original_body_result = body_result
+    # Convert TensorArrays returned by body into their flow variables
+    result = nest.map_structure(
+        _convert_tensorarray_to_flow,
+        nest.flatten(body_result, expand_composites=True),
+        expand_composites=True)
+    result = ops.convert_n_to_tensor_or_composite(result)
+
+    # Add NextIteration and the back edges to complete the loop.
+    if len(merge_vars) != len(result):
+      raise ValueError("Number of inputs and outputs of 'body' must match "
+                       f"'loop_vars'. Got {len(merge_vars)} for the number of "
+                       f"inputs/outputs, and {len(result)} for 'loop_vars'.")
+    next_vars = []
+    for m, v in zip(merge_vars, result):
+      next_vars.append(_AddNextAndBackEdge(m, v))
+
+    # Add the exit ops.
+    exit_vars = [exit(x[0]) for x in switch_vars]
+    self._loop_exits = exit_vars
+
+    # Exit the loop.
+    self.ExitResult(exit_vars)
+
+    return original_body_result, exit_vars
+
+  def BuildLoop(self, pred, body, loop_vars, shape_invariants,
+                return_same_structure):
+    """Add the loop termination condition and body to the graph."""
+
+    # Keep flat_orig_loop_vars to identify which are TensorArrays
+    flat_orig_loop_vars = nest.flatten(loop_vars, expand_composites=True)
+
+    loop_vars = nest.map_structure(
+        _convert_to_tensor_or_composite_or_tensorarray, loop_vars)
+    # Convert TensorArrays to their flow variables
+    flat_loop_vars = nest.map_structure(
+        _convert_tensorarray_to_flow,
+        nest.flatten(loop_vars, expand_composites=True))
+
+    if shape_invariants is not None:
+      loop_vars_signature = nest.map_structure(
+          _shape_invariant_to_type_spec, loop_vars, shape_invariants)
+    else:
+      loop_vars_signature = nest.map_structure(
+          _shape_invariant_to_type_spec, loop_vars)
+
+    try:
+      self.Enter()
+      # _BuildLoop calls _update_input in several places. _mutation_lock()
+      # ensures a Session.run call cannot occur between creating and mutating
+      # new ops.
+      with ops.get_default_graph()._mutation_lock():  # pylint: disable=protected-access
+        original_body_result, exit_vars = self._BuildLoop(
+            pred, body, flat_orig_loop_vars, flat_loop_vars,
+            loop_vars_signature)
+    finally:
+      self.Exit()
+
+    flat_result = nest.flatten(original_body_result, expand_composites=True)
+    # Convert TensorArray flow variables outside the context back into
+    # their associated TensorArrays for returning to caller.
+    exit_vars_with_tensorarrays = nest.map_structure(
+        _convert_flow_to_tensorarray, flat_result, exit_vars)
+
+    packed_exit_vars = nest.pack_sequence_as(
+        structure=original_body_result,
+        flat_sequence=exit_vars_with_tensorarrays,
+        expand_composites=True)
+
+    if return_same_structure:
+      return packed_exit_vars
+    else:
+      return packed_exit_vars[0] if len(exit_vars) == 1 else packed_exit_vars
+
+  def _FixControlInputsAndContext(self, enters):
+    graph = ops.get_default_graph()
+    # pylint: disable=protected-access
+    for e in enters:
+      if isinstance(e, tensor_lib.Tensor):
+        xs = [e]
+      else:
+        raise TypeError("'enters' must be a list of Tensors. "
+                        f"Received: {type(e)}.")
+      for x in xs:
+        inp_op = x.op.inputs[0].op
+        control_inputs = graph._control_dependencies_for_inputs([inp_op])
+        outer_control_inputs = []
+        for op in control_inputs:
+          # We need to keep control inputs that are in any ancestor
+          # ControlFlowContext, and within outer WhileContext.
+          keep_as_control_input = True
+          op_ctxt = util.GetOutputContext(op)
+          outer_ctxt = self.outer_context
+          outer_while_context = (None if outer_ctxt is None else
+                                 outer_ctxt.GetWhileContext())
+          while outer_ctxt != op_ctxt:
+            if outer_ctxt is None or outer_ctxt == outer_while_context:
+              keep_as_control_input = False
+              break
+            outer_ctxt = outer_ctxt.outer_context
+          if keep_as_control_input:
+            outer_control_inputs.append(op)
+        x.op._set_control_flow_context(self)
+        x.op._add_control_inputs(outer_control_inputs)
+        graph._record_op_seen_by_control_dependencies(x.op)
+    # pylint: enable=protected-access
+
+  def IsWhileContext(self):
+    return True
+
+
+# pylint: enable=redefined-outer-name
+
+
+def _AsTensorList(x, p):
+  """Return x as a list of Tensors or IndexedSlices.
+
+  For entries of `x` that are Operations, this returns an Identity of `p`
+  with a dependency on the operation.
+
+  Args:
+    x: A Tensor/IndexedSlices/Operation or a list or tuple of them.
+    p: A Tensor to return for entries in `x` that are Operations.
+
+  Returns:
+    A list of Tensors or IndexedSlices.
+  """
+  if not isinstance(x, (list, _basetuple)):
+    x = [x]
+
+  l = []
+  for v in x:
+    if isinstance(v, ops.Operation):
+      v = with_dependencies([v], p)
+    v = ops.convert_to_tensor_or_composite(v)
+    if isinstance(v, tensor_lib.Tensor):
+      l.append(array_ops.identity(v))
+    else:
+      l.append(
+          indexed_slices.IndexedSlices(
+              array_ops.identity(v.values), array_ops.identity(v.indices)))
+  return l
+
+
+def _CheckResults(a, b):
+  assert len(a) == len(b), (
+      "Values returned by a() and b() must have the same length.")
+  for x, y in zip(a, b):
+    assert x.dtype == y.dtype, (
+        "Values returned by a() [%s] and b() [%s] must have "
+        "the same type: %s, %s." % (x.name, y.name, x.dtype.name, y.dtype.name))
+
+
+def with_dependencies(dependencies, output_tensor, name=None):
+  """Produces the content of `output_tensor` only after `dependencies`.
+
+  In some cases, a user may want the output of an operation to be
+  consumed externally only after some other dependencies have run
+  first. This function ensures returns `output_tensor`, but only after all
+  operations in `dependencies` have run. Note that this means that there is
+  no guarantee that `output_tensor` will be evaluated after any `dependencies`
+  have run.
+
+  See also `tf.tuple` and `tf.group`.
+
+  Args:
+    dependencies: Iterable of operations to run before this op finishes.
+    output_tensor: A `Tensor` or `IndexedSlices` that will be returned.
+    name: (Optional) A name for this operation.
+
+  Returns:
+    Same as `output_tensor`.
+
+  Raises:
+    TypeError: if `output_tensor` is not a `Tensor` or `IndexedSlices`.
+  """
+  if context.executing_eagerly():
+    return output_tensor
+  with ops.name_scope(name, "control_dependency",
+                      list(dependencies) + [output_tensor]) as name:
+    with ops.colocate_with(output_tensor):
+      with ops.control_dependencies(dependencies):
+        output_tensor = ops.convert_to_tensor_or_composite(output_tensor)
+        if isinstance(output_tensor, indexed_slices.IndexedSlices):
+          return indexed_slices.IndexedSlices(
+              _Identity(output_tensor.values, name=name), output_tensor.indices,
+              output_tensor.dense_shape)
+        else:
+          return _Identity(output_tensor, name=name)
+
+
+def _GroupControlDeps(dev, deps, name=None):
+  with ops.control_dependencies(deps):
+    if dev is None:
+      return no_op(name=name)
+    else:
+      with ops.device(dev):
+        return no_op(name=name)
+
+
+# TODO(touts): Accept "inputs" as a list.
+@tf_export("group")
+def group(*inputs, **kwargs):
+  """Create an op that groups multiple operations.
+
+  When this op finishes, all ops in `inputs` have finished. This op has no
+  output.
+
+  Note: *In TensorFlow 2 with eager and/or Autograph, you should not require
+  this method, as ops execute in the expected order thanks to automatic control
+  dependencies.* Only use `tf.group` when working with v1
+  `tf.Graph` code.
+
+  When operating in a v1-style graph context, ops are not executed in the same
+  order as specified in the code; TensorFlow will attempt to execute ops in
+  parallel or in an order convenient to the result it is computing.  `tf.group`
+  allows you to request that one or more results finish before execution
+  continues.
+
+  `tf.group` creates a single op (of type `NoOp`), and then adds appropriate
+  control dependencies.  Thus, `c = tf.group(a, b)` will compute the same graph
+  as this:
+
+      with tf.control_dependencies([a, b]):
+          c = tf.no_op()
+
+  See also `tf.tuple` and
+  `tf.control_dependencies`.
+
+  Args:
+    *inputs: Zero or more tensors to group.
+    name: A name for this operation (optional).
+
+  Returns:
+    An Operation that executes all its inputs.
+
+  Raises:
+    ValueError: If an unknown keyword argument is provided.
+  """
+  if context.executing_eagerly():
+    return None
+  name = kwargs.pop("name", None)
+  if kwargs:
+    raise ValueError("Unknown keyword arguments: " + ", ".join(kwargs.keys()))
+  with ops.name_scope(name, "group_deps", inputs) as name:
+    # Grouping no inputs means do nothing
+    if not inputs:
+      return no_op(name=name)
+
+    # Sorts *inputs according to their devices.
+    ops_on_device = {}  # device -> operations specified on the device.
+    for inp in nest.flatten(inputs, expand_composites=True):
+      if not hasattr(inp, "device"):
+        raise TypeError("'inputs' should be zero or more (nested) Tensors. "
+                        f"Received '{inp}' with type '{type(inp)}'.")
+      dev = inp.device
+      if dev in ops_on_device:
+        ops_on_device[dev].append(inp)
+      else:
+        ops_on_device[dev] = [inp]
+    if len(ops_on_device) == 1:
+      # 1-level tree. The root node is the returned NoOp node.
+      (dev, deps), = ops_on_device.items()
+      return _GroupControlDeps(dev, deps, name=name)
+
+    # 2-level tree. The root node is the returned NoOp node.
+    # deps contains 1 NoOp node for each device.
+    deps = []
+
+    def device_key(dev):
+      """A sort key that allows None to be compared to strings."""
+      return "" if dev is None else dev
+
+    for dev in sorted(ops_on_device, key=device_key):
+      deps.append(_GroupControlDeps(dev, ops_on_device[dev]))
+
+    with ops.control_dependencies(deps):
+      return no_op(name=name)
+
+
+@tf_export("tuple", v1=[])
+@dispatch.add_dispatch_support
+def tuple_v2(tensors, control_inputs=None, name=None):
+  """Groups tensors together.
+
+  The returned tensors have the same value as the input tensors, but they
+  are computed only after all the input tensors have been computed.
+
+  Note: *In TensorFlow 2 with eager and/or Autograph, you should not require
+  this method, as ops execute in the expected order thanks to automatic control
+  dependencies.* Only use `tf.tuple` when working with v1 `tf.Graph` code.
+
+  See also `tf.group` and `tf.control_dependencies`.
+
+  Example:
+  >>> with tf.Graph().as_default():
+  ...   with tf.compat.v1.Session() as sess:
+  ...     v = tf.Variable(0.0)
+  ...     a = tf.constant(1.0)
+  ...     sess.run(tf.compat.v1.global_variables_initializer())
+  ...     for i in range(5):
+  ...       update_op = v.assign_add(1.0)
+  ...       b = a + v
+  ...       res_b = sess.run(b)
+  ...       res_v = sess.run(v)
+  ...       print(res_v)
+  0.0
+  0.0
+  0.0
+  0.0
+  0.0
+
+  >>> with tf.Graph().as_default():
+  ...   with tf.compat.v1.Session() as sess:
+  ...     v = tf.Variable(0.0)
+  ...     a = tf.constant(1.0)
+  ...     sess.run(tf.compat.v1.global_variables_initializer())
+  ...     for i in range(5):
+  ...       update_op = v.assign_add(1.0)
+  ...       calc = [a + v]
+  ...       # `tf.tuple` ensures `update_op` is run before `b`
+  ...       b = tf.tuple(calc, [tf.group(update_op)])
+  ...       res_b = sess.run(b)
+  ...       res_v = sess.run(v)
+  ...       print(res_v)
+  1.0
+  2.0
+  3.0
+  4.0
+  5.0
+
+
+  Args:
+    tensors: A list of `Tensor`s or `IndexedSlices`, some entries can be `None`.
+    control_inputs: List of additional ops to finish before returning.
+    name: (optional) A name to use as a `name_scope` for the operation.
+
+  Returns:
+    Same as `tensors`.
+
+  Raises:
+    ValueError: If `tensors` does not contain any `Tensor` or `IndexedSlices`.
+    TypeError: If `control_inputs` is not a list of `Operation` or `Tensor`
+      objects.
+
+  """
+  return tuple(tensors=tensors, name=name, control_inputs=control_inputs)  # pylint: disable=redefined-builtin
+
+
+@tf_export(v1=["tuple"])
+@dispatch.add_dispatch_support
+def tuple(tensors, name=None, control_inputs=None):  # pylint: disable=redefined-builtin
+  """Group tensors together.
+
+  This creates a tuple of tensors with the same values as the `tensors`
+  argument, except that the value of each tensor is only returned after the
+  values of all tensors have been computed.
+
+  `control_inputs` contains additional ops that have to finish before this op
+  finishes, but whose outputs are not returned.
+
+  This can be used as a "join" mechanism for parallel computations: all the
+  argument tensors can be computed in parallel, but the values of any tensor
+  returned by `tuple` are only available after all the parallel computations
+  are done.
+
+  See also `tf.group` and
+  `tf.control_dependencies`.
+
+  Args:
+    tensors: A list of `Tensor`s or `IndexedSlices`, some entries can be `None`.
+    name: (optional) A name to use as a `name_scope` for the operation.
+    control_inputs: List of additional ops to finish before returning.
+
+  Returns:
+    Same as `tensors`.
+
+  Raises:
+    ValueError: If `tensors` does not contain any `Tensor` or `IndexedSlices`.
+    TypeError: If `control_inputs` is not a list of `Operation` or `Tensor`
+      objects.
+
+  """
+  if context.executing_eagerly():
+    return tensors
+  with ops.name_scope(name, "tuple", tensors) as name:
+    tensors = [
+        t if (isinstance(t, ops.Operation) or tensor_util.is_tf_type(t) or
+              t is None) else ops.convert_to_tensor(t) for t in tensors
+    ]
+    gating_ops = [
+        t if isinstance(t, ops.Operation) else t.op
+        for t in tensors
+        if t is not None
+    ]
+    if control_inputs:
+      for c in control_inputs:
+        if isinstance(c, tensor_lib.Tensor):
+          c = c.op
+        elif not isinstance(c, ops.Operation):
+          raise TypeError(
+              "'control_inputs' must only contain Operation or Tensor. "
+              f"Received: {type(c)}")
+        gating_ops.append(c)
+    # Note that in order to ensure ordering in the pbtxt, we must take care to
+    # ensure the order here.
+    gating_ops = sorted(set(gating_ops), key=lambda op: op._id)  # Uniquify ops.
+    if not gating_ops:
+      raise ValueError("'tensors' must have at least one Tensor. "
+                       f"Received: {tensors}.")
+    gate = group(*gating_ops)
+    tpl = []
+    for t in tensors:
+      if tensor_util.is_tf_type(t):
+        tpl.append(with_dependencies([gate], t))
+      elif isinstance(t, ops.Operation):
+        with ops.control_dependencies([gate]):
+          tpl.append(group(t))
+      else:
+        tpl.append(None)
+    return tpl
+
+
+class XLAControlFlowContext(ControlFlowContext):
+  """Base class for XLA and TPU control flow contexts."""
+
+  def __init__(self):
+    super(XLAControlFlowContext, self).__init__()
+    self._name = "XLAControlFlowContext"
+
+  def to_control_flow_context_def(self, context_def, export_scope=None):
+    # pylint: disable=useless-super-delegation
+    # NOTE(slebedev): the method is required by `ControlFlowContext`.
+    super(XLAControlFlowContext,
+          self).to_control_flow_context_def(context_def, export_scope)
+
+  def IsXLAContext(self):
+    return True
+
+  def AddOp(self, _):
+    pass
+
+  def AddValue(self, x):
+    return x
+
+  def RequiresUniqueFunctionRetracing(self):
+    """Returns whether the tf.function should be retraced if the context changes.
+    """
+    return False
+
+
+@tf_export("__internal__.get_enclosing_xla_context", v1=[])
+def get_enclosing_xla_context():
+  """Recursively find and return the XLAControlFlowContext."""
+  graph = ops.get_default_graph()
+  while graph is not None:
+    # pylint: disable=protected-access
+    context_ = graph._get_control_flow_context()
+    # pylint: enable=protected-access
+    while context_ is not None:
+      if isinstance(context_, XLAControlFlowContext):
+        return context_
+      context_ = context_.outer_context
+    # This may be a FuncGraph due to defuns or v2 control flow. We need to
+    # find the original graph with the XLAControlFlowContext.
+    graph = getattr(graph, "outer_graph", None)
+  return None
+
+
+def from_control_flow_context_def(context_def, import_scope=None):
+  """Deserializes `context_def` into the appropriate ControlFlowContext.
+
+  Args:
+    context_def: ControlFlowContextDef proto
+    import_scope: Optional `string`. Name scope to add.
+
+  Returns:
+    A ControlFlowContext subclass
+  """
+  if context_def.HasField("cond_ctxt"):
+    return CondContext.from_proto(
+        context_def.cond_ctxt, import_scope=import_scope)
+  if context_def.HasField("while_ctxt"):
+    return WhileContext.from_proto(
+        context_def.while_ctxt, import_scope=import_scope)
+  raise NotImplementedError("Unknown ControlFlowContextDef field: %s" %
+                            context_def.WhichOneof("ctxt"))
+
+
+ops.register_proto_function(
+    ops.GraphKeys.COND_CONTEXT,
+    proto_type=control_flow_pb2.CondContextDef,
+    to_proto=CondContext.to_proto,
+    from_proto=CondContext.from_proto)
+
+ops.register_proto_function(
+    ops.GraphKeys.WHILE_CONTEXT,
+    proto_type=control_flow_pb2.WhileContextDef,
+    to_proto=WhileContext.to_proto,
+    from_proto=WhileContext.from_proto)

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/control_flow_switch_case.py

@@ -0,0 +1,253 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Switch case for Control Flow Operations."""
+
+from tensorflow.python.eager import context
+from tensorflow.python.framework import ops
+from tensorflow.python.framework import tensor
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import cond_v2
+from tensorflow.python.ops import control_flow_util as util
+from tensorflow.python.ops import gen_functional_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.util.tf_export import tf_export
+
+
+def _indexed_case_verify_and_canonicalize_args(branch_fns, default,
+                                               branch_index):
+  """Verifies input arguments for the case function.
+
+  Args:
+    branch_fns: Dict or list of pairs of an `int` and a callable which returns a
+      list of tensors.
+    default: Optional callable that returns a list of tensors.
+    branch_index: Optional int `Tensor`, which selects for the corresponding
+      pred_fn_pair.
+
+  Raises:
+    TypeError: If `branch_fns` is not a list/dictionary.
+    TypeError: If `branch_fns` is a list but does not contain 2-tuples or
+               callables.
+    TypeError: If `fns[i]` is not callable for any i, or `default` is not
+               callable.
+
+  Returns:
+    branch_fns: validated list of callables for each branch (default last).
+  """
+  if not isinstance(branch_index, tensor.Tensor):
+    raise TypeError("'branch_index' must be a Tensor, got {}".format(
+        type(branch_index)))
+  if not branch_index.dtype.is_integer:
+    raise TypeError("'branch_index' must be an integer Tensor, got {}".format(
+        branch_index.dtype))
+
+  if not branch_fns:
+    raise ValueError("Must provide at least one item in 'branch_fns'")
+  if not isinstance(branch_fns, (list, tuple, dict)):
+    raise TypeError("'branch_fns' must be a list, tuple, or dict")
+
+  if isinstance(branch_fns, dict):
+    branch_fns = branch_fns.items()
+
+  if all(callable(fn) for fn in branch_fns):
+    branch_fns = list(enumerate(branch_fns))
+
+  for key_fn_pair in branch_fns:
+    if not isinstance(key_fn_pair, tuple) or len(key_fn_pair) != 2:
+      raise TypeError("Each entry in 'branch_fns' must be a 2-tuple. "
+                      f"Received {key_fn_pair}.")
+    key, branch_fn = key_fn_pair
+
+    if not isinstance(key, int):
+      raise TypeError("key must be a Python `int`, got {}".format(type(key)))
+
+    if not callable(branch_fn):
+      raise TypeError("fn for key {} must be callable.".format(key))
+
+  keys = [p[0] for p in branch_fns]
+  if min(keys) < 0 or max(keys) >= len(keys) or len(set(keys)) != len(keys):
+    raise ValueError(
+        "branch indices (keys) must form contiguous range of [0 to {}) but "
+        "found {{{}}}".format(len(keys), ",".join(map(str, sorted(keys)))))
+  actions = [p[1] for p in sorted(branch_fns)]
+  if default is not None:
+    actions.append(default)
+  return actions
+
+
+def _indexed_case_helper(branch_fns,
+                         default,
+                         branch_index,
+                         name,
+                         lower_using_switch_merge=None):
+  """Implementation of case that emits the n-way indexed Case op.
+
+  Args:
+    branch_fns: Dict or list of pairs of a boolean scalar tensor, and a callable
+      which returns a list of tensors.
+    default: Optional callable that returns a list of tensors.
+    branch_index: Optional int `Tensor`, which selects for the corresponding
+      pred_fn_pair.
+    name: A name for this operation (optional).
+    lower_using_switch_merge: Lower this op using switch merge ops (optional).
+
+  Returns:
+    The tensors returned by the pair whose key matched branch_index, or
+    those returned by `default` if none does.
+
+  Raises:
+    TypeError: If `branch_fns` is not a list/dictionary.
+    TypeError: If `branch_fns` is a list but does not contain 2-tuples or
+               callables.
+    TypeError: If `fns[i]` is not callable for any i, or `default` is not
+               callable.
+  """
+  branch_fns = _indexed_case_verify_and_canonicalize_args(
+      branch_fns, default, branch_index)
+  with ops.name_scope(name, "case", [branch_index]):
+    if context.executing_eagerly() and not hasattr(branch_index, "graph"):
+      branch_index = array_ops.where(
+          math_ops.less(branch_index, 0)
+          | math_ops.greater_equal(branch_index, len(branch_fns)),
+          len(branch_fns) - 1, branch_index)
+      return branch_fns[int(branch_index)]()
+    return cond_v2.indexed_case(
+        branch_index,
+        branch_fns,
+        lower_using_switch_merge=lower_using_switch_merge)
+
+
+@tf_export("__internal__.execute_fn_for_device", v1=[])
+def execute_fn_for_device(device_branch_fns, default_fn, name="execute_fn"):
+  """Executes one of the provided callables based on the device placement.
+
+  This API is used when the implementations for high level function depend on
+  the underlying device placement. It takes a dictionary of device type to
+  callables. The device type includes "CPU", "GPU", "TPU", etc. When the type of
+  the device where to run this op matches the key in 'device_branch_fns',
+  the corresponding callable is executed, falling back to 'default_fn' if none
+  matches.
+
+  **Example:**
+  ```python
+  def f1(): return tf.constant(1)
+  def f2(): return tf.constant(2)
+  r = tf.execute_fn_for_device({"CPU": f1, "GPU": f2}, default_fn=f1)
+  ```
+  'r' is evaluated as 1 when it runs on CPU, 2 running on GPU, 1 running on
+  any other device types.
+
+
+  Args:
+    device_branch_fns: a dictionary of device types to the callables. Each
+      callable must return a matching structure of tensors.
+    default_fn: fallback callable when the underlying device does not match any
+      key in the 'device_branch_fns'.
+    name: A name for this operation (optional).
+
+  Returns:
+    The tensors returned by the callable identified by device type during
+    execution, or those returned by 'default_fn' if no key matches.
+  """
+  # Always execute the default fn for XLA to avoid complicated graph by case op.
+  # see more discussions in b/167276293.
+  is_in_xla = util.GraphOrParentsInXlaContext(ops.get_default_graph())
+  if is_in_xla:
+    return default_fn()
+  device_branch_fns_upper = {k.upper(): v for k, v in device_branch_fns.items()}
+  branch_fns = list(device_branch_fns_upper.values())
+  devices = list(device_branch_fns_upper.keys())
+  device_index = gen_functional_ops.device_index(device_names=devices)
+  return _indexed_case_helper(
+      branch_fns,
+      default_fn,
+      device_index,
+      name,
+      lower_using_switch_merge=False)
+
+
+@tf_export("switch_case")
+def switch_case(branch_index, branch_fns, default=None, name="switch_case"):
+  """Create a switch/case operation, i.e.
+
+  an integer-indexed conditional.
+
+  See also `tf.case`.
+
+  This op can be substantially more efficient than `tf.case` when exactly one
+  branch will be selected. `tf.switch_case` is more like a C++ switch/case
+  statement than `tf.case`, which is more like an if/elif/elif/else chain.
+
+  The `branch_fns` parameter is either a dict from `int` to callables, or list
+  of (`int`, callable) pairs, or simply a list of callables (in which case the
+  index is implicitly the key). The `branch_index` `Tensor` is used to select an
+  element in `branch_fns` with matching `int` key, falling back to `default`
+  if none match, or `max(keys)` if no `default` is provided. The keys must form
+  a contiguous set from `0` to `len(branch_fns) - 1`.
+
+  `tf.switch_case` supports nested structures as implemented in `tf.nest`. All
+  callables must return the same (possibly nested) value structure of lists,
+  tuples, and/or named tuples.
+
+  **Example:**
+
+  Pseudocode:
+
+  ```c++
+  switch (branch_index) {  // c-style switch
+    case 0: return 17;
+    case 1: return 31;
+    default: return -1;
+  }
+  ```
+  or
+  ```python
+  branches = {0: lambda: 17, 1: lambda: 31}
+  branches.get(branch_index, lambda: -1)()
+  ```
+
+  Expressions:
+
+  ```python
+  def f1(): return tf.constant(17)
+  def f2(): return tf.constant(31)
+  def f3(): return tf.constant(-1)
+  r = tf.switch_case(branch_index, branch_fns={0: f1, 1: f2}, default=f3)
+  # Equivalent: tf.switch_case(branch_index, branch_fns={0: f1, 1: f2, 2: f3})
+  ```
+
+  Args:
+    branch_index: An int Tensor specifying which of `branch_fns` should be
+      executed.
+    branch_fns: A `dict` mapping `int`s to callables, or a `list` of (`int`,
+      callable) pairs, or simply a list of callables (in which case the index
+      serves as the key). Each callable must return a matching structure of
+      tensors.
+    default: Optional callable that returns a structure of tensors.
+    name: A name for this operation (optional).
+
+  Returns:
+    The tensors returned by the callable identified by `branch_index`, or those
+    returned by `default` if no key matches and `default` was provided, or those
+    returned by the max-keyed `branch_fn` if no `default` is provided.
+
+  Raises:
+    TypeError: If `branch_fns` is not a list/dictionary.
+    TypeError: If `branch_fns` is a list but does not contain 2-tuples or
+               callables.
+    TypeError: If `fns[i]` is not callable for any i, or `default` is not
+               callable.
+  """
+  return _indexed_case_helper(branch_fns, default, branch_index, name)

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/control_flow_v2_func_graphs.py

@@ -0,0 +1,56 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""FuncGraphs for V2 control flow."""
+
+from tensorflow.python.framework import func_graph
+from tensorflow.python.framework import ops
+
+
+class ControlFlowFuncGraph(func_graph.FuncGraph):
+  """Contains control flow-specific FuncGraph logic."""
+
+  def __init__(self, *args, **kwargs):
+    super(ControlFlowFuncGraph, self).__init__(*args, **kwargs)
+    outer_graph = self.outer_graph
+    # Unlike tf.function, control flow FuncGraphs are generally created one per
+    # op. This means hard-coding any outer device scopes in the body (rather
+    # than inspecting the call-time placement of the control flow op) makes
+    # sense.
+    self._device_function_stack = outer_graph._device_function_stack.copy()  # pylint: disable=protected-access
+    self.is_control_flow_graph = True
+    if ops.executing_eagerly_outside_functions():
+      func_graph.override_func_graph_name_scope(
+          self, self.outer_graph.get_name_scope())
+
+
+class CondBranchFuncGraph(ControlFlowFuncGraph):
+  """FuncGraph for branches of tf.cond().
+
+  This is used to distinguish cond branches from other functions.
+  """
+
+
+class WhileCondFuncGraph(ControlFlowFuncGraph):
+  """FuncGraph for the condition of tf.while_loop().
+
+  This is used to distinguish while conditions from other functions.
+  """
+
+
+class WhileBodyFuncGraph(ControlFlowFuncGraph):
+  """FuncGraph for the body of tf.while_loop().
+
+  This is used to distinguish while bodies from other functions.
+  """

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/control_flow_v2_toggles.py

@@ -0,0 +1,69 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""API for enabling v2 control flow."""
+
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import control_flow_util
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.util.tf_export import tf_export
+
+
+@tf_export(v1=["enable_control_flow_v2"])
+def enable_control_flow_v2():  # pylint: disable=invalid-name
+  """Use control flow v2.
+
+  control flow v2 (cfv2) is an improved version of control flow in TensorFlow
+  with support for higher order derivatives. Enabling cfv2 will change the
+  graph/function representation of control flow, e.g., `tf.while_loop` and
+  `tf.cond` will generate functional `While` and `If` ops instead of low-level
+  `Switch`, `Merge` etc. ops. Note: Importing and running graphs exported
+  with old control flow will still be supported.
+
+  Calling tf.enable_control_flow_v2() lets you opt-in to this TensorFlow 2.0
+  feature.
+
+  Note: v2 control flow is always enabled inside of tf.function. Calling this
+  function is not required.
+  """
+  # pylint: disable=protected-access
+  logging.vlog(1, "Enabling control flow v2")
+  ops._control_flow_api_gauge.get_cell().set(True)
+  control_flow_util.ENABLE_CONTROL_FLOW_V2 = True
+
+
+@tf_export(v1=["disable_control_flow_v2"])
+def disable_control_flow_v2():  # pylint: disable=invalid-name
+  """Opts out of control flow v2.
+
+  Note: v2 control flow is always enabled inside of tf.function. Calling this
+  function has no effect in that case.
+
+  If your code needs tf.disable_control_flow_v2() to be called to work
+  properly please file a bug.
+  """
+  # pylint: disable=protected-access
+  logging.vlog(1, "Disabling control flow v2")
+  ops._control_flow_api_gauge.get_cell().set(False)
+  control_flow_util.ENABLE_CONTROL_FLOW_V2 = False
+
+
+@tf_export(v1=["control_flow_v2_enabled"])
+def control_flow_v2_enabled():  # pylint: disable=invalid-name
+  """Returns `True` if v2 control flow is enabled.
+
+  Note: v2 control flow is always enabled inside of tf.function.
+  """
+  return control_flow_util.EnableControlFlowV2(ops.get_default_graph())

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/custom_gradient.py

@@ -0,0 +1,823 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Decorator to overrides the gradient for a function."""
+
+from tensorflow.python.eager import backprop
+from tensorflow.python.eager import context
+from tensorflow.python.eager import record
+from tensorflow.python.framework import composite_tensor_gradient
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import gen_array_ops
+from tensorflow.python.ops import handle_data_util
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import op_selector
+from tensorflow.python.ops import resource_variable_ops
+from tensorflow.python.ops import variable_scope
+from tensorflow.python.ops.unconnected_gradients import UnconnectedGradients
+from tensorflow.python.platform import tf_logging as logging
+from tensorflow.python.util import nest
+from tensorflow.python.util import tf_decorator
+from tensorflow.python.util import tf_inspect
+from tensorflow.python.util import variable_utils
+from tensorflow.python.util.tf_export import tf_export
+
+
+VAR_OP_TYPES = [
+    "VariableV2",
+    "VarHandleOp",
+]
+
+
+@tf_export("custom_gradient")
+def custom_gradient(f=None):
+  """Decorator to define a function with a custom gradient.
+
+  This decorator allows fine grained control over the gradients of a sequence
+  for operations.  This may be useful for multiple reasons, including providing
+  a more efficient or numerically stable gradient for a sequence of operations.
+
+  For example, consider the following function that commonly occurs in the
+  computation of cross entropy and log likelihoods:
+
+  ```python
+  def log1pexp(x):
+    return tf.math.log(1 + tf.exp(x))
+  ```
+
+  Due to numerical instability, the gradient of this function evaluated at x=100
+  is NaN.  For example:
+
+  ```python
+  with tf.GradientTape() as tape:
+    tape.watch(x)
+    y=log1pexp(x)
+  dy_dx = tape.gradient(y, x) # Will be NaN when evaluated.
+  ```
+
+  The gradient expression can be analytically simplified to provide numerical
+  stability:
+
+  ```python
+  @tf.custom_gradient
+  def log1pexp(x):
+    e = tf.exp(x)
+    def grad(upstream):
+      return upstream * (1 - 1 / (1 + e))
+    return tf.math.log(1 + e), grad
+  ```
+
+  With this definition, the gradient `dy_dx` at `x = 100` will be correctly
+  evaluated as 1.0.
+
+  The variable `upstream` is defined as the upstream gradient. i.e. the gradient
+  from all the layers or functions originating from this layer. The above
+  example has no upstream functions, therefore `upstream = dy/dy = 1.0`.
+
+  Assume that `x_i` is `log1pexp` in the forward pass `x_1 = x_1(x_0)`,
+  `x_2 = x_2(x_1)`, ..., `x_i = x_i(x_i-1)`, ..., `x_n = x_n(x_n-1)`. By
+  chain rule we know that `dx_n/dx_0 = dx_n/dx_n-1 * dx_n-1/dx_n-2 * ... *
+  dx_i/dx_i-1 * ... * dx_1/dx_0`.
+
+  In this case the gradient of our current function defined as
+  `dx_i/dx_i-1 = (exp(x_i) / (1 + exp(x_i))) = (1 - 1 / (1 + exp(x_i)))`. The
+  upstream gradient `upstream` would be `dx_n/dx_n-1 * dx_n-1/dx_n-2 * ... *
+  dx_i+1/dx_i`. The upstream gradient multiplied by the current gradient is
+  then passed downstream.
+
+  In case the function takes multiple variables as input, the `grad`
+  function must also return  the same number of variables.
+  We take the function `z = x * y` as an example.
+
+  >>> @tf.custom_gradient
+  ... def bar(x, y):
+  ...   def grad(upstream):
+  ...     dz_dx = y
+  ...     dz_dy = x
+  ...     return upstream * dz_dx, upstream * dz_dy
+  ...   z = x * y
+  ...   return z, grad
+  >>> x = tf.constant(2.0, dtype=tf.float32)
+  >>> y = tf.constant(3.0, dtype=tf.float32)
+  >>> with tf.GradientTape(persistent=True) as tape:
+  ...   tape.watch(x)
+  ...   tape.watch(y)
+  ...   z = bar(x, y)
+  >>> z
+  <tf.Tensor: shape=(), dtype=float32, numpy=6.0>
+  >>> tape.gradient(z, x)
+  <tf.Tensor: shape=(), dtype=float32, numpy=3.0>
+  >>> tape.gradient(z, y)
+  <tf.Tensor: shape=(), dtype=float32, numpy=2.0>
+
+  Nesting custom gradients can lead to unintuitive results. The default
+  behavior does not correspond to n-th order derivatives. For example
+
+  ```python
+  @tf.custom_gradient
+  def op(x):
+    y = op1(x)
+    @tf.custom_gradient
+    def grad_fn(dy):
+      gdy = op2(x, y, dy)
+      def grad_grad_fn(ddy):  # Not the 2nd order gradient of op w.r.t. x.
+        return op3(x, y, dy, ddy)
+      return gdy, grad_grad_fn
+    return y, grad_fn
+  ```
+
+  The function `grad_grad_fn` will be calculating the first order gradient
+  of `grad_fn` with respect to `dy`, which is used to generate forward-mode
+  gradient graphs from backward-mode gradient graphs, but is not the same as
+  the second order gradient of `op` with respect to `x`.
+
+  Instead, wrap nested `@tf.custom_gradients` in another function:
+
+  ```python
+  @tf.custom_gradient
+  def op_with_fused_backprop(x):
+    y, x_grad = fused_op(x)
+    def first_order_gradient(dy):
+      @tf.custom_gradient
+      def first_order_custom(unused_x):
+        def second_order_and_transpose(ddy):
+          return second_order_for_x(...), gradient_wrt_dy(...)
+        return x_grad, second_order_and_transpose
+      return dy * first_order_custom(x)
+    return y, first_order_gradient
+  ```
+
+  Additional arguments to the inner `@tf.custom_gradient`-decorated function
+  control the expected return values of the innermost function.
+
+  The examples above illustrate how to specify custom gradients for functions
+  which do not read from variables. The following example uses variables, which
+  require special handling because they are effectively inputs of the forward
+  function.
+
+  >>> weights = tf.Variable(tf.ones([2]))  # Trainable variable weights
+  >>> @tf.custom_gradient
+  ... def linear_poly(x):
+  ...   # Creating polynomial
+  ...   poly = weights[1] * x + weights[0]
+  ...
+  ...   def grad_fn(dpoly, variables):
+  ...     # dy/dx = weights[1] and we need to left multiply dpoly
+  ...     grad_xs = dpoly * weights[1]  # Scalar gradient
+  ...
+  ...     grad_vars = []  # To store gradients of passed variables
+  ...     assert variables is not None
+  ...     assert len(variables) == 1
+  ...     assert variables[0] is weights
+  ...     # Manually computing dy/dweights
+  ...     dy_dw = dpoly * tf.stack([x ** 1, x ** 0])
+  ...     grad_vars.append(
+  ...         tf.reduce_sum(tf.reshape(dy_dw, [2, -1]), axis=1)
+  ...     )
+  ...     return grad_xs, grad_vars
+  ...   return poly, grad_fn
+  >>> x = tf.constant([1., 2., 3.])
+  >>> with tf.GradientTape(persistent=True) as tape:
+  ...   tape.watch(x)
+  ...   poly = linear_poly(x)
+  >>> poly # poly = x + 1
+  <tf.Tensor: shape=(3,),
+    dtype=float32,
+    numpy=array([2., 3., 4.], dtype=float32)>
+  >>> tape.gradient(poly, x)  # conventional scalar gradient dy/dx
+  <tf.Tensor: shape=(3,),
+    dtype=float32,
+    numpy=array([1., 1., 1.], dtype=float32)>
+  >>> tape.gradient(poly, weights)
+  <tf.Tensor: shape=(2,), dtype=float32, numpy=array([6., 3.], dtype=float32)>
+
+  Above example illustrates usage of trainable variable `weights`.
+  In the example, the inner `grad_fn` accepts an extra `variables` input
+  parameter and also returns an extra `grad_vars` output. That extra argument
+  is passed if the forward function reads any variables. You need to
+  compute the gradient w.r.t. each of those `variables` and output it as a list
+  of `grad_vars`. Note here that default value of `variables` is set to `None`
+  when no variables are used in the forward function.
+
+  It should be noted `tf.GradientTape` is still watching the forward pass of a
+  `tf.custom_gradient`, and will use the ops it watches. As a consequence,
+  calling `tf.function` while the tape is still watching leads
+  to a gradient graph being built. If an op is used in `tf.function` without
+  registered gradient, a `LookupError` will be raised.
+
+  Users can insert `tf.stop_gradient` to customize this behavior. This
+  is demonstrated in the example below. `tf.random.shuffle` does not have a
+  registered gradient. As a result `tf.stop_gradient` is used to avoid the
+  `LookupError`.
+
+  ```python
+  x = tf.constant([0.3, 0.5], dtype=tf.float32)
+
+  @tf.custom_gradient
+  def test_func_with_stop_grad(x):
+    @tf.function
+    def _inner_func():
+      # Avoid exception during the forward pass
+      return tf.stop_gradient(tf.random.shuffle(x))
+      # return tf.random.shuffle(x)  # This will raise
+
+    res = _inner_func()
+    def grad(upstream):
+      return upstream  # Arbitrarily defined custom gradient
+    return res, grad
+
+  with tf.GradientTape() as g:
+    g.watch(x)
+    res = test_func_with_stop_grad(x)
+
+  g.gradient(res, x)
+  ```
+
+  See also `tf.RegisterGradient` which registers a gradient function for a
+  primitive TensorFlow operation. `tf.custom_gradient` on the other hand allows
+  for fine grained control over the gradient computation of a sequence of
+  operations.
+
+  Note that if the decorated function uses `Variable`s, the enclosing variable
+  scope must be using
+  [ResourceVariables](https://www.tensorflow.org/guide/migrate/tf1_vs_tf2#resourcevariables_instead_of_referencevariables).
+
+  Args:
+    f: function `f(*x)` that returns a tuple `(y, grad_fn)` where: - `x` is a
+      sequence of (nested structures of) `Tensor` inputs to the function. - `y`
+      is a (nested structure of) `Tensor` outputs of applying TensorFlow
+      operations in `f` to `x`. - `grad_fn` is a function with the signature
+      `g(*grad_ys)` which returns a list of `Tensor`s the same size as
+      (flattened) `x` - the derivatives of `Tensor`s in `y` with respect to the
+      `Tensor`s in `x`.  `grad_ys` is a sequence of `Tensor`s the same size as
+      (flattened) `y` holding the initial value gradients for each `Tensor` in
+      `y`.  In a pure mathematical sense, a vector-argument vector-valued
+      function `f`'s derivatives should be its Jacobian matrix `J`. Here we are
+      expressing the Jacobian `J` as a function `grad_fn` which defines how `J`
+      will transform a vector `grad_ys` when left-multiplied with it (`grad_ys *
+      J`, the vector-Jacobian product, or VJP). This functional representation
+      of a matrix is convenient to use for chain-rule calculation (in e.g. the
+      back-propagation algorithm).  If `f` uses `Variable`s (that are not part
+      of the inputs), i.e. through `get_variable`, then `grad_fn` should have
+      signature `g(*grad_ys, variables=None)`, where `variables` is a list of
+      the `Variable`s, and return a 2-tuple `(grad_xs, grad_vars)`, where
+      `grad_xs` is the same as above, and `grad_vars` is a `list<Tensor>` with
+      the derivatives of `Tensor`s in `y` with respect to the variables (that
+      is, grad_vars has one Tensor per variable in variables).
+
+  Returns:
+    A function `h(x)` which returns the same value as `f(x)[0]` and whose
+    gradient (as calculated by `tf.gradients`) is determined by `f(x)[1]`.
+  """
+
+  if f is None:
+    return lambda f: custom_gradient(f=f)
+
+  @Bind.decorator
+  def decorated(wrapped, args, kwargs):
+    """Decorated function with custom gradient."""
+    if context.executing_eagerly():
+      return _eager_mode_decorator(wrapped, args, kwargs)
+    else:
+      return _graph_mode_decorator(wrapped, args, kwargs)
+
+  return tf_decorator.make_decorator(f, decorated(f))  # pylint: disable=no-value-for-parameter
+
+
+class Bind:
+  """When called evaluates `d(f, args, kwargs)` but supports binding `f`.
+
+  >>> @Bind.decorator
+  ... def my_decorator(f, args, kwargs):
+  ...   print("my_decorator called with", args, kwargs)
+  ...   return f(*args, **kwargs)
+
+  >>> class Foo:
+  ...   @my_decorator
+  ...   def bar(self, a, b, c):
+  ...     return a * b * c
+
+  >>> Foo.bar(None, 1, 2, c=3)
+  my_decorator called with (None, 1, 2) {'c': 3}
+  6
+
+  >>> foo = Foo()
+  >>> foo.bar(1, 2, c=3)
+  my_decorator called with (1, 2) {'c': 3}
+  6
+  """
+
+  @classmethod
+  def decorator(cls, d):
+    return lambda f: Bind(f, d)
+
+  def __init__(self, f, d):
+    self._f = f
+    self._d = d
+
+  def __get__(self, instance, owner):
+    if instance is not None:
+      f = self._f.__get__(instance, owner)
+      return tf_decorator.make_decorator(f, Bind(f, self._d))
+    else:
+      return self
+
+  def __call__(self, *a, **k):
+    return self._d(self._f, a, k)
+
+
+def get_variable_by_name(var_name):
+  """Given a variable name, retrieves a handle on the tensorflow Variable."""
+  global_vars = ops.get_collection(ops.GraphKeys.GLOBAL_VARIABLES)
+
+  def _filter_fn(item):
+    try:
+      return var_name == item.op.name
+    except AttributeError:
+      # Collection items without operation are ignored.
+      return False
+
+  candidate_vars = list(filter(_filter_fn, global_vars))
+
+  if len(candidate_vars) >= 1:
+    # Filter out non-trainable variables.
+    candidate_vars = [v for v in candidate_vars if v.trainable]
+  else:
+    raise ValueError("Unsuccessful at finding variable {}.".format(var_name))
+
+  if len(candidate_vars) == 1:
+    return candidate_vars[0]
+  elif len(candidate_vars) > 1:
+    raise ValueError(
+        "Unsuccessful at finding trainable variable {}. "
+        "Number of candidates: {}. "
+        "Candidates: {}".format(var_name, len(candidate_vars), candidate_vars))
+  else:
+    # The variable is not trainable.
+    return None
+
+
+def _get_dependent_variables(input_ops, output_ops):
+  """Finds variables involved in the subgraph between input_ops and output_ops.
+
+  Args:
+    input_ops: Flattened list of input ops
+    output_ops: Flattened list of output ops
+
+  Returns:
+    A list of variables
+  """
+
+  # avoids the edge-case when input_ops == output_ops.
+  output_ops = nest.map_structure(gen_array_ops.identity, output_ops)
+  inbetween_ops = op_selector.get_backward_walk_ops(
+      seed_ops=output_ops,
+      stop_at_ts=input_ops,
+      inclusive=False,
+      only_differentiable=True)
+  var_ops = (op for op in inbetween_ops if op.type in VAR_OP_TYPES)
+  var_names = (op.name for op in var_ops)
+  tf_vars = (get_variable_by_name(var_name) for var_name in var_names)
+  tf_vars = [v for v in tf_vars if v is not None]
+  return tf_vars
+
+
+def generate_name():
+  return "CustomGradient-%s" % ops.uid()
+
+
+def _graph_mode_decorator(f, args, kwargs):
+  """Implement custom gradient decorator for graph mode."""
+  # TODO(rsepassi): Add support for kwargs
+  if kwargs:
+    raise ValueError(
+        "The custom_gradient decorator currently supports keywords "
+        "arguments only when eager execution is enabled.")
+  name = generate_name()
+  args = variable_utils.convert_variables_to_tensors(args)
+  args = nest.map_structure(ops.convert_to_tensor, args, expand_composites=True)
+
+  # Checking global and local variables attempts to ensure that no non-resource
+  # Variables are added to the graph.
+  current_var_scope = variable_scope.get_variable_scope()
+  before_vars = set([
+      v.ref() for v in current_var_scope.global_variables() +
+      current_var_scope.local_variables()
+  ])
+  with record.VariableWatcher() as variable_watcher:
+    result, grad_fn = f(*args)
+
+  flat_args = composite_tensor_gradient.get_flat_tensors_for_gradients(
+      nest.flatten(args))
+  flat_result = composite_tensor_gradient.get_flat_tensors_for_gradients(
+      nest.flatten(result))
+  flat_result_len = len(flat_result)
+
+  after_vars = set([
+      v.ref() for v in current_var_scope.global_variables() +
+      current_var_scope.local_variables()
+  ])
+  new_vars = after_vars - before_vars
+  new_vars_list = [v.deref() for v in new_vars]
+  for v in new_vars_list:
+    if not resource_variable_ops.is_resource_variable(v):
+      raise TypeError(
+          "All variables used by a function wrapped with @custom_gradient must "
+          "be `ResourceVariable`s. Ensure that no `variable_scope` is created "
+          "with `use_resource=False`.")
+
+  # The variables that grad_fn needs to return gradients for are the set of
+  # variables used that are *not* part of the inputs.
+  variables_in_tape = frozenset([
+      v.ref() for v in variable_watcher.watched_variables()
+  ])
+
+  graphs = {getattr(o, "graph", None) for o in flat_result}
+  # Not all results may be tensors. However, we want to ensure all tensor
+  # outputs are from the same graph and get a list of captured inputs for
+  # variable search
+  graphs.discard(None)  # Discard non-graph outputs
+  if graphs:
+    if len(graphs) > 1:
+      raise ValueError(
+          "All custom_gradient outputs should be from the same graph")
+    output_graph = graphs.pop()
+    filtered_input_tensors = []
+    for i in flat_args:
+      if i.graph == output_graph:
+        filtered_input_tensors.append(i)
+  else:
+    filtered_input_tensors = flat_args
+
+  variables_in_subgraph = frozenset([
+      v.ref() for v in _get_dependent_variables(
+          input_ops=filtered_input_tensors, output_ops=flat_result)
+  ])
+  variables = sorted(
+      [v.deref() for v in variables_in_subgraph.union(variables_in_tape)],
+      key=lambda v: v.name)
+
+  grad_argspec = tf_inspect.getfullargspec(grad_fn)
+  variables_in_signature = ("variables" in grad_argspec.args or
+                            "variables" in grad_argspec.kwonlyargs or
+                            grad_argspec.varkw)
+  if variables and not variables_in_signature:
+    raise TypeError(
+        "@tf.custom_gradient grad_fn must accept keyword argument 'variables', "
+        "since function uses variables: {}".format(variables))
+  if variables_in_signature and not variables:
+    # User seems to intend to use variables but none were captured.
+    logging.vlog(
+        1, "@custom_gradient grad_fn has 'variables' in signature, "
+        "but no ResourceVariables were used on the forward pass.")
+
+  all_tensors = flat_result + flat_args + variables
+
+  def tape_grad_fn(*result_grad_components):
+    """Custom grad fn wrapper."""
+    result_grads = composite_tensor_gradient.replace_flat_tensors_for_gradients(
+        nest.flatten(result), result_grad_components[:flat_result_len])
+    if not isinstance(result_grads, (list, tuple)):
+      result_grads = [result_grads]
+
+    if variables:
+      input_grads, variable_grads = grad_fn(*result_grads, variables=variables)
+      if len(variable_grads) != len(variables):
+        raise ValueError("Must return gradient for each variable from "
+                         "@custom_gradient grad_fn.")
+    else:
+      input_grads = grad_fn(*result_grads)
+      variable_grads = []
+
+    # Need to return one value per input to the IdentityN, so pad the
+    # gradients of the inputs of the custom_gradient function with the
+    # gradients of the outputs as well.
+    input_grads = composite_tensor_gradient.get_flat_tensors_for_gradients(
+        nest.flatten(input_grads))
+    return ([None] * flat_result_len) + input_grads + variable_grads
+
+  @ops.RegisterGradient(name)
+  def internal_grad_fn(unused_op, *result_grads):  # pylint: disable=unused-variable
+    """Custom grad fn wrapper."""
+    return tape_grad_fn(*result_grads)
+
+  original_tensors = all_tensors
+  with ops.get_default_graph().gradient_override_map({"IdentityN": name}):
+    all_tensors = array_ops.identity_n(all_tensors)
+
+  original_tensors = [ops.convert_to_tensor(x) for x in original_tensors]
+
+  # Propagate handle data for happier shape inference for resource variables.
+  for i, t in enumerate(original_tensors):
+    if t.dtype == dtypes.resource and hasattr(t, "_handle_data"):
+      all_tensors[i]._handle_data = t._handle_data  # pylint: disable=protected-access
+  record.record_operation(
+      f.__name__, all_tensors, original_tensors, tape_grad_fn)
+  for ot, t in zip(original_tensors, all_tensors):
+    handle_data_util.copy_handle_data(ot, t)
+  flat_result = composite_tensor_gradient.replace_flat_tensors_for_gradients(
+      nest.flatten(result), all_tensors[:flat_result_len])
+  return nest.pack_sequence_as(result, flat_result)
+
+
+def _eager_mode_decorator(f, args, kwargs):
+  """Implement custom gradient decorator for eager mode."""
+  with record.VariableWatcher() as variable_watcher:
+    result, grad_fn = f(*args, **kwargs)
+  flat_args = composite_tensor_gradient.get_flat_tensors_for_gradients(
+      nest.flatten(args))
+  flat_kwargs = composite_tensor_gradient.get_flat_tensors_for_gradients(
+      nest.flatten(kwargs))
+  all_inputs = flat_args + flat_kwargs
+  # The variables that grad_fn needs to return gradients for are the set of
+  # variables used that are *not* part of the inputs.
+  variables = [
+      v.deref()  # pylint: disable=g-complex-comprehension
+      for v in set(v.ref() for v in variable_watcher.watched_variables())
+      if all(v.deref() is not i for i in all_inputs)
+  ]
+  grad_argspec = tf_inspect.getfullargspec(grad_fn)
+  if (variables and ("variables" not in grad_argspec.args) and
+      ("variables" not in grad_argspec.kwonlyargs) and
+      not grad_argspec.varkw):
+    raise TypeError(
+        "@tf.custom_gradient grad_fn must accept keyword argument 'variables', "
+        "since function uses variables: {}".format(variables))
+  flat_result = composite_tensor_gradient.get_flat_tensors_for_gradients(
+      nest.flatten(result))
+  # TODO(apassos) consider removing the identity below.
+  flat_result = [gen_array_ops.identity(x) for x in flat_result]
+
+  input_tensors = [
+      ops.convert_to_tensor(x) for x in flat_args + list(variables)]
+
+  recorded_inputs = input_tensors
+  arg_count = len(flat_args)
+
+  def actual_grad_fn(*result_grad_components):
+    """Custom grad fn wrapper."""
+    result_grads = composite_tensor_gradient.replace_flat_tensors_for_gradients(
+        nest.flatten(result), result_grad_components)
+    if not isinstance(result_grads, (list, tuple)):
+      result_grads = [result_grads]
+
+    if variables:
+      input_grads, variable_grads = grad_fn(*result_grads, variables=variables)
+      if len(variable_grads) != len(variables):
+        raise ValueError("Must return gradient for each variable from "
+                         "@custom_gradient grad_fn.")
+    else:
+      input_grads = grad_fn(*result_grads)
+      variable_grads = []
+    flat_grads = composite_tensor_gradient.get_flat_tensors_for_gradients(
+        nest.flatten(input_grads))
+    if len(flat_grads) != arg_count:
+      raise ValueError(
+          f"custom_gradient function expected to return {arg_count} "
+          f"gradients, but returned {len(flat_grads)} instead.")
+    return flat_grads + variable_grads
+
+  record.record_operation(f.__name__, flat_result, recorded_inputs,
+                          actual_grad_fn)
+  flat_result = composite_tensor_gradient.replace_flat_tensors_for_gradients(
+      nest.flatten(result), flat_result)
+  return nest.pack_sequence_as(result, flat_result)
+
+
+@tf_export("recompute_grad")
+def recompute_grad(f):
+  """Defines a function as a recompute-checkpoint for the tape auto-diff.
+
+  Tape checkpointing is a technique to reduce the memory consumption of the
+  auto-diff tape:
+
+  - Without tape checkpointing operations and intermediate values are
+  recorded to the tape for use in the backward pass.
+
+  - With tape checkpointing, only the function call and its inputs are
+  recorded. During back-propagation the `recompute_grad` custom gradient
+  (`tf.custom_gradient`) recomputes the function under a localized Tape object.
+  This recomputation of the function during backpropagation performs redundant
+  calculation, but reduces the overall memory usage of the Tape.
+
+  >>> y = tf.Variable(1.0)
+
+  >>> def my_function(x):
+  ...   tf.print('running')
+  ...   z = x*y
+  ...   return z
+
+  >>> my_function_recompute = tf.recompute_grad(my_function)
+
+  >>> with tf.GradientTape() as tape:
+  ...   r = tf.constant(1.0)
+  ...   for i in range(4):
+  ...     r = my_function_recompute(r)
+  running
+  running
+  running
+  running
+
+  >>> grad = tape.gradient(r, [y])
+  running
+  running
+  running
+  running
+
+  Without `recompute_grad`, the tape contains all intermitate steps, and no
+  recomputation is performed.
+
+  >>> with tf.GradientTape() as tape:
+  ...   r = tf.constant(1.0)
+  ...   for i in range(4):
+  ...     r = my_function(r)
+  running
+  running
+  running
+  running
+
+  >>> grad = tape.gradient(r, [y])
+
+
+  If `f` was a `tf.keras` `Model` or `Layer` object, methods and attributes
+  such as `f.variables` are not available on the returned function `g`.
+  Either keep a reference of `f` , or use `g.__wrapped__` for accessing
+  these variables and methods.
+
+
+  >>> def print_running_and_return(x):
+  ...   tf.print("running")
+  ...   return x
+
+  >>> model = tf.keras.Sequential([
+  ...   tf.keras.layers.Lambda(print_running_and_return),
+  ...   tf.keras.layers.Dense(2)
+  ... ])
+
+  >>> model_recompute = tf.recompute_grad(model)
+
+  >>> with tf.GradientTape(persistent=True) as tape:
+  ...   r = tf.constant([[1,2]])
+  ...   for i in range(4):
+  ...     r = model_recompute(r)
+  running
+  running
+  running
+  running
+
+  >>> grad = tape.gradient(r, model.variables)
+  running
+  running
+  running
+  running
+
+  Alternatively, use the `__wrapped__` attribute to access the original
+  model object.
+
+  >>> grad = tape.gradient(r, model_recompute.__wrapped__.variables)
+  running
+  running
+  running
+  running
+
+
+  Args:
+    f: function `f(*x)` that returns a `Tensor` or sequence of `Tensor` outputs.
+
+  Returns:
+    A function `g` wrapping `f` that defines a custom gradient, which recomputes
+    `f` on the backwards pass of a gradient call.
+  """
+  # TODO(cdfreeman) Add is_recomputing functionality from graph mode version
+
+  @custom_gradient
+  def inner(*args, **kwargs):
+    """Inner function closure for calculating gradients."""
+    current_var_scope = variable_scope.get_variable_scope()
+    with record.stop_recording():
+      result = f(*args, **kwargs)
+
+    def grad_wrapper(*wrapper_args, variables=None):
+      """Wrapper function to accomodate lack of kwargs in graph mode custom_gradient."""
+
+      @custom_gradient
+      def inner_recompute_grad(*dresult):
+        """Nested custom gradient function for computing grads in reverse and forward mode autodiff."""
+        # Gradient calculation for reverse mode autodiff.
+        with backprop.GradientTape() as t:
+          id_args = nest.map_structure(gen_array_ops.identity, args)
+          # Tuple `dresult` should contain at least one tensor.
+          assert len(dresult) >= 1
+
+          if not context.executing_eagerly():
+            # XLA doesn't respect `tf.control_dependencies`. The code block
+            # below manually adds a data dependency to `dresult` to ensure
+            # recomputation of `f(*args, **kwargs)` happens after `dresult`.
+
+            # This works even if `dresult[0]` is a size 0 tensor as reduce_max
+            # of a size 0 tensor returns -inf. Use reshape here to avoid reading
+            # the entire `dresult[0]`.
+            elem = math_ops.reduce_max(array_ops.reshape(dresult[0], [-1])[:1])
+            # Cast elem to bool in case elem is NaN.
+            elem_bool = math_ops.cast(elem, dtypes.bool)
+            dresult_dep = array_ops.where_v2(
+                elem_bool == elem_bool, 0., float("nan"))  # pylint: disable=comparison-with-itself
+            id_args = nest.map_structure(
+                lambda x: x + math_ops.cast(dresult_dep, x.dtype), id_args)
+
+          t.watch(id_args)
+          if variables is not None:
+            t.watch(variables)
+          with variable_scope.variable_scope(current_var_scope):
+            recomputed_result = f(*id_args, **kwargs)
+        kw_vars = []
+        if variables is not None:
+          kw_vars = list(variables)
+        grads = t.gradient(
+            recomputed_result,
+            list(id_args) + kw_vars,
+            output_gradients=dresult,
+            unconnected_gradients=UnconnectedGradients.ZERO)
+
+        def transpose(*t_args, **t_kwargs):
+          """Gradient function calculation for forward mode autodiff."""
+          # Just throw an error since gradients / activations are not stored on
+          # tape for recompute.
+          raise NotImplementedError(
+              "recompute_grad tried to transpose grad of {}. "
+              "Consider not using recompute_grad in forward mode"
+              "autodiff".format(f.__name__))
+
+        return (grads[:len(id_args)], grads[len(id_args):]), transpose
+
+      return inner_recompute_grad(*wrapper_args)
+
+    return result, grad_wrapper
+
+  return tf_decorator.make_decorator(f, inner)
+
+
+@tf_export("grad_pass_through")
+def grad_pass_through(f):
+  """Creates a grad-pass-through op with the forward behavior provided in f.
+
+  Use this function to wrap any op, maintaining its behavior in the forward
+  pass, but replacing the original op in the backward graph with an identity.
+  For example:
+
+  ```python
+  x = tf.Variable(1.0, name="x")
+  z = tf.Variable(3.0, name="z")
+
+  with tf.GradientTape() as tape:
+    # y will evaluate to 9.0
+    y = tf.grad_pass_through(x.assign)(z**2)
+  # grads will evaluate to 6.0
+  grads = tape.gradient(y, z)
+  ```
+
+  Another example is a 'differentiable' moving average approximation, where
+  gradients are allowed to flow into the last value fed to the moving average,
+  but the moving average is still used for the forward pass:
+
+  ```python
+  x = ... # Some scalar value
+  # A moving average object, we don't need to know how this is implemented
+  moving_average = MovingAverage()
+  with backprop.GradientTape() as tape:
+    # mavg_x will evaluate to the current running average value
+    mavg_x = tf.grad_pass_through(moving_average)(x)
+  grads = tape.gradient(mavg_x, x) # grads will evaluate to 1.0
+  ```
+
+  Args:
+    f: function `f(*x)` that returns a `Tensor` or nested structure of `Tensor`
+      outputs.
+
+  Returns:
+    A function `h(x)` which returns the same values as `f(x)` and whose
+    gradients are the same as those of an identity function.
+  """
+  @custom_gradient
+  def _grad_pass_through_op(*args, **kwargs):
+    def grad(*args, **kwargs):
+      variables = kwargs.get("variables")
+      if variables is not None:
+        # Variables involved in the wrapped op will not receive gradients.
+        return args, [None] * len(variables)
+      return args
+    return f(*args, **kwargs), grad
+  return tf_decorator.make_decorator(f, _grad_pass_through_op)

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/default_gradient.py

@@ -0,0 +1,80 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities for computing default gradients."""
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import tensor_shape
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import resource_variable_ops
+
+
+def get_zeros_dtype(t):
+  """Return the dtype for the default gradient for a Tensor."""
+  if t.dtype == dtypes.resource:
+    handle_data = resource_variable_ops.get_eager_safe_handle_data(t)
+    if (handle_data is None or not handle_data.is_set or
+        len(handle_data.shape_and_type) != 1):
+      raise ValueError("Internal error: Tried to take gradients (or similar) "
+                       "of a variable without handle data:\n%s" % str(t))
+    return handle_data.shape_and_type[0].dtype
+  return t.dtype
+
+
+def shape_and_dtype(t):
+  """Return the shape and dtype for the default gradient for a Tensor."""
+  if t.dtype == dtypes.resource:
+    handle_data = resource_variable_ops.get_eager_safe_handle_data(t)
+    if (handle_data is None or not handle_data.is_set or
+        len(handle_data.shape_and_type) != 1):
+      raise ValueError("Internal error: Tried to take gradients (or similar) "
+                       "of a variable without handle data:\n%s" % str(t))
+    shape_and_type = handle_data.shape_and_type[0]
+    return (tensor_shape.TensorShape(shape_and_type.shape),
+            dtypes.as_dtype(shape_and_type.dtype))
+  return t.shape, t.dtype
+
+
+def zeros_like(t):
+  """Like array_ops.zeros_like, but respects resource handles."""
+  if t.dtype == dtypes.resource:
+    return array_ops.zeros(*shape_and_dtype(t))
+  else:
+    return array_ops.zeros_like(t)
+
+
+def ones_like(t):
+  """Like array_ops.ones_like, but respects resource handles."""
+  if t.dtype == dtypes.resource:
+    return array_ops.ones(*shape_and_dtype(t))
+  else:
+    return array_ops.ones_like(t)
+
+
+def supports_default_grad(t):
+  """Whether tensor `t` supports creating a default gradient.
+
+  This function assumes that `t` is of a trainable type.
+
+  Args:
+    t: Tensor
+
+  Returns:
+    Bool
+  """
+  if t.dtype == dtypes.resource:
+    handle_data = resource_variable_ops.get_eager_safe_handle_data(t)
+    if (handle_data is None or not handle_data.is_set or
+        len(handle_data.shape_and_type) != 1):
+      return False
+  return True

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/filesystem_ops.py

@@ -0,0 +1,38 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Filesystem related operations."""
+
+from tensorflow.python.ops import gen_filesystem_ops as _gen_filesystem_ops
+
+
+# pylint: disable=protected-access
+def filesystem_set_configuration(scheme, key, value, name=None):
+  """Set configuration of the file system.
+
+  Args:
+    scheme: File system scheme.
+    key: The name of the configuration option.
+    value: The value of the configuration option.
+    name: A name for the operation (optional).
+
+  Returns:
+    None.
+  """
+
+  return _gen_filesystem_ops.file_system_set_configuration(
+      scheme, key=key, value=value, name=name)
+
+
+# pylint: enable=protected-access

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/gen_batch_ops.py

@@ -0,0 +1,699 @@
+"""Python wrappers around TensorFlow ops.
+
+This file is MACHINE GENERATED! Do not edit.
+"""
+
+import collections
+
+from tensorflow.python import pywrap_tfe as pywrap_tfe
+from tensorflow.python.eager import context as _context
+from tensorflow.python.eager import core as _core
+from tensorflow.python.eager import execute as _execute
+from tensorflow.python.framework import dtypes as _dtypes
+from tensorflow.security.fuzzing.py import annotation_types as _atypes
+
+from tensorflow.python.framework import op_def_registry as _op_def_registry
+from tensorflow.python.framework import ops as _ops
+from tensorflow.python.framework import op_def_library as _op_def_library
+from tensorflow.python.util.deprecation import deprecated_endpoints
+from tensorflow.python.util import dispatch as _dispatch
+from tensorflow.python.util.tf_export import tf_export
+
+from typing import TypeVar, List, Any
+from typing_extensions import Annotated
+_BatchOutput = collections.namedtuple(
+    "Batch",
+    ["batched_tensors", "batch_index", "id"])
+
+
+def batch(in_tensors, num_batch_threads: int, max_batch_size: int, batch_timeout_micros: int, grad_timeout_micros: int, max_enqueued_batches:int=10, allowed_batch_sizes=[], container:str="", shared_name:str="", batching_queue:str="", name=None):
+  r"""Batches all input tensors nondeterministically.
+
+  When many instances of this Op are being run concurrently with the same
+  container/shared_name in the same device, some will output zero-shaped Tensors
+  and others will output Tensors of size up to max_batch_size.
+
+  All Tensors in in_tensors are batched together (so, for example, labels and
+  features should be batched with a single instance of this operation.
+
+  Each invocation of batch emits an `id` scalar which will be used to identify
+  this particular invocation when doing unbatch or its gradient.
+
+  Each op which emits a non-empty batch will also emit a non-empty batch_index
+  Tensor, which, is a [K, 3] matrix where each row contains the invocation's id,
+  start, and length of elements of each set of Tensors present in batched_tensors.
+
+  Batched tensors are concatenated along the first dimension, and all tensors in
+  in_tensors must have the first dimension of the same size.
+
+  in_tensors: The tensors to be batched.
+  num_batch_threads: Number of scheduling threads for processing batches of work.
+   Determines the number of batches processed in parallel.
+  max_batch_size: Batch sizes will never be bigger than this.
+  batch_timeout_micros: Maximum number of microseconds to wait before outputting
+   an incomplete batch.
+  allowed_batch_sizes: Optional list of allowed batch sizes. If left empty, does
+   nothing. Otherwise, supplies a list of batch sizes, causing the op to pad
+   batches up to one of those sizes. The entries must increase monotonically, and
+   the final entry must equal max_batch_size.
+  grad_timeout_micros: The timeout to use for the gradient. See Unbatch.
+  batched_tensors: Either empty tensors or a batch of concatenated Tensors.
+  batch_index: If out_tensors is non-empty, has information to invert it.
+  container: Controls the scope of sharing of this batch.
+  id: always contains a scalar with a unique ID for this invocation of Batch.
+  shared_name: Concurrently running instances of batch in the same device with the
+   same container and shared_name will batch their elements together. If left
+   empty, the op name will be used as the shared name.
+  T: the types of tensors to be batched.
+
+  Args:
+    in_tensors: A list of `Tensor` objects.
+    num_batch_threads: An `int`.
+    max_batch_size: An `int`.
+    batch_timeout_micros: An `int`.
+    grad_timeout_micros: An `int`.
+    max_enqueued_batches: An optional `int`. Defaults to `10`.
+    allowed_batch_sizes: An optional list of `ints`. Defaults to `[]`.
+    container: An optional `string`. Defaults to `""`.
+    shared_name: An optional `string`. Defaults to `""`.
+    batching_queue: An optional `string`. Defaults to `""`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A tuple of `Tensor` objects (batched_tensors, batch_index, id).
+
+    batched_tensors: A list of `Tensor` objects. Has the same type as `in_tensors`.
+    batch_index: A `Tensor` of type `int64`.
+    id: A `Tensor` of type `int64`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "Batch", name, in_tensors, "num_batch_threads",
+        num_batch_threads, "max_batch_size", max_batch_size,
+        "max_enqueued_batches", max_enqueued_batches, "batch_timeout_micros",
+        batch_timeout_micros, "allowed_batch_sizes", allowed_batch_sizes,
+        "grad_timeout_micros", grad_timeout_micros, "container", container,
+        "shared_name", shared_name, "batching_queue", batching_queue)
+      _result = _BatchOutput._make(_result)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return batch_eager_fallback(
+          in_tensors, num_batch_threads=num_batch_threads,
+          max_batch_size=max_batch_size,
+          max_enqueued_batches=max_enqueued_batches,
+          batch_timeout_micros=batch_timeout_micros,
+          allowed_batch_sizes=allowed_batch_sizes,
+          grad_timeout_micros=grad_timeout_micros, container=container,
+          shared_name=shared_name, batching_queue=batching_queue, name=name,
+          ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  num_batch_threads = _execute.make_int(num_batch_threads, "num_batch_threads")
+  max_batch_size = _execute.make_int(max_batch_size, "max_batch_size")
+  batch_timeout_micros = _execute.make_int(batch_timeout_micros, "batch_timeout_micros")
+  grad_timeout_micros = _execute.make_int(grad_timeout_micros, "grad_timeout_micros")
+  if max_enqueued_batches is None:
+    max_enqueued_batches = 10
+  max_enqueued_batches = _execute.make_int(max_enqueued_batches, "max_enqueued_batches")
+  if allowed_batch_sizes is None:
+    allowed_batch_sizes = []
+  if not isinstance(allowed_batch_sizes, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'allowed_batch_sizes' argument to "
+        "'batch' Op, not %r." % allowed_batch_sizes)
+  allowed_batch_sizes = [_execute.make_int(_i, "allowed_batch_sizes") for _i in allowed_batch_sizes]
+  if container is None:
+    container = ""
+  container = _execute.make_str(container, "container")
+  if shared_name is None:
+    shared_name = ""
+  shared_name = _execute.make_str(shared_name, "shared_name")
+  if batching_queue is None:
+    batching_queue = ""
+  batching_queue = _execute.make_str(batching_queue, "batching_queue")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "Batch", in_tensors=in_tensors, num_batch_threads=num_batch_threads,
+                 max_batch_size=max_batch_size,
+                 batch_timeout_micros=batch_timeout_micros,
+                 grad_timeout_micros=grad_timeout_micros,
+                 max_enqueued_batches=max_enqueued_batches,
+                 allowed_batch_sizes=allowed_batch_sizes, container=container,
+                 shared_name=shared_name, batching_queue=batching_queue,
+                 name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("num_batch_threads", _op._get_attr_int("num_batch_threads"),
+              "max_batch_size", _op._get_attr_int("max_batch_size"),
+              "max_enqueued_batches",
+              _op._get_attr_int("max_enqueued_batches"),
+              "batch_timeout_micros",
+              _op._get_attr_int("batch_timeout_micros"),
+              "allowed_batch_sizes", _op.get_attr("allowed_batch_sizes"),
+              "grad_timeout_micros", _op._get_attr_int("grad_timeout_micros"),
+              "container", _op.get_attr("container"), "shared_name",
+              _op.get_attr("shared_name"), "batching_queue",
+              _op.get_attr("batching_queue"), "T", _op.get_attr("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "Batch", _inputs_flat, _attrs, _result)
+  _result = [_result[:len(in_tensors)]] + _result[len(in_tensors):]
+  _result = _BatchOutput._make(_result)
+  return _result
+
+Batch = tf_export("raw_ops.Batch")(_ops.to_raw_op(batch))
+
+
+def batch_eager_fallback(in_tensors, num_batch_threads: int, max_batch_size: int, batch_timeout_micros: int, grad_timeout_micros: int, max_enqueued_batches: int, allowed_batch_sizes, container: str, shared_name: str, batching_queue: str, name, ctx):
+  num_batch_threads = _execute.make_int(num_batch_threads, "num_batch_threads")
+  max_batch_size = _execute.make_int(max_batch_size, "max_batch_size")
+  batch_timeout_micros = _execute.make_int(batch_timeout_micros, "batch_timeout_micros")
+  grad_timeout_micros = _execute.make_int(grad_timeout_micros, "grad_timeout_micros")
+  if max_enqueued_batches is None:
+    max_enqueued_batches = 10
+  max_enqueued_batches = _execute.make_int(max_enqueued_batches, "max_enqueued_batches")
+  if allowed_batch_sizes is None:
+    allowed_batch_sizes = []
+  if not isinstance(allowed_batch_sizes, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'allowed_batch_sizes' argument to "
+        "'batch' Op, not %r." % allowed_batch_sizes)
+  allowed_batch_sizes = [_execute.make_int(_i, "allowed_batch_sizes") for _i in allowed_batch_sizes]
+  if container is None:
+    container = ""
+  container = _execute.make_str(container, "container")
+  if shared_name is None:
+    shared_name = ""
+  shared_name = _execute.make_str(shared_name, "shared_name")
+  if batching_queue is None:
+    batching_queue = ""
+  batching_queue = _execute.make_str(batching_queue, "batching_queue")
+  _attr_T, in_tensors = _execute.convert_to_mixed_eager_tensors(in_tensors, ctx)
+  _inputs_flat = list(in_tensors)
+  _attrs = ("num_batch_threads", num_batch_threads, "max_batch_size",
+  max_batch_size, "max_enqueued_batches", max_enqueued_batches,
+  "batch_timeout_micros", batch_timeout_micros, "allowed_batch_sizes",
+  allowed_batch_sizes, "grad_timeout_micros", grad_timeout_micros,
+  "container", container, "shared_name", shared_name, "batching_queue",
+  batching_queue, "T", _attr_T)
+  _result = _execute.execute(b"Batch", len(in_tensors) + 2,
+                             inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
+                             name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "Batch", _inputs_flat, _attrs, _result)
+  _result = [_result[:len(in_tensors)]] + _result[len(in_tensors):]
+  _result = _BatchOutput._make(_result)
+  return _result
+
+
+def batch_function(in_tensors, captured_tensors, f, num_batch_threads: int, max_batch_size: int, batch_timeout_micros: int, Tout, max_enqueued_batches:int=10, allowed_batch_sizes=[], container:str="", shared_name:str="", batching_queue:str="", low_priority_max_batch_size:int=0, low_priority_batch_timeout_micros:int=0, low_priority_allowed_batch_sizes=[], low_priority_max_enqueued_batches:int=0, enable_large_batch_splitting:bool=False, name=None):
+  r"""Batches all the inputs tensors to the computation done by the function.
+
+  So, for example, in the following code
+
+    ```python
+
+    # This input will be captured.
+    y = tf.placeholder_with_default(1.0, shape=[])
+
+    @tf.Defun(tf.float32)
+    def computation(a):
+      return tf.matmul(a, a) + y
+
+    b = gen_batch_ops.batch_function(
+            f=computation
+            in_tensors=[a],
+            captured_tensors=computation.captured_inputs,
+            Tout=[o.type for o in computation.definition.signature.output_arg],
+            num_batch_threads=1,
+            max_batch_size=10,
+            batch_timeout_micros=100000,  # 100ms
+            allowed_batch_sizes=[3, 10],
+            batching_queue="")
+    ```
+
+  If more than one session.run call is simultaneously trying to compute `b`
+  the values of `a` will be gathered, non-deterministically concatenated
+  along the first axis, and only one thread will run the computation.
+
+  Assumes that all arguments of the function are Tensors which will be batched
+  along their first dimension.
+
+  Arguments that are captured, are not batched. The session.run call which does
+  the concatenation, will use the values of the captured tensors available to it.
+  Therefore, typical uses of captured tensors should involve values which remain
+  unchanged across session.run calls. Inference is a good example of this.
+
+  SparseTensor is not supported. The return value of the decorated function
+  must be a Tensor or a list/tuple of Tensors.
+
+  Args:
+    in_tensors: A list of `Tensor` objects. The tensors to be batched.
+    captured_tensors: A list of `Tensor` objects.
+      The tensors which are captured in the function, and don't need
+      to be batched.
+    f: A function decorated with @Defun.
+    num_batch_threads: An `int`.
+      Number of scheduling threads for processing batches of work.
+      Determines the number of batches processed in parallel.
+    max_batch_size: An `int`. Batch sizes will never be bigger than this.
+    batch_timeout_micros: An `int`.
+      Maximum number of microseconds to wait before outputting
+      an incomplete batch.
+    Tout: A list of `tf.DTypes` that has length `>= 1`.
+      the types of the output tensors.
+    max_enqueued_batches: An optional `int`. Defaults to `10`.
+      Maximum number of batches enqueued. Default: 10.
+    allowed_batch_sizes: An optional list of `ints`. Defaults to `[]`.
+      Optional list of allowed batch sizes. If left empty, does
+      nothing. Otherwise, supplies a list of batch sizes, causing the op to pad
+      batches up to one of those sizes. The entries must increase monotonically.
+      If enable_large_batch_splitting is false (i.e., large-input-split is not
+      enabled) the final entry must equal max_batch_size.
+    container: An optional `string`. Defaults to `""`.
+      Controls the scope of sharing of this batch.
+    shared_name: An optional `string`. Defaults to `""`.
+      Concurrently running instances of batch in the same device with the
+      same container and shared_name will batch their elements together. If left
+      empty, the op name will be used as the shared name.
+    batching_queue: An optional `string`. Defaults to `""`.
+    low_priority_max_batch_size: An optional `int`. Defaults to `0`.
+    low_priority_batch_timeout_micros: An optional `int`. Defaults to `0`.
+    low_priority_allowed_batch_sizes: An optional list of `ints`. Defaults to `[]`.
+    low_priority_max_enqueued_batches: An optional `int`. Defaults to `0`.
+    enable_large_batch_splitting: An optional `bool`. Defaults to `False`.
+      input with a large size (i.e., larger than the largest value of
+      `allowed_batch_sizes`) will be splitted into multiple batches with batch size.
+    name: A name for the operation (optional).
+
+  Returns:
+    A list of `Tensor` objects of type `Tout`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "BatchFunction", name, in_tensors, captured_tensors, "f", f,
+        "num_batch_threads", num_batch_threads, "max_batch_size",
+        max_batch_size, "batch_timeout_micros", batch_timeout_micros,
+        "max_enqueued_batches", max_enqueued_batches, "allowed_batch_sizes",
+        allowed_batch_sizes, "container", container, "shared_name",
+        shared_name, "batching_queue", batching_queue,
+        "low_priority_max_batch_size", low_priority_max_batch_size,
+        "low_priority_batch_timeout_micros",
+        low_priority_batch_timeout_micros, "low_priority_allowed_batch_sizes",
+        low_priority_allowed_batch_sizes, "low_priority_max_enqueued_batches",
+        low_priority_max_enqueued_batches, "Tout", Tout,
+        "enable_large_batch_splitting", enable_large_batch_splitting)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return batch_function_eager_fallback(
+          in_tensors, captured_tensors, f=f,
+          num_batch_threads=num_batch_threads, max_batch_size=max_batch_size,
+          batch_timeout_micros=batch_timeout_micros,
+          max_enqueued_batches=max_enqueued_batches,
+          allowed_batch_sizes=allowed_batch_sizes, container=container,
+          shared_name=shared_name, batching_queue=batching_queue,
+          low_priority_max_batch_size=low_priority_max_batch_size,
+          low_priority_batch_timeout_micros=low_priority_batch_timeout_micros,
+          low_priority_allowed_batch_sizes=low_priority_allowed_batch_sizes,
+          low_priority_max_enqueued_batches=low_priority_max_enqueued_batches,
+          Tout=Tout,
+          enable_large_batch_splitting=enable_large_batch_splitting,
+          name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  num_batch_threads = _execute.make_int(num_batch_threads, "num_batch_threads")
+  max_batch_size = _execute.make_int(max_batch_size, "max_batch_size")
+  batch_timeout_micros = _execute.make_int(batch_timeout_micros, "batch_timeout_micros")
+  if not isinstance(Tout, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'Tout' argument to "
+        "'batch_function' Op, not %r." % Tout)
+  Tout = [_execute.make_type(_t, "Tout") for _t in Tout]
+  if max_enqueued_batches is None:
+    max_enqueued_batches = 10
+  max_enqueued_batches = _execute.make_int(max_enqueued_batches, "max_enqueued_batches")
+  if allowed_batch_sizes is None:
+    allowed_batch_sizes = []
+  if not isinstance(allowed_batch_sizes, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'allowed_batch_sizes' argument to "
+        "'batch_function' Op, not %r." % allowed_batch_sizes)
+  allowed_batch_sizes = [_execute.make_int(_i, "allowed_batch_sizes") for _i in allowed_batch_sizes]
+  if container is None:
+    container = ""
+  container = _execute.make_str(container, "container")
+  if shared_name is None:
+    shared_name = ""
+  shared_name = _execute.make_str(shared_name, "shared_name")
+  if batching_queue is None:
+    batching_queue = ""
+  batching_queue = _execute.make_str(batching_queue, "batching_queue")
+  if low_priority_max_batch_size is None:
+    low_priority_max_batch_size = 0
+  low_priority_max_batch_size = _execute.make_int(low_priority_max_batch_size, "low_priority_max_batch_size")
+  if low_priority_batch_timeout_micros is None:
+    low_priority_batch_timeout_micros = 0
+  low_priority_batch_timeout_micros = _execute.make_int(low_priority_batch_timeout_micros, "low_priority_batch_timeout_micros")
+  if low_priority_allowed_batch_sizes is None:
+    low_priority_allowed_batch_sizes = []
+  if not isinstance(low_priority_allowed_batch_sizes, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'low_priority_allowed_batch_sizes' argument to "
+        "'batch_function' Op, not %r." % low_priority_allowed_batch_sizes)
+  low_priority_allowed_batch_sizes = [_execute.make_int(_i, "low_priority_allowed_batch_sizes") for _i in low_priority_allowed_batch_sizes]
+  if low_priority_max_enqueued_batches is None:
+    low_priority_max_enqueued_batches = 0
+  low_priority_max_enqueued_batches = _execute.make_int(low_priority_max_enqueued_batches, "low_priority_max_enqueued_batches")
+  if enable_large_batch_splitting is None:
+    enable_large_batch_splitting = False
+  enable_large_batch_splitting = _execute.make_bool(enable_large_batch_splitting, "enable_large_batch_splitting")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "BatchFunction", in_tensors=in_tensors,
+                         captured_tensors=captured_tensors, f=f,
+                         num_batch_threads=num_batch_threads,
+                         max_batch_size=max_batch_size,
+                         batch_timeout_micros=batch_timeout_micros, Tout=Tout,
+                         max_enqueued_batches=max_enqueued_batches,
+                         allowed_batch_sizes=allowed_batch_sizes,
+                         container=container, shared_name=shared_name,
+                         batching_queue=batching_queue,
+                         low_priority_max_batch_size=low_priority_max_batch_size,
+                         low_priority_batch_timeout_micros=low_priority_batch_timeout_micros,
+                         low_priority_allowed_batch_sizes=low_priority_allowed_batch_sizes,
+                         low_priority_max_enqueued_batches=low_priority_max_enqueued_batches,
+                         enable_large_batch_splitting=enable_large_batch_splitting,
+                         name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("f", _op.get_attr("f"), "num_batch_threads",
+              _op._get_attr_int("num_batch_threads"), "max_batch_size",
+              _op._get_attr_int("max_batch_size"), "batch_timeout_micros",
+              _op._get_attr_int("batch_timeout_micros"),
+              "max_enqueued_batches",
+              _op._get_attr_int("max_enqueued_batches"),
+              "allowed_batch_sizes", _op.get_attr("allowed_batch_sizes"),
+              "container", _op.get_attr("container"), "shared_name",
+              _op.get_attr("shared_name"), "batching_queue",
+              _op.get_attr("batching_queue"), "low_priority_max_batch_size",
+              _op._get_attr_int("low_priority_max_batch_size"),
+              "low_priority_batch_timeout_micros",
+              _op._get_attr_int("low_priority_batch_timeout_micros"),
+              "low_priority_allowed_batch_sizes",
+              _op.get_attr("low_priority_allowed_batch_sizes"),
+              "low_priority_max_enqueued_batches",
+              _op._get_attr_int("low_priority_max_enqueued_batches"), "Tin",
+              _op.get_attr("Tin"), "Tcaptured", _op.get_attr("Tcaptured"),
+              "Tout", _op.get_attr("Tout"), "enable_large_batch_splitting",
+              _op._get_attr_bool("enable_large_batch_splitting"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "BatchFunction", _inputs_flat, _attrs, _result)
+  return _result
+
+BatchFunction = tf_export("raw_ops.BatchFunction")(_ops.to_raw_op(batch_function))
+
+
+def batch_function_eager_fallback(in_tensors, captured_tensors, f, num_batch_threads: int, max_batch_size: int, batch_timeout_micros: int, Tout, max_enqueued_batches: int, allowed_batch_sizes, container: str, shared_name: str, batching_queue: str, low_priority_max_batch_size: int, low_priority_batch_timeout_micros: int, low_priority_allowed_batch_sizes, low_priority_max_enqueued_batches: int, enable_large_batch_splitting: bool, name, ctx):
+  num_batch_threads = _execute.make_int(num_batch_threads, "num_batch_threads")
+  max_batch_size = _execute.make_int(max_batch_size, "max_batch_size")
+  batch_timeout_micros = _execute.make_int(batch_timeout_micros, "batch_timeout_micros")
+  if not isinstance(Tout, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'Tout' argument to "
+        "'batch_function' Op, not %r." % Tout)
+  Tout = [_execute.make_type(_t, "Tout") for _t in Tout]
+  if max_enqueued_batches is None:
+    max_enqueued_batches = 10
+  max_enqueued_batches = _execute.make_int(max_enqueued_batches, "max_enqueued_batches")
+  if allowed_batch_sizes is None:
+    allowed_batch_sizes = []
+  if not isinstance(allowed_batch_sizes, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'allowed_batch_sizes' argument to "
+        "'batch_function' Op, not %r." % allowed_batch_sizes)
+  allowed_batch_sizes = [_execute.make_int(_i, "allowed_batch_sizes") for _i in allowed_batch_sizes]
+  if container is None:
+    container = ""
+  container = _execute.make_str(container, "container")
+  if shared_name is None:
+    shared_name = ""
+  shared_name = _execute.make_str(shared_name, "shared_name")
+  if batching_queue is None:
+    batching_queue = ""
+  batching_queue = _execute.make_str(batching_queue, "batching_queue")
+  if low_priority_max_batch_size is None:
+    low_priority_max_batch_size = 0
+  low_priority_max_batch_size = _execute.make_int(low_priority_max_batch_size, "low_priority_max_batch_size")
+  if low_priority_batch_timeout_micros is None:
+    low_priority_batch_timeout_micros = 0
+  low_priority_batch_timeout_micros = _execute.make_int(low_priority_batch_timeout_micros, "low_priority_batch_timeout_micros")
+  if low_priority_allowed_batch_sizes is None:
+    low_priority_allowed_batch_sizes = []
+  if not isinstance(low_priority_allowed_batch_sizes, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'low_priority_allowed_batch_sizes' argument to "
+        "'batch_function' Op, not %r." % low_priority_allowed_batch_sizes)
+  low_priority_allowed_batch_sizes = [_execute.make_int(_i, "low_priority_allowed_batch_sizes") for _i in low_priority_allowed_batch_sizes]
+  if low_priority_max_enqueued_batches is None:
+    low_priority_max_enqueued_batches = 0
+  low_priority_max_enqueued_batches = _execute.make_int(low_priority_max_enqueued_batches, "low_priority_max_enqueued_batches")
+  if enable_large_batch_splitting is None:
+    enable_large_batch_splitting = False
+  enable_large_batch_splitting = _execute.make_bool(enable_large_batch_splitting, "enable_large_batch_splitting")
+  _attr_Tin, in_tensors = _execute.convert_to_mixed_eager_tensors(in_tensors, ctx)
+  _attr_Tcaptured, captured_tensors = _execute.convert_to_mixed_eager_tensors(captured_tensors, ctx)
+  _inputs_flat = list(in_tensors) + list(captured_tensors)
+  _attrs = ("f", f, "num_batch_threads", num_batch_threads, "max_batch_size",
+  max_batch_size, "batch_timeout_micros", batch_timeout_micros,
+  "max_enqueued_batches", max_enqueued_batches, "allowed_batch_sizes",
+  allowed_batch_sizes, "container", container, "shared_name", shared_name,
+  "batching_queue", batching_queue, "low_priority_max_batch_size",
+  low_priority_max_batch_size, "low_priority_batch_timeout_micros",
+  low_priority_batch_timeout_micros, "low_priority_allowed_batch_sizes",
+  low_priority_allowed_batch_sizes, "low_priority_max_enqueued_batches",
+  low_priority_max_enqueued_batches, "Tin", _attr_Tin, "Tcaptured",
+  _attr_Tcaptured, "Tout", Tout, "enable_large_batch_splitting",
+  enable_large_batch_splitting)
+  _result = _execute.execute(b"BatchFunction", len(Tout), inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "BatchFunction", _inputs_flat, _attrs, _result)
+  return _result
+
+
+TV_Unbatch_T = TypeVar("TV_Unbatch_T", _atypes.BFloat16, _atypes.Bool, _atypes.Complex128, _atypes.Complex64, _atypes.Float16, _atypes.Float32, _atypes.Float64, _atypes.Float8e4m3fn, _atypes.Float8e5m2, _atypes.Half, _atypes.Int16, _atypes.Int32, _atypes.Int4, _atypes.Int64, _atypes.Int8, _atypes.QInt16, _atypes.QInt32, _atypes.QInt8, _atypes.QUInt16, _atypes.QUInt8, _atypes.Resource, _atypes.String, _atypes.UInt16, _atypes.UInt32, _atypes.UInt4, _atypes.UInt64, _atypes.UInt8, _atypes.Variant)
+
+def unbatch(batched_tensor: Annotated[Any, TV_Unbatch_T], batch_index: Annotated[Any, _atypes.Int64], id: Annotated[Any, _atypes.Int64], timeout_micros: int, container:str="", shared_name:str="", name=None) -> Annotated[Any, TV_Unbatch_T]:
+  r"""Reverses the operation of Batch for a single output Tensor.
+
+  An instance of Unbatch either receives an empty batched_tensor, in which case it
+  asynchronously waits until the values become available from a concurrently
+  running instance of Unbatch with the same container and shared_name, or receives
+  a non-empty batched_tensor in which case it finalizes all other concurrently
+  running instances and outputs its own element from the batch.
+
+  batched_tensor: The possibly transformed output of Batch. The size of the first
+   dimension should remain unchanged by the transformations for the operation to
+   work.
+  batch_index: The matching batch_index obtained from Batch.
+  id: The id scalar emitted by Batch.
+  unbatched_tensor: The Tensor corresponding to this execution.
+  timeout_micros: Maximum amount of time (in microseconds) to wait to receive the
+   batched input tensor associated with a given invocation of the op.
+  container: Container to control resource sharing.
+  shared_name: Instances of Unbatch with the same container and shared_name are
+   assumed to possibly belong to the same batch. If left empty, the op name will
+   be used as the shared name.
+
+  Args:
+    batched_tensor: A `Tensor`.
+    batch_index: A `Tensor` of type `int64`.
+    id: A `Tensor` of type `int64`.
+    timeout_micros: An `int`.
+    container: An optional `string`. Defaults to `""`.
+    shared_name: An optional `string`. Defaults to `""`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `batched_tensor`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "Unbatch", name, batched_tensor, batch_index, id,
+        "timeout_micros", timeout_micros, "container", container,
+        "shared_name", shared_name)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return unbatch_eager_fallback(
+          batched_tensor, batch_index, id, timeout_micros=timeout_micros,
+          container=container, shared_name=shared_name, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  timeout_micros = _execute.make_int(timeout_micros, "timeout_micros")
+  if container is None:
+    container = ""
+  container = _execute.make_str(container, "container")
+  if shared_name is None:
+    shared_name = ""
+  shared_name = _execute.make_str(shared_name, "shared_name")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "Unbatch", batched_tensor=batched_tensor, batch_index=batch_index,
+                   id=id, timeout_micros=timeout_micros, container=container,
+                   shared_name=shared_name, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("timeout_micros", _op._get_attr_int("timeout_micros"),
+              "container", _op.get_attr("container"), "shared_name",
+              _op.get_attr("shared_name"), "T", _op._get_attr_type("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "Unbatch", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+Unbatch = tf_export("raw_ops.Unbatch")(_ops.to_raw_op(unbatch))
+
+
+def unbatch_eager_fallback(batched_tensor: Annotated[Any, TV_Unbatch_T], batch_index: Annotated[Any, _atypes.Int64], id: Annotated[Any, _atypes.Int64], timeout_micros: int, container: str, shared_name: str, name, ctx) -> Annotated[Any, TV_Unbatch_T]:
+  timeout_micros = _execute.make_int(timeout_micros, "timeout_micros")
+  if container is None:
+    container = ""
+  container = _execute.make_str(container, "container")
+  if shared_name is None:
+    shared_name = ""
+  shared_name = _execute.make_str(shared_name, "shared_name")
+  _attr_T, (batched_tensor,) = _execute.args_to_matching_eager([batched_tensor], ctx, [])
+  batch_index = _ops.convert_to_tensor(batch_index, _dtypes.int64)
+  id = _ops.convert_to_tensor(id, _dtypes.int64)
+  _inputs_flat = [batched_tensor, batch_index, id]
+  _attrs = ("timeout_micros", timeout_micros, "container", container,
+  "shared_name", shared_name, "T", _attr_T)
+  _result = _execute.execute(b"Unbatch", 1, inputs=_inputs_flat, attrs=_attrs,
+                             ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "Unbatch", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_UnbatchGrad_T = TypeVar("TV_UnbatchGrad_T", _atypes.BFloat16, _atypes.Bool, _atypes.Complex128, _atypes.Complex64, _atypes.Float16, _atypes.Float32, _atypes.Float64, _atypes.Float8e4m3fn, _atypes.Float8e5m2, _atypes.Half, _atypes.Int16, _atypes.Int32, _atypes.Int4, _atypes.Int64, _atypes.Int8, _atypes.QInt16, _atypes.QInt32, _atypes.QInt8, _atypes.QUInt16, _atypes.QUInt8, _atypes.Resource, _atypes.String, _atypes.UInt16, _atypes.UInt32, _atypes.UInt4, _atypes.UInt64, _atypes.UInt8, _atypes.Variant)
+
+def unbatch_grad(original_input: Annotated[Any, TV_UnbatchGrad_T], batch_index: Annotated[Any, _atypes.Int64], grad: Annotated[Any, TV_UnbatchGrad_T], id: Annotated[Any, _atypes.Int64], container:str="", shared_name:str="", name=None) -> Annotated[Any, TV_UnbatchGrad_T]:
+  r"""Gradient of Unbatch.
+
+  Acts like Batch but using the given batch_index index of batching things as they
+  become available. This ensures that the gradients are propagated back in the
+  same session which did the forward pass.
+
+  original_input: The input to the Unbatch operation this is the gradient of.
+  batch_index: The batch_index given to the Unbatch operation this is the gradient
+  of.
+  grad: The downstream gradient.
+  id: The id scalar emitted by Batch.
+  batched_grad: The return value, either an empty tensor or the batched gradient.
+  container: Container to control resource sharing.
+  shared_name: Instances of UnbatchGrad with the same container and shared_name
+   are assumed to possibly belong to the same batch. If left empty, the op name
+   will be used as the shared name.
+
+  Args:
+    original_input: A `Tensor`.
+    batch_index: A `Tensor` of type `int64`.
+    grad: A `Tensor`. Must have the same type as `original_input`.
+    id: A `Tensor` of type `int64`.
+    container: An optional `string`. Defaults to `""`.
+    shared_name: An optional `string`. Defaults to `""`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `original_input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "UnbatchGrad", name, original_input, batch_index, grad, id,
+        "container", container, "shared_name", shared_name)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return unbatch_grad_eager_fallback(
+          original_input, batch_index, grad, id, container=container,
+          shared_name=shared_name, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  if container is None:
+    container = ""
+  container = _execute.make_str(container, "container")
+  if shared_name is None:
+    shared_name = ""
+  shared_name = _execute.make_str(shared_name, "shared_name")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "UnbatchGrad", original_input=original_input, batch_index=batch_index,
+                       grad=grad, id=id, container=container,
+                       shared_name=shared_name, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("container", _op.get_attr("container"), "shared_name",
+              _op.get_attr("shared_name"), "T", _op._get_attr_type("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "UnbatchGrad", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+UnbatchGrad = tf_export("raw_ops.UnbatchGrad")(_ops.to_raw_op(unbatch_grad))
+
+
+def unbatch_grad_eager_fallback(original_input: Annotated[Any, TV_UnbatchGrad_T], batch_index: Annotated[Any, _atypes.Int64], grad: Annotated[Any, TV_UnbatchGrad_T], id: Annotated[Any, _atypes.Int64], container: str, shared_name: str, name, ctx) -> Annotated[Any, TV_UnbatchGrad_T]:
+  if container is None:
+    container = ""
+  container = _execute.make_str(container, "container")
+  if shared_name is None:
+    shared_name = ""
+  shared_name = _execute.make_str(shared_name, "shared_name")
+  _attr_T, _inputs_T = _execute.args_to_matching_eager([original_input, grad], ctx, [])
+  (original_input, grad) = _inputs_T
+  batch_index = _ops.convert_to_tensor(batch_index, _dtypes.int64)
+  id = _ops.convert_to_tensor(id, _dtypes.int64)
+  _inputs_flat = [original_input, batch_index, grad, id]
+  _attrs = ("container", container, "shared_name", shared_name, "T", _attr_T)
+  _result = _execute.execute(b"UnbatchGrad", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "UnbatchGrad", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/gen_bitwise_ops.py

@@ -0,0 +1,765 @@
+"""Python wrappers around TensorFlow ops.
+
+This file is MACHINE GENERATED! Do not edit.
+"""
+
+import collections
+
+from tensorflow.python import pywrap_tfe as pywrap_tfe
+from tensorflow.python.eager import context as _context
+from tensorflow.python.eager import core as _core
+from tensorflow.python.eager import execute as _execute
+from tensorflow.python.framework import dtypes as _dtypes
+from tensorflow.security.fuzzing.py import annotation_types as _atypes
+
+from tensorflow.python.framework import op_def_registry as _op_def_registry
+from tensorflow.python.framework import ops as _ops
+from tensorflow.python.framework import op_def_library as _op_def_library
+from tensorflow.python.util.deprecation import deprecated_endpoints
+from tensorflow.python.util import dispatch as _dispatch
+from tensorflow.python.util.tf_export import tf_export
+
+from typing import TypeVar, List, Any
+from typing_extensions import Annotated
+
+TV_BitwiseAnd_T = TypeVar("TV_BitwiseAnd_T", _atypes.Int16, _atypes.Int32, _atypes.Int64, _atypes.Int8, _atypes.UInt16, _atypes.UInt32, _atypes.UInt64, _atypes.UInt8)
+
+@_dispatch.add_fallback_dispatch_list
+@_dispatch.add_type_based_api_dispatcher
+@tf_export('bitwise.bitwise_and')
+def bitwise_and(x: Annotated[Any, TV_BitwiseAnd_T], y: Annotated[Any, TV_BitwiseAnd_T], name=None) -> Annotated[Any, TV_BitwiseAnd_T]:
+  r"""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`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "BitwiseAnd", name, x, y)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      _result = _dispatcher_for_bitwise_and(
+          (x, y, name,), None)
+      if _result is not NotImplemented:
+        return _result
+      return bitwise_and_eager_fallback(
+          x, y, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+    except (TypeError, ValueError):
+      _result = _dispatch.dispatch(
+            bitwise_and, (), dict(x=x, y=y, name=name)
+          )
+      if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+        return _result
+      raise
+  else:
+    _result = _dispatcher_for_bitwise_and(
+        (x, y, name,), None)
+    if _result is not NotImplemented:
+      return _result
+  # Add nodes to the TensorFlow graph.
+  try:
+    _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "BitwiseAnd", x=x, y=y, name=name)
+  except (TypeError, ValueError):
+    _result = _dispatch.dispatch(
+          bitwise_and, (), dict(x=x, y=y, name=name)
+        )
+    if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+      return _result
+    raise
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "BitwiseAnd", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+BitwiseAnd = tf_export("raw_ops.BitwiseAnd")(_ops.to_raw_op(bitwise_and))
+_dispatcher_for_bitwise_and = bitwise_and._tf_type_based_dispatcher.Dispatch
+
+
+def bitwise_and_eager_fallback(x: Annotated[Any, TV_BitwiseAnd_T], y: Annotated[Any, TV_BitwiseAnd_T], name, ctx) -> Annotated[Any, TV_BitwiseAnd_T]:
+  _attr_T, _inputs_T = _execute.args_to_matching_eager([x, y], ctx, [_dtypes.int8, _dtypes.int16, _dtypes.int32, _dtypes.int64, _dtypes.uint8, _dtypes.uint16, _dtypes.uint32, _dtypes.uint64, ])
+  (x, y) = _inputs_T
+  _inputs_flat = [x, y]
+  _attrs = ("T", _attr_T)
+  _result = _execute.execute(b"BitwiseAnd", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "BitwiseAnd", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_BitwiseOr_T = TypeVar("TV_BitwiseOr_T", _atypes.Int16, _atypes.Int32, _atypes.Int64, _atypes.Int8, _atypes.UInt16, _atypes.UInt32, _atypes.UInt64, _atypes.UInt8)
+
+@_dispatch.add_fallback_dispatch_list
+@_dispatch.add_type_based_api_dispatcher
+@tf_export('bitwise.bitwise_or')
+def bitwise_or(x: Annotated[Any, TV_BitwiseOr_T], y: Annotated[Any, TV_BitwiseOr_T], name=None) -> Annotated[Any, TV_BitwiseOr_T]:
+  r"""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`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "BitwiseOr", name, x, y)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      _result = _dispatcher_for_bitwise_or(
+          (x, y, name,), None)
+      if _result is not NotImplemented:
+        return _result
+      return bitwise_or_eager_fallback(
+          x, y, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+    except (TypeError, ValueError):
+      _result = _dispatch.dispatch(
+            bitwise_or, (), dict(x=x, y=y, name=name)
+          )
+      if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+        return _result
+      raise
+  else:
+    _result = _dispatcher_for_bitwise_or(
+        (x, y, name,), None)
+    if _result is not NotImplemented:
+      return _result
+  # Add nodes to the TensorFlow graph.
+  try:
+    _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "BitwiseOr", x=x, y=y, name=name)
+  except (TypeError, ValueError):
+    _result = _dispatch.dispatch(
+          bitwise_or, (), dict(x=x, y=y, name=name)
+        )
+    if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+      return _result
+    raise
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "BitwiseOr", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+BitwiseOr = tf_export("raw_ops.BitwiseOr")(_ops.to_raw_op(bitwise_or))
+_dispatcher_for_bitwise_or = bitwise_or._tf_type_based_dispatcher.Dispatch
+
+
+def bitwise_or_eager_fallback(x: Annotated[Any, TV_BitwiseOr_T], y: Annotated[Any, TV_BitwiseOr_T], name, ctx) -> Annotated[Any, TV_BitwiseOr_T]:
+  _attr_T, _inputs_T = _execute.args_to_matching_eager([x, y], ctx, [_dtypes.int8, _dtypes.int16, _dtypes.int32, _dtypes.int64, _dtypes.uint8, _dtypes.uint16, _dtypes.uint32, _dtypes.uint64, ])
+  (x, y) = _inputs_T
+  _inputs_flat = [x, y]
+  _attrs = ("T", _attr_T)
+  _result = _execute.execute(b"BitwiseOr", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "BitwiseOr", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_BitwiseXor_T = TypeVar("TV_BitwiseXor_T", _atypes.Int16, _atypes.Int32, _atypes.Int64, _atypes.Int8, _atypes.UInt16, _atypes.UInt32, _atypes.UInt64, _atypes.UInt8)
+
+@_dispatch.add_fallback_dispatch_list
+@_dispatch.add_type_based_api_dispatcher
+@tf_export('bitwise.bitwise_xor')
+def bitwise_xor(x: Annotated[Any, TV_BitwiseXor_T], y: Annotated[Any, TV_BitwiseXor_T], name=None) -> Annotated[Any, TV_BitwiseXor_T]:
+  r"""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`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "BitwiseXor", name, x, y)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      _result = _dispatcher_for_bitwise_xor(
+          (x, y, name,), None)
+      if _result is not NotImplemented:
+        return _result
+      return bitwise_xor_eager_fallback(
+          x, y, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+    except (TypeError, ValueError):
+      _result = _dispatch.dispatch(
+            bitwise_xor, (), dict(x=x, y=y, name=name)
+          )
+      if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+        return _result
+      raise
+  else:
+    _result = _dispatcher_for_bitwise_xor(
+        (x, y, name,), None)
+    if _result is not NotImplemented:
+      return _result
+  # Add nodes to the TensorFlow graph.
+  try:
+    _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "BitwiseXor", x=x, y=y, name=name)
+  except (TypeError, ValueError):
+    _result = _dispatch.dispatch(
+          bitwise_xor, (), dict(x=x, y=y, name=name)
+        )
+    if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+      return _result
+    raise
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "BitwiseXor", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+BitwiseXor = tf_export("raw_ops.BitwiseXor")(_ops.to_raw_op(bitwise_xor))
+_dispatcher_for_bitwise_xor = bitwise_xor._tf_type_based_dispatcher.Dispatch
+
+
+def bitwise_xor_eager_fallback(x: Annotated[Any, TV_BitwiseXor_T], y: Annotated[Any, TV_BitwiseXor_T], name, ctx) -> Annotated[Any, TV_BitwiseXor_T]:
+  _attr_T, _inputs_T = _execute.args_to_matching_eager([x, y], ctx, [_dtypes.int8, _dtypes.int16, _dtypes.int32, _dtypes.int64, _dtypes.uint8, _dtypes.uint16, _dtypes.uint32, _dtypes.uint64, ])
+  (x, y) = _inputs_T
+  _inputs_flat = [x, y]
+  _attrs = ("T", _attr_T)
+  _result = _execute.execute(b"BitwiseXor", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "BitwiseXor", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_Invert_T = TypeVar("TV_Invert_T", _atypes.Int16, _atypes.Int32, _atypes.Int64, _atypes.Int8, _atypes.UInt16, _atypes.UInt32, _atypes.UInt64, _atypes.UInt8)
+
+@_dispatch.add_fallback_dispatch_list
+@_dispatch.add_type_based_api_dispatcher
+@tf_export('bitwise.invert')
+def invert(x: Annotated[Any, TV_Invert_T], name=None) -> Annotated[Any, TV_Invert_T]:
+  r"""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`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "Invert", name, x)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      _result = _dispatcher_for_invert(
+          (x, name,), None)
+      if _result is not NotImplemented:
+        return _result
+      return invert_eager_fallback(
+          x, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+    except (TypeError, ValueError):
+      _result = _dispatch.dispatch(
+            invert, (), dict(x=x, name=name)
+          )
+      if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+        return _result
+      raise
+  else:
+    _result = _dispatcher_for_invert(
+        (x, name,), None)
+    if _result is not NotImplemented:
+      return _result
+  # Add nodes to the TensorFlow graph.
+  try:
+    _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "Invert", x=x, name=name)
+  except (TypeError, ValueError):
+    _result = _dispatch.dispatch(
+          invert, (), dict(x=x, name=name)
+        )
+    if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+      return _result
+    raise
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "Invert", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+Invert = tf_export("raw_ops.Invert")(_ops.to_raw_op(invert))
+_dispatcher_for_invert = invert._tf_type_based_dispatcher.Dispatch
+
+
+def invert_eager_fallback(x: Annotated[Any, TV_Invert_T], name, ctx) -> Annotated[Any, TV_Invert_T]:
+  _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.int8, _dtypes.int16, _dtypes.int32, _dtypes.int64, _dtypes.uint8, _dtypes.uint16, _dtypes.uint32, _dtypes.uint64, ])
+  _inputs_flat = [x]
+  _attrs = ("T", _attr_T)
+  _result = _execute.execute(b"Invert", 1, inputs=_inputs_flat, attrs=_attrs,
+                             ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "Invert", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_LeftShift_T = TypeVar("TV_LeftShift_T", _atypes.Int16, _atypes.Int32, _atypes.Int64, _atypes.Int8, _atypes.UInt16, _atypes.UInt32, _atypes.UInt64, _atypes.UInt8)
+
+@_dispatch.add_fallback_dispatch_list
+@_dispatch.add_type_based_api_dispatcher
+@tf_export('bitwise.left_shift')
+def left_shift(x: Annotated[Any, TV_LeftShift_T], y: Annotated[Any, TV_LeftShift_T], name=None) -> Annotated[Any, TV_LeftShift_T]:
+  r"""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`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "LeftShift", name, x, y)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      _result = _dispatcher_for_left_shift(
+          (x, y, name,), None)
+      if _result is not NotImplemented:
+        return _result
+      return left_shift_eager_fallback(
+          x, y, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+    except (TypeError, ValueError):
+      _result = _dispatch.dispatch(
+            left_shift, (), dict(x=x, y=y, name=name)
+          )
+      if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+        return _result
+      raise
+  else:
+    _result = _dispatcher_for_left_shift(
+        (x, y, name,), None)
+    if _result is not NotImplemented:
+      return _result
+  # Add nodes to the TensorFlow graph.
+  try:
+    _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "LeftShift", x=x, y=y, name=name)
+  except (TypeError, ValueError):
+    _result = _dispatch.dispatch(
+          left_shift, (), dict(x=x, y=y, name=name)
+        )
+    if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+      return _result
+    raise
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "LeftShift", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+LeftShift = tf_export("raw_ops.LeftShift")(_ops.to_raw_op(left_shift))
+_dispatcher_for_left_shift = left_shift._tf_type_based_dispatcher.Dispatch
+
+
+def left_shift_eager_fallback(x: Annotated[Any, TV_LeftShift_T], y: Annotated[Any, TV_LeftShift_T], name, ctx) -> Annotated[Any, TV_LeftShift_T]:
+  _attr_T, _inputs_T = _execute.args_to_matching_eager([x, y], ctx, [_dtypes.int8, _dtypes.int16, _dtypes.int32, _dtypes.int64, _dtypes.uint8, _dtypes.uint16, _dtypes.uint32, _dtypes.uint64, ])
+  (x, y) = _inputs_T
+  _inputs_flat = [x, y]
+  _attrs = ("T", _attr_T)
+  _result = _execute.execute(b"LeftShift", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "LeftShift", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_PopulationCount_T = TypeVar("TV_PopulationCount_T", _atypes.Int16, _atypes.Int32, _atypes.Int64, _atypes.Int8, _atypes.UInt16, _atypes.UInt32, _atypes.UInt64, _atypes.UInt8)
+
+def population_count(x: Annotated[Any, TV_PopulationCount_T], name=None) -> Annotated[Any, _atypes.UInt8]:
+  r"""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`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "PopulationCount", name, x)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return population_count_eager_fallback(
+          x, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "PopulationCount", x=x, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "PopulationCount", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+PopulationCount = tf_export("raw_ops.PopulationCount")(_ops.to_raw_op(population_count))
+
+
+def population_count_eager_fallback(x: Annotated[Any, TV_PopulationCount_T], name, ctx) -> Annotated[Any, _atypes.UInt8]:
+  _attr_T, (x,) = _execute.args_to_matching_eager([x], ctx, [_dtypes.int8, _dtypes.int16, _dtypes.int32, _dtypes.int64, _dtypes.uint8, _dtypes.uint16, _dtypes.uint32, _dtypes.uint64, ])
+  _inputs_flat = [x]
+  _attrs = ("T", _attr_T)
+  _result = _execute.execute(b"PopulationCount", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "PopulationCount", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_RightShift_T = TypeVar("TV_RightShift_T", _atypes.Int16, _atypes.Int32, _atypes.Int64, _atypes.Int8, _atypes.UInt16, _atypes.UInt32, _atypes.UInt64, _atypes.UInt8)
+
+@_dispatch.add_fallback_dispatch_list
+@_dispatch.add_type_based_api_dispatcher
+@tf_export('bitwise.right_shift')
+def right_shift(x: Annotated[Any, TV_RightShift_T], y: Annotated[Any, TV_RightShift_T], name=None) -> Annotated[Any, TV_RightShift_T]:
+  r"""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`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "RightShift", name, x, y)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      _result = _dispatcher_for_right_shift(
+          (x, y, name,), None)
+      if _result is not NotImplemented:
+        return _result
+      return right_shift_eager_fallback(
+          x, y, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+    except (TypeError, ValueError):
+      _result = _dispatch.dispatch(
+            right_shift, (), dict(x=x, y=y, name=name)
+          )
+      if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+        return _result
+      raise
+  else:
+    _result = _dispatcher_for_right_shift(
+        (x, y, name,), None)
+    if _result is not NotImplemented:
+      return _result
+  # Add nodes to the TensorFlow graph.
+  try:
+    _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "RightShift", x=x, y=y, name=name)
+  except (TypeError, ValueError):
+    _result = _dispatch.dispatch(
+          right_shift, (), dict(x=x, y=y, name=name)
+        )
+    if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
+      return _result
+    raise
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "RightShift", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+RightShift = tf_export("raw_ops.RightShift")(_ops.to_raw_op(right_shift))
+_dispatcher_for_right_shift = right_shift._tf_type_based_dispatcher.Dispatch
+
+
+def right_shift_eager_fallback(x: Annotated[Any, TV_RightShift_T], y: Annotated[Any, TV_RightShift_T], name, ctx) -> Annotated[Any, TV_RightShift_T]:
+  _attr_T, _inputs_T = _execute.args_to_matching_eager([x, y], ctx, [_dtypes.int8, _dtypes.int16, _dtypes.int32, _dtypes.int64, _dtypes.uint8, _dtypes.uint16, _dtypes.uint32, _dtypes.uint64, ])
+  (x, y) = _inputs_T
+  _inputs_flat = [x, y]
+  _attrs = ("T", _attr_T)
+  _result = _execute.execute(b"RightShift", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "RightShift", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/gen_collective_ops.py

@@ -0,0 +1,1452 @@
+"""Python wrappers around TensorFlow ops.
+
+This file is MACHINE GENERATED! Do not edit.
+"""
+
+import collections
+
+from tensorflow.python import pywrap_tfe as pywrap_tfe
+from tensorflow.python.eager import context as _context
+from tensorflow.python.eager import core as _core
+from tensorflow.python.eager import execute as _execute
+from tensorflow.python.framework import dtypes as _dtypes
+from tensorflow.security.fuzzing.py import annotation_types as _atypes
+
+from tensorflow.python.framework import op_def_registry as _op_def_registry
+from tensorflow.python.framework import ops as _ops
+from tensorflow.python.framework import op_def_library as _op_def_library
+from tensorflow.python.util.deprecation import deprecated_endpoints
+from tensorflow.python.util import dispatch as _dispatch
+from tensorflow.python.util.tf_export import tf_export
+
+from typing import TypeVar, List, Any
+from typing_extensions import Annotated
+
+TV_CollectiveAllToAllV2_T = TypeVar("TV_CollectiveAllToAllV2_T", _atypes.BFloat16, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_all_to_all_v2(input: Annotated[Any, TV_CollectiveAllToAllV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], ordering_token: Annotated[List[Any], _atypes.Resource], communication_hint:str="auto", timeout_seconds:float=0, is_stateless:bool=False, name=None) -> Annotated[Any, TV_CollectiveAllToAllV2_T]:
+  r"""Mutually exchanges multiple tensors of identical type and shape.
+
+  `is_stateless` means each op does not need control dependencies to other
+  collective ops. In this case, keys that are unique at runtime
+  (e.g. `instance_key`) should be used to distinguish collective groups.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`, `half`, `float64`, `int32`, `int64`.
+    group_size: A `Tensor` of type `int32`.
+    group_key: A `Tensor` of type `int32`.
+    instance_key: A `Tensor` of type `int32`.
+    ordering_token: A list of `Tensor` objects with type `resource`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    is_stateless: An optional `bool`. Defaults to `False`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveAllToAllV2", name, input, group_size, group_key,
+        instance_key, ordering_token, "communication_hint",
+        communication_hint, "timeout_seconds", timeout_seconds,
+        "is_stateless", is_stateless)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_all_to_all_v2_eager_fallback(
+          input, group_size, group_key, instance_key, ordering_token,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, is_stateless=is_stateless,
+          name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  if not isinstance(ordering_token, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'ordering_token' argument to "
+        "'collective_all_to_all_v2' Op, not %r." % ordering_token)
+  _attr_Nordering_token = len(ordering_token)
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  if is_stateless is None:
+    is_stateless = False
+  is_stateless = _execute.make_bool(is_stateless, "is_stateless")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveAllToAllV2", input=input, group_size=group_size,
+                                group_key=group_key,
+                                instance_key=instance_key,
+                                ordering_token=ordering_token,
+                                communication_hint=communication_hint,
+                                timeout_seconds=timeout_seconds,
+                                is_stateless=is_stateless, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "communication_hint",
+              _op.get_attr("communication_hint"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"), "is_stateless",
+              _op._get_attr_bool("is_stateless"), "Nordering_token",
+              _op._get_attr_int("Nordering_token"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveAllToAllV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveAllToAllV2 = tf_export("raw_ops.CollectiveAllToAllV2")(_ops.to_raw_op(collective_all_to_all_v2))
+
+
+def collective_all_to_all_v2_eager_fallback(input: Annotated[Any, TV_CollectiveAllToAllV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], ordering_token: Annotated[List[Any], _atypes.Resource], communication_hint: str, timeout_seconds: float, is_stateless: bool, name, ctx) -> Annotated[Any, TV_CollectiveAllToAllV2_T]:
+  if not isinstance(ordering_token, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'ordering_token' argument to "
+        "'collective_all_to_all_v2' Op, not %r." % ordering_token)
+  _attr_Nordering_token = len(ordering_token)
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  if is_stateless is None:
+    is_stateless = False
+  is_stateless = _execute.make_bool(is_stateless, "is_stateless")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.bfloat16, _dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  group_size = _ops.convert_to_tensor(group_size, _dtypes.int32)
+  group_key = _ops.convert_to_tensor(group_key, _dtypes.int32)
+  instance_key = _ops.convert_to_tensor(instance_key, _dtypes.int32)
+  ordering_token = _ops.convert_n_to_tensor(ordering_token, _dtypes.resource)
+  _inputs_flat = [input, group_size, group_key, instance_key] + list(ordering_token)
+  _attrs = ("T", _attr_T, "communication_hint", communication_hint,
+  "timeout_seconds", timeout_seconds, "is_stateless", is_stateless,
+  "Nordering_token", _attr_Nordering_token)
+  _result = _execute.execute(b"CollectiveAllToAllV2", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveAllToAllV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveAllToAllV3_T = TypeVar("TV_CollectiveAllToAllV3_T", _atypes.BFloat16, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_all_to_all_v3(input: Annotated[Any, TV_CollectiveAllToAllV3_T], communicator: Annotated[Any, _atypes.Resource], group_assignment: Annotated[Any, _atypes.Int32], timeout_seconds:float=0, name=None) -> Annotated[Any, TV_CollectiveAllToAllV3_T]:
+  r"""Mutually exchanges multiple tensors of identical type and shape.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`, `half`, `float64`, `int32`, `int64`.
+    communicator: A `Tensor` of type `resource`.
+    group_assignment: A `Tensor` of type `int32`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveAllToAllV3", name, input, communicator,
+        group_assignment, "timeout_seconds", timeout_seconds)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_all_to_all_v3_eager_fallback(
+          input, communicator, group_assignment,
+          timeout_seconds=timeout_seconds, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveAllToAllV3", input=input, communicator=communicator,
+                                group_assignment=group_assignment,
+                                timeout_seconds=timeout_seconds, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveAllToAllV3", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveAllToAllV3 = tf_export("raw_ops.CollectiveAllToAllV3")(_ops.to_raw_op(collective_all_to_all_v3))
+
+
+def collective_all_to_all_v3_eager_fallback(input: Annotated[Any, TV_CollectiveAllToAllV3_T], communicator: Annotated[Any, _atypes.Resource], group_assignment: Annotated[Any, _atypes.Int32], timeout_seconds: float, name, ctx) -> Annotated[Any, TV_CollectiveAllToAllV3_T]:
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.bfloat16, _dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  communicator = _ops.convert_to_tensor(communicator, _dtypes.resource)
+  group_assignment = _ops.convert_to_tensor(group_assignment, _dtypes.int32)
+  _inputs_flat = [input, communicator, group_assignment]
+  _attrs = ("T", _attr_T, "timeout_seconds", timeout_seconds)
+  _result = _execute.execute(b"CollectiveAllToAllV3", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveAllToAllV3", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+_CollectiveAssignGroupV2Output = collections.namedtuple(
+    "CollectiveAssignGroupV2",
+    ["group_size", "group_key"])
+
+
+def collective_assign_group_v2(group_assignment: Annotated[Any, _atypes.Int32], device_index: Annotated[Any, _atypes.Int32], base_key: Annotated[Any, _atypes.Int32], name=None):
+  r"""Assign group keys based on group assignment.
+
+  Args:
+    group_assignment: A `Tensor` of type `int32`.
+    device_index: A `Tensor` of type `int32`.
+    base_key: A `Tensor` of type `int32`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A tuple of `Tensor` objects (group_size, group_key).
+
+    group_size: A `Tensor` of type `int32`.
+    group_key: A `Tensor` of type `int32`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveAssignGroupV2", name, group_assignment, device_index,
+        base_key)
+      _result = _CollectiveAssignGroupV2Output._make(_result)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_assign_group_v2_eager_fallback(
+          group_assignment, device_index, base_key, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveAssignGroupV2", group_assignment=group_assignment,
+                                   device_index=device_index,
+                                   base_key=base_key, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ()
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveAssignGroupV2", _inputs_flat, _attrs, _result)
+  _result = _CollectiveAssignGroupV2Output._make(_result)
+  return _result
+
+CollectiveAssignGroupV2 = tf_export("raw_ops.CollectiveAssignGroupV2")(_ops.to_raw_op(collective_assign_group_v2))
+
+
+def collective_assign_group_v2_eager_fallback(group_assignment: Annotated[Any, _atypes.Int32], device_index: Annotated[Any, _atypes.Int32], base_key: Annotated[Any, _atypes.Int32], name, ctx):
+  group_assignment = _ops.convert_to_tensor(group_assignment, _dtypes.int32)
+  device_index = _ops.convert_to_tensor(device_index, _dtypes.int32)
+  base_key = _ops.convert_to_tensor(base_key, _dtypes.int32)
+  _inputs_flat = [group_assignment, device_index, base_key]
+  _attrs = None
+  _result = _execute.execute(b"CollectiveAssignGroupV2", 2,
+                             inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
+                             name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveAssignGroupV2", _inputs_flat, _attrs, _result)
+  _result = _CollectiveAssignGroupV2Output._make(_result)
+  return _result
+
+
+TV_CollectiveBcastRecv_T = TypeVar("TV_CollectiveBcastRecv_T", _atypes.Bool, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_bcast_recv(T: TV_CollectiveBcastRecv_T, group_size: int, group_key: int, instance_key: int, shape, communication_hint:str="auto", timeout_seconds:float=0, name=None) -> Annotated[Any, TV_CollectiveBcastRecv_T]:
+  r"""Receives a tensor value broadcast from another device.
+
+  Args:
+    T: A `tf.DType` from: `tf.bool, tf.float32, tf.half, tf.float64, tf.int32, tf.int64`.
+    group_size: An `int`.
+    group_key: An `int`.
+    instance_key: An `int`.
+    shape: A `tf.TensorShape` or list of `ints`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor` of type `T`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveBcastRecv", name, "T", T, "group_size", group_size,
+        "group_key", group_key, "instance_key", instance_key, "shape", shape,
+        "communication_hint", communication_hint, "timeout_seconds",
+        timeout_seconds)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_bcast_recv_eager_fallback(
+          T=T, group_size=group_size, group_key=group_key,
+          instance_key=instance_key, shape=shape,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  T = _execute.make_type(T, "T")
+  group_size = _execute.make_int(group_size, "group_size")
+  group_key = _execute.make_int(group_key, "group_key")
+  instance_key = _execute.make_int(instance_key, "instance_key")
+  shape = _execute.make_shape(shape, "shape")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveBcastRecv", T=T, group_size=group_size,
+                               group_key=group_key, instance_key=instance_key,
+                               shape=shape,
+                               communication_hint=communication_hint,
+                               timeout_seconds=timeout_seconds, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "group_size",
+              _op._get_attr_int("group_size"), "group_key",
+              _op._get_attr_int("group_key"), "instance_key",
+              _op._get_attr_int("instance_key"), "shape",
+              _op.get_attr("shape"), "communication_hint",
+              _op.get_attr("communication_hint"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveBcastRecv", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveBcastRecv = tf_export("raw_ops.CollectiveBcastRecv")(_ops.to_raw_op(collective_bcast_recv))
+
+
+def collective_bcast_recv_eager_fallback(T: TV_CollectiveBcastRecv_T, group_size: int, group_key: int, instance_key: int, shape, communication_hint: str, timeout_seconds: float, name, ctx) -> Annotated[Any, TV_CollectiveBcastRecv_T]:
+  T = _execute.make_type(T, "T")
+  group_size = _execute.make_int(group_size, "group_size")
+  group_key = _execute.make_int(group_key, "group_key")
+  instance_key = _execute.make_int(instance_key, "instance_key")
+  shape = _execute.make_shape(shape, "shape")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _inputs_flat = []
+  _attrs = ("T", T, "group_size", group_size, "group_key", group_key,
+  "instance_key", instance_key, "shape", shape, "communication_hint",
+  communication_hint, "timeout_seconds", timeout_seconds)
+  _result = _execute.execute(b"CollectiveBcastRecv", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveBcastRecv", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveBcastRecvV2_T = TypeVar("TV_CollectiveBcastRecvV2_T", _atypes.Bool, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+TV_CollectiveBcastRecvV2_Tshape = TypeVar("TV_CollectiveBcastRecvV2_Tshape", _atypes.Int32, _atypes.Int64)
+
+def collective_bcast_recv_v2(group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], shape: Annotated[Any, TV_CollectiveBcastRecvV2_Tshape], T: TV_CollectiveBcastRecvV2_T, communication_hint:str="auto", timeout_seconds:float=0, name=None) -> Annotated[Any, TV_CollectiveBcastRecvV2_T]:
+  r"""Receives a tensor value broadcast from another device.
+
+  Args:
+    group_size: A `Tensor` of type `int32`.
+    group_key: A `Tensor` of type `int32`.
+    instance_key: A `Tensor` of type `int32`.
+    shape: A `Tensor`. Must be one of the following types: `int32`, `int64`.
+    T: A `tf.DType` from: `tf.bool, tf.float32, tf.half, tf.float64, tf.int32, tf.int64`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor` of type `T`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveBcastRecvV2", name, group_size, group_key,
+        instance_key, shape, "T", T, "communication_hint", communication_hint,
+        "timeout_seconds", timeout_seconds)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_bcast_recv_v2_eager_fallback(
+          group_size, group_key, instance_key, shape, T=T,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  T = _execute.make_type(T, "T")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveBcastRecvV2", group_size=group_size, group_key=group_key,
+                                 instance_key=instance_key, shape=shape, T=T,
+                                 communication_hint=communication_hint,
+                                 timeout_seconds=timeout_seconds, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "Tshape",
+              _op._get_attr_type("Tshape"), "communication_hint",
+              _op.get_attr("communication_hint"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveBcastRecvV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveBcastRecvV2 = tf_export("raw_ops.CollectiveBcastRecvV2")(_ops.to_raw_op(collective_bcast_recv_v2))
+
+
+def collective_bcast_recv_v2_eager_fallback(group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], shape: Annotated[Any, TV_CollectiveBcastRecvV2_Tshape], T: TV_CollectiveBcastRecvV2_T, communication_hint: str, timeout_seconds: float, name, ctx) -> Annotated[Any, TV_CollectiveBcastRecvV2_T]:
+  T = _execute.make_type(T, "T")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _attr_Tshape, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32)
+  group_size = _ops.convert_to_tensor(group_size, _dtypes.int32)
+  group_key = _ops.convert_to_tensor(group_key, _dtypes.int32)
+  instance_key = _ops.convert_to_tensor(instance_key, _dtypes.int32)
+  _inputs_flat = [group_size, group_key, instance_key, shape]
+  _attrs = ("T", T, "Tshape", _attr_Tshape, "communication_hint",
+  communication_hint, "timeout_seconds", timeout_seconds)
+  _result = _execute.execute(b"CollectiveBcastRecvV2", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveBcastRecvV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveBcastSend_T = TypeVar("TV_CollectiveBcastSend_T", _atypes.Bool, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_bcast_send(input: Annotated[Any, TV_CollectiveBcastSend_T], group_size: int, group_key: int, instance_key: int, shape, communication_hint:str="auto", timeout_seconds:float=0, name=None) -> Annotated[Any, TV_CollectiveBcastSend_T]:
+  r"""Broadcasts a tensor value to one or more other devices.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `bool`, `float32`, `half`, `float64`, `int32`, `int64`.
+    group_size: An `int`.
+    group_key: An `int`.
+    instance_key: An `int`.
+    shape: A `tf.TensorShape` or list of `ints`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveBcastSend", name, input, "group_size", group_size,
+        "group_key", group_key, "instance_key", instance_key, "shape", shape,
+        "communication_hint", communication_hint, "timeout_seconds",
+        timeout_seconds)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_bcast_send_eager_fallback(
+          input, group_size=group_size, group_key=group_key,
+          instance_key=instance_key, shape=shape,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  group_size = _execute.make_int(group_size, "group_size")
+  group_key = _execute.make_int(group_key, "group_key")
+  instance_key = _execute.make_int(instance_key, "instance_key")
+  shape = _execute.make_shape(shape, "shape")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveBcastSend", input=input, group_size=group_size,
+                               group_key=group_key, instance_key=instance_key,
+                               shape=shape,
+                               communication_hint=communication_hint,
+                               timeout_seconds=timeout_seconds, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "group_size",
+              _op._get_attr_int("group_size"), "group_key",
+              _op._get_attr_int("group_key"), "instance_key",
+              _op._get_attr_int("instance_key"), "shape",
+              _op.get_attr("shape"), "communication_hint",
+              _op.get_attr("communication_hint"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveBcastSend", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveBcastSend = tf_export("raw_ops.CollectiveBcastSend")(_ops.to_raw_op(collective_bcast_send))
+
+
+def collective_bcast_send_eager_fallback(input: Annotated[Any, TV_CollectiveBcastSend_T], group_size: int, group_key: int, instance_key: int, shape, communication_hint: str, timeout_seconds: float, name, ctx) -> Annotated[Any, TV_CollectiveBcastSend_T]:
+  group_size = _execute.make_int(group_size, "group_size")
+  group_key = _execute.make_int(group_key, "group_key")
+  instance_key = _execute.make_int(instance_key, "instance_key")
+  shape = _execute.make_shape(shape, "shape")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.bool, _dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  _inputs_flat = [input]
+  _attrs = ("T", _attr_T, "group_size", group_size, "group_key", group_key,
+  "instance_key", instance_key, "shape", shape, "communication_hint",
+  communication_hint, "timeout_seconds", timeout_seconds)
+  _result = _execute.execute(b"CollectiveBcastSend", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveBcastSend", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveBcastSendV2_T = TypeVar("TV_CollectiveBcastSendV2_T", _atypes.Bool, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_bcast_send_v2(input: Annotated[Any, TV_CollectiveBcastSendV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], communication_hint:str="auto", timeout_seconds:float=0, name=None) -> Annotated[Any, TV_CollectiveBcastSendV2_T]:
+  r"""Broadcasts a tensor value to one or more other devices.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `bool`, `float32`, `half`, `float64`, `int32`, `int64`.
+    group_size: A `Tensor` of type `int32`.
+    group_key: A `Tensor` of type `int32`.
+    instance_key: A `Tensor` of type `int32`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveBcastSendV2", name, input, group_size, group_key,
+        instance_key, "communication_hint", communication_hint,
+        "timeout_seconds", timeout_seconds)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_bcast_send_v2_eager_fallback(
+          input, group_size, group_key, instance_key,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveBcastSendV2", input=input, group_size=group_size,
+                                 group_key=group_key,
+                                 instance_key=instance_key,
+                                 communication_hint=communication_hint,
+                                 timeout_seconds=timeout_seconds, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "communication_hint",
+              _op.get_attr("communication_hint"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveBcastSendV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveBcastSendV2 = tf_export("raw_ops.CollectiveBcastSendV2")(_ops.to_raw_op(collective_bcast_send_v2))
+
+
+def collective_bcast_send_v2_eager_fallback(input: Annotated[Any, TV_CollectiveBcastSendV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], communication_hint: str, timeout_seconds: float, name, ctx) -> Annotated[Any, TV_CollectiveBcastSendV2_T]:
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.bool, _dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  group_size = _ops.convert_to_tensor(group_size, _dtypes.int32)
+  group_key = _ops.convert_to_tensor(group_key, _dtypes.int32)
+  instance_key = _ops.convert_to_tensor(instance_key, _dtypes.int32)
+  _inputs_flat = [input, group_size, group_key, instance_key]
+  _attrs = ("T", _attr_T, "communication_hint", communication_hint,
+  "timeout_seconds", timeout_seconds)
+  _result = _execute.execute(b"CollectiveBcastSendV2", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveBcastSendV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveGather_T = TypeVar("TV_CollectiveGather_T", _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_gather(input: Annotated[Any, TV_CollectiveGather_T], group_size: int, group_key: int, instance_key: int, shape, communication_hint:str="auto", timeout_seconds:float=0, name=None) -> Annotated[Any, TV_CollectiveGather_T]:
+  r"""Mutually accumulates multiple tensors of identical type and shape.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `float32`, `half`, `float64`, `int32`, `int64`.
+    group_size: An `int`.
+    group_key: An `int`.
+    instance_key: An `int`.
+    shape: A `tf.TensorShape` or list of `ints`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveGather", name, input, "group_size", group_size,
+        "group_key", group_key, "instance_key", instance_key, "shape", shape,
+        "communication_hint", communication_hint, "timeout_seconds",
+        timeout_seconds)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_gather_eager_fallback(
+          input, group_size=group_size, group_key=group_key,
+          instance_key=instance_key, shape=shape,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  group_size = _execute.make_int(group_size, "group_size")
+  group_key = _execute.make_int(group_key, "group_key")
+  instance_key = _execute.make_int(instance_key, "instance_key")
+  shape = _execute.make_shape(shape, "shape")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveGather", input=input, group_size=group_size,
+                            group_key=group_key, instance_key=instance_key,
+                            shape=shape,
+                            communication_hint=communication_hint,
+                            timeout_seconds=timeout_seconds, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "group_size",
+              _op._get_attr_int("group_size"), "group_key",
+              _op._get_attr_int("group_key"), "instance_key",
+              _op._get_attr_int("instance_key"), "shape",
+              _op.get_attr("shape"), "communication_hint",
+              _op.get_attr("communication_hint"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveGather", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveGather = tf_export("raw_ops.CollectiveGather")(_ops.to_raw_op(collective_gather))
+
+
+def collective_gather_eager_fallback(input: Annotated[Any, TV_CollectiveGather_T], group_size: int, group_key: int, instance_key: int, shape, communication_hint: str, timeout_seconds: float, name, ctx) -> Annotated[Any, TV_CollectiveGather_T]:
+  group_size = _execute.make_int(group_size, "group_size")
+  group_key = _execute.make_int(group_key, "group_key")
+  instance_key = _execute.make_int(instance_key, "instance_key")
+  shape = _execute.make_shape(shape, "shape")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  _inputs_flat = [input]
+  _attrs = ("T", _attr_T, "group_size", group_size, "group_key", group_key,
+  "instance_key", instance_key, "shape", shape, "communication_hint",
+  communication_hint, "timeout_seconds", timeout_seconds)
+  _result = _execute.execute(b"CollectiveGather", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveGather", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveGatherV2_T = TypeVar("TV_CollectiveGatherV2_T", _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_gather_v2(input: Annotated[Any, TV_CollectiveGatherV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], ordering_token: Annotated[List[Any], _atypes.Resource], communication_hint:str="auto", timeout_seconds:float=0, is_stateless:bool=False, name=None) -> Annotated[Any, TV_CollectiveGatherV2_T]:
+  r"""Mutually accumulates multiple tensors of identical type and shape.
+
+  `is_stateless` means each op does not need control dependencies to other
+  collective ops. In this case, keys that are unique at runtime
+  (e.g. `instance_key`) should be used to distinguish collective groups.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `float32`, `half`, `float64`, `int32`, `int64`.
+    group_size: A `Tensor` of type `int32`.
+    group_key: A `Tensor` of type `int32`.
+    instance_key: A `Tensor` of type `int32`.
+    ordering_token: A list of `Tensor` objects with type `resource`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    is_stateless: An optional `bool`. Defaults to `False`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveGatherV2", name, input, group_size, group_key,
+        instance_key, ordering_token, "communication_hint",
+        communication_hint, "timeout_seconds", timeout_seconds,
+        "is_stateless", is_stateless)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_gather_v2_eager_fallback(
+          input, group_size, group_key, instance_key, ordering_token,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, is_stateless=is_stateless,
+          name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  if not isinstance(ordering_token, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'ordering_token' argument to "
+        "'collective_gather_v2' Op, not %r." % ordering_token)
+  _attr_Nordering_token = len(ordering_token)
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  if is_stateless is None:
+    is_stateless = False
+  is_stateless = _execute.make_bool(is_stateless, "is_stateless")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveGatherV2", input=input, group_size=group_size,
+                              group_key=group_key, instance_key=instance_key,
+                              ordering_token=ordering_token,
+                              communication_hint=communication_hint,
+                              timeout_seconds=timeout_seconds,
+                              is_stateless=is_stateless, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "communication_hint",
+              _op.get_attr("communication_hint"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"), "is_stateless",
+              _op._get_attr_bool("is_stateless"), "Nordering_token",
+              _op._get_attr_int("Nordering_token"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveGatherV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveGatherV2 = tf_export("raw_ops.CollectiveGatherV2")(_ops.to_raw_op(collective_gather_v2))
+
+
+def collective_gather_v2_eager_fallback(input: Annotated[Any, TV_CollectiveGatherV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], ordering_token: Annotated[List[Any], _atypes.Resource], communication_hint: str, timeout_seconds: float, is_stateless: bool, name, ctx) -> Annotated[Any, TV_CollectiveGatherV2_T]:
+  if not isinstance(ordering_token, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'ordering_token' argument to "
+        "'collective_gather_v2' Op, not %r." % ordering_token)
+  _attr_Nordering_token = len(ordering_token)
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  if is_stateless is None:
+    is_stateless = False
+  is_stateless = _execute.make_bool(is_stateless, "is_stateless")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  group_size = _ops.convert_to_tensor(group_size, _dtypes.int32)
+  group_key = _ops.convert_to_tensor(group_key, _dtypes.int32)
+  instance_key = _ops.convert_to_tensor(instance_key, _dtypes.int32)
+  ordering_token = _ops.convert_n_to_tensor(ordering_token, _dtypes.resource)
+  _inputs_flat = [input, group_size, group_key, instance_key] + list(ordering_token)
+  _attrs = ("T", _attr_T, "communication_hint", communication_hint,
+  "timeout_seconds", timeout_seconds, "is_stateless", is_stateless,
+  "Nordering_token", _attr_Nordering_token)
+  _result = _execute.execute(b"CollectiveGatherV2", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveGatherV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+def collective_initialize_communicator(group_key: Annotated[Any, _atypes.Int32], rank: Annotated[Any, _atypes.Int32], group_size: Annotated[Any, _atypes.Int32], communication_hint:str="auto", timeout_seconds:float=0, name=None) -> Annotated[Any, _atypes.Resource]:
+  r"""Initializes a group for collective operations.
+
+  Args:
+    group_key: A `Tensor` of type `int32`.
+    rank: A `Tensor` of type `int32`.
+    group_size: A `Tensor` of type `int32`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor` of type `resource`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveInitializeCommunicator", name, group_key, rank,
+        group_size, "communication_hint", communication_hint,
+        "timeout_seconds", timeout_seconds)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_initialize_communicator_eager_fallback(
+          group_key, rank, group_size, communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveInitializeCommunicator", group_key=group_key, rank=rank,
+                                            group_size=group_size,
+                                            communication_hint=communication_hint,
+                                            timeout_seconds=timeout_seconds,
+                                            name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("communication_hint", _op.get_attr("communication_hint"),
+              "timeout_seconds", _op.get_attr("timeout_seconds"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveInitializeCommunicator", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveInitializeCommunicator = tf_export("raw_ops.CollectiveInitializeCommunicator")(_ops.to_raw_op(collective_initialize_communicator))
+
+
+def collective_initialize_communicator_eager_fallback(group_key: Annotated[Any, _atypes.Int32], rank: Annotated[Any, _atypes.Int32], group_size: Annotated[Any, _atypes.Int32], communication_hint: str, timeout_seconds: float, name, ctx) -> Annotated[Any, _atypes.Resource]:
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  group_key = _ops.convert_to_tensor(group_key, _dtypes.int32)
+  rank = _ops.convert_to_tensor(rank, _dtypes.int32)
+  group_size = _ops.convert_to_tensor(group_size, _dtypes.int32)
+  _inputs_flat = [group_key, rank, group_size]
+  _attrs = ("communication_hint", communication_hint, "timeout_seconds",
+  timeout_seconds)
+  _result = _execute.execute(b"CollectiveInitializeCommunicator", 1,
+                             inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
+                             name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveInitializeCommunicator", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveReduce_T = TypeVar("TV_CollectiveReduce_T", _atypes.BFloat16, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_reduce(input: Annotated[Any, TV_CollectiveReduce_T], group_size: int, group_key: int, instance_key: int, merge_op: str, final_op: str, subdiv_offsets, wait_for=[], communication_hint:str="auto", timeout_seconds:float=0, name=None) -> Annotated[Any, TV_CollectiveReduce_T]:
+  r"""Mutually reduces multiple tensors of identical type and shape.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`, `half`, `float64`, `int32`, `int64`.
+    group_size: An `int`.
+    group_key: An `int`.
+    instance_key: An `int`.
+    merge_op: A `string` from: `"Min", "Max", "Mul", "Add"`.
+    final_op: A `string` from: `"Id", "Div"`.
+    subdiv_offsets: A list of `ints`.
+    wait_for: An optional list of `ints`. Defaults to `[]`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveReduce", name, input, "group_size", group_size,
+        "group_key", group_key, "instance_key", instance_key, "merge_op",
+        merge_op, "final_op", final_op, "subdiv_offsets", subdiv_offsets,
+        "wait_for", wait_for, "communication_hint", communication_hint,
+        "timeout_seconds", timeout_seconds)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_reduce_eager_fallback(
+          input, group_size=group_size, group_key=group_key,
+          instance_key=instance_key, merge_op=merge_op, final_op=final_op,
+          subdiv_offsets=subdiv_offsets, wait_for=wait_for,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  group_size = _execute.make_int(group_size, "group_size")
+  group_key = _execute.make_int(group_key, "group_key")
+  instance_key = _execute.make_int(instance_key, "instance_key")
+  merge_op = _execute.make_str(merge_op, "merge_op")
+  final_op = _execute.make_str(final_op, "final_op")
+  if not isinstance(subdiv_offsets, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'subdiv_offsets' argument to "
+        "'collective_reduce' Op, not %r." % subdiv_offsets)
+  subdiv_offsets = [_execute.make_int(_i, "subdiv_offsets") for _i in subdiv_offsets]
+  if wait_for is None:
+    wait_for = []
+  if not isinstance(wait_for, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'wait_for' argument to "
+        "'collective_reduce' Op, not %r." % wait_for)
+  wait_for = [_execute.make_int(_i, "wait_for") for _i in wait_for]
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveReduce", input=input, group_size=group_size,
+                            group_key=group_key, instance_key=instance_key,
+                            merge_op=merge_op, final_op=final_op,
+                            subdiv_offsets=subdiv_offsets, wait_for=wait_for,
+                            communication_hint=communication_hint,
+                            timeout_seconds=timeout_seconds, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "group_size",
+              _op._get_attr_int("group_size"), "group_key",
+              _op._get_attr_int("group_key"), "instance_key",
+              _op._get_attr_int("instance_key"), "merge_op",
+              _op.get_attr("merge_op"), "final_op", _op.get_attr("final_op"),
+              "subdiv_offsets", _op.get_attr("subdiv_offsets"), "wait_for",
+              _op.get_attr("wait_for"), "communication_hint",
+              _op.get_attr("communication_hint"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveReduce", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveReduce = tf_export("raw_ops.CollectiveReduce")(_ops.to_raw_op(collective_reduce))
+
+
+def collective_reduce_eager_fallback(input: Annotated[Any, TV_CollectiveReduce_T], group_size: int, group_key: int, instance_key: int, merge_op: str, final_op: str, subdiv_offsets, wait_for, communication_hint: str, timeout_seconds: float, name, ctx) -> Annotated[Any, TV_CollectiveReduce_T]:
+  group_size = _execute.make_int(group_size, "group_size")
+  group_key = _execute.make_int(group_key, "group_key")
+  instance_key = _execute.make_int(instance_key, "instance_key")
+  merge_op = _execute.make_str(merge_op, "merge_op")
+  final_op = _execute.make_str(final_op, "final_op")
+  if not isinstance(subdiv_offsets, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'subdiv_offsets' argument to "
+        "'collective_reduce' Op, not %r." % subdiv_offsets)
+  subdiv_offsets = [_execute.make_int(_i, "subdiv_offsets") for _i in subdiv_offsets]
+  if wait_for is None:
+    wait_for = []
+  if not isinstance(wait_for, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'wait_for' argument to "
+        "'collective_reduce' Op, not %r." % wait_for)
+  wait_for = [_execute.make_int(_i, "wait_for") for _i in wait_for]
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.bfloat16, _dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  _inputs_flat = [input]
+  _attrs = ("T", _attr_T, "group_size", group_size, "group_key", group_key,
+  "instance_key", instance_key, "merge_op", merge_op, "final_op", final_op,
+  "subdiv_offsets", subdiv_offsets, "wait_for", wait_for,
+  "communication_hint", communication_hint, "timeout_seconds",
+  timeout_seconds)
+  _result = _execute.execute(b"CollectiveReduce", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveReduce", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveReduceScatterV2_T = TypeVar("TV_CollectiveReduceScatterV2_T", _atypes.BFloat16, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_reduce_scatter_v2(input: Annotated[Any, TV_CollectiveReduceScatterV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], ordering_token: Annotated[List[Any], _atypes.Resource], merge_op: str, final_op: str, communication_hint:str="auto", timeout_seconds:float=0, is_stateless:bool=False, max_subdivs_per_device:int=-1, name=None) -> Annotated[Any, TV_CollectiveReduceScatterV2_T]:
+  r"""Mutually reduces multiple tensors of identical type and shape and scatters the result.
+
+  `is_stateless` means each op does not need control dependencies to other
+  collective ops. In this case, keys that are unique at runtime
+  (e.g. `instance_key`) should be used to distinguish collective groups.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`, `half`, `float64`, `int32`, `int64`.
+    group_size: A `Tensor` of type `int32`.
+    group_key: A `Tensor` of type `int32`.
+    instance_key: A `Tensor` of type `int32`.
+    ordering_token: A list of `Tensor` objects with type `resource`.
+    merge_op: A `string` from: `"Min", "Max", "Mul", "Add"`.
+    final_op: A `string` from: `"Id", "Div"`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    is_stateless: An optional `bool`. Defaults to `False`.
+    max_subdivs_per_device: An optional `int`. Defaults to `-1`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveReduceScatterV2", name, input, group_size, group_key,
+        instance_key, ordering_token, "merge_op", merge_op, "final_op",
+        final_op, "communication_hint", communication_hint, "timeout_seconds",
+        timeout_seconds, "is_stateless", is_stateless,
+        "max_subdivs_per_device", max_subdivs_per_device)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_reduce_scatter_v2_eager_fallback(
+          input, group_size, group_key, instance_key, ordering_token,
+          merge_op=merge_op, final_op=final_op,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, is_stateless=is_stateless,
+          max_subdivs_per_device=max_subdivs_per_device, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  if not isinstance(ordering_token, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'ordering_token' argument to "
+        "'collective_reduce_scatter_v2' Op, not %r." % ordering_token)
+  _attr_Nordering_token = len(ordering_token)
+  merge_op = _execute.make_str(merge_op, "merge_op")
+  final_op = _execute.make_str(final_op, "final_op")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  if is_stateless is None:
+    is_stateless = False
+  is_stateless = _execute.make_bool(is_stateless, "is_stateless")
+  if max_subdivs_per_device is None:
+    max_subdivs_per_device = -1
+  max_subdivs_per_device = _execute.make_int(max_subdivs_per_device, "max_subdivs_per_device")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveReduceScatterV2", input=input, group_size=group_size,
+                                     group_key=group_key,
+                                     instance_key=instance_key,
+                                     ordering_token=ordering_token,
+                                     merge_op=merge_op, final_op=final_op,
+                                     communication_hint=communication_hint,
+                                     timeout_seconds=timeout_seconds,
+                                     is_stateless=is_stateless,
+                                     max_subdivs_per_device=max_subdivs_per_device,
+                                     name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "merge_op",
+              _op.get_attr("merge_op"), "final_op", _op.get_attr("final_op"),
+              "communication_hint", _op.get_attr("communication_hint"),
+              "timeout_seconds", _op.get_attr("timeout_seconds"),
+              "is_stateless", _op._get_attr_bool("is_stateless"),
+              "Nordering_token", _op._get_attr_int("Nordering_token"),
+              "max_subdivs_per_device",
+              _op._get_attr_int("max_subdivs_per_device"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveReduceScatterV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveReduceScatterV2 = tf_export("raw_ops.CollectiveReduceScatterV2")(_ops.to_raw_op(collective_reduce_scatter_v2))
+
+
+def collective_reduce_scatter_v2_eager_fallback(input: Annotated[Any, TV_CollectiveReduceScatterV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], ordering_token: Annotated[List[Any], _atypes.Resource], merge_op: str, final_op: str, communication_hint: str, timeout_seconds: float, is_stateless: bool, max_subdivs_per_device: int, name, ctx) -> Annotated[Any, TV_CollectiveReduceScatterV2_T]:
+  if not isinstance(ordering_token, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'ordering_token' argument to "
+        "'collective_reduce_scatter_v2' Op, not %r." % ordering_token)
+  _attr_Nordering_token = len(ordering_token)
+  merge_op = _execute.make_str(merge_op, "merge_op")
+  final_op = _execute.make_str(final_op, "final_op")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  if is_stateless is None:
+    is_stateless = False
+  is_stateless = _execute.make_bool(is_stateless, "is_stateless")
+  if max_subdivs_per_device is None:
+    max_subdivs_per_device = -1
+  max_subdivs_per_device = _execute.make_int(max_subdivs_per_device, "max_subdivs_per_device")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.bfloat16, _dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  group_size = _ops.convert_to_tensor(group_size, _dtypes.int32)
+  group_key = _ops.convert_to_tensor(group_key, _dtypes.int32)
+  instance_key = _ops.convert_to_tensor(instance_key, _dtypes.int32)
+  ordering_token = _ops.convert_n_to_tensor(ordering_token, _dtypes.resource)
+  _inputs_flat = [input, group_size, group_key, instance_key] + list(ordering_token)
+  _attrs = ("T", _attr_T, "merge_op", merge_op, "final_op", final_op,
+  "communication_hint", communication_hint, "timeout_seconds",
+  timeout_seconds, "is_stateless", is_stateless, "Nordering_token",
+  _attr_Nordering_token, "max_subdivs_per_device", max_subdivs_per_device)
+  _result = _execute.execute(b"CollectiveReduceScatterV2", 1,
+                             inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
+                             name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveReduceScatterV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveReduceV2_T = TypeVar("TV_CollectiveReduceV2_T", _atypes.BFloat16, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_reduce_v2(input: Annotated[Any, TV_CollectiveReduceV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], ordering_token: Annotated[List[Any], _atypes.Resource], merge_op: str, final_op: str, communication_hint:str="auto", timeout_seconds:float=0, is_stateless:bool=False, max_subdivs_per_device:int=-1, name=None) -> Annotated[Any, TV_CollectiveReduceV2_T]:
+  r"""Mutually reduces multiple tensors of identical type and shape.
+
+  `is_stateless` means each op does not need control dependencies to other
+  collective ops. In this case, keys that are unique at runtime
+  (e.g. `instance_key`) should be used to distinguish collective groups.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`, `half`, `float64`, `int32`, `int64`.
+    group_size: A `Tensor` of type `int32`.
+    group_key: A `Tensor` of type `int32`.
+    instance_key: A `Tensor` of type `int32`.
+    ordering_token: A list of `Tensor` objects with type `resource`.
+    merge_op: A `string` from: `"Min", "Max", "Mul", "Add"`.
+    final_op: A `string` from: `"Id", "Div"`.
+    communication_hint: An optional `string`. Defaults to `"auto"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    is_stateless: An optional `bool`. Defaults to `False`.
+    max_subdivs_per_device: An optional `int`. Defaults to `-1`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveReduceV2", name, input, group_size, group_key,
+        instance_key, ordering_token, "merge_op", merge_op, "final_op",
+        final_op, "communication_hint", communication_hint, "timeout_seconds",
+        timeout_seconds, "is_stateless", is_stateless,
+        "max_subdivs_per_device", max_subdivs_per_device)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_reduce_v2_eager_fallback(
+          input, group_size, group_key, instance_key, ordering_token,
+          merge_op=merge_op, final_op=final_op,
+          communication_hint=communication_hint,
+          timeout_seconds=timeout_seconds, is_stateless=is_stateless,
+          max_subdivs_per_device=max_subdivs_per_device, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  if not isinstance(ordering_token, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'ordering_token' argument to "
+        "'collective_reduce_v2' Op, not %r." % ordering_token)
+  _attr_Nordering_token = len(ordering_token)
+  merge_op = _execute.make_str(merge_op, "merge_op")
+  final_op = _execute.make_str(final_op, "final_op")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  if is_stateless is None:
+    is_stateless = False
+  is_stateless = _execute.make_bool(is_stateless, "is_stateless")
+  if max_subdivs_per_device is None:
+    max_subdivs_per_device = -1
+  max_subdivs_per_device = _execute.make_int(max_subdivs_per_device, "max_subdivs_per_device")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveReduceV2", input=input, group_size=group_size,
+                              group_key=group_key, instance_key=instance_key,
+                              ordering_token=ordering_token,
+                              merge_op=merge_op, final_op=final_op,
+                              communication_hint=communication_hint,
+                              timeout_seconds=timeout_seconds,
+                              is_stateless=is_stateless,
+                              max_subdivs_per_device=max_subdivs_per_device,
+                              name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "merge_op",
+              _op.get_attr("merge_op"), "final_op", _op.get_attr("final_op"),
+              "communication_hint", _op.get_attr("communication_hint"),
+              "timeout_seconds", _op.get_attr("timeout_seconds"),
+              "is_stateless", _op._get_attr_bool("is_stateless"),
+              "Nordering_token", _op._get_attr_int("Nordering_token"),
+              "max_subdivs_per_device",
+              _op._get_attr_int("max_subdivs_per_device"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveReduceV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveReduceV2 = tf_export("raw_ops.CollectiveReduceV2")(_ops.to_raw_op(collective_reduce_v2))
+
+
+def collective_reduce_v2_eager_fallback(input: Annotated[Any, TV_CollectiveReduceV2_T], group_size: Annotated[Any, _atypes.Int32], group_key: Annotated[Any, _atypes.Int32], instance_key: Annotated[Any, _atypes.Int32], ordering_token: Annotated[List[Any], _atypes.Resource], merge_op: str, final_op: str, communication_hint: str, timeout_seconds: float, is_stateless: bool, max_subdivs_per_device: int, name, ctx) -> Annotated[Any, TV_CollectiveReduceV2_T]:
+  if not isinstance(ordering_token, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'ordering_token' argument to "
+        "'collective_reduce_v2' Op, not %r." % ordering_token)
+  _attr_Nordering_token = len(ordering_token)
+  merge_op = _execute.make_str(merge_op, "merge_op")
+  final_op = _execute.make_str(final_op, "final_op")
+  if communication_hint is None:
+    communication_hint = "auto"
+  communication_hint = _execute.make_str(communication_hint, "communication_hint")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  if is_stateless is None:
+    is_stateless = False
+  is_stateless = _execute.make_bool(is_stateless, "is_stateless")
+  if max_subdivs_per_device is None:
+    max_subdivs_per_device = -1
+  max_subdivs_per_device = _execute.make_int(max_subdivs_per_device, "max_subdivs_per_device")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.bfloat16, _dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  group_size = _ops.convert_to_tensor(group_size, _dtypes.int32)
+  group_key = _ops.convert_to_tensor(group_key, _dtypes.int32)
+  instance_key = _ops.convert_to_tensor(instance_key, _dtypes.int32)
+  ordering_token = _ops.convert_n_to_tensor(ordering_token, _dtypes.resource)
+  _inputs_flat = [input, group_size, group_key, instance_key] + list(ordering_token)
+  _attrs = ("T", _attr_T, "merge_op", merge_op, "final_op", final_op,
+  "communication_hint", communication_hint, "timeout_seconds",
+  timeout_seconds, "is_stateless", is_stateless, "Nordering_token",
+  _attr_Nordering_token, "max_subdivs_per_device", max_subdivs_per_device)
+  _result = _execute.execute(b"CollectiveReduceV2", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveReduceV2", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+TV_CollectiveReduceV3_T = TypeVar("TV_CollectiveReduceV3_T", _atypes.BFloat16, _atypes.Float32, _atypes.Float64, _atypes.Half, _atypes.Int32, _atypes.Int64)
+
+def collective_reduce_v3(input: Annotated[Any, TV_CollectiveReduceV3_T], communicator: Annotated[Any, _atypes.Resource], group_assignment: Annotated[Any, _atypes.Int32], reduction: str, timeout_seconds:float=0, name=None) -> Annotated[Any, TV_CollectiveReduceV3_T]:
+  r"""Mutually reduces multiple tensors of identical type and shape.
+
+  Args:
+    input: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`, `half`, `float64`, `int32`, `int64`.
+    communicator: A `Tensor` of type `resource`.
+    group_assignment: A `Tensor` of type `int32`.
+    reduction: A `string` from: `"Min", "Max", "Mul", "Add"`.
+    timeout_seconds: An optional `float`. Defaults to `0`.
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor`. Has the same type as `input`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CollectiveReduceV3", name, input, communicator,
+        group_assignment, "reduction", reduction, "timeout_seconds",
+        timeout_seconds)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return collective_reduce_v3_eager_fallback(
+          input, communicator, group_assignment, reduction=reduction,
+          timeout_seconds=timeout_seconds, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  reduction = _execute.make_str(reduction, "reduction")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CollectiveReduceV3", input=input, communicator=communicator,
+                              group_assignment=group_assignment,
+                              reduction=reduction,
+                              timeout_seconds=timeout_seconds, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("T", _op._get_attr_type("T"), "reduction",
+              _op.get_attr("reduction"), "timeout_seconds",
+              _op.get_attr("timeout_seconds"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CollectiveReduceV3", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CollectiveReduceV3 = tf_export("raw_ops.CollectiveReduceV3")(_ops.to_raw_op(collective_reduce_v3))
+
+
+def collective_reduce_v3_eager_fallback(input: Annotated[Any, TV_CollectiveReduceV3_T], communicator: Annotated[Any, _atypes.Resource], group_assignment: Annotated[Any, _atypes.Int32], reduction: str, timeout_seconds: float, name, ctx) -> Annotated[Any, TV_CollectiveReduceV3_T]:
+  reduction = _execute.make_str(reduction, "reduction")
+  if timeout_seconds is None:
+    timeout_seconds = 0
+  timeout_seconds = _execute.make_float(timeout_seconds, "timeout_seconds")
+  _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.bfloat16, _dtypes.float32, _dtypes.half, _dtypes.float64, _dtypes.int32, _dtypes.int64, ])
+  communicator = _ops.convert_to_tensor(communicator, _dtypes.resource)
+  group_assignment = _ops.convert_to_tensor(group_assignment, _dtypes.int32)
+  _inputs_flat = [input, communicator, group_assignment]
+  _attrs = ("T", _attr_T, "reduction", reduction, "timeout_seconds",
+  timeout_seconds)
+  _result = _execute.execute(b"CollectiveReduceV3", 1, inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CollectiveReduceV3", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+

videochat2/lib/python3.10/site-packages/tensorflow/python/ops/gen_composite_tensor_ops.py

@@ -0,0 +1,172 @@
+"""Python wrappers around TensorFlow ops.
+
+This file is MACHINE GENERATED! Do not edit.
+"""
+
+import collections
+
+from tensorflow.python import pywrap_tfe as pywrap_tfe
+from tensorflow.python.eager import context as _context
+from tensorflow.python.eager import core as _core
+from tensorflow.python.eager import execute as _execute
+from tensorflow.python.framework import dtypes as _dtypes
+from tensorflow.security.fuzzing.py import annotation_types as _atypes
+
+from tensorflow.python.framework import op_def_registry as _op_def_registry
+from tensorflow.python.framework import ops as _ops
+from tensorflow.python.framework import op_def_library as _op_def_library
+from tensorflow.python.util.deprecation import deprecated_endpoints
+from tensorflow.python.util import dispatch as _dispatch
+from tensorflow.python.util.tf_export import tf_export
+
+from typing import TypeVar, List, Any
+from typing_extensions import Annotated
+
+def composite_tensor_variant_from_components(components, metadata: str, name=None) -> Annotated[Any, _atypes.Variant]:
+  r"""Encodes an `ExtensionType` value into a `variant` scalar Tensor.
+
+  Returns a scalar variant tensor containing a single `CompositeTensorVariant`
+  with the specified Tensor components and TypeSpec.
+
+  Args:
+    components: A list of `Tensor` objects.
+      The component tensors for the extension type value.
+    metadata: A `string`.
+      String serialization for the TypeSpec.  (Note: the encoding for the TypeSpec
+      may change in future versions of TensorFlow.)
+    name: A name for the operation (optional).
+
+  Returns:
+    A `Tensor` of type `variant`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CompositeTensorVariantFromComponents", name, components,
+        "metadata", metadata)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return composite_tensor_variant_from_components_eager_fallback(
+          components, metadata=metadata, name=name, ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  metadata = _execute.make_str(metadata, "metadata")
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CompositeTensorVariantFromComponents", components=components,
+                                                metadata=metadata, name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("metadata", _op.get_attr("metadata"), "Tcomponents",
+              _op.get_attr("Tcomponents"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CompositeTensorVariantFromComponents", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+CompositeTensorVariantFromComponents = tf_export("raw_ops.CompositeTensorVariantFromComponents")(_ops.to_raw_op(composite_tensor_variant_from_components))
+
+
+def composite_tensor_variant_from_components_eager_fallback(components, metadata: str, name, ctx) -> Annotated[Any, _atypes.Variant]:
+  metadata = _execute.make_str(metadata, "metadata")
+  _attr_Tcomponents, components = _execute.convert_to_mixed_eager_tensors(components, ctx)
+  _inputs_flat = list(components)
+  _attrs = ("metadata", metadata, "Tcomponents", _attr_Tcomponents)
+  _result = _execute.execute(b"CompositeTensorVariantFromComponents", 1,
+                             inputs=_inputs_flat, attrs=_attrs, ctx=ctx,
+                             name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CompositeTensorVariantFromComponents", _inputs_flat, _attrs, _result)
+  _result, = _result
+  return _result
+
+
+def composite_tensor_variant_to_components(encoded: Annotated[Any, _atypes.Variant], metadata: str, Tcomponents, name=None):
+  r"""Decodes a `variant` scalar Tensor into an `ExtensionType` value.
+
+  Returns the Tensor components encoded in a `CompositeTensorVariant`.
+
+  Raises an error if `type_spec_proto` doesn't match the TypeSpec
+  in `encoded`.
+
+  Args:
+    encoded: A `Tensor` of type `variant`.
+      A scalar `variant` Tensor containing an encoded ExtensionType value.
+    metadata: A `string`.
+      String serialization for the TypeSpec.  Must be compatible with the
+      `TypeSpec` contained in `encoded`.  (Note: the encoding for the TypeSpec
+      may change in future versions of TensorFlow.)
+    Tcomponents: A list of `tf.DTypes`. Expected dtypes for components.
+    name: A name for the operation (optional).
+
+  Returns:
+    A list of `Tensor` objects of type `Tcomponents`.
+  """
+  _ctx = _context._context or _context.context()
+  tld = _ctx._thread_local_data
+  if tld.is_eager:
+    try:
+      _result = pywrap_tfe.TFE_Py_FastPathExecute(
+        _ctx, "CompositeTensorVariantToComponents", name, encoded, "metadata",
+        metadata, "Tcomponents", Tcomponents)
+      return _result
+    except _core._NotOkStatusException as e:
+      _ops.raise_from_not_ok_status(e, name)
+    except _core._FallbackException:
+      pass
+    try:
+      return composite_tensor_variant_to_components_eager_fallback(
+          encoded, metadata=metadata, Tcomponents=Tcomponents, name=name,
+          ctx=_ctx)
+    except _core._SymbolicException:
+      pass  # Add nodes to the TensorFlow graph.
+  # Add nodes to the TensorFlow graph.
+  metadata = _execute.make_str(metadata, "metadata")
+  if not isinstance(Tcomponents, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'Tcomponents' argument to "
+        "'composite_tensor_variant_to_components' Op, not %r." % Tcomponents)
+  Tcomponents = [_execute.make_type(_t, "Tcomponents") for _t in Tcomponents]
+  _, _, _op, _outputs = _op_def_library._apply_op_helper(
+        "CompositeTensorVariantToComponents", encoded=encoded,
+                                              metadata=metadata,
+                                              Tcomponents=Tcomponents,
+                                              name=name)
+  _result = _outputs[:]
+  if _execute.must_record_gradient():
+    _attrs = ("metadata", _op.get_attr("metadata"), "Tcomponents",
+              _op.get_attr("Tcomponents"))
+    _inputs_flat = _op.inputs
+    _execute.record_gradient(
+        "CompositeTensorVariantToComponents", _inputs_flat, _attrs, _result)
+  return _result
+
+CompositeTensorVariantToComponents = tf_export("raw_ops.CompositeTensorVariantToComponents")(_ops.to_raw_op(composite_tensor_variant_to_components))
+
+
+def composite_tensor_variant_to_components_eager_fallback(encoded: Annotated[Any, _atypes.Variant], metadata: str, Tcomponents, name, ctx):
+  metadata = _execute.make_str(metadata, "metadata")
+  if not isinstance(Tcomponents, (list, tuple)):
+    raise TypeError(
+        "Expected list for 'Tcomponents' argument to "
+        "'composite_tensor_variant_to_components' Op, not %r." % Tcomponents)
+  Tcomponents = [_execute.make_type(_t, "Tcomponents") for _t in Tcomponents]
+  encoded = _ops.convert_to_tensor(encoded, _dtypes.variant)
+  _inputs_flat = [encoded]
+  _attrs = ("metadata", metadata, "Tcomponents", Tcomponents)
+  _result = _execute.execute(b"CompositeTensorVariantToComponents",
+                             len(Tcomponents), inputs=_inputs_flat,
+                             attrs=_attrs, ctx=ctx, name=name)
+  if _execute.must_record_gradient():
+    _execute.record_gradient(
+        "CompositeTensorVariantToComponents", _inputs_flat, _attrs, _result)
+  return _result
+