"""simple docstring"""






from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


_A        =     logging.get_logger(__name__)

# General docstring
_A        =     'RegNetConfig'

# Base docstring
_A        =     'facebook/regnet-y-040'
_A        =     [1, 1_0_8_8, 7, 7]

# Image classification docstring
_A        =     'facebook/regnet-y-040'
_A        =     'tabby, tabby cat'

_A        =     [
    'facebook/regnet-y-040',
    # See all regnet models at https://huggingface.co/models?filter=regnet
]

class lowerCamelCase		(tf.keras.layers.Layer   ):






					'''simple docstring'''


					def __init__(    self      :					List[Any] ,			_snake_case      :					int ,			_snake_case      :					int = 3 ,			_snake_case      :					int = 1 ,			_snake_case      :					int = 1 ,			_snake_case      :					Optional[str] = "relu" ,			**_snake_case      :					List[Any] ,			)				->							Dict:
									super().__init__(**lowerCamelCase_		)
									# The padding and conv has been verified in
									# https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
									SCREAMING_SNAKE_CASE__			=					tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2		)
									SCREAMING_SNAKE_CASE__			=					tf.keras.layers.ConvaD(
									    filters=lowerCamelCase_ ,			kernel_size=lowerCamelCase_ ,			strides=lowerCamelCase_ ,			padding="VALID" ,			groups=lowerCamelCase_ ,			use_bias=lowerCamelCase_ ,			name="convolution" ,			)
									SCREAMING_SNAKE_CASE__			=					tf.keras.layers.BatchNormalization(epsilon=1e-5 ,			momentum=0.9 ,			name="normalization"		)
									SCREAMING_SNAKE_CASE__			=					ACTaFN[activation] if activation is not None else tf.identity



					def       lowerCAmelCase_       (    self      :					Dict ,			_snake_case      :					Union[str, Any]		)				->							List[str]:
									SCREAMING_SNAKE_CASE__			=					self.convolution(self.padding(lowerCamelCase_		)		)
									SCREAMING_SNAKE_CASE__			=					self.normalization(lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					self.activation(lowerCamelCase_		)
									return hidden_state



class lowerCamelCase		(tf.keras.layers.Layer   ):






					'''simple docstring'''


					def __init__(    self      :					List[Any] ,			_snake_case      :					RegNetConfig ,			**_snake_case      :					List[str]		)				->							Optional[int]:
									super().__init__(**lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					config.num_channels
									SCREAMING_SNAKE_CASE__			=					TFRegNetConvLayer(
									    out_channels=config.embedding_size ,			kernel_size=3 ,			stride=2 ,			activation=config.hidden_act ,			name="embedder" ,			)



					def       lowerCAmelCase_       (    self      :					List[str] ,			_snake_case      :					Union[str, Any]		)				->							str:
									SCREAMING_SNAKE_CASE__			=					shape_list(lowerCamelCase_		)[1]
									if tf.executing_eagerly() and num_channels != self.num_channels:
													raise ValueError(
													    "Make sure that the channel dimension of the pixel values match with the one set in the configuration."		)

									# When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
									# So change the input format from `NCHW` to `NHWC`.
									# shape = (batch_size, in_height, in_width, in_channels=num_channels)
									SCREAMING_SNAKE_CASE__			=					tf.transpose(lowerCamelCase_ ,			perm=(0, 2, 3, 1)		)
									SCREAMING_SNAKE_CASE__			=					self.embedder(lowerCamelCase_		)
									return hidden_state



class lowerCamelCase		(tf.keras.layers.Layer   ):






					'''simple docstring'''


					def __init__(    self      :					Any ,			_snake_case      :					int ,			_snake_case      :					int = 2 ,			**_snake_case      :					List[str]		)				->							List[Any]:
									super().__init__(**lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					tf.keras.layers.ConvaD(
									    filters=lowerCamelCase_ ,			kernel_size=1 ,			strides=lowerCamelCase_ ,			use_bias=lowerCamelCase_ ,			name="convolution"		)
									SCREAMING_SNAKE_CASE__			=					tf.keras.layers.BatchNormalization(epsilon=1e-5 ,			momentum=0.9 ,			name="normalization"		)



					def       lowerCAmelCase_       (    self      :					Dict ,			_snake_case      :					tf.Tensor ,			_snake_case      :					bool = False		)				->							List[str]:
									return self.normalization(self.convolution(lowerCamelCase_		) ,			training=lowerCamelCase_		)



class lowerCamelCase		(tf.keras.layers.Layer   ):






					'''simple docstring'''


					def __init__(    self      :					str ,			_snake_case      :					int ,			_snake_case      :					int ,			**_snake_case      :					str		)				->							List[str]:
									super().__init__(**lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					tf.keras.layers.GlobalAveragePoolingaD(keepdims=lowerCamelCase_ ,			name="pooler"		)
									SCREAMING_SNAKE_CASE__			=					[
									    tf.keras.layers.ConvaD(filters=lowerCamelCase_ ,			kernel_size=1 ,			activation="relu" ,			name="attention.0"		),
									    tf.keras.layers.ConvaD(filters=lowerCamelCase_ ,			kernel_size=1 ,			activation="sigmoid" ,			name="attention.2"		),
									]



					def       lowerCAmelCase_       (    self      :					List[Any] ,			_snake_case      :					int		)				->							Tuple:
									SCREAMING_SNAKE_CASE__			=					self.pooler(lowerCamelCase_		)
									for layer_module in self.attention:
													SCREAMING_SNAKE_CASE__			=					layer_module(lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					hidden_state * pooled
									return hidden_state



class lowerCamelCase		(tf.keras.layers.Layer   ):






					'''simple docstring'''


					def __init__(    self      :					int ,			_snake_case      :					RegNetConfig ,			_snake_case      :					int ,			_snake_case      :					int ,			_snake_case      :					int = 1 ,			**_snake_case      :					Tuple		)				->							List[str]:
									super().__init__(**lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					in_channels != out_channels or stride != 1
									SCREAMING_SNAKE_CASE__			=					max(1 ,			out_channels // config.groups_width		)
									SCREAMING_SNAKE_CASE__			=					(
									    TFRegNetShortCut(lowerCamelCase_ ,			stride=lowerCamelCase_ ,			name="shortcut"		)
									    if should_apply_shortcut
									    else tf.keras.layers.Activation("linear" ,			name="shortcut"		)
									)
									# `self.layers` instead of `self.layer` because that is a reserved argument.
									SCREAMING_SNAKE_CASE__			=					[
									    TFRegNetConvLayer(lowerCamelCase_ ,			kernel_size=1 ,			activation=config.hidden_act ,			name="layer.0"		),
									    TFRegNetConvLayer(
									        lowerCamelCase_ ,			stride=lowerCamelCase_ ,			groups=lowerCamelCase_ ,			activation=config.hidden_act ,			name="layer.1"		),
									    TFRegNetConvLayer(lowerCamelCase_ ,			kernel_size=1 ,			activation=lowerCamelCase_ ,			name="layer.2"		),
									]
									SCREAMING_SNAKE_CASE__			=					ACTaFN[config.hidden_act]



					def       lowerCAmelCase_       (    self      :					Tuple ,			_snake_case      :					Optional[Any]		)				->							int:
									SCREAMING_SNAKE_CASE__			=					hidden_state
									for layer_module in self.layers:
													SCREAMING_SNAKE_CASE__			=					layer_module(lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					self.shortcut(lowerCamelCase_		)
									hidden_state += residual
									SCREAMING_SNAKE_CASE__			=					self.activation(lowerCamelCase_		)
									return hidden_state



class lowerCamelCase		(tf.keras.layers.Layer   ):






					'''simple docstring'''


					def __init__(    self      :					Any ,			_snake_case      :					RegNetConfig ,			_snake_case      :					int ,			_snake_case      :					int ,			_snake_case      :					int = 1 ,			**_snake_case      :					Union[str, Any]		)				->							Union[str, Any]:
									super().__init__(**lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					in_channels != out_channels or stride != 1
									SCREAMING_SNAKE_CASE__			=					max(1 ,			out_channels // config.groups_width		)
									SCREAMING_SNAKE_CASE__			=					(
									    TFRegNetShortCut(lowerCamelCase_ ,			stride=lowerCamelCase_ ,			name="shortcut"		)
									    if should_apply_shortcut
									    else tf.keras.layers.Activation("linear" ,			name="shortcut"		)
									)
									SCREAMING_SNAKE_CASE__			=					[
									    TFRegNetConvLayer(lowerCamelCase_ ,			kernel_size=1 ,			activation=config.hidden_act ,			name="layer.0"		),
									    TFRegNetConvLayer(
									        lowerCamelCase_ ,			stride=lowerCamelCase_ ,			groups=lowerCamelCase_ ,			activation=config.hidden_act ,			name="layer.1"		),
									    TFRegNetSELayer(lowerCamelCase_ ,			reduced_channels=int(round(in_channels / 4		)		) ,			name="layer.2"		),
									    TFRegNetConvLayer(lowerCamelCase_ ,			kernel_size=1 ,			activation=lowerCamelCase_ ,			name="layer.3"		),
									]
									SCREAMING_SNAKE_CASE__			=					ACTaFN[config.hidden_act]



					def       lowerCAmelCase_       (    self      :					Dict ,			_snake_case      :					Any		)				->							int:
									SCREAMING_SNAKE_CASE__			=					hidden_state
									for layer_module in self.layers:
													SCREAMING_SNAKE_CASE__			=					layer_module(lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					self.shortcut(lowerCamelCase_		)
									hidden_state += residual
									SCREAMING_SNAKE_CASE__			=					self.activation(lowerCamelCase_		)
									return hidden_state



class lowerCamelCase		(tf.keras.layers.Layer   ):






					'''simple docstring'''


					def __init__(    self      :					Union[str, Any] ,			_snake_case      :					RegNetConfig ,			_snake_case      :					int ,			_snake_case      :					int ,			_snake_case      :					int = 2 ,			_snake_case      :					int = 2 ,			**_snake_case      :					Optional[int]		)				->							Optional[Any]:
									super().__init__(**lowerCamelCase_		)

									SCREAMING_SNAKE_CASE__			=					TFRegNetXLayer if config.layer_type == """x""" else TFRegNetYLayer
									SCREAMING_SNAKE_CASE__			=					[
									    # downsampling is done in the first layer with stride of 2
									    layer(lowerCamelCase_ ,			lowerCamelCase_ ,			lowerCamelCase_ ,			stride=lowerCamelCase_ ,			name="layers.0"		),
									    *[layer(lowerCamelCase_ ,			lowerCamelCase_ ,			lowerCamelCase_ ,			name=F"""layers.{i+1}"""		) for i in range(depth - 1		)],
									]



					def       lowerCAmelCase_       (    self      :					List[str] ,			_snake_case      :					Any		)				->							int:



									for layer_module in self.layers:
													SCREAMING_SNAKE_CASE__			=					layer_module(lowerCamelCase_		)
									return hidden_state



class lowerCamelCase		(tf.keras.layers.Layer   ):






					'''simple docstring'''


					def __init__(    self      :					int ,			_snake_case      :					RegNetConfig ,			**_snake_case      :					List[str]		)				->							int:
									super().__init__(**lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					[]
									# based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
									self.stages.append(
									    TFRegNetStage(
									        lowerCamelCase_ ,			config.embedding_size ,			config.hidden_sizes[0] ,			stride=2 if config.downsample_in_first_stage else 1 ,			depth=config.depths[0] ,			name="stages.0" ,			)		)
									SCREAMING_SNAKE_CASE__			=					zip(config.hidden_sizes ,			config.hidden_sizes[1:]		)
									for i, ((in_channels, out_channels), depth) in enumerate(zip(lowerCamelCase_ ,			config.depths[1:]		)		):
													self.stages.append(TFRegNetStage(lowerCamelCase_ ,			lowerCamelCase_ ,			lowerCamelCase_ ,			depth=lowerCamelCase_ ,			name=F"""stages.{i+1}"""		)		)



					def       lowerCAmelCase_       (    self      :					Optional[Any] ,			_snake_case      :					tf.Tensor ,			_snake_case      :					bool = False ,			_snake_case      :					bool = True		)				->							int:
									SCREAMING_SNAKE_CASE__			=					() if output_hidden_states else None

									for stage_module in self.stages:
													if output_hidden_states:
																	SCREAMING_SNAKE_CASE__			=					hidden_states + (hidden_state,)

													SCREAMING_SNAKE_CASE__			=					stage_module(lowerCamelCase_		)

									if output_hidden_states:
													SCREAMING_SNAKE_CASE__			=					hidden_states + (hidden_state,)

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

									return TFBaseModelOutputWithNoAttention(last_hidden_state=lowerCamelCase_ ,			hidden_states=lowerCamelCase_		)



@keras_serializable
class lowerCamelCase		(tf.keras.layers.Layer   ):






					'''simple docstring'''


					a 						=		RegNetConfig



					def __init__(    self      :					str ,			_snake_case      :					int ,			**_snake_case      :					str		)				->							str:
									super().__init__(**lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					config
									SCREAMING_SNAKE_CASE__			=					TFRegNetEmbeddings(lowerCamelCase_ ,			name="embedder"		)
									SCREAMING_SNAKE_CASE__			=					TFRegNetEncoder(lowerCamelCase_ ,			name="encoder"		)
									SCREAMING_SNAKE_CASE__			=					tf.keras.layers.GlobalAveragePoolingaD(keepdims=lowerCamelCase_ ,			name="pooler"		)



					@unpack_inputs
					def       lowerCAmelCase_       (    self      :					List[Any] ,			_snake_case      :					tf.Tensor ,			_snake_case      :					Optional[bool] = None ,			_snake_case      :					Optional[bool] = None ,			_snake_case      :					bool = False ,			)				->							Dict:
									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

									SCREAMING_SNAKE_CASE__			=					self.embedder(lowerCamelCase_ ,			training=lowerCamelCase_		)

									SCREAMING_SNAKE_CASE__			=					self.encoder(
									    lowerCamelCase_ ,			output_hidden_states=lowerCamelCase_ ,			return_dict=lowerCamelCase_ ,			training=lowerCamelCase_		)

									SCREAMING_SNAKE_CASE__			=					encoder_outputs[0]
									SCREAMING_SNAKE_CASE__			=					self.pooler(lowerCamelCase_		)

									# Change to NCHW output format have uniformity in the modules
									SCREAMING_SNAKE_CASE__			=					tf.transpose(lowerCamelCase_ ,			perm=(0, 3, 1, 2)		)
									SCREAMING_SNAKE_CASE__			=					tf.transpose(lowerCamelCase_ ,			perm=(0, 3, 1, 2)		)

									# Change the other hidden state outputs to NCHW as well
									if output_hidden_states:
													SCREAMING_SNAKE_CASE__			=					tuple([tf.transpose(lowerCamelCase_ ,			perm=(0, 3, 1, 2)		) for h in encoder_outputs[1]]		)

									if not return_dict:
													return (last_hidden_state, pooled_output) + encoder_outputs[1:]

									return TFBaseModelOutputWithPoolingAndNoAttention(
									    last_hidden_state=lowerCamelCase_ ,			pooler_output=lowerCamelCase_ ,			hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states ,			)



class lowerCamelCase		(lowercase_   ):






					'''simple docstring'''


					a 						=		RegNetConfig
					a 						=		"regnet"
					a 						=		"pixel_values"



					@property
					def       lowerCAmelCase_       (    self      :					Optional[int]		)				->							Optional[Any]:
									return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224) ,			dtype=tf.floataa		)}



_A        =     R'\n    Parameters:\n    This model is a Tensorflow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and\n    behavior.\n        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n'

_A        =     R'\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConveNextImageProcessor.__call__`] for details.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n'

@add_start_docstrings(
    "The bare RegNet model outputting raw features without any specific head on top."     ,     lowercase_     ,     )
class lowerCamelCase		(lowercase_   ):






					'''simple docstring'''


					def __init__(    self      :					Dict ,			_snake_case      :					RegNetConfig ,			*_snake_case      :					Union[str, Any] ,			**_snake_case      :					int		)				->							List[Any]:
									super().__init__(lowerCamelCase_ ,			*lowerCamelCase_ ,			**lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					TFRegNetMainLayer(lowerCamelCase_ ,			name="regnet"		)



					@unpack_inputs
					@add_start_docstrings_to_model_forward(lowerCamelCase_		)
					@add_code_sample_docstrings(
					    checkpoint=_CHECKPOINT_FOR_DOC ,			output_type=lowerCamelCase_ ,			config_class=_CONFIG_FOR_DOC ,			modality="vision" ,			expected_output=_EXPECTED_OUTPUT_SHAPE ,			)
					def       lowerCAmelCase_       (    self      :					Dict ,			_snake_case      :					tf.Tensor ,			_snake_case      :					Optional[bool] = None ,			_snake_case      :					Optional[bool] = None ,			_snake_case      :					List[Any]=False ,			)				->							List[str]:
									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

									SCREAMING_SNAKE_CASE__			=					self.regnet(
									    pixel_values=lowerCamelCase_ ,			output_hidden_states=lowerCamelCase_ ,			return_dict=lowerCamelCase_ ,			training=lowerCamelCase_ ,			)
									if not return_dict:
													return (outputs[0],) + outputs[1:]

									return TFBaseModelOutputWithPoolingAndNoAttention(
									    last_hidden_state=outputs.last_hidden_state ,			pooler_output=outputs.pooler_output ,			hidden_states=outputs.hidden_states ,			)



@add_start_docstrings(
    "\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "     ,     lowercase_     ,     )
class lowerCamelCase		(lowercase_     ,     lowercase_   ):






					'''simple docstring'''


					def __init__(    self      :					Optional[int] ,			_snake_case      :					RegNetConfig ,			*_snake_case      :					Union[str, Any] ,			**_snake_case      :					List[Any]		)				->							Optional[int]:
									super().__init__(lowerCamelCase_ ,			*lowerCamelCase_ ,			**lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					config.num_labels
									SCREAMING_SNAKE_CASE__			=					TFRegNetMainLayer(lowerCamelCase_ ,			name="regnet"		)
									# classification head
									SCREAMING_SNAKE_CASE__			=					[
									    tf.keras.layers.Flatten(),
									    tf.keras.layers.Dense(config.num_labels ,			name="classifier.1"		) if config.num_labels > 0 else tf.identity,
									]



					@unpack_inputs
					@add_start_docstrings_to_model_forward(lowerCamelCase_		)
					@add_code_sample_docstrings(
					    checkpoint=_IMAGE_CLASS_CHECKPOINT ,			output_type=lowerCamelCase_ ,			config_class=_CONFIG_FOR_DOC ,			expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT ,			)
					def       lowerCAmelCase_       (    self      :					str ,			_snake_case      :					tf.Tensor = None ,			_snake_case      :					tf.Tensor = None ,			_snake_case      :					bool = None ,			_snake_case      :					bool = None ,			_snake_case      :					Optional[Any]=False ,			)				->							Dict:
									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

									SCREAMING_SNAKE_CASE__			=					self.regnet(
									    lowerCamelCase_ ,			output_hidden_states=lowerCamelCase_ ,			return_dict=lowerCamelCase_ ,			training=lowerCamelCase_		)

									SCREAMING_SNAKE_CASE__			=					outputs.pooler_output if return_dict else outputs[1]

									SCREAMING_SNAKE_CASE__			=					self.classifier[0](lowerCamelCase_		)
									SCREAMING_SNAKE_CASE__			=					self.classifier[1](lowerCamelCase_		)

									SCREAMING_SNAKE_CASE__			=					None if labels is None else self.hf_compute_loss(labels=lowerCamelCase_ ,			logits=lowerCamelCase_		)

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

									return TFSequenceClassifierOutput(loss=lowerCamelCase_ ,			logits=lowerCamelCase_ ,			hidden_states=outputs.hidden_states		)











'''simple docstring'''




from math import sqrt



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				str		=			0
		for i in range(1			,			int(sqrt(lowerCamelCase_	) + 1	)	):
				if n % i == 0 and i != sqrt(lowerCamelCase_	):
						total += i + n // i
				elif i == sqrt(lowerCamelCase_	):
						total += i
		return total - n



def 		__A		(  lowerCamelCase_ = 1_00_00	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				str		=			sum(
		    i
		    for i in range(1			,			lowerCamelCase_	)
		    if sum_of_divisors(sum_of_divisors(lowerCamelCase_	)	) == i and sum_of_divisors(lowerCamelCase_	) != i	)
		return total


if __name__ == "__main__":
							print(solution(int(str(input()).strip())))



