




from __future__ import annotations

import os






class 			A			:
     """simple docstring"""

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

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




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




     @property
     def  __snake_case   (    self  :   List[Any]			)				->       Dict:
           return self._hand




     def  __snake_case   (    self  :   List[str]	,  A__  :   Tuple			)				->       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  :   Tuple			)				->       str:
           lowerCamelCase__        =				PokerHand._HAND_NAME[self._hand_type - 1_4]
           lowerCamelCase__        =				PokerHand._CARD_NAME[self._high_card]
           lowerCamelCase__        =				PokerHand._CARD_NAME[self._first_pair]
           lowerCamelCase__        =				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]:
                 lowerCamelCase__        =				'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  :   Dict	,  A__  :   List[Any]			)				->       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  :   Tuple			)				->       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  :   Optional[Any]			)				->       bool:
           return len(self._card_suit			) == 1




     def  __snake_case   (    self  :   List[Any]			)				->       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
                       lowerCamelCase__        =				self._card_values.pop(0			)
                       self._card_values.append(__SCREAMING_SNAKE_CASE			)
                 return True
           return False




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




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




     def __repr__(    self  :   str			)				->       Any:
           return F"""{self.__class__}(\"{self._hand}\")"""




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




     def __eq__(    self  :   List[Any]	,  A__  :   Tuple			)				->       List[str]:
           if isinstance(__SCREAMING_SNAKE_CASE	,  __SCREAMING_SNAKE_CASE			):
                 return self.compare_with(__SCREAMING_SNAKE_CASE			) == "Tie"
           return NotImplemented




     def __lt__(    self  :   List[str]	,  A__  :   int			)				->       Dict:
           if isinstance(__SCREAMING_SNAKE_CASE	,  __SCREAMING_SNAKE_CASE			):
                 return self.compare_with(__SCREAMING_SNAKE_CASE			) == "Loss"
           return NotImplemented




     def __le__(    self  :   List[str]	,  A__  :   int			)				->       Tuple:
           if isinstance(__SCREAMING_SNAKE_CASE	,  __SCREAMING_SNAKE_CASE			):
                 return self < other or self == other
           return NotImplemented




     def __gt__(    self  :   Dict	,  A__  :   Any			)				->       Optional[int]:
           if isinstance(__SCREAMING_SNAKE_CASE	,  __SCREAMING_SNAKE_CASE			):
                 return not self < other and self != other
           return NotImplemented




     def __ge__(    self  :   str	,  A__  :   Dict			)				->       List[str]:
           if isinstance(__SCREAMING_SNAKE_CASE	,  __SCREAMING_SNAKE_CASE			):
                 return not self < other
           return NotImplemented




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





def 			lowerCAmelCase_			(  )					->			int:


      '''simple docstring'''




      lowerCamelCase__        =				0
      lowerCamelCase__        =				os.path.abspath(os.path.dirname(snake_case__						)						)
      lowerCamelCase__        =				os.path.join(snake_case__     ,				'poker_hands.txt'						)
      with open(snake_case__						) as file_hand:
            for line in file_hand:
                  lowerCamelCase__        =				line[:14].strip()
                  lowerCamelCase__        =				line[15:].strip()
                  lowerCamelCase__  ,		lowerCamelCase__        =				PokerHand(snake_case__						), PokerHand(snake_case__						)
                  lowerCamelCase__        =				player.compare_with(snake_case__						)
                  if output == "Win":
                        answer += 1
      return answer


if __name__ == "__main__":
      solution()





def 			lowerCAmelCase_			(  lowerCamelCase:       int     ,				lowerCamelCase:       list[tuple[int, int, int]]						)					->			list[tuple[int, int, int]]:


      '''simple docstring'''




      lowerCamelCase__        =				sorted(lowerCamelCase     ,				key=lambda lowerCamelCase						: edge[2]						)

      lowerCamelCase__        =				list(range(lowerCamelCase						)						)

      def find_parent(lowerCamelCase:       int						):
            if i != parent[i]:
                  lowerCamelCase__        =				find_parent(parent[i]						)
            return parent[i]

      lowerCamelCase__        =				0
      lowerCamelCase__        =				[]

      for edge in edges:
            lowerCamelCase__        =				find_parent(edge[0]						)
            lowerCamelCase__        =				find_parent(edge[1]						)
            if parent_a != parent_b:
                  minimum_spanning_tree_cost += edge[2]
                  minimum_spanning_tree.append(lowerCamelCase						)
                  lowerCamelCase__        =				parent_b

      return minimum_spanning_tree


if __name__ == "__main__":  # pragma: no cover
      __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    :   Tuple       =list(map(int, input().strip().split()))
      __SCREAMING_SNAKE_CASE    :   Optional[Any]       =[]

      for _ in range(num_edges):
            __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    :   Optional[int]       =(int(x) for x in input().strip().split())
            edges.append((nodea, nodea, cost))

      kruskal(num_nodes, edges)