






"""simple docstring"""



import warnings

from transformers import AutoTokenizer
from transformers.utils import is_torch_available
from transformers.utils.generic import ExplicitEnum

from ...processing_utils import ProcessorMixin


if is_torch_available():
						import torch





class 					_UpperCAmelCase       ( _A							):
					SCREAMING_SNAKE_CASE_		:				str							    =   "char"
					SCREAMING_SNAKE_CASE_		:				Any							    =   "bpe"
					SCREAMING_SNAKE_CASE_		:				Optional[int]							    =   "wp"
__A		:       int  				=		(DecodeType.CHARACTER, DecodeType.BPE, DecodeType.WORDPIECE)





class 					_UpperCAmelCase       ( _A							):
					SCREAMING_SNAKE_CASE_		:				Any							    =   ["image_processor", "char_tokenizer"]
					SCREAMING_SNAKE_CASE_		:				Any							    =   "ViTImageProcessor"
					SCREAMING_SNAKE_CASE_		:				Optional[int]							    =   "MgpstrTokenizer"




					def __init__(				self     :						List[str]    ,						A     :						Union[str, Any]=None    ,						A     :						str=None    ,						**A     :						Optional[Any]   )  ->  str:
							lowercase_ : Optional[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.'''    ,						A    ,						)
									lowercase_ : List[Any]							       =   kwargs.pop('''feature_extractor'''   )

							lowercase_ : str							       =   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`.'''   )

							lowercase_ : List[str]							       =   tokenizer
							lowercase_ : Union[str, Any]							       =   AutoTokenizer.from_pretrained('''gpt2'''   )
							lowercase_ : List[Any]							       =   AutoTokenizer.from_pretrained('''bert-base-uncased'''   )

							super().__init__(A    ,						A   )




					def __call__(				self     :						List[Any]    ,						A     :						int=None    ,						A     :						Tuple=None    ,						A     :						List[Any]=None    ,						**A     :						Union[str, Any]   )  ->  int:
							if images is None and text is None:
									raise ValueError('''You need to specify either an `images` or `text` input to process.'''   )

							if images is not None:
									lowercase_ : Optional[Any]							       =   self.image_processor(A    ,						return_tensors=A    ,						**A   )
							if text is not None:
									lowercase_ : Union[str, Any]							       =   self.char_tokenizer(A    ,						return_tensors=A    ,						**A   )

							if text is None:
									return inputs
							elif images is None:
									return encodings
							else:
									lowercase_ : List[str]							       =   encodings['''input_ids''']
									return inputs




					def   A  (				self     :						Optional[Any]    ,						A     :						int   )  ->  Optional[int]:
							lowercase_       ,					lowercase_       ,					lowercase_ : Any							       =   sequences
							lowercase_ : Tuple							       =   char_preds.size(0   )

							lowercase_       ,					lowercase_ : Optional[int]							       =   self._decode_helper(A    ,						'''char'''   )
							lowercase_       ,					lowercase_ : Dict							       =   self._decode_helper(A    ,						'''bpe'''   )
							lowercase_       ,					lowercase_ : Optional[int]							       =   self._decode_helper(A    ,						'''wp'''   )

							lowercase_ : int							       =   []
							lowercase_ : Optional[int]							       =   []
							for i in range(A   ):
									lowercase_ : Dict							       =   [char_scores[i], bpe_scores[i], wp_scores[i]]
									lowercase_ : List[Any]							       =   [char_strs[i], bpe_strs[i], wp_strs[i]]
									lowercase_ : Dict							       =   scores.index(max(A   )   )
									final_strs.append(strs[max_score_index]   )
									final_scores.append(scores[max_score_index]   )

							lowercase_ : List[Any]							       =   {}
							lowercase_ : Any							       =   final_strs
							lowercase_ : List[Any]							       =   final_scores
							lowercase_ : Optional[Any]							       =   char_strs
							lowercase_ : Union[str, Any]							       =   bpe_strs
							lowercase_ : Dict							       =   wp_strs
							return out




					def   A  (				self     :						Dict    ,						A     :						List[Any]    ,						A     :						Dict   )  ->  Optional[Any]:
							if format == DecodeType.CHARACTER:
									lowercase_ : List[str]							       =   self.char_decode
									lowercase_ : str							       =   1
									lowercase_ : str							       =   '''[s]'''
							elif format == DecodeType.BPE:
									lowercase_ : Optional[int]							       =   self.bpe_decode
									lowercase_ : List[Any]							       =   2
									lowercase_ : Any							       =   '''#'''
							elif format == DecodeType.WORDPIECE:
									lowercase_ : Optional[Any]							       =   self.wp_decode
									lowercase_ : Optional[int]							       =   1_02
									lowercase_ : str							       =   '''[SEP]'''
							else:
									raise ValueError(F'''Format {format} is not supported.'''   )

							lowercase_       ,					lowercase_ : Union[str, Any]							       =   [], []
							lowercase_ : Dict							       =   pred_logits.size(0   )
							lowercase_ : Dict							       =   pred_logits.size(1   )
							lowercase_       ,					lowercase_ : Dict							       =   pred_logits.topk(1    ,						dim=-1    ,						largest=A    ,						sorted=A   )
							lowercase_ : List[str]							       =   preds_index.view(-1    ,						A   )[:, 1:]
							lowercase_ : Dict							       =   decoder(A   )
							lowercase_       ,					lowercase_ : Dict							       =   torch.nn.functional.softmax(A    ,						dim=2   ).max(dim=2   )
							lowercase_ : Optional[int]							       =   preds_max_prob[:, 1:]

							for index in range(A   ):
									lowercase_ : Union[str, Any]							       =   preds_str[index].find(A   )
									lowercase_ : Union[str, Any]							       =   preds_str[index][:pred_eos]
									lowercase_ : Dict							       =   preds_index[index].cpu().tolist()
									lowercase_ : int							       =   pred_index.index(A   ) if eos_token in pred_index else -1
									lowercase_ : List[str]							       =   preds_max_prob[index][: pred_eos_index + 1]
									lowercase_ : Optional[int]							       =   pred_max_prob.cumprod(dim=0   )[-1] if pred_max_prob.nelement() != 0 else 0.0
									dec_strs.append(A   )
									conf_scores.append(A   )

							return dec_strs, conf_scores




					def   A  (				self     :						str    ,						A     :						Optional[int]   )  ->  Any:
							lowercase_ : Tuple							       =   [seq.replace(''' '''    ,						''''''   ) for seq in self.char_tokenizer.batch_decode(A   )]
							return decode_strs




					def   A  (				self     :						Tuple    ,						A     :						Union[str, Any]   )  ->  Optional[int]:
							return self.bpe_tokenizer.batch_decode(A   )






					def   A  (				self     :						Dict    ,						A     :						int   )  ->  str:
							lowercase_ : str							       =   [seq.replace(''' '''    ,						''''''   ) for seq in self.wp_tokenizer.batch_decode(A   )]
							return decode_strs











"""simple docstring"""



def 						lowercase    (				__snake_case				: int = 1_0_0_0	):
		lowercase_       ,					lowercase_ : str							       =   1, 1
		lowercase_ : List[str]							       =   2
		while True:
				lowercase_ : Tuple							       =   0
				lowercase_ : List[Any]							       =   fa + fa
				lowercase_       ,					lowercase_ : Optional[int]							       =   fa, f
				index += 1
				for _ in str(__snake_case	):
						i += 1
				if i == n:
						break
		return index


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



