



import math
import sys

class 	__snake_case :







							'''simple docstring'''






							def __init__(							self						):
											a__			 =						0
											a__			 =						[]
											a__			 =						{}  # To store the pos of node in array


							def _a (							self						):
											return self.cur_size == 0


							def _a (							self					,					a_						):
											a__			 =						self.left(a_						)
											a__			 =						self.right(a_						)
											if lc < self.cur_size and self.array(a_						)[0] < self.array(a_						)[0]:
															a__			 =						lc
											else:
															a__			 =						idx
											if rc < self.cur_size and self.array(a_						)[0] < self.array(a_						)[0]:
															a__			 =						rc
											if smallest != idx:
															self.swap(a_					,					a_						)
															self.min_heapify(a_						)


							def _a (							self					,					a_						):
											# Inserts a node into the Priority Queue
											a__			 =						self.cur_size
											self.cur_size += 1
											self.array.append((sys.maxsize, tup[1])						)
											self.decrease_key((sys.maxsize, tup[1])					,					tup[0]						)


							def _a (							self						):
											# Removes and returns the min element at top of priority queue
											a__			 =						self.array[0][1]
											a__			 =						self.array[self.cur_size - 1]
											self.cur_size -= 1
											self.min_heapify(1						)
											del self.pos[min_node]
											return min_node


							def _a (							self					,					a_						):
											# returns the index of left child
											return 2 * i + 1


							def _a (							self					,					a_						):
											# returns the index of right child
											return 2 * i + 2


							def _a (							self					,					a_						):
											# returns the index of parent
											return math.floor(i / 2						)


							def _a (							self					,					a_					,					a_						):
											# swaps array elements at indices i and j
											# update the pos{}
											a__			 =						j
											a__			 =						i
											a__			 =						self.array[i]
											a__			 =						self.array[j]
											a__			 =						temp







							def _a (							self					,					a_					,					a_						):
											a__			 =						self.pos[tup[1]]
											# assuming the new_d is atmost old_d
											a__			 =						(new_d, tup[1])
											while idx > 0 and self.array[self.par(a_						)][0] > self.array[idx][0]:
															self.swap(a_					,					self.par(a_						)						)
															a__			 =						self.par(a_						)




class 	__snake_case :







							'''simple docstring'''






							def __init__(							self					,					a_						):
											a__			 =						{}  # To store graph: u -> (v,w)
											a__			 =						num  # Number of nodes in graph
											# To store the distance from source vertex
											a__			 =						[0] * self.num_nodes
											a__			 =						[-1] * self.num_nodes  # To store the path


							def _a (							self					,					a_					,					a_					,					a_						):
											#  Edge going from node u to v and v to u with weight w
											# u (w)-> v, v (w) -> u
											# Check if u already in graph
											if u in self.adjList:
															self.adjList[u].append((v, w)						)
											else:
															a__			 =						[(v, w)]

											# Assuming undirected graph
											if v in self.adjList:
															self.adjList[v].append((u, w)						)
											else:
															a__			 =						[(u, w)]


							def _a (							self						):
											# u -> v(w)
											for u in self.adjList:
															print(a_					,					"""->"""					,					""" -> """.join(str(F'''{v}({w})'''						) for v, w in self.adjList[u]						)						)


							def _a (							self					,					a_						):
											# Flush old junk values in par[]
											a__			 =						[-1] * self.num_nodes
											# src is the source node
											a__			 =						0
											a__			 =						PriorityQueue()
											q.insert((0, src)						)  # (dist from src, node)
											for u in self.adjList:
															if u != src:
																			a__			 =						sys.maxsize  # Infinity
																			a__			 =						-1

											while not q.is_empty():
															a__			 =						q.extract_min()  # Returns node with the min dist from source
															# Update the distance of all the neighbours of u and
															# if their prev dist was INFINITY then push them in Q
															for v, w in self.adjList[u]:
																			a__			 =						self.dist[u] + w
																			if self.dist[v] > new_dist:
																							if self.dist[v] == sys.maxsize:
																											q.insert((new_dist, v)						)
																							else:
																											q.decrease_key((self.dist[v], v)					,					a_						)
																							a__			 =						new_dist
																							a__			 =						u

        # Show the shortest distances from src
											self.show_distances(a_						)


							def _a (							self					,					a_						):
											print(F'''Distance from node: {src}'''						)
											for u in range(self.num_nodes						):
															print(F'''Node {u} has distance: {self.dist[u]}'''						)







							def _a (							self					,					a_					,					a_						):
											# To show the shortest path from src to dest
											# WARNING: Use it *after* calling dijkstra
											a__			 =						[]
											a__			 =						0
											a__			 =						dest
											# Backtracking from dest to src
											while self.par[temp] != -1:
															path.append(a_						)
															if temp != src:
																			for v, w in self.adjList[temp]:
																							if v == self.par[temp]:
																											cost += w
																											break
															a__			 =						self.par[temp]
											path.append(a_						)
											path.reverse()

											print(F'''----Path to reach {dest} from {src}----'''						)
											for u in path:
															print(F'''{u}'''					,					end=""" """						)
															if u != dest:
																			print("""-> """					,					end=""""""						)

											print("""\nTotal cost of path: """					,					a_						)


