



'''simple docstring'''




from __future__ import annotations

import os

class      UpperCamelCase_					:
	lowercase		=					(
	    "High card",
	    "One pair",
	    "Two pairs",
	    "Three of a kind",
	    "Straight",
	    "Flush",
	    "Full house",
	    "Four of a kind",
	    "Straight flush",
	    "Royal flush",
	)

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





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





	@property
	def 					_lowercase(    self       )     ->     Union[str, Any]:
								return self._hand





	def 					_lowercase(    self						,						A       )     ->     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(__UpperCAmelCase       )
															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       )     ->     str:
								UpperCAmelCase	:						Dict					=						PokerHand._HAND_NAME[self._hand_type - 14]
								UpperCAmelCase	:						Optional[int]					=						PokerHand._CARD_NAME[self._high_card]
								UpperCAmelCase	:						Optional[Any]					=						PokerHand._CARD_NAME[self._first_pair]
								UpperCAmelCase	:						List[str]					=						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]:
															UpperCAmelCase	:						Tuple					=						"""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						,						A       )     ->     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       )     ->     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       )     ->     bool:
								return len(self._card_suit       ) == 1





	def 					_lowercase(    self       )     ->     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
																						UpperCAmelCase	:						Optional[int]					=						self._card_values.pop(0       )
																						self._card_values.append(__UpperCAmelCase       )
															return True
								return False





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





	def 					_lowercase(    self       )     ->     int:
								UpperCAmelCase	:						Dict					=						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:
																													UpperCAmelCase	:						str					=						self._card_values[i]
																													kind += 1
																						elif vala == self._card_values[i]:
																													kind += 2
																						elif not vala:
																													UpperCAmelCase	:						Dict					=						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)
								UpperCAmelCase	:						int					=						kind + 2 if kind in [4, 5] else kind
								# first meaning first pair to compare in 'compare_with'
								UpperCAmelCase	:						int					=						max(__UpperCAmelCase						,						__UpperCAmelCase       )
								UpperCAmelCase	:						Optional[Any]					=						min(__UpperCAmelCase						,						__UpperCAmelCase       )
								# 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(__UpperCAmelCase       ) != 3:
															UpperCAmelCase	:						List[Any]					=						second, first
								UpperCAmelCase	:						List[Any]					=						first
								UpperCAmelCase	:						Any					=						second
								return kind





	def 					_lowercase(    self       )     ->     tuple[list[int], set[str]]:
								UpperCAmelCase	:						dict					=						{"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
								UpperCAmelCase	:						Union[str, Any]					=						self._hand.translate(str.maketrans(__UpperCAmelCase       )       ).split()
								UpperCAmelCase	:						List[str]					=						[int(card[:-1]       ) for card in new_hand]
								UpperCAmelCase	:						Dict					=						{card[-1] for card in new_hand}
								return sorted(__UpperCAmelCase						,						reverse=__UpperCAmelCase       ), card_suit





	def __repr__(    self       )     ->     List[Any]:
								return f'''{self.__class__}("{self._hand}")'''





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





	def __eq__(    self						,						A       )     ->     Optional[int]:
								if isinstance(__UpperCAmelCase						,						__UpperCAmelCase       ):
															return self.compare_with(__UpperCAmelCase       ) == "Tie"
								return NotImplemented





	def __lt__(    self						,						A       )     ->     List[str]:
								if isinstance(__UpperCAmelCase						,						__UpperCAmelCase       ):
															return self.compare_with(__UpperCAmelCase       ) == "Loss"
								return NotImplemented





	def __le__(    self						,						A       )     ->     List[Any]:
								if isinstance(__UpperCAmelCase						,						__UpperCAmelCase       ):
															return self < other or self == other
								return NotImplemented





	def __gt__(    self						,						A       )     ->     Union[str, Any]:
								if isinstance(__UpperCAmelCase						,						__UpperCAmelCase       ):
															return not self < other and self != other
								return NotImplemented





	def __ge__(    self						,						A       )     ->     int:
								if isinstance(__UpperCAmelCase						,						__UpperCAmelCase       ):
															return not self < other
								return NotImplemented






	def __hash__(    self       )     ->     Dict:
								return object.__hash__(self       )




def  __lowerCamelCase    (   ) ->     Union[str, Any]:
							UpperCAmelCase	:						Tuple					=						0
							UpperCAmelCase	:						List[Any]					=						os.path.abspath(os.path.dirname(lowerCAmelCase__						)						)
							UpperCAmelCase	:						Dict					=						os.path.join(lowerCAmelCase__      ,							"""poker_hands.txt"""						)
							with open(lowerCAmelCase__						) as file_hand:
														for line in file_hand:
																					UpperCAmelCase	:						Any					=						line[:1_4].strip()
																					UpperCAmelCase	:						List[str]					=						line[1_5:].strip()
																					UpperCAmelCase	:						Dict					=						PokerHand(lowerCAmelCase__						), PokerHand(lowerCAmelCase__						)
																					UpperCAmelCase	:						Optional[int]					=						player.compare_with(lowerCAmelCase__						)
																					if output == "Win":
																												answer += 1
							return answer


if __name__ == "__main__":
							solution()






'''simple docstring'''
from __future__ import annotations


def 	lowercase_						( lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int			):

			"""simple docstring"""





			assert (
			    c % greatest_common_divisor(lowerCAmelCase__      ,				lowerCAmelCase__			) == 0
			)  # greatest_common_divisor(a,b) function implemented below
			((__UpperCAmelCase)					,	(__UpperCAmelCase)					,	(__UpperCAmelCase)) :   int    					=  extended_gcd(lowerCAmelCase__      ,				lowerCAmelCase__			)  # extended_gcd(a,b) function implemented below
			__UpperCAmelCase :   Union[str, Any]    					=  c / d
			return (r * x, r * y)


def 	lowercase_						( lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int = 2			):

			"""simple docstring"""





			((__UpperCAmelCase)					,	(__UpperCAmelCase)) :   List[str]    					=  diophantine(lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__			)  # Initial value
			__UpperCAmelCase :   List[str]    					=  greatest_common_divisor(lowerCAmelCase__      ,				lowerCAmelCase__			)
			__UpperCAmelCase :   List[str]    					=  a // d
			__UpperCAmelCase :   Tuple    					=  b // d

			for i in range(lowerCAmelCase__			):
						__UpperCAmelCase :   List[Any]    					=  xa + i * q
						__UpperCAmelCase :   Tuple    					=  ya - i * p
						print(lowerCAmelCase__      ,				lowerCAmelCase__			)


def 	lowercase_						( lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int			):

			"""simple docstring"""





			if a < b:
						__UpperCAmelCase					,	__UpperCAmelCase :   List[str]    					=  b, a

			while a % b != 0:
						__UpperCAmelCase					,	__UpperCAmelCase :   Optional[int]    					=  b, a % b

			return b


def 	lowercase_						( lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int			):

			"""simple docstring"""





			assert a >= 0 and b >= 0

			if b == 0:
						__UpperCAmelCase					,	__UpperCAmelCase					,	__UpperCAmelCase :   List[str]    					=  a, 1, 0
			else:
						((__UpperCAmelCase)					,	(__UpperCAmelCase)					,	(__UpperCAmelCase)) :   str    					=  extended_gcd(lowerCAmelCase__      ,				a % b			)
						__UpperCAmelCase :   Optional[Any]    					=  q
						__UpperCAmelCase :   Dict    					=  p - q * (a // b)

			assert a % d == 0 and b % d == 0
			assert d == a * x + b * y

			return (d, x, y)


if __name__ == "__main__":
					from doctest import testmod

					testmod(name='''diophantine''', verbose=True)
					testmod(name='''diophantine_all_soln''', verbose=True)
					testmod(name='''extended_gcd''', verbose=True)
					testmod(name='''greatest_common_divisor''', verbose=True)




