
from __future__ import annotations



def 						lowercase_      (       A__ = 4		)							->							list[list[int]]:
    """simple docstring"""

    snake_case								= abs(A__		) or 4
    return [[1 + x + y * row_size for x in range(A__		)] for y in range(A__		)]



def 						lowercase_      (       A__		)							->							list[list[int]]:
    """simple docstring"""

    return reverse_row(transpose(A__		)		)
    # OR.. transpose(reverse_column(matrix))



def 						lowercase_      (       A__		)							->							list[list[int]]:
    """simple docstring"""

    return reverse_row(reverse_column(A__		)		)
    # OR.. reverse_column(reverse_row(matrix))



def 						lowercase_      (       A__		)							->							list[list[int]]:
    """simple docstring"""

    return reverse_column(transpose(A__		)		)
    # OR.. transpose(reverse_row(matrix))



def 						lowercase_      (       A__		)							->							list[list[int]]:
    """simple docstring"""

    snake_case								= [list(A__		) for x in zip(*A__		)]
    return matrix



def 						lowercase_      (       A__		)							->							list[list[int]]:
    """simple docstring"""

    snake_case								= matrix[::-1]
    return matrix



def 						lowercase_      (       A__		)							->							list[list[int]]:
    """simple docstring"""

    snake_case								= [x[::-1] for x in matrix]
    return matrix



def 						lowercase_      (       A__		)							->							None:
    """simple docstring"""

    for i in matrix:
        print(*A__		)


if __name__ == "__main__":
   _A   =			make_matrix()
   print("\norigin:\n")
   print_matrix(matrix)
   print("\nrotate 90 counterclockwise:\n")
   print_matrix(rotate_aa(matrix))

   _A   =			make_matrix()
   print("\norigin:\n")
   print_matrix(matrix)
   print("\nrotate 180:\n")
   print_matrix(rotate_aaa(matrix))

   _A   =			make_matrix()
   print("\norigin:\n")
   print_matrix(matrix)
   print("\nrotate 270 counterclockwise:\n")
   print_matrix(rotate_aaa(matrix))




from collections import defaultdict







class 					lowerCamelCase		:





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

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

         snake_case								= defaultdict(_A       )  # 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
         snake_case								= (1 << len(_A       )) - 1





     def 		UpperCAmelCase(self				:   str    ,   _A				:   Optional[Any]    ,   _A				:   List[Any]       )						->						str:
         # 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
         snake_case								= self.count_ways_until(_A    ,   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.
         snake_case								= total_ways_util

         return self.dp[mask][task_no]





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

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

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

