






"""simple docstring"""
class        UpperCamelCase__ :







    """simple docstring"""







    def __init__(		self :	Optional[Any] ):





           '''simple docstring'''

           __magic_name__      				=    0
           __magic_name__      				=    0
           __magic_name__      				=    {}







    def 				a__			(		self :	List[str]				,    UpperCamelCase_ :	List[str] ):





           '''simple docstring'''

           if vertex not in self.adjacency:
                  __magic_name__      				=    {}
                  self.num_vertices += 1







    def 				a__			(		self :	Optional[Any]				,    UpperCamelCase_ :	str				,    UpperCamelCase_ :	Tuple				,    UpperCamelCase_ :	Optional[Any] ):





           '''simple docstring'''

           self.add_vertex(UpperCamelCase_ )
           self.add_vertex(UpperCamelCase_ )

           if head == tail:
                  return

           __magic_name__      				=    weight
           __magic_name__      				=    weight







    def 				a__			(		self :	Union[str, Any] ):





           '''simple docstring'''

           __magic_name__      				=    self.get_edges()
           for edge in edges:
                  __magic_name__				,  __magic_name__				,  __magic_name__      				=    edge
                  edges.remove((tail, head, weight) )
           for i in range(len(UpperCamelCase_ ) ):
                  __magic_name__      				=    list(edges[i] )

           edges.sort(key=lambda UpperCamelCase_ : e[2] )
           for i in range(len(UpperCamelCase_ ) - 1 ):
                  if edges[i][2] >= edges[i + 1][2]:
                         __magic_name__      				=    edges[i][2] + 1
           for edge in edges:
                  __magic_name__				,  __magic_name__				,  __magic_name__      				=    edge
                  __magic_name__      				=    weight
                  __magic_name__      				=    weight







    def __str__(		self :	Any ):





           '''simple docstring'''

           __magic_name__      				=    ''
           for tail in self.adjacency:
                  for head in self.adjacency[tail]:
                         __magic_name__      				=    self.adjacency[head][tail]
                         string += f"""{head} -> {tail} == {weight}\n"""
           return string.rstrip('\n' )







    def 				a__			(		self :	str ):





           '''simple docstring'''

           __magic_name__      				=    []
           for tail in self.adjacency:
                  for head in self.adjacency[tail]:
                         output.append((tail, head, self.adjacency[head][tail]) )
           return output







    def 				a__			(		self :	Dict ):





           '''simple docstring'''

           return self.adjacency.keys()







    @staticmethod
    def 				a__			(		UpperCamelCase_ :	Tuple=None				,    UpperCamelCase_ :	Union[str, Any]=None ):





           '''simple docstring'''

           __magic_name__      				=    Graph()
           if vertices is None:
                  __magic_name__      				=    []
           if edges is None:
                  __magic_name__      				=    []
           for vertex in vertices:
                  g.add_vertex(UpperCamelCase_ )
           for edge in edges:
                  g.add_edge(*UpperCamelCase_ )
           return g



    class        UpperCamelCase__ :







        """simple docstring"""







        def __init__(		self :	Dict ):





               '''simple docstring'''

               __magic_name__      				=    {}
               __magic_name__      				=    {}







        def __len__(		self :	List[Any] ):





               '''simple docstring'''

               return len(self.parent )







        def 				a__			(		self :	Dict				,    UpperCamelCase_ :	List[Any] ):





               '''simple docstring'''

               if item in self.parent:
                      return self.find(UpperCamelCase_ )

               __magic_name__      				=    item
               __magic_name__      				=    0
               return item







        def 				a__			(		self :	Optional[Any]				,    UpperCamelCase_ :	Any ):





               '''simple docstring'''

               if item not in self.parent:
                      return self.make_set(UpperCamelCase_ )
               if item != self.parent[item]:
                      __magic_name__      				=    self.find(self.parent[item] )
               return self.parent[item]







        def 				a__			(		self :	Dict				,    UpperCamelCase_ :	str				,    UpperCamelCase_ :	Dict ):





               '''simple docstring'''

               __magic_name__      				=    self.find(UpperCamelCase_ )
               __magic_name__      				=    self.find(UpperCamelCase_ )

               if roota == roota:
                      return roota

               if self.rank[roota] > self.rank[roota]:
                      __magic_name__      				=    roota
                      return roota

               if self.rank[roota] < self.rank[roota]:
                      __magic_name__      				=    roota
                      return roota

               if self.rank[roota] == self.rank[roota]:
                      self.rank[roota] += 1
                      __magic_name__      				=    roota
                      return roota
               return None







    @staticmethod
    def 				a__			(		UpperCamelCase_ :	List[Any] ):





           '''simple docstring'''

           __magic_name__      				=    graph.num_vertices

           __magic_name__      				=    Graph.UnionFind()
           __magic_name__      				=    []
           while num_components > 1:
                  __magic_name__      				=    {}
                  for vertex in graph.get_vertices():
                         __magic_name__      				=    -1

                  __magic_name__      				=    graph.get_edges()
                  for edge in edges:
                         __magic_name__				,  __magic_name__				,  __magic_name__      				=    edge
                         edges.remove((tail, head, weight) )
                  for edge in edges:
                         __magic_name__				,  __magic_name__				,  __magic_name__      				=    edge
                         __magic_name__      				=    union_find.find(UpperCamelCase_ )
                         __magic_name__      				=    union_find.find(UpperCamelCase_ )
                         if seta != seta:
                                if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
                                       __magic_name__      				=    [head, tail, weight]

                                if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
                                       __magic_name__      				=    [head, tail, weight]
                  for vertex in cheap_edge:
                         if cheap_edge[vertex] != -1:
                                __magic_name__				,  __magic_name__				,  __magic_name__      				=    cheap_edge[vertex]
                                if union_find.find(UpperCamelCase_ ) != union_find.find(UpperCamelCase_ ):
                                       union_find.union(UpperCamelCase_				,    UpperCamelCase_ )
                                       mst_edges.append(cheap_edge[vertex] )
                                       __magic_name__      				=    num_components - 1
           __magic_name__      				=    Graph.build(edges=UpperCamelCase_ )
           return mst







"""simple docstring"""
def 							A						(				__snake_case: int = 1_0_0_0_0_0_0  )    ->		int:

       """simple docstring"""





       __magic_name__      				=    limit + 1
       __magic_name__      				=    [0] * limit
       for first_term in range(1 ,     __snake_case  ):
              for n in range(__snake_case ,     __snake_case ,     __snake_case  ):
                     __magic_name__      				=    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

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

       return count


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