





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      UpperCamelCase_						(					unittest.TestCase   ):




					def 		lowerCAmelCase     (						self					)						->							Dict:
										_snake_case													=			logging.get_logger()

										# the current default level is logging.WARNING
										_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 		lowerCAmelCase     (						self					)						->							Optional[Any]:
										_snake_case													=			logging.get_verbosity()

										_snake_case													=			logging.get_logger('transformers.models.bart.tokenization_bart'					)
										_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 		lowerCAmelCase     (						self					)						->							List[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
										_snake_case													=			logging.get_logger('transformers.models.bart.tokenization_bart'					)

										_snake_case													=			os.getenv('TRANSFORMERS_VERBOSITY'			,  lowerCAmelCase_					)
										_snake_case													=			logging.log_levels[env_level_str]

										_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
										_snake_case													=			''
										transformers.utils.logging._reset_library_root_logger()




					@mockenv(TRANSFORMERS_VERBOSITY='super-error'					)
					def 		lowerCAmelCase     (						self					)						->							Union[str, Any]:
										# reset for the env var to take effect, next time some logger call is made
										transformers.utils.logging._reset_library_root_logger()
										_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 		lowerCAmelCase     (						self					)						->							List[str]:
										# testing `logger.warning_advice()`
										transformers.utils.logging._reset_library_root_logger()

										_snake_case													=			logging.get_logger('transformers.models.bart.tokenization_bart'					)
										_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   lowerCamelCase__       (       )     ->	List[str]:



					'''simple docstring'''




					disable_progress_bar()
					assert are_progress_bars_disabled()

					enable_progress_bar()
					assert not are_progress_bars_disabled()










def   lowerCamelCase__       (       )     ->	int:



					'''simple docstring'''




					return 1





def   lowerCamelCase__       (       UpperCamelCase__     :    int  )     ->	int:



					'''simple docstring'''




					return 0 if x < 0 else two_pence(x - 2  ) + one_pence()





def   lowerCamelCase__       (       UpperCamelCase__     :    int  )     ->	int:



					'''simple docstring'''




					return 0 if x < 0 else five_pence(x - 5  ) + two_pence(UpperCamelCase__  )





def   lowerCamelCase__       (       UpperCamelCase__     :    int  )     ->	int:



					'''simple docstring'''




					return 0 if x < 0 else ten_pence(x - 10  ) + five_pence(UpperCamelCase__  )





def   lowerCamelCase__       (       UpperCamelCase__     :    int  )     ->	int:



					'''simple docstring'''




					return 0 if x < 0 else twenty_pence(x - 20  ) + ten_pence(UpperCamelCase__  )





def   lowerCamelCase__       (       UpperCamelCase__     :    int  )     ->	int:



					'''simple docstring'''




					return 0 if x < 0 else fifty_pence(x - 50  ) + twenty_pence(UpperCamelCase__  )





def   lowerCamelCase__       (       UpperCamelCase__     :    int  )     ->	int:



					'''simple docstring'''




					return 0 if x < 0 else one_pound(x - 100  ) + fifty_pence(UpperCamelCase__  )





def   lowerCamelCase__       (       UpperCamelCase__     :    int  )     ->	int:



					'''simple docstring'''




					return 0 if x < 0 else two_pound(x - 200  ) + one_pound(UpperCamelCase__  )





def   lowerCamelCase__       (       UpperCamelCase__     :    int = 200  )     ->	int:



					'''simple docstring'''




					return two_pound(UpperCamelCase__  )


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



