



from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
a_    :  Optional[int]						  =		Lock()

def      __lowercase(						UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__			):


      """simple docstring"""



      global process_lock

      # we perform n swaps since after n swaps we know we are sorted
      # we *could* stop early if we are sorted already, but it takes as long to
      # find out we are sorted as it does to sort the list with this algorithm
      for i in range(0 , 10			):
            if (i + position) % 2 == 0 and r_send is not None:
                  # send your value to your right neighbor
                  process_lock.acquire()
                  r_send[1].send(UpperCAmelCase__			)
                  process_lock.release()

                  # receive your right neighbor's value
                  process_lock.acquire()
                  lowerCamelCase             =		rr_cv[0].recv()
                  process_lock.release()

                  # take the lower value since you are on the left
                  lowerCamelCase             =		min(UpperCAmelCase__ , UpperCAmelCase__			)
            elif (i + position) % 2 != 0 and l_send is not None:
                  # send your value to your left neighbor
                  process_lock.acquire()
                  l_send[1].send(UpperCAmelCase__			)
                  process_lock.release()

                  # receive your left neighbor's value
                  process_lock.acquire()
                  lowerCamelCase             =		lr_cv[0].recv()
                  process_lock.release()

                  # take the higher value since you are on the right
                  lowerCamelCase             =		max(UpperCAmelCase__ , UpperCAmelCase__			)
    # after all swaps are performed, send the values back to main
      result_pipe[1].send(UpperCAmelCase__			)

def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



      lowerCamelCase             =		[]
      lowerCamelCase             =		[]
      # initialize the list of pipes where the values will be retrieved
      for _ in arr:
            result_pipe.append(Pipe()			)
      # creates the processes
      # the first and last process only have one neighbor so they are made outside
      # of the loop
      lowerCamelCase             =		Pipe()
      lowerCamelCase             =		Pipe()
      process_array_.append(
          Process(
              target=UpperCAmelCase__ , args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0]) , )			)
      lowerCamelCase             =		temp_rs
      lowerCamelCase             =		temp_rr

      for i in range(1 , len(UpperCAmelCase__			) - 1			):
            lowerCamelCase             =		Pipe()
            lowerCamelCase             =		Pipe()
            process_array_.append(
                Process(
                    target=UpperCAmelCase__ , args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i]) , )			)
            lowerCamelCase             =		temp_rs
            lowerCamelCase             =		temp_rr

      process_array_.append(
          Process(
              target=UpperCAmelCase__ , args=(
                  len(UpperCAmelCase__			) - 1,
                  arr[len(UpperCAmelCase__			) - 1],
                  temp_ls,
                  None,
                  temp_lr,
                  None,
                  result_pipe[len(UpperCAmelCase__			) - 1],
              ) , )			)

      # start the processes
      for p in process_array_:
            p.start()

      # wait for the processes to end and write their values to the list
      for p in range(0 , len(UpperCAmelCase__			)			):
            lowerCamelCase             =		result_pipe[p][0].recv()
            process_array_[p].join()
      return arr

def      __lowercase(						):


      """simple docstring"""



      lowerCamelCase             =		list(range(10 , 0 , -1			)			)
      print("Initial List"			)
      print(*UpperCAmelCase__			)
      lowerCamelCase             =		odd_even_transposition(UpperCAmelCase__			)
      print("Sorted List\n"			)
      print(*UpperCAmelCase__			)


if __name__ == "__main__":
     main()




def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



      if n == 1 or not isinstance(UpperCAmelCase__ , UpperCAmelCase__			):
            return 0
      elif n == 2:
            return 1
      else:
            lowerCamelCase             =		[0, 1]
            for i in range(2 , n + 1			):
                  sequence.append(sequence[i - 1] + sequence[i - 2]			)

            return sequence[n]

def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



      lowerCamelCase             =		0
      lowerCamelCase             =		2

      while digits < n:
            index += 1
            lowerCamelCase             =		len(str(fibonacci(UpperCAmelCase__			)			)			)

      return index

def      __lowercase(						UpperCAmelCase__ = 1000			):


      """simple docstring"""



      return fibonacci_digits_index(UpperCAmelCase__			)


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