



'''simple docstring'''



from __future__ import annotations

from collections import deque






class 					UpperCAmelCase__	:



					def __init__(    self			,				UpperCamelCase     )     ->			Optional[int]:
						__lowerCAmelCase												=  []
						self.adlist.append(
						    {"value": "", "next_states": [], "fail_state": 0, "output": []}     )

						for keyword in keywords:
							self.add_keyword(UpperCamelCase     )
						self.set_fail_transitions()



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase     )     ->			int | None:
						for state in self.adlist[current_state]["next_states"]:
							if char == self.adlist[state]["value"]:
								return state
						return None



					def        UpperCAmelCase_ (    self			,				UpperCamelCase     )     ->			None:
						__lowerCAmelCase												=  0
						for character in keyword:
							__lowerCAmelCase												=  self.find_next_state(UpperCamelCase			,				UpperCamelCase     )
							if next_state is None:
								self.adlist.append(
								    {
								        "value": character,
								        "next_states": [],
								        "fail_state": 0,
								        "output": [],
								    }     )
								self.adlist[current_state]["next_states"].append(len(self.adlist     ) - 1     )
								__lowerCAmelCase												=  len(self.adlist     ) - 1
							else:
								__lowerCAmelCase												=  next_state
						self.adlist[current_state]["output"].append(UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			None:
						__lowerCAmelCase												=  deque()
						for node in self.adlist[0]["next_states"]:
							q.append(UpperCamelCase     )
							__lowerCAmelCase												=  0
						while q:
							__lowerCAmelCase												=  q.popleft()
							for child in self.adlist[r]["next_states"]:
								q.append(UpperCamelCase     )
								__lowerCAmelCase												=  self.adlist[r]["fail_state"]
								while (
								    self.find_next_state(UpperCamelCase			,				self.adlist[child]["value"]     ) is None
								    and state != 0
								):
									__lowerCAmelCase												=  self.adlist[state]["fail_state"]
								__lowerCAmelCase												=  self.find_next_state(
								    UpperCamelCase			,				self.adlist[child]["value"]     )
								if self.adlist[child]["fail_state"] is None:
									__lowerCAmelCase												=  0
								__lowerCAmelCase												=  (
								    self.adlist[child]["output"]
								    + self.adlist[self.adlist[child]["fail_state"]]["output"]
								)



					def        UpperCAmelCase_ (    self			,				UpperCamelCase     )     ->			dict[str, list[int]]:
						__lowerCAmelCase												=  {}  # returns a dict with keywords and list of its occurrences
						__lowerCAmelCase												=  0
						for i in range(len(UpperCamelCase     )     ):
							while (
							    self.find_next_state(UpperCamelCase			,				string[i]     ) is None
							    and current_state != 0
							):
								__lowerCAmelCase												=  self.adlist[current_state]["fail_state"]
							__lowerCAmelCase												=  self.find_next_state(UpperCamelCase			,				string[i]     )
							if next_state is None:
								__lowerCAmelCase												=  0
							else:
								__lowerCAmelCase												=  next_state
								for key in self.adlist[current_state]["output"]:
									if key not in result:
										__lowerCAmelCase												=  []
									result[key].append(i - len(UpperCamelCase     ) + 1     )
						return result


if __name__ == "__main__":
	import doctest

	doctest.testmod()




'''simple docstring'''



def   __lowerCAmelCase					(							lowerCamelCase   :						Union[str, Any]					):






	'''simple docstring'''




	__lowerCAmelCase												=  1
	__lowerCAmelCase												=  2
	while i * i <= n:
		__lowerCAmelCase												=  0
		while n % i == 0:
			n //= i
			multiplicity += 1
		n_divisors *= multiplicity + 1
		i += 1
	if n > 1:
		n_divisors *= 2
	return n_divisors



def   __lowerCAmelCase					(							):






	'''simple docstring'''




	__lowerCAmelCase												=  1
	__lowerCAmelCase												=  1

	while True:
		i += 1
		t_num += i

		if count_divisors(lowerCamelCase					) > 5_00:
			break

	return t_num


if __name__ == "__main__":
	print(solution())