




from math import factorial




class 						__lowercase		:




      """simple docstring"""





      def __init__(				self    ,				A    ,				A     )		->    str:
         snake_case				:    List[Any]           =	real
         if isinstance(A    ,				A     ):
            snake_case				:    Dict           =	[1] * rank
         else:
            snake_case				:    Any           =	rank

      def __repr__(				self     )		->    Optional[int]:
         return (
             f"""{self.real}+"""
             f"""{"+".join(str(A     )+"E"+str(n+1     )for n,dual in enumerate(self.duals     )     )}"""
         )

      def      UpperCAmelCase				(				self     )		->    Any:
         snake_case				:    str           =	self.duals.copy()
         while cur[-1] == 0:
            cur.pop(-1     )
         return Dual(self.real    ,				A     )

      def __add__(				self    ,				A     )		->    Any:
         if not isinstance(A    ,				A     ):
            return Dual(self.real + other    ,				self.duals     )
         snake_case				:    List[Any]           =	self.duals.copy()
         snake_case				:    List[Any]           =	other.duals.copy()
         if len(A     ) > len(A     ):
            o_dual.extend([1] * (len(A     ) - len(A     ))     )
         elif len(A     ) < len(A     ):
            s_dual.extend([1] * (len(A     ) - len(A     ))     )
         snake_case				:    int           =	[]
         for i in range(len(A     )     ):
            new_duals.append(s_dual[i] + o_dual[i]     )
         return Dual(self.real + other.real    ,				A     )

      _snake_case												=						__add__

      def __sub__(				self    ,				A     )		->    List[str]:
         return self + other * -1

      def __mul__(				self    ,				A     )		->    Union[str, Any]:
         if not isinstance(A    ,				A     ):
            snake_case				:    Tuple           =	[]
            for i in self.duals:
               new_duals.append(i * other     )
            return Dual(self.real * other    ,				A     )
         snake_case				:    Any           =	[0] * (len(self.duals     ) + len(other.duals     ) + 1)
         for i, item in enumerate(self.duals     ):
            for j, jtem in enumerate(other.duals     ):
               new_duals[i + j + 1] += item * jtem
         for k in range(len(self.duals     )     ):
            new_duals[k] += self.duals[k] * other.real
         for index in range(len(other.duals     )     ):
            new_duals[index] += other.duals[index] * self.real
         return Dual(self.real * other.real    ,				A     )

      _snake_case												=						__mul__

      def __truediv__(				self    ,				A     )		->    Optional[int]:
         if not isinstance(A    ,				A     ):
            snake_case				:    Union[str, Any]           =	[]
            for i in self.duals:
               new_duals.append(i / other     )
            return Dual(self.real / other    ,				A     )
         raise ValueError

      def __floordiv__(				self    ,				A     )		->    Any:
         if not isinstance(A    ,				A     ):
            snake_case				:    Dict           =	[]
            for i in self.duals:
               new_duals.append(i // other     )
            return Dual(self.real // other    ,				A     )
         raise ValueError

      def __pow__(				self    ,				A     )		->    Optional[int]:
         if n < 0 or isinstance(A    ,				A     ):
            raise ValueError("""power must be a positive integer"""     )
         if n == 0:
            return 1
         if n == 1:
            return self
         snake_case				:    Optional[Any]           =	self
         for _ in range(n - 1     ):
            x *= self
         return x




def 						SCREAMING_SNAKE_CASE__ (   lowercase						,lowercase						,lowercase					)  ->       int:
   if not callable(lowercase					):
      raise ValueError("""differentiate() requires a function as input for func"""					)
   if not isinstance(lowercase						,(float, int)					):
      raise ValueError("""differentiate() requires a float as input for position"""					)
   if not isinstance(lowercase						,lowercase					):
      raise ValueError("""differentiate() requires an int as input for order"""					)
   snake_case				:    str           =	Dual(lowercase						,1					)
   snake_case				:    Union[str, Any]           =	func(lowercase					)
   if order == 0:
      return result.real
   return result.duals[order - 1] * factorial(lowercase					)


if __name__ == "__main__":
       import doctest

       doctest.testmod()




       def 						SCREAMING_SNAKE_CASE__ (   lowercase					)  ->       Tuple:
          return y**2 * y**4
       print(differentiate(f, 9, 2))











from collections import defaultdict




def 						SCREAMING_SNAKE_CASE__ (   lowercase						,lowercase					)  ->       bool:
   snake_case				:    List[str]           =	first_str.lower().strip()
   snake_case				:    List[str]           =	second_str.lower().strip()

   # Remove whitespace
   snake_case				:    Any           =	first_str.replace(""" """						,""""""					)
   snake_case				:    List[str]           =	second_str.replace(""" """						,""""""					)

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

   # Default values for count should be 0
   snake_case				:    defaultdict[str, int]           =	defaultdict(lowercase					)

   # For each character in input strings,
   # increment count in the corresponding
   for i in range(len(lowercase					)					):
      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()
       lowerCamelCase	:	List[Any]				=   input('Enter the first string ').strip()
       lowerCamelCase	:	Optional[int]				=   input('Enter the second string ').strip()

       lowerCamelCase	:	Optional[Any]				=   check_anagrams(input_a, input_b)
       print(f"""{input_a} and {input_b} are {"" if status else "not "}anagrams.""")





