


"""simple docstring"""




import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar
class 					lowerCAmelCase	(					unittest.TestCase    ):




		'''simple docstring'''







		def 							__A						(	self				)     ->							Tuple:
								SCREAMING_SNAKE_CASE													=					logging.get_logger()

								# the current default level is logging.WARNING
								SCREAMING_SNAKE_CASE													=					logging.get_verbosity()

								logging.set_verbosity_error()
								self.assertEqual(logger.getEffectiveLevel()						,       logging.get_verbosity()				)

								logging.set_verbosity_warning()
								self.assertEqual(logger.getEffectiveLevel()						,       logging.get_verbosity()				)

								logging.set_verbosity_info()
								self.assertEqual(logger.getEffectiveLevel()						,       logging.get_verbosity()				)

								logging.set_verbosity_debug()
								self.assertEqual(logger.getEffectiveLevel()						,       logging.get_verbosity()				)

								# restore to the original level
								logging.set_verbosity(lowerCAmelCase__				)







		def 							__A						(	self				)     ->							Any:
								SCREAMING_SNAKE_CASE													=					logging.get_verbosity()

								SCREAMING_SNAKE_CASE													=					logging.get_logger('transformers.models.bart.tokenization_bart'				)
								SCREAMING_SNAKE_CASE													=					'Testing 1, 2, 3'

								# should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
								if level_origin <= logging.WARNING:
														with CaptureLogger(lowerCAmelCase__				) as cl:
																				logger.warning(lowerCAmelCase__				)
														self.assertEqual(cl.out						,       msg + '\n'				)

								# this is setting the level for all of `transformers.*` loggers
								logging.set_verbosity_error()

								# should not be able to log warnings
								with CaptureLogger(lowerCAmelCase__				) as cl:
														logger.warning(lowerCAmelCase__				)
								self.assertEqual(cl.out						,       ''				)

								# should be able to log warnings again
								logging.set_verbosity_warning()
								with CaptureLogger(lowerCAmelCase__				) as cl:
														logger.warning(lowerCAmelCase__				)
								self.assertEqual(cl.out						,       msg + '\n'				)

								# restore to the original level
								logging.set_verbosity(lowerCAmelCase__				)







		@mockenv(TRANSFORMERS_VERBOSITY='error'				)
		def 							__A						(	self				)     ->							str:
								# reset for the env var to take effect, next time some logger call is made
								transformers.utils.logging._reset_library_root_logger()
								# this action activates the env var
								SCREAMING_SNAKE_CASE													=					logging.get_logger('transformers.models.bart.tokenization_bart'				)

								SCREAMING_SNAKE_CASE													=					os.getenv('TRANSFORMERS_VERBOSITY'						,       lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					logging.log_levels[env_level_str]

								SCREAMING_SNAKE_CASE													=					logging.get_verbosity()
								self.assertEqual(
								    lowerCAmelCase__						,       lowerCAmelCase__						,       F'TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'						,       )

								# restore to the original level
								SCREAMING_SNAKE_CASE													=					''
								transformers.utils.logging._reset_library_root_logger()







		@mockenv(TRANSFORMERS_VERBOSITY='super-error'				)
		def 							__A						(	self				)     ->							int:
								# reset for the env var to take effect, next time some logger call is made
								transformers.utils.logging._reset_library_root_logger()
								SCREAMING_SNAKE_CASE													=					logging.logging.getLogger()
								with CaptureLogger(lowerCAmelCase__				) as cl:
														# this action activates the env var
														logging.get_logger('transformers.models.bart.tokenization_bart'				)
								self.assertIn('Unknown option TRANSFORMERS_VERBOSITY=super-error'						,       cl.out				)

								# no need to restore as nothing was changed







		def 							__A						(	self				)     ->							List[Any]:
								# testing `logger.warning_advice()`
								transformers.utils.logging._reset_library_root_logger()

								SCREAMING_SNAKE_CASE													=					logging.get_logger('transformers.models.bart.tokenization_bart'				)
								SCREAMING_SNAKE_CASE													=					'Testing 1, 2, 3'

								with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='1'				):
														# nothing should be logged as env var disables this method
														with CaptureLogger(lowerCAmelCase__				) as cl:
																				logger.warning_advice(lowerCAmelCase__				)
														self.assertEqual(cl.out						,       ''				)

								with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=''				):
														# should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
														with CaptureLogger(lowerCAmelCase__				) as cl:
																				logger.warning_advice(lowerCAmelCase__				)
														self.assertEqual(cl.out						,       msg + '\n'				)





def     lowercase			()   ->						Optional[Any]:
						disable_progress_bar()
						assert are_progress_bars_disabled()

						enable_progress_bar()
						assert not are_progress_bars_disabled()






"""simple docstring"""




def     lowercase			(SCREAMING_SNAKE_CASE_		:				int = 10_00  )   ->						int:
						SCREAMING_SNAKE_CASE													=					2**power
						SCREAMING_SNAKE_CASE													=					0
						while n:
												SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					r + n % 10, n // 10
						return r


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


