

from __future__ import annotations

import sys
from collections import deque
from typing import Generic, TypeVar

A											=     TypeVar('T')


class SCREAMING_SNAKE_CASE  (		Generic[T]							):






			"""simple docstring"""




			__A						  =  42  # Cache store of keys
			__A						  =  42  # References of the keys in cache
			__A						  =  1_0  # Maximum capacity of cache


			def __init__(    self ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= deque()
				snake_case_      		= set()
				if not n:
					snake_case_      		= sys.maxsize
				elif n < 0:
					raise ValueError('n should be an integer greater than 0.'							)
				else:
					snake_case_      		= n


			def 			__lowerCAmelCase (    self ,				__UpperCamelCase							):

				"""simple docstring"""


				if x not in self.key_reference:
					if len(self.dq_store							) == LRUCache._MAX_CAPACITY:
						snake_case_      		= self.dq_store.pop()
						self.key_reference.remove(__UpperCamelCase							)
				else:
					self.dq_store.remove(__UpperCamelCase							)

				self.dq_store.appendleft(__UpperCamelCase							)
				self.key_reference.add(__UpperCamelCase							)


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				for k in self.dq_store:
					print(__UpperCamelCase							)







			def __repr__(    self							):

				"""simple docstring"""


				return f"""LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store							)}"""


if __name__ == "__main__":
		import doctest

		doctest.testmod()

		A											=     LRUCache(4)
		lru_cache.refer('A')
		lru_cache.refer(2)
		lru_cache.refer(3)
		lru_cache.refer('A')
		lru_cache.refer(4)
		lru_cache.refer(5)
		lru_cache.display()

		print(lru_cache)
		assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"



from collections import defaultdict





def a(lowercase__			, lowercase__	):





	'''simple docstring'''
	snake_case_      		= first_str.lower().strip()
	snake_case_      		= second_str.lower().strip()

	# Remove whitespace
	snake_case_      		= first_str.replace(' '			, ''	)
	snake_case_      		= 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(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()
		A											=     input('Enter the first string ').strip()
		A											=     input('Enter the second string ').strip()

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