if __name__ == "__main__":
	UpperCAmelCase												=   Graph(9)
	graph.add_edge(0, 1, 4)
	graph.add_edge(0, 7, 8)
	graph.add_edge(1, 2, 8)
	graph.add_edge(1, 7, 11)
	graph.add_edge(2, 3, 7)
	graph.add_edge(2, 8, 2)
	graph.add_edge(2, 5, 4)
	graph.add_edge(3, 4, 9)
	graph.add_edge(3, 5, 14)
	graph.add_edge(4, 5, 10)
	graph.add_edge(5, 6, 2)
	graph.add_edge(6, 7, 1)
	graph.add_edge(6, 8, 6)
	graph.add_edge(7, 8, 7)
	graph.show_graph()
	graph.dijkstra(0)
	graph.show_path(0, 4)

# OUTPUT
# 0 -> 1(4) -> 7(8)
# 1 -> 0(4) -> 2(8) -> 7(11)
# 7 -> 0(8) -> 1(11) -> 6(1) -> 8(7)
# 2 -> 1(8) -> 3(7) -> 8(2) -> 5(4)
# 3 -> 2(7) -> 4(9) -> 5(14)
# 8 -> 2(2) -> 6(6) -> 7(7)
# 5 -> 2(4) -> 3(14) -> 4(10) -> 6(2)
# 4 -> 3(9) -> 5(10)
# 6 -> 5(2) -> 7(1) -> 8(6)
# Distance from node: 0
# Node 0 has distance: 0
# Node 1 has distance: 4
# Node 2 has distance: 12
# Node 3 has distance: 19
# Node 4 has distance: 21
# Node 5 has distance: 11
# Node 6 has distance: 9
# Node 7 has distance: 8
# Node 8 has distance: 14
# ----Path to reach 4 from 0----
# 0 -> 7 -> 6 -> 5 -> 4
# Total cost of path:  21






def      A_ (		__a       :			int						):

				"""simple docstring"""
				if number != int(__a						):
								raise ValueError("""factorial() only accepts integral values"""						)
				if number < 0:
								raise ValueError("""factorial() not defined for negative values"""						)
				a__			 =						1
				for i in range(1	,						number + 1						):
								value *= i
				return value

def      A_ (		__a       :			int						):

				"""simple docstring"""
				if not isinstance(__a	,						__a						):
								raise ValueError("""factorial() only accepts integral values"""						)
				if n < 0:
								raise ValueError("""factorial() not defined for negative values"""						)
				return 1 if n == 0 or n == 1 else n * factorial(n - 1						)


if __name__ == "__main__":
	import doctest

	doctest.testmod()

	UpperCAmelCase								=   int(input("""Enter a positive integer: """).strip() or 0)
	print(f"""factorial{n} is {factorial(n)}""")

