
from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFRoFormerForCausalLM,
					    TFRoFormerForMaskedLM,
					    TFRoFormerForMultipleChoice,
					    TFRoFormerForQuestionAnswering,
					    TFRoFormerForSequenceClassification,
					    TFRoFormerForTokenClassification,
					    TFRoFormerModel,
					)
					from transformers.models.roformer.modeling_tf_roformer import (
					    TFRoFormerSelfAttention,
					    TFRoFormerSinusoidalPositionalEmbedding,
					)

class    lowerCAmelCase__     :






		def __init__(		self		:							int							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]=13							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]=7							,			SCREAMING_SNAKE_CASE__		:							int=True							,			SCREAMING_SNAKE_CASE__		:							Tuple=True							,			SCREAMING_SNAKE_CASE__		:							Any=True							,			SCREAMING_SNAKE_CASE__		:							Tuple=True							,			SCREAMING_SNAKE_CASE__		:							List[Any]=99							,			SCREAMING_SNAKE_CASE__		:							Any=32							,			SCREAMING_SNAKE_CASE__		:							Optional[int]=2							,			SCREAMING_SNAKE_CASE__		:							str=4							,			SCREAMING_SNAKE_CASE__		:							Any=37							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]="gelu"							,			SCREAMING_SNAKE_CASE__		:							Tuple=0.1							,			SCREAMING_SNAKE_CASE__		:							Dict=0.1							,			SCREAMING_SNAKE_CASE__		:							Tuple=5_12							,			SCREAMING_SNAKE_CASE__		:							List[str]=16							,			SCREAMING_SNAKE_CASE__		:							Optional[int]=2							,			SCREAMING_SNAKE_CASE__		:							List[str]=0.02							,			SCREAMING_SNAKE_CASE__		:							List[str]=3							,			SCREAMING_SNAKE_CASE__		:							Dict=4							,			SCREAMING_SNAKE_CASE__		:							List[Any]=None							,			)     ->							Union[str, Any]:
						__lowerCamelCase    					=	parent
						__lowerCamelCase    					=	13
						__lowerCamelCase    					=	7
						__lowerCamelCase    					=	True
						__lowerCamelCase    					=	True
						__lowerCamelCase    					=	True
						__lowerCamelCase    					=	True
						__lowerCamelCase    					=	99
						__lowerCamelCase    					=	32
						__lowerCamelCase    					=	2
						__lowerCamelCase    					=	4
						__lowerCamelCase    					=	37
						__lowerCamelCase    					=	'''gelu'''
						__lowerCamelCase    					=	0.1
						__lowerCamelCase    					=	0.1
						__lowerCamelCase    					=	5_12
						__lowerCamelCase    					=	16
						__lowerCamelCase    					=	2
						__lowerCamelCase    					=	0.02
						__lowerCamelCase    					=	3
						__lowerCamelCase    					=	4
						__lowerCamelCase    					=	None






		def  __A       (		self		:							Optional[Any]  )     ->							Tuple:
						__lowerCamelCase    					=	ids_tensor([self.batch_size, self.seq_length]							,			self.vocab_size  )

						__lowerCamelCase    					=	None
						if self.use_input_mask:
										__lowerCamelCase    					=	random_attention_mask([self.batch_size, self.seq_length]  )

						__lowerCamelCase    					=	None
						if self.use_token_type_ids:
										__lowerCamelCase    					=	ids_tensor([self.batch_size, self.seq_length]							,			self.type_vocab_size  )

						__lowerCamelCase    					=	None
						__lowerCamelCase    					=	None
						__lowerCamelCase    					=	None
						if self.use_labels:
										__lowerCamelCase    					=	ids_tensor([self.batch_size]							,			self.type_sequence_label_size  )
										__lowerCamelCase    					=	ids_tensor([self.batch_size, self.seq_length]							,			self.num_labels  )
										__lowerCamelCase    					=	ids_tensor([self.batch_size]							,			self.num_choices  )

						__lowerCamelCase    					=	RoFormerConfig(
						    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							,			initializer_range=self.initializer_range							,			return_dict=SCREAMING_SNAKE_CASE__							,			)

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






		def  __A       (		self		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							Any							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							List[Any]  )     ->							Optional[int]:
						__lowerCamelCase    					=	TFRoFormerModel(config=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

						__lowerCamelCase    					=	[input_ids, input_mask]
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )

						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )

						self.parent.assertEqual(result.last_hidden_state.shape							,			(self.batch_size, self.seq_length, self.hidden_size)  )






		def  __A       (		self		:							Optional[Any]							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							int  )     ->							str:
						__lowerCamelCase    					=	True
						__lowerCamelCase    					=	TFRoFormerForCausalLM(config=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	{
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )['''logits''']
						self.parent.assertListEqual(
						    list(prediction_scores.numpy().shape  )							,			[self.batch_size, self.seq_length, self.vocab_size]  )






		def  __A       (		self		:							str							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							str							,			SCREAMING_SNAKE_CASE__		:							str							,			SCREAMING_SNAKE_CASE__		:							Tuple  )     ->							int:
						__lowerCamelCase    					=	TFRoFormerForMaskedLM(config=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	{
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )
						self.parent.assertEqual(result.logits.shape							,			(self.batch_size, self.seq_length, self.vocab_size)  )






		def  __A       (		self		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							str							,			SCREAMING_SNAKE_CASE__		:							Optional[int]							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							Any  )     ->							Any:
						__lowerCamelCase    					=	self.num_labels
						__lowerCamelCase    					=	TFRoFormerForSequenceClassification(config=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	{
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}

						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )
						self.parent.assertEqual(result.logits.shape							,			(self.batch_size, self.num_labels)  )






		def  __A       (		self		:							Dict							,			SCREAMING_SNAKE_CASE__		:							Optional[int]							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							List[str]  )     ->							Dict:
						__lowerCamelCase    					=	self.num_choices
						__lowerCamelCase    					=	TFRoFormerForMultipleChoice(config=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE__							,			1  )							,			(1, self.num_choices, 1)  )
						__lowerCamelCase    					=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE__							,			1  )							,			(1, self.num_choices, 1)  )
						__lowerCamelCase    					=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE__							,			1  )							,			(1, self.num_choices, 1)  )
						__lowerCamelCase    					=	{
						    '''input_ids''': multiple_choice_inputs_ids,
						    '''attention_mask''': multiple_choice_input_mask,
						    '''token_type_ids''': multiple_choice_token_type_ids,
						}
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )
						self.parent.assertEqual(result.logits.shape							,			(self.batch_size, self.num_choices)  )






		def  __A       (		self		:							Dict							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							Any							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							Dict  )     ->							Dict:
						__lowerCamelCase    					=	self.num_labels
						__lowerCamelCase    					=	TFRoFormerForTokenClassification(config=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	{
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )
						self.parent.assertEqual(result.logits.shape							,			(self.batch_size, self.seq_length, self.num_labels)  )






		def  __A       (		self		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							Any							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							str							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							Optional[int]  )     ->							Any:
						__lowerCamelCase    					=	TFRoFormerForQuestionAnswering(config=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	{
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}

						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )
						self.parent.assertEqual(result.start_logits.shape							,			(self.batch_size, self.seq_length)  )
						self.parent.assertEqual(result.end_logits.shape							,			(self.batch_size, self.seq_length)  )







		def  __A       (		self		:							Union[str, Any]  )     ->							List[Any]:
						__lowerCamelCase    					=	self.prepare_config_and_inputs()
						(
						    (
						    __lowerCamelCase
						)					,    (
						    __lowerCamelCase
						)					,    (
						    __lowerCamelCase
						)					,    (
						    __lowerCamelCase
						)					,    (
						    __lowerCamelCase
						)					,    (
						    __lowerCamelCase
						)					,    (
						    __lowerCamelCase
						)					,    
						)    					=	config_and_inputs
						__lowerCamelCase    					=	{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
						return config, inputs_dict





@require_tf
class    lowerCAmelCase__     (	__lowercase  ,	__lowercase  ,	unittest.TestCase			):
		a__       :						List[Any]        =		(
		    (
		        TFRoFormerModel,
		        TFRoFormerForCausalLM,
		        TFRoFormerForMaskedLM,
		        TFRoFormerForQuestionAnswering,
		        TFRoFormerForSequenceClassification,
		        TFRoFormerForTokenClassification,
		        TFRoFormerForMultipleChoice,
		    )
		    if is_tf_available()
		    else ()
		)
		a__       :						Optional[Any]        =		(
		    {
		        """feature-extraction""": TFRoFormerModel,
		        """fill-mask""": TFRoFormerForMaskedLM,
		        """question-answering""": TFRoFormerForQuestionAnswering,
		        """text-classification""": TFRoFormerForSequenceClassification,
		        """text-generation""": TFRoFormerForCausalLM,
		        """token-classification""": TFRoFormerForTokenClassification,
		        """zero-shot""": TFRoFormerForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)

		a__       :						Any        =		False
		a__       :						int        =		False






		def  __A       (		self		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							Any							,			SCREAMING_SNAKE_CASE__		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							str							,			SCREAMING_SNAKE_CASE__		:							str  )     ->							List[Any]:
						if pipeline_test_casse_name == "TextGenerationPipelineTests":
										return True

						return False






		def  __A       (		self		:							Dict  )     ->							Union[str, Any]:
						__lowerCamelCase    					=	TFRoFormerModelTester(self  )
						__lowerCamelCase    					=	ConfigTester(self							,			config_class=SCREAMING_SNAKE_CASE__							,			hidden_size=37  )






		def  __A       (		self		:							int  )     ->							List[Any]:
						self.config_tester.run_common_tests()






		def  __A       (		self		:							Union[str, Any]  )     ->							Dict:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							int  )     ->							Optional[int]:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							Dict  )     ->							Dict:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_lm_head(*SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							Dict  )     ->							int:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							int  )     ->							Optional[int]:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							Optional[int]  )     ->							List[Any]:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							Union[str, Any]  )     ->							str:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE__  )







		@slow
		def  __A       (		self		:							Tuple  )     ->							List[str]:
						__lowerCamelCase    					=	TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base'''  )
						self.assertIsNotNone(SCREAMING_SNAKE_CASE__  )





@require_tf
class    lowerCAmelCase__     (	unittest.TestCase			):






		@slow
		def  __A       (		self		:							Union[str, Any]  )     ->							int:
						__lowerCamelCase    					=	TFRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base'''  )
						__lowerCamelCase    					=	tf.constant([[0, 1, 2, 3, 4, 5]]  )
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )[0]

						# TODO Replace vocab size
						__lowerCamelCase    					=	5_00_00

						__lowerCamelCase    					=	[1, 6, vocab_size]
						self.assertEqual(output.shape							,			SCREAMING_SNAKE_CASE__  )

						print(output[:, :3, :3]  )

						# TODO Replace values below with what was printed above.
						__lowerCamelCase    					=	tf.constant(
						    [
						        [
						            [-0.12053341, -1.0264901, 0.29221946],
						            [-1.5133783, 0.197433, 0.15190607],
						            [-5.0135403, -3.900256, -0.84038764],
						        ]
						    ]  )
						tf.debugging.assert_near(output[:, :3, :3]							,			SCREAMING_SNAKE_CASE__							,			atol=1e-4  )





