



"""simple docstring"""
from math import factorial

def    _snake_case		(		UpperCamelCase		:	int = 100		):
 return sum(map(UpperCamelCase    ,	str(factorial(UpperCamelCase		)		)		)		)


if __name__ == "__main__":
      print(solution(int(input("Enter the Number: ").strip())))





"""simple docstring"""
import dataclasses
import re
import string
from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple

import numpy as np

from . import residue_constants


A:     List[str]										=	Mapping[str, np.ndarray]
A:     Union[str, Any]										=	Mapping[str, Any]  # Is a nested dict.
A:     Any										=	0.01



@dataclasses.dataclass(frozen=UpperCAmelCase__				)
class    SCREAMING_SNAKE_CASE__						:
   __lowerCAmelCase						:     np.ndarray  # [num_res, num_atom_type, 3]

   # Amino-acid type for each residue represented as an integer between 0 and
   # 20, where 20 is 'X'.
   __lowerCAmelCase						:     np.ndarray  # [num_res]

   # Binary float mask to indicate presence of a particular atom. 1.0 if an atom
   # is present and 0.0 if not. This should be used for loss masking.
   __lowerCAmelCase						:     np.ndarray  # [num_res, num_atom_type]

   # Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
   __lowerCAmelCase						:     np.ndarray  # [num_res]

   # B-factors, or temperature factors, of each residue (in sq. angstroms units),
   # representing the displacement of the residue from its ground truth mean
   # value.
   __lowerCAmelCase						:     np.ndarray  # [num_res, num_atom_type]

   # Chain indices for multi-chain predictions
   __lowerCAmelCase						:     Optional[np.ndarray]		=		None

   # Optional remark about the protein. Included as a comment in output PDB
   # files
   __lowerCAmelCase						:     Optional[str]		=		None

   # Templates used to generate this protein (prediction-only)
   __lowerCAmelCase						:     Optional[Sequence[str]]		=		None

   # Chain corresponding to each parent
   __lowerCAmelCase						:     Optional[Sequence[int]]		=		None

