






from queue import PriorityQueue
from typing import Any

import numpy as np





def 						__UpperCAmelCase			(     a_							,     a_							,     a_							,     a_							,     a_							,     a_							,     a_							,     a_							,     a_							,     ):

							for nxt, d in graph[v]:
														if nxt in visited_forward:
																					continue
														snake_case_				=							cst_fwd.get(__a							,     np.inf)
														snake_case_				=							cst_fwd[v] + d
														if new_cost_f < old_cost_f:
																					queue.put((new_cost_f, nxt))
																					snake_case_				=							new_cost_f
																					snake_case_				=							v
														if nxt in visited_backward:
																					if cst_fwd[v] + d + cst_bwd[nxt] < shortest_distance:
																												snake_case_				=							cst_fwd[v] + d + cst_bwd[nxt]
							return shortest_distance





def 						__UpperCAmelCase			(     a_							,     a_							,     a_							,     a_):
							snake_case_				=							-1

							snake_case_				=							set()
							snake_case_				=							set()
							snake_case_				=							{source: 0}
							snake_case_				=							{destination: 0}
							snake_case_				=							{source: None}
							snake_case_				=							{destination: None}
							snake_case_				=							PriorityQueue()
							snake_case_				=							PriorityQueue()

							snake_case_				=							np.inf

							queue_forward.put((0, source))
							queue_backward.put((0, destination))

							if source == destination:
														return 0

							while not queue_forward.empty() and not queue_backward.empty():
														snake_case_			,		snake_case_				=							queue_forward.get()
														visited_forward.add(__a)

														snake_case_			,		snake_case_				=							queue_backward.get()
														visited_backward.add(__a)

														snake_case_				=							pass_and_relaxation(
														    __a							,     __a							,     __a							,     __a							,     __a							,     __a							,     __a							,     __a							,     __a							,     )

														snake_case_				=							pass_and_relaxation(
														    __a							,     __a							,     __a							,     __a							,     __a							,     __a							,     __a							,     __a							,     __a							,     )

														if cst_fwd[v_fwd] + cst_bwd[v_bwd] >= shortest_distance:
																					break

							if shortest_distance != np.inf:
														snake_case_				=							shortest_distance
							return shortest_path_distance


lowercase  							=					{
    '''B''': [['''C''', 1]],
    '''C''': [['''D''', 1]],
    '''D''': [['''F''', 1]],
    '''E''': [['''B''', 1], ['''G''', 2]],
    '''F''': [],
    '''G''': [['''F''', 1]],
}
lowercase  							=					{
    '''B''': [['''E''', 1]],
    '''C''': [['''B''', 1]],
    '''D''': [['''C''', 1]],
    '''F''': [['''D''', 1], ['''G''', 1]],
    '''E''': [[None, np.inf]],
    '''G''': [['''E''', 2]],
}

if __name__ == "__main__":
	import doctest

	doctest.testmod()












def    __lowerCamelCase					(							__a   :int = 1_0_0_0_0_0_0    )		->				int:






		"""simple docstring"""

		A__        =   limit + 1
		A__        =   [0] * limit
		for first_term in range(1    ,     __a    ):
				for n in range(__a    ,     __a    ,     __a    ):
						A__        =   first_term + n / first_term
						if common_difference % 4:  # d must be divisble by 4
								continue
						else:
								common_difference /= 4
								if (
								    first_term > common_difference
								    and first_term < 4 * common_difference
								):  # since x,y,z are positive integers
										frequency[n] += 1  # so z>0 and a>d ,also 4d<a

		A__        =   sum(1 for x in frequency[1:limit] if x == 1_0    )

		return count


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



