

from __future__ import annotations

import unittest
from collections.abc import Iterator



class  __snake_case					:

  def __init__(   self  ,						_A  ,						_A):
      SCREAMING_SNAKE_CASE_													=  label
      SCREAMING_SNAKE_CASE_													=  parent
      SCREAMING_SNAKE_CASE_													=  None
      SCREAMING_SNAKE_CASE_													=  None






class  __snake_case					:

  def __init__(   self):
      SCREAMING_SNAKE_CASE_													=  None

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  None

  def   lowerCAmelCase__       (   self):
      return self.root is None

  def   lowerCAmelCase__       (   self  ,						_A):
      SCREAMING_SNAKE_CASE_													=  self._put(self.root  ,						_A)

  def   lowerCAmelCase__       (   self  ,						_A  ,						_A  ,						_A = None):
      if node is None:
          SCREAMING_SNAKE_CASE_													=  Node(_A  ,						_A)
      else:
          if label < node.label:
              SCREAMING_SNAKE_CASE_													=  self._put(node.left  ,						_A  ,						_A)
          elif label > node.label:
              SCREAMING_SNAKE_CASE_													=  self._put(node.right  ,						_A  ,						_A)
          else:
              SCREAMING_SNAKE_CASE_													=  f"""Node with label {label} already exists"""
              raise Exception(_A)

      return node

  def   lowerCAmelCase__       (   self  ,						_A):
      return self._search(self.root  ,						_A)

  def   lowerCAmelCase__       (   self  ,						_A  ,						_A):
      if node is None:
          SCREAMING_SNAKE_CASE_													=  f"""Node with label {label} does not exist"""
          raise Exception(_A)
      else:
          if label < node.label:
              SCREAMING_SNAKE_CASE_													=  self._search(node.left  ,						_A)
          elif label > node.label:
              SCREAMING_SNAKE_CASE_													=  self._search(node.right  ,						_A)

      return node

  def   lowerCAmelCase__       (   self  ,						_A):
      SCREAMING_SNAKE_CASE_													=  self.search(_A)
      if node.right and node.left:
          SCREAMING_SNAKE_CASE_													=  self._get_lowest_node(node.right)
          SCREAMING_SNAKE_CASE_													=  node.left
          SCREAMING_SNAKE_CASE_													=  node.right
          SCREAMING_SNAKE_CASE_													=  lowest_node
          if node.right:
              SCREAMING_SNAKE_CASE_													=  lowest_node
          self._reassign_nodes(_A  ,						_A)
      elif not node.right and node.left:
          self._reassign_nodes(_A  ,						node.left)
      elif node.right and not node.left:
          self._reassign_nodes(_A  ,						node.right)
      else:
          self._reassign_nodes(_A  ,						_A)

  def   lowerCAmelCase__       (   self  ,						_A  ,						_A):
      if new_children:
          SCREAMING_SNAKE_CASE_													=  node.parent

      if node.parent:
          if node.parent.right == node:
              SCREAMING_SNAKE_CASE_													=  new_children
          else:
              SCREAMING_SNAKE_CASE_													=  new_children
      else:
          SCREAMING_SNAKE_CASE_													=  new_children

  def   lowerCAmelCase__       (   self  ,						_A):
      if node.left:
          SCREAMING_SNAKE_CASE_													=  self._get_lowest_node(node.left)
      else:
          SCREAMING_SNAKE_CASE_													=  node
          self._reassign_nodes(_A  ,						node.right)

      return lowest_node

  def   lowerCAmelCase__       (   self  ,						_A):
      try:
          self.search(_A)
          return True
      except Exception:
          return False

  def   lowerCAmelCase__       (   self):
      if self.root is None:
          raise Exception('Binary search tree is empty')

      SCREAMING_SNAKE_CASE_													=  self.root
      while node.right is not None:
          SCREAMING_SNAKE_CASE_													=  node.right

      return node.label

  def   lowerCAmelCase__       (   self):
      if self.root is None:
          raise Exception('Binary search tree is empty')

      SCREAMING_SNAKE_CASE_													=  self.root
      while node.left is not None:
          SCREAMING_SNAKE_CASE_													=  node.left

      return node.label

  def   lowerCAmelCase__       (   self):
      return self._inorder_traversal(self.root)

  def   lowerCAmelCase__       (   self  ,						_A):
      if node is not None:
          yield from self._inorder_traversal(node.left)
          yield node
          yield from self._inorder_traversal(node.right)

  def   lowerCAmelCase__       (   self):
      return self._preorder_traversal(self.root)


  def   lowerCAmelCase__       (   self  ,						_A):
      if node is not None:
          yield node
          yield from self._preorder_traversal(node.left)
          yield from self._preorder_traversal(node.right)






