





from __future__ import annotations

from collections import deque
from collections.abc import Iterator
from dataclasses import dataclass


@dataclass
class   A			:
			'''simple docstring'''




			__lowerCamelCase	:       int
			__lowerCamelCase	:       int


class   A			:
			'''simple docstring'''




			def __init__(			self   :    List[str]							,	__lowerCAmelCase   :    int   )	->	Dict:







					"""simple docstring"""






					A__        =   [[] for _ in range(__lowerCAmelCase   )]
					A__        =   size






			def __getitem__(			self   :    Dict							,	__lowerCAmelCase   :    int   )	->	Iterator[Edge]:







					"""simple docstring"""






					return iter(self._graph[vertex]   )






			@property
			def    a_       (			self   :    Tuple   )	->	str:







					"""simple docstring"""






					return self._size






			def    a_       (			self   :    str							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    int   )	->	Tuple:







					"""simple docstring"""






					if weight not in (0, 1):
							raise ValueError("""Edge weight must be either 0 or 1."""   )

					if to_vertex < 0 or to_vertex >= self.size:
							raise ValueError("""Vertex indexes must be in [0; size)."""   )

					self._graph[from_vertex].append(Edge(__lowerCAmelCase							,	__lowerCAmelCase   )   )







			def    a_       (			self   :    Dict							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    int   )	->	int | None:







					"""simple docstring"""






					A__        =   deque([start_vertex]   )
					A__        =   [None] * self.size
					A__        =   0

					while queue:
							A__        =   queue.popleft()
							A__        =   distances[current_vertex]
							if current_distance is None:
									continue

							for edge in self[current_vertex]:
									A__        =   current_distance + edge.weight
									A__        =   distances[edge.destination_vertex]
									if (
									    isinstance(__lowerCAmelCase							,	__lowerCAmelCase   )
									    and new_distance >= dest_vertex_distance
									):
											continue
									A__        =   new_distance
									if edge.weight == 0:
											queue.appendleft(edge.destination_vertex   )
									else:
											queue.append(edge.destination_vertex   )

					if distances[finish_vertex] is None:
							raise ValueError("""No path from start_vertex to finish_vertex."""   )

					return distances[finish_vertex]


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() = }''')



