
import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class 						__magic_name__				(  snake_case      ):
		_lowerCAmelCase						=		["image_processor", "tokenizer"]
		_lowerCAmelCase						=		"VideoMAEImageProcessor"
		_lowerCAmelCase						=		("CLIPTokenizer", "CLIPTokenizerFast")





		def __init__(							self      :		List[Any]  ,					lowerCamelCase__      :		str=None  ,					lowerCamelCase__      :		List[str]=None  ,					**lowerCamelCase__      :		Optional[int]			):
							lowerCAmelCase						:   List[Any]							=       None
							if "feature_extractor" in kwargs:
												warnings.warn(
												    '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
												    ''' instead.'''  ,					lowerCamelCase__  ,					)
												lowerCAmelCase						:   Any							=       kwargs.pop('''feature_extractor'''			)

							lowerCAmelCase						:   Union[str, Any]							=       image_processor if image_processor is not None else feature_extractor
							if image_processor is None:
												raise ValueError('''You need to specify an `image_processor`.'''			)
							if tokenizer is None:
												raise ValueError('''You need to specify a `tokenizer`.'''			)

							super().__init__(lowerCamelCase__  ,					lowerCamelCase__			)
							lowerCAmelCase						:   List[str]							=       self.image_processor





		def __call__(							self      :		Union[str, Any]  ,					lowerCamelCase__      :		str=None  ,					lowerCamelCase__      :		str=None  ,					lowerCamelCase__      :		int=None  ,					**lowerCamelCase__      :		Optional[int]			):

							if text is None and videos is None:
												raise ValueError('''You have to specify either text or videos. Both cannot be none.'''			)

							if text is not None:
												lowerCAmelCase						:   Optional[int]							=       self.tokenizer(lowerCamelCase__  ,					return_tensors=lowerCamelCase__  ,					**lowerCamelCase__			)

							if videos is not None:
												lowerCAmelCase						:   Union[str, Any]							=       self.image_processor(lowerCamelCase__  ,					return_tensors=lowerCamelCase__  ,					**lowerCamelCase__			)

							if text is not None and videos is not None:
												lowerCAmelCase						:   Optional[int]							=       image_features.pixel_values
												return encoding
							elif text is not None:
												return encoding
							else:
												return BatchEncoding(data=dict(**lowerCamelCase__			)  ,					tensor_type=lowerCamelCase__			)





		def  _A							(							self      :		Any  ,					*lowerCamelCase__      :		List[Any]  ,					**lowerCamelCase__      :		str			):
							return self.tokenizer.batch_decode(*lowerCamelCase__  ,					**lowerCamelCase__			)





		def  _A							(							self      :		str  ,					*lowerCamelCase__      :		str  ,					**lowerCamelCase__      :		Any			):
							return self.tokenizer.decode(*lowerCamelCase__  ,					**lowerCamelCase__			)





		@property
		def  _A							(							self      :		Dict			):
							return ["input_ids", "attention_mask", "position_ids", "pixel_values"]





		@property
		def  _A							(							self      :		str			):
							warnings.warn(
							    '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''  ,					lowerCamelCase__  ,					)
							return self.image_processor_class





		@property
		def  _A							(							self      :		Any			):
							warnings.warn(
							    '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''  ,					lowerCamelCase__  ,					)
							return self.image_processor


from math import floor, sqrt
def       UpperCAmelCase__							(    __magic_name__  :       int					):


					'''simple docstring'''

					lowerCAmelCase						:   int							=       0.0
					lowerCAmelCase						:   int							=       1.0
					lowerCAmelCase						:   Any							=       int(sqrt(__magic_name__					)					)
					lowerCAmelCase						:   Optional[int]							=       root
					lowerCAmelCase						:   Dict							=       0
					while integer_part != 2 * root:
										lowerCAmelCase						:   str							=       denominator * integer_part - numerator
										lowerCAmelCase						:   Dict							=       (n - numerator**2) / denominator
										lowerCAmelCase						:   str							=       int((root + numerator) / denominator					)
										period += 1
					return period
def       UpperCAmelCase__							(    __magic_name__  :       int = 1_00_00					):


					'''simple docstring'''

					lowerCAmelCase						:   List[str]							=       0
					for i in range(2							,					n + 1					):
										lowerCAmelCase						:   Any							=       sqrt(__magic_name__					)
										if sr - floor(__magic_name__					) != 0 and continuous_fraction_period(__magic_name__					) % 2 == 1:
															count_odd_periods += 1
					return count_odd_periods


if __name__ == "__main__":
		print(f"""{solution(int(input().strip()))}""")
