
"""simple docstring"""




from typing import List, Optional, Tuple, Union

import torch
from torch import nn
from torch.nn import CrossEntropyLoss

from ... import AutoBackbone
from ...modeling_outputs import SemanticSegmenterOutput
from ...modeling_utils import PreTrainedModel
from ...utils import add_start_docstrings, add_start_docstrings_to_model_forward, replace_return_docstrings
from ...utils.backbone_utils import BackboneMixin
from .configuration_upernet import UperNetConfig


a		:       Optional[int]     						=       [
    'openmmlab/upernet-convnext-tiny',
    # See all UperNet models at https://huggingface.co/models?filter=upernet
]

# General docstring
a		:       Optional[int]     						=       'UperNetConfig'







class     lowercase(nn.Module       ):



     def __init__(							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE = 0     ,				__SCREAMING_SNAKE_CASE = False     ,				__SCREAMING_SNAKE_CASE = 1     ,				)		->     Any:







         """simple docstring"""



         super().__init__()
         a__		=			nn.Convad(
             in_channels=lowercase_     ,				out_channels=lowercase_     ,				kernel_size=lowercase_     ,				padding=lowercase_     ,				bias=lowercase_     ,				dilation=lowercase_     ,				)
         a__		=			nn.BatchNormad(lowercase_   )
         a__		=			nn.ReLU()




     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE   )		->     List[str]:







         """simple docstring"""



         a__		=			self.conv(lowercase_   )
         a__		=			self.batch_norm(lowercase_   )
         a__		=			self.activation(lowercase_   )

         return output







class     lowercase(nn.Module       ):



     def __init__(							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE   )		->     Union[str, Any]:







         """simple docstring"""



         super().__init__()
         a__		=			[
             nn.AdaptiveAvgPoolad(lowercase_   ),
             UperNetConvModule(lowercase_     ,				lowercase_     ,				kernel_size=1   ),
         ]
         for i, layer in enumerate(self.layers   ):
             self.add_module(str(lowercase_   )     ,				lowercase_   )




     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE   )		->     Any:







         """simple docstring"""



         a__		=			input
         for layer in self.layers:
             a__		=			layer(lowercase_   )
         return hidden_state







class     lowercase(nn.Module       ):



     def __init__(							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE   )		->     int:







         """simple docstring"""



         super().__init__()
         a__		=			pool_scales
         a__		=			align_corners
         a__		=			in_channels
         a__		=			channels
         a__		=			[]
         for i, pool_scale in enumerate(lowercase_   ):
             a__		=			UperNetPyramidPoolingBlock(pool_scale=lowercase_     ,				in_channels=lowercase_     ,				channels=lowercase_   )
             self.blocks.append(lowercase_   )
             self.add_module(str(lowercase_   )     ,				lowercase_   )




     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE   )		->     str:







         """simple docstring"""



         a__		=			[]
         for ppm in self.blocks:
             a__		=			ppm(lowercase_   )
             a__		=			nn.functional.interpolate(
                 lowercase_     ,				size=x.size()[2:]     ,				mode='bilinear'     ,				align_corners=self.align_corners   )
             ppm_outs.append(lowercase_   )
         return ppm_outs







