


import cmath
import math






def 			UpperCamelCase (     __magic_name__					:							float   ,   __magic_name__					:							float   ,   __magic_name__					:							float   ,   __magic_name__					:							float					):
		"""simple docstring"""




		lowercase__					      =		math.radians(__magic_name__					)
		lowercase__					      =		math.radians(__magic_name__					)

		# Convert voltage and current to rectangular form
		lowercase__					      =		cmath.rect(__magic_name__   ,   __magic_name__					)
		lowercase__					      =		cmath.rect(__magic_name__   ,   __magic_name__					)

		# Calculate apparent power
		return voltage_rect * current_rect


if __name__ == "__main__":
	import doctest

	doctest.testmod()





from __future__ import annotations

from collections import deque



class 							A   :
					'''simple docstring'''






					def __init__(self   :						Any				, _UpperCAmelCase   :						list[str]		)						->       Optional[int]:




							"""simple docstring"""


							lowercase__					      =		[]
							self.adlist.append(
							    {"""value""": """""", """next_states""": [], """fail_state""": 0, """output""": []}		)

							for keyword in keywords:
									self.add_keyword(_UpperCAmelCase		)
							self.set_fail_transitions()

					def   lowerCamelCase__					(self   :						List[str]				, _UpperCAmelCase   :						int				, _UpperCAmelCase   :						str		)						->       int | None:




							"""simple docstring"""


							for state in self.adlist[current_state]["next_states"]:
									if char == self.adlist[state]["value"]:
											return state
							return None

					def   lowerCamelCase__					(self   :						List[Any]				, _UpperCAmelCase   :						str		)						->       None:




							"""simple docstring"""


							lowercase__					      =		0
							for character in keyword:
									lowercase__					      =		self.find_next_state(_UpperCAmelCase				, _UpperCAmelCase		)
									if next_state is None:
											self.adlist.append(
											    {
											        """value""": character,
											        """next_states""": [],
											        """fail_state""": 0,
											        """output""": [],
											    }		)
											self.adlist[current_state]["next_states"].append(len(self.adlist		) - 1		)
											lowercase__					      =		len(self.adlist		) - 1
									else:
											lowercase__					      =		next_state
							self.adlist[current_state]["output"].append(_UpperCAmelCase		)

					def   lowerCamelCase__					(self   :						Any		)						->       None:




							"""simple docstring"""


							lowercase__					      =		deque()
							for node in self.adlist[0]["next_states"]:
									q.append(_UpperCAmelCase		)
									lowercase__					      =		0
							while q:
									lowercase__					      =		q.popleft()
									for child in self.adlist[r]["next_states"]:
											q.append(_UpperCAmelCase		)
											lowercase__					      =		self.adlist[r]["""fail_state"""]
											while (
											    self.find_next_state(_UpperCAmelCase				, self.adlist[child]["""value"""]		) is None
											    and state != 0
											):
													lowercase__					      =		self.adlist[state]["""fail_state"""]
											lowercase__					      =		self.find_next_state(
											    _UpperCAmelCase				, self.adlist[child]["""value"""]		)
											if self.adlist[child]["fail_state"] is None:
													lowercase__					      =		0
											lowercase__					      =		(
											    self.adlist[child]["""output"""]
											    + self.adlist[self.adlist[child]["""fail_state"""]]["""output"""]
											)


					def   lowerCamelCase__					(self   :						List[str]				, _UpperCAmelCase   :						str		)						->       dict[str, list[int]]:




							"""simple docstring"""


							lowercase__					      =		{}  # returns a dict with keywords and list of its occurrences
							lowercase__					      =		0
							for i in range(len(_UpperCAmelCase		)		):
									while (
									    self.find_next_state(_UpperCAmelCase				, string[i]		) is None
									    and current_state != 0
									):
											lowercase__					      =		self.adlist[current_state]["""fail_state"""]
									lowercase__					      =		self.find_next_state(_UpperCAmelCase				, string[i]		)
									if next_state is None:
											lowercase__					      =		0
									else:
											lowercase__					      =		next_state
											for key in self.adlist[current_state]["output"]:
													if key not in result:
															lowercase__					      =		[]
													result[key].append(i - len(_UpperCAmelCase		) + 1		)
							return result


if __name__ == "__main__":
	import doctest

	doctest.testmod()

