



'''simple docstring'''







from __future__ import annotations

import os




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

			__snake_case  :		List[str]		=      (
			    '',  # placeholder as tuples are zero-indexed
			    'One',
			    'Two',
			    'Three',
			    'Four',
			    'Five',
			    'Six',
			    'Seven',
			    'Eight',
			    'Nine',
			    'Ten',
			    'Jack',
			    'Queen',
			    'King',
			    'Ace',
			)






			def __init__(   self  :							Dict      ,       SCREAMING_SNAKE_CASE  :							Union[str, Any]	):




					"""simple docstring"""







					if not isinstance(lowercase_      ,       lowercase_	):
							SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      f'Hand should be of type \'str\': {hand!r}'
							raise TypeError(lowercase_	)
					# split removes duplicate whitespaces so no need of strip
					if len(hand.split(' '	)	) != 5:
							SCREAMING_SNAKE_CASE_						:Optional[int]										=      f'Hand should contain only 5 cards: {hand!r}'
							raise ValueError(lowercase_	)
					SCREAMING_SNAKE_CASE_						:str										=      hand
					SCREAMING_SNAKE_CASE_						:str										=      0
					SCREAMING_SNAKE_CASE_						:List[str]										=      0
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      self._internal_state()
					SCREAMING_SNAKE_CASE_						:List[Any]										=      self._get_hand_type()
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      self._card_values[0]






			@property
			def 				_lowercase	(   self  :							Optional[Any]	):




					"""simple docstring"""







					return self._hand






			def 				_lowercase	(   self  :							int      ,       SCREAMING_SNAKE_CASE  :							Optional[Any]	):




					"""simple docstring"""







					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(lowercase_	)
							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  :							Dict	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Tuple										=      PokerHand._HAND_NAME[self._hand_type - 14]
					SCREAMING_SNAKE_CASE_						:List[Any]										=      PokerHand._CARD_NAME[self._high_card]
					SCREAMING_SNAKE_CASE_						:Any										=      PokerHand._CARD_NAME[self._first_pair]
					SCREAMING_SNAKE_CASE_						: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]:
							SCREAMING_SNAKE_CASE_						:List[str]										=      "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      ,       SCREAMING_SNAKE_CASE  :							Dict	):




					"""simple docstring"""







					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[Any]	):




					"""simple docstring"""







					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  :							Any	):




					"""simple docstring"""







					return len(self._card_suit	) == 1






			def 				_lowercase	(   self  :							Any	):




					"""simple docstring"""







					if sorted(self._card_values	) == [2, 3, 4, 5, 14]:
							if self._card_values[0] == 14:
									# Remember, our list is sorted in reverse order
									SCREAMING_SNAKE_CASE_						:Optional[int]										=      self._card_values.pop(0	)
									self._card_values.append(lowercase_	)
							return True
					return False






			def 				_lowercase	(   self  :							int	):




					"""simple docstring"""







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






			def 				_lowercase	(   self  :							Dict	):




					"""simple docstring"""







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






			def 				_lowercase	(   self  :							Dict	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:dict										=      {"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
					SCREAMING_SNAKE_CASE_						:Tuple										=      self._hand.translate(str.maketrans(lowercase_	)	).split()
					SCREAMING_SNAKE_CASE_						:Dict										=      [int(card[:-1]	) for card in new_hand]
					SCREAMING_SNAKE_CASE_						:Tuple										=      {card[-1] for card in new_hand}
					return sorted(lowercase_      ,       reverse=lowercase_	), card_suit






			def __repr__(   self  :							Optional[Any]	):




					"""simple docstring"""







					return f'{self.__class__}("{self._hand}")'






			def __str__(   self  :							List[str]	):




					"""simple docstring"""







					return self._hand






			def __eq__(   self  :							Optional[Any]      ,       SCREAMING_SNAKE_CASE  :							int	):




					"""simple docstring"""







					if isinstance(lowercase_      ,       lowercase_	):
							return self.compare_with(lowercase_	) == "Tie"
					return NotImplemented






			def __lt__(   self  :							Union[str, Any]      ,       SCREAMING_SNAKE_CASE  :							Optional[int]	):




					"""simple docstring"""







					if isinstance(lowercase_      ,       lowercase_	):
							return self.compare_with(lowercase_	) == "Loss"
					return NotImplemented






			def __le__(   self  :							int      ,       SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					if isinstance(lowercase_      ,       lowercase_	):
							return self < other or self == other
					return NotImplemented






			def __gt__(   self  :							int      ,       SCREAMING_SNAKE_CASE  :							Any	):




					"""simple docstring"""







					if isinstance(lowercase_      ,       lowercase_	):
							return not self < other and self != other
					return NotImplemented






			def __ge__(   self  :							str      ,       SCREAMING_SNAKE_CASE  :							Optional[Any]	):




					"""simple docstring"""







					if isinstance(lowercase_      ,       lowercase_	):
							return not self < other
					return NotImplemented






			def __hash__(   self  :							Any	):




					"""simple docstring"""







					return object.__hash__(self	)







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


if __name__ == "__main__":
							solution()


'''simple docstring'''
import itertools

def     UpperCamelCase_  (						__SCREAMING_SNAKE_CASE = 1_0_0_0_0_0_0							):
    """simple docstring"""






    snake_case_			:     Optional[int]        =    [1]

    for i in itertools.count(len(__SCREAMING_SNAKE_CASE							)							):
        snake_case_			:     str        =    0
        for j in itertools.count(1							):
            snake_case_			:     List[str]        =    -1 if j % 2 == 0 else +1
            snake_case_			:     str        =    (j * j * 3 - j) // 2
            if index > i:
                break
            item += partitions[i - index] * sign
            item %= number
            index += j
            if index > i:
                break
            item += partitions[i - index] * sign
            item %= number

        if item == 0:
            return i
        partitions.append(__SCREAMING_SNAKE_CASE							)

    return 0


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  print(f"""{solution() = }""")




