
'''simple docstring'''
import sys

sys.set_int_max_str_digits(0)  # type: ignore







def 							A_  (    __SCREAMING_SNAKE_CASE    :	int			)					->							bool:





  """simple docstring"""

  __A		:  int       				=		[0] * 11
  __A		:  Optional[int]       				=		[0] * 11

  # mark last 9 numbers
  for _ in range(9			):
    __A		:  str       				=		1
    __A		:  Optional[int]       				=		number // 10
  # flag
  __A		:  List[Any]       				=		True

  # check last 9 numbers for pandigitality

  for x in range(9			):
    if not check_last[x + 1]:
      __A		:  Optional[Any]       				=		False
  if not f:
    return f

  # mark first 9 numbers
  __A		:  Tuple       				=		int(str(__SCREAMING_SNAKE_CASE			)[:9]			)

  for _ in range(9			):
    __A		:  List[str]       				=		1
    __A		:  str       				=		number // 10

  # check first 9 numbers for pandigitality

  for x in range(9			):
    if not check_front[x + 1]:
      __A		:  Any       				=		False
  return f







def 							A_  (    __SCREAMING_SNAKE_CASE    :	int			)					->							bool:





  """simple docstring"""

  __A		:  Tuple       				=		[0] * 11

  # mark last 9 numbers
  for _ in range(9			):
    __A		:  List[str]       				=		1
    __A		:  Optional[int]       				=		number // 10
  # flag
  __A		:  Tuple       				=		True

  # check last 9 numbers for pandigitality

  for x in range(9			):
    if not check_last[x + 1]:
      __A		:  Tuple       				=		False
  return f







def 							A_  (    )					->							int:





  """simple docstring"""

  __A		:  Optional[int]       				=		1
  __A		:  List[Any]       				=		1
  __A		:  List[str]       				=		2
  # temporary Fibonacci numbers

  __A		:  int       				=		1
  __A		:  Tuple       				=		1
  __A		:  Tuple       				=		2
  # temporary Fibonacci numbers mod 1e9

  # mod m=1e9, done for fast optimisation
  __A		:  Dict       				=		[0] * 100_0000
  __A		:  Tuple       				=		10_0000_0000

  for x in range(100_0000			):
    __A		:  Tuple       				=		(aa + ba) % m
    __A		:  List[Any]       				=		ba % m
    __A		:  Any       				=		ca % m
    if checka(__SCREAMING_SNAKE_CASE			):
      __A		:  Any       				=		1

  for x in range(100_0000			):
    __A		:  Any       				=		a + b
    __A		:  Optional[Any]       				=		b
    __A		:  Any       				=		c
    # perform check only if in tocheck
    if tocheck[x + 3] and check(__SCREAMING_SNAKE_CASE			):
      return x + 3  # first 2 already done
  return -1


if __name__ == "__main__":
     print(F"{solution() = }")





'''simple docstring'''
A__ :		Optional[Any]					=[chr(i) for i in range(32, 126)]
A__ :		Tuple					=list(range(len(alphabets)))
A__ :		int					=list(range(len(alphabets)))
A__ :		Optional[Any]					=list(range(len(alphabets)))
A__ :		Any					=list(reversed(range(len(alphabets))))
A__ :		Optional[int]					=[]
A__ :		Tuple					=0







def 							A_  (    )					->							Any:





  """simple docstring"""

  global gear_one_pos
  global gear_two_pos
  global gear_three_pos
  __A		:  Any       				=		gear_one[0]
  gear_one.append(__SCREAMING_SNAKE_CASE			)
  del gear_one[0]
  gear_one_pos += 1
  if gear_one_pos % int(len(__SCREAMING_SNAKE_CASE			)			) == 0:
    __A		:  Any       				=		gear_two[0]
    gear_two.append(__SCREAMING_SNAKE_CASE			)
    del gear_two[0]
    gear_two_pos += 1
    if gear_two_pos % int(len(__SCREAMING_SNAKE_CASE			)			) == 0:
      __A		:  str       				=		gear_three[0]
      gear_three.append(__SCREAMING_SNAKE_CASE			)
      del gear_three[0]
      gear_three_pos += 1







def 							A_  (    __SCREAMING_SNAKE_CASE    :	str			)					->							List[str]:





  """simple docstring"""

  __A		:  Union[str, Any]       				=		alphabets.index(__SCREAMING_SNAKE_CASE			)
  __A		:  Dict       				=		gear_one[target]
  __A		:  int       				=		gear_two[target]
  __A		:  List[str]       				=		gear_three[target]
  __A		:  List[Any]       				=		reflector[target]
  __A		:  List[Any]       				=		gear_three.index(__SCREAMING_SNAKE_CASE			)
  __A		:  Tuple       				=		gear_two.index(__SCREAMING_SNAKE_CASE			)
  __A		:  List[str]       				=		gear_one.index(__SCREAMING_SNAKE_CASE			)
  code.append(alphabets[target]			)
  rotator()


if __name__ == "__main__":
     A__ :		int					=list(input('Type your message:\n'))
     while True:
          try:
               A__ :		Any					=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!'
     )



