
import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import (
          FalconForCausalLM,
          FalconForQuestionAnswering,
          FalconForSequenceClassification,
          FalconForTokenClassification,
          FalconModel,
      )



class 		UpperCamelCase__  :
   def __init__(self :					Union[str, Any]					,				snake_case_ :					Union[str, Any]					,				snake_case_ :					List[str]=3					,				snake_case_ :					Any=7					,				snake_case_ :					int=True					,				snake_case_ :					Any=True					,				snake_case_ :					str=False					,				snake_case_ :					str=True					,				snake_case_ :					List[str]=9_9					,				snake_case_ :					Tuple=3_2					,				snake_case_ :					Any=5					,				snake_case_ :					Tuple=4					,				snake_case_ :					Dict=3_7					,				snake_case_ :					Union[str, Any]="gelu"					,				snake_case_ :					Optional[Any]=0.1					,				snake_case_ :					List[Any]=0.1					,				snake_case_ :					Dict=5_1_2					,				snake_case_ :					Tuple=1_6					,				snake_case_ :					List[str]=2					,				snake_case_ :					str=0.02					,				snake_case_ :					List[Any]=3					,				snake_case_ :					List[str]=4					,				snake_case_ :					Any=None					,				):
    __a :  int						=  parent
    __a :  int						=  batch_size
    __a :  Union[str, Any]						=  seq_length
    __a :  int						=  is_training
    __a :  Any						=  use_input_mask
    __a :  List[Any]						=  use_token_type_ids
    __a :  Optional[int]						=  use_labels
    __a :  Optional[int]						=  vocab_size
    __a :  Tuple						=  hidden_size
    __a :  str						=  num_hidden_layers
    __a :  Tuple						=  num_attention_heads
    __a :  List[str]						=  intermediate_size
    __a :  Optional[Any]						=  hidden_act
    __a :  List[str]						=  hidden_dropout_prob
    __a :  Union[str, Any]						=  attention_probs_dropout_prob
    __a :  Optional[int]						=  max_position_embeddings
    __a :  int						=  type_vocab_size
    __a :  Optional[Any]						=  type_sequence_label_size
    __a :  Optional[Any]						=  initializer_range
    __a :  Any						=  num_labels
    __a :  Any						=  num_choices
    __a :  List[str]						=  scope
   def       lowerCAmelCase			(self :					List[Any]   ):
    __a :  int						=  ids_tensor([self.batch_size, self.seq_length]					,				self.vocab_size   )

    __a :  List[str]						=  None
    if self.use_input_mask:
     __a :  Optional[Any]						=  random_attention_mask([self.batch_size, self.seq_length]   )

    __a :  str						=  None

    __a :  List[str]						=  None
    __a :  Tuple						=  None
    __a :  Dict						=  None
    if self.use_labels:
     __a :  Dict						=  ids_tensor([self.batch_size]					,				self.type_sequence_label_size   )
     __a :  str						=  ids_tensor([self.batch_size, self.seq_length]					,				self.num_labels   )
     __a :  List[Any]						=  ids_tensor([self.batch_size]					,				self.num_choices   )

    __a :  Tuple						=  self.get_config()

    return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
   def       lowerCAmelCase			(self :					Union[str, Any]   ):
    return FalconConfig(
        vocab_size=self.vocab_size					,				hidden_size=self.hidden_size					,				num_hidden_layers=self.num_hidden_layers					,				num_attention_heads=self.num_attention_heads					,				intermediate_size=self.intermediate_size					,				hidden_act=self.hidden_act					,				hidden_dropout_prob=self.hidden_dropout_prob					,				attention_probs_dropout_prob=self.attention_probs_dropout_prob					,				max_position_embeddings=self.max_position_embeddings					,				type_vocab_size=self.type_vocab_size					,				is_decoder=snake_case_					,				initializer_range=self.initializer_range					,				pad_token_id=1					,				new_decoder_architecture=snake_case_					,				)
   def       lowerCAmelCase			(self :					int					,				snake_case_ :					str					,				snake_case_ :					Union[str, Any]					,				snake_case_ :					Any					,				snake_case_ :					Optional[int]					,				snake_case_ :					Optional[Any]					,				snake_case_ :					List[str]					,				snake_case_ :					Optional[Any]   ):
    __a :  Dict						=  FalconModel(config=snake_case_   )
    model.to(snake_case_   )
    model.eval()
    __a :  List[Any]						=  model(snake_case_					,				attention_mask=snake_case_   )
    __a :  List[str]						=  model(snake_case_   )
    self.parent.assertEqual(result.last_hidden_state.shape					,				(self.batch_size, self.seq_length, self.hidden_size)   )
   def       lowerCAmelCase			(self :					Tuple					,				snake_case_ :					Optional[int]					,				snake_case_ :					int					,				snake_case_ :					Optional[int]					,				snake_case_ :					Optional[Any]					,				snake_case_ :					int					,				snake_case_ :					List[Any]					,				snake_case_ :					List[Any]					,				snake_case_ :					Optional[int]					,				snake_case_ :					Optional[int]					,				):
    __a :  List[str]						=  True
    __a :  str						=  FalconModel(snake_case_   )
    model.to(snake_case_   )
    model.eval()
    __a :  str						=  model(
        snake_case_					,				attention_mask=snake_case_					,				encoder_hidden_states=snake_case_					,				encoder_attention_mask=snake_case_					,				)
    __a :  List[str]						=  model(
        snake_case_					,				attention_mask=snake_case_					,				encoder_hidden_states=snake_case_					,				)
    __a :  List[Any]						=  model(snake_case_					,				attention_mask=snake_case_   )
    self.parent.assertEqual(result.last_hidden_state.shape					,				(self.batch_size, self.seq_length, self.hidden_size)   )
   def       lowerCAmelCase			(self :					Union[str, Any]					,				snake_case_ :					int					,				snake_case_ :					Any					,				snake_case_ :					Optional[int]					,				snake_case_ :					List[Any]					,				snake_case_ :					str					,				snake_case_ :					Tuple					,				snake_case_ :					List[Any]					,				snake_case_ :					List[str]					,				snake_case_ :					int					,				):
    __a :  Any						=  FalconForCausalLM(config=snake_case_   )
    model.to(snake_case_   )
    model.eval()
    __a :  Tuple						=  model(snake_case_					,				attention_mask=snake_case_					,				labels=snake_case_   )
    self.parent.assertEqual(result.logits.shape					,				(self.batch_size, self.seq_length, self.vocab_size)   )
   def       lowerCAmelCase			(self :					str					,				snake_case_ :					int					,				snake_case_ :					int					,				snake_case_ :					Tuple					,				snake_case_ :					Optional[Any]					,				snake_case_ :					Optional[Any]					,				snake_case_ :					Dict					,				snake_case_ :					Union[str, Any]					,				snake_case_ :					List[str]					,				snake_case_ :					int					,				):
    __a :  int						=  True
    __a :  Any						=  True
    __a :  Tuple						=  FalconForCausalLM(config=snake_case_   )
    model.to(snake_case_   )
    model.eval()

    # first forward pass
    __a :  List[Any]						=  model(
        snake_case_					,				attention_mask=snake_case_					,				encoder_hidden_states=snake_case_					,				encoder_attention_mask=snake_case_					,				use_cache=snake_case_					,				)
    __a :  Dict						=  outputs.past_key_values

    # create hypothetical multiple next token and extent to next_input_ids
    __a :  Union[str, Any]						=  ids_tensor((self.batch_size, 3)					,				config.vocab_size   )
    __a :  str						=  ids_tensor((self.batch_size, 3)					,				vocab_size=2   )

    # append to next input_ids and
    __a :  Dict						=  torch.cat([input_ids, next_tokens]					,				dim=-1   )
    __a :  int						=  torch.cat([input_mask, next_mask]					,				dim=-1   )

    __a :  Dict						=  model(
        snake_case_					,				attention_mask=snake_case_					,				encoder_hidden_states=snake_case_					,				encoder_attention_mask=snake_case_					,				output_hidden_states=snake_case_					,				)['''hidden_states'''][0]
    __a :  List[Any]						=  model(
        snake_case_					,				attention_mask=snake_case_					,				encoder_hidden_states=snake_case_					,				encoder_attention_mask=snake_case_					,				past_key_values=snake_case_					,				output_hidden_states=snake_case_					,				)['''hidden_states'''][0]

    # select random slice
    __a :  Optional[Any]						=  ids_tensor((1,)					,				output_from_past.shape[-1]   ).item()
    __a :  Any						=  output_from_no_past[:, -3:, random_slice_idx].detach()
    __a :  int						=  output_from_past[:, :, random_slice_idx].detach()

    self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]   )

    # test that outputs are equal for slice
    self.parent.assertTrue(torch.allclose(snake_case_					,				snake_case_					,				atol=1E-3   )   )







   def       lowerCAmelCase			(self :					str   ):
    __a :  Optional[int]						=  self.prepare_config_and_inputs()
    (
        (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       
    ) :  Optional[int]						=  config_and_inputs
    __a :  int						=  {'''input_ids''': input_ids, '''attention_mask''': input_mask}
    return config, inputs_dict





@require_torch
class 		UpperCamelCase__  (       __lowercase    ,__lowercase    ,__lowercase    ,unittest.TestCase    ):
   _SCREAMING_SNAKE_CASE      :							int	       =      (
       (
           FalconModel,
           FalconForCausalLM,
           FalconForSequenceClassification,
           FalconForTokenClassification,
           FalconForQuestionAnswering,
       )
       if is_torch_available()
       else ()
   )
   _SCREAMING_SNAKE_CASE      :							List[Any]	       =      (FalconForCausalLM,) if is_torch_available() else ()
   _SCREAMING_SNAKE_CASE      :							List[str]	       =      (
       {
           "feature-extraction": FalconModel,
           "text-classification": FalconForSequenceClassification,
           "text-generation": FalconForCausalLM,
           "question-answering": FalconForQuestionAnswering,
           "token-classification": FalconForTokenClassification,
           "zero-shot": FalconForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   _SCREAMING_SNAKE_CASE      :							Optional[Any]	       =      False
   _SCREAMING_SNAKE_CASE      :							Tuple	       =      False
   def       lowerCAmelCase			(self :					Optional[int]   ):
    __a :  str						=  FalconModelTester(self   )
    __a :  Dict						=  ConfigTester(self					,				config_class=snake_case_					,				hidden_size=3_7   )
   def       lowerCAmelCase			(self :					Optional[int]   ):
    self.config_tester.run_common_tests()
   def       lowerCAmelCase			(self :					Optional[int]   ):
    __a :  Any						=  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*snake_case_   )
   def       lowerCAmelCase			(self :					int   ):
    __a				,       *__a :  Any						=  self.model_tester.prepare_config_and_inputs()
    for alibi in [True, False]:
     __a :  List[str]						=  alibi
     self.model_tester.create_and_check_model(snake_case_					,				*snake_case_   )
   def       lowerCAmelCase			(self :					Optional[int]   ):
    __a				,       __a :  Tuple						=  self.model_tester.prepare_config_and_inputs_for_common()
    __a :  List[Any]						=  3
    __a :  Optional[int]						=  input_dict['''input_ids''']
    __a :  List[Any]						=  input_ids.ne(1   ).to(snake_case_   )
    __a :  int						=  ids_tensor([self.model_tester.batch_size]					,				self.model_tester.type_sequence_label_size   )
    __a :  Union[str, Any]						=  FalconForSequenceClassification(snake_case_   )
    model.to(snake_case_   )
    model.eval()
    __a :  Any						=  model(snake_case_					,				attention_mask=snake_case_					,				labels=snake_case_   )
    self.assertEqual(result.logits.shape					,				(self.model_tester.batch_size, self.model_tester.num_labels)   )
   def       lowerCAmelCase			(self :					Tuple   ):
    __a				,       __a :  List[str]						=  self.model_tester.prepare_config_and_inputs_for_common()
    __a :  Optional[int]						=  3
    __a :  List[Any]						=  '''single_label_classification'''
    __a :  Dict						=  input_dict['''input_ids''']
    __a :  Optional[int]						=  input_ids.ne(1   ).to(snake_case_   )
    __a :  Union[str, Any]						=  ids_tensor([self.model_tester.batch_size]					,				self.model_tester.type_sequence_label_size   )
    __a :  Optional[Any]						=  FalconForSequenceClassification(snake_case_   )
    model.to(snake_case_   )
    model.eval()
    __a :  Optional[int]						=  model(snake_case_					,				attention_mask=snake_case_					,				labels=snake_case_   )
    self.assertEqual(result.logits.shape					,				(self.model_tester.batch_size, self.model_tester.num_labels)   )
   def       lowerCAmelCase			(self :					Union[str, Any]   ):
    __a				,       __a :  Union[str, Any]						=  self.model_tester.prepare_config_and_inputs_for_common()
    __a :  Dict						=  input_dict['''input_ids''']
    __a :  Optional[Any]						=  FalconForCausalLM(snake_case_   )
    model.to(snake_case_   )
    model.eval()
    __a :  Optional[int]						=  model(snake_case_					,				use_cache=snake_case_   )
    __a :  Tuple						=  input_ids.shape[0]
    __a :  Any						=  model._convert_to_rw_cache(result.past_key_values   )
    __a :  List[Any]						=  model._convert_cache_to_standard_format(snake_case_					,				snake_case_   )
    for layer in range(len(snake_case_   )   ):
     for tensor_idx in range(2   ):
      self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3   )
      self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4   )
      self.assertTrue(
          torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]   )   )
   def       lowerCAmelCase			(self :					Dict   ):
    __a				,       __a :  int						=  self.model_tester.prepare_config_and_inputs_for_common()
    __a :  int						=  3
    __a :  int						=  '''multi_label_classification'''
    __a :  Union[str, Any]						=  input_dict['''input_ids''']
    __a :  List[str]						=  input_ids.ne(1   ).to(snake_case_   )
    __a :  List[str]						=  ids_tensor(
        [self.model_tester.batch_size, config.num_labels]					,				self.model_tester.type_sequence_label_size   ).to(torch.float   )
    __a :  Union[str, Any]						=  FalconForSequenceClassification(snake_case_   )
    model.to(snake_case_   )
    model.eval()
    __a :  Union[str, Any]						=  model(snake_case_					,				attention_mask=snake_case_					,				labels=snake_case_   )
    self.assertEqual(result.logits.shape					,				(self.model_tester.batch_size, self.model_tester.num_labels)   )







   def       lowerCAmelCase			(self :					List[Any]   ):
    # Falcon can have different numbers of KV-heads than the number of query heads, so we need
    # to override this test to use the right head counts.
    for model_class in self.all_generative_model_classes:
     __a				,       __a :  Any						=  self.model_tester.prepare_config_and_inputs_for_common()

     # If it doesn't support cache, pass the test
     if not hasattr(snake_case_					,				'''use_cache'''   ):
      return

     __a :  Optional[Any]						=  model_class(snake_case_   ).to(snake_case_   )
     if "use_cache" not in inputs:
      __a :  Optional[int]						=  True
     __a :  Any						=  model(**snake_case_   )

     # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
     if "past_key_values" not in outputs:
      return

     __a :  Tuple						=  (
         getattr(snake_case_					,				'''decoder_layers'''					,				snake_case_   )
         or getattr(snake_case_					,				'''num_decoder_layers'''					,				snake_case_   )
         or config.num_hidden_layers
     )
     __a :  List[Any]						=  getattr(snake_case_					,				'''num_kv_heads'''					,				config.num_attention_heads   )
     __a :  Union[str, Any]						=  getattr(snake_case_					,				'''d_model'''					,				config.hidden_size   )
     __a :  int						=  embed_dim // num_attention_heads

     __a :  Tuple						=  outputs['''past_key_values''']
     self.assertEqual(len(snake_case_   )					,				snake_case_   )

     __a				,       __a :  Union[str, Any]						=  inputs['''input_ids'''].shape
     for i in range(snake_case_   ):
      if config.new_decoder_architecture:
       __a :  int						=  config.num_attention_heads
      elif config.multi_query:
       __a :  Any						=  1
      self.assertEqual(len(past_kv[0]   )					,				2   )  # K V for the decoder = 2
      self.assertEqual(
          past_kv[i][0].shape					,				(batch_size, num_attention_heads, seq_length, per_head_embed_dim)   )
      self.assertEqual(
          past_kv[i][1].shape					,				(batch_size, num_attention_heads, seq_length, per_head_embed_dim)   )





