






'''simple docstring'''
import re
import time
from typing import Optional

import IPython.display as disp

from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length





def  _a(  UpperCamelCase__				:						List[Any]							):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=int(UpperCamelCase__							)
      SCREAMING_SNAKE_CASE__		,	SCREAMING_SNAKE_CASE__		,	SCREAMING_SNAKE_CASE__     :				List[str]									=t // 3_6_0_0, (t // 6_0) % 6_0, t % 6_0
      return f"{h}:{m:02d}:{s:02d}" if h != 0 else f"{m:02d}:{s:02d}"





def  _a(  UpperCamelCase__				:						Optional[Any],	UpperCamelCase__				:						Dict,	UpperCamelCase__				:						int,	UpperCamelCase__				:						Union[str, Any],	UpperCamelCase__				:						Dict=3_0_0							):




      '''simple docstring'''






      return f"\n    <div>\n      {prefix}\n      <progress value='{value}' max='{total}' style='width:{width}px; height:20px; vertical-align: middle;'></progress>\n      {label}\n    </div>\n    "





def  _a(  UpperCamelCase__				:						Any							):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__     :				List[str]									='''<table border="1" class="dataframe">\n'''
      html_code += """  <thead>\n <tr style="text-align: left;">\n"""
      for i in items[0]:
            html_code += f"      <th>{i}</th>\n"
      html_code += "    </tr>\n  </thead>\n  <tbody>\n"
      for line in items[1:]:
            html_code += "    <tr>\n"
            for elt in line:
                  SCREAMING_SNAKE_CASE__     :				List[Any]									=f"{elt:.6f}" if isinstance(UpperCamelCase__,	UpperCamelCase__							) else str(UpperCamelCase__							)
                  html_code += f"      <td>{elt}</td>\n"
            html_code += "    </tr>\n"
      html_code += "  </tbody>\n</table><p>"
      return html_code






