
"""simple docstring"""
from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map





def  _lowerCAmelCase     (  lowerCamelCase__				:				Dict					)	->     Dict[str, torch.Tensor]:
  _SCREAMING_SNAKE_CASE :					str				     =			[]
  _SCREAMING_SNAKE_CASE :					str				     =			[]
  _SCREAMING_SNAKE_CASE :					Tuple				     =			[]

  for rt in rc.restypes:
    _SCREAMING_SNAKE_CASE :					Any				     =			rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
    restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names]					)
    _SCREAMING_SNAKE_CASE :					Optional[int]				     =			{name: i for i, name in enumerate(snake_case__					)}
    restype_atomaa_to_atomaa_list.append(
        [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types]					)

    restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names]					)

  # Add dummy mapping for restype 'UNK'
  restype_atomaa_to_atomaa_list.append([0] * 1_4					)
  restype_atomaa_to_atomaa_list.append([0] * 3_7					)
  restype_atomaa_mask_list.append([0.0] * 1_4					)

  _SCREAMING_SNAKE_CASE :					int				     =			torch.tensor(
      snake_case__,    dtype=torch.intaa,    device=protein["aatype"].device,    )
  _SCREAMING_SNAKE_CASE :					List[Any]				     =			torch.tensor(
      snake_case__,    dtype=torch.intaa,    device=protein["aatype"].device,    )
  _SCREAMING_SNAKE_CASE :					Dict				     =			torch.tensor(
      snake_case__,    dtype=torch.floataa,    device=protein["aatype"].device,    )
  _SCREAMING_SNAKE_CASE :					Union[str, Any]				     =			protein["aatype"].to(torch.long					)

  # create the mapping for (residx, atom14) --> atom37, i.e. an array
  # with shape (num_res, 14) containing the atom37 indices for this protein
  _SCREAMING_SNAKE_CASE :					Optional[int]				     =			restype_atomaa_to_atomaa[protein_aatype]
  _SCREAMING_SNAKE_CASE :					List[str]				     =			restype_atomaa_mask[protein_aatype]

  _SCREAMING_SNAKE_CASE :					Dict				     =			residx_atomaa_mask
  _SCREAMING_SNAKE_CASE :					int				     =			residx_atomaa_to_atomaa.long()

  # create the gather indices for mapping back
  _SCREAMING_SNAKE_CASE :					Union[str, Any]				     =			restype_atomaa_to_atomaa[protein_aatype]
  _SCREAMING_SNAKE_CASE :					Optional[Any]				     =			residx_atomaa_to_atomaa.long()

  # create the corresponding mask
  _SCREAMING_SNAKE_CASE :					Optional[Any]				     =			torch.zeros([2_1, 3_7],    dtype=torch.floataa,    device=protein["aatype"].device					)
  for restype, restype_letter in enumerate(rc.restypes					):
    _SCREAMING_SNAKE_CASE :					Optional[Any]				     =			rc.restype_atoa[restype_letter]
    _SCREAMING_SNAKE_CASE :					int				     =			rc.residue_atoms[restype_name]
    for atom_name in atom_names:
      _SCREAMING_SNAKE_CASE :					Any				     =			rc.atom_order[atom_name]
      _SCREAMING_SNAKE_CASE :					str				     =			1

  _SCREAMING_SNAKE_CASE :					Dict				     =			restype_atomaa_mask[protein_aatype]
  _SCREAMING_SNAKE_CASE :					Dict				     =			residx_atomaa_mask

  return protein





def  _lowerCAmelCase     (  lowerCamelCase__				:				Optional[int]					)	->     Dict[str, np.ndarray]:
  _SCREAMING_SNAKE_CASE :					str				     =			tree_map(lambda lowerCamelCase__					: torch.tensor(snake_case__,    device=batch["aatype"].device					),    snake_case__,    np.ndarray					)
  _SCREAMING_SNAKE_CASE :					Optional[Any]				     =			tensor_tree_map(lambda lowerCamelCase__					: np.array(snake_case__					),    make_atomaa_masks(snake_case__					)					)
  return out









"""simple docstring"""




def        a__					(							snake_case__ = 10_00							)		->   int:
			lowerCamelCase ,  lowerCamelCase      =   1, 1
			lowerCamelCase      =   2
			while True:
						lowerCamelCase      =   0
						lowerCamelCase      =   fa + fa
						lowerCamelCase ,  lowerCamelCase      =   fa, f
						index += 1
						for _ in str(snake_case__							):
									i += 1
						if i == n:
									break
			return index


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