@require_tf
class    lowerCAmelCase__     (	unittest.TestCase			):
		a__       :						Union[str, Any]        =		1e-4






		def  __A       (		self		:							Optional[Any]  )     ->							List[str]:
						__lowerCamelCase    					=	tf.constant([[4, 10]]  )
						__lowerCamelCase    					=	TFRoFormerSinusoidalPositionalEmbedding(num_positions=6							,			embedding_dim=6  )

						__lowerCamelCase    					=	emba(input_ids.shape  )
						__lowerCamelCase    					=	tf.constant(
						    [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]]  )

						tf.debugging.assert_near(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			atol=self.tolerance  )







		def  __A       (		self		:							Optional[Any]  )     ->							Optional[int]:
						__lowerCamelCase    					=	tf.constant(
						    [
						        [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
						        [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
						        [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
						    ]  )
						__lowerCamelCase    					=	TFRoFormerSinusoidalPositionalEmbedding(num_positions=5_12							,			embedding_dim=5_12  )
						emba([2, 16, 5_12]  )
						__lowerCamelCase    					=	emba.weight[:3, :5]

						tf.debugging.assert_near(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			atol=self.tolerance  )





@require_tf
class    lowerCAmelCase__     (	unittest.TestCase			):
		a__       :						str        =		1e-4






		def  __A       (		self		:							Tuple  )     ->							List[Any]:
						# 2,12,16,64
						__lowerCamelCase    					=	tf.reshape(tf.range(2 * 12 * 16 * 64							,			dtype=tf.floataa  )							,			shape=(2, 12, 16, 64)  ) / 1_00

						__lowerCamelCase    					=	-tf.reshape(tf.range(2 * 12 * 16 * 64							,			dtype=tf.floataa  )							,			shape=(2, 12, 16, 64)  ) / 1_00

						__lowerCamelCase    					=	TFRoFormerSinusoidalPositionalEmbedding(num_positions=32							,			embedding_dim=64  )
						__lowerCamelCase    					=	embed_positions([2, 16, 7_68]  )[None, None, :, :]

						__lowerCamelCase					,    __lowerCamelCase    					=	TFRoFormerSelfAttention.apply_rotary_position_embeddings(
						    SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  )

						__lowerCamelCase    					=	tf.constant(
						    [
						        [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
						        [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
						        [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
						        [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
						        [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
						        [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
						    ]  )
						__lowerCamelCase    					=	tf.constant(
						    [
						        [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
						        [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
						        [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
						        [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
						        [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
						        [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
						    ]  )

						tf.debugging.assert_near(query_layer[0, 0, :6, :8]							,			SCREAMING_SNAKE_CASE__							,			atol=self.tolerance  )
						tf.debugging.assert_near(key_layer[0, 0, :6, :8]							,			SCREAMING_SNAKE_CASE__							,			atol=self.tolerance  )





from __future__ import annotations

from fractions import Fraction




def  __magic_name__ (   __lowerCAmelCase	:						int		,  __lowerCAmelCase	:						int							)			->   bool:
				return (
				    num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
				)




def  __magic_name__ (   __lowerCAmelCase	:						int							)			->   list[str]:
				__lowerCamelCase    					=	[]
				__lowerCamelCase    					=	11
				__lowerCamelCase    					=	int('''1''' + '''0''' * digit_len							)
				for num in range(__lowerCAmelCase		,  __lowerCAmelCase							):
								while den <= 99:
												if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
																if is_digit_cancelling(__lowerCAmelCase		,  __lowerCAmelCase							):
																				solutions.append(f'''{num}/{den}'''							)
												den += 1
								num += 1
								__lowerCamelCase    					=	10
				return solutions




def  __magic_name__ (   __lowerCAmelCase	:						int = 2							)			->   int:
				__lowerCamelCase    					=	1.0
				for fraction in fraction_list(__lowerCAmelCase							):
								__lowerCamelCase    					=	Fraction(__lowerCAmelCase							)
								result *= frac.denominator / frac.numerator
				return int(__lowerCAmelCase							)


if __name__ == "__main__":
					print(solution())



