






def _UpperCAmelCase   (	a						:	Optional[int] ):
							if not head:
														return True
							# split the list to two parts
							snake_case__  , snake_case__	  =       head.next, head
							while fast and fast.next:
														snake_case__	  =       fast.next.next
														snake_case__	  =       slow.next
							snake_case__	  =       slow.next
							snake_case__	  =       None  # Don't forget here! But forget still works!
							# reverse the second part
							snake_case__	  =       None
							while second:
														snake_case__	  =       second.next
														snake_case__	  =       node
														snake_case__	  =       second
														snake_case__	  =       nxt
							# compare two parts
							# second part has the same or one less node
							while node:
														if node.val != head.val:
																					return False
														snake_case__	  =       node.next
														snake_case__	  =       head.next
							return True

def _UpperCAmelCase   (	a						:	Optional[int] ):
							if not head or not head.next:
														return True

							# 1. Get the midpoint (slow)
							snake_case__	  =       snake_case__	  =       snake_case__	  =       head
							while fast and fast.next:
														snake_case__  , snake_case__	  =       fast.next.next, slow.next

							# 2. Push the second half into the stack
							snake_case__	  =       [slow.val]
							while slow.next:
														snake_case__	  =       slow.next
														stack.append(slow.val )

							# 3. Comparison
							while stack:
														if stack.pop() != cur.val:
																					return False
														snake_case__	  =       cur.next

							return True



def _UpperCAmelCase   (	a						:	Dict ):
							if not head or not head.next:
														return True
							snake_case__	  =       {}
							snake_case__	  =       0
							while head:
														if head.val in d:
																					d[head.val].append(a )
														else:
																					snake_case__	  =       [pos]
														snake_case__	  =       head.next
														pos += 1
							snake_case__	  =       pos - 1
							snake_case__	  =       0
							for v in d.values():
														if len(a ) % 2 != 0:
																					middle += 1
														else:
																					snake_case__	  =       0
																					for i in range(0  ,					len(a ) ):
																												if v[i] + v[len(a ) - 1 - step] != checksum:
																																			return False
																												step += 1
														if middle > 1:
																					return False
							return True








def _UpperCAmelCase   (	a						:	int = 1000 ):
							snake_case__  , snake_case__	  =       1, 1
							snake_case__	  =       2
							while True:
														snake_case__	  =       0
														snake_case__	  =       fa + fa
														snake_case__  , snake_case__	  =       fa, f
														index += 1
														for _ in str(a ):
																					i += 1
														if i == n:
																					break
							return index


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