






import math



def 			_SCREAMING_SNAKE_CASE						( __lowercase   :			Any    )						->      bool:





    """simple docstring"""

    __A         =	math.loga(math.sqrt(4 * positive_integer + 1    ) / 2 + 1 / 2    )

    return exponent == int(__lowercase    )



def 			_SCREAMING_SNAKE_CASE						( __lowercase   :			Any = 1 / 1_2_3_4_5    )						->      int:





    """simple docstring"""

    __A         =	0
    __A         =	0

    __A         =	3
    while True:
        __A         =	(integer**2 - 1) / 4
        # if candidate is an integer, then there is a partition for k
        if partition_candidate == int(__lowercase    ):
            __A         =	int(__lowercase    )
            total_partitions += 1
            if check_partition_perfect(__lowercase    ):
                perfect_partitions += 1
        if perfect_partitions > 0:
            if perfect_partitions / total_partitions < max_proportion:
                return int(__lowercase    )
        integer += 1


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












import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate



def 			_SCREAMING_SNAKE_CASE						( __lowercase   :			Optional[int]    )						->      List[str]:





    """simple docstring"""

    return x + 2






class       __lowercase      (	unittest.TestCase  ):







     '''simple docstring'''




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	"""x = 3"""
         __A         =	{}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         assert result == 3
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3}				)

         __A         =	"""x = y"""
         __A         =	{"""y""": 5}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 5, """y""": 5}				)




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	"""y = add_two(x)"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 5}				)

         # Won't work without the tool
         with CaptureStdout() as out:
             __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         assert result is None
         assert "tried to execute add_two" in out.out




     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         __A         =	"""x = 3"""
         __A         =	{}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         assert result == 3
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3}				)




     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	"""test_dict = {'x': x, 'y': add_two(x)}"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 5}				)
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}}				)




     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         __A         =	"""x = 3\ny = 5"""
         __A         =	{}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 5}				)




     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         __A         =	"""text = f'This is x: {x}.'"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == "This is x: 3."
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """text""": """This is x: 3."""}				)




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A         =	"""if x <= 3:\n    y = 2\nelse:\n    y = 5"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == 2
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 2}				)

         __A         =	{"""x""": 8}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         # evaluate returns the value of the last assignment.
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 8, """y""": 5}				)




     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         __A         =	"""test_list = [x, add_two(x)]"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         self.assertListEqual(UpperCamelCase_ ,	[3, 5]				)
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """test_list""": [3, 5]}				)




     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         __A         =	"""y = x"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{} ,	state=UpperCamelCase_				)
         assert result == 3
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """y""": 3}				)




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	"""test_list = [x, add_two(x)]\ntest_list[1]"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """test_list""": [3, 5]}				)

         __A         =	"""test_dict = {'x': x, 'y': add_two(x)}\ntest_dict['y']"""
         __A         =	{"""x""": 3}
         __A         =	evaluate(UpperCamelCase_ ,	{"""add_two""": add_two} ,	state=UpperCamelCase_				)
         assert result == 5
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}}				)





     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	"""x = 0\nfor i in range(3):\n    x = i"""
         __A         =	{}
         __A         =	evaluate(UpperCamelCase_ ,	{"""range""": range} ,	state=UpperCamelCase_				)
         assert result == 2
         self.assertDictEqual(UpperCamelCase_ ,	{"""x""": 2, """i""": 2}				)




