code: 
  '''simple docstring'''
  
  from __future__ import annotations
  
  # Define the Gravitational Constant G and the function
  UpperCamelCase_     			=       6.6_7_4_3e-1_1  # unit of G : m^3 * kg^-1 * s^-2
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       float  ,      _lowerCamelCase						:       float  ,      _lowerCamelCase						:       float  ,      _lowerCamelCase						:       float		)    ->						dict[str, float]:
    _lowerCAmelCase       :  Union[str, Any]   				=					mass_a * mass_a
  
    if (force, mass_a, mass_a, distance).count(0		) != 1:
      raise ValueError("""One and only one argument must be 0"""		)
    if force < 0:
      raise ValueError("""Gravitational force can not be negative"""		)
    if distance < 0:
      raise ValueError("""Distance can not be negative"""		)
    if mass_a < 0 or mass_a < 0:
      raise ValueError("""Mass can not be negative"""		)
    if force == 0:
      _lowerCAmelCase       :  Optional[int]   				=					GRAVITATIONAL_CONSTANT * product_of_mass / (distance**2)
      return {"force": force}
    elif mass_a == 0:
      _lowerCAmelCase       :  Tuple   				=					(force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
      return {"mass_1": mass_a}
    elif mass_a == 0:
      _lowerCAmelCase       :  List[str]   				=					(force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
      return {"mass_2": mass_a}
    elif distance == 0:
      _lowerCAmelCase       :  Dict   				=					(GRAVITATIONAL_CONSTANT * product_of_mass / (force)) ** 0.5
      return {"distance": distance}
    raise ValueError("""One and only one argument must be 0"""		)
  
  
  # Run doctest
  if __name__ == "__main__":
       import doctest
  
       doctest.testmod()
  
  
  
style_context: 
  '''simple docstring'''
  
  import json
  import os
  import unittest
  
  from transformers.models.gpt_neox_japanese.tokenization_gpt_neox_japanese import (
      VOCAB_FILES_NAMES,
      GPTNeoXJapaneseTokenizer,
  )
  from transformers.testing_utils import require_tokenizers, slow
  
  from ...test_tokenization_common import TokenizerTesterMixin
  
  
  @require_tokenizers
  class   a_  (_a							,			unittest.TestCase    ):
         __lowerCAmelCase    :				List[Any]    =      GPTNeoXJapaneseTokenizer
         __lowerCAmelCase    :				Any    =      False
         __lowerCAmelCase    :				List[Any]    =      {"""do_clean_text""": False, """add_prefix_space""": False}
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           super().setUp()
  
           _lowerCAmelCase       :  Any   				=					[
               """こん""",
               """こんに""",
               """にちは""",
               """ばんは""",
               """世界,㔺界""",
               """、""",
               """。""",
               """<BR>""",
               """<SP>""",
               """<TAB>""",
               """<URL>""",
               """<EMAIL>""",
               """<TEL>""",
               """<DATE>""",
               """<PRICE>""",
               """<BLOCK>""",
               """<KIGOU>""",
               """<U2000U2BFF>""",
               """<|emoji1|>""",
               """<unk>""",
               """<|startoftext|>""",
               """<|endoftext|>""",
           ]
           _lowerCAmelCase       :  Union[str, Any]   				=					{"""emoji""": {"""\ud83d\ude00""": """<|emoji1|>"""}, """emoji_inv""": {"""<|emoji1|>""": """\ud83d\ude00"""}}  # 😀
           _lowerCAmelCase       :  Any   				=					{"""unk_token""": """<unk>"""}
  
           _lowerCAmelCase       :  Optional[int]   				=					os.path.join(self.tmpdirname   ,   VOCAB_FILES_NAMES["""vocab_file"""]  )
           _lowerCAmelCase       :  Any   				=					os.path.join(self.tmpdirname   ,   VOCAB_FILES_NAMES["""emoji_file"""]  )
           with open(self.vocab_file   ,   """w"""   ,   encoding="""utf-8"""  ) as vocab_writer:
             vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]  )  )
           with open(self.emoji_file   ,   """w"""  ) as emoji_writer:
             emoji_writer.write(json.dumps(snake_case_  )  )
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   **snake_case_  ):
           kwargs.update(self.special_tokens_map  )
           return GPTNeoXJapaneseTokenizer.from_pretrained(self.tmpdirname   ,   **snake_case_  )
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_  ):
           _lowerCAmelCase       :  Tuple   				=					"""こんにちは、世界。 \nこんばんは、㔺界。😀"""
           _lowerCAmelCase       :  str   				=					"""こんにちは、世界。 \nこんばんは、世界。😀"""
           return input_text, output_text
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_  ):
           _lowerCAmelCase				,					_lowerCAmelCase       :  str   				=					self.get_input_output_texts(snake_case_  )
           _lowerCAmelCase       :  Tuple   				=					tokenizer.encode(snake_case_   ,   add_special_tokens=snake_case_  )
           _lowerCAmelCase       :  Optional[Any]   				=					tokenizer.decode(snake_case_   ,   clean_up_tokenization_spaces=snake_case_  )
           return text, ids
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass  # TODO add if relevant
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass  # TODO add if relevant
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass  # TODO add if relevant
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  List[Any]   				=					self.get_tokenizer()
  
           # Testing tokenization
           _lowerCAmelCase       :  Tuple   				=					"""こんにちは、世界。　こんばんは、㔺界。"""
           _lowerCAmelCase       :  Optional[Any]   				=					["""こん""", """にちは""", """、""", """世界""", """。""", """<SP>""", """こん""", """ばんは""", """、""", """㔺界""", """。"""]
           _lowerCAmelCase       :  Tuple   				=					tokenizer.tokenize(snake_case_  )
           self.assertListEqual(snake_case_   ,   snake_case_  )
  
           # Testing conversion to ids without special tokens
           _lowerCAmelCase       :  Optional[int]   				=					[0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
           _lowerCAmelCase       :  Optional[int]   				=					tokenizer.convert_tokens_to_ids(snake_case_  )
           self.assertListEqual(snake_case_   ,   snake_case_  )
  
           # Testing conversion to ids with special tokens
           _lowerCAmelCase       :  Optional[Any]   				=					tokens + [tokenizer.unk_token]
           _lowerCAmelCase       :  List[str]   				=					[0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 1_9]
           _lowerCAmelCase       :  Dict   				=					tokenizer.convert_tokens_to_ids(snake_case_  )
           self.assertListEqual(snake_case_   ,   snake_case_  )
  
  
  
  
         @slow
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  int   				=					self.tokenizer_class.from_pretrained("""abeja/gpt-neox-japanese-2.7b"""  )
  
           _lowerCAmelCase       :  List[Any]   				=					tokenizer.encode("""ありがとう。"""   ,   add_special_tokens=snake_case_  )
           _lowerCAmelCase       :  List[str]   				=					tokenizer.encode("""どういたしまして。"""   ,   add_special_tokens=snake_case_  )
  
           _lowerCAmelCase       :  int   				=					tokenizer.build_inputs_with_special_tokens(snake_case_  )
           _lowerCAmelCase       :  Any   				=					tokenizer.build_inputs_with_special_tokens(snake_case_   ,   snake_case_  )
  
           assert encoded_sentence == ids_a
           assert encoded_pair == ids_a + ids_a
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           # Intentionally convert some words to accommodate character fluctuations unique to Japanese
           pass
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           # tokenizer has no padding token
           pass
  
  
  