

'''simple docstring'''





from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
							from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


UpperCamelCase_							=					logging.get_logger(__name__)

UpperCamelCase_							=					{
    """microsoft/deberta-v2-xlarge""": """https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json""",
    """microsoft/deberta-v2-xxlarge""": """https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json""",
    """microsoft/deberta-v2-xlarge-mnli""": (
        """https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json"""
    ),
    """microsoft/deberta-v2-xxlarge-mnli""": (
        """https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json"""
    ),
}





class 		__SCREAMING_SNAKE_CASE       ( lowercase__			):
				lowerCamelCase_							=						'deberta-v2'







				def __init__(					self    :		Optional[int]		,				UpperCAmelCase__    :		Optional[Any]=128100		,				UpperCAmelCase__    :		str=1536		,				UpperCAmelCase__    :		Any=24		,				UpperCAmelCase__    :		Optional[int]=24		,				UpperCAmelCase__    :		Union[str, Any]=6144		,				UpperCAmelCase__    :		Optional[Any]="gelu"		,				UpperCAmelCase__    :		Dict=0.1		,				UpperCAmelCase__    :		Optional[int]=0.1		,				UpperCAmelCase__    :		Tuple=512		,				UpperCAmelCase__    :		Dict=0		,				UpperCAmelCase__    :		List[str]=0.02		,				UpperCAmelCase__    :		Any=1E-7		,				UpperCAmelCase__    :		Optional[Any]=False		,				UpperCAmelCase__    :		Union[str, Any]=-1		,				UpperCAmelCase__    :		Dict=0		,				UpperCAmelCase__    :		Tuple=True		,				UpperCAmelCase__    :		int=None		,				UpperCAmelCase__    :		Optional[int]=0		,				UpperCAmelCase__    :		List[str]="gelu"		,				**UpperCAmelCase__    :		List[str]		,				):
										'''simple docstring'''
										super().__init__(**UpperCAmelCase__      )

										lowercase   :       Dict								=hidden_size
										lowercase   :       List[Any]								=num_hidden_layers
										lowercase   :       Any								=num_attention_heads
										lowercase   :       Union[str, Any]								=intermediate_size
										lowercase   :       int								=hidden_act
										lowercase   :       List[Any]								=hidden_dropout_prob
										lowercase   :       str								=attention_probs_dropout_prob
										lowercase   :       Optional[int]								=max_position_embeddings
										lowercase   :       str								=type_vocab_size
										lowercase   :       Dict								=initializer_range
										lowercase   :       str								=relative_attention
										lowercase   :       List[Any]								=max_relative_positions
										lowercase   :       Union[str, Any]								=pad_token_id
										lowercase   :       Union[str, Any]								=position_biased_input

										# Backwards compatibility
										if type(UpperCAmelCase__      ) == str:
																lowercase   :       Optional[int]								=[x.strip() for x in pos_att_type.lower().split('''|'''      )]

										lowercase   :       List[str]								=pos_att_type
										lowercase   :       List[str]								=vocab_size
										lowercase   :       str								=layer_norm_eps

										lowercase   :       Optional[int]								=kwargs.get('''pooler_hidden_size'''		,				UpperCAmelCase__      )
										lowercase   :       Tuple								=pooler_dropout
										lowercase   :       Union[str, Any]								=pooler_hidden_act





class 		__SCREAMING_SNAKE_CASE       ( lowercase__			):







				@property
				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										if self.task == "multiple-choice":
																lowercase   :       Optional[Any]								={0: '''batch''', 1: '''choice''', 2: '''sequence'''}
										else:
																lowercase   :       List[Any]								={0: '''batch''', 1: '''sequence'''}
										if self._config.type_vocab_size > 0:
																return OrderedDict(
																    [('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ('''token_type_ids''', dynamic_axis)]      )
										else:
																return OrderedDict([('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis)]      )







				@property
				def    lowerCamelCase_  (					self    :		Tuple      ):
										'''simple docstring'''
										return 12







				def    lowerCamelCase_  (					self    :		Tuple		,				UpperCAmelCase__    :		Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]		,				UpperCAmelCase__    :		int = -1		,				UpperCAmelCase__    :		int = -1		,				UpperCAmelCase__    :		int = -1		,				UpperCAmelCase__    :		bool = False		,				UpperCAmelCase__    :		Optional["TensorType"] = None		,				UpperCAmelCase__    :		int = 3		,				UpperCAmelCase__    :		int = 40		,				UpperCAmelCase__    :		int = 40		,				UpperCAmelCase__    :		"PreTrainedTokenizerBase" = None		,				):
										'''simple docstring'''
										lowercase   :       Dict								=super().generate_dummy_inputs(preprocessor=UpperCAmelCase__		,				framework=UpperCAmelCase__      )
										if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
																del dummy_inputs["token_type_ids"]
										return dummy_inputs








'''simple docstring'''





from collections import defaultdict






def 							_lowerCAmelCase (      __magic_name__	:    str      ,   __magic_name__	:    str	)							->     bool:
						lowercase   :       Optional[int]								=first_str.lower().strip()
						lowercase   :       Union[str, Any]								=second_str.lower().strip()

						# Remove whitespace
						lowercase   :       Optional[int]								=first_str.replace(''' '''      ,   ''''''	)
						lowercase   :       Optional[Any]								=second_str.replace(''' '''      ,   ''''''	)

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

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

						# For each character in input strings,
						# increment count in the corresponding
						for i in range(len(__magic_name__	)	):
												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()
							UpperCamelCase_							=					input("""Enter the first string """).strip()
							UpperCamelCase_							=					input("""Enter the second string """).strip()

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





