

'''simple docstring'''





from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase_							=					logging.get_logger(__name__)

UpperCamelCase_							=					{
    """funnel-transformer/small""": """https://huggingface.co/funnel-transformer/small/resolve/main/config.json""",
    """funnel-transformer/small-base""": """https://huggingface.co/funnel-transformer/small-base/resolve/main/config.json""",
    """funnel-transformer/medium""": """https://huggingface.co/funnel-transformer/medium/resolve/main/config.json""",
    """funnel-transformer/medium-base""": """https://huggingface.co/funnel-transformer/medium-base/resolve/main/config.json""",
    """funnel-transformer/intermediate""": (
        """https://huggingface.co/funnel-transformer/intermediate/resolve/main/config.json"""
    ),
    """funnel-transformer/intermediate-base""": (
        """https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/config.json"""
    ),
    """funnel-transformer/large""": """https://huggingface.co/funnel-transformer/large/resolve/main/config.json""",
    """funnel-transformer/large-base""": """https://huggingface.co/funnel-transformer/large-base/resolve/main/config.json""",
    """funnel-transformer/xlarge""": """https://huggingface.co/funnel-transformer/xlarge/resolve/main/config.json""",
    """funnel-transformer/xlarge-base""": """https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/config.json""",
}





class 		__SCREAMING_SNAKE_CASE       ( lowercase__			):
				lowerCamelCase_							=						'funnel'
				lowerCamelCase_							=						{
				    'hidden_size': 'd_model',
				    'num_attention_heads': 'n_head',
				}







				def __init__(					self    :		List[str]		,				UpperCAmelCase__    :		Dict=30522		,				UpperCAmelCase__    :		Dict=[4, 4, 4]		,				UpperCAmelCase__    :		Optional[Any]=None		,				UpperCAmelCase__    :		Tuple=2		,				UpperCAmelCase__    :		List[str]=768		,				UpperCAmelCase__    :		Dict=12		,				UpperCAmelCase__    :		Dict=64		,				UpperCAmelCase__    :		str=3072		,				UpperCAmelCase__    :		int="gelu_new"		,				UpperCAmelCase__    :		Dict=0.1		,				UpperCAmelCase__    :		Optional[Any]=0.1		,				UpperCAmelCase__    :		List[Any]=0.0		,				UpperCAmelCase__    :		Dict=0.1		,				UpperCAmelCase__    :		Union[str, Any]=None		,				UpperCAmelCase__    :		str=1E-9		,				UpperCAmelCase__    :		int="mean"		,				UpperCAmelCase__    :		Tuple="relative_shift"		,				UpperCAmelCase__    :		int=True		,				UpperCAmelCase__    :		List[Any]=True		,				UpperCAmelCase__    :		Optional[Any]=True		,				**UpperCAmelCase__    :		int		,				):
										'''simple docstring'''
										lowercase   :       List[str]								=vocab_size
										lowercase   :       Dict								=block_sizes
										lowercase   :       List[str]								=[1] * len(UpperCAmelCase__      ) if block_repeats is None else block_repeats
										assert len(UpperCAmelCase__      ) == len(
										    self.block_repeats      ), "`block_sizes` and `block_repeats` should have the same length."
										lowercase   :       List[str]								=num_decoder_layers
										lowercase   :       Union[str, Any]								=d_model
										lowercase   :       List[str]								=n_head
										lowercase   :       List[str]								=d_head
										lowercase   :       Dict								=d_inner
										lowercase   :       Any								=hidden_act
										lowercase   :       str								=hidden_dropout
										lowercase   :       Optional[int]								=attention_dropout
										lowercase   :       List[Any]								=activation_dropout
										lowercase   :       List[str]								=initializer_range
										lowercase   :       Union[str, Any]								=initializer_std
										lowercase   :       Dict								=layer_norm_eps
										assert pooling_type in [
										    "mean",
										    "max",
										], F'''Got {pooling_type} for `pooling_type` but only \'mean\' and \'max\' are supported.'''
										lowercase   :       Optional[Any]								=pooling_type
										assert attention_type in [
										    "relative_shift",
										    "factorized",
										], F'''Got {attention_type} for `attention_type` but only \'relative_shift\' and \'factorized\' are supported.'''
										lowercase   :       str								=attention_type
										lowercase   :       List[str]								=separate_cls
										lowercase   :       Tuple								=truncate_seq
										lowercase   :       List[Any]								=pool_q_only

										super().__init__(**UpperCAmelCase__      )







				@property
				def    lowerCamelCase_  (					self    :		Dict      ):
										'''simple docstring'''
										return sum(self.block_sizes      )







				@num_hidden_layers.setter
				def    lowerCamelCase_  (					self    :		Tuple		,				UpperCAmelCase__    :		str      ):
										'''simple docstring'''
										raise NotImplementedError(
										    '''This model does not support the setting of `num_hidden_layers`. Please set `block_sizes`.'''      )







				@property
				def    lowerCamelCase_  (					self    :		Optional[int]      ):
										'''simple docstring'''
										return len(self.block_sizes      )







				@num_blocks.setter
				def    lowerCamelCase_  (					self    :		Tuple		,				UpperCAmelCase__    :		str      ):
										'''simple docstring'''
										raise NotImplementedError('''This model does not support the setting of `num_blocks`. Please set `block_sizes`.'''      )








'''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.''')





