






"""simple docstring"""

from __future__ import annotations

import os

class     A_				:
				UpperCAmelCase__										=					(
				    '''High card''',
				    '''One pair''',
				    '''Two pairs''',
				    '''Three of a kind''',
				    '''Straight''',
				    '''Flush''',
				    '''Full house''',
				    '''Four of a kind''',
				    '''Straight flush''',
				    '''Royal flush''',
				)

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







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







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







				def      _snake_case       (				self				:    List[str]    ,     __lowerCamelCase				:    PokerHand						)					->       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(lowerCAmelCase__						)
																else:
																						return "Win" if self._second_pair > other._second_pair else "Loss"
										return "Win" if self._first_pair > other._first_pair else "Loss"







				def      _snake_case       (				self				:    List[Any]						)					->       str:
										__magic_name__      =  PokerHand._HAND_NAME[self._hand_type - 1_4]
										__magic_name__      =  PokerHand._CARD_NAME[self._high_card]
										__magic_name__      =  PokerHand._CARD_NAME[self._first_pair]
										__magic_name__      =  PokerHand._CARD_NAME[self._second_pair]
										if self._hand_type in [2_2, 1_9, 1_8]:
																return name + f''', {high}-high'''
										elif self._hand_type in [2_1, 1_7, 1_5]:
																return name + f''', {paira}s'''
										elif self._hand_type in [2_0, 1_6]:
																__magic_name__      =  "over" if self._hand_type == 2_0 else "and"
																return name + f''', {paira}s {join} {paira}s'''
										elif self._hand_type == 2_3:
																return name
										else:
																return name + f''', {high}'''







				def      _snake_case       (				self				:    Optional[Any]    ,     __lowerCamelCase				:    PokerHand						)					->       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      _snake_case       (				self				:    Dict						)					->       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 2_3 if sum(self._card_values						) == 6_0 else 2_2
																return 1_9
										elif self._is_five_high_straight() or self._is_straight():
																return 1_8
										return 1_4 + self._is_same_kind()







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







				def      _snake_case       (				self				:    Optional[int]						)					->       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, 1_4]:
																if self._card_values[0] == 1_4:
																						# Remember, our list is sorted in reverse order
																						__magic_name__      =  self._card_values.pop(0						)
																						self._card_values.append(lowerCAmelCase__						)
																return True
										return False







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







				def      _snake_case       (				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
										__magic_name__      =  __magic_name__      =  __magic_name__      =  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:
																												__magic_name__      =  self._card_values[i]
																												kind += 1
																						elif vala == self._card_values[i]:
																												kind += 2
																						elif not vala:
																												__magic_name__      =  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)
										__magic_name__      =  kind + 2 if kind in [4, 5] else kind
										# first meaning first pair to compare in 'compare_with'
										__magic_name__      =  max(lowerCAmelCase__    ,     lowerCAmelCase__						)
										__magic_name__      =  min(lowerCAmelCase__    ,     lowerCAmelCase__						)
										# 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(lowerCAmelCase__						) != 3:
																__magic_name__   ,     __magic_name__      =  second, first
										__magic_name__      =  first
										__magic_name__      =  second
										return kind







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







				def __repr__(				self				:    str						)					->       Tuple:
										return f'''{self.__class__}(\"{self._hand}\")'''







				def __str__(				self				:    int						)					->       int:
										return self._hand







				def __eq__(				self				:    Any    ,     __lowerCamelCase				:    Dict						)					->       Optional[Any]:
										if isinstance(lowerCAmelCase__    ,     lowerCAmelCase__						):
																return self.compare_with(lowerCAmelCase__						) == "Tie"
										return NotImplemented







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







				def __le__(				self				:    List[Any]    ,     __lowerCamelCase				:    Dict						)					->       Optional[Any]:
										if isinstance(lowerCAmelCase__    ,     lowerCAmelCase__						):
																return self < other or self == other
										return NotImplemented







				def __gt__(				self				:    List[Any]    ,     __lowerCamelCase				:    str						)					->       List[Any]:
										if isinstance(lowerCAmelCase__    ,     lowerCAmelCase__						):
																return not self < other and self != other
										return NotImplemented







				def __ge__(				self				:    Optional[Any]    ,     __lowerCamelCase				:    Any						)					->       str:
										if isinstance(lowerCAmelCase__    ,     lowerCAmelCase__						):
																return not self < other
										return NotImplemented







				def __hash__(				self				:    List[Any]						)					->       str:
										return object.__hash__(self						)






def _lowerCAmelCase						(	):

						'''simple docstring'''






						__magic_name__      =  0
						__magic_name__      =  os.path.abspath(os.path.dirname(__A ) )
						__magic_name__      =  os.path.join(__A			,    "poker_hands.txt" )
						with open(__A ) as file_hand:
												for line in file_hand:
																		__magic_name__      =  line[:1_4].strip()
																		__magic_name__      =  line[1_5:].strip()
																		__magic_name__   ,     __magic_name__      =  PokerHand(__A ), PokerHand(__A )
																		__magic_name__      =  player.compare_with(__A )
																		if output == "Win":
																								answer += 1
						return answer


if __name__ == "__main__":
			solution()






def   _lowerCAmelCase(						):

  for a in range(300      ):
    for b in range(a + 1 ,							400      ):
      for c in range(b + 1 ,							500      ):
        if (a + b + c) == 1000 and (a**2) + (b**2) == (c**2):
          return a * b * c

  return -1
def   _lowerCAmelCase(						):

  for a in range(300      ):
    for b in range(400      ):
      UpperCAmelCase          =	1000 - a - b
      if a < b < c and (a**2) + (b**2) == (c**2):
        return a * b * c

  return -1
def   _lowerCAmelCase(						):
  import timeit

  print(
      timeit.timeit("solution()" ,							setup="from __main__ import solution" ,							number=1000      )      )
  print(
      timeit.timeit(
          "solution_fast()" ,							setup="from __main__ import solution_fast" ,							number=1000      )      )


if __name__ == "__main__":
      print(f"{solution() = }")



