






from typing import List, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCamelCase :      Any										=				logging.get_logger(__name__)

__lowerCamelCase :      Optional[Any]										=				{
    """huggingface/informer-tourism-monthly""": (
        """https://huggingface.co/huggingface/informer-tourism-monthly/resolve/main/config.json"""
    ),
    # See all Informer models at https://huggingface.co/models?filter=informer
}



class 							SCREAMING_SNAKE_CASE__						(    UpperCamelCase_						):





					"""simple docstring"""






					a_     =		"informer"
					a_     =		{
					    "hidden_size": "d_model",
					    "num_attention_heads": "encoder_attention_heads",
					    "num_hidden_layers": "encoder_layers",
					}



					def __init__( self					:  List[str]							,		__A					:  Optional[int] = None							,		__A					:  Optional[int] = None							,		__A					:  str = "student_t"							,		__A					:  str = "nll"							,		__A					:  int = 1							,		__A					:  List[int] = None							,		__A					:  Optional[Union[str, bool]] = "mean"							,		__A					:  int = 0							,		__A					:  int = 0							,		__A					:  int = 0							,		__A					:  int = 0							,		__A					:  Optional[List[int]] = None							,		__A					:  Optional[List[int]] = None							,		__A					:  int = 6_4							,		__A					:  int = 3_2							,		__A					:  int = 3_2							,		__A					:  int = 2							,		__A					:  int = 2							,		__A					:  int = 2							,		__A					:  int = 2							,		__A					:  bool = True							,		__A					:  str = "gelu"							,		__A					:  float = 0.0_5							,		__A					:  float = 0.1							,		__A					:  float = 0.1							,		__A					:  float = 0.1							,		__A					:  float = 0.1							,		__A					:  int = 1_0_0							,		__A					:  float = 0.0_2							,		__A					:  Dict=True							,		__A					:  str = "prob"							,		__A					:  int = 5							,		__A					:  bool = True							,		**__A					:  Optional[int]							,		):
						# time series specific configuration
						snake_case__			:				List[str]       =  prediction_length
						snake_case__			:				Union[str, Any]       =  context_length or prediction_length
						snake_case__			:				Tuple       =  distribution_output
						snake_case__			:				Tuple       =  loss
						snake_case__			:				List[str]       =  input_size
						snake_case__			:				Optional[int]       =  num_time_features
						snake_case__			:				Dict       =  lags_sequence if lags_sequence is not None else [1, 2, 3, 4, 5, 6, 7]
						snake_case__			:				Optional[int]       =  scaling
						snake_case__			:				Dict       =  num_dynamic_real_features
						snake_case__			:				Union[str, Any]       =  num_static_real_features
						snake_case__			:				Dict       =  num_static_categorical_features

						# set cardinality
						if cardinality and num_static_categorical_features > 0:
							if len(__A	) != num_static_categorical_features:
								raise ValueError(
								    "The cardinality should be a list of the same length as `num_static_categorical_features`"	)
							snake_case__			:				List[str]       =  cardinality
						else:
							snake_case__			:				Optional[int]       =  [0]

						# set embedding_dimension
						if embedding_dimension and num_static_categorical_features > 0:
							if len(__A	) != num_static_categorical_features:
								raise ValueError(
								    "The embedding dimension should be a list of the same length as `num_static_categorical_features`"	)
							snake_case__			:				List[str]       =  embedding_dimension
						else:
							snake_case__			:				Dict       =  [min(5_0							,		(cat + 1) // 2	) for cat in self.cardinality]

						snake_case__			:				List[str]       =  num_parallel_samples

						# Transformer architecture configuration
						snake_case__			:				Any       =  input_size * len(self.lags_sequence	) + self._number_of_features
						snake_case__			:				str       =  d_model
						snake_case__			:				List[str]       =  encoder_attention_heads
						snake_case__			:				List[str]       =  decoder_attention_heads
						snake_case__			:				List[Any]       =  encoder_ffn_dim
						snake_case__			:				List[str]       =  decoder_ffn_dim
						snake_case__			:				Any       =  encoder_layers
						snake_case__			:				Any       =  decoder_layers

						snake_case__			:				int       =  dropout
						snake_case__			:				Dict       =  attention_dropout
						snake_case__			:				Union[str, Any]       =  activation_dropout
						snake_case__			:				Optional[Any]       =  encoder_layerdrop
						snake_case__			:				str       =  decoder_layerdrop

						snake_case__			:				Optional[Any]       =  activation_function
						snake_case__			:				Any       =  init_std

						snake_case__			:				Optional[int]       =  use_cache

						# Informer
						snake_case__			:				Optional[int]       =  attention_type
						snake_case__			:				int       =  sampling_factor
						snake_case__			:				Union[str, Any]       =  distil

						super().__init__(is_encoder_decoder=__A							,		**__A	)






					@property
					def 	_lowercase					( self					:  int	):
						return (
						    sum(self.embedding_dimension	)
						    + self.num_dynamic_real_features
						    + self.num_time_features
						    + self.num_static_real_features
						    + self.input_size * 2  # the log1p(abs(loc)) and log(scale) features
						)











import sys

__lowerCamelCase :      List[str]										=				(
    """73167176531330624919225119674426574742355349194934"""
    """96983520312774506326239578318016984801869478851843"""
    """85861560789112949495459501737958331952853208805511"""
    """12540698747158523863050715693290963295227443043557"""
    """66896648950445244523161731856403098711121722383113"""
    """62229893423380308135336276614282806444486645238749"""
    """30358907296290491560440772390713810515859307960866"""
    """70172427121883998797908792274921901699720888093776"""
    """65727333001053367881220235421809751254540594752243"""
    """52584907711670556013604839586446706324415722155397"""
    """53697817977846174064955149290862569321978468622482"""
    """83972241375657056057490261407972968652414535100474"""
    """82166370484403199890008895243450658541227588666881"""
    """16427171479924442928230863465674813919123162824586"""
    """17866458359124566529476545682848912883142607690042"""
    """24219022671055626321111109370544217506941658960408"""
    """07198403850962455444362981230987879927244284909188"""
    """84580156166097919133875499200524063689912560717606"""
    """05886116467109405077541002256983155200055935729725"""
    """71636269561882670428252483600823257530420752963450"""
)







def 					SCREAMING_SNAKE_CASE    (			snake_case_ :							str = N       ):
	snake_case__			:				Any       =  -sys.maxsize - 1
	for i in range(len(snake_case_       ) - 12       ):
		snake_case__			:				Tuple       =  1
		for j in range(13       ):
			product *= int(n[i + j]       )
		if product > largest_product:
			snake_case__			:				Dict       =  product
	return largest_product


if __name__ == "__main__":
	print(f"{solution() = }")



