

"""simple docstring"""






import io
import json
import unittest

from parameterized import parameterized

from transformers import FSMTForConditionalGeneration, FSMTTokenizer
from transformers.testing_utils import get_tests_dir, require_torch, slow, torch_device
from utils import calculate_bleu


__lowerCamelCase										=		get_tests_dir() + '/test_data/fsmt/fsmt_val_data.json'
with io.open(filename, "r", encoding="utf-8") as f:
 __lowerCamelCase										=		json.load(f)
@require_torch
class        _lowercase					(     unittest.TestCase     ):







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      return FSMTTokenizer.from_pretrained(UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      __magic_name__     =      FSMTForConditionalGeneration.from_pretrained(UpperCamelCase_       ).to(UpperCamelCase_       )
      if torch_device == "cuda":
       model.half()
      return model







     @parameterized.expand(
         [
             ['''en-ru''', 2_6.0],
             ['''ru-en''', 2_2.0],
             ['''en-de''', 2_2.0],
             ['''de-en''', 2_9.0],
         ]       )
     @slow
     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_       ):
      # note: this test is not testing the best performance since it only evals a small batch
      # but it should be enough to detect a regression in the output quality
      __magic_name__     =      f'''facebook/wmt19-{pair}'''
      __magic_name__     =      self.get_tokenizer(UpperCamelCase_       )
      __magic_name__     =      self.get_model(UpperCamelCase_       )

      __magic_name__     =      bleu_data[pair]['''src''']
      __magic_name__     =      bleu_data[pair]['''tgt''']

      __magic_name__     =      tokenizer(UpperCamelCase_ ,						return_tensors='''pt''' ,						truncation=UpperCamelCase_ ,						padding='''longest'''       ).to(UpperCamelCase_       )
      __magic_name__     =      model.generate(
          input_ids=batch.input_ids ,						num_beams=8 ,						)
      __magic_name__     =      tokenizer.batch_decode(
          UpperCamelCase_ ,						skip_special_tokens=UpperCamelCase_ ,						clean_up_tokenization_spaces=UpperCamelCase_       )
      __magic_name__     =      calculate_bleu(UpperCamelCase_ ,						UpperCamelCase_       )
      print(UpperCamelCase_       )
      self.assertGreaterEqual(scores['''bleu'''] ,						UpperCamelCase_       )




"""simple docstring"""






def 	lowercase      (   ) ->      int:
 return 1





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else two_pence(x - 2						) + one_pence()





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else five_pence(x - 5						) + two_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else ten_pence(x - 10						) + five_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else twenty_pence(x - 20						) + ten_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else fifty_pence(x - 50						) + twenty_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else one_pound(x - 100						) + fifty_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else two_pound(x - 200						) + one_pound(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase = 200						) ->      int:
 return two_pound(__UpperCamelCase						)


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

