"""simple docstring"""







from __future__ import annotations

import os

class 						UpperCamelCase     :
				UpperCAmelCase							: List[str]       =						(
				    """High card""",
				    """One pair""",
				    """Two pairs""",
				    """Three of a kind""",
				    """Straight""",
				    """Flush""",
				    """Full house""",
				    """Four of a kind""",
				    """Straight flush""",
				    """Royal flush""",
				)

				UpperCAmelCase							: int       =						(
				    """""",  # placeholder as tuples are zero-indexed
				    """One""",
				    """Two""",
				    """Three""",
				    """Four""",
				    """Five""",
				    """Six""",
				    """Seven""",
				    """Eight""",
				    """Nine""",
				    """Ten""",
				    """Jack""",
				    """Queen""",
				    """King""",
				    """Ace""",
				)



				def __init__(self							: List[Any]      ,    _A							: List[str])       ->      None:
					if not isinstance(_A      ,    _A):
						__snake_case     :				Tuple 						=					f"Hand should be of type \'str\': {hand!r}"
						raise TypeError(_A)
					# split removes duplicate whitespaces so no need of strip
					if len(hand.split(' ')) != 5:
						__snake_case     :				Dict 						=					f"Hand should contain only 5 cards: {hand!r}"
						raise ValueError(_A)
					__snake_case     :				Any 						=					hand
					__snake_case     :				Dict 						=					0
					__snake_case     :				int 						=					0
					__snake_case     :				Dict 						=					self._internal_state()
					__snake_case     :				str 						=					self._get_hand_type()
					__snake_case     :				Dict 						=					self._card_values[0]



				@property
				def    _lowercase	(self							: List[Any])       ->      Dict:
					return self._hand



				def    _lowercase	(self							: Any      ,    _A							: Tuple)       ->      str:
					# Breaking the tie works on the following order of precedence:
					# 1. First pair (default 0)
					# 2. Second pair (default 0)
					# 3. Compare all cards in reverse order because they are sorted.

					# First pair and second pair will only be a non-zero value if the card
					# type is either from the following:
					# 21: Four of a kind
					# 20: Full house
					# 17: Three of a kind
					# 16: Two pairs
					# 15: One pair
					if self._hand_type > other._hand_type:
						return "Win"
					elif self._hand_type < other._hand_type:
						return "Loss"
					elif self._first_pair == other._first_pair:
						if self._second_pair == other._second_pair:
							return self._compare_cards(_A)
						else:
							return "Win" if self._second_pair > other._second_pair else "Loss"
					return "Win" if self._first_pair > other._first_pair else "Loss"



				def    _lowercase	(self							: Optional[int])       ->      str:
					__snake_case     :				str 						=					PokerHand._HAND_NAME[self._hand_type - 14]
					__snake_case     :				Any 						=					PokerHand._CARD_NAME[self._high_card]
					__snake_case     :				List[Any] 						=					PokerHand._CARD_NAME[self._first_pair]
					__snake_case     :				Any 						=					PokerHand._CARD_NAME[self._second_pair]
					if self._hand_type in [22, 19, 18]:
						return name + f", {high}-high"
					elif self._hand_type in [21, 17, 15]:
						return name + f", {paira}s"
					elif self._hand_type in [20, 16]:
						__snake_case     :				List[Any] 						=					"""over""" if self._hand_type == 20 else """and"""
						return name + f", {paira}s {join} {paira}s"
					elif self._hand_type == 23:
						return name
					else:
						return name + f", {high}"



				def    _lowercase	(self							: str      ,    _A							: Optional[Any])       ->      str:
					# Enumerate gives us the index as well as the element of a list
					for index, card_value in enumerate(self._card_values):
						if card_value != other._card_values[index]:
							return "Win" if card_value > other._card_values[index] else "Loss"
					return "Tie"



				def    _lowercase	(self							: List[str])       ->      int:
					# Number representing the type of hand internally:
					# 23: Royal flush
					# 22: Straight flush
					# 21: Four of a kind
					# 20: Full house
					# 19: Flush
					# 18: Straight
					# 17: Three of a kind
					# 16: Two pairs
					# 15: One pair
					# 14: High card
					if self._is_flush():
						if self._is_five_high_straight() or self._is_straight():
							return 23 if sum(self._card_values) == 60 else 22
						return 19
					elif self._is_five_high_straight() or self._is_straight():
						return 18
					return 14 + self._is_same_kind()



				def    _lowercase	(self							: Optional[Any])       ->      bool:
					return len(self._card_suit) == 1



				def    _lowercase	(self							: Dict)       ->      bool:
					# If a card is a five high straight (low ace) change the location of
					# ace from the start of the list to the end. Check whether the first
					# element is ace or not. (Don't want to change again)
					# Five high straight (low ace): AH 2H 3S 4C 5D
					# Why use sorted here? One call to this function will mutate the list to
					# [5, 4, 3, 2, 14] and so for subsequent calls (which will be rare) we
					# need to compare the sorted version.
					# Refer test_multiple_calls_five_high_straight in test_poker_hand.py
					if sorted(self._card_values) == [2, 3, 4, 5, 14]:
						if self._card_values[0] == 14:
							# Remember, our list is sorted in reverse order
							__snake_case     :				Union[str, Any] 						=					self._card_values.pop(0)
							self._card_values.append(_A)
						return True
					return False



				def    _lowercase	(self							: Optional[Any])       ->      bool:
					for i in range(4):
						if self._card_values[i] - self._card_values[i + 1] != 1:
							return False
					return True



				def    _lowercase	(self							: str)       ->      int:
					# Kind Values for internal use:
					# 7: Four of a kind
					# 6: Full house
					# 3: Three of a kind
					# 2: Two pairs
					# 1: One pair
					# 0: False
					__snake_case     :				int 						=					0
					for i in range(4):
						# Compare two cards at a time, if they are same increase 'kind',
						# add the value of the card to val1, if it is repeating again we
						# will add 2 to 'kind' as there are now 3 cards with same value.
						# If we get card of different value than val1, we will do the same
						# thing with val2
						if self._card_values[i] == self._card_values[i + 1]:
							if not vala:
								__snake_case     :				int 						=					self._card_values[i]
								kind += 1
							elif vala == self._card_values[i]:
								kind += 2
							elif not vala:
								__snake_case     :				Tuple 						=					self._card_values[i]
								kind += 1
							elif vala == self._card_values[i]:
								kind += 2
        # For consistency in hand type (look at note in _get_hand_type function)
					__snake_case     :				Optional[Any] 						=					kind + 2 if kind in [4, 5] else kind
					# first meaning first pair to compare in 'compare_with'
					__snake_case     :				Union[str, Any] 						=					max(_A      ,    _A)
					__snake_case     :				Optional[int] 						=					min(_A      ,    _A)
					# If it's full house (three count pair + two count pair), make sure
					# first pair is three count and if not then switch them both.
					if kind == 6 and self._card_values.count(_A) != 3:
						__snake_case     :				Optional[Any] 						=					second, first
					__snake_case     :				List[str] 						=					first
					__snake_case     :				List[str] 						=					second
					return kind



				def    _lowercase	(self							: str)       ->      tuple[list[int], set[str]]:
					# Internal representation of hand as a list of card values and
					# a set of card suit
					__snake_case     :				dict 						=					{"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
					__snake_case     :				int 						=					self._hand.translate(str.maketrans(_A)).split()
					__snake_case     :				Optional[int] 						=					[int(card[:-1]) for card in new_hand]
					__snake_case     :				Optional[int] 						=					{card[-1] for card in new_hand}
					return sorted(_A      ,    reverse=_A), card_suit



				def __repr__(self							: Tuple)       ->      Optional[int]:
					return f"{self.__class__}(\"{self._hand}\")"



				def __str__(self							: Union[str, Any])       ->      List[str]:
					return self._hand



				def __eq__(self							: Tuple      ,    _A							: int)       ->      Tuple:
					if isinstance(_A      ,    _A):
						return self.compare_with(_A) == "Tie"
					return NotImplemented



				def __lt__(self							: Optional[Any]      ,    _A							: int)       ->      Tuple:
					if isinstance(_A      ,    _A):
						return self.compare_with(_A) == "Loss"
					return NotImplemented



				def __le__(self							: Optional[int]      ,    _A							: List[str])       ->      List[Any]:
					if isinstance(_A      ,    _A):
						return self < other or self == other
					return NotImplemented



				def __gt__(self							: Tuple      ,    _A							: List[Any])       ->      Optional[int]:
					if isinstance(_A      ,    _A):
						return not self < other and self != other
					return NotImplemented



				def __ge__(self							: List[Any]      ,    _A							: Dict)       ->      int:
					if isinstance(_A      ,    _A):
						return not self < other
					return NotImplemented






				def __hash__(self							: Any)       ->      Optional[int]:
					return object.__hash__(self)







def     __UpperCAmelCase							(       )				->     int:

	'''simple docstring'''





	__snake_case     :				Optional[Any] 						=					0
	__snake_case     :				int 						=					os.path.abspath(os.path.dirname(_lowercase    )    )
	__snake_case     :				str 						=					os.path.join(_lowercase     ,				'poker_hands.txt'    )
	with open(_lowercase    ) as file_hand:
		for line in file_hand:
			__snake_case     :				Optional[int] 						=					line[:14].strip()
			__snake_case     :				Optional[int] 						=					line[15:].strip()
			__snake_case     :				Optional[int] 						=					PokerHand(_lowercase    ), PokerHand(_lowercase    )
			__snake_case     :				Union[str, Any] 						=					player.compare_with(_lowercase    )
			if output == "Win":
				answer += 1
	return answer


if __name__ == "__main__":
	solution()










'''simple docstring'''




import functools
import operator

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


a  :     Union[str, Any]       =       logging.get_logger(__name__)

a  :     int       =       {
    """facebook/hubert-base-ls960""": """https://huggingface.co/facebook/hubert-base-ls960/resolve/main/config.json""",
    # See all Hubert models at https://huggingface.co/models?filter=hubert
}

class      UpperCamelCase_					(				__magic_name__     ):
	lowercase		=					'hubert'





	def __init__(    self						,						A=32						,						A=768						,						A=12						,						A=12						,						A=3072						,						A="gelu"						,						A=0.1						,						A=0.1						,						A=0.1						,						A=True						,						A=0.0						,						A=0.1						,						A=0.1						,						A=0.0_2						,						A=1e-5						,						A="group"						,						A="gelu"						,						A=(512, 512, 512, 512, 512, 512, 512)						,						A=(5, 2, 2, 2, 2, 2, 2)						,						A=(10, 3, 3, 3, 3, 2, 2)						,						A=False						,						A=128						,						A=16						,						A=False						,						A=True						,						A=0.0_5						,						A=10						,						A=2						,						A=0.0						,						A=10						,						A=0						,						A="sum"						,						A=False						,						A=False						,						A=256						,						A=0						,						A=1						,						A=2						,						**A						,						)     ->     List[str]:
								super().__init__(**A						,						pad_token_id=A						,						bos_token_id=A						,						eos_token_id=A       )
								UpperCAmelCase	:						List[Any]					=						hidden_size
								UpperCAmelCase	:						List[Any]					=						feat_extract_norm
								UpperCAmelCase	:						Optional[Any]					=						feat_extract_activation
								UpperCAmelCase	:						Optional[int]					=						list(A       )
								UpperCAmelCase	:						int					=						list(A       )
								UpperCAmelCase	:						Any					=						list(A       )
								UpperCAmelCase	:						Any					=						conv_bias
								UpperCAmelCase	:						Dict					=						num_conv_pos_embeddings
								UpperCAmelCase	:						Tuple					=						num_conv_pos_embedding_groups
								UpperCAmelCase	:						str					=						len(self.conv_dim       )
								UpperCAmelCase	:						Optional[Any]					=						num_hidden_layers
								UpperCAmelCase	:						int					=						intermediate_size
								UpperCAmelCase	:						Any					=						hidden_act
								UpperCAmelCase	:						Tuple					=						num_attention_heads
								UpperCAmelCase	:						int					=						hidden_dropout
								UpperCAmelCase	:						Any					=						attention_dropout
								UpperCAmelCase	:						Any					=						activation_dropout
								UpperCAmelCase	:						str					=						feat_proj_layer_norm
								UpperCAmelCase	:						int					=						feat_proj_dropout
								UpperCAmelCase	:						List[Any]					=						final_dropout
								UpperCAmelCase	:						int					=						layerdrop
								UpperCAmelCase	:						Dict					=						layer_norm_eps
								UpperCAmelCase	:						Union[str, Any]					=						initializer_range
								UpperCAmelCase	:						Any					=						vocab_size
								UpperCAmelCase	:						Optional[int]					=						do_stable_layer_norm
								UpperCAmelCase	:						Optional[int]					=						use_weighted_layer_sum
								UpperCAmelCase	:						Dict					=						classifier_proj_size

								if (
								    (len(self.conv_stride       ) != self.num_feat_extract_layers)
								    or (len(self.conv_kernel       ) != self.num_feat_extract_layers)
								    or (len(self.conv_dim       ) != self.num_feat_extract_layers)
								):
															raise ValueError(
															    """Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="""
															    """ `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="""
															    f''' {len(self.conv_dim       )}`, `len(config.conv_stride) = {len(self.conv_stride       )}`,'''
															    f''' `len(config.conv_kernel) = {len(self.conv_kernel       )}`.'''       )

								# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
								UpperCAmelCase	:						Union[str, Any]					=						apply_spec_augment
								UpperCAmelCase	:						Tuple					=						mask_time_prob
								UpperCAmelCase	:						Optional[Any]					=						mask_time_length
								UpperCAmelCase	:						List[Any]					=						mask_time_min_masks
								UpperCAmelCase	:						Any					=						mask_feature_prob
								UpperCAmelCase	:						Any					=						mask_feature_length
								UpperCAmelCase	:						Tuple					=						mask_feature_min_masks

								# ctc loss
								UpperCAmelCase	:						int					=						ctc_loss_reduction
								UpperCAmelCase	:						Any					=						ctc_zero_infinity






	@property
	def 					_lowercase(    self       )     ->     Union[str, Any]:
								return functools.reduce(operator.mul						,						self.conv_stride						,						1       )

