



from __future__ import annotations

import os


class    _lowercase :
				'''simple docstring'''







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

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

				def __init__(			self  ,			snake_case__     ):

									'''simple docstring'''


									if not isinstance(snake_case__  ,			snake_case__     ):
														UpperCamelCase_			= F"""Hand should be of type 'str': {hand!r}"""
														raise TypeError(snake_case__     )
									# split removes duplicate whitespaces so no need of strip
									if len(hand.split(" "     )     ) != 5:
														UpperCamelCase_			= F"""Hand should contain only 5 cards: {hand!r}"""
														raise ValueError(snake_case__     )
									UpperCamelCase_			= hand
									UpperCamelCase_			= 0
									UpperCamelCase_			= 0
									UpperCamelCase_	,     UpperCamelCase_			= self._internal_state()
									UpperCamelCase_			= self._get_hand_type()
									UpperCamelCase_			= self._card_values[0]

				@property
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									return self._hand

				def    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''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(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    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= PokerHand._HAND_NAME[self._hand_type - 14]
									UpperCamelCase_			= PokerHand._CARD_NAME[self._high_card]
									UpperCamelCase_			= PokerHand._CARD_NAME[self._first_pair]
									UpperCamelCase_			= 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_			= "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    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''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    _lowerCamelCase       (			self     ):

									'''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    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									return len(self._card_suit     ) == 1

				def    _lowerCamelCase       (			self     ):

									'''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
																			UpperCamelCase_			= self._card_values.pop(0     )
																			self._card_values.append(snake_case__     )
														return True
									return False

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


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

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


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

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


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

				def __repr__(			self     ):

									'''simple docstring'''


									return F"""{self.__class__}(\"{self._hand}\")"""

				def __str__(			self     ):

									'''simple docstring'''


									return self._hand

				def __eq__(			self  ,			snake_case__     ):

									'''simple docstring'''


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

				def __lt__(			self  ,			snake_case__     ):

									'''simple docstring'''


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

				def __le__(			self  ,			snake_case__     ):

									'''simple docstring'''


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

				def __gt__(			self  ,			snake_case__     ):

									'''simple docstring'''


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

				def __ge__(			self  ,			snake_case__     ):

									'''simple docstring'''


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

				def __hash__(			self     ):

									'''simple docstring'''


									return object.__hash__(self     )




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


if __name__ == "__main__":
	solution()

"""simple docstring"""






from __future__ import annotations



def     a_		(   lowerCamelCase			):
				for r in range(1   ,     lowerCamelCase			):
								UpperCAmelCase__			 =				[]
								for x in range(n - 1			):
												UpperCAmelCase__			 =				pow(lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			)
												if val in li:
																break
												li.append(lowerCamelCase			)
								else:
												return r
				return None


if __name__ == "__main__":
						lowerCAmelCase__    :    Any			=      int(input('Enter a prime number q: '))
						lowerCAmelCase__    :    List[str]			=      find_primitive(q)
						if a is None:
												print(F"""Cannot find the primitive for the value: {a!r}""")
						else:
												lowerCAmelCase__    :    str			=      int(input('Enter private key of A: '))
												lowerCAmelCase__    :    List[Any]			=      pow(a, a_private, q)
												lowerCAmelCase__    :    List[str]			=      int(input('Enter private key of B: '))
												lowerCAmelCase__    :    Any			=      pow(a, b_private, q)

												lowerCAmelCase__    :    Union[str, Any]			=      pow(b_public, a_private, q)
												lowerCAmelCase__    :    Tuple			=      pow(a_public, b_private, q)

												print('The key value generated by A is: ', a_secret)
												print('The key value generated by B is: ', b_secret)



