



from __future__ import annotations

def       _lowerCAmelCase   (						A__	):
      lowercase__     =  [True] * limit
      lowercase__     =  False
      lowercase__     =  False
      lowercase__     =  True

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

      lowercase__     =  [2]

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

      return primes

def       _lowerCAmelCase   (						A__ = 1_000_000	):
      lowercase__     =  prime_sieve(A__	)
      lowercase__     =  0
      lowercase__     =  0

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

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

      return largest


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





from __future__ import annotations

def   _lowerCAmelCase   (						A__						,  A__	):
      if b == 0:
            return (1, 0)
      ((lowercase__),	(lowercase__))     =  extended_euclid(A__						,  a % b	)
      lowercase__     =  a // b
      return (y, x - k * y)

def   _lowerCAmelCase   (						A__						,  A__						,  A__						,  A__	):
      ((lowercase__),	(lowercase__))     =  extended_euclid(A__						,  A__	)
      lowercase__     =  na * na
      lowercase__     =  ra * x * na + ra * y * na
      return (n % m + m) % m

def   _lowerCAmelCase   (						A__						,  A__	):
      ((lowercase__),	(lowercase__))     =  extended_euclid(A__						,  A__	)
      if b < 0:
            lowercase__     =  (b % n + n) % n
      return b

def   _lowerCAmelCase   (						A__						,  A__						,  A__						,  A__	):
      lowercase__,	lowercase__     =  invert_modulo(A__						,  A__	), invert_modulo(A__						,  A__	)
      lowercase__     =  na * na
      lowercase__     =  ra * x * na + ra * y * na
      return (n % m + m) % m


if __name__ == "__main__":
       from doctest import testmod

       testmod(name="chinese_remainder_theorem", verbose=True)
       testmod(name="chinese_remainder_theorem2", verbose=True)
       testmod(name="invert_modulo", verbose=True)
       testmod(name="extended_euclid", verbose=True)
