






"""simple docstring"""


def 			snake_case  (A_      :str      ):







  '''simple docstring'''

  if not isinstance(SCREAMING_SNAKE_CASE__	,			SCREAMING_SNAKE_CASE__      ):
    raise ValueError('Input series is not valid, valid series - [1, 2/3, 2]'      )
  if len(SCREAMING_SNAKE_CASE__      ) == 0:
    raise ValueError('Input list must be a non empty list'      )
  if len(SCREAMING_SNAKE_CASE__      ) == 1 and series[0] != 0:
    return True
  a     :			Dict				=   []
  a     :			Any				=   len(SCREAMING_SNAKE_CASE__      )
  for i in range(0	,			SCREAMING_SNAKE_CASE__      ):
    if series[i] == 0:
      raise ValueError('Input series cannot have 0 as an element'      )
    rec_series.append(1 / series[i]      )
  a     :			Tuple				=   rec_series[1] - rec_series[0]
  for index in range(2	,			SCREAMING_SNAKE_CASE__      ):
    if rec_series[index] - rec_series[index - 1] != common_diff:
      return False
  return True




def 			snake_case  (A_      :Tuple      ):







  '''simple docstring'''

  if not isinstance(SCREAMING_SNAKE_CASE__	,			SCREAMING_SNAKE_CASE__      ):
    raise ValueError('Input series is not valid, valid series - [2, 4, 6]'      )
  if len(SCREAMING_SNAKE_CASE__      ) == 0:
    raise ValueError('Input list must be a non empty list'      )
  a     :			List[str]				=   0
  for val in series:
    answer += 1 / val
  return len(SCREAMING_SNAKE_CASE__      ) / answer


if __name__ == "__main__":
   import doctest

   doctest.testmod()






'''simple docstring'''
from __future__ import annotations

import sys




def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__       )   ->				tuple[int, int]:


		'''simple docstring'''


		if abs(SCREAMING_SNAKE_CASE__       ) == 1:
				return a, 0
		elif abs(SCREAMING_SNAKE_CASE__       ) == 1:
				return 0, b

		snake_case       ,snake_case   :    Tuple			       =		a, b
		snake_case       ,snake_case   :    List[str]			       =		1, 0
		snake_case       ,snake_case   :    Optional[Any]			       =		0, 1

		while remainder != 0:
				snake_case   :    int			       =		old_remainder // remainder
				snake_case       ,snake_case   :    Tuple			       =		remainder, old_remainder - quotient * remainder
				snake_case       ,snake_case   :    Optional[Any]			       =		coeff_a, old_coeff_a - quotient * coeff_a
				snake_case       ,snake_case   :    Dict			       =		coeff_b, old_coeff_b - quotient * coeff_b

		# sign correction for negative numbers
		if a < 0:
				snake_case   :    Optional[Any]			       =		-old_coeff_a
		if b < 0:
				snake_case   :    int			       =		-old_coeff_b

		return old_coeff_a, old_coeff_b




def 					_UpperCamelCase		(    )   ->				str:


		'''simple docstring'''


		if len(sys.argv       ) < 3:
				print('''2 integer arguments required'''       )
				return 1
		snake_case   :    str			       =		int(sys.argv[1]       )
		snake_case   :    List[str]			       =		int(sys.argv[2]       )
		print(extended_euclidean_algorithm(SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__       )       )
		return 0


if __name__ == "__main__":
						raise SystemExit(main())


