






"""simple docstring"""





from __future__ import annotations

from decimal import Decimal

from numpy import array







def      lowerCamelCase__       (							_lowerCamelCase       :		list[list[float]] )      ->				list[list[float]]:
  lowerCamelCase_         =						Decimal

  # Check if the provided matrix has 2 rows and 2 columns
  # since this implementation only works for 2x2 matrices
  if len(_lowerCamelCase ) == 2 and len(matrix[0] ) == 2 and len(matrix[1] ) == 2:
    # Calculate the determinant of the matrix
    lowerCamelCase_         =						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
    lowerCamelCase_         =						[[0.0, 0.0], [0.0, 0.0]]
    lowerCamelCase_     ,	lowerCamelCase_         =						matrix[1][1], matrix[0][0]
    lowerCamelCase_     ,	lowerCamelCase_         =						-matrix[1][0], -matrix[0][1]

    # Calculate the inverse of the matrix
    return [
        [(float(d(_lowerCamelCase ) ) / determinant) or 0.0 for n in row] for row in swapped_matrix
    ]
  elif (
      len(_lowerCamelCase ) == 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
    lowerCamelCase_         =						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
    lowerCamelCase_         =						[
        [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 )],
    ]
    lowerCamelCase_         =						(d(matrix[1][1] ) * d(matrix[2][2] )) - (
        d(matrix[1][2] ) * d(matrix[2][1] )
    )
    lowerCamelCase_         =						-(
        (d(matrix[1][0] ) * d(matrix[2][2] )) - (d(matrix[1][2] ) * d(matrix[2][0] ))
    )
    lowerCamelCase_         =						(d(matrix[1][0] ) * d(matrix[2][1] )) - (
        d(matrix[1][1] ) * d(matrix[2][0] )
    )
    lowerCamelCase_         =						-(
        (d(matrix[0][1] ) * d(matrix[2][2] )) - (d(matrix[0][2] ) * d(matrix[2][1] ))
    )
    lowerCamelCase_         =						(d(matrix[0][0] ) * d(matrix[2][2] )) - (
        d(matrix[0][2] ) * d(matrix[2][0] )
    )
    lowerCamelCase_         =						-(
        (d(matrix[0][0] ) * d(matrix[2][1] )) - (d(matrix[0][1] ) * d(matrix[2][0] ))
    )
    lowerCamelCase_         =						(d(matrix[0][1] ) * d(matrix[1][2] )) - (
        d(matrix[0][2] ) * d(matrix[1][1] )
    )
    lowerCamelCase_         =						-(
        (d(matrix[0][0] ) * d(matrix[1][2] )) - (d(matrix[0][2] ) * d(matrix[1][0] ))
    )
    lowerCamelCase_         =						(d(matrix[0][0] ) * d(matrix[1][1] )) - (
        d(matrix[0][1] ) * d(matrix[1][0] )
    )

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

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

        # Calculate the inverse of the matrix
    return [[float(d(_lowerCamelCase ) ) 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"""





from __future__ import annotations







def      lowerCamelCase__       (							_lowerCamelCase       :		int )      ->				list[int]:
  lowerCamelCase_         =						[True] * limit
  lowerCamelCase_         =						False
  lowerCamelCase_         =						False
  lowerCamelCase_         =						True

  for i in range(3		,				int(limit**0.5 + 1 )		,				2 ):
    lowerCamelCase_         =						i * 2
    while index < limit:
      lowerCamelCase_         =						False
      lowerCamelCase_         =						index + i

  lowerCamelCase_         =						[2]

  for i in range(3		,				_lowerCamelCase		,				2 ):
    if is_prime[i]:
      primes.append(_lowerCamelCase )

  return primes







def      lowerCamelCase__       (							_lowerCamelCase       :		int = 1000000 )      ->				int:
  lowerCamelCase_         =						prime_sieve(_lowerCamelCase )
  lowerCamelCase_         =						0
  lowerCamelCase_         =						0

  for i in range(len(_lowerCamelCase ) ):
    for j in range(i + length		,				len(_lowerCamelCase ) ):
      lowerCamelCase_         =						sum(primes[i:j] )
      if sol >= ceiling:
        break

      if sol in primes:
        lowerCamelCase_         =						j - i
        lowerCamelCase_         =						sol

  return largest


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




