'''simple docstring'''

import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY





@is_pipeline_test
@require_torch_or_tf
class 							lowercase						(						unittest.TestCase ):
   lowerCamelCase_    					=MODEL_FOR_CAUSAL_LM_MAPPING
   lowerCamelCase_    					=TF_MODEL_FOR_CAUSAL_LM_MAPPING


   @require_torch
   def __UpperCAmelCase       (   self				:	Optional[int])      ->					Optional[int]:
         lowercase_     =      pipeline(task="text-generation"   ,		model="sshleifer/tiny-ctrl"   ,		framework="pt")
         # Using `do_sample=False` to force deterministic output
         lowercase_     =      text_generator("This is a test"   ,		do_sample=__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 {
                     "generated_text": (
                         "This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
                         " oscope. FiliFili@@"
                     )
                 }
             ]   ,		)

         lowercase_     =      text_generator(["This is a test", "This is a second test"])
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 [
                     {
                         "generated_text": (
                             "This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
                             " oscope. FiliFili@@"
                         )
                     }
                 ],
                 [
                     {
                         "generated_text": (
                             "This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy"
                             " oscope. oscope. FiliFili@@"
                         )
                     }
                 ],
             ]   ,		)

         lowercase_     =      text_generator("This is a test"   ,		do_sample=__lowerCAmelCase   ,		num_return_sequences=2   ,		return_tensors=__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 {"generated_token_ids": ANY(__lowerCAmelCase)},
                 {"generated_token_ids": ANY(__lowerCAmelCase)},
             ]   ,		)
         lowercase_     =      text_generator.model.config.eos_token_id
         lowercase_     =      "<pad>"
         lowercase_     =      text_generator(
             ["This is a test", "This is a second test"]   ,		do_sample=__lowerCAmelCase   ,		num_return_sequences=2   ,		batch_size=2   ,		return_tensors=__lowerCAmelCase   ,		)
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 [
                     {"generated_token_ids": ANY(__lowerCAmelCase)},
                     {"generated_token_ids": ANY(__lowerCAmelCase)},
                 ],
                 [
                     {"generated_token_ids": ANY(__lowerCAmelCase)},
                     {"generated_token_ids": ANY(__lowerCAmelCase)},
                 ],
             ]   ,		)


   @require_tf
   def __UpperCAmelCase       (   self				:	int)      ->					Optional[int]:
         lowercase_     =      pipeline(task="text-generation"   ,		model="sshleifer/tiny-ctrl"   ,		framework="tf")

         # Using `do_sample=False` to force deterministic output
         lowercase_     =      text_generator("This is a test"   ,		do_sample=__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 {
                     "generated_text": (
                         "This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"
                         " please,"
                     )
                 }
             ]   ,		)

         lowercase_     =      text_generator(["This is a test", "This is a second test"]   ,		do_sample=__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 [
                     {
                         "generated_text": (
                             "This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"
                             " please,"
                         )
                     }
                 ],
                 [
                     {
                         "generated_text": (
                             "This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes"
                             " Cannes 閲閲Cannes Cannes Cannes 攵 please,"
                         )
                     }
                 ],
             ]   ,		)


   def __UpperCAmelCase       (   self				:	str   ,		__lowerCAmelCase				:	Tuple   ,		__lowerCAmelCase				:	Tuple   ,		__lowerCAmelCase				:	Dict)      ->					List[str]:
         lowercase_     =      TextGenerationPipeline(model=__lowerCAmelCase   ,		tokenizer=__lowerCAmelCase)
         return text_generator, ["This is a test", "Another test"]


   def __UpperCAmelCase       (   self				:	Any)      ->					Optional[Any]:
         lowercase_     =      "Hello I believe in"
         lowercase_     =      pipeline("text-generation"   ,		model="hf-internal-testing/tiny-random-gpt2")
         lowercase_     =      text_generator(__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase   ,		[{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}]   ,		)

         lowercase_     =      text_generator(__lowerCAmelCase   ,		stop_sequence=" fe")
         self.assertEqual(__lowerCAmelCase   ,		[{"generated_text": "Hello I believe in fe"}])


   def __UpperCAmelCase       (   self				:	Optional[int]   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Union[str, Any])      ->					Union[str, Any]:
         lowercase_     =      text_generator.model
         lowercase_     =      text_generator.tokenizer

         lowercase_     =      text_generator("This is a test")
         self.assertEqual(__lowerCAmelCase   ,		[{"generated_text": ANY(__lowerCAmelCase)}])
         self.assertTrue(outputs[0]["generated_text"].startswith("This is a test"))

         lowercase_     =      text_generator("This is a test"   ,		return_full_text=__lowerCAmelCase)
         self.assertEqual(__lowerCAmelCase   ,		[{"generated_text": ANY(__lowerCAmelCase)}])
         self.assertNotIn("This is a test"   ,		outputs[0]["generated_text"])

         lowercase_     =      pipeline(task="text-generation"   ,		model=__lowerCAmelCase   ,		tokenizer=__lowerCAmelCase   ,		return_full_text=__lowerCAmelCase)
         lowercase_     =      text_generator("This is a test")
         self.assertEqual(__lowerCAmelCase   ,		[{"generated_text": ANY(__lowerCAmelCase)}])
         self.assertNotIn("This is a test"   ,		outputs[0]["generated_text"])

         lowercase_     =      text_generator("This is a test"   ,		return_full_text=__lowerCAmelCase)
         self.assertEqual(__lowerCAmelCase   ,		[{"generated_text": ANY(__lowerCAmelCase)}])
         self.assertTrue(outputs[0]["generated_text"].startswith("This is a test"))

         lowercase_     =      text_generator(["This is great !", "Something else"]   ,		num_return_sequences=2   ,		do_sample=__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 [{"generated_text": ANY(__lowerCAmelCase)}, {"generated_text": ANY(__lowerCAmelCase)}],
                 [{"generated_text": ANY(__lowerCAmelCase)}, {"generated_text": ANY(__lowerCAmelCase)}],
             ]   ,		)

         if text_generator.tokenizer.pad_token is not None:
               lowercase_     =      text_generator(
                   ["This is great !", "Something else"]   ,		num_return_sequences=2   ,		batch_size=2   ,		do_sample=__lowerCAmelCase)
               self.assertEqual(
                   __lowerCAmelCase   ,		[
                       [{"generated_text": ANY(__lowerCAmelCase)}, {"generated_text": ANY(__lowerCAmelCase)}],
                       [{"generated_text": ANY(__lowerCAmelCase)}, {"generated_text": ANY(__lowerCAmelCase)}],
                   ]   ,		)

         with self.assertRaises(__lowerCAmelCase):
               lowercase_     =      text_generator("test"   ,		return_full_text=__lowerCAmelCase   ,		return_text=__lowerCAmelCase)
         with self.assertRaises(__lowerCAmelCase):
               lowercase_     =      text_generator("test"   ,		return_full_text=__lowerCAmelCase   ,		return_tensors=__lowerCAmelCase)
         with self.assertRaises(__lowerCAmelCase):
               lowercase_     =      text_generator("test"   ,		return_text=__lowerCAmelCase   ,		return_tensors=__lowerCAmelCase)

         # Empty prompt is slighly special
         # it requires BOS token to exist.
         # Special case for Pegasus which will always append EOS so will
         # work even without BOS.
         if (
             text_generator.tokenizer.bos_token_id is not None
             or "Pegasus" in tokenizer.__class__.__name__
             or "Git" in model.__class__.__name__
         ):
               lowercase_     =      text_generator("")
               self.assertEqual(__lowerCAmelCase   ,		[{"generated_text": ANY(__lowerCAmelCase)}])
         else:
               with self.assertRaises((ValueError, AssertionError)):
                     lowercase_     =      text_generator("")

         if text_generator.framework == "tf":
               # TF generation does not support max_new_tokens, and it's impossible
               # to control long generation with only max_length without
               # fancy calculation, dismissing tests for now.
               return
         # We don't care about infinite range models.
         # They already work.
         # Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
         lowercase_     =      ["RwkvForCausalLM", "XGLMForCausalLM", "GPTNeoXForCausalLM"]
         if (
             tokenizer.model_max_length < 1_0000
             and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
         ):
               # Handling of large generations
               with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)):
                     text_generator("This is a test" * 500   ,		max_new_tokens=20)

               lowercase_     =      text_generator("This is a test" * 500   ,		handle_long_generation="hole"   ,		max_new_tokens=20)
               # Hole strategy cannot work
               with self.assertRaises(__lowerCAmelCase):
                     text_generator(
                         "This is a test" * 500   ,		handle_long_generation="hole"   ,		max_new_tokens=tokenizer.model_max_length + 10   ,		)


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

         # Classic `model_kwargs`
         lowercase_     =      pipeline(
             model="hf-internal-testing/tiny-random-bloom"   ,		model_kwargs={"device_map": "auto", "torch_dtype": torch.bfloataa}   ,		)
         self.assertEqual(pipe.model.device   ,		torch.device(0))
         self.assertEqual(pipe.model.lm_head.weight.dtype   ,		torch.bfloataa)
         lowercase_     =      pipe("This is a test")
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 {
                     "generated_text": (
                         "This is a test test test test test test test test test test test test test test test test"
                         " test"
                     )
                 }
             ]   ,		)

         # Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
         lowercase_     =      pipeline(model="hf-internal-testing/tiny-random-bloom"   ,		device_map="auto"   ,		torch_dtype=torch.bfloataa)
         self.assertEqual(pipe.model.device   ,		torch.device(0))
         self.assertEqual(pipe.model.lm_head.weight.dtype   ,		torch.bfloataa)
         lowercase_     =      pipe("This is a test")
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 {
                     "generated_text": (
                         "This is a test test test test test test test test test test test test test test test test"
                         " test"
                     )
                 }
             ]   ,		)

         # torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
         lowercase_     =      pipeline(model="hf-internal-testing/tiny-random-bloom"   ,		device_map="auto")
         self.assertEqual(pipe.model.device   ,		torch.device(0))
         self.assertEqual(pipe.model.lm_head.weight.dtype   ,		torch.floataa)
         lowercase_     =      pipe("This is a test")
         self.assertEqual(
             __lowerCAmelCase   ,		[
                 {
                     "generated_text": (
                         "This is a test test test test test test test test test test test test test test test test"
                         " test"
                     )
                 }
             ]   ,		)


   @require_torch
   @require_torch_gpu
   def __UpperCAmelCase       (   self				:	Tuple)      ->					str:
         import torch

         lowercase_     =      pipeline(model="hf-internal-testing/tiny-random-bloom"   ,		device=0   ,		torch_dtype=torch.floataa)
         pipe("This is a test")


   @require_torch
   @require_accelerate
   @require_torch_gpu
   def __UpperCAmelCase       (   self				:	List[str])      ->					Dict:
         import torch

         lowercase_     =      pipeline(model="hf-internal-testing/tiny-random-bloom"   ,		device_map="auto"   ,		torch_dtype=torch.floataa)
         pipe("This is a test"   ,		do_sample=__lowerCAmelCase   ,		top_p=0.5)


   def __UpperCAmelCase       (   self				:	List[str])      ->					int:
         lowercase_     =      "Hello world"
         lowercase_     =      pipeline("text-generation"   ,		model="hf-internal-testing/tiny-random-gpt2")
         if text_generator.model.framework == "tf":
               lowercase_     =      logging.get_logger("transformers.generation.tf_utils")
         else:
               lowercase_     =      logging.get_logger("transformers.generation.utils")
         lowercase_     =      "Both `max_new_tokens`"  # The beggining of the message to be checked in this test

         # Both are set by the user -> log warning
         with CaptureLogger(__lowerCAmelCase) as cl:
               lowercase_     =      text_generator(__lowerCAmelCase   ,		max_length=10   ,		max_new_tokens=1)
         self.assertIn(__lowerCAmelCase   ,		cl.out)

         # The user only sets one -> no warning
         with CaptureLogger(__lowerCAmelCase) as cl:
               lowercase_     =      text_generator(__lowerCAmelCase   ,		max_new_tokens=1)
         self.assertNotIn(__lowerCAmelCase   ,		cl.out)

         with CaptureLogger(__lowerCAmelCase) as cl:
               lowercase_     =      text_generator(__lowerCAmelCase   ,		max_length=10)
         self.assertNotIn(__lowerCAmelCase   ,		cl.out)







'''simple docstring'''

from __future__ import annotations


def __a (	__lowerCamelCase			:						int | str				)	->							bool:
      '''simple docstring'''


      lowercase_     =      str(__lowerCamelCase				)
      return n == n[::-1]


def __a (	__lowerCamelCase			:						int = 1_000_000				)	->							Optional[int]:
      '''simple docstring'''


      lowercase_     =      0

      for i in range(1 ,		__lowerCamelCase				):
            if is_palindrome(__lowerCamelCase				) and is_palindrome(bin(__lowerCamelCase				).split("b"				)[1]				):
                  total += i
      return total


if __name__ == "__main__":
       print(solution(int(str(input().strip()))))






