






class 						SCREAMING_SNAKE_CASE				:





							"""simple docstring"""

							def __init__(  self:   List[Any]   )    ->				Union[str, Any]:
												_A								= {}

							def       __A (  self:   str   )    ->				None:
												print(self.vertex   )
												for i in self.vertex:
																	print(__A		,     ''' -> '''		,     ''' -> '''.join([str(__A   ) for j in self.vertex[i]]   )   )

							def       __A (  self:   Union[str, Any]		,     __A:   int		,     __A:   int   )    ->				None:
												# check if vertex is already present,
												if from_vertex in self.vertex:
																	self.vertex[from_vertex].append(__A   )
												else:
																	# else make a new vertex
																	_A								= [to_vertex]

							def       __A (  self:   Any   )    ->				None:
												# visited array for storing already visited nodes
												_A								= [False] * len(self.vertex   )

												# call the recursive helper function
												for i in range(len(self.vertex   )   ):
																	if not visited[i]:
																						self.dfs_recursive(__A		,     __A   )



							def       __A (  self:   List[Any]		,     __A:   int		,     __A:   list   )    ->				None:
												# mark start vertex as visited
												_A								= True

												print(__A		,     end=''' '''   )

												# Recur for all the vertices that are adjacent to this node
												for i in self.vertex:
																	if not visited[i]:
																						self.dfs_recursive(__A		,     __A   )


if __name__ == "__main__":
				__A      =				Graph()
				g.add_edge(0, 1)
				g.add_edge(0, 2)
				g.add_edge(1, 2)
				g.add_edge(2, 0)
				g.add_edge(2, 3)
				g.add_edge(3, 3)

				g.print_graph()
				print('DFS:')
				g.dfs()

				# OUTPUT:
				# 0  ->  1 -> 2
				# 1  ->  2
				# 2  ->  0 -> 3
				# 3  ->  3
				# DFS:
				#  0 1 2 3











def      __A					(     _lowercase = 1_00_00_00 ):

					'''simple docstring'''







					_A								= 1
					_A								= 1
					_A								= {1: 1}

					for inputa in range(2					,			_lowercase ):
										_A								= 0
										_A								= inputa

										while True:
															if number in counters:
																				counter += counters[number]
																				break
															if number % 2 == 0:
																				number //= 2
																				counter += 1
															else:
																				_A								= (3 * number) + 1
																				counter += 1

										if inputa not in counters:
															_A								= counter

										if counter > pre_counter:
															_A								= inputa
															_A								= counter
					return largest_number


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



