



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

import numpy as np

from transformers.testing_utils import (
    is_pt_tf_cross_test,
    require_tf,
    require_torch,
    require_torchvision,
    require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available


if is_vision_available():
						from PIL import Image

						from transformers import AutoProcessor, SamImageProcessor, SamProcessor

if is_torch_available():
						import torch

if is_tf_available():
						import tensorflow as tf
@require_vision
@require_torchvision
class 				lowerCamelCase  (			unittest.TestCase				):






					'''simple docstring'''





					def    lowerCAmelCase_				(       self:							List[Any]						)   ->	Optional[int]:
											snake_case_ :Union[str, Any]						=			tempfile.mkdtemp()
											snake_case_ :Any						=			SamImageProcessor()
											snake_case_ :Tuple						=			SamProcessor(snake_case						)
											processor.save_pretrained(self.tmpdirname						)






					def    lowerCAmelCase_				(       self:							Any						,     **snake_case:							Optional[Any]						)   ->	Tuple:
											return AutoProcessor.from_pretrained(self.tmpdirname						,     **snake_case						).image_processor






					def    lowerCAmelCase_				(       self:							Dict						)   ->	int:
											shutil.rmtree(self.tmpdirname						)






					def    lowerCAmelCase_				(       self:							List[Any]						)   ->	Tuple:
											snake_case_ :Tuple						=			[np.random.randint(255						,     size=(3, 30, 400)						,     dtype=np.uinta						)]

											snake_case_ :List[str]						=			[Image.fromarray(np.moveaxis(snake_case						,     0						,     -1						)						) for x in image_inputs]

											return image_inputs






					def    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	Optional[int]:
											snake_case_ :Optional[int]						=			SamProcessor(image_processor=self.get_image_processor()						)
											processor.save_pretrained(self.tmpdirname						)

											snake_case_ :Optional[int]						=			self.get_image_processor(do_normalize=snake_case						,     padding_value=1.0						)

											snake_case_ :Union[str, Any]						=			SamProcessor.from_pretrained(self.tmpdirname						,     do_normalize=snake_case						,     padding_value=1.0						)

											self.assertEqual(processor.image_processor.to_json_string()						,     image_processor_add_kwargs.to_json_string()						)
											self.assertIsInstance(processor.image_processor						,     snake_case						)






					def    lowerCAmelCase_				(       self:							Tuple						)   ->	List[str]:
											snake_case_ :Dict						=			self.get_image_processor()

											snake_case_ :List[Any]						=			SamProcessor(image_processor=snake_case						)

											snake_case_ :int						=			self.prepare_image_inputs()

											snake_case_ :Dict						=			image_processor(snake_case						,     return_tensors="""np"""						)
											snake_case_ :Optional[Any]						=			processor(images=snake_case						,     return_tensors="""np"""						)

											input_feat_extract.pop("""original_sizes"""						)  # pop original_sizes as it is popped in the processor
											input_feat_extract.pop("""reshaped_input_sizes"""						)  # pop original_sizes as it is popped in the processor

											for key in input_feat_extract.keys():
																	self.assertAlmostEqual(input_feat_extract[key].sum()						,     input_processor[key].sum()						,     delta=1E-2						)






					@require_torch
					def    lowerCAmelCase_				(       self:							Optional[Any]						)   ->	Optional[int]:
											snake_case_ :str						=			self.get_image_processor()

											snake_case_ :str						=			SamProcessor(image_processor=snake_case						)
											snake_case_ :Dict						=			[torch.ones((1, 3, 5, 5)						)]

											snake_case_ :int						=			[[1_764, 2_646]]

											snake_case_ :Optional[Any]						=			[[683, 1_024]]
											snake_case_ :Any						=			processor.post_process_masks(snake_case						,     snake_case						,     snake_case						)
											self.assertEqual(masks[0].shape						,     (1, 3, 1_764, 2_646)						)

											snake_case_ :Dict						=			processor.post_process_masks(
											    snake_case						,     torch.tensor(snake_case						)						,     torch.tensor(snake_case						)						)
											self.assertEqual(masks[0].shape						,     (1, 3, 1_764, 2_646)						)

											# should also work with np
											snake_case_ :str						=			[np.ones((1, 3, 5, 5)						)]
											snake_case_ :Union[str, Any]						=			processor.post_process_masks(snake_case						,     np.array(snake_case						)						,     np.array(snake_case						)						)

											self.assertEqual(masks[0].shape						,     (1, 3, 1_764, 2_646)						)

											snake_case_ :List[str]						=			[[1, 0], [0, 1]]
											with self.assertRaises(snake_case						):
																	snake_case_ :int						=			processor.post_process_masks(snake_case						,     np.array(snake_case						)						,     np.array(snake_case						)						)

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






					'''simple docstring'''





					def    lowerCAmelCase_				(       self:							List[Any]						)   ->	str:
											snake_case_ :Dict						=			tempfile.mkdtemp()
											snake_case_ :Dict						=			SamImageProcessor()
											snake_case_ :int						=			SamProcessor(snake_case						)
											processor.save_pretrained(self.tmpdirname						)






					def    lowerCAmelCase_				(       self:							Optional[Any]						,     **snake_case:							Tuple						)   ->	Any:
											return AutoProcessor.from_pretrained(self.tmpdirname						,     **snake_case						).image_processor






					def    lowerCAmelCase_				(       self:							str						)   ->	List[Any]:
											shutil.rmtree(self.tmpdirname						)






					def    lowerCAmelCase_				(       self:							Optional[int]						)   ->	List[Any]:
											snake_case_ :List[str]						=			[np.random.randint(255						,     size=(3, 30, 400)						,     dtype=np.uinta						)]

											snake_case_ :Optional[Any]						=			[Image.fromarray(np.moveaxis(snake_case						,     0						,     -1						)						) for x in image_inputs]

											return image_inputs






					def    lowerCAmelCase_				(       self:							List[Any]						)   ->	int:
											snake_case_ :Optional[int]						=			SamProcessor(image_processor=self.get_image_processor()						)
											processor.save_pretrained(self.tmpdirname						)

											snake_case_ :Optional[int]						=			self.get_image_processor(do_normalize=snake_case						,     padding_value=1.0						)

											snake_case_ :Optional[Any]						=			SamProcessor.from_pretrained(self.tmpdirname						,     do_normalize=snake_case						,     padding_value=1.0						)

											self.assertEqual(processor.image_processor.to_json_string()						,     image_processor_add_kwargs.to_json_string()						)
											self.assertIsInstance(processor.image_processor						,     snake_case						)






					def    lowerCAmelCase_				(       self:							int						)   ->	Optional[int]:
											snake_case_ :Any						=			self.get_image_processor()

											snake_case_ :int						=			SamProcessor(image_processor=snake_case						)

											snake_case_ :List[Any]						=			self.prepare_image_inputs()

											snake_case_ :Optional[Any]						=			image_processor(snake_case						,     return_tensors="""np"""						)
											snake_case_ :List[str]						=			processor(images=snake_case						,     return_tensors="""np"""						)

											input_feat_extract.pop("""original_sizes"""						)  # pop original_sizes as it is popped in the processor
											input_feat_extract.pop("""reshaped_input_sizes"""						)  # pop reshaped_input_sizes as it is popped in the processor

											for key in input_feat_extract.keys():
																	self.assertAlmostEqual(input_feat_extract[key].sum()						,     input_processor[key].sum()						,     delta=1E-2						)






					@require_tf
					def    lowerCAmelCase_				(       self:							List[str]						)   ->	Union[str, Any]:
											snake_case_ :Dict						=			self.get_image_processor()

											snake_case_ :Any						=			SamProcessor(image_processor=snake_case						)
											snake_case_ :Optional[int]						=			[tf.ones((1, 3, 5, 5)						)]

											snake_case_ :Dict						=			[[1_764, 2_646]]

											snake_case_ :Dict						=			[[683, 1_024]]
											snake_case_ :Union[str, Any]						=			processor.post_process_masks(snake_case						,     snake_case						,     snake_case						,     return_tensors="""tf"""						)
											self.assertEqual(masks[0].shape						,     (1, 3, 1_764, 2_646)						)

											snake_case_ :List[str]						=			processor.post_process_masks(
											    snake_case						,     tf.convert_to_tensor(snake_case						)						,     tf.convert_to_tensor(snake_case						)						,     return_tensors="""tf"""						,     )
											self.assertEqual(masks[0].shape						,     (1, 3, 1_764, 2_646)						)

											# should also work with np
											snake_case_ :Dict						=			[np.ones((1, 3, 5, 5)						)]
											snake_case_ :str						=			processor.post_process_masks(
											    snake_case						,     np.array(snake_case						)						,     np.array(snake_case						)						,     return_tensors="""tf"""						)

											self.assertEqual(masks[0].shape						,     (1, 3, 1_764, 2_646)						)

											snake_case_ :Optional[Any]						=			[[1, 0], [0, 1]]
											with self.assertRaises(tf.errors.InvalidArgumentError						):
																	snake_case_ :List[str]						=			processor.post_process_masks(
																	    snake_case						,     np.array(snake_case						)						,     np.array(snake_case						)						,     return_tensors="""tf"""						)

@require_vision
@require_torchvision
class 				lowerCamelCase  (			unittest.TestCase				):






					'''simple docstring'''





					def    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	str:
											snake_case_ :int						=			tempfile.mkdtemp()
											snake_case_ :str						=			SamImageProcessor()
											snake_case_ :Optional[int]						=			SamProcessor(snake_case						)
											processor.save_pretrained(self.tmpdirname						)






					def    lowerCAmelCase_				(       self:							str						,     **snake_case:							int						)   ->	List[str]:
											return AutoProcessor.from_pretrained(self.tmpdirname						,     **snake_case						).image_processor






					def    lowerCAmelCase_				(       self:							str						)   ->	List[str]:
											shutil.rmtree(self.tmpdirname						)






					def    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	str:
											snake_case_ :Tuple						=			[np.random.randint(255						,     size=(3, 30, 400)						,     dtype=np.uinta						)]

											snake_case_ :str						=			[Image.fromarray(np.moveaxis(snake_case						,     0						,     -1						)						) for x in image_inputs]

											return image_inputs






					@is_pt_tf_cross_test
					def    lowerCAmelCase_				(       self:							Optional[int]						)   ->	Tuple:
											snake_case_ :int						=			self.get_image_processor()

											snake_case_ :Optional[Any]						=			SamProcessor(image_processor=snake_case						)
											snake_case_ :Optional[int]						=			np.random.randint(0						,     2						,     size=(1, 3, 5, 5)						).astype(np.floataa						)
											snake_case_ :Optional[int]						=			[tf.convert_to_tensor(snake_case						)]
											snake_case_ :Optional[int]						=			[torch.tensor(snake_case						)]

											snake_case_ :Dict						=			[[1_764, 2_646]]

											snake_case_ :Optional[Any]						=			[[683, 1_024]]
											snake_case_ :List[str]						=			processor.post_process_masks(
											    snake_case						,     snake_case						,     snake_case						,     return_tensors="""tf"""						)
											snake_case_ :Union[str, Any]						=			processor.post_process_masks(
											    snake_case						,     snake_case						,     snake_case						,     return_tensors="""pt"""						)

											self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy()						)						)






					@is_pt_tf_cross_test
					def    lowerCAmelCase_				(       self:							List[str]						)   ->	int:
											snake_case_ :Optional[Any]						=			self.get_image_processor()

											snake_case_ :Any						=			SamProcessor(image_processor=snake_case						)

											snake_case_ :Union[str, Any]						=			self.prepare_image_inputs()

											snake_case_ :Optional[Any]						=			image_processor(snake_case						,     return_tensors="""pt"""						)["""pixel_values"""].numpy()
											snake_case_ :Dict						=			processor(images=snake_case						,     return_tensors="""pt"""						)["""pixel_values"""].numpy()

											snake_case_ :int						=			image_processor(snake_case						,     return_tensors="""tf"""						)["""pixel_values"""].numpy()
											snake_case_ :Optional[Any]						=			processor(images=snake_case						,     return_tensors="""tf"""						)["""pixel_values"""].numpy()

											self.assertTrue(np.allclose(snake_case						,     snake_case						)						)
											self.assertTrue(np.allclose(snake_case						,     snake_case						)						)
											self.assertTrue(np.allclose(snake_case						,     snake_case						)						)




'''simple docstring'''






def 				UpperCamelCase_			(    A__					:   int = 1_00					):
  '''simple docstring'''





  lowerCAmelCase_			:      int			=   set()

  lowerCAmelCase_			:      Tuple			=   0

  lowerCAmelCase_			:      str			=   n + 1  # maximum limit

  for a in range(2							,    A__					):
    for b in range(2							,    A__					):
      lowerCAmelCase_			:      str			=   a**b  # calculates the current power
      collect_powers.add(A__					)  # adds the result to the set
  return len(A__					)


if __name__ == "__main__":
  print("Number of terms ", solution(int(str(input()).strip())))



