





import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format



class    UpperCamelCase__     :






							"""simple docstring"""

							snake_case_							 =						None

							def      A_  (      self				:     Any    )	->Dict:
													SCREAMING_SNAKE_CASE__     :				int   =					self.feature_extraction_class(**self.feat_extract_dict    )
													SCREAMING_SNAKE_CASE__     :				int   =					json.loads(feat_extract.to_json_string()    )
													for key, value in self.feat_extract_dict.items():
																			self.assertEqual(obj[key]							,	a    )

							def      A_  (      self				:     str    )	->List[str]:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.feature_extraction_class(**self.feat_extract_dict    )

													with tempfile.TemporaryDirectory() as tmpdirname:
																			SCREAMING_SNAKE_CASE__     :				Dict   =					os.path.join(a							,	"feat_extract.json"    )
																			feat_extract_first.to_json_file(a    )
																			SCREAMING_SNAKE_CASE__     :				int   =					self.feature_extraction_class.from_json_file(a    )

													self.assertEqual(feat_extract_second.to_dict()							,	feat_extract_first.to_dict()    )

							def      A_  (      self				:     Optional[Any]    )	->Optional[int]:
													SCREAMING_SNAKE_CASE__     :				Dict   =					self.feature_extraction_class(**self.feat_extract_dict    )

													with tempfile.TemporaryDirectory() as tmpdirname:
																			SCREAMING_SNAKE_CASE__     :				List[str]   =					feat_extract_first.save_pretrained(a    )[0]
																			check_json_file_has_correct_format(a    )
																			SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.feature_extraction_class.from_pretrained(a    )

													self.assertEqual(feat_extract_second.to_dict()							,	feat_extract_first.to_dict()    )






							def      A_  (      self				:     List[str]    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				str   =					self.feature_extraction_class()
													self.assertIsNotNone(a    )






from __future__ import annotations

from fractions import Fraction







def       UpperCAmelCase							(     _lowerCamelCase      :  int			,   _lowerCamelCase      :  int     ):





						'''simple docstring'''


						return (
						    num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
						)







def       UpperCAmelCase							(     _lowerCamelCase      :  int     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				int   =					[]
						SCREAMING_SNAKE_CASE__     :				str   =					11
						SCREAMING_SNAKE_CASE__     :				Any   =					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
												SCREAMING_SNAKE_CASE__     :				str   =					10
						return solutions







def       UpperCAmelCase							(     _lowerCamelCase      :  int = 2     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				Optional[int]   =					1.0
						for fraction in fraction_list(_lowerCamelCase     ):
												SCREAMING_SNAKE_CASE__     :				Any   =					Fraction(_lowerCamelCase     )
												result *= frac.denominator / frac.numerator
						return int(_lowerCamelCase     )


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