class     lowercase(nn.Module       ):



     def __init__(							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE   )		->     int:







         """simple docstring"""



         super().__init__()

         a__		=			config
         a__		=			config.pool_scales  # e.g. (1, 2, 3, 6)
         a__		=			in_channels
         a__		=			config.hidden_size
         a__		=			False
         a__		=			nn.Convad(self.channels     ,				config.num_labels     ,				kernel_size=1   )

         # PSP Module
         a__		=			UperNetPyramidPoolingModule(
             self.pool_scales     ,				self.in_channels[-1]     ,				self.channels     ,				align_corners=self.align_corners     ,				)
         a__		=			UperNetConvModule(
             self.in_channels[-1] + len(self.pool_scales   ) * self.channels     ,				self.channels     ,				kernel_size=3     ,				padding=1     ,				)
         # FPN Module
         a__		=			nn.ModuleList()
         a__		=			nn.ModuleList()
         for in_channels in self.in_channels[:-1]:  # skip the top layer
             a__		=			UperNetConvModule(lowercase_     ,				self.channels     ,				kernel_size=1   )
             a__		=			UperNetConvModule(self.channels     ,				self.channels     ,				kernel_size=3     ,				padding=1   )
             self.lateral_convs.append(lowercase_   )
             self.fpn_convs.append(lowercase_   )

         a__		=			UperNetConvModule(
             len(self.in_channels   ) * self.channels     ,				self.channels     ,				kernel_size=3     ,				padding=1     ,				)



     def 			lowercase__  (							self   )		->     Optional[Any]:







         """simple docstring"""



         self.apply(self._init_weights   )



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE   )		->     List[Any]:







         """simple docstring"""



         if isinstance(lowercase_     ,				nn.Convad   ):
             module.weight.data.normal_(mean=0.0     ,				std=self.config.initializer_range   )
             if module.bias is not None:
                 module.bias.data.zero_()



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE   )		->     Dict:







         """simple docstring"""



         a__		=			inputs[-1]
         a__		=			[x]
         psp_outs.extend(self.psp_modules(lowercase_   )   )
         a__		=			torch.cat(lowercase_     ,				dim=1   )
         a__		=			self.bottleneck(lowercase_   )

         return output




     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE   )		->     Union[str, Any]:







         """simple docstring"""



         a__		=			[lateral_conv(encoder_hidden_states[i]   ) for i, lateral_conv in enumerate(self.lateral_convs   )]

         laterals.append(self.psp_forward(lowercase_   )   )

         # build top-down path
         a__		=			len(lowercase_   )
         for i in range(used_backbone_levels - 1     ,				0     ,				-1   ):
             a__		=			laterals[i - 1].shape[2:]
             a__		=			laterals[i - 1] + nn.functional.interpolate(
                 laterals[i]     ,				size=lowercase_     ,				mode='bilinear'     ,				align_corners=self.align_corners   )

         # build outputs
         a__		=			[self.fpn_convs[i](laterals[i]   ) for i in range(used_backbone_levels - 1   )]
         # append psp feature
         fpn_outs.append(laterals[-1]   )

         for i in range(used_backbone_levels - 1     ,				0     ,				-1   ):
             a__		=			nn.functional.interpolate(
                 fpn_outs[i]     ,				size=fpn_outs[0].shape[2:]     ,				mode='bilinear'     ,				align_corners=self.align_corners   )
         a__		=			torch.cat(lowercase_     ,				dim=1   )
         a__		=			self.fpn_bottleneck(lowercase_   )
         a__		=			self.classifier(lowercase_   )

         return output







class     lowercase(nn.Module       ):



     def __init__(							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE = 2     ,				__SCREAMING_SNAKE_CASE = 3     ,				__SCREAMING_SNAKE_CASE = 1   )		->     Tuple:







         """simple docstring"""



         super().__init__()

         a__		=			config
         a__		=			config.auxiliary_in_channels
         a__		=			config.auxiliary_channels
         a__		=			config.auxiliary_num_convs
         a__		=			config.auxiliary_concat_input
         a__		=			in_index

         a__		=			(kernel_size // 2) * dilation
         a__		=			[]
         convs.append(
             UperNetConvModule(
                 self.in_channels     ,				self.channels     ,				kernel_size=lowercase_     ,				padding=lowercase_     ,				dilation=lowercase_   )   )
         for i in range(self.num_convs - 1   ):
             convs.append(
                 UperNetConvModule(
                     self.channels     ,				self.channels     ,				kernel_size=lowercase_     ,				padding=lowercase_     ,				dilation=lowercase_   )   )
         if self.num_convs == 0:
             a__		=			nn.Identity()
         else:
             a__		=			nn.Sequential(*lowercase_   )
         if self.concat_input:
             a__		=			UperNetConvModule(
                 self.in_channels + self.channels     ,				self.channels     ,				kernel_size=lowercase_     ,				padding=kernel_size // 2   )

         a__		=			nn.Convad(self.channels     ,				config.num_labels     ,				kernel_size=1   )



     def 			lowercase__  (							self   )		->     Optional[int]:







         """simple docstring"""



         self.apply(self._init_weights   )



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE   )		->     Any:







         """simple docstring"""



         if isinstance(lowercase_     ,				nn.Convad   ):
             module.weight.data.normal_(mean=0.0     ,				std=self.config.initializer_range   )
             if module.bias is not None:
                 module.bias.data.zero_()




     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE   )		->     str:







         """simple docstring"""



         a__		=			encoder_hidden_states[self.in_index]
         a__		=			self.convs(lowercase_   )
         if self.concat_input:
             a__		=			self.conv_cat(torch.cat([hidden_states, output]     ,				dim=1   )   )
         a__		=			self.classifier(lowercase_   )
         return output