class  __snake_case					(      unittest.TestCase    ):

  @staticmethod
  def   lowerCAmelCase__       (   ):
      SCREAMING_SNAKE_CASE_													=  BinarySearchTree()
      t.put(8)
      t.put(3)
      t.put(6)
      t.put(1)
      t.put(10)
      t.put(14)
      t.put(13)
      t.put(4)
      t.put(7)
      t.put(5)

      return t

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  BinarySearchTree()
      assert t.is_empty()

      t.put(8)
      assert t.root is not None
      assert t.root.parent is None
      assert t.root.label == 8

      t.put(10)
      assert t.root.right is not None
      assert t.root.right.parent == t.root
      assert t.root.right.label == 10

      t.put(3)
      assert t.root.left is not None
      assert t.root.left.parent == t.root
      assert t.root.left.label == 3

      t.put(6)
      assert t.root.left.right is not None
      assert t.root.left.right.parent == t.root.left
      assert t.root.left.right.label == 6

      t.put(1)
      assert t.root.left.left is not None
      assert t.root.left.left.parent == t.root.left
      assert t.root.left.left.label == 1

      with self.assertRaises(_A):  # noqa: B017
          t.put(1)

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()

      SCREAMING_SNAKE_CASE_													=  t.search(6)
      assert node.label == 6

      SCREAMING_SNAKE_CASE_													=  t.search(13)
      assert node.label == 13

      with self.assertRaises(_A):  # noqa: B017
          t.search(2)

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()

      t.remove(13)
      assert t.root is not None
      assert t.root.right is not None
      assert t.root.right.right is not None
      assert t.root.right.right.right is None
      assert t.root.right.right.left is None

      t.remove(7)
      assert t.root.left is not None
      assert t.root.left.right is not None
      assert t.root.left.right.left is not None
      assert t.root.left.right.right is None
      assert t.root.left.right.left.label == 4

      t.remove(6)
      assert t.root.left.left is not None
      assert t.root.left.right.right is not None
      assert t.root.left.left.label == 1
      assert t.root.left.right.label == 4
      assert t.root.left.right.right.label == 5
      assert t.root.left.right.left is None
      assert t.root.left.left.parent == t.root.left
      assert t.root.left.right.parent == t.root.left

      t.remove(3)
      assert t.root is not None
      assert t.root.left.label == 4
      assert t.root.left.right.label == 5
      assert t.root.left.left.label == 1
      assert t.root.left.parent == t.root
      assert t.root.left.left.parent == t.root.left
      assert t.root.left.right.parent == t.root.left

      t.remove(4)
      assert t.root.left is not None
      assert t.root.left.left is not None
      assert t.root.left.label == 5
      assert t.root.left.right is None
      assert t.root.left.left.label == 1
      assert t.root.left.parent == t.root
      assert t.root.left.left.parent == t.root.left

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()

      t.remove(3)
      assert t.root is not None
      assert t.root.left is not None
      assert t.root.left.left is not None
      assert t.root.left.right is not None
      assert t.root.left.right.left is not None
      assert t.root.left.right.right is not None
      assert t.root.left.label == 4
      assert t.root.left.right.label == 6
      assert t.root.left.left.label == 1
      assert t.root.left.right.right.label == 7
      assert t.root.left.right.left.label == 5
      assert t.root.left.parent == t.root
      assert t.root.left.right.parent == t.root.left
      assert t.root.left.left.parent == t.root.left
      assert t.root.left.right.left.parent == t.root.left.right

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()
      t.empty()
      assert t.root is None

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()
      assert not t.is_empty()

      t.empty()
      assert t.is_empty()

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()

      assert t.exists(6)
      assert not t.exists(-1)

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()

      assert t.get_max_label() == 14

      t.empty()
      with self.assertRaises(_A):  # noqa: B017
          t.get_max_label()

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()

      assert t.get_min_label() == 1

      t.empty()
      with self.assertRaises(_A):  # noqa: B017
          t.get_min_label()

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()

      SCREAMING_SNAKE_CASE_													=  [i.label for i in t.inorder_traversal()]
      assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 10, 13, 14]


  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self._get_binary_search_tree()

      SCREAMING_SNAKE_CASE_													=  [i.label for i in t.preorder_traversal()]
      assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 10, 14, 13]






