






from __future__ import annotations

from typing import Any







class  _lowercase   :
      def __init__(     self				,			a				,			a				,			a = 0   ):
       snake_case__  :    Dict							       =row, column
       snake_case__  :    int							       =[[default_value for c in range(a   )] for r in range(a   )]
      def __str__(     self   ):
       snake_case__  :    Any							       =F"Matrix consist of {self.row} rows and {self.column} columns\n"

       # Make string identifier
       snake_case__  :    Tuple							       =0
       for row_vector in self.array:
        for obj in row_vector:
         snake_case__  :    Any							       =max(a				,			len(str(a   )   )   )
       snake_case__  :    int							       =F"%{max_element_length}s"

       # Make string and return
       def single_line(a   ) -> str:
        nonlocal string_format_identifier
        snake_case__  :    int							       ='['
        line += ", ".join(string_format_identifier % (obj,) for obj in row_vector   )
        line += "]"
        return line

       s += "\n".join(single_line(a   ) for row_vector in self.array   )
       return s
      def __repr__(     self   ):
       return str(self   )
      def 						lowercase__					(     self				,			a   ):







       if not (isinstance(a				,			(list, tuple)   ) and len(a   ) == 2):
        return False
       elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
        return False
       else:
        return True
      def __getitem__(     self				,			a   ):
       assert self.validate_indicies(a   )
       return self.array[loc[0]][loc[1]]
      def __setitem__(     self				,			a				,			a   ):
       assert self.validate_indicies(a   )
       snake_case__  :    Optional[Any]							       =value
      def __add__(     self				,			a   ):
       assert isinstance(a				,			a   )
       assert self.row == another.row and self.column == another.column

       # Add
       snake_case__  :    List[Any]							       =Matrix(self.row				,			self.column   )
       for r in range(self.row   ):
        for c in range(self.column   ):
         snake_case__  :    Tuple							       =self[r, c] + another[r, c]
       return result
      def __neg__(     self   ):
       snake_case__  :    str							       =Matrix(self.row				,			self.column   )
       for r in range(self.row   ):
        for c in range(self.column   ):
         snake_case__  :    List[Any]							       =-self[r, c]
       return result
      def __sub__(     self				,			a   ):
       return self + (-another)
      def __mul__(     self				,			a   ):







       if isinstance(a				,			(int, float)   ):  # Scalar multiplication
        snake_case__  :    Any							       =Matrix(self.row				,			self.column   )
        for r in range(self.row   ):
         for c in range(self.column   ):
          snake_case__  :    Optional[Any]							       =self[r, c] * another
        return result
       elif isinstance(a				,			a   ):  # Matrix multiplication
        assert self.column == another.row
        snake_case__  :    List[str]							       =Matrix(self.row				,			another.column   )
        for r in range(self.row   ):
         for c in range(another.column   ):
          for i in range(self.column   ):
           result[r, c] += self[r, i] * another[i, c]
        return result
       else:
        snake_case__  :    Union[str, Any]							       =F"Unsupported type given for another ({type(a   )})"
        raise TypeError(a   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =Matrix(self.column				,			self.row   )
       for r in range(self.row   ):
        for c in range(self.column   ):
         snake_case__  :    Optional[int]							       =self[r, c]
       return result



      def 						lowercase__					(     self				,			a				,			a   ):
       assert isinstance(a				,			a   ) and isinstance(a				,			a   )
       assert self.row == self.column == u.row == v.row  # u, v should be column vector
       assert u.column == v.column == 1  # u, v should be column vector

       # Calculate
       snake_case__  :    Any							       =v.transpose()
       snake_case__  :    Any							       =(v_t * self * u)[0, 0] + 1
       if numerator_factor == 0:
        return None  # It's not invertable
       return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))


# Testing
if __name__ == "__main__":







      def 			A__							(      ):





       '''simple docstring'''







       snake_case__  :    Any							       =Matrix(3		,  3		,  0	)
       for i in range(3	):
        snake_case__  :    List[str]							       =1
       print(f"a^(-1) is {ainv}"	)
       # u, v
       snake_case__  :    Dict							       =Matrix(3		,  1		,  0	)
       snake_case__  :    Any							       =1, 2, -3
       snake_case__  :    Any							       =Matrix(3		,  1		,  0	)
       snake_case__  :    List[Any]							       =4, -2, 5
       print(f"u is {u}"	)
       print(f"v is {v}"	)
       print(f"uv^T is {u * v.transpose()}"	)
       # Sherman Morrison
       print(f"(a + uv^T)^(-1) is {ainv.sherman_morrison(SCREAMING_SNAKE_CASE_		,  SCREAMING_SNAKE_CASE_	)}"	)







      def 			A__							(      ):





       '''simple docstring'''







       import doctest

       doctest.testmod()

      testa()













def 			A__							(      _a  :					list	):





 '''simple docstring'''







 if len(_a	) <= 1:
  return [tuple(_a	)]

 snake_case__  :    Optional[int]							       =[]

 def generate(_a  :					int		,  _a  :					list	):
  if k == 1:
   res.append(tuple(arr[:]	)	)
   return

  generate(k - 1		,  _a	)

  for i in range(k - 1	):
   if k % 2 == 0:  # k is even
    snake_case__       ,   snake_case__  :    Dict							       =arr[k - 1], arr[i]
   else:  # k is odd
    snake_case__       ,   snake_case__  :    int							       =arr[k - 1], arr[0]
   generate(k - 1		,  _a	)

 generate(len(_a	)		,  _a	)
 return res


if __name__ == "__main__":
       __lowerCamelCase	:		Optional[int]										=   input("""Enter numbers separated by a comma:\n""").strip()
       __lowerCamelCase	:		Any										=   [int(item) for item in user_input.split(""",""")]
       print(heaps(arr))