@require_torch
class 		UpperCamelCase__  (       unittest.TestCase    ):
   @slow
   def       lowerCAmelCase			(self :					Optional[int]   ):
    __a :  int						=  AutoTokenizer.from_pretrained('''Rocketknight1/falcon-rw-1b'''   )
    __a :  Union[str, Any]						=  FalconForCausalLM.from_pretrained('''Rocketknight1/falcon-rw-1b'''   )
    model.eval()
    model.to(snake_case_   )
    __a :  Dict						=  tokenizer('''My favorite food is'''					,				return_tensors='''pt'''   ).to(snake_case_   )

    __a :  List[str]						=  (
        '''My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'''
    )

    __a :  Tuple						=  model.generate(**snake_case_					,				do_sample=snake_case_					,				max_new_tokens=1_9   )
    __a :  List[Any]						=  tokenizer.batch_decode(snake_case_   )[0]

    self.assertEqual(snake_case_					,				snake_case_   )
   @slow
   def       lowerCAmelCase			(self :					List[Any]   ):
    # The big models are way too big for the CI, so we use tiny random models that resemble their
    # architectures but with much smaller and fewer layers
    for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
     __a :  Union[str, Any]						=  AutoTokenizer.from_pretrained(snake_case_   )
     __a :  int						=  FalconForCausalLM.from_pretrained(snake_case_   )
     model.eval()
     model.to(snake_case_   )
     __a :  Any						=  tokenizer('''My favorite food is'''					,				return_tensors='''pt'''   ).to(snake_case_   )

     # We just test that these run without errors - the models are randomly initialized
     # and so the actual text outputs will be garbage
     model.generate(**snake_case_					,				do_sample=snake_case_					,				max_new_tokens=4   )
     model.generate(**snake_case_					,				do_sample=snake_case_					,				max_new_tokens=4   )
     model.generate(**snake_case_					,				num_beams=2					,				max_new_tokens=4   )







   @slow
   def       lowerCAmelCase			(self :					List[Any]   ):
    # The big models are way too big for the CI, so we use tiny random models that resemble their
    # architectures but with much smaller and fewer layers
    with torch.no_grad():
     for repo in [
         "Rocketknight1/falcon-rw-1b",
         "Rocketknight1/tiny-random-falcon-7b",
         "Rocketknight1/tiny-random-falcon-40b",
     ]:
      __a :  Optional[int]						=  AutoTokenizer.from_pretrained(snake_case_   )
      __a :  List[str]						=  FalconForCausalLM.from_pretrained(snake_case_   )
      model.eval()
      model.to(device=snake_case_   )
      __a :  Dict						=  tokenizer('''My favorite food is'''					,				return_tensors='''pt'''   ).to(snake_case_   )

      # Test results are the same with and without cache
      __a :  Tuple						=  model.generate(**snake_case_					,				do_sample=snake_case_					,				max_new_tokens=2_0					,				use_cache=snake_case_   )
      __a :  Union[str, Any]						=  model.generate(**snake_case_					,				do_sample=snake_case_					,				max_new_tokens=2_0					,				use_cache=snake_case_   )
      self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0   )