def    _UpperCAmelCase    (					):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_													=  BinarySearchTree()
    t.put(8    )
    t.put(3    )
    t.put(6    )
    t.put(1    )
    t.put(10    )
    t.put(14    )
    t.put(13    )
    t.put(4    )
    t.put(7    )
    t.put(5    )

    print(
        '\n            8\n           / \\\n          3   10\n         / \\    \\\n        1   6    14\n           / \\   /\n          4   7 13\n           \\\n            5\n        '    )

    print('Label 6 exists:'	,				t.exists(6    )    )
    print('Label 13 exists:'	,				t.exists(13    )    )
    print('Label -1 exists:'	,				t.exists(-1    )    )
    print('Label 12 exists:'	,				t.exists(12    )    )

    # Prints all the elements of the list in inorder traversal
    SCREAMING_SNAKE_CASE_													=  [i.label for i in t.inorder_traversal()]
    print('Inorder traversal:'	,				_SCREAMING_SNAKE_CASE    )

    # Prints all the elements of the list in preorder traversal
    SCREAMING_SNAKE_CASE_													=  [i.label for i in t.preorder_traversal()]
    print('Preorder traversal:'	,				_SCREAMING_SNAKE_CASE    )

    print('Max. label:'	,				t.get_max_label()    )
    print('Min. label:'	,				t.get_min_label()    )

    # Delete elements
    print('\nDeleting elements 13, 10, 8, 3, 6, 14'    )
    print(
        '\n          4\n         / \\\n        1   7\n             \\\n              5\n        '    )
    t.remove(13    )
    t.remove(10    )
    t.remove(8    )
    t.remove(3    )
    t.remove(6    )
    t.remove(14    )

    # Prints all the elements of the list in inorder traversal after delete
    SCREAMING_SNAKE_CASE_													=  [i.label for i in t.inorder_traversal()]
    print('Inorder traversal after delete:'	,				_SCREAMING_SNAKE_CASE    )

    # Prints all the elements of the list in preorder traversal after delete
    SCREAMING_SNAKE_CASE_													=  [i.label for i in t.preorder_traversal()]
    print('Preorder traversal after delete:'	,				_SCREAMING_SNAKE_CASE    )

    print('Max. label:'	,				t.get_max_label()    )
    print('Min. label:'	,				t.get_min_label()    )


if __name__ == "__main__":
   binary_search_tree_example()





from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
       import tensorflow as tf

       from transformers import TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
       from PIL import Image

       from transformers import ConvNextImageProcessor



