'''simple docstring'''




from __future__ import annotations






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       )			->					Optional[int]:
    __lowerCamelCase						=						0
    __lowerCamelCase						=						len(UpperCamelCase__       ) - 1
    while left <= right:
        __lowerCamelCase						=						(left + right) // 2
        if left == right:
            if sorted_list[middle] < item:
                __lowerCamelCase						=						middle + 1
            break
        elif sorted_list[middle] < item:
            __lowerCamelCase						=						middle + 1
        else:
            __lowerCamelCase						=						middle - 1
    sorted_list.insert(UpperCamelCase__       ,						UpperCamelCase__       )
    return sorted_list






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       )			->					List[Any]:
    __lowerCamelCase						=						[]
    while left and right:
        if left[0][0] < right[0][0]:
            result.append(left.pop(0       )       )
        else:
            result.append(right.pop(0       )       )
    return result + left + right






def __lowerCAmelCase				(							UpperCamelCase__       )			->					Optional[Any]:
    __lowerCamelCase						=						len(UpperCamelCase__       )
    if length <= 1:
        return list_ad
    __lowerCamelCase						=						length // 2
    return merge(sortlist_ad(list_ad[:middle]       )       ,						sortlist_ad(list_ad[middle:]       )       )






def __lowerCAmelCase				(							UpperCamelCase__       )			->					list[int]:

    if len(UpperCamelCase__       ) <= 1:
        return collection
    __lowerCamelCase						=						[]
    __lowerCamelCase						=						False
    for i in range(0       ,						len(UpperCamelCase__       )       ,						2       ):
        if i == len(UpperCamelCase__       ) - 1:
            __lowerCamelCase						=						True
        else:
            if collection[i] < collection[i + 1]:
                two_paired_list.append([collection[i], collection[i + 1]]       )
            else:
                two_paired_list.append([collection[i + 1], collection[i]]       )
    __lowerCamelCase						=						sortlist_ad(UpperCamelCase__       )
    __lowerCamelCase						=						[i[0] for i in sorted_list_ad]
    result.append(sorted_list_ad[-1][1]       )
    if has_last_odd_item:
        __lowerCamelCase						=						collection[-1]
        __lowerCamelCase						=						binary_search_insertion(UpperCamelCase__       ,						UpperCamelCase__       )
    __lowerCamelCase						=						False
    for i in range(len(UpperCamelCase__       ) - 1       ):
        if result[i] == collection[-1] and has_last_odd_item:
            __lowerCamelCase						=						True
        __lowerCamelCase						=						sorted_list_ad[i][1]
        # If last_odd_item is inserted before the item's index,
        # you should forward index one more.
        if is_last_odd_item_inserted_before_this_index:
            __lowerCamelCase						=						result[: i + 2] + binary_search_insertion(result[i + 2 :]       ,						UpperCamelCase__       )
        else:
            __lowerCamelCase						=						result[: i + 1] + binary_search_insertion(result[i + 1 :]       ,						UpperCamelCase__       )

    return result


if __name__ == "__main__":
  __UpperCAmelCase  							=input("Enter numbers separated by a comma:\n").strip()
  __UpperCAmelCase  							=[int(item) for item in user_input.split(",")]
  print(merge_insertion_sort(unsorted))

'''simple docstring'''




__UpperCAmelCase  							=[chr(i) for i in range(3_2, 1_2_6)]
__UpperCAmelCase  							=list(range(len(alphabets)))
__UpperCAmelCase  							=list(range(len(alphabets)))
__UpperCAmelCase  							=list(range(len(alphabets)))
__UpperCAmelCase  							=list(reversed(range(len(alphabets))))
__UpperCAmelCase  							=[]
__UpperCAmelCase  							=__UpperCAmelCase  							=__UpperCAmelCase  							=0






def __lowerCAmelCase				(							)			->					List[Any]:
    global gear_one_pos
    global gear_two_pos
    global gear_three_pos
    __lowerCamelCase						=						gear_one[0]
    gear_one.append(UpperCamelCase__       )
    del gear_one[0]
    gear_one_pos += 1
    if gear_one_pos % int(len(UpperCamelCase__       )       ) == 0:
        __lowerCamelCase						=						gear_two[0]
        gear_two.append(UpperCamelCase__       )
        del gear_two[0]
        gear_two_pos += 1
        if gear_two_pos % int(len(UpperCamelCase__       )       ) == 0:
            __lowerCamelCase						=						gear_three[0]
            gear_three.append(UpperCamelCase__       )
            del gear_three[0]
            gear_three_pos += 1






def __lowerCAmelCase				(							UpperCamelCase__       )			->					Optional[Any]:
    __lowerCamelCase						=						alphabets.index(UpperCamelCase__       )
    __lowerCamelCase						=						gear_one[target]
    __lowerCamelCase						=						gear_two[target]
    __lowerCamelCase						=						gear_three[target]
    __lowerCamelCase						=						reflector[target]
    __lowerCamelCase						=						gear_three.index(UpperCamelCase__       )
    __lowerCamelCase						=						gear_two.index(UpperCamelCase__       )
    __lowerCamelCase						=						gear_one.index(UpperCamelCase__       )
    code.append(alphabets[target]       )
    rotator()


if __name__ == "__main__":
  __UpperCAmelCase  							=list(input("Type your message:\n"))
  while True:
    try:
      __UpperCAmelCase  							=int(input("Please set token:(must be only digits)\n"))
      break
    except Exception as error:
      print(error)
  for _ in range(token):
    rotator()
  for j in decode:
    engine(j)
  print("\n" + "".join(code))
  print(
      f'\nYour Token is {token} please write it down.\nIf you want to decode '
      "this message again you should input same digits as token!"
  )
