from collections import defaultdict


def      a__ (		__UpperCamelCase     ,      __UpperCamelCase				):
      SCREAMING_SNAKE_CASE_          =  first_str.lower().strip()
      SCREAMING_SNAKE_CASE_          =  second_str.lower().strip()

      # Remove whitespace
      SCREAMING_SNAKE_CASE_          =  first_str.replace(" "     ,      ""				)
      SCREAMING_SNAKE_CASE_          =  second_str.replace(" "     ,      ""				)

      # Strings of different lengths are not anagrams
      if len(__UpperCamelCase				) != len(__UpperCamelCase				):
            return False

      # Default values for count should be 0
      SCREAMING_SNAKE_CASE_          =  defaultdict(__UpperCamelCase				)

      # For each character in input strings,
      # increment count in the corresponding
      for i in range(len(__UpperCamelCase				)				):
            count[first_str[i]] += 1
            count[second_str[i]] -= 1

      return all(_count == 0 for _count in count.values()				)


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

      testmod()
      A     :  Optional[Any]					     =       input("Enter the first string ").strip()
      A     :  Optional[Any]					     =       input("Enter the second string ").strip()

      A     :  int					     =       check_anagrams(input_a, input_b)
      print(f"{input_a} and {input_b} are {'' if status else 'not '}anagrams.")



from collections.abc import Callable


def      a__ (		__UpperCamelCase     ,      __UpperCamelCase     ,      __UpperCamelCase				):
      SCREAMING_SNAKE_CASE_          =  a
      SCREAMING_SNAKE_CASE_          =  b
      if function(__UpperCamelCase				) == 0:  # one of the a or b is a root for the function
            return a
      elif function(__UpperCamelCase				) == 0:
            return b
      elif (
          function(__UpperCamelCase				) * function(__UpperCamelCase				) > 0
      ):  # if none of these are root and they are both positive or negative,
            # then this algorithm can't find the root
            raise ValueError("could not find root in given interval."				)
      else:
            SCREAMING_SNAKE_CASE_          =  start + (end - start) / 2.0
            while abs(start - mid				) > 1_0**-7:  # until precisely equals to 10^-7
                  if function(__UpperCamelCase				) == 0:
                        return mid
                  elif function(__UpperCamelCase				) * function(__UpperCamelCase				) < 0:
                        SCREAMING_SNAKE_CASE_          =  mid
                  else:
                        SCREAMING_SNAKE_CASE_          =  mid
                  SCREAMING_SNAKE_CASE_          =  start + (end - start) / 2.0
            return mid


def      a__ (		__UpperCamelCase				):
      return x**3 - 2 * x - 5


if __name__ == "__main__":
      print(bisection(f, 1, 10_00))

      import doctest

      doctest.testmod()


