code: 
  
  
  
  
  
  '''simple docstring'''
  
  lowercase_			       =				float("""inf""")
  
  
  class       a_  :
  
      '''simple docstring'''
  
  
      def __init__(	self				,	A )	->     Optional[Any]:
          _SCREAMING_SNAKE_CASE             =    [0] * n
          _SCREAMING_SNAKE_CASE             =    [0] * n
          _SCREAMING_SNAKE_CASE             =    [0] * n
          _SCREAMING_SNAKE_CASE             =    [[] for _ in range(A )]
  
  
      def     snake_case_(	self				,	A				,	A				,	A				,	A=0 )	->     Optional[int]:
          self.adj[a].append([b, len(self.adj[b] ), c, 0] )
          self.adj[b].append([a, len(self.adj[a] ) - 1, rcap, 0] )
  
  
      def     snake_case_(	self				,	A				,	A				,	A )	->     Optional[Any]:
          if vertex == sink or not flow:
              return flow
  
          for i in range(self.ptr[vertex]				,	len(self.adj[vertex] ) ):
              _SCREAMING_SNAKE_CASE             =    self.adj[vertex][i]
              if self.lvl[e[0]] == self.lvl[vertex] + 1:
                  _SCREAMING_SNAKE_CASE             =    self.depth_first_search(e[0]				,	A				,	min(A				,	e[2] - e[3] ) )
                  if p:
                      self.adj[vertex][i][3] += p
                      self.adj[e[0]][e[1]][3] -= p
                      return p
              _SCREAMING_SNAKE_CASE             =    self.ptr[vertex] + 1
          return 0
  
  
  
  
  
      def     snake_case_(	self				,	A				,	A )	->     List[str]:
          _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    0, source
          for l in range(31 ):  # noqa: E741  l = 30 maybe faster for random data
              while True:
                  _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    [0] * len(self.q ), [0] * len(self.q )
                  _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    0, 1, 1
                  while qi < qe and not self.lvl[sink]:
                      _SCREAMING_SNAKE_CASE             =    self.q[qi]
                      qi += 1
                      for e in self.adj[v]:
                          if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
                              _SCREAMING_SNAKE_CASE             =    e[0]
                              qe += 1
                              _SCREAMING_SNAKE_CASE             =    self.lvl[v] + 1
  
                  _SCREAMING_SNAKE_CASE             =    self.depth_first_search(A				,	A				,	A )
                  while p:
                      flow += p
                      _SCREAMING_SNAKE_CASE             =    self.depth_first_search(A				,	A				,	A )
  
                  if not self.lvl[sink]:
                      break
  
          return flow
  
  
  
  
  lowercase_			       =				Dinic(10)
  lowercase_			       =				0
  lowercase_			       =				9
  for vertex in range(1, 5):
        graph.add_edge(source, vertex, 1)
  for vertex in range(5, 9):
        graph.add_edge(vertex, sink, 1)
  for vertex in range(1, 5):
        graph.add_edge(vertex, vertex + 4, 1)
  
  # Now we can know that is the maximum flow(source -> sink)
  print(graph.max_flow(source, sink))
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  def lowerCamelCase		(  __lowerCamelCase				:					int = 10**6					)		->int:
  
      if n <= 0:
          raise ValueError("""Please enter an integer greater than 0"""					)
  
      _SCREAMING_SNAKE_CASE             =    list(range(n + 1					)					)
      for number in range(2      , n + 1					):
          if phi[number] == number:
              phi[number] -= 1
              for multiple in range(number * 2      , n + 1      , __lowerCamelCase					):
                  _SCREAMING_SNAKE_CASE             =    (phi[multiple] // number) * (number - 1)
  
      _SCREAMING_SNAKE_CASE             =    1
      for number in range(1      , n + 1					):
          if (answer / phi[answer]) < (number / phi[number]):
              _SCREAMING_SNAKE_CASE             =    number
  
      return answer
  
  
  if __name__ == "__main__":
        print(solution())
  
  
  
  