def 							lowerCAmelCase(     __lowerCamelCase						):
					__a		 =       current_set.copy()
					for row_index, row in enumerate(__lowerCamelCase						):
										__a		 =       row[0]
										for column_index, column in enumerate(__lowerCamelCase						):
															if magnitude == 0:
																				__a		 =       column
																				continue
															__a		 =       column / magnitude
    # Subtract to cancel term
					__a		 =       current_set[0]
					__a		 =       [first_row]
					__a		 =       current_set[1::]
					for row in current_set:
										__a		 =       []
										# If first term is 0, it is already in form we want, so we preserve it
										if row[0] == 0:
															final_set.append(__lowerCamelCase						)
															continue
										for column_index in range(len(__lowerCamelCase						)						):
															temp_row.append(first_row[column_index] - row[column_index]						)
										final_set.append(__lowerCamelCase						)
					# Create next recursion iteration set
					if len(final_set[0]						) != 3:
										__a		 =       final_set[0]
										__a		 =       []
										__a		 =       []
										for row in final_set[1::]:
															current_first_column.append(row[0]						)
															next_iteration.append(row[1::]						)
										__a		 =       simplify(__lowerCamelCase						)
										for i in range(len(__lowerCamelCase						)						):
															resultant[i].insert(0				,    current_first_column[i]						)
										resultant.insert(0				,    __lowerCamelCase						)
										__a		 =       resultant
					return final_set
def 							lowerCAmelCase(     __lowerCamelCase						):




					if len(__lowerCamelCase						) == 0:
										raise IndexError('solve_simultaneous() requires n lists of length n+1'						)
					__a		 =       len(__lowerCamelCase						) + 1
					if any(len(__lowerCamelCase						) != _length for item in equations						):
										raise IndexError('solve_simultaneous() requires n lists of length n+1'						)
					for row in equations:
										if any(not isinstance(__lowerCamelCase				,    (int, float)						) for column in row						):
															raise ValueError('solve_simultaneous() requires lists of integers'						)
					if len(__lowerCamelCase						) == 1:
										return [equations[0][-1] / equations[0][0]]
					__a		 =       equations.copy()
					if any(0 in row for row in data_set						):
										__a		 =       data_set.copy()
										__a		 =       []
										for row_index, row in enumerate(__lowerCamelCase						):
															if 0 not in row:
																				__a		 =       data_set.pop(__lowerCamelCase						)
																				break
										if not full_row:
															raise ValueError('solve_simultaneous() requires at least 1 full equation'						)
										data_set.insert(0				,    __lowerCamelCase						)
					__a		 =       data_set.copy()
					__a		 =       simplify(__lowerCamelCase						)
					__a		 =       simplified[::-1]
					__a		 =       []
					for row in simplified:
										__a		 =       row[-1]
										if not solutions:
															if row[-2] == 0:
																				solutions.append(0						)
																				continue
															solutions.append(current_solution / row[-2]						)
															continue
										__a		 =       row.copy()[: len(__lowerCamelCase						) - 1 :]
										while temp_row[0] == 0:
															temp_row.pop(0						)
										if len(__lowerCamelCase						) == 0:
															solutions.append(0						)
															continue
										__a		 =       temp_row[1::]
										__a		 =       temp_row[::-1]
										for column_index, column in enumerate(__lowerCamelCase						):
															current_solution -= column * solutions[column_index]
										solutions.append(__lowerCamelCase						)
					__a		 =       []
					for item in solutions:
										final.append(float(round(__lowerCamelCase				,    5						)						)						)
					return final[::-1]


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	lowerCamelCase_    :		List[Any]							=	[
	    [2, 1, 1, 1, 1, 4],
	    [1, 2, 1, 1, 1, 5],
	    [1, 1, 2, 1, 1, 6],
	    [1, 1, 1, 2, 1, 7],
	    [1, 1, 1, 1, 2, 8],
	]
	print(solve_simultaneous(eq))
	print(solve_simultaneous([[4, 2]]))





from math import sqrt
def 							lowerCAmelCase(     __lowerCamelCase						):
					__a		 =       0
					for i in range(1				,    int(sqrt(__lowerCamelCase						) + 1						)						):
										if n % i == 0 and i != sqrt(__lowerCamelCase						):
															total += i + n // i
										elif i == sqrt(__lowerCamelCase						):
															total += i
					return total - n
def 							lowerCAmelCase(     __lowerCamelCase = 1_0000						):
					__a		 =       sum(
					    i
					    for i in range(1				,    __lowerCamelCase						)
					    if sum_of_divisors(sum_of_divisors(__lowerCamelCase						)						) == i and sum_of_divisors(__lowerCamelCase						) != i						)
					return total


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




