




'''simple docstring'''





from __future__ import annotations

from decimal import Decimal

from numpy import array


def 					UpperCamelCase_(     snake_case							:	list[list[float]]					):

							'''simple docstring'''






							snake_case_      =				Decimal

							# Check if the provided matrix has 2 rows and 2 columns
							# since this implementation only works for 2x2 matrices
							if len(snake_case					) == 2 and len(matrix[0]					) == 2 and len(matrix[1]					) == 2:
														# Calculate the determinant of the matrix
														snake_case_      =				float(
														    d(matrix[0][0]					) * d(matrix[1][1]					) - d(matrix[1][0]					) * d(matrix[0][1]					)					)
														if determinant == 0:
																					raise ValueError("This matrix has no inverse."					)

														# Creates a copy of the matrix with swapped positions of the elements
														snake_case_      =				[[0.0, 0.0], [0.0, 0.0]]
														snake_case_ ,				snake_case_      =				matrix[1][1], matrix[0][0]
														snake_case_ ,				snake_case_      =				-matrix[1][0], -matrix[0][1]

														# Calculate the inverse of the matrix
														return [
														    [(float(d(snake_case					)					) / determinant) or 0.0 for n in row] for row in swapped_matrix
														]
							elif (
							    len(snake_case					) == 3
							    and len(matrix[0]					) == 3
							    and len(matrix[1]					) == 3
							    and len(matrix[2]					) == 3
							):
														# Calculate the determinant of the matrix using Sarrus rule
														snake_case_      =				float(
														    (
														        (d(matrix[0][0]					) * d(matrix[1][1]					) * d(matrix[2][2]					))
														        + (d(matrix[0][1]					) * d(matrix[1][2]					) * d(matrix[2][0]					))
														        + (d(matrix[0][2]					) * d(matrix[1][0]					) * d(matrix[2][1]					))
														    )
														    - (
														        (d(matrix[0][2]					) * d(matrix[1][1]					) * d(matrix[2][0]					))
														        + (d(matrix[0][1]					) * d(matrix[1][0]					) * d(matrix[2][2]					))
														        + (d(matrix[0][0]					) * d(matrix[1][2]					) * d(matrix[2][1]					))
														    )					)
														if determinant == 0:
																					raise ValueError("This matrix has no inverse."					)

														# Creating cofactor matrix
														snake_case_      =				[
														    [d(0.0					), d(0.0					), d(0.0					)],
														    [d(0.0					), d(0.0					), d(0.0					)],
														    [d(0.0					), d(0.0					), d(0.0					)],
														]
														snake_case_      =				(d(matrix[1][1]					) * d(matrix[2][2]					)) - (
														    d(matrix[1][2]					) * d(matrix[2][1]					)
														)
														snake_case_      =				-(
														    (d(matrix[1][0]					) * d(matrix[2][2]					)) - (d(matrix[1][2]					) * d(matrix[2][0]					))
														)
														snake_case_      =				(d(matrix[1][0]					) * d(matrix[2][1]					)) - (
														    d(matrix[1][1]					) * d(matrix[2][0]					)
														)
														snake_case_      =				-(
														    (d(matrix[0][1]					) * d(matrix[2][2]					)) - (d(matrix[0][2]					) * d(matrix[2][1]					))
														)
														snake_case_      =				(d(matrix[0][0]					) * d(matrix[2][2]					)) - (
														    d(matrix[0][2]					) * d(matrix[2][0]					)
														)
														snake_case_      =				-(
														    (d(matrix[0][0]					) * d(matrix[2][1]					)) - (d(matrix[0][1]					) * d(matrix[2][0]					))
														)
														snake_case_      =				(d(matrix[0][1]					) * d(matrix[1][2]					)) - (
														    d(matrix[0][2]					) * d(matrix[1][1]					)
														)
														snake_case_      =				-(
														    (d(matrix[0][0]					) * d(matrix[1][2]					)) - (d(matrix[0][2]					) * d(matrix[1][0]					))
														)
														snake_case_      =				(d(matrix[0][0]					) * d(matrix[1][1]					)) - (
														    d(matrix[0][1]					) * d(matrix[1][0]					)
														)

														# Transpose the cofactor matrix (Adjoint matrix)
														snake_case_      =				array(snake_case					)
														for i in range(3					):
																					for j in range(3					):
																												snake_case_      =				cofactor_matrix[j][i]

        # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
														snake_case_      =				array(snake_case					)
														for i in range(3					):
																					for j in range(3					):
																												inverse_matrix[i][j] /= d(snake_case					)

        # Calculate the inverse of the matrix
														return [[float(d(snake_case					)					) or 0.0 for n in row] for row in inverse_matrix]
							raise ValueError("Please provide a matrix of size 2x2 or 3x3."					)










'''simple docstring'''





def 					UpperCamelCase_(     snake_case							:	int = 1_0_0_0					):

							'''simple docstring'''






							snake_case_      =				3
							snake_case_      =				0
							while a < n:
														if a % 3 == 0 or a % 5 == 0:
																					result += a
														elif a % 1_5 == 0:
																					result -= a
														a += 1
							return result


if __name__ == "__main__":
		print(F"{solution() = }")




