





"""simple docstring"""



from __future__ import annotations






class 		__snake_case :





 """simple docstring"""


 def __init__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     __A   :						Any									=					TypeError(
         '''Matrices must be formed from a list of zero or more lists containing at '''
         '''least one and the same number of values, each of which must be of type '''
         '''int or float.'''  )
     if len(a_  ) != 0:
         __A   :						Any									=					len(rows[0]  )
         if cols == 0:
             raise error
         for row in rows:
             if len(a_  ) != cols:
                 raise error
             for value in row:
                 if not isinstance(a_ ,						(int, float)  ):
                     raise error
         __A   :						Tuple									=					rows
     else:
         __A   :						Optional[int]									=					[]

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return [[row[i] for row in self.rows] for i in range(len(self.rows[0]  )  )]

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return len(self.rows  )

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return len(self.rows[0]  )

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return (self.num_rows, self.num_columns)

 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return self.order[0] == self.order[1]

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						int									=					[
         [0 if column_num != row_num else 1 for column_num in range(self.num_rows  )]
         for row_num in range(self.num_rows  )
     ]
     return Matrix(a_  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     if not self.is_square:
         return 0
     if self.order == (0, 0):
         return 1
     if self.order == (1, 1):
         return int(self.rows[0][0]  )
     if self.order == (2, 2):
         return int(
             (self.rows[0][0] * self.rows[1][1])
             - (self.rows[0][1] * self.rows[1][0])  )
     else:
         return sum(
             self.rows[0][column] * self.cofactors().rows[0][column]
             for column in range(self.num_columns  )  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return bool(self.determinant()  )

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase  ):



     '''simple docstring'''




     __A   :						Optional[Any]									=					[
         [
             self.rows[other_row][other_column]
             for other_column in range(self.num_columns  )
             if other_column != column
         ]
         for other_row in range(self.num_rows  )
         if other_row != row
     ]
     return Matrix(a_  ).determinant()

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase  ):



     '''simple docstring'''




     if (row + column) % 2 == 0:
         return self.get_minor(a_ ,						a_  )
     return -1 * self.get_minor(a_ ,						a_  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return Matrix(
         [
             [self.get_minor(a_ ,						a_  ) for column in range(self.num_columns  )]
             for row in range(self.num_rows  )
         ]  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return Matrix(
         [
             [
                 self.minors().rows[row][column]
                 if (row + column) % 2 == 0
                 else self.minors().rows[row][column] * -1
                 for column in range(self.minors().num_columns  )
             ]
             for row in range(self.minors().num_rows  )
         ]  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Dict									=					[
         [self.cofactors().rows[column][row] for column in range(self.num_columns  )]
         for row in range(self.num_rows  )
     ]
     return Matrix(a_  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						str									=					self.determinant()
     if not determinant:
         raise TypeError('''Only matrices with a non-zero determinant have an inverse'''  )
     return self.adjugate() * (1 / determinant)

 def __repr__(   self  ):



     '''simple docstring'''




     return str(self.rows  )

 def __str__(   self  ):



     '''simple docstring'''




     if self.num_rows == 0:
         return "[]"
     if self.num_rows == 1:
         return "[[" + ". ".join(str(self.rows[0]  )  ) + "]]"
     return (
         "["
         + "\n ".join(
             [
                 '''[''' + '''. '''.join([str(a_  ) for value in row]  ) + '''.]'''
                 for row in self.rows
             ]  )
         + "]"
     )

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase = None  ):



     '''simple docstring'''




     __A   :						Dict									=					TypeError('''Row must be a list containing all ints and/or floats'''  )
     if not isinstance(a_ ,						a_  ):
         raise type_error
     for value in row:
         if not isinstance(a_ ,						(int, float)  ):
             raise type_error
     if len(a_  ) != self.num_columns:
         raise ValueError(
             '''Row must be equal in length to the other rows in the matrix'''  )
     if position is None:
         self.rows.append(a_  )
     else:
         __A   :						Optional[int]									=					self.rows[0:position] + [row] + self.rows[position:]

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase = None  ):



     '''simple docstring'''




     __A   :						Optional[Any]									=					TypeError(
         '''Column must be a list containing all ints and/or floats'''  )
     if not isinstance(a_ ,						a_  ):
         raise type_error
     for value in column:
         if not isinstance(a_ ,						(int, float)  ):
             raise type_error
     if len(a_  ) != self.num_rows:
         raise ValueError(
             '''Column must be equal in length to the other columns in the matrix'''  )
     if position is None:
         __A   :						Optional[int]									=					[self.rows[i] + [column[i]] for i in range(self.num_rows  )]
     else:
         __A   :						Tuple									=					[
             self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
             for i in range(self.num_rows  )
         ]

 def __eq__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     if not isinstance(a_ ,						a_  ):
         return NotImplemented
     return self.rows == other.rows

 def __ne__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     return not self == other

 def __neg__(   self  ):



     '''simple docstring'''




     return self * -1

 def __add__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     if self.order != other.order:
         raise ValueError('''Addition requires matrices of the same order'''  )
     return Matrix(
         [
             [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns  )]
             for i in range(self.num_rows  )
         ]  )

 def __sub__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     if self.order != other.order:
         raise ValueError('''Subtraction requires matrices of the same order'''  )
     return Matrix(
         [
             [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns  )]
             for i in range(self.num_rows  )
         ]  )

 def __mul__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     if isinstance(a_ ,						(int, float)  ):
         return Matrix(
             [[int(element * other  ) for element in row] for row in self.rows]  )
     elif isinstance(a_ ,						a_  ):
         if self.num_columns != other.num_rows:
             raise ValueError(
                 '''The number of columns in the first matrix must '''
                 '''be equal to the number of rows in the second'''  )
         return Matrix(
             [
                 [Matrix.dot_product(a_ ,						a_  ) for column in other.columns()]
                 for row in self.rows
             ]  )
     else:
         raise TypeError(
             '''A Matrix can only be multiplied by an int, float, or another matrix'''  )

 def __pow__(   self ,						__lowerCamelCase  ):



     '''simple docstring'''




     if not isinstance(a_ ,						a_  ):
         raise TypeError('''A Matrix can only be raised to the power of an int'''  )
     if not self.is_square:
         raise ValueError('''Only square matrices can be raised to a power'''  )
     if other == 0:
         return self.identity()
     if other < 0:
         if self.is_invertable():
             return self.inverse() ** (-other)
         raise ValueError(
             '''Only invertable matrices can be raised to a negative power'''  )
     __A   :						List[str]									=					self
     for _ in range(other - 1  ):
         result *= self
     return result







 @classmethod
 def  UpperCamelCase__(   cls ,						__lowerCamelCase ,						__lowerCamelCase  ):



     '''simple docstring'''




     return sum(row[i] * column[i] for i in range(len(a_  )  )  )