class      __SCREAMING_SNAKE_CASE      :
 snake_case_  							=							5
 snake_case_  							=							0.2




 def __init__(      self	:							str					,      __lowercase	:							int					,      __lowercase	:							Optional[str] = None					,      __lowercase	:							bool = True					,      __lowercase	:							Optional["NotebookTrainingTracker"] = None					,      __lowercase	:							int = 3_00					,      )	->						Optional[Any]:
       SCREAMING_SNAKE_CASE__     :				List[Any]									=total
       SCREAMING_SNAKE_CASE__     :				List[str]									='''''' if prefix is None else prefix
       SCREAMING_SNAKE_CASE__     :				Tuple									=leave
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									=parent
       SCREAMING_SNAKE_CASE__     :				List[Any]									=width
       SCREAMING_SNAKE_CASE__     :				List[Any]									=None
       SCREAMING_SNAKE_CASE__     :				List[str]									=None
       SCREAMING_SNAKE_CASE__     :				str									=None




 def      __magic_name__	(      self	:							int					,      __lowercase	:							int					,      __lowercase	:							bool = False					,      __lowercase	:							str = None      )	->						Union[str, Any]:
       SCREAMING_SNAKE_CASE__     :				Tuple									=value
       if comment is not None:
             SCREAMING_SNAKE_CASE__     :				Tuple									=comment
       if self.last_value is None:
             SCREAMING_SNAKE_CASE__     :				str									=time.time()
             SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=value
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=None
             SCREAMING_SNAKE_CASE__     :				Any									=self.warmup
             SCREAMING_SNAKE_CASE__     :				Any									=1
             self.update_bar(__lowercase      )
       elif value <= self.last_value and not force_update:
             return
       elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for					,      self.total      ):
             if self.first_calls > 0:
                   self.first_calls -= 1
             SCREAMING_SNAKE_CASE__     :				Optional[int]									=time.time()
             SCREAMING_SNAKE_CASE__     :				Any									=current_time - self.start_time
             # We could have value = self.start_value if the update is called twixe with the same start value.
             if value > self.start_value:
                   SCREAMING_SNAKE_CASE__     :				Any									=self.elapsed_time / (value - self.start_value)
             else:
                   SCREAMING_SNAKE_CASE__     :				Dict									=None
             if value >= self.total:
                   SCREAMING_SNAKE_CASE__     :				int									=self.total
                   SCREAMING_SNAKE_CASE__     :				Optional[int]									=None
                   if not self.leave:
                         self.close()
             elif self.average_time_per_item is not None:
                   SCREAMING_SNAKE_CASE__     :				List[Any]									=self.average_time_per_item * (self.total - value)
             self.update_bar(__lowercase      )
             SCREAMING_SNAKE_CASE__     :				int									=value
             SCREAMING_SNAKE_CASE__     :				Optional[int]									=current_time
             if self.average_time_per_item is None:
                   SCREAMING_SNAKE_CASE__     :				List[str]									=1
             else:
                   SCREAMING_SNAKE_CASE__     :				int									=max(int(self.update_every / self.average_time_per_item      )					,      1      )




 def      __magic_name__	(      self	:							str					,      __lowercase	:							List[str]					,      __lowercase	:							Union[str, Any]=None      )	->						List[str]:
       SCREAMING_SNAKE_CASE__     :				Tuple									=''' ''' * (len(str(self.total      )      ) - len(str(__lowercase      )      )) + str(__lowercase      )
       if self.elapsed_time is None:
             SCREAMING_SNAKE_CASE__     :				str									=F"[{spaced_value}/{self.total} : < :"
       elif self.predicted_remaining is None:
             SCREAMING_SNAKE_CASE__     :				Any									=F"[{spaced_value}/{self.total} {format_time(self.elapsed_time      )}"
       else:
             SCREAMING_SNAKE_CASE__     :				List[str]									=(
                 F"[{spaced_value}/{self.total} {format_time(self.elapsed_time      )} <"
                 F" {format_time(self.predicted_remaining      )}"
             )
             self.label += F", {1/self.average_time_per_item:.2f} it/s"
       self.label += "]" if self.comment is None or len(self.comment      ) == 0 else F", {self.comment}]"
       self.display()




 def      __magic_name__	(      self	:							Dict      )	->						Optional[Any]:
       SCREAMING_SNAKE_CASE__     :				int									=html_progress_bar(self.value					,      self.total					,      self.prefix					,      self.label					,      self.width      )
       if self.parent is not None:
             # If this is a child bar, the parent will take care of the display.
             self.parent.display()
             return
       if self.output is None:
             SCREAMING_SNAKE_CASE__     :				Optional[int]									=disp.display(disp.HTML(self.html_code      )					,      display_id=__lowercase      )
       else:
             self.output.update(disp.HTML(self.html_code      )      )




 def      __magic_name__	(      self	:							Dict      )	->						str:
       if self.parent is None and self.output is not None:
             self.output.update(disp.HTML(''''''      )      )






