


'''simple docstring'''

def __snake_case					(      UpperCAmelCase_						:						int = 50000000		):
 lowerCamelCase_      =  set()
 lowerCamelCase_      =  int((limit - 24) ** (1 / 2)		)

 lowerCamelCase_      =  set(range(3					,				prime_square_limit + 1					,				2		)		)
 primes.add(2		)
 for p in range(3					,				prime_square_limit + 1					,				2		):
  if p not in primes:
   continue
  primes.difference_update(set(range(p * p					,				prime_square_limit + 1					,				UpperCAmelCase_		)		)		)

 for primea in primes:
  lowerCamelCase_      =  primea * primea
  for primea in primes:
   lowerCamelCase_      =  primea * primea * primea
   if square + cube >= limit - 16:
    break
   for primea in primes:
    lowerCamelCase_      =  primea * primea * primea * primea
    lowerCamelCase_      =  square + cube + tetr
    if total >= limit:
     break
    ret.add(UpperCAmelCase_		)

 return len(UpperCAmelCase_		)


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








from __future__ import annotations

from typing import Any



class 				lowerCAmelCase_		:
       def __init__(			self,			SCREAMING_SNAKE_CASE_       )     ->		None:
          UpperCamelCase    :  Any							=	num_of_nodes
          UpperCamelCase    :  list[list[int]]							=	[]
          UpperCamelCase    :  dict[int, int]							=	{}
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		None:
          self.m_edges.append([u_node, v_node, weight]       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_       )     ->		int:

          if self.m_component[u_node] == u_node:
             return u_node
          return self.find_component(self.m_component[u_node]       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_       )     ->		None:

          if self.m_component[u_node] != u_node:
             for k in self.m_component:
                UpperCamelCase    :  Dict							=	self.find_component(SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		None:

          if component_size[u_node] <= component_size[v_node]:
             UpperCamelCase    :  Tuple							=	v_node
             component_size[v_node] += component_size[u_node]
             self.set_component(SCREAMING_SNAKE_CASE_       )

          elif component_size[u_node] >= component_size[v_node]:
             UpperCamelCase    :  Union[str, Any]							=	self.find_component(SCREAMING_SNAKE_CASE_       )
             component_size[u_node] += component_size[v_node]
             self.set_component(SCREAMING_SNAKE_CASE_       )






       def 					snake_case_       (			self       )     ->		None:
          UpperCamelCase    :  int							=	[]
          UpperCamelCase    :  int							=	0

          UpperCamelCase    :  list[Any]							=	[-1] * self.m_num_of_nodes

          # A list of components (initialized to all of the nodes)
          for node in range(self.m_num_of_nodes       ):
             self.m_component.update({node: node}       )
             component_size.append(1       )

          UpperCamelCase    :  List[str]							=	self.m_num_of_nodes

          while num_of_components > 1:
             for edge in self.m_edges:
                UpperCamelCase	,     UpperCamelCase	,     UpperCamelCase    :  List[Any]							=	edge

                UpperCamelCase    :  str							=	self.m_component[u]
                UpperCamelCase    :  Any							=	self.m_component[v]

                if u_component != v_component:

                   for component in (u_component, v_component):
                      if (
                          minimum_weight_edge[component] == -1
                          or minimum_weight_edge[component][2] > w
                      ):
                         UpperCamelCase    :  Any							=	[u, v, w]

             for edge in minimum_weight_edge:
                if isinstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       ):
                   UpperCamelCase	,     UpperCamelCase	,     UpperCamelCase    :  int							=	edge

                   UpperCamelCase    :  List[Any]							=	self.m_component[u]
                   UpperCamelCase    :  Tuple							=	self.m_component[v]

                   if u_component != v_component:
                      mst_weight += w
                      self.union(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
                      print(F"""Added edge [{u} - {v}]\nAdded weight: {w}\n"""       )
                      num_of_components -= 1

             UpperCamelCase    :  Optional[Any]							=	[-1] * self.m_num_of_nodes
          print(F"""The total weight of the minimal spanning tree is: {mst_weight}"""       )






def 		UpperCamelCase	(   )	->     None:
   pass


if __name__ == "__main__":
    import doctest

    doctest.testmod()



