



'''simple docstring'''
import torch
from torch import nn






class 				lowercase__      (				nn.Module  ):





	def __init__(					self   :							Any					,lowerCamelCase__   :							Any					,lowerCamelCase__   :							Tuple					,lowerCamelCase__   :							str					,lowerCamelCase__   :							Union[str, Any]					,lowerCamelCase__   :							Tuple=1					,lowerCamelCase__   :							List[str]=False					):







							'''simple docstring'''
							super().__init__()

							_UpperCamelCase   :						Tuple												=  n_token
							_UpperCamelCase   :						str												=  d_embed
							_UpperCamelCase   :						List[Any]												=  d_proj

							_UpperCamelCase   :						Dict												=  cutoffs + [n_token]
							_UpperCamelCase   :						str												=  [0] + self.cutoffs
							_UpperCamelCase   :						List[Any]												=  div_val

							_UpperCamelCase   :						List[Any]												=  self.cutoffs[0]
							_UpperCamelCase   :						List[Any]												=  len(self.cutoffs					) - 1
							_UpperCamelCase   :						Tuple												=  self.shortlist_size + self.n_clusters

							if self.n_clusters > 0:
													_UpperCamelCase   :						Any												=  nn.Parameter(torch.zeros(self.n_clusters					,self.d_embed					)					)
													_UpperCamelCase   :						Union[str, Any]												=  nn.Parameter(torch.zeros(self.n_clusters					)					)

							_UpperCamelCase   :						str												=  nn.ModuleList()
							_UpperCamelCase   :						Tuple												=  nn.ParameterList()

							if div_val == 1:
													for i in range(len(self.cutoffs					)					):
																			if d_proj != d_embed:
																									self.out_projs.append(nn.Parameter(torch.FloatTensor(lowerCamelCase__					,lowerCamelCase__					)					)					)
																			else:
																									self.out_projs.append(lowerCamelCase__					)

													self.out_layers.append(nn.Linear(lowerCamelCase__					,lowerCamelCase__					)					)
							else:
													for i in range(len(self.cutoffs					)					):
																			_UpperCamelCase							,     _UpperCamelCase   :						int												=  self.cutoff_ends[i], self.cutoff_ends[i + 1]
																			_UpperCamelCase   :						Union[str, Any]												=  d_embed // (div_val**i)

																			self.out_projs.append(nn.Parameter(torch.FloatTensor(lowerCamelCase__					,lowerCamelCase__					)					)					)

																			self.out_layers.append(nn.Linear(lowerCamelCase__					,r_idx - l_idx					)					)

							_UpperCamelCase   :						Optional[int]												=  keep_order





	def       UpperCamelCase_    (					self   :							str					,lowerCamelCase__   :							Union[str, Any]					,lowerCamelCase__   :							Union[str, Any]					,lowerCamelCase__   :							Optional[int]					,lowerCamelCase__   :							Union[str, Any]					):







							'''simple docstring'''
							if proj is None:
													_UpperCamelCase   :						Optional[Any]												=  nn.functional.linear(lowerCamelCase__					,lowerCamelCase__					,bias=lowerCamelCase__					)
							else:
													# if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
													_UpperCamelCase   :						Dict												=  nn.functional.linear(lowerCamelCase__					,proj.t().contiguous()					)
													_UpperCamelCase   :						Dict												=  nn.functional.linear(lowerCamelCase__					,lowerCamelCase__					,bias=lowerCamelCase__					)
													# else:
													#     logit = torch.einsum('bd,de,ev->bv', (hidden, proj, weight.t()))
													#     if bias is not None:
													#         logit = logit + bias

							return logit





	def       UpperCamelCase_    (					self   :							List[Any]					,lowerCamelCase__   :							int					,lowerCamelCase__   :							Optional[Any]=None					,lowerCamelCase__   :							List[Any]=False					):







							'''simple docstring'''

							if labels is not None:
													# Shift so that tokens < n predict n
													_UpperCamelCase   :						Tuple												=  hidden[..., :-1, :].contiguous()
													_UpperCamelCase   :						int												=  labels[..., 1:].contiguous()
													_UpperCamelCase   :						Dict												=  hidden.view(-1					,hidden.size(-1					)					)
													_UpperCamelCase   :						Optional[Any]												=  labels.view(-1					)
													if hidden.size(0					) != labels.size(0					):
																			raise RuntimeError('Input and labels should have the same size in the batch dimension.'					)
							else:
													_UpperCamelCase   :						List[Any]												=  hidden.view(-1					,hidden.size(-1					)					)

							if self.n_clusters == 0:
													_UpperCamelCase   :						int												=  self._compute_logit(lowerCamelCase__					,self.out_layers[0].weight					,self.out_layers[0].bias					,self.out_projs[0]					)
													if labels is not None:
																			_UpperCamelCase   :						Dict												=  labels != -100
																			_UpperCamelCase   :						Optional[Any]												=  torch.zeros_like(lowerCamelCase__					,dtype=hidden.dtype					,device=hidden.device					)
																			_UpperCamelCase   :						int												=  (
																			    -nn.functional.log_softmax(lowerCamelCase__					,dim=-1					)[mask].gather(1					,labels[mask].unsqueeze(1					)					).squeeze(1					)
																			)
													else:
																			_UpperCamelCase   :						Any												=  nn.functional.log_softmax(lowerCamelCase__					,dim=-1					)
							else:
													# construct weights and biases
													_UpperCamelCase							,     _UpperCamelCase   :						int												=  [], []
													for i in range(len(self.cutoffs					)					):
																			if self.div_val == 1:
																									_UpperCamelCase							,     _UpperCamelCase   :						Any												=  self.cutoff_ends[i], self.cutoff_ends[i + 1]
																									_UpperCamelCase   :						Optional[int]												=  self.out_layers[0].weight[l_idx:r_idx]
																									_UpperCamelCase   :						Optional[int]												=  self.out_layers[0].bias[l_idx:r_idx]
																			else:
																									_UpperCamelCase   :						Tuple												=  self.out_layers[i].weight
																									_UpperCamelCase   :						int												=  self.out_layers[i].bias

																			if i == 0:
																									_UpperCamelCase   :						Optional[int]												=  torch.cat([weight_i, self.cluster_weight]					,dim=0					)
																									_UpperCamelCase   :						Any												=  torch.cat([bias_i, self.cluster_bias]					,dim=0					)

																			weights.append(lowerCamelCase__					)
																			biases.append(lowerCamelCase__					)

													_UpperCamelCase							,     _UpperCamelCase							,     _UpperCamelCase   :						Optional[Any]												=  weights[0], biases[0], self.out_projs[0]

													_UpperCamelCase   :						List[Any]												=  self._compute_logit(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					)
													_UpperCamelCase   :						int												=  nn.functional.log_softmax(lowerCamelCase__					,dim=1					)

													if labels is None:
																			_UpperCamelCase   :						Optional[int]												=  hidden.new_empty((head_logit.size(0					), self.n_token)					)
													else:
																			_UpperCamelCase   :						Any												=  torch.zeros_like(lowerCamelCase__					,dtype=hidden.dtype					,device=hidden.device					)

													_UpperCamelCase   :						Tuple												=  0
													_UpperCamelCase   :						Optional[Any]												=  [0] + self.cutoffs
													for i in range(len(lowerCamelCase__					) - 1					):
																			_UpperCamelCase							,     _UpperCamelCase   :						List[str]												=  cutoff_values[i], cutoff_values[i + 1]

																			if labels is not None:
																									_UpperCamelCase   :						Any												=  (labels >= l_idx) & (labels < r_idx)
																									_UpperCamelCase   :						Union[str, Any]												=  mask_i.nonzero().squeeze()

																									if indices_i.numel() == 0:
																															continue

																									_UpperCamelCase   :						Tuple												=  labels.index_select(0					,lowerCamelCase__					) - l_idx
																									_UpperCamelCase   :						List[str]												=  head_logprob.index_select(0					,lowerCamelCase__					)
																									_UpperCamelCase   :						Dict												=  hidden.index_select(0					,lowerCamelCase__					)
																			else:
																									_UpperCamelCase   :						List[Any]												=  hidden

																			if i == 0:
																									if labels is not None:
																															_UpperCamelCase   :						str												=  head_logprob_i.gather(1					,target_i[:, None]					).squeeze(1					)
																									else:
																															_UpperCamelCase   :						Optional[int]												=  head_logprob[:, : self.cutoffs[0]]
																			else:
																									_UpperCamelCase							,     _UpperCamelCase							,     _UpperCamelCase   :						Tuple												=  weights[i], biases[i], self.out_projs[i]

																									_UpperCamelCase   :						Optional[Any]												=  self._compute_logit(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					)
																									_UpperCamelCase   :						Tuple												=  nn.functional.log_softmax(lowerCamelCase__					,dim=1					)
																									_UpperCamelCase   :						List[str]												=  self.cutoffs[0] + i - 1  # No probability for the head cluster
																									if labels is not None:
																															_UpperCamelCase   :						Optional[Any]												=  head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather(
																															    1					,target_i[:, None]					).squeeze(1					)
																									else:
																															_UpperCamelCase   :						Optional[int]												=  head_logprob[:, cluster_prob_idx, None] + tail_logprob_i
																															_UpperCamelCase   :						Optional[int]												=  logprob_i

																			if labels is not None:
																									if (hasattr(self					,'keep_order'					) and self.keep_order) or keep_order:
																															out.index_copy_(0					,lowerCamelCase__					,-logprob_i					)
																									else:
																															out[offset : offset + logprob_i.size(0					)].copy_(-logprob_i					)
																									offset += logprob_i.size(0					)

							return out





	def       UpperCamelCase_    (					self   :							Tuple					,lowerCamelCase__   :							str					):







							'''simple docstring'''
							if self.n_clusters == 0:
													_UpperCamelCase   :						List[str]												=  self._compute_logit(lowerCamelCase__					,self.out_layers[0].weight					,self.out_layers[0].bias					,self.out_projs[0]					)
													return nn.functional.log_softmax(lowerCamelCase__					,dim=-1					)
							else:
													# construct weights and biases
													_UpperCamelCase							,     _UpperCamelCase   :						Optional[Any]												=  [], []
													for i in range(len(self.cutoffs					)					):
																			if self.div_val == 1:
																									_UpperCamelCase							,     _UpperCamelCase   :						Dict												=  self.cutoff_ends[i], self.cutoff_ends[i + 1]
																									_UpperCamelCase   :						str												=  self.out_layers[0].weight[l_idx:r_idx]
																									_UpperCamelCase   :						Dict												=  self.out_layers[0].bias[l_idx:r_idx]
																			else:
																									_UpperCamelCase   :						Tuple												=  self.out_layers[i].weight
																									_UpperCamelCase   :						Optional[Any]												=  self.out_layers[i].bias

																			if i == 0:
																									_UpperCamelCase   :						Dict												=  torch.cat([weight_i, self.cluster_weight]					,dim=0					)
																									_UpperCamelCase   :						List[Any]												=  torch.cat([bias_i, self.cluster_bias]					,dim=0					)

																			weights.append(lowerCamelCase__					)
																			biases.append(lowerCamelCase__					)

													_UpperCamelCase							,     _UpperCamelCase							,     _UpperCamelCase   :						Union[str, Any]												=  weights[0], biases[0], self.out_projs[0]
													_UpperCamelCase   :						List[str]												=  self._compute_logit(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					)

													_UpperCamelCase   :						Optional[int]												=  hidden.new_empty((head_logit.size(0					), self.n_token)					)
													_UpperCamelCase   :						Dict												=  nn.functional.log_softmax(lowerCamelCase__					,dim=1					)

													_UpperCamelCase   :						List[Any]												=  [0] + self.cutoffs
													for i in range(len(lowerCamelCase__					) - 1					):
																			_UpperCamelCase							,     _UpperCamelCase   :						List[Any]												=  cutoff_values[i], cutoff_values[i + 1]

																			if i == 0:
																									_UpperCamelCase   :						Optional[Any]												=  head_logprob[:, : self.cutoffs[0]]
																			else:
																									_UpperCamelCase							,     _UpperCamelCase							,     _UpperCamelCase   :						Any												=  weights[i], biases[i], self.out_projs[i]

																									_UpperCamelCase   :						str												=  self._compute_logit(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					)
																									_UpperCamelCase   :						Optional[int]												=  nn.functional.log_softmax(lowerCamelCase__					,dim=1					)

																									_UpperCamelCase   :						List[Any]												=  head_logprob[:, -i] + tail_logprob_i
																									_UpperCamelCase   :						Tuple												=  logprob_i

													return out







'''simple docstring'''
from math import ceil






def A__       (	UpperCAmelCase_ = 1_0_0_1				):
						_UpperCamelCase   :						int												=  1

						for i in range(1    ,    int(ceil(n / 2.0				)				)				):
												_UpperCamelCase   :						Dict												=  2 * i + 1
												_UpperCamelCase   :						Tuple												=  2 * i
												_UpperCamelCase   :						Any												=  total + 4 * odd**2 - 6 * even

						return total


if __name__ == "__main__":
					import sys

					if len(sys.argv) == 1:
										print(solution())
					else:
										try:
															snake_case_					:      Tuple    			=    int(sys.argv[1])
															print(solution(n))
										except ValueError:
															print('Invalid entry - please enter a number')


