


def 				lowercase_		(		_A      :   int = 998001						):

      """simple docstring"""




      for number in range(n - 1   , 9999   , -1						):
            lowerCamelCase__		:    Union[str, Any]   =  str(_A						)

            # checks whether 'str_number' is a palindrome.
            if str_number == str_number[::-1]:
                  lowerCamelCase__		:    List[Any]   =  999

                  # if 'number' is a product of two 3-digit numbers
                  # then number is the answer otherwise fetch next number.
                  while divisor != 99:
                        if (number % divisor == 0) and (len(str(number // divisor						)						) == 3.0):
                              return number
                        divisor -= 1
      raise ValueError("That number is larger than our acceptable range."						)


if __name__ == "__main__":
    print(f'{solution() = }')






import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
    import torch


A				:   Union[str, Any]		= random.Random()

def 				lowercase_		(		_A      :   Any   , _A      :   int=1.0   , _A      :   Optional[int]=None   , _A      :   Union[str, Any]=None						):

      """simple docstring"""




      if rng is None:
            lowerCamelCase__		:    Any   =  global_rng

      lowerCamelCase__		:    Optional[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
class       _lowercase			(							unittest.TestCase):


       """simple docstring"""




       def __init__(       self							:      Tuple ,				__lowerCamelCase							:      str ,				__lowerCamelCase							:      Union[str, Any]=7 ,				__lowerCamelCase							:      int=400 ,				__lowerCamelCase							:      Tuple=2000 ,				__lowerCamelCase							:      int=1 ,				__lowerCamelCase							:      int=0.0 ,				__lowerCamelCase							:      int=24000 ,				__lowerCamelCase							:      Union[str, Any]=True ,				):


             '''simple docstring'''



             lowerCamelCase__		:    str   =  parent
             lowerCamelCase__		:    Union[str, Any]   =  batch_size
             lowerCamelCase__		:    str   =  min_seq_length
             lowerCamelCase__		:    int   =  max_seq_length
             lowerCamelCase__		:    List[Any]   =  (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
             lowerCamelCase__		:    List[str]   =  feature_size
             lowerCamelCase__		:    List[Any]   =  padding_value
             lowerCamelCase__		:    Union[str, Any]   =  sampling_rate
             lowerCamelCase__		:    Tuple   =  return_attention_mask





       def 						lowerCAmelCase					(       self							:      List[Any]	):


             '''simple docstring'''



             return {
                 "feature_size": self.feature_size,
                 "padding_value": self.padding_value,
                 "sampling_rate": self.sampling_rate,
                 "return_attention_mask": self.return_attention_mask,
             }





       def 						lowerCAmelCase					(       self							:      List[str] ,				__lowerCamelCase							:      Tuple=False ,				__lowerCamelCase							:      Optional[int]=False	):


             '''simple docstring'''



             def _flatten(__lowerCamelCase							:      Dict	):
                   return list(itertools.chain(*__lowerCamelCase	)	)

             if equal_length:
                   lowerCamelCase__		:    List[Any]   =  floats_list((self.batch_size, self.max_seq_length)	)
             else:
                   # make sure that inputs increase in size
                   lowerCamelCase__		:    Dict   =  [
                       _flatten(floats_list((x, self.feature_size)	)	)
                       for x in range(self.min_seq_length ,				self.max_seq_length ,				self.seq_length_diff	)
                   ]

             if numpify:
                   lowerCamelCase__		:    Optional[int]   =  [np.asarray(__lowerCamelCase	) for x in audio_inputs]

             return audio_inputs







@require_torch
class       _lowercase			(							lowercase__							,  unittest.TestCase):


       """simple docstring"""




       A__ 						=      EncodecFeatureExtractor





       def 						lowerCAmelCase					(       self							:      Union[str, Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    Optional[int]   =  EnCodecFeatureExtractionTester(self	)





       def 						lowerCAmelCase					(       self							:      int	):


             '''simple docstring'''



             lowerCamelCase__		:    Tuple   =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
             # create three inputs of length 800, 1000, and 1200
             lowerCamelCase__		:    Union[str, Any]   =  [floats_list((1, x)	)[0] for x in range(800 ,				1400 ,				200	)]
             lowerCamelCase__		:    Dict   =  [np.asarray(__lowerCamelCase	) for audio_input in audio_inputs]

             # Test not batched input
             lowerCamelCase__		:    Dict   =  feat_extract(audio_inputs[0] ,				return_tensors="np"	).input_values
             lowerCamelCase__		:    Optional[int]   =  feat_extract(np_audio_inputs[0] ,				return_tensors="np"	).input_values
             self.assertTrue(np.allclose(__lowerCamelCase ,				__lowerCamelCase ,				atol=1E-3	)	)

             # Test batched
             lowerCamelCase__		:    Dict   =  feat_extract(__lowerCamelCase ,				padding=__lowerCamelCase ,				return_tensors="np"	).input_values
             lowerCamelCase__		:    Any   =  feat_extract(__lowerCamelCase ,				padding=__lowerCamelCase ,				return_tensors="np"	).input_values
             for enc_seq_a, enc_seq_a in zip(__lowerCamelCase ,				__lowerCamelCase	):
                   self.assertTrue(np.allclose(__lowerCamelCase ,				__lowerCamelCase ,				atol=1E-3	)	)





       def 						lowerCAmelCase					(       self							:      Tuple	):


             '''simple docstring'''



             lowerCamelCase__		:    Optional[Any]   =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
             lowerCamelCase__		:    Tuple   =  np.random.rand(100	).astype(np.floataa	)
             lowerCamelCase__		:    str   =  np_audio_inputs.tolist()

             for inputs in [py_audio_inputs, np_audio_inputs]:
                   lowerCamelCase__		:    List[Any]   =  feature_extractor.pad([{"input_values": inputs}] ,				return_tensors="np"	)
                   self.assertTrue(np_processed.input_values.dtype == np.floataa	)
                   lowerCamelCase__		:    int   =  feature_extractor.pad([{"input_values": inputs}] ,				return_tensors="pt"	)
                   self.assertTrue(pt_processed.input_values.dtype == torch.floataa	)





       def 						lowerCAmelCase					(       self							:      str ,				__lowerCamelCase							:      Any	):


             '''simple docstring'''



             from datasets import load_dataset

             lowerCamelCase__		:    List[Any]   =  load_dataset("hf-internal-testing/librispeech_asr_dummy" ,				"clean" ,				split="validation"	)
             # automatic decoding with librispeech
             lowerCamelCase__		:    Union[str, Any]   =  ds.sort("id"	).select(range(__lowerCamelCase	)	)[:num_samples]["audio"]

             return [x["array"] for x in audio_samples]





       def 						lowerCAmelCase					(       self							:      List[Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    List[Any]   =  torch.tensor(
                 [2.3_8_0_4E-0_3, 2.0_7_5_2E-0_3, 1.9_8_3_6E-0_3, 2.1_0_5_7E-0_3, 1.6_1_7_4E-0_3,
                  3.0_5_1_8E-0_4, 9.1_5_5_3E-0_5, 3.3_5_6_9E-0_4, 9.7_6_5_6E-0_4, 1.8_3_1_1E-0_3,
                  2.0_1_4_2E-0_3, 2.1_0_5_7E-0_3, 1.7_3_9_5E-0_3, 4.5_7_7_6E-0_4, -3.9_6_7_3E-0_4,
                  4.5_7_7_6E-0_4, 1.0_0_7_1E-0_3, 9.1_5_5_3E-0_5, 4.8_8_2_8E-0_4, 1.1_5_9_7E-0_3,
                  7.3_2_4_2E-0_4, 9.4_6_0_4E-0_4, 1.8_0_0_5E-0_3, 1.8_3_1_1E-0_3, 8.8_5_0_1E-0_4,
                  4.2_7_2_5E-0_4, 4.8_8_2_8E-0_4, 7.3_2_4_2E-0_4, 1.0_9_8_6E-0_3, 2.1_0_5_7E-0_3]	)
             # fmt: on
             lowerCamelCase__		:    str   =  self._load_datasamples(1	)
             lowerCamelCase__		:    Any   =  EncodecFeatureExtractor()
             lowerCamelCase__		:    Optional[int]   =  feature_extractor(__lowerCamelCase ,				return_tensors="pt"	).input_values
             self.assertEquals(input_values.shape ,				(1, 1, 93680)	)
             self.assertTrue(torch.allclose(input_values[0, 0, :30] ,				__lowerCamelCase ,				atol=1E-6	)	)





       def 						lowerCAmelCase					(       self							:      Optional[int]	):


             '''simple docstring'''



             lowerCamelCase__		:    Any   =  torch.tensor(
                 [2.3_8_0_4E-0_3, 2.0_7_5_2E-0_3, 1.9_8_3_6E-0_3, 2.1_0_5_7E-0_3, 1.6_1_7_4E-0_3,
                  3.0_5_1_8E-0_4, 9.1_5_5_3E-0_5, 3.3_5_6_9E-0_4, 9.7_6_5_6E-0_4, 1.8_3_1_1E-0_3,
                  2.0_1_4_2E-0_3, 2.1_0_5_7E-0_3, 1.7_3_9_5E-0_3, 4.5_7_7_6E-0_4, -3.9_6_7_3E-0_4,
                  4.5_7_7_6E-0_4, 1.0_0_7_1E-0_3, 9.1_5_5_3E-0_5, 4.8_8_2_8E-0_4, 1.1_5_9_7E-0_3,
                  7.3_2_4_2E-0_4, 9.4_6_0_4E-0_4, 1.8_0_0_5E-0_3, 1.8_3_1_1E-0_3, 8.8_5_0_1E-0_4,
                  4.2_7_2_5E-0_4, 4.8_8_2_8E-0_4, 7.3_2_4_2E-0_4, 1.0_9_8_6E-0_3, 2.1_0_5_7E-0_3]	)
             # fmt: on
             lowerCamelCase__		:    Any   =  self._load_datasamples(1	)
             lowerCamelCase__		:    int   =  [np.tile(input_audio[0][None] ,				reps=(2, 1)	)]
             input_audio[0][1] *= 0.5
             lowerCamelCase__		:    List[str]   =  EncodecFeatureExtractor(feature_size=2	)
             lowerCamelCase__		:    Optional[Any]   =  feature_extractor(__lowerCamelCase ,				return_tensors="pt"	).input_values
             self.assertEquals(input_values.shape ,				(1, 2, 93680)	)
             self.assertTrue(torch.allclose(input_values[0, 0, :30] ,				__lowerCamelCase ,				atol=1E-6	)	)
             self.assertTrue(torch.allclose(input_values[0, 1, :30] ,				EXPECTED_INPUT_VALUES * 0.5 ,				atol=1E-6	)	)





       def 						lowerCAmelCase					(       self							:      Dict	):


             '''simple docstring'''



             lowerCamelCase__		:    Tuple   =  self._load_datasamples(2	)
             # would be easier if the stride was like
             lowerCamelCase__		:    Optional[Any]   =  EncodecFeatureExtractor(feature_size=1 ,				chunk_length_s=1 ,				overlap=0.0_1	)

             # pad and trunc raise an error ?
             with self.assertRaisesRegex(
                 __lowerCamelCase ,				"^Both padding and truncation were set. Make sure you only set one.$" ,				):
                   lowerCamelCase__		:    str   =  feature_extractor(
                       __lowerCamelCase ,				padding="max_length" ,				truncation=__lowerCamelCase ,				return_tensors="pt"	).input_values

             # truncate to chunk
             lowerCamelCase__		:    Optional[int]   =  feature_extractor(__lowerCamelCase ,				truncation=__lowerCamelCase ,				return_tensors="pt"	).input_values
             self.assertEquals(truncated_outputs.shape ,				(2, 1, 71520)	)  # 2 chunks

             # force truncate to max_length
             lowerCamelCase__		:    List[str]   =  feature_extractor(
                 __lowerCamelCase ,				truncation=__lowerCamelCase ,				max_length=48000 ,				return_tensors="pt"	).input_values
             self.assertEquals(truncated_outputs.shape ,				(2, 1, 48000)	)

             # pad to chunk
             lowerCamelCase__		:    int   =  feature_extractor(__lowerCamelCase ,				padding=__lowerCamelCase ,				return_tensors="pt"	).input_values
             self.assertEquals(padded_outputs.shape ,				(2, 1, 95280)	)

             # pad to chunk
             lowerCamelCase__		:    Optional[int]   =  feature_extractor(__lowerCamelCase ,				return_tensors="pt"	).input_values
             self.assertEquals(truncated_outputs.shape ,				(2, 1, 95280)	)

             # force pad to max length
             lowerCamelCase__		:    Tuple   =  feature_extractor(
                 __lowerCamelCase ,				padding="max_length" ,				max_length=100000 ,				return_tensors="pt"	).input_values
             self.assertEquals(truncated_outputs.shape ,				(2, 1, 100000)	)

             # force no pad
             with self.assertRaisesRegex(
                 __lowerCamelCase ,				"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$" ,				):
                   lowerCamelCase__		:    Optional[Any]   =  feature_extractor(__lowerCamelCase ,				padding=__lowerCamelCase ,				return_tensors="pt"	).input_values

             lowerCamelCase__		:    str   =  feature_extractor(input_audio[0] ,				padding=__lowerCamelCase ,				return_tensors="pt"	).input_values
             self.assertEquals(truncated_outputs.shape ,				(1, 1, 93680)	)

             # no pad if no chunk_length_s
             lowerCamelCase__		:    Tuple   =  None
             with self.assertRaisesRegex(
                 __lowerCamelCase ,				"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$" ,				):
                   lowerCamelCase__		:    List[str]   =  feature_extractor(__lowerCamelCase ,				padding=__lowerCamelCase ,				return_tensors="pt"	).input_values

             lowerCamelCase__		:    Tuple   =  feature_extractor(input_audio[0] ,				padding=__lowerCamelCase ,				return_tensors="pt"	).input_values
             self.assertEquals(truncated_outputs.shape ,				(1, 1, 93680)	)

             # no pad if no overlap
             lowerCamelCase__		:    List[Any]   =  2
             lowerCamelCase__		:    List[Any]   =  None
             with self.assertRaisesRegex(
                 __lowerCamelCase ,				"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$" ,				):
                   lowerCamelCase__		:    Optional[Any]   =  feature_extractor(__lowerCamelCase ,				padding=__lowerCamelCase ,				return_tensors="pt"	).input_values

             lowerCamelCase__		:    Optional[Any]   =  feature_extractor(input_audio[0] ,				padding=__lowerCamelCase ,				return_tensors="pt"	).input_values
             self.assertEquals(truncated_outputs.shape ,				(1, 1, 93680)	)


