





import unittest

import numpy as np
import torch

from diffusers import KarrasVePipeline, KarrasVeScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class   snake_case_							(						unittest.TestCase		):






  @property
  def  UpperCAmelCase__		(				self					:	Union[str, Any]     )->Union[str, Any]:






   '''simple docstring'''

   torch.manual_seed(0     )
   __lowerCAmelCase	:			Optional[Any]         =  UNetaDModel(
       block_out_channels=(32, 64)  ,    layers_per_block=2  ,    sample_size=32  ,    in_channels=3  ,    out_channels=3  ,    down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")  ,    up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")  ,    )
   return model






  def  UpperCAmelCase__		(				self					:	int     )->List[Any]:






   '''simple docstring'''

   __lowerCAmelCase	:			int         =  self.dummy_uncond_unet
   __lowerCAmelCase	:			Union[str, Any]         =  KarrasVeScheduler()

   __lowerCAmelCase	:			Tuple         =  KarrasVePipeline(unet=_snake_case  ,    scheduler=_snake_case     )
   pipe.to(_snake_case     )
   pipe.set_progress_bar_config(disable=_snake_case     )

   __lowerCAmelCase	:			Dict         =  torch.manual_seed(0     )
   __lowerCAmelCase	:			Union[str, Any]         =  pipe(num_inference_steps=2  ,    generator=_snake_case  ,    output_type="""numpy"""     ).images

   __lowerCAmelCase	:			Optional[Any]         =  torch.manual_seed(0     )
   __lowerCAmelCase	:			List[Any]         =  pipe(num_inference_steps=2  ,    generator=_snake_case  ,    output_type="""numpy"""  ,    return_dict=_snake_case     )[0]

   __lowerCAmelCase	:			str         =  image[0, -3:, -3:, -1]
   __lowerCAmelCase	:			Dict         =  image_from_tuple[0, -3:, -3:, -1]

   assert image.shape == (1, 32, 32, 3)
   __lowerCAmelCase	:			Optional[Any]         =  np.array([0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]     )

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






@slow
@require_torch
class   snake_case_							(						unittest.TestCase		):






  def  UpperCAmelCase__		(				self					:	Dict     )->Any:






   '''simple docstring'''

   __lowerCAmelCase	:			Tuple         =  "google/ncsnpp-celebahq-256"
   __lowerCAmelCase	:			List[Any]         =  UNetaDModel.from_pretrained(_snake_case     )
   __lowerCAmelCase	:			Tuple         =  KarrasVeScheduler()

   __lowerCAmelCase	:			List[Any]         =  KarrasVePipeline(unet=_snake_case  ,    scheduler=_snake_case     )
   pipe.to(_snake_case     )
   pipe.set_progress_bar_config(disable=_snake_case     )

   __lowerCAmelCase	:			Tuple         =  torch.manual_seed(0     )
   __lowerCAmelCase	:			Optional[int]         =  pipe(num_inference_steps=20  ,    generator=_snake_case  ,    output_type="""numpy"""     ).images

   __lowerCAmelCase	:			Any         =  image[0, -3:, -3:, -1]
   assert image.shape == (1, 256, 256, 3)
   __lowerCAmelCase	:			str         =  np.array([0.578, 0.5_811, 0.5_924, 0.5_809, 0.587, 0.5_886, 0.5_861, 0.5_802, 0.586]     )

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






from collections import defaultdict


class        __magic_name__	:





     """simple docstring"""



     def __init__(				self							:int      ,   snake_case							:Dict      ,   snake_case							:Optional[Any]	):





        '''simple docstring'''




        A_       :					Optional[int]        =      total  # total no of tasks (N)

        # DP table will have a dimension of (2^M)*N
        # initially all values are set to -1
        A_       :					str        =      [
            [-1 for i in range(total + 1	)] for j in range(2 ** len(snake_case	)	)
        ]

        A_       :					Optional[int]        =      defaultdict(snake_case	)  # stores the list of persons for each task

        # final_mask is used to check if all persons are included by setting all bits
        # to 1
        A_       :					Dict        =      (1 << len(snake_case	)) - 1



     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]      ,   snake_case							:Union[str, Any]      ,   snake_case							:str	):





        '''simple docstring'''




        if mask == self.final_mask:
           return 1

        # if not everyone gets the task and no more tasks are available, return 0
        if task_no > self.total_tasks:
           return 0

        # if case already considered
        if self.dp[mask][task_no] != -1:
           return self.dp[mask][task_no]

        # Number of ways when we don't this task in the arrangement
        A_       :					Tuple        =      self.count_ways_until(snake_case      ,   task_no + 1	)

        # now assign the tasks one by one to all possible persons and recursively
        # assign for the remaining tasks.
        if task_no in self.task:
           for p in self.task[task_no]:
              # if p is already given a task
              if mask & (1 << p):
                 continue

              # assign this task to p and change the mask value. And recursively
              # assign tasks with the new mask value.
              total_ways_util += self.count_ways_until(mask | (1 << p)      ,   task_no + 1	)

        # save the value.
        A_       :					Any        =      total_ways_util

        return self.dp[mask][task_no]





     def     SCREAMING_SNAKE_CASE		(				self							:int      ,   snake_case							:List[str]	):





        '''simple docstring'''




        for i in range(len(snake_case	)	):
           for j in task_performed[i]:
              self.task[j].append(snake_case	)

        # call the function to fill the DP table, final answer is stored in dp[0][1]
        return self.count_ways_until(0      ,   1	)


if __name__ == "__main__":
 _lowerCAmelCase				:   Dict						       =						5  # total no of tasks (the value of N)

 # the list of tasks that can be done by M persons.
 _lowerCAmelCase				:   str						       =						[[1, 3, 4], [1, 2, 5], [3, 4]]
 print(
     AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
         task_performed
     )
 )
