code: 
  
  
  
  
  
  
  snake_case_    						=				float('''inf''')
  
  
  class    SCREAMING_SNAKE_CASE__      :
  
  
  
  
  
      def __init__(   self		,     a):
           lowercase__					:     List[Any]   = [0] * n
           lowercase__					:     Any   = [0] * n
           lowercase__					:     Tuple   = [0] * n
           lowercase__					:     int   = [[] for _ in range(__a)]
  
  
  
  
  
      def    snake_case_       (   self		,     a		,     a		,     a		,     a=0):
           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):
  
  
  
  
  
           if vertex == sink or not flow:
                return flow
  
           for i in range(self.ptr[vertex]		,     len(self.adj[vertex])):
                lowercase__					:     List[Any]   = self.adj[vertex][i]
                if self.lvl[e[0]] == self.lvl[vertex] + 1:
                     lowercase__					:     Optional[int]   = 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
                lowercase__					:     int   = self.ptr[vertex] + 1
           return 0
  
  
  
  
  
      def    snake_case_       (   self		,     a		,     a):
           lowercase__					:     Optional[int]   = 0, source
           for l in range(31):  # noqa: E741  l = 30 maybe faster for random data
                while True:
                     lowercase__					:     List[str]   = [0] * len(self.q), [0] * len(self.q)
                     lowercase__					:     List[Any]   = 0, 1, 1
                     while qi < qe and not self.lvl[sink]:
                          lowercase__					:     Optional[int]   = self.q[qi]
                          qi += 1
                          for e in self.adj[v]:
                               if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
                                    lowercase__					:     Optional[Any]   = e[0]
                                    qe += 1
                                    lowercase__					:     List[Any]   = self.lvl[v] + 1
  
                     lowercase__					:     Tuple   = self.depth_first_search(__a		,     __a		,     __a)
                     while p:
                          flow += p
                          lowercase__					:     Optional[Any]   = self.depth_first_search(__a		,     __a		,     __a)
  
                     if not self.lvl[sink]:
                          break
  
           return flow
  
  
  
  snake_case_    						=				Dinic(10)
  snake_case_    						=				0
  snake_case_    						=				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: 
  
  from transformers.models.cpm.tokenization_cpm import CpmTokenizer
  from transformers.testing_utils import custom_tokenizers
  
  from ..xlnet.test_modeling_xlnet import XLNetModelTest
  
  
  @custom_tokenizers
  class    SCREAMING_SNAKE_CASE__      (__snake_case  ):
  
  
  
  
  
      def    snake_case_       (   self		,     a		,     a		,     a		,     a		,     a):
           return True
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     Tuple   = CpmTokenizer.from_pretrained('TsinghuaAI/CPM-Generate')
           lowercase__					:     str   = 'Hugging Face大法好，谁用谁知道。'
           lowercase__					:     Optional[int]   = 'Hugging Face大法好,谁用谁知道。<unk>'
           lowercase__					:     Any   = '▁Hu gg ing ▁ ▂ ▁F ace ▁大法 ▁好 ▁ , ▁谁 ▁用 ▁谁 ▁知 道 ▁ 。'.split()
  
           lowercase__					:     Any   = tokenizer.tokenize(a)
           self.assertListEqual(a		,     a)
  
           lowercase__					:     List[Any]   = tokens + [tokenizer.unk_token]
  
           lowercase__					:     Any   = [1_3789, 1_3283, 1421, 8, 10, 1164, 1_3608, 1_6528, 63, 8, 9, 440, 108, 440, 121, 90, 8, 12, 0]
           self.assertListEqual(tokenizer.convert_tokens_to_ids(a)		,     a)
  
           lowercase__					:     Optional[Any]   = tokenizer.decode(a)
           self.assertEqual(a		,     a)
  
  