"""simple docstring"""






import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation





class 				_A		( unittest.TestCase			):

      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			get_activation("""swish"""		)

            self.assertIsInstance(__lowerCamelCase	, nn.SiLU		)

            self.assertEqual(act(torch.tensor(-100	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertNotEqual(act(torch.tensor(-1	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertEqual(act(torch.tensor(0	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertEqual(act(torch.tensor(20	, dtype=torch.floataa		)		).item()	, 20		)

      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			get_activation("""silu"""		)

            self.assertIsInstance(__lowerCamelCase	, nn.SiLU		)

            self.assertEqual(act(torch.tensor(-100	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertNotEqual(act(torch.tensor(-1	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertEqual(act(torch.tensor(0	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertEqual(act(torch.tensor(20	, dtype=torch.floataa		)		).item()	, 20		)

      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			get_activation("""mish"""		)

            self.assertIsInstance(__lowerCamelCase	, nn.Mish		)

            self.assertEqual(act(torch.tensor(-200	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertNotEqual(act(torch.tensor(-1	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertEqual(act(torch.tensor(0	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertEqual(act(torch.tensor(20	, dtype=torch.floataa		)		).item()	, 20		)







      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			get_activation("""gelu"""		)

            self.assertIsInstance(__lowerCamelCase	, nn.GELU		)

            self.assertEqual(act(torch.tensor(-100	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertNotEqual(act(torch.tensor(-1	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertEqual(act(torch.tensor(0	, dtype=torch.floataa		)		).item()	, 0		)
            self.assertEqual(act(torch.tensor(20	, dtype=torch.floataa		)		).item()	, 20		)




"""simple docstring"""






from __future__ import annotations

import math


def     UpperCAmelCase__ (       lowerCAmelCase__  :int	)				->					list[int]:
      '''simple docstring'''


      if num <= 0:
            lowercase														=			f'{num}: Invalid input, please enter a positive integer.'
            raise ValueError(lowerCAmelCase__	)

      lowercase														=			[True] * (num + 1)
      lowercase														=			[]
      lowercase														=			2
      lowercase														=			int(math.sqrt(lowerCAmelCase__	)	)

      while start <= end:
            # If start is a prime
            if sieve[start] is True:
                  prime.append(lowerCAmelCase__	)

                  # Set multiples of start be False
                  for i in range(start * start      ,	num + 1      ,	lowerCAmelCase__	):
                        if sieve[i] is True:
                              lowercase														=			False

            start += 1

      for j in range(end + 1      ,	num + 1	):
            if sieve[j] is True:
                  prime.append(lowerCAmelCase__	)

      return prime


if __name__ == "__main__":
       print(prime_sieve(int(input("""Enter a positive integer: """).strip())))



