






from collections import defaultdict
class 		SCREAMING_SNAKE_CASE__	:

  '''simple docstring'''







  def __init__(      self		:			List[Any]       ,				lowerCamelCase		:			Any       ,				lowerCamelCase		:			Tuple							)						->	Dict:


         """simple docstring"""
         _UpperCAmelCase							=    total  # total no of tasks (N)

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

         _UpperCAmelCase							=    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
         _UpperCAmelCase							=    (1 << len(lowerCamelCase							)) - 1


  def  lowerCamelCase       (      self		:			Tuple       ,				lowerCamelCase		:			Any       ,				lowerCamelCase		:			Any							)						->	List[Any]:


         """simple docstring"""
         # 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
         _UpperCAmelCase							=    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.
         _UpperCAmelCase							=    total_ways_util

         return self.dp[mask][task_no]





  def  lowerCamelCase       (      self		:			List[Any]       ,				lowerCamelCase		:			Tuple							)						->	Optional[int]:


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

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







from typing import List, Optional

from tokenizers import ByteLevelBPETokenizer

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_blenderbot_small import BlenderbotSmallTokenizer


__a:     Union[str, Any]   					=					logging.get_logger(__name__)

__a:     str   					=					{
    '''vocab_file''': '''vocab.json''',
    '''merges_file''': '''merges.txt''',
    '''tokenizer_config_file''': '''tokenizer_config.json''',
}

__a:     Dict   					=					{
    '''vocab_file''': {
        '''facebook/blenderbot_small-90M''': '''https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/vocab.json'''
    },
    '''merges_file''': {
        '''facebook/blenderbot_small-90M''': '''https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/merges.txt'''
    },
    '''tokenizer_config_file''': {
        '''facebook/blenderbot_small-90M''': (
            '''https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/tokenizer_config.json'''
        )
    },
}

__a:     Union[str, Any]   					=					{
    '''facebook/blenderbot_small-90M''': 512,
}
class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase     ):

  '''simple docstring'''







  _lowerCamelCase    =  VOCAB_FILES_NAMES
  _lowerCamelCase    =  PRETRAINED_VOCAB_FILES_MAP
  _lowerCamelCase    =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  _lowerCamelCase    =  BlenderbotSmallTokenizer


  def __init__(      self		:			List[str]       ,				lowerCamelCase		:			List[str]=None       ,				lowerCamelCase		:			str=None       ,				lowerCamelCase		:			Optional[Any]="<|endoftext|>"       ,				lowerCamelCase		:			Dict="<|endoftext|>"       ,				lowerCamelCase		:			str="<|endoftext|>"       ,				lowerCamelCase		:			str=False       ,				lowerCamelCase		:			Tuple=True       ,				**lowerCamelCase		:			List[str]       ,				)						->	List[Any]:


         """simple docstring"""
         super().__init__(
             ByteLevelBPETokenizer(
                 vocab=lowerCamelCase       ,				merges=lowerCamelCase       ,				add_prefix_space=lowerCamelCase       ,				trim_offsets=lowerCamelCase       ,				)       ,				bos_token=lowerCamelCase       ,				eos_token=lowerCamelCase       ,				unk_token=lowerCamelCase       ,				**lowerCamelCase       ,				)
         _UpperCAmelCase							=    add_prefix_space


  def  lowerCamelCase       (      self		:			Union[str, Any]       ,				lowerCamelCase		:			str       ,				lowerCamelCase		:			Union[str, Any]=None							)						->	str:


         """simple docstring"""
         _UpperCAmelCase							=    [self.bos_token_id] + token_ids_a + [self.eos_token_id]
         if token_ids_a is None:
                return output

         return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]





  def  lowerCamelCase       (      self		:			Any       ,				lowerCamelCase		:			List[int]       ,				lowerCamelCase		:			Optional[List[int]] = None							)						->	List[int]:


         """simple docstring"""
         _UpperCAmelCase							=    [self.sep_token_id]
         _UpperCAmelCase							=    [self.cls_token_id]

         if token_ids_a is None:
                return len(cls + token_ids_a + sep							) * [0]
         return len(cls + token_ids_a + sep + sep + token_ids_a + sep							) * [0]