




from __future__ import annotations

from typing import TypedDict





class 	lowerCamelCase_							(				_a ):


 '''simple docstring'''







 lowercase_       =   42
 lowercase_       =   42


def  UpperCAmelCase_							(				__UpperCAmelCase						:     str							) ->			list[str]:



      if not isinstance(__UpperCAmelCase      ,      __UpperCAmelCase							):
            raise TypeError('The parameter s type must be str.'							)

      return [s[i:] + s[:i] for i in range(len(__UpperCAmelCase							)							)]

def  UpperCAmelCase_							(				__UpperCAmelCase						:     str							) ->			BWTTransformDict:



      if not isinstance(__UpperCAmelCase      ,      __UpperCAmelCase							):
            raise TypeError('The parameter s type must be str.'							)
      if not s:
            raise ValueError('The parameter s must not be empty.'							)

      SCREAMING_SNAKE_CASE_     						=      all_rotations(__UpperCAmelCase							)
      rotations.sort()  # sort the list of rotations in alphabetically order
      # make a string composed of the last char of each rotation
      SCREAMING_SNAKE_CASE_     						=      {
          "bwt_string": "".join([word[-1] for word in rotations]							),
          "idx_original_string": rotations.index(__UpperCAmelCase							),
      }
      return response

def  UpperCAmelCase_							(				__UpperCAmelCase						:     str      ,      __UpperCAmelCase						:     int							) ->			str:



      if not isinstance(__UpperCAmelCase      ,      __UpperCAmelCase							):
            raise TypeError('The parameter bwt_string type must be str.'							)
      if not bwt_string:
            raise ValueError('The parameter bwt_string must not be empty.'							)
      try:
            SCREAMING_SNAKE_CASE_     						=      int(__UpperCAmelCase							)
      except ValueError:
            raise TypeError(
                'The parameter idx_original_string type must be int or passive'
                ' of cast to int.'							)
      if idx_original_string < 0:
            raise ValueError('The parameter idx_original_string must not be lower than 0.'							)
      if idx_original_string >= len(__UpperCAmelCase							):
            raise ValueError(
                'The parameter idx_original_string must be lower than' ' len(bwt_string).'							)

      SCREAMING_SNAKE_CASE_     						=      [""""""] * len(__UpperCAmelCase							)
      for _ in range(len(__UpperCAmelCase							)							):
            for i in range(len(__UpperCAmelCase							)							):
                  SCREAMING_SNAKE_CASE_     						=      bwt_string[i] + ordered_rotations[i]
            ordered_rotations.sort()
      return ordered_rotations[idx_original_string]


if __name__ == "__main__":
   lowerCamelCase__			:       Optional[int]         =							'''Provide a string that I will generate its BWT transform: '''
   lowerCamelCase__			:       Optional[Any]         =							input(entry_msg).strip()
   lowerCamelCase__			:       Any         =							bwt_transform(s)
   print(
       f'''Burrows Wheeler transform for string \'{s}\' results '''
       f'''in \'{result['bwt_string']}\''''
   )
   lowerCamelCase__			:       Optional[int]         =							reverse_bwt(result['bwt_string'], result['idx_original_string'])
   print(
       f'''Reversing Burrows Wheeler transform for entry \'{result['bwt_string']}\' '''
       f'''we get original string \'{original_string}\''''
   )





def  UpperCAmelCase_							(				) ->			int:
      return 1

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

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

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

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

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

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			int:
      return 0 if x < 0 else one_pound(x - 1_00							) + fifty_pence(__UpperCAmelCase							)

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			int:
      return 0 if x < 0 else two_pound(x - 2_00							) + one_pound(__UpperCAmelCase							)

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int = 2_00							) ->			int:
      return two_pound(__UpperCAmelCase							)


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