






'''simple docstring'''
from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor






class      __SCREAMING_SNAKE_CASE      :




 def __init__(      self	:							str					,      __lowercase	:							Tuple					,      __lowercase	:							Optional[Any]=3					,      __lowercase	:							Union[str, Any]=32					,      __lowercase	:							Optional[Any]=3					,      __lowercase	:							Optional[int]=10					,      __lowercase	:							List[str]=[10, 20, 30, 40]					,      __lowercase	:							Union[str, Any]=[1, 1, 2, 1]					,      __lowercase	:							Optional[int]=True					,      __lowercase	:							List[Any]=True					,      __lowercase	:							Optional[int]="relu"					,      __lowercase	:							Optional[Any]=3					,      __lowercase	:							str=None					,      )	->						List[Any]:
       SCREAMING_SNAKE_CASE__     :				Any									=parent
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									=batch_size
       SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=image_size
       SCREAMING_SNAKE_CASE__     :				Tuple									=num_channels
       SCREAMING_SNAKE_CASE__     :				List[str]									=embeddings_size
       SCREAMING_SNAKE_CASE__     :				List[Any]									=hidden_sizes
       SCREAMING_SNAKE_CASE__     :				Any									=depths
       SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=is_training
       SCREAMING_SNAKE_CASE__     :				Optional[int]									=use_labels
       SCREAMING_SNAKE_CASE__     :				Dict									=hidden_act
       SCREAMING_SNAKE_CASE__     :				List[Any]									=num_labels
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									=scope
       SCREAMING_SNAKE_CASE__     :				Tuple									=len(__lowercase      )




 def      __magic_name__	(      self	:							List[str]      )	->						List[str]:
       SCREAMING_SNAKE_CASE__     :				Tuple									=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

       SCREAMING_SNAKE_CASE__     :				int									=None
       if self.use_labels:
             SCREAMING_SNAKE_CASE__     :				str									=ids_tensor([self.batch_size]					,      self.num_labels      )

       SCREAMING_SNAKE_CASE__     :				Dict									=self.get_config()
       return config, pixel_values, labels




 def      __magic_name__	(      self	:							List[Any]      )	->						Union[str, Any]:
       return RegNetConfig(
           num_channels=self.num_channels					,      embeddings_size=self.embeddings_size					,      hidden_sizes=self.hidden_sizes					,      depths=self.depths					,      hidden_act=self.hidden_act					,      num_labels=self.num_labels					,      )




 def      __magic_name__	(      self	:							Dict					,      __lowercase	:							List[str]					,      __lowercase	:							Optional[int]					,      __lowercase	:							int      )	->						Dict:
       SCREAMING_SNAKE_CASE__     :				Tuple									=TFRegNetModel(config=__lowercase      )
       SCREAMING_SNAKE_CASE__     :				Tuple									=model(__lowercase					,      training=__lowercase      )
       # 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      __magic_name__	(      self	:							int					,      __lowercase	:							Any					,      __lowercase	:							Optional[Any]					,      __lowercase	:							Tuple      )	->						Tuple:
       SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=self.num_labels
       SCREAMING_SNAKE_CASE__     :				List[str]									=TFRegNetForImageClassification(__lowercase      )
       SCREAMING_SNAKE_CASE__     :				Tuple									=model(__lowercase					,      labels=__lowercase					,      training=__lowercase      )
       self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.num_labels)      )




 def      __magic_name__	(      self	:							int      )	->						Optional[int]:
       SCREAMING_SNAKE_CASE__     :				Optional[int]									=self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE__		,	SCREAMING_SNAKE_CASE__		,	SCREAMING_SNAKE_CASE__     :				int									=config_and_inputs
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									={'''pixel_values''': pixel_values}
       return config, inputs_dict