class      __SCREAMING_SNAKE_CASE      (			lowerCamelCase				):




 def __init__(      self	:							Union[str, Any]					,      __lowercase	:							Dict					,      __lowercase	:							Union[str, Any]=None      )	->						Optional[int]:
       super().__init__(__lowercase      )
       SCREAMING_SNAKE_CASE__     :				Any									=None if column_names is None else [column_names]
       SCREAMING_SNAKE_CASE__     :				Dict									=None




 def      __magic_name__	(      self	:							Optional[int]      )	->						Union[str, Any]:
       SCREAMING_SNAKE_CASE__     :				str									=html_progress_bar(self.value					,      self.total					,      self.prefix					,      self.label					,      self.width      )
       if self.inner_table is not None:
             self.html_code += text_to_html_table(self.inner_table      )
       if self.child_bar is not None:
             self.html_code += self.child_bar.html_code
       if self.output is None:
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=disp.display(disp.HTML(self.html_code      )					,      display_id=__lowercase      )
       else:
             self.output.update(disp.HTML(self.html_code      )      )




 def      __magic_name__	(      self	:							int					,      __lowercase	:							str      )	->						List[str]:
       if self.inner_table is None:
             SCREAMING_SNAKE_CASE__     :				List[str]									=[list(values.keys()      ), list(values.values()      )]
       else:
             SCREAMING_SNAKE_CASE__     :				Dict									=self.inner_table[0]
             if len(self.inner_table      ) == 1:
                   # We give a chance to update the column names at the first iteration
                   for key in values.keys():
                         if key not in columns:
                               columns.append(__lowercase      )
                   SCREAMING_SNAKE_CASE__     :				List[str]									=columns
             self.inner_table.append([values[c] for c in columns]      )




 def      __magic_name__	(      self	:							Optional[Any]					,      __lowercase	:							str					,      __lowercase	:							Dict=None					,      __lowercase	:							List[Any]=3_00      )	->						Union[str, Any]:
       SCREAMING_SNAKE_CASE__     :				int									=NotebookProgressBar(__lowercase					,      prefix=__lowercase					,      parent=self					,      width=__lowercase      )
       return self.child_bar




 def      __magic_name__	(      self	:							Union[str, Any]      )	->						int:
       SCREAMING_SNAKE_CASE__     :				Any									=None
       self.display()