class     lowercase(_lowerCamelCase       ):
     __snake_case:	List[Any]						=     UperNetConfig
     __snake_case:	Tuple						=     'pixel_values'
     __snake_case:	Union[str, Any]						=     True



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE   )		->     str:







         """simple docstring"""



         if isinstance(lowercase_     ,				lowercase_   ):
             module.backbone.init_weights()
             module.decode_head.init_weights()
             module.auxiliary_head.init_weights()



     def 			lowercase__  (							self   )		->     Any:







         """simple docstring"""



         self.backbone.init_weights()
         self.decode_head.init_weights()
         self.auxiliary_head.init_weights()




     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE=False   )		->     int:







         """simple docstring"""



         if isinstance(lowercase_     ,				lowercase_   ):
             a__		=			value




a		:       List[str]     						=       r'\n    Parameters:\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use\n    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n        config ([`UperNetConfig`]): 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 [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n'

a		:       Optional[int]     						=       r'\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Padding will be ignored by default should you provide it. Pixel values can be obtained using\n            [`AutoImageProcessor`]. See [`SegformerImageProcessor.__call__`] for details.\n        output_attentions (`bool`, *optional*):\n            Whether or not to return the attentions tensors of all attention layers in case the backbone has them. See\n            `attentions` under returned tensors for more detail.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers of the backbone. See `hidden_states` under\n            returned tensors for 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(
    'UperNet framework leveraging any vision backbone e.g. for ADE20k, CityScapes.'    ,						_lowerCamelCase    ,						)
class     lowercase(_lowerCamelCase       ):



     def __init__(							self     ,				__SCREAMING_SNAKE_CASE   )		->     Tuple:







         """simple docstring"""



         super().__init__(lowercase_   )

         a__		=			AutoBackbone.from_config(config.backbone_config   )

         # Semantic segmentation head(s)
         a__		=			UperNetHead(lowercase_     ,				in_channels=self.backbone.channels   )
         a__		=			UperNetFCNHead(lowercase_   ) if config.use_auxiliary_head else None

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




     @add_start_docstrings_to_model_forward(UPERNET_INPUTS_DOCSTRING.format('batch_size, sequence_length'   )   )
     @replace_return_docstrings(output_type=lowercase_     ,				config_class=_CONFIG_FOR_DOC   )
     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				)		->     List[Any]:







         """simple docstring"""



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

         a__		=			self.backbone.forward_with_filtered_kwargs(
             lowercase_     ,				output_hidden_states=lowercase_     ,				output_attentions=lowercase_   )
         a__		=			outputs.feature_maps

         a__		=			self.decode_head(lowercase_   )
         a__		=			nn.functional.interpolate(lowercase_     ,				size=pixel_values.shape[2:]     ,				mode='bilinear'     ,				align_corners=lowercase_   )

         a__		=			None
         if self.auxiliary_head is not None:
             a__		=			self.auxiliary_head(lowercase_   )
             a__		=			nn.functional.interpolate(
                 lowercase_     ,				size=pixel_values.shape[2:]     ,				mode='bilinear'     ,				align_corners=lowercase_   )

         a__		=			None
         if labels is not None:
             if self.config.num_labels == 1:
                 raise ValueError('The number of labels should be greater than one'   )
             else:
                 # compute weighted loss
                 a__		=			CrossEntropyLoss(ignore_index=self.config.loss_ignore_index   )
                 a__		=			loss_fct(lowercase_     ,				lowercase_   )
                 a__		=			loss_fct(lowercase_     ,				lowercase_   )
                 a__		=			main_loss + self.config.auxiliary_loss_weight * auxiliary_loss

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

         return SemanticSegmenterOutput(
             loss=lowercase_     ,				logits=lowercase_     ,				hidden_states=outputs.hidden_states     ,				attentions=outputs.attentions     ,				)








'''simple docstring'''

from collections.abc import Generator


def 						__magic_name__       (      )						->   Generator[int, None, None]:

					'''simple docstring'''

					snake_case_     ,snake_case_		     =							0, 1
					while True:
										snake_case_     ,snake_case_		     =							b, a + b
										yield b


def 						__magic_name__       (      __UpperCAmelCase = 1000      )						->   int:

					'''simple docstring'''

					snake_case_		     =							1
					snake_case_		     =							fibonacci_generator()
					while len(str(next(__UpperCAmelCase      )      )      ) < n:
										answer += 1
					return answer + 1


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