from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt




def    __UpperCamelCase     (				lowerCAmelCase__							:				int  ):
 __a :  int						=  int(number**0.5  )
 return number == sq * sq




def    __UpperCamelCase     (				lowerCAmelCase__							:				int  ,   lowerCAmelCase__							:				int  ,   lowerCAmelCase__							:				int  ,   lowerCAmelCase__							:				int  ,   lowerCAmelCase__							:				int  ,   lowerCAmelCase__							:				int  ):
 __a :  int						=  x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
 __a :  int						=  x_den * y_den * z_den
 __a :  int						=  gcd(lowerCAmelCase__  ,   lowerCAmelCase__  )
 top //= hcf
 bottom //= hcf
 return top, bottom




def    __UpperCamelCase     (				lowerCAmelCase__							:				int = 3_5  ):
 __a :  set						=  set()
 __a :  int
 __a :  Fraction						=  Fraction(0  )
 __a :  tuple[int, int]

 for x_num in range(1  ,   order + 1  ):
  for x_den in range(x_num + 1  ,   order + 1  ):
   for y_num in range(1  ,   order + 1  ):
    for y_den in range(y_num + 1  ,   order + 1  ):
     # n=1
     __a :  Any						=  x_num * y_den + x_den * y_num
     __a :  Dict						=  x_den * y_den
     __a :  int						=  gcd(lowerCAmelCase__  ,   lowerCAmelCase__  )
     z_num //= hcf
     z_den //= hcf
     if 0 < z_num < z_den <= order:
      __a :  str						=  add_three(
          lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  )
      unique_s.add(lowerCAmelCase__  )

     # n=2
     __a :  Union[str, Any]						=  (
         x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
     )
     __a :  Optional[Any]						=  x_den * x_den * y_den * y_den
     if is_sq(lowerCAmelCase__  ) and is_sq(lowerCAmelCase__  ):
      __a :  Any						=  int(sqrt(lowerCAmelCase__  )  )
      __a :  Optional[Any]						=  int(sqrt(lowerCAmelCase__  )  )
      __a :  int						=  gcd(lowerCAmelCase__  ,   lowerCAmelCase__  )
      z_num //= hcf
      z_den //= hcf
      if 0 < z_num < z_den <= order:
       __a :  str						=  add_three(
           lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  )
       unique_s.add(lowerCAmelCase__  )

                    # n=-1
     __a :  List[str]						=  x_num * y_num
     __a :  List[str]						=  x_den * y_num + x_num * y_den
     __a :  str						=  gcd(lowerCAmelCase__  ,   lowerCAmelCase__  )
     z_num //= hcf
     z_den //= hcf
     if 0 < z_num < z_den <= order:
      __a :  Optional[int]						=  add_three(
          lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  )
      unique_s.add(lowerCAmelCase__  )

     # n=2
     __a :  List[str]						=  x_num * x_num * y_num * y_num
     __a :  Optional[int]						=  (
         x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
     )
     if is_sq(lowerCAmelCase__  ) and is_sq(lowerCAmelCase__  ):
      __a :  Union[str, Any]						=  int(sqrt(lowerCAmelCase__  )  )
      __a :  List[str]						=  int(sqrt(lowerCAmelCase__  )  )
      __a :  Optional[int]						=  gcd(lowerCAmelCase__  ,   lowerCAmelCase__  )
      z_num //= hcf
      z_den //= hcf
      if 0 < z_num < z_den <= order:
       __a :  int						=  add_three(
           lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  )
       unique_s.add(lowerCAmelCase__  )

 for num, den in unique_s:
  total += Fraction(lowerCAmelCase__  ,   lowerCAmelCase__  )

 return total.denominator + total.numerator


if __name__ == "__main__":
      print(F"""{solution() = }""")