class      __SCREAMING_SNAKE_CASE      (			lowerCamelCase				):




 def __init__(      self	:							Tuple      )	->						Optional[int]:
       SCREAMING_SNAKE_CASE__     :				int									=None
       SCREAMING_SNAKE_CASE__     :				Optional[int]									=None
       SCREAMING_SNAKE_CASE__     :				Any									=False




 def      __magic_name__	(      self	:							Dict					,      __lowercase	:							Optional[int]					,      __lowercase	:							Dict					,      __lowercase	:							List[Any]					,      **__lowercase	:							Any      )	->						List[Any]:
       SCREAMING_SNAKE_CASE__     :				Optional[int]									='''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
       SCREAMING_SNAKE_CASE__     :				Any									=0
       SCREAMING_SNAKE_CASE__     :				List[Any]									=0
       SCREAMING_SNAKE_CASE__     :				Tuple									=[self.first_column] + ['''Training Loss''']
       if args.evaluation_strategy != IntervalStrategy.NO:
             column_names.append('''Validation Loss'''      )
       SCREAMING_SNAKE_CASE__     :				Dict									=NotebookTrainingTracker(state.max_steps					,      __lowercase      )




 def      __magic_name__	(      self	:							Optional[int]					,      __lowercase	:							List[str]					,      __lowercase	:							str					,      __lowercase	:							int					,      **__lowercase	:							Optional[int]      )	->						str:
       SCREAMING_SNAKE_CASE__     :				Dict									=int(state.epoch      ) if int(state.epoch      ) == state.epoch else F"{state.epoch:.2f}"
       self.training_tracker.update(
           state.global_step + 1					,      comment=F"Epoch {epoch}/{state.num_train_epochs}"					,      force_update=self._force_next_update					,      )
       SCREAMING_SNAKE_CASE__     :				List[str]									=False




 def      __magic_name__	(      self	:							Union[str, Any]					,      __lowercase	:							Dict					,      __lowercase	:							int					,      __lowercase	:							Optional[int]					,      __lowercase	:							str=None					,      **__lowercase	:							int      )	->						List[str]:
       if not has_length(__lowercase      ):
             return
       if self.prediction_bar is None:
             if self.training_tracker is not None:
                   SCREAMING_SNAKE_CASE__     :				List[str]									=self.training_tracker.add_child(len(__lowercase      )      )
             else:
                   SCREAMING_SNAKE_CASE__     :				Optional[Any]									=NotebookProgressBar(len(__lowercase      )      )
             self.prediction_bar.update(1      )
       else:
             self.prediction_bar.update(self.prediction_bar.value + 1      )




 def      __magic_name__	(      self	:							Dict					,      __lowercase	:							List[Any]					,      __lowercase	:							Any					,      __lowercase	:							Dict					,      **__lowercase	:							Dict      )	->						Optional[int]:
       if self.prediction_bar is not None:
             self.prediction_bar.close()
       SCREAMING_SNAKE_CASE__     :				int									=None




 def      __magic_name__	(      self	:							Optional[Any]					,      __lowercase	:							Optional[Any]					,      __lowercase	:							Dict					,      __lowercase	:							List[str]					,      __lowercase	:							Tuple=None					,      **__lowercase	:							List[str]      )	->						int:
       # Only for when there is no evaluation
       if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
             SCREAMING_SNAKE_CASE__     :				List[Any]									={'''Training Loss''': logs['''loss''']}
             # First column is necessarily Step sine we're not in epoch eval strategy
             SCREAMING_SNAKE_CASE__     :				List[Any]									=state.global_step
             self.training_tracker.write_line(__lowercase      )




 def      __magic_name__	(      self	:							Optional[Any]					,      __lowercase	:							List[str]					,      __lowercase	:							List[str]					,      __lowercase	:							str					,      __lowercase	:							List[str]=None					,      **__lowercase	:							List[str]      )	->						Tuple:
       if self.training_tracker is not None:
             SCREAMING_SNAKE_CASE__     :				Tuple									={'''Training Loss''': '''No log''', '''Validation Loss''': '''No log'''}
             for log in reversed(state.log_history      ):
                   if "loss" in log:
                         SCREAMING_SNAKE_CASE__     :				Optional[Any]									=log['''loss''']
                         break

             if self.first_column == "Epoch":
                   SCREAMING_SNAKE_CASE__     :				Optional[Any]									=int(state.epoch      )
             else:
                   SCREAMING_SNAKE_CASE__     :				int									=state.global_step
             SCREAMING_SNAKE_CASE__     :				Tuple									='''eval'''
             for k in metrics:
                   if k.endswith('''_loss'''      ):
                         SCREAMING_SNAKE_CASE__     :				Optional[Any]									=re.sub(r'''\_loss$'''					,      ''''''					,      __lowercase      )
             SCREAMING_SNAKE_CASE__     :				List[str]									=metrics.pop('''total_flos'''					,      __lowercase      )
             SCREAMING_SNAKE_CASE__     :				List[Any]									=metrics.pop('''epoch'''					,      __lowercase      )
             SCREAMING_SNAKE_CASE__     :				int									=metrics.pop(F"{metric_key_prefix}_runtime"					,      __lowercase      )
             SCREAMING_SNAKE_CASE__     :				Any									=metrics.pop(F"{metric_key_prefix}_samples_per_second"					,      __lowercase      )
             SCREAMING_SNAKE_CASE__     :				Tuple									=metrics.pop(F"{metric_key_prefix}_steps_per_second"					,      __lowercase      )
             SCREAMING_SNAKE_CASE__     :				int									=metrics.pop(F"{metric_key_prefix}_jit_compilation_time"					,      __lowercase      )
             for k, v in metrics.items():
                   if k == F"{metric_key_prefix}_loss":
                         SCREAMING_SNAKE_CASE__     :				int									=v
                   else:
                         SCREAMING_SNAKE_CASE__     :				Tuple									=k.split('''_'''      )
                         SCREAMING_SNAKE_CASE__     :				Dict									=''' '''.join([part.capitalize() for part in splits[1:]]      )
                         SCREAMING_SNAKE_CASE__     :				str									=v
             self.training_tracker.write_line(__lowercase      )
             self.training_tracker.remove_child()
             SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=None
             # Evaluation takes a long time so we should force the next update.
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=True




 def      __magic_name__	(      self	:							Union[str, Any]					,      __lowercase	:							Union[str, Any]					,      __lowercase	:							Tuple					,      __lowercase	:							int					,      **__lowercase	:							Optional[int]      )	->						Tuple:
       self.training_tracker.update(
           state.global_step					,      comment=F"Epoch {int(state.epoch      )}/{state.num_train_epochs}"					,      force_update=__lowercase      )
       SCREAMING_SNAKE_CASE__     :				Dict									=None







'''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]      )      )