if __name__ == "__main__":
 import doctest

 doctest.testmod()











"""simple docstring"""



from decimal import Decimal, getcontext
from math import ceil, factorial







def 		__lowercase					(       snake_case_  :  int						)       ->str:



    '''simple docstring'''







    if not isinstance(snake_case_    ,snake_case_						):
        raise TypeError('''Undefined for non-integers'''						)
    elif precision < 1:
        raise ValueError('''Undefined for non-natural numbers'''						)

    __A   :						int									=					precision
    __A   :						Tuple									=					ceil(precision / 14						)
    __A   :						Dict									=					426880 * Decimal(10005						).sqrt()
    __A   :						Optional[Any]									=					1
    __A   :						int									=					13591409
    __A   :						Optional[int]									=					Decimal(snake_case_						)
    for k in range(1    ,snake_case_						):
        __A   :						int									=					factorial(6 * k						) // (factorial(3 * k						) * factorial(snake_case_						) ** 3)
        linear_term += 545140134
        exponential_term *= -262537412640768000
        partial_sum += Decimal(multinomial_term * linear_term						) / exponential_term
    return str(constant_term / partial_sum						)[:-1]


if __name__ == "__main__":
       a_			=      50
       print(f'''The first {n} digits of pi is: {pi(n)}''')