@require_tf
class      __SCREAMING_SNAKE_CASE      (			lowerCamelCase	,				lowerCamelCase	,				unittest.TestCase				):
 snake_case_  							=							(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
 snake_case_  							=							(
     {"""feature-extraction""": TFRegNetModel, """image-classification""": TFRegNetForImageClassification}
     if is_tf_available()
     else {}
 )

 snake_case_  							=							False
 snake_case_  							=							False
 snake_case_  							=							False
 snake_case_  							=							False
 snake_case_  							=							False




 def      __magic_name__	(      self	:							List[str]      )	->						List[Any]:
       SCREAMING_SNAKE_CASE__     :				Tuple									=TFRegNetModelTester(self      )
       SCREAMING_SNAKE_CASE__     :				Dict									=ConfigTester(self					,      config_class=__lowercase					,      has_text_modality=__lowercase      )




 def      __magic_name__	(      self	:							Optional[int]      )	->						Dict:
       return




 @unittest.skip(reason='''RegNet does not use inputs_embeds'''      )
 def      __magic_name__	(      self	:							Optional[int]      )	->						Optional[int]:
       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      __magic_name__	(      self	:							List[str]      )	->						str:
       super().test_keras_fit()




 @unittest.skip(reason='''RegNet does not support input and output embeddings'''      )
 def      __magic_name__	(      self	:							int      )	->						int:
       pass




 def      __magic_name__	(      self	:							Any      )	->						Dict:
       SCREAMING_SNAKE_CASE__		,	SCREAMING_SNAKE_CASE__     :				List[str]									=self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             SCREAMING_SNAKE_CASE__     :				Any									=model_class(__lowercase      )
             SCREAMING_SNAKE_CASE__     :				Dict									=inspect.signature(model.call      )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             SCREAMING_SNAKE_CASE__     :				Optional[int]									=[*signature.parameters.keys()]

             SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=['''pixel_values''']
             self.assertListEqual(arg_names[:1]					,      __lowercase      )




 def      __magic_name__	(      self	:							Optional[int]      )	->						str:
       SCREAMING_SNAKE_CASE__     :				Optional[int]									=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__lowercase      )




 def      __magic_name__	(      self	:							List[str]      )	->						Any:
       def check_hidden_states_output(__lowercase	:							List[str]					,      __lowercase	:							List[Any]					,      __lowercase	:							Dict      ):
             SCREAMING_SNAKE_CASE__     :				List[str]									=model_class(__lowercase      )
             SCREAMING_SNAKE_CASE__     :				Tuple									=model(**self._prepare_for_class(__lowercase					,      __lowercase      )					,      training=__lowercase      )

             SCREAMING_SNAKE_CASE__     :				Optional[int]									=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

             SCREAMING_SNAKE_CASE__     :				Optional[int]									=self.model_tester.num_stages
             self.assertEqual(len(__lowercase      )					,      expected_num_stages + 1      )

             # RegNet'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 // 2, self.model_tester.image_size // 2]					,      )

       SCREAMING_SNAKE_CASE__		,	SCREAMING_SNAKE_CASE__     :				List[str]									=self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE__     :				List[str]									=['''basic''', '''bottleneck''']
       for model_class in self.all_model_classes:
             for layer_type in layers_type:
                   SCREAMING_SNAKE_CASE__     :				List[Any]									=layer_type
                   SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=True
                   check_hidden_states_output(__lowercase					,      __lowercase					,      __lowercase      )

                   # check that output_hidden_states also work using config
                   del inputs_dict["output_hidden_states"]
                   SCREAMING_SNAKE_CASE__     :				Optional[Any]									=True

                   check_hidden_states_output(__lowercase					,      __lowercase					,      __lowercase      )




 def      __magic_name__	(      self	:							List[Any]      )	->						Dict:
       SCREAMING_SNAKE_CASE__		,	SCREAMING_SNAKE_CASE__     :				Dict									=self.model_tester.prepare_config_and_inputs_for_common()

       def check_equivalence(__lowercase	:							Optional[int]					,      __lowercase	:							List[Any]					,      __lowercase	:							List[Any]					,      __lowercase	:							List[str]={}      ):
             SCREAMING_SNAKE_CASE__     :				Optional[int]									=model(__lowercase					,      return_dict=__lowercase					,      **__lowercase      )
             SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=model(__lowercase					,      return_dict=__lowercase					,      **__lowercase      ).to_tuple()

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

                   recursive_check(__lowercase					,      __lowercase      )

       for model_class in self.all_model_classes:
             SCREAMING_SNAKE_CASE__     :				str									=model_class(__lowercase      )

             SCREAMING_SNAKE_CASE__     :				int									=self._prepare_for_class(__lowercase					,      __lowercase      )
             SCREAMING_SNAKE_CASE__     :				Optional[int]									=self._prepare_for_class(__lowercase					,      __lowercase      )
             check_equivalence(__lowercase					,      __lowercase					,      __lowercase      )

             SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=self._prepare_for_class(__lowercase					,      __lowercase					,      return_labels=__lowercase      )
             SCREAMING_SNAKE_CASE__     :				int									=self._prepare_for_class(__lowercase					,      __lowercase					,      return_labels=__lowercase      )
             check_equivalence(__lowercase					,      __lowercase					,      __lowercase      )

             SCREAMING_SNAKE_CASE__     :				List[str]									=self._prepare_for_class(__lowercase					,      __lowercase      )
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=self._prepare_for_class(__lowercase					,      __lowercase      )
             check_equivalence(__lowercase					,      __lowercase					,      __lowercase					,      {'''output_hidden_states''': True}      )

             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=self._prepare_for_class(__lowercase					,      __lowercase					,      return_labels=__lowercase      )
             SCREAMING_SNAKE_CASE__     :				List[str]									=self._prepare_for_class(__lowercase					,      __lowercase					,      return_labels=__lowercase      )
             check_equivalence(__lowercase					,      __lowercase					,      __lowercase					,      {'''output_hidden_states''': True}      )




 def      __magic_name__	(      self	:							Any      )	->						Optional[Any]:
       SCREAMING_SNAKE_CASE__     :				Optional[int]									=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*__lowercase      )




 @slow
 def      __magic_name__	(      self	:							Dict      )	->						Optional[int]:
       for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             SCREAMING_SNAKE_CASE__     :				Dict									=TFRegNetModel.from_pretrained(__lowercase      )
             self.assertIsNotNone(__lowercase      )





