





'''simple docstring'''
a_					=	[
    [0, 1_6, 1_3, 0, 0, 0],
    [0, 0, 1_0, 1_2, 0, 0],
    [0, 4, 0, 0, 1_4, 0],
    [0, 0, 9, 0, 0, 2_0],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]





def 	_a(					UpperCamelCase__			:  Dict,		UpperCamelCase__			:  Optional[int],		UpperCamelCase__			:  List[str],		UpperCamelCase__			:  Union[str, Any]							):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__       :			Any													=[False] * len(_a							)
      SCREAMING_SNAKE_CASE__       :			Optional[Any]													=[s]
      SCREAMING_SNAKE_CASE__       :			Any													=True

      while queue:
            SCREAMING_SNAKE_CASE__       :			Tuple													=queue.pop(0							)
            for ind in range(len(graph[u]							)							):
                  if visited[ind] is False and graph[u][ind] > 0:
                        queue.append(_a							)
                        SCREAMING_SNAKE_CASE__       :			Dict													=True
                        SCREAMING_SNAKE_CASE__       :			Any													=u

      return visited[t]





def 	_a(					UpperCamelCase__			:  Any,		UpperCamelCase__			:  Dict,		UpperCamelCase__			:  str							):




      '''simple docstring'''






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

            while s != source:
                  # Find the minimum value in select path
                  SCREAMING_SNAKE_CASE__       :			List[str]													=min(_a,		graph[parent[s]][s]							)
                  SCREAMING_SNAKE_CASE__       :			int													=parent[s]

            max_flow += path_flow
            SCREAMING_SNAKE_CASE__       :			int													=sink

            while v != source:
                  SCREAMING_SNAKE_CASE__       :			List[Any]													=parent[v]
                  graph[u][v] -= path_flow
                  graph[v][u] += path_flow
                  SCREAMING_SNAKE_CASE__       :			Any													=parent[v]

      for i in range(len(_a							)							):
            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'''
import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()






@slow
@require_torch_gpu
class        __SCREAMING_SNAKE_CASE (     unittest.TestCase			):




 def        __magic_name__		( self		:							List[str] )		->  Optional[Any]:
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()




 def        __magic_name__		( self		:							Union[str, Any] )		->  Dict:
       SCREAMING_SNAKE_CASE__       :			Optional[int]													=StableDiffusionKDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4''' )
       SCREAMING_SNAKE_CASE__       :			str													=sd_pipe.to(__lowercase )
       sd_pipe.set_progress_bar_config(disable=__lowercase )

       sd_pipe.set_scheduler('''sample_euler''' )

       SCREAMING_SNAKE_CASE__       :			List[Any]													='''A painting of a squirrel eating a burger'''
       SCREAMING_SNAKE_CASE__       :			List[str]													=torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=sd_pipe([prompt]   , generator=__lowercase   , guidance_scale=9.0   , num_inference_steps=20   , output_type='''np''' )

       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=output.images

       SCREAMING_SNAKE_CASE__       :			int													=image[0, -3:, -3:, -1]

       assert image.shape == (1, 5_12, 5_12, 3)
       SCREAMING_SNAKE_CASE__       :			Any													=np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2




 def        __magic_name__		( self		:							List[str] )		->  List[Any]:
       SCREAMING_SNAKE_CASE__       :			List[str]													=StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''' )
       SCREAMING_SNAKE_CASE__       :			int													=sd_pipe.to(__lowercase )
       sd_pipe.set_progress_bar_config(disable=__lowercase )

       sd_pipe.set_scheduler('''sample_euler''' )

       SCREAMING_SNAKE_CASE__       :			Any													='''A painting of a squirrel eating a burger'''
       SCREAMING_SNAKE_CASE__       :			Dict													=torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__       :			Tuple													=sd_pipe([prompt]   , generator=__lowercase   , guidance_scale=9.0   , num_inference_steps=20   , output_type='''np''' )

       SCREAMING_SNAKE_CASE__       :			Dict													=output.images

       SCREAMING_SNAKE_CASE__       :			Dict													=image[0, -3:, -3:, -1]

       assert image.shape == (1, 5_12, 5_12, 3)
       SCREAMING_SNAKE_CASE__       :			List[str]													=np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-1




 def        __magic_name__		( self		:							List[str] )		->  List[Any]:
       SCREAMING_SNAKE_CASE__       :			Any													=StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''' )
       SCREAMING_SNAKE_CASE__       :			Tuple													=sd_pipe.to(__lowercase )
       sd_pipe.set_progress_bar_config(disable=__lowercase )

       sd_pipe.set_scheduler('''sample_dpmpp_2m''' )

       SCREAMING_SNAKE_CASE__       :			Tuple													='''A painting of a squirrel eating a burger'''
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__       :			List[Any]													=sd_pipe(
           [prompt]   , generator=__lowercase   , guidance_scale=7.5   , num_inference_steps=15   , output_type='''np'''   , use_karras_sigmas=__lowercase   , )

       SCREAMING_SNAKE_CASE__       :			Optional[int]													=output.images

       SCREAMING_SNAKE_CASE__       :			Dict													=image[0, -3:, -3:, -1]

       assert image.shape == (1, 5_12, 5_12, 3)
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=np.array(
           [0.11381689, 0.12112921, 0.1389457, 0.12549606, 0.1244964, 0.10831517, 0.11562866, 0.10867816, 0.10499048] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2