import collections.abc
from typing import Optional, Tuple, Union

import torch
import torch.utils.checkpoint
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import BaseModelOutputWithNoAttention, ImageClassifierOutputWithNoAttention
from ...modeling_utils import PreTrainedModel
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_poolformer import PoolFormerConfig


__lowerCamelCase			: Union[str, Any]							   =		logging.get_logger(__name__)

# General docstring
__lowerCamelCase			: List[Any]							   =		'''PoolFormerConfig'''

# Base docstring
__lowerCamelCase			: Union[str, Any]							   =		'''sail/poolformer_s12'''
__lowerCamelCase			: List[Any]							   =		[1, 512, 7, 7]

# Image classification docstring
__lowerCamelCase			: str							   =		'''sail/poolformer_s12'''
__lowerCamelCase			: Optional[int]							   =		'''tabby, tabby cat'''

__lowerCamelCase			: Union[str, Any]							   =		[
    '''sail/poolformer_s12''',
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
]



def 	__SCREAMING_SNAKE_CASE  (					__UpperCamelCase    :       List[Any] ,     __UpperCamelCase    :       float = 0.0 ,     __UpperCamelCase    :       bool = False	)							->					int:







  """simple docstring"""





  if drop_prob == 0.0 or not training:
    return input
  SCREAMING_SNAKE_CASE__										=      1 - drop_prob
  SCREAMING_SNAKE_CASE__										=      (input.shape[0],) + (1,) * (input.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
  SCREAMING_SNAKE_CASE__										=      keep_prob + torch.rand(__lowerCamelCase ,     dtype=input.dtype ,     device=input.device	)
  random_tensor.floor_()  # binarize
  SCREAMING_SNAKE_CASE__										=      input.div(__lowerCamelCase	) * random_tensor
  return output







class __snake_case				(						nn.Module		):




   def __init__(    self			:				List[str]       ,	_lowercase			:				str = None      ):



     """simple docstring"""






     super().__init__()
     SCREAMING_SNAKE_CASE__										=      drop_prob




   def 	__a						(    self			:				Optional[Any]       ,	_lowercase			:				Dict      ):



     """simple docstring"""






     return drop_path(_lowercase       ,	self.drop_prob       ,	self.training      )




   def 	__a						(    self			:				Tuple      ):



     """simple docstring"""






     return "p={}".format(self.drop_prob      )







class __snake_case				(						nn.Module		):




   def __init__(    self			:				Tuple       ,	_lowercase			:				Any       ,	_lowercase			:				Tuple       ,	_lowercase			:				List[str]       ,	_lowercase			:				List[Any]       ,	_lowercase			:				Union[str, Any]       ,	_lowercase			:				Optional[Any]=None      ):



     """simple docstring"""






     super().__init__()
     SCREAMING_SNAKE_CASE__										=      patch_size if isinstance(_lowercase       ,	collections.abc.Iterable      ) else (patch_size, patch_size)
     SCREAMING_SNAKE_CASE__										=      stride if isinstance(_lowercase       ,	collections.abc.Iterable      ) else (stride, stride)
     SCREAMING_SNAKE_CASE__										=      padding if isinstance(_lowercase       ,	collections.abc.Iterable      ) else (padding, padding)

     SCREAMING_SNAKE_CASE__										=      nn.Convad(_lowercase       ,	_lowercase       ,	kernel_size=_lowercase       ,	stride=_lowercase       ,	padding=_lowercase      )
     SCREAMING_SNAKE_CASE__										=      norm_layer(_lowercase      ) if norm_layer else nn.Identity()




   def 	__a						(    self			:				Union[str, Any]       ,	_lowercase			:				Tuple      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      self.projection(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      self.norm(_lowercase      )
     return embeddings







class __snake_case				(						nn.GroupNorm		):




   def __init__(    self			:				int       ,	_lowercase			:				Optional[Any]       ,	**_lowercase			:				int      ):



     """simple docstring"""






     super().__init__(1       ,	_lowercase       ,	**_lowercase      )







class __snake_case				(						nn.Module		):




   def __init__(    self			:				List[str]       ,	_lowercase			:				Dict      ):



     """simple docstring"""






     super().__init__()
     SCREAMING_SNAKE_CASE__										=      nn.AvgPoolad(_lowercase       ,	stride=1       ,	padding=pool_size // 2       ,	count_include_pad=_lowercase      )




   def 	__a						(    self			:				Union[str, Any]       ,	_lowercase			:				Optional[int]      ):



     """simple docstring"""






     return self.pool(_lowercase      ) - hidden_states







class __snake_case				(						nn.Module		):




   def __init__(    self			:				Optional[Any]       ,	_lowercase			:				Union[str, Any]       ,	_lowercase			:				List[Any]       ,	_lowercase			:				Dict       ,	_lowercase			:				Tuple      ):



     """simple docstring"""






     super().__init__()
     SCREAMING_SNAKE_CASE__										=      nn.Convad(_lowercase       ,	_lowercase       ,	1      )
     SCREAMING_SNAKE_CASE__										=      nn.Convad(_lowercase       ,	_lowercase       ,	1      )
     SCREAMING_SNAKE_CASE__										=      PoolFormerDropPath(_lowercase      )
     if isinstance(config.hidden_act       ,	_lowercase      ):
       SCREAMING_SNAKE_CASE__										=      ACTaFN[config.hidden_act]
     else:
       SCREAMING_SNAKE_CASE__										=      config.hidden_act




   def 	__a						(    self			:				str       ,	_lowercase			:				Optional[Any]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      self.conva(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      self.act_fn(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      self.drop(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      self.conva(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      self.drop(_lowercase      )

     return hidden_states







class __snake_case				(						nn.Module		):




   def __init__(    self			:				Dict       ,	_lowercase			:				Dict       ,	_lowercase			:				str       ,	_lowercase			:				int       ,	_lowercase			:				Optional[int]       ,	_lowercase			:				str       ,	_lowercase			:				List[Any]      ):



     """simple docstring"""






     super().__init__()
     SCREAMING_SNAKE_CASE__										=      PoolFormerPooling(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      PoolFormerOutput(_lowercase       ,	_lowercase       ,	_lowercase       ,	_lowercase      )
     SCREAMING_SNAKE_CASE__										=      PoolFormerGroupNorm(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      PoolFormerGroupNorm(_lowercase      )

     # Useful for training neural nets
     SCREAMING_SNAKE_CASE__										=      PoolFormerDropPath(_lowercase      ) if drop_path > 0.0 else nn.Identity()
     SCREAMING_SNAKE_CASE__										=      config.use_layer_scale
     if config.use_layer_scale:
       SCREAMING_SNAKE_CASE__										=      nn.Parameter(
           config.layer_scale_init_value * torch.ones((_lowercase)      )       ,	requires_grad=_lowercase      )
       SCREAMING_SNAKE_CASE__										=      nn.Parameter(
           config.layer_scale_init_value * torch.ones((_lowercase)      )       ,	requires_grad=_lowercase      )




   def 	__a						(    self			:				int       ,	_lowercase			:				Dict      ):



     """simple docstring"""






     if self.use_layer_scale:
       SCREAMING_SNAKE_CASE__										=      self.pooling(self.before_norm(_lowercase      )      )
       SCREAMING_SNAKE_CASE__										=      self.layer_scale_a.unsqueeze(-1      ).unsqueeze(-1      ) * pooling_output
       # First residual connection
       SCREAMING_SNAKE_CASE__										=      hidden_states + self.drop_path(_lowercase      )
       SCREAMING_SNAKE_CASE__										=      ()

       SCREAMING_SNAKE_CASE__										=      self.output(self.after_norm(_lowercase      )      )
       SCREAMING_SNAKE_CASE__										=      self.layer_scale_a.unsqueeze(-1      ).unsqueeze(-1      ) * layer_output
       # Second residual connection
       SCREAMING_SNAKE_CASE__										=      hidden_states + self.drop_path(_lowercase      )

       SCREAMING_SNAKE_CASE__										=      (output,) + outputs
       return outputs

     else:
       SCREAMING_SNAKE_CASE__										=      self.drop_path(self.pooling(self.before_norm(_lowercase      )      )      )
       # First residual connection
       SCREAMING_SNAKE_CASE__										=      pooling_output + hidden_states
       SCREAMING_SNAKE_CASE__										=      ()

       # Second residual connection inside the PoolFormerOutput block
       SCREAMING_SNAKE_CASE__										=      self.drop_path(self.output(self.after_norm(_lowercase      )      )      )
       SCREAMING_SNAKE_CASE__										=      hidden_states + layer_output

       SCREAMING_SNAKE_CASE__										=      (output,) + outputs
       return outputs







class __snake_case				(						nn.Module		):




   def __init__(    self			:				Union[str, Any]       ,	_lowercase			:				List[str]      ):



     """simple docstring"""






     super().__init__()
     SCREAMING_SNAKE_CASE__										=      config
     # stochastic depth decay rule
     SCREAMING_SNAKE_CASE__										=      [x.item() for x in torch.linspace(0       ,	config.drop_path_rate       ,	sum(config.depths      )      )]

     # patch embeddings
     SCREAMING_SNAKE_CASE__										=      []
     for i in range(config.num_encoder_blocks      ):
       embeddings.append(
           PoolFormerEmbeddings(
               patch_size=config.patch_sizes[i]       ,	stride=config.strides[i]       ,	padding=config.padding[i]       ,	num_channels=config.num_channels if i == 0 else config.hidden_sizes[i - 1]       ,	hidden_size=config.hidden_sizes[i]       ,	)      )
     SCREAMING_SNAKE_CASE__										=      nn.ModuleList(_lowercase      )

     # Transformer blocks
     SCREAMING_SNAKE_CASE__										=      []
     SCREAMING_SNAKE_CASE__										=      0
     for i in range(config.num_encoder_blocks      ):
       # each block consists of layers
       SCREAMING_SNAKE_CASE__										=      []
       if i != 0:
         cur += config.depths[i - 1]
       for j in range(config.depths[i]      ):
         layers.append(
             PoolFormerLayer(
                 _lowercase       ,	num_channels=config.hidden_sizes[i]       ,	pool_size=config.pool_size       ,	hidden_size=config.hidden_sizes[i]       ,	intermediate_size=int(config.hidden_sizes[i] * config.mlp_ratio      )       ,	drop_path=dpr[cur + j]       ,	)      )
       blocks.append(nn.ModuleList(_lowercase      )      )

     SCREAMING_SNAKE_CASE__										=      nn.ModuleList(_lowercase      )




   def 	__a						(    self			:				Optional[Any]       ,	_lowercase			:				List[Any]       ,	_lowercase			:				Optional[Any]=False       ,	_lowercase			:				int=True      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      () if output_hidden_states else None

     SCREAMING_SNAKE_CASE__										=      pixel_values
     for idx, layers in enumerate(zip(self.patch_embeddings       ,	self.block      )      ):
       SCREAMING_SNAKE_CASE__							,     SCREAMING_SNAKE_CASE__										=      layers
       # Get patch embeddings from hidden_states
       SCREAMING_SNAKE_CASE__										=      embedding_layer(_lowercase      )
       # Send the embeddings through the blocks
       for _, blk in enumerate(_lowercase      ):
         SCREAMING_SNAKE_CASE__										=      blk(_lowercase      )
         SCREAMING_SNAKE_CASE__										=      layer_outputs[0]

       if output_hidden_states:
         SCREAMING_SNAKE_CASE__										=      all_hidden_states + (hidden_states,)

     if not return_dict:
       return tuple(v for v in [hidden_states, all_hidden_states] if v is not None      )

     return BaseModelOutputWithNoAttention(last_hidden_state=_lowercase       ,	hidden_states=_lowercase      )







class __snake_case				(						snake_case_		):
   lowerCAmelCase_														=							PoolFormerConfig
   lowerCAmelCase_														=							"poolformer"
   lowerCAmelCase_														=							"pixel_values"
   lowerCAmelCase_														=							True




   def 	__a						(    self			:				str       ,	_lowercase			:				Optional[int]      ):



     """simple docstring"""






     if isinstance(_lowercase       ,	(nn.Linear, nn.Convad)      ):
       module.weight.data.normal_(mean=0.0       ,	std=self.config.initializer_range      )
       if module.bias is not None:
         module.bias.data.zero_()
     elif isinstance(_lowercase       ,	nn.LayerNorm      ):
       module.bias.data.zero_()
       module.weight.data.fill_(1.0      )




   def 	__a						(    self			:				Dict       ,	_lowercase			:				int       ,	_lowercase			:				Tuple=False      ):



     """simple docstring"""






     if isinstance(_lowercase       ,	_lowercase      ):
       SCREAMING_SNAKE_CASE__										=      value





__lowerCamelCase			: Optional[Any]							   =		r'''
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use
    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`PoolFormerConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
'''

__lowerCamelCase			: Optional[Any]							   =		r'''
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`PoolFormerImageProcessor.__call__`] for details.
'''







@add_start_docstrings(
    "The bare PoolFormer Model transformer outputting raw hidden-states without any specific head on top."   ,		snake_case_   ,		)
class __snake_case				(						snake_case_		):




   def __init__(    self			:				Dict       ,	_lowercase			:				List[Any]      ):



     """simple docstring"""






     super().__init__(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      config

     SCREAMING_SNAKE_CASE__										=      PoolFormerEncoder(_lowercase      )

     # Initialize weights and apply final processing
     self.post_init()




   def 	__a						(    self			:				str      ):



     """simple docstring"""






     return self.embeddings.patch_embeddings




   @add_start_docstrings_to_model_forward(_lowercase      )
   @add_code_sample_docstrings(
       checkpoint=_CHECKPOINT_FOR_DOC       ,	output_type=_lowercase       ,	config_class=_CONFIG_FOR_DOC       ,	modality="""vision"""       ,	expected_output=_EXPECTED_OUTPUT_SHAPE       ,	)
   def 	__a						(    self			:				Tuple       ,	_lowercase			:				List[Any] = None       ,	_lowercase			:				Union[str, Any] = None       ,	_lowercase			:				Any = None       ,	):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      (
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     SCREAMING_SNAKE_CASE__										=      return_dict if return_dict is not None else self.config.use_return_dict

     if pixel_values is None:
       raise ValueError("""You have to specify pixel_values"""      )

     SCREAMING_SNAKE_CASE__										=      self.encoder(
         _lowercase       ,	output_hidden_states=_lowercase       ,	return_dict=_lowercase       ,	)
     SCREAMING_SNAKE_CASE__										=      encoder_outputs[0]

     if not return_dict:
       return (sequence_output, None) + encoder_outputs[1:]

     return BaseModelOutputWithNoAttention(
         last_hidden_state=_lowercase       ,	hidden_states=encoder_outputs.hidden_states       ,	)







class __snake_case				(						nn.Module		):




   def __init__(    self			:				str       ,	_lowercase			:				int      ):



     """simple docstring"""






     super().__init__()
     SCREAMING_SNAKE_CASE__										=      nn.Linear(config.hidden_size       ,	config.hidden_size      )




   def 	__a						(    self			:				List[Any]       ,	_lowercase			:				List[str]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      self.dense(_lowercase      )
     return output







@add_start_docstrings(
    "\n    PoolFormer Model transformer with an image classification head on top\n    "   ,		snake_case_   ,		)
class __snake_case				(						snake_case_		):




   def __init__(    self			:				List[Any]       ,	_lowercase			:				int      ):



     """simple docstring"""






     super().__init__(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      config.num_labels
     SCREAMING_SNAKE_CASE__										=      PoolFormerModel(_lowercase      )

     # Final norm
     SCREAMING_SNAKE_CASE__										=      PoolFormerGroupNorm(config.hidden_sizes[-1]      )
     # Classifier head
     SCREAMING_SNAKE_CASE__										=      (
         nn.Linear(config.hidden_sizes[-1]       ,	config.num_labels      ) if config.num_labels > 0 else nn.Identity()
     )

     # Initialize weights and apply final processing
     self.post_init()




   @add_start_docstrings_to_model_forward(_lowercase      )
   @add_code_sample_docstrings(
       checkpoint=_IMAGE_CLASS_CHECKPOINT       ,	output_type=_lowercase       ,	config_class=_CONFIG_FOR_DOC       ,	expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT       ,	)
   def 	__a						(    self			:				Optional[int]       ,	_lowercase			:				Union[str, Any] = None       ,	_lowercase			:				Optional[Any] = None       ,	_lowercase			:				Optional[int] = None       ,	_lowercase			:				int = None       ,	):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      return_dict if return_dict is not None else self.config.use_return_dict

     SCREAMING_SNAKE_CASE__										=      self.poolformer(
         _lowercase       ,	output_hidden_states=_lowercase       ,	return_dict=_lowercase       ,	)

     SCREAMING_SNAKE_CASE__										=      outputs[0]

     SCREAMING_SNAKE_CASE__										=      self.classifier(self.norm(_lowercase      ).mean([-2, -1]      )      )

     SCREAMING_SNAKE_CASE__										=      None
     if labels is not None:
       if self.config.problem_type is None:
         if self.num_labels == 1:
           SCREAMING_SNAKE_CASE__										=      """regression"""
         elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
           SCREAMING_SNAKE_CASE__										=      """single_label_classification"""
         else:
           SCREAMING_SNAKE_CASE__										=      """multi_label_classification"""

       if self.config.problem_type == "regression":
         SCREAMING_SNAKE_CASE__										=      MSELoss()
         if self.num_labels == 1:
           SCREAMING_SNAKE_CASE__										=      loss_fct(logits.squeeze()       ,	labels.squeeze()      )
         else:
           SCREAMING_SNAKE_CASE__										=      loss_fct(_lowercase       ,	_lowercase      )
       elif self.config.problem_type == "single_label_classification":
         SCREAMING_SNAKE_CASE__										=      CrossEntropyLoss()
         SCREAMING_SNAKE_CASE__										=      loss_fct(logits.view(-1       ,	self.num_labels      )       ,	labels.view(-1      )      )
       elif self.config.problem_type == "multi_label_classification":
         SCREAMING_SNAKE_CASE__										=      BCEWithLogitsLoss()
         SCREAMING_SNAKE_CASE__										=      loss_fct(_lowercase       ,	_lowercase      )

     if not return_dict:
       SCREAMING_SNAKE_CASE__										=      (logits,) + outputs[2:]
       return ((loss,) + output) if loss is not None else output

     return ImageClassifierOutputWithNoAttention(loss=_lowercase       ,	logits=_lowercase       ,	hidden_states=outputs.hidden_states      )







'''simple docstring'''

from __future__ import annotations

import math





def lowerCamelCase						(     __lowerCamelCase :    int    )						->list[int]:

    if num <= 0:
        _SCREAMING_SNAKE_CASE									=			F'{num}: Invalid input, please enter a positive integer.'
        raise ValueError(__lowerCamelCase    )

    _SCREAMING_SNAKE_CASE									=			[True] * (num + 1)
    _SCREAMING_SNAKE_CASE									=			[]
    _SCREAMING_SNAKE_CASE									=			2
    _SCREAMING_SNAKE_CASE									=			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:
                    _SCREAMING_SNAKE_CASE									=			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())))



