code: 
  
  
  
  from __future__ import annotations
  
  import os
  
  
  
  class        lowerCAmelCase_	:
  							UpperCAmelCase__       :      Optional[int]       =						(
  							    "High card",
  							    "One pair",
  							    "Two pairs",
  							    "Three of a kind",
  							    "Straight",
  							    "Flush",
  							    "Full house",
  							    "Four of a kind",
  							    "Straight flush",
  							    "Royal flush",
  							)
  
  							UpperCAmelCase__       :      Any       =						(
  							    "",  # placeholder as tuples are zero-indexed
  							    "One",
  							    "Two",
  							    "Three",
  							    "Four",
  							    "Five",
  							    "Six",
  							    "Seven",
  							    "Eight",
  							    "Nine",
  							    "Ten",
  							    "Jack",
  							    "Queen",
  							    "King",
  							    "Ace",
  							)
  							def __init__(    self,    SCREAMING_SNAKE_CASE_ )  ->	None:
  										if not isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
  													UpperCamelCase					:						str					=			F"""Hand should be of type 'str': {hand!r}"""
  													raise TypeError(SCREAMING_SNAKE_CASE_ )
  										# split removes duplicate whitespaces so no need of strip
  										if len(hand.split(' ' ) ) != 5:
  													UpperCamelCase					:						Any					=			F"""Hand should contain only 5 cards: {hand!r}"""
  													raise ValueError(SCREAMING_SNAKE_CASE_ )
  										UpperCamelCase					:						Optional[Any]					=			hand
  										UpperCamelCase					:						int					=			0
  										UpperCamelCase					:						Union[str, Any]					=			0
  										UpperCamelCase					:						str					=			self._internal_state()
  										UpperCamelCase					:						Tuple					=			self._get_hand_type()
  										UpperCamelCase					:						Any					=			self._card_values[0]
  							@property
  							def       snake_case_ (    self )  ->	Optional[Any]:
  										return self._hand
  							def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	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(SCREAMING_SNAKE_CASE_ )
  													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 )  ->	str:
  										UpperCamelCase					:						str					=			PokerHand._HAND_NAME[self._hand_type - 14]
  										UpperCamelCase					:						Union[str, Any]					=			PokerHand._CARD_NAME[self._high_card]
  										UpperCamelCase					:						str					=			PokerHand._CARD_NAME[self._first_pair]
  										UpperCamelCase					:						Dict					=			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					:						Union[str, 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       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	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 )  ->	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       snake_case_ (    self )  ->	bool:
  										return len(self._card_suit ) == 1
  							def       snake_case_ (    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[Any]					=			self._card_values.pop(0 )
  																self._card_values.append(SCREAMING_SNAKE_CASE_ )
  													return True
  										return False
  							def       snake_case_ (    self )  ->	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 )  ->	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
  										UpperCamelCase					:						List[Any]					=			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					:						List[Any]					=			self._card_values[i]
  																			kind += 1
  																elif vala == self._card_values[i]:
  																			kind += 2
  																elif not vala:
  																			UpperCamelCase					:						int					=			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					:						Optional[Any]					=			kind + 2 if kind in [4, 5] else kind
  										# first meaning first pair to compare in 'compare_with'
  										UpperCamelCase					:						str					=			max(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
  										UpperCamelCase					:						Optional[Any]					=			min(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
  										# 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(SCREAMING_SNAKE_CASE_ ) != 3:
  													UpperCamelCase					:						int					=			second, first
  										UpperCamelCase					:						Optional[Any]					=			first
  										UpperCamelCase					:						Union[str, Any]					=			second
  										return kind
  							def       snake_case_ (    self )  ->	tuple[list[int], set[str]]:
  										# Internal representation of hand as a list of card values and
  										# a set of card suit
  										UpperCamelCase					:						dict					=			{"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
  										UpperCamelCase					:						int					=			self._hand.translate(str.maketrans(SCREAMING_SNAKE_CASE_ ) ).split()
  										UpperCamelCase					:						Dict					=			[int(card[:-1] ) for card in new_hand]
  										UpperCamelCase					:						Dict					=			{card[-1] for card in new_hand}
  										return sorted(SCREAMING_SNAKE_CASE_,    reverse=SCREAMING_SNAKE_CASE_ ), card_suit
  							def __repr__(    self )  ->	Dict:
  										return F"""{self.__class__}(\"{self._hand}\")"""
  							def __str__(    self )  ->	int:
  										return self._hand
  							def __eq__(    self,    SCREAMING_SNAKE_CASE_ )  ->	str:
  										if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
  													return self.compare_with(SCREAMING_SNAKE_CASE_ ) == "Tie"
  										return NotImplemented
  							def __lt__(    self,    SCREAMING_SNAKE_CASE_ )  ->	Optional[int]:
  										if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
  													return self.compare_with(SCREAMING_SNAKE_CASE_ ) == "Loss"
  										return NotImplemented
  							def __le__(    self,    SCREAMING_SNAKE_CASE_ )  ->	Union[str, Any]:
  										if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
  													return self < other or self == other
  										return NotImplemented
  							def __gt__(    self,    SCREAMING_SNAKE_CASE_ )  ->	Tuple:
  										if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
  													return not self < other and self != other
  										return NotImplemented
  							def __ge__(    self,    SCREAMING_SNAKE_CASE_ )  ->	Any:
  										if isinstance(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
  													return not self < other
  										return NotImplemented
  
  
  
  
  
  
  							def __hash__(    self )  ->	Union[str, Any]:
  										return object.__hash__(self )
  
  
  
  
  
  
  def 	UpperCamelCase			(     )			->  int:
  			# Solution for problem number 54 from Project Euler
  			# Input from poker_hands.txt file
  			UpperCamelCase					:						str					=			0
  			UpperCamelCase					:						Tuple					=			os.path.abspath(os.path.dirname(snake_case__			)			)
  			UpperCamelCase					:						Union[str, Any]					=			os.path.join(snake_case__ ,  'poker_hands.txt'			)
  			with open(snake_case__			) as file_hand:
  						for line in file_hand:
  									UpperCamelCase					:						Tuple					=			line[:14].strip()
  									UpperCamelCase					:						Union[str, Any]					=			line[15:].strip()
  									UpperCamelCase					:						Any					=			PokerHand(snake_case__			), PokerHand(snake_case__			)
  									UpperCamelCase					:						Union[str, Any]					=			player.compare_with(snake_case__			)
  									if output == "Win":
  												answer += 1
  			return answer
  
  
  if __name__ == "__main__":
  				solution()
  
  
  
  
style_context: 
  
  
  
  from __future__ import annotations
  
  import sys
  def 	UpperCamelCase			(     snake_case__ :					int ,  snake_case__ :					int			)			->  tuple[int, int]:
     # base cases
     if abs(snake_case__			) == 1:
        return a, 0
     elif abs(snake_case__			) == 1:
        return 0, b
  
     UpperCamelCase			,  UpperCamelCase					:						Dict					=			a, b
     UpperCamelCase			,  UpperCamelCase					:						int					=			1, 0
     UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			0, 1
  
     while remainder != 0:
        UpperCamelCase					:						str					=			old_remainder // remainder
        UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			remainder, old_remainder - quotient * remainder
        UpperCamelCase			,  UpperCamelCase					:						List[Any]					=			coeff_a, old_coeff_a - quotient * coeff_a
        UpperCamelCase			,  UpperCamelCase					:						Optional[Any]					=			coeff_b, old_coeff_b - quotient * coeff_b
  
     # sign correction for negative numbers
     if a < 0:
        UpperCamelCase					:						Dict					=			-old_coeff_a
     if b < 0:
        UpperCamelCase					:						Any					=			-old_coeff_b
  
     return old_coeff_a, old_coeff_b
  def 	UpperCamelCase			(     )			->  Tuple:
     if len(sys.argv			) < 3:
        print('2 integer arguments required'			)
        return 1
     UpperCamelCase					:						Union[str, Any]					=			int(sys.argv[1]			)
     UpperCamelCase					:						Optional[int]					=			int(sys.argv[2]			)
     print(extended_euclidean_algorithm(snake_case__ ,  snake_case__			)			)
     return 0
  
  
  if __name__ == "__main__":
      raise SystemExit(main())
  
  
  
  