


from __future__ import annotations

import os


class        A_					:




      '''simple docstring'''


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

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




      def __init__(				self:       Optional[int]						,      a:       str				):
       if not isinstance(a						,      a				):
        __lowerCamelCase		:							str							=						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:
        __lowerCamelCase		:							List[str]							=						F'Hand should contain only 5 cards: {hand!r}'
        raise ValueError(a				)
       __lowerCamelCase		:							Union[str, Any]							=						hand
       __lowerCamelCase		:							str							=						0
       __lowerCamelCase		:							Dict							=						0
       __lowerCamelCase					,     __lowerCamelCase		:							List[str]							=						self._internal_state()
       __lowerCamelCase		:							List[Any]							=						self._get_hand_type()
       __lowerCamelCase		:							List[str]							=						self._card_values[0]




      @property
      def      _snake_case	(				self:       Any				):
       return self._hand




      def      _snake_case	(				self:       List[str]						,      a:       PokerHand				):
       # 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      _snake_case	(				self:       Dict				):
       __lowerCamelCase		:							Any							=						PokerHand._HAND_NAME[self._hand_type - 14]
       __lowerCamelCase		:							Optional[Any]							=						PokerHand._CARD_NAME[self._high_card]
       __lowerCamelCase		:							Tuple							=						PokerHand._CARD_NAME[self._first_pair]
       __lowerCamelCase		:							List[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]:
        __lowerCamelCase		:							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      _snake_case	(				self:       Dict						,      a:       PokerHand				):
       # 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				):
       # 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:       Optional[Any]				):
       return len(self._card_suit				) == 1




      def      _snake_case	(				self:       int				):
       # 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
         __lowerCamelCase		:							Tuple							=						self._card_values.pop(0				)
         self._card_values.append(a				)
        return True
       return False




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




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




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




      def __repr__(				self:       Union[str, Any]				):
       return F'{self.__class__}("{self._hand}")'




      def __str__(				self:       List[Any]				):
       return self._hand




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




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




      def __le__(				self:       Any						,      a:       List[str]				):
       if isinstance(a						,      a				):
        return self < other or self == other
       return NotImplemented




      def __gt__(				self:       Optional[Any]						,      a:       int				):
       if isinstance(a						,      a				):
        return not self < other and self != other
       return NotImplemented




      def __ge__(				self:       Tuple						,      a:       Dict				):
       if isinstance(a						,      a				):
        return not self < other
       return NotImplemented




      def __hash__(				self:       Any				):
       return object.__hash__(self				)



def       UpperCamelCase__     (  ):
 # Solution for problem number 54 from Project Euler
 # Input from poker_hands.txt file
 __lowerCamelCase		:							Union[str, Any]							=						0
 __lowerCamelCase		:							int							=						os.path.abspath(os.path.dirname(SCREAMING_SNAKE_CASE__						)						)
 __lowerCamelCase		:							Optional[int]							=						os.path.join(SCREAMING_SNAKE_CASE__			,       'poker_hands.txt'						)
 with open(SCREAMING_SNAKE_CASE__						) as file_hand:
  for line in file_hand:
   __lowerCamelCase		:							List[str]							=						line[:14].strip()
   __lowerCamelCase		:							List[Any]							=						line[15:].strip()
   __lowerCamelCase					,     __lowerCamelCase		:							Any							=						PokerHand(SCREAMING_SNAKE_CASE__						), PokerHand(SCREAMING_SNAKE_CASE__						)
   __lowerCamelCase		:							int							=						player.compare_with(SCREAMING_SNAKE_CASE__						)
   if output == "Win":
    answer += 1
 return answer


if __name__ == "__main__":
       solution()





def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__ = 100						):
 __lowerCamelCase		:							List[Any]							=						[[0 for _ in range(SCREAMING_SNAKE_CASE__						)] for _ in range(m + 1						)]
 for i in range(m + 1						):
  __lowerCamelCase		:							Any							=						1

 for n in range(m + 1						):
  for k in range(1			,       SCREAMING_SNAKE_CASE__						):
   memo[n][k] += memo[n][k - 1]
   if n > k:
    memo[n][k] += memo[n - k - 1][k]

 return memo[m][m - 1] - 1


if __name__ == "__main__":
       print(solution(int(input('Enter a number: ').strip())))

