


'''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


__UpperCAmelCase      :Tuple			    =       Mapping[str, np.ndarray]
__UpperCAmelCase      :List[Any]			    =       Mapping[str, Any]  # Is a nested dict.
__UpperCAmelCase      :Optional[Any]			    =       0.01



@dataclasses.dataclass(frozen=_a	)
class      a    :


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			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'.
     SCREAMING_SNAKE_CASE	:			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.
     SCREAMING_SNAKE_CASE	:			np.ndarray  # [num_res, num_atom_type]

     # Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
     SCREAMING_SNAKE_CASE	:			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.
     SCREAMING_SNAKE_CASE	:			np.ndarray  # [num_res, num_atom_type]

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

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

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

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




def      _a     (						_lowercase :     str  ):





     '''simple docstring'''






     __UpperCAmelCase     :			Optional[int]  							=      R'''(\[[A-Z]+\]\n)'''
     __UpperCAmelCase     :			List[str]  							=      [tag.strip() for tag in re.split(_lowercase      , _lowercase  ) if len(_lowercase  ) > 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     :			Optional[int]  							=      None
     __UpperCAmelCase     :			Tuple  							=      None
     __UpperCAmelCase     :			Dict  							=      None
     for g in groups:
          if "[PRIMARY]" == g[0]:
               __UpperCAmelCase     :			Optional[Any]  							=      g[1][0].strip()
               for i in range(len(_lowercase  )  ):
                    if seq[i] not in residue_constants.restypes:
                         __UpperCAmelCase     :			str  							=      '''X'''  # FIXME: strings are immutable
               __UpperCAmelCase     :			Optional[Any]  							=      np.array(
                   [residue_constants.restype_order.get(_lowercase      , 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(_lowercase      , g[1][axis].split()  )  )  )
               __UpperCAmelCase     :			List[str]  							=      np.array(_lowercase  )
               __UpperCAmelCase     :			Union[str, Any]  							=      np.zeros((len(tertiary[0]  ) // 3, residue_constants.atom_type_num, 3)  ).astype(np.floataa  )
               for i, atom in enumerate(_lowercase  ):
                    __UpperCAmelCase     :			Optional[int]  							=      np.transpose(tertiary_np[:, i::3]  )
               atom_positions *= PICO_TO_ANGSTROM
          elif "[MASK]" == g[0]:
               __UpperCAmelCase     :			Optional[Any]  							=      np.array(list(map({'''-''': 0, '''+''': 1}.get      , g[1][0].strip()  )  )  )
               __UpperCAmelCase     :			Optional[int]  							=      np.zeros(
                   (
                       len(_lowercase  ),
                       residue_constants.atom_type_num,
                   )  ).astype(np.floataa  )
               for i, atom in enumerate(_lowercase  ):
                    __UpperCAmelCase     :			Dict  							=      1
               atom_mask *= mask[..., None]

     assert aatype is not None

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




def      _a     (						_lowercase :     Protein      , _lowercase :     int = 0  ):





     '''simple docstring'''






     __UpperCAmelCase     :			List[str]  							=      []

     __UpperCAmelCase     :			Optional[int]  							=      prot.remark
     if remark is not None:
          pdb_headers.append(F'REMARK {remark}'  )

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

     if parents is None or len(_lowercase  ) == 0:
          __UpperCAmelCase     :			str  							=      ['''N/A''']

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

     return pdb_headers




def      _a     (						_lowercase :     Protein      , _lowercase :     str  ):





     '''simple docstring'''






     __UpperCAmelCase     :			List[str]  							=      []
     __UpperCAmelCase     :			Optional[Any]  							=      pdb_str.split('''\n'''  )

     __UpperCAmelCase     :			Tuple  							=      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     :			List[Any]  							=      []
          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(_lowercase  )      , []  )
                    parent_dict[str(_lowercase  )].append(_lowercase  )

               __UpperCAmelCase     :			List[str]  							=      max([int(_lowercase  ) for chain_idx in parent_dict]  )
               for i in range(max_idx + 1  ):
                    __UpperCAmelCase     :			Tuple  							=      parent_dict.get(str(_lowercase  )      , ['''N/A''']  )
                    parents_per_chain.append(_lowercase  )
          else:
               parents_per_chain.append(list(prot.parents  )  )
     else:
          __UpperCAmelCase     :			str  							=      [['''N/A''']]

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

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

     __UpperCAmelCase     :			int  							=      0
     for i, l in enumerate(_lowercase  ):
          if "PARENT" not in l and "REMARK" not in l:
               out_pdb_lines.append(_lowercase  )
          if "TER" in l and "END" not in lines[i + 1]:
               chain_counter += 1
               if not chain_counter >= len(_lowercase  ):
                    __UpperCAmelCase     :			List[str]  							=      parents_per_chain[chain_counter]
               else:
                    __UpperCAmelCase     :			Dict  							=      ['''N/A''']

               out_pdb_lines.append(make_parent_line(_lowercase  )  )

     return "\n".join(_lowercase  )




def      _a     (						_lowercase :     Protein  ):





     '''simple docstring'''






     __UpperCAmelCase     :			Dict  							=      residue_constants.restypes + ['''X''']

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

     __UpperCAmelCase     :			Any  							=      residue_constants.atom_types

     __UpperCAmelCase     :			List[str]  							=      []

     __UpperCAmelCase     :			int  							=      prot.atom_mask
     __UpperCAmelCase     :			Union[str, Any]  							=      prot.aatype
     __UpperCAmelCase     :			Optional[int]  							=      prot.atom_positions
     __UpperCAmelCase     :			List[str]  							=      prot.residue_index.astype(np.intaa  )
     __UpperCAmelCase     :			Any  							=      prot.b_factors
     __UpperCAmelCase     :			Dict  							=      prot.chain_index

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

     __UpperCAmelCase     :			List[Any]  							=      get_pdb_headers(_lowercase  )
     if len(_lowercase  ) > 0:
          pdb_lines.extend(_lowercase  )

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

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

               __UpperCAmelCase     :			Any  							=      '''A'''
               if chain_index is not None:
                    __UpperCAmelCase     :			Optional[Any]  							=      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(_lowercase  )
               atom_index += 1

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

          if should_terminate:
               # Close the chain.
               __UpperCAmelCase     :			List[Any]  							=      '''TER'''
               __UpperCAmelCase     :			Optional[Any]  							=      (
                   F'{chain_end:<6}{atom_index:>5}      {res_atoa(aatype[i]  ):>3} {chain_tag:>1}{residue_index[i]:>4}'
               )
               pdb_lines.append(_lowercase  )
               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(_lowercase      , _lowercase  )  )

     pdb_lines.append('''END'''  )
     pdb_lines.append(''''''  )
     return "\n".join(_lowercase  )




def      _a     (						_lowercase :     Protein  ):





     '''simple docstring'''






     return residue_constants.STANDARD_ATOM_MASK[prot.aatype]




def      _a     (						_lowercase :     FeatureDict      , _lowercase :     ModelOutput      , _lowercase :     Optional[np.ndarray] = None      , _lowercase :     Optional[np.ndarray] = None      , _lowercase :     Optional[str] = None      , _lowercase :     Optional[Sequence[str]] = None      , _lowercase :     Optional[Sequence[int]] = None      , ):





     '''simple docstring'''






     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=_lowercase      , remark=_lowercase      , parents=_lowercase      , parents_chain_index=_lowercase      , )



'''simple docstring'''



def      _a     (						_lowercase :     List[str]  ):





     '''simple docstring'''






     __UpperCAmelCase     :			str  							=      1
     __UpperCAmelCase     :			List[str]  							=      2
     while i * i <= n:
          __UpperCAmelCase     :			Optional[Any]  							=      0
          while n % i == 0:
               n //= i
               multiplicity += 1
          n_divisors *= multiplicity + 1
          i += 1
     if n > 1:
          n_divisors *= 2
     return n_divisors




def      _a     (						):





     '''simple docstring'''






     __UpperCAmelCase     :			Optional[Any]  							=      1
     __UpperCAmelCase     :			List[Any]  							=      1

     while True:
          i += 1
          t_num += i

          if count_divisors(_lowercase  ) > 500:
               break

     return t_num


if __name__ == "__main__":
      print(solution())