def  __UpperCamelCase    (						A = 50000000							):
     UpperCamelCase__										=      set()
     UpperCamelCase__										=      int((limit - 24) ** (1 / 2)							)

     UpperCamelCase__										=      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 ,							A							)							)							)

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

     return len(A							)


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




from typing import Optional, Union

import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin



class     _A   (    __UpperCamelCase	, __UpperCamelCase							):






  @register_to_config
  def __init__(self   ,				SCREAMING_SNAKE_CASE_ = 768   ,				)		->      Tuple:





       '''simple docstring'''





       super().__init__()

       UpperCamelCase__										=      nn.Parameter(torch.zeros(1   ,				SCREAMING_SNAKE_CASE_	)	)
       UpperCamelCase__										=      nn.Parameter(torch.ones(1   ,				SCREAMING_SNAKE_CASE_	)	)






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_ = None   ,				SCREAMING_SNAKE_CASE_ = None   ,				)		->      Tuple:





       '''simple docstring'''





       UpperCamelCase__										=      nn.Parameter(self.mean.to(SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	)	)
       UpperCamelCase__										=      nn.Parameter(self.std.to(SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	)	)
       return self






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_	)		->      int:





       '''simple docstring'''





       UpperCamelCase__										=      (embeds - self.mean) * 1.0 / self.std
       return embeds






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_	)		->      int:





       '''simple docstring'''





       UpperCamelCase__										=      (embeds * self.std) + self.mean
       return embeds



