



'''simple docstring'''





from math import asin, atan, cos, radians, sin, sqrt, tan

_UpperCamelCase											=						6378137.0
_UpperCamelCase											=						6356752.314245
_UpperCamelCase											=						6378137

def        a_     (							_lowerCAmelCase       ,_lowerCAmelCase       ,_lowerCAmelCase       ,_lowerCAmelCase       )      ->      float:
  __lowerCamelCase       :       Any           = (AXIS_A - AXIS_B) / AXIS_A
  __lowerCamelCase       :       List[str]           = atan((1 - flattening) * tan(radians(_lowerCamelCase       )       )       )
  __lowerCamelCase       :       Dict           = atan((1 - flattening) * tan(radians(_lowerCamelCase       )       )       )
  __lowerCamelCase       :       Optional[Any]           = radians(_lowerCamelCase       )
  __lowerCamelCase       :       int           = radians(_lowerCamelCase       )
  # Equation
  __lowerCamelCase       :       Dict           = sin((phi_a - phi_a) / 2       )
  __lowerCamelCase       :       Tuple           = sin((lambda_a - lambda_a) / 2       )
  # Square both values
  sin_sq_phi *= sin_sq_phi
  sin_sq_lambda *= sin_sq_lambda
  __lowerCamelCase       :       int           = sqrt(sin_sq_phi + (cos(_lowerCamelCase       ) * cos(_lowerCamelCase       ) * sin_sq_lambda)       )
  return 2 * RADIUS * asin(_lowerCamelCase       )


if __name__ == "__main__":
   import doctest

   doctest.testmod()







"""simple docstring"""




def 							SCREAMING_SNAKE_CASE     (			_lowerCamelCase						:       Any	)       ->      List[Any]:  # noqa: E741
  _lowerCAmelCase						:       Optional[int]  			=     len(_lowerCamelCase	)
  _lowerCAmelCase						:       str  			=     0
  _lowerCAmelCase						:       Any  			=     [0] * n
  _lowerCAmelCase						:       str  			=     [False] * n
  _lowerCAmelCase						:       str  			=     [False] * n

  def dfs(_lowerCamelCase						:       Tuple			,_lowerCamelCase						:       Union[str, Any]			,_lowerCamelCase						:       Union[str, Any]			,_lowerCamelCase						:       str	):
    if parent == root:
      out_edge_count += 1
    _lowerCAmelCase						:       Any  			=     True
    _lowerCAmelCase						:       int  			=     at

    for to in l[at]:
      if to == parent:
        pass
      elif not visited[to]:
        _lowerCAmelCase						:       Union[str, Any]  			=     dfs(_lowerCamelCase			,_lowerCamelCase			,_lowerCamelCase			,_lowerCamelCase	)
        _lowerCAmelCase						:       Optional[int]  			=     min(low[at]			,low[to]	)

        # AP found via bridge
        if at < low[to]:
          _lowerCAmelCase						:       int  			=     True
        # AP found via cycle
        if at == low[to]:
          _lowerCAmelCase						:       Tuple  			=     True
      else:
        _lowerCAmelCase						:       Union[str, Any]  			=     min(low[at]			,_lowerCamelCase	)
    return out_edge_count

  for i in range(_lowerCamelCase	):
    if not visited[i]:
      _lowerCAmelCase						:       int  			=     0
      _lowerCAmelCase						:       Dict  			=     dfs(_lowerCamelCase			,_lowerCamelCase			,-1			,_lowerCamelCase	)
      _lowerCAmelCase						:       List[str]  			=     out_edge_count > 1

  for x in range(len(_lowerCamelCase	)	):
    if is_art[x] is True:
      print(_lowerCamelCase	)


# Adjacency list of graph
_a      :		Optional[Any]           =   {
    0: [1, 2],
    1: [0, 2],
    2: [0, 1, 3, 5],
    3: [2, 4],
    4: [3],
    5: [2, 6, 8],
    6: [5, 7],
    7: [6, 8],
    8: [5, 7],
}






compute_ap(data)