class  __snake_case					:

  def __init__(   self  ,						_A  ,						_A=13  ,						_A=32  ,						_A=3  ,						_A=4  ,						_A=[10, 20, 30, 40]  ,						_A=[2, 2, 3, 2]  ,						_A=True  ,						_A=True  ,						_A=37  ,						_A="gelu"  ,						_A=10  ,						_A=0.0_2  ,						_A=3  ,						_A=None  ,						):
      SCREAMING_SNAKE_CASE_													=  parent
      SCREAMING_SNAKE_CASE_													=  batch_size
      SCREAMING_SNAKE_CASE_													=  image_size
      SCREAMING_SNAKE_CASE_													=  num_channels
      SCREAMING_SNAKE_CASE_													=  num_stages
      SCREAMING_SNAKE_CASE_													=  hidden_sizes
      SCREAMING_SNAKE_CASE_													=  depths
      SCREAMING_SNAKE_CASE_													=  is_training
      SCREAMING_SNAKE_CASE_													=  use_labels
      SCREAMING_SNAKE_CASE_													=  intermediate_size
      SCREAMING_SNAKE_CASE_													=  hidden_act
      SCREAMING_SNAKE_CASE_													=  type_sequence_label_size
      SCREAMING_SNAKE_CASE_													=  initializer_range
      SCREAMING_SNAKE_CASE_													=  scope

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

      SCREAMING_SNAKE_CASE_													=  None
      if self.use_labels:
          SCREAMING_SNAKE_CASE_													=  ids_tensor([self.batch_size]  ,						self.type_sequence_label_size)

      SCREAMING_SNAKE_CASE_													=  self.get_config()

      return config, pixel_values, labels

  def   lowerCAmelCase__       (   self):
      return ConvNextConfig(
          num_channels=self.num_channels  ,						hidden_sizes=self.hidden_sizes  ,						depths=self.depths  ,						num_stages=self.num_stages  ,						hidden_act=self.hidden_act  ,						is_decoder=_A  ,						initializer_range=self.initializer_range  ,						)

  def   lowerCAmelCase__       (   self  ,						_A  ,						_A  ,						_A):
      SCREAMING_SNAKE_CASE_													=  TFConvNextModel(config=_A)
      SCREAMING_SNAKE_CASE_													=  model(_A  ,						training=_A)
      # expected last hidden states: B, C, H // 32, W // 32
      self.parent.assertEqual(
          result.last_hidden_state.shape  ,						(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)  ,						)

  def   lowerCAmelCase__       (   self  ,						_A  ,						_A  ,						_A):
      SCREAMING_SNAKE_CASE_													=  self.type_sequence_label_size
      SCREAMING_SNAKE_CASE_													=  TFConvNextForImageClassification(_A)
      SCREAMING_SNAKE_CASE_													=  model(_A  ,						labels=_A  ,						training=_A)
      self.parent.assertEqual(result.logits.shape  ,						(self.batch_size, self.type_sequence_label_size))


  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self.prepare_config_and_inputs()
      SCREAMING_SNAKE_CASE_							,     SCREAMING_SNAKE_CASE_							,     SCREAMING_SNAKE_CASE_													=  config_and_inputs
      SCREAMING_SNAKE_CASE_													=  {'pixel_values': pixel_values}
      return config, inputs_dict






