
"""simple docstring"""
import random
import shutil
import tempfile
import unittest

import numpy as np

from transformers import TaTokenizer, TaTokenizerFast
from transformers.testing_utils import require_sentencepiece, require_torch
from transformers.utils.import_utils import is_speech_available, is_torch_available


if is_torch_available():
    pass

if is_speech_available():
    from transformers import EncodecFeatureExtractor, MusicgenProcessor


_a   :      Optional[int]       =				random.Random()
def 					a__ ( a :					int							,  a :					List[Any]=1.0							,  a :					Tuple=None							,  a :					str=None		):

  """simple docstring"""







  if rng is None:
    _snake_case  :    Dict            = global_rng

  _snake_case  :    Union[str, Any]            = []
  for batch_idx in range(shape[0]		):
    values.append([]		)
    for _ in range(shape[1]		):
      values[-1].append(rng.random() * scale		)

  return values






@require_torch
@require_sentencepiece
class   _UpperCAmelCase					(       unittest.TestCase):
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    List[str]            = "facebook/musicgen-small"
      _snake_case  :    Dict            = tempfile.mkdtemp()
    def        lowerCamelCase__						(     self    ,     **snake_case_  ):
      return TaTokenizer.from_pretrained(self.checkpoint    ,     **snake_case_  )
    def        lowerCamelCase__						(     self    ,     **snake_case_  ):
      return EncodecFeatureExtractor.from_pretrained(self.checkpoint    ,     **snake_case_  )
    def        lowerCamelCase__						(     self  ):
      shutil.rmtree(self.tmpdirname  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Optional[int]            = self.get_tokenizer()
      _snake_case  :    Any            = self.get_feature_extractor()

      _snake_case  :    List[str]            = MusicgenProcessor(tokenizer=snake_case_    ,     feature_extractor=snake_case_  )

      processor.save_pretrained(self.tmpdirname  )
      _snake_case  :    Optional[Any]            = MusicgenProcessor.from_pretrained(self.tmpdirname  )

      self.assertEqual(processor.tokenizer.get_vocab()    ,     tokenizer.get_vocab()  )
      self.assertIsInstance(processor.tokenizer    ,     snake_case_  )

      self.assertEqual(processor.feature_extractor.to_json_string()    ,     feature_extractor.to_json_string()  )
      self.assertIsInstance(processor.feature_extractor    ,     snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Optional[int]            = MusicgenProcessor(tokenizer=self.get_tokenizer()    ,     feature_extractor=self.get_feature_extractor()  )
      processor.save_pretrained(self.tmpdirname  )

      _snake_case  :    Tuple            = self.get_tokenizer(bos_token="(BOS)"    ,     eos_token="(EOS)"  )
      _snake_case  :    List[str]            = self.get_feature_extractor(do_normalize=snake_case_    ,     padding_value=1.0  )

      _snake_case  :    int            = MusicgenProcessor.from_pretrained(
          self.tmpdirname    ,     bos_token="(BOS)"    ,     eos_token="(EOS)"    ,     do_normalize=snake_case_    ,     padding_value=1.0  )

      self.assertEqual(processor.tokenizer.get_vocab()    ,     tokenizer_add_kwargs.get_vocab()  )
      self.assertIsInstance(processor.tokenizer    ,     snake_case_  )

      self.assertEqual(processor.feature_extractor.to_json_string()    ,     feature_extractor_add_kwargs.to_json_string()  )
      self.assertIsInstance(processor.feature_extractor    ,     snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    str            = self.get_feature_extractor()
      _snake_case  :    List[Any]            = self.get_tokenizer()

      _snake_case  :    List[str]            = MusicgenProcessor(tokenizer=snake_case_    ,     feature_extractor=snake_case_  )

      _snake_case  :    List[str]            = floats_list((3, 10_00)  )

      _snake_case  :    str            = feature_extractor(snake_case_    ,     return_tensors="np"  )
      _snake_case  :    List[Any]            = processor(snake_case_    ,     return_tensors="np"  )

      for key in input_feat_extract.keys():
        self.assertAlmostEqual(input_feat_extract[key].sum()    ,     input_processor[key].sum()    ,     delta=1E-2  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Union[str, Any]            = self.get_feature_extractor()
      _snake_case  :    Optional[Any]            = self.get_tokenizer()

      _snake_case  :    Tuple            = MusicgenProcessor(tokenizer=snake_case_    ,     feature_extractor=snake_case_  )

      _snake_case  :    str            = "This is a test string"

      _snake_case  :    List[Any]            = processor(text=snake_case_  )

      _snake_case  :    Any            = tokenizer(snake_case_  )

      for key in encoded_tok.keys():
        self.assertListEqual(encoded_tok[key]    ,     encoded_processor[key]  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Dict            = self.get_feature_extractor()
      _snake_case  :    str            = self.get_tokenizer()

      _snake_case  :    Union[str, Any]            = MusicgenProcessor(tokenizer=snake_case_    ,     feature_extractor=snake_case_  )

      _snake_case  :    Dict            = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      _snake_case  :    int            = processor.batch_decode(sequences=snake_case_  )
      _snake_case  :    Tuple            = tokenizer.batch_decode(snake_case_  )

      self.assertListEqual(snake_case_    ,     snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Dict            = self.get_feature_extractor()
      _snake_case  :    Tuple            = self.get_tokenizer()

      _snake_case  :    Union[str, Any]            = MusicgenProcessor(tokenizer=snake_case_    ,     feature_extractor=snake_case_  )

      self.assertListEqual(
          processor.model_input_names    ,     feature_extractor.model_input_names    ,     msg="`processor` and `feature_extractor` model input names do not match"    ,     )


    def        lowerCamelCase__						(     self  ):
      _snake_case  :    List[str]            = self.get_feature_extractor(padding_side="left"  )
      _snake_case  :    Tuple            = self.get_tokenizer()

      _snake_case  :    Tuple            = MusicgenProcessor(tokenizer=snake_case_    ,     feature_extractor=snake_case_  )

      _snake_case  :    Tuple            = [floats_list((1, x)  )[0] for x in range(5    ,     20    ,     5  )]
      _snake_case  :    List[str]            = processor(snake_case_  ).padding_mask

      _snake_case  :    Dict            = np.asarray(floats_list((3, 20)  )  )[:, None, :]
      _snake_case  :    Tuple            = processor.batch_decode(snake_case_    ,     padding_mask=snake_case_  )

      self.assertIsInstance(snake_case_    ,     snake_case_  )

      for audio in decoded_audios:
        self.assertIsInstance(snake_case_    ,     np.ndarray  )

      self.assertTrue(decoded_audios[0].shape == (1, 10)  )
      self.assertTrue(decoded_audios[1].shape == (1, 15)  )
      self.assertTrue(decoded_audios[2].shape == (1, 20)  )




from __future__ import annotations

from collections import Counter



def  snake_case_(_UpperCamelCase	)				->      list[int]:



  """simple docstring"""






  _snake_case		=				[True] * n
  _snake_case		=				False
  _snake_case		=				False
  _snake_case		=				True

  for i in range(3					,			int(n**0.5 + 1	)					,			2	):
    _snake_case		=				i * 2
    while index < n:
      _snake_case		=				False
      _snake_case		=				index + i

  _snake_case		=				[2]

  for i in range(3					,			_UpperCamelCase					,			2	):
    if is_prime[i]:
      primes.append(_UpperCamelCase	)

  return primes



def  snake_case_(_UpperCamelCase	)				->      list[list[int]]:



  """simple docstring"""






  _snake_case		=				str(_UpperCamelCase	)
  _snake_case		=				[]
  _snake_case		=				['''0''', '''1''', '''2''', '''3''', '''4''', '''5''', '''6''', '''7''', '''8''', '''9''']

  for duplicate in Counter(_UpperCamelCase	) - Counter(set(_UpperCamelCase	)	):
    _snake_case		=				[int(number_str.replace(_UpperCamelCase					,			_UpperCamelCase	)	) for digit in digits]
    replacements.append(_UpperCamelCase	)

  return replacements



def  snake_case_(_UpperCamelCase = 8	)				->      int:



  """simple docstring"""






  _snake_case		=				set()

  # Filter primes with less than 3 replaceable digits
  _snake_case		=				{
      x for x in set(prime_sieve(1_000_000	)	) if len(str(_UpperCamelCase	)	) - len(set(str(_UpperCamelCase	)	)	) >= 3
  }

  for prime in primes:
    if prime in numbers_checked:
      continue

    _snake_case		=				digit_replacements(_UpperCamelCase	)

    for family in replacements:
      numbers_checked.update(_UpperCamelCase	)
      _snake_case		=				primes.intersection(_UpperCamelCase	)

      if len(_UpperCamelCase	) != family_length:
        continue

      return min(_UpperCamelCase	)

  return -1


if __name__ == "__main__":
 print(solution())

