


'''simple docstring'''

import torch
from torch import nn





class 						__SCREAMING_SNAKE_CASE					(      nn.Module ):






					def __init__(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase=1     ,							__UpperCamelCase=False		)       ->    int:
										super().__init__()

										_a						=		n_token
										_a						=		d_embed
										_a						=		d_proj

										_a						=		cutoffs + [n_token]
										_a						=		[0] + self.cutoffs
										_a						=		div_val

										_a						=		self.cutoffs[0]
										_a						=		len(self.cutoffs		) - 1
										_a						=		self.shortlist_size + self.n_clusters

										if self.n_clusters > 0:
															_a						=		nn.Parameter(torch.zeros(self.n_clusters     ,							self.d_embed		)		)
															_a						=		nn.Parameter(torch.zeros(self.n_clusters		)		)

										_a						=		nn.ModuleList()
										_a						=		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(__UpperCamelCase     ,							__UpperCamelCase		)		)		)
																				else:
																									self.out_projs.append(__UpperCamelCase		)

															self.out_layers.append(nn.Linear(__UpperCamelCase     ,							__UpperCamelCase		)		)
										else:
															for i in range(len(self.cutoffs		)		):
																				_a			,			_a						=		self.cutoff_ends[i], self.cutoff_ends[i + 1]
																				_a						=		d_embed // (div_val**i)

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

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

										_a						=		keep_order






					def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    Tuple:

										if proj is None:
															_a						=		nn.functional.linear(__UpperCamelCase     ,							__UpperCamelCase     ,							bias=__UpperCamelCase		)
										else:
															# if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
															_a						=		nn.functional.linear(__UpperCamelCase     ,							proj.t().contiguous()		)
															_a						=		nn.functional.linear(__UpperCamelCase     ,							__UpperCamelCase     ,							bias=__UpperCamelCase		)
															# else:
															#     logit = torch.einsum('bd,de,ev->bv', (hidden, proj, weight.t()))
															#     if bias is not None:
															#         logit = logit + bias

										return logit






					def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase=None     ,							__UpperCamelCase=False		)       ->    Optional[Any]:

										if labels is not None:
															# Shift so that tokens < n predict n
															_a						=		hidden[..., :-1, :].contiguous()
															_a						=		labels[..., 1:].contiguous()
															_a						=		hidden.view(-1     ,							hidden.size(-1		)		)
															_a						=		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:
															_a						=		hidden.view(-1     ,							hidden.size(-1		)		)

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

																				if i == 0:
																									_a						=		torch.cat([weight_i, self.cluster_weight]     ,							dim=0		)
																									_a						=		torch.cat([bias_i, self.cluster_bias]     ,							dim=0		)

																				weights.append(__UpperCamelCase		)
																				biases.append(__UpperCamelCase		)

															_a			,			_a			,			_a						=		weights[0], biases[0], self.out_projs[0]

															_a						=		self._compute_logit(__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)
															_a						=		nn.functional.log_softmax(__UpperCamelCase     ,							dim=1		)

															if labels is None:
																				_a						=		hidden.new_empty((head_logit.size(0		), self.n_token)		)
															else:
																				_a						=		torch.zeros_like(__UpperCamelCase     ,							dtype=hidden.dtype     ,							device=hidden.device		)

															_a						=		0
															_a						=		[0] + self.cutoffs
															for i in range(len(__UpperCamelCase		) - 1		):
																				_a			,			_a						=		cutoff_values[i], cutoff_values[i + 1]

																				if labels is not None:
																									_a						=		(labels >= l_idx) & (labels < r_idx)
																									_a						=		mask_i.nonzero().squeeze()

																									if indices_i.numel() == 0:
																														continue

																									_a						=		labels.index_select(0     ,							__UpperCamelCase		) - l_idx
																									_a						=		head_logprob.index_select(0     ,							__UpperCamelCase		)
																									_a						=		hidden.index_select(0     ,							__UpperCamelCase		)
																				else:
																									_a						=		hidden

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

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

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

										return out






					def  a_					(			self     ,							__UpperCamelCase		)       ->    List[str]:

										if self.n_clusters == 0:
															_a						=		self._compute_logit(__UpperCamelCase     ,							self.out_layers[0].weight     ,							self.out_layers[0].bias     ,							self.out_projs[0]		)
															return nn.functional.log_softmax(__UpperCamelCase     ,							dim=-1		)
										else:
															# construct weights and biases
															_a			,			_a						=		[], []
															for i in range(len(self.cutoffs		)		):
																				if self.div_val == 1:
																									_a			,			_a						=		self.cutoff_ends[i], self.cutoff_ends[i + 1]
																									_a						=		self.out_layers[0].weight[l_idx:r_idx]
																									_a						=		self.out_layers[0].bias[l_idx:r_idx]
																				else:
																									_a						=		self.out_layers[i].weight
																									_a						=		self.out_layers[i].bias

																				if i == 0:
																									_a						=		torch.cat([weight_i, self.cluster_weight]     ,							dim=0		)
																									_a						=		torch.cat([bias_i, self.cluster_bias]     ,							dim=0		)

																				weights.append(__UpperCamelCase		)
																				biases.append(__UpperCamelCase		)

															_a			,			_a			,			_a						=		weights[0], biases[0], self.out_projs[0]
															_a						=		self._compute_logit(__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)

															_a						=		hidden.new_empty((head_logit.size(0		), self.n_token)		)
															_a						=		nn.functional.log_softmax(__UpperCamelCase     ,							dim=1		)

															_a						=		[0] + self.cutoffs
															for i in range(len(__UpperCamelCase		) - 1		):
																				_a			,			_a						=		cutoff_values[i], cutoff_values[i + 1]

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

																									_a						=		self._compute_logit(__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)
																									_a						=		nn.functional.log_softmax(__UpperCamelCase     ,							dim=1		)

																									_a						=		head_logprob[:, -i] + tail_logprob_i
																									_a						=		logprob_i

															return out





'''simple docstring'''

def __UpperCamelCase   (			__lowerCamelCase		: int = 400_0000				)      ->     int:







     '''simple docstring'''






     _a						=		[]
     _a			,			_a						=		0, 1
     while b <= n:
          if b % 2 == 0:
               even_fibs.append(__lowerCamelCase				)
          _a			,			_a						=		b, a + b
     return sum(__lowerCamelCase				)


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

