
import argparse
import os

import align
import numpy as np
import requests
import tensorflow as tf
import torch
from PIL import Image
from tokenizer import Tokenizer

from transformers import (
    AlignConfig,
    AlignModel,
    AlignProcessor,
    BertConfig,
    BertTokenizer,
    EfficientNetConfig,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_UpperCamelCase:					str     =logging.get_logger(__name__)



def 	_a  (					__SCREAMING_SNAKE_CASE					:  Any    ):






  """simple docstring"""




  _lowerCAmelCase						=		tf.image.resize(__SCREAMING_SNAKE_CASE		,				(346, 346)    )
  _lowerCAmelCase						=		tf.image.crop_to_bounding_box(__SCREAMING_SNAKE_CASE		,				(346 - 289) // 2		,				(346 - 289) // 2		,				289		,				289    )
  return image



def 	_a  (					):






  """simple docstring"""




  _lowerCAmelCase						=		EfficientNetConfig.from_pretrained('google/efficientnet-b7'    )
  _lowerCAmelCase						=		289
  _lowerCAmelCase						=		640
  _lowerCAmelCase						=		{'0': 'LABEL_0', '1': 'LABEL_1'}
  _lowerCAmelCase						=		{'LABEL_0': 0, 'LABEL_1': 1}
  _lowerCAmelCase						=		[]

  _lowerCAmelCase						=		BertConfig()
  _lowerCAmelCase						=		AlignConfig.from_text_vision_configs(
      text_config=__SCREAMING_SNAKE_CASE		,				vision_config=__SCREAMING_SNAKE_CASE		,				projection_dim=640    )
  return config



def 	_a  (					):






  """simple docstring"""




  _lowerCAmelCase						=		'http://images.cocodataset.org/val2017/000000039769.jpg'
  _lowerCAmelCase						=		Image.open(requests.get(__SCREAMING_SNAKE_CASE		,				stream=__SCREAMING_SNAKE_CASE    ).raw    )
  return im



def 	_a  (					):






  """simple docstring"""




  _lowerCAmelCase						=		EfficientNetImageProcessor(
      do_center_crop=__SCREAMING_SNAKE_CASE		,				rescale_factor=1 / 1_2_7.5		,				rescale_offset=__SCREAMING_SNAKE_CASE		,				do_normalize=__SCREAMING_SNAKE_CASE		,				include_top=__SCREAMING_SNAKE_CASE		,				resample=Image.BILINEAR		,				)
  _lowerCAmelCase						=		BertTokenizer.from_pretrained('bert-base-uncased'    )
  _lowerCAmelCase						=		64
  _lowerCAmelCase						=		AlignProcessor(image_processor=__SCREAMING_SNAKE_CASE		,				tokenizer=__SCREAMING_SNAKE_CASE    )
  return processor



def 	_a  (					__SCREAMING_SNAKE_CASE					:  Tuple    ):






  """simple docstring"""




  _lowerCAmelCase						=		[v.split('_'    )[0].split('block'    )[1] for v in original_param_names if v.startswith('block'    )]
  _lowerCAmelCase						=		list(set(__SCREAMING_SNAKE_CASE    )    )
  _lowerCAmelCase						=		sorted(__SCREAMING_SNAKE_CASE    )
  _lowerCAmelCase						=		len(__SCREAMING_SNAKE_CASE    )
  _lowerCAmelCase						=		{b: str(__SCREAMING_SNAKE_CASE    ) for b, i in zip(__SCREAMING_SNAKE_CASE		,				range(__SCREAMING_SNAKE_CASE    )    )}

  _lowerCAmelCase						=		[]
  rename_keys.append(('stem_conv/kernel:0', 'embeddings.convolution.weight')    )
  rename_keys.append(('stem_bn/gamma:0', 'embeddings.batchnorm.weight')    )
  rename_keys.append(('stem_bn/beta:0', 'embeddings.batchnorm.bias')    )
  rename_keys.append(('stem_bn/moving_mean:0', 'embeddings.batchnorm.running_mean')    )
  rename_keys.append(('stem_bn/moving_variance:0', 'embeddings.batchnorm.running_var')    )

  for b in block_names:
    _lowerCAmelCase						=		block_name_mapping[b]
    rename_keys.append((f'''block{b}_expand_conv/kernel:0''', f'''encoder.blocks.{hf_b}.expansion.expand_conv.weight''')    )
    rename_keys.append((f'''block{b}_expand_bn/gamma:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.weight''')    )
    rename_keys.append((f'''block{b}_expand_bn/beta:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.bias''')    )
    rename_keys.append(
        (f'''block{b}_expand_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_mean''')    )
    rename_keys.append(
        (f'''block{b}_expand_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_var''')    )
    rename_keys.append(
        (f'''block{b}_dwconv/depthwise_kernel:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight''')    )
    rename_keys.append((f'''block{b}_bn/gamma:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight''')    )
    rename_keys.append((f'''block{b}_bn/beta:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias''')    )
    rename_keys.append(
        (f'''block{b}_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean''')    )
    rename_keys.append(
        (f'''block{b}_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var''')    )

    rename_keys.append((f'''block{b}_se_reduce/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.weight''')    )
    rename_keys.append((f'''block{b}_se_reduce/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.bias''')    )
    rename_keys.append((f'''block{b}_se_expand/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.weight''')    )
    rename_keys.append((f'''block{b}_se_expand/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.bias''')    )
    rename_keys.append(
        (f'''block{b}_project_conv/kernel:0''', f'''encoder.blocks.{hf_b}.projection.project_conv.weight''')    )
    rename_keys.append((f'''block{b}_project_bn/gamma:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.weight''')    )
    rename_keys.append((f'''block{b}_project_bn/beta:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.bias''')    )
    rename_keys.append(
        (f'''block{b}_project_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_mean''')    )
    rename_keys.append(
        (f'''block{b}_project_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_var''')    )

  _lowerCAmelCase						=		{}
  for item in rename_keys:
    if item[0] in original_param_names:
      _lowerCAmelCase						=		'vision_model.' + item[1]

    # BERT text encoder
  _lowerCAmelCase						=		[]
  _lowerCAmelCase						=		'tf_bert_model/bert'
  _lowerCAmelCase						=		'text_model'
  for i in range(12    ):
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/self/query/kernel:0''',
            f'''{new}.encoder.layer.{i}.attention.self.query.weight''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/self/query/bias:0''',
            f'''{new}.encoder.layer.{i}.attention.self.query.bias''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/self/key/kernel:0''',
            f'''{new}.encoder.layer.{i}.attention.self.key.weight''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/self/key/bias:0''',
            f'''{new}.encoder.layer.{i}.attention.self.key.bias''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/self/value/kernel:0''',
            f'''{new}.encoder.layer.{i}.attention.self.value.weight''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/self/value/bias:0''',
            f'''{new}.encoder.layer.{i}.attention.self.value.bias''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/output/dense/kernel:0''',
            f'''{new}.encoder.layer.{i}.attention.output.dense.weight''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/output/dense/bias:0''',
            f'''{new}.encoder.layer.{i}.attention.output.dense.bias''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/output/LayerNorm/gamma:0''',
            f'''{new}.encoder.layer.{i}.attention.output.LayerNorm.weight''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/attention/output/LayerNorm/beta:0''',
            f'''{new}.encoder.layer.{i}.attention.output.LayerNorm.bias''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/intermediate/dense/kernel:0''',
            f'''{new}.encoder.layer.{i}.intermediate.dense.weight''',
        )    )
    rename_keys.append(
        (
            f'''{old}/encoder/layer_._{i}/intermediate/dense/bias:0''',
            f'''{new}.encoder.layer.{i}.intermediate.dense.bias''',
        )    )
    rename_keys.append(
        (f'''{old}/encoder/layer_._{i}/output/dense/kernel:0''', f'''{new}.encoder.layer.{i}.output.dense.weight''')    )
    rename_keys.append(
        (f'''{old}/encoder/layer_._{i}/output/dense/bias:0''', f'''{new}.encoder.layer.{i}.output.dense.bias''')    )
    rename_keys.append(
        (f'''{old}/encoder/layer_._{i}/output/LayerNorm/gamma:0''', f'''{new}.encoder.layer.{i}.output.LayerNorm.weight''')    )
    rename_keys.append(
        (f'''{old}/encoder/layer_._{i}/output/LayerNorm/beta:0''', f'''{new}.encoder.layer.{i}.output.LayerNorm.bias''')    )

  rename_keys.append((f'''{old}/embeddings/word_embeddings/weight:0''', f'''{new}.embeddings.word_embeddings.weight''')    )
  rename_keys.append(
      (f'''{old}/embeddings/position_embeddings/embeddings:0''', f'''{new}.embeddings.position_embeddings.weight''')    )
  rename_keys.append(
      (f'''{old}/embeddings/token_type_embeddings/embeddings:0''', f'''{new}.embeddings.token_type_embeddings.weight''')    )
  rename_keys.append((f'''{old}/embeddings/LayerNorm/gamma:0''', f'''{new}.embeddings.LayerNorm.weight''')    )
  rename_keys.append((f'''{old}/embeddings/LayerNorm/beta:0''', f'''{new}.embeddings.LayerNorm.bias''')    )

  rename_keys.append((f'''{old}/pooler/dense/kernel:0''', f'''{new}.pooler.dense.weight''')    )
  rename_keys.append((f'''{old}/pooler/dense/bias:0''', f'''{new}.pooler.dense.bias''')    )
  rename_keys.append(('dense/kernel:0', 'text_projection.weight')    )
  rename_keys.append(('dense/bias:0', 'text_projection.bias')    )
  rename_keys.append(('dense/bias:0', 'text_projection.bias')    )
  rename_keys.append(('temperature:0', 'temperature')    )

  for item in rename_keys:
    if item[0] in original_param_names:
      _lowerCAmelCase						=		item[1]
  return key_mapping



def 	_a  (					__SCREAMING_SNAKE_CASE					:  List[str]		,				__SCREAMING_SNAKE_CASE					:  Any		,				__SCREAMING_SNAKE_CASE					:  Union[str, Any]    ):






  """simple docstring"""




  list(hf_params.keys()    )

  for key, value in tf_params.items():
    if key not in key_mapping:
      continue

    _lowerCAmelCase						=		key_mapping[key]
    if "_conv" in key and "kernel" in key:
      _lowerCAmelCase						=		torch.from_numpy(__SCREAMING_SNAKE_CASE    ).permute(3		,				2		,				0		,				1    )
    elif "embeddings" in key:
      _lowerCAmelCase						=		torch.from_numpy(__SCREAMING_SNAKE_CASE    )
    elif "depthwise_kernel" in key:
      _lowerCAmelCase						=		torch.from_numpy(__SCREAMING_SNAKE_CASE    ).permute(2		,				3		,				0		,				1    )
    elif "kernel" in key:
      _lowerCAmelCase						=		torch.from_numpy(np.transpose(__SCREAMING_SNAKE_CASE    )    )
    elif "temperature" in key:
      _lowerCAmelCase						=		value
    elif "bn/gamma" or "bn/beta" in key:
      _lowerCAmelCase						=		torch.from_numpy(np.transpose(__SCREAMING_SNAKE_CASE    )    ).squeeze()
    else:
      _lowerCAmelCase						=		torch.from_numpy(__SCREAMING_SNAKE_CASE    )

    # Replace HF parameters with original TF model parameters
    hf_params[hf_key].copy_(__SCREAMING_SNAKE_CASE    )



@torch.no_grad()
def 	_a  (					__SCREAMING_SNAKE_CASE					:  Any		,				__SCREAMING_SNAKE_CASE					:  str		,				__SCREAMING_SNAKE_CASE					:  List[str]		,				__SCREAMING_SNAKE_CASE					:  Dict    ):






  """simple docstring"""




  _lowerCAmelCase						=		64
  _lowerCAmelCase						=		Tokenizer(__SCREAMING_SNAKE_CASE    )
  _lowerCAmelCase						=		align.Align('efficientnet-b7'		,				'bert-base'		,				640		,				__SCREAMING_SNAKE_CASE		,				tok.get_vocab_size()    )
  original_model.compile()
  original_model.load_weights(__SCREAMING_SNAKE_CASE    )

  _lowerCAmelCase						=		original_model.trainable_variables
  _lowerCAmelCase						=		original_model.non_trainable_variables
  _lowerCAmelCase						=		{param.name: param.numpy() for param in tf_params}
  for param in tf_non_train_params:
    _lowerCAmelCase						=		param.numpy()
  _lowerCAmelCase						=		list(tf_params.keys()    )

  # Load HuggingFace model
  _lowerCAmelCase						=		get_align_config()
  _lowerCAmelCase						=		AlignModel(__SCREAMING_SNAKE_CASE    ).eval()
  _lowerCAmelCase						=		hf_model.state_dict()

  # Create src-to-dst parameter name mapping dictionary
  print('Converting parameters...'    )
  _lowerCAmelCase						=		rename_keys(__SCREAMING_SNAKE_CASE    )
  replace_params(__SCREAMING_SNAKE_CASE		,				__SCREAMING_SNAKE_CASE		,				__SCREAMING_SNAKE_CASE    )

  # Initialize processor
  _lowerCAmelCase						=		get_processor()
  _lowerCAmelCase						=		processor(
      images=prepare_img()		,				text='A picture of a cat'		,				padding='max_length'		,				max_length=64		,				return_tensors='pt'    )

  # HF model inference
  hf_model.eval()
  with torch.no_grad():
    _lowerCAmelCase						=		hf_model(**__SCREAMING_SNAKE_CASE    )

  _lowerCAmelCase						=		outputs.image_embeds.detach().numpy()
  _lowerCAmelCase						=		outputs.text_embeds.detach().numpy()

  # Original model inference
  _lowerCAmelCase						=		False
  _lowerCAmelCase						=		EfficientNetImageProcessor(
      do_center_crop=__SCREAMING_SNAKE_CASE		,				do_rescale=__SCREAMING_SNAKE_CASE		,				do_normalize=__SCREAMING_SNAKE_CASE		,				include_top=__SCREAMING_SNAKE_CASE		,				resample=Image.BILINEAR		,				)
  _lowerCAmelCase						=		tf_image_processor(images=prepare_img()		,				return_tensors='tf'		,				data_format='channels_last'    )['pixel_values']
  _lowerCAmelCase						=		tok(tf.constant(['A picture of a cat']    )    )

  _lowerCAmelCase						=		original_model.image_encoder(__SCREAMING_SNAKE_CASE		,				training=__SCREAMING_SNAKE_CASE    )
  _lowerCAmelCase						=		original_model.text_encoder(__SCREAMING_SNAKE_CASE		,				training=__SCREAMING_SNAKE_CASE    )

  _lowerCAmelCase						=		tf.nn.la_normalize(__SCREAMING_SNAKE_CASE		,				axis=-1    )
  _lowerCAmelCase						=		tf.nn.la_normalize(__SCREAMING_SNAKE_CASE		,				axis=-1    )

  # Check whether original and HF model outputs match  -> np.allclose
  if not np.allclose(__SCREAMING_SNAKE_CASE		,				__SCREAMING_SNAKE_CASE		,				atol=1E-3    ):
    raise ValueError('The predicted image features are not the same.'    )
  if not np.allclose(__SCREAMING_SNAKE_CASE		,				__SCREAMING_SNAKE_CASE		,				atol=1E-3    ):
    raise ValueError('The predicted text features are not the same.'    )
  print('Model outputs match!'    )

  if save_model:
    # Create folder to save model
    if not os.path.isdir(__SCREAMING_SNAKE_CASE    ):
      os.mkdir(__SCREAMING_SNAKE_CASE    )
    # Save converted model and image processor
    hf_model.save_pretrained(__SCREAMING_SNAKE_CASE    )
    processor.save_pretrained(__SCREAMING_SNAKE_CASE    )

  if push_to_hub:
    # Push model and image processor to hub
    print('Pushing converted ALIGN to the hub...'    )
    processor.push_to_hub('align-base'    )
    hf_model.push_to_hub('align-base'    )


if __name__ == "__main__":
       _UpperCamelCase:					str     =argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '--checkpoint_path',
           default='./weights/model-weights',
           type=str,
           help='Path to the pretrained TF ALIGN checkpoint.',
       )
       parser.add_argument(
           '--pytorch_dump_folder_path',
           default='hf_model',
           type=str,
           help='Path to the output PyTorch model directory.',
       )
       parser.add_argument('--save_model', action='store_true', help='Save model to local')
       parser.add_argument('--push_to_hub', action='store_true', help='Push model and image processor to the hub')

       _UpperCamelCase:					List[str]     =parser.parse_args()
       convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)


from __future__ import annotations

import os





class 						__lowercase:


       """simple docstring"""







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

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



       def __init__(     self					:			Dict  ,      _lowerCAmelCase					:			str       )					->   None:
         if not isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           _lowerCAmelCase						=		F'''Hand should be of type \'str\': {hand!r}'''
           raise TypeError(_lowerCAmelCase       )
         # 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(_lowerCAmelCase       )
         _lowerCAmelCase						=		hand
         _lowerCAmelCase						=		0
         _lowerCAmelCase						=		0
         _lowerCAmelCase	,       _lowerCAmelCase						=		self._internal_state()
         _lowerCAmelCase						=		self._get_hand_type()
         _lowerCAmelCase						=		self._card_values[0]



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



       def SCREAMING_SNAKE_CASE_				(     self					:			int  ,      _lowerCAmelCase					:			PokerHand       )					->   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(_lowerCAmelCase       )
           else:
             return "Win" if self._second_pair > other._second_pair else "Loss"
         return "Win" if self._first_pair > other._first_pair else "Loss"



       def SCREAMING_SNAKE_CASE_				(     self					:			str       )					->   str:
         _lowerCAmelCase						=		PokerHand._HAND_NAME[self._hand_type - 14]
         _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 [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						=		'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 SCREAMING_SNAKE_CASE_				(     self					:			Any  ,      _lowerCAmelCase					:			PokerHand       )					->   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 SCREAMING_SNAKE_CASE_				(     self					:			Optional[Any]       )					->   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 SCREAMING_SNAKE_CASE_				(     self					:			Any       )					->   bool:
         return len(self._card_suit       ) == 1



       def SCREAMING_SNAKE_CASE_				(     self					:			str       )					->   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
             _lowerCAmelCase						=		self._card_values.pop(0       )
             self._card_values.append(_lowerCAmelCase       )
           return True
         return False



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



       def SCREAMING_SNAKE_CASE_				(     self					:			Dict       )					->   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(_lowerCAmelCase  ,      _lowerCAmelCase       )
         _lowerCAmelCase						=		min(_lowerCAmelCase  ,      _lowerCAmelCase       )
         # 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(_lowerCAmelCase       ) != 3:
           _lowerCAmelCase	,       _lowerCAmelCase						=		second, first
         _lowerCAmelCase						=		first
         _lowerCAmelCase						=		second
         return kind



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[int]       )					->   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(_lowerCAmelCase       )       ).split()
         _lowerCAmelCase						=		[int(card[:-1]       ) for card in new_hand]
         _lowerCAmelCase						=		{card[-1] for card in new_hand}
         return sorted(_lowerCAmelCase  ,      reverse=_lowerCAmelCase       ), card_suit



       def __repr__(     self					:			Tuple       )					->   Optional[Any]:
         return F'''{self.__class__}("{self._hand}")'''



       def __str__(     self					:			Optional[int]       )					->   Union[str, Any]:
         return self._hand



       def __eq__(     self					:			Optional[int]  ,      _lowerCAmelCase					:			str       )					->   Tuple:
         if isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           return self.compare_with(_lowerCAmelCase       ) == "Tie"
         return NotImplemented



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



       def __le__(     self					:			str  ,      _lowerCAmelCase					:			Dict       )					->   str:
         if isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           return self < other or self == other
         return NotImplemented



       def __gt__(     self					:			Union[str, Any]  ,      _lowerCAmelCase					:			List[Any]       )					->   int:
         if isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           return not self < other and self != other
         return NotImplemented



       def __ge__(     self					:			Dict  ,      _lowerCAmelCase					:			Dict       )					->   Optional[Any]:
         if isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           return not self < other
         return NotImplemented






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



def 	_a  (					):






  """simple docstring"""




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


if __name__ == "__main__":
       solution()