@require_tf
class  __snake_case					(      lowerCAmelCase__       ,	lowerCAmelCase__       ,	unittest.TestCase    ):
  __lowerCAmelCase       :		str  	=					(TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
  __lowerCAmelCase       :		List[str]  	=					(
      {'feature-extraction': TFConvNextModel, 'image-classification': TFConvNextForImageClassification}
      if is_tf_available()
      else {}
  )

  __lowerCAmelCase       :		Union[str, Any]  	=					False
  __lowerCAmelCase       :		Dict  	=					False
  __lowerCAmelCase       :		Optional[int]  	=					False
  __lowerCAmelCase       :		Optional[Any]  	=					False
  __lowerCAmelCase       :		List[Any]  	=					False

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  TFConvNextModelTester(self)
      SCREAMING_SNAKE_CASE_													=  ConfigTester(
          self  ,						config_class=_A  ,						has_text_modality=_A  ,						hidden_size=37  ,						)

  @unittest.skip(reason='ConvNext does not use inputs_embeds')
  def   lowerCAmelCase__       (   self):
      pass

  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices('GPU')) == 0  ,						reason='TF does not support backprop for grouped convolutions on CPU.'  ,						)
  @slow
  def   lowerCAmelCase__       (   self):
      super().test_keras_fit()

  @unittest.skip(reason='ConvNext does not support input and output embeddings')
  def   lowerCAmelCase__       (   self):
      pass

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_							,     SCREAMING_SNAKE_CASE_													=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          SCREAMING_SNAKE_CASE_													=  model_class(_A)
          SCREAMING_SNAKE_CASE_													=  inspect.signature(model.call)
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          SCREAMING_SNAKE_CASE_													=  [*signature.parameters.keys()]

          SCREAMING_SNAKE_CASE_													=  ['pixel_values']
          self.assertListEqual(arg_names[:1]  ,						_A)

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_A)

  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices('GPU')) == 0  ,						reason='TF does not support backprop for grouped convolutions on CPU.'  ,						)
  def   lowerCAmelCase__       (   self):
      super().test_dataset_conversion()

  def   lowerCAmelCase__       (   self):
      def check_hidden_states_output(_A  ,						_A  ,						_A):
          SCREAMING_SNAKE_CASE_													=  model_class(_A)

          SCREAMING_SNAKE_CASE_													=  model(**self._prepare_for_class(_A  ,						_A))
          SCREAMING_SNAKE_CASE_													=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

          SCREAMING_SNAKE_CASE_													=  self.model_tester.num_stages
          self.assertEqual(len(_A)  ,						expected_num_stages + 1)

          # ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
          self.assertListEqual(
              list(hidden_states[0].shape[-2:])  ,						[self.model_tester.image_size // 4, self.model_tester.image_size // 4]  ,						)

      SCREAMING_SNAKE_CASE_							,     SCREAMING_SNAKE_CASE_													=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          SCREAMING_SNAKE_CASE_													=  True
          check_hidden_states_output(_A  ,						_A  ,						_A)

          # check that output_hidden_states also work using config
          del inputs_dict["output_hidden_states"]
          SCREAMING_SNAKE_CASE_													=  True

          check_hidden_states_output(_A  ,						_A  ,						_A)

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_							,     SCREAMING_SNAKE_CASE_													=  self.model_tester.prepare_config_and_inputs_for_common()

      def check_equivalence(_A  ,						_A  ,						_A  ,						_A={}):
          SCREAMING_SNAKE_CASE_													=  model(_A  ,						return_dict=_A  ,						**_A)
          SCREAMING_SNAKE_CASE_													=  model(_A  ,						return_dict=_A  ,						**_A).to_tuple()

          def recursive_check(_A  ,						_A):
              if isinstance(_A  ,						(List, Tuple)):
                  for tuple_iterable_value, dict_iterable_value in zip(_A  ,						_A):
                      recursive_check(_A  ,						_A)
              elif tuple_object is None:
                  return
              else:
                  self.assertTrue(
                      all(tf.equal(_A  ,						_A))  ,						msg=(
                          'Tuple and dict output are not equal. Difference:'
                          f""" {tf.math.reduce_max(tf.abs(tuple_object - dict_object))}"""
                      )  ,						)

              recursive_check(_A  ,						_A)

      for model_class in self.all_model_classes:
          SCREAMING_SNAKE_CASE_													=  model_class(_A)

          SCREAMING_SNAKE_CASE_													=  self._prepare_for_class(_A  ,						_A)
          SCREAMING_SNAKE_CASE_													=  self._prepare_for_class(_A  ,						_A)
          check_equivalence(_A  ,						_A  ,						_A)

          SCREAMING_SNAKE_CASE_													=  self._prepare_for_class(_A  ,						_A  ,						return_labels=_A)
          SCREAMING_SNAKE_CASE_													=  self._prepare_for_class(_A  ,						_A  ,						return_labels=_A)
          check_equivalence(_A  ,						_A  ,						_A)

          SCREAMING_SNAKE_CASE_													=  self._prepare_for_class(_A  ,						_A)
          SCREAMING_SNAKE_CASE_													=  self._prepare_for_class(_A  ,						_A)
          check_equivalence(_A  ,						_A  ,						_A  ,						{'output_hidden_states': True})

          SCREAMING_SNAKE_CASE_													=  self._prepare_for_class(_A  ,						_A  ,						return_labels=_A)
          SCREAMING_SNAKE_CASE_													=  self._prepare_for_class(_A  ,						_A  ,						return_labels=_A)
          check_equivalence(_A  ,						_A  ,						_A  ,						{'output_hidden_states': True})

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_A)


  @slow
  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  TFConvNextModel.from_pretrained('facebook/convnext-tiny-224')
      self.assertIsNotNone(_A)






def    _UpperCAmelCase    (					):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_													=  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
    return image





@require_tf
@require_vision
class  __snake_case					(      unittest.TestCase    ):

  @cached_property
  def   lowerCAmelCase__       (   self):
      return ConvNextImageProcessor.from_pretrained('facebook/convnext-tiny-224') if is_vision_available() else None


  @slow
  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  TFConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224')

      SCREAMING_SNAKE_CASE_													=  self.default_image_processor
      SCREAMING_SNAKE_CASE_													=  prepare_img()
      SCREAMING_SNAKE_CASE_													=  image_processor(images=_A  ,						return_tensors='tf')

      # forward pass
      SCREAMING_SNAKE_CASE_													=  model(**_A)

      # verify the logits
      SCREAMING_SNAKE_CASE_													=  tf.TensorShape((1, 1000))
      self.assertEqual(outputs.logits.shape  ,						_A)

      SCREAMING_SNAKE_CASE_													=  tf.constant([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1])

      tf.debugging.assert_near(outputs.logits[0, :3]  ,						_A  ,						atol=1E-4)


