


from math import isclose, sqrt







def 						lowerCamelCase(   a__	,a__	,a__):
				_SCREAMING_SNAKE_CASE			  =point_y / 4 / point_x
				_SCREAMING_SNAKE_CASE			  =2 * normal_gradient / (1 + normal_gradient * normal_gradient)
				_SCREAMING_SNAKE_CASE			  =(1 - normal_gradient * normal_gradient) / (
				    1 + normal_gradient * normal_gradient
				)
				_SCREAMING_SNAKE_CASE			  =(sa - ca * incoming_gradient) / (ca + sa * incoming_gradient)

				# to find the next point, solve the simultaeneous equations:
				# y^2 + 4x^2 = 100
				# y - b = m * (x - a)
				# ==> A x^2 + B x + C = 0
				_SCREAMING_SNAKE_CASE			  =outgoing_gradient**2 + 4
				_SCREAMING_SNAKE_CASE			  =2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
				_SCREAMING_SNAKE_CASE			  =(point_y - outgoing_gradient * point_x) ** 2 - 100

				_SCREAMING_SNAKE_CASE			  =(
				    -linear_term - sqrt(linear_term**2 - 4 * quadratic_term * constant_term)
				) / (2 * quadratic_term)
				_SCREAMING_SNAKE_CASE			  =(
				    -linear_term + sqrt(linear_term**2 - 4 * quadratic_term * constant_term)
				) / (2 * quadratic_term)

				# two solutions, one of which is our input point
				_SCREAMING_SNAKE_CASE			  =x_minus if isclose(a__	,a__) else x_plus
				_SCREAMING_SNAKE_CASE			  =point_y + outgoing_gradient * (next_x - point_x)

				return next_x, next_y, outgoing_gradient







def 						lowerCamelCase(   a__ = 1.4	,a__ = -9.6):
				_SCREAMING_SNAKE_CASE			  =0
				_SCREAMING_SNAKE_CASE			  =first_x_coord
				_SCREAMING_SNAKE_CASE			  =first_y_coord
				_SCREAMING_SNAKE_CASE			  =(10.1 - point_y) / (0.0 - point_x)

				while not (-0.01 <= point_x <= 0.01 and point_y > 0):
								_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =next_point(a__	,a__	,a__)
								num_reflections += 1

				return num_reflections


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



import os
import unittest

from transformers import LxmertTokenizer, LxmertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class 						A__							(		UpperCamelCase__   ,     unittest.TestCase  ):
						UpperCAmelCase             =						LxmertTokenizer
						UpperCAmelCase             =						LxmertTokenizerFast
						UpperCAmelCase             =						True
						UpperCAmelCase             =						True




						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     Tuple:


										"""simple docstring"""





										super().setUp()

										_SCREAMING_SNAKE_CASE			  =[
										    '''[UNK]''',
										    '''[CLS]''',
										    '''[SEP]''',
										    '''want''',
										    '''##want''',
										    '''##ed''',
										    '''wa''',
										    '''un''',
										    '''runn''',
										    '''##ing''',
										    ''',''',
										    '''low''',
										    '''lowest''',
										]
										_SCREAMING_SNAKE_CASE			  =os.path.join(self.tmpdirname				,    VOCAB_FILES_NAMES['''vocab_file''']  )
										with open(self.vocab_file				,    '''w'''				,    encoding='''utf-8'''  ) as vocab_writer:
														vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]  )  )




						def 							__UpperCamelCase				(       self					:      List[str]				,    _a					:      Tuple  )							->     Optional[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  ='''UNwant\u00E9d,running'''
										_SCREAMING_SNAKE_CASE			  ='''unwanted, running'''
										return input_text, output_text




						def 							__UpperCamelCase				(       self					:      Tuple  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.tokenizer_class(self.vocab_file  )

										_SCREAMING_SNAKE_CASE			  =tokenizer.tokenize('''UNwant\u00E9d,running'''  )
										self.assertListEqual(_a				,    ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']  )
										self.assertListEqual(tokenizer.convert_tokens_to_ids(_a  )				,    [7, 4, 5, 10, 8, 9]  )




						def 							__UpperCamelCase				(       self					:      Dict  )							->     List[Any]:


										"""simple docstring"""





										if not self.test_rust_tokenizer:
														return

										_SCREAMING_SNAKE_CASE			  =self.get_tokenizer()
										_SCREAMING_SNAKE_CASE			  =self.get_rust_tokenizer()

										_SCREAMING_SNAKE_CASE			  ='''I was born in 92000, and this is falsé.'''

										_SCREAMING_SNAKE_CASE			  =tokenizer.tokenize(_a  )
										_SCREAMING_SNAKE_CASE			  =rust_tokenizer.tokenize(_a  )
										self.assertListEqual(_a				,    _a  )

										_SCREAMING_SNAKE_CASE			  =tokenizer.encode(_a				,    add_special_tokens=_a  )
										_SCREAMING_SNAKE_CASE			  =rust_tokenizer.encode(_a				,    add_special_tokens=_a  )
										self.assertListEqual(_a				,    _a  )

										_SCREAMING_SNAKE_CASE			  =self.get_rust_tokenizer()
										_SCREAMING_SNAKE_CASE			  =tokenizer.encode(_a  )
										_SCREAMING_SNAKE_CASE			  =rust_tokenizer.encode(_a  )
										self.assertListEqual(_a				,    _a  )