



"""simple docstring"""






from dataclasses import dataclass
from typing import Dict, Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .attention_processor import AttentionProcessor, AttnProcessor
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder

@dataclass
class 	__SCREAMING_SNAKE_CASE     (				lowerCAmelCase_       ):


					'''simple docstring'''





					_a             =							4_2





class 	__SCREAMING_SNAKE_CASE     (				lowerCAmelCase_		,       lowerCAmelCase_       ):


					'''simple docstring'''





					_a             =							True



					@register_to_config
					def __init__(	self							:  Union[str, Any],  lowerCamelCase							:  int = 3,  lowerCamelCase							:  int = 3,  lowerCamelCase							:  Tuple[str] = ("DownEncoderBlock2D",),  lowerCamelCase							:  Tuple[str] = ("UpDecoderBlock2D",),  lowerCamelCase							:  Tuple[int] = (64,),  lowerCamelCase							:  int = 1,  lowerCamelCase							:  str = "silu",  lowerCamelCase							:  int = 4,  lowerCamelCase							:  int = 32,  lowerCamelCase							:  int = 32,  lowerCamelCase							:  float = 0.18_215,  )-> Any:
								super().__init__()

								# pass init params to Encoder
								lowerCamelCase__		:		Union[str, Any]		     =Encoder(
								    in_channels=lowerCamelCase,  out_channels=lowerCamelCase,  down_block_types=lowerCamelCase,  block_out_channels=lowerCamelCase,  layers_per_block=lowerCamelCase,  act_fn=lowerCamelCase,  norm_num_groups=lowerCamelCase,  double_z=lowerCamelCase,  )

								# pass init params to Decoder
								lowerCamelCase__		:		int		     =Decoder(
								    in_channels=lowerCamelCase,  out_channels=lowerCamelCase,  up_block_types=lowerCamelCase,  block_out_channels=lowerCamelCase,  layers_per_block=lowerCamelCase,  norm_num_groups=lowerCamelCase,  act_fn=lowerCamelCase,  )

								lowerCamelCase__		:		List[Any]		     =nn.Convad(2 * latent_channels,  2 * latent_channels,  1					)
								lowerCamelCase__		:		Tuple		     =nn.Convad(lowerCamelCase,  lowerCamelCase,  1					)

								lowerCamelCase__		:		str		     =False
								lowerCamelCase__		:		Optional[Any]		     =False

								# only relevant if vae tiling is enabled
								lowerCamelCase__		:		str		     =self.config.sample_size
								lowerCamelCase__		:		Any		     =(
								    self.config.sample_size[0]
								    if isinstance(self.config.sample_size,  (list, tuple)					)
								    else self.config.sample_size
								)
								lowerCamelCase__		:		Optional[int]		     =int(sample_size / (2 ** (len(self.config.block_out_channels					) - 1))					)
								lowerCamelCase__		:		List[Any]		     =0.25



					def 		snake_case	(	self							:  List[Any],  lowerCamelCase							:  Optional[int],  lowerCamelCase							:  Union[str, Any]=False					)-> Optional[Any]:
								if isinstance(lowerCamelCase,  (Encoder, Decoder)					):
											lowerCamelCase__		:		Tuple		     =value



					def 		snake_case	(	self							:  str,  lowerCamelCase							:  bool = True					)-> Tuple:
								lowerCamelCase__		:		str		     =use_tiling



					def 		snake_case	(	self							:  int					)-> Optional[int]:
								self.enable_tiling(lowerCamelCase					)



					def 		snake_case	(	self							:  Optional[Any]					)-> Any:
								lowerCamelCase__		:		str		     =True



					def 		snake_case	(	self							:  Optional[Any]					)-> int:
								lowerCamelCase__		:		int		     =False



					@property
					# Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
					def 		snake_case	(	self							:  List[str]					)-> Dict[str, AttentionProcessor]:
								lowerCamelCase__		:		str		     ={}

								def fn_recursive_add_processors(lowerCamelCase							:  str,  lowerCamelCase							:  torch.nn.Module,  lowerCamelCase							:  Dict[str, AttentionProcessor]					):
											if hasattr(lowerCamelCase,  '''set_processor'''					):
														lowerCamelCase__		:		Optional[int]		     =module.processor

											for sub_name, child in module.named_children():
														fn_recursive_add_processors(F'''{name}.{sub_name}''',  lowerCamelCase,  lowerCamelCase					)

											return processors

								for name, module in self.named_children():
											fn_recursive_add_processors(lowerCamelCase,  lowerCamelCase,  lowerCamelCase					)

								return processors



					def 		snake_case	(	self							:  str,  lowerCamelCase							:  Union[AttentionProcessor, Dict[str, AttentionProcessor]]					)-> Any:
								lowerCamelCase__		:		Any		     =len(self.attn_processors.keys()					)

								if isinstance(lowerCamelCase,  lowerCamelCase					) and len(lowerCamelCase					) != count:
											raise ValueError(
											    F'''A dict of processors was passed, but the number of processors {len(lowerCamelCase					)} does not match the'''
											    F''' number of attention layers: {count}. Please make sure to pass {count} processor classes.'''					)

								def fn_recursive_attn_processor(lowerCamelCase							:  str,  lowerCamelCase							:  torch.nn.Module,  lowerCamelCase							:  str					):
											if hasattr(lowerCamelCase,  '''set_processor'''					):
														if not isinstance(lowerCamelCase,  lowerCamelCase					):
																	module.set_processor(lowerCamelCase					)
														else:
																	module.set_processor(processor.pop(F'''{name}.processor'''					)					)

											for sub_name, child in module.named_children():
														fn_recursive_attn_processor(F'''{name}.{sub_name}''',  lowerCamelCase,  lowerCamelCase					)

								for name, module in self.named_children():
											fn_recursive_attn_processor(lowerCamelCase,  lowerCamelCase,  lowerCamelCase					)



					def 		snake_case	(	self							:  Tuple					)-> Union[str, Any]:
								self.set_attn_processor(AttnProcessor()					)



					@apply_forward_hook
					def 		snake_case	(	self							:  Any,  lowerCamelCase							:  torch.FloatTensor,  lowerCamelCase							:  bool = True					)-> AutoencoderKLOutput:
								if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size):
											return self.tiled_encode(lowerCamelCase,  return_dict=lowerCamelCase					)

								if self.use_slicing and x.shape[0] > 1:
											lowerCamelCase__		:		Dict		     =[self.encoder(lowerCamelCase					) for x_slice in x.split(1					)]
											lowerCamelCase__		:		Tuple		     =torch.cat(lowerCamelCase					)
								else:
											lowerCamelCase__		:		List[Any]		     =self.encoder(lowerCamelCase					)

								lowerCamelCase__		:		Tuple		     =self.quant_conv(lowerCamelCase					)
								lowerCamelCase__		:		List[str]		     =DiagonalGaussianDistribution(lowerCamelCase					)

								if not return_dict:
											return (posterior,)

								return AutoencoderKLOutput(latent_dist=lowerCamelCase					)



					def 		snake_case	(	self							:  Union[str, Any],  lowerCamelCase							:  torch.FloatTensor,  lowerCamelCase							:  bool = True					)-> Union[DecoderOutput, torch.FloatTensor]:
								if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size):
											return self.tiled_decode(lowerCamelCase,  return_dict=lowerCamelCase					)

								lowerCamelCase__		:		List[str]		     =self.post_quant_conv(lowerCamelCase					)
								lowerCamelCase__		:		Tuple		     =self.decoder(lowerCamelCase					)

								if not return_dict:
											return (dec,)

								return DecoderOutput(sample=lowerCamelCase					)



					@apply_forward_hook
					def 		snake_case	(	self							:  str,  lowerCamelCase							:  torch.FloatTensor,  lowerCamelCase							:  bool = True					)-> Union[DecoderOutput, torch.FloatTensor]:
								if self.use_slicing and z.shape[0] > 1:
											lowerCamelCase__		:		Tuple		     =[self._decode(lowerCamelCase					).sample for z_slice in z.split(1					)]
											lowerCamelCase__		:		int		     =torch.cat(lowerCamelCase					)
								else:
											lowerCamelCase__		:		List[Any]		     =self._decode(lowerCamelCase					).sample

								if not return_dict:
											return (decoded,)

								return DecoderOutput(sample=lowerCamelCase					)



					def 		snake_case	(	self							:  Optional[Any],  lowerCamelCase							:  int,  lowerCamelCase							:  Optional[Any],  lowerCamelCase							:  str					)-> Any:
								lowerCamelCase__		:		Optional[Any]		     =min(a.shape[2],  b.shape[2],  lowerCamelCase					)
								for y in range(lowerCamelCase					):
											lowerCamelCase__		:		Optional[int]		     =a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent)
								return b



					def 		snake_case	(	self							:  List[str],  lowerCamelCase							:  List[Any],  lowerCamelCase							:  Optional[int],  lowerCamelCase							:  Tuple					)-> Tuple:
								lowerCamelCase__		:		Optional[Any]		     =min(a.shape[3],  b.shape[3],  lowerCamelCase					)
								for x in range(lowerCamelCase					):
											lowerCamelCase__		:		str		     =a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent)
								return b



					def 		snake_case	(	self							:  Union[str, Any],  lowerCamelCase							:  torch.FloatTensor,  lowerCamelCase							:  bool = True					)-> AutoencoderKLOutput:
								lowerCamelCase__		:		Union[str, Any]		     =int(self.tile_sample_min_size * (1 - self.tile_overlap_factor)					)
								lowerCamelCase__		:		List[str]		     =int(self.tile_latent_min_size * self.tile_overlap_factor					)
								lowerCamelCase__		:		str		     =self.tile_latent_min_size - blend_extent

								# Split the image into 512x512 tiles and encode them separately.
								lowerCamelCase__		:		List[Any]		     =[]
								for i in range(0,  x.shape[2],  lowerCamelCase					):
											lowerCamelCase__		:		Optional[int]		     =[]
											for j in range(0,  x.shape[3],  lowerCamelCase					):
														lowerCamelCase__		:		List[Any]		     =x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size]
														lowerCamelCase__		:		Optional[Any]		     =self.encoder(lowerCamelCase					)
														lowerCamelCase__		:		Optional[int]		     =self.quant_conv(lowerCamelCase					)
														row.append(lowerCamelCase					)
											rows.append(lowerCamelCase					)
								lowerCamelCase__		:		List[Any]		     =[]
								for i, row in enumerate(lowerCamelCase					):
											lowerCamelCase__		:		Tuple		     =[]
											for j, tile in enumerate(lowerCamelCase					):
														# blend the above tile and the left tile
														# to the current tile and add the current tile to the result row
														if i > 0:
																	lowerCamelCase__		:		Optional[Any]		     =self.blend_v(rows[i - 1][j],  lowerCamelCase,  lowerCamelCase					)
														if j > 0:
																	lowerCamelCase__		:		Dict		     =self.blend_h(row[j - 1],  lowerCamelCase,  lowerCamelCase					)
														result_row.append(tile[:, :, :row_limit, :row_limit]					)
											result_rows.append(torch.cat(lowerCamelCase,  dim=3					)					)

								lowerCamelCase__		:		str		     =torch.cat(lowerCamelCase,  dim=2					)
								lowerCamelCase__		:		Optional[Any]		     =DiagonalGaussianDistribution(lowerCamelCase					)

								if not return_dict:
											return (posterior,)

								return AutoencoderKLOutput(latent_dist=lowerCamelCase					)



					def 		snake_case	(	self							:  Dict,  lowerCamelCase							:  torch.FloatTensor,  lowerCamelCase							:  bool = True					)-> Union[DecoderOutput, torch.FloatTensor]:
								lowerCamelCase__		:		Any		     =int(self.tile_latent_min_size * (1 - self.tile_overlap_factor)					)
								lowerCamelCase__		:		List[str]		     =int(self.tile_sample_min_size * self.tile_overlap_factor					)
								lowerCamelCase__		:		Dict		     =self.tile_sample_min_size - blend_extent

								# Split z into overlapping 64x64 tiles and decode them separately.
								# The tiles have an overlap to avoid seams between tiles.
								lowerCamelCase__		:		int		     =[]
								for i in range(0,  z.shape[2],  lowerCamelCase					):
											lowerCamelCase__		:		List[str]		     =[]
											for j in range(0,  z.shape[3],  lowerCamelCase					):
														lowerCamelCase__		:		Any		     =z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size]
														lowerCamelCase__		:		Tuple		     =self.post_quant_conv(lowerCamelCase					)
														lowerCamelCase__		:		Optional[int]		     =self.decoder(lowerCamelCase					)
														row.append(lowerCamelCase					)
											rows.append(lowerCamelCase					)
								lowerCamelCase__		:		Tuple		     =[]
								for i, row in enumerate(lowerCamelCase					):
											lowerCamelCase__		:		Any		     =[]
											for j, tile in enumerate(lowerCamelCase					):
														# blend the above tile and the left tile
														# to the current tile and add the current tile to the result row
														if i > 0:
																	lowerCamelCase__		:		Tuple		     =self.blend_v(rows[i - 1][j],  lowerCamelCase,  lowerCamelCase					)
														if j > 0:
																	lowerCamelCase__		:		Union[str, Any]		     =self.blend_h(row[j - 1],  lowerCamelCase,  lowerCamelCase					)
														result_row.append(tile[:, :, :row_limit, :row_limit]					)
											result_rows.append(torch.cat(lowerCamelCase,  dim=3					)					)

								lowerCamelCase__		:		Optional[Any]		     =torch.cat(lowerCamelCase,  dim=2					)
								if not return_dict:
											return (dec,)

								return DecoderOutput(sample=lowerCamelCase					)




					def 		snake_case	(	self							:  Any,  lowerCamelCase							:  torch.FloatTensor,  lowerCamelCase							:  bool = False,  lowerCamelCase							:  bool = True,  lowerCamelCase							:  Optional[torch.Generator] = None,  )-> Union[DecoderOutput, torch.FloatTensor]:
								lowerCamelCase__		:		Union[str, Any]		     =sample
								lowerCamelCase__		:		Union[str, Any]		     =self.encode(lowerCamelCase					).latent_dist
								if sample_posterior:
											lowerCamelCase__		:		str		     =posterior.sample(generator=lowerCamelCase					)
								else:
											lowerCamelCase__		:		List[Any]		     =posterior.mode()
								lowerCamelCase__		:		Optional[int]		     =self.decode(lowerCamelCase					).sample

								if not return_dict:
											return (dec,)

								return DecoderOutput(sample=lowerCamelCase					)









