



"""simple docstring"""






def 			snake_case_    ( A_   :						float		):


       '''simple docstring'''





       return 10 - x * x






def 			snake_case_    ( A_   :						float,							A_   :						float		):


       '''simple docstring'''





       if equation(A_		) * equation(A_		) >= 0:
              raise ValueError('''Wrong space!'''		)

       _lowerCamelCase		:							Any            =					a
       while (b - a) >= 0.01:
              # Find middle point
              _lowerCamelCase		:							List[str]            =					(a + b) / 2
              # Check if middle point is root
              if equation(A_		) == 0.0:
                     break
              # Decide the side to repeat the steps
              if equation(A_		) * equation(A_		) < 0:
                     _lowerCamelCase		:							Optional[Any]            =					c
              else:
                     _lowerCamelCase		:							Dict            =					c
       return c


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   print(bisection(-2, 5))
   print(bisection(0, 6))









import math


def       UpperCamelCase__(			UpperCamelCase__     :			int    )->list:
       A__		   =		[True] * n
       A__		   =		False
       A__		   =		False
       A__		   =		True

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

       A__		   =		[2]

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

       return primes


def       UpperCamelCase__(			UpperCamelCase__     :			int = 99_99_66_66_33_33    )->int:
       A__		   =		math.floor(math.sqrt(UpperCamelCase__    )    ) + 1_00
       A__		   =		prime_sieve(UpperCamelCase__    )

       A__		   =		0
       A__		   =		0
       A__		   =		primes[prime_index]

       while (last_prime**2) <= limit:
              A__		   =		primes[prime_index + 1]

              A__		   =		last_prime**2
              A__		   =		next_prime**2

              # Get numbers divisible by lps(current)
              A__		   =		lower_bound + last_prime
              while upper_bound > current <= limit:
                     matches_sum += current
                     current += last_prime

              # Reset the upper_bound
              while (upper_bound - next_prime) > limit:
                     upper_bound -= next_prime

              # Add the numbers divisible by ups(current)
              A__		   =		upper_bound - next_prime
              while current > lower_bound:
                     matches_sum += current
                     current -= next_prime

              # Remove the numbers divisible by both ups and lps
              A__		   =		0
              while upper_bound > current <= limit:
                     if current <= lower_bound:
                            # Increment the current number
                            current += last_prime * next_prime
                            continue

                     if current > limit:
                            break

                     # Remove twice since it was added by both ups and lps
                     matches_sum -= current * 2

                     # Increment the current number
                     current += last_prime * next_prime

              # Setup for next pair
              A__		   =		next_prime
              prime_index += 1

       return matches_sum


if __name__ == "__main__":
       print(solution())





