code: 
  
  import math
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					int    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       if n <= 0:
            raise ValueError('Only positive integers have prime factors'    )
       lowercase__					:     Optional[Any]   = []
       while n % 2 == 0:
            pf.append(2    )
            lowercase__					:     List[Any]   = int(n / 2    )
       for i in range(3			,  int(math.sqrt(SCREAMING_SNAKE_CASE_    )    ) + 1			,  2    ):
            while n % i == 0:
                 pf.append(SCREAMING_SNAKE_CASE_    )
                 lowercase__					:     Dict   = int(n / i    )
       if n > 2:
            pf.append(SCREAMING_SNAKE_CASE_    )
       return pf
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					int    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       if n <= 0:
            raise ValueError('Only positive numbers are accepted'    )
       lowercase__					:     Optional[int]   = 1
       lowercase__					:     Any   = 1
       while n % 2 == 0:
            temp += 1
            lowercase__					:     List[Any]   = int(n / 2    )
       div *= temp
       for i in range(3			,  int(math.sqrt(SCREAMING_SNAKE_CASE_    )    ) + 1			,  2    ):
            lowercase__					:     Dict   = 1
            while n % i == 0:
                 temp += 1
                 lowercase__					:     Dict   = int(n / i    )
            div *= temp
       if n > 1:
            div *= 2
       return div
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					int    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       if n <= 0:
            raise ValueError('Only positive numbers are accepted'    )
       lowercase__					:     Tuple   = 1
       lowercase__					:     Dict   = 1
       while n % 2 == 0:
            temp += 1
            lowercase__					:     Optional[int]   = int(n / 2    )
       if temp > 1:
            s *= (2**temp - 1) / (2 - 1)
       for i in range(3			,  int(math.sqrt(SCREAMING_SNAKE_CASE_    )    ) + 1			,  2    ):
            lowercase__					:     List[Any]   = 1
            while n % i == 0:
                 temp += 1
                 lowercase__					:     Any   = int(n / i    )
            if temp > 1:
                 s *= (i**temp - 1) / (i - 1)
       return int(SCREAMING_SNAKE_CASE_    )
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					int    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       lowercase__					:     Union[str, Any]   = n
       for x in set(prime_factors(SCREAMING_SNAKE_CASE_    )    ):
            s *= (x - 1) / x
       return int(SCREAMING_SNAKE_CASE_    )
  
  
  if __name__ == "__main__":
         import doctest
  
         doctest.testmod()
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_tf_available,
      is_torch_available,
  )
  
  
  snake_case_    						=				{'''configuration_gptj''': ['''GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPTJConfig''', '''GPTJOnnxConfig''']}
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				[
             '''GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST''',
             '''GPTJForCausalLM''',
             '''GPTJForQuestionAnswering''',
             '''GPTJForSequenceClassification''',
             '''GPTJModel''',
             '''GPTJPreTrainedModel''',
         ]
  
  try:
         if not is_tf_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				[
             '''TFGPTJForCausalLM''',
             '''TFGPTJForQuestionAnswering''',
             '''TFGPTJForSequenceClassification''',
             '''TFGPTJModel''',
             '''TFGPTJPreTrainedModel''',
         ]
  
  try:
         if not is_flax_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				[
             '''FlaxGPTJForCausalLM''',
             '''FlaxGPTJModel''',
             '''FlaxGPTJPreTrainedModel''',
         ]
  
  
  if TYPE_CHECKING:
         from .configuration_gptj import GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTJConfig, GPTJOnnxConfig
  
         try:
                if not is_torch_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_gptj import (
                    GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST,
                    GPTJForCausalLM,
                    GPTJForQuestionAnswering,
                    GPTJForSequenceClassification,
                    GPTJModel,
                    GPTJPreTrainedModel,
                )
  
         try:
                if not is_tf_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_tf_gptj import (
                    TFGPTJForCausalLM,
                    TFGPTJForQuestionAnswering,
                    TFGPTJForSequenceClassification,
                    TFGPTJModel,
                    TFGPTJPreTrainedModel,
                )
  
         try:
                if not is_flax_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_flax_gptj import FlaxGPTJForCausalLM, FlaxGPTJModel, FlaxGPTJPreTrainedModel
  
  else:
         import sys
  
         snake_case_    						=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  