def  _a(  ):




      '''simple docstring'''






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







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




 @cached_property
 def      __magic_name__	(      self	:							Any      )	->						str:
       return (
           AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )
           if is_vision_available()
           else None
       )




 @slow
 def      __magic_name__	(      self	:							List[Any]      )	->						Optional[Any]:
       SCREAMING_SNAKE_CASE__     :				List[str]									=TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )

       SCREAMING_SNAKE_CASE__     :				Any									=self.default_image_processor
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									=prepare_img()
       SCREAMING_SNAKE_CASE__     :				Dict									=image_processor(images=__lowercase					,      return_tensors='''tf'''      )

       # forward pass
       SCREAMING_SNAKE_CASE__     :				List[Any]									=model(**__lowercase					,      training=__lowercase      )

       # verify the logits
       SCREAMING_SNAKE_CASE__     :				Tuple									=tf.TensorShape((1, 10_00)      )
       self.assertEqual(outputs.logits.shape					,      __lowercase      )

       SCREAMING_SNAKE_CASE__     :				int									=tf.constant([-0.4180, -1.5051, -3.4836]      )

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







'''simple docstring'''
import unittest

from transformers import JukeboxTokenizer
from transformers.testing_utils import require_torch






class      __SCREAMING_SNAKE_CASE      (			unittest.TestCase				):
 snake_case_  							=							JukeboxTokenizer
 snake_case_  							=							{
     """artist""": """Zac Brown Band""",
     """genres""": """Country""",
     """lyrics""": """I met a traveller from an antique land,
        Who said \"Two vast and trunkless legs of stone
        Stand in the desert. . . . Near them, on the sand,
        Half sunk a shattered visage lies, whose frown,
        And wrinkled lip, and sneer of cold command,
        Tell that its sculptor well those passions read
        Which yet survive, stamped on these lifeless things,
        The hand that mocked them, and the heart that fed;
        And on the pedestal, these words appear:
        My name is Ozymandias, King of Kings;
        Look on my Works, ye Mighty, and despair!
        Nothing beside remains. Round the decay
        Of that colossal Wreck, boundless and bare
        The lone and level sands stretch far away
        """,
 }




 @require_torch
 def      __magic_name__	(      self	:							Optional[int]      )	->						str:
       import torch

       SCREAMING_SNAKE_CASE__     :				List[str]									=JukeboxTokenizer.from_pretrained('''openai/jukebox-1b-lyrics'''      )
       SCREAMING_SNAKE_CASE__     :				str									=tokenizer(**self.metas      )['''input_ids''']
       # fmt: off
       SCREAMING_SNAKE_CASE__     :				str									=[
           torch.tensor([[
               0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27,
               76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32,
               44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43,
               47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76,
               76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35,
               30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76,
               27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45,
               45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46,
               41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
               19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31,
               76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63,
               76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39,
               64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40,
               30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8,
               27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45,
               34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45,
               27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34,
               41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76,
               76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49,
               44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64,
               76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41,
               32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27,
               40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76,
               20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46,
               45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49,
               31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27,
               45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78,
               76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29,
               34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48,
               31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41,
               40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31,
               38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64,
               78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31,
               76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39,
               41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76,
               27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44,
               46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78,
               76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76,
               41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45,
               46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49,
               41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65,
               78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76,
               40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39,
               27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33,
               76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76,
               76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76,
               41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64,
               76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76,
               27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67,
               78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46,
               34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76,
               44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47,
               40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51,
               78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76,
               46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27,
               38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47,
               40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28,
               27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
               20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30,
               76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45,
               76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44,
               76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76,
               76, 76]]      ),
           torch.tensor([[0, 0, 0, 10_69, 11]]      ),
           torch.tensor([[0, 0, 0, 10_69, 11]]      ),
       ]
       # fmt: on
       self.assertTrue(torch.allclose(tokens[0]					,      EXPECTED_OUTPUT[0]      )      )
       self.assertTrue(torch.allclose(tokens[1]					,      EXPECTED_OUTPUT[1]      )      )
       self.assertTrue(torch.allclose(tokens[2]					,      EXPECTED_OUTPUT[2]      )      )




 @require_torch
 def      __magic_name__	(      self	:							Any      )	->						List[str]:
       import torch

       SCREAMING_SNAKE_CASE__     :				int									=JukeboxTokenizer.from_pretrained('''openai/jukebox-5b-lyrics'''      )
       SCREAMING_SNAKE_CASE__     :				List[str]									=tokenizer(**self.metas      )['''input_ids''']
       # fmt: off
       SCREAMING_SNAKE_CASE__     :				Optional[int]									=[
           torch.tensor([[
               0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39,
               31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38,
               31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27,
               40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64,
               79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41,
               77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48,
               27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40,
               37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41,
               32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77,
               77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40,
               77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63,
               77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77,
               46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31,
               77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77,
               77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37,
               77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30,
               77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45,
               64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49,
               40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1,
               40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77,
               38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31,
               31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29,
               41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77,
               77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27,
               46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46,
               41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45,
               31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44,
               31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77,
               23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47,
               44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42,
               31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77,
               38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35,
               40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77,
               77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34,
               27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34,
               31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77,
               34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32,
               31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77,
               1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42,
               31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31,
               45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42,
               31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77,
               77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77,
               15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77,
               11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33,
               45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12,
               41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41,
               44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34,
               46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42,
               27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77,
               77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45,
               35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63,
               77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30,
               31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77,
               77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38,
               41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64,
               77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27,
               40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77,
               77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31,
               77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45,
               27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34,
               77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77,
               77, 77, 77, 77, 77, 77]]      ),
           torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]      ),
           torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]      ),
       ]
       # fmt: on
       self.assertTrue(torch.allclose(tokens[0]					,      EXPECTED_OUTPUT[0]      )      )
       self.assertTrue(torch.allclose(tokens[1]					,      EXPECTED_OUTPUT[1]      )      )
       self.assertTrue(torch.allclose(tokens[2]					,      EXPECTED_OUTPUT[2]      )      )