"""simple docstring"""





__A  =				[
    [0, 16, 13, 0, 0, 0],
    [0, 0, 10, 12, 0, 0],
    [0, 4, 0, 0, 14, 0],
    [0, 0, 9, 0, 0, 20],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]


def    lowercase_   (   _lowerCamelCase:	str						,   _lowerCamelCase:	str						,   _lowerCamelCase:	Tuple						,   _lowerCamelCase:	List[Any]      ) ->      Optional[Any]:



       '''simple docstring'''

       __lowerCamelCase					:		Tuple		   =     [False] * len(_lowerCamelCase      )
       __lowerCamelCase					:		Optional[int]		   =     [s]
       __lowerCamelCase					:		Dict		   =     True

       while queue:
              __lowerCamelCase					:		Union[str, Any]		   =     queue.pop(0      )
              for ind in range(len(graph[u]      )      ):
                     if visited[ind] is False and graph[u][ind] > 0:
                            queue.append(_lowerCamelCase      )
                            __lowerCamelCase					:		Any		   =     True
                            __lowerCamelCase					:		str		   =     u

       return visited[t]


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]						,   _lowerCamelCase:	List[str]						,   _lowerCamelCase:	int      ) ->      Dict:



       '''simple docstring'''

       __lowerCamelCase					:		Dict		   =     [-1] * (len(_lowerCamelCase      ))
       __lowerCamelCase					:		Union[str, Any]		   =     0
       __lowerCamelCase					:		Optional[Any]		   =     []
       __lowerCamelCase					:		int		   =     [i[:] for i in graph]  # Record original cut, copy.
       while bfs(_lowerCamelCase						,   _lowerCamelCase						,   _lowerCamelCase						,   _lowerCamelCase      ):
              __lowerCamelCase					:		Union[str, Any]		   =     float("Inf"      )
              __lowerCamelCase					:		Any		   =     sink

              while s != source:
                     # Find the minimum value in select path
                     __lowerCamelCase					:		Optional[int]		   =     min(_lowerCamelCase						,   graph[parent[s]][s]      )
                     __lowerCamelCase					:		Dict		   =     parent[s]

              max_flow += path_flow
              __lowerCamelCase					:		Union[str, Any]		   =     sink

              while v != source:
                     __lowerCamelCase					:		Optional[int]		   =     parent[v]
                     graph[u][v] -= path_flow
                     graph[v][u] += path_flow
                     __lowerCamelCase					:		Optional[int]		   =     parent[v]

       for i in range(len(_lowerCamelCase      )      ):
              for j in range(len(graph[0]      )      ):
                     if graph[i][j] == 0 and temp[i][j] > 0:
                            res.append((i, j)      )

       return res


if __name__ == "__main__":
    print(mincut(test_graph, source=0, sink=5))
"""simple docstring"""





from functools import lru_cache


def    lowercase_   (   _lowerCamelCase:	int      ) ->      set:



							'''simple docstring'''

							__lowerCamelCase					:		Optional[Any]		   =     2
							__lowerCamelCase					:		Tuple		   =     set()
							while i * i <= n:
														if n % i:
																					i += 1
														else:
																					n //= i
																					factors.add(_lowerCamelCase      )
							if n > 1:
														factors.add(_lowerCamelCase      )
							return factors


@lru_cache
def    lowercase_   (   _lowerCamelCase:	int      ) ->      int:



							'''simple docstring'''

							return len(unique_prime_factors(_lowerCamelCase      )      )


def    lowercase_   (   _lowerCamelCase:	list      ) ->      bool:



							'''simple docstring'''

							return len(set(_lowerCamelCase      )      ) in (0, 1)


def    lowercase_   (   _lowerCamelCase:	int      ) ->      list:



							'''simple docstring'''

							__lowerCamelCase					:		str		   =     2

							while True:
														# Increment each value of a generated range
														__lowerCamelCase					:		int		   =     [base + i for i in range(_lowerCamelCase      )]

														# Run elements through out unique_prime_factors function
														# Append our target number to the end.
														__lowerCamelCase					:		Dict		   =     [upf_len(_lowerCamelCase      ) for x in group]
														checker.append(_lowerCamelCase      )

														# If all numbers in the list are equal, return the group variable.
														if equality(_lowerCamelCase      ):
																					return group

														# Increment our base variable by 1
														base += 1


def    lowercase_   (   _lowerCamelCase:	int = 4      ) ->      int:



							'''simple docstring'''

							__lowerCamelCase					:		Any		   =     run(_lowerCamelCase      )
							return results[0] if len(_lowerCamelCase      ) else None


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