def    _snake_case		(		UpperCamelCase		:	str		):
 UpperCAmelCase			:      str			=			R"""(\[[A-Z]+\]\n)"""
 UpperCAmelCase			:      List[str]			=			[tag.strip() for tag in re.split(UpperCamelCase    ,	UpperCamelCase		) if len(UpperCamelCase		) > 0]
 UpperCAmelCase			:      Iterator[Tuple[str, List[str]]]			=			zip(tags[0::2]    ,	[l.split("""\n"""		) for l in tags[1::2]]		)

 UpperCAmelCase			:      List[str]			=			["N", "CA", "C"]
 UpperCAmelCase			:      List[str]			=			None
 UpperCAmelCase			:      Tuple			=			None
 UpperCAmelCase			:      Tuple			=			None
 for g in groups:
  if "[PRIMARY]" == g[0]:
   UpperCAmelCase			:      Any			=			g[1][0].strip()
   for i in range(len(UpperCamelCase		)		):
    if seq[i] not in residue_constants.restypes:
     UpperCAmelCase			:      int			=			"""X"""  # FIXME: strings are immutable
   UpperCAmelCase			:      Optional[int]			=			np.array(
       [residue_constants.restype_order.get(UpperCamelCase    ,	residue_constants.restype_num		) for res_symbol in seq]		)
  elif "[TERTIARY]" == g[0]:
   UpperCAmelCase			:      List[List[float]]			=			[]
   for axis in range(3		):
    tertiary.append(list(map(UpperCamelCase    ,	g[1][axis].split()		)		)		)
   UpperCAmelCase			:      Optional[Any]			=			np.array(UpperCamelCase		)
   UpperCAmelCase			:      Any			=			np.zeros((len(tertiary[0]		) // 3, residue_constants.atom_type_num, 3)		).astype(np.floataa		)
   for i, atom in enumerate(UpperCamelCase		):
    UpperCAmelCase			:      Any			=			np.transpose(tertiary_np[:, i::3]		)
   atom_positions *= PICO_TO_ANGSTROM
  elif "[MASK]" == g[0]:
   UpperCAmelCase			:      Union[str, Any]			=			np.array(list(map({"""-""": 0, """+""": 1}.get    ,	g[1][0].strip()		)		)		)
   UpperCAmelCase			:      Union[str, Any]			=			np.zeros(
       (
           len(UpperCamelCase		),
           residue_constants.atom_type_num,
       )		).astype(np.floataa		)
   for i, atom in enumerate(UpperCamelCase		):
    UpperCAmelCase			:      Any			=			1
   atom_mask *= mask[..., None]

 assert aatype is not None

 return Protein(
     atom_positions=UpperCamelCase    ,	atom_mask=UpperCamelCase    ,	aatype=UpperCamelCase    ,	residue_index=np.arange(len(UpperCamelCase		)		)    ,	b_factors=UpperCamelCase    ,	)

def    _snake_case		(		UpperCamelCase		:	Protein    ,	UpperCamelCase		:	int = 0		):
 UpperCAmelCase			:      List[str]			=			[]

 UpperCAmelCase			:      List[Any]			=			prot.remark
 if remark is not None:
  pdb_headers.append(F"REMARK {remark}"		)

 UpperCAmelCase			:      List[str]			=			prot.parents
 UpperCAmelCase			:      List[Any]			=			prot.parents_chain_index
 if parents is not None and parents_chain_index is not None:
  UpperCAmelCase			:      int			=			[p for i, p in zip(UpperCamelCase    ,	UpperCamelCase		) if i == chain_id]

 if parents is None or len(UpperCamelCase		) == 0:
  UpperCAmelCase			:      Tuple			=			["""N/A"""]

 pdb_headers.append(F"PARENT {' '.join(UpperCamelCase		)}"		)

 return pdb_headers

def    _snake_case		(		UpperCamelCase		:	Protein    ,	UpperCamelCase		:	str		):
 UpperCAmelCase			:      List[str]			=			[]
 UpperCAmelCase			:      Tuple			=			pdb_str.split("""\n"""		)

 UpperCAmelCase			:      List[Any]			=			prot.remark
 if remark is not None:
  out_pdb_lines.append(F"REMARK {remark}"		)

 UpperCAmelCase			:      List[List[str]]
 if prot.parents is not None and len(prot.parents		) > 0:
  UpperCAmelCase			:      Tuple			=			[]
  if prot.parents_chain_index is not None:
   UpperCAmelCase			:      Dict[str, List[str]]			=			{}
   for p, i in zip(prot.parents    ,	prot.parents_chain_index		):
    parent_dict.setdefault(str(UpperCamelCase		)    ,	[]		)
    parent_dict[str(UpperCamelCase		)].append(UpperCamelCase		)

   UpperCAmelCase			:      Tuple			=			max([int(UpperCamelCase		) for chain_idx in parent_dict]		)
   for i in range(max_idx + 1		):
    UpperCAmelCase			:      int			=			parent_dict.get(str(UpperCamelCase		)    ,	["""N/A"""]		)
    parents_per_chain.append(UpperCamelCase		)
  else:
   parents_per_chain.append(list(prot.parents		)		)
 else:
  UpperCAmelCase			:      Union[str, Any]			=			[["""N/A"""]]

 def make_parent_line(UpperCamelCase		:	Sequence[str]		) -> str:
  return F"PARENT {' '.join(UpperCamelCase		)}"

 out_pdb_lines.append(make_parent_line(parents_per_chain[0]		)		)

 UpperCAmelCase			:      Any			=			0
 for i, l in enumerate(UpperCamelCase		):
  if "PARENT" not in l and "REMARK" not in l:
   out_pdb_lines.append(UpperCamelCase		)
  if "TER" in l and "END" not in lines[i + 1]:
   chain_counter += 1
   if not chain_counter >= len(UpperCamelCase		):
    UpperCAmelCase			:      List[Any]			=			parents_per_chain[chain_counter]
   else:
    UpperCAmelCase			:      Optional[Any]			=			["""N/A"""]

   out_pdb_lines.append(make_parent_line(UpperCamelCase		)		)

 return "\n".join(UpperCamelCase		)

def    _snake_case		(		UpperCamelCase		:	Protein		):
 UpperCAmelCase			:      int			=			residue_constants.restypes + ["""X"""]

 def res_atoa(UpperCamelCase		:	int		) -> str:
  return residue_constants.restype_atoa.get(restypes[r]    ,	"""UNK"""		)

 UpperCAmelCase			:      List[str]			=			residue_constants.atom_types

 UpperCAmelCase			:      List[str]			=			[]

 UpperCAmelCase			:      Dict			=			prot.atom_mask
 UpperCAmelCase			:      Optional[int]			=			prot.aatype
 UpperCAmelCase			:      Optional[int]			=			prot.atom_positions
 UpperCAmelCase			:      str			=			prot.residue_index.astype(np.intaa		)
 UpperCAmelCase			:      Tuple			=			prot.b_factors
 UpperCAmelCase			:      str			=			prot.chain_index

 if np.any(aatype > residue_constants.restype_num		):
  raise ValueError("""Invalid aatypes."""		)

 UpperCAmelCase			:      Any			=			get_pdb_headers(UpperCamelCase		)
 if len(UpperCamelCase		) > 0:
  pdb_lines.extend(UpperCamelCase		)

 UpperCAmelCase			:      List[str]			=			aatype.shape[0]
 UpperCAmelCase			:      int			=			1
 UpperCAmelCase			:      Optional[Any]			=			0
 UpperCAmelCase			:      str			=			string.ascii_uppercase
 UpperCAmelCase			:      Tuple			=			None
 # Add all atom sites.
 for i in range(UpperCamelCase		):
  UpperCAmelCase			:      Optional[int]			=			res_atoa(aatype[i]		)
  for atom_name, pos, mask, b_factor in zip(UpperCamelCase    ,	atom_positions[i]    ,	atom_mask[i]    ,	b_factors[i]		):
   if mask < 0.5:
    continue

   UpperCAmelCase			:      List[Any]			=			"""ATOM"""
   UpperCAmelCase			:      Dict			=			atom_name if len(UpperCamelCase		) == 4 else F" {atom_name}"
   UpperCAmelCase			:      Union[str, Any]			=			""""""
   UpperCAmelCase			:      Dict			=			""""""
   UpperCAmelCase			:      Optional[int]			=			1.00
   UpperCAmelCase			:      Union[str, Any]			=			atom_name[0]  # Protein supports only C, N, O, S, this works.
   UpperCAmelCase			:      Any			=			""""""

   UpperCAmelCase			:      List[Any]			=			"""A"""
   if chain_index is not None:
    UpperCAmelCase			:      List[str]			=			chain_tags[chain_index[i]]

   # PDB is a columnar format, every space matters here!
   UpperCAmelCase			:      Dict			=			(
       F"{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}"
       F"{res_name_a:>3} {chain_tag:>1}"
       F"{residue_index[i]:>4}{insertion_code:>1}   "
       F"{pos[0]:>8.3f}{pos[1]:>8.3f}{pos[2]:>8.3f}"
       F"{occupancy:>6.2f}{b_factor:>6.2f}          "
       F"{element:>2}{charge:>2}"
   )
   pdb_lines.append(UpperCamelCase		)
   atom_index += 1

  UpperCAmelCase			:      Union[str, Any]			=			i == n - 1
  if chain_index is not None:
   if i != n - 1 and chain_index[i + 1] != prev_chain_index:
    UpperCAmelCase			:      Any			=			True
    UpperCAmelCase			:      List[str]			=			chain_index[i + 1]

  if should_terminate:
   # Close the chain.
   UpperCAmelCase			:      Optional[int]			=			"""TER"""
   UpperCAmelCase			:      Union[str, Any]			=			(
       F"{chain_end:<6}{atom_index:>5}      {res_atoa(aatype[i]		):>3} {chain_tag:>1}{residue_index[i]:>4}"
   )
   pdb_lines.append(UpperCamelCase		)
   atom_index += 1

   if i != n - 1:
    # "prev" is a misnomer here. This happens at the beginning of
    # each new chain.
    pdb_lines.extend(get_pdb_headers(UpperCamelCase    ,	UpperCamelCase		)		)

 pdb_lines.append("""END"""		)
 pdb_lines.append(""""""		)
 return "\n".join(UpperCamelCase		)

def    _snake_case		(		UpperCamelCase		:	Protein		):
 return residue_constants.STANDARD_ATOM_MASK[prot.aatype]

def    _snake_case		(		UpperCamelCase		:	FeatureDict    ,	UpperCamelCase		:	ModelOutput    ,	UpperCamelCase		:	Optional[np.ndarray] = None    ,	UpperCamelCase		:	Optional[np.ndarray] = None    ,	UpperCamelCase		:	Optional[str] = None    ,	UpperCamelCase		:	Optional[Sequence[str]] = None    ,	UpperCamelCase		:	Optional[Sequence[int]] = None    ,	):
 return Protein(
     aatype=features["""aatype"""]    ,	atom_positions=result["""final_atom_positions"""]    ,	atom_mask=result["""final_atom_mask"""]    ,	residue_index=features["""residue_index"""] + 1    ,	b_factors=b_factors if b_factors is not None else np.zeros_like(result["""final_atom_mask"""]		)    ,	chain_index=UpperCamelCase    ,	remark=UpperCamelCase    ,	parents=UpperCamelCase    ,	parents_chain_index=UpperCamelCase    ,	)
