


"""simple docstring"""






from collections import defaultdict


class     __lowerCamelCase  :

     '''simple docstring'''


     def __init__(      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase							)       ->							int:
          _a    	=				total  # total no of tasks (N)

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

          _a    	=				defaultdict(__UpperCAmelCase							)  # 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    	=				(1 << len(__UpperCAmelCase							)) - 1


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase							)       ->							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
          _a    	=				self.count_ways_until(__UpperCAmelCase    ,				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    	=				total_ways_util

          return self.dp[mask][task_no]





     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase							)       ->							Tuple:
          # Store the list of persons for each task
          for i in range(len(__UpperCAmelCase							)							):
               for j in task_performed[i]:
                    self.task[j].append(__UpperCAmelCase							)

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

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



"""simple docstring"""






from typing import Any
def       A_   (   _lowerCAmelCase     :					list       ):






     """simple docstring"""

     if not input_list:
          return []
     _a    	=				[input_list.count(_lowerCAmelCase       ) for value in input_list]
     _a    	=				max(_lowerCAmelCase       )  # Gets the maximum count in the input list.
     # Gets values of modes
     return sorted({input_list[i] for i, value in enumerate(_lowerCAmelCase       ) if value == y}       )


if __name__ == "__main__":
   import doctest

   doctest.testmod()