




# Author: OMKAR PATHAK, Nwachukwu Chidiebere

# Use a Python dictionary to construct the graph.
from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

__SCREAMING_SNAKE_CASE 						=TypeVar("""T""")






class  __magic_name__						(  Generic[T]):
				'''simple docstring'''







				def __init__(							self:   Dict		,					_lowerCamelCase:   Any = True		):
											SCREAMING_SNAKE_CASE_   	=    {}  # dictionary of lists
											SCREAMING_SNAKE_CASE_   	=    directed


				def     _A							(							self:   str		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   str		):

											if not self.directed:  # For undirected graphs
																		# if both source vertex and destination vertex are both present in the
																		# adjacency list, add destination vertex to source vertex list of adjacent
																		# vertices and add source vertex to destination vertex list of adjacent
																		# vertices.
																		if source_vertex in self.adj_list and destination_vertex in self.adj_list:
																									self.adj_list[source_vertex].append(_lowerCamelCase		)
																									self.adj_list[destination_vertex].append(_lowerCamelCase		)
																		# if only source vertex is present in adjacency list, add destination vertex
																		# to source vertex list of adjacent vertices, then create a new vertex with
																		# destination vertex as key and assign a list containing the source vertex
																		# as it's first adjacent vertex.
																		elif source_vertex in self.adj_list:
																									self.adj_list[source_vertex].append(_lowerCamelCase		)
																									SCREAMING_SNAKE_CASE_   	=    [source_vertex]
																		# if only destination vertex is present in adjacency list, add source vertex
																		# to destination vertex list of adjacent vertices, then create a new vertex
																		# with source vertex as key and assign a list containing the source vertex
																		# as it's first adjacent vertex.
																		elif destination_vertex in self.adj_list:
																									self.adj_list[destination_vertex].append(_lowerCamelCase		)
																									SCREAMING_SNAKE_CASE_   	=    [destination_vertex]
																		# if both source vertex and destination vertex are not present in adjacency
																		# list, create a new vertex with source vertex as key and assign a list
																		# containing the destination vertex as it's first adjacent vertex also
																		# create a new vertex with destination vertex as key and assign a list
																		# containing the source vertex as it's first adjacent vertex.
																		else:
																									SCREAMING_SNAKE_CASE_   	=    [destination_vertex]
																									SCREAMING_SNAKE_CASE_   	=    [source_vertex]
											else:  # For directed graphs
																		# if both source vertex and destination vertex are present in adjacency
																		# list, add destination vertex to source vertex list of adjacent vertices.
																		if source_vertex in self.adj_list and destination_vertex in self.adj_list:
																									self.adj_list[source_vertex].append(_lowerCamelCase		)
																		# if only source vertex is present in adjacency list, add destination
																		# vertex to source vertex list of adjacent vertices and create a new vertex
																		# with destination vertex as key, which has no adjacent vertex
																		elif source_vertex in self.adj_list:
																									self.adj_list[source_vertex].append(_lowerCamelCase		)
																									SCREAMING_SNAKE_CASE_   	=    []
																		# if only destination vertex is present in adjacency list, create a new
																		# vertex with source vertex as key and assign a list containing destination
																		# vertex as first adjacent vertex
																		elif destination_vertex in self.adj_list:
																									SCREAMING_SNAKE_CASE_   	=    [destination_vertex]
																		# if both source vertex and destination vertex are not present in adjacency
																		# list, create a new vertex with source vertex as key and a list containing
																		# destination vertex as it's first adjacent vertex. Then create a new vertex
																		# with destination vertex as key, which has no adjacent vertex
																		else:
																									SCREAMING_SNAKE_CASE_   	=    [destination_vertex]
																									SCREAMING_SNAKE_CASE_   	=    []

											return self





				def __repr__(							self:   Union[str, Any]		):
											return pformat(self.adj_list		)








from __future__ import annotations

from math import pi

# Define the Reduced Planck Constant ℏ (H bar), speed of light C, value of
# Pi and the function
__SCREAMING_SNAKE_CASE 						=1.0_5_4_5_7_1_8_1_7e-3_4  # unit of ℏ : J * s

__SCREAMING_SNAKE_CASE 						=3e8  # unit of c : m * s^-1

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase  ,    _lowerCAmelCase     ):

							if (force, area, distance).count(0     ) != 1:
														raise ValueError('''One and only one argument must be 0'''     )
							if force < 0:
														raise ValueError('''Magnitude of force can not be negative'''     )
							if distance < 0:
														raise ValueError('''Distance can not be negative'''     )
							if area < 0:
														raise ValueError('''Area can not be negative'''     )
							if force == 0:
														SCREAMING_SNAKE_CASE_   	=    (REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (
														    2_4_0 * (distance) ** 4
														)
														return {"force": force}
							elif area == 0:
														SCREAMING_SNAKE_CASE_   	=    (2_4_0 * force * (distance) ** 4) / (
														    REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2
														)
														return {"area": area}
							elif distance == 0:
														SCREAMING_SNAKE_CASE_   	=    (
														    (REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (2_4_0 * force)
														) ** (1 / 4)
														return {"distance": distance}
							raise ValueError('''One and only one argument must be 0'''     )


# Run doctest
if __name__ == "__main__":
			import doctest

			doctest.testmod()