"""simple docstring"""






from collections import defaultdict

class 	__SCREAMING_SNAKE_CASE     :


					'''simple docstring'''





					def __init__(	self							:  Union[str, Any],  lowerCamelCase							:  List[Any],  lowerCamelCase							:  List[str]					)-> Optional[int]:
								lowerCamelCase__		:		List[Any]		     =total  # total no of tasks (N)

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

								lowerCamelCase__		:		Any		     =defaultdict(lowerCamelCase					)  # 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
								lowerCamelCase__		:		List[Any]		     =(1 << len(lowerCamelCase					)) - 1



					def 		snake_case	(	self							:  int,  lowerCamelCase							:  str,  lowerCamelCase							:  Any					)-> Any:
								# if mask == self.finalmask all persons are distributed tasks, return 1
								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
								lowerCamelCase__		:		Optional[int]		     =self.count_ways_until(lowerCamelCase,  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.
								lowerCamelCase__		:		int		     =total_ways_util

								return self.dp[mask][task_no]




					def 		snake_case	(	self							:  Dict,  lowerCamelCase							:  Dict					)-> int:
								# Store the list of persons for each task
								for i in range(len(lowerCamelCase					)					):
											for j in task_performed[i]:
														self.task[j].append(lowerCamelCase					)

        # 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__":
		_lowercase			:			Tuple										=						5  # total no of tasks (the value of N)

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




