
import argparse
import os
import re

import packaging.version


lowercase__		:Optional[int]   =    """examples/"""
lowercase__		:Optional[Any]   =    {
    """examples""": (re.compile(r"^check_min_version\(\"[^\"]+\"\)\s*$", re.MULTILINE), """check_min_version(\"VERSION\")\n"""),
    """init""": (re.compile(r"^__version__\s+=\s+\"([^\"]+)\"\s*$", re.MULTILINE), """__version__ = \"VERSION\"\n"""),
    """setup""": (re.compile(r"^(\s*)version\s*=\s*\"[^\"]+\",", re.MULTILINE), r"""\1version=\"VERSION\","""),
    """doc""": (re.compile(r"^(\s*)release\s*=\s*\"[^\"]+\"$", re.MULTILINE), """release = \"VERSION\"\n"""),
}
lowercase__		:Tuple   =    {
    """init""": """src/transformers/__init__.py""",
    """setup""": """setup.py""",
}
lowercase__		:Optional[int]   =    """README.md"""



def        UpperCamelCase    (							lowerCAmelCase__ ,			lowerCAmelCase__ ,			lowerCAmelCase__		):
					'''simple docstring'''





					with open(_snake_case ,			'''r''' ,			encoding='''utf-8''' ,			newline='''\n'''		) as f:
										lowercase							=						f.read()
					lowercase							=						REPLACE_PATTERNS[pattern]
					lowercase							=						replace.replace('''VERSION''' ,			_snake_case		)
					lowercase							=						re_pattern.sub(_snake_case ,			_snake_case		)
					with open(_snake_case ,			'''w''' ,			encoding='''utf-8''' ,			newline='''\n'''		) as f:
										f.write(_snake_case		)



def        UpperCamelCase    (							lowerCAmelCase__		):
					'''simple docstring'''





					for folder, directories, fnames in os.walk(_snake_case		):
										# Removing some of the folders with non-actively maintained examples from the walk
										if "research_projects" in directories:
															directories.remove('''research_projects'''		)
										if "legacy" in directories:
															directories.remove('''legacy'''		)
										for fname in fnames:
															if fname.endswith('''.py'''		):
																				update_version_in_file(os.path.join(_snake_case ,			_snake_case		) ,			_snake_case ,			pattern='''examples'''		)



def        UpperCamelCase    (							lowerCAmelCase__ ,			lowerCAmelCase__=False		):
					'''simple docstring'''





					for pattern, fname in REPLACE_FILES.items():
										update_version_in_file(_snake_case ,			_snake_case ,			_snake_case		)
					if not patch:
										update_version_in_examples(_snake_case		)



def        UpperCamelCase    (							):
					'''simple docstring'''
					lowercase							=						'''🤗 Transformers currently provides the following architectures'''
					lowercase							=						'''1. Want to contribute a new model?'''
					with open(_snake_case ,			'''r''' ,			encoding='''utf-8''' ,			newline='''\n'''		) as f:
										lowercase							=						f.readlines()

					# Find the start of the list.
					lowercase							=						0
					while not lines[start_index].startswith(_start_prompt		):
										start_index += 1
					start_index += 1

					lowercase							=						start_index
					# Update the lines in the model list.
					while not lines[index].startswith(_end_prompt		):
										if lines[index].startswith('''1.'''		):
															lowercase							=						lines[index].replace(
															    '''https://huggingface.co/docs/transformers/main/model_doc''' ,			'''https://huggingface.co/docs/transformers/model_doc''' ,			)
										index += 1

					with open(_snake_case ,			'''w''' ,			encoding='''utf-8''' ,			newline='''\n'''		) as f:
										f.writelines(_snake_case		)



def        UpperCamelCase    (							):
					'''simple docstring'''





					with open(REPLACE_FILES['''init'''] ,			'''r'''		) as f:
										lowercase							=						f.read()
					lowercase							=						REPLACE_PATTERNS['''init'''][0].search(_snake_case		).groups()[0]
					return packaging.version.parse(_snake_case		)



def        UpperCamelCase    (							lowerCAmelCase__=False		):
					'''simple docstring'''
					lowercase							=						get_version()
					if patch and default_version.is_devrelease:
										raise ValueError('''Can\'t create a patch version from the dev branch, checkout a released version!'''		)
					if default_version.is_devrelease:
										lowercase							=						default_version.base_version
					elif patch:
										lowercase							=						f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}'
					else:
										lowercase							=						f'{default_version.major}.{default_version.minor + 1}.0'

					# Now let's ask nicely if that's the right one.
					lowercase							=						input(f'Which version are you releasing? [{default_version}]'		)
					if len(_snake_case		) == 0:
										lowercase							=						default_version

					print(f'Updating version to {version}.'		)
					global_version_update(_snake_case ,			patch=_snake_case		)
					if not patch:
										print('''Cleaning main README, don\'t forget to run `make fix-copies`.'''		)
										clean_main_ref_in_model_list()



def        UpperCamelCase    (							):
					'''simple docstring'''
					lowercase							=						get_version()
					lowercase							=						f'{current_version.major}.{current_version.minor + 1}.0.dev0'
					lowercase							=						current_version.base_version

					# Check with the user we got that right.
					lowercase							=						input(f'Which version are we developing now? [{dev_version}]'		)
					if len(_snake_case		) == 0:
										lowercase							=						dev_version

					print(f'Updating version to {version}.'		)
					global_version_update(_snake_case		)
					print('''Cleaning main README, don\'t forget to run `make fix-copies`.'''		)
					clean_main_ref_in_model_list()


if __name__ == "__main__":
							lowercase__		:Dict   =    argparse.ArgumentParser()
							parser.add_argument("--post_release", action="store_true", help="Whether this is pre or post release.")
							parser.add_argument("--patch", action="store_true", help="Whether or not this is a patch release.")
							lowercase__		:Any   =    parser.parse_args()
							if not args.post_release:
														pre_release_work(patch=args.patch)
							elif args.patch:
														print("Nothing to do after a patch :-)")
							else:
														post_release_work()








"""simple docstring"""
from __future__ import annotations






def 		lowercase							(     _snake_case						:      int | str     )     ->bool:
	"""simple docstring"""





	__snake_case	:						List[str]						=				str(_snake_case     )
	return n == n[::-1]






def 		lowercase							(     _snake_case						:      int = 1_000_000     )     ->str:
	"""simple docstring"""





	__snake_case	:						Union[str, Any]						=				0

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


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





