






from __future__ import annotations

import bisect



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase = 0  ,  __UpperCamelCase = -1 ):







     if hi < 0:
          a_    :     List[Any]										=    len(__UpperCAmelCase )

     while lo < hi:
          a_    :     List[Any]										=    lo + (hi - lo) // 2
          if sorted_collection[mid] < item:
               a_    :     List[str]										=    mid + 1
          else:
               a_    :     Dict										=    mid

     return lo



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase = 0  ,  __UpperCamelCase = -1 ):







     if hi < 0:
          a_    :     Dict										=    len(__UpperCAmelCase )

     while lo < hi:
          a_    :     List[str]										=    lo + (hi - lo) // 2
          if sorted_collection[mid] <= item:
               a_    :     Dict										=    mid + 1
          else:
               a_    :     Dict										=    mid

     return lo



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase = 0  ,  __UpperCamelCase = -1 ):
     sorted_collection.insert(bisect_left(__UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase )  ,  __UpperCAmelCase )



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase = 0  ,  __UpperCamelCase = -1 ):
     sorted_collection.insert(bisect_right(__UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase )  ,  __UpperCAmelCase )



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase ):
     a_    :     int										=    0
     a_    :     Optional[Any]										=    len(__UpperCAmelCase ) - 1

     while left <= right:
          a_    :     List[Any]										=    left + (right - left) // 2
          a_    :     Dict										=    sorted_collection[midpoint]
          if current_item == item:
               return midpoint
          elif item < current_item:
               a_    :     str										=    midpoint - 1
          else:
               a_    :     Optional[Any]										=    midpoint + 1
     return None



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase ):
     a_    :     Optional[int]										=    bisect.bisect_left(__UpperCAmelCase  ,  __UpperCAmelCase )
     if index != len(__UpperCAmelCase ) and sorted_collection[index] == item:
          return index
     return None



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase ):







     if right < left:
          return None

     a_    :     Union[str, Any]										=    left + (right - left) // 2

     if sorted_collection[midpoint] == item:
          return midpoint
     elif sorted_collection[midpoint] > item:
          return binary_search_by_recursion(__UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  midpoint - 1 )
     else:
          return binary_search_by_recursion(__UpperCAmelCase  ,  __UpperCAmelCase  ,  midpoint + 1  ,  __UpperCAmelCase )


if __name__ == "__main__":
       __lowerCamelCase        =     input('''Enter numbers separated by comma:\n''').strip()
       __lowerCamelCase        =     sorted(int(item) for item in user_input.split(''','''))
       __lowerCamelCase        =     int(input('''Enter a single number to be found in the list:\n'''))
       __lowerCamelCase        =     binary_search(collection, target)
       if result is None:
              print(f'''{target} was not found in {collection}.''')
       else:
              print(f'''{target} was found at position {result} in {collection}.''')







import numpy as np

__lowerCamelCase        =     [
    ['''a''', '''b''', '''c''', '''d''', '''e'''],
    ['''f''', '''g''', '''h''', '''i''', '''k'''],
    ['''l''', '''m''', '''n''', '''o''', '''p'''],
    ['''q''', '''r''', '''s''', '''t''', '''u'''],
    ['''v''', '''w''', '''x''', '''y''', '''z'''],
]


class   a__	:

       def __init__(   self      :     Union[str, Any]    ):
            a_    :     List[Any]										=    np.array(lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     Union[str, Any]      ,							lowerCamelCase_      :     str    ):
            a_			,			a_    :     Optional[int]										=    np.where(letter == self.SQUARE    )
            a_    :     Union[str, Any]										=    np.concatenate([indexa + 1, indexa + 1]    )
            return indexes

       def 						UpperCAmelCase(   self      :     Tuple      ,							lowerCamelCase_      :     int      ,							lowerCamelCase_      :     int    ):
            a_    :     str										=    self.SQUARE[indexa - 1, indexa - 1]
            return letter

       def 						UpperCAmelCase(   self      :     Optional[Any]      ,							lowerCamelCase_      :     str    ):
            a_    :     List[str]										=    message.lower()
            a_    :     str										=    message.replace(""" """      ,							""""""    )
            a_    :     Union[str, Any]										=    message.replace("""j"""      ,							"""i"""    )

            a_    :     Optional[Any]										=    np.empty((2, len(lowerCamelCase_    ))    )
            for letter_index in range(len(lowerCamelCase_    )    ):
                 a_    :     int										=    self.letter_to_numbers(message[letter_index]    )

                 a_    :     str										=    numbers[0]
                 a_    :     int										=    numbers[1]

            a_    :     int										=    first_step.reshape(2 * len(lowerCamelCase_    )    )
            a_    :     Optional[Any]										=    """"""
            for numbers_index in range(len(lowerCamelCase_    )    ):
                 a_    :     Optional[Any]										=    int(second_step[numbers_index * 2]    )
                 a_    :     Optional[Any]										=    int(second_step[(numbers_index * 2) + 1]    )
                 a_    :     Optional[Any]										=    self.numbers_to_letter(lowerCamelCase_      ,							lowerCamelCase_    )
                 a_    :     List[str]										=    encoded_message + letter

            return encoded_message

       def 						UpperCAmelCase(   self      :     Tuple      ,							lowerCamelCase_      :     str    ):
            a_    :     Optional[Any]										=    message.lower()
            message.replace(""" """      ,							""""""    )
            a_    :     int										=    np.empty(2 * len(lowerCamelCase_    )    )
            for letter_index in range(len(lowerCamelCase_    )    ):
                 a_    :     str										=    self.letter_to_numbers(message[letter_index]    )
                 a_    :     Optional[int]										=    numbers[0]
                 a_    :     Optional[Any]										=    numbers[1]

            a_    :     Tuple										=    first_step.reshape((2, len(lowerCamelCase_    ))    )
            a_    :     Optional[int]										=    """"""
            for numbers_index in range(len(lowerCamelCase_    )    ):
                 a_    :     Dict										=    int(second_step[0, numbers_index]    )
                 a_    :     Tuple										=    int(second_step[1, numbers_index]    )
                 a_    :     Tuple										=    self.numbers_to_letter(lowerCamelCase_      ,							lowerCamelCase_    )
                 a_    :     Union[str, Any]										=    decoded_message + letter

            return decoded_message



