



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


_lowerCamelCase						    =  Mapping[str, np.ndarray]
_lowerCamelCase						    =  Mapping[str, Any]  # Is a nested dict.
_lowerCamelCase						    =  0.0_1

@dataclasses.dataclass(frozen=UpperCamelCase )
class       _SCREAMING_SNAKE_CASE	:
     lowerCAmelCase					=			42  # [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					=			42  # [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					=			42  # [num_res, num_atom_type]

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

     # Chain indices for multi-chain predictions
     lowerCAmelCase					=			None

     # Optional remark about the protein. Included as a comment in output PDB
     # files
     lowerCAmelCase					=			None

     # Templates used to generate this protein (prediction-only)
     lowerCAmelCase					=			None

     # Chain corresponding to each parent
     lowerCAmelCase					=			None






def 	_lowerCAmelCase						(				__lowerCamelCase   :     str     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    List[Any]       =	r"(\[[A-Z]+\]\n)"
 __SCREAMING_SNAKE_CASE       :    List[str]       =	[tag.strip() for tag in re.split(__lowerCamelCase		,	__lowerCamelCase     ) if len(__lowerCamelCase     ) > 0]
 __SCREAMING_SNAKE_CASE       :    Iterator[Tuple[str, List[str]]]       =	zip(tags[0::2]		,	[l.split("\n"     ) for l in tags[1::2]]     )

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

 assert aatype is not None

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






def 	_lowerCAmelCase						(				__lowerCamelCase   :     Protein		,	__lowerCamelCase   :     int = 0     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    List[str]       =	[]

 __SCREAMING_SNAKE_CASE       :    Any       =	prot.remark
 if remark is not None:
  pdb_headers.append(F"""REMARK {remark}"""     )

 __SCREAMING_SNAKE_CASE       :    Any       =	prot.parents
 __SCREAMING_SNAKE_CASE       :    Tuple       =	prot.parents_chain_index
 if parents is not None and parents_chain_index is not None:
  __SCREAMING_SNAKE_CASE       :    Dict       =	[p for i, p in zip(__lowerCamelCase		,	__lowerCamelCase     ) if i == chain_id]

 if parents is None or len(__lowerCamelCase     ) == 0:
  __SCREAMING_SNAKE_CASE       :    List[Any]       =	["N/A"]

 pdb_headers.append(F"""PARENT {" ".join(__lowerCamelCase     )}"""     )

 return pdb_headers






def 	_lowerCAmelCase						(				__lowerCamelCase   :     Protein		,	__lowerCamelCase   :     str     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    List[str]       =	[]
 __SCREAMING_SNAKE_CASE       :    Optional[int]       =	pdb_str.split("\n"     )

 __SCREAMING_SNAKE_CASE       :    str       =	prot.remark
 if remark is not None:
  out_pdb_lines.append(F"""REMARK {remark}"""     )

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

   __SCREAMING_SNAKE_CASE       :    Dict       =	max([int(__lowerCamelCase     ) for chain_idx in parent_dict]     )
   for i in range(max_idx + 1     ):
    __SCREAMING_SNAKE_CASE       :    List[str]       =	parent_dict.get(str(__lowerCamelCase     )		,	["N/A"]     )
    parents_per_chain.append(__lowerCamelCase     )
  else:
   parents_per_chain.append(list(prot.parents     )     )
 else:
  __SCREAMING_SNAKE_CASE       :    List[str]       =	[["N/A"]]

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

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

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

   out_pdb_lines.append(make_parent_line(__lowerCamelCase     )     )

 return "\n".join(__lowerCamelCase     )






def 	_lowerCAmelCase						(				__lowerCamelCase   :     Protein     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    int       =	residue_constants.restypes + ["X"]

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

 __SCREAMING_SNAKE_CASE       :    Optional[int]       =	residue_constants.atom_types

 __SCREAMING_SNAKE_CASE       :    List[str]       =	[]

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

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

 __SCREAMING_SNAKE_CASE       :    List[str]       =	get_pdb_headers(__lowerCamelCase     )
 if len(__lowerCamelCase     ) > 0:
  pdb_lines.extend(__lowerCamelCase     )

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

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

   __SCREAMING_SNAKE_CASE       :    Dict       =	"A"
   if chain_index is not None:
    __SCREAMING_SNAKE_CASE       :    List[Any]       =	chain_tags[chain_index[i]]

   # PDB is a columnar format, every space matters here!
   __SCREAMING_SNAKE_CASE       :    Optional[int]       =	(
       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(__lowerCamelCase     )
   atom_index += 1

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

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

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






def 	_lowerCAmelCase						(				__lowerCamelCase   :     Protein     ):



 """simple docstring"""





 return residue_constants.STANDARD_ATOM_MASK[prot.aatype]






def 	_lowerCAmelCase						(				__lowerCamelCase   :     FeatureDict		,	__lowerCamelCase   :     ModelOutput		,	__lowerCamelCase   :     Optional[np.ndarray] = None		,	__lowerCamelCase   :     Optional[np.ndarray] = None		,	__lowerCamelCase   :     Optional[str] = None		,	__lowerCamelCase   :     Optional[Sequence[str]] = None		,	__lowerCamelCase   :     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=__lowerCamelCase		,	remark=__lowerCamelCase		,	parents=__lowerCamelCase		,	parents_chain_index=__lowerCamelCase		,	)











from math import sqrt






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int     ):



 """simple docstring"""





 if 1 < number < 4:
  # 2 and 3 are primes
  return True
 elif number < 2 or number % 2 == 0 or number % 3 == 0:
  # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
  return False

 # All primes number are in format of 6k +/- 1
 for i in range(5		,	int(sqrt(__lowerCamelCase     ) + 1     )		,	6     ):
  if number % i == 0 or number % (i + 2) == 0:
   return False
 return True






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int = 10001     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    List[Any]       =	0
 __SCREAMING_SNAKE_CASE       :    Dict       =	1
 while count != nth and number < 3:
  number += 1
  if is_prime(__lowerCamelCase     ):
   count += 1
 while count != nth:
  number += 2
  if is_prime(__lowerCamelCase     ):
   count += 1
 return number


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






