diff --git "a/data/dataset_AlphaFold.csv" "b/data/dataset_AlphaFold.csv"
new file mode 100644--- /dev/null
+++ "b/data/dataset_AlphaFold.csv"
@@ -0,0 +1,56290 @@
+"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language"
+"AlphaFold","oist/BioinfoUgrp","Nextflow.md",".md","4676","168","Nextflow
+========
+
+A DSL for data-driven computational pipelines <http://nextflow.io>.
+
+In 2022, _Nextflow_ had a backwards-incompatible change that depreacated an old
+syntax called _DSL1_ in favor of the _DSL2_ syntax.  We still provide the old
+version `21.10.6` in the `Nextflow` module on _deigo_.  Newer versions are in
+the `Nextflow2` module.  To use a _DSL1_ pipeline with the `Nextflow2` module,
+pass the `-dsl1` flag to the `nextflow` program.
+
+The `Nextflow2` module also limits the use of memory by setting the environment
+variable `NXF_OPTS` to `-Xms500M -Xmx2G`.  Please contact us or open an issue
+if you hit the limit.
+
+
+Installation on deigo
+---------------------
+
+See also <https://groups.oist.jp/scs/install-software-your-unit>.
+
+### Release or edge versions from GitHub
+
+Source: https://github.com/nextflow-io/nextflow
+
+```
+APP=Nextflow2
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+VER=25.10.2
+mkdir -p $APPDIR/$VER/bin
+cd $APPDIR/$VER
+wget https://github.com/nextflow-io/nextflow/releases/download/v${VER}/nextflow-${VER}-dist
+mv nextflow-${VER}-dist bin/nextflow
+chmod 775 bin/nextflow
+mkdir -p $MODROOT/$APP/modulefiles/
+cd $MODROOT/$APP/modulefiles/
+cat <<'__END__' > $VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp/Other""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/nextflow-io/nextflow/releases"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""pipeline, SLURM"")
+whatis(""Description: "".."" Data-driven computational pipelines."")
+
+help([[Nextflow version downloaded from GitHub
+
+See https://www.nextflow.io/ for help.]])
+
+-- Package settings
+depends_on(""singularity"")
+depends_on(""java-jdk/17"")
+setenv(""NXF_OPTS"", ""-Xms500M -Xmx2G"")
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+nf-test
+=======
+
+Testing framework for Nextflow pipelines (<https://www.nf-test.com/>).
+
+Installation on deigo
+---------------------
+
+```
+APP=nf-test
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+VER=0.9.2
+mkdir -p $APPDIR/$VER/bin
+cd $APPDIR/$VER
+wget https://github.com/askimed/nf-test/releases/download/v${VER}/nf-test-${VER}.tar.gz
+pushd bin
+tar xvfz ../nf-test-${VER}.tar.gz
+chmod 775 nf-test
+chmod 664 nf-test.jar
+popd
+rm nf-test-${VER}.tar.gz
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/askimed/nf-test/releases"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""pipeline, SLURM"")
+whatis(""Description: ""..""Testing framework for Nextflow pipelines."")
+
+help([[nf-test version downloaded from GitHub
+
+See https://www.nf-test.com/ for help.]])
+
+-- Package settings
+depends_on(""Nextflow2"")
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+nf-core
+=======
+
+Python package with helper tools for the nf-core community (<https://nf-co.re/docs/nf-core-tools>).
+
+To install a new latest version, update the `VER` variable below and run the commands.
+
+```
+ml purge
+ml bioinfo-ugrp-modules Nextflow2
+ml python/3.11.4
+APP=nf-core
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+VER=3.5.1
+mkdir -p $APPDIR/$VER
+cd $APPDIR/$VER
+PYTHONUSERBASE=$(pwd) pip3 install --no-warn-script-location --user $APP 
+PYTHONUSERBASE=$(pwd) pip3 install --no-warn-script-location --user pre-commit
+cd $MODROOT/$APP/modulefiles/
+cp 3.1.2.lua ${VER}.lua
+```
+
+Contents of 3.1.2.lua:
+
+```
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp/Other""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+-- setenv(""Nextflow_MOD_HOME"", apphome)
+-- setenv(""Nextflow_MOD_VERSION"", appversion)
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://nf-co.re/docs/nf-core-tools"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""pipeline, SLURM"")
+whatis(""Description: "".."" Python package with helper tools for the nf-core community."")
+
+help([[nf-core tools installed with pip
+
+See https://nf-co.re/ for help.]])
+
+-- Package settings
+depends_on(""singularity"")
+prepend_path(""PATH"", apphome..""/bin"")
+prepend_path(""PYTHONPATH"", apphome..""/lib/python3.11/site-packages/"")
+depends_on(""Nextflow2"")
+depends_on(""python/3.11.4"")
+depends_on(""Other/nf-test"")
+```
+","Markdown"
+"AlphaFold","oist/BioinfoUgrp","DebianMedModules.md",".md","6201","156","Debian Med modules
+==================
+
+The [Debian Med](https://www.debian.org/devel/debian-med/) project packages
+bioinformatics and other medically relevant software for the
+[Debian](https://www.debian.org/intro/about) operating system.  We collect
+many of them in a [Singularity](https://sylabs.io/) container and create one
+module per package on Deigo.
+
+For users
+---------
+
+```
+ml bioinfo-ugrp-modules DebianMed
+ml av
+```
+
+Enjoy !
+
+
+For developers
+--------------
+
+### Docker image
+
+See [oist/BioinfoUgrp_DebianMed_Images](https://github.com/oist/BioinfoUgrp_DebianMed_Images)
+on how to create a Docker image with [GitHub actions](https://docs.github.com/en/actions).
+
+### Create a new Singularity image
+
+Pull the Docker image built on GitHub.
+
+```
+export DEBVERSION=13.0-1
+singularity pull DebianMed_${DEBVERSION}.sif docker://ghcr.io/oist/bioinfougrp_debianmed_images:${DEBVERSION}
+```
+
+### Generate all the modules
+
+Make sure the module and modulefiles created are writable for the group:
+
+```
+umask 002
+```
+
+Generate a list of all the bioinformatics packages recommended by the med-bio and med-cloud metapackages:
+
+```
+PKGLIST=$(./DebianMed_$DEBVERSION.sif apt show med-bio med-cloud |
+  grep Recommends                   | 
+  sed 's/ |/,/'g                    |  # Sanitize pipe symbols representive alternatives
+  cut -d' ' -f2-                    |  # Remove 'Recommends: '
+  sed -e 's/, /\n/g'                |  # Make it a space-separated pacakge list 
+  sort -u                           |  # Remove duplicates and in the next command, remove R packages
+  grep -v -e r-cran -e r-bioc -e r-other )
+```
+
+Create the modules
+
+```
+ln -s DebianMed_${DEBVERSION}.sif debalamod.sif
+debalamod.sif cp /debalamod .
+chmod 775 debalamod
+for package in $PKGLIST source-highlight
+do
+  ./debalamod $package
+done
+```
+
+After creating a new module, if it is not seen by `ml av`, delete the cache:
+
+```
+rm -rf ~/.lmod.d/.cache
+```
+
+### `biosyntax-less` module
+
+This module was generated by hand as it needs complex setting of environment variables.
+
+```
+mkdir -p /bucket/BioinfoUgrp/DebianMed/$DEBVERSION/modules/biosyntax-less/1.0.0b-2
+cd /bucket/BioinfoUgrp/DebianMed/$DEBVERSION/modules/biosyntax-less/1.0.0b-2
+cat > src-hilite-lesspipe-bio.sh <<__END__
+#!/bin/sh
+LC_ALL=C singularity exec /bucket/BioinfoUgrp/DebianMed/$DEBVERSION/DebianMed_$DEBVERSION.sif /usr/share/source-highlight/src-hilite-lesspipe-bio.sh ""\$@"" 
+__END__
+chmod 775 src-hilite-lesspipe-bio.sh
+mkdir -p /bucket/BioinfoUgrp/DebianMed/$DEBVERSION/modulefiles/biosyntax-less/
+cat > /bucket/BioinfoUgrp/DebianMed/$DEBVERSION/modulefiles/biosyntax-less/1.0.0b-2.lua <<__END__
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp/DebianMed/$DEBVERSION""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, ""modules"", ""biosyntax-less"", appversion)
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/oist/BioinfoUgrp"")
+whatis(""Category: "".."" bioinformatics"")
+whatis(""Keywords: "".."" Bioinformatics, Debian"")
+whatis(""Description: "".."" Syntax Highlighting for Computational Biology"")
+
+help([[This module runs from Singularity image of Debian Med.
+Please contact the Bioinfo user group for details.]])
+
+-- Package settings
+depends_on(""singularity"", ""source-highlight"")
+
+-- Adatpted from /usr/share/doc/biosyntax-less/rc_append.txt
+
+pushenv(""HIGHLIGHT"", ""/usr/share/source-highlight"")
+pushenv(""LESSOPEN"", ""| "" .. apphome .. ""/src-hilite-lesspipe-bio.sh %s"")
+pushenv(""LESS"", "" -R "")
+
+set_alias(""less"", ""less -NSi -# 10"")
+--  -N: add line numbers
+--  -S: don't wrap lines (force to single line)
+--  -# 10: Horizontal scroll distance
+
+-- Explicit call of  <file format>-less for piping data
+-- i.e:  samtools view -h aligned_hits.bam | sam-less
+-- Core syntaxes (default)
+set_alias(""clustal-less"", ""source-highlight -f esc --lang-def=\$HIGHLIGHT/clustal.lang --outlang-def=\$HIGHLIGHT/bioSyntax.outlang     --style-file=\$HIGHLIGHT/fasta.style | less"")
+set_alias(""bed-less"", ""source-highlight     -f esc --lang-def=\$HIGHLIGHT/bed.lang     --outlang-def=\$HIGHLIGHT/bioSyntax.outlang     --style-file=\$HIGHLIGHT/sam.style   | less"")
+set_alias(""fa-less"", ""source-highlight      -f esc --lang-def=\$HIGHLIGHT/fasta.lang   --outlang-def=\$HIGHLIGHT/bioSyntax.outlang     --style-file=\$HIGHLIGHT/fasta.style | less"")
+set_alias(""fq-less"", ""source-highlight      -f esc --lang-def=\$HIGHLIGHT/fastq.lang   --outlang-def=\$HIGHLIGHT/bioSyntax.outlang     --style-file=\$HIGHLIGHT/fasta.style | less"")
+set_alias(""gtf-less"", ""source-highlight     -f esc --lang-def=\$HIGHLIGHT/gtf.lang     --outlang-def=\$HIGHLIGHT/bioSyntax-vcf.outlang --style-file=\$HIGHLIGHT/vcf.style   | less"")
+set_alias(""pdb-less"", ""source-highlight     -f esc --lang-def=\$HIGHLIGHT/pdb.lang     --outlang-def=\$HIGHLIGHT/bioSyntax-vcf.outlang --style-file=\$HIGHLIGHT/pdb.style   | less"")
+set_alias(""sam-less"", ""source-highlight     -f esc --lang-def=\$HIGHLIGHT/sam.lang     --outlang-def=\$HIGHLIGHT/bioSyntax.outlang     --style-file=\$HIGHLIGHT/sam.style   | less"")
+set_alias(""vcf-less"", ""source-highlight     -f esc --lang-def=\$HIGHLIGHT/vcf.lang     --outlang-def=\$HIGHLIGHT/bioSyntax-vcf.outlang --style-file=\$HIGHLIGHT/vcf.style   | less"")
+set_alias(""bam-less"", ""sam-less"")
+
+-- Auxillary syntaxes (uncomment to activate)
+set_alias(""fai-less"", ""source-highlight      -f esc --lang-def=\$HIGHLIGHT/faidx.lang    --outlang-def=\$HIGHLIGHT/bioSyntax.outlang   --style-file=\$HIGHLIGHT/sam.style   | less"")
+set_alias(""flagstat-less"", ""source-highlight -f esc --lang-def=\$HIGHLIGHT/flagstat.lang --outlang-def=\$HIGHLIGHT/bioSyntax.outlang   --style-file=\$HIGHLIGHT/sam.style   | less"")
+__END__
+```
+
+### Finally make the modules available
+
+Test them before !
+
+```
+cat > /apps/.bioinfo-ugrp-modulefiles81/DebianMed/$DEBVERSION.lua <<__END__
+-- Setup Modulepath for packages built by this compiler
+-- local mroot = os.getenv(""MODULEPATH_ROOT"")
+prepend_path(""MODULEPATH"", ""/bucket/BioinfoUgrp/DebianMed/$DEBVERSION/modulefiles"")
+__END__
+```
+
+## TODO
+
+ - Parse description from Debian package
+ - Export man pages and add MANPATH to the Lua module.
+","Markdown"
+"AlphaFold","oist/BioinfoUgrp","DataBases.md",".md","6966","163","# Databases
+
+## Taxified BLAST databases
+The following databases were constructed using ncbi-blast v2.10.0+. The module `ncbi-blast/2.10.0+` has to be loaded in order to use these databases.
+- NCBI NT and NR databases (release 238) : `ml DB/blastDB/ncbi/238`. To be used with the arguments `nt` or `nr` supplied to `-db` in the commands of your scripts. Example script to get a taxified blast report:
+```
+module load ncbi-blast/2.10.0+
+module load DB/blastDB/ncbi/238
+WORKDIR=""$PWD""
+FASTA=FULL/PATH/TO/YOUR/FASTA/FILE
+blastn -task megablast -db nt -query $FASTA -num_threads ${SLURM_CPUS_PER_TASK} -out ${WORKDIR}/megablastn.out \
+	-outfmt '6 qseqid bitscore evalue length qlen qcovs pident sseqid sgi sacc staxid ssciname scomname stitle sseq' \
+	-max_target_seqs 1
+```
+- Swiss-Prot (version 2020_06): `ml DB/blastDB/sprot/2020_06`
+- UniRef90 (version 2020_06): `ml DB/blastDB/uniref90/2020_06`
+
+## Taxified DIAMOND databases
+The following databases were constructed using DIAMOND v2.0.4.142. The module `Other/DIAMOND/2.0.4.142` has to be loaded in order to use them.
+- the NCBI-NR database (release 238): `ml DB/diamondDB/ncbi/238`
+- Swiss-Prot (version 2020_06): `ml DB/diamondDB/sprot/2020_06`
+- UniRef90 (version 2020_06): `ml DB/diamondDB/uniref90/2020_06`
+
+Unlike ncbi-blast, DIAMOND requires full path of the databases. The database module automatically create an environment variable ""DIAMONDDB"" which specifies full path to the DIAMOND database. So you need to prepend `${DIAMONDDB}` to the name of database. 
+Example script to run diamond with the database module:
+```
+# load ncbi database for DIAMOND (proper version of DIAMOND is automatically loaded)
+module load DB/diamondDB/ncbi/238
+
+# check the loaded DIAMOND version and ${DIAMONDDB} variable
+diamond --version
+echo ${DIAMONDDB}
+
+# run diamond search
+WORKDIR=""$PWD""
+FASTA=FULL/PATH/TO/YOUR/FASTA/FILE
+diamond blastp -db ${DIAMONDDB}/nr -q $FASTA -p ${SLURM_CPUS_PER_TASK} -out ${WORKDIR}/diamond.blastp.out -outfmt 6
+```
+
+## GTDB DIAMOND Database (r226)
+
+The Genome Taxonomy Database (GTDB) DIAMOND database was constructed using DIAMOND v2.1.11. The ```bioinfo-ugrp-modules``` module needs to be loaded in order to use it. 
+
+### Available as Module
+
+Load the module to access the database path: `module load DB/diamondDB/GTDB/r226`
+
+
+**Use case**: Fast sequence similarity searches against GTDB reference genomes (BLAST-like functionality)
+
+##### Example script
+
+```bash
+# Load bioinfo-user group modules
+module load bioinfo-ugrp-modules
+# Load GTDB database module
+module load DB/diamondDB/GTDB/r226
+
+# Optional: set variables for output directory and fasta files path
+OUTDIR=/path/to/ouput/directory
+FASTA=/path/to/fasta/files
+
+# Create output directory if it does not exist
+mkdir -p ${OUTDIR}
+
+# Run search
+diamond blastp -d ${DIAMONDDB}/gtdb.dmnd -q ${FASTA} -p 4 -o ${OUTDIR}
+
+```
+
+## GTDB-Tk r226 Reference Data
+
+The GTDB-Tk r226 reference data package contains the auxiliary files required for taxonomic classification of bacterial and archaeal genomes. This is **the database only** - the GTDB-Tk software itself is not installed as a module, but is available through nf-core pipeline containers.The ```bioinfo-ugrp-modules``` module needs to be loaded in order to use it. 
+
+
+**Use case**: Provides the reference database path for GTDB-Tk when running nf-core pipelines (e.g., nf-core/mag)
+
+
+### Available as Module
+
+Load the module to access the database path: ```module load DB/GTDBTK/ref_data/226.0```
+
+This module sets `$GTDBTK_DATA_PATH` & `GTDBTK_DATA_ARCHIVED` environment variables pointing to the uncompressed and compressed reference data location.
+
+### Usage with nf-core Pipelines
+
+The GTDB-Tk r226 reference data is available for use with nf-core pipelines (e.g., nf-core/mag, nf-core/taxprofiler). Instead of downloading the ~100GB database, you simply specify the path to the pre-installed data.
+
+The nf-core pipeline will use its own containerized version of the GTDB-Tk software and access your local reference data.
+
+##### Example nf-core/mag pipeline
+
+```bash
+
+# Load bioinfo-user group modules
+module load bioinfo-ugrp-modules
+# Load the module to get database path
+module load bioinfo/gtdbtk/r226-full
+
+# Optional: set variables for output directory 
+OUTDIR=/path/to/ouput/directory
+
+# Run nf-core pipeline specifying the compressed database path
+# Note: for uncompressed use GTDBTK_DATA_PATH
+nextflow run nf-core/mag \
+  --profile oist \
+  --input samplesheet.csv \
+  --outdir ${OUTDIR} \
+  --gtdb_db ${GTDBTK_DATA_ARCHIVED} 
+```
+
+---
+
+## Pfam
+
+Version 34.0:  Use `ml DB/Pfam/34.0` to invoke it in your scripts.
+
+## Dfam
+
+Version 3.9 downloaded from <https://www.dfam.org/releases/Dfam_3.9/families/> and <https://www.dfam.org/releases/Dfam_3.9/families/FamDB>.  HDF5 files were uncompressed after checking their MD5 sums.
+
+The command `ml DB/Dfam/3.9` exposes two environment variables
+ - `$BioinfoUgrp_Dfam` containing the path to the directory containing the HMM files, that can be passed to RepeatMasker through its `-libdir` argument.
+ - `$BioinfoUgrp_FamDB` containing the path to the directory containing the HDF5 files, to be bind-mounted on `/opt/RepeatMasker/Libraries/famdb/` when using `TETools`.
+ - `SINGULARITY_BINDPATH`, with a value to replace `/opt/RepeatMasker/Libraries/famdb` in the Singularity containers with the local full copy of Dfam.
+
+This is done with the following Lua module file.
+
+```
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://dfam.org"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""annotation, transposon, repeat"")
+whatis(""Description: ""..""The Dfam open collection of Transposable Element DNA sequence alignments"")
+
+-- Package settings
+LmodMessage(""You can find the Dfam database HMMs in the directory pointed to\nby the environment variable $BioinfoUgrp_Dfam, and the\nHDF5 files in $BioinfoUgrp_FamDB."")
+setenv(""BioinfoUgrp_Dfam"", apphome)
+setenv(""BioinfoUgrp_FamDB"", apphome .. ""/FamDB"")
+setenv(""SINGULARITY_BINDPATH"", apphome..""/FamDB:/opt/RepeatMasker/Libraries/famdb"")
+```
+
+## Dfam for RepeatMasker
+
+The command `ml DB/Dfam_RepeatMasker/3.6__4.1.3` will set an environmental variable that changes the behaviour of the `repeatmodeler` module, so that it will use the full Dfam database provided by us instead of the “_curated only_” version provided by default.
+
+### Developer details
+
+The RepeatMasker program does not follow symbolic links and the Dfam database is large (160 Gb), so I had to use hard links to the files of the `Dfam` module instead.  Also, the modulefile contains:
+
+```
+setenv(""BioinfoUgrp_Dfam_Rmsk_4_1_3"", apphome..""/RepeatMasker_4.1.3/Libraries"")
+setenv(""SINGULARITY_BINDPATH"", apphome..""/Libraries:/opt/RepeatMasker/Libraries"")
+```
+","Markdown"
+"AlphaFold","oist/BioinfoUgrp","mkDebMedModule.sh",".sh","1711","63","#!/bin/bash -e
+ml singularity
+APP=$1
+if [ -z ""$DEBVERSION"" ]
+then
+	printf 'Error: $DEBVERSION is not set and exported\n'
+	exit 1
+fi
+
+printf ""==== $APP ====\n""
+
+MODROOT=/bucket/BioinfoUgrp/DebianMed/$DEBVERSION
+DEBMEDIMAGE=$MODROOT/DebianMed_$DEBVERSION.sif
+APPDIR=$MODROOT/modules/$APP
+VER=$(singularity exec $DEBMEDIMAGE dpkg-query -W -f='${Version}' $APP | perl -pe 's/^.*?://')
+PROGLIST=$($DEBMEDIMAGE dpkg -L $APP | grep -v -e 'package diverts' -e 'diverted by' | grep /bin/) || true
+if [ -z ""$PROGLIST"" ]
+then
+	printf ""Module not created: package $APP has no executables\n""
+	exit 0
+fi
+
+printf ""   creating module in $APPDIR/$VER\n""
+
+mkdir -p $APPDIR/$VER/bin
+cd $APPDIR/$VER
+
+for prog in $(basename -a $PROGLIST)
+do
+cat <<__END__ > bin/$prog
+#!/bin/sh
+LC_ALL=C singularity exec $DEBMEDIMAGE $prog ""\$@"" 
+__END__
+chmod 775 bin/$prog
+done
+mkdir -p $MODROOT/modulefiles/$APP
+cd $MODROOT/modulefiles/$APP
+
+printf ""   creating modulefile $VER in $MODROOT/modulefiles/$APP\n""
+
+cat <<__END__ > $VER.lua
+-- Default settings
+local modroot    = ""$MODROOT""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, ""modules"", ""$APP"", appversion)
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/oist/BioinfoUgrp"")
+whatis(""Category: "".."" bioinformatics"")
+whatis(""Keywords: "".."" Bioinformatics, Debian"")
+whatis(""Description: "".."" Module automatically generated by the Bioinfo user group."")
+
+help([[This module runs from Singularity image of Debian Med.
+Please contact the Bioinfo user group for details.]])
+
+-- Package settings
+depends_on(""singularity"")
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+","Shell"
+"AlphaFold","oist/BioinfoUgrp","RStudio/launch_rserver.sh",".sh","1801","57","#!/bin/sh -e
+
+if [ ""$1"" = ""desktop"" ]; then
+  # Replace the shell process with the rstudio process
+  exec rstudio
+fi
+
+RSTUDIO_TEMP=$(mktemp -d -p ~)
+trap ""{ rm -rf $RSTUDIO_TEMP; }"" EXIT
+
+cat <<__DBCONF__ > $RSTUDIO_TEMP/dbconf
+provider=sqlite
+directory=$RSTUDIO_TEMP/db.sqlite3
+__DBCONF__
+
+
+export RSTUDIO_PASSWORD=${RSTUDIO_PASSWORD-`date -R | md5sum | cut -c-16`}
+
+if [ -z ""$RSTUDIO_PORT"" ]
+then
+	# Taken from https://gitlab.oit.duke.edu/chsi-informatics/containers/singularity-rstudio-base/-/blob/master/port_and_password_1_3.sh
+	LOWERPORT=50000
+	UPPERPORT=65535
+	for RSTUDIO_PORT in $(seq $LOWERPORT $UPPERPORT);
+	do
+	    RSTUDIO_PORT=""`shuf -i $LOWERPORT-$UPPERPORT -n 1`""
+	    # echo ""Testing port: $RSTUDIO_PORT""
+	    ss -lpn | grep -q "":$RSTUDIO_PORT "" || break
+	done
+fi
+
+RSTUDIO_HOST=$(hostname -A | cut -f1 -d' ')
+RSTUDIO_HOST=${RSTUDIO_HOST:-localhost}
+
+printf ""\nRStudio URL:\t\thttp://${RSTUDIO_HOST}:${RSTUDIO_PORT}/\n""
+printf ""RStudio Username:\t$USER\n""
+printf ""RStudio Password:\t$RSTUDIO_PASSWORD\n""
+if [ ! $RSTUDIO_HOST = ""localhost"" ]
+then
+	printf ""\nIf you remote work, you can forward the server to port 1664 on your computer with:\n""
+	printf ""ssh ${USER}@${RSTUDIO_HOST} -J ${USER}@login.oist.jp,${USER}@deigo.oist.jp -L 1664:localhost:${RSTUDIO_PORT}\n""
+fi
+printf ""\nYou may need to clean your temporary files by yourself:\n""
+printf ""RStudio temporary files:\t$RSTUDIO_TEMP\n""
+printf ""\nThis image will build its packages in the following directory if it exists:\n""
+grep ^R_LIBS_USER /etc/R/Renviron.site
+printf ""\n""
+
+/usr/lib/rstudio-server/bin/rserver \
+	--server-working-dir $RSTUDIO_TEMP \
+	--server-data-dir $RSTUDIO_TEMP \
+	--database-config-file $RSTUDIO_TEMP/dbconf \
+	--server-user=$USER \
+	--www-port=$RSTUDIO_PORT \
+	--auth-none 0 \
+	--auth-pam-helper rstudio_auth
+","Shell"
+"AlphaFold","oist/BioinfoUgrp","RStudio/rstudio_auth.sh",".sh","569","28","#!/usr/bin/env bash
+
+# Confirm username is supplied
+if [[ $# -lt 1 ]]; then
+  echo ""Usage: auth USERNAME""
+  exit 1
+fi
+USERNAME=""${1}""
+
+# Confirm password environment variable exists
+if [[ -z ""${RSTUDIO_PASSWORD}"" ]]; then
+  echo ""The environment variable RSTUDIO_PASSWORD is not set""
+  exit 1
+fi
+
+# Read in the password from user
+read -s -p ""Password: "" PASSWORD
+echo """"
+
+# Authenticate user
+if [[ ""${USER}"" == ""${USERNAME}"" && ""${PASSWORD}"" == ""${RSTUDIO_PASSWORD}"" ]]; then
+  echo ""Successful authentication""
+  exit 0
+else
+  echo ""Invalid authentication""
+  exit 1
+fi
+","Shell"
+"AlphaFold","oist/BioinfoUgrp","AlphaFold/AlphaFold2.md",".md","6034","106","# Alphafold 2.0 and 2.1 @ SAION
+
+*Disclaimer: this implementation was made for general use with the help of Jan Moren of SCS. I do take no responsibility for bugs or errors, but if you could report them, I will gladly try to fix on my extra time. Nonetheless, the AF2 predictions appear to be working. Feel free but not obligated to acknowledge me or at least the SCS if this work was helpful for your research.*
+
+In order to use AF2, you need [SAION access](https://oist.service-now.com/sp?id=sc_category&sys_id=9c71871fdbcdeb806885f00ebf961928) and have basic knowledge of the [terminal](https://groups.oist.jp/scs/basic-linux-commands) and [slurm submission commands](https://groups.oist.jp/scs/use-slurm).  
+AF2 is part of the OIST [Bioinfo User group](https://github.com/oist/BioinfoUgrp).  
+AF2 was implemented using the [docker image](https://hub.docker.com/r/uvarc/alphafold) made by the University of Virginia, that here we gratefully acknowledge.
+## AF2 content
+### AF 2.0
+* 'alphafold_2.0.0.sif': singularity image created from the previously mentioned docker file
+* 'run_alphafold.sh': AF2 run script. Contains the default parameters (except input file and output folder). DO NOT MODIFY
+* 'alphafold_example_script.sh': AF2 sbatch example. Copy to your folder and modify (add input file and output folder paths).
+* 'get_plddt_attribfile.py': Chimera attribute file generator. Automatically generates an attribute file for plddt coloring in chimera.
+### AF 2.1
+* 'alphafold_2.1.1.sif': singularity image created from the previously mentioned docker file
+* 'run_alphafold.sh': AF2 run script. Contains the default parameters (except input file and output folder). DO NOT MODIFY
+* 'run_alphafold_multimer.sh': AF2 run script specialized in multimer run. Contains the default parameters (except input file and output folder). DO NOT MODIFY
+* 'alphafold_example_script.sh': AF2 sbatch example. Copy to your folder and modify (add input file and output folder paths).
+* 'get_plddt_attribfile.py': Chimera attribute file generator. Automatically generates an attribute file for plddt coloring in chimera.
+
+MULTIMER RUN [instructions](https://github.com/deepmind/alphafold#running-alphafold-multimer)
+TL;DR: provide a multi fasta file as input.
+
+## Example run
+Assume to have a folder in /work with the input single protein sequence: example.fasta and a test output folder: test_out/.  
+Copy the example script:
+> cp /bucket/BioinfoUgrp/alphafold/2.1.1/bin/alphafold_example_script.sh .
+
+Change the file name and modify the input and output folder paths, using your favourite text editor:  
+
+> mv alphafold_example_script.sh AF2_testrun.sh  
+> vim AF2_testrun.sh 
+> (change input file and output folder, save and exit)  
+
+OPTIONAL: CHECK IF THE RESOURCES YOU ARE REQUESTING VIA SLURM ARE ENOUGH (by default 4cpu cores, 100GB, 1 GPU)    
+   
+Submit the job: 
+
+> sbatch AF2_testrun.sh 
+
+The job is expected to take 2 to 12+ hours depending on sequence lenght.
+
+## Output
+A description of the output can be found in [AlphaFold 2 Github page](https://github.com/deepmind/alphafold/blob/main/README.md#alphafold-output).  
+However, for lazy people, ranked_0.pdb is the highest scoring model.
+
+## Example script
+For convenience, we report here the example script content for version 2.1.1. 
+
+> #!/bin/bash  
+> #SBATCH --job-name=test_af  
+> #SBATCH -c 4  
+> #SBATCH --mem=100G  
+> #SBATCH --partition=gpu  
+> #SBATCH -t 4-0  
+> #SBATCH --gres=gpu:1  
+>   
+> module load bioinfo-ugrp-modules  
+> module load alphafold/2.1.1 
+>   
+> \# Uncomment the monomer or multimer depending on the use case  
+> \# Monomer  
+> \# run_alphafold.sh --fasta_paths test.fa --output_dir test_output  
+> \# Multimer  
+> \# run_alphafold_multimer.sh --fasta_paths multifasta_test.fa --output_dir test_output  
+
+
+## Attrib file
+If you use Chimera to visualize the pdb file, you might be interested in per-residue plddt coloring. plddt is the self-evaluated confidence measure of the prediction of alphafold2. It goes from 0 (low confidence) to 100 (high confidence). A low value indicates either badly predicted regions or disordered regions.   
+To automatically generate a chimera attribute file for coloring by plddt, you can use the python script I made:
+> module load python/3.7.3   
+> python /bucket/BioinfoUgrp/alphafold/2.0.0/bin/get_plddt_attribfile.py <result_model_X.pkl> <outfile.txt>
+The text file generated can be used in Chimera (Tools > Structure Analysis > Define Attribute) after opening the same pdb model.   
+
+## Appendix: parameters
+This is a list of all the default parameters in the run_alphafold script. If you want to modify them, do not change the default script. Instead, provide them to the example run script just like the input fasta and output folder.  
+Default parameters (v2.0):
+> MAX_TEMPLATE_DATE=2030-09-09   
+> MODEL_NAMES=model_1,model_2,model_3,model_4,model_5   
+> DATA_DIR=/bucket/BioinfoUgrp/alphafold/database/
+> UNIREF90_PATH=$DATA_DIR/uniref90/uniref90.fasta   
+> MGNIFY_PATH=$DATA_DIR/mgnify/mgy_clusters.fa   
+> UNICLUST30_PATH=$DATA_DIR/uniclust30/uniclust30_2018_08/uniclust30_2018_08   
+> BFD_PATH=$DATA_DIR/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt   
+> PDB70_PATH=$DATA_DIR/pdb70/pdb70   
+> TEMPLATE_PATH=$DATA_DIR/pdb_mmcif/mmcif_files/   
+> OBSOLETE_PATH=$DATA_DIR/pdb_mmcif/obsolete.dat   
+
+Default parameters (v2.1):
+> MAX_TEMPLATE_DATE=2030-09-09  
+> MODEL_PRESET=multimer  
+> DATA_DIR=/bucket/BioinfoUgrp/alphafold/database/
+> UNIREF90_PATH=$DATA_DIR/uniref90/uniref90.fasta  
+> MGNIFY_PATH=$DATA_DIR/mgnify/mgy_clusters.fa  
+> UNICLUST30_PATH=$DATA_DIR/uniclust30/uniclust30_2018_08/uniclust30_2018_08  
+> BFD_PATH=$DATA_DIR/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt  
+> PDB70_PATH=$DATA_DIR/pdb70/pdb70   
+> TEMPLATE_PATH=$DATA_DIR/pdb_mmcif/mmcif_files/  
+> OBSOLETE_PATH=$DATA_DIR/pdb_mmcif/obsolete.dat  
+> PDB_SEQRES_PATH=$DATA_DIR/pdb_seqres/pdb_seqres.txt  
+> UNIPROT_PATH=$DATA_DIR/uniprot/  
+
+
+## Appendix: contact
+Stefano Pascarelli, PhD, Laurino unit
+","Markdown"
+"AlphaFold","oist/BioinfoUgrp","Other/Assembly.md",".md","16928","630","# Bioinformatics modules for genome assembly
+
+To use the modules, load the `bioinfo-ugrp-modules` metamodule first.
+
+```bash
+ml bioinfo-ugrp-modules
+ml av Other
+ml Other/<your-favorite-module>
+```
+
+## assembly-stats
+
+- Home page: https://github.com/sanger-pathogens/assembly-stats
+- Source code: https://github.com/sanger-pathogens/assembly-stats
+
+### Installation on Deigo
+
+```bash
+APP=assembly-stats
+VER=1.0.1
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/sanger-pathogens/assembly-stats/archive/refs/tags/v1.0.1.tar.gz | tar xzvf -
+mv $APP-$VER $VER
+cd $VER && mkdir build && cd build
+cmake -DINSTALL_DIR:PATH=$APPDIR/$VER ..
+make test
+make install
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/sanger-pathogens/assembly-stats"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly-stats"")
+whatis(""Description: ""..""Get assembly statistics from FASTA and FASTQ files."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running assembly-stats on Deigo
+
+```bash
+ml Other/assembly-stats
+srun -p compute -c 1 --mem 10G -t 00:10:00 --pty \
+    assembly-stats contigs.fasta
+```
+
+## BandageNG
+
+- Home page: https://github.com/asl/BandageNG
+- Source code: https://github.com/asl/BandageNG
+
+### Installation on Deigo
+
+I created a Singularity image with the following definition file on my Linux laptop.
+
+```
+Bootstrap: docker
+From: debian:bookworm
+
+
+%runscript
+    exec /squashfs-root/AppRun ""$@""
+
+%post
+    # Update the image
+    apt update
+    apt upgrade -y
+    
+    # Add a package needed to suppress some debconf error messages
+    apt install -y whiptail
+    
+    # Install all locales
+    apt install -y locales-all
+
+    # Install FUSE to extract and run the AppImage
+    apt install -y fuse3
+    # X11 and other dependencies
+    apt install -y x11-apps mesa-utils libgl1 libglu1-mesa
+    apt install -y dbus
+    dbus-uuidgen > /etc/machine-id
+
+    # Download BandageNG
+    apt install -y wget
+    wget https://github.com/asl/BandageNG/releases/download/continuous/BandageNG-Linux-827c5cb.AppImage
+    chmod 775 BandageNG-Linux-827c5cb.AppImage
+    ./BandageNG-Linux-827c5cb.AppImage --appimage-extract
+
+    # Clean downoladed package cache.  Yes I know about /var/libs.
+    apt clean
+```
+
+Then, I copied it in my home directory on _deigo_.
+
+```bash
+APP=BandageNG
+VER=2025-03-28
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR/$VER
+cd $APPDIR/$VER
+cp ~/BandageNG.sif BandageNG
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/chaoszhang/ASTER"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""BandageNG"")
+whatis(""Description: "".."" a Bioinformatics Application for Navigating De novo Assembly Graphs Easily"")
+
+-- Package settings
+depends_on(""singularity"")
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+## pbgzip
+
+- Home page: https://github.com/nh13/pbgzip
+- Source code: https://github.com/nh13/pbgzip
+
+### Installation on Deigo
+
+```bash
+APP=pbgzip
+VER=20160804
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/nh13/pbgzip
+mv pbgzip $VER && cd $VER 
+sh autogen.sh && ./configure --prefix=$APPDIR/$VER && make 
+make install
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/nh13/pbgzip"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""pbgzip"")
+whatis(""Description: ""..""This tool and API implements parallel block gzip."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running pbgzip on Deigo
+
+```bash
+module load Other/pbgzip
+srun -p compute -c 128 --mem 100G -t 1:00:00 --pty \
+    pbgzip <arguments>
+```
+
+## SMARTdenovo
+
+```bash
+APP=SMARTdenovo
+VER=2021-02-24
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $MODROOT/$APP
+cd $MODROOT/$APP
+git clone https://github.com/ruanjue/smartdenovo $VER
+ml gcc
+cd $VER
+make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/ruanjue/smartdenovo"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""PacBio, Nanopore, genome, assembler"")
+whatis(""Description: ""..""de novo assembler for PacBio and Oxford Nanopore (ONT) data"")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+## BUSCO
+
+- Home page: https://busco.ezlab.org/
+- Source code: https://gitlab.com/ezlab/busco
+
+### Installation on Deigo
+
+```bash
+module load singularity
+APP=BUSCO
+VER=5.8.2
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $APPDIR
+cd $APPDIR
+singularity pull busco.sif docker://ezlabgva/busco:v${VER}_cv1
+echo '#!/bin/sh' > busco && echo ""singularity exec $APPDIR/busco.sif busco \$*"" >> busco && chmod +x busco
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://busco.ezlab.org/"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly"")
+whatis(""Description: ""..""Assessing genome assembly and annotation completeness with Benchmarking Universal Single-Copy Orthologs (BUSCO)."")
+
+-- Package settings
+depends_on(""singularity"")
+prepend_path(""PATH"", apphome)
+
+LmodMessage([[
+================================================================================
+The BUSCO module runs a read-only Singularity image.
+
+If you need to change AUGUSTUS configuration, you can do a local copy with the
+following command that will place it in $HOME/augustus_config.
+
+    singularity exec /bucket/BioinfoUgrp/Other/BUSCO/5.8.2/busco.sif cp -r /usr/local/config $HOME/augustus_config
+
+You can then pass the information by exporting the AUGUSTUS_CONFIG_PATH variable.
+
+    export AUGUSTUS_CONFIG_PATH=""$HOME/augustus_config""
+================================================================================
+]])
+__END__
+```
+
+### Example commands for running BUSCO on Deigo
+
+The following command executes `$ busco` using the Singularity image:
+
+```bash
+module load Other/BUSCO
+srun -p compute -c 128 --mem 500G -t 24:00:00 --pty \
+    busco.sif <arguments> 
+```
+
+We also provide a command `busco` that is effectively the same as above:
+
+```bash
+module load Other/BUSCO
+srun -p compute -c 128 --mem 500G -t 24:00:00 --pty \
+    busco <arguments>
+```
+
+**IMPORTANT: Using Augustus for BUSCO running via its Singularity image requires the Augustus' config directory to be copied (from inside of Singularity container environment) to your own environment (outside Singularity in Deigo). The module we provide automatically copy the config directory to `$HOME/augustus_config` if it does not exist yet, and also set the `AUGUSTUS_CONFIG_PATH` varieble as `$HOME/augustus_config`, when the module is loaded.**
+
+## gfatools
+
+- Home page: https://github.com/lh3/gfatools
+- Source code: https://github.com/lh3/gfatools/releases
+
+### Installation on Deigo
+
+```bash
+APP=gfatools
+VER=0.5
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/lh3/gfatools/archive/refs/tags/v$VER.tar.gz | tar xzvf -
+mv $APP-$VER $VER
+cd $VER && make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/lh3/gfatools"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""gfa, assembly"")
+whatis(""Description: ""..""Tools for manipulating sequence graphs in the GFA and rGFA formats."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running gfatools on Deigo
+
+```bash
+module load Other/gfatools
+srun -p compute -c 1 --mem 40G -t 1:00:00 --pty \
+    gfatools <arguments>
+```
+
+## hifiasm
+
+- Home page: https://github.com/chhylp123/hifiasm
+- Source code: https://github.com/chhylp123/hifiasm/releases
+
+### Installation on Deigo
+
+```bash
+APP=hifiasm
+VER=0.25.0
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/chhylp123/hifiasm/archive/refs/tags/$VER.tar.gz | tar xzvf -
+mv $APP-$VER $VER
+cd $VER
+ml purge && ml gcc/11.2.1
+make CXXFLAGS=""-g -O3 -mavx2 -mpopcnt -fomit-frame-pointer -Wall""  # Replace SSE with AVX.  When updating, check that the other flags did not change.
+cd /bucket/BioinfoUgrp/Other/modulefiles/hifiasm
+cp 0.20.0.lua ${VER}.lua
+```
+
+### Example commands for running hifiasm on Deigo
+
+```bash
+module load Other/hifiasm
+srun -p compute -c 64 --mem 500G -t 24:00:00 --pty \
+    hifiasm <arguments>
+```
+
+## Canu (and HiCanu)
+
+- Home page: https://github.com/marbl/canu
+- Source code: https://github.com/marbl/canu/releases
+
+### Installation on Deigo
+
+```bash
+APP=canu
+VER=2.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/marbl/canu/releases/download/v$VER/$APP-$VER.Linux-amd64.tar.xz | tar Jxvf -
+mv $APP-$VER $VER
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/marbl/canu"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly"")
+whatis(""Description: ""..""A single molecule sequence assembler for genomes large and small."")
+
+-- Package settings
+depends_on(""samtools"")
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+### Example commands for running Canu on Deigo
+
+```bash
+module load Other/canu
+srun -p compute -c 128 --mem 500G -t 24:00:00 --pty \
+    canu <arguments>
+```
+
+## purge_dups
+
+- Home page: https://github.com/dfguan/purge_dups
+- Source code: https://github.com/dfguan/purge_dups
+
+### Installation on Deigo
+
+**WARNING: This module currently does not support the optional runner script nor k-mer comparision plot.**
+
+```bash
+APP=purge_dups
+VER=1.2.5
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/dfguan/purge_dups
+mv purge_dups $VER && cd $VER/src && make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/dfguan/purge_dups"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly"")
+whatis(""Description: ""..""haplotypic duplication identification tool."")
+
+-- Package settings
+depends_on(""Other/minimap2"")
+prepend_path(""PATH"", apphome..""/bin"")
+prepend_path(""PATH"", apphome..""/scripts"")
+__END__
+```
+
+### Example commands for running purge_dups on Deigo
+
+To load the module, run:
+
+```bash
+module load Other/purge_dups
+```
+
+Then, the following commands become available:
+
+- `calcuts`
+- `get_seqs`
+- `ngscstat`
+- `pbcstat`
+- `purge_dups`
+- `split_fa`
+
+See the [README](https://github.com/dfguan/purge_dups) written by the developer for details about how to use the programs.
+
+## Asset
+
+- Home page: https://github.com/dfguan/asset
+- Source code: https://github.com/dfguan/asset
+
+### Installation on Deigo
+
+**WARNING: This module currently does not support the optional runner script.**
+
+```bash
+APP=asset
+VER=1.0.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/dfguan/asset
+mv asset $VER && cd $VER/src && make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/dfguan/asset"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly"")
+whatis(""Description: ""..""assembly evaluation tool."")
+
+-- Package settings
+depends_on(""samtools"", ""bedtools"", ""bwa"", ""Other/minimap2"")
+prepend_path(""PATH"", apphome..""/bin"")
+prepend_path(""PATH"", apphome..""/scripts"")
+__END__
+```
+
+### Example commands for running Asset on Deigo
+
+To load the module, run:
+
+```bash
+module load Other/asset
+```
+
+Then, the following commands become available:
+
+- `10x`
+- `acc`
+- `ast_10x`
+- `ast_bion`
+- `ast_bion_bnx`
+- `ast_hic`
+- `ast_hic2`
+- `ast_pb`
+- `col_conts`
+- `detgaps`
+- `pchlst`
+- `pchlst0`
+- `split_fa`
+- `union`
+- `union_brks`
+
+See the [README](https://github.com/dfguan/asset) written by the developer or [another workflow](https://github.com/VGP/vgp-assembly/tree/master/pipeline/asset) written by researchers of the Vertebrate Genome Project for details about how to use the programs.
+
+## SPAdes
+- Home page: https://github.com/ablab/spades
+- Source code: http://cab.spbu.ru/files/release3.15.1/SPAdes-3.15.1-Linux.tar.gz
+
+### Installation on Deigo
+```bash
+APP=SPAdes
+VER=3.15.1
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - http://cab.spbu.ru/files/release3.15.1/SPAdes-3.15.1-Linux.tar.gz | tar xzvf -
+mv $APP-$VER-Linux $VER
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER
+#%Module1.0##################################################################
+set approot    [lrange [split [module-info name] {/}] 0 0]
+set appname    [lrange [split [module-info name] {/}] 1 1]
+set appversion [lrange [split [module-info name] {/}] 2 2]
+set apphome    /bucket/BioinfoUgrp/$approot/$appname/$appversion
+
+## URL of application homepage:
+set appurl     https://github.com/ablab/spades
+
+## Short description of package:
+module-whatis  ""SPAdes is an assembly toolkit containing various assembly pipelines.""
+
+## Load any needed modules:
+module load python/3.7.3
+
+## Modify as needed, removing any variables not needed.
+## Non-path variables can be set with ""setenv VARIABLE value""
+prepend-path    PATH            $apphome
+prepend-path    PATH            $apphome/bin
+__END__
+```
+
+## Flye
+- Home page: https://github.com/mikolmogorov/Flye/tree/flye
+- Installation: https://github.com/mikolmogorov/Flye/tree/flye
+
+### Installation on Deigo
+```bash
+APP=Flye
+VER=2.9.5
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/mikolmogorov/Flye/archive/refs/tags/$VER.tar.gz | tar xzvf -
+mv $APP-$VER $VER
+cd $VER
+make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/mikolmogorov/Flye/tree/flye"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""flye"")
+whatis(""Description: ""..""Flye is a de novo assembler for single-molecule sequencing reads, such as those produced by PacBio and Oxford Nanopore Technologies.."")
+
+-- Package settings
+depends_on(""python/3.7.3"")
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+","Markdown"
+"AlphaFold","oist/BioinfoUgrp","Other/Other.md",".md","60648","1963","# A collection of general bioinformatics modules
+
+To use the modules, load the `bioinfo-ugrp-modules` metamodule first.
+
+```bash
+ml bioinfo-ugrp-modules
+ml av Other
+ml Other/<your-favorite-module>
+```
+
+Here are installation snippets to help the members of the bioinfo user group to update the modules.
+
+## ASTRAL
+- Home page: https://github.com/smirarab/ASTRAL
+- Source code: https://github.com/smirarab/ASTRAL
+
+### Installation on Deigo
+```
+APP=astral
+VER=5.7.8
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget https://github.com/smirarab/ASTRAL/raw/master/Astral.$VER.zip && unzip Astral.$VER.zip && rm Astral.$VER.zip
+mv Astral $VER && cd $VER
+chmod g+r * && chmod g+x *
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER
+#%Module1.0##################################################################
+set approot    [lrange [split [module-info name] {/}] 0 0]
+set appname    [lrange [split [module-info name] {/}] 1 1]
+set appversion [lrange [split [module-info name] {/}] 2 2]
+set apphome    /bucket/BioinfoUgrp/$approot/$appname/$appversion
+
+## URL of application homepage:
+set appurl     https://github.com/smirarab/ASTRAL
+
+## Short description of package:
+module-whatis  ""ASTRAL is a tool for estimating an unrooted species tree given a set of unrooted gene trees. To be called in script with: java -jar dollarASTRAL. Replace dollar by the actual symbol""
+
+## Load any needed modules:
+
+## Modify as needed, removing any variables not needed.
+## Non-path variables can be set with ""setenv VARIABLE value""
+prepend-path    PATH            $apphome    
+prepend-path    PATH $apphome/lib
+prepend-path    ASTRAL      $apphome/astral.5.7.8.jar
+__END__
+```
+
+## ASTER
+
+- Home page: https://github.com/chaoszhang/ASTER
+- Source code: https://github.com/chaoszhang/ASTER
+
+### Installation on Deigo
+
+```bash
+APP=aster
+VER=1.20.4.6
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget https://github.com/chaoszhang/ASTER/archive/refs/heads/Linux.zip
+unzip Linux.zip
+cd ASTER-Linux
+make
+cd ..
+mv ASTER-Linux/bin $VER
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/chaoszhang/ASTER"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""ASTER"")
+whatis(""Description: "".."" Accurate Species Tree EstimatoR: a family of optimation algorithms for species tree inference (including ASTRAL & CASTER)."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+## pbgzip
+
+- Home page: https://github.com/nh13/pbgzip
+- Source code: https://github.com/nh13/pbgzip
+
+### Installation on Deigo
+
+```bash
+APP=pbgzip
+VER=20160804
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/nh13/pbgzip
+mv pbgzip $VER && cd $VER 
+sh autogen.sh && ./configure --prefix=$APPDIR/$VER && make 
+make install
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/nh13/pbgzip"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""pbgzip"")
+whatis(""Description: ""..""This tool and API implements parallel block gzip."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running pbgzip on Deigo
+
+```bash
+module load Other/pbgzip
+srun -p compute -c 128 --mem 100G -t 1:00:00 --pty \
+    pbgzip <arguments>
+```
+
+
+- Home page: https://www.ncbi.nlm.nih.gov/datasets/docs/v2/download-and-install/
+
+### Installation on Deigo
+
+```bash
+APP=ncbi-datasets-cli
+VER=18.10.2
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR/$VER
+cd $APPDIR/$VER
+wget https://ftp.ncbi.nlm.nih.gov/pub/datasets/command-line/v2/linux-amd64/datasets
+chmod 775 datasets
+wget https://ftp.ncbi.nlm.nih.gov/pub/datasets/command-line/v2/linux-amd64/dataformat
+chmod 775 dataformat
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://www.ncbi.nlm.nih.gov/datasets/docs/v2/download-and-install/"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""NCBI"")
+whatis(""Description: ""..""Use datasets to download biological sequence data across all domains of life from NCBI. Use dataformat to convert metadata from JSON Lines format to other formats."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running pairtools on Deigo
+
+```bash
+module load Other/pairtools
+srun -p compute -c 128 --mem 20G -t 1:00:00 --pty \
+    pairtools parse -c example.chrom.sizes -o example_R1.pairs.gz --drop-sam example_R1.bam 
+```
+
+
+## pairtools
+
+- Home page: https://pairtools.readthedocs.io/en/latest/
+- Source code: https://github.com/open2c/pairtools
+
+### Installation on Deigo
+
+```bash
+module load python/3.7.3
+APP=pairtools
+VER=0.3.0
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/open2c/pairtools/archive/refs/tags/v0.3.0.tar.gz | tar xzvf -
+mv $APP-$VER $VER
+cd $VER
+mkdir -p lib/python3.7/site-packages
+PYTHONUSERBASE=$(pwd) python setup.py install --user
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://pairtools.readthedocs.io/en/latest/"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""pairtools"")
+whatis(""Description: ""..""pairtools is a simple and fast command-line framework to process sequencing data from a Hi-C experiment."")
+
+-- Package settings
+depends_on(""python/3.7.3 "", ""samtools"", ""pbgzip"", ""htslib"")
+prepend_path(""PATH"", apphome..""/bin"")
+prepend_path(""PYTHONPATH"", apphome..""/lib/python3.7/site-packages"")
+__END__
+```
+
+### Example commands for running pairtools on Deigo
+
+```bash
+module load Other/pairtools
+srun -p compute -c 128 --mem 20G -t 1:00:00 --pty \
+    pairtools parse -c example.chrom.sizes -o example_R1.pairs.gz --drop-sam example_R1.bam 
+```
+
+## preseq
+
+- Home page: http://smithlabresearch.org/software/preseq/
+- Source code: https://github.com/smithlabcode/preseq
+
+### Installation on Deigo
+
+```bash
+APP=preseq
+VER=3.1.2
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/smithlabcode/preseq/releases/download/v3.1.2/preseq-3.1.2.tar.gz | tar xzvf -
+mv $APP-$VER $VER
+cd $VER && mkdir build && cd build
+../configure --prefix=$APPDIR/$VER && make && make install && cd .. && rm -r build
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""http://smithlabresearch.org/software/preseq/"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""preseq"")
+whatis(""Description: ""..""The preseq package is aimed at predicting and estimating the complexity of a genomic sequencing library, equivalent to predicting and estimating the number of redundant reads from a given sequencing depth and how many will be expected from additional sequencing using an initial sequencing experiment"")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+### Example commands for running preseq on Deigo
+
+```bash
+module load Other/preseq
+srun -p compute -c 128 --mem 20G -t 1:00:00 --pty \
+    preseq c_curve -o output.txt input.sort.bed
+```
+
+
+## seqkit
+
+- Home page: https://bioinf.shenwei.me/seqkit/
+- Source code: https://github.com/shenwei356/seqkit
+
+### Installation on Deigo
+
+```bash
+APP=seqkit
+VER=2.10.0
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $APPDIR
+cd $APPDIR
+wget -qO- https://github.com/shenwei356/seqkit/releases/download/v$VER/seqkit_linux_amd64.tar.gz | tar xzvf -
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/shenwei356/seqkit"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""fasta, fastq, sequence analysis"")
+whatis(""Description: ""..""A cross-platform and ultrafast toolkit for FASTA/Q file manipulation in Golang"")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running seqkit on Deigo
+
+```bash
+module load Other/seqkit
+srun -p compute -c 1 --mem 40G -t 24:00:00 --pty \
+    seqkit <subcommand> <arguments>
+```
+
+## GNU parallel
+
+- Home page: https://www.gnu.org/software/parallel
+- Source code: https://ftp.gnu.org/gnu/parallel
+
+### Installation on Deigo
+
+```bash
+APP=parallel
+VER=20210622
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR/$VER
+cd $APPDIR
+wget -O - https://ftp.gnu.org/gnu/parallel/parallel-$VER.tar.bz2 | tar xjvf -
+cd $APP-$VER && ./configure --prefix=$APPDIR/$VER && make && make install && cd .. && rm -r $APP-$VER
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://www.gnu.org/software/parallel"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""GNU, parallel"")
+whatis(""Description: ""..""A shell tool for executing jobs in parallel using one or more computers."")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+### Example commands for running GNU parallel on Deigo
+
+```bash
+module load Other/parallel
+srun -p compute -c 1 --mem 40G -t 1:00:00 --pty \
+    parallel <arguments>
+```
+
+## mosdepth
+
+- Home page: https://github.com/brentp/mosdepth
+- Source code: https://github.com/brentp/mosdepth/releases
+
+### Installation on Deigo
+
+```bash
+APP=mosdepth
+VER=0.3.1
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $APPDIR
+cd $APPDIR
+wget https://github.com/brentp/mosdepth/releases/download/v$VER/mosdepth && chmod +x mosdepth
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/brentp/mosdepth"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly"")
+whatis(""Description: ""..""fast BAM/CRAM depth calculation for WGS, exome, or targeted sequencing."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running mosdepth on Deigo
+
+```bash
+module load Other/mosdepth
+srun -p compute -c 1 --mem 100G -t 24:00:00 --pty \
+    mosdepth <arguments>
+```
+
+## Meryl
+
+- Home page: https://github.com/marbl/meryl
+- Source code: https://github.com/marbl/meryl/releases
+
+### Installation on Deigo
+
+```bash
+APP=meryl
+VER=1.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/marbl/meryl/releases/download/v$VER/meryl-$VER.Linux-amd64.tar.xz | tar Jxvf -
+mv $APP-$VER $VER
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/marbl/meryl"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly"")
+whatis(""Description: ""..""A genomic k-mer counter (and sequence utility) with nice features."")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+### Example commands for running Meryl on Deigo
+
+```bash
+module load Other/meryl
+srun -p compute -c 128 --mem 500G -t 24:00:00 --pty \
+    meryl <arguments>
+```
+
+## Merqury
+
+- Home page: https://github.com/marbl/merqury
+- Source code: https://github.com/marbl/merqury/releases
+
+### Installation on Deigo
+
+```bash
+module load R/4.0.4
+APP=merqury
+VER=1.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/marbl/merqury/archive/refs/tags/v$VER.tar.gz | tar zxvf -
+mv $APP-$VER $VER && cd $VER
+sed -i 's/echo $?/echo 1/' util/util.sh
+for FILE in plot/*.R; do sed -i 's|#!/usr/bin/env Rscript|#!/usr/bin/env -S Rscript --vanilla|'
+mkdir -p lib/R && Rscript -e 'install.packages(c(""argparse"",""R6"",""jsonlite"",""findpython"",""ggplot2"",""scales""), lib=""./lib/R"")'
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/marbl/merqury"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly"")
+whatis(""Description: ""..""k-mer based assembly evaluation."")
+
+-- Package settings
+depends_on(""R/4.0.4"", ""samtools/1.12"", ""bedtools/v2.29.2"", ""Other/meryl/1.3"")
+prepend_path(""PATH"", apphome)
+prepend_path(""R_LIBS"", apphome..""/lib/R"")
+setenv(""MERQURY"", apphome)
+__END__
+```
+
+### Example commands for running Merqury on Deigo
+
+```bash
+module load Other/merqury
+srun -p compute -c 128 --mem 500G -t 24:00:00 --pty \
+    merqury.sh <arguments>
+```
+
+## Peregrine
+
+- Home page: https://github.com/cschin/Peregrine
+- Source code: https://hub.docker.com/r/cschin/peregrine/tags
+
+### Installation on Deigo
+
+```bash
+module load singularity
+APP=peregrine
+VER=1.6.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $APPDIR
+cd $APPDIR
+singularity pull $APP.sif docker://cschin/$APP:$VER
+echo '#!/bin/sh' > $APP && echo ""echo yes | singularity run $APPDIR/$APP.sif asm \$*"" >> $APP && chmod +x $APP
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/cschin/Peregrine"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly"")
+whatis(""Description: ""..""Fast Genome Assembler Using SHIMMER Index."")
+
+-- Package settings
+depends_on(""singularity"")
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running Peregeine on Deigo
+
+The following command executes `$ pg_run.py asm` using the Singularity image:
+
+```bash
+module load Other/peregrine
+srun -p compute -c 128 --mem 500G -t 24:00:00 --pty \
+    peregrine.sif asm <arguments> 
+```
+
+For simplicity and to skip the interactive prompt message, we also provide a command `peregrine` that is effectively the same as above:
+
+```bash
+module load Other/peregrine
+srun -p compute -c 128 --mem 500G -t 24:00:00 --pty \
+    peregrine <arguments>
+```
+
+## IPA (Improved Phased Assembler)
+
+- Home page: https://github.com/PacificBiosciences/pbipa
+- Source code: https://anaconda.org/bioconda/pbipa
+
+IPA was installed with conda before and we had to remove the module for that reason.  Please let us know if you want IPA back.
+
+## DeepVariant
+
+- Home page: https://github.com/google/deepvariant
+- Source code: https://hub.docker.com/r/google/deepvariant/tags
+
+### Installation on Deigo
+
+```bash
+module load singularity
+APP=deepvariant
+VER=1.1.0
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $APPDIR
+cd $APPDIR
+singularity pull $APP.sif docker://google/$APP:$VER
+for CMD in run_deepvariant make_examples call_variants postprocess_variants; do echo '#!/bin/sh' > $CMD && echo ""singularity exec $APPDIR/$APP.sif $CMD \$*"" >> $CMD && chmod +x $CMD; done
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/google/deepvariant"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""variant call"")
+whatis(""Description: ""..""DeepVariant is an analysis pipeline that uses a deep neural network to call genetic variants from next-generation DNA sequencing data."")
+
+-- Package settings
+depends_on(""singularity"")
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running DeepVariant on Deigo
+
+The following command executes `$ run_deepvariant` using the Singularity image:
+
+```bash
+module load Other/deepvariant
+srun -p compute -c 128 --mem 500G -t 24:00:00 --pty \
+    deepvariant.sif <arguments> 
+```
+
+We also provide a command `run_deepvariant` that is effectively the same as above:
+
+```bash
+module load Other/deepvariant
+srun -p compute -c 128 --mem 500G -t 24:00:00 --pty \
+    run_deepvariant <arguments>
+```
+
+## arima_pipeline (ArimaGenomics Hi-C mapping pipeline)
+
+- Home page: https://github.com/ArimaGenomics/mapping_pipeline
+- Source code: https://github.com/ArimaGenomics/mapping_pipeline
+
+### Installation on Deigo
+
+```bash
+APP=arima_pipeline
+VER=2019.02.08
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/ArimaGenomics/mapping_pipeline
+mv mapping_pipeline $VER && cd $VER
+chmod +x *.pl
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/ArimaGenomics/mapping_pipeline"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""Hi-C, mapping"")
+whatis(""Description: ""..""Mapping pipeline for data generated using Arima-HiC."")
+
+-- Package settings
+depends_on(""samtools"", ""picard"", ""bwa"")
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running arima_pipeline on Deigo
+
+To load the module, run:
+
+```bash
+module load Other/arima_pipeline
+```
+
+Then, the following executables become available as commands:
+
+- `filter_five_end.pl`
+- `two_read_bam_combiner.pl`
+- `get_stats.pl`
+
+See the pipeline script ([01_mapping_arima.sh](https://github.com/ArimaGenomics/mapping_pipeline/blob/master/01_mapping_arima.sh)) written by the developer for details about how to use the Perl scripts.
+
+## SALSA
+
+- Home page: https://github.com/marbl/SALSA
+- Source code: https://github.com/marbl/SALSA/releases
+
+### Installation on Deigo
+
+```bash
+APP=SALSA
+VER=2.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/marbl/SALSA/archive/refs/tags/v$VER.tar.gz | tar xzvf -
+mv $APP-$VER $VER && cd $VER && make
+wget https://s3.amazonaws.com/hicfiles.tc4ga.com/public/juicer/juicer_tools_1.22.01.jar
+cat <<'__END__' > convert.sh
+#!/bin/bash
+JUICER_JAR=/bucket/BioinfoUgrp/Other/SALSA/2.3/juicer_tools_1.22.01.jar
+SALSA_OUT_DIR=$1
+
+samtools faidx ${SALSA_OUT_DIR}/scaffolds_FINAL.fasta
+cut -f 1,2 ${SALSA_OUT_DIR}/scaffolds_FINAL.fasta.fai > ${SALSA_OUT_DIR}/chromosome_sizes.tsv
+alignments2txt.py -b ${SALSA_OUT_DIR}/alignment_iteration_1.bed -a ${SALSA_OUT_DIR}/scaffolds_FINAL.agp -l ${SALSA_OUT_DIR}/scaffold_length_iteration_1 > ${SALSA_OUT_DIR}/alignments.txt
+awk '{if ($2 > $6) {print $1""\t""$6""\t""$7""\t""$8""\t""$5""\t""$2""\t""$3""\t""$4} else {print}}'  ${SALSA_OUT_DIR}/alignments.txt | sort -k2,2d -k6,6d -T $PWD --parallel=16 | awk 'NF'  > ${SALSA_OUT_DIR}/alignments_sorted.txt
+java -jar -Xmx500G ${JUICER_JAR} pre ${SALSA_OUT_DIR}/alignments_sorted.txt ${SALSA_OUT_DIR}/salsa_scaffolds.hic ${SALSA_OUT_DIR}/chromosome_sizes.tsv
+__END__
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/marbl/SALSA"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly, scaffolding"")
+whatis(""Description: ""..""SALSA: A tool to scaffold long read assemblies with Hi-C data."")
+
+-- Package settings
+depends_on(""python/2.7.18"", ""bedtools"")
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running SALSA on Deigo
+
+The main routine is executed as follows:
+
+```bash
+module load Other/SALSA
+srun -p compute -c 1 --mem 500G -t 48:00:00 --pty \
+    run_pipeline.py <arguments>
+```
+
+Some hard-coded values specific to the developers' environment in (`convert.sh`; see SALSA's README for what the script itself does) are replaced so that it works in our environment:
+
+```bash
+module load Other/SALSA
+srun -p compute -c 16 --mem 500G -t 48:00:00 --pty \
+    convert.sh <salsa-out-dir>
+```
+
+## Juicer
+
+- Home page: https://github.com/aidenlab/juicer
+- Source code: https://github.com/aidenlab/juicer/releases
+
+### Installation on Deigo
+
+NOTE: Only the ""CPU"" mode is installed, as the codes for HPCs are hard to use.
+
+```bash
+APP=juicer
+VER=1.6
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/aidenlab/juicer/archive/refs/tags/$VER.tar.gz | tar xzvf -
+mv $APP-$VER/CPU scripts && mv $APP-$VER/misc/* . && rm -rf scripts/README.md $APP-$VER
+sed -i 's|juiceDir=""/opt/juicer""|juiceDir="".""|' scripts/juicer.sh
+CMD=juicer_copy_scripts_dir
+echo '#!/bin/sh' > $CMD && echo ""ln -sf $APPDIR/scripts/ ."" >> $CMD
+chmod +x * scripts/common/*
+cd scripts/common && wget https://s3.amazonaws.com/hicfiles.tc4ga.com/public/juicer/juicer_tools_1.22.01.jar && ln -sf juicer_tools_1.22.01.jar juicer_tools.jar
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/aidenlab/juicer"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""Hi-C, scaffolding"")
+whatis(""Description: ""..""A One-Click System for Analyzing Loop-Resolution Hi-C Experiments."")
+
+-- Package settings
+depends_on(""java-jdk/14"", ""bwa"")
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running Juicer on Deigo
+
+Juicer (and other tools by Aiden lab) adopts a very unique approach to run programs. Read carefully e.g. [their wiki](https://github.com/aidenlab/juicer/wiki/Installation) to understand their assumptions.
+
+To copy the `scripts/` directory (of the CPU mode), we provide the following command:
+
+```bash
+module load Other/juicer
+juicer_copy_scripts_dir   # A symlink `scripts` will be generated in the current directory
+```
+
+Note that `scripts/common/juicer_tools.jar` is already downloaded and put in the appropriate directory in the module.
+Then, after creating some directories required, you will need to run the main shell script as follows:
+
+```bash
+module load Other/juicer
+srun -p compute -c 128 --mem 500G -t 48:00:00 --pty \
+    ./scripts/juicer.sh <arguments>
+```
+
+Note that the default path of the option `-D` is replaced from `/opt/juicer` to `.` (i.e. the directory you ran `juicer.sh`).
+
+## 3D-DNA
+
+- Home page: https://github.com/aidenlab/3d-dna
+- Source code: https://github.com/aidenlab/3d-dna
+
+### Installation on Deigo
+
+**IMPORTANT: Currently only the normal mode is supported by this module. That is, the diploid mode, phasing mode, etc. are NOT supported.**
+
+```bash
+APP=3d-dna
+VER=180922
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/aidenlab/3d-dna
+mv 3d-dna $VER && cd $VER
+ln -sf run-asm-pipeline.sh 3d-dna
+ln -sf run-asm-pipeline-post-review.sh 3d-dna-post-review
+cd visualize/ && ln -sf run-assembly-visualizer.sh 3d-dna-run-assembly-visualizer && cd ..
+CMD=3d-dna-fasta2assembly
+echo '#!/bin/sh' > $CMD && echo ""awk -f $APPDIR/$VER/utils/generate-assembly-file-from-fasta.awk \$*"" >> $CMD
+chmod +x *.sh */*.sh $CMD
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/aidenlab/3d-dna"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""Hi-C, scaffolding"")
+whatis(""Description: ""..""3D de novo assembly (3D DNA) pipeline."")
+
+-- Package settings
+depends_on(""bwa"", ""Other/bioawk"", ""Other/parallel"", ""Other/juicer"")
+prepend_path(""PATH"", apphome)
+prepend_path(""PATH"", apphome..""/visualize"")
+__END__
+```
+
+### Example commands for running 3D-DNA on Deigo
+
+3D-DNA (and other tools by Aiden lab) adopts a very unique approach to run programs. Read carefully e.g. [their manual](http://aidenlab.org/assembly/manual_180322.pdf) to understand their assumptions.
+
+By loading the module, the following main commands become available via `PATH`. Additionally, we provide alias names for these programs to make it easier to remember the commands:
+
+- `run-asm-pipeline.sh` (alias: `3d-dna`)
+- `run-asm-pipeline-post-review.sh` (alias: `3d-dna-post-review`)
+- `run-assembly-visualizer.sh` (alias: `3d-dna-run-assembly-visualizer`)
+
+These commands can be executed like this:
+
+```bash
+module load Other/3d-dna
+srun -p compute -c 128 --mem 500G -t 48:00:00 --pty \
+    run-asm-pipeline.sh <arguments>
+```
+
+or using their alias names:
+
+```bash
+module load Other/3d-dna
+srun -p compute -c 128 --mem 500G -t 48:00:00 --pty \
+    3d-dna <arguments>   # This is exactly same as the previous example
+```
+
+We also provide a command `3d-dna-fasta2assembly`, which is an alias of `$ awk -f /path/to/utils/generate-assembly-file-from-fasta.awk`. A usage example of this command is as follows:
+
+```bash
+module load Other/3d-dna
+srun -p compute -c 1 --mem 40G -t 1:00:00 --pty \
+    3d-dna-fasta2assembly ${YOUR_ASSEMBLY}.fasta > ${YOUR_ASSEMBLY}.assembly
+```
+
+## hic2cool
+
+- Home page: https://github.com/4dn-dcic/hic2cool
+- Source code: https://github.com/4dn-dcic/hic2cool/releases
+
+### Installation on Deigo
+
+```bash
+module load python/3.7.3
+APP=hic2cool
+VER=0.8.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/4dn-dcic/hic2cool/archive/refs/tags/$VER.tar.gz | tar xzvf -
+mv $APP-$VER $VER && cd $VER
+mkdir -p lib/python3.7/site-packages
+sed -i 's|    name = ""hic2cool"",|    name = ""hic2cool"",\n    zip_safe = False,|' setup.py
+PYTHONUSERBASE=$(pwd) python setup.py install --user
+PYTHONUSERBASE=$(pwd) pip install -r requirements.txt --force-reinstall --user
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/4dn-dcic/hic2cool"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""Hi-C"")
+whatis(""Description: ""..""Lightweight converter between hic and cool contact matrices."")
+
+-- Package settings
+depends_on(""python/3.7.3"")
+prepend_path(""PATH"", apphome..""/bin"")
+prepend_path(""PYTHONPATH"", apphome..""/lib/python3.7/site-packages"")
+__END__
+```
+
+### Example commands for running hic2cool on Deigo
+
+```bash
+module load Other/hic2cool
+srun -p compute -c 128 --mem 500G -t 12:00:00 --pty \
+    hic2cool <arguments>
+```
+
+
+## make_telomere_bed
+
+- Home page: https://github.com/yoshihikosuzuki/make_telomere_bed
+- Source code: https://github.com/yoshihikosuzuki/make_telomere_bed
+
+### Installation on Deigo
+
+```bash
+module load python/3.7.3
+APP=make_telomere_bed
+VER=2021.05.20
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/yoshihikosuzuki/make_telomere_bed
+mv make_telomere_bed $VER && cd $VER
+mkdir -p lib/python3.7/site-packages
+PYTHONUSERBASE=$(pwd) python setup.py install --user
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/yoshihikosuzuki/make_telomere_bed"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""telomere"")
+whatis(""Description: ""..""Make a .bed file for telomeres in a contig/scaffold file."")
+
+-- Package settings
+depends_on(""python/3.7.3"", ""Other/trf"")
+prepend_path(""PATH"", apphome..""/bin"")
+prepend_path(""PYTHONPATH"", apphome..""/lib/python3.7/site-packages"")
+__END__
+```
+
+### Example commands for running make_telomere_bed on Deigo
+
+```bash
+module load Other/make_telomere_bed
+srun -p compute -c 1 --mem 100G -t 12:00:00 --pty \
+    make_telomere_bed <arguments>
+```
+
+
+- Home page: https://github.com/thegenemyers/GENESCOPE.FK
+- Source code: https://github.com/thegenemyers/GENESCOPE.FK
+
+### Installation on Deigo
+
+```bash
+module load R/4.0.4
+APP=genescope
+VER=2021.03.26
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/thegenemyers/GENESCOPE.FK
+mv GENESCOPE.FK $VER && cd $VER
+mkdir -p lib/R && cat <<'__END__' > install.R
+local_lib_path = ""./lib/R""
+install.packages('minpack.lm', lib=local_lib_path)
+install.packages('argparse', lib=local_lib_path)
+install.packages('.', repos=NULL, type=""source"", lib=local_lib_path)
+__END__
+Rscript install.R
+Rscript -e 'install.packages(c(""R6"", ""jsonlite"", ""findpython""), lib=""./lib/R"")'
+sed -i 's|#!/usr/bin/env Rscript|#!/usr/bin/env -S Rscript --vanilla|' GeneScopeFK.R
+mkdir -p bin && mv GeneScopeFK.R bin/
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/thegenemyers/GENESCOPE.FK"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""sequencing"")
+whatis(""Description: ""..""A derivative of GenomeScope2.0 modified to work with FastK."")
+
+-- Package settings
+depends_on(""R/4.0.4"", ""Other/FASTK"")
+prepend_path(""PATH"", apphome..""/bin"")
+prepend_path(""R_LIBS"", apphome..""/lib/R"")
+__END__
+```
+
+### Example commands for running GeneScope on Deigo
+
+```bash
+module load Other/genescope
+srun -p compute -c 1 --mem 40G -t 1:00:00 --pty \
+    GeneScopeFK.R <arguments>
+```
+
+## KMC (for GenomeScope 2.0 and Smudgeplot)
+
+- Home page: https://github.com/tbenavi1/KMC
+- Source code: https://github.com/tbenavi1/KMC
+
+### Installation on Deigo
+
+```bash
+APP=KMC
+VER=genomescope
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/tbenavi1/KMC
+mv KMC $VER && cd $VER && make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/tbenavi1/KMC"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""k-mer counter"")
+whatis(""Description: ""..""Fast and frugal disk based k-mer counter (version for GenomeScope and Smudgeplot)."")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+### Example commands for running KMC (for GenomeScope/Smudgeplot) on Deigo
+
+To load the module, run:
+
+```bash
+module load Other/KMC/genomescope
+```
+
+Then, the following commands become available:
+
+- `kmc`
+- `kmc_dump`
+- `kmc_tools`
+- `smudge_pairs`
+
+Visit the [GitHub page](https://github.com/tbenavi1/KMC) for details about how to use the programs.
+
+## GenomeScope 2.0
+
+- Home page: https://github.com/tbenavi1/genomescope2.0
+- Source code: https://github.com/tbenavi1/genomescope2.0
+
+### Installation on Deigo
+
+```bash
+module load R/4.0.4
+APP=genomescope
+VER=2.0
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/tbenavi1/genomescope2.0
+mv genomescope2.0 $VER && cd $VER
+mkdir -p lib/R && sed -i 's|local_lib_path = ""~/R_libs/""|local_lib_path = ""./lib/R""|' install.R && Rscript install.R
+Rscript -e 'install.packages(c(""R6"", ""jsonlite"", ""findpython""), lib=""./lib/R"")'
+sed -i 's|#!/usr/bin/env Rscript|#!/usr/bin/env -S Rscript --vanilla|' genomescope.R
+mkdir -p bin && mv genomescope.R bin/
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/tbenavi1/genomescope2.0"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""sequencing"")
+whatis(""Description: ""..""Reference-free profiling of polyploid genomes."")
+
+-- Package settings
+depends_on(""R/4.0.4"", ""Other/KMC/genomescope"")
+prepend_path(""PATH"", apphome..""/bin"")
+prepend_path(""R_LIBS"", apphome..""/lib/R"")
+__END__
+```
+
+### Example commands for running GenomeScope 2.0 on Deigo
+
+```bash
+module load Other/genomescope/2.0
+srun -p compute -c 1 --mem 40G -t 1:00:00 --pty \
+    genomescope.R <arguments>
+```
+
+## Smudgeplot
+
+- Home page: https://github.com/KamilSJaron/smudgeplot
+- Source code: https://github.com/KamilSJaron/smudgeplot
+
+### Installation on Deigo
+
+```bash
+module load R/4.0.4
+APP=smudgeplot
+VER=0.2.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/KamilSJaron/smudgeplot
+mv smudgeplot $VER && cd $VER
+mkdir -p lib/R && Rscript -e 'install.packages(c(""devtools"",""argparse"",""R6"",""jsonlite"",""findpython"",""viridis""), lib=""./lib/R"")'
+sed -i '1ilocal_lib_path = ""./lib/R""' install.R && sed -i 's|install.packages(""."", repos = NULL, type=""source"")|install.packages(""."", repos = NULL, type=""source"", lib=local_lib_path)|' install.R
+R_LIBS=./lib/R Rscript install.R && unset R_LIBS
+sed -i 's|#!/usr/bin/env Rscript|#!/usr/bin/env -S Rscript --vanilla|' exec/smudgeplot_plot.R
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/KamilSJaron/smudgeplot"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""qc, sequencing"")
+whatis(""Description: ""..""Inference of ploidy and heterozygosity structure using whole genome sequencing data."")
+
+-- Package settings
+depends_on(""R/4.0.4"", ""Other/KMC/genomescope"", ""Other/genomescope/2.0"")
+prepend_path(""PATH"", apphome..""/exec"")
+prepend_path(""R_LIBS"", apphome..""/lib/R"")
+__END__
+```
+
+### Example commands for running Smudgeplot on Deigo
+
+```bash
+module load Other/smudeplot
+srun -p compute -c 1 --mem 100G -t 24:00:00 --pty \
+    smudgeplot.py <arguments>
+```
+
+## iqtree2
+- Home page: http://www.iqtree.org
+- Source code: https://github.com/iqtree/iqtree2/releases
+
+### Installation on Deigo
+
+```bash
+DIS=iqtree2
+APP=iqtree
+VER=2.2.0
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/iqtree/iqtree2/archive/refs/tags/v2.2.0.tar.gz | tar xzvf -
+mv $DIS-$VER $VER
+cd $VER && mkdir build && cd build
+cmake ..
+make -j
+cd $MODROOT/$APP/$VER
+mkdir -p bin
+cd bin
+ln -s $MODROOT/$APP/$VER/build/iqtree2 .
+ln -s iqtree2 iqtree
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""http://www.iqtree.org"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""iqtree"")
+whatis(""Description: ""..""A fast and effective stochastic algorithm to infer phylogenetic trees by maximum likelihood"")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+```bash
+DIS=iqtree2
+APP=iqtree
+VER=2.2.2.5
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+## getting submodules for dating
+# https://github.com/Cibiv/IQ-TREE/issues/151
+# https://github.com/Cibiv/IQ-TREE/issues/151
+# Submodule 'lsd2' (https://github.com/tothuhien/lsd2.git) registered for path 'lsd2'
+# git checkout latest #VER=2.2.2.6
+# git submodule init 
+# git submodule update
+### leads to compiling errors
+# /bucket/BioinfoUgrp/Other/iqtree/2.2.2.6/alignment/superalignment.cpp:28:10: erreur fatale: boost/container_hash/hash.hpp : Aucun fichier ou dossier de ce type
+# /bucket/BioinfoUgrp/Other/iqtree/2.2.2.6/alignment/alignment.cpp:24:10: erreur fatale: boost/container_hash/hash.hpp : Aucun fichier ou dossier de ce type
+## switch to older distrib
+wget -O - https://github.com/iqtree/iqtree2/archive/refs/tags/v2.2.2.5.tar.gz | tar xzvf -
+mv $DIS-$VER $VER && cd $VER
+git clone https://github.com/tothuhien/lsd2
+mkdir build && cd build
+## enabling dating
+cmake -DUSE_LSD2=ON ..
+make -j
+cd $MODROOT/$APP/$VER
+mkdir -p bin
+cd bin
+ln -s $MODROOT/$APP/$VER/build/iqtree2 .
+ln -s iqtree2 iqtree
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""http://www.iqtree.org"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""iqtree"")
+whatis(""Description: ""..""A fast and effective stochastic algorithm to infer phylogenetic trees by maximum likelihood"")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+## FastTree
+- Home page: http://www.microbesonline.org/fasttree/
+- Source code: http://www.microbesonline.org/fasttree/#Install
+
+### Installation on Deigo
+
+```bash
+APP=fasttree
+VER=2.1.11
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR/$VER/bin
+cd $APPDIR/$VER/bin
+wget -O - http://www.microbesonline.org/fasttree/FastTreeMP > fasttree
+chmod a+x fasttree
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""http://www.microbesonline.org/fasttree/"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""fasttree"")
+whatis(""Description: ""..""FastTree infers approximately-maximum-likelihood phylogenetic trees from alignments of nucleotide or protein sequences."")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+## bcftools
+- Home page: http://www.htslib.org
+- Source code: https://github.com/samtools/bcftools/releases/download/1.15.1/bcftools-1.15.1.tar.bz2
+
+### Installation on Deigo
+```bash
+APP=bcftools
+VER=1.15.1
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/samtools/bcftools/releases/download/1.15.1/bcftools-1.15.1.tar.bz2 | tar xjvf -
+mv $APP-$VER $VER
+cd $VER
+./configure --prefix=$APPDIR/$VER && make && make install
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""http://www.htslib.org"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""bcftools"")
+whatis(""Description: ""..""contains all the vcf* commands which previously lived in the htslib repository (such as vcfcheck, vcfmerge, vcfisec, etc.) and the samtools BCF calling from bcftools subdirectory of samtools."")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+## prokka
+- Home page: https://github.com/tseemann/prokka
+- Source code: https://hub.docker.com/r/staphb/prokka
+
+### Installation on Deigo
+```bash
+module load singularity
+APP=prokka
+VER=1.14.5
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $APPDIR
+cd $APPDIR
+singularity build prokka.sif docker://staphb/prokka:${VER}
+echo '#!/bin/sh' > prokka && echo ""singularity exec $APPDIR/prokka.sif prokka \$*"" >> prokka && chmod +x prokka
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://hub.docker.com/r/staphb/prokka"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""annotation"")
+whatis(""Description: ""..""rapid prokaryotic genome annotation"")
+
+-- Package settings
+depends_on(""singularity"")
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+## BEAST1
+- Home page: https://beast.community/index.html
+- Source code: https://github.com/beast-dev/beast-mcmc/releases/download/v1.10.4/BEASTv1.10.4.tgz
+
+### Installation on Deigo
+```bash
+APP=BEAST
+VER=1.10.4
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/beast-dev/beast-mcmc/releases/download/v1.10.4/BEASTv1.10.4.tgz | tar xzvf -
+mv ${APP}v${VER} $VER
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER
+#%Module1.0##################################################################
+set approot    [lrange [split [module-info name] {/}] 0 0]
+set appname    [lrange [split [module-info name] {/}] 1 1]
+set appversion [lrange [split [module-info name] {/}] 2 2]
+set apphome    /bucket/BioinfoUgrp/$approot/$appname/$appversion
+
+## URL of application homepage:
+set appurl     https://beast.community
+
+## Short description of package:
+module-whatis  ""BEAST is a cross-platform program for Bayesian analysis of molecular sequences using MCMC.""
+
+## Load any needed modules:
+module load java-jdk/1.8.0_20
+module load beagle/3.1.2
+
+## Modify as needed, removing any variables not needed.
+## Non-path variables can be set with ""setenv VARIABLE value""
+prepend-path    PATH            $apphome
+prepend-path    PATH            $apphome/bin
+setenv			JAVA_HOME		/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.252.b09-2.el8_1.x86_64
+setenv			JRE_HOME		/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.252.b09-2.el8_1.x86_64/jre
+__END__
+```
+
+## mugsy
+- Home page: https://mugsy.sourceforge.net
+- Source code: https://sourceforge.net/projects/mugsy/files/
+
+### Installation on Deigo
+```
+APP=mugsy
+VER=1r2.2
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://sourceforge.net/projects/mugsy/files/${APP}_x86-64-v${VER}.tgz | tar xzvf - && mv ${APP}_x86-64-v${VER} ${VER} && cd ${VER}
+sed -i 's/export MUGSY_INSTALL/#export MUGSY_INSTALL/g' mugsyenv.sh
+echo ""export MUGSY_INSTALL=$PWD"" >> mugsyenv.sh
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER
+#%Module1.0##################################################################
+set approot    [lrange [split [module-info name] {/}] 0 0]
+set appname    [lrange [split [module-info name] {/}] 1 1]
+set appversion [lrange [split [module-info name] {/}] 2 2]
+set apphome    /bucket/BioinfoUgrp/$approot/$appname/$appversion
+
+## URL of application homepage:
+set appurl     https://mugsy.sourceforge.net
+
+## Short description of package:
+module-whatis  ""Mugsy is a multiple whole genome aligner.""
+
+## Load any needed modules:
+
+## Modify as needed, removing any variables not needed.
+## Non-path variables can be set with ""setenv VARIABLE value""
+prepend-path    PATH            $apphome
+prepend-path    PATH            $apphome/MUMmer3.20
+eval [exec /usr/bin/env -i /usr/share/Modules/bin/createmodule.sh $apphome/mugsyenv.sh]
+__END__
+```
+
+## TCSF_IMRA
+- Home page: https://github.com/Yukihirokinjo/TCSF_IMRA
+
+### Installation on Deigo
+```
+APP=TCSF_IMRA
+VER=2.7.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/Yukihirokinjo/TCSF_IMRA.git
+mv $APP $VER && cd $VER
+chmod u+x *.bash
+chmod u+x *.R
+echo '#!/bin/sh' > tcsf && echo ""TCSF-$VER.bash \$*"" >> tcsf && chmod +x tcsf
+echo '#!/bin/sh' > imra && echo ""IMRA-$VER.bash \$*"" >> imra && chmod +x imra
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/Yukihirokinjo/TCSF_IMRA"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""TCSF_IMRA"")
+whatis(""Description: ""..""tools developed for improving de novo assembly of endosymbiont genomes"")
+
+-- Package settings
+depends_on(""seqtk/1.3"", ""R/4.2.1"", ""ncbi-blast/2.10.0+"", ""bowtie2/2.2.6"", ""samtools/1.12"", ""SPAdes/3.13.0"", ""idba/1.1.3-7"")
+prepend_path(""PATH"", apphome, apphome..""/Rlib"")
+setenv(""TCSF_IMRA"", apphome)
+__END__
+```
+
+## InterProScan
+- Home page: https://interproscan-docs.readthedocs.io/en/v5/
+- Source code: 
+
+### Installation on Deigo
+```bash
+APP=interproscan
+VER=5.76-107.0
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget https://ftp.ebi.ac.uk/pub/software/unix/iprscan/5/${VER}/interproscan-${VER}-64-bit.tar.gz
+wget https://ftp.ebi.ac.uk/pub/software/unix/iprscan/5/${VER}/interproscan-${VER}-64-bit.tar.gz.md5
+md5sum -c interproscan-${VER}-64-bit.tar.gz.md5
+tar -pxvzf interproscan-${VER}-64-bit.tar.gz
+chmod -R g+w interproscan-${VER}
+mv interproscan-${VER} ${VER}
+cd ${VER}
+python3 setup.py -f interproscan.properties
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://interproscan-docs.readthedocs.io/en/v5/"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""InterPro"")
+whatis(""Description: "".."" InterproScan to run the scanning algorithms from the InterPro database in an integrated way."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+if os.getenv(""IPRDIR"") then
+    prepend_path(""IPRDIR"", apphome)
+else
+    setenv(""IPRDIR"", apphome)
+end
+
+-- Load dependencies
+-- begin ChatGPT
+-- Load dependencies (Ensure at least one version is loaded)
+local python_versions = {""python/3.11.4"", ""python/3.10.2""}
+local java_versions = {""java-jdk/21"", ""java-jdk/17"", ""java-jdk/14"", ""java-jdk/11""}
+
+local function ensure_one_loaded(versions)
+    for _, v in ipairs(versions) do
+        if isloaded(v) then
+            return  -- If one is already loaded, no need to load another
+        end
+    end
+    depends_on(versions[1])  -- Load the first option if none are loaded
+end
+
+ensure_one_loaded(python_versions)
+ensure_one_loaded(java_versions)
+-- end ChatGPT
+
+-- Display note when the module is loaded
+if (mode() == ""load"") then
+    LmodMessage([[
+An environment variable ""IPRDIR"" has been set to the InterProScan directory.
+InterProScan software has been installed.
+
+USAGE EXAMPLE:
+  ${IPRDIR}/interproscan.sh -i input.fasta --output-file-base IPRresult -cpu 4
+]])
+end
+__END__
+```
+
+## RAxML NG (RAxML Next Generation MPI)
+- Home page: https://github.com/amkozlov/raxml-ng/
+- Source code: https://github.com/amkozlov/raxml-ng/releases/download/1.2.0/raxml-ng_v1.2.0_linux_x86_64_MPI.zip
+
+### Installation on Deigo
+```
+APP=raxml-ng-mpi
+VER=1.2.0
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+mkdir -p $APPDIR/$VER
+cd $APPDIR/$VER
+wget -O - https://github.com/amkozlov/raxml-ng/releases/download/1.2.0/raxml-ng_v1.2.0_linux_x86_64_MPI.zip > $APP-$VER.zip && unzip $APP-$VER.zip && rm $APP-$VER.zip
+sh install.sh
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/amkozlov/raxml-ng"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""raxml-ng"")
+whatis(""Description: ""..""RAxML-NG is a phylogenetic tree inference tool which uses maximum-likelihood (ML) optimality criterion"")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+## PAML
+- Home page: http://abacus.gene.ucl.ac.uk/software/#paml-for-unixlinux
+- Source code: https://github.com/abacus-gene/paml
+
+### Installation on Deigo
+```
+APP=paml
+VER=4.10.6
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/abacus-gene/paml # this reads as version 4.9j on GitHub, which prints out as 4.10.6 when executed
+mv $APP $VER && cd $VER/src
+## allow higher number of taxa in some programs
+sed -i ""s/#define NS            500/#define NS            5000/g"" mcmctree.c
+sed -i ""s/#define NS            1000/#define NS            5000/g"" yn00.c
+sed -i ""s/#define NS          10/#define NS          5000/g"" basemlg.c
+## compile
+make -f Makefile
+rm *.o
+mkdir ../bin
+mv baseml basemlg chi2 codeml evolver infinitesites mcmctree pamp yn00 ../bin
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/abacus-gene/paml"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""PAML"")
+whatis(""Description: ""..""PAML is a program package for model fitting and phylogenetic tree reconstruction using DNA and protein sequence data. The programs are written in ANSI C"")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+## PHYLUCE
+- Home page: https://phyluce.readthedocs.io/en/latest/
+- Source code: https://phyluce.readthedocs.io/en/latest/installation.html
+- - Note: switched to miniforge installation on 2024/12/11
+
+### Installation on Deigo
+```
+APP=phyluce
+VER=1.7.3
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+curl -L -O ""https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh""
+bash Miniforge3-$(uname)-$(uname -m).sh -b -p $APPDIR/$VER && rm Miniforge3-$(uname)-$(uname -m).sh && cd $VER
+source ./bin/activate
+./bin/mamba env create -p $MODROOT/$APP/$VER/envs/phyluce-1.7.3 --file=https://raw.githubusercontent.com/faircloth-lab/phyluce/v1.7.3/distrib/phyluce-1.7.3-py36-Linux-conda.yml
+### modulefile
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER
+#%Module1.0##################################################################
+set approot    [lrange [split [module-info name] {/}] 0 0]
+set appname    [lrange [split [module-info name] {/}] 1 1]
+set appversion [lrange [split [module-info name] {/}] 2 2]
+set apphome    /bucket/BioinfoUgrp/$approot/$appname/$appversion
+
+## URL of application homepage:
+set appurl     https://phyluce.readthedocs.io/en/latest/index.html
+
+## Short description of package:
+module-whatis  ""Phyluce installed using Miniforge3.""
+
+## Load any needed modules:
+
+## Modify as needed, removing any variables not needed.
+## Non-path variables can be set with ""setenv VARIABLE value""
+prepend-path    PATH            $apphome/bin
+prepend-path    PATH            $apphome/envs/phyluce-1.7.3
+prepend-path    PATH            $apphome/envs/phyluce-1.7.3/bin
+prepend-path    PATH $apphome/lib
+prepend-path    PYTHONPATH	$apphome/bin
+__END__
+
+```
+
+## VeryFastTree
+- Home page: https://github.com/citiususc/veryfasttree
+
+### Installation on Deigo
+
+```bash
+APP=veryfasttree
+VER=4.0.2
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR/ && cd $APPDIR/
+git clone https://github.com/citiususc/veryfasttree
+mv veryfasttree $VER && cd $VER/
+cmake -DINSTALL_DIR:PATH=$APPDIR/$VER
+make
+chmod a+x VeryFastTree
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/citiususc/veryfasttree"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""veryfasttree"")
+whatis(""Description: ""..""VeryFastTree is a new tool designed for efficient phylogenetic tree inference, specifically tailored to handle massive taxonomic datasets."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+## phyloflash
+- Home page: http://hrgv.github.io/phyloFlash/
+- Note: switched to miniforge installation on 2024/12/12
+### Installation on Deigo
+```bash
+APP=phyloflash
+VER=3.4.2
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+curl -L -O ""https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh""
+bash Miniforge3-$(uname)-$(uname -m).sh -b -p $APPDIR/$VER && rm Miniforge3-$(uname)-$(uname -m).sh && cd $VER
+source ./bin/activate
+# add the channel to the configuration for the active environment
+# https://stackoverflow.com/questions/40616381/can-i-add-a-channel-to-a-specific-conda-environment
+./bin/conda config --env --add channels defaults
+./bin/conda config --env --add channels bioconda
+./bin/conda config --env --add channels conda-forge
+# Create new environment named ""pf"" with phyloflash
+#./bin/mamba env create -p $MODROOT/$APP/$VER/envs/pf $APP #### needs yml file
+./bin/conda create -n pf $APP
+# ./bin/conda activate $MODROOT/$APP/$VER/envs/pf #### CondaError: Run 'conda init' before 'conda activate'
+# export PATH=$MODROOT/$APP/$VER/envs/pf/bin:$PATH
+# ./envs/pf/bin/phyloFlash.pl -check_env
+### modulefile
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""http://hrgv.github.io/phyloFlash/"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""rRNA, phylogeny, illumina, transcriptome"")
+whatis(""Description: ""..""phyloFlash is a pipeline to rapidly reconstruct the SSU rRNAs and explore phylogenetic composition of an Illumina (meta)genomic or transcriptomic dataset."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+prepend_path(""PATH"", apphome..""/envs/pf"")
+prepend_path(""PATH"", apphome..""/envs/pf/bin"")
+__END__
+```
+
+
+## QIIME2-amplicon
+- Home page: https://github.com/qiime2/qiime2
+- Installation: https://docs.qiime2.org/2024.5/install/native/#miniconda
+- Note: switched to miniforge installation on 2024/12/12
+
+### Installation on Deigo
+```bash
+APP=qiime2-amplicon
+VER=2024.5
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+curl -L -O ""https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh""
+bash Miniforge3-$(uname)-$(uname -m).sh -b -p $APPDIR/$VER && rm Miniforge3-$(uname)-$(uname -m).sh && cd $VER
+source ./bin/activate
+./bin/mamba env create -p $MODROOT/$APP/$VER/envs/$APP-$VER --file=https://data.qiime2.org/distro/amplicon/qiime2-amplicon-2024.5-py39-linux-conda.yml
+# conda activate /bucket/BioinfoUgrp/Other/qiime2-amplicon/2024.5/envs/qiime2-amplicon-2024.5
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/qiime2/qiime2"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""DNA, amplicon, metagenome"")
+whatis(""Description: ""..""QIIME 2 is a powerful, extensible, and decentralized microbiome bioinformatics platform that is free, open source, and community developed."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+prepend_path(""PATH"", apphome..""/envs/qiime2-amplicon-2024.5"")
+prepend_path(""PATH"", apphome..""/envs/qiime2-amplicon-2024.5/bin"")
+__END__
+```
+
+## BAMM
+- Home page: https://github.com/macroevolution/bamm
+- Installation: https://github.com/macroevolution/bamm
+
+### Installation on Deigo
+```bash
+APP=bamm
+VER=2.5
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR/$VER
+cd $APPDIR
+git clone https://github.com/macroevolution/bamm
+mv $APP $VER
+cd $VER
+# compile
+mkdir build
+cd build
+cmake ..
+make -j
+cd $MODROOT/$APP/$VER
+mkdir -p bin
+cd bin
+ln -s $MODROOT/$APP/$VER/build/bamm .
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/macroevolution/bamm"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""bamm"")
+whatis(""Description: ""..""A program for multimodel inference on speciation and trait evolution."")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+","Markdown"
+"AlphaFold","oist/BioinfoUgrp","Other/Repeats.md",".md","5088","188","# A collection of general bioinformatics modules
+
+To use the modules, load the `bioinfo-ugrp-modules` metamodule first.
+
+```bash
+ml bioinfo-ugrp-modules
+ml av Other
+ml Other/<your-favorite-module>
+```
+
+Here are installation snippets to help the members of the bioinfo user group to update the modules.
+
+## DfamTEBrowser
+
+```
+APP=DfamTEBrowser
+VER=1.0.0
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget https://github.com/Dfam-consortium/DfamTEBrowser/archive/refs/tags/${VER}.tar.gz
+tar xvfz ${VER}.tar.gz
+mv DfamTEBrowser-$VER $VER
+rm ${VER}.tar.gz
+cd ${VER}/Libraries
+ln -s /bucket/.deigo/BioinfoUgrp/DB/Dfam/3.9/RepeatPeps.lib
+ln -s /bucket/.deigo/BioinfoUgrp/DB/Dfam/3.9/Dfam-RepeatMasker.lib Dfam-curated.fa
+/bucket/BioinfoUgrp/Other/TETools/1.95/bin/makeblastdb -in /bucket/BioinfoUgrp/Other/DfamTEBrowser/1.0.0/Libraries/Dfam-curated.fa -dbtype nucl
+/bucket/BioinfoUgrp/Other/TETools/1.95/bin/makeblastdb -in /bucket/BioinfoUgrp/Other/DfamTEBrowser/1.0.0/Libraries/RepeatPeps.lib  -dbtype prot
+```
+
+### Module file template
+
+```
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/Dfam-consortium/DfamTEBrowser"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""Dfam, RepeatMasker, RepeatModeller"")
+whatis(""Description: ""..""Dfam Transposable Element Family Genome Browser"")
+
+-- Package settings
+depends_on(""Other/TETools"", ""Other/ULTRA"")
+prepend_path(""PATH"", apphome)
+```
+
+## TETools
+
+Downloaded singularity image from <https://github.com/Dfam-consortium/TETools>:
+
+```
+APP=TETools
+VER=1.95
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR/$VER/bin
+cd $APPDIR/$VER
+singularity pull docker://dfam/tetools:$VER
+CMDS=""BuildDatabase calcDivergenceFromAlign.pl createRepeatLandscape.pl famdb.py generateSeedAlignments.pl RepeatMasker RepeatModeler rmblastn makeblastdb blastx""
+for cmd in $CMDS; do
+  cat > ""bin/$cmd"" <<EOF
+#!/bin/sh
+VER=${VER}
+COMMAND=${cmd}
+LC_ALL=C singularity exec /bucket/.deigo/BioinfoUgrp/Other/TETools/\${VER}/tetools_\${VER}.sif \$COMMAND ""\$@""
+EOF
+  chmod +x ""bin/$cmd""
+done
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cd $APP
+cp 1.94.lua ${VER}.lua
+```
+
+### Module file template
+
+```
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/Dfam-consortium/TETools"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""Dfam, RepeatMasker, RepeatModeller"")
+whatis(""Description: ""..""Dfam Transposable Element Tools Container."")
+
+-- Package settings
+depends_on(""singularity"")
+prepend_path(""PATH"", apphome..""/bin"")
+```
+
+## Tandem Repeat Finder (TRF)
+
+- Home page: https://github.com/Benson-Genomics-Lab/TRF
+- Source code: https://github.com/Benson-Genomics-Lab/TRF/releases
+
+### Installation on Deigo
+
+```bash
+APP=trf
+VER=4.09.1
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $APPDIR
+cd $APPDIR
+wget https://github.com/Benson-Genomics-Lab/TRF/releases/download/v$VER/trf409.linux64 && mv trf409.linux64 $APP && chmod +x $APP
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/Benson-Genomics-Lab/TRF"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""DNA, repeat"")
+whatis(""Description: ""..""Tandem Repeats Finder: a program to analyze DNA sequences."")
+
+-- Package settings
+prepend_path(""PATH"", apphome.."""")
+__END__
+```
+
+### Example commands for running Tandem Repeat Finder on Deigo
+
+```bash
+module load Other/trf
+srun -p compute -c 1 --mem 40G -t 10:00:00 --pty \
+    trf <arguments>
+```
+
+## ULTRA
+
+```
+APP=ULTRA
+VER=1.2.1
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/TravisWheelerLab/ULTRA $VER
+cd $VER
+git checkout $VER
+cmake .
+make
+cd $MODROOT/modulefiles/$APP
+cp 1.2.1.lua ${VER}.lua
+```
+
+### Module file template
+
+```
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/TravisWheelerLab/ULTRA"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""DNA, repeat"")
+whatis(""Description: ""..""ULTRA Locates Tandemly Repetitive Areas"")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+```
+","Markdown"
+"AlphaFold","oist/BioinfoUgrp","Other/Alignment.md",".md","14530","559","# A collection of general bioinformatics modules
+
+To use the modules, load the `bioinfo-ugrp-modules` metamodule first.
+
+```bash
+ml bioinfo-ugrp-modules
+ml av Other
+ml Other/<your-favorite-module>
+```
+
+Here are installation snippets to help the members of the bioinfo user group to update the modules.
+
+## BWA
+
+- Home page: https://github.com/lh3/bwa
+- Source code: https://github.com/lh3/bwa
+
+### Installation on Deigo
+
+```bash
+APP=bwa
+VER=0.7.17
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/lh3/bwa/releases/download/v0.7.17/bwa-0.7.17.tar.bz2 | tar xjvf -
+mv $APP-$VER $VER
+cd $VER
+make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/lh3/bwa"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""bwa"")
+whatis(""Description: ""..""BWA is a software package for mapping DNA sequences against a large reference genome, such as the human genome."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running bwa on Deigo
+
+```bash
+module load Other/bwa
+srun -p compute -c 128 --mem 100G -t 1:00:00 --pty \
+    bwa mem <arguments>
+```
+
+
+## samblaster
+
+- Home page: https://academic.oup.com/bioinformatics/article/30/17/2503/2748175
+- Source code: https://github.com/GregoryFaust/samblaster
+
+### Installation on Deigo
+
+```bash
+APP=samblaster
+VER=0.1.26
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/GregoryFaust/samblaster/releases/download/v.0.1.26/samblaster-v.0.1.26.tar.gz | tar xzvf -
+mv $APP-v.$VER $VER
+cd $VER && make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/GregoryFaust/samblaster"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""samblaster"")
+whatis(""Description: ""..""samblaster is a fast and flexible program for marking duplicates in read-id grouped paired-end SAM files"")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running samblaster on Deigo
+
+```bash
+module load Other/samblaster
+srun -p compute -c 1 --mem 40G -t 1:00:00 --pty \
+    bwa mem <idxbase> samp.r1.fq samp.r2.fq | samblaster | samtools view -Sb - > samp.out.bam
+```
+
+## hal
+
+ - Homepage: https://github.com/ComparativeGenomicsToolkit/hal
+ - Source code: https://github.com/ComparativeGenomicsToolkit/hal/releases
+
+### Installation on Deigo
+
+```bash
+APP=hal
+VER=2.2
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR/${VER}
+cd $APPDIR/${VER}
+wget https://github.com/ComparativeGenomicsToolkit/hal/archive/refs/tags/release-V${VER}.tar.gz
+tar xvfz release-V${VER}.tar.gz
+git clone https://github.com/ComparativeGenomicsToolkit/sonLib.git
+pushd sonLib
+git checkout a4d45c46c6b9ee580fbac89db10894bac8844fd9 # As of January 23 2023
+make
+popd
+cd hal-release-V${VER}
+make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/ComparativeGenomicsToolkit/hal"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""hal, assembly, cactus"")
+whatis(""Description: ""..""Tools for manipulating sequence graphs in the HAL formats."")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/hal-release-V""..appversion..""/bin"")
+__END__
+```
+
+## k8 (Javascript shell)
+
+- Home page: https://github.com/attractivechaos/k8
+- Source code: https://github.com/attractivechaos/k8/releases
+
+This module is installed just to satisfy the requirements by paftools.js in the minimap2 module.
+
+### Installation on Deigo
+
+```bash
+APP=k8
+VER=0.2.5
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/attractivechaos/k8/releases/download/$VER/$APP-$VER.tar.bz2 | tar xjvf -
+mv $APP-$VER $VER && cd $VER
+ln -sf k8-Linux k8
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/attractivechaos/k8"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""javascript"")
+whatis(""Description: ""..""k8 Javascript shell."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running minimap2 on Deigo
+
+```bash
+module load Other/k8
+srun -p compute -c 1 --mem 40G -t 10:00:00 --pty \
+    k8 <arguments>
+```
+
+## minimap2
+
+- Home page: https://github.com/lh3/minimap2
+- Source code: https://github.com/lh3/minimap2/releases
+
+### Installation on Deigo
+
+```bash
+APP=minimap2
+VER=2.20
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/lh3/minimap2/archive/refs/tags/v$VER.tar.gz | tar xzvf -
+mv $APP-$VER $VER
+cd $VER && make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/lh3/minimap2"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""alignment"")
+whatis(""Description: ""..""A versatile pairwise aligner for genomic and spliced nucleotide sequences."")
+
+-- Package settings
+depends_on(""Other/k8"")
+prepend_path(""PATH"", apphome)
+prepend_path(""PATH"", apphome..""/misc"")
+__END__
+```
+
+### Example commands for running minimap2 on Deigo
+
+```bash
+module load Other/minimap2
+srun -p compute -c 64 --mem 500G -t 24:00:00 --pty \
+    minimap2 <arguments>
+```
+
+The `paftools.js` command is also available:
+
+```bash
+module load Other/minimap2
+srun -p compute -c 1 --mem 100G -t 24:00:00 --pty \
+    paftools.js <arguments>
+```
+
+## winnowmap
+
+- Home page: https://github.com/marbl/Winnowmap
+- Source code: https://github.com/marbl/Winnowmap/releases
+
+### Installation on Deigo
+
+```bash
+APP=winnowmap
+VER=2.03
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/marbl/Winnowmap/archive/refs/tags/v$VER.tar.gz | tar xzvf -
+mv Winnowmap-$VER $VER
+cd $VER && make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/marbl/Winnowmap"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""alignment"")
+whatis(""Description: ""..""Long read / genome alignment software"")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+### Example commands for running winnowmap on Deigo
+
+```bash
+module load Other/winnowmap
+srun -p compute -c 64 --mem 500G -t 24:00:00 --pty \
+    winnowmap <arguments>
+```
+
+
+## DAZZ_DB
+
+- Home page: https://github.com/thegenemyers/DAZZ_DB
+- Source code: https://github.com/thegenemyers/DAZZ_DB
+
+### Installation on Deigo
+
+```bash
+APP=DAZZ_DB
+VER=2021.03.30
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/thegenemyers/DAZZ_DB
+mv DAZZ_DB $VER && cd $VER && make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/thegenemyers/DAZZ_DB"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""assembly, sequencing"")
+whatis(""Description: ""..""The Dazzler Data Base."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running DAZZ_DB on Deigo
+
+To load the module, run:
+
+```bash
+module load Other/DAZZ_DB
+```
+
+Then the following commands become available:
+
+- `arrow2DB`
+- `Catrack`
+- `DAM2fasta`
+- `DB2arrow`
+- `DB2fasta`
+- `DB2quiva`
+- `DBa2b`
+- `DBb2a`
+- `DBdump`
+- `DBdust`
+- `DBmv`
+- `DBrm`
+- `DBshow`
+- `DBsplit`
+- `DBstats`
+- `DBtrim`
+- `DBwipe`
+- `fasta2DAM`
+- `fasta2DB`
+- `quiva2DB`
+- `rangen`
+- `simulator`
+
+See the [README](https://github.com/thegenemyers/DAZZ_DB) written by the developer for details about how to use the programs.
+
+## FASTK
+
+- Home page: https://github.com/thegenemyers/FASTK
+- Source code: https://github.com/thegenemyers/FASTK
+
+### Installation on Deigo
+
+```bash
+APP=FASTK
+VER=2021.05.27
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+git clone https://github.com/thegenemyers/FASTK
+mv FASTK $VER && cd $VER && make
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/thegenemyers/FASTK"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""k-mer counter"")
+whatis(""Description: ""..""A fast K-mer counter for high-fidelity shotgun datasets."")
+
+-- Package settings
+prepend_path(""PATH"", apphome)
+__END__
+```
+
+### Example commands for running FASTK on Deigo
+
+To load the module, run:
+
+```bash
+module load Other/FASTK
+```
+
+Then the following commands become available:
+
+- `Fastcp`
+- `FastK`
+- `Fastmv`
+- `Fastrm`
+- `Haplex`
+- `Histex`
+- `Homex`
+- `Logex`
+- `Profex`
+- `Symmex`
+- `Tabex`
+- `Vennex`
+
+See the [README](https://github.com/thegenemyers/FASTK) written by the developer for details about how to use the programs.
+
+
+## SAMtools
+- Home page: http://www.htslib.org
+- Source code: https://github.com/samtools/samtools/releases/download/1.15.1/samtools-1.15.1.tar.bz2
+
+### Installation on Deigo
+```bash
+APP=samtools
+VER=1.15.1
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+cd $APPDIR
+wget -O - https://github.com/samtools/samtools/releases/download/1.15.1/samtools-1.15.1.tar.bz2 | tar xjvf -
+mv $APP-$VER $VER
+cd $VER
+./configure --prefix=$APPDIR/$VER && make && make install
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""http://www.htslib.org"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""samtools"")
+whatis(""Description: ""..""mpileup and other tools for handling SAM, BAM, CRAM."")
+
+-- Package settings
+prepend_path(""PATH"", apphome..""/bin"")
+__END__
+```
+
+
+## DIAMOND
+- Home page: https://github.com/bbuchfink/diamond
+- Source code: https://github.com/bbuchfink/diamond/releases/download/v2.0.15/diamond-linux64.tar.gz
+
+### Installation on Deigo
+```bash
+APP=DIAMOND
+VER=2.0.15.153
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP
+mkdir -p $APPDIR
+mkdir $VER
+cd $APPDIR/$VER
+wget -O - https://github.com/bbuchfink/diamond/releases/download/v2.0.15/diamond-linux64.tar.gz | tar xzvf -
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER
+#%Module1.0##################################################################
+set approot    [lrange [split [module-info name] {/}] 0 0]
+set appname    [lrange [split [module-info name] {/}] 1 1]
+set appversion [lrange [split [module-info name] {/}] 2 2]
+set apphome    /bucket/BioinfoUgrp/$approot/$appname/$appversion
+
+## URL of application homepage:
+set appurl     https://github.com/bbuchfink/diamond
+
+## Short description of package:
+module-whatis  ""DIAMOND is a sequence aligner for protein and translated DNA searches, designed for high performance analysis of big sequence data.""
+
+## Load any needed modules:
+
+## Modify as needed, removing any variables not needed.
+## Non-path variables can be set with ""setenv VARIABLE value""
+prepend-path    PATH            $apphome
+__END__
+```
+
+## cactus
+- Home page: (https://github.com/ComparativeGenomicsToolkit/cactus)
+- Source code: quay.io/comparative-genomics-toolkit/cactus:v2.9.7
+
+### Installation on Deigo
+```
+ml singularity
+APP=cactus
+VER=2.9.7
+MODROOT=/bucket/BioinfoUgrp/Other
+APPDIR=$MODROOT/$APP/$VER
+mkdir -p $APPDIR
+cd $APPDIR
+singularity build $APP.sif docker:quay.io/comparative-genomics-toolkit/${APP}:v${VER}
+echo '#!/bin/sh' > $APP && echo ""singularity exec $APPDIR/$APP.sif $APP \$*"" >> $APP && chmod +x $APP
+echo '#!/bin/sh' > cactus-pangenome && echo ""singularity exec $APPDIR/$APP.sif cactus-pangenome \$*"" >> cactus-pangenome && chmod +x cactus-pangenome
+cd $MODROOT/modulefiles/
+mkdir -p $APP
+cat <<'__END__' > $APP/$VER.lua
+-- Default settings
+local modroot    = ""/bucket/BioinfoUgrp""
+local appname    = myModuleName()
+local appversion = myModuleVersion()
+local apphome    = pathJoin(modroot, myModuleFullName())
+
+-- Package information
+whatis(""Name: ""..appname)
+whatis(""Version: ""..appversion)
+whatis(""URL: ""..""https://github.com/ComparativeGenomicsToolkit/cactus"")
+whatis(""Category: ""..""bioinformatics"")
+whatis(""Keywords: ""..""alignment"")
+whatis(""Description: ""..""reference-free whole-genome alignment program"")
+
+-- Package settings
+depends_on(""singularity"")
+prepend_path(""PATH"", apphome)
+__END__
+```
+","Markdown"
+"AlphaFold","alisiafadini/ROCKET","test/conftest.py",".py","341","18","import sys
+from unittest.mock import MagicMock
+
+to_mock = [
+    ""openfold"",
+    ""openfold.model"",
+    ""openfold.utils"",
+    ""openfold.config"",
+    ""openfold.data"",
+    ""openfold.model.model"",
+    ""openfold.np"",
+    ""openfold.utils.import_weights"",
+    ""openfold.utils.script_utils"",
+]
+
+for mod in to_mock:
+    sys.modules[mod] = MagicMock()
+","Python"
+"AlphaFold","alisiafadini/ROCKET","test/unit/test_cryo_structurefactors.py",".py","2503","82","import pytest
+import torch
+
+
+class DummyCryoSFCalc:
+    def __init__(self, *a, **k):
+        self.Fprotein_HKL = torch.tensor([5.0])
+        self.Fo = torch.tensor([2.0])
+        self.bins = torch.tensor([0])
+        self.SigF = ""should be overwritten""
+        self.called = []
+
+    def calc_fprotein(self):
+        self.called.append(""calc_fprotein"")
+
+    def calc_Ec(self, x):
+        self.called.append((""calc_Ec"", x))
+        # Return dummy normalized value
+        return torch.tensor([1.0])
+
+    def get_scales_adam(self, sub_ratio=1.0):
+        self.called.append((""get_scales_adam"", sub_ratio))
+
+
+@pytest.fixture(autouse=True)
+def patch_cryo_SFcalculator(monkeypatch):
+    import SFC_Torch
+
+    import rocket.cryo.structurefactors
+
+    monkeypatch.setattr(rocket.cryo.structurefactors, ""SFcalculator"", DummyCryoSFCalc)
+    monkeypatch.setattr(SFC_Torch, ""SFcalculator"", DummyCryoSFCalc)
+
+
+def test_initial_cryoSFC_sets_attributes():
+    from rocket.cryo.structurefactors import initial_cryoSFC
+
+    result = initial_cryoSFC(
+        ""model.pdb"", ""map.mtz"", ""Emean"", ""PHIEmean"", device=""cpu"", n_bins=11
+    )
+
+    # Instance of DummyCryoSFCalc
+    assert isinstance(result, DummyCryoSFCalc)
+    assert result.SigF is None
+    assert torch.allclose(result.Fprotein_HKL, torch.tensor([1.0]))
+    called = result.called
+    # Should be three calls
+    assert len(called) == 3
+    assert called[0] == ""calc_fprotein""
+    assert called[2] == (""get_scales_adam"", 1.0)
+    name, tensor_arg = called[1]
+    assert name == ""calc_Ec""
+    assert torch.allclose(tensor_arg, torch.tensor([5.0]))
+
+
+def test_initial_cryoSFC_device_and_bins(monkeypatch):
+    # Patch to record init args
+    recorded_kwargs = {}
+
+    class DummyCryoSFCalcRecord(DummyCryoSFCalc):
+        def __init__(self, *a, **k):
+            recorded_kwargs.update(k)
+            super().__init__(*a, **k)
+
+    import SFC_Torch
+
+    import rocket.cryo.structurefactors
+
+    monkeypatch.setattr(
+        rocket.cryo.structurefactors, ""SFcalculator"", DummyCryoSFCalcRecord
+    )
+    monkeypatch.setattr(SFC_Torch, ""SFcalculator"", DummyCryoSFCalcRecord)
+
+    from rocket.cryo.structurefactors import initial_cryoSFC
+
+    _ = initial_cryoSFC(""x.pdb"", ""y.mtz"", ""E"", ""PHIE"", device=""cuda:1"", n_bins=3)
+    assert recorded_kwargs[""device""] == ""cuda:1""
+    assert recorded_kwargs[""n_bins""] == 3
+    assert recorded_kwargs[""mode""] == ""cryoem""
+    assert recorded_kwargs[""freeflag""] == ""None""
+    assert recorded_kwargs[""expcolumns""] == [""E"", ""PHIE""]
+","Python"
+"AlphaFold","alisiafadini/ROCKET","test/unit/test_xtal_structurefactors.py",".py","6818","228","import numpy as np
+import pytest
+import torch
+
+from rocket.xtal.structurefactors import (
+    calculate_Sigma_atoms,
+    compute_sigmaA_true,
+    ftotal_amplitudes,
+    ftotal_phis,
+    initial_SFC,
+    normalize_Fs,
+)
+
+# ---------- MOCKS for initial_SFC ----------
+
+
+class DummySFCalc:
+    def __init__(self, *a, **k):
+        self.Fprotein_HKL = torch.tensor([1.0])
+        self.Fprotein_asu = torch.tensor([1.0])
+        self.Fmask_HKL = torch.tensor([1.0])
+        self.solventpct = 0.5
+
+    def inspect_data(self, **k):
+        pass
+
+    def calc_fprotein(self):
+        pass
+
+    def calc_fsolvent(self):
+        self.Fmask_HKL = torch.zeros(1)
+
+    def get_scales_adam(self):
+        pass
+
+
+@pytest.fixture(autouse=True)
+def patch_SFcalculator(monkeypatch):
+    import SFC_Torch
+
+    import rocket.xtal.structurefactors
+
+    monkeypatch.setattr(rocket.xtal.structurefactors, ""SFcalculator"", DummySFCalc)
+    monkeypatch.setattr(SFC_Torch, ""SFcalculator"", DummySFCalc)
+    # Patch SFC.utils.try_gpu
+    monkeypatch.setattr(""SFC_Torch.utils.try_gpu"", lambda: ""cpu"")
+
+
+# ---------- TESTS ----------
+
+
+def test_initial_SFC_device_default():
+    result = initial_SFC(""pdb"", ""mtz"", ""F"", ""SigF"", device=None)
+    assert isinstance(result, DummySFCalc)
+
+
+def test_initial_SFC_added_chain():
+    result = initial_SFC(
+        ""pdb"",
+        ""mtz"",
+        ""F"",
+        ""SigF"",
+        added_chain_HKL=torch.tensor([2.0]),
+        added_chain_asu=torch.tensor([3.0]),
+        total_chain_copy=2.0,
+    )
+    assert torch.allclose(result.Fprotein_HKL, torch.tensor([3.0]))  # 1 + 2
+    assert torch.allclose(result.Fprotein_asu, torch.tensor([4.0]))  # 1 + 3
+    # solventpct should update: 1 - (1-0.5)*2 = 0.0
+    assert pytest.approx(result.solventpct) == 0.0
+
+
+def test_initial_SFC_solvent_false():
+    result = initial_SFC(""pdb"", ""mtz"", ""F"", ""SigF"", solvent=False)
+    assert torch.all(result.Fmask_HKL == 0)
+
+
+def test_initial_SFC_custom_device(monkeypatch):
+    # Should not call try_gpu if device given
+    device = ""cuda""
+    called = []
+    monkeypatch.setattr(""SFC_Torch.utils.try_gpu"", lambda: called.append(True))
+    result = initial_SFC(""pdb"", ""mtz"", ""F"", ""SigF"", device=device)
+    assert result is not None
+    assert not called  # try_gpu should not be called
+
+
+# ----------- ftotal_amplitudes -------------
+
+
+def test_ftotal_amplitudes_sorted():
+    Ftotal = torch.tensor([3 + 4j, 1 + 1j, 0 + 2j])
+    dHKL = np.array([2.0, 3.0, 1.0])
+    result = ftotal_amplitudes(Ftotal, dHKL, sort_by_res=True)
+    expected = torch.abs(Ftotal)[torch.tensor([1, 0, 2])]
+    torch.testing.assert_close(result, expected)
+
+
+def test_ftotal_amplitudes_nosort():
+    Ftotal = torch.tensor([3 + 4j, 1 + 1j, 0 + 2j])
+    dHKL = np.array([2.0, 3.0, 1.0])
+    result = ftotal_amplitudes(Ftotal, dHKL, sort_by_res=False)
+    expected = torch.abs(Ftotal)
+    torch.testing.assert_close(result, expected)
+
+
+def test_ftotal_amplitudes_empty():
+    Ftotal = torch.tensor([], dtype=torch.cfloat)
+    dHKL = np.array([])
+    result = ftotal_amplitudes(Ftotal, dHKL)
+    assert result.shape == (0,)
+
+
+# ----------- ftotal_phis -------------
+
+
+def test_ftotal_phis_sorted():
+    Fc = torch.tensor([1 + 0j, 0 + 1j, -1 + 0j])
+    dHKL = np.array([1.0, 3.0, 2.0])
+    result = ftotal_phis(Fc, dHKL, sort_by_res=True)
+    PI_on_180 = 0.017453292519943295
+    phases = torch.angle(Fc) / PI_on_180
+    sorted_indices = np.argsort(dHKL)[::-1]
+    sorted_indices = sorted_indices.copy()  # ensures positive strides
+    expected = phases[torch.tensor(sorted_indices)]
+
+    torch.testing.assert_close(result, expected)
+
+
+def test_ftotal_phis_nosort():
+    Fc = torch.tensor([1 + 0j, 0 + 1j])
+    dHKL = np.array([1.0, 2.0])
+    result = ftotal_phis(Fc, dHKL, sort_by_res=False)
+    PI_on_180 = 0.017453292519943295
+    expected = torch.angle(Fc) / PI_on_180
+    torch.testing.assert_close(result, expected)
+
+
+def test_ftotal_phis_empty():
+    Fc = torch.tensor([], dtype=torch.cfloat)
+    dHKL = np.array([])
+    result = ftotal_phis(Fc, dHKL)
+    assert result.shape == (0,)
+
+
+# ----------- compute_sigmaA_true -------------
+
+
+def test_compute_sigmaA_true_single_bin():
+    Eobs = np.array([1, 2])
+    phiobs = np.array([0, np.pi / 2])
+    Ecalc = np.array([1, 2])
+    phicalc = np.array([0, np.pi / 2])
+    bin_labels = np.array([0, 0])
+    result = compute_sigmaA_true(Eobs, phiobs, Ecalc, phicalc, bin_labels)
+    # cos(0)=1, so: 1*1*1, 2*2*1 => mean(1,4)=2.5
+    assert np.allclose(result, [2.5])
+
+
+def test_compute_sigmaA_true_multiple_bins():
+    Eobs = np.array([1, 2, 2])
+    phiobs = np.array([0, np.pi / 2, np.pi])
+    Ecalc = np.array([2, 1, 3])
+    phicalc = np.array([0, np.pi / 2, 0])
+    bin_labels = np.array([0, 1, 0])
+    # For bin 0: (1*2*cos(0), 2*3*cos(pi)) = (2, -6) => mean(-2)
+    # For bin 1: (2*1*cos(0)) = 2
+    result = compute_sigmaA_true(Eobs, phiobs, Ecalc, phicalc, bin_labels)
+    assert np.allclose(result, [-2, 2])
+
+
+def test_compute_sigmaA_true_empty():
+    result = compute_sigmaA_true(
+        np.array([]), np.array([]), np.array([]), np.array([]), np.array([])
+    )
+    assert result == []
+
+
+# ----------- calculate_Sigma_atoms -------------
+
+
+def test_calculate_Sigma_atoms_simple():
+    Fs = torch.tensor([2.0, 4.0])
+    eps = torch.tensor([1.0, 2.0])
+    bin_labels = torch.tensor([0, 0])
+    result = calculate_Sigma_atoms(Fs, eps, bin_labels)
+    expected = torch.mean(torch.tensor([4.0 / 1.0, 16.0 / 2.0]))
+    torch.testing.assert_close(result, torch.tensor([expected]))
+
+
+def test_calculate_Sigma_atoms_multiple_bins():
+    Fs = torch.tensor([2.0, 4.0, 3.0])
+    eps = torch.tensor([1.0, 2.0, 3.0])
+    bin_labels = torch.tensor([0, 1, 0])
+    # bin 0: [4/1, 9/3] = [4, 3.0], mean=3.5
+    # bin 1: [16/2]=8
+    result = calculate_Sigma_atoms(Fs, eps, bin_labels)
+    torch.testing.assert_close(result, torch.tensor([3.5, 8.0]))
+
+
+def test_calculate_Sigma_atoms_empty():
+    Fs = torch.tensor([], dtype=torch.float32)
+    eps = torch.tensor([], dtype=torch.float32)
+    bin_labels = torch.tensor([], dtype=torch.int64)
+    with pytest.raises(ValueError, match=""All input tensors must be non-empty""):
+        calculate_Sigma_atoms(Fs, eps, bin_labels)
+
+
+# ----------- normalize_Fs -------------
+
+
+def test_normalize_Fs_all_one_bin():
+    Fs = torch.tensor([2.0, 4.0])
+    eps = torch.tensor([1.0, 2.0])
+    Sigma_atoms = torch.tensor([6.0])
+    bin_labels = torch.tensor([0, 0])
+    E = normalize_Fs(Fs, eps, Sigma_atoms, bin_labels)
+    assert round(torch.mean(E**2).item()) == 1
+
+
+def test_normalize_Fs_raises_on_bad_scale():
+    Fs = torch.tensor([1.0, 1.0])
+    eps = torch.tensor([1.0, 1.0])
+    Sigma_atoms = torch.tensor([0.1])  # Will cause mean(E**2) != 1
+    bin_labels = torch.tensor([0, 0])
+    with pytest.raises(AssertionError):
+        normalize_Fs(Fs, eps, Sigma_atoms, bin_labels)
+","Python"
+"AlphaFold","alisiafadini/ROCKET","test/unit/test_coordinates.py",".py","41954","1278","from unittest.mock import MagicMock, patch
+
+import numpy as np
+import pytest
+import torch
+
+from rocket.coordinates import (
+    align_tensors,
+    calculate_mse_loss_per_residue,
+    construct_SO3,
+    decompose_SO3,
+    extract_allatoms,
+    extract_atoms_and_backbone,
+    extract_bfactors,
+    find_rigidbody_matrix_lbfgs_quat,
+    fractionalize_torch,
+    kabsch_align_matrices,
+    pose_train_lbfgs_quat,
+    quaternions_to_SO3,
+    rigidbody_refine_quat,
+    select_CA_elements,
+    select_CA_from_craname,
+    weighted_kabsch,
+    write_pdb_with_positions,
+)
+
+
+@pytest.fixture
+def mock_setup():
+    """"""Create mock data for rigid body refinement tests.""""""
+    # Create mock coordinates
+    xyz = torch.tensor(
+        [
+            [1.0, 2.0, 3.0],
+            [2.0, 3.0, 4.0],
+            [3.0, 4.0, 5.0],
+            [4.0, 5.0, 6.0],
+            [5.0, 6.0, 7.0],
+        ],
+        dtype=torch.float32,
+    )
+
+    # Create mock CRA names
+    cra_name = [""A-0-GLY-CA"", ""A-1-ALA-CA"", ""A-2-LEU-CA"", ""A-3-VAL-CA"", ""A-4-PHE-CA""]
+
+    # Create mock LLGloss
+    llgloss = MagicMock()
+    llgloss.device = ""cpu""
+
+    return xyz, cra_name, llgloss
+
+
+@patch(""rocket.coordinates.find_rigidbody_matrix_lbfgs_quat"")
+def test_rigidbody_refine_quat_single_domain(mock_find_rigidbody, mock_setup):
+    """"""Test rigidbody_refine_quat with a single domain.""""""
+    xyz, cra_name, llgloss = mock_setup
+
+    # Mock the quaternions and translation vectors returned by find_rigidbody_matrix_lbfgs_quat  # noqa: E501
+    trans_vecs = [torch.tensor([0.1, 0.2, 0.3])]
+    qs = [torch.tensor([0.9, 0.1, 0.1, 0.1])]
+    mock_find_rigidbody.return_value = (trans_vecs, qs, [10.0, 9.0, 8.0])  # Loss track
+
+    # Call the function
+    result_xyz, loss_track = rigidbody_refine_quat(
+        xyz=xyz, llgloss=llgloss, cra_name=cra_name, lbfgs=True, verbose=False
+    )
+
+    # Verify find_rigidbody_matrix_lbfgs_quat was called correctly
+    mock_find_rigidbody.assert_called_once()
+    args, kwargs = mock_find_rigidbody.call_args
+    assert args[0] == llgloss
+    assert torch.equal(args[1].detach(), xyz.detach())
+    assert args[2] == llgloss.device
+    # The domain_bools would be one array of all True
+    assert len(args[3]) == 1
+    assert np.all(args[3][0])
+
+    # Check that result has correct shape
+    assert result_xyz.shape == xyz.shape
+    assert loss_track == [10.0, 9.0, 8.0]
+
+    # Check that the transformation is applied correctly
+    propose_rmcom = xyz - torch.mean(xyz, dim=0)
+    propose_com = torch.mean(xyz, dim=0)
+    expected_rotation = quaternions_to_SO3(qs[0]).detach()
+    optimized_xyz = (
+        torch.matmul(propose_rmcom, expected_rotation)
+        + propose_com
+        + trans_vecs[0].detach()
+    )
+    assert torch.allclose(result_xyz, optimized_xyz)
+
+
+@patch(""rocket.coordinates.find_rigidbody_matrix_lbfgs_quat"")
+def test_rigidbody_refine_quat_multiple_domains(mock_find_rigidbody, mock_setup):
+    """"""Test rigidbody_refine_quat with multiple domains.""""""
+    xyz, cra_name, llgloss = mock_setup
+
+    # Domain segmentation at residue 2 (so residues 1-2 and 3-5 are two domains)
+    domain_segs = [3]  # Split between residues 2 and 3
+
+    # Mock the quaternions and translation vectors returned by find_rigidbody_matrix_lbfgs_quat  # noqa: E501
+    trans_vecs = [torch.tensor([0.1, 0.2, 0.3]), torch.tensor([0.4, 0.5, 0.6])]
+    qs = [torch.tensor([0.9, 0.1, 0.1, 0.1]), torch.tensor([0.8, 0.2, 0.2, 0.2])]
+    mock_find_rigidbody.return_value = (trans_vecs, qs, [10.0, 9.0])  # Loss track
+
+    # Call the function with domain segmentation
+    result_xyz, loss_track = rigidbody_refine_quat(
+        xyz=xyz,
+        llgloss=llgloss,
+        cra_name=cra_name,
+        lbfgs=True,
+        verbose=False,
+        domain_segs=domain_segs,
+    )
+
+    # Verify find_rigidbody_matrix_lbfgs_quat was called correctly
+    mock_find_rigidbody.assert_called_once()
+    args, kwargs = mock_find_rigidbody.call_args
+
+    # There should be 2 domain boolean arrays
+    assert len(args[3]) == 2
+
+    # First domain: residues 1-2
+    expected_domain1 = np.array([True, True, False, False, False])
+    assert np.array_equal(args[3][0], expected_domain1)
+
+    # Second domain: residues 3-5
+    expected_domain2 = np.array([False, False, True, True, True])
+    assert np.array_equal(args[3][1], expected_domain2)
+
+    # Check that result has correct shape
+    assert result_xyz.shape == xyz.shape
+    assert loss_track == [10.0, 9.0]
+
+    # Each domain should have coordinates transformed separately
+    # So the transformation for first three atoms is different from last two
+    domain_bools = args[3]
+    optimized_xyz = torch.ones_like(xyz)
+    for i in range(2):
+        propose_rmcom = xyz[domain_bools[i]] - torch.mean(xyz[domain_bools[i]], dim=0)
+        propose_com = torch.mean(xyz[domain_bools[i]], dim=0)
+        transform_i = quaternions_to_SO3(qs[i]).detach()
+        optimized_xyz[domain_bools[i]] = (
+            torch.matmul(propose_rmcom, transform_i)
+            + propose_com
+            + trans_vecs[i].detach()
+        )
+    assert torch.allclose(result_xyz, optimized_xyz)
+
+
+@patch(""rocket.coordinates.find_rigidbody_matrix_lbfgs_quat"")
+def test_rigidbody_refine_quat_with_added_chains(mock_find_rigidbody, mock_setup):
+    """"""Test rigidbody_refine_quat with additional chain parameters.""""""
+    xyz, cra_name, llgloss = mock_setup
+
+    # Mock additional chain parameters
+    added_chain_HKL = torch.tensor([1.0, 2.0, 3.0])
+    added_chain_asu = torch.tensor([4.0, 5.0, 6.0])
+
+    # Mock return values
+    trans_vecs = [torch.tensor([0.1, 0.2, 0.3])]
+    qs = [torch.tensor([0.9, 0.1, 0.1, 0.1])]
+    mock_find_rigidbody.return_value = (trans_vecs, qs, [8.0, 7.0])
+
+    # Call the function with additional chain parameters
+    result_xyz, loss_track = rigidbody_refine_quat(
+        xyz=xyz,
+        llgloss=llgloss,
+        cra_name=cra_name,
+        lbfgs=True,
+        added_chain_HKL=added_chain_HKL,
+        added_chain_asu=added_chain_asu,
+        lbfgs_lr=100.0,
+        verbose=False,
+    )
+
+    # Verify find_rigidbody_matrix_lbfgs_quat was called with correct parameters
+    mock_find_rigidbody.assert_called_once()
+    args, kwargs = mock_find_rigidbody.call_args
+    assert torch.equal(kwargs[""added_chain_HKL""], added_chain_HKL)
+    assert torch.equal(kwargs[""added_chain_asu""], added_chain_asu)
+    assert kwargs[""lbfgs_lr""] == 100.0
+    assert kwargs[""verbose""] is False
+
+    # Check results
+    assert result_xyz.shape == xyz.shape
+    assert loss_track == [8.0, 7.0]
+
+
+def test_rigidbody_refine_quat_integration():
+    """"""Integration test for rigidbody_refine_quat using actual computation.""""""
+    # Create simple test data
+    xyz = torch.tensor(
+        [
+            [1.0, 2.0, 3.0],
+            [2.0, 3.0, 4.0],
+            [3.0, 4.0, 5.0],
+        ],
+        dtype=torch.float32,
+        requires_grad=True,
+    )
+    cra_name = [""A-0-GLY-CA"", ""A-1-ALA-CA"", ""A-2-LEU-CA""]
+
+    # Create a mock llgloss that returns a simple loss value
+    class MockLLGLoss:
+        def __init__(self):
+            self.device = torch.device(""cpu"")
+            self.call_count = 0
+
+        def __call__(self, positions, **kwargs):
+            # Simple loss function: sum of squared distances from origin
+            self.call_count += 1
+            return -torch.sum(torch.sum(positions**2, dim=1))
+
+    llgloss = MockLLGLoss()
+
+    # We'll use a patch here to avoid testing the full LBFGS optimization
+    with patch(""rocket.coordinates.find_rigidbody_matrix_lbfgs_quat"") as mock_find:
+        # Mock quaternion and translation that makes a simple transformation
+        q = torch.tensor([1.0, 0.0, 0.0, 0.0], dtype=torch.float32)  # Identity rotation
+        trans = torch.tensor([1.0, 1.0, 1.0], dtype=torch.float32)  # Simple translation
+        mock_find.return_value = ([trans], [q], [-100.0])
+
+        # Call the function
+        optimized_xyz, loss_track = rigidbody_refine_quat(
+            xyz=xyz, llgloss=llgloss, cra_name=cra_name, lbfgs=True, verbose=False
+        )
+
+        # For an identity rotation and translation of [1,1,1],
+        # each point should be shifted by [1,1,1]
+        expected_xyz = xyz + torch.tensor([1.0, 1.0, 1.0])
+        assert torch.allclose(optimized_xyz, expected_xyz)
+        assert loss_track == [-100.0]
+
+
+@pytest.fixture
+def mock_optimizer():
+    """"""Creates a mock LBFGS optimizer.""""""
+    mock_opt = MagicMock()
+    mock_opt.step.return_value = torch.tensor(-10.0)
+    return mock_opt
+
+
+@patch(""torch.optim.LBFGS"")
+def test_find_rigidbody_matrix_lbfgs_quat(mock_lbfgs_class, mock_setup, mock_optimizer):
+    """"""Test find_rigidbody_matrix_lbfgs_quat function.""""""
+    xyz, cra_name, llgloss = mock_setup
+
+    # Make just 2 points for simplicity
+    xyz = xyz[:2]
+    device = ""cpu""
+
+    # Create domain booleans
+    domain_bools = [np.array([True, True])]
+
+    # Configure the mock optimizer
+    mock_lbfgs_class.return_value = mock_optimizer
+
+    # Call the function
+    trans_vecs, qs, loss_track = find_rigidbody_matrix_lbfgs_quat(
+        llgloss=llgloss,
+        xyz=xyz,
+        device=device,
+        domain_bools=domain_bools,
+        lbfgs_lr=200.0,
+        verbose=False,
+    )
+
+    # Check that the LBFGS optimizer was created with correct parameters
+    mock_lbfgs_class.assert_called_once()
+    args, kwargs = mock_lbfgs_class.call_args
+    assert len(args[0]) == 2  # qs + trans_vecs
+    assert kwargs[""lr""] == 200.0
+    assert kwargs[""line_search_fn""] == ""strong_wolfe""
+
+    # Check that the optimizer step was called 15 times (default n_steps)
+    assert mock_optimizer.step.call_count == 15
+
+    # Check return values
+    assert len(trans_vecs) == 1
+    assert len(qs) == 1
+    assert len(loss_track) == 15
+    assert all(x == -10.0 for x in loss_track)
+
+    # Check that q is initialized as identity quaternion
+    assert torch.allclose(qs[0], torch.tensor([1.0, 0.0, 0.0, 0.0], device=device))
+
+    # Check that translation vector is initialized as zeros
+    assert torch.allclose(trans_vecs[0], torch.tensor([0.0, 0.0, 0.0], device=device))
+
+
+def test_pose_train_lbfgs_quat():
+    """"""Test pose_train_lbfgs_quat function with mock optimizer.""""""
+
+    # Create mock data
+    llgloss = MagicMock()
+    llgloss.return_value = torch.tensor(-5.0)
+
+    # Create quaternions and translation vectors
+    qs = [torch.tensor([1.0, 0.0, 0.0, 0.0], requires_grad=True)]
+    trans_vecs = [torch.tensor([0.0, 0.0, 0.0], requires_grad=True)]
+
+    # Mock coordinates
+    xyz = torch.tensor(
+        [
+            [1.0, 2.0, 3.0],
+            [2.0, 3.0, 4.0],
+            [3.0, 4.0, 5.0],
+        ],
+        dtype=torch.float32,
+    )
+
+    # Mock domain booleans
+    domain_bools = [np.array([True, True, True])]
+
+    # Use patch to mock the optimizer
+    with patch(""torch.optim.LBFGS"") as mock_lbfgs_class:
+        # Create a mock optimizer that returns a specified loss
+        mock_optimizer = MagicMock()
+        mock_optimizer.step.return_value = torch.tensor(-5.0)
+        mock_lbfgs_class.return_value = mock_optimizer
+
+        # Call the function with few steps to speed up test
+        loss_track = pose_train_lbfgs_quat(
+            llgloss=llgloss,
+            qs=qs,
+            trans_vecs=trans_vecs,
+            xyz=xyz,
+            domain_bools=domain_bools,
+            lr=100.0,
+            n_steps=3,
+            verbose=False,
+        )
+
+        # Check that optimizer was created with correct parameters
+        mock_lbfgs_class.assert_called_once()
+        args, kwargs = mock_lbfgs_class.call_args
+        assert args[0] == qs + trans_vecs
+        assert kwargs[""lr""] == 100.0
+
+        # Check that optimizer.step was called the expected number of times
+        assert mock_optimizer.step.call_count == 3
+
+        # Check the loss track
+        assert len(loss_track) == 3
+        assert all(x == -5.0 for x in loss_track)
+
+
+def test_pose_train_lbfgs_quat_with_added_chains():
+    """"""Test pose_train_lbfgs_quat function properly passes added chains to llgloss.""""""
+    import torch
+
+    from rocket.coordinates import pose_train_lbfgs_quat
+
+    # Track calls to llgloss
+    call_args_list = []
+
+    # Create a mock llgloss that records its arguments and returns a tensor that requires gradients  # noqa: E501
+    def mock_llgloss_function(
+        xyz, added_chain_HKL=None, added_chain_asu=None, **kwargs
+    ):
+        call_args_list.append({
+            ""xyz"": xyz,
+            ""added_chain_HKL"": added_chain_HKL,
+            ""added_chain_asu"": added_chain_asu,
+            ""kwargs"": kwargs,
+        })
+        # Create a tensor that requires gradients
+        result = torch.tensor(-5.0, requires_grad=True)
+        return result
+
+    llgloss = MagicMock(side_effect=mock_llgloss_function)
+
+    # Create quaternions and translation vectors
+    qs = [torch.tensor([1.0, 0.0, 0.0, 0.0], requires_grad=True)]
+    trans_vecs = [torch.tensor([0.0, 0.0, 0.0], requires_grad=True)]
+
+    # Mock coordinates
+    xyz = torch.tensor(
+        [
+            [1.0, 2.0, 3.0],
+            [2.0, 3.0, 4.0],
+            [3.0, 4.0, 5.0],
+        ],
+        dtype=torch.float32,
+    )
+
+    # Mock domain booleans
+    domain_bools = [np.array([True, True, True])]
+
+    # Create added chain tensors
+    added_chain_HKL = torch.tensor([1.0, 2.0, 3.0])
+    added_chain_asu = torch.tensor([4.0, 5.0, 6.0])
+
+    # Use patch to mock the optimizer with a simpler approach
+    with patch(""torch.optim.LBFGS"") as mock_lbfgs_class:
+        # Create a mock optimizer that just returns a fixed loss value when step is called  # noqa: E501
+        mock_optimizer = MagicMock()
+
+        # Make step actually call the closure function once and return its value
+        def mock_step(closure):
+            return closure()
+
+        mock_optimizer.step.side_effect = mock_step
+        mock_lbfgs_class.return_value = mock_optimizer
+
+        # Call the function with just 1 step
+        loss_track = pose_train_lbfgs_quat(
+            llgloss=llgloss,
+            qs=qs,
+            trans_vecs=trans_vecs,
+            xyz=xyz,
+            domain_bools=domain_bools,
+            lr=100.0,
+            n_steps=1,  # Use a single step for simplicity
+            added_chain_HKL=added_chain_HKL,
+            added_chain_asu=added_chain_asu,
+            verbose=False,
+        )
+
+        # Verify that llgloss was called at least once
+        assert len(call_args_list) > 0
+
+        # Verify that the most recent call included the added_chain parameters
+        last_call = call_args_list[-1]
+        assert torch.equal(last_call[""added_chain_HKL""], added_chain_HKL)
+        assert torch.equal(last_call[""added_chain_asu""], added_chain_asu)
+
+        # Check the loss track has expected values
+        assert len(loss_track) == 1
+        assert loss_track[0] == 5.0
+
+
+def test_quaternions_to_SO3_identity():
+    """"""Test quaternions_to_SO3 with identity quaternion.""""""
+
+    # Identity quaternion [r,i,j,k] = [1,0,0,0]
+    q = torch.tensor([1.0, 0.0, 0.0, 0.0])
+
+    # Apply the function
+    rotation_matrix = quaternions_to_SO3(q)
+
+    # Check that the result is the identity matrix
+    expected = torch.eye(3)
+    assert torch.allclose(rotation_matrix, expected)
+
+
+def test_quaternions_to_SO3_rotation():
+    """"""Test quaternions_to_SO3 with a 90-degree rotation around z-axis.""""""
+
+    # Quaternion for 90-degree rotation around z-axis
+    # [r,i,j,k] = [cos(45°),0,0,sin(45°)]
+    # 45° is half of the desired rotation angle
+    import math
+
+    angle = math.pi / 4  # 45 degrees
+    q = torch.tensor([math.cos(angle), 0.0, 0.0, math.sin(angle)])
+
+    # Apply the function
+    rotation_matrix = quaternions_to_SO3(q)
+
+    # Expected: 90-degree rotation around z-axis
+    expected = torch.tensor([[0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]])
+
+    assert torch.allclose(rotation_matrix, expected, atol=1e-6)
+
+
+def test_quaternions_to_SO3_normalization():
+    """"""Test that quaternions_to_SO3 properly normalizes the quaternion.""""""
+    from rocket.coordinates import quaternions_to_SO3
+
+    # Non-normalized quaternion
+    q = torch.tensor([2.0, 0.0, 0.0, 0.0])
+
+    # Apply the function
+    rotation_matrix = quaternions_to_SO3(q)
+
+    # Should still produce the identity matrix
+    expected = torch.eye(3)
+    assert torch.allclose(rotation_matrix, expected)
+
+
+def test_quaternions_to_SO3_batch():
+    """"""Test quaternions_to_SO3 with batched quaternions.""""""
+    from rocket.coordinates import quaternions_to_SO3
+
+    # Batch of quaternions: identity and 180-degree rotation around x-axis
+    qs = torch.tensor([
+        [1.0, 0.0, 0.0, 0.0],  # identity
+        [0.0, 1.0, 0.0, 0.0],  # 180° around x
+    ])
+
+    # Apply the function
+    rotation_matrices = quaternions_to_SO3(qs)
+
+    # Expected matrices
+    expected = torch.tensor([
+        [  # Identity
+            [1.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 0.0, 1.0],
+        ],
+        [  # 180° around x
+            [1.0, 0.0, 0.0],
+            [0.0, -1.0, 0.0],
+            [0.0, 0.0, -1.0],
+        ],
+    ])
+
+    assert torch.allclose(rotation_matrices, expected)
+
+
+def test_construct_SO3():
+    """"""Test construct_SO3 function.""""""
+
+    # Test with orthogonal vectors
+    v1 = torch.tensor([1.0, 0.0, 0.0])
+    v2 = torch.tensor([0.0, 1.0, 0.0])
+
+    R = construct_SO3(v1, v2)
+
+    # Should be identity matrix
+    expected = torch.eye(3)
+    assert torch.allclose(R, expected)
+
+    # Test with non-orthogonal vectors
+    v1 = torch.tensor([1.0, 1.0, 0.0])
+    v2 = torch.tensor([0.0, 1.0, 1.0])
+
+    R = construct_SO3(v1, v2)
+
+    # Check that R is orthogonal (R^T * R = I)
+    identity = torch.matmul(R.T, R)
+    assert torch.allclose(identity, torch.eye(3), atol=1e-6)
+
+    # Check that det(R) = 1 (proper rotation)
+    det = torch.det(R)
+    assert torch.isclose(det, torch.tensor(1.0))
+
+
+def test_decompose_SO3():
+    """"""Test decompose_SO3 function.""""""
+
+    # Create a rotation matrix
+    theta = torch.tensor(0.5)  # some angle
+    c, s = torch.cos(theta), torch.sin(theta)
+    R = torch.tensor([[c, -s, 0], [s, c, 0], [0, 0, 1]])
+
+    # Decompose it
+    v1, v2 = decompose_SO3(R)
+
+    # Reconstruct the rotation matrix
+    R_recon = construct_SO3(v1, v2)
+
+    # Check they match
+    assert torch.allclose(R, R_recon, atol=1e-6)
+
+    # Test with custom a, b, c parameters
+    v1, v2 = decompose_SO3(R, a=2.0, b=1.5, c=0.5)
+
+    # The reconstructed matrix should still be the same
+    R_recon = construct_SO3(v1, v2)
+    assert torch.allclose(R, R_recon, atol=1e-6)
+
+    # Test exception with c=0
+    with pytest.raises(AssertionError):
+        decompose_SO3(R, c=0.0)
+
+
+def test_select_CA_elements():
+    """"""Test select_CA_elements function.""""""
+
+    # Test with mixed atom types
+    cra_names = [""A-1-GLY-CA"", ""A-1-GLY-N"", ""A-2-ALA-CA"", ""A-2-ALA-CB""]
+
+    result = select_CA_elements(cra_names)
+
+    expected = [True, False, True, False]
+    assert result == expected
+
+
+def test_select_CA_from_craname():
+    """"""Test select_CA_from_craname function.""""""
+
+    # Test with mixed atom types
+    cra_names = [""A-1-GLY-CA"", ""A-1-GLY-N"", ""A-2-ALA-CA"", ""A-2-ALA-CB""]
+
+    ca_list, mask = select_CA_from_craname(cra_names)
+
+    expected_list = [""A-1-GLY-CA"", ""A-2-ALA-CA""]
+    expected_mask = [True, False, True, False]
+
+    assert ca_list == expected_list
+    assert mask == expected_mask
+
+
+def test_calculate_mse_loss_per_residue():
+    """"""Test calculate_mse_loss_per_residue function.""""""
+
+    # Create two tensors with atom coordinates
+    tensor1 = torch.tensor([
+        [1.0, 1.0, 1.0],  # residue 1
+        [2.0, 2.0, 2.0],  # residue 1
+        [3.0, 3.0, 3.0],  # residue 2
+        [4.0, 4.0, 4.0],  # residue 3
+    ])
+
+    tensor2 = torch.tensor([
+        [1.1, 1.1, 1.1],  # residue 1
+        [2.1, 2.1, 2.1],  # residue 1
+        [3.1, 3.1, 3.1],  # residue 2
+        [4.1, 4.1, 4.1],  # residue 3
+    ])
+
+    # Residue numbers
+    residue_numbers = [1, 1, 2, 3]
+
+    # Calculate MSE loss per residue
+    mse_losses = calculate_mse_loss_per_residue(tensor1, tensor2, residue_numbers)
+
+    # Expected results:
+    # Residue 1: sqrt(mean(sum((1,1,1)-(1.1,1.1,1.1))^2 + sum((2,2,2)-(2.1,2.1,2.1))^2)) = sqrt(3*0.1^2 + 3*0.1^2) = sqrt(0.06)  # noqa: E501
+    # Residue 2: sqrt(sum((3,3,3)-(3.1,3.1,3.1))^2) = sqrt(0.03)
+    # Residue 3: sqrt(sum((4,4,4)-(4.1,4.1,4.1))^2) = sqrt(0.03)
+
+    expected = [
+        np.sqrt(0.06),  # residue 1 with 2 atoms
+        np.sqrt(0.03),  # residue 2 with 1 atom
+        np.sqrt(0.03),  # residue 3 with 1 atom
+    ]
+
+    assert len(mse_losses) == 3
+    for actual, expecte in zip(mse_losses, expected, strict=False):
+        assert np.isclose(actual, expecte)
+
+
+@patch(""builtins.open"", new_callable=MagicMock)
+def test_write_pdb_with_positions(mock_open):
+    """"""Test write_pdb_with_positions function.""""""
+
+    # Create mock file handles
+    mock_file_in = MagicMock()
+    mock_file_out = MagicMock()
+
+    # Configure mock_open to return different file handles for input and output
+    mock_open.side_effect = [mock_file_in, mock_file_out]
+
+    # Set up mock file content
+    mock_file_in.__enter__.return_value.readlines = lambda: [
+        ""HEADER    TEST FILE\n"",
+        ""ATOM      1  N   ALA A   1      10.000  20.000  30.000  1.00 10.00           N\n"",  # noqa: E501
+        ""ATOM      2  CA  ALA A   1      11.000  21.000  31.000  1.00 10.00           C\n"",  # noqa: E501
+        ""TER\n"",
+    ]
+    mock_file_in.__enter__.return_value.__iter__ = lambda self: iter(self.readlines())
+
+    # Positions to write
+    positions = [[12.345, 23.456, 34.567], [45.678, 56.789, 67.890]]
+
+    # Call function
+    write_pdb_with_positions(""input.pdb"", positions, ""output.pdb"")
+
+    # Check that files were opened correctly
+    mock_open.assert_any_call(""input.pdb"")
+    mock_open.assert_any_call(""output.pdb"", ""w"")
+
+    # Check that write was called with correct content
+    calls = mock_file_out.__enter__.return_value.write.call_args_list
+
+    # First line should be header (unchanged)
+    assert calls[0][0][0] == ""HEADER    TEST FILE\n""
+
+    # Second line should be first ATOM with updated coordinates
+    expected_line1 = ""ATOM      1  N   ALA A   1      12.345  23.456  34.567  1.00 10.00           N\n""  # noqa: E501
+    assert calls[1][0][0] == expected_line1
+
+    # Third line should be second ATOM with updated coordinates
+    expected_line2 = ""ATOM      2  CA  ALA A   1      45.678  56.789  67.890  1.00 10.00           C\n""  # noqa: E501
+    assert calls[2][0][0] == expected_line2
+
+    # Fourth line should be TER (unchanged)
+    assert calls[3][0][0] == ""TER\n""
+
+
+@pytest.fixture
+def mock_unit_cell():
+    """"""Create a mock unit cell with known fractionalization matrix.""""""
+    mock_cell = MagicMock()
+    # Create a simple fractionalization matrix
+    # This matrix converts from orthogonal to fractional coordinates
+    mock_cell.fractionalization_matrix = np.array([
+        [0.1, 0.0, 0.0],  # a* = 0.1
+        [0.0, 0.1, 0.0],  # b* = 0.1
+        [0.0, 0.0, 0.1],  # c* = 0.1
+    ])
+    return mock_cell
+
+
+def test_fractionalize_torch_simple_matrix(mock_unit_cell):
+    """"""Test fractionalize_torch with a simple fractionalization matrix.""""""
+
+    # Create a simple set of orthogonal coordinates
+    atom_pos_orth = torch.tensor([
+        [10.0, 0.0, 0.0],  # 10 Å along x-axis
+        [0.0, 20.0, 0.0],  # 20 Å along y-axis
+        [0.0, 0.0, 30.0],  # 30 Å along z-axis
+        [5.0, 5.0, 5.0],  # 5 Å along each axis
+    ])
+
+    # Call the function
+    atom_pos_frac = fractionalize_torch(atom_pos_orth, mock_unit_cell, device=""cpu"")
+
+    # With our simple fractionalization matrix (0.1 on diagonal),
+    # orthogonal coordinates are simply multiplied by 0.1
+    expected_frac = torch.tensor([
+        [1.0, 0.0, 0.0],  # 10 * 0.1 = 1.0 along a
+        [0.0, 2.0, 0.0],  # 20 * 0.1 = 2.0 along b
+        [0.0, 0.0, 3.0],  # 30 * 0.1 = 3.0 along c
+        [0.5, 0.5, 0.5],  # 5 * 0.1 = 0.5 along each axis
+    ])
+
+    assert torch.allclose(atom_pos_frac, expected_frac)
+
+
+def test_extract_allatoms_with_mocking():
+    """"""Test extract_allatoms with mocked residue_constants.""""""
+
+    # Create minimal test data
+    cra_name_sfc = [
+        ""A-0-GLY-N"",
+        ""A-0-GLY-CA"",
+        ""A-0-GLY-C"",
+        ""A-0-GLY-O"",
+        ""A-1-ALA-N"",
+        ""A-1-ALA-CA"",
+        ""A-1-ALA-C"",
+        ""A-1-ALA-O"",
+        ""A-1-ALA-CB"",
+    ]
+
+    # Let's see key parts of the function
+    # 1. It expects residue_constants.atom_types to be a list of atom names
+    # 2. It expects feats[""aatype""] to contain residue type indices
+    # 3. It expects outputs[""final_atom_mask""] to be [n_res, N_atom_types]
+    # 4. It expects outputs[""final_atom_positions""] to be [n_res, N_atom_types, 3]
+
+    # We'll patch more of the function's internal calls to isolate the test
+
+    with (
+        patch(
+            ""rocket.coordinates.residue_constants.atom_types"",
+            [""N"", ""CA"", ""C"", ""O"", ""CB""],
+        ),
+        patch(
+            ""rocket.coordinates.residue_constants.restype_1to3"",
+            {0: ""GLY"", 1: ""ALA"", -1: ""UNK""},
+        ),
+    ):  # noqa: E501
+        # Create expected outputs for different stages of the function
+        atom_type_indices = {  # noqa: F841
+            ""N"": 0,
+            ""CA"": 1,
+            ""C"": 2,
+            ""O"": 3,
+            ""CB"": 4,
+        }
+
+        # Mock atom_positions that will be returned at the end
+        expected_positions = torch.tensor([
+            [1.0, 2.0, 3.0],  # GLY-N
+            [2.0, 3.0, 4.0],  # GLY-CA
+            [3.0, 4.0, 5.0],  # GLY-C
+            [4.0, 5.0, 6.0],  # GLY-O
+            [5.0, 6.0, 7.0],  # ALA-N
+            [6.0, 7.0, 8.0],  # ALA-CA
+            [7.0, 8.0, 9.0],  # ALA-C
+            [8.0, 9.0, 10.0],  # ALA-O
+            [9.0, 10.0, 11.0],  # ALA-CB
+        ])
+
+        # Mock plddt that will be returned
+        expected_plddt = torch.tensor([
+            90.0,
+            90.0,
+            90.0,
+            90.0,
+            80.0,
+            80.0,
+            80.0,
+            80.0,
+            80.0,
+        ])  # noqa: E501
+
+        # Now instead of mocking np.char.add, we'll mock the whole extraction process
+        with (
+            patch(""torch.cat"", return_value=expected_positions),
+            patch(""torch.repeat_interleave"", return_value=expected_plddt),
+        ):
+            # Create minimal outputs and feats that will pass through the mocked parts
+            outputs = {
+                ""final_atom_mask"": torch.tensor([
+                    [1.0, 1.0, 1.0, 1.0, 0.0],  # GLY
+                    [1.0, 1.0, 1.0, 1.0, 1.0],  # ALA
+                ]),  # Just needs correct shape
+                ""final_atom_positions"": torch.concat(
+                    [
+                        expected_positions[:5].unsqueeze(0),
+                        expected_positions[4:].unsqueeze(0),
+                    ],
+                    axis=0,
+                ),  # Will be mocked
+                ""plddt"": torch.tensor([90.0, 80.0]),  # Per-residue scores
+            }
+            feats = {""aatype"": torch.tensor([[0], [1]])}  # GLY and ALA
+
+            # Call the function
+            positions, plddt = extract_allatoms(outputs, feats, cra_name_sfc)
+
+    # Verify the results
+    assert torch.allclose(positions, expected_positions)
+    assert torch.allclose(plddt, expected_plddt)
+
+
+def test_extract_atoms_and_backbone():
+    """"""Test extract_atoms_and_backbone function with minimal mocking.""""""
+
+    # Create mock inputs
+    outputs = {
+        ""final_atom_mask"": torch.tensor([
+            # First residue (GLY) - only backbone atoms
+            [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],
+            # Second residue (ALA) - backbone + CB
+            [1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0],
+        ]),
+        ""final_atom_positions"": torch.tensor([
+            # GLY residue
+            [
+                [1.0, 2.0, 3.0],  # N
+                [2.0, 3.0, 4.0],  # CA
+                [3.0, 4.0, 5.0],  # C
+                [4.0, 5.0, 6.0],  # O
+                [0.0, 0.0, 0.0],  # CB (not present in GLY)
+                [0.0, 0.0, 0.0],  # CG (not present)
+                [0.0, 0.0, 0.0],  # CD (not present)
+            ],
+            # ALA residue
+            [
+                [5.0, 6.0, 7.0],  # N
+                [6.0, 7.0, 8.0],  # CA
+                [7.0, 8.0, 9.0],  # C
+                [8.0, 9.0, 10.0],  # O
+                [9.0, 10.0, 11.0],  # CB
+                [0.0, 0.0, 0.0],  # CG (not present in ALA)
+                [0.0, 0.0, 0.0],  # CD (not present)
+            ],
+        ]),
+    }
+
+    feats = {
+        ""aatype"": torch.tensor([[0], [1]])  # GLY and ALA
+    }
+
+    # Mock residue_constants.atom_types
+    with patch(
+        ""rocket.coordinates.residue_constants.atom_types"",
+        [""N"", ""CA"", ""C"", ""O"", ""CB"", ""CG"", ""CD""],
+    ):
+        # Call the function
+        positions, backbone_mask = extract_atoms_and_backbone(outputs, feats)
+
+    # Expected positions - Only atoms with mask=1 should be included
+    expected_positions = torch.tensor([
+        [1.0, 2.0, 3.0],  # GLY-N
+        [2.0, 3.0, 4.0],  # GLY-CA
+        [3.0, 4.0, 5.0],  # GLY-C
+        [4.0, 5.0, 6.0],  # GLY-O
+        [5.0, 6.0, 7.0],  # ALA-N
+        [6.0, 7.0, 8.0],  # ALA-CA
+        [7.0, 8.0, 9.0],  # ALA-C
+        [8.0, 9.0, 10.0],  # ALA-O
+        [9.0, 10.0, 11.0],  # ALA-CB
+    ])
+
+    # Expected backbone mask - True for N, CA, C, O atoms
+    expected_backbone_mask = torch.tensor(
+        [
+            True,  # GLY-N
+            True,  # GLY-CA
+            True,  # GLY-C
+            True,  # GLY-O
+            True,  # ALA-N
+            True,  # ALA-CA
+            True,  # ALA-C
+            True,  # ALA-O
+            False,  # ALA-CB
+        ],
+        dtype=torch.bool,
+    )
+
+    # Check results
+    assert torch.equal(positions, expected_positions)
+    assert torch.equal(backbone_mask, expected_backbone_mask)
+
+
+def test_extract_atoms_and_backbone_all_atoms():
+    """"""Test extract_atoms_and_backbone with all atom types present.""""""
+    # Create mock inputs with a more complex amino acid (e.g., LYS)
+    outputs = {
+        ""final_atom_mask"": torch.tensor([
+            # LYS residue with all atoms
+            [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+        ]),
+        ""final_atom_positions"": torch.tensor([
+            # LYS residue
+            [
+                [1.0, 1.0, 1.0],  # N
+                [2.0, 2.0, 2.0],  # CA
+                [3.0, 3.0, 3.0],  # C
+                [4.0, 4.0, 4.0],  # O
+                [5.0, 5.0, 5.0],  # CB
+                [6.0, 6.0, 6.0],  # CG
+                [7.0, 7.0, 7.0],  # CD
+            ]
+        ]),
+    }
+
+    feats = {
+        ""aatype"": torch.tensor([[3]])  # LYS (arbitrary residue type)
+    }
+
+    # Mock residue_constants.atom_types
+    with patch(
+        ""rocket.coordinates.residue_constants.atom_types"",
+        [""N"", ""CA"", ""C"", ""O"", ""CB"", ""CG"", ""CD""],
+    ):
+        # Call the function
+        positions, backbone_mask = extract_atoms_and_backbone(outputs, feats)
+
+    # Expected positions - All atoms should be included
+    expected_positions = torch.tensor([
+        [1.0, 1.0, 1.0],  # N
+        [2.0, 2.0, 2.0],  # CA
+        [3.0, 3.0, 3.0],  # C
+        [4.0, 4.0, 4.0],  # O
+        [5.0, 5.0, 5.0],  # CB
+        [6.0, 6.0, 6.0],  # CG
+        [7.0, 7.0, 7.0],  # CD
+    ])
+
+    # Expected backbone mask - True for N, CA, C, O atoms
+    expected_backbone_mask = torch.tensor(
+        [
+            True,  # N
+            True,  # CA
+            True,  # C
+            True,  # O
+            False,  # CB
+            False,  # CG
+            False,  # CD
+        ],
+        dtype=torch.bool,
+    )
+
+    # Check results
+    assert torch.equal(positions, expected_positions)
+    assert torch.equal(backbone_mask, expected_backbone_mask)
+
+
+def test_extract_bfactors():
+    """"""Test the extract_bfactors function.""""""
+
+    # Create a mock protein structure
+    class MockProtein:
+        def __init__(self):
+            # Create atom mask: 2 residues with different numbers of atoms
+            self.atom_mask = np.array([
+                [1.0, 1.0, 1.0, 1.0, 0.0],  # First residue has 4 atoms
+                [1.0, 1.0, 1.0, 1.0, 1.0],  # Second residue has 5 atoms
+            ])
+
+            # Create aatype (residue types)
+            self.aatype = np.array([
+                0,  # GLY
+                1,  # ALA
+            ])
+
+            # Create b-factors: assign different values to each atom
+            self.b_factors = np.array([
+                [10.0, 15.0, 20.0, 25.0, 0.0],  # First residue B-factors
+                [30.0, 35.0, 40.0, 45.0, 50.0],  # Second residue B-factors
+            ])
+
+    # Create the mock protein
+    mock_prot = MockProtein()
+
+    # Call the function
+    b_factor_array = extract_bfactors(mock_prot)
+
+    # Expected B-factors (only for atoms with mask >= 0.5)
+    expected_b_factors = np.array([
+        10.0,  # First residue, first atom
+        15.0,  # First residue, second atom
+        20.0,  # First residue, third atom
+        25.0,  # First residue, fourth atom
+        30.0,  # Second residue, first atom
+        35.0,  # Second residue, second atom
+        40.0,  # Second residue, third atom
+        45.0,  # Second residue, fourth atom
+        50.0,  # Second residue, fifth atom
+    ])
+
+    # Check results
+    assert np.array_equal(b_factor_array, expected_b_factors)
+    assert b_factor_array.shape == (9,)
+
+
+def test_extract_bfactors_with_masked_atoms():
+    """"""Test extract_bfactors with partially masked atoms.""""""
+
+    # Create a mock protein structure with some atoms masked out
+    class MockProtein:
+        def __init__(self):
+            # Create atom mask with some atoms masked out
+            self.atom_mask = np.array([
+                [1.0, 0.4, 1.0, 1.0, 0.0],  # Second atom is masked out (below 0.5)
+                [1.0, 1.0, 0.3, 1.0, 1.0],  # Third atom is masked out (below 0.5)
+            ])
+
+            # Create aatype (residue types)
+            self.aatype = np.array([
+                0,  # GLY
+                1,  # ALA
+            ])
+
+            # Create b-factors
+            self.b_factors = np.array([
+                [10.0, 15.0, 20.0, 25.0, 0.0],  # First residue B-factors
+                [30.0, 35.0, 40.0, 45.0, 50.0],  # Second residue B-factors
+            ])
+
+    # Create the mock protein
+    mock_prot = MockProtein()
+
+    # Call the function
+    b_factor_array = extract_bfactors(mock_prot)
+
+    # Expected B-factors (only for atoms with mask >= 0.5)
+    # Note: second atom of first residue and third atom of second residue are masked out
+    expected_b_factors = np.array([
+        10.0,  # First residue, first atom
+        # 15.0 is skipped (masked out)
+        20.0,  # First residue, third atom
+        25.0,  # First residue, fourth atom
+        30.0,  # Second residue, first atom
+        35.0,  # Second residue, second atom
+        # 40.0 is skipped (masked out)
+        45.0,  # Second residue, fourth atom
+        50.0,  # Second residue, fifth atom
+    ])
+
+    # Check results
+    assert np.array_equal(b_factor_array, expected_b_factors)
+    assert b_factor_array.shape == (7,)  # 9 total atoms minus 2 masked atoms
+
+
+def test_kabsch_align_matrices_identity():
+    """"""Test kabsch_align_matrices with identical tensors.""""""
+
+    # Create identical tensors (a simple cube)
+    tensor1 = torch.tensor([
+        [0.0, 0.0, 0.0],  # Origin
+        [1.0, 0.0, 0.0],  # X-axis point
+        [0.0, 1.0, 0.0],  # Y-axis point
+        [0.0, 0.0, 1.0],  # Z-axis point
+        [1.0, 1.0, 1.0],  # Diagonal point
+    ])
+    tensor2 = tensor1.clone()
+
+    # Apply the function
+    centroid1, centroid2, rotation_matrix = kabsch_align_matrices(tensor1, tensor2)
+
+    # Expected results:
+    # - Centroids should be the same
+    # - Rotation matrix should be identity since tensors are identical
+    expected_centroid = torch.tensor([[0.4, 0.4, 0.4]])
+    expected_rotation = torch.eye(3)
+
+    # Check results
+    assert torch.allclose(centroid1, expected_centroid)
+    assert torch.allclose(centroid2, expected_centroid)
+    assert torch.allclose(rotation_matrix, expected_rotation, atol=1e-5)
+
+
+def test_kabsch_align_matrices_translation():
+    """"""Test kabsch_align_matrices with translated tensors.""""""
+
+    # Create two tensors with the same shape but different positions
+    # The second tensor is shifted by [1, 2, 3]
+    tensor1 = torch.tensor([
+        [0.0, 0.0, 0.0],
+        [1.0, 0.0, 0.0],
+        [0.0, 1.0, 0.0],
+        [0.0, 0.0, 1.0],
+        [1.0, 1.0, 1.0],
+    ])
+
+    translation = torch.tensor([1.0, 2.0, 3.0])
+    tensor2 = tensor1 + translation
+
+    # Apply the function
+    centroid1, centroid2, rotation_matrix = kabsch_align_matrices(tensor1, tensor2)
+
+    # Expected results:
+    # - Centroids should reflect the translation
+    # - Rotation matrix should be identity since there's only translation
+    expected_centroid1 = torch.tensor([[0.4, 0.4, 0.4]])
+    expected_centroid2 = expected_centroid1 + translation
+    expected_rotation = torch.eye(3)
+
+    # Check results
+    assert torch.allclose(centroid1, expected_centroid1)
+    assert torch.allclose(centroid2, expected_centroid2)
+    assert torch.allclose(rotation_matrix, expected_rotation, atol=1e-5)
+
+
+def test_kabsch_align_matrices_rotation():
+    """"""Test kabsch_align_matrices with rotated tensors.""""""
+
+    # Create a tensor representing a simple structure
+    tensor1 = torch.tensor(
+        [
+            [0.0, 0.0, 0.0],
+            [1.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 0.0, 1.0],
+            [1.0, 1.0, 1.0],
+        ],
+        dtype=torch.float32,
+    )
+
+    # Create a rotation matrix (90 degrees around Z axis)
+    angle = np.pi / 2  # 90 degrees
+    rotation = torch.tensor(
+        [
+            [np.cos(angle), -np.sin(angle), 0],
+            [np.sin(angle), np.cos(angle), 0],
+            [0, 0, 1],
+        ],
+        dtype=torch.float32,
+    )
+
+    # Apply rotation to create tensor2
+    tensor2 = torch.matmul(tensor1, rotation.T)
+
+    # Apply the function
+    centroid1, centroid2, calculated_rotation = kabsch_align_matrices(tensor1, tensor2)
+
+    # Expected results:
+    # - Centroids should be the same in magnitude (the origin point is moved)
+    # - Rotation matrix should match the original rotation
+
+    # Check that the calculated rotation is close to the expected rotation
+    # Note: The calculated rotation will align tensor1 to tensor2, so it should be
+    # the transpose of the original rotation
+    assert torch.allclose(calculated_rotation, rotation, atol=1e-5)
+
+    # Check that the centroids are at the same distance from origin
+    assert torch.allclose(torch.norm(centroid1), torch.norm(centroid2))
+
+
+def test_kabsch_align_matrices_complex():
+    """"""Test kabsch_align_matrices with a more complex transformation.""""""
+
+    # Create a tensor representing a protein backbone fragment
+    tensor1 = torch.tensor(
+        [
+            [0.0, 0.0, 0.0],  # N
+            [1.5, 0.0, 0.0],  # CA
+            [2.5, 1.2, 0.0],  # C
+            [3.5, 1.5, 1.0],  # N
+            [4.0, 2.5, 1.5],  # CA
+        ],
+        dtype=torch.float32,
+    )
+
+    # Create a transformation: rotation + translation
+    angle = np.pi / 4  # 45 degrees
+    rotation = torch.tensor(
+        [
+            [np.cos(angle), -np.sin(angle), 0],
+            [np.sin(angle), np.cos(angle), 0],
+            [0, 0, 1],
+        ],
+        dtype=torch.float32,
+    )
+    translation = torch.tensor([5.0, -3.0, 2.0])
+
+    # Apply transformation manually
+    centroid1_manual = torch.mean(tensor1, dim=0, keepdim=True)
+    tensor1_centered = tensor1 - centroid1_manual
+    tensor2 = (
+        torch.matmul(tensor1_centered, rotation.T) + centroid1_manual + translation
+    )  # noqa: E501
+
+    # Apply the function
+    centroid1, centroid2, calculated_rotation = kabsch_align_matrices(tensor1, tensor2)
+
+    # Apply the calculated transformation to tensor1
+    aligned_tensor1 = align_tensors(tensor1, centroid1, centroid2, calculated_rotation)
+
+    # Check that the aligned tensor matches tensor2
+    assert torch.allclose(aligned_tensor1, tensor2, atol=1e-6)
+
+    # Check that the rotation matrix is orthogonal (R^T R = I)
+    identity = torch.matmul(calculated_rotation.T, calculated_rotation)
+    assert torch.allclose(identity, torch.eye(3), atol=1e-6)
+
+    # Check that the determinant is 1 (proper rotation, not a reflection)
+    assert torch.allclose(torch.det(calculated_rotation), torch.tensor(1.0))
+
+
+def test_weighted_kabsch_basic():
+    """"""Test weighted_kabsch function with mocked dependencies.""""""
+
+    # Create test inputs
+    moving_tensor = torch.tensor([
+        [1.0, 2.0, 3.0],  # Atom 1
+        [2.0, 3.0, 4.0],  # Atom 2
+        [3.0, 4.0, 5.0],  # Atom 3
+        [4.0, 5.0, 6.0],  # Atom 4
+    ])
+
+    ref_tensor = torch.tensor([
+        [2.0, 3.0, 4.0],  # Atom 1 (moved)
+        [3.0, 4.0, 5.0],  # Atom 2 (moved)
+        [4.0, 5.0, 6.0],  # Atom 3 (moved)
+        [5.0, 6.0, 7.0],  # Atom 4 (moved)
+    ])
+
+    # Create cra_name list with backbone atoms
+    cra_name = [
+        ""A-1-GLY-N"",
+        ""A-2-ALA-CA"",
+        ""A-3-VAL-C"",
+        ""A-4-LEU-O"",
+    ]
+
+    # Create a mock Rotation class
+    class MockRotation:
+        def as_matrix(self):
+            # Identity rotation
+            return np.eye(3)
+
+        @classmethod
+        def align_vectors(cls, target, source, weights=None):
+            # Return the mock rotation and a dummy residual
+            return (MockRotation(), 0.0)
+
+    # Expected result to return from align_tensors
+    expected_aligned = torch.tensor([
+        [2.0, 3.0, 4.0],  # Aligned with reference
+        [3.0, 4.0, 5.0],
+        [4.0, 5.0, 6.0],
+        [5.0, 6.0, 7.0],
+    ])
+
+    # Patch both Rotation class and align_tensors function
+    with (
+        patch(""rocket.coordinates.Rotation"", MockRotation),
+        patch(""rocket.coordinates.align_tensors"", return_value=expected_aligned),
+    ):
+        # Call the function
+        aligned_tensor = weighted_kabsch(moving_tensor, ref_tensor, cra_name)
+
+    # Check that we got the expected tensor back
+    assert torch.equal(aligned_tensor, expected_aligned)
+","Python"
+"AlphaFold","alisiafadini/ROCKET","test/unit/test_xtal_utils.py",".py","5044","179","import numpy as np
+import torch
+
+from rocket.xtal.utils import (
+    Ak_approx,
+    compute_sigmaA_true,
+    find_bin_dHKL,
+    interpolate_smooth,
+    lb_Ak,
+    llgIa_calculate,
+    llgIa_firstdev,
+    llgIa_seconddev,
+    llgIc_calculate,
+    llgIc_firstdev,
+    llgIc_seconddev,
+    llgItot_calculate,
+    llgItot_firstdev,
+    llgItot_with_derivatives2sigmaA,
+    logcosh,
+    newton_step,
+    ub_Ak,
+)
+
+
+def test_newton_step_identity():
+    x = torch.tensor([1.0, 2.0])
+    grad = torch.tensor([0.1, -0.2])
+    Hessian = torch.eye(2)
+    result = newton_step(x, grad, Hessian)
+    expected = x - grad
+    assert torch.allclose(result, expected, atol=1e-6)
+
+
+def test_newton_step_zero_grad():
+    x = torch.tensor([1.0, 2.0])
+    grad = torch.zeros(2)
+    Hessian = torch.eye(2)
+    result = newton_step(x, grad, Hessian)
+    assert torch.allclose(result, x)
+
+
+def test_llgIa_firstdev_simple():
+    sA = torch.tensor([0.5])
+    d = torch.tensor([1.0])
+    Eeff = torch.tensor([1.0])
+    Ec = torch.tensor([1.0])
+    result = llgIa_firstdev(sA, d, Eeff, Ec)
+    assert torch.isfinite(result).all()
+
+
+def test_llgIc_firstdev_simple():
+    sA = torch.tensor([0.5])
+    d = torch.tensor([1.0])
+    Eeff = torch.tensor([1.0])
+    Ec = torch.tensor([1.0])
+    result = llgIc_firstdev(sA, d, Eeff, Ec)
+    assert torch.isfinite(result).all()
+
+
+def test_llgItot_firstdev_mix():
+    sigmaA = torch.tensor([0.5, 0.6])
+    d = torch.tensor([1.0, 1.0])
+    Eeff = torch.tensor([1.0, 1.0])
+    Ec = torch.tensor([1.0, 1.0])
+    centric = torch.tensor([True, False])
+    total = llgItot_firstdev(sigmaA, d, Eeff, Ec, centric)
+    part_c = llgIc_firstdev(sigmaA, d[centric], Eeff[centric], Ec[centric])
+    part_a = llgIa_firstdev(sigmaA, d[~centric], Eeff[~centric], Ec[~centric])
+    expected = part_c.sum() + part_a.sum()
+    assert torch.allclose(total, expected)
+
+
+def test_llgIa_seconddev_finite():
+    sA = torch.tensor([0.5])
+    d = torch.tensor([1.0])
+    Eeff = torch.tensor([1.0])
+    Ec = torch.tensor([1.0])
+    out = llgIa_seconddev(sA, d, Eeff, Ec)
+    assert torch.isfinite(out).all()
+
+
+def test_llgIc_seconddev_finite():
+    sA = torch.tensor([0.5])
+    d = torch.tensor([1.0])
+    Eeff = torch.tensor([1.0])
+    Ec = torch.tensor([1.0])
+    out = llgIc_seconddev(sA, d, Eeff, Ec)
+    assert torch.isfinite(out).all()
+
+
+def test_interpolate_smooth_linear_zero():
+    sigmaAs = torch.tensor([1.0, 2.0, 3.0, 4.0])
+    out = interpolate_smooth(sigmaAs)
+    assert out >= 0
+
+
+def test_llgItot_with_derivatives2sigmaA_matches_autodiff():
+    sigmaA = torch.tensor([0.5], requires_grad=True)
+    d = torch.tensor([1.0])
+    Eeff = torch.tensor([1.0])
+    Ec = torch.tensor([1.0])
+    centric = torch.tensor([False])
+    l1, lp1, lpp1 = llgItot_with_derivatives2sigmaA(
+        sigmaA, d, Eeff, Ec, centric, method=""autodiff""
+    )
+    l2, lp2, lpp2 = llgItot_with_derivatives2sigmaA(
+        sigmaA, d, Eeff, Ec, centric, method=""analytical""
+    )
+    print((lp1 - lp2).abs())
+    assert torch.allclose(l1, l2, atol=1e-5)
+    assert torch.allclose(lp1, lp2, atol=1e-2)  # TODO this is too high!!!
+    assert torch.allclose(lpp1, lpp2, atol=5e-1)  # TODO this is too high!!!
+
+
+def test_Ak_approx_bounds():
+    nu = torch.tensor([1.0])
+    z = torch.tensor([2.0])
+    lb = lb_Ak(nu, z)
+    ub = ub_Ak(nu, z)
+    ak = Ak_approx(nu, z)
+    assert torch.all(lb <= ak)
+    assert torch.all(ak <= ub)
+
+
+def test_llgIa_calculate_simple():
+    sA = torch.tensor([0.5])
+    d = torch.tensor([1.0])
+    Eeff = torch.tensor([1.0])
+    Ec = torch.tensor([1.0])
+    out = llgIa_calculate(sA, d, Eeff, Ec)
+    assert torch.isfinite(out).all()
+
+
+def test_llgIc_calculate_simple():
+    sA = torch.tensor([0.5])
+    d = torch.tensor([1.0])
+    Eeff = torch.tensor([1.0])
+    Ec = torch.tensor([1.0])
+    out = llgIc_calculate(sA, d, Eeff, Ec)
+    assert torch.isfinite(out).all()
+
+
+def test_llgItot_calculate_simple():
+    sA = torch.tensor([0.5, 0.7])
+    d = torch.tensor([1.0, 1.0])
+    Eeff = torch.tensor([1.0, 1.0])
+    Ec = torch.tensor([1.0, 1.0])
+    centric = torch.tensor([False, True])
+    out = llgItot_calculate(sA, d, Eeff, Ec, centric)
+    assert torch.isfinite(out).all()
+
+
+def test_logcosh_matches_numpy():
+    xs = torch.tensor([-2.0, 0.0, 2.0])
+    out = logcosh(xs)
+    np_out = np.log(np.cosh(xs.numpy()))
+    assert np.allclose(out.numpy(), np_out, atol=1e-6)
+
+
+def test_find_bin_dHKL_simple():
+    dHKLs = torch.tensor([1.0, 2.0, 3.0, 4.0])
+    bin_labels = torch.tensor([0, 0, 1, 1])
+    out = find_bin_dHKL(dHKLs, bin_labels)
+    assert out[0] == out[1]
+    assert out[2] == out[3]
+    # Check value is mean of min and max for each bin
+    assert np.isclose(out[0], 1.5)
+    assert np.isclose(out[2], 3.5)
+
+
+def test_compute_sigmaA_true_all_phases_aligned():
+    Eobs = np.array([1.0, 2.0])
+    phiobs = np.array([0.0, 0.0])
+    Ecalc = np.array([1.0, 2.0])
+    phicalc = np.array([0.0, 0.0])
+    bin_labels = np.array([0, 0])
+    out = compute_sigmaA_true(Eobs, phiobs, Ecalc, phicalc, bin_labels)
+    assert np.isclose(out[0], 2.5)
+","Python"
+"AlphaFold","alisiafadini/ROCKET","test/unit/test_refinement_utils.py",".py","27696","807","from unittest.mock import MagicMock, patch
+
+import numpy as np
+import pytest
+import torch
+
+from rocket.refinement_utils import (
+    EarlyStopper,
+    generate_feature_dict,
+    get_common_bb_ind,
+    get_common_ca_ind,
+    get_current_lr,
+    get_identical_indices,
+    get_pattern_index,
+    init_bias,
+    init_llgloss,
+    init_processed_dict,
+    number_to_letter,
+    position_alignment,
+    sigmaA_from_true,
+    update_sigmaA,
+)
+
+
+@pytest.fixture
+def mock_data_processor():
+    """"""Create a mock data processor object with process_fasta method.""""""
+    data_processor = MagicMock()
+    data_processor.process_fasta.return_value = {""features"": ""test_features""}
+    return data_processor
+
+
+def test_generate_feature_dict(mock_data_processor):
+    expected_result = {""features"": ""test_features""}
+
+    fasta_path = ""/path/to/fasta""
+    alignment_dir = ""/path/to/alignment""
+
+    result = generate_feature_dict(
+        fasta_path=fasta_path,
+        alignment_dir=alignment_dir,
+        data_processor=mock_data_processor,
+    )
+
+    # Verify process_fasta was called with correct parameters
+    mock_data_processor.process_fasta.assert_called_once_with(
+        fasta_path=fasta_path, alignment_dir=alignment_dir, seqemb_mode=False
+    )
+    assert result == expected_result
+
+
+def test_number_to_letter():
+    # Test valid cases (0-25 should map to A-Z)
+    assert number_to_letter(0) == ""A""
+    assert number_to_letter(1) == ""B""
+    assert number_to_letter(25) == ""Z""
+
+    # Test boundary cases
+    assert number_to_letter(-1) is None
+    assert number_to_letter(26) is None
+
+    # Test some middle values
+    assert number_to_letter(7) == ""H""
+    assert number_to_letter(12) == ""M""
+    assert number_to_letter(19) == ""T""
+
+
+def test_get_identical_indices():
+    # Test case from docstring
+    A = ""EWTUY""
+    B = ""E-RUY""
+    ind_A, ind_B = get_identical_indices(A, B)
+    assert ind_A.tolist() == [0, 3, 4]
+    assert ind_B.tolist() == [0, 2, 3]
+
+    # Test with identical strings
+    A = ""ABCDE""
+    B = ""ABCDE""
+    ind_A, ind_B = get_identical_indices(A, B)
+    assert ind_A.tolist() == [0, 1, 2, 3, 4]
+    assert ind_B.tolist() == [0, 1, 2, 3, 4]
+
+    # Test with no identical characters
+    A = ""ABCDE""
+    B = ""FGHIJ""
+    ind_A, ind_B = get_identical_indices(A, B)
+    assert ind_A.tolist() == []
+    assert ind_B.tolist() == []
+
+    # Test with gaps in both sequences
+    A = ""A-BC-DE""
+    B = ""-AB-CDE""
+    ind_A, ind_B = get_identical_indices(A, B)
+    assert ind_A.tolist() == [1, 3, 4]
+    assert ind_B.tolist() == [1, 3, 4]
+
+    # Test with empty strings
+    A = """"
+    B = """"
+    ind_A, ind_B = get_identical_indices(A, B)
+    assert ind_A.tolist() == []
+    assert ind_B.tolist() == []
+
+
+def test_get_pattern_index():
+    # Test with more complex patterns
+    pdb_like_list = [""A-1-ASP-CA"", ""A-2-GLY-N"", ""A-2-GLY-CA"", ""A-3-PHE-CA""]
+    # Find the CA atom of residue 2
+    pattern = r"".*-2-.*-CA$""
+    assert get_pattern_index(pdb_like_list, pattern) == 2
+
+    # Find any atom of PHE
+    pattern = r"".*-PHE-.*""
+    assert get_pattern_index(pdb_like_list, pattern) == 3
+
+
+@pytest.fixture
+def mock_pdb1():
+    """"""Simple mock PDBParser for first protein.""""""
+    pdb = MagicMock()
+    pdb.sequence = ""GFTT""
+    pdb.cra_name = [
+        ""A-0-GLY-CA"",
+        ""A-1-PHE-CA"",
+        ""A-2-THR-CA"",
+        ""A-3-THR-CA"",
+        ""A-3-THR-N"",
+    ]
+    return pdb
+
+
+@pytest.fixture
+def mock_pdb2():
+    """"""Simple mock PDBParser for second protein.""""""
+    pdb = MagicMock()
+    pdb.sequence = ""DGFTT""
+    pdb.cra_name = [
+        ""A-0-ASP-CA"",
+        ""A-1-GLY-CA"",
+        ""A-2-PHE-CA"",
+        ""A-3-THR-CA"",
+        ""A-4-THR-CA"",
+        ""A-4-THR-N"",
+    ]
+    return pdb
+
+
+def test_get_common_ca_ind(mock_pdb1, mock_pdb2):
+    """"""Minimal test to verify the I/O pipeline of get_common_ca_ind.""""""
+
+    # Call the function
+    common_ind1, common_ind2 = get_common_ca_ind(mock_pdb1, mock_pdb2)
+
+    # Verify the function returns numpy arrays
+    assert isinstance(common_ind1, list)
+    assert isinstance(common_ind2, list)
+
+    assert common_ind1 == [0, 1, 2, 3]
+    assert common_ind2 == [1, 2, 3, 4]
+
+
+def test_get_common_bb_ind(mock_pdb1, mock_pdb2):
+    """"""Minimal test to verify the I/O pipeline of get_common_ca_ind.""""""
+
+    # Call the function
+    common_ind1, common_ind2 = get_common_bb_ind(mock_pdb1, mock_pdb2)
+
+    # Verify the function returns numpy arrays
+    assert isinstance(common_ind1, list)
+    assert isinstance(common_ind2, list)
+
+    assert common_ind1 == [0, 1, 2, 3, 4]
+    assert common_ind2 == [1, 2, 3, 4, 5]
+
+
+def test_get_current_lr():
+    """"""Test that get_current_lr returns the learning rate from optimizer.""""""
+    # Create a mock optimizer with param_groups
+    optimizer = MagicMock()
+
+    # Set up the mock to have param_groups with a learning rate
+    expected_lr = 0.001
+    optimizer.param_groups = [{""lr"": expected_lr}]
+
+    # Test that the function returns the expected learning rate
+    result = get_current_lr(optimizer)
+    assert result == expected_lr
+
+    # Test with a different learning rate
+    new_lr = 0.0001
+    optimizer.param_groups = [{""lr"": new_lr}]
+    result = get_current_lr(optimizer)
+    assert result == new_lr
+
+
+def test_early_stopper():
+    """"""Test basic functionality of EarlyStopper.""""""
+    # Create EarlyStopper with small patience for testing
+    stopper = EarlyStopper(patience=2, min_delta=0.1)
+
+    # First call should set the minimum loss and return False (don't stop)
+    assert stopper.early_stop(10.0) is False
+    assert stopper.min_loss == 10.0
+    assert stopper.counter == 0
+
+    # Significant improvement should reset counter and return False
+    assert stopper.early_stop(9.8) is False
+    assert stopper.min_loss == 9.8
+    assert stopper.counter == 0
+
+    # No significant improvement should increment counter and return False
+    assert stopper.early_stop(9.75) is False
+    assert stopper.min_loss == 9.8  # Unchanged
+    assert stopper.counter == 1
+
+    # Still no improvement - should hit patience limit and return True (stop)
+    assert stopper.early_stop(9.85) is True
+    assert stopper.counter == 2
+
+
+@patch(""rocket.make_processed_dict_from_template"")
+@patch(""glob.glob"")
+@patch(""builtins.open"")
+@patch(""pickle.load"")
+def test_init_processed_dict(mock_pickle_load, mock_open, mock_glob, mock_make_dict):
+    """"""Test init_processed_dict with both bias_version=4 and other values.""""""
+    # Mock device
+    device = torch.device(""cpu"")
+
+    # Test with bias_version=4 (uses make_processed_dict_from_template)
+    # Setup mock return value for rocket.make_processed_dict_from_template
+    mock_processed_dict = {""template_torsion_angles_sin_cos"": torch.ones(5, 4, 2)}
+    mock_make_dict.return_value = mock_processed_dict
+
+    # Call the function
+    result_dict, feature_key, features = init_processed_dict(
+        bias_version=4,
+        path=""/test/path"",
+        device=device,
+        template_pdb=""template.pdb"",
+        target_seq=""ABCDEFG"",
+    )
+
+    # Verify the function called make_processed_dict_from_template
+    mock_make_dict.assert_called_once_with(
+        template_pdb=""/test/path/ROCKET_inputs/template.pdb"",
+        target_seq=""ABCDEFG"",
+        config_preset=""model_1_ptm"",
+        device=device,
+        msa_dict=None,
+    )
+
+    # Verify returned values
+    assert result_dict == mock_processed_dict
+    assert feature_key == ""template_torsion_angles_sin_cos""
+    assert torch.equal(features, mock_processed_dict[""template_torsion_angles_sin_cos""])
+
+    # Reset mocks for next test
+    mock_make_dict.reset_mock()
+
+    # Test with bias_version=1 (uses pickle loading)
+    # Setup mock returns for glob, open, and pickle.load
+    mock_glob.return_value = [""/test/path/predictions/test_processed_feats.pickle""]
+    mock_pickle_dict = {""msa_feat"": torch.ones(5, 10, 23), ""aatype"": torch.zeros(10)}
+    mock_pickle_load.return_value = mock_pickle_dict
+
+    # Call the function with bias_version=1
+    result_dict, feature_key, features = init_processed_dict(
+        bias_version=1, path=""/test/path"", device=device
+    )
+
+    # Verify the glob pattern was correct
+    mock_glob.assert_called_once_with(""/test/path/predictions/*processed_feats.pickle"")
+
+    # Verify pickle.load was called
+    mock_pickle_load.assert_called_once()
+
+    # Verify returned values
+    assert feature_key == ""msa_feat""
+    assert torch.equal(features, mock_pickle_dict[""msa_feat""])
+    assert ""msa_feat"" in result_dict
+    assert ""aatype"" in result_dict
+
+
+def test_init_llgloss():
+    """"""Test init_llgloss creates LLGloss object with correct parameters.""""""
+    # Mock the structure factor object
+    mock_sfc = MagicMock()
+    mock_sfc.dHKL = torch.tensor([1.5, 2.0, 2.5, 3.0, 3.5])
+    mock_sfc.device = ""cpu""
+
+    # Mock the tng_file path
+    mock_tng_file = ""/path/to/test.tng""
+
+    # Mock the LLGloss constructor
+    with patch(""rocket.xtal.targets.LLGloss"") as mock_llgloss_class:
+        # Create a mock LLGloss object to be returned
+        mock_llgloss = MagicMock()
+        mock_llgloss_class.return_value = mock_llgloss
+
+        # Call the function with default resolution parameters
+        result = init_llgloss(mock_sfc, mock_tng_file)
+
+        # Verify LLGloss was created with correct parameters
+        mock_llgloss_class.assert_called_once_with(
+            mock_sfc,
+            mock_tng_file,
+            mock_sfc.device,
+            min(mock_sfc.dHKL),
+            max(mock_sfc.dHKL),
+        )
+
+        # Verify the function returns the LLGloss object
+        assert result == mock_llgloss
+
+        # Reset mock for next test
+        mock_llgloss_class.reset_mock()
+
+        # Test with custom resolution parameters
+        min_res = 2.0
+        max_res = 3.0
+        result = init_llgloss(
+            mock_sfc, mock_tng_file, min_resolution=min_res, max_resolution=max_res
+        )  # noqa: E501
+
+        # Verify LLGloss was created with custom resolution parameters
+        mock_llgloss_class.assert_called_once_with(
+            mock_sfc, mock_tng_file, mock_sfc.device, min_res, max_res
+        )
+
+
+@patch(""torch.optim.Adam"")
+@patch(""torch.optim.AdamW"")
+def test_init_bias(mock_adamw, mock_adam):
+    """"""Test init_bias function with different bias versions.""""""
+    # Mock the device and learning rates
+    device = torch.device(""cpu"")
+    lr_a = 1e-3
+    lr_m = 1e-4
+
+    # Create a mock device_processed_features with minimum required data
+    mock_features = {
+        ""aatype"": torch.zeros(10)  # Simulate a sequence with 10 residues
+    }
+
+    # Set up the mocked optimizers
+    mock_optimizer = MagicMock()
+    mock_adam.return_value = mock_optimizer
+    mock_adamw.return_value = mock_optimizer
+
+    # Test bias_version=3
+    result_features, optimizer, bias_names = init_bias(
+        device_processed_features=mock_features,
+        bias_version=3,
+        device=device,
+        lr_a=lr_a,
+        lr_m=lr_m,
+    )
+
+    # Check that msa_feat_bias was created with correct shape
+    assert ""msa_feat_bias"" in result_features
+    assert result_features[""msa_feat_bias""].shape == (512, 10, 23)
+    assert result_features[""msa_feat_weights""].shape == (512, 10, 23)
+    assert result_features[""msa_feat_bias""].requires_grad
+
+    # Check optimizer was created with correct parameters
+    mock_adam.assert_called_once()
+    assert bias_names == [""msa_feat_bias"", ""msa_feat_weights""]
+
+    # Reset mocks for next test
+    mock_adam.reset_mock()
+    mock_adamw.reset_mock()
+
+    # Test bias_version=1
+    result_features, optimizer, bias_names = init_bias(
+        device_processed_features=mock_features,
+        bias_version=1,
+        device=device,
+        lr_a=lr_a,
+        lr_m=lr_m,
+    )
+
+    # Check that msa_feat_bias was created with correct shape
+    assert ""msa_feat_bias"" in result_features
+    assert result_features[""msa_feat_bias""].shape == (512, 10, 23)
+    assert result_features[""msa_feat_bias""].requires_grad
+
+    # Check optimizer was created with correct parameters
+    mock_adam.assert_called_once()
+    assert bias_names == [""msa_feat_bias""]
+
+    # Reset mocks for next test
+    mock_adam.reset_mock()
+    mock_adamw.reset_mock()
+
+    # Test bias_version=4
+    result_features, optimizer, bias_names = init_bias(
+        device_processed_features={
+            ""aatype"": torch.zeros(10),
+            ""template_torsion_angles_sin_cos"": torch.zeros(10, 5, 2),
+        },
+        bias_version=4,
+        device=device,
+        lr_a=lr_a,
+        lr_m=lr_m,
+    )
+
+    # Check that template_torsion_angles_sin_cos_bias was created
+    assert ""template_torsion_angles_sin_cos_bias"" in result_features
+    assert result_features[""template_torsion_angles_sin_cos_bias""].shape == (10, 5, 2)
+    assert result_features[""template_torsion_angles_sin_cos_bias""].requires_grad
+
+    # Check bias names
+    assert bias_names == [""template_torsion_angles_sin_cos_bias""]
+
+    # Reset mocks for weight decay test
+    mock_adam.reset_mock()
+    mock_adamw.reset_mock()
+
+    # Test with weight_decay
+    result_features, optimizer, bias_names = init_bias(
+        device_processed_features=mock_features,
+        bias_version=2,
+        device=device,
+        lr_a=lr_a,
+        lr_m=lr_m,
+        weight_decay=0.01,
+    )
+
+    # Check AdamW was called instead of Adam
+    mock_adamw.assert_called_once()
+    mock_adam.assert_not_called()
+
+
+@patch(""rocket.coordinates.extract_allatoms"")
+@patch(""rocket.coordinates.iterative_kabsch_alignment"")
+@patch(""rocket.utils.plddt2pseudoB_pt"")
+@patch(""rocket.utils.weighting"")
+@patch(""rocket.utils.assert_numpy"")
+def test_position_alignment(
+    mock_assert_numpy,
+    mock_weighting,
+    mock_plddt2pseudoB,
+    mock_weighted_kabsch,
+    mock_extract_allatoms,
+):
+    """"""Test position_alignment with mocked dependencies.""""""
+    # Create mock inputs
+    af2_output = {
+        ""plddt"": torch.ones(10) * 90.0  # 10 residues with good plddt scores
+    }
+    device_processed_features = {}
+    cra_name = [""A-1-GLY-CA"", ""A-1-GLY-N"", ""A-2-ALA-CA""]
+    best_pos = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])
+    exclude_res = []
+
+    # Configure mocks
+    # extract_allatoms returns coordinates and plddts
+    mock_extract_allatoms.return_value = (
+        torch.ones((3, 3)),  # xyz coordinates
+        torch.ones(3),  # plddts for atoms
+    )
+
+    # Configure assert_numpy to return numpy arrays
+    mock_assert_numpy.side_effect = (
+        lambda x: x.numpy() if isinstance(x, torch.Tensor) else x
+    )  # noqa: E501
+
+    # Configure plddt2pseudoB to return B-factors
+    pseudo_bs = torch.ones(3) * 30.0
+    mock_plddt2pseudoB.return_value = pseudo_bs
+
+    # Configure weighting to return weights
+    weights = np.ones(3)
+    mock_weighting.return_value = weights
+
+    # Configure weighted_kabsch to return aligned coordinates
+    aligned_xyz = torch.tensor([[1.5, 2.5, 3.5], [4.5, 5.5, 6.5], [7.5, 8.5, 9.5]])
+    mock_weighted_kabsch.return_value = aligned_xyz
+
+    # Call the function
+    result_xyz, result_plddts, result_bs = position_alignment(
+        af2_output, device_processed_features, cra_name, best_pos, exclude_res
+    )
+
+    # Verify the function works as expected
+    assert torch.equal(result_xyz, aligned_xyz)
+    assert torch.equal(torch.tensor(result_plddts), af2_output[""plddt""])
+    assert torch.equal(result_bs, pseudo_bs)
+
+    # Check that extract_allatoms was called with correct arguments
+    mock_extract_allatoms.assert_called_once_with(
+        af2_output, device_processed_features, cra_name
+    )
+
+    # Check that weighted_kabsch was called with correct arguments
+    mock_weighted_kabsch.assert_called_once()
+    args, kwargs = mock_weighted_kabsch.call_args
+    assert torch.equal(args[0], torch.ones((3, 3)))  # xyz_orth_sfc
+    assert torch.equal(args[1], best_pos)  # best_pos
+    assert args[2] == cra_name  # cra_name
+    assert np.array_equal(kwargs[""weights""], weights)  # weights
+    assert kwargs[""exclude_res""] == exclude_res  # exclude_res
+
+
+@patch(""rocket.coordinates.extract_allatoms"")
+@patch(""rocket.coordinates.iterative_kabsch_alignment"")
+@patch(""rocket.utils.plddt2pseudoB_pt"")
+@patch(""rocket.utils.weighting"")
+@patch(""rocket.utils.assert_numpy"")
+def test_position_alignment_with_reference_bfactor(
+    mock_assert_numpy,
+    mock_weighting,
+    mock_plddt2pseudoB,
+    mock_weighted_kabsch,
+    mock_extract_allatoms,
+):
+    """"""Test position_alignment with reference_bfactor parameter.""""""
+    # Create mock inputs
+    af2_output = {""plddt"": torch.ones(10) * 90.0}
+    device_processed_features = {}
+    cra_name = [""A-1-GLY-CA"", ""A-1-GLY-N"", ""A-2-ALA-CA""]
+    best_pos = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])
+    exclude_res = []
+    reference_bfactor = torch.ones(3) * 20.0
+
+    # Configure mocks as before
+    mock_extract_allatoms.return_value = (torch.ones((3, 3)), torch.ones(3))
+    mock_assert_numpy.side_effect = (
+        lambda x: x.numpy() if isinstance(x, torch.Tensor) else x
+    )  # noqa: E501
+    mock_plddt2pseudoB.return_value = torch.ones(3) * 30.0
+    mock_weighting.return_value = np.ones(3)
+    mock_weighted_kabsch.return_value = torch.tensor([
+        [1.5, 2.5, 3.5],
+        [4.5, 5.5, 6.5],
+        [7.5, 8.5, 9.5],
+    ])
+
+    # Call the function with reference_bfactor
+    position_alignment(
+        af2_output,
+        device_processed_features,
+        cra_name,
+        best_pos,
+        exclude_res,
+        reference_bfactor=reference_bfactor,
+    )
+
+    # Check that weighting was called with reference_bfactor instead of pseudo_Bs
+    mock_weighting.assert_called_once()
+    args = mock_weighting.call_args[0]
+    # Should be using reference_bfactor.numpy()
+    assert np.array_equal(args[0], reference_bfactor.numpy())
+
+
+def test_update_sigmaA():
+    """"""Test update_sigmaA with mocked LLGloss objects.""""""
+    # Create mock LLGloss objects
+    llgloss = MagicMock()
+    llgloss_rbr = MagicMock()
+
+    # Create a mock for aligned_xyz
+    aligned_xyz = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])
+
+    # Set up return values for compute_Ecalc
+    mock_ecalc = torch.tensor([0.5, 0.6, 0.7])
+    mock_fc = torch.tensor([1.0 + 2.0j, 3.0 + 4.0j, 5.0 + 6.0j])
+    llgloss.compute_Ecalc.return_value = (mock_ecalc, mock_fc)
+
+    mock_ecalc_rbr = torch.tensor([0.4, 0.5, 0.6])
+    mock_fc_rbr = torch.tensor([0.5 + 1.0j, 1.5 + 2.0j, 2.5 + 3.0j])
+    llgloss_rbr.compute_Ecalc.return_value = (mock_ecalc_rbr, mock_fc_rbr)
+
+    # Test with no constant_fp parameters
+    result_llgloss, result_llgloss_rbr, result_ecalc, result_fc = update_sigmaA(
+        llgloss, llgloss_rbr, aligned_xyz
+    )
+
+    # Verify that compute_Ecalc was called correctly
+    llgloss.compute_Ecalc.assert_called_once()
+    # Use ANY for tensor arguments to avoid tensor comparison issues
+    args, kwargs = llgloss.compute_Ecalc.call_args
+    assert torch.equal(args[0], aligned_xyz.detach())
+    assert kwargs[""return_Fc""] is True
+    assert kwargs[""update_scales""] is True
+    assert kwargs[""added_chain_HKL""] is None
+    assert kwargs[""added_chain_asu""] is None
+
+    # Verify that compute_Ecalc was called correctly for llgloss_rbr
+    llgloss_rbr.compute_Ecalc.assert_called_once()
+    args, kwargs = llgloss_rbr.compute_Ecalc.call_args
+    assert torch.equal(args[0], aligned_xyz.detach())
+    assert kwargs[""return_Fc""] is True
+    assert kwargs[""solvent""] is False
+    assert kwargs[""update_scales""] is True
+    assert kwargs[""added_chain_HKL""] is None
+    assert kwargs[""added_chain_asu""] is None
+
+    # Verify that refine_sigmaA_newton was called with correct parameters
+    llgloss.refine_sigmaA_newton.assert_called_once()
+    args, kwargs = llgloss.refine_sigmaA_newton.call_args
+    assert torch.equal(args[0], mock_ecalc)
+    assert kwargs[""n_steps""] == 5
+    assert kwargs[""subset""] == ""working""
+    assert kwargs[""smooth_overall_weight""] == 0.0
+
+    # Verify that refine_sigmaA_newton was called correctly for llgloss_rbr
+    llgloss_rbr.refine_sigmaA_newton.assert_called_once()
+    args, kwargs = llgloss_rbr.refine_sigmaA_newton.call_args
+    assert torch.equal(args[0], mock_ecalc_rbr)
+    assert kwargs[""n_steps""] == 2
+    assert kwargs[""subset""] == ""working""
+    assert kwargs[""smooth_overall_weight""] == 0.0
+
+    # Verify that the function returns the expected values
+    assert result_llgloss == llgloss
+    assert result_llgloss_rbr == llgloss_rbr
+    assert torch.equal(result_ecalc, mock_ecalc)
+    assert torch.equal(result_fc, mock_fc)
+
+    # Reset mocks for the next test
+    llgloss.reset_mock()
+    llgloss_rbr.reset_mock()
+
+    # Test with constant_fp parameters
+    constant_fp_added_HKL = torch.tensor([0.1, 0.2, 0.3])
+    constant_fp_added_asu = torch.tensor([0.4, 0.5, 0.6])
+
+    update_sigmaA(
+        llgloss,
+        llgloss_rbr,
+        aligned_xyz,
+        constant_fp_added_HKL=constant_fp_added_HKL,
+        constant_fp_added_asu=constant_fp_added_asu,
+    )
+
+    # Verify that compute_Ecalc was called with constant_fp parameters
+    llgloss.compute_Ecalc.assert_called_once()
+    args, kwargs = llgloss.compute_Ecalc.call_args
+    assert torch.equal(args[0], aligned_xyz.detach())
+    assert kwargs[""return_Fc""] is True
+    assert kwargs[""update_scales""] is True
+    assert torch.equal(kwargs[""added_chain_HKL""], constant_fp_added_HKL)
+    assert torch.equal(kwargs[""added_chain_asu""], constant_fp_added_asu)
+
+    # Verify that compute_Ecalc was called with constant_fp parameters for llgloss_rbr
+    llgloss_rbr.compute_Ecalc.assert_called_once()
+    args, kwargs = llgloss_rbr.compute_Ecalc.call_args
+    assert torch.equal(args[0], aligned_xyz.detach())
+    assert kwargs[""return_Fc""] is True
+    assert kwargs[""solvent""] is False
+    assert kwargs[""update_scales""] is True
+    assert torch.equal(kwargs[""added_chain_HKL""], constant_fp_added_HKL)
+    assert torch.equal(kwargs[""added_chain_asu""], constant_fp_added_asu)
+
+
+def tensor_call_equal(call1, call2):
+    """"""Helper function to compare calls containing tensors.""""""
+    if len(call1) != len(call2):
+        return False
+
+    for arg1, arg2 in zip(call1, call2, strict=False):
+        if isinstance(arg1, torch.Tensor) and isinstance(arg2, torch.Tensor):
+            if not torch.equal(arg1, arg2):
+                return False
+        elif arg1 != arg2:
+            return False
+    return True
+
+
+@patch(""rocket.xtal.utils.sigmaA_from_model"")
+def test_sigmaA_from_true(mock_sigmaA_from_model):
+    """"""Test sigmaA_from_true with mocked dependencies.""""""
+    # Create mock LLGloss objects
+    llgloss = MagicMock()
+    llgloss_rbr = MagicMock()
+
+    # Configure bin_labels and dHKL properties that will be accessed
+    llgloss.bin_labels = torch.tensor([1, 2, 3])
+    llgloss.sfc.dHKL = torch.tensor([2.0, 2.5, 3.0])
+
+    # Create mock aligned_xyz, Etrue, and phitrue
+    aligned_xyz = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])
+    Etrue = torch.tensor([1.1, 1.2, 1.3])
+    phitrue = torch.tensor([0.1, 0.2, 0.3])
+
+    # Set up return values for compute_Ecalc
+    mock_ecalc = torch.tensor([0.5, 0.6, 0.7])
+    mock_fc = torch.tensor([1.0 + 2.0j, 3.0 + 4.0j, 5.0 + 6.0j])
+    llgloss.compute_Ecalc.return_value = (mock_ecalc, mock_fc)
+
+    mock_ecalc_rbr = torch.tensor([0.4, 0.5, 0.6])
+    mock_fc_rbr = torch.tensor([0.5 + 1.0j, 1.5 + 2.0j, 2.5 + 3.0j])
+    llgloss_rbr.compute_Ecalc.return_value = (mock_ecalc_rbr, mock_fc_rbr)
+
+    # Mock sigmaA_from_model return values
+    mock_sigmas = torch.tensor([0.8, 0.7, 0.6])
+    mock_sigmas_rbr = torch.tensor([0.85, 0.75, 0.65])
+    mock_sigmaA_from_model.side_effect = [mock_sigmas, mock_sigmas_rbr]
+
+    # Call the function
+    result_llgloss, result_llgloss_rbr = sigmaA_from_true(
+        llgloss, llgloss_rbr, aligned_xyz, Etrue, phitrue
+    )
+
+    # Verify compute_Ecalc was called correctly
+    llgloss.compute_Ecalc.assert_called_once()
+    args, kwargs = llgloss.compute_Ecalc.call_args
+    assert torch.equal(args[0], aligned_xyz.detach())
+    assert kwargs[""return_Fc""] is True
+    assert kwargs[""update_scales""] is True
+    assert kwargs[""added_chain_HKL""] is None
+    assert kwargs[""added_chain_asu""] is None
+
+    # Verify compute_Ecalc was called correctly for llgloss_rbr
+    llgloss_rbr.compute_Ecalc.assert_called_once()
+    args, kwargs = llgloss_rbr.compute_Ecalc.call_args
+    assert torch.equal(args[0], aligned_xyz.detach())
+    assert kwargs[""return_Fc""] is True
+    assert kwargs[""solvent""] is False
+    assert kwargs[""update_scales""] is True
+    assert kwargs[""added_chain_HKL""] is None
+    assert kwargs[""added_chain_asu""] is None
+
+    # Check if sigmaA_from_model was called with the expected arguments
+    assert mock_sigmaA_from_model.call_count == 2
+
+    # Check first call arguments (for llgloss)
+    args_llgloss = mock_sigmaA_from_model.call_args_list[0][0]
+    assert torch.equal(args_llgloss[0], Etrue)
+    assert torch.equal(args_llgloss[1], phitrue)
+    assert torch.equal(args_llgloss[2], mock_ecalc)
+    assert torch.equal(args_llgloss[3], mock_fc)
+    assert torch.equal(args_llgloss[4], llgloss.sfc.dHKL)
+    assert torch.equal(args_llgloss[5], llgloss.bin_labels)
+
+    # Check second call arguments (for llgloss_rbr)
+    args_llgloss_rbr = mock_sigmaA_from_model.call_args_list[1][0]
+    assert torch.equal(args_llgloss_rbr[0], Etrue)
+    assert torch.equal(args_llgloss_rbr[1], phitrue)
+    assert torch.equal(args_llgloss_rbr[2], mock_ecalc_rbr)
+    assert torch.equal(args_llgloss_rbr[3], mock_fc_rbr)
+    assert torch.equal(args_llgloss_rbr[4], llgloss.sfc.dHKL)
+    assert torch.equal(args_llgloss_rbr[5], llgloss.bin_labels)
+
+    # Verify sigmaAs properties were updated correctly
+    assert torch.equal(llgloss.sigmaAs, mock_sigmas)
+    assert torch.equal(llgloss_rbr.sigmaAs, mock_sigmas_rbr)
+
+    # Verify the function returns the modified llgloss objects
+    assert result_llgloss is llgloss
+    assert result_llgloss_rbr is llgloss_rbr
+
+
+@patch(""rocket.xtal.utils.sigmaA_from_model"")
+def test_sigmaA_from_true_with_constant_fp(mock_sigmaA_from_model):
+    """"""Test sigmaA_from_true with constant_fp parameters.""""""
+    # Create mock LLGloss objects
+    llgloss = MagicMock()
+    llgloss_rbr = MagicMock()
+
+    # Configure necessary properties
+    llgloss.bin_labels = torch.tensor([1, 2, 3])
+    llgloss.sfc.dHKL = torch.tensor([2.0, 2.5, 3.0])
+
+    # Mock input parameters
+    aligned_xyz = torch.tensor([[1.0, 2.0, 3.0]])
+    Etrue = torch.tensor([1.1, 1.2, 1.3])
+    phitrue = torch.tensor([0.1, 0.2, 0.3])
+    constant_fp_added_HKL = torch.tensor([0.1, 0.2, 0.3])
+    constant_fp_added_asu = torch.tensor([0.4, 0.5, 0.6])
+
+    # Configure compute_Ecalc return values
+    llgloss.compute_Ecalc.return_value = (
+        torch.tensor([0.5]),
+        torch.tensor([1.0 + 2.0j]),
+    )
+    llgloss_rbr.compute_Ecalc.return_value = (
+        torch.tensor([0.4]),
+        torch.tensor([0.5 + 1.0j]),
+    )  # noqa: E501
+
+    # Configure sigmaA_from_model return values
+    mock_sigmaA_from_model.side_effect = [torch.tensor([0.8]), torch.tensor([0.85])]
+
+    # Call the function with constant_fp parameters
+    sigmaA_from_true(
+        llgloss,
+        llgloss_rbr,
+        aligned_xyz,
+        Etrue,
+        phitrue,
+        constant_fp_added_HKL=constant_fp_added_HKL,
+        constant_fp_added_asu=constant_fp_added_asu,
+    )
+
+    # Verify compute_Ecalc was called with constant_fp parameters
+    args, kwargs = llgloss.compute_Ecalc.call_args
+    assert torch.equal(kwargs[""added_chain_HKL""], constant_fp_added_HKL)
+    assert torch.equal(kwargs[""added_chain_asu""], constant_fp_added_asu)
+
+    # Verify compute_Ecalc was called with constant_fp parameters for llgloss_rbr
+    args, kwargs = llgloss_rbr.compute_Ecalc.call_args
+    assert torch.equal(kwargs[""added_chain_HKL""], constant_fp_added_HKL)
+    assert torch.equal(kwargs[""added_chain_asu""], constant_fp_added_asu)
+","Python"
+"AlphaFold","alisiafadini/ROCKET","test/unit/test_utils.py",".py","7274","268","# Mock external dependencies before importing utils
+from unittest.mock import MagicMock, patch
+
+import numpy as np
+import pytest
+import torch
+
+from rocket.utils import (
+    apply_resolution_cutoff,
+    assert_numpy,
+    assert_tensor,
+    convert_feat_tensors_to_numpy,
+    d2q,
+    dict_map,
+    get_params_path,
+    load_mtz,
+    load_pdb,
+    move_tensors_to_device,
+    move_tensors_to_device_inplace,
+    plddt2pseudoB_np,
+    tree_map,
+    try_gpu,
+    weighting,
+    weighting_torch,
+)
+
+
+def test_plddt2pseudoB_basic():
+    arr = np.array([0, 50, 100])
+    out = plddt2pseudoB_np(arr)
+    assert out.shape == arr.shape
+    assert np.all(out > 0)
+    assert np.isfinite(out).all()
+
+
+def test_plddt2pseudoB_empty():
+    arr = np.array([])
+    out = plddt2pseudoB_np(arr)
+    assert out.shape == arr.shape
+
+
+def test_weighting_cutoffs():
+    b = np.array([10.0, 11.5, 20.0, 30.0, 40.0])
+    w = weighting(b)
+    assert np.isclose(w[0], 1.0)
+    assert np.isclose(w[1], 1.0)
+    assert 0.5 < w[2] < 1.0
+    assert np.isclose(w[3], 0.5)
+    assert w[4] < 0.5
+
+
+def test_weighting_torch_matches_numpy():
+    b = torch.tensor([10.0, 11.5, 20.0, 30.0, 40.0])
+    wn = weighting(b.numpy())
+    wt = weighting_torch(b).numpy()
+    np.testing.assert_allclose(wn, wt, rtol=1e-5)
+
+
+def test_weighting_scalar():
+    w = weighting(10.0)
+    assert w == 1.0
+
+
+def test_dict_map_exclude_keys():
+    d = {""a"": 1, ""msa_feat_bias"": 2}
+
+    def fn(x):
+        return x + 1
+
+    out = dict_map(fn, d, int)
+    assert out[""a""] == 2
+    assert out[""msa_feat_bias""] == 2  # should not be mapped
+
+
+def test_tree_map_nested():
+    tree = {""a"": [1, 2], ""b"": (3, 4)}
+    out = tree_map(lambda x: x * 2, tree, int)
+    assert out[""a""] == [2, 4]
+    assert out[""b""] == (6, 8)
+
+
+def test_tree_map_non_supported():
+    class Dummy:
+        pass
+
+    with pytest.raises(ValueError):
+        tree_map(lambda x: x, Dummy(), int)
+
+
+def test_try_gpu_cpu():
+    with patch(""torch.cuda.device_count"", return_value=0):
+        dev = try_gpu()
+        assert str(dev) == ""cpu""
+
+
+def test_try_gpu_cuda():
+    with patch(""torch.cuda.device_count"", return_value=2):
+        dev = try_gpu(1)
+        assert str(dev) == ""cuda:1""
+
+
+def test_move_tensors_to_device():
+    d = {""a"": torch.zeros(2), ""b"": 3}
+    out = move_tensors_to_device(d, device=""cpu"")
+    assert out[""a""].device.type == ""cpu""
+    assert out[""b""] == 3
+
+
+def test_move_tensors_to_device_inplace():
+    d = {""a"": torch.zeros(2)}
+    move_tensors_to_device_inplace(d, device=""cpu"")
+    assert d[""a""].device.type == ""cpu""
+
+
+def test_convert_feat_tensors_to_numpy():
+    d = {""a"": torch.ones(2), ""b"": ""notensor""}
+    out = convert_feat_tensors_to_numpy(d)
+    assert isinstance(out[""a""], np.ndarray)
+    assert out[""b""] == ""notensor""
+
+
+def test_assert_numpy_from_tensor():
+    arr = torch.ones(2)
+    np_arr = assert_numpy(arr)
+    assert isinstance(np_arr, np.ndarray)
+
+
+def test_assert_numpy_from_list():
+    lst = [1, 2, 3]
+    np_arr = assert_numpy(lst)
+    assert isinstance(np_arr, np.ndarray)
+
+
+def test_assert_tensor_from_np():
+    arr = np.ones(2)
+    tensor = assert_tensor(arr, device=""cpu"")
+    assert isinstance(tensor, torch.Tensor)
+    assert tensor.device.type == ""cpu""
+
+
+def test_assert_tensor_from_list():
+    lst = [1, 2, 3]
+    tensor = assert_tensor(lst, device=""cpu"")
+    assert isinstance(tensor, torch.Tensor)
+    assert tensor.device.type == ""cpu""
+
+
+def test_d2q_scalar_and_array():
+    assert np.isclose(d2q(2.0), np.pi)
+    arr = np.array([1.0, 2.0])
+    out = d2q(arr)
+    assert np.allclose(out, 2 * np.pi / arr)
+
+
+def test_load_mtz():
+    with patch(""rocket.utils.rs.read_mtz"") as mock_read:
+        mock_ds = MagicMock()
+        mock_read.return_value = mock_ds
+        load_mtz(""file.mtz"")
+        mock_read.assert_called_once_with(""file.mtz"")
+        mock_ds.compute_dHKL.assert_called_once_with(inplace=True)
+
+
+def test_load_pdb():
+    with patch(""rocket.utils.PDBParser"") as mock_pdb:
+        load_pdb(""file.pdb"")
+        mock_pdb.assert_called_once_with(""file.pdb"")
+
+
+def test_get_params_path(monkeypatch):
+    monkeypatch.setenv(""OPENFOLD_RESOURCES"", ""/tmp/resources"")
+    path = get_params_path()
+    assert path == ""/tmp/resources/params""
+
+
+def test_get_params_path_missing(monkeypatch):
+    monkeypatch.delenv(""OPENFOLD_RESOURCES"", raising=False)
+    with pytest.raises(ValueError):
+        get_params_path()
+
+
+def test_apply_resolution_cutoff_with_dataset():
+    """"""
+    Test apply_resolution_cutoff with a DataSet object and explicit max_resolution.
+    """"""
+
+    # Setup mock dataset
+    mock_ds = MagicMock()
+    mock_ds.dHKL = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+
+    # Mock the filtering and copy chain
+    filtered_mock = MagicMock()
+    mock_ds.__getitem__.return_value = filtered_mock
+
+    # Call the function
+    result = apply_resolution_cutoff(mock_ds, min_resolution=2.0, max_resolution=4.0)
+
+    # Assertions
+    mock_ds.compute_dHKL.assert_called_once_with(inplace=True)
+
+    # Check that the filtering happened correctly
+    args, _ = mock_ds.__getitem__.call_args
+    mask = args[0]
+    expected_mask = (mock_ds.dHKL >= 2.0) & (mock_ds.dHKL <= 4.0)
+    np.testing.assert_array_equal(mask, expected_mask)
+
+    # Check that copy() was called on the filtered result
+    filtered_mock.copy.assert_called_once()
+
+    # Check that the final result is the copied, filtered mock
+    assert result == filtered_mock.copy.return_value
+
+
+def test_apply_resolution_cutoff_with_filepath():
+    """"""Test apply_resolution_cutoff with a file path string.""""""
+
+    with patch(""rocket.utils.rs.read_mtz"") as mock_read_mtz:
+        # Setup mock dataset
+        mock_ds = MagicMock()
+        mock_ds.dHKL = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        mock_read_mtz.return_value = mock_ds
+
+        # Mock the filtering and copy chain
+        filtered_mock = MagicMock()
+        mock_ds.__getitem__.return_value = filtered_mock
+
+        # Call the function
+        apply_resolution_cutoff(""test.mtz"", min_resolution=2.0, max_resolution=4.0)
+
+        # Assertions
+        mock_read_mtz.assert_called_once_with(""test.mtz"")
+        mock_ds.compute_dHKL.assert_called_once_with(inplace=True)
+
+        # Check filtering
+        args, _ = mock_ds.__getitem__.call_args
+        mask = args[0]
+        expected_mask = (mock_ds.dHKL >= 2.0) & (mock_ds.dHKL <= 4.0)
+        np.testing.assert_array_equal(mask, expected_mask)
+
+        filtered_mock.copy.assert_called_once()
+
+
+def test_apply_resolution_cutoff_no_max_resolution():
+    """"""Test apply_resolution_cutoff when max_resolution is not provided.""""""
+
+    # Setup mock dataset
+    mock_ds = MagicMock()
+    mock_ds.dHKL = np.array([1.0, 2.0, 3.0, 4.0, 5.0])  # .max() will be 5.0
+
+    # Mock the filtering and copy chain
+    filtered_mock = MagicMock()
+    mock_ds.__getitem__.return_value = filtered_mock
+
+    # Call the function
+    apply_resolution_cutoff(mock_ds, min_resolution=3.0)
+
+    # Assertions
+    mock_ds.compute_dHKL.assert_called_once_with(inplace=True)
+
+    # Check filtering logic
+    args, _ = mock_ds.__getitem__.call_args
+    mask = args[0]
+    # max_resolution should be inferred as 5.0
+    expected_mask = (mock_ds.dHKL >= 3.0) & (mock_ds.dHKL <= 5.0)
+    np.testing.assert_array_equal(mask, expected_mask)
+
+    filtered_mock.copy.assert_called_once()
+","Python"
+"AlphaFold","alisiafadini/ROCKET","test/unit/test_cryo_utils.py",".py","5819","191","import math
+from unittest.mock import patch
+
+import numpy as np
+import pandas as pd
+import pytest
+import torch
+
+from rocket.cryo import utils as cryo_utils
+
+
+# Test downsample_data
+@pytest.mark.parametrize(
+    ""downsample_ratio, expected_vals"",
+    [
+        (2, {1, 2, 4}),  # Only rows where all H/K/L divisible by 2
+        (1, {1, 2, 3, 4}),  # All rows should pass for ratio 1
+    ],
+)
+def test_downsample_data_masking_and_no_downsampling(downsample_ratio, expected_vals):
+    df = pd.DataFrame({
+        ""H"": [0, 2, 3, 4],
+        ""K"": [0, 2, 3, 4],
+        ""L"": [0, 2, 3, 4],
+        ""VAL"": [1, 2, 3, 4],
+    })
+    df.get_hkls = lambda: df[[""H"", ""K"", ""L""]].values
+
+    with patch(""reciprocalspaceship.read_mtz"", return_value=df):
+        result = cryo_utils.downsample_data(
+            ""dummy.mtz"", downsample_ratio=downsample_ratio
+        )
+        assert set(result[""VAL""]) == expected_vals
+        assert result.shape[0] == len(expected_vals)
+
+
+# Test compute_sigmaA_for_bin is within clamped values
+def test_compute_sigmaA_for_bin_typical():
+    # Chosen so cosdphi=1, everything positive, no sqrt_arg issues
+    eEsel = np.array([1.0, 2.0])
+    Ecalc_sel = np.array([1.0, 2.0])
+    dobssel = np.array([1.0, 1.0])
+    expectE_phi = np.array([0.0, 0.0])
+    Ecalc_phi = np.array([0.0, 0.0])
+    result = cryo_utils.compute_sigmaA_for_bin(
+        eEsel, Ecalc_sel, dobssel, expectE_phi, Ecalc_phi
+    )
+    assert 1e-6 <= result <= 0.999
+
+
+def test_compute_sigmaA_for_bin_zero_division_or_nan():
+    # Inputs that lead to denominator zero (all zeros)
+    eEsel = np.array([0.0, 0.0])
+    Ecalc_sel = np.array([0.0, 0.0])
+    dobssel = np.array([0.0, 0.0])
+    expectE_phi = np.array([0.0, 0.0])
+    Ecalc_phi = np.array([0.0, 0.0])
+    with pytest.raises((ZeroDivisionError, ValueError)):
+        cryo_utils.compute_sigmaA_for_bin(
+            eEsel, Ecalc_sel, dobssel, expectE_phi, Ecalc_phi
+        )
+
+
+# Test compute_sigmaA_error
+def test_compute_sigmaA_error_finite():
+    dobssel = np.array([0.5, 0.7])
+    sigmaA = 0.5
+    abseE = np.array([1.0, 2.0])
+    absEc = np.array([2.0, 1.0])
+    cosdphi = np.array([1.0, 1.0])
+    over_sampling_factor = 1.0
+    result = cryo_utils.compute_sigmaA_error(
+        dobssel, sigmaA, abseE, absEc, cosdphi, over_sampling_factor
+    )
+    assert isinstance(result, float)
+    assert result > 0
+
+
+# Test fit_line
+def test_fit_line_perfect():
+    x = np.array([1, 2, 3])
+    y = 2 * x + 1
+    w = np.ones_like(x)
+    slope, intercept = cryo_utils.fit_line(x, y, w)
+    assert np.isclose(slope, 2.0)
+    assert np.isclose(intercept, 1.0)
+
+
+# Test combine_sigmaA
+def test_combine_sigmaA_shape_and_type():
+    slope = 1.0
+    intercept = 0.0
+    xdat = np.array([0.0, 1.0])
+    ydat = np.array([0.1, 0.2])
+    wdat = np.array([1.0, 2.0])
+    sigma_linlog = 1.0
+    linlogsiga, logsiga_combined = cryo_utils.combine_sigmaA(
+        slope, intercept, xdat, ydat, wdat, sigma_linlog
+    )
+    assert len(linlogsiga) == 2
+    assert len(logsiga_combined) == 2
+    assert all(isinstance(v, float) for v in linlogsiga)
+    assert all(isinstance(v, float) for v in logsiga_combined)
+
+
+# Test llgcryo_calculate (torch-based)
+def test_llgcryo_calculate_simple():
+    E_amp = torch.tensor([1.0])
+    E_phi = torch.tensor([0.0])
+    Ec_amp = torch.tensor([1.0])
+    Ec_phi = torch.tensor([0.0])
+    sigmaA = torch.tensor([0.5])
+    dobs = torch.tensor([0.5])
+    result = cryo_utils.llgcryo_calculate(E_amp, E_phi, Ec_amp, Ec_phi, sigmaA, dobs)
+    assert result.shape == (1,)
+    assert torch.isfinite(result).all()
+
+
+# Test load_tng_data with minimal mock
+def test_load_tng_data_keys_and_types():
+    df = pd.DataFrame({
+        ""Emean"": [1.0, 2.0],
+        ""PHIEmean"": [0.0, 90.0],
+        ""Dobs"": [1.0, 2.0],
+    })
+    with (
+        patch(""rocket.utils.load_mtz"", return_value=df),
+        patch(""rocket.utils.try_gpu"", return_value=""cpu""),
+    ):
+        result = cryo_utils.load_tng_data(""dummy_file"")
+        assert set(result.keys()) == {""Emean"", ""PHIEmean"", ""Dobs""}
+        for k in result:
+            assert isinstance(result[k], torch.Tensor)
+            assert result[k].shape[0] == 2
+
+
+# Test sigmaA_from_model_in_map with dummy sfc object
+def test_sigmaA_from_model_in_map_dummy():
+    class DummySFC:
+        def __init__(self):
+            self.n_bins = 2
+            self.bins = np.array([0, 0, 1, 1])
+
+    expectE_amp = np.array([1.0, 1.0, 2.0, 2.0])
+    expectE_phi = np.array([0.0, 0.0, 0.0, 0.0])
+    dobs = np.array([1.0, 1.0, 1.0, 1.0])
+    Ecalc_amp = np.array([1.0, 1.0, 2.0, 2.0])
+    Ecalc_phi = np.array([0.0, 0.0, 0.0, 0.0])
+    dhkl = np.array([1.0, 1.0, 2.0, 2.0])
+    sfc = DummySFC()
+    over_sampling_factor = 1.0
+    model_sigmaA = cryo_utils.sigmaA_from_model_in_map(
+        expectE_amp,
+        expectE_phi,
+        dobs,
+        Ecalc_amp,
+        Ecalc_phi,
+        sfc,
+        over_sampling_factor,
+        dhkl,
+        plot=False,
+    )
+    assert model_sigmaA.shape == expectE_amp.shape
+    assert np.all(model_sigmaA > 0)
+    assert np.all(model_sigmaA < 1)
+
+
+# Test combine_sigmaA logic (numerical, edge)
+def test_combine_sigmaA_behavior():
+    slope, intercept = 0.0, 0.0
+    xdat = np.array([0.0])
+    ydat = np.array([0.0])
+    wdat = np.array([1.0])
+    sigma_linlog = 1.0
+    linlogsiga, logsiga_combined = cryo_utils.combine_sigmaA(
+        slope, intercept, xdat, ydat, wdat, sigma_linlog
+    )
+    # With all zeros, log(0.999) and logsiga_combined = 0
+    assert np.isclose(linlogsiga[0], math.log(0.999))
+    assert np.isfinite(logsiga_combined[0])
+
+
+# Test fit_line for zero slope
+def test_fit_line_zero_slope():
+    x = np.array([1, 2, 3])
+    y = np.array([5, 5, 5])
+    w = np.ones_like(x)
+    slope, intercept = cryo_utils.fit_line(x, y, w)
+    assert np.isclose(slope, 0.0)
+    assert np.isclose(intercept, 5.0)
+","Python"
+"AlphaFold","alisiafadini/ROCKET","test/functional/dummy.py",".py","0","0","","Python"
+"AlphaFold","alisiafadini/ROCKET","test/scripts/dummy.py",".py","0","0","","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/coordinates.py",".py","32989","1043","""""""
+Functions relating model coordinates/PDB file modificaitons
+""""""
+
+import time
+
+import numpy as np
+import torch
+from openfold.np import residue_constants
+from scipy.spatial.transform import Rotation
+from SFC_Torch import SFcalculator
+
+from rocket import utils
+
+
+def rigidbody_refine_quat(
+    xyz,
+    llgloss,
+    cra_name,
+    lbfgs=False,
+    added_chain_HKL=None,
+    added_chain_asu=None,
+    lbfgs_lr=150.0,
+    verbose=True,
+    domain_segs=None,
+):
+    resid = [int(i.split(""-"")[1]) + 1 for i in cra_name]
+    minid = min(resid)
+    maxid = max(resid)
+
+    if domain_segs is None:
+        domain_ranges = [[minid, maxid + 1]]
+    else:
+        domain_ranges = []
+        start = minid
+        for i, seg in enumerate(domain_segs):
+            domain_ranges.append([start, seg])
+            start = seg
+            if i == len(domain_segs) - 1:
+                domain_ranges.append([start, maxid + 1])
+
+    domain_bools = []
+    for domain_start, domain_end_notin in domain_ranges:
+        domain_bools.append(
+            np.array([(i >= domain_start) and (i < domain_end_notin) for i in resid])
+        )
+    n_domains = len(domain_bools)
+
+    # llgloss.sfc.get_scales_lbfgs()
+    if lbfgs:
+        trans_vecs, qs, loss_track_pose = find_rigidbody_matrix_lbfgs_quat(
+            llgloss,
+            xyz.detach(),
+            llgloss.device,
+            domain_bools,
+            added_chain_HKL=added_chain_HKL,
+            added_chain_asu=added_chain_asu,
+            lbfgs_lr=lbfgs_lr,
+            verbose=verbose,
+        )
+    else:
+        pass
+        # trans_vec, q, loss_track_pose = find_rigidbody_matrix_adam_quat(
+        #     llgloss,
+        #     propose_coms.clone().detach(),
+        #     propose_rmcom.clone().detach(),
+        #     llgloss.device,
+        #     added_chain_HKL=added_chain_HKL,
+        #     added_chain_asu=added_chain_asu,
+        #     verbose=verbose
+        # )
+    optimized_xyz = torch.ones_like(xyz)
+    for i in range(n_domains):
+        propose_rmcom = xyz[domain_bools[i]] - torch.mean(xyz[domain_bools[i]], dim=0)
+        propose_com = torch.mean(xyz[domain_bools[i]], dim=0)
+        transform_i = quaternions_to_SO3(qs[i]).detach()
+        optimized_xyz[domain_bools[i]] = (
+            torch.matmul(propose_rmcom, transform_i)
+            + propose_com
+            + trans_vecs[i].detach()
+        )
+
+    return optimized_xyz, loss_track_pose
+
+
+def find_rigidbody_matrix_lbfgs_quat(
+    llgloss,
+    xyz,
+    device,
+    domain_bools,
+    added_chain_HKL=None,
+    added_chain_asu=None,
+    lbfgs_lr=150.0,
+    verbose=True,
+):
+    n_domains = len(domain_bools)
+    qs = [
+        torch.tensor(
+            [1.0, 0.0, 0.0, 0.0], dtype=torch.float32, device=device, requires_grad=True
+        )
+        for _ in range(n_domains)
+    ]
+    trans_vecs = [
+        torch.tensor([0.0, 0.0, 0.0], device=device, requires_grad=True)
+        for _ in range(n_domains)
+    ]
+
+    loss_track_pose = pose_train_lbfgs_quat(
+        llgloss,
+        qs,
+        trans_vecs,
+        xyz,
+        domain_bools,
+        loss_track=[],
+        lr=lbfgs_lr,
+        added_chain_HKL=added_chain_HKL,
+        added_chain_asu=added_chain_asu,
+        verbose=verbose,
+    )
+    return trans_vecs, qs, loss_track_pose
+
+
+def find_rigidbody_matrix_adam_quat(
+    llgloss,
+    propose_com,
+    propose_rmcom,
+    device,
+    added_chain_HKL=None,
+    added_chain_asu=None,
+    verbose=True,
+):
+    q = torch.tensor(
+        [1.0, 0.0, 0.0, 0.0], dtype=torch.float32, device=device, requires_grad=True
+    )
+    trans_vec = torch.tensor([0.0, 0.0, 0.0], device=device, requires_grad=True)
+    loss_track_pose = pose_train_adam_quat(
+        llgloss,
+        q,
+        trans_vec,
+        propose_com,
+        propose_rmcom,
+        loss_track=[],
+        added_chain_HKL=added_chain_HKL,
+        added_chain_asu=added_chain_asu,
+        verbose=verbose,
+    )
+    return trans_vec, q, loss_track_pose
+
+
+def pose_train_lbfgs_quat(
+    llgloss,
+    qs,
+    trans_vecs,
+    xyz,
+    domain_bools,
+    lr=150.0,
+    n_steps=15,
+    loss_track=None,
+    added_chain_HKL=None,
+    added_chain_asu=None,
+    verbose=True,
+):
+    if loss_track is None:
+        loss_track = []
+
+    def closure():
+        optimizer.zero_grad()
+        temp_model = torch.zeros_like(xyz)
+        for i in range(n_domains):
+            temp_R = quaternions_to_SO3(qs[i])
+            temp_model[domain_bools[i]] = (
+                torch.matmul(propose_rmcoms[i], temp_R)
+                + propose_coms[i]
+                + trans_vecs[i]
+            )
+        loss = -llgloss(
+            temp_model,
+            bin_labels=None,
+            num_batch=1,
+            sub_ratio=1.0,
+            solvent=False,
+            return_Rfactors=False,
+            added_chain_HKL=added_chain_HKL,
+            added_chain_asu=added_chain_asu,
+        )
+        loss.backward()
+        return loss
+
+    n_domains = len(domain_bools)
+    optimizer = torch.optim.LBFGS(
+        qs + trans_vecs,
+        lr=lr,
+        line_search_fn=""strong_wolfe"",
+        tolerance_change=1e-9,
+        max_iter=1,
+    )
+    propose_rmcoms = []
+    propose_coms = []
+    for domain_bool in domain_bools:
+        propose_rmcoms.append(xyz[domain_bool] - torch.mean(xyz[domain_bool], dim=0))
+        propose_coms.append(torch.mean(xyz[domain_bool], dim=0))
+    start_time = time.time()
+    for _ in range(n_steps):
+        temp = optimizer.step(closure)
+        loss_track.append(temp.item())
+    elapsed_time = time.time() - start_time
+    if verbose:
+        print(
+            f""LBFGS RBR, {n_steps} steps, time taken: {elapsed_time:.4f} seconds"",
+            flush=True,
+        )
+    return loss_track
+
+
+def pose_train_adam_quat(
+    llgloss,
+    q,
+    trans_vec,
+    propose_com,
+    propose_rmcom,
+    lr=1e-3,
+    n_steps=100,
+    loss_track=None,
+    added_chain_HKL=None,
+    added_chain_asu=None,
+    verbose=True,
+):
+    if loss_track is None:
+        loss_track = []
+
+    def pose_steptrain(optimizer):
+        optimizer.zero_grad()
+        temp_R = quaternions_to_SO3(q)
+        temp_model = torch.matmul(propose_rmcom, temp_R) + propose_com + trans_vec
+        loss = -llgloss(
+            temp_model,
+            bin_labels=None,
+            num_batch=1,
+            sub_ratio=1.0,
+            solvent=False,
+            return_Rfactors=False,
+            added_chain_HKL=added_chain_HKL,
+            added_chain_asu=added_chain_asu,
+        )
+        loss.backward()
+        optimizer.step()
+        return loss.item()
+
+    start_time = time.time()
+    optimizer = torch.optim.Adam([q, trans_vec], lr=lr)
+    for _ in range(n_steps):
+        temp = pose_steptrain(optimizer)
+        loss_track.append(temp)
+    elapsed_time = time.time() - start_time
+    if verbose:
+        print(
+            f""Adam RBR, {n_steps} steps, time taken: {elapsed_time:.4f} seconds"",
+            flush=True,
+        )
+    return loss_track
+
+
+def pose_train_adam_matrix(
+    llgloss,
+    rot_v1,
+    rot_v2,
+    trans_vec,
+    propose_com,
+    propose_rmcom,
+    lr=1e-3,
+    n_steps=100,
+    loss_track=None,
+    added_chain=None,
+):
+    if loss_track is None:
+        loss_track = []
+
+    def pose_steptrain(optimizer):
+        optimizer.zero_grad()
+        temp_R = construct_SO3(rot_v1, rot_v2)
+        temp_model = torch.matmul(propose_rmcom, temp_R) + propose_com + trans_vec
+        loss = -llgloss(
+            temp_model,
+            bin_labels=None,
+            num_batch=1,
+            return_Rfactors=False,
+            sub_ratio=1.0,
+            solvent=False,
+            added_chain=added_chain,
+        )
+        loss.backward()
+        optimizer.step()
+        return loss.item()
+
+    start_time = time.time()
+    optimizer = torch.optim.Adam([rot_v1, rot_v2, trans_vec], lr=lr)
+    for k in range(n_steps):
+        temp = pose_steptrain(optimizer)
+        loss_track.append(temp)
+
+        elapsed_time = time.time() - start_time
+        print(f""Step {k + 1}/{n_steps} - Time: {elapsed_time:.4f} s, Loss: {temp:.3f}"")
+
+    return loss_track
+
+
+def pose_train_lbfgs(
+    llgloss,
+    rot_v1,
+    rot_v2,
+    trans_vec,
+    propose_com,
+    propose_rmcom,
+    lr=0.005,
+    n_steps=50,
+    loss_track=None,
+):
+    if loss_track is None:
+        loss_track = []
+
+    def closure():
+        optimizer.zero_grad()
+        temp_R = construct_SO3(rot_v1, rot_v2)
+        temp_model = torch.matmul(propose_rmcom, temp_R) + propose_com + trans_vec
+        loss = -llgloss(
+            temp_model,
+            bin_labels=None,
+            return_Rfactors=False,
+            num_batch=1,
+            sub_ratio=1.0,
+        )
+        loss.backward()
+        return loss
+
+    start_time = time.time()
+
+    optimizer = torch.optim.LBFGS(
+        [rot_v1, rot_v2, trans_vec],
+        lr=lr,
+        line_search_fn=""strong_wolfe"",
+        tolerance_change=1e-3,
+        max_iter=1,
+    )
+
+    for k in range(n_steps):
+        temp = optimizer.step(closure)
+        loss_track.append(temp.item())
+        elapsed_time = time.time() - start_time
+        print(f""Step {k + 1}/{n_steps} - Time by optimizer: {elapsed_time:.4f} s"")
+    return loss_track
+
+
+def find_rigidbody_matrix_adam(
+    llgloss, propose_com, propose_rmcom, device, added_chain
+):
+    q = torch.tensor([1.0, 0.0, 0.0, 0.0], dtype=torch.float32)
+    unit_R = quaternions_to_SO3(q)
+    v1, v2 = decompose_SO3(unit_R)
+    rot_v1 = torch.tensor(utils.assert_numpy(v1), device=device, requires_grad=True)
+    rot_v2 = torch.tensor(utils.assert_numpy(v2), device=device, requires_grad=True)
+    trans_vec = torch.tensor([0.0, 0.0, 0.0], device=device, requires_grad=True)
+
+    loss_track_pose = pose_train_adam_matrix(
+        llgloss,
+        rot_v1,
+        rot_v2,
+        trans_vec,
+        propose_com,
+        propose_rmcom,
+        loss_track=[],
+        added_chain=added_chain,
+    )
+    return trans_vec, rot_v1, rot_v2, loss_track_pose
+
+
+def find_rigidbody_matrix_lbfgs(llgloss, propose_com, propose_rmcom, device):
+    q = torch.tensor([1.0, 0.0, 0.0, 0.0], dtype=torch.float32)
+    unit_R = quaternions_to_SO3(q)
+    v1, v2 = decompose_SO3(unit_R)
+    rot_v1 = torch.tensor(utils.assert_numpy(v1), device=device, requires_grad=True)
+    rot_v2 = torch.tensor(utils.assert_numpy(v2), device=device, requires_grad=True)
+    trans_vec = torch.tensor([0.0, 0.0, 0.0], device=device, requires_grad=True)
+
+    loss_track_pose = pose_train_lbfgs(
+        llgloss,
+        rot_v1,
+        rot_v2,
+        trans_vec,
+        propose_com,
+        propose_rmcom,
+        loss_track=[],
+    )
+    return trans_vec, rot_v1, rot_v2, loss_track_pose
+
+
+def construct_SO3(v1, v2):
+    """"""
+    Construct a continuous representation of SO(3) rotation with two 3D vectors
+    https://arxiv.org/abs/1812.07035
+    Parameters
+    ----------
+    v1, v2: 3D tensors
+        Real-valued tensor in 3D space
+    Returns
+    -------
+    R, A 3*3 SO(3) rotation matrix
+    """"""
+    e1 = v1 / torch.norm(v1)
+    u2 = v2 - e1 * torch.tensordot(e1, v2, dims=1)
+    e2 = u2 / torch.norm(u2)
+    e3 = torch.cross(e1, e2)
+    R = torch.stack((e1, e2, e3)).T
+    return R
+
+
+def decompose_SO3(R, a=1, b=1, c=1):
+    """"""
+    Decompose the rotation matrix into the two vector representation
+    This decomposition is not unique
+    a, b, c can be set as arbitrary constants you like
+    C != 0
+    Parameters
+    ----------
+    R: 3*3 tensors
+        Real-valued rotation matrix
+    Returns
+    -------
+    v1, v2: Two real-valued 3D tensors, continuous representation of the rotation matrix
+    """"""
+    assert c != 0, ""Give a nonzero c!""
+    v1 = a * R[:, 0]
+    v2 = b * R[:, 0] + c * R[:, 1]
+
+    return v1, v2
+
+
+def quaternions_to_SO3(q):
+    """"""
+    Normalizes q and maps to group matrix.
+    https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Quaternion-derived_rotation_matrix
+    https://danceswithcode.net/engineeringnotes/quaternions/quaternions.html
+    """"""
+    # q = assert_tensor(q, torch.float32)
+    q = q / q.norm(p=2, dim=-1, keepdim=True)
+    r, i, j, k = q[..., 0], q[..., 1], q[..., 2], q[..., 3]
+
+    return torch.stack(
+        [
+            1 - 2 * j * j - 2 * k * k,
+            2 * (i * j - r * k),
+            2 * (i * k + r * j),
+            2 * (i * j + r * k),
+            1 - 2 * i * i - 2 * k * k,
+            2 * (j * k - r * i),
+            2 * (i * k - r * j),
+            2 * (j * k + r * i),
+            1 - 2 * i * i - 2 * j * j,
+        ],
+        -1,
+    ).view(*q.shape[:-1], 3, 3)
+
+
+def select_CA_elements(data):
+    return [element.endswith(""-CA"") for element in data]
+
+
+def select_CA_from_craname(cra_name_list):
+    boolean_mask = select_CA_elements(cra_name_list)
+    cra_CAs_list = [
+        element
+        for element, mask in zip(cra_name_list, boolean_mask, strict=False)
+        if mask
+    ]
+    return cra_CAs_list, boolean_mask
+
+
+def calculate_mse_loss_per_residue(tensor1, tensor2, residue_numbers):
+    mse_losses = []
+
+    for residue in set(residue_numbers):
+        # Find indices of atoms with the current residue number in tensor1
+        indices1 = [i for i, x in enumerate(residue_numbers) if x == residue]
+
+        if len(indices1) > 0:
+            # Extract coordinates for atoms with the current residue number in tensor1
+            coords1 = tensor1[indices1, :]
+
+            # Extract coordinates for atoms with the current residue number in tensor2
+            coords2 = tensor2[indices1, :]
+
+            # Calculate MSE loss for coordinates of atoms with the same residue number
+            mse_loss = torch.sqrt(torch.sum((coords1 - coords2) ** 2))
+            mse_losses.append(mse_loss.item())
+
+    return mse_losses
+
+
+def write_pdb_with_positions(input_pdb_file, positions, output_pdb_file):
+    # positions here expected to be rounded to 3 decimal points
+
+    with open(input_pdb_file) as f_in, open(output_pdb_file, ""w"") as f_out:
+        for line in f_in:
+            if line.startswith(""ATOM""):
+                atom_info = line[
+                    :30
+                ]  # Extract the first 30 characters containing atom information
+                rounded_pos = positions.pop(
+                    0
+                )  # Pop the first rounded position from the list
+                new_line = (
+                    f""{atom_info}{rounded_pos[0]:8.3f}{rounded_pos[1]:8.3f}{rounded_pos[2]:8.3f}""
+                    + line[54:]
+                )
+                f_out.write(new_line)
+            else:
+                f_out.write(line)
+
+
+def fractionalize_torch(atom_pos_orth, unitcell, device=None):
+    """"""
+    Apply symmetry operations to real space asu model coordinates
+
+    Parameters
+    ----------
+    atom_pos_orth: tensor, [N_atom, 3]
+        ASU model ccordinates
+
+    Will return fractional coordinates; Otherwise will return orthogonal coordinates
+
+    Return
+    ------
+    atom_pos_sym_oped, [N_atoms, N_ops, 3] tensor, fractional or orthogonal coordinates
+    """"""
+    if device is None:
+        device = utils.try_gpu()
+    atom_pos_orth.to(device=device)
+    orth2frac_tensor = torch.tensor(
+        unitcell.fractionalization_matrix.tolist(), device=device
+    )
+    atom_pos_frac = torch.tensordot(atom_pos_orth, orth2frac_tensor.T, 1)
+
+    return atom_pos_frac
+
+
+def extract_allatoms(outputs, feats, cra_name_sfc: list):
+    N_atom_types = len(residue_constants.atom_types)  # by default 37
+    atom_mask = outputs[""final_atom_mask""]  # shape [n_res, N_atom_types]
+    n_res = atom_mask.shape[0]
+
+    # get atom positions in vectorized manner
+    positions_atom = outputs[""final_atom_positions""][atom_mask == 1.0]  # [n_atom, 3]
+
+    # get plddt in vectorized manner
+    plddt_atom = (
+        outputs[""plddt""].reshape([-1, 1]).repeat([1, N_atom_types])[atom_mask == 1.0]
+    )  # shape [n_atom,]
+
+    # get cra_name from AF2, [chain-resid-resname-atomname,...]
+    res_names = utils.assert_numpy(
+        [i + ""-"" for i in list(residue_constants.restype_1to3.values())] + [""UNK-""]
+    )
+    aatype = feats[
+        ""aatype""
+    ]  # TODO: tackle the match between UNK and real non-standard aa name from SFC
+    aatype_1d = res_names[utils.assert_numpy(aatype[:, 0], arr_type=int)]
+    chain_resid = np.array([
+        ""A-"" + str(i) + ""-"" for i in range(n_res)
+    ])  # TODO: here we assume all residues in same chain A
+    crname_repeats = (
+        np.char.add(chain_resid, aatype_1d).reshape(-1, 1).repeat(N_atom_types, axis=-1)
+    )  # [n_res, N_atom_types]
+    crname_atom = crname_repeats[utils.assert_numpy(atom_mask) == 1]
+    atom_types_repeats = (
+        utils.assert_numpy(residue_constants.atom_types)
+        .reshape(1, N_atom_types)
+        .repeat(n_res, axis=0)
+    )  # [n_res, N_atom_types]
+    aname_atom = atom_types_repeats[utils.assert_numpy(atom_mask) == 1]
+    cra_name_af = np.char.add(crname_atom, aname_atom).tolist()
+
+    # reorder and assert the same topology
+    reorder_index = utils.assert_numpy(
+        [cra_name_af.index(i) for i in cra_name_sfc], arr_type=int
+    )
+
+    assert np.all(
+        utils.assert_numpy(cra_name_af)[reorder_index]
+        == utils.assert_numpy(cra_name_sfc)
+    ), ""Mismatch topolgy between AF and SFC!""
+
+    return positions_atom[reorder_index], plddt_atom[reorder_index]
+
+
+def extract_atoms_and_backbone(outputs, feats):
+    atom_types = residue_constants.atom_types
+    atom_mask = outputs[""final_atom_mask""]
+    pdb_lines = []
+    aatype = feats[""aatype""]
+    atom_positions = outputs[""final_atom_positions""]
+    selected_atoms_mask = []
+
+    n = aatype.shape[0]
+    for i in range(n):
+        for atom_name, pos, mask in zip(
+            atom_types, atom_positions[i], atom_mask[i], strict=False
+        ):
+            if mask < 0.5:
+                continue
+            pdb_lines.append(pos)
+
+            if atom_name in [""C"", ""CA"", ""O"", ""N""]:
+                selected_atoms_mask.append(torch.tensor(1, dtype=torch.bool))
+            else:
+                selected_atoms_mask.append(torch.tensor(0, dtype=torch.bool))
+
+    return torch.stack(pdb_lines), torch.stack(selected_atoms_mask)
+
+
+def extract_bfactors(prot):
+    atom_mask = prot.atom_mask
+    aatype = prot.aatype
+    b_factors = prot.b_factors
+
+    b_factor_lines = []
+
+    n = aatype.shape[0]
+    # Add all atom sites.
+    for i in range(n):
+        for mask, b_factor in zip(atom_mask[i], b_factors[i], strict=False):
+            if mask < 0.5:
+                continue
+
+            b_factor_lines.append(b_factor)
+
+    return np.array(b_factor_lines)
+
+
+def kabsch_align_matrices(tensor1, tensor2):
+    # Center the atoms by subtracting their centroids
+    centroid1 = torch.mean(tensor1, dim=0, keepdim=True)
+    tensor1_centered = tensor1 - centroid1
+    centroid2 = torch.mean(tensor2, dim=0, keepdim=True)
+    tensor2_centered = tensor2 - centroid2
+
+    # Calculate the covariance matrix
+    covariance_matrix = torch.matmul(tensor2_centered.t(), tensor1_centered)
+
+    # Perform Singular Value Decomposition (SVD) on the covariance matrix
+    U, _, Vt = torch.linalg.svd(covariance_matrix)
+
+    # Calculate the rotation matrix
+    rotation_matrix = torch.matmul(U, Vt)
+
+    # Ensure the determinant is positive
+    if torch.det(rotation_matrix) < 0:
+        Vt[:, -1] *= -1
+        rotation_matrix = torch.matmul(Vt.t(), U.t())
+
+    # Ensure the rotation matrix is not a reflection
+    if torch.det(rotation_matrix) < 0:
+        rotation_matrix[:, 0] *= -1
+
+    return centroid1, centroid2, rotation_matrix
+
+
+def select_confident_atoms(current_pos, target_pos, bfacts=None, b_thresh=400.0):
+    if bfacts is None:
+        # If bfacts is None, set mask to all True
+        reshaped_mask = torch.ones_like(current_pos, dtype=torch.bool)
+    else:
+        # Boolean mask for confident atoms
+        mask = bfacts < b_thresh
+        reshaped_mask = mask.unsqueeze(1).expand_as(current_pos)
+
+    # Select confident atoms using the mask
+    current_pos_conf = torch.flatten(current_pos)[torch.flatten(reshaped_mask)]
+    target_pos_conf = torch.flatten(target_pos)[torch.flatten(reshaped_mask)]
+
+    N = current_pos_conf.numel() // 3
+
+    return current_pos_conf.view(N, 3), target_pos_conf.view(N, 3)
+
+
+def align_tensors(tensor1, centroid1, centroid2, rotation_matrix):
+    """"""
+    Apply rotation and translation to a tensor
+    """"""
+    tensor1_centered = tensor1 - centroid1
+    # Apply the rotation and translation to align the first tensor to the second one
+    aligned_tensor1 = torch.matmul(tensor1_centered, rotation_matrix.T) + centroid2
+
+    return aligned_tensor1
+
+
+def weighted_kabsch_svd(P, Q, weights=None):
+    """"""
+    Computes the optimal rotation matrix that minimizes the weighted RMSD
+    between two sets of corresponding points P and Q using SVD.
+
+    Args:
+        P (np.ndarray): Reference points, shape (N, 3).
+        Q (np.ndarray): Points to align to P, shape (N, 3).
+        weights (np.ndarray, optional): Weights for each point, shape (N,).
+
+    Returns:
+        np.ndarray: Optimal rotation matrix (3, 3).
+    """"""
+    if P.shape[0] < 3:
+        raise ValueError(""Need at least 3 points for stable alignment"")
+
+    # Center the point clouds using weighted average
+    centroid_P = np.average(P, axis=0, weights=weights)
+    centroid_Q = np.average(Q, axis=0, weights=weights)
+    P_centered = P - centroid_P
+    Q_centered = Q - centroid_Q
+
+    # Compute weighted covariance matrix
+    H = Q_centered.T @ np.diag(weights if weights is not None else 1) @ P_centered
+
+    # Perform SVD
+    try:
+        U, _, Vt = np.linalg.svd(H)
+    except np.linalg.LinAlgError:
+        return np.identity(3)  # Fallback for unstable SVD
+
+    # Calculate rotation matrix R
+    R = Vt.T @ U.T
+
+    # Handle reflection case (ensures a right-handed coordinate system)
+    if np.linalg.det(R) < 0:
+        Vt[-1, :] *= -1
+        R = Vt.T @ U.T
+
+    return R
+
+
+def iterative_kabsch_alignment(
+    moving_tensor,
+    ref_tensor,
+    cra_name,
+    weights=None,
+    exclude_res=None,
+    domain_segs=None,
+    cutoff=2.0,
+    cycles=5,
+):
+    """"""
+    Performs Kabsch alignment with iterative outlier rejection on protein structures.
+
+    Args:
+        moving_tensor (torch.Tensor): Coords to move, shape [n_points, 3].
+        ref_tensor (torch.Tensor): Reference coords, shape [n_points, 3].
+        cra_name (List[str]): Chain-residue-atom identifiers, [n_points].
+        weights (torch.Tensor|np.ndarray, optional): Weights for the alignment.
+        exclude_res (List[int], optional): Residue IDs to exclude.
+        domain_segs (List[int], optional): Residue IDs defining domain boundaries.
+        cutoff (float): Distance cutoff in Angstroms for outlier rejection.
+        cycles (int): Max number of refinement cycles. Set to 0 for a single
+                      alignment without outlier rejection.
+
+    Returns:
+        torch.Tensor: The aligned moving_tensor, shape [n_points, 3].
+    """"""
+    # --- 1. Initial Filtering Setup ---
+    backbone_bool = np.array([i.split(""-"")[-1] in [""N"", ""CA"", ""C""] for i in cra_name])
+    resid = np.array([int(i.split(""-"")[1]) for i in cra_name])
+    minid, maxid = resid.min(), resid.max()
+
+    if exclude_res is None:
+        residue_bool = (resid > minid + 4) & (resid < maxid - 4)
+    else:
+        residue_bool = np.isin(resid, exclude_res, invert=True)
+
+    # --- 2. Define Domains ---
+    if domain_segs is None:
+        domain_ranges = [[minid, maxid + 1]]
+    else:
+        domain_ranges = []
+        start = minid
+        sorted_segs = sorted(domain_segs)
+        for i, seg in enumerate(sorted_segs):
+            domain_ranges.append([start, seg])
+            start = seg
+            if i == len(sorted_segs) - 1:
+                domain_ranges.append([start, maxid + 1])
+
+    # --- 3. Process Each Domain ---
+    aligned_pos = moving_tensor.clone()
+    for domain_start, domain_end_notin in domain_ranges:
+        domain_bool = (resid >= domain_start) & (resid < domain_end_notin)
+        working_set_mask = backbone_bool & residue_bool & domain_bool
+
+        if not working_set_mask.any():
+            continue
+
+        moving_align_coords = utils.assert_numpy(moving_tensor)[working_set_mask]
+        ref_align_coords = utils.assert_numpy(ref_tensor)[working_set_mask]
+        if moving_align_coords.shape[0] < 3:
+            continue
+
+        align_weights = (
+            utils.assert_numpy(weights)[working_set_mask]
+            if weights is not None
+            else None
+        )  # noqa: E501
+
+        # --- 4. Iterative Alignment for the Current Domain ---
+        inlier_indices = np.arange(moving_align_coords.shape[0])
+        final_R = np.identity(3)
+
+        for cycle in range(cycles + 1):
+            P_iter = ref_align_coords[inlier_indices]
+            Q_iter = moving_align_coords[inlier_indices]
+            w_iter = (
+                align_weights[inlier_indices] if align_weights is not None else None
+            )  # noqa: E501
+            try:
+                R_iter = weighted_kabsch_svd(P_iter, Q_iter, weights=w_iter)
+            except ValueError:
+                break
+            final_R = R_iter
+
+            if cycle == cycles:
+                break
+
+            # Apply transform and find new inliers
+            centroid_Q = np.average(Q_iter, axis=0, weights=w_iter)
+            centroid_P = np.average(P_iter, axis=0, weights=w_iter)
+            t_iter = centroid_P - final_R @ centroid_Q
+
+            transformed_align_coords = (final_R @ moving_align_coords.T).T + t_iter
+            distances = np.linalg.norm(
+                ref_align_coords - transformed_align_coords, axis=1
+            )  # noqa: E501
+            new_inlier_indices = np.where(distances < cutoff)[0]
+
+            if len(new_inlier_indices) < 3 or np.array_equal(
+                inlier_indices, new_inlier_indices
+            ):  # noqa: E501
+                break
+            inlier_indices = new_inlier_indices
+        # --- 5. Apply Final Transformation to the Entire Domain ---
+        P_final = ref_align_coords[inlier_indices]
+        Q_final = moving_align_coords[inlier_indices]
+        w_final = align_weights[inlier_indices] if align_weights is not None else None
+
+        # Calculate final centroids based on the final set of inliers
+        final_centroid_moving = np.average(Q_final, axis=0, weights=w_final)
+        final_centroid_ref = np.average(P_final, axis=0, weights=w_final)
+        # Get all points in the domain and convert components to tensors
+        moving_domain_tensor = moving_tensor[domain_bool]
+        R_torch = torch.tensor(
+            final_R, dtype=moving_tensor.dtype, device=moving_tensor.device
+        )
+        centroid1_torch = torch.tensor(
+            final_centroid_moving,
+            dtype=moving_tensor.dtype,
+            device=moving_tensor.device,
+        )
+        centroid2_torch = torch.tensor(
+            final_centroid_ref, dtype=moving_tensor.dtype, device=moving_tensor.device
+        )
+
+        # Use your function to apply the final transformation
+        aligned_domain_tensor = align_tensors(
+            moving_domain_tensor, centroid1_torch, centroid2_torch, R_torch
+        )
+        aligned_pos[domain_bool] = aligned_domain_tensor
+
+    return aligned_pos
+
+
+def weighted_kabsch(
+    moving_tensor,
+    ref_tensor,
+    cra_name,
+    weights=None,
+    exclude_res=None,
+    domain_segs=None,
+):
+    """"""
+    Weighted Kabsch Alignment, using scipy implementation
+    'scipy.spatial.transform.Rotation.align_vectors'
+
+    Args:
+        moving_tensor: torch.Tensor, [n_points, 3]
+            coordinates you want to move
+
+        ref_tensor: torch.Tensor, [n_points, 3]
+            reference coordinates you want to align to
+
+        cra_name: List[str], [n_points]
+            chain-residue-atom name of each atom
+
+        weights: torch.Tensor | np.ndarray, [n_points]
+            weights used in the Kabsch Alignment
+
+        exclude_res: List[int] or None
+            list of resid you want to exclude from the alignment
+
+        domain_segs: List[int] or None
+            List of resid as boundary between different domains,
+            i.e. domain_segs = [196] means there are two domains, [0-195] and [196-END]
+
+    Returns:
+        aligned_tensor: torch.Tensor, [n_points, 3]
+    """"""
+    # use only backbone atoms
+    backbone_bool = np.array([i.split(""-"")[-1] in [""N"", ""CA"", ""C""] for i in cra_name])
+
+    # exclude some residues, by default 5 residues on both ends
+    resid = [int(i.split(""-"")[1]) + 1 for i in cra_name]
+    minid = min(resid)
+    maxid = max(resid)
+    if exclude_res is None:
+        residue_bool = np.array([(i > minid + 4) and (i < (maxid - 4)) for i in resid])
+    else:
+        residue_bool = np.array([i not in exclude_res for i in resid])
+
+    if domain_segs is None:
+        domain_ranges = [[minid, maxid + 1]]
+    else:
+        domain_ranges = []
+        start = minid
+        for i, seg in enumerate(domain_segs):
+            domain_ranges.append([start, seg])
+            start = seg
+            if i == len(domain_segs) - 1:
+                domain_ranges.append([start, maxid + 1])
+    aligned_pos = torch.ones_like(moving_tensor)
+    for domain_range in domain_ranges:
+        domain_start, domain_end_notin = domain_range
+        domain_bool = np.array([
+            (i >= domain_start) and (i < domain_end_notin) for i in resid
+        ])
+        working_set = backbone_bool & residue_bool & domain_bool
+        moving_tensor_np = utils.assert_numpy(moving_tensor)[working_set]
+        ref_tensor_np = utils.assert_numpy(ref_tensor)[working_set]
+        if weights is None:
+            weights_np = None
+        else:
+            weights_np = utils.assert_numpy(weights)[working_set]
+
+        com_moving = np.average(moving_tensor_np, axis=0, weights=weights_np)
+        com_ref = np.average(ref_tensor_np, axis=0, weights=weights_np)
+        C, _ = Rotation.align_vectors(
+            ref_tensor_np - com_ref, moving_tensor_np - com_moving, weights=weights_np
+        )
+
+        rotation_matrix = torch.tensor(C.as_matrix()).to(moving_tensor)
+        centroid1 = torch.tensor(com_moving).to(moving_tensor)
+        centroid2 = torch.tensor(com_ref).to(moving_tensor)
+        aligned_pos[domain_bool] = align_tensors(
+            moving_tensor[domain_bool], centroid1, centroid2, rotation_matrix
+        )
+    return aligned_pos
+
+
+def cutoff_kabsch(
+    moving_tensor, ref_tensor, cra_name, pseudoB, threshB=None, exclude_res=None
+):
+    # use only backbone atoms
+    backbone_bool = np.array([i.split(""-"")[-1] in [""N"", ""CA"", ""C""] for i in cra_name])
+
+    # exclude some residues, by default 5 residues on both ends
+    resid = [int(i.split(""-"")[1]) for i in cra_name]
+    if exclude_res is None:
+        minid = min(resid)
+        maxid = max(resid)
+        residue_bool = np.array([(i > minid + 4) and (i < (maxid - 4)) for i in resid])
+    else:
+        residue_bool = np.array([i not in exclude_res for i in resid])
+
+    if threshB is None:
+        bfactor_bool = np.ones_like(backbone_bool, dtype=bool)
+    else:
+        bfactor_bool = pseudoB < threshB
+
+    working_set = backbone_bool & residue_bool & bfactor_bool
+    centroid1, centroid2, rotation_matrix = kabsch_align_matrices(
+        moving_tensor[working_set].detach(), ref_tensor[working_set].detach()
+    )
+    aligned_pos = align_tensors(moving_tensor, centroid1, centroid2, rotation_matrix)
+
+    return aligned_pos
+
+
+def set_new_positions(orth_pos, frac_pos, sfmodel, device=None):
+    if device is None:
+        device = utils.try_gpu()
+    sfmodel.atom_pos_orth = torch.squeeze(orth_pos, dim=1).to(device)
+    sfmodel.atom_pos_frac = torch.squeeze(frac_pos, dim=1).to(device)
+    return sfmodel
+
+
+def transfer_positions(aligned_pos, sfcalculator_model, device=None):
+    if device is None:
+        device = utils.try_gpu()
+    # Transfer positions to sfcalculator
+    frac_pos = fractionalize_torch(
+        aligned_pos,
+        sfcalculator_model.unit_cell,
+        sfcalculator_model.space_group,
+        device=device,
+    )
+    sfcalculator_model = set_new_positions(
+        aligned_pos, frac_pos, sfcalculator_model, device=device
+    )
+
+    # add bfactor calculation based on plddt
+    # sfcalculator_model.atom_b_iso = b_factors
+
+    sfcalculator_model = update_sfcalculator(sfcalculator_model)
+    return sfcalculator_model
+
+
+def update_sfcalculator(sfmodel):
+    sfmodel.inspect_data(verbose=False)
+    sfmodel.calc_fprotein()
+    sfmodel.calc_fsolvent()
+    sfmodel.init_scales(requires_grad=True)
+    sfmodel.calc_ftotal()
+    return sfmodel
+
+
+def initialize_model_frac_pos(model_file, tng_file, device=None):
+    if device is None:
+        device = utils.try_gpu()
+    sfcalculator_model = SFcalculator(
+        model_file,
+        tng_file,
+        expcolumns=[""FP"", ""SIGFP""],
+        set_experiment=True,
+        testset_value=0,
+        device=device,
+    )
+    target_pos = sfcalculator_model.atom_pos_orth
+    sfcalculator_model.atom_pos_frac = sfcalculator_model.atom_pos_frac * 0.00
+    sfcalculator_model.atom_pos_orth = sfcalculator_model.atom_pos_orth * 0.00
+    sfcalculator_model.atom_pos_frac.requires_grad = True
+
+    return sfcalculator_model, target_pos
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/refinement_mse.py",".py","10695","323","import os
+import time
+import uuid
+import warnings
+
+import numpy as np
+import torch
+import yaml
+from openfold.config import model_config
+from pydantic import BaseModel
+from SFC_Torch import PDBParser
+from tqdm import tqdm
+
+import rocket
+from rocket import coordinates as rk_coordinates
+from rocket import refinement_utils as rkrf_utils
+from rocket import utils as rk_utils
+
+PRESET = ""model_1""
+# THRESH_B = None
+EXCLUDING_RES = None
+
+
+class RocketMSERefinmentConfig(BaseModel):
+    path: str
+    file_root: str
+    bias_version: int
+    iterations: int
+    template_pdb: str | None = None
+    cuda_device: int = (0,)
+    num_of_runs: int = 1
+    init_recycling: int = (1,)
+    additive_learning_rate: float
+    multiplicative_learning_rate: float
+    weight_decay: float | None = 0.0001  # TODO: should default be 0.0?
+    rbr_opt_algorithm: str
+    rbr_lbfgs_learning_rate: float
+    note: str = """"
+    free_flag: str
+    testset_value: int
+    verbose: bool = False
+    starting_bias: str | None = None
+    starting_weights: str | None = None
+    uuid_hex: str | None = None
+
+    # intercept them upload load/save and cast to string as appropriate
+    def to_yaml_file(self, file_path: str) -> None:
+        with open(file_path, ""w"") as file:
+            yaml.dump(self.dict(), file)
+
+    @classmethod
+    def from_yaml_file(self, file_path: str):
+        with open(file_path) as file:
+            payload = yaml.safe_load(file)
+        return RocketMSERefinmentConfig.model_validate(payload)
+
+
+def run_refinement_mse(*, config: RocketMSERefinmentConfig) -> str:
+    ############ 1. Global settings ############
+    # Device
+    device = f""cuda:{config.cuda_device}""
+
+    # Configure input paths
+    input_pdb = f""{config.path}/{config.file_root}/{config.file_root}-pred-aligned.pdb""
+
+    # Configure output path
+    # Generate uuid for this run
+    if config.uuid_hex is None:
+        refinement_run_uuid = uuid.uuid4().hex
+    else:
+        refinement_run_uuid = config.uuid_hex
+    output_directory_path = (
+        f""{config.path}/{config.file_root}/outputs/{refinement_run_uuid}/{config.note}""
+    )
+    try:
+        os.makedirs(output_directory_path, exist_ok=True)
+    except FileExistsError:
+        print(
+            f""Warning: Directory '{output_directory_path}' already exists. Overwriting.""
+        )
+    print(
+        f""System: {config.file_root}, run ID: {refinement_run_uuid!s}, Note: {config.note}"",  # noqa: E501
+        flush=True,
+    )
+    if not config.verbose:
+        warnings.filterwarnings(""ignore"")
+
+    ############ 2. Initializations ############
+    target_pdb = PDBParser(input_pdb)
+    reference_pos = torch.tensor(
+        target_pdb.atom_pos, dtype=torch.float32, device=device
+    )
+    mseloss = rocket.MSElossBB(target_pdb, target_pdb, device)
+
+    # CA mask and residue numbers for track
+    cra_calphas_list, calphas_mask = rk_coordinates.select_CA_from_craname(
+        target_pdb.cra_name
+    )
+
+    # Use initial pos B factor instead of best pos B factor for weighted L2
+    init_pos_bfactor = torch.tensor(
+        target_pdb.atom_b_iso, dtype=torch.float32, device=device
+    )
+    bfactor_weights = rk_utils.weighting_torch(init_pos_bfactor, cutoff2=20.0)
+
+    # Model initialization
+    version_to_class = {
+        1: rocket.MSABiasAFv1,
+        2: rocket.MSABiasAFv2,
+        3: rocket.MSABiasAFv3,
+        4: rocket.TemplateBiasAF,
+    }
+    af_bias = version_to_class[config.bias_version](
+        model_config(PRESET, train=True), PRESET
+    ).to(device)
+    af_bias.freeze()  # Free all AF2 parameters to save time
+
+    # Optimizer settings and initialization
+    lr_a = config.additive_learning_rate
+    lr_m = config.multiplicative_learning_rate
+
+    # Initialize best Rfree weights and bias for Phase 1
+    best_loss = float(""inf"")
+    best_run = None
+    best_msa_bias = None
+    best_feat_weights = None
+    best_iter = None
+    best_pos = reference_pos
+
+    for n in range(config.num_of_runs):
+        run_id = rkrf_utils.number_to_letter(n)
+
+        # Initialize the processed dict space
+        device_processed_features, feature_key, features_at_it_start = (
+            rkrf_utils.init_processed_dict(
+                bias_version=config.bias_version,
+                path=config.path,
+                file_root=config.file_root,
+                device=device,
+                template_pdb=config.template_pdb,
+                PRESET=PRESET,
+            )
+        )
+        # Initialize bias
+        device_processed_features, optimizer, bias_names = rkrf_utils.init_bias(
+            device_processed_features=device_processed_features,
+            bias_version=config.bias_version,
+            device=device,
+            lr_a=lr_a,
+            lr_m=lr_m,
+            weight_decay=config.weight_decay,
+            starting_bias=config.starting_bias,
+            starting_weights=config.starting_weights,
+        )
+
+        # List initialization for saving values
+        mse_losses = []
+        time_by_epoch = []
+        memory_by_epoch = []
+        all_pldtts = []
+        mean_it_plddts = []
+        absolute_feats_changes = []
+
+        early_stopper = rkrf_utils.EarlyStopper(patience=50, min_delta=0.1)
+
+        progress_bar = tqdm(
+            range(config.iterations),
+            desc=f""{config.file_root}, uuid: {refinement_run_uuid[:4]}, run: {run_id}"",
+        )
+
+        ############ 3. Run Refinement ############
+        for iteration in progress_bar:
+            start_time = time.time()
+            optimizer.zero_grad()
+
+            # Avoid passing through graph a second time
+            device_processed_features[feature_key] = (
+                features_at_it_start.detach().clone()
+            )
+
+            # AF pass
+            if iteration == 0:
+                af2_output, prevs = af_bias(
+                    device_processed_features,
+                    [None, None, None],
+                    num_iters=config.init_recycling,
+                    bias=False,
+                )
+                prevs = [tensor.detach() for tensor in prevs]
+
+            deep_copied_prevs = [tensor.clone().detach() for tensor in prevs]
+            af2_output, __ = af_bias(
+                device_processed_features, deep_copied_prevs, num_iters=1, bias=True
+            )
+
+            # Position Kabsch Alignment
+            aligned_xyz, plddts_res, pseudo_Bs = rkrf_utils.position_alignment(
+                af2_output=af2_output,
+                device_processed_features=device_processed_features,
+                cra_name=target_pdb.cra_name,
+                best_pos=best_pos,
+                exclude_res=EXCLUDING_RES,
+            )
+
+            all_pldtts.append(plddts_res)
+            mean_it_plddts.append(np.mean(plddts_res))
+
+            # MSE loss
+            loss = mseloss.forward(aligned_xyz, bfactor_weights)
+
+            mse_losses.append(loss.item())
+
+            # check if current Rfree is the best so far
+            if mse_losses[-1] < best_loss:
+                best_loss = mse_losses[-1]
+                best_msa_bias = (
+                    device_processed_features[""msa_feat_bias""].detach().cpu().clone()
+                )
+                best_feat_weights = (
+                    device_processed_features[""msa_feat_weights""].detach().cpu().clone()
+                )
+                best_run = run_id
+                best_iter = iteration
+                best_pos = aligned_xyz.detach().clone()
+
+            # Save postRBR PDB
+            mseloss.pdb_obj.atom_b_iso = rk_utils.assert_numpy(pseudo_Bs)
+            mseloss.pdb_obj.atom_pos = rk_utils.assert_numpy(aligned_xyz)
+            mseloss.pdb_obj.savePDB(
+                f""{output_directory_path!s}/{run_id}_{iteration}_aligned.pdb""
+            )
+
+            progress_bar.set_postfix(
+                MSE=f""{loss.item():.2f}"",
+                memory=f""{torch.cuda.max_memory_allocated() / 1024**3:.1f}G"",
+            )
+
+            loss.backward()
+
+            if early_stopper.early_stop(loss.item()):
+                break
+
+            optimizer.step()
+
+            time_by_epoch.append(time.time() - start_time)
+            memory_by_epoch.append(torch.cuda.max_memory_allocated() / 1024**3)
+
+            # Save the absolute difference in mean contribution from each residue
+            # channel from previous iteration
+            if config.bias_version == 4:
+                features_at_step_end = (
+                    device_processed_features[""template_torsion_angles_sin_cos""][..., 0]
+                    .detach()
+                    .clone()
+                )
+                mean_change = torch.mean(
+                    torch.abs(features_at_step_end - features_at_it_start[..., 0]),
+                    dim=(0, 2, 3),
+                )
+            else:
+                features_at_step_end = (
+                    device_processed_features[""msa_feat""][:, :, 25:48, 0]
+                    .detach()
+                    .clone()
+                )
+                mean_change = torch.mean(
+                    torch.abs(
+                        features_at_step_end - features_at_it_start[:, :, 25:48, 0]
+                    ),
+                    dim=(0, 2),
+                )
+            absolute_feats_changes.append(rk_utils.assert_numpy(mean_change))
+
+        ####### Save data
+        # Average plddt per iteration
+        np.save(
+            f""{output_directory_path!s}/mean_it_plddt_{run_id}.npy"",
+            np.array(mean_it_plddts),
+        )
+
+        # MSE per iteration
+        np.save(
+            f""{output_directory_path!s}/MSE_it_{run_id}.npy"",
+            rk_utils.assert_numpy(mse_losses),
+        )
+
+        np.save(
+            f""{output_directory_path!s}/time_it_{run_id}.npy"",
+            rk_utils.assert_numpy(time_by_epoch),
+        )
+
+        np.save(
+            f""{output_directory_path!s}/memory_it_{run_id}.npy"",
+            rk_utils.assert_numpy(memory_by_epoch),
+        )
+
+        # Absolute MSA change per column per iteration
+        np.save(
+            f""{output_directory_path!s}/MSA_changes_it_{run_id}.npy"",
+            rk_utils.assert_numpy(absolute_feats_changes),
+        )
+
+        # Mean plddt per residue (over iterations)
+        np.save(
+            f""{output_directory_path!s}/mean_plddt_res_{run_id}.npy"",
+            np.mean(np.array(all_pldtts), axis=0),
+        )
+
+    # Save the best msa_bias and feat_weights
+    torch.save(
+        best_msa_bias,
+        f""{output_directory_path!s}/best_msa_bias_{best_run}_{best_iter}.pt"",
+    )
+
+    torch.save(
+        best_feat_weights,
+        f""{output_directory_path!s}/best_feat_weights_{best_run}_{best_iter}.pt"",
+    )
+
+    config.to_yaml_file(f""{output_directory_path!s}/config.yaml"")
+
+    return refinement_run_uuid
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/refinement_cryoem.py",".py","25211","658","import glob
+import os
+import shutil
+import time
+import uuid
+
+import numpy as np
+import torch
+from loguru import logger
+from openfold.config import model_config
+from openfold.data import data_pipeline, feature_pipeline
+from tqdm import tqdm
+
+import rocket
+from rocket import coordinates as rk_coordinates
+from rocket import refinement_utils as rkrf_utils
+from rocket import utils as rk_utils
+from rocket.cryo import structurefactors as cryo_sf
+from rocket.cryo import targets as cryo_targets
+from rocket.cryo import utils as cryo_utils
+from rocket.refinement_config import RocketRefinmentConfig
+
+PRESET = ""model_1_ptm""
+EXCLUDING_RES = None
+N_BINS = 20
+
+
+def run_cryoem_refinement(config: RocketRefinmentConfig | str) -> RocketRefinmentConfig:
+    if isinstance(config, str):
+        config = RocketRefinmentConfig.from_yaml_file(config)
+    assert config.datamode == ""cryoem"", ""Make sure to set datamode to 'cryoem'!""
+
+    ############ 1. Global settings ############
+    # Device
+    device = f""cuda:{config.cuda_device}""
+
+    # Using LBFGS or Adam in RBR
+    if config.rbr_opt_algorithm == ""lbfgs"":
+        RBR_LBFGS = True
+    elif config.rbr_opt_algorithm == ""adam"":
+        RBR_LBFGS = False
+    else:
+        raise ValueError(""rbr_opt only supports lbfgs or adam"")
+
+    target_id = config.file_id
+    path = config.path
+    mtz_file = f""{path}/ROCKET_inputs/{target_id}-Edata.mtz""
+    try:
+        input_pdb = glob.glob(config.input_pdb)[0]
+    except Exception as err:
+        raise ValueError(""input_pdb path is not valid!"") from err
+    note = config.note
+    bias_version = config.bias_version
+    iterations = config.iterations
+    num_of_runs = config.num_of_runs
+
+    if config.uuid_hex:
+        refinement_run_uuid = config.uuid_hex
+    else:
+        config.paths.uuid_hex = uuid.uuid4().hex[:10]
+        refinement_run_uuid = config.uuid_hex
+    output_directory_path = f""{path}/ROCKET_outputs/{refinement_run_uuid}/{note}""
+    try:
+        os.makedirs(output_directory_path, exist_ok=True)
+    except FileExistsError:
+        logger.info(
+            f""Warning: Directory '{output_directory_path}' already exists. Overwriting.""
+        )
+        logger.info(
+            f""System: {target_id}, run ID: {refinement_run_uuid!s}, Note: {note}"",
+        )
+
+    ############ 2. Initializations ############
+    # Do downsampling if specified
+    if config.downsample_ratio:
+        if config.downsample_ratio == 1:
+            logger.info(""Downsampling ratio is 1. Skipping downsampling..."")
+        else:
+            logger.info(
+                f""Downsampling reciprocal space, axis ratio: {config.downsample_ratio}""
+            )
+            mtz_file = cryo_utils.downsample_data(mtz_file, config.downsample_ratio)
+
+    # Apply resolution cutoff to the reflection file
+    if config.min_resolution is not None or config.max_resolution is not None:
+        mtz_file = rk_utils.apply_resolution_cutoff(
+            mtz_file,
+            min_resolution=config.min_resolution,
+            max_resolution=config.max_resolution,
+        )
+    if type(mtz_file) is str:
+        mtz_file = rk_utils.load_mtz(mtz_file)
+
+    # Prepare reusable variables for RSCC calculation
+    dobs_values = mtz_file[""Dobs""].to_numpy()
+    structure_factor = mtz_file.to_structurefactor(
+        sf_key=""Emean"", phase_key=""PHIEmean""
+    ).to_numpy()
+    rscc_reference_Fmap = torch.tensor(dobs_values * structure_factor, device=device)
+
+    # Initialize SFC
+    cryo_sfc = cryo_sf.initial_cryoSFC(
+        input_pdb, mtz_file, ""Emean"", ""PHIEmean"", device, N_BINS
+    )
+
+    sfc_rbr = cryo_sf.initial_cryoSFC(
+        input_pdb, mtz_file, ""Emean"", ""PHIEmean"", device, N_BINS
+    )
+    # prepare reusable variables for RSCC calculation
+    gridsize = mtz_file.get_reciprocal_grid_size(sample_rate=3.0)
+    Rg = torch.tensor(
+        rk_utils.g_function_np(2 * cryo_sfc.dmin, 1 / cryo_sfc.dHKL), device=device
+    )
+    uc_volume = cryo_sfc.unit_cell.volume
+
+    reference_pos = cryo_sfc.atom_pos_orth.clone()
+    target_seq = cryo_sfc._pdb.sequence
+    cra_calphas_list, calphas_mask = rk_coordinates.select_CA_from_craname(
+        cryo_sfc.cra_name
+    )
+
+    # Initialize RSCC Bfactor if phase1
+    if ""phase1"" in config.note:
+        Fprotein_plddt = cryo_sfc.calc_fprotein(Return=True)
+        ccmap = rk_utils.get_rscc_from_Fmap(
+            Fprotein_plddt.detach(),
+            rscc_reference_Fmap,
+            cryo_sfc.HKL_array,
+            gridsize,
+            Rg,
+            uc_volume,
+        )
+        atom_cc = rk_utils.interpolate_grid_points(
+            ccmap, cryo_sfc.atom_pos_frac.cpu().numpy()
+        )
+        rscc_bfactor = torch.tensor(
+            rk_utils.get_b_from_CC(atom_cc, cryo_sfc.dmin),
+            dtype=torch.float32,
+            device=device,
+        )
+
+        cryo_sfc.atom_b_iso = rscc_bfactor.clone().detach()
+        sfc_rbr.atom_b_iso = rscc_bfactor.clone().detach()
+
+    # Use initial pos B factor instead of best pos B factor for weighted L2
+    init_pos_bfactor = cryo_sfc.atom_b_iso.clone()
+    # Ad hoc settings for B-factor weighting cutoffs
+    cutoff1 = np.quantile(init_pos_bfactor.cpu().numpy(), 0.3)
+    cutoff2 = cutoff1 * 1.5
+    bfactor_weights = rk_utils.weighting_torch(init_pos_bfactor, cutoff1, cutoff2)
+    bfactor_weights = bfactor_weights / torch.sum(bfactor_weights)
+
+    # residue_numbers = [int(name.split(""-"")[1]) for name in cra_calphas_list]
+
+    # LLG initialization
+    cryo_llgloss = cryo_targets.LLGloss(cryo_sfc, mtz_file)
+    cryo_llgloss_rbr = cryo_targets.LLGloss(sfc_rbr, mtz_file)
+
+    # Model initialization
+    version_to_class = {
+        1: rocket.MSABiasAFv1,
+        2: rocket.MSABiasAFv2,
+        3: rocket.MSABiasAFv3,
+        4: rocket.TemplateBiasAF,
+    }
+    af_bias = version_to_class[bias_version](
+        model_config(PRESET, train=True), PRESET
+    ).to(device)
+    af_bias.freeze()
+
+    # Optimizer settings and initialization
+    if ""phase1"" in config.note:
+        lr_a = config.additive_learning_rate
+        lr_m = config.multiplicative_learning_rate
+    elif ""phase2"" in config.note:
+        lr_a = config.phase2_final_lr
+        lr_m = config.phase2_final_lr
+
+    best_loss = float(""inf"")
+    best_msa_bias = None
+    best_feat_weights = None
+    best_run = None
+    best_iter = None
+
+    # MH edit @ Nov 8th, 2024: Support to use msa as input
+    if config.msa_subratio is not None and config.input_msa is None:
+        config.input_msa = ""alignments""  # default dir for alignment
+
+    recombination_bias = None
+    if config.input_msa is not None:
+        fasta_path = [
+            f
+            for ext in (""*.fa"", ""*.fasta"")
+            for f in glob.glob(os.path.join(config.path, ext))
+        ][0]
+        a3m_path = os.path.join(config.path, config.input_msa)
+        if os.path.isfile(a3m_path):
+            msa_name, ext = os.path.splitext(os.path.basename(a3m_path))
+            alignment_dir = os.path.join(os.path.dirname(a3m_path), ""tmp_align"")
+            os.makedirs(alignment_dir, exist_ok=True)
+            shutil.copy(a3m_path, os.path.join(alignment_dir, msa_name + "".a3m""))
+            tmp_align = True
+        elif os.path.isdir(a3m_path):
+            alignment_dir = a3m_path
+            tmp_align = False
+        data_processor = data_pipeline.DataPipeline(template_featurizer=None)
+        feature_dict = rkrf_utils.generate_feature_dict(
+            fasta_path,
+            alignment_dir,
+            data_processor,
+        )
+        # prepare featuerizer
+        afconfig = model_config(PRESET)
+        afconfig.data.common.max_recycling_iters = config.init_recycling
+        del afconfig.data.common.masked_msa
+        afconfig.data.common.resample_msa_in_recycling = False
+        feature_processor = feature_pipeline.FeaturePipeline(afconfig.data)
+        if tmp_align:
+            shutil.rmtree(alignment_dir)
+
+        # MH edits @ Oct 19, 2024, support MSA subsampling at the beginning
+        if config.msa_subratio is not None:
+            assert config.msa_subratio > 0.0 and config.msa_subratio <= 1.0, (
+                ""msa_subratio should be None or between 0.0 and 1.0!""
+            )
+            # Do subsampling of msa, keep the first sequence
+            if config.sub_msa_path is None:
+                idx = np.arange(feature_dict[""msa""].shape[0] - 1) + 1
+                sub_idx = np.concatenate((
+                    np.array([0]),
+                    np.random.choice(
+                        idx, size=int(config.msa_subratio * len(idx)), replace=False
+                    ),
+                ))
+                feature_dict[""msa""] = feature_dict[""msa""][sub_idx]
+                feature_dict[""deletion_matrix_int""] = feature_dict[
+                    ""deletion_matrix_int""
+                ][sub_idx]
+                # Save out the subsampled msa
+                np.save(
+                    f""{output_directory_path!s}/sub_msa.npy"",
+                    feature_dict[""msa""],
+                )
+                np.save(
+                    f""{output_directory_path!s}/sub_delmat.npy"",
+                    feature_dict[""deletion_matrix_int""],
+                )
+            else:
+                feature_dict[""msa""] = np.load(config.sub_msa_path, allow_pickle=True)
+                feature_dict[""deletion_matrix_int""] = np.load(
+                    config.sub_delmat_path, allow_pickle=True
+                )
+        processed_feature_dict = feature_processor.process_features(
+            feature_dict, mode=""predict""
+        )
+
+        # Edit by MH @ Nov 18, 2024, use bias of fullmsa to realize the cluster msa
+        if config.bias_from_fullmsa:
+            fullmsa_dir = os.path.join(config.path, ""alignments"")
+            fullmsa_feature_dict = rkrf_utils.generate_feature_dict(
+                fasta_path,
+                fullmsa_dir,
+                data_processor,
+            )
+            fullmsa_processed_feature_dict = feature_processor.process_features(
+                fullmsa_feature_dict, mode=""predict""
+            )
+            fullmsa_profile = fullmsa_processed_feature_dict[""msa_feat""][
+                :, :, 25:48
+            ].clone()
+            submsa_profile = processed_feature_dict[""msa_feat""][:, :, 25:48].clone()
+            processed_feature_dict[""msa_feat""][:, :, 25:48] = (
+                fullmsa_profile.clone()
+            )  # Use full msa's profile as basis for linear space -- higher rank (?)
+            recombination_bias = (
+                submsa_profile[..., 0] - fullmsa_profile[..., 0]
+            )  # Use difference as the initial bias so we can start from desired profile
+        elif config.chimera_profile:
+            fullmsa_dir = os.path.join(config.path, ""alignments"")
+            fullmsa_feature_dict = rkrf_utils.generate_feature_dict(
+                fasta_path,
+                fullmsa_dir,
+                data_processor,
+            )
+            fullmsa_processed_feature_dict = feature_processor.process_features(
+                fullmsa_feature_dict, mode=""predict""
+            )
+            full_profile = fullmsa_processed_feature_dict[""msa_feat""][
+                :, :, 25:48
+            ].clone()
+            sub_profile = processed_feature_dict[""msa_feat""][:, :, 25:48].clone()
+            processed_feature_dict[""msa_feat""][:, :, 25:48] = torch.where(
+                sub_profile == 0.0, full_profile.clone(), sub_profile.clone()
+            )
+
+        device_processed_features = rk_utils.move_tensors_to_device(
+            processed_feature_dict, device=device
+        )
+        feature_key = ""msa_feat""
+
+        if config.msa_feat_init_path is None:
+            features_at_it_start = (
+                device_processed_features[feature_key].detach().clone()
+            )
+            np.save(
+                f""{output_directory_path!s}/msa_feat_start.npy"",
+                rk_utils.assert_numpy(features_at_it_start[..., 0]),
+            )
+        else:
+            msa_feat_init_np = np.load(
+                glob.glob(config.msa_feat_init_path)[0], allow_pickle=True
+            )
+            features_at_it_start_np = np.repeat(
+                np.expand_dims(msa_feat_init_np, -1), config.init_recycling + 1, -1
+            )
+            features_at_it_start = torch.tensor(features_at_it_start_np).to(
+                device_processed_features[feature_key]
+            )
+            device_processed_features[feature_key] = (
+                features_at_it_start.detach().clone()
+            )
+
+    else:
+        # Initialize the processed dict space
+        device_processed_features, feature_key, features_at_it_start = (
+            rkrf_utils.init_processed_dict(
+                bias_version=config.bias_version,
+                path=config.path,
+                device=device,
+                template_pdb=config.template_pdb,
+                target_seq=target_seq,
+                PRESET=PRESET,
+            )
+        )
+
+    # MH edit @ Oct 2nd, 2024: Support optional template input
+    if config.template_pdb is not None:
+        device_processed_features_template = rocket.make_processed_dict_from_template(
+            config.template_pdb,
+            target_seq,
+            device=device,
+            mask_sidechains_add_cb=True,
+            mask_sidechains=True,
+            max_recycling_iters=config.init_recycling,
+        )
+        for key in device_processed_features_template:
+            if key.startswith(""template_""):
+                device_processed_features[key] = device_processed_features_template[key]
+    # Write out config used, start the journey
+    config.to_yaml_file(f""{output_directory_path!s}/config.yaml"")
+    for n in range(num_of_runs):
+        run_id = rkrf_utils.number_to_letter(n)
+        best_pos = reference_pos
+
+        # Initialize bias
+        device_processed_features, optimizer, bias_names = rkrf_utils.init_bias(
+            device_processed_features=device_processed_features,
+            bias_version=config.bias_version,
+            device=device,
+            lr_a=lr_a,
+            lr_m=lr_m,
+            weight_decay=config.weight_decay,
+            starting_bias=config.starting_bias,
+            starting_weights=config.starting_weights,
+            recombination_bias=recombination_bias,
+        )
+
+        # List initialization for saving values
+        # sigmas_by_epoch = []
+        llg_losses = []
+        time_by_epoch = []
+        memory_by_epoch = []
+        all_pldtts = []
+        mean_it_plddts = []
+
+        progress_bar = tqdm(
+            range(iterations),
+            desc=f""{target_id}, uuid: {refinement_run_uuid[:4]}, run: {run_id}"",
+        )
+
+        # Prepare MDTraj PDB trajectory writer (open in append mode if exists)
+        traj_writer = None
+        md = None
+        mdtraj_template = None
+        try:
+            import mdtraj as md  # type: ignore
+
+            try:
+                from mdtraj.formats import PDBTrajectoryFile  # type: ignore
+            except Exception:
+                PDBTrajectoryFile = None  # type: ignore
+            traj_path_pdb = (
+                f""{output_directory_path!s}/{run_id}_refinement_trajectory.pdb""
+            )
+            mdtraj_template = md.load_pdb(input_pdb)
+            if PDBTrajectoryFile is not None:
+                traj_writer = PDBTrajectoryFile(traj_path_pdb, mode=""w"")
+            else:
+                traj_writer = None
+        except Exception as e:  # pragma: no cover - optional dependency
+            logger.warning(
+                f""mdtraj not available or failed to initialize writer ({e}); ""
+                ""falling back to per-iteration PDB saves.""
+            )
+
+        # Run smooth stage in phase 1
+        if ""phase1"" in config.note:
+            w_L2 = config.l2_weight
+        elif ""phase2"" in config.note:
+            w_L2 = 0.0
+
+        ######
+        early_stopper = rkrf_utils.EarlyStopper(patience=200, min_delta=10.0)
+
+        #### Phase 1 smooth scheduling ######
+        if config.smooth_stage_epochs is not None:
+            lr_a_initial = lr_a
+            lr_m_initial = lr_m
+            w_L2_initial = w_L2
+            lr_stage1_final = config.phase2_final_lr
+            smooth_stage_epochs = config.smooth_stage_epochs
+
+            # Decay rates for each stage
+            decay_rate_stage1_add = (lr_stage1_final / lr_a) ** (
+                1 / smooth_stage_epochs
+            )
+            decay_rate_stage1_mul = (lr_stage1_final / lr_m) ** (
+                1 / smooth_stage_epochs
+            )
+
+        ############ 3. Run Refinement ############
+        for iteration in progress_bar:
+            start_time = time.time()
+            optimizer.zero_grad()
+
+            # Avoid passing through graph a second time
+            device_processed_features[feature_key] = (
+                features_at_it_start.detach().clone()
+            )
+
+            # AF pass
+            if iteration == 0:
+                af2_output, prevs = af_bias(
+                    device_processed_features,
+                    [None, None, None],
+                    num_iters=config.init_recycling,
+                    bias=False,
+                )
+
+                prevs = [tensor.detach() for tensor in prevs]
+
+            deep_copied_prevs = [tensor.clone().detach() for tensor in prevs]
+
+            af2_output, __ = af_bias(
+                device_processed_features, deep_copied_prevs, num_iters=1, bias=True
+            )
+            L_plddt = -torch.mean(af2_output[""plddt""])
+
+            # Position Kabsch Alignment
+            aligned_xyz, plddts_res, pseudo_Bs = rkrf_utils.position_alignment(
+                af2_output=af2_output,
+                device_processed_features=device_processed_features,
+                cra_name=cryo_sfc.cra_name,
+                best_pos=best_pos,
+                exclude_res=EXCLUDING_RES,
+                domain_segs=config.domain_segs,
+                reference_bfactor=init_pos_bfactor,
+            )
+
+            cryo_llgloss.sfc.atom_b_iso = pseudo_Bs.detach().clone()
+            cryo_llgloss_rbr.sfc.atom_b_iso = pseudo_Bs.detach().clone()
+            all_pldtts.append(plddts_res)
+            mean_it_plddts.append(np.mean(plddts_res))
+
+            # Save the preRBR structure, for debugging
+            cryo_llgloss_rbr.sfc.atom_pos_orth = aligned_xyz.detach().clone()
+
+            # Compute RSCC, update the Bfacotrs
+            Fprotein_plddt = cryo_llgloss_rbr.sfc.calc_fprotein(Return=True)
+            ccmap = rk_utils.get_rscc_from_Fmap(
+                Fprotein_plddt.detach(),
+                rscc_reference_Fmap,
+                cryo_llgloss_rbr.sfc.HKL_array,
+                gridsize,
+                Rg,
+                uc_volume,
+            )
+            atom_cc = rk_utils.interpolate_grid_points(
+                ccmap, cryo_llgloss_rbr.sfc.atom_pos_frac.cpu().numpy()
+            )
+            rscc_bfactor = torch.tensor(
+                rk_utils.get_b_from_CC(atom_cc, cryo_llgloss_rbr.sfc.dmin),
+                dtype=torch.float32,
+                device=device,
+            )
+            cryo_llgloss_rbr.sfc.atom_b_iso = rscc_bfactor.detach().clone()
+            cryo_llgloss.sfc.atom_b_iso = rscc_bfactor.detach().clone()
+
+            # cryo_llgloss_rbr.sfc.savePDB(
+            #     f""{output_directory_path!s}/{run_id}_{iteration}_preRBR.pdb""
+            # )
+            if config.sfc_scale:
+                cryo_llgloss_rbr.sfc.calc_fprotein()
+                cryo_llgloss_rbr.sfc.get_scales_adam(
+                    lr=0.01,
+                    n_steps=10,
+                    sub_ratio=0.7,
+                    initialize=False,
+                )
+
+            # Rigid body refinement (RBR) step
+            optimized_xyz, loss_track_pose = rk_coordinates.rigidbody_refine_quat(
+                aligned_xyz,
+                cryo_llgloss_rbr,
+                sfc_rbr.cra_name,
+                domain_segs=config.domain_segs,
+                lbfgs=RBR_LBFGS,
+                lbfgs_lr=config.rbr_lbfgs_learning_rate,
+                verbose=config.verbose,
+            )
+
+            # Save the postRBR structure
+            cryo_llgloss.sfc.atom_pos_orth = optimized_xyz.detach().clone()
+
+            # Save trajectory on the fly
+            if traj_writer is not None:
+                coords_nm = optimized_xyz.detach().cpu().numpy().reshape(-1, 3) / 10.0
+                traj_writer.write(
+                    coords_nm, mdtraj_template.topology, modelIndex=iteration
+                )
+                # Flush the underlying file handle to write data immediately
+                if hasattr(traj_writer, ""_file"") and hasattr(
+                    traj_writer._file, ""flush""
+                ):
+                    traj_writer._file.flush()
+            else:
+                pdb_path = f""{output_directory_path!s}/{run_id}_{iteration}_postRBR.pdb""
+                cryo_llgloss.sfc.savePDB(pdb_path)
+
+            # LLG loss
+            L_llg = -cryo_llgloss(
+                optimized_xyz,
+                bin_labels=None,
+                num_batch=config.number_of_batches,
+                sub_ratio=config.batch_sub_ratio,
+                update_scales=config.sfc_scale,
+            )
+
+            llg_estimate = L_llg.clone().item() / (
+                config.batch_sub_ratio * config.number_of_batches
+            )  # + 30 * L_plddt
+
+            llg_losses.append(llg_estimate)
+
+            # check if current loss is the best so far
+            if llg_losses[-1] < best_loss:
+                best_loss = llg_losses[-1]
+                best_msa_bias = (
+                    device_processed_features[""msa_feat_bias""].detach().cpu().clone()
+                )
+                best_feat_weights = (
+                    device_processed_features[""msa_feat_weights""].detach().cpu().clone()
+                )
+                best_run = run_id
+                best_iter = iteration
+                best_pos = optimized_xyz.detach().clone()
+
+            progress_bar.set_postfix(
+                NEG_LLG=f""{llg_estimate:.2f}"",
+                memory=f""{torch.cuda.max_memory_allocated() / 1024**3:.1f}G"",
+            )
+
+            #### add an L2 loss to constrain confident atoms ###
+            if w_L2 > 0.0:
+                # use
+                L2_loss = torch.sum(
+                    bfactor_weights.unsqueeze(-1) * (optimized_xyz - reference_pos) ** 2
+                )  # / conf_best.shape[0]
+                loss = L_llg + w_L2 * L2_loss + config.w_plddt * L_plddt
+                loss.backward()
+            else:
+                loss = L_llg + config.w_plddt * L_plddt
+                loss.backward()
+
+                if early_stopper.early_stop(loss.item()):
+                    break
+
+            # Smooth in last part of phase 1 instead of beginning of phase 2
+            if (""phase1"" in config.note) and (config.smooth_stage_epochs is not None):
+                if iteration > (config.iterations - smooth_stage_epochs):
+                    lr_a = lr_a_initial * (decay_rate_stage1_add**iteration)
+                    lr_m = lr_m_initial * (decay_rate_stage1_mul**iteration)
+                    w_L2 = w_L2_initial * (1 - (iteration / smooth_stage_epochs))
+
+                # Update the learning rates in the optimizer
+                optimizer.param_groups[0][""lr""] = lr_a
+                optimizer.param_groups[1][""lr""] = lr_m
+                optimizer.step()
+            else:
+                optimizer.step()
+
+            time_by_epoch.append(time.time() - start_time)
+            memory_by_epoch.append(torch.cuda.max_memory_allocated() / 1024**3)
+
+        # Close the trajectory writer if it was opened
+        if traj_writer is not None:
+            traj_writer.close()
+
+        # Average plddt per iteration
+        np.save(
+            f""{output_directory_path!s}/mean_it_plddt_{run_id}.npy"",
+            np.array(mean_it_plddts),
+        )
+
+        # LLG per iteration
+        np.save(
+            f""{output_directory_path!s}/NEG_LLG_it_{run_id}.npy"",
+            rk_utils.assert_numpy(llg_losses),
+        )
+
+    torch.save(
+        best_msa_bias,
+        f""{output_directory_path!s}/best_msa_bias_{best_run}_{best_iter}.pt"",
+    )
+
+    torch.save(
+        best_feat_weights,
+        f""{output_directory_path!s}/best_feat_weights_{best_run}_{best_iter}.pt"",
+    )
+
+    # Save best model as a single PDB (preserve input_pdb topology)
+    try:
+        if best_pos is not None:
+            try:
+                cryo_llgloss.sfc.atom_pos_orth = best_pos
+                best_name = (
+                    f""{output_directory_path!s}/best_model_{best_run}_{best_iter}.pdb""
+                )
+                cryo_llgloss.sfc.savePDB(best_name)
+            except Exception:
+                try:
+                    import mdtraj as md  # type: ignore
+
+                    topo = md.load_pdb(input_pdb).topology
+                    coords_nm = best_pos.detach().cpu().numpy().reshape(1, -1, 3) / 10.0
+                    traj = md.Trajectory(coords_nm, topo)
+                    traj.save(
+                        f""{output_directory_path!s}/best_model_{best_run}_{best_iter}.pdb""
+                    )
+                except Exception:
+                    logger.warning(
+                        ""Failed to write best model PDB with both SFC and mdtraj.""
+                    )
+    except NameError:
+        pass
+
+    return config
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/refinement_utils.py",".py","15167","478","import glob
+import pickle
+import re
+
+import numpy as np
+import skbio
+import torch
+from SFC_Torch import PDBParser
+
+import rocket
+from rocket import coordinates as rk_coordinates
+from rocket import utils as rk_utils
+from rocket.xtal import utils as llg_utils
+
+
+def generate_feature_dict(
+    fasta_path,
+    alignment_dir,
+    data_processor,
+):
+    feature_dict = data_processor.process_fasta(
+        fasta_path=fasta_path,
+        alignment_dir=alignment_dir,
+        seqemb_mode=False,
+    )
+    return feature_dict
+
+
+def number_to_letter(n):
+    if 0 <= n <= 25:
+        return chr(n + 65)
+    else:
+        return None
+
+
+def get_identical_indices(A, B):
+    """"""
+    Get indices of aligned string A and B to produce identical sequence
+
+    >>> A = 'EWTUY'
+    >>> B = 'E-RUY'
+    >>> get_identical_indices(A, B)
+    [0,3,4], [0,2,3]
+
+    So A[0,3,4] = 'EUY' = B[0,2,3]
+    """"""
+    ind_A = []
+    ind_B = []
+    ai = 0
+    bi = 0
+    for a, b in zip(A, B, strict=False):
+        if a == ""-"":
+            bi += 1
+            continue
+        if b == ""-"":
+            ai += 1
+            continue
+        if a == b:
+            ind_A.append(ai)
+            ind_B.append(bi)
+            ai += 1
+            bi += 1
+        else:
+            ai += 1
+            bi += 1
+    return np.array(ind_A), np.array(ind_B)
+
+
+def get_pattern_index(str_list, pattern):
+    return next((i for i, s in enumerate(str_list) if re.match(pattern, s)), None)
+
+
+def get_common_ca_ind(pdb1: PDBParser, pdb2: PDBParser):
+    """"""
+    A known bug: it can throw some residues out when the two pdbs have ideentical sequences
+    for example, ""DFGTT"" for both, and it will only keep ""GTT""
+    """"""  # noqa: E501
+    seq1 = pdb1.sequence
+    seq2 = pdb2.sequence
+    alignment = skbio.alignment.StripedSmithWaterman(seq1)(
+        seq2
+    )  # Align sequence with Smith Waterman Algorithm
+    subind_1 = np.arange(alignment.query_begin, alignment.query_end + 1)
+    subind_2 = np.arange(alignment.target_begin, alignment.target_end_optimal + 1)
+    subsubind_1, subsubind_2 = get_identical_indices(
+        alignment.aligned_query_sequence, alignment.aligned_target_sequence
+    )
+    common_seq1 = subind_1[subsubind_1]
+    common_seq2 = subind_2[subsubind_2]
+    common_ca_ind_1 = [
+        get_pattern_index(pdb1.cra_name, rf"".*-{j}-.*-CA$"") for j in common_seq1
+    ]
+    common_ca_ind_2 = [
+        get_pattern_index(pdb2.cra_name, rf"".*-{i}-.*-CA$"") for i in common_seq2
+    ]
+    assert (
+        np.array([i[-6:] for i in np.array(pdb1.cra_name)[common_ca_ind_1]])
+        == np.array([i[-6:] for i in np.array(pdb2.cra_name)[common_ca_ind_2]])
+    ).all()
+    return common_ca_ind_1, common_ca_ind_2
+
+
+def get_common_bb_ind(pdb1, pdb2):
+    seq1 = pdb1.sequence
+    seq2 = pdb2.sequence
+    alignment = skbio.alignment.StripedSmithWaterman(seq1)(
+        seq2
+    )  # Align sequence with Smith Waterman Algorithm
+    subind_1 = np.arange(alignment.query_begin, alignment.query_end + 1)
+    subind_2 = np.arange(alignment.target_begin, alignment.target_end_optimal + 1)
+    subsubind_1, subsubind_2 = get_identical_indices(
+        alignment.aligned_query_sequence, alignment.aligned_target_sequence
+    )
+    common_seq1 = subind_1[subsubind_1]
+    common_seq2 = subind_2[subsubind_2]
+    common_ca_ind_1 = [
+        get_pattern_index(pdb1.cra_name, rf"".*-{j}-.*-CA$"") for j in common_seq1
+    ]
+    common_N_ind_1 = [
+        get_pattern_index(pdb1.cra_name, rf"".*-{j}-.*-N$"") for j in common_seq1
+    ]
+    common_C_ind_1 = [
+        get_pattern_index(pdb1.cra_name, rf"".*-{j}-.*-C$"") for j in common_seq1
+    ]
+    common_ca_ind_2 = [
+        get_pattern_index(pdb2.cra_name, rf"".*-{i}-.*-CA$"") for i in common_seq2
+    ]
+    common_N_ind_2 = [
+        get_pattern_index(pdb2.cra_name, rf"".*-{i}-.*-N$"") for i in common_seq2
+    ]
+    common_C_ind_2 = [
+        get_pattern_index(pdb2.cra_name, rf"".*-{i}-.*-C$"") for i in common_seq2
+    ]
+
+    filtered_ca_ind_1 = list(filter(lambda x: x is not None, common_ca_ind_1))
+    filtered_N_ind_1 = list(filter(lambda x: x is not None, common_N_ind_1))
+    filtered_C_ind_1 = list(filter(lambda x: x is not None, common_C_ind_1))
+
+    filtered_ca_ind_2 = list(filter(lambda x: x is not None, common_ca_ind_2))
+    filtered_N_ind_2 = list(filter(lambda x: x is not None, common_N_ind_2))
+    filtered_C_ind_2 = list(filter(lambda x: x is not None, common_C_ind_2))
+
+    # Now add only the valid lists
+    common_bb_ind_1 = filtered_ca_ind_1 + filtered_N_ind_1 + filtered_C_ind_1
+    common_bb_ind_2 = filtered_ca_ind_2 + filtered_N_ind_2 + filtered_C_ind_2
+    assert (
+        np.array([i[-6:] for i in np.array(pdb1.cra_name)[common_bb_ind_1]])
+        == np.array([i[-6:] for i in np.array(pdb2.cra_name)[common_bb_ind_2]])
+    ).all()
+    return common_bb_ind_1, common_bb_ind_2
+
+
+def get_current_lr(optimizer):
+    for param_group in optimizer.param_groups:
+        return param_group[""lr""]
+
+
+class EarlyStopper:
+    def __init__(self, patience=200, min_delta=0.1):
+        self.patience = patience
+        self.min_delta = min_delta
+        self.counter = 0
+        self.min_loss = float(""inf"")
+
+    def early_stop(self, loss):
+        if loss < (self.min_loss - self.min_delta):
+            self.min_loss = loss
+            self.counter = 0
+        else:
+            self.counter += 1
+            if self.counter >= self.patience:
+                return True
+        return False
+
+
+def init_processed_dict(
+    bias_version,
+    path,
+    device,
+    template_pdb=None,
+    target_seq=None,
+    PRESET=""model_1_ptm"",
+    postfix=""processed_feats.pickle"",
+):
+    if bias_version == 4:
+        device_processed_features = rocket.make_processed_dict_from_template(
+            template_pdb=f""{path}/ROCKET_inputs/{template_pdb}"",
+            target_seq=target_seq,
+            config_preset=PRESET,
+            device=device,
+            msa_dict=None,
+        )
+        features_at_it_start = (
+            device_processed_features[""template_torsion_angles_sin_cos""]
+            .detach()
+            .clone()
+        )
+        feature_key = ""template_torsion_angles_sin_cos""
+    else:
+        with open(glob.glob(f""{path}/predictions/*{postfix}"")[0], ""rb"") as file:
+            # Load the data from the pickle file
+            processed_features = pickle.load(file)
+
+        device_processed_features = rk_utils.move_tensors_to_device(
+            processed_features, device=device
+        )
+        features_at_it_start = device_processed_features[""msa_feat""].detach().clone()
+        feature_key = ""msa_feat""
+    return device_processed_features, feature_key, features_at_it_start
+
+
+def init_llgloss(sfc, tng_file, min_resolution=None, max_resolution=None):
+    resol_min = min(sfc.dHKL) if min_resolution is None else min_resolution
+    resol_max = max(sfc.dHKL) if max_resolution is None else max_resolution
+    llgloss = rocket.xtal.targets.LLGloss(
+        sfc, tng_file, sfc.device, resol_min, resol_max
+    )
+    return llgloss
+
+
+def init_bias(
+    device_processed_features,
+    bias_version,
+    device,
+    lr_a,
+    lr_m,
+    weight_decay=None,
+    starting_bias=None,
+    starting_weights=None,
+    recombination_bias=None,
+):
+    num_res = device_processed_features[""aatype""].shape[0]
+    device_processed_features[""msa_feat_bias""] = torch.zeros(
+        (512, num_res, 23), requires_grad=True, device=device
+    )
+
+    if bias_version == 4:
+        device_processed_features[""template_torsion_angles_sin_cos_bias""] = (
+            torch.zeros_like(
+                device_processed_features[""template_torsion_angles_sin_cos""],
+                requires_grad=True,
+                device=device,
+            )
+        )
+        if weight_decay is None:
+            optimizer = torch.optim.Adam([
+                {
+                    ""params"": device_processed_features[
+                        ""template_torsion_angles_sin_cos_bias""
+                    ],
+                    ""lr"": lr_a,
+                },
+            ])
+        else:
+            optimizer = torch.optim.AdamW(
+                [
+                    {
+                        ""params"": device_processed_features[
+                            ""template_torsion_angles_sin_cos_bias""
+                        ],
+                        ""lr"": lr_a,
+                    },
+                ],
+                weight_decay=weight_decay,
+            )
+        bias_names = [""template_torsion_angles_sin_cos_bias""]
+
+    elif bias_version == 3:
+        if starting_weights is not None:
+            device_processed_features[""msa_feat_weights""] = (
+                torch.load(glob.glob(starting_weights)[0])
+                .detach()
+                .to(device=device)
+                .requires_grad_(True)
+            )
+        else:
+            device_processed_features[""msa_feat_weights""] = torch.ones(
+                (512, num_res, 23), requires_grad=True, device=device
+            )
+
+        if recombination_bias is not None:
+            device_processed_features[""msa_feat_bias""] = (
+                recombination_bias.detach().to(device=device).requires_grad_(True)
+            )
+        elif starting_bias is not None:
+            device_processed_features[""msa_feat_bias""] = (
+                torch.load(glob.glob(starting_bias)[0])
+                .detach()
+                .to(device=device)
+                .requires_grad_(True)
+            )
+
+        if weight_decay is None:
+            optimizer = torch.optim.Adam([
+                {""params"": device_processed_features[""msa_feat_bias""], ""lr"": lr_a},
+                {
+                    ""params"": device_processed_features[""msa_feat_weights""],
+                    ""lr"": lr_m,
+                },
+            ])
+        else:
+            optimizer = torch.optim.AdamW(
+                [
+                    {""params"": device_processed_features[""msa_feat_bias""], ""lr"": lr_a},
+                    {
+                        ""params"": device_processed_features[""msa_feat_weights""],
+                        ""lr"": lr_m,
+                    },
+                ],
+                weight_decay=weight_decay,
+            )
+        bias_names = [""msa_feat_bias"", ""msa_feat_weights""]
+
+    elif bias_version == 2:
+        device_processed_features[""msa_feat_weights""] = torch.eye(
+            512, dtype=torch.float32, requires_grad=True, device=device
+        )
+
+        if weight_decay is None:
+            optimizer = torch.optim.Adam([
+                {""params"": device_processed_features[""msa_feat_bias""], ""lr"": lr_a},
+                {
+                    ""params"": device_processed_features[""msa_feat_weights""],
+                    ""lr"": lr_m,
+                },
+            ])
+        else:
+            optimizer = torch.optim.AdamW(
+                [
+                    {""params"": device_processed_features[""msa_feat_bias""], ""lr"": lr_a},
+                    {
+                        ""params"": device_processed_features[""msa_feat_weights""],
+                        ""lr"": lr_m,
+                    },
+                ],
+                weight_decay=weight_decay,
+            )
+        bias_names = [""msa_feat_bias"", ""msa_feat_weights""]
+
+    elif bias_version == 1:
+        if weight_decay is None:
+            optimizer = torch.optim.Adam([
+                {""params"": device_processed_features[""msa_feat_bias""], ""lr"": lr_a},
+            ])
+        else:
+            optimizer = torch.optim.AdamW(
+                [
+                    {""params"": device_processed_features[""msa_feat_bias""], ""lr"": lr_a},
+                ],
+                weight_decay=weight_decay,
+            )
+
+        bias_names = [""msa_feat_bias""]
+
+    return device_processed_features, optimizer, bias_names
+
+
+def position_alignment(
+    af2_output,
+    device_processed_features,
+    cra_name,
+    best_pos,
+    exclude_res,
+    domain_segs=None,
+    reference_bfactor=None,
+):
+    xyz_orth_sfc, plddts = rk_coordinates.extract_allatoms(
+        af2_output, device_processed_features, cra_name
+    )
+    plddts_res = rk_utils.assert_numpy(af2_output[""plddt""])
+    pseudo_Bs = rk_utils.plddt2pseudoB_pt(plddts)
+
+    # MH @ Sep 10 2024, temp edits to convert weighted kabsch to cutoff kabsch
+    if reference_bfactor is None:
+        pseudoB_np = rk_utils.assert_numpy(pseudo_Bs)
+        cutoff1 = np.quantile(pseudoB_np, 0.3)
+        cutoff2 = cutoff1 * 1.5
+        weights = rk_utils.weighting(pseudoB_np, cutoff1, cutoff2)
+    else:
+        assert reference_bfactor.shape == pseudo_Bs.shape, (
+            ""Reference bfactor should have same shape as model bfactor!""
+        )
+        reference_bfactor_np = rk_utils.assert_numpy(reference_bfactor)
+        cutoff1 = np.quantile(reference_bfactor_np, 0.3)
+        cutoff2 = cutoff1 * 1.5
+        weights = rk_utils.weighting(reference_bfactor_np, cutoff1, cutoff2)
+    # plddts_np = rk_utils.assert_numpy(plddts)
+    # weights = np.ones_like(plddts_np)
+    # weights[plddts_np < 85.0] = 1e-5
+
+    aligned_xyz = rk_coordinates.iterative_kabsch_alignment(
+        xyz_orth_sfc,
+        best_pos,
+        cra_name,
+        weights=weights,
+        exclude_res=exclude_res,
+        domain_segs=domain_segs,
+    )
+    return aligned_xyz, plddts_res, pseudo_Bs.detach()
+
+
+def update_sigmaA(
+    llgloss,
+    llgloss_rbr,
+    aligned_xyz,
+    constant_fp_added_HKL=None,
+    constant_fp_added_asu=None,
+):
+    Ecalc, Fc = llgloss.compute_Ecalc(
+        aligned_xyz.detach(),
+        return_Fc=True,
+        return_Rfactors=False,
+        update_scales=True,
+        added_chain_HKL=constant_fp_added_HKL,
+        added_chain_asu=constant_fp_added_asu,
+    )
+    Ecalc_rbr, _ = llgloss_rbr.compute_Ecalc(
+        aligned_xyz.detach(),
+        return_Fc=True,
+        return_Rfactors=False,
+        solvent=False,
+        update_scales=True,
+        added_chain_HKL=constant_fp_added_HKL,
+        added_chain_asu=constant_fp_added_asu,
+    )
+    llgloss.refine_sigmaA_newton(
+        Ecalc, n_steps=5, subset=""working"", smooth_overall_weight=0.0
+    )
+    llgloss_rbr.refine_sigmaA_newton(
+        Ecalc_rbr, n_steps=2, subset=""working"", smooth_overall_weight=0.0
+    )
+    return llgloss, llgloss_rbr, Ecalc, Fc
+
+
+def sigmaA_from_true(
+    llgloss,
+    llgloss_rbr,
+    aligned_xyz,
+    Etrue,
+    phitrue,
+    constant_fp_added_HKL=None,
+    constant_fp_added_asu=None,
+):
+    Ecalc, Fc = llgloss.compute_Ecalc(
+        aligned_xyz.detach(),
+        return_Fc=True,
+        update_scales=True,
+        added_chain_HKL=constant_fp_added_HKL,
+        added_chain_asu=constant_fp_added_asu,
+    )
+    Ecalc_rbr, Fc_rbr = llgloss_rbr.compute_Ecalc(
+        aligned_xyz.detach(),
+        return_Fc=True,
+        solvent=False,
+        update_scales=True,
+        added_chain_HKL=constant_fp_added_HKL,
+        added_chain_asu=constant_fp_added_asu,
+    )
+    sigmas = llg_utils.sigmaA_from_model(
+        Etrue,
+        phitrue,
+        Ecalc,
+        Fc,
+        llgloss.sfc.dHKL,
+        llgloss.bin_labels,
+    )
+    llgloss.sigmaAs = sigmas
+    sigmas_rbr = llg_utils.sigmaA_from_model(
+        Etrue,
+        phitrue,
+        Ecalc_rbr,
+        Fc_rbr,
+        llgloss.sfc.dHKL,
+        llgloss.bin_labels,
+    )
+    llgloss_rbr.sigmaAs = sigmas_rbr
+    return llgloss, llgloss_rbr
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/__init__.py",".py","704","27","# Top Level API
+# Submodules
+from rocket import base, coordinates, cryo, refinement_utils, utils, xtal
+from rocket.base import MSABiasAFv1, MSABiasAFv2, MSABiasAFv3, TemplateBiasAF
+from rocket.helper import make_processed_dict_from_template
+from rocket.mse import MSEloss, MSElossBB
+from rocket.xtal.targets import LLGloss
+
+__all__ = [
+    # List submodules you want to expose
+    ""base"",
+    ""coordinates"",
+    ""xtal"",
+    ""cryo"",
+    ""utils"",
+    ""refinement_utils"",
+    # List specific classes/functions you want to expose directly
+    ""MSABiasAFv1"",
+    ""MSABiasAFv2"",
+    ""MSABiasAFv3"",
+    ""TemplateBiasAF"",
+    ""make_processed_dict_from_template"",
+    ""LLGloss"",
+    ""MSEloss"",
+    ""MSElossBB"",
+]
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/refinement_config.py",".py","13412","382","""""""
+This module contains the configuration classes for the ROCKET refinement pipeline.
+The configuration is stored in a human-readable YAML file and
+can be loaded into a RocketRefinmentConfig object.
+""""""
+
+import os
+import uuid
+from enum import Enum
+from typing import Any, ClassVar
+
+import yaml
+from pydantic import BaseModel, Field, field_validator
+
+
+# Custom StrEnum implementation for Python < 3.11
+class StrEnum(str, Enum):
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
+class DATAMODE(StrEnum):
+    XRAY = ""xray""
+    CRYOEM = ""cryoem""
+
+
+# Path and file configuration
+class PathConfig(BaseModel):
+    path: str = """"
+    file_id: str = """"
+    input_pdb: str = """"
+    template_pdb: str | None = None
+    input_msa: str | None = None
+    sub_msa_path: str | None = None
+    sub_delmat_path: str | None = None
+    msa_feat_init_path: str | None = None
+    starting_bias: str | None = None
+    starting_weights: str | None = None
+    uuid_hex: str | None = None
+
+
+# Hardware and execution configuration
+class ExecutionConfig(BaseModel):
+    cuda_device: int = 0
+    num_of_runs: int = 1
+    verbose: bool = False
+
+
+# Optimization parameters
+class OptimizationParams(BaseModel):
+    additive_learning_rate: float = 0.05
+    multiplicative_learning_rate: float = 1.0
+    weight_decay: float | None = 0.0001
+    batch_sub_ratio: float = 0.7
+    number_of_batches: int = 1
+    rbr_opt_algorithm: str = ""lbfgs""
+    rbr_lbfgs_learning_rate: float = 150.0
+    smooth_stage_epochs: int | None = 50
+    phase2_final_lr: float = 1e-3
+    l2_weight: float = 1e-7
+
+
+# Feature flags
+class FeatureFlags(BaseModel):
+    solvent: bool = True
+    sfc_scale: bool = True
+    refine_sigmaA: bool = True
+    additional_chain: bool = False
+    total_chain_copy: float = 1.0
+    bias_from_fullmsa: bool = False
+    chimera_profile: bool = False
+
+
+# Algorithm parameters
+class AlgorithmConfig(BaseModel):
+    bias_version: int = 3
+    iterations: int = 100
+    init_recycling: int = 1
+    domain_segs: list[int] | None = None
+    optimization: OptimizationParams = Field(default_factory=OptimizationParams)
+    features: FeatureFlags = Field(default_factory=FeatureFlags)
+
+
+# Data-specific configuration
+class DataConfig(BaseModel):
+    datamode: DATAMODE = ""xray""
+    free_flag: str = ""R-free-flags""
+    testset_value: int = 1
+    min_resolution: float | None = None
+    max_resolution: float | None = None
+    voxel_spacing: float = 4.5
+    msa_subratio: float | None = None
+    w_plddt: float = 0.0
+    downsample_ratio: int | None = None
+
+    @field_validator(""datamode"", mode=""before"")
+    @classmethod
+    def validate_datamode(cls, v: str) -> ""DATAMODE"":
+        """"""
+        Validates and converts the input to a DATAMODE enum member.
+
+        Raises:
+            ValueError: If `v` is not a valid DATAMODE value.
+        """"""
+        if isinstance(v, str):
+            try:
+                return DATAMODE(v)
+            except ValueError as err:
+                valid_values = [e.value for e in DATAMODE]
+                raise ValueError(
+                    f""Invalid datamode: {v}. Must be one of: {valid_values}""
+                ) from err
+        return v
+
+    model_config = {""use_enum_values"": True}
+
+
+# Main configuration class
+class RocketRefinmentConfig(BaseModel):
+    # Metadata
+    note: str = """"
+
+    # Nested configurations
+    paths: PathConfig = Field(default_factory=PathConfig)
+    execution: ExecutionConfig = Field(default_factory=ExecutionConfig)
+    algorithm: AlgorithmConfig = Field(default_factory=AlgorithmConfig)
+    data: DataConfig = Field(default_factory=DataConfig)
+
+    model_config = {""use_enum_values"": True}
+
+    # Mapping for flat to nested structure conversion
+    _flat_to_nested_map: ClassVar[dict[str, str]] = {
+        # Paths
+        ""path"": ""paths.path"",
+        ""file_id"": ""paths.file_id"",
+        ""input_pdb"": ""paths.input_pdb"",
+        ""template_pdb"": ""paths.template_pdb"",
+        ""input_msa"": ""paths.input_msa"",
+        ""sub_msa_path"": ""paths.sub_msa_path"",
+        ""sub_delmat_path"": ""paths.sub_delmat_path"",
+        ""msa_feat_init_path"": ""paths.msa_feat_init_path"",
+        ""starting_bias"": ""paths.starting_bias"",
+        ""starting_weights"": ""paths.starting_weights"",
+        ""uuid_hex"": ""paths.uuid_hex"",
+        # Execution
+        ""cuda_device"": ""execution.cuda_device"",
+        ""num_of_runs"": ""execution.num_of_runs"",
+        ""verbose"": ""execution.verbose"",
+        # Algorithm
+        ""bias_version"": ""algorithm.bias_version"",
+        ""iterations"": ""algorithm.iterations"",
+        ""init_recycling"": ""algorithm.init_recycling"",
+        ""domain_segs"": ""algorithm.domain_segs"",
+        # Optimization
+        ""additive_learning_rate"": ""algorithm.optimization.additive_learning_rate"",
+        ""multiplicative_learning_rate"": ""algorithm.optimization.multiplicative_learning_rate"",  # noqa: E501
+        ""weight_decay"": ""algorithm.optimization.weight_decay"",
+        ""batch_sub_ratio"": ""algorithm.optimization.batch_sub_ratio"",
+        ""number_of_batches"": ""algorithm.optimization.number_of_batches"",
+        ""rbr_opt_algorithm"": ""algorithm.optimization.rbr_opt_algorithm"",
+        ""rbr_lbfgs_learning_rate"": ""algorithm.optimization.rbr_lbfgs_learning_rate"",
+        ""smooth_stage_epochs"": ""algorithm.optimization.smooth_stage_epochs"",
+        ""phase2_final_lr"": ""algorithm.optimization.phase2_final_lr"",
+        ""l2_weight"": ""algorithm.optimization.l2_weight"",
+        # Features
+        ""solvent"": ""algorithm.features.solvent"",
+        ""sfc_scale"": ""algorithm.features.sfc_scale"",
+        ""refine_sigmaA"": ""algorithm.features.refine_sigmaA"",
+        ""additional_chain"": ""algorithm.features.additional_chain"",
+        ""total_chain_copy"": ""algorithm.features.total_chain_copy"",
+        ""bias_from_fullmsa"": ""algorithm.features.bias_from_fullmsa"",
+        ""chimera_profile"": ""algorithm.features.chimera_profile"",
+        # Data
+        ""datamode"": ""data.datamode"",
+        ""free_flag"": ""data.free_flag"",
+        ""testset_value"": ""data.testset_value"",
+        ""min_resolution"": ""data.min_resolution"",
+        ""max_resolution"": ""data.max_resolution"",
+        ""voxel_spacing"": ""data.voxel_spacing"",
+        ""msa_subratio"": ""data.msa_subratio"",
+        ""w_plddt"": ""data.w_plddt"",
+        ""downsample_ratio"": ""data.downsample_ratio"",
+        # Metadata
+        ""note"": ""note"",
+    }
+
+    # Helper methods for backward compatibility
+    def __getattr__(self, name):
+        """"""Allow access to nested attributes directly for backward compatibility""""""
+        if name in self._flat_to_nested_map:
+            path = self._flat_to_nested_map[name].split(""."")
+            value = self
+            for part in path:
+                value = getattr(value, part)
+            return value
+        raise AttributeError(
+            f""'{type(self).__name__}' object has no attribute '{name}'""
+        )
+
+    def to_yaml_file(self, file_path: str) -> None:
+        """"""Save configuration to YAML with fields in specific order""""""
+        # Convert model to dict
+        model_dict = self.model_dump()
+
+        # Create an ordered dictionary with the desired field order
+        ordered_dict = {}
+        # Define the order of top-level fields
+        field_order = [""note"", ""data"", ""paths"", ""execution"", ""algorithm""]
+
+        # Add fields in the specified order
+        for field in field_order:
+            if field in model_dict:
+                ordered_dict[field] = model_dict[field]
+
+        # Add any remaining fields that weren't in our order list
+        for key, value in model_dict.items():
+            if key not in ordered_dict:
+                ordered_dict[key] = value
+
+        # Write to file
+        with open(file_path, ""w"") as file:
+            yaml.dump(ordered_dict, file, sort_keys=False)
+
+    def to_flat_yaml_file(self, file_path: str) -> None:
+        """"""Save configuration in the old flat format for backward compatibility""""""
+        flat_dict = self.to_flat_dict()
+        with open(file_path, ""w"") as file:
+            yaml.dump(flat_dict, file)
+
+    def to_flat_dict(self) -> dict[str, Any]:
+        """"""Convert the nested structure to a flat dictionary""""""
+        result = {}
+        for flat_key, nested_path in self._flat_to_nested_map.items():
+            path_parts = nested_path.split(""."")
+            value = self
+            for part in path_parts:
+                value = getattr(value, part)
+            result[flat_key] = value
+        return result
+
+    @classmethod
+    def from_yaml_file(cls, file_path: str):
+        with open(file_path) as file:
+            payload = yaml.safe_load(file)
+
+        # Try to determine if this is a flat or nested format
+        if any(key in payload for key in [""paths"", ""algorithm"", ""data"", ""execution""]):
+            # This appears to be a nested format
+            return cls.model_validate(payload)
+        else:
+            # This appears to be a flat format
+            return cls.from_flat_dict(payload)
+
+    @classmethod
+    def from_flat_dict(cls, flat_dict: dict[str, Any]):
+        """"""Create an instance from a flat dictionary (old format)""""""
+        # Initialize nested dictionaries
+        nested_dict = {
+            ""paths"": {},
+            ""execution"": {},
+            ""algorithm"": {""optimization"": {}, ""features"": {}},
+            ""data"": {},
+            ""note"": flat_dict.get(""note"", """"),
+        }
+
+        # Map flat keys to nested structure
+        for flat_key, value in flat_dict.items():
+            if flat_key in cls._flat_to_nested_map:
+                nested_path = cls._flat_to_nested_map[flat_key].split(""."")
+
+                # Navigate to the correct nested dictionary
+                target_dict = nested_dict
+                for part in nested_path[:-1]:
+                    target_dict = target_dict[part]
+
+                # Set the value in the nested structure
+                target_dict[nested_path[-1]] = value
+
+        # Create the instance
+        return cls.model_validate(nested_dict)
+
+
+class RUNMODE(StrEnum):
+    PHASE1 = ""phase1""
+    PHASE2 = ""phase2""
+    BOTH = ""both""
+
+
+def gen_config(
+    mode: RUNMODE | None = RUNMODE.BOTH,
+    datamode: DATAMODE | None = None,
+    working_dir: str | None = None,
+    file_id: str | None = None,
+    pre_phase1_config: RocketRefinmentConfig | None = None,
+):
+    if mode == RUNMODE.PHASE1:
+        phase1_config = gen_config_phase1(datamode, working_dir, file_id)
+        phase1_config.to_yaml_file(
+            os.path.join(working_dir, ""ROCKET_config_phase1.yaml"")
+        )
+        return phase1_config
+    elif mode == RUNMODE.PHASE2:
+        phase2_config = gen_config_phase2(pre_phase1_config)
+        phase2_config.to_yaml_file(
+            os.path.join(phase2_config.working_dir, ""ROCKET_config_phase2.yaml"")
+        )
+        return phase2_config
+    else:
+        phase1_config = gen_config_phase1(datamode, working_dir, file_id)
+        phase1_config.to_yaml_file(
+            os.path.join(working_dir, ""ROCKET_config_phase1.yaml"")
+        )
+        phase2_config = gen_config_phase2(phase1_config)
+        phase2_config.to_yaml_file(
+            os.path.join(working_dir, ""ROCKET_config_phase2.yaml"")
+        )
+        return phase1_config, phase2_config
+
+
+def gen_config_phase1(datamode: DATAMODE, working_dir: str, file_id: str):
+    phase1_config = RocketRefinmentConfig(
+        note=""phase1_<your_note_here>"",
+        paths=PathConfig(
+            path=working_dir,
+            file_id=file_id,
+            input_pdb=os.path.join(
+                working_dir, ""ROCKET_inputs"", f""{file_id}-pred-aligned.pdb""
+            ),  # noqa: E501
+            uuid_hex=uuid.uuid4().hex[:10],
+        ),
+        execution=ExecutionConfig(
+            cuda_device=0,
+            num_of_runs=3,
+            verbose=False,
+        ),
+        algorithm=AlgorithmConfig(
+            iterations=100,
+            optimization=OptimizationParams(
+                additive_learning_rate=0.05,
+                multiplicative_learning_rate=1.0,
+                l2_weight=1e-7,
+                phase2_final_lr=1e-3,
+                smooth_stage_epochs=50,
+            ),
+        ),
+        data=DataConfig(
+            datamode=datamode,
+            min_resolution=3.0,
+        ),
+    )
+    return phase1_config
+
+
+def gen_config_phase2(phase1_config: RocketRefinmentConfig):
+    phase2_config = phase1_config.model_copy()
+    phase2_config.note = ""phase2_<your_note_here>""
+    phase2_config.data.min_resolution = None
+
+    output_directory_path = os.path.join(
+        phase2_config.path, ""ROCKET_outputs"", phase2_config.uuid_hex
+    )
+    phase1_path = os.path.join(output_directory_path, phase1_config.note)
+    input_pdb_path = os.path.join(phase1_path, ""best_model_*_*.pdb"")
+    starting_bias_path = os.path.join(phase1_path, ""best_msa_bias*.pt"")
+    starting_weights_path = os.path.join(phase1_path, ""best_feat_weights*.pt"")
+
+    phase2_config.paths.input_pdb = input_pdb_path
+    phase2_config.paths.starting_bias = starting_bias_path
+    phase2_config.paths.starting_weights = starting_weights_path
+    if phase1_config.input_msa is not None:
+        msa_feat_init_path = os.path.join(phase1_path, ""msa_feat_start.npy"")
+        phase2_config.paths.msa_feat_init_path = msa_feat_init_path
+
+    phase2_config.algorithm.iterations = 500
+    phase2_config.algorithm.optimization.smooth_stage_epochs = None
+    phase2_config.execution.num_of_runs = 1
+
+    return phase2_config
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/utils.py",".py","12823","389","import os
+from functools import partial
+
+import numpy as np
+import reciprocalspaceship as rs
+import torch
+from scipy.interpolate import RegularGridInterpolator
+from SFC_Torch import PDBParser
+from SFC_Torch.mask import reciprocal_grid
+
+
+def plddt2pseudoB_np(plddts):
+    # Use Tom Terwilliger's formula to convert plddt to Bfactor
+    deltas = 1.5 * np.exp(4 * (0.7 - 0.01 * plddts))
+    b_factors = (8 * np.pi**2 * deltas**2) / 3
+    return b_factors
+
+
+def plddt2pseudoB_pt(plddts):
+    # Use Terwilliger's formula to convert plddt to pseudoB
+    deltas = 1.5 * torch.exp(4 * (0.7 - 0.01 * plddts))
+    b_factors = (8 * torch.pi**2 * deltas**2) / 3
+
+    return b_factors
+
+
+def weighting(x, cutoff1=11.5, cutoff2=30.0):
+    """"""
+    Convert B factor to weights for L2 loss and Kabsch Alignment
+    w(B) =
+    1.0                                           B <= cutoff1
+    1.0 - 0.5*(B-cutoff1)/(cutoff2-cutoff1)       cutoff1 < B <= cutoff2
+    0.5 * exp(-sqrt(B-cutoff2))                   cutoff2 < B
+    """"""
+    a = np.where(x <= cutoff1, 1.0, 1.0 - 0.5 * (x - cutoff1) / (cutoff2 - cutoff1))
+    b = 0.5 * np.exp(-np.sqrt(np.where(x <= cutoff2, 1.0, x - cutoff2)))
+    return np.where(a >= 0.5, a, b)
+
+
+def weighting_torch(x, cutoff1=11.5, cutoff2=30.0):
+    """"""
+    pytorch implementation of the weighting function:
+    w(B) =
+    1.0                                           B <= cutoff1
+    1.0 - 0.5*(B-cutoff1)/(cutoff2-cutoff1)       cutoff1 < B <= cutoff2
+    0.5 * exp(-sqrt(B-cutoff2))                   cutoff2 < B
+    """"""
+    a = torch.where(x <= cutoff1, 1.0, 1.0 - 0.5 * (x - cutoff1) / (cutoff2 - cutoff1))
+    b = 0.5 * torch.exp(-torch.sqrt(torch.where(x <= cutoff2, 1.0, x - cutoff2)))
+    return torch.where(a >= 0.5, a, b)
+
+
+def dict_map(fn, dic, leaf_type, exclude_keys=None):
+    if exclude_keys is None:
+        exclude_keys = {""msa_feat_bias"", ""msa_feat_weights""}
+
+    new_dict = {}
+    for k, v in dic.items():
+        if k in exclude_keys:
+            new_dict[k] = v  # Keep the key-value pair as it is
+        elif isinstance(v, dict):
+            new_dict[k] = dict_map(fn, v, leaf_type, exclude_keys)
+        else:
+            new_dict[k] = tree_map(fn, v, leaf_type)
+
+    return new_dict
+
+
+def tree_map(fn, tree, leaf_type):
+    if isinstance(tree, dict):
+        return dict_map(fn, tree, leaf_type)
+    elif isinstance(tree, list):
+        return [tree_map(fn, x, leaf_type) for x in tree]
+    elif isinstance(tree, tuple):
+        return tuple([tree_map(fn, x, leaf_type) for x in tree])
+    elif isinstance(tree, leaf_type):
+        return fn(tree)
+    else:
+        print(type(tree))
+        raise ValueError(""Not supported"")
+
+
+tensor_tree_map = partial(tree_map, leaf_type=torch.Tensor)
+
+
+def try_gpu(i=0):
+    if torch.cuda.device_count() >= i + 1:
+        return torch.device(f""cuda:{i}"")
+    return torch.device(""cpu"")
+
+
+def move_tensors_to_device_inplace(processed_features, device=None):
+    """"""
+    Moves PyTorch tensors in a dictionary to the specified device in-place.
+
+    Args:
+        processed_features (dict): Dictionary containing tensors.
+        device (str): Device to move tensors to (e.g., ""cuda:0"", ""cpu"").
+    """"""
+    if device is None:
+        device = try_gpu()
+    # Iterate through the keys and values in the input dictionary
+    for key, value in processed_features.items():
+        # Check if the value is a PyTorch tensor
+        if isinstance(value, torch.Tensor):
+            # Move the tensor to the specified device in-place
+            processed_features[key] = value.to(device)
+
+
+def move_tensors_to_device(processed_features, device=None):
+    """"""
+    Moves PyTorch tensors in a dictionary to the specified device.
+
+    Args:
+        processed_features (dict): Dictionary containing tensors.
+        device (str): Device to move tensors to (e.g., ""cuda:0"", ""cpu"").
+
+    Returns:
+        dict: Dictionary with tensors moved to the specified device.
+    """"""
+    if device is None:
+        device = try_gpu()
+    processed_features_on_device = {}
+
+    for key, value in processed_features.items():
+        if isinstance(value, torch.Tensor):
+            device_value = value.clone().to(device)
+        else:
+            device_value = value
+        processed_features_on_device[key] = device_value
+
+    return processed_features_on_device
+
+
+def convert_feat_tensors_to_numpy(dictionary):
+    numpy_dict = {}
+    for key, value in dictionary.items():
+        if isinstance(value, torch.Tensor):
+            numpy_dict[key] = value.detach().cpu().numpy()
+        else:
+            numpy_dict[key] = value
+    return numpy_dict
+
+
+def is_list_or_tuple(x):
+    return isinstance(x, list | tuple)
+
+
+def assert_numpy(x, arr_type=None):
+    if isinstance(x, torch.Tensor):
+        if x.is_cuda:
+            x = x.cpu()
+        x = x.detach().numpy()
+    if is_list_or_tuple(x):
+        x = np.array(x)
+    assert isinstance(x, np.ndarray)
+    if arr_type is not None:
+        x = x.astype(arr_type)
+    return x
+
+
+def assert_tensor(x, arr_type=None, device=""cuda:0""):
+    if isinstance(x, np.ndarray):
+        x = torch.tensor(x, device=device)
+    if is_list_or_tuple(x):
+        x = np.array(x)
+        x = torch.tensor(x, device=device)
+    assert isinstance(x, torch.Tensor)
+    if arr_type is not None:
+        x = x.to(arr_type)
+    return x
+
+
+def d2q(d):
+    return 2 * np.pi / d
+
+
+def load_mtz(mtz: str) -> rs.DataSet:
+    dataset = rs.read_mtz(mtz)
+    dataset.compute_dHKL(inplace=True)
+    return dataset
+
+
+def load_pdb(pdb: str) -> PDBParser:
+    model = PDBParser(pdb)
+    return model
+
+
+def get_params_path():
+    resources_path = os.environ.get(""OPENFOLD_RESOURCES"", None)
+    if resources_path is None:
+        raise ValueError(""Please set OPENFOLD_RESOURCES environment variable"")
+    params_path = os.path.join(resources_path, ""params"")
+    return params_path
+
+
+def apply_resolution_cutoff(
+    dataset: rs.DataSet | str,
+    min_resolution: float = None,
+    max_resolution: float = None,
+):
+    """"""
+    Apply resolution cutoff to a dataset.
+
+    Args:
+        dataset (rs.DataSet | str): The dataset to filter, can be a path to an MTZ file
+            or an rs.DataSet object.
+        min_resolution (float): Minimum resolution to keep.
+        max_resolution (float): Maximum resolution to keep.
+
+    Returns:
+        rs.DataSet: Filtered dataset with applied resolution cutoff.
+    """"""
+    if isinstance(dataset, str):
+        dataset = rs.read_mtz(dataset)
+
+    dataset.compute_dHKL(inplace=True)
+    if max_resolution is None:
+        max_resolution = dataset.dHKL.max()
+    if min_resolution is None:
+        min_resolution = dataset.dHKL.min()
+    filtered_dataset = dataset[
+        (dataset.dHKL >= (min_resolution - 1e-4))
+        & (dataset.dHKL <= (max_resolution + 1e-4))
+    ].copy()
+
+    return filtered_dataset
+
+
+def g_function_np(R: float, s: np.ndarray) -> np.ndarray:
+    """"""
+    Calculates the Fourier transform of a sphere (g-function) using
+    spherical Bessel function in NumPy.
+
+    Args:
+        R (float): The radius of the sphere.
+        s (np.ndarray): An array of reciprocal space vector magnitudes (1/d).
+
+    Returns:
+        np.ndarray: The calculated g-function values.
+    """"""
+    # Ensure s is a numpy array
+    if not isinstance(s, np.ndarray):
+        s = np.array(s, dtype=np.float64)
+
+    # Create an output array initialized with the value for s=0
+    g_vals = np.ones_like(s)
+
+    # Identify non-zero s values to avoid division by zero
+    nonzero_mask = np.abs(s) > 1e-9
+
+    # Calculate the g-function only for non-zero s
+    s_nonzero = s[nonzero_mask]
+    x = 2 * np.pi * R * s_nonzero
+    g_vals_nonzero = 3 * (np.sin(x) - x * np.cos(x)) / np.power(x, 3)
+
+    # Place the calculated values into the output array
+    g_vals[nonzero_mask] = g_vals_nonzero
+
+    return g_vals
+
+
+def map2fourier(map_grid, HKL_arrays):
+    rs_grid = torch.fft.ifftn(map_grid, dim=(-3, -2, -1), norm=""forward"")
+    tuple_index = tuple(torch.tensor(HKL_arrays.T, device=rs_grid.device, dtype=int))
+    Frs = rs_grid[tuple_index]
+    return Frs
+
+
+def fourier2map(Fs, HKL_arrays, gridsize):
+    rs_grid = reciprocal_grid(HKL_arrays, Fs, gridsize)
+    map_grid = torch.real(torch.fft.fftn(rs_grid, dim=(-3, -2, -1)))
+    return map_grid
+
+
+def interpolate_grid_points(map_grid, frac_coords_batch, method=""linear""):
+    """"""
+    Interpolates values on a 3D grid at a batch of fractional coordinates.
+
+    Args:
+        map_grid (np.ndarray): A 3D NumPy array representing the data grid.
+        frac_coords_batch (np.ndarray): A 2D NumPy array of shape (N, 3),
+                                        where N is the number of points and
+                                        each row contains the [x, y, z]
+                                        fractional coordinates.
+
+    Returns:
+        np.ndarray: A 1D NumPy array of shape (N,) containing the
+                    interpolated values for each point in the batch.
+    """"""
+    # 1. Define the grid points (indices) for each dimension.
+    x = np.arange(map_grid.shape[0])
+    y = np.arange(map_grid.shape[1])
+    z = np.arange(map_grid.shape[2])
+
+    # 2. Create the interpolator object.
+    interpolator = RegularGridInterpolator(
+        (x, y, z), map_grid, method=method, bounds_error=False, fill_value=None
+    )
+
+    # 3. Convert the batch of fractional coordinates to grid coordinates.
+    grid_shape = np.array(map_grid.shape)
+    frac_coords_batch = frac_coords_batch % 1.0
+    point_coords_batch = frac_coords_batch * (grid_shape - 1)
+
+    # 4. Get the interpolated values for the entire batch of points.
+    interpolated_values = interpolator(point_coords_batch)
+
+    return interpolated_values
+
+
+def get_rscc_from_Fmap(
+    Fcalc: torch.Tensor,
+    Fmap: torch.Tensor,
+    HKL_arrays: np.ndarray,
+    gridsize: list[int],
+    Rg: torch.Tensor,
+    unitcell_volume: float,
+) -> float:
+    assert len(Fcalc) == len(HKL_arrays)
+    assert len(Fmap) == len(HKL_arrays)
+    assert len(Rg) == len(HKL_arrays)
+
+    map1 = fourier2map(Fcalc, HKL_arrays, gridsize)
+    map1_normed = (map1 - map1.mean()) / map1.std()
+
+    map2 = fourier2map(Fmap, HKL_arrays, gridsize)
+    map2_normed = (map2 - map2.mean()) / map2.std()
+
+    productmap = map1_normed * map2_normed
+    Fproductmap = map2fourier(productmap, HKL_arrays)
+    Fproductmap_smooth = Fproductmap * Rg
+
+    productmap_smooth = fourier2map(Fproductmap_smooth, HKL_arrays, gridsize)
+    productmap_smooth_norm = 2.0 * productmap_smooth / unitcell_volume
+
+    variance1_map = map1_normed * map1_normed
+    Fvmap1 = map2fourier(variance1_map, HKL_arrays)
+    Fvmap1_smoothed = Fvmap1 * Rg
+    vmap1_smoothed = fourier2map(Fvmap1_smoothed, HKL_arrays, gridsize)
+    vmap1_smoothed_normed = 2.0 * vmap1_smoothed / unitcell_volume
+    vmap1_smoothed_normed_offset = (
+        vmap1_smoothed_normed - vmap1_smoothed_normed.min() + 1e-3
+    )
+
+    variance2_map = map2_normed * map2_normed
+    Fvmap2 = map2fourier(variance2_map, HKL_arrays)
+    Fvmap2_smoothed = Fvmap2 * Rg
+    vmap2_smoothed = fourier2map(Fvmap2_smoothed, HKL_arrays, gridsize)
+    vmap2_smoothed_normed = 2.0 * vmap2_smoothed / unitcell_volume
+    vmap2_smoothed_normed_offset = (
+        vmap2_smoothed_normed - vmap2_smoothed_normed.min() + 1e-3
+    )
+
+    ccmap = (productmap_smooth_norm - productmap_smooth_norm.mean()) / torch.sqrt(
+        vmap1_smoothed_normed_offset * vmap2_smoothed_normed_offset
+    )
+    return ccmap.cpu().numpy()
+
+
+def get_b_from_CC(CC_values, d_min):
+    # Truncate very small or negative CC values
+    CC_trunc = (CC_values + 0.001 + np.abs(CC_values - 0.001)) / 2
+
+    # Flex arrays can't be used as exponents, so work around this with logs
+    # TODO: verify the constants here
+    # Randy's note: In case you’re wondering, the magic numbers and the magic formula
+    # come from some things I did in Mathematica.
+    # I worked out a formula that converts RMSD to an expected CC.
+    u1 = np.exp(np.log(0.188779) * CC_trunc)
+    u2 = np.exp(2.21742 * CC_trunc * np.log(CC_trunc))
+    u3 = np.exp(0.777046 * np.tan(CC_trunc) * np.log(CC_trunc) * CC_trunc)
+    b_values_from_CC = (
+        np.power(d_min, 2) * 134.024 * np.power(0.213624 - u1 * u2 - 0.359452 * u3, 2)
+    )
+    # Previous Approach, now we dropped
+    # Truncate B-values at a maximum of 350 above minimum
+    # 350 was chosen semi-arbitrarily as a point at which the sigmaA curve drops
+    # below 0.1 at 6A, so that data beyond 6A will have little influence
+    # bmax = np.min(b_values_from_CC) + 350.0
+    # b_values_from_CC = (b_values_from_CC + bmax - np.abs(b_values_from_CC - bmax)) / 2
+
+    # Do normal truncation instead, as Randy Suggested
+    bmin = np.min(b_values_from_CC)
+    b_values_from_CC = b_values_from_CC - bmin
+    bmax = 999.0
+    b_values_from_CC = np.clip(b_values_from_CC, 0.0, bmax)
+    return b_values_from_CC
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/base.py",".py","5091","161","""""""
+Include modified subclasses of AlphaFold
+""""""
+
+import os
+import re
+
+import torch
+from openfold.model.model import AlphaFold
+from openfold.utils.import_weights import import_jax_weights_
+from openfold.utils.script_utils import get_model_basename
+
+# from openfold.utils.tensor_utils import tensor_tree_map
+from rocket.utils import get_params_path, tensor_tree_map
+
+
+class MSABiasAFv1(AlphaFold):
+    """"""
+    AlphaFold with trainable bias in MSA space
+    """"""
+
+    def __init__(
+        self,
+        config,
+        preset,
+        params_root=None,
+        use_deepspeed_evo_attention=True,
+    ):
+        super().__init__(config)
+
+        if params_root is None:
+            params_root = get_params_path()
+
+        # AlphaFold params
+        params_path = os.path.join(params_root, f""params_{preset}.npz"")
+        model_basename = get_model_basename(params_path)
+        model_version = ""_"".join(model_basename.split(""_"")[1:])
+        import_jax_weights_(self, params_path, version=model_version)
+        config.globals.use_deepspeed_evo_attention = use_deepspeed_evo_attention
+        # print(""DEEPSPEED IS "", config.globals.use_deepspeed_evo_attention)
+        self.eval()  # without this, dropout enabled
+
+        # self.train()
+        # for m in self.modules():
+        #    if m.__class__.__name__.startswith(""Dropout""):
+        #        m.eval()
+
+    def freeze(self, skip_str=None):
+        """"""
+        freeze AF2 parameters, skip those parameters with str match
+        """"""
+        if skip_str is None:
+            for params in self.parameters():
+                params.requires_grad_(False)
+        else:
+            for name, params in self.named_parameters():
+                if re.match(skip_str, name) is None:
+                    params.requires_grad_(False)
+
+    def unfreeze(self, skip_str=None):
+        """"""
+        unfreeze AF2 parameters, skip those parameters with str match
+        """"""
+        if skip_str is None:
+            for params in self.parameters():
+                params.requires_grad_(True)
+        else:
+            for name, params in self.named_parameters():
+                if re.match(skip_str, name) is None:
+                    params.requires_grad_(True)
+
+    def _bias(self, feats):
+        feats[""msa_feat""][:, :, 25:48] = (
+            feats[""msa_feat""][:, :, 25:48] + feats[""msa_feat_bias""]
+        )
+        return feats
+
+    def iteration(self, feats, prevs, _recycle=True, bias=True):
+        if bias:
+            feats = self._bias(feats)
+        return super().iteration(feats, prevs, _recycle)
+
+    def forward(self, batch, prevs=None, num_iters=1, bias=True):
+        if prevs is None:
+            prevs = [None, None, None]
+        is_grad_enabled = torch.is_grad_enabled()
+
+        # Main recycling loop
+        for cycle_no in range(num_iters):
+            # Select the features for the current recycling cycle
+            fetch_cur_batch = lambda t: t[..., cycle_no]  # noqa: E731, B023
+            feats = tensor_tree_map(fetch_cur_batch, batch)
+
+            is_final_iter = cycle_no == (num_iters - 1)
+
+            with torch.set_grad_enabled(is_grad_enabled and is_final_iter):
+                if is_final_iter and torch.is_autocast_enabled():
+                    # Sidestep AMP bug (PyTorch issue #65766)
+                    torch.clear_autocast_cache()
+
+                # Run the next iteration of the model
+                outputs, m_1_prev, z_prev, x_prev, _ = self.iteration(
+                    feats, prevs, _recycle=(num_iters > 1), bias=bias
+                )
+
+                if not is_final_iter:
+                    del outputs
+                    prevs = [m_1_prev, z_prev, x_prev]
+                    del m_1_prev, z_prev, x_prev
+
+        # Run auxiliary heads
+        outputs.update(self.aux_heads(outputs))
+
+        return outputs, [m_1_prev, z_prev, x_prev]
+
+
+class MSABiasAFv2(MSABiasAFv1):
+    """"""
+    AlphaFold with trainable bias + trainable linear combination in MSA space
+    """"""
+
+    def _bias(self, feats):
+        feats[""msa_feat""][:, :, 25:48] = (
+            torch.einsum(
+                ""ijk,in->njk"",
+                feats[""msa_feat""][:, :, 25:48],
+                feats[""msa_feat_weights""],
+            )
+            + feats[""msa_feat_bias""]
+        )
+        return feats
+
+
+class MSABiasAFv3(MSABiasAFv1):
+    """"""
+    AlphaFold with trainable bias + trainable linear combination in MSA space
+    """"""
+
+    def _bias(self, feats):
+        feats[""msa_feat""][:, :, 25:48] = (
+            feats[""msa_feat""][:, :, 25:48].clone() * feats[""msa_feat_weights""]
+            + feats[""msa_feat_bias""]
+        )
+        return feats
+
+
+class TemplateBiasAF(MSABiasAFv1):
+    """"""
+    AlphaFold with trainable bias in template representation
+    """"""
+
+    def _bias(self, feats):
+        # TODO: make sure the following operations are valid,
+        # Values in feature have to be mapped into -1.0 - 1.0
+
+        feats[""template_torsion_angles_sin_cos""] = (
+            feats[""template_torsion_angles_sin_cos""].clone()
+            + feats[""template_torsion_angles_sin_cos_bias""]
+        )
+        return feats
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/helper.py",".py","6109","178","import numpy as np
+from openfold import config
+from openfold.data import data_pipeline, feature_pipeline
+from openfold.np import protein, residue_constants
+
+from rocket import utils as rk_utils
+
+
+def make_decoy_seq(target_seq, template_resid, decoy_seq_ori):
+    decoy_seq = """"
+    j = 0
+    for i in range(len(target_seq)):
+        if i in template_resid:
+            decoy_seq += decoy_seq_ori[j]
+            j += 1
+        else:
+            decoy_seq += ""-""
+    return decoy_seq
+
+
+def check_sequence(decoy_seqence, target_sequence):
+    assert len(decoy_seqence) == len(target_sequence)
+    for m, n in zip(decoy_seqence, target_sequence, strict=False):
+        if m == n or m == ""-"":
+            pass
+        else:
+            print(m, n, ""do not match!"", flush=True)
+            return False
+    return True
+
+
+def make_processed_dict_from_template(
+    template_pdb,
+    target_seq=None,
+    config_preset=""model_1"",
+    msa_dict=None,
+    device=""cpu"",
+    seq_replacement=""-"",  # gap string
+    mask_sidechains_add_cb=True,
+    mask_sidechains=True,
+    deterministic=True,
+    max_recycling_iters=0,  # no recycling
+):
+    """"""
+    template_pdb           :  path to pdb file used as template
+    config_dict            :  the name of the model to get the parameters from.
+                              Options: model_[1-5]
+    msa_dict               :  dictionary containing precomputed msa properties in numpy
+    device                 :  ""cpu"" or ""cuda:i""
+    mask_sidechains_add_cb :  mask out sidechain atoms except for C-Beta, add gly C-Beta
+    mask_sidechains        :  mask out sidechain atoms except for C-Beta
+    deterministic          :  make all data processing deterministic (no masking, etc.)
+    """"""
+    decoy_prot = protein.from_pdb_string(pdb_to_string(template_pdb))
+    decoy_seq_ori = """".join([residue_constants.restypes[x] for x in decoy_prot.aatype])
+    if target_seq is None:
+        target_seq = decoy_seq_ori
+        template_idxs = np.arange(len(decoy_prot.residue_index))
+        decoy_seq = (
+            seq_replacement * len(target_seq)
+            if len(seq_replacement) == 1
+            else target_seq
+        )
+    else:
+        template_idxs = decoy_prot.residue_index - 1
+        decoy_seq = make_decoy_seq(target_seq, template_idxs, decoy_seq_ori)
+        assert check_sequence(decoy_seq, target_seq)
+    template_idx_set = set(template_idxs)
+
+    pos = np.zeros([1, len(target_seq), 37, 3])
+    atom_mask = np.zeros([1, len(target_seq), 37])
+    if mask_sidechains_add_cb:
+        pos[0, template_idxs, :5] = decoy_prot.atom_positions[:, :5]
+        backbone_modelled = np.asarray(
+            np.all(decoy_prot.atom_mask[:, [0, 1, 2]] == 1, axis=1)
+        )
+        backbone_idx_set = set(template_idxs[backbone_modelled])
+        projected_cb = [
+            i
+            for i, b, m in zip(
+                template_idxs, backbone_modelled, decoy_prot.atom_mask, strict=False
+            )
+            if m[3] == 0 and b
+        ]
+        projected_cb_set = set(projected_cb)
+        gly_idx = [i for i, a in enumerate(target_seq) if a == ""G""]
+        assert all(
+            k in projected_cb_set
+            for k in gly_idx
+            if k in template_idx_set and k in backbone_idx_set
+        )
+        cbs = np.array([
+            extend(c, n, ca, 1.522, 1.927, -2.143)
+            for c, n, ca in zip(pos[0, :, 2], pos[0, :, 0], pos[0, :, 1], strict=False)
+        ])
+        pos[0, projected_cb, 3] = cbs[projected_cb]
+        atom_mask[0, template_idxs, :5] = decoy_prot.atom_mask[:, :5]
+        atom_mask[0, projected_cb, 3] = 1
+    elif mask_sidechains:
+        pos[0, template_idxs, :5] = decoy_prot.atom_positions[:, :5]
+        atom_mask[0, template_idxs, :5] = decoy_prot.atom_mask[:, :5]
+    else:
+        pos[0, template_idxs] = decoy_prot.atom_positions
+        atom_mask[0, template_idxs] = decoy_prot.atom_mask
+    template = {
+        ""template_aatype"": residue_constants.sequence_to_onehot(
+            decoy_seq, residue_constants.HHBLITS_AA_TO_ID
+        )[None],
+        ""template_all_atom_mask"": atom_mask.astype(np.float32),
+        ""template_all_atom_positions"": pos.astype(np.float32),
+        ""template_domain_names"": np.asarray([""None""]),
+    }
+
+    # Make feature_dict
+    feature_dict = {}
+    feature_dict.update(
+        data_pipeline.make_sequence_features(target_seq, ""test"", len(target_seq))
+    )
+    feature_dict.update(template)
+    if msa_dict is None:
+        # Make dummy msa features
+        msa = [data_pipeline.make_dummy_msa_obj(target_seq)]
+        msa_dict = data_pipeline.make_msa_features(msa)
+
+    feature_dict.update(msa_dict)
+
+    # create a config
+    cfg = config.model_config(config_preset)
+    cfg.data.common.max_recycling_iters = max_recycling_iters  # no
+    if deterministic:
+        cfg.data.eval.masked_msa_replace_fraction = 0.0
+        cfg.data.predict.masked_msa_replace_fraction = 0.0
+
+    # process_dict
+    feature_processor = feature_pipeline.FeaturePipeline(cfg.data)
+    processed_feature_dict = feature_processor.process_features(
+        feature_dict, mode=""predict""
+    )
+    if device != ""cpu"":
+        processed_feature_dict = rk_utils.move_tensors_to_device(
+            processed_feature_dict, device=device
+        )
+
+    return processed_feature_dict
+
+
+""""""
+Read in a PDB file from a path
+""""""
+
+
+def pdb_to_string(pdb_file):
+    lines = []
+    for line in open(pdb_file):  # noqa: SIM115
+        if line[:6] == ""HETATM"" and line[17:20] == ""MSE"":
+            line = ""ATOM  "" + line[6:17] + ""MET"" + line[20:]
+        if line[:4] == ""ATOM"":
+            lines.append(line)
+    return """".join(lines)
+
+
+""""""
+Function used to add C-Beta to glycine resides
+input:  3 coords (a,b,c), (L)ength, (A)ngle, and (D)ihedral
+output: 4th coord
+""""""
+
+
+def extend(a, b, c, L, A, D):
+    def N(x):
+        return x / np.sqrt(np.square(x).sum(-1, keepdims=True) + 1e-08)
+
+    bc = N(b - c)
+    n = N(np.cross(b - a, bc))
+    m = [bc, np.cross(n, bc), n]
+    d = [L * np.cos(A), L * np.sin(A) * np.cos(D), -L * np.sin(A) * np.sin(D)]
+    return c + sum([m * d for m, d in zip(m, d, strict=False)])
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/refinement_xray.py",".py","31407","813","import glob
+import os
+import shutil
+import time
+import uuid
+import warnings
+
+import numpy as np
+import torch
+from loguru import logger
+from openfold.config import model_config
+from openfold.data import data_pipeline, feature_pipeline
+from SFC_Torch import SFcalculator
+from tqdm import tqdm
+
+import rocket
+from rocket import coordinates as rk_coordinates
+from rocket import refinement_utils as rkrf_utils
+from rocket import utils as rk_utils
+from rocket.refinement_config import RocketRefinmentConfig
+from rocket.xtal import structurefactors as llg_sf
+
+PRESET = ""model_1_ptm""
+EXCLUDING_RES = None
+
+
+def run_xray_refinement(config: RocketRefinmentConfig | str) -> RocketRefinmentConfig:
+    if isinstance(config, str):
+        config = RocketRefinmentConfig.from_yaml_file(config)
+    assert config.datamode == ""xray"", ""Make sure to set datamode to 'xray'!""
+
+    ############ 1. Global settings ############
+    # Device
+    device = f""cuda:{config.cuda_device}""
+
+    # Using LBFGS or Adam in RBR
+    if config.rbr_opt_algorithm == ""lbfgs"":
+        RBR_LBFGS = True
+    elif config.rbr_opt_algorithm == ""adam"":
+        RBR_LBFGS = False
+    else:
+        raise ValueError(""rbr_opt only supports lbfgs or adam"")
+
+    # Configure input paths
+    tng_file = f""{config.path}/ROCKET_inputs/{config.file_id}-Edata.mtz""
+    try:
+        input_pdb = glob.glob(config.input_pdb)[0]
+    except Exception as err:
+        raise ValueError(""input_pdb path is not valid!"") from err
+
+    # Configure output path
+    # Generate uuid for this run
+    if config.uuid_hex:
+        refinement_run_uuid = config.uuid_hex
+    else:
+        config.paths.uuid_hex = uuid.uuid4().hex[:10]
+        refinement_run_uuid = config.uuid_hex
+    output_directory_path = (
+        f""{config.path}/ROCKET_outputs/{refinement_run_uuid}/{config.note}""
+    )
+    try:
+        os.makedirs(output_directory_path, exist_ok=True)
+    except FileExistsError:
+        logger.info(
+            f""Warning: Directory '{output_directory_path}' already exists. Overwriting.""
+        )
+    logger.info(
+        f""System: {config.file_id}, run ID: {refinement_run_uuid!s}, Note: {config.note}"",  # noqa: E501
+        flush=True,
+    )
+    if not config.verbose:
+        warnings.filterwarnings(""ignore"")
+
+    ############ 2. Initializations ############
+
+    # Apply resolution cutoff to the reflection file
+    if config.min_resolution is not None or config.max_resolution is not None:
+        tng_file = rk_utils.apply_resolution_cutoff(
+            tng_file,
+            min_resolution=config.min_resolution,
+            max_resolution=config.max_resolution,
+        )
+
+    # If there are additional chain in the system
+    if config.additional_chain:
+        added_chain_pdb = (
+            f""{config.path}/ROCKET_inputs/{config.file_id}_added_chain.pdb""
+        )
+        if not os.path.exists(added_chain_pdb):
+            raise FileNotFoundError(
+                f""Additional chain PDB file '{added_chain_pdb}' does not exist!""
+            )
+        # calculate the structure factors for the additional chain
+        sfc_added_chain = SFcalculator(
+            added_chain_pdb,
+            tng_file,
+            expcolumns=[""FEFF"", ""DOBS""],
+            freeflag=config.free_flag,
+            set_experiment=True,
+            testset_value=config.testset_value,
+            device=device,
+        )
+        sfc_added_chain.calc_fprotein()
+        constant_fp_added_HKL = sfc_added_chain.Fprotein_HKL.clone().detach()
+        constant_fp_added_asu = sfc_added_chain.Fprotein_asu.clone().detach()
+        del sfc_added_chain
+
+        phitrue_path = f""{config.path}/ROCKET_inputs/{config.file_id}_allchains-phitrue-solvent{config.solvent}.npy""  # noqa: E501
+        Etrue_path = f""{config.path}/ROCKET_inputs/{config.file_id}_allchains-Etrue-solvent{config.solvent}.npy""  # noqa: E501
+
+        if os.path.exists(phitrue_path) and os.path.exists(Etrue_path):
+            SIGMA_TRUE = True
+            phitrue = np.load(phitrue_path)
+            Etrue = np.load(Etrue_path)
+        else:
+            SIGMA_TRUE = False
+    else:
+        constant_fp_added_HKL = None
+        constant_fp_added_asu = None
+
+        phitrue_path = f""{config.path}/ROCKET_inputs/{config.file_id}-phitrue-solvent{config.solvent}.npy""  # noqa: E501
+        Etrue_path = f""{config.path}/ROCKET_inputs/{config.file_id}-Etrue-solvent{config.solvent}.npy""  # noqa: E501
+
+        if os.path.exists(phitrue_path) and os.path.exists(Etrue_path):
+            SIGMA_TRUE = True
+            phitrue = np.load(phitrue_path)
+            Etrue = np.load(Etrue_path)
+        else:
+            SIGMA_TRUE = False
+
+    # Initialize SFC
+    sfc = llg_sf.initial_SFC(
+        input_pdb,
+        tng_file,
+        ""FEFF"",
+        ""DOBS"",
+        Freelabel=config.free_flag,
+        device=device,
+        testset_value=config.testset_value,
+        added_chain_HKL=constant_fp_added_HKL,
+        added_chain_asu=constant_fp_added_asu,
+        total_chain_copy=config.total_chain_copy,
+        spacing=config.voxel_spacing,
+    )
+    reference_pos = sfc.atom_pos_orth.clone()
+    target_seq = sfc._pdb.sequence
+
+    # Use initial pos B factor instead of best pos B factor for weighted L2
+    init_pos_bfactor = sfc.atom_b_iso.clone()
+    bfactor_weights = rk_utils.weighting_torch(init_pos_bfactor, cutoff2=20.0)
+
+    sfc_rbr = llg_sf.initial_SFC(
+        input_pdb,
+        tng_file,
+        ""FEFF"",
+        ""DOBS"",
+        Freelabel=config.free_flag,
+        device=device,
+        solvent=False,
+        testset_value=config.testset_value,
+        added_chain_HKL=constant_fp_added_HKL,
+        added_chain_asu=constant_fp_added_asu,
+        total_chain_copy=config.total_chain_copy,
+        spacing=config.voxel_spacing,
+    )
+
+    # LLG initialization with resol cut
+    llgloss = rkrf_utils.init_llgloss(
+        sfc, tng_file, config.min_resolution, config.max_resolution
+    )
+    llgloss_rbr = rkrf_utils.init_llgloss(
+        sfc_rbr, tng_file, config.min_resolution, config.max_resolution
+    )
+
+    # Model initialization
+    version_to_class = {
+        1: rocket.MSABiasAFv1,
+        2: rocket.MSABiasAFv2,
+        3: rocket.MSABiasAFv3,
+        4: rocket.TemplateBiasAF,
+    }
+    af_bias = version_to_class[config.bias_version](
+        model_config(PRESET, train=True), PRESET
+    ).to(device)
+    af_bias.freeze()  # Free all AF2 parameters to save time
+
+    # Optimizer settings and initialization
+    # Run smooth stage in phase 1 instead
+    if ""phase1"" in config.note:
+        lr_a = config.additive_learning_rate
+        lr_m = config.multiplicative_learning_rate
+    elif ""phase2"" in config.note:
+        lr_a = config.phase2_final_lr
+        lr_m = config.phase2_final_lr
+
+    # Initialize best Rfree weights and bias for Phase 1
+    best_llg = float(""inf"")
+    best_msa_bias = None
+    best_feat_weights = None
+    best_run = None
+    best_iter = None
+
+    # MH edit @ Nov 8th, 2024: Support to use msa as input
+    if config.msa_subratio is not None and config.input_msa is None:
+        config.input_msa = ""alignments""  # default dir for alignment
+
+    recombination_bias = None
+    if config.input_msa is not None:
+        fasta_path = [
+            f
+            for ext in (""*.fa"", ""*.fasta"")
+            for f in glob.glob(os.path.join(config.path, ext))
+        ][0]
+        a3m_path = os.path.join(config.path, config.input_msa)
+        if os.path.isfile(a3m_path):
+            msa_name, ext = os.path.splitext(os.path.basename(a3m_path))
+            alignment_dir = os.path.join(os.path.dirname(a3m_path), ""tmp_align"")
+            os.makedirs(alignment_dir, exist_ok=True)
+            shutil.copy(a3m_path, os.path.join(alignment_dir, msa_name + "".a3m""))
+            tmp_align = True
+        elif os.path.isdir(a3m_path):
+            alignment_dir = a3m_path
+            tmp_align = False
+        data_processor = data_pipeline.DataPipeline(template_featurizer=None)
+        feature_dict = rkrf_utils.generate_feature_dict(
+            fasta_path,
+            alignment_dir,
+            data_processor,
+        )
+        # prepare featuerizer
+        afconfig = model_config(PRESET)
+        afconfig.data.common.max_recycling_iters = config.init_recycling
+        del afconfig.data.common.masked_msa
+        afconfig.data.common.resample_msa_in_recycling = False
+        feature_processor = feature_pipeline.FeaturePipeline(afconfig.data)
+        if tmp_align:
+            shutil.rmtree(alignment_dir)
+
+        # MH edits @ Oct 19, 2024, support MSA subsampling at the beginning
+        if config.msa_subratio is not None:
+            assert config.msa_subratio > 0.0 and config.msa_subratio <= 1.0, (
+                ""msa_subratio should be None or between 0.0 and 1.0!""
+            )
+            # Do subsampling of msa, keep the first sequence
+            if config.sub_msa_path is None:
+                idx = np.arange(feature_dict[""msa""].shape[0] - 1) + 1
+                sub_idx = np.concatenate((
+                    np.array([0]),
+                    np.random.choice(
+                        idx, size=int(config.msa_subratio * len(idx)), replace=False
+                    ),
+                ))
+                feature_dict[""msa""] = feature_dict[""msa""][sub_idx]
+                feature_dict[""deletion_matrix_int""] = feature_dict[
+                    ""deletion_matrix_int""
+                ][sub_idx]
+                # Save out the subsampled msa
+                np.save(
+                    f""{output_directory_path!s}/sub_msa.npy"",
+                    feature_dict[""msa""],
+                )
+                np.save(
+                    f""{output_directory_path!s}/sub_delmat.npy"",
+                    feature_dict[""deletion_matrix_int""],
+                )
+            else:
+                feature_dict[""msa""] = np.load(config.sub_msa_path, allow_pickle=True)
+                feature_dict[""deletion_matrix_int""] = np.load(
+                    config.sub_delmat_path, allow_pickle=True
+                )
+        processed_feature_dict = feature_processor.process_features(
+            feature_dict, mode=""predict""
+        )
+
+        # Edit by MH @ Nov 18, 2024, use bias of fullmsa to realize the cluster msa
+        if config.bias_from_fullmsa:
+            fullmsa_dir = os.path.join(config.path, ""alignments"")
+            fullmsa_feature_dict = rkrf_utils.generate_feature_dict(
+                fasta_path,
+                fullmsa_dir,
+                data_processor,
+            )
+            fullmsa_processed_feature_dict = feature_processor.process_features(
+                fullmsa_feature_dict, mode=""predict""
+            )
+            fullmsa_profile = fullmsa_processed_feature_dict[""msa_feat""][
+                :, :, 25:48
+            ].clone()
+            submsa_profile = processed_feature_dict[""msa_feat""][:, :, 25:48].clone()
+            processed_feature_dict[""msa_feat""][:, :, 25:48] = (
+                fullmsa_profile.clone()
+            )  # Use full msa's profile as basis for linear space -- higher rank (?)
+            recombination_bias = (
+                submsa_profile[..., 0] - fullmsa_profile[..., 0]
+            )  # Use the difference as the initial bias, to start from a desired profile
+        elif config.chimera_profile:
+            fullmsa_dir = os.path.join(config.path, ""alignments"")
+            fullmsa_feature_dict = rkrf_utils.generate_feature_dict(
+                fasta_path,
+                fullmsa_dir,
+                data_processor,
+            )
+            fullmsa_processed_feature_dict = feature_processor.process_features(
+                fullmsa_feature_dict, mode=""predict""
+            )
+            full_profile = fullmsa_processed_feature_dict[""msa_feat""][
+                :, :, 25:48
+            ].clone()
+            sub_profile = processed_feature_dict[""msa_feat""][:, :, 25:48].clone()
+            processed_feature_dict[""msa_feat""][:, :, 25:48] = torch.where(
+                sub_profile == 0.0, full_profile.clone(), sub_profile.clone()
+            )
+
+        device_processed_features = rk_utils.move_tensors_to_device(
+            processed_feature_dict, device=device
+        )
+        feature_key = ""msa_feat""
+
+        if config.msa_feat_init_path is None:
+            features_at_it_start = (
+                device_processed_features[feature_key].detach().clone()
+            )
+            np.save(
+                f""{output_directory_path!s}/msa_feat_start.npy"",
+                rk_utils.assert_numpy(features_at_it_start[..., 0]),
+            )
+        else:
+            msa_feat_init_np = np.load(
+                glob.glob(config.msa_feat_init_path)[0], allow_pickle=True
+            )
+            features_at_it_start_np = np.repeat(
+                np.expand_dims(msa_feat_init_np, -1), config.init_recycling + 1, -1
+            )
+            features_at_it_start = torch.tensor(features_at_it_start_np).to(
+                device_processed_features[feature_key]
+            )
+            device_processed_features[feature_key] = (
+                features_at_it_start.detach().clone()
+            )
+
+    else:
+        # Initialize the processed dict space
+        device_processed_features, feature_key, features_at_it_start = (
+            rkrf_utils.init_processed_dict(
+                bias_version=config.bias_version,
+                path=config.path,
+                device=device,
+                template_pdb=config.template_pdb,
+                target_seq=target_seq,
+                PRESET=PRESET,
+            )
+        )
+
+    # MH edit @ Oct 2nd, 2024: Support optional template input
+    if config.template_pdb is not None:
+        device_processed_features_template = rocket.make_processed_dict_from_template(
+            config.template_pdb,
+            target_seq,
+            device=device,
+            mask_sidechains_add_cb=True,
+            mask_sidechains=True,
+            max_recycling_iters=config.init_recycling,
+        )
+        for key in device_processed_features_template:
+            if key.startswith(""template_""):
+                device_processed_features[key] = device_processed_features_template[key]
+
+    # Write out config used, start the journey
+    config.to_yaml_file(f""{output_directory_path!s}/config.yaml"")
+    for n in range(config.num_of_runs):
+        run_id = rkrf_utils.number_to_letter(n)
+        best_pos = reference_pos
+
+        # Initialize bias
+        device_processed_features, optimizer, bias_names = rkrf_utils.init_bias(
+            device_processed_features=device_processed_features,
+            bias_version=config.bias_version,
+            device=device,
+            lr_a=lr_a,
+            lr_m=lr_m,
+            weight_decay=config.weight_decay,
+            starting_bias=config.starting_bias,
+            starting_weights=config.starting_weights,
+            recombination_bias=recombination_bias,
+        )
+
+        # List initialization for saving values
+        rbr_loss_by_epoch = []
+        llg_losses = []
+        rfree_by_epoch = []
+        rwork_by_epoch = []
+        time_by_epoch = []
+        memory_by_epoch = []
+        all_pldtts = []
+        mean_it_plddts = []
+        absolute_feats_changes = []
+
+        progress_bar = tqdm(
+            range(config.iterations),
+            desc=f""{config.file_id}, uuid: {refinement_run_uuid[:4]}, run: {run_id}"",
+        )
+
+        # Prepare an MDTraj trajectory writer so we can append frames
+        # to a single trajectory file instead of writing one PDB per iteration.
+        # Prefer HDF5 (smaller, single-file) and fall back to a multi-model
+        # PDB if HDF5 support isn't available. Import mdtraj lazily so the
+        # rest of the code still runs if mdtraj isn't installed.
+        traj_writer = None
+        md = None
+        mdtraj_template = None
+        try:
+            import mdtraj as md  # type: ignore
+
+            try:
+                from mdtraj.formats import PDBTrajectoryFile  # type: ignore
+            except Exception:
+                PDBTrajectoryFile = None  # type: ignore
+            traj_path_pdb = (
+                f""{output_directory_path!s}/{run_id}_refinement_trajectory.pdb""
+            )
+            mdtraj_template = md.load_pdb(input_pdb)
+            if PDBTrajectoryFile is not None:
+                traj_writer = PDBTrajectoryFile(traj_path_pdb, mode=""w"")
+            else:
+                traj_writer = None
+        except Exception as e:  # pragma: no cover - optional dependency
+            logger.warning(
+                f""mdtraj not available or failed to initialize writer ({e}); ""
+                ""falling back to per-iteration PDB saves.""
+            )
+
+        # Run smooth stage in phase 1
+        if ""phase1"" in config.note:
+            w_L2 = config.l2_weight
+        elif ""phase2"" in config.note:
+            w_L2 = 0.0
+
+        ######
+        early_stopper = rkrf_utils.EarlyStopper(patience=200, min_delta=10.0)
+
+        #### Phase 1 smooth scheduling ######
+        if config.smooth_stage_epochs is not None:
+            lr_a_initial = lr_a
+            lr_m_initial = lr_m
+            w_L2_initial = w_L2
+            lr_stage1_final = config.phase2_final_lr
+            smooth_stage_epochs = config.smooth_stage_epochs
+
+            # Decay rates for each stage
+            decay_rate_stage1_add = (lr_stage1_final / lr_a) ** (
+                1 / smooth_stage_epochs
+            )
+            decay_rate_stage1_mul = (lr_stage1_final / lr_m) ** (
+                1 / smooth_stage_epochs
+            )
+
+        ############ 3. Run Refinement ############
+        for iteration in progress_bar:
+            start_time = time.time()
+            optimizer.zero_grad()
+
+            # Avoid passing through graph a second time
+            device_processed_features[feature_key] = (
+                features_at_it_start.detach().clone()
+            )
+
+            # AF pass
+            if iteration == 0:
+                af2_output, prevs = af_bias(
+                    device_processed_features,
+                    [None, None, None],
+                    num_iters=config.init_recycling,
+                    bias=False,
+                )
+                prevs = [tensor.detach() for tensor in prevs]
+
+                # # MH @ June 19: Fix the iteration 0 for phase 2 running
+                # print(""config.starting_bias"", config.starting_bias)
+                # if (config.starting_bias is not None) or (
+                #     config.starting_weights is not None
+                # ):
+                #     deep_copied_prevs = [tensor.clone().detach() for tensor in prevs]
+                #     af2_output, __ = af_bias(
+                #         device_processed_features,
+                #         deep_copied_prevs,
+                #         num_iters=1,
+                #         bias=True,
+                #     )
+            deep_copied_prevs = [tensor.clone().detach() for tensor in prevs]
+            af2_output, __ = af_bias(
+                device_processed_features, deep_copied_prevs, num_iters=1, bias=True
+            )
+
+            # pLDDT loss
+            L_plddt = -torch.mean(af2_output[""plddt""])
+
+            # Position Kabsch Alignment
+            aligned_xyz, plddts_res, pseudo_Bs = rkrf_utils.position_alignment(
+                af2_output=af2_output,
+                device_processed_features=device_processed_features,
+                cra_name=sfc.cra_name,
+                best_pos=best_pos,
+                exclude_res=EXCLUDING_RES,
+                domain_segs=config.domain_segs,
+                reference_bfactor=init_pos_bfactor,
+            )
+            llgloss.sfc.atom_b_iso = pseudo_Bs.detach().clone()
+            llgloss_rbr.sfc.atom_b_iso = pseudo_Bs.detach().clone()
+            all_pldtts.append(plddts_res)
+            mean_it_plddts.append(np.mean(plddts_res))
+
+            ##############################################
+
+            # Calculate (or refine) sigmaA
+            if config.refine_sigmaA is True:
+                llgloss, llgloss_rbr, Ecalc, Fc = rkrf_utils.update_sigmaA(
+                    llgloss=llgloss,
+                    llgloss_rbr=llgloss_rbr,
+                    aligned_xyz=aligned_xyz,
+                    constant_fp_added_HKL=constant_fp_added_HKL,
+                    constant_fp_added_asu=constant_fp_added_asu,
+                )
+            else:
+                if SIGMA_TRUE:
+                    llgloss, llgloss_rbr = rkrf_utils.sigmaA_from_true(
+                        llgloss=llgloss,
+                        llgloss_rbr=llgloss_rbr,
+                        aligned_xyz=aligned_xyz,
+                        Etrue=Etrue,
+                        phitrue=phitrue,
+                        constant_fp_added_HKL=constant_fp_added_HKL,
+                        constant_fp_added_asu=constant_fp_added_asu,
+                    )
+                else:
+                    raise ValueError(
+                        ""No Etrue or phitrue provided! Can't get the true sigmaA!""
+                    )
+
+            # For record
+            # if SIGMA_TRUE:
+            #     true_sigmas = llg_utils.sigmaA_from_model(
+            #         Etrue,
+            #         phitrue,
+            #         Ecalc,
+            #         Fc,
+            #         llgloss.sfc.dHKL,
+            #         llgloss.bin_labels,
+            #     )
+
+            # Update SFC and save
+            llgloss.sfc.atom_pos_orth = aligned_xyz.detach().clone()
+            # llgloss.sfc.savePDB(
+            #    f""{output_directory_path!s}/{run_id}_{iteration}_preRBR.pdb""
+            # )
+
+            # Rigid body refinement (RBR) step
+            optimized_xyz, loss_track_pose = rk_coordinates.rigidbody_refine_quat(
+                aligned_xyz,
+                llgloss_rbr,
+                sfc.cra_name,
+                domain_segs=config.domain_segs,
+                lbfgs=RBR_LBFGS,
+                added_chain_HKL=constant_fp_added_HKL,
+                added_chain_asu=constant_fp_added_asu,
+                lbfgs_lr=config.rbr_lbfgs_learning_rate,
+                verbose=config.verbose,
+            )
+            rbr_loss_by_epoch.append(loss_track_pose)
+
+            # LLG loss
+            llg, r_work, r_free = llgloss(
+                optimized_xyz,
+                bin_labels=None,
+                num_batch=config.number_of_batches,
+                sub_ratio=config.batch_sub_ratio,
+                solvent=config.solvent,
+                update_scales=config.sfc_scale,
+                added_chain_HKL=constant_fp_added_HKL,
+                added_chain_asu=constant_fp_added_asu,
+                return_Rfactors=True,
+            )
+            L_llg = -llg
+
+            llg_estimate = L_llg.clone().item() / (
+                config.batch_sub_ratio * config.number_of_batches
+            )
+            llg_losses.append(llg_estimate)
+            rwork_by_epoch.append(r_work.item())
+            rfree_by_epoch.append(r_free.item())
+
+            # check if current Rfree is the best so far
+            if llg_losses[-1] < best_llg:
+                best_llg = llg_losses[-1]
+                best_msa_bias = (
+                    device_processed_features[""msa_feat_bias""].detach().cpu().clone()
+                )
+                best_feat_weights = (
+                    device_processed_features[""msa_feat_weights""].detach().cpu().clone()
+                )
+                best_run = run_id
+                best_iter = iteration
+                best_pos = optimized_xyz.detach().clone()
+                # best_pos_bfactor = llgloss.sfc.atom_b_iso.detach().clone()
+
+            llgloss.sfc.atom_pos_orth = optimized_xyz
+            # Save postRBR frame: either append to a single PDB trajectory using
+            # MDTraj if available, or fall back to writing one PDB per iteration.
+            if traj_writer is not None:
+                coords_nm = optimized_xyz.detach().cpu().numpy().reshape(-1, 3) / 10.0
+                traj_writer.write(
+                    coords_nm, mdtraj_template.topology, modelIndex=iteration
+                )
+                # Flush the underlying file handle to write data immediately
+                if hasattr(traj_writer, ""_file"") and hasattr(
+                    traj_writer._file, ""flush""
+                ):
+                    traj_writer._file.flush()
+            else:
+                pdb_path = f""{output_directory_path!s}/{run_id}_{iteration}_postRBR.pdb""
+                llgloss.sfc.savePDB(pdb_path)
+
+            progress_bar.set_postfix(
+                NEG_LLG=f""{llg_estimate:.2f}"",
+                r_feff_work=f""{r_work.item():.3f}"",
+                r_feff_free=f""{r_free.item():.3f}"",
+                memory=f""{torch.cuda.max_memory_allocated() / 1024**3:.1f}G"",
+            )
+
+            # if config.alignment_mode == ""B"":
+            #     if loss < best_loss:
+            #         best_loss = loss
+
+            # Save sigmaA values for further processing
+            # sigmas_dict = {
+            #     f""sigma_{i + 1}"": sigma_value.item()
+            #     for i, sigma_value in enumerate(sigmas)
+            # }
+            # sigmas_by_epoch.append(sigmas_dict)
+
+            # if SIGMA_TRUE:
+            #     true_sigmas_dict = {
+            #         f""sigma_{i + 1}"": sigma_value.item()
+            #         for i, sigma_value in enumerate(true_sigmas)
+            #     }
+            #     true_sigmas_by_epoch.append(true_sigmas_dict)
+
+            #### add an L2 loss to constrain confident atoms ###
+            if w_L2 > 0.0:
+                # use
+                L2_loss = torch.sum(
+                    bfactor_weights.unsqueeze(-1) * (optimized_xyz - reference_pos) ** 2
+                )  # / conf_best.shape[0]
+                loss = L_llg + w_L2 * L2_loss + config.w_plddt * L_plddt
+                loss.backward()
+            else:
+                loss = L_llg + config.w_plddt * L_plddt
+                loss.backward()
+
+                if early_stopper.early_stop(loss.item()):
+                    break
+
+            # Smooth last several iterations of phase 1 instead of beginning of phase 2
+            if (""phase1"" in config.note) and (config.smooth_stage_epochs is not None):
+                if iteration > (config.iterations - smooth_stage_epochs):
+                    lr_a = lr_a_initial * (decay_rate_stage1_add**iteration)
+                    lr_m = lr_m_initial * (decay_rate_stage1_mul**iteration)
+                    w_L2 = w_L2_initial * (1 - (iteration / smooth_stage_epochs))
+
+                # Update the learning rates in the optimizer
+                optimizer.param_groups[0][""lr""] = lr_a
+                optimizer.param_groups[1][""lr""] = lr_m
+                optimizer.step()
+            else:
+                optimizer.step()
+
+            time_by_epoch.append(time.time() - start_time)
+            memory_by_epoch.append(torch.cuda.max_memory_allocated() / 1024**3)
+
+            # Save the absolute difference in mean contribution
+            # from each residue channel from previous iteration
+            if config.bias_version == 4:
+                features_at_step_end = (
+                    device_processed_features[""template_torsion_angles_sin_cos""][..., 0]
+                    .detach()
+                    .clone()
+                )
+                mean_change = torch.mean(
+                    torch.abs(features_at_step_end - features_at_it_start[..., 0]),
+                    dim=(0, 2, 3),
+                )
+            else:
+                features_at_step_end = (
+                    device_processed_features[""msa_feat""][:, :, 25:48, 0]
+                    .detach()
+                    .clone()
+                )
+                mean_change = torch.mean(
+                    torch.abs(
+                        features_at_step_end - features_at_it_start[:, :, 25:48, 0]
+                    ),
+                    dim=(0, 2),
+                )
+            absolute_feats_changes.append(rk_utils.assert_numpy(mean_change))
+
+        ####### Save data
+        # Close mdtraj writer if used so file is flushed and closed properly
+        try:
+            if traj_writer is not None:
+                traj_writer.close()
+        except Exception:
+            pass
+        # Average plddt per iteration
+        np.save(
+            f""{output_directory_path!s}/mean_it_plddt_{run_id}.npy"",
+            np.array(mean_it_plddts),
+        )
+
+        # LLG per iteration
+        np.save(
+            f""{output_directory_path!s}/NEG_LLG_it_{run_id}.npy"",
+            rk_utils.assert_numpy(llg_losses),
+        )
+
+        # R work per iteration
+        np.save(
+            f""{output_directory_path!s}/rwork_it_{run_id}.npy"",
+            rk_utils.assert_numpy(rwork_by_epoch),
+        )
+
+        # R free per iteration
+        np.save(
+            f""{output_directory_path!s}/rfree_it_{run_id}.npy"",
+            rk_utils.assert_numpy(rfree_by_epoch),
+        )
+
+        np.save(
+            f""{output_directory_path!s}/time_it_{run_id}.npy"",
+            rk_utils.assert_numpy(time_by_epoch),
+        )
+
+        np.save(
+            f""{output_directory_path!s}/memory_it_{run_id}.npy"",
+            rk_utils.assert_numpy(memory_by_epoch),
+        )
+
+        # Absolute MSA change per column per iteration
+        np.save(
+            f""{output_directory_path!s}/MSA_changes_it_{run_id}.npy"",
+            rk_utils.assert_numpy(absolute_feats_changes),
+        )
+
+        # Mean plddt per residue (over iterations)
+        np.save(
+            f""{output_directory_path!s}/plddt_res_{run_id}.npy"",
+            np.array(all_pldtts),
+        )
+
+        # Iteration sigmaA dictionary
+        # with open(
+        #     f""{output_directory_path!s}/sigmas_by_epoch_{run_id}.pkl"",
+        #     ""wb"",
+        # ) as file:
+        #     pickle.dump(sigmas_by_epoch, file)
+
+        # if SIGMA_TRUE:
+        #     with open(
+        #         f""{output_directory_path!s}/true_sigmas_by_epoch_{run_id}.pkl"",
+        #         ""wb"",
+        #     ) as file:
+        #         pickle.dump(true_sigmas_by_epoch, file)
+
+    # Save the best msa_bias and feat_weights
+    torch.save(
+        best_msa_bias,
+        f""{output_directory_path!s}/best_msa_bias_{best_run}_{best_iter}.pt"",
+    )
+
+    torch.save(
+        best_feat_weights,
+        f""{output_directory_path!s}/best_feat_weights_{best_run}_{best_iter}.pt"",
+    )
+
+    # Save best model as a single PDB (preserve input_pdb topology)
+    try:
+        if best_pos is not None:
+            # best_pos is in Å, set it on the llgloss.sfc object and save
+            try:
+                llgloss.sfc.atom_pos_orth = best_pos
+                best_name = (
+                    f""{output_directory_path!s}/best_model_{best_run}_{best_iter}.pdb""
+                )
+                llgloss.sfc.savePDB(best_name)
+            except Exception:
+                # Fallback: try to write using mdtraj with the input topology
+                try:
+                    import mdtraj as md  # type: ignore
+
+                    topo = md.load_pdb(input_pdb).topology
+                    coords_nm = best_pos.detach().cpu().numpy().reshape(1, -1, 3) / 10.0
+                    traj = md.Trajectory(coords_nm, topo)
+                    traj.save(
+                        f""{output_directory_path!s}/best_model_{best_run}_{best_iter}.pdb""
+                    )
+                except Exception:
+                    logger.warning(
+                        ""Failed to write best model PDB with both SFC and mdtraj.""
+                    )
+    except NameError:
+        # best_pos not defined; nothing to save
+        pass
+
+    return config
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/msacluster_utils.py",".py","3399","109","""""""
+Modified from https://github.com/HWaymentSteele/AF_Cluster/blob/main/scripts/utils.py
+""""""
+
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from Bio import SeqIO
+
+
+def lprint(string, f):
+    print(string)
+    f.write(string + ""\n"")
+
+
+def load_fasta(path):
+    """"""
+    Handle case where path is a folder with multiple a3ms from different databases
+    """"""
+    seqs, IDs = [], []
+    seen_sequences = set()
+    if os.path.isdir(path):
+        for file in os.listdir(path):
+            file_name, ext = os.path.splitext(file)
+            if ext not in ["".a3m"", "".fasta""]:
+                continue
+            file_path = os.path.join(path, file)
+            with open(file_path) as handle:
+                for record in SeqIO.parse(handle, ""fasta""):
+                    seq = """".join(list(record.seq))
+                    if seq in seen_sequences:
+                        continue
+                    seen_sequences.add(seq)
+                    IDs.append(record.id)
+                    seqs.append(seq)
+    elif os.path.isfile(path):
+        file_name, ext = os.path.splitext(os.path.basename(path))
+        if ext not in ["".a3m"", "".fasta""]:
+            raise KeyError(""Input alignment should be a3m or fasta format"")
+        with open(path) as handle:
+            for record in SeqIO.parse(handle, ""fasta""):
+                seq = """".join(list(record.seq))
+                if seq in seen_sequences:
+                    continue
+                seen_sequences.add(seq)
+                IDs.append(record.id)
+                seqs.append(seq)
+    return IDs, seqs
+
+
+def write_fasta(names, seqs, outfile=""tmp.fasta""):
+    with open(outfile, ""w"") as f:
+        for nm, seq in list(zip(names, seqs, strict=False)):
+            f.write(f"">{nm}\n{seq}\n"")
+
+
+def encode_seqs(seqs, max_len=108, alphabet=None):
+    if alphabet is None:
+        alphabet = ""ACDEFGHIKLMNPQRSTVWY-""
+
+    arr = np.zeros([len(seqs), max_len, len(alphabet)])
+    for j, seq in enumerate(seqs):
+        for i, char in enumerate(seq):
+            for k, res in enumerate(alphabet):
+                if char == res:
+                    arr[j, i, k] += 1
+    return arr.reshape([len(seqs), max_len * len(alphabet)])
+
+
+def consensusVoting(seqs):
+    ## Find the consensus sequence
+    consensus = """"
+    residues = ""ACDEFGHIKLMNPQRSTVWY-""
+    n_chars = len(seqs[0])
+    for i in range(n_chars):
+        baseArray = [x[i] for x in seqs]
+        baseCount = np.array([baseArray.count(a) for a in list(residues)])
+        vote = np.argmax(baseCount)
+        consensus += residues[vote]
+
+    return consensus
+
+
+def plot_landscape(x, y, df, query_, plot_type, args):
+    plt.figure(figsize=(5, 5))
+    tmp = df.loc[df.dbscan_label == -1]
+    plt.scatter(tmp[x], tmp[y], color=""lightgray"", marker=""x"", label=""unclustered"")
+
+    tmp = df.loc[df.dbscan_label > 9]
+    plt.scatter(tmp[x], tmp[y], color=""black"", label=""other clusters"")
+
+    tmp = df.loc[df.dbscan_label >= 0][df.dbscan_label <= 9]
+    sns.scatterplot(
+        x=x, y=y, hue=""dbscan_label"", data=tmp, palette=""tab10"", linewidth=0
+    )
+
+    plt.scatter(query_[x], query_[y], color=""red"", marker=""*"", s=150, label=""Ref Seq"")
+    plt.legend(bbox_to_anchor=(1, 1), frameon=False)
+
+    plt.xlabel(x)
+    plt.ylabel(y)
+    plt.tight_layout()
+
+    plt.savefig(
+        args.o + ""/"" + args.keyword + ""_"" + plot_type + "".pdf"", bbox_inches=""tight""
+    )
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/mse.py",".py","2903","97","""""""
+MSE target for a target PDB file
+""""""
+
+import numpy as np
+import torch
+from SFC_Torch import PDBParser
+
+from rocket import refinement_utils as rkrf_utils
+
+
+class MSElossBB:
+    """"""
+    Object_oreinted interface to calculate MSE loss for backbone or CA atoms
+    """"""
+
+    def __init__(
+        self, target: PDBParser, moving: PDBParser, device: torch.device, selection=""BB""
+    ):
+        """"""
+        selection: str
+            ""BB"" for backbone, ""CA"" for Calpha
+        """"""
+
+        self.device = device
+        self.target_cra = target.cra_name
+        self.moving_cra = moving.cra_name
+        self.pdb_obj = moving
+        self.target_pos = torch.tensor(
+            target.atom_pos, device=device, dtype=torch.float32
+        ).clone()
+        self.selection = selection
+        if selection == ""BB"":
+            self.ind1, self.ind2 = rkrf_utils.get_common_bb_ind(moving, target)
+        elif selection == ""CA"":
+            self.ind1, self.ind2 = rkrf_utils.get_common_ca_ind(moving, target)
+
+    def forward(self, xyz_ort: torch.Tensor, weights: torch.Tensor):
+        mse_loss = torch.mean(
+            torch.sum(
+                (xyz_ort[self.ind1] - self.target_pos[self.ind2]) ** 2,
+                dim=-1,
+            )
+            * weights[self.ind1]
+        )
+        return mse_loss
+
+
+class MSEloss:
+    """"""
+    Object_oreinted interface to calculate MSE loss
+    """"""
+
+    def __init__(self, target: PDBParser, moving: PDBParser, device: torch.device):
+        assert target.sequence == moving.sequence, (
+            ""target pdb has different sequence with moving pdb!""
+        )
+        # get the intersect atoms index
+        self.target_pdb = target
+        self.device = device
+        index_target = []
+        index_moving = []
+        for i, name in enumerate(moving.cra_name):
+            try:
+                id_t = target.cra_name.index(name)
+                index_moving.append(i)
+                index_target.append(id_t)
+            except ValueError:
+                pass
+        assert (
+            np.array(target.cra_name)[index_target]
+            == np.array(moving.cra_name)[index_moving]
+        ).all()
+        self.index_target = np.array(index_target)
+        self.index_moving = np.array(index_moving)
+        self.target_pos = torch.tensor(
+            target.atom_pos, device=device, dtype=torch.float32
+        )
+
+    @property
+    def sequence(self):
+        return self.target_pdb.sequence
+
+    def forward(self, xyz_ort: torch.Tensor, subratio=1.0):
+        sub_boolean_mask = np.random.rand(len(self.index_moving)) < subratio
+        mse_loss = torch.mean(
+            torch.sum(
+                (
+                    xyz_ort[self.index_moving][sub_boolean_mask]
+                    - self.target_pos[self.index_target][sub_boolean_mask]
+                )
+                ** 2,
+                dim=-1,
+            )
+        )
+        return mse_loss
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/xtal/targets.py",".py","15988","433","""""""
+LLG targets for xtal data
+""""""
+
+import time
+from functools import partial
+
+import numpy as np
+import torch
+from SFC_Torch import SFcalculator
+
+from rocket import utils
+from rocket.xtal import structurefactors as llg_sf
+from rocket.xtal import utils as llg_utils
+
+
+class LLGloss(torch.nn.Module):
+    """"""
+    Object_oriented interface to calculate LLG loss
+
+    # Initialization, only have to do it once
+    sfc = llg_sf.initial_SFC(...)
+    llgloss = LLGloss(sfc, tng_file, device)
+    Ecalc = llgloss.compute_Ecalc(xyz_orth)
+    llgloss.refine_sigmaA_adam(Ecalc.detach(), n_step=50)
+    llgloss.freeze_sigmaA()
+
+    # Loss calculation for each step
+    loss = -llgloss(xyz_orth, bin_labels=[1,2,3], num_batch=10, sub_ratio=0.3)
+
+    resol_min, resol_max: None | float
+        resolution cutoff for used miller index. Will use resol_min <= dHKL <= resol_max
+
+    TODO:
+    Currently the initialization needs Eobs, Eps, Centric, Dobs, Feff, Bin_labels.
+    We do so by loading the tng_data.
+    Later we should be able to calculate everything from SFcalculator,
+    all necesary information is ready there.
+
+    """"""
+
+    def __init__(
+        self,
+        sfc: SFcalculator,
+        tng_file: str,
+        device: torch.device,
+        resol_min=None,
+        resol_max=None,
+    ) -> None:
+        super().__init__()
+        self.sfc = sfc
+        self.device = device
+        data_dict = llg_utils.load_tng_data(tng_file, device=device)
+
+        self.register_buffer(""Eobs"", data_dict[""EDATA""])
+        self.Eobs: torch.Tensor
+        self.register_buffer(""Eps"", data_dict[""EPS""])
+        self.Eps: torch.Tensor
+        self.register_buffer(""Centric"", data_dict[""CENTRIC""])
+        self.Centric: torch.Tensor
+        self.register_buffer(""Dobs"", data_dict[""DOBS""])
+        self.Dobs: torch.Tensor
+        self.register_buffer(""Feff"", data_dict[""FEFF""])
+        self.Feff: torch.Tensor
+        self.register_buffer(""bin_labels"", data_dict[""BIN_LABELS""])
+        self.bin_labels: torch.Tensor
+        self.unique_bins = torch.unique(self.bin_labels)
+        self.register_buffer(""bin_dHKL"", data_dict[""BIN_dHKLS""])
+        self.bin_dHKL: torch.Tensor
+
+        if resol_min is None:
+            resol_min = min(self.sfc.dHKL)
+
+        if resol_max is None:
+            resol_max = max(self.sfc.dHKL)
+
+        resol_bool = (self.sfc.dHKL >= (resol_min - 1e-4)) & (
+            self.sfc.dHKL <= (resol_max + 1e-4)
+        )
+        self.working_set = (~self.sfc.free_flag) & (~self.sfc.Outlier) & (resol_bool)
+        self.free_set = (self.sfc.free_flag) & (~self.sfc.Outlier) & (resol_bool)
+
+    def init_sigmaAs(self, Ecalc, subset=""working"", requires_grad=True):
+        if subset == ""working"":
+            subset_boolean = (~self.sfc.free_flag) & (~self.sfc.Outlier)
+        elif subset == ""free"":
+            subset_boolean = (self.sfc.free_flag) & (~self.sfc.Outlier)
+
+        Ecalc = Ecalc.detach().clone()
+        self.sigmaAs = []
+        for bin_i in self.unique_bins:
+            index_i = self.bin_labels[subset_boolean] == bin_i
+            Eobs_i = self.Eobs[subset_boolean][index_i]
+            Ecalc_i = Ecalc[subset_boolean][index_i]
+
+            # Initialize from correlation coefficient
+            sigmaA_i = (
+                torch.corrcoef(torch.stack([Eobs_i**2, Ecalc_i**2], dim=0))[1][0]
+                .clamp(min=0.001, max=0.999)
+                .sqrt()
+                .to(device=self.device, dtype=torch.float32)
+                .requires_grad_(requires_grad)
+            )
+            self.sigmaAs.append(sigmaA_i)
+
+    def init_sigmaAs_nodata(self, frac=1.0, rms=0.7, requires_grad=True):
+        self.sigmaAs = []
+        for bin_i in self.unique_bins:
+            index_i = self.bin_labels == bin_i
+            s = self.bin_dHKL[index_i][0]
+            sigmaA_i = torch.sqrt(torch.tensor(frac)) * torch.exp(
+                -2 / 3 * torch.pi**2 * torch.tensor(rms) ** 2 * s**-2
+            ).to(device=self.device, dtype=torch.float32).requires_grad_(requires_grad)
+            self.sigmaAs.append(sigmaA_i)
+
+    def freeze_sigmaA(self):
+        self.sigmaAs = [sigmaA.requires_grad_(False) for sigmaA in self.sigmaAs]
+
+    def unfreeze_sigmaA(self):
+        self.sigmaAs = [sigmaA.requires_grad_(True) for sigmaA in self.sigmaAs]
+
+    def refine_sigmaA_adam(
+        self, Ecalc, n_steps=50, lr=0.01, sub_ratio=0.3, initialize=True, verbose=False
+    ):
+        def adam_opt_i(i, index_i, n_steps, sub_ratio, lr, verbose):
+            def adam_stepopt(sub_boolean_mask):
+                loss = -llg_utils.llgTot_calculate(
+                    self.sigmaAs[i],
+                    Eobs_i[sub_boolean_mask],
+                    Ecalc_i[sub_boolean_mask],
+                    centric_i[sub_boolean_mask],
+                )
+                adam.zero_grad()
+                loss.backward()
+                adam.step()
+                self.sigmaAs[i].data = torch.clamp(self.sigmaAs[i].data, 0.015, 0.99)
+                return loss
+
+            Eobs = self.Eobs.detach().clone()
+            Ecalc_cloned = Ecalc.detach().clone()
+            Eobs_i = Eobs[index_i]
+            Ecalc_i = Ecalc_cloned[index_i]
+            centric_i = self.Centric[index_i]
+            adam = torch.optim.Adam([self.sigmaAs[i]], lr=lr)
+            for _ in range(n_steps):
+                start_time = time.time()
+                sub_boolean_mask = (
+                    np.random.rand(
+                        len(Eobs_i),
+                    )
+                    < sub_ratio
+                )
+                temp_loss = adam_stepopt(sub_boolean_mask)
+                time_this_round = round(time.time() - start_time, 3)
+                str_ = ""Time: "" + str(time_this_round)
+                if verbose:
+                    print(
+                        f""SigmaA {i}"", utils.assert_numpy(temp_loss), str_, flush=True
+                    )
+
+        if initialize:
+            self.init_sigmaAs(Ecalc, requires_grad=True)
+
+        for i, bin_i in enumerate(self.unique_bins):
+            index_i = self.bin_labels == bin_i
+            adam_opt_i(
+                i, index_i, n_steps=n_steps, sub_ratio=sub_ratio, lr=lr, verbose=verbose
+            )
+
+    def refine_sigmaA_newton(
+        self,
+        Ecalc,
+        n_steps=2,
+        initialize=True,
+        method=""autodiff"",
+        subset=""test"",
+        edge_weights=0.25,
+        smooth_overall_weight=200.0,
+    ):
+        """"""
+        subset : str, ""working"" or ""free""
+
+        method : str, ""autodiff"" or ""analytical""
+
+        TODO: include smooth_constraint
+        """"""
+        if initialize:
+            self.init_sigmaAs(Ecalc, subset=""working"", requires_grad=False)
+            # self.init_sigmaAs_nodata()
+
+        if subset == ""working"":
+            subset_boolean = (~self.sfc.free_flag) & (~self.sfc.Outlier)
+        elif subset == ""test"":
+            subset_boolean = (self.sfc.free_flag) & (~self.sfc.Outlier)
+
+        for _n in range(n_steps):
+            lps = []
+            lpps = []
+            ls = []
+            for i, label in enumerate(self.unique_bins):
+                # for i in range(0, len(self.unique_bins) - 1, 2):
+                # TODO: tackle the corner case where no freeset in a bin
+                index_i = self.bin_labels[subset_boolean] == label
+
+                Ecalc_i = Ecalc[subset_boolean][index_i]
+                Eob_i = self.Eobs[subset_boolean][index_i]
+
+                Centric_i = self.Centric[subset_boolean][index_i]
+                Dobs_i = self.Dobs[subset_boolean][index_i]
+                sigmaA_i = self.sigmaAs[int(i)].detach().clone()
+                l, lp, lpp = llg_utils.llgItot_with_derivatives2sigmaA(  # noqa: E741
+                    sigmaA=sigmaA_i,
+                    dobs=Dobs_i,
+                    Eeff=Eob_i,
+                    Ec=Ecalc_i,
+                    centric_tensor=Centric_i,
+                    method=method,
+                )
+                ls.append(l)
+                lps.append(lp)
+                lpps.append(lpp)
+
+            dL1 = torch.stack(lps).detach()
+            H1 = torch.diag(torch.stack(lpps).detach())
+
+            # Smooth terms
+            sigmaAs_tensor = (
+                torch.stack(self.sigmaAs).detach().clone().requires_grad_(True)
+            )
+            smooth_calculator = partial(
+                llg_utils.interpolate_smooth,
+                edge_weights=edge_weights,
+                total_weight=smooth_overall_weight,
+            )
+            Ls = smooth_calculator(sigmaAs_tensor)
+            dL2 = torch.autograd.grad(Ls, sigmaAs_tensor, create_graph=True)[0]
+            H2 = torch.autograd.functional.hessian(smooth_calculator, sigmaAs_tensor)
+
+            # Combine the two terms
+            dL_total = dL1 - dL2.detach()
+            Htotal = H1 - H2.detach()
+
+            sigmaAs_updated = llg_utils.newton_step(sigmaAs_tensor, dL_total, Htotal)
+            sigmaAs_new = torch.clamp(sigmaAs_updated, 0.015, 0.99)
+            self.sigmaAs = [s.detach().requires_grad_(False) for s in sigmaAs_new]
+
+    def compute_Ecalc(
+        self,
+        xyz_orth,
+        solvent=True,
+        return_Fc=False,
+        return_Rfactors=False,
+        update_scales=False,
+        scale_steps=10,
+        scale_initialize=False,
+        added_chain_HKL=None,
+        added_chain_asu=None,
+    ) -> torch.Tensor:
+        """"""
+        Compute normalized structure factors (Ecalc).
+
+        Args:
+            xyz_orth: Orthogonal coordinates of atoms
+            solvent: Whether to include solvent contribution
+            return_Fc: Whether to return calculated structure factors Fc
+            return_Rfactors: Whether to calculate and return R-work and R-free
+            update_scales: Whether to update scaling factors
+            scale_steps: Number of steps for scale refinement
+            scale_initialize: Whether to initialize scales
+            added_chain_HKL: Additional HKL contributions
+            added_chain_asu: Additional ASU contributions
+
+        Returns:
+            If return_Rfactors=True and return_Fc=True: (Ecalc, Fc, R_work, R_free)
+            If return_Rfactors=True and return_Fc=False: (Ecalc, R_work, R_free)
+            If return_Rfactors=False and return_Fc=True: (Ecalc, Fc)
+            If return_Rfactors=False and return_Fc=False: Ecalc
+
+        Note:
+            R-factors are calculated using:
+            R_FEFF = Sum[DOBS^2 * |FEFF - FCALC|] / Sum[DOBS^2 * FEFF]
+            R_work uses the working set (~free_flag), R_free uses the free set
+            (free_flag)
+        """"""
+        self.sfc.calc_fprotein(atoms_position_tensor=xyz_orth)
+
+        if added_chain_HKL is not None:
+            self.sfc.Fprotein_HKL = self.sfc.Fprotein_HKL + added_chain_HKL
+            self.sfc.Fprotein_asu = self.sfc.Fprotein_asu + added_chain_asu
+
+        if solvent:
+            self.sfc.calc_fsolvent()
+            if update_scales:
+                self.sfc.get_scales_adam(
+                    lr=0.01,
+                    n_steps=scale_steps,
+                    sub_ratio=0.7,
+                    initialize=scale_initialize,
+                )
+            Fc = self.sfc.calc_ftotal()
+        else:
+            # MH note: we need scales here, even without solvent contribution
+            self.sfc.Fmask_HKL = torch.zeros_like(self.sfc.Fprotein_HKL)
+            if update_scales:
+                self.sfc.get_scales_adam(
+                    lr=0.01,
+                    n_steps=scale_steps,
+                    sub_ratio=0.7,
+                    initialize=scale_initialize,
+                )
+            Fc = self.sfc.calc_ftotal()
+
+        Fm = llg_sf.ftotal_amplitudes(Fc, self.sfc.dHKL, sort_by_res=True)
+        sigmaP = llg_sf.calculate_Sigma_atoms(Fm, self.Eps, self.bin_labels)
+        Ecalc = llg_sf.normalize_Fs(Fm, self.Eps, sigmaP, self.bin_labels)
+
+        if return_Rfactors:
+            # Calculate R-work and R-free using the formula:
+            # R_FEFF = Sum[DOBS^2 * |FEFF - FCALC|] / Sum[DOBS^2 * FEFF]
+
+            # Calculate R-work (working set)
+            working_mask = self.working_set
+            dobs_work = self.Dobs[working_mask]
+            feff_work = self.Feff[working_mask]
+            fcalc_work = Fc[working_mask]
+
+            numerator_work = torch.sum(dobs_work**2 * torch.abs(feff_work - fcalc_work))
+            denominator_work = torch.sum(dobs_work**2 * feff_work)
+            R_work = numerator_work / (denominator_work + 1e-8)  # avoid divide by zero
+
+            # Calculate R-free (free set)
+            free_mask = self.free_set
+            dobs_free = self.Dobs[free_mask]
+            feff_free = self.Feff[free_mask]
+            fcalc_free = Fc[free_mask]
+
+            numerator_free = torch.sum(dobs_free**2 * torch.abs(feff_free - fcalc_free))
+            denominator_free = torch.sum(dobs_free**2 * feff_free)
+            R_free = numerator_free / (denominator_free + 1e-8)  # avoid divide by zero
+
+            if return_Fc:
+                return Ecalc, Fc, R_work, R_free
+            else:
+                return Ecalc, R_work, R_free
+        elif return_Fc:
+            return Ecalc, Fc
+        else:
+            return Ecalc
+
+    def forward(
+        self,
+        xyz_ort: torch.Tensor,
+        bin_labels=None,
+        num_batch=1,
+        sub_ratio=1.0,
+        solvent=True,
+        update_scales=False,
+        added_chain_HKL=None,
+        added_chain_asu=None,
+        return_Rfactors=False,
+    ):
+        """"""
+        Args:
+            xyz_orth: torch.Tensor, [N_atoms, 3] in angstroms
+                Orthogonal coordinates of proteins, coming from AF2 model, send to SFC
+
+            bin_labels: None or List[int]
+                Labels of bins used in the loss calculation.
+                If None, will use the whole miller indices.
+                Serve as a proxy for resolution selection
+
+            num_batch: int
+                Number of batches
+
+            sub_ratio: float between 0.0 and 1.0
+                Fraction of mini-batch sampling over all miller indices,
+                e.g. 0.3 meaning each batch sample 30% of miller indices
+
+            return_Rfactors: bool
+                Whether to calculate and return R-work and R-free factors.
+                If True, returns (llg, r_work, r_free). If False, returns llg only.
+
+        """"""
+
+        if return_Rfactors:
+            Ecalc, r_work, r_free = self.compute_Ecalc(
+                xyz_ort,
+                solvent=solvent,
+                update_scales=update_scales,
+                added_chain_HKL=added_chain_HKL,
+                added_chain_asu=added_chain_asu,
+                return_Rfactors=True,
+            )
+        else:
+            Ecalc = self.compute_Ecalc(
+                xyz_ort,
+                solvent=solvent,
+                update_scales=update_scales,
+                added_chain_HKL=added_chain_HKL,
+                added_chain_asu=added_chain_asu,
+                return_Rfactors=False,
+            )
+        llg = 0.0
+
+        if bin_labels is None:
+            bin_labels = self.unique_bins
+
+        for i, label in enumerate(bin_labels):
+            index_i = self.bin_labels[self.working_set] == label
+            # if sum(index_i) == 0:
+            #    continue
+            Ecalc_i = Ecalc[self.working_set][index_i]
+            Eob_i = self.Eobs[self.working_set][index_i]
+            Centric_i = self.Centric[self.working_set][index_i]
+            Dobs_i = self.Dobs[self.working_set][index_i]
+
+            sigmaA_i = self.sigmaAs[int(i)]
+            for _j in range(num_batch):
+                sub_boolean_mask = np.random.rand(len(Eob_i)) < sub_ratio
+                llg_ij = llg_utils.llgItot_calculate(
+                    sigmaA_i,
+                    Dobs_i[sub_boolean_mask],
+                    Eob_i[sub_boolean_mask],
+                    Ecalc_i[sub_boolean_mask],
+                    Centric_i[sub_boolean_mask],
+                ).sum()
+                llg = llg + llg_ij
+
+        if return_Rfactors:
+            return llg, r_work, r_free
+        else:
+            return llg
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/xtal/__init__.py",".py","99","4","from . import structurefactors, targets, utils
+
+__all__ = [""structurefactors"", ""targets"", ""utils""]
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/xtal/utils.py",".py","13947","485","""""""
+Functions relating to sigmaa calculation and refinement
+""""""
+
+import numpy as np
+import reciprocalspaceship as rs
+import torch
+
+from rocket import utils
+from rocket.xtal import structurefactors
+
+
+def newton_step(tensor_pre_update, gradient, Hessian):
+    # updated_tensor = torch.clamp(
+    #    tensor_pre_update - derivatives_tensor,
+    #    0.015,
+    #    0.99,
+    # )
+    gamma = 1.0
+    derivatives_tensor = torch.matmul(torch.linalg.inv(Hessian), gradient)
+    updated_tensor = tensor_pre_update - gamma * derivatives_tensor
+
+    # ds_tensor = torch.matmul(torch.linalg.inv(Htotal), dL_total)
+    # sigmaAs_new = sigmaAs_tensor - ds_tensor
+    #             sigmaAs_new = llg_utils.newton_step(
+    #            sigmaAs_tensor, dL_total, torch.linalg.inv(Htotal)
+    #        )
+    return updated_tensor
+
+
+def llgIa_firstdev(sigmaA, dobs, Eeff, Ec):
+    """"""
+    partial llgIa / partial sigmaA
+    """"""
+
+    bessel_argument = (2 * dobs * Ec * Eeff * sigmaA) / (1 - dobs**2 * sigmaA**2)
+    bessel_ratio = Ak_approx(
+        torch.tensor(1).to(bessel_argument), bessel_argument
+    ).squeeze()
+
+    dLa = (
+        2
+        * dobs
+        * (
+            Ec * Eeff * (dobs**2 * sigmaA**2 + 1) * bessel_ratio
+            - dobs * sigmaA * (dobs**2 * sigmaA**2 + Ec**2 + Eeff**2 - 1)
+        )
+        / (dobs**2 * sigmaA**2 - 1) ** 2
+    )
+
+    return dLa
+
+
+def llgIc_firstdev(sigmaA, dobs, Eeff, Ec):
+    """"""
+    partial llgIc / partial sigmaA
+    """"""
+
+    tanh_argument = (dobs * Ec * Eeff * sigmaA) / (1 - dobs**2 * sigmaA**2)
+
+    dLc = (
+        dobs
+        * (
+            Ec * Eeff * (dobs**2 * sigmaA**2 + 1) * torch.tanh(tanh_argument)
+            - dobs * sigmaA * (dobs**2 * sigmaA**2 + Ec**2 + Eeff**2 - 1)
+        )
+        / (dobs**2 * sigmaA**2 - 1) ** 2
+    )
+
+    return dLc
+
+
+def llgItot_firstdev(sigmaA, dobs, Eeff, Ec, centric_tensor):
+    """"""
+    partial llgI / partial sigmaA
+    """"""
+    llgIp_centric = llgIc_firstdev(
+        sigmaA, dobs[centric_tensor], Eeff[centric_tensor], Ec[centric_tensor]
+    )
+    llgIp_acentric = llgIa_firstdev(
+        sigmaA, dobs[~centric_tensor], Eeff[~centric_tensor], Ec[~centric_tensor]
+    )
+
+    return llgIp_centric.sum() + llgIp_acentric.sum()
+
+
+def llgIa_seconddev(sigmaA, dobs, Eeff, Ec):
+    """"""
+    partial^2 llgIa / partial sigmaA^2
+    """"""
+
+    bessel_argument = (2 * dobs * Ec * Eeff * sigmaA) / (1 - dobs**2 * sigmaA**2)
+    bessel_ratio = Ak_approx(
+        torch.tensor(1).to(bessel_argument), bessel_argument
+    ).squeeze()
+
+    d2La = (
+        2
+        * dobs
+        / (dobs**2 * sigmaA**2 - 1) ** 4
+        * (
+            dobs
+            * (
+                Ec**2
+                * (
+                    3 * dobs**4 * sigmaA**4
+                    + 2 * (dobs**2 * Eeff * sigmaA**2 + Eeff) ** 2
+                    - 2 * dobs**2 * sigmaA**2
+                    - 1
+                )
+                + (dobs**2 * sigmaA**2 - 1)
+                * (dobs**4 * sigmaA**4 + Eeff**2 * (3 * dobs**2 * sigmaA**2 + 1) - 1)
+            )
+            + Ec
+            * Eeff
+            * bessel_ratio
+            * (
+                bessel_ratio * (-2 * dobs * Ec * Eeff * (dobs**2 * sigmaA**2 + 1) ** 2)
+                - (
+                    (
+                        dobs**6 * sigmaA**6
+                        + 3 * dobs**4 * sigmaA**4
+                        - 5 * dobs**2 * sigmaA**2
+                        + 1
+                    )
+                    / sigmaA
+                )
+            )
+        )
+    )
+
+    return d2La
+
+
+def llgIc_seconddev(sigmaA, dobs, Eeff, Ec):
+    """"""
+    partial^2 llgIc / partial sigmaA^2
+    """"""
+
+    tanh_and_sech_argument = (dobs * Ec * Eeff * sigmaA) / (1 - dobs**2 * sigmaA**2)
+
+    term_1 = (
+        dobs**4 * sigmaA**4
+        + 3 * dobs**2 * sigmaA**2 * (Ec**2 + Eeff**2)
+        + Ec**2
+        + Eeff**2
+        - 1
+    )
+    term_2 = (
+        Ec
+        * Eeff
+        * (dobs**2 * sigmaA**2 + 1) ** 2
+        * torch.cosh(tanh_and_sech_argument) ** -2
+    )
+    term_3 = (dobs**4 * sigmaA**4 + 2 * dobs**2 * sigmaA**2 - 3) * torch.tanh(
+        tanh_and_sech_argument
+    )
+
+    d2Lc = (dobs**2 * sigmaA**2 - 1) ** -4 * (
+        dobs**2
+        * (
+            (dobs**2 * sigmaA**2 - 1) * term_1
+            + Ec * Eeff * (term_2 - 2 * dobs * sigmaA * term_3)
+        )
+    )
+
+    return d2Lc
+
+
+def llgItot_seconddev(sigmaA, dobs, Eeff, Ec, centric_tensor):
+    """"""
+    partial^2 llgI / partial sigmaA^2
+    """"""
+
+    llgIpp_centric = llgIc_seconddev(
+        sigmaA, dobs[centric_tensor], Eeff[centric_tensor], Ec[centric_tensor]
+    )
+    llgIpp_acentric = llgIa_seconddev(
+        sigmaA, dobs[~centric_tensor], Eeff[~centric_tensor], Ec[~centric_tensor]
+    )
+
+    return llgIpp_centric.sum() + llgIpp_acentric.sum()
+
+
+def interpolate_smooth(sigmaAs_tensor, edge_weights=0.25, total_weight=200.0):
+    # Calculate loss for internal values
+    internal_loss = (
+        (sigmaAs_tensor[1:-1] - (sigmaAs_tensor[:-2] + sigmaAs_tensor[2:]) / 2) ** 2
+    ).sum()
+
+    # Extrapolate at the edges
+    edge_loss_start = (
+        sigmaAs_tensor[0] - 2 * sigmaAs_tensor[1] + sigmaAs_tensor[2]
+    ) ** 2
+    edge_loss_end = (
+        sigmaAs_tensor[-1] - 2 * sigmaAs_tensor[-2] + sigmaAs_tensor[-3]
+    ) ** 2
+
+    # Total loss
+    total_loss = (
+        internal_loss + edge_weights * edge_loss_start + edge_weights * edge_loss_end
+    ) / float(sigmaAs_tensor.shape[0])
+
+    return total_weight * total_loss
+
+
+def llgItot_with_derivatives2sigmaA(
+    sigmaA, dobs, Eeff, Ec, centric_tensor, method=""autodiff""
+):
+    """"""
+    sigmaA : torch.Tensor
+
+    method : str, ""autodiff"" or ""analytical""
+        calculate derivatives with autodiff or analytical expression
+    """"""
+    if method == ""autodiff"":
+        sA = sigmaA.detach().clone().requires_grad_(True)
+        l = llgItot_calculate(sA, dobs, Eeff, Ec, centric_tensor)  # noqa: E741
+        lp = torch.autograd.grad(l, sA, create_graph=True)[0]
+        lpp = torch.autograd.grad(lp, sA, create_graph=True, allow_unused=True)[0]
+    elif method == ""analytical"":
+        l = llgItot_calculate(sigmaA, dobs, Eeff, Ec, centric_tensor)  # noqa: E741
+        lp = llgItot_firstdev(
+            sigmaA, dobs.detach(), Eeff.detach(), Ec.detach(), centric_tensor.detach()
+        )
+        lpp = llgItot_seconddev(
+            sigmaA, dobs.detach(), Eeff.detach(), Ec.detach(), centric_tensor.detach()
+        )
+
+    return l.detach().clone(), lp.detach().clone(), lpp.detach().clone()
+
+
+def Ak_approx(nu, z):
+    """"""
+    Approximation of ratio of modified Bessel functions of 1st kind.
+    https://arxiv.org/pdf/1902.02603.pdf
+
+    Parameters
+    ----------
+    nu: tensor, shape (N0,)
+            Order of modified Bessel functions of 1st kind.
+    z: tensor, shape (N1,)
+            Argument of Bessel function. Positive values only.
+
+    Return
+    ------
+    tensor, shape (N1, N0)
+    """"""
+    return 0.5 * (lb_Ak(nu, z) + ub_Ak(nu, z))
+
+
+def ub_Ak(nu, z):
+    """"""
+    Upper-bound for the ratio of modified Bessel functions of 1st kind.
+    https://arxiv.org/pdf/1606.02008.pdf (Theorems 5 and 6).
+
+    Return
+    ------
+    ub: tensor, shape (z.shape[0], nu.shape[0])
+            Upper-bound for Ak(nu, z).
+    """"""
+    assert torch.all(nu >= 0)
+    nu = nu.reshape(1, -1)
+    z = z.reshape(-1, 1)
+
+    ub = torch.zeros(z.shape[0], nu.shape[1]).to(z)
+    ub[:, nu.reshape(-1) >= 0.5] = torch.min(
+        B(0, nu[nu >= 0.5], z), B_tilde(2, nu[nu >= 0.5], z)
+    )
+    ub[:, nu.reshape(-1) < 0.5] = B_tilde(2, nu[nu < 0.5], z)
+    return ub
+
+
+def lb_Ak(nu, z):
+    """"""
+    Lower-bound for the ratio of modified Bessel functions of 1st kind.
+    https://arxiv.org/pdf/1606.02008.pdf (Theorems 5 and 6).
+    """"""
+    assert torch.all(nu >= 0)
+    nu = nu.reshape(1, -1)
+    z = z.reshape(-1, 1)
+    return B_tilde(0, nu, z)
+
+
+def B_tilde(alpha, nu, z):
+    """"""
+    https://arxiv.org/pdf/1606.02008.pdf
+    """"""
+    nu = nu.reshape(1, -1)
+    z = z.reshape(-1, 1)
+    sigma = nu + float(alpha + 1) / 2.0
+    delta_p = nu + 0.5 + sigma / (2 * torch.sqrt(sigma**2 + z**2))
+    delta_m = nu - 0.5 - sigma / (2 * torch.sqrt(sigma**2 + z**2))
+    return z / (delta_m + torch.sqrt(delta_p**2 + z**2))
+
+
+def B(alpha, nu, z):
+    """"""
+    https://arxiv.org/pdf/1606.02008.pdf
+    """"""
+    nu = nu.reshape(1, -1)
+    z = z.reshape(-1, 1)
+    lamda = nu + float(alpha - 1) / 2.0
+    delta = nu - 0.5 + lamda / (2 * torch.sqrt(lamda**2 + z**2))
+    return z / (delta + torch.sqrt(delta**2 + z**2))
+
+
+def llgIa_calculate(sigmaA, dobs, Eeff, Ec):
+    # acentric reflections
+    bessel_arg = (2 * dobs * sigmaA * Eeff * Ec) / (1 - dobs**2 * sigmaA**2)
+    exp_bessel = torch.special.i0e(bessel_arg)
+
+    llg = torch.sum(
+        torch.log((1 - dobs**2 * sigmaA**2) ** (-1) * exp_bessel)
+        + (
+            sigmaA
+            * dobs
+            * (-dobs * sigmaA * Eeff**2 - dobs * sigmaA * Ec**2 + 2 * Eeff * Ec)
+        )
+        / (1 - dobs**2 * sigmaA**2)
+    )
+    return llg
+
+
+def llgIc_calculate(sigmaA, dobs, Eeff, Ec):
+    # centric reflections
+    cosh_arg = (sigmaA * dobs * Ec * Eeff) / (1 - dobs**2 * sigmaA**2)
+    expo_arg = (sigmaA**2 * dobs**2 * (Eeff**2 + Ec**2)) / (2 * dobs**2 * sigmaA**2 - 2)
+
+    llg = torch.sum(
+        torch.log((1 - dobs**2 * sigmaA**2) ** (-0.5)) + expo_arg + logcosh(cosh_arg)
+    )
+
+    return llg
+
+
+def llgItot_calculate(sigmaA, dobs, Eeff, Ec, centric_tensor):
+    # (1) Make a centric and acentric tensor
+    acentric_tensor = ~centric_tensor
+
+    # (2) Call respective llg targets with indexed data
+    llg_centric = llgIc_calculate(
+        sigmaA, dobs[centric_tensor], Eeff[centric_tensor], Ec[centric_tensor]
+    )
+    llg_acentric = llgIa_calculate(
+        sigmaA, dobs[acentric_tensor], Eeff[acentric_tensor], Ec[acentric_tensor]
+    )
+
+    return llg_acentric + llg_centric
+
+
+def llgA_calculate(sigmaA, E, Ec):
+    # acentric reflections
+    bessel_arg = (2 * sigmaA * E * Ec) / (1 - sigmaA**2)
+    exp_bessel = torch.special.i0e(bessel_arg)
+    llg = torch.sum(
+        torch.log((1 - sigmaA**2) ** (-1) * exp_bessel)
+        + (sigmaA * (-sigmaA * E**2 - sigmaA * Ec**2 + 2 * E * Ec)) / (1 - sigmaA**2)
+    )
+
+    return llg
+
+
+def logcosh(x):
+    # s always has real part >= 0
+
+    s = torch.sign(x) * x
+    p = torch.exp(-2 * s)
+    return s + torch.log1p(p) - torch.log(torch.tensor(2.0))
+
+
+def llgC_calculate(sigmaA, E, Ec):
+    # centric reflections
+    cosh_arg = (Ec * sigmaA * E) / (1 - sigmaA**2)
+    expo_arg = (sigmaA**2 * Ec**2 + sigmaA**2 * E**2 - 2 * Ec * E * sigmaA) / (
+        2 * sigmaA**2 - 2
+    )
+    cosh_exp = -Ec * E * sigmaA / (1 - sigmaA**2)
+
+    llg = torch.sum(
+        torch.log((1 - sigmaA**2) ** (-0.5)) + expo_arg + logcosh(cosh_arg) + cosh_exp
+    )
+
+    return llg
+
+
+def llgTot_calculate(sigmaA, E, Ec, centric_tensor):
+    # (1) Make a centric and acentric tensor
+    acentric_tensor = ~centric_tensor
+
+    # (2) Call respective llg targets with indexed data
+    llg_centric = llgC_calculate(sigmaA, E[centric_tensor], Ec[centric_tensor])
+    llg_acentric = llgA_calculate(sigmaA, E[acentric_tensor], Ec[acentric_tensor])
+
+    return llg_acentric + llg_centric
+
+
+def sigmaA_from_model(E_true, phi_true, E_model, Fcs, dHKL, bin_labels):
+    # TODO naming Etrue vs Eobs
+
+    phitrue_rad = np.deg2rad(phi_true)
+    phimodel = utils.assert_numpy(
+        structurefactors.ftotal_phis(Fcs, dHKL, sort_by_res=True)
+    )
+    phimodel_rad = np.deg2rad(phimodel)
+
+    sigmaAs = structurefactors.compute_sigmaA_true(
+        utils.assert_numpy(E_true),
+        phitrue_rad,
+        utils.assert_numpy(E_model),
+        phimodel_rad,
+        utils.assert_numpy(bin_labels),
+    )
+
+    return sigmaAs
+
+
+def compute_sigmaA_true(Eobs, phiobs, Ecalc, phicalc, bin_labels):
+    # TODO naming Etrue vs Eobs
+
+    # Combine the absolute values and phase difference into sigmaA_true
+    sigmaA_true = Eobs * Ecalc * np.cos(phiobs - phicalc)
+    data = np.stack((sigmaA_true, bin_labels), axis=1)
+
+    Sigma_trues = []
+    for label in np.unique(bin_labels):
+        F_in_bin = data[data[:, 1] == label][:, 0]
+        bin_mean = np.mean(F_in_bin)
+        Sigma_trues.append(bin_mean)
+
+    return Sigma_trues
+
+
+def find_bin_dHKL(dHKLs, bin_labels):
+    unique_bins = bin_labels.unique()
+
+    bin_dHKLs = []
+
+    for bin_label in unique_bins:
+        # Find indices corresponding to the current bin
+        bin_indices = torch.where(bin_labels == bin_label)[0]
+        # Extract distances for the current bin
+        bin_distances = dHKLs[bin_indices]
+        # Find the largest and lowest distances
+        max_distance = torch.max(bin_distances)
+        min_distance = torch.min(bin_distances)
+        # Calculate the halfway distance
+        halfway_distance = (max_distance + min_distance) / 2.0
+        # Add the halfway distance for each row in the current bin
+        bin_dHKLs.extend([halfway_distance.item()] * len(bin_indices))
+
+    return torch.tensor(bin_dHKLs)
+
+
+def load_tng_data(tng_file, device=None):
+    if device is None:
+        device = utils.try_gpu()
+    if isinstance(tng_file, str):
+        tng = utils.load_mtz(tng_file).dropna()
+    elif isinstance(tng_file, rs.DataSet):
+        tng = tng_file.dropna()
+    # Generate PhaserTNG tensors
+    eps = torch.tensor(tng[""EPS""].values, device=device)
+    centric = torch.tensor(tng[""CENT""].values, device=device).bool()
+    dobs = torch.tensor(tng[""DOBS""].values, device=device)
+    feff = torch.tensor(tng[""FEFF""].values, device=device)
+    bin_labels = torch.tensor(tng[""BIN""].values, device=device)
+    resn = torch.tensor(tng[""RESN""].values, device=device)
+    dHKLs = torch.tensor(tng[""dHKL""].values, device=device)
+    bin_dHKLs = find_bin_dHKL(dHKLs, bin_labels).to(device=device)
+
+    Edata = feff / resn
+
+    data_dict = {
+        ""EDATA"": Edata,
+        ""EPS"": eps,
+        ""CENTRIC"": centric,
+        ""DOBS"": dobs,
+        ""FEFF"": feff,
+        ""BIN_LABELS"": bin_labels,
+        ""BIN_dHKLS"": bin_dHKLs,
+    }
+
+    return data_dict
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/xtal/structurefactors.py",".py","3358","117","""""""
+Functions relating model structure factor manipulation and normalization
+""""""
+
+import numpy as np
+import SFC_Torch as SFC
+import torch
+from SFC_Torch import SFcalculator
+
+
+def initial_SFC(
+    pdb_file,
+    mtz_file,
+    Flabel,
+    SigFlabel,
+    Freelabel=None,
+    device=None,  # <--- default to None
+    testset_value=0,
+    n_bins=10,
+    solvent=True,
+    added_chain_HKL=None,
+    added_chain_asu=None,
+    total_chain_copy=1.0,
+    spacing=4.5,
+):
+    if device is None:
+        device = SFC.utils.try_gpu()  # <-- assign here
+
+    sfcalculator = SFcalculator(
+        pdb_file,
+        mtz_file,
+        expcolumns=[Flabel, SigFlabel],
+        freeflag=Freelabel,
+        set_experiment=True,
+        testset_value=testset_value,
+        device=device,
+        n_bins=n_bins,
+    )
+    sfcalculator.inspect_data(verbose=False, spacing=spacing)
+    sfcalculator.calc_fprotein()
+
+    if added_chain_HKL is not None:
+        sfcalculator.Fprotein_HKL = sfcalculator.Fprotein_HKL + added_chain_HKL
+        sfcalculator.Fprotein_asu = sfcalculator.Fprotein_asu + added_chain_asu
+        sfcalculator.solventpct = 1 - (1 - sfcalculator.solventpct) * total_chain_copy
+
+    if solvent:
+        sfcalculator.calc_fsolvent()
+    else:
+        sfcalculator.Fmask_HKL = torch.zeros_like(sfcalculator.Fprotein_HKL)
+    sfcalculator.get_scales_adam()
+    return sfcalculator
+
+
+def ftotal_amplitudes(Ftotal, dHKL, sort_by_res=True):
+    F_mag = torch.abs(Ftotal)
+
+    if sort_by_res:
+        dHKL_tensor = torch.from_numpy(dHKL)
+        sorted_indices = torch.argsort(dHKL_tensor, descending=True)
+        return F_mag[sorted_indices]
+
+    return F_mag
+
+
+def ftotal_phis(Fc, dHKL, sort_by_res=True):
+    PI_on_180 = 0.017453292519943295
+    Fc_phase = torch.angle(Fc) / PI_on_180
+    dHKL_tensor = torch.from_numpy(dHKL)
+    if sort_by_res:
+        sorted_indices = torch.argsort(dHKL_tensor, descending=True)
+        Fc_phase = Fc_phase[sorted_indices]
+    return Fc_phase
+
+
+def compute_sigmaA_true(Eobs, phiobs, Ecalc, phicalc, bin_labels):
+    # Combine the absolute values and phase difference into sigmaA_true
+    sigmaA_true = Eobs * Ecalc * np.cos(phiobs - phicalc)
+    data = np.stack((sigmaA_true, bin_labels), axis=1)
+
+    Sigma_trues = []
+    for label in np.unique(bin_labels):
+        F_in_bin = data[data[:, 1] == label][:, 0]
+        bin_mean = np.mean(F_in_bin)
+        Sigma_trues.append(bin_mean)
+
+    return Sigma_trues
+
+
+def calculate_Sigma_atoms(Fs, eps, bin_labels):
+    if Fs.numel() == 0 or eps.numel() == 0 or bin_labels.numel() == 0:
+        raise ValueError(""All input tensors must be non-empty."")
+    F_over_eps = Fs**2 / eps
+    data = torch.stack((F_over_eps, bin_labels), dim=1)
+
+    Sigma = []
+    for label in torch.unique(bin_labels):
+        F_in_bin = data[data[:, 1] == label][:, 0]
+        bin_mean = torch.mean(F_in_bin)
+        Sigma.append(bin_mean)
+
+    return torch.stack(Sigma)
+
+
+def normalize_Fs(Fs, eps, Sigma_atoms, bin_labels):
+    # e.g. Ecalc = Fc / (eps*SigmaP)**(-0.5)
+    data = torch.stack((Fs, eps, bin_labels), dim=1)
+
+    for label in torch.unique(bin_labels):
+        indices = data[:, 2] == label
+        data[indices, 0] = Fs[indices] / torch.sqrt(
+            eps[indices] * Sigma_atoms[label.item()].item()
+        )
+    assert round(torch.mean(data[:, 0] ** 2).item()) == 1
+
+    return data[:, 0]
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/cryo/targets.py",".py","7816","239","""""""
+LLG targets for cryoEM data
+""""""
+
+import numpy as np
+import reciprocalspaceship as rs
+import torch
+from SFC_Torch import SFcalculator
+
+from rocket import utils as rk_utils
+from rocket.cryo import utils as cryo_utils
+
+
+class LLGloss(torch.nn.Module):
+    """"""
+    Object_oriented interface to calculate LLG loss
+
+    # Initialization, only have to do it once
+    sfc = llg_sf.initial_SFC(...)
+    llgloss = LLGloss(sfc, tng_file, device)
+    Ecalc = llgloss.compute_Ecalc(xyz_orth)
+    TODO: sigmaA calculation/initialization
+
+    # Loss calculation for each step
+    loss = -llgloss(xyz_orth, bin_labels=[1,2,3], num_batch=10, sub_ratio=0.3)
+
+    resol_min, resol_max: None | float
+        resolution cutoff for the used miller index.
+        Will use resol_min <= dHKL <= resol_max
+
+    TODO:
+    Currently the initialization needs Eobs, Eps, Centric, Dobs, Feff, Bin_labels.
+    We load them through tng_data.
+    Later we should be able to calculate everything from SFcalculator,
+    all necesary information is ready there.
+
+    """"""
+
+    def __init__(
+        self,
+        sfc: SFcalculator,
+        mtz_file: str | rs.DataSet,
+        resol_min=None,
+        resol_max=None,
+    ) -> None:
+        super().__init__()
+        self.sfc = sfc
+        self.device = sfc.device
+        assert isinstance(mtz_file, str | rs.DataSet), (
+            ""mtz_file must be a path to mtz file or rs.DataSet""
+        )
+
+        data_dict = cryo_utils.load_tng_data(mtz_file, device=self.device)
+
+        self.register_buffer(""Emean"", data_dict[""Emean""])
+        self.register_buffer(""PHIEmean"", data_dict[""PHIEmean""])
+        self.register_buffer(""Dobs"", data_dict[""Dobs""])
+
+        if resol_min is None:
+            resol_min = min(self.sfc.dHKL)
+
+        if resol_max is None:
+            resol_max = max(self.sfc.dHKL)
+
+        resol_bool = (self.sfc.dHKL >= (resol_min - 1e-4)) & (
+            self.sfc.dHKL <= (resol_max + 1e-4)
+        )
+        self.working_set = resol_bool
+
+    def assign_sigmaAs_sfc(self, Ec_HKL):
+        """"""
+        This function is copied from SFC, compute sigmaA using corr(Eo, Ec)
+
+        # TODO: make sure the correlation works for complex number
+
+        Args:
+            Ec_HKL (torch.tensor) : [N_HKL]
+
+        Returns:
+            sigmaAs [N_bins]
+        """"""
+
+        Ecalc = Ec_HKL.abs().detach().clone()
+        sigmaAs = torch.zeros(self.sfc.n_bins, dtype=torch.float32, device=self.device)
+        for i in range(self.sfc.n_bins):
+            index_i = self.sfc.bins == i
+            Eobs_i = self.Emean[index_i].square()  # [N_subset]
+            Ecalc_i = Ecalc[index_i].square()  # [N_subset]
+            # Compute correlation coefficient
+            Eoi_centered = Eobs_i - Eobs_i.mean()
+            Eci_centered = Ecalc_i - torch.mean(Ecalc_i, dim=-1, keepdims=True)
+            Covi = (Eci_centered @ Eoi_centered) / (Eoi_centered.shape[0] - 1)
+            Eoi_std = torch.std(Eoi_centered, correction=0)
+            Eci_std = torch.std(Eci_centered, dim=-1, correction=0)
+            sigmaAs[i] = (Covi / (Eoi_std * Eci_std)).clamp(min=0.001, max=0.999).sqrt()
+        return sigmaAs
+
+    def assign_sigmaAs_read(self, Ec_HKL):
+        """"""
+        This function is copied from SFC, compute sigmaA using corr(Eo, Ec)
+
+        # TODO: make sure the correlation works for complex number
+
+        Args:
+            Ec_HKL (torch.tensor) : [N_HKL]
+
+        Returns:
+            sigmaAs [N_bins]
+        """"""
+
+        # Ecalc = Ec_HKL.abs().detach().clone()
+        Ecalc = Ec_HKL.detach().clone()
+
+        oversampling_factor = 4
+        Eobs_amp = self.Emean
+        Eobs_phi = self.PHIEmean
+
+        PI_on_180 = 0.017453292519943295
+        Ecalc_amp = torch.abs(Ecalc)
+        Ecalc_phi = torch.angle(Ecalc) / PI_on_180
+
+        sigmaAs = cryo_utils.sigmaA_from_model_in_map(
+            rk_utils.assert_numpy(Eobs_amp),
+            rk_utils.assert_numpy(Eobs_phi),
+            rk_utils.assert_numpy(self.Dobs),
+            rk_utils.assert_numpy(Ecalc_amp),
+            rk_utils.assert_numpy(Ecalc_phi),
+            self.sfc,
+            oversampling_factor,
+            self.sfc.dHKL,
+            plot=False,
+        )
+
+        return sigmaAs
+
+    def freeze_sigmaA(self):
+        self.sigmaAs = [sigmaA.requires_grad_(False) for sigmaA in self.sigmaAs]
+
+    def unfreeze_sigmaA(self):
+        self.sigmaAs = [sigmaA.requires_grad_(True) for sigmaA in self.sigmaAs]
+
+    def compute_Ecalc(
+        self,
+        xyz_orth,
+        update_scales=False,
+        scale_steps=10,
+        scale_initialize=False,
+    ) -> torch.Tensor:
+        self.sfc.calc_fprotein(atoms_position_tensor=xyz_orth)
+
+        if update_scales:
+            # We used Emean to override the Fo attribute in SFC,
+            # so the scales are optimized to match Ep and Emean
+            self.sfc.get_scales_adam(
+                lr=0.01,
+                n_steps=scale_steps,
+                sub_ratio=0.7,
+                initialize=scale_initialize,
+            )
+
+        # We have normalized the Ep above, and the scales are optimized to match Emean,
+        # so we what we got is already Ecalc
+        # Note @ Aug 26 by MH, do scaling first, then normalizationg
+        # Fc_HKL = self.sfc.calc_ftotal()
+        # replace with its normalized Ep
+        # Ec_HKL = self.sfc.calc_Ec(Fc_HKL)
+
+        ## testing
+        Ep = self.sfc.calc_Ec(self.sfc.Fprotein_HKL)
+        self.sfc.Fprotein_HKL = Ep
+        Fc_HKL = self.sfc.calc_ftotal()
+        Ec_HKL = self.sfc.calc_Ec(Fc_HKL)
+        self.sigmaAs = self.assign_sigmaAs_read(Ec_HKL)
+
+        return Ec_HKL
+
+    def forward(
+        self,
+        xyz_ort: torch.Tensor,
+        bin_labels=None,
+        num_batch=1,
+        sub_ratio=1.0,
+        update_scales=False,
+        solvent=False,
+        added_chain_HKL=None,
+        added_chain_asu=None,
+    ):
+        """"""
+        TODO: Use rfree label in the LLG calculation
+        Args:
+            xyz_orth: torch.Tensor, [N_atoms, 3] in angstroms
+                Orthogonal coordinates of proteins, coming from AF2 model, send to SFC
+
+            bin_labels: None or List[int]
+                Labels of bins used in the loss calculation.
+                If None, will use the whole miller indices.
+                Serve as a proxy for resolution selection
+
+            num_batch: int
+                Number of batches
+
+            sub_ratio: float between 0.0 and 1.0
+                Fraction of mini-batch sampling over all miller indices,
+                e.g. 0.3 meaning each batch sample 30% of miller indices
+
+        """"""
+
+        Ecalc = self.compute_Ecalc(
+            xyz_ort,
+            update_scales=update_scales,
+        )
+        llg = 0.0
+
+        if bin_labels is None:
+            bin_labels = self.sfc.n_bins
+
+        # for i, label in enumerate(bin_labels):
+        for i, label in enumerate(range(bin_labels)):
+            index_i = self.sfc.bins[self.working_set] == label
+            Ecalc_i = torch.abs(Ecalc[self.working_set][index_i])
+            Ecalc_phi_i = torch.angle(Ecalc[self.working_set][index_i])
+            Eob_i = self.Emean[self.working_set][index_i]
+            Eob_phi_i = self.PHIEmean[self.working_set][index_i] * (torch.pi / 180)
+            Dobs_i = self.Dobs[self.working_set][index_i]
+
+            sigmaA_i = self.sigmaAs[int(i)]
+            for _ in range(num_batch):
+                sub_boolean_mask = np.random.rand(len(Eob_i)) < sub_ratio
+                llg_ij = cryo_utils.llgcryo_calculate(
+                    Eob_i[sub_boolean_mask],
+                    Eob_phi_i[sub_boolean_mask],
+                    Ecalc_i[sub_boolean_mask],
+                    Ecalc_phi_i[sub_boolean_mask],
+                    sigmaA_i,
+                    Dobs_i[sub_boolean_mask],
+                ).sum()
+                llg = llg + llg_ij
+        return llg
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/cryo/__init__.py",".py","0","0","","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/cryo/utils.py",".py","7137","238","""""""
+Functions relating to sigmaa calculation and refinement for cryoEM
+""""""
+
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+import reciprocalspaceship as rs
+import torch
+
+from rocket import utils
+
+
+def downsample_data(mtz_path, downsample_ratio: int):
+    """"""
+    Downsample the data in an mtz file by a given ratio
+    """"""
+    df = rs.read_mtz(mtz_path)
+    # Get the h, k, l values
+    hkls = df.get_hkls()
+    # Create a boolean mask where all h, k, l values are divisible by the ratio
+    mask = (
+        (hkls[:, 0] % downsample_ratio == 0)
+        & (hkls[:, 1] % downsample_ratio == 0)
+        & (hkls[:, 2] % downsample_ratio == 0)
+    )
+    # Apply the mask to the DataFrame
+    downsampled_df = df[mask].copy()
+
+    return downsampled_df
+
+
+def load_tng_data(tng_file, device=None):
+    if device is None:
+        device = utils.try_gpu()
+    if isinstance(tng_file, str):
+        tng = utils.load_mtz(tng_file).dropna()
+    elif isinstance(tng_file, rs.DataSet):
+        tng = tng_file.dropna()
+
+    # Generate PhaserTNG tensors
+    emean = torch.tensor(tng[""Emean""].values, dtype=torch.float32, device=device)
+    phi_emean = torch.tensor(tng[""PHIEmean""].values, dtype=torch.float32, device=device)
+    dobs = torch.tensor(tng[""Dobs""].values, dtype=torch.float32, device=device)
+
+    data_dict = {
+        ""Emean"": emean,
+        ""PHIEmean"": phi_emean,
+        ""Dobs"": dobs,
+    }
+
+    return data_dict
+
+
+# sigmaA functions
+
+
+def compute_sigmaA_for_bin(eEsel, Ecalc_sel, dobssel, expectE_phi, Ecalc_phi):
+    abseE = np.abs(eEsel)
+    absEc = np.abs(Ecalc_sel)
+    p1 = np.radians(expectE_phi)
+    p2 = np.radians(Ecalc_phi)
+    cosdphi = np.cos(p2 - p1)
+
+    sum0 = np.sum(2.0 * dobssel * abseE * absEc * cosdphi)
+    sum1 = np.sum(2 * np.square(dobssel) * (1.0 - np.square(abseE) - np.square(absEc)))
+    sum2 = np.sum(2 * np.power(dobssel, 3) * abseE * absEc * cosdphi)
+    sum3 = np.sum(-2 * np.power(dobssel, 4))
+
+    u1 = -2 * sum2**3 + 9 * sum1 * sum2 * sum3 - 27 * sum0 * sum3**2
+    sqrt_arg = u1**2 - 4 * (sum2**2 - 3 * sum1 * sum3) ** 3
+
+    if sqrt_arg < 0:
+        raise ValueError(""Argument of square root in sigmaA calculation is negative"")
+
+    third = 1.0 / 3
+    x1 = (u1 + math.sqrt(sqrt_arg)) ** third
+    denominator = 6 * sum3 * x1
+    if denominator == 0:
+        raise ZeroDivisionError(""Division by zero in sigmaA calculation"")
+    sigmaA = (
+        2 * 2.0**third * sum2**2
+        - 6 * 2.0**third * sum1 * sum3
+        - 2 * sum2 * x1
+        + 2.0 ** (2 * third) * x1**2
+    ) / denominator
+
+    if not np.isfinite(sigmaA):
+        raise ValueError(""sigmaA is NaN or inf in sigmaA calculation"")
+
+    return max(min(sigmaA, 0.999), 1.0e-6)
+
+
+def compute_sigmaA_error(dobssel, sigmaA, abseE, absEc, cosdphi, over_sampling_factor):
+    denom = np.power((1 - np.square(dobssel) * sigmaA**2), 3)
+    sum0 = np.sum(
+        (2 * np.square(dobssel) * (1.0 - np.square(abseE) - np.square(absEc))) / denom
+    )
+    sum1 = np.sum((12 * np.power(dobssel, 3) * abseE * absEc * cosdphi) / denom)
+    sum2 = np.sum(
+        (-6 * np.power(dobssel, 4) * (np.square(abseE) + np.square(absEc))) / denom
+    )
+    sum3 = np.sum((4 * np.power(dobssel, 5) * abseE * absEc * cosdphi) / denom)
+    sum4 = np.sum((-2 * np.power(dobssel, 6)) / denom)
+    d2LLGbydsigmaA = (
+        sum0 + sum1 * sigmaA + sum2 * sigmaA**2 + sum3 * sigmaA**3 + sum4 * sigmaA**4
+    )
+    d2LLGbydsigmaA /= over_sampling_factor
+    return 1.0 / math.sqrt(abs(d2LLGbydsigmaA))
+
+
+def fit_line(xdat, ydat, wdat):
+    W = np.sum(wdat)
+    Wx = np.sum(wdat * xdat)
+    Wy = np.sum(wdat * ydat)
+    Wxx = np.sum(wdat * xdat * xdat)
+    Wxy = np.sum(wdat * xdat * ydat)
+    slope = (W * Wxy - Wx * Wy) / (W * Wxx - Wx * Wx)
+    intercept = (Wy * Wxx - Wx * Wxy) / (W * Wxx - Wx * Wx)
+    return slope, intercept
+
+
+def combine_sigmaA(slope, intercept, xdat, ydat, wdat, sigma_linlog):
+    linlogsiga = []
+    logsiga_combined = []
+
+    for i, x in enumerate(xdat):
+        linlog = min(math.log(0.999), (intercept + slope * x))
+        linlogsiga.append(linlog)
+        sigma_sigmaA = 1.0 / math.sqrt(wdat[i])
+        sigma_lnsigmaA = math.exp(-ydat[i]) * sigma_sigmaA
+        combined_logsiga = (ydat[i] / sigma_lnsigmaA**2 + linlog / sigma_linlog**2) / (
+            1.0 / sigma_lnsigmaA**2 + 1.0 / sigma_linlog**2
+        )
+        logsiga_combined.append(combined_logsiga)
+
+    return linlogsiga, logsiga_combined
+
+
+def sigmaA_from_model_in_map(
+    expectE_amp,
+    expectE_phi,
+    dobs,
+    Ecalc_amp,
+    Ecalc_phi,
+    sfc,
+    over_sampling_factor,
+    dhkl,
+    plot=False,
+):
+    n_bins = sfc.n_bins
+    model_sigmaA = np.zeros_like(expectE_amp, dtype=np.float32)
+    xdat = []
+    ydat = []
+    wdat = []
+
+    for i_bin in range(n_bins):
+        bin_mask = sfc.bins == i_bin
+        if not np.any(bin_mask):
+            continue
+
+        eEsel = expectE_amp[bin_mask]
+        Ecalc_sel = Ecalc_amp[bin_mask]
+        dobssel = dobs[bin_mask]
+        cosdphi = np.cos(
+            np.radians(Ecalc_phi[bin_mask]) - np.radians(expectE_phi[bin_mask])
+        )
+
+        sigmaA = compute_sigmaA_for_bin(
+            eEsel, Ecalc_sel, dobssel, expectE_phi[bin_mask], Ecalc_phi[bin_mask]
+        )
+        sigma_sigmaA = compute_sigmaA_error(
+            dobssel,
+            sigmaA,
+            np.abs(eEsel),
+            np.abs(Ecalc_sel),
+            cosdphi,
+            over_sampling_factor,
+        )
+
+        ssqr = np.mean(np.square(1 / dhkl[bin_mask]))
+        xdat.append(ssqr)
+        ydat.append(math.log(sigmaA))
+        wdat.append(abs(1.0 / sigma_sigmaA**2))
+
+    xdat = np.array(xdat)
+    ydat = np.array(ydat)
+    wdat = np.array(wdat)
+
+    slope, intercept = fit_line(xdat, ydat, wdat)
+
+    linlogsiga, logsiga_combined = combine_sigmaA(
+        slope, intercept, xdat, ydat, wdat, math.log(1.5)
+    )
+
+    i_bin_used = 0
+    for i_bin in range(n_bins):
+        bin_mask = sfc.bins == i_bin
+        if not np.any(bin_mask):
+            continue
+
+        combined_siga = math.exp(logsiga_combined[i_bin_used])
+        model_sigmaA[bin_mask] = combined_siga
+        i_bin_used += 1
+
+    if plot:
+        plot_sigmaA(xdat, ydat, linlogsiga, logsiga_combined)
+
+    return model_sigmaA
+
+
+def plot_sigmaA(xdat, ydat, linlogsiga, logsiga_combined):
+    fig, ax = plt.subplots(2, 1)
+    ax[0].plot(xdat, ydat, label=""ln(sigmaA)"")
+    ax[0].plot(xdat, linlogsiga, label=""line fit"")
+    ax[0].plot(xdat, logsiga_combined, label=""combined"")
+    ax[0].legend(loc=""upper right"")
+    ax[1].plot(xdat, np.exp(ydat), label=""sigmaA"")
+    ax[1].plot(xdat, np.exp(linlogsiga), label=""line fit"")
+    ax[1].plot(xdat, np.exp(logsiga_combined), label=""combined"")
+    ax[1].legend(loc=""lower left"")
+    plt.show()
+
+
+def llgcryo_calculate(E_amp, E_phi, Ec_amp, Ec_phi, sigmaA, dobs):
+    cos_phi_diff = torch.cos(Ec_phi - E_phi)
+    term1 = (
+        2 / (1 - dobs**2 * sigmaA**2) * dobs * sigmaA * E_amp * Ec_amp * cos_phi_diff
+    )
+
+    term2 = (dobs**2 * sigmaA**2 * (E_amp**2 + Ec_amp**2)) / (1 - dobs**2 * sigmaA**2)
+    term3 = torch.log(1 - dobs**2 * sigmaA**2)
+
+    llg_cryo = term1 - term2 - term3
+
+    return llg_cryo
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/cryo/structurefactors.py",".py","1620","57","from SFC_Torch import SFcalculator
+
+
+def initial_cryoSFC(
+    pdb_file,
+    mtz_file,
+    Elabel,
+    PHIElabel,
+    device,
+    n_bins=15,
+):
+    """"""
+    Initialize a SFC for docking target in cryoEM problem.
+    Note, we override the attribute .Fo to store Emean, to easily compute scales
+    Also no freeflag is needed for cryoEM cases
+    Args:
+        pdb_file  : path to initial dock model
+        mtz_file  : path to map.mtz file
+        Elabel    : column name for Emean
+        PHIElabel : column name for PHIEmean
+        device    : torch device
+        n_bins    : number of bins in the resolution binning
+    Return:
+        SFcalculator with attributes
+        .Fo is Emean from map.mtz
+        .bins is resolution binning label
+    """"""
+    # it will store Emean in attribute Fo
+    sfcalculator = SFcalculator(
+        pdb_file,
+        mtz_file,
+        expcolumns=[Elabel, PHIElabel],
+        freeflag=""None"",
+        set_experiment=True,
+        testset_value=0,
+        device=device,
+        n_bins=n_bins,
+        mode=""cryoem"",
+    )
+
+    # SigF is actually PHIEmean, don't need it here
+    sfcalculator.SigF = None
+
+    # calculate fprotein from default pdb file, no solvent is needed
+    sfcalculator.calc_fprotein()
+
+    Ep = sfcalculator.calc_Ec(sfcalculator.Fprotein_HKL)
+    sfcalculator.Fprotein_HKL = Ep
+
+    # normalize the Fp, use it to replace the Fp, initialize scales
+    # note @ Aug 27 by MH: treat Emean as Fmean
+    # Ep = sfcalculator.calc_Ec(sfcalculator.Fprotein_HKL)
+    # sfcalculator.Fprotein_HKL = Ep
+    sfcalculator.get_scales_adam(sub_ratio=1.0)
+
+    return sfcalculator
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/run_preprocess.py",".py","17217","487","import argparse
+import glob
+import os
+import shutil
+import subprocess
+
+from loguru import logger
+from SFC_Torch import PDBParser
+
+from ..refinement_config import gen_config_phase1, gen_config_phase2
+from ..utils import plddt2pseudoB_np
+
+### Phenix variables
+phenix_directory = os.environ[""PHENIX_ROOT""]
+phenix_source = os.path.join(phenix_directory, ""phenix_env.sh"")
+
+
+def get_script_path(import_stmt: str) -> str:
+    """"""Source Phenix and run phenix.python to get script path.""""""
+    module_name = import_stmt.split(""import"")[-1].strip()
+    python_code = f""{import_stmt}; print({module_name}.__file__)""
+
+    bash_cmd = f'source {phenix_source} && phenix.python -c ""{python_code}""'
+
+    try:
+        result = subprocess.run(
+            [""bash"", ""-c"", bash_cmd], check=True, capture_output=True, text=True
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        print(f""Error resolving script path for '{import_stmt}':\n{e.stderr}"")
+        return None
+
+
+# Phenix scripts paths
+em_nodockedmodel_script = get_script_path(
+    ""from New_Voyager.scripts import emplace_simple""
+)
+em_dockedmodel_script = get_script_path(
+    ""from cctbx.maptbx import prepare_map_for_refinement""
+)
+xtal_edata_script = get_script_path(""from phasertng.scripts import mtz_generator"")
+
+
+def run_command(command, env_source=None):
+    """"""Runs a shell command with optional Phenix environment sourcing.""""""
+    cmd_str = (
+        f""bash -c 'source {env_source} && {' '.join(command)}'""
+        if env_source
+        else "" "".join(command)
+    )
+
+    logger.info(f""Executing: {cmd_str}"")
+
+    subprocess.run(cmd_str, shell=True, check=True, executable=""/bin/bash"")
+
+
+def run_openfold(
+    file_id,
+    output_dir,
+    precomputed_alignment_dir,
+    jax_param_path,
+    max_recycling_iters,
+    use_deepspeed_evoformer_attention,
+):
+    """"""Runs OpenFold inference using the specified parameters.""""""
+    fasta_dir = f""{file_id}_fasta""
+    predicted_model = os.path.join(
+        output_dir, ""predictions"", f""{file_id}_model_1_ptm_unrelaxed.pdb""
+    )
+
+    if os.path.exists(predicted_model):
+        logger.info(f""Skipping OpenFold: output {predicted_model} already exists."")
+        return predicted_model
+
+    openfold_cmd = [
+        ""rk.predict"",
+        fasta_dir,
+        ""--output_dir"",
+        f""{output_dir}"",
+        ""--config_preset"",
+        ""model_1_ptm"",
+        ""--model_device"",
+        ""cuda:0"",
+        ""--save_output"",
+        ""--data_random_seed"",
+        ""42"",
+        ""--skip_relaxation"",
+        ""--max_recycling_iters"",
+        f""{max_recycling_iters}"",
+        ""--use_precomputed_alignments"",
+        f""{precomputed_alignment_dir}"",
+    ]
+    if use_deepspeed_evoformer_attention:
+        openfold_cmd.extend([""--use_deepspeed_evoformer_attention""])
+
+    if jax_param_path:
+        openfold_cmd.extend([""--jax_params_path"", jax_param_path])
+
+    run_command(openfold_cmd)
+
+    if not os.path.exists(predicted_model):
+        raise FileNotFoundError(f""Expected output model {predicted_model} not found."")
+
+    return predicted_model
+
+
+def generate_seg_id_file(file_id, output_dir):
+    """"""Generates seg_id.txt using chain changes and >20-residue continuous stretches.
+    Skips first seg_id, outputs None if only one domain.""""""
+    seg_id_path = os.path.join(output_dir, ""ROCKET_inputs"", ""seg_id.txt"")
+    aligned_pdb_path = os.path.join(output_dir, ""ROCKET_inputs"", f""{file_id}-MRed.pdb"")
+
+    if not os.path.exists(aligned_pdb_path):
+        raise FileNotFoundError(f""Aligned PDB file not found at {aligned_pdb_path}"")
+
+    # Collect residues per chain in order of appearance
+    chain_residues = {}
+    chain_order = []
+    with open(aligned_pdb_path) as f:
+        for line in f:
+            if line.startswith(""ATOM""):
+                try:
+                    chain_id = line[21].strip()
+                    res_num = int(line[22:26].strip())
+                    if chain_id not in chain_residues:
+                        chain_residues[chain_id] = set()
+                        chain_order.append(chain_id)
+                    chain_residues[chain_id].add(res_num)
+                except ValueError:
+                    continue
+
+    domain_ranges = []
+    seg_start_residues = []
+    previous_chain = None
+
+    for chain_id in chain_order:
+        if chain_id == previous_chain:
+            continue  # Only one domain per unique chain
+
+        residues = sorted(chain_residues[chain_id])
+        if not residues:
+            continue
+
+        # Find first continuous stretch >20
+        current_stretch = [residues[0]]
+        for i in range(1, len(residues)):
+            if residues[i] == residues[i - 1] + 1:
+                current_stretch.append(residues[i])
+            else:
+                if len(current_stretch) > 20:
+                    domain_ranges.append((current_stretch[0], current_stretch[-1]))
+                    seg_start_residues.append(current_stretch[0])
+                    break
+                current_stretch = [residues[i]]
+
+        # Handle final stretch
+        if len(current_stretch) > 20 and (
+            not domain_ranges
+            or domain_ranges[-1] != (current_stretch[0], current_stretch[-1])
+        ):
+            domain_ranges.append((current_stretch[0], current_stretch[-1]))
+            seg_start_residues.append(current_stretch[0])
+
+        previous_chain = chain_id
+
+    # Write seg_id.txt
+    with open(seg_id_path, ""w"") as out_f:
+        for i, (start, end) in enumerate(domain_ranges, 1):
+            out_f.write(f""domain{i}: {start}-{end}\n"")
+
+        if len(seg_start_residues) > 1:
+            seg_ids = "","".join(str(r) for r in seg_start_residues[1:])  # Skip first
+            out_f.write(f'seg_id: ""{seg_ids}""\n')
+            logger.info(f""Segment ID file written to {seg_id_path}"")
+            return seg_start_residues[1:]
+        else:
+            out_f.write(""seg_id: None\n"")
+            logger.info(""No segment, only one domain found."")
+            return None
+
+
+def run_process_predicted_model(file_id, input_dir, predicted_model):
+    """"""Processes the predicted model using Phenix.""""""
+    logger.info(""Looking for"", predicted_model)
+
+    process_cmd = [
+        ""phenix.process_predicted_model"",
+        ""output_files.mark_atoms_to_keep_with_occ_one=True"",
+        f""{predicted_model}"",
+        ""minimum_domain_length=20"",
+        ""b_value_field_is=plddt"",
+        ""minimum_sequential_residues=10"",
+        f""pae_file={os.path.join(input_dir, f'{file_id}_pae.json')}"",
+        ""pae_power=2"",
+        ""pae_cutoff=4"",
+        ""pae_graph_resolution=0.5"",
+    ]
+
+    run_command(process_cmd, env_source=phenix_source)
+
+
+def move_processed_predicted_files(output_dir):
+    """"""Moves processed files into a 'processed_predicted_files' directory.""""""
+    processed_dir = os.path.join(output_dir, ""processed_predicted_files"")
+    os.makedirs(processed_dir, exist_ok=True)
+
+    processed_files = glob.glob(""*processed*"") + glob.glob(""*.seq"")
+
+    if not processed_files:
+        logger.info(""No processed files found to move."")
+        return
+
+    for file_path in processed_files:
+        if os.path.isfile(file_path):
+            shutil.move(
+                file_path, os.path.join(processed_dir, os.path.basename(file_path))
+            )
+
+
+def dock_into_data(
+    file_id,
+    method,
+    resolution,
+    output_dir,
+    predicted_model,
+    predocked_model,
+    map1,
+    map2,
+    fixed_model=None,
+    fasta_composition=None,
+):
+    """"""Handles molecular docking for Xray or CryoEM data.""""""
+    docking_output_dir = os.path.join(output_dir, ""docking_outputs"")
+    os.makedirs(docking_output_dir, exist_ok=True)
+
+    if method == ""xray"":
+        mtz_files = glob.glob(os.path.join(f""{file_id}_data"", ""*.mtz""))
+
+        for mtz_file in mtz_files:
+            if os.path.isfile(mtz_file):
+                shutil.copy2(
+                    mtz_file,
+                    os.path.join(
+                        output_dir,
+                        ""processed_predicted_files"",
+                        os.path.basename(mtz_file),
+                    ),
+                )
+
+                # Always run Edata generation
+                edata_cmd = [""phenix.python"", xtal_edata_script, ""-i"", mtz_file]
+                run_command(edata_cmd, env_source=phenix_source)
+
+        # If predocked_model is provided, skip MR and copy the model directly
+        if predocked_model:
+            print(""Predocked model provided for Xray: skipping MR step."")
+            rocket_dir = os.path.join(output_dir, ""ROCKET_inputs"")
+            os.makedirs(rocket_dir, exist_ok=True)
+
+            aligned_pdb_path = os.path.join(rocket_dir, f""{file_id}-MRed.pdb"")
+            shutil.copy2(predocked_model, aligned_pdb_path)
+        else:
+            # Proceed with MR step
+            mr_cmd = [
+                ""phasertng.picard"",
+                f""directory={os.path.join(output_dir, 'processed_predicted_files')}"",
+                f""database={os.path.join(output_dir, 'phaser_files')}"",
+            ]
+            run_command(mr_cmd, env_source=phenix_source)
+
+    elif method == ""cryoem"":
+        docking_script = (
+            em_dockedmodel_script if predocked_model else em_nodockedmodel_script
+        )
+        docking_cmd = [""phenix.python"", docking_script]
+
+        if predocked_model:
+            docking_cmd += [map1, map2, predocked_model, resolution]
+            if fixed_model:
+                docking_cmd.append(f""--fixed_model={fixed_model}"")
+        else:
+            docking_cmd += [
+                f""--d_min={resolution}"",
+                f""--output_folder={docking_output_dir}"",
+                f""--model_file={predicted_model}"",
+                f""--map1={map1}"",
+                f""--map2={map2}"",
+                f""--sequence_composition={fasta_composition}"",
+                ""--level=logfile"",
+            ]
+            if fixed_model:
+                docking_cmd.append(f""--fixed_model={fixed_model}"")
+
+        run_command(docking_cmd, env_source=phenix_source)
+
+        if predocked_model:
+            for file in [""weighted_map_data.mtz"", ""likelihood_weighted.map""]:
+                src_path = os.path.join(""."", file)
+                dest_path = os.path.join(docking_output_dir, file)
+                if os.path.exists(src_path):
+                    shutil.move(src_path, dest_path)
+
+            # Move the predocked model
+            model_filename = os.path.basename(predocked_model)
+            model_dest_path = os.path.join(docking_output_dir, model_filename)
+            if os.path.exists(predocked_model):
+                shutil.copy(predocked_model, model_dest_path)
+
+
+def prepare_rk_inputs(file_id, output_dir, method):
+    """"""Creates ROCKET_inputs directory and moves necessary files.""""""
+    rocket_dir = os.path.join(output_dir, ""ROCKET_inputs"")
+    os.makedirs(rocket_dir, exist_ok=True)
+
+    if method == ""xray"":
+        best_pdb_src = os.path.join(
+            output_dir, ""phaser_files"", ""best.1.coordinates.pdb""
+        )
+        mtz_files = glob.glob(""./*feff/*.data.mtz"")
+    elif method == ""cryoem"":
+        best_pdb_src = next(
+            iter(glob.glob(os.path.join(output_dir, ""docking_outputs"", ""*.pdb""))), None
+        )
+        mtz_files = glob.glob(f""{output_dir}/docking_outputs/weighted_map_data.mtz"")
+    else:
+        raise ValueError(""Invalid method. Choose either 'xray' or 'cryoem'."")
+
+    best_pdb_dst = os.path.join(rocket_dir, f""{file_id}-MRed.pdb"")
+    if best_pdb_src and os.path.exists(best_pdb_src):
+        shutil.copy2(best_pdb_src, best_pdb_dst)
+
+    for mtz_src in mtz_files:
+        mtz_dst = os.path.join(rocket_dir, f""{file_id}-Edata.mtz"")
+        shutil.copy2(mtz_src, mtz_dst)
+
+
+def prepare_pred_aligned(output_dir, file_id):
+    mr_model_path = os.path.join(output_dir, ""ROCKET_inputs"", f""{file_id}-MRed.pdb"")
+    assert os.path.exists(mr_model_path), f""MR model not found: {mr_model_path}""
+    pred_model_path = os.path.join(
+        output_dir, ""predictions"", f""{file_id}_model_1_ptm_unrelaxed.pdb""
+    )
+    assert os.path.exists(pred_model_path), (
+        f""Predicted model not found: {pred_model_path}""
+    )
+    superpose_command = [
+        ""phenix.superpose_pdbs"",
+        f""{mr_model_path}"",
+        f""{pred_model_path}"",
+        f""output.file_name={os.path.join(output_dir, 'ROCKET_inputs', f'{file_id}-pred-aligned_unprocessed.pdb')}"",  # noqa: E501
+    ]
+    run_command(superpose_command, env_source=phenix_source)
+    aligned_model_path = os.path.join(
+        output_dir, ""ROCKET_inputs"", f""{file_id}-pred-aligned_unprocessed.pdb""
+    )
+    assert os.path.exists(aligned_model_path), (
+        f""Failed to superpose models: {aligned_model_path}""
+    )
+
+    mr_model = PDBParser(mr_model_path)
+    align_model = PDBParser(aligned_model_path)
+    align_model.set_spacegroup(mr_model.spacegroup)
+    align_model.set_unitcell(mr_model.cell)
+    align_model.set_biso(plddt2pseudoB_np(align_model.atom_b_iso))
+    align_model.savePDB(
+        os.path.join(output_dir, ""ROCKET_inputs"", f""{file_id}-pred-aligned.pdb"")
+    )
+
+
+def symlink_input_files(file_id, output_dir, precomputed_alignment_dir):
+    """"""Symlinks the sequence FASTA and alignment directory to the output folder.""""""
+    fasta_src = os.path.join(f""{file_id}_fasta"", f""{file_id}.fasta"")
+    fasta_dst = os.path.join(output_dir, f""{file_id}.fasta"")
+    if os.path.exists(fasta_src):
+        if not os.path.exists(fasta_dst):
+            os.symlink(os.path.abspath(fasta_src), fasta_dst)
+    else:
+        raise FileNotFoundError(f""FASTA file not found: {fasta_src}"")
+
+    alignments_dst = os.path.join(output_dir, ""alignments"")
+    if not os.path.exists(alignments_dst):
+        os.symlink(
+            os.path.join(os.path.abspath(precomputed_alignment_dir), file_id),
+            alignments_dst,
+        )
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=""Run OpenFold inference and dock into data""
+    )
+
+    parser.add_argument(""--file_id"", required=True)
+    parser.add_argument(""--method"", choices=[""xray"", ""cryoem""], required=True)
+    parser.add_argument(""--resolution"", default=None)
+    parser.add_argument(""--output_dir"", default=""preprocessing_output"")
+    parser.add_argument(""--precomputed_alignment_dir"", default=""alignments/"")
+    parser.add_argument(""--max_recycling_iters"", type=int, default=4)
+    parser.add_argument(
+        ""--use_deepspeed_evoformer_attention"",
+        action=""store_true"",
+        default=False,
+        help=""Whether to use the DeepSpeed evoformer attention layer. ""
+        ""Must have deepspeed installed in the environment."",
+    )
+    parser.add_argument(""--jax_params_path"", default=None)
+    parser.add_argument(""--predocked_model"", default=None)
+    parser.add_argument(""--fixed_model"", default=None)
+    parser.add_argument(""--map1"", default=None)
+    parser.add_argument(""--map2"", default=None)
+    parser.add_argument(""--full_composition"", default=None)
+
+    args = parser.parse_args()
+
+    if args.method == ""cryoem"":
+        missing = [
+            arg for arg in [""map1"", ""map2"", ""resolution""] if getattr(args, arg) is None
+        ]
+        if missing:
+            parser.error(
+                f""The following arguments are required for 'cryoem' method: {', '.join(missing)}""  # noqa: E501
+            )
+
+        # Require full_composition only if predocked_model is not provided
+        if not args.predocked_model and args.full_composition is None:
+            parser.error(
+                ""--full_composition is required for cryoem when --predocked_model is not provided.""  # noqa: E501
+            )
+
+    return args
+
+
+def cli_runpreprocess():
+    args = parse_args()
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    symlink_input_files(args.file_id, args.output_dir, args.precomputed_alignment_dir)
+
+    predicted_model = run_openfold(
+        args.file_id,
+        args.output_dir,
+        args.precomputed_alignment_dir,
+        args.jax_params_path,
+        args.max_recycling_iters,
+        args.use_deepspeed_evoformer_attention,
+    )
+    run_process_predicted_model(args.file_id, args.output_dir, predicted_model)
+    move_processed_predicted_files(args.output_dir)
+
+    dock_into_data(
+        args.file_id,
+        args.method,
+        args.resolution,
+        args.output_dir,
+        predicted_model,
+        args.predocked_model,
+        args.map1,
+        args.map2,
+        args.fixed_model,
+        args.full_composition,
+    )
+    prepare_rk_inputs(args.file_id, args.output_dir, args.method)
+    prepare_pred_aligned(args.output_dir, args.file_id)
+    seg_id = generate_seg_id_file(args.file_id, args.output_dir)
+
+    # Generate ROCKET configuration yaml files
+    phase1_config = gen_config_phase1(
+        datamode=args.method,
+        file_id=args.file_id,
+        working_dir=os.path.abspath(args.output_dir),
+    )
+    phase1_config.algorithm.init_recycling = args.max_recycling_iters
+    if seg_id:
+        phase1_config.algorithm.domain_segs = seg_id
+    phase1_config.to_yaml_file(
+        os.path.join(args.output_dir, ""ROCKET_config_phase1.yaml"")
+    )
+    phase2_config = gen_config_phase2(phase1_config)
+    phase2_config.to_yaml_file(
+        os.path.join(args.output_dir, ""ROCKET_config_phase2.yaml"")
+    )
+
+
+if __name__ == ""__main__"":
+    cli_runpreprocess()
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/__init__.py",".py","0","0","","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/run_pretrained_openfold.py",".py","20177","564","# Modified by Minhuan Li, for ROCKET, 2025
+# Remove the requirement template, remove single seq mode, read resources from
+# the system environment variables
+
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import argparse
+import json
+import logging
+import math
+import os
+import pickle
+import random
+import time
+
+import numpy as np
+import torch
+from openfold.config import model_config
+from openfold.data import data_pipeline, feature_pipeline, templates
+from openfold.data.tools import hhsearch, hmmsearch
+from openfold.np import protein
+from openfold.utils.script_utils import (
+    load_models_from_command_line,
+    parse_fasta,
+    prep_output,
+    relax_protein,
+    run_model,
+)
+from openfold.utils.tensor_utils import tensor_tree_map
+from openfold.utils.trace_utils import (
+    pad_feature_dict_seq,
+    trace_model_,
+)
+
+# from scripts.precompute_embeddings import EmbeddingGenerator
+from ..utils import get_params_path
+
+logging.basicConfig()
+logger = logging.getLogger(__file__)
+logger.setLevel(level=logging.INFO)
+
+torch_versions = torch.__version__.split(""."")
+torch_major_version = int(torch_versions[0])
+torch_minor_version = int(torch_versions[1])
+if torch_major_version > 1 or (torch_major_version == 1 and torch_minor_version >= 12):
+    # Gives a large speedup on Ampere-class GPUs
+    torch.set_float32_matmul_precision(""high"")
+
+torch.set_grad_enabled(False)
+
+
+TRACING_INTERVAL = 50
+
+
+def precompute_alignments(tags, seqs, alignment_dir, args):
+    for tag, seq in zip(tags, seqs, strict=False):
+        tmp_fasta_path = os.path.join(args.output_dir, f""tmp_{os.getpid()}.fasta"")
+        with open(tmp_fasta_path, ""w"") as fp:
+            fp.write(f"">{tag}\n{seq}"")
+
+        local_alignment_dir = os.path.join(alignment_dir, tag)
+
+        if args.use_precomputed_alignments is None:
+            logger.info(f""Generating alignments for {tag}..."")
+
+            os.makedirs(local_alignment_dir, exist_ok=True)
+
+            if ""multimer"" in args.config_preset:
+                template_searcher = hmmsearch.Hmmsearch(
+                    binary_path=args.hmmsearch_binary_path,
+                    hmmbuild_binary_path=args.hmmbuild_binary_path,
+                    database_path=args.pdb_seqres_database_path,
+                )
+            else:
+                template_searcher = hhsearch.HHSearch(
+                    binary_path=args.hhsearch_binary_path,
+                    databases=[args.pdb70_database_path],
+                )
+
+            # In seqemb mode, use AlignmentRunner only to generate templates
+            if args.use_single_seq_mode:
+                # alignment_runner = data_pipeline.AlignmentRunner(
+                #     jackhmmer_binary_path=args.jackhmmer_binary_path,
+                #     uniref90_database_path=args.uniref90_database_path,
+                #     template_searcher=template_searcher,
+                #     no_cpus=args.cpus,
+                # )
+                # embedding_generator = EmbeddingGenerator()
+                # embedding_generator.run(tmp_fasta_path, alignment_dir)
+                # MH edit @ Mar 24 2025, remove the single seq mode for ROCKET
+                raise NotImplementedError(
+                    ""Single Seq Mode not supported for ROCKET use""
+                )
+            else:
+                alignment_runner = data_pipeline.AlignmentRunner(
+                    jackhmmer_binary_path=args.jackhmmer_binary_path,
+                    hhblits_binary_path=args.hhblits_binary_path,
+                    uniref90_database_path=args.uniref90_database_path,
+                    mgnify_database_path=args.mgnify_database_path,
+                    bfd_database_path=args.bfd_database_path,
+                    uniref30_database_path=args.uniref30_database_path,
+                    uniclust30_database_path=args.uniclust30_database_path,
+                    uniprot_database_path=args.uniprot_database_path,
+                    template_searcher=template_searcher,
+                    use_small_bfd=args.bfd_database_path is None,
+                    no_cpus=args.cpus,
+                )
+
+            alignment_runner.run(tmp_fasta_path, local_alignment_dir)
+        else:
+            logger.info(f""Using precomputed alignments for {tag} at {alignment_dir}..."")
+
+        # Remove temporary FASTA file
+        os.remove(tmp_fasta_path)
+
+
+def round_up_seqlen(seqlen):
+    return int(math.ceil(seqlen / TRACING_INTERVAL)) * TRACING_INTERVAL
+
+
+def generate_feature_dict(
+    tags,
+    seqs,
+    alignment_dir,
+    data_processor,
+    args,
+):
+    tmp_fasta_path = os.path.join(args.output_dir, f""tmp_{os.getpid()}.fasta"")
+
+    if ""multimer"" in args.config_preset:
+        with open(tmp_fasta_path, ""w"") as fp:
+            fp.write(
+                ""\n"".join([
+                    f"">{tag}\n{seq}"" for tag, seq in zip(tags, seqs, strict=False)
+                ])
+            )
+        feature_dict = data_processor.process_fasta(
+            fasta_path=tmp_fasta_path,
+            alignment_dir=alignment_dir,
+        )
+    elif len(seqs) == 1:
+        tag = tags[0]
+        seq = seqs[0]
+        with open(tmp_fasta_path, ""w"") as fp:
+            fp.write(f"">{tag}\n{seq}"")
+
+        local_alignment_dir = os.path.join(alignment_dir, tag)
+        feature_dict = data_processor.process_fasta(
+            fasta_path=tmp_fasta_path,
+            alignment_dir=local_alignment_dir,
+            seqemb_mode=args.use_single_seq_mode,
+        )
+    else:
+        with open(tmp_fasta_path, ""w"") as fp:
+            fp.write(
+                ""\n"".join([
+                    f"">{tag}\n{seq}"" for tag, seq in zip(tags, seqs, strict=False)
+                ])
+            )
+        feature_dict = data_processor.process_multiseq_fasta(
+            fasta_path=tmp_fasta_path,
+            super_alignment_dir=alignment_dir,
+        )
+
+    # Remove temporary FASTA file
+    os.remove(tmp_fasta_path)
+
+    return feature_dict
+
+
+def list_files_with_extensions(dir, extensions):
+    return [f for f in os.listdir(dir) if f.endswith(extensions)]
+
+
+def main(args):
+    # Create the output directory
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    if args.config_preset.startswith(""seq""):
+        args.use_single_seq_mode = True
+
+    config = model_config(
+        args.config_preset,
+        long_sequence_inference=args.long_sequence_inference,
+        use_deepspeed_evoformer_attention=args.use_deepspeed_evoformer_attention,
+    )
+
+    # MH @ Jun 21, 2024, support customized n_recycling for initial prediction
+    config.data.common.max_recycling_iters = args.max_recycling_iters
+
+    if args.experiment_config_json:
+        with open(args.experiment_config_json) as f:
+            custom_config_dict = json.load(f)
+        config.update_from_flattened_dict(custom_config_dict)
+
+    if args.experiment_config_json:
+        with open(args.experiment_config_json) as f:
+            custom_config_dict = json.load(f)
+        config.update_from_flattened_dict(custom_config_dict)
+
+    if args.trace_model and not config.data.predict.fixed_size:
+        raise ValueError(
+            ""Tracing requires that fixed_size mode be enabled in the config""
+        )
+
+    is_multimer = ""multimer"" in args.config_preset
+
+    # MH @ Jun 21, 2024. Support case where no template mmcif
+    if args.template_mmcif_dir is None:
+        template_featurizer = None
+    else:
+        if is_multimer:
+            template_featurizer = templates.HmmsearchHitFeaturizer(
+                mmcif_dir=args.template_mmcif_dir,
+                max_template_date=args.max_template_date,
+                max_hits=config.data.predict.max_templates,
+                kalign_binary_path=args.kalign_binary_path,
+                release_dates_path=args.release_dates_path,
+                obsolete_pdbs_path=args.obsolete_pdbs_path,
+            )
+        else:
+            template_featurizer = templates.HhsearchHitFeaturizer(
+                mmcif_dir=args.template_mmcif_dir,
+                max_template_date=args.max_template_date,
+                max_hits=config.data.predict.max_templates,
+                kalign_binary_path=args.kalign_binary_path,
+                release_dates_path=args.release_dates_path,
+                obsolete_pdbs_path=args.obsolete_pdbs_path,
+            )
+
+    data_processor = data_pipeline.DataPipeline(
+        template_featurizer=template_featurizer,
+    )
+
+    if is_multimer:
+        data_processor = data_pipeline.DataPipelineMultimer(
+            monomer_data_pipeline=data_processor,
+        )
+
+    output_dir_base = args.output_dir
+    random_seed = args.data_random_seed
+    if random_seed is None:
+        random_seed = random.randrange(2**32)
+
+    np.random.seed(random_seed)
+    torch.manual_seed(random_seed + 1)
+
+    feature_processor = feature_pipeline.FeaturePipeline(config.data)
+    if not os.path.exists(output_dir_base):
+        os.makedirs(output_dir_base)
+    if args.use_precomputed_alignments is None:
+        alignment_dir = os.path.join(output_dir_base, ""alignments"")
+    else:
+        alignment_dir = args.use_precomputed_alignments
+
+    tag_list = []
+    seq_list = []
+    for fasta_file in list_files_with_extensions(args.fasta_dir, ("".fasta"", "".fa"")):
+        # Gather input sequences
+        fasta_path = os.path.join(args.fasta_dir, fasta_file)
+        with open(fasta_path) as fp:
+            data = fp.read()
+
+        tags, seqs = parse_fasta(data)
+
+        if not is_multimer and len(tags) != 1:
+            print(
+                f""{fasta_path} contains more than one sequence but ""
+                f""multimer mode is not enabled. Skipping...""
+            )
+            continue
+
+        # assert len(tags) == len(set(tags)), ""All FASTA tags must be unique""
+        tag = ""-"".join(tags)
+
+        tag_list.append((tag, tags))
+        seq_list.append(seqs)
+
+    seq_sort_fn = lambda target: sum([len(s) for s in target[1]])  # noqa: E731
+    sorted_targets = sorted(zip(tag_list, seq_list, strict=False), key=seq_sort_fn)
+    feature_dicts = {}
+    model_generator = load_models_from_command_line(
+        config,
+        args.model_device,
+        args.openfold_checkpoint_path,
+        args.jax_param_path,
+        args.output_dir,
+    )
+
+    for model, output_directory in model_generator:
+        cur_tracing_interval = 0
+        for (tag, tags), seqs in sorted_targets:
+            output_name = f""{tag}_{args.config_preset}""
+            if args.output_postfix is not None:
+                output_name = f""{output_name}_{args.output_postfix}""
+
+            # Does nothing if the alignments have already been computed
+            precompute_alignments(tags, seqs, alignment_dir, args)
+
+            feature_dict = feature_dicts.get(tag)
+            if feature_dict is None:
+                feature_dict = generate_feature_dict(
+                    tags,
+                    seqs,
+                    alignment_dir,
+                    data_processor,
+                    args,
+                )
+
+                if args.trace_model:
+                    n = feature_dict[""aatype""].shape[-2]
+                    rounded_seqlen = round_up_seqlen(n)
+                    feature_dict = pad_feature_dict_seq(
+                        feature_dict,
+                        rounded_seqlen,
+                    )
+
+                feature_dicts[tag] = feature_dict
+
+            processed_feature_dict = feature_processor.process_features(
+                feature_dict, mode=""predict"", is_multimer=is_multimer
+            )
+
+            processed_feature_dict = {
+                k: torch.as_tensor(v, device=args.model_device)
+                for k, v in processed_feature_dict.items()
+            }
+
+            if args.trace_model and rounded_seqlen > cur_tracing_interval:
+                logger.info(f""Tracing model at {rounded_seqlen} residues..."")
+                t = time.perf_counter()
+                trace_model_(model, processed_feature_dict)
+                tracing_time = time.perf_counter() - t
+                logger.info(f""Tracing time: {tracing_time}"")
+                cur_tracing_interval = rounded_seqlen
+
+            out = run_model(model, processed_feature_dict, tag, args.output_dir)
+
+            # MH @ Jun 21, 2024, save out the processed feature dict
+            with open(
+                f""{output_directory}/{output_name}_processed_feats.pickle"", ""wb""
+            ) as file:
+                from rocket import utils as rk_utils
+
+                device_processed_features = rk_utils.move_tensors_to_device(
+                    processed_feature_dict, device=""cpu""
+                )
+                pickle.dump(device_processed_features, file)
+
+            # Toss out the recycling dimensions --- we don't need them anymore
+            processed_feature_dict = tensor_tree_map(
+                lambda x: np.array(x[..., -1].cpu()), processed_feature_dict
+            )
+            out = tensor_tree_map(lambda x: np.array(x.cpu()), out)
+
+            unrelaxed_protein = prep_output(
+                out,
+                processed_feature_dict,
+                feature_dict,
+                feature_processor,
+                args.config_preset,
+                args.multimer_ri_gap,
+                args.subtract_plddt,
+            )
+
+            unrelaxed_file_suffix = ""_unrelaxed.pdb""
+            if args.cif_output:
+                unrelaxed_file_suffix = ""_unrelaxed.cif""
+            unrelaxed_output_path = os.path.join(
+                output_directory, f""{output_name}{unrelaxed_file_suffix}""
+            )
+
+            with open(unrelaxed_output_path, ""w"") as fp:
+                if args.cif_output:
+                    fp.write(protein.to_modelcif(unrelaxed_protein))
+                else:
+                    fp.write(protein.to_pdb(unrelaxed_protein))
+
+            logger.info(f""Output written to {unrelaxed_output_path}..."")
+
+            if not args.skip_relaxation:
+                # Relax the prediction.
+                logger.info(f""Running relaxation on {unrelaxed_output_path}..."")
+                relax_protein(
+                    config,
+                    args.model_device,
+                    unrelaxed_protein,
+                    output_directory,
+                    output_name,
+                    args.cif_output,
+                )
+
+            if args.save_outputs:
+                output_dict_path = os.path.join(
+                    output_directory, f""{output_name}_output_dict.pkl""
+                )
+                with open(output_dict_path, ""wb"") as fp:
+                    pickle.dump(out, fp, protocol=pickle.HIGHEST_PROTOCOL)
+
+                logger.info(f""Model output written to {output_dict_path}..."")
+
+
+def cli_runopenfold():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        ""fasta_dir"",
+        type=str,
+        help=""Path to directory containing FASTA files, one sequence per file"",
+    )
+    parser.add_argument(
+        ""--template_mmcif_dir"",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        ""--use_precomputed_alignments"",
+        type=str,
+        default=None,
+        help=""""""Path to alignment directory. If provided, alignment computation
+                is skipped and database path arguments are ignored."""""",
+    )
+    parser.add_argument(
+        ""--use_single_seq_mode"",
+        action=""store_true"",
+        default=False,
+        help=""""""Use single sequence embeddings instead of MSAs."""""",
+    )
+    parser.add_argument(
+        ""--output_dir"",
+        type=str,
+        default=os.getcwd(),
+        help=""""""Name of the directory in which to output the prediction"""""",
+    )
+    parser.add_argument(
+        ""--model_device"",
+        type=str,
+        default=""cpu"",
+        help=""""""Name of the device on which to run the model. Any valid torch
+             device name is accepted (e.g. ""cpu"", ""cuda:0"")"""""",
+    )
+    parser.add_argument(
+        ""--config_preset"",
+        type=str,
+        default=""model_1"",
+        help=""""""Name of a model config preset defined in openfold/config.py"""""",
+    )
+    parser.add_argument(
+        ""--jax_param_path"",
+        type=str,
+        default=None,
+        help=""""""Path to JAX model parameters. If None, and openfold_checkpoint_path
+             is also None, parameters are selected automatically according to
+             the model name from openfold/resources/params"""""",
+    )
+    parser.add_argument(
+        ""--openfold_checkpoint_path"",
+        type=str,
+        default=None,
+        help=""""""Path to OpenFold checkpoint. Can be either a DeepSpeed
+             checkpoint directory or a .pt file"""""",
+    )
+    parser.add_argument(
+        ""--save_outputs"",
+        action=""store_true"",
+        default=False,
+        help=""Whether to save all model outputs, including embeddings, etc."",
+    )
+    parser.add_argument(
+        ""--cpus"",
+        type=int,
+        default=4,
+        help=""""""Number of CPUs with which to run alignment tools"""""",
+    )
+    parser.add_argument(
+        ""--preset"", type=str, default=""full_dbs"", choices=(""reduced_dbs"", ""full_dbs"")
+    )
+    parser.add_argument(""--data_random_seed"", type=int, default=None)
+    parser.add_argument(
+        ""--output_postfix"",
+        type=str,
+        default=None,
+        help=""""""Postfix for output prediction filenames"""""",
+    )
+    # MH @ Jun 21, 2024, support different n_recyclings for initial predictions
+    parser.add_argument(""--max_recycling_iters"", type=int, default=4)
+    parser.add_argument(
+        ""--skip_relaxation"",
+        action=""store_true"",
+        default=False,
+    )
+    parser.add_argument(
+        ""--multimer_ri_gap"",
+        type=int,
+        default=200,
+        help=""""""Residue index offset between multiple sequences, if provided"""""",
+    )
+    parser.add_argument(
+        ""--trace_model"",
+        action=""store_true"",
+        default=False,
+        help=""""""Whether to convert parts of each model to TorchScript.
+                Significantly improves runtime at the cost of lengthy
+                'compilation.' Useful for large batch jobs."""""",
+    )
+    parser.add_argument(
+        ""--subtract_plddt"",
+        action=""store_true"",
+        default=False,
+        help=""""""""Whether to output (100 - pLDDT) in the B-factor column instead
+                 of the pLDDT itself"""""",
+    )
+    parser.add_argument(
+        ""--long_sequence_inference"",
+        action=""store_true"",
+        default=False,
+        help=""""""enable options to reduce memory usage at the cost of speed, helps longer
+        sequences fit into GPU memory, see the README for details"""""",
+    )
+    parser.add_argument(
+        ""--cif_output"",
+        action=""store_true"",
+        default=False,
+        help=""Output predicted models in ModelCIF format instead of PDB format (default)"",  # noqa: E501
+    )
+    parser.add_argument(
+        ""--experiment_config_json"",
+        default="""",
+        help=""Path to a json file with custom config values to overwrite config setting"",  # noqa: E501
+    )
+    parser.add_argument(
+        ""--use_deepspeed_evoformer_attention"",
+        action=""store_true"",
+        default=False,
+        help=""Whether to use the DeepSpeed evoformer attention layer.""
+        ""Must have deepspeed installed in the environment."",
+    )
+    # add_data_args(parser)
+    args = parser.parse_args()
+
+    if args.jax_param_path is None and args.openfold_checkpoint_path is None:
+        args.jax_param_path = os.path.join(
+            get_params_path(), ""params_"" + args.config_preset + "".npz""
+        )
+
+    if args.model_device == ""cpu"" and torch.cuda.is_available():
+        logging.warning(
+            """"""The model is being run on CPU. Consider specifying
+            --model_device for better performance""""""
+        )
+
+    main(args)
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/run_msacluster.py",".py","10560","333","""""""
+Cluster sequences in a MSA using DBSCAN algorithm and write .a3m file for each cluster.
+Assumes first sequence in fasta is the query sequence.
+
+rk.msacluster v1 -i alignments/ -o msaclusters --run_TSNE
+
+This script is modified from AF_cluster repo:
+https://github.com/HWaymentSteele/AF_Cluster/blob/main/scripts/ClusterMSA.py
+""""""
+
+import argparse
+import os
+
+import numpy as np
+import pandas as pd
+from polyleven import levenshtein
+from sklearn.cluster import DBSCAN
+
+from rocket.msacluster_utils import (
+    consensusVoting,
+    encode_seqs,
+    load_fasta,
+    lprint,
+    plot_landscape,
+    write_fasta,
+)
+
+
+def main():
+    p = argparse.ArgumentParser(
+        description=""""""
+    Cluster sequences in a MSA using DBSCAN algorithm and write .a3m file for each cluster.
+    Assumes first sequence in fasta is the query sequence.
+
+    H Wayment-Steele, 2022
+
+    Modified by Minhuan Li for ROCKET, 2024
+    """"""  # noqa: E501
+    )
+
+    p.add_argument(
+        ""keyword"", action=""store"", help=""Keyword to call all generated MSAs.""
+    )
+    p.add_argument(
+        ""-i"",
+        action=""store"",
+        help=""fasta/a3m file of original alignment, or path containing fasta/a3m files"",
+    )
+    p.add_argument(
+        ""-o"", action=""store"", help=""name of output directory to write MSAs to.""
+    )
+    p.add_argument(
+        ""--n_controls"",
+        action=""store"",
+        default=10,
+        type=int,
+        help=""Number of control msas to generate (Default 10)"",
+    )
+    p.add_argument(
+        ""--verbose"",
+        action=""store_true"",
+        help=""Print cluster info as they are generated."",
+    )
+
+    p.add_argument(
+        ""--scan"", action=""store_true"", help=""Select eps value on 1/4 of data, shuffled.""
+    )
+    p.add_argument(
+        ""--eps_val"",
+        action=""store"",
+        type=float,
+        help=""Use single value for eps instead of scanning."",
+    )
+    p.add_argument(
+        ""--resample"",
+        action=""store_true"",
+        help=""If included, will resample the original MSA with replacement before writing."",  # noqa: E501
+    )
+    p.add_argument(
+        ""--gap_cutoff"",
+        action=""store"",
+        type=float,
+        default=0.25,
+        help=""Remove sequences with gaps representing more than this frac of seq."",
+    )
+    p.add_argument(
+        ""--min_eps"",
+        action=""store"",
+        default=3,
+        help=""Min epsilon value to scan for DBSCAN (Default 3)."",
+    )
+    p.add_argument(
+        ""--max_eps"",
+        action=""store"",
+        default=20,
+        help=""Max epsilon value to scan for DBSCAN (Default 20)."",
+    )
+    p.add_argument(
+        ""--eps_step"",
+        action=""store"",
+        default=0.5,
+        help=""step for epsilon scan for DBSCAN (Default 0.5)."",
+    )
+    p.add_argument(
+        ""--min_samples"",
+        action=""store"",
+        default=10,
+        help=""Default min_samples for DBSCAN (Default 3, recommended no lower than that)."",  # noqa: E501
+    )
+
+    p.add_argument(
+        ""--run_PCA"",
+        action=""store_true"",
+        help=""Run PCA on one-hot embedding of sequences and store in output_cluster_metadata.tsv"",  # noqa: E501
+    )
+    p.add_argument(
+        ""--run_TSNE"",
+        action=""store_true"",
+        help=""Run TSNE on one-hot embedding of sequences and store in output_cluster_metadata.tsv"",  # noqa: E501
+    )
+
+    args = p.parse_args()
+
+    if args.run_PCA:
+        from sklearn.decomposition import PCA
+
+    if args.run_TSNE:
+        from sklearn.manifold import TSNE
+
+    os.makedirs(args.o, exist_ok=True)
+    f = open(f""msacluster_{args.keyword}.log"", ""w"")  # noqa: SIM115
+    IDs, seqs = load_fasta(args.i)
+
+    seqs = [
+        """".join([x for x in s if x.isupper() or x == ""-""]) for s in seqs
+    ]  # remove lowercase letters in alignment
+
+    df = pd.DataFrame({""SequenceName"": IDs, ""sequence"": seqs})
+
+    query_ = df.iloc[:1]
+    df = df.iloc[1:]
+
+    if args.resample:
+        df = df.sample(frac=1)
+
+    L = len(df.sequence.iloc[0])
+    N = len(df)  # noqa: F841
+
+    df[""frac_gaps""] = [x.count(""-"") / L for x in df[""sequence""]]
+
+    former_len = len(df)
+    df = df.loc[df.frac_gaps < args.gap_cutoff]
+
+    new_len = len(df)
+    lprint(args.keyword, f)
+    lprint(
+        f""{former_len - new_len} seqs removed for containing more than {int(args.gap_cutoff * 100)}% gaps, {new_len} remaining"",  # noqa: E501
+        f,
+    )
+
+    ohe_seqs = encode_seqs(df.sequence.tolist(), max_len=L)
+
+    n_clusters = []
+    eps_test_vals = np.arange(args.min_eps, args.max_eps + args.eps_step, args.eps_step)
+
+    if args.eps_val is None:  # performing scan
+        lprint(""eps\tn_clusters\tn_not_clustered"", f)
+
+        for eps in eps_test_vals:
+            testset = encode_seqs(df.sample(frac=0.25).sequence.tolist(), max_len=L)
+            clustering = DBSCAN(eps=eps, min_samples=args.min_samples).fit(testset)
+            n_clust = len(set(clustering.labels_))
+            n_not_clustered = len(
+                clustering.labels_[np.where(clustering.labels_ == -1)]
+            )
+            lprint(""%.2f\t%d\t%d"" % (eps, n_clust, n_not_clustered), f)  # noqa: UP031
+            n_clusters.append(n_clust)
+            if eps > 10 and n_clust == 1:
+                break
+
+        eps_to_select = eps_test_vals[np.argmax(n_clusters)]
+    else:
+        eps_to_select = args.eps_val
+
+    # perform actual clustering
+
+    clustering = DBSCAN(eps=eps_to_select, min_samples=args.min_samples).fit(ohe_seqs)
+
+    lprint(""Selected eps={:.2f}"".format(eps_to_select), f)  # noqa: UP032
+
+    lprint(""%d total seqs"" % len(df), f)  # noqa: UP031
+
+    df[""dbscan_label""] = clustering.labels_
+
+    clusters = [x for x in df.dbscan_label.unique() if x >= 0]
+    unclustered = len(df.loc[df.dbscan_label == -1])
+
+    lprint(
+        ""%d clusters, %d of %d not clustered (%.2f)""  # noqa: UP031
+        % (len(clusters), unclustered, len(df), unclustered / len(df)),
+        f,
+    )
+
+    avg_dist_to_query = np.mean([
+        1 - levenshtein(x, query_[""sequence""].iloc[0]) / L
+        for x in df.loc[df.dbscan_label == -1][""sequence""].tolist()
+    ])
+    lprint(""avg identity to query of unclustered: %.2f"" % avg_dist_to_query, f)  # noqa: UP031
+
+    avg_dist_to_query = np.mean([
+        1 - levenshtein(x, query_[""sequence""].iloc[0]) / L
+        for x in df.loc[df.dbscan_label != -1][""sequence""].tolist()
+    ])
+    lprint(""avg identity to query of clustered: %.2f"" % avg_dist_to_query, f)  # noqa: UP031
+
+    cluster_metadata = []
+    for clust in clusters:
+        tmp = df.loc[df.dbscan_label == clust]
+
+        cs = consensusVoting(tmp.sequence.tolist())
+
+        avg_dist_to_cs = np.mean([
+            1 - levenshtein(x, cs) / L for x in tmp.sequence.tolist()
+        ])
+        avg_dist_to_query = np.mean([
+            1 - levenshtein(x, query_[""sequence""].iloc[0]) / L
+            for x in tmp.sequence.tolist()
+        ])
+
+        if args.verbose:
+            print(""Cluster %d consensus seq, %d seqs:"" % (clust, len(tmp)))  # noqa: UP031
+            print(cs)
+            print(""#########################################"")
+            for _, row in tmp.iterrows():
+                print(row[""SequenceName""], row[""sequence""])
+            print(""#########################################"")
+
+        tmp = pd.concat([query_, tmp], axis=0)
+
+        cluster_metadata.append({
+            ""cluster_ind"": clust,
+            ""consensusSeq"": cs,
+            ""avg_lev_dist"": ""%.3f"" % avg_dist_to_cs,  # noqa: UP031
+            ""avg_dist_to_query"": ""%.3f"" % avg_dist_to_query,  # noqa: UP031
+            ""size"": len(tmp),
+        })
+
+        write_fasta(
+            tmp.SequenceName.tolist(),
+            tmp.sequence.tolist(),
+            outfile=args.o + ""/"" + args.keyword + ""_"" + ""%03d"" % clust + "".a3m"",  # noqa: UP031
+        )
+
+    print(f""writing {args.n_controls} size-10 uniformly sampled clusters"", flush=True)
+    for i in range(args.n_controls):
+        tmp = df.sample(n=10)
+        tmp = pd.concat([query_, tmp], axis=0)
+        write_fasta(
+            tmp.SequenceName.tolist(),
+            tmp.sequence.tolist(),
+            outfile=args.o + ""/"" + ""U10-"" + args.keyword + ""_"" + ""%03d"" % i + "".a3m"",  # noqa: UP031
+        )
+    if len(df) > 100:
+        print(
+            f""writing {args.n_controls} size-100 uniformly sampled clusters"", flush=True
+        )
+        for i in range(args.n_controls):
+            tmp = df.sample(n=100)
+            tmp = pd.concat([query_, tmp], axis=0)
+            write_fasta(
+                tmp.SequenceName.tolist(),
+                tmp.sequence.tolist(),
+                outfile=args.o
+                + ""/""
+                + ""U100-""
+                + args.keyword
+                + ""_""
+                + ""%03d"" % i  # noqa: UP031
+                + "".a3m"",
+            )
+
+    if args.run_PCA:
+        lprint(""Running PCA ..."", f)
+        ohe_vecs = encode_seqs(df.sequence.tolist(), max_len=L)
+        mdl = PCA()
+        embedding = mdl.fit_transform(ohe_vecs)
+
+        query_embedding = mdl.transform(
+            encode_seqs(query_.sequence.tolist(), max_len=L)
+        )
+
+        df[""PC 1""] = embedding[:, 0]
+        df[""PC 2""] = embedding[:, 1]
+
+        query_[""PC 1""] = query_embedding[:, 0]
+        query_[""PC 2""] = query_embedding[:, 1]
+
+        plot_landscape(""PC 1"", ""PC 2"", df, query_, ""PCA"", args)
+
+        lprint(""Saved PCA plot to "" + args.o + ""/"" + args.keyword + ""_PCA.pdf"", f)
+
+    if args.run_TSNE:
+        lprint(""Running TSNE ..."", f)
+        ohe_vecs = encode_seqs(
+            df.sequence.tolist() + [query_.sequence.tolist()], max_len=L
+        )
+        # different than PCA because tSNE doesn't have .transform attribute
+
+        mdl = TSNE()
+        embedding = mdl.fit_transform(ohe_vecs)
+
+        df[""TSNE 1""] = embedding[:-1, 0]
+        df[""TSNE 2""] = embedding[:-1, 1]
+
+        query_[""TSNE 1""] = embedding[-1:, 0]
+        query_[""TSNE 2""] = embedding[-1:, 1]
+
+        plot_landscape(""TSNE 1"", ""TSNE 2"", df, query_, ""TSNE"", args)
+
+        lprint(""Saved TSNE plot to "" + args.o + ""/"" + args.keyword + ""_TSNE.pdf"", f)
+
+    outfile = args.o + ""/"" + args.keyword + ""_clustering_assignments.tsv""
+    lprint(""wrote clustering data to %s"" % outfile, f)  # noqa: UP031
+    df.to_csv(outfile, index=False, sep=""\t"")
+
+    metad_outfile = args.o + ""/"" + args.keyword + ""_cluster_metadata.tsv""
+    lprint(""wrote cluster metadata to %s"" % metad_outfile, f)  # noqa: UP031
+    metad_df = pd.DataFrame.from_records(cluster_metadata)
+    metad_df.to_csv(metad_outfile, index=False, sep=""\t"")
+
+    print(""Saved this output to msacluster_%s.log"" % args.keyword)  # noqa: UP031
+    f.close()
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/run_config.py",".py","3025","91","import argparse
+import os
+
+from loguru import logger
+
+from ..refinement_config import DATAMODE, RUNMODE, RocketRefinmentConfig, gen_config
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description=""Generate ROCKET configuration files"")
+    parser.add_argument(
+        ""--mode"",
+        type=str,
+        choices=[""phase1"", ""phase2"", ""both""],
+        default=""both"",
+        help=""Execution mode: phase1, phase2, or both (default: both)"",
+    )
+    parser.add_argument(
+        ""--datamode"", type=str, choices=[""xray"", ""cryoem""], help=""Data mode""
+    )
+    parser.add_argument(""--working-dir"", type=str, help=""Working directory path"")
+    parser.add_argument(""--file-id"", type=str, help=""File ID to use"")
+    parser.add_argument(
+        ""--pre-phase1-config"",
+        type=str,
+        help=""Path to pre-phase1 configuration file (required for phase2 mode)"",
+    )
+
+    args = parser.parse_args()
+
+    # Convert string mode to RUNMODE enum
+    run_mode = RUNMODE(args.mode)
+
+    # Convert string datamode to DATAMODE enum if provided
+    data_mode = None
+    if args.datamode:
+        data_mode = DATAMODE(args.datamode)
+
+    # Load pre_phase1_config if provided and mode is phase2
+    pre_phase1_config_obj = None
+    if args.pre_phase1_config:
+        if run_mode == RUNMODE.PHASE2 and not os.path.exists(args.pre_phase1_config):
+            parser.error(f""Pre-phase1 config file not found: {args.pre_phase1_config}"")
+        # Load the config file
+        pre_phase1_config_obj = RocketRefinmentConfig.from_yaml_file(
+            args.pre_phase1_config
+        )  # noqa: E501
+    elif run_mode == RUNMODE.PHASE2:
+        parser.error(""--pre-phase1-config is required when mode is phase2"")
+
+    return {
+        ""mode"": run_mode,
+        ""datamode"": data_mode,
+        ""working_dir"": args.working_dir,
+        ""file_id"": args.file_id,
+        ""pre_phase1_config"": pre_phase1_config_obj,
+    }
+
+
+def cli_runconfig():
+    args = parse_args()
+
+    result = gen_config(
+        mode=args.get(""mode""),
+        datamode=args.get(""datamode""),
+        working_dir=args.get(""working_dir""),
+        file_id=args.get(""file_id""),
+        pre_phase1_config=args.get(""pre_phase1_config""),
+    )
+
+    if args.get(""mode"") == RUNMODE.BOTH:
+        phase1_config, phase2_config = result
+        logger.info(
+            f""Generated Phase 1 config at: {os.path.join(args.get('working_dir'), 'ROCKET_config_phase1.yaml')}""  # noqa: E501
+        )
+        logger.info(
+            f""Generated Phase 2 config at: {os.path.join(args.get('working_dir'), 'ROCKET_config_phase2.yaml')}""  # noqa: E501
+        )
+    elif args.get(""mode"") == RUNMODE.PHASE1:
+        logger.info(
+            f""Generated Phase 1 config at: {os.path.join(args.get('working_dir'), 'ROCKET_config_phase1.yaml')}""  # noqa: E501
+        )
+    else:  # PHASE2
+        logger.info(
+            f""Generated Phase 2 config at: {os.path.join(result.working_dir, 'ROCKET_config_phase2.yaml')}""  # noqa: E501
+        )
+
+
+if __name__ == ""__main__"":
+    cli_runconfig()
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/run_msascore.py",".py","14245","414","#!/usr/bin/env python3
+
+import argparse
+import glob
+import os
+import shutil
+
+import pandas as pd
+import torch
+from loguru import logger
+from openfold.config import model_config
+from openfold.data import data_pipeline, feature_pipeline
+from tqdm import tqdm
+
+import rocket
+from rocket import coordinates as rk_coordinates
+from rocket import refinement_utils as rkrf_utils
+from rocket import utils as rk_utils
+
+PRESET = ""model_1_ptm""
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=(
+            ""Run LLG scoring for system with different msas, ""
+            ""supporting both xray and cryoem modes""
+        )
+    )
+    parser.add_argument(""path"", action=""store"", help=""Path to parent folder"")
+    parser.add_argument(""system"", action=""store"", help=""file_id for the dataset"")
+    parser.add_argument(
+        ""-i"", action=""store"", help=""prefix for msas to use, path will prepend""
+    )
+    parser.add_argument(
+        ""-o"",
+        action=""store"",
+        help=(
+            ""name of output directory to write prediction and scoring to, ""
+            ""path will prepend""
+        ),
+    )
+    parser.add_argument(
+        ""--datamode"",
+        choices=[""xray"", ""cryoem""],
+        required=True,
+        help=""Choose between xray or cryoem mode"",
+    )
+    parser.add_argument(
+        ""--domain_segs"",
+        type=int,
+        nargs=""*"",
+        default=None,
+        help=""A list of resid as domain boundaries"",
+    )
+    parser.add_argument(
+        ""--additional_chain"", action=""store_true"", help=""Additional Chain in ASU""
+    )
+    parser.add_argument(
+        ""--init_recycling"", default=4, type=int, help=""number of initial recycling""
+    )
+    parser.add_argument(
+        ""--free_flag"", default=""R-free-flags"", type=str, help=""Column name of free flag""
+    )
+    parser.add_argument(
+        ""--testset_value"", default=1, type=int, help=""Value for test set""
+    )
+    parser.add_argument(
+        ""--voxel_spacing"",
+        default=4.5,
+        type=float,
+        help=""Voxel spacing for solvent percentage estimation"",
+    )
+    parser.add_argument(
+        ""--min_resolution"", default=3.0, type=float, help=""min resolution cut""
+    )
+    parser.add_argument(
+        ""--chimera_profile"", action=""store_true"", help=""Use chimera profile""
+    )
+    parser.add_argument(
+        ""--score_fullmsa"", action=""store_true"", help=""Also score the full msa""
+    )
+    config = parser.parse_args()
+
+    device = rk_utils.try_gpu()
+    RBR_LBFGS = True
+
+    output_directory_path = os.path.join(config.path, config.o)
+    os.makedirs(output_directory_path, exist_ok=True)
+
+    logger.info(f""Working with system {config.system}"", flush=True)
+
+    # Input paths
+    tng_file = os.path.join(config.path, ""ROCKET_inputs"", f""{config.system}-Edata.mtz"")
+    input_pdb = os.path.join(
+        config.path, ""ROCKET_inputs"", f""{config.system}-pred-aligned.pdb""
+    )
+
+    # Handle additional chain
+    constant_fp_added_HKL = None
+    constant_fp_added_asu = None
+    if config.additional_chain:
+        constant_fp_added_HKL = torch.load(
+            f""{config.path}/ROCKET_inputs/{config.system}_added_chain_atoms_HKL.pt""
+        ).to(device=device)
+        constant_fp_added_asu = torch.load(
+            f""{config.path}/ROCKET_inputs/{config.system}_added_chain_atoms_asu.pt""
+        ).to(device=device)
+
+    # --- Data mode specific imports and objects ---
+    if config.datamode == ""xray"":
+        from rocket.xtal import structurefactors as sf_module
+
+        def llgloss_init(sfc, mtz, minres, maxres):
+            return rkrf_utils.init_llgloss(sfc, mtz, minres, maxres)
+
+        initial_SFC = sf_module.initial_SFC
+        SFC_kwargs = {
+            ""Freelabel"": config.free_flag,
+            ""device"": device,
+            ""testset_value"": config.testset_value,
+            ""added_chain_HKL"": constant_fp_added_HKL,
+            ""added_chain_asu"": constant_fp_added_asu,
+            ""spacing"": config.voxel_spacing,
+        }
+        LBFGS_LR = 150
+
+    elif config.datamode == ""cryoem"":
+        from rocket.cryo import structurefactors as sf_module
+        from rocket.cryo import targets as cryo_targets
+
+        def llgloss_init(sfc, mtz, *_):
+            return cryo_targets.LLGloss(sfc, mtz)
+
+        def initial_SFC(
+            pdb,
+            mtz,
+            FP,
+            SIGFP,
+            Freelabel,
+            device,
+            testset_value,
+            added_chain_HKL,
+            added_chain_asu,
+            spacing,
+        ):
+            return sf_module.initial_cryoSFC(pdb, mtz, ""Emean"", ""PHIEmean"", device, 20)
+
+        SFC_kwargs = {
+            ""Freelabel"": config.free_flag,
+            ""device"": device,
+            ""testset_value"": config.testset_value,
+            ""added_chain_HKL"": constant_fp_added_HKL,
+            ""added_chain_asu"": constant_fp_added_asu,
+            ""spacing"": config.voxel_spacing,
+        }
+        LBFGS_LR = 0.1
+
+    else:
+        raise ValueError(f""Unknown datamode: {config.datamode}"")
+
+    # --- SFC and LLGloss Initialization ---
+    sfc = initial_SFC(input_pdb, tng_file, ""FEFF"", ""DOBS"", **SFC_kwargs)
+    reference_pos = sfc.atom_pos_orth.clone()
+    init_pos_bfactor = sfc.atom_b_iso.clone()
+
+    sfc_rbr = initial_SFC(input_pdb, tng_file, ""FEFF"", ""DOBS"", **SFC_kwargs)
+
+    llgloss = llgloss_init(sfc, tng_file, config.min_resolution, None)
+    llgloss_rbr = llgloss_init(sfc_rbr, tng_file, config.min_resolution, None)
+
+    # AF2 model initialization
+    af_bias = rocket.MSABiasAFv3(model_config(PRESET, train=True), PRESET).to(device)
+    af_bias.freeze()
+
+    fasta_path = [
+        f
+        for ext in (""*.fa"", ""*.fasta"")
+        for f in glob.glob(os.path.join(config.path, ext))
+    ][0]
+
+    fullmsa_dir = os.path.join(config.path, ""alignments"")
+    data_processor = data_pipeline.DataPipeline(template_featurizer=None)
+    fullmsa_feature_dict = rkrf_utils.generate_feature_dict(
+        fasta_path,
+        fullmsa_dir,
+        data_processor,
+    )
+
+    afconfig = model_config(PRESET)
+    afconfig.data.common.max_recycling_iters = config.init_recycling
+    del afconfig.data.common.masked_msa
+    afconfig.data.common.resample_msa_in_recycling = False
+    feature_processor = feature_pipeline.FeaturePipeline(afconfig.data)
+    fullmsa_processed_feature_dict = feature_processor.process_features(
+        fullmsa_feature_dict, mode=""predict""
+    )
+    full_profile = fullmsa_processed_feature_dict[""msa_feat""][:, :, 25:48].clone()
+
+    df = pd.DataFrame(
+        columns=[
+            ""msa_name"",
+            ""depth"",
+            ""mean_plddt"",
+            ""llg"",
+            #  ""rfree"",
+            #  ""rwork""
+        ]
+    )
+    df.to_csv(os.path.join(output_directory_path, ""msa_scoring.csv""), index=False)
+
+    # --- (Optional) Score the full MSA ---
+    if config.score_fullmsa:
+        msa_name = ""fullmsa""
+        device_processed_features = rk_utils.move_tensors_to_device(
+            fullmsa_processed_feature_dict, device=device
+        )
+        af2_output, prevs = af_bias(
+            device_processed_features,
+            [None, None, None],
+            num_iters=config.init_recycling,
+            bias=False,
+        )
+        prevs = [tensor.detach() for tensor in prevs]
+        deep_copied_prevs = [tensor.clone().detach() for tensor in prevs]
+        af2_output, __ = af_bias(
+            device_processed_features, deep_copied_prevs, num_iters=1, bias=False
+        )
+        plddt = torch.mean(af2_output[""plddt""])
+        aligned_xyz, plddts_res, pseudo_Bs = rkrf_utils.position_alignment(
+            af2_output=af2_output,
+            device_processed_features=device_processed_features,
+            cra_name=sfc.cra_name,
+            best_pos=reference_pos,
+            exclude_res=None,
+            domain_segs=config.domain_segs,
+            reference_bfactor=init_pos_bfactor,
+        )
+        llgloss.sfc.atom_b_iso = pseudo_Bs.detach()
+        llgloss_rbr.sfc.atom_b_iso = pseudo_Bs.detach()
+
+        if config.datamode == ""xray"":
+            llgloss, llgloss_rbr, Ecalc, Fc = rkrf_utils.update_sigmaA(
+                llgloss=llgloss,
+                llgloss_rbr=llgloss_rbr,
+                aligned_xyz=aligned_xyz,
+                constant_fp_added_HKL=constant_fp_added_HKL,
+                constant_fp_added_asu=constant_fp_added_asu,
+            )
+        optimized_xyz, loss_track_pose = rk_coordinates.rigidbody_refine_quat(
+            aligned_xyz,
+            llgloss_rbr,
+            sfc.cra_name,
+            domain_segs=config.domain_segs,
+            lbfgs=RBR_LBFGS,
+            added_chain_HKL=constant_fp_added_HKL,
+            added_chain_asu=constant_fp_added_asu,
+            lbfgs_lr=LBFGS_LR,
+            verbose=False,
+        )
+        llg = llgloss(
+            optimized_xyz,
+            bin_labels=None,
+            num_batch=1,
+            sub_ratio=1.0,
+            solvent=True,
+            update_scales=True,
+            added_chain_HKL=constant_fp_added_HKL,
+            added_chain_asu=constant_fp_added_asu,
+        )
+        llgloss.sfc.atom_pos_orth = optimized_xyz
+        llgloss.sfc.savePDB(f""{output_directory_path!s}/{msa_name}_postRBR.pdb"")
+        (
+            plddt_i,
+            llg_i,
+        ) = (
+            plddt.item(),
+            llg.item(),
+            # llgloss.sfc.r_free.item(),
+            # llgloss.sfc.r_work.item(),
+        )
+        df_tmp = pd.DataFrame({
+            ""msa_name"": [msa_name],
+            ""depth"": [fullmsa_feature_dict[""msa""].shape[0]],
+            ""mean_plddt"": [plddt_i],
+            ""llg"": [llg_i],
+            # ""rfree"": [rfree_i],
+            # ""rwork"": [rwork_i],
+        })
+        df_tmp.to_csv(
+            os.path.join(output_directory_path, ""msa_scoring.csv""),
+            mode=""a"",
+            header=False,
+            index=False,
+        )
+
+    # --- Score all MSAs ---
+    a3m_paths = glob.glob(os.path.join(config.path, config.i + ""*.a3m""))
+    print(f""{len(a3m_paths)} msa files available..."", flush=True)
+    a3m_paths.sort()
+
+    for a3m_path in tqdm(a3m_paths):
+        msa_name, ext = os.path.splitext(os.path.basename(a3m_path))
+        data_processor = data_pipeline.DataPipeline(template_featurizer=None)
+        temp_alignment_dir = os.path.join(os.path.dirname(a3m_path), ""tmp_align"")
+        os.makedirs(temp_alignment_dir, exist_ok=True)
+        shutil.copy(a3m_path, os.path.join(temp_alignment_dir, msa_name + "".a3m""))
+        feature_dict = rkrf_utils.generate_feature_dict(
+            fasta_path,
+            temp_alignment_dir,
+            data_processor,
+        )
+        afconfig = model_config(PRESET)
+        afconfig.data.common.max_recycling_iters = config.init_recycling
+        del afconfig.data.common.masked_msa
+        afconfig.data.common.resample_msa_in_recycling = False
+        feature_processor = feature_pipeline.FeaturePipeline(afconfig.data)
+        processed_feature_dict = feature_processor.process_features(
+            feature_dict, mode=""predict""
+        )
+
+        if config.chimera_profile:
+            sub_profile = processed_feature_dict[""msa_feat""][:, :, 25:48].clone()
+            processed_feature_dict[""msa_feat""][:, :, 25:48] = torch.where(
+                sub_profile == 0.0, full_profile.clone(), sub_profile.clone()
+            )
+
+        device_processed_features = rk_utils.move_tensors_to_device(
+            processed_feature_dict, device=device
+        )
+
+        af2_output, prevs = af_bias(
+            device_processed_features,
+            [None, None, None],
+            num_iters=config.init_recycling,
+            bias=False,
+        )
+        prevs = [tensor.detach() for tensor in prevs]
+        deep_copied_prevs = [tensor.clone().detach() for tensor in prevs]
+        af2_output, __ = af_bias(
+            device_processed_features, deep_copied_prevs, num_iters=1, bias=False
+        )
+        plddt = torch.mean(af2_output[""plddt""])
+        aligned_xyz, plddts_res, pseudo_Bs = rkrf_utils.position_alignment(
+            af2_output=af2_output,
+            device_processed_features=device_processed_features,
+            cra_name=sfc.cra_name,
+            best_pos=reference_pos,
+            exclude_res=None,
+            domain_segs=config.domain_segs,
+            reference_bfactor=init_pos_bfactor,
+        )
+        llgloss.sfc.atom_b_iso = pseudo_Bs.detach()
+        llgloss_rbr.sfc.atom_b_iso = pseudo_Bs.detach()
+        if config.datamode == ""xray"":
+            llgloss, llgloss_rbr, Ecalc, Fc = rkrf_utils.update_sigmaA(
+                llgloss=llgloss,
+                llgloss_rbr=llgloss_rbr,
+                aligned_xyz=aligned_xyz,
+                constant_fp_added_HKL=constant_fp_added_HKL,
+                constant_fp_added_asu=constant_fp_added_asu,
+            )
+        optimized_xyz, loss_track_pose = rk_coordinates.rigidbody_refine_quat(
+            aligned_xyz,
+            llgloss_rbr,
+            sfc.cra_name,
+            domain_segs=config.domain_segs,
+            lbfgs=RBR_LBFGS,
+            added_chain_HKL=constant_fp_added_HKL,
+            added_chain_asu=constant_fp_added_asu,
+            lbfgs_lr=LBFGS_LR,
+            verbose=False,
+        )
+        llg = llgloss(
+            optimized_xyz,
+            bin_labels=None,
+            num_batch=1,
+            sub_ratio=1.0,
+            solvent=True,
+            update_scales=True,
+            added_chain_HKL=constant_fp_added_HKL,
+            added_chain_asu=constant_fp_added_asu,
+        )
+        llgloss.sfc.atom_pos_orth = optimized_xyz
+        llgloss.sfc.savePDB(f""{output_directory_path!s}/{msa_name}_postRBR.pdb"")
+        (
+            plddt_i,
+            llg_i,
+        ) = (
+            plddt.item(),
+            llg.item(),
+            # llgloss.sfc.r_free.item(),
+            # llgloss.sfc.r_work.item(),
+        )
+        df_tmp = pd.DataFrame({
+            ""msa_name"": [msa_name],
+            ""depth"": [feature_dict[""msa""].shape[0]],
+            ""mean_plddt"": [plddt_i],
+            ""llg"": [llg_i],
+            # ""rfree"": [rfree_i],
+            # ""rwork"": [rwork_i],
+        })
+        df_tmp.to_csv(
+            os.path.join(output_directory_path, ""msa_scoring.csv""),
+            mode=""a"",
+            header=False,
+            index=False,
+        )
+        shutil.rmtree(temp_alignment_dir)
+
+
+if __name__ == ""__main__"":
+    main()
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/run_refine.py",".py","757","23","import argparse
+
+from ..refinement_config import RocketRefinmentConfig
+from ..refinement_cryoem import run_cryoem_refinement
+from ..refinement_xray import run_xray_refinement
+
+
+def run_refinement(config: RocketRefinmentConfig | str) -> RocketRefinmentConfig:
+    if isinstance(config, str):
+        config = RocketRefinmentConfig.from_yaml_file(config)
+
+    if config.datamode == ""xray"":
+        return run_xray_refinement(config)
+    elif config.datamode == ""cryoem"":
+        return run_cryoem_refinement(config)
+
+
+def cli_runrefine():
+    parser = argparse.ArgumentParser(description=""Run ROCKET refinement"")
+    parser.add_argument(""config"", type=str, help=""Path to the configuration file"")
+    args = parser.parse_args()
+    run_refinement(args.config)
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/archived_scripts/run_phase1andphase2.py",".py","15103","508","import argparse
+import glob
+import os
+
+from rocket.refinement_xray import RocketRefinmentConfig, run_refinement
+
+
+# WORKING_DIRECTORY = Path(""/net/cci/alisia/openfold_tests/run_openfold/test_cases"")
+# ALL_DATASETS = [""6lzm""]
+def int_or_none(value):
+    if value.lower() == ""none"":
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError(
+            f""Invalid value: {value}. Must be an integer or 'None'.""
+        )
+
+
+def float_or_none(value):
+    if value.lower() == ""none"":
+        return None
+    try:
+        return float(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError(
+            f""Invalid value: {value}. Must be an float or 'None'.""
+        )
+
+
+def parse_arguments():
+    """"""Parse commandline arguments""""""
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawTextHelpFormatter, description=__doc__
+    )
+
+    parser.add_argument(
+        ""-p"",
+        ""--path"",
+        default=""./benchmark_data/"",
+        help=(""Path to the parent folder""),
+    )
+
+    # Required arguments
+    parser.add_argument(
+        ""-sys"",
+        ""--systems"",
+        nargs=""+"",
+        help=(""PDB codes or filename roots for the dataset""),
+    )
+
+    parser.add_argument(
+        ""--note"",
+        default="""",
+        help=(""note""),
+    )
+
+    parser.add_argument(
+        ""--template_pdb"",
+        default=None,
+        help=(""template model name in the path""),
+    )
+
+    parser.add_argument(
+        ""--input_msa"",
+        default=None,
+        help=(
+            ""path to msa file .a3m/.fasta for use, working path and system will prepend""
+        ),
+    )
+
+    parser.add_argument(
+        ""--domain_segs"",
+        type=int,
+        nargs=""*"",
+        default=None,
+        help=(""A list of resid as domain boundaries""),
+    )
+
+    parser.add_argument(
+        ""--additional_chain"", action=""store_true"", help=(""Additional Chain in ASU"")
+    )
+
+    parser.add_argument(
+        ""--only_phase1"",
+        action=""store_true"",
+        help=(""Turn off phase 2 refinement in the pipeline""),
+    )
+
+    parser.add_argument(
+        ""--only_phase2"",
+        action=""store_true"",
+        help=(""Turn off phase 1 refinement in the pipeline""),
+    )
+
+    parser.add_argument(""--phase1_uuid"", default=None, help=(""uuid for phase 1 run""))
+
+    parser.add_argument(""--mse_uuid"", default=None, help=(""uuid for mse run""))
+
+    parser.add_argument(
+        ""--init_recycling"",
+        default=20,
+        type=int,
+        help=(""number of initial recycling""),
+    )
+
+    parser.add_argument(
+        ""--phase1_add_lr"",
+        default=0.05,
+        type=float,
+        help=(""phase 1 additive learning rate""),
+    )
+
+    parser.add_argument(
+        ""--phase1_mul_lr"",
+        default=1.0,
+        type=float,
+        help=(""phase 1 multiplicative learning rate""),
+    )
+
+    parser.add_argument(
+        ""--phase1_w_l2"",
+        default=1e-11,
+        type=float,
+        help=(""phase 1 weights of L2 loss""),
+    )
+
+    parser.add_argument(
+        ""--phase2_final_lr"",
+        default=1e-3,
+        type=float,
+        help=(""phase 2 final learning rate""),
+    )
+
+    parser.add_argument(
+        ""--smooth_stage_epochs"",
+        default=50,
+        type=int_or_none,
+        help=(""number of smooth stages in phase1""),
+    )
+
+    parser.add_argument(
+        ""--phase1_min_resol"",
+        default=3.0,
+        type=float,
+        help=(""phase 1 resolution cut""),
+    )
+
+    parser.add_argument(
+        ""--free_flag"",
+        default=""R-free-flags"",
+        type=str,
+        help=(""Column name of free flag""),
+    )
+
+    parser.add_argument(
+        ""--testset_value"",
+        default=1,
+        type=int,
+        help=(""Value for test set""),
+    )
+
+    parser.add_argument(
+        ""--voxel_spacing"",
+        default=4.5,
+        type=float,
+        help=(""Voxel spacing for solvent percentage estimation""),
+    )
+
+    parser.add_argument(
+        ""--w_plddt"",
+        default=0.0,
+        type=float,
+        help=(""Weights for plddt loss""),
+    )
+
+    parser.add_argument(
+        ""--msa_subratio"",
+        default=None,
+        type=float_or_none,
+        help=(
+            ""MSA subsampling ratio, between 0.0 and 1.0. Default None, no subsampling.""
+        ),
+    )
+
+    return parser.parse_args()
+
+
+def generate_phase1_config(
+    *,
+    working_path: str,
+    file_root: str,
+    cuda_device: int = 0,
+    free_flag: str = ""R-free-flags"",
+    testset_value: int = 1,
+    template_pdb: str | None = None,
+    input_msa: str | None = None,
+    additional_chain: bool = False,
+    additive_learning_rate: float = 0.05,
+    multiplicative_learning_rate: float = 1.0,
+    init_recycling: int = 20,
+    phase1_min_resol: float = 4.0,
+    phase1_w_l2: float = 1e-3,
+    phase2_final_lr: float = 1e-3,
+    smooth_stage_epochs: int | None = 50,
+    domain_segs: list[int] | None = None,
+    note: str = """",
+    mse_uuid: str | None = None,
+    voxel_spacing: float = 4.5,
+    msa_subratio: float | None = None,
+) -> RocketRefinmentConfig:
+    if mse_uuid is None:
+        starting_bias_path = None
+        starting_weights_path = None
+    else:
+        output_directory_path = f""{working_path}/{file_root}/outputs/{mse_uuid}""
+        mse_path = glob.glob(f""{output_directory_path}/mse*/"")[0]
+        starting_bias_path = glob.glob(os.path.join(mse_path, ""best_msa_bias*.pt""))[0]
+        starting_weights_path = glob.glob(
+            os.path.join(mse_path, ""best_feat_weights*.pt"")
+        )[0]
+
+    if template_pdb is not None:
+        template_pdb = f""{working_path}/{file_root}/{template_pdb}""
+
+    phase1_config = RocketRefinmentConfig(
+        file_root=file_root,
+        path=working_path,
+        init_recycling=init_recycling,
+        batch_sub_ratio=0.7,
+        number_of_batches=1,
+        rbr_opt_algorithm=""lbfgs"",
+        rbr_lbfgs_learning_rate=150.0,
+        additional_chain=additional_chain,
+        template_pdb=template_pdb,
+        input_msa=input_msa,
+        domain_segs=domain_segs,
+        verbose=False,
+        bias_version=3,
+        num_of_runs=3,
+        iterations=100,
+        cuda_device=cuda_device,
+        solvent=True,
+        sfc_scale=True,
+        refine_sigmaA=True,
+        additive_learning_rate=additive_learning_rate,
+        multiplicative_learning_rate=multiplicative_learning_rate,
+        phase2_final_lr=phase2_final_lr,
+        smooth_stage_epochs=smooth_stage_epochs,
+        free_flag=free_flag,
+        testset_value=testset_value,
+        l2_weight=phase1_w_l2,
+        # b_threshold=10.0,
+        min_resolution=phase1_min_resol,
+        note=""phase1"" + note,
+        uuid_hex=mse_uuid,
+        starting_bias=starting_bias_path,
+        starting_weights=starting_weights_path,
+        voxel_spacing=voxel_spacing,
+        msa_subratio=msa_subratio,
+    )
+
+    return phase1_config
+
+
+def generate_phase2_config(
+    *,
+    phase1_uuid: str | None,
+    working_path: str,
+    file_root: str,
+    cuda_device: int = 0,
+    free_flag: str = ""R-free-flags"",
+    testset_value: int = 1,
+    additional_chain: bool = False,
+    phase1_add_lr: float = 0.05,
+    phase1_mul_lr: float = 1.0,
+    phase1_w_l2: float = 1e-3,
+    phase2_final_lr: float = 1e-3,
+    input_msa: str | None = None,
+    template_pdb: str | None = None,
+    domain_segs: list[int] | None = None,
+    voxel_spacing: float = 4.5,
+    init_recycling: int = 20,
+    note: str = """",
+    w_plddt: float = 0.0,
+    # msa_subratio: Union[float, None] = None,
+) -> RocketRefinmentConfig:
+    if phase1_uuid is None:
+        starting_bias_path = None
+        starting_weights_path = None
+    else:
+        output_directory_path = f""{working_path}/{file_root}/outputs/{phase1_uuid}""
+        phase1_path = glob.glob(f""{output_directory_path}/phase1*/"")[0]
+        starting_bias_path = glob.glob(os.path.join(phase1_path, ""best_msa_bias*.pt""))[
+            0
+        ]
+        starting_weights_path = glob.glob(
+            os.path.join(phase1_path, ""best_feat_weights*.pt"")
+        )[0]
+
+    if input_msa is not None:
+        msa_feat_init_path = glob.glob(os.path.join(phase1_path, ""msa_feat_start.npy""))[
+            0
+        ]
+    else:
+        msa_feat_init_path = None
+        # best_runid = os.path.basename(starting_bias_path).split(""_"")[-2]
+        # if msa_subratio is not None:
+        #     sub_msa_path = glob.glob(os.path.join(phase1_path, f""sub_msa_{best_runid}.npy""))[0]
+        #     sub_delmat_path = glob.glob(os.path.join(phase1_path, f""sub_delmat_{best_runid}.npy""))[0]
+        # else:
+        #     sub_msa_path = None
+        #     sub_delmat_path = None
+
+    if template_pdb is not None:
+        template_pdb = f""{working_path}/{file_root}/{template_pdb}""
+
+    phase2_config = RocketRefinmentConfig(
+        file_root=file_root,
+        path=working_path,
+        batch_sub_ratio=1.0,
+        number_of_batches=1,
+        init_recycling=init_recycling,
+        rbr_opt_algorithm=""lbfgs"",
+        rbr_lbfgs_learning_rate=150.0,
+        smooth_stage_epochs=50,
+        additional_chain=additional_chain,
+        input_msa=input_msa,
+        template_pdb=template_pdb,
+        domain_segs=domain_segs,
+        verbose=False,
+        bias_version=3,
+        iterations=500,
+        cuda_device=cuda_device,
+        solvent=True,
+        sfc_scale=True,
+        refine_sigmaA=True,
+        additive_learning_rate=phase1_add_lr,
+        multiplicative_learning_rate=phase1_mul_lr,
+        phase2_final_lr=phase2_final_lr,
+        weight_decay=None,
+        free_flag=free_flag,
+        testset_value=testset_value,
+        l2_weight=phase1_w_l2,
+        w_plddt=w_plddt,
+        b_threshold=10.0,
+        note=""phase2"" + note,
+        uuid_hex=phase1_uuid,
+        starting_bias=starting_bias_path,
+        starting_weights=starting_weights_path,
+        voxel_spacing=voxel_spacing,
+        msa_subratio=None,
+        msa_feat_init_path=msa_feat_init_path,
+        # sub_msa_path=sub_msa_path,
+        # sub_delmat_path=sub_delmat_path,
+    )
+
+    return phase2_config
+
+
+def run_both_phases_single_dataset(
+    *,
+    working_path,
+    file_root,
+    note,
+    free_flag,
+    testset_value,
+    additional_chain,
+    phase1_add_lr,
+    phase1_mul_lr,
+    phase1_w_l2,
+    w_plddt,
+    phase2_final_lr,
+    smooth_stage_epochs,
+    init_recycling,
+    phase1_min_resol,
+    domain_segs,
+    mse_uuid,
+    voxel_spacing,
+    template_pdb,
+    msa_subratio,
+    input_msa,
+) -> None:
+    phase1_config = generate_phase1_config(
+        working_path=working_path,
+        file_root=file_root,
+        note=note,
+        free_flag=free_flag,
+        testset_value=testset_value,
+        additional_chain=additional_chain,
+        additive_learning_rate=phase1_add_lr,
+        multiplicative_learning_rate=phase1_mul_lr,
+        phase1_w_l2=phase1_w_l2,
+        init_recycling=init_recycling,
+        phase2_final_lr=phase2_final_lr,
+        smooth_stage_epochs=smooth_stage_epochs,
+        phase1_min_resol=phase1_min_resol,
+        template_pdb=template_pdb,
+        input_msa=input_msa,
+        domain_segs=domain_segs,
+        mse_uuid=mse_uuid,
+        voxel_spacing=voxel_spacing,
+        msa_subratio=msa_subratio,
+    )
+    phase1_uuid = run_refinement(config=phase1_config)
+
+    phase2_config = generate_phase2_config(
+        phase1_uuid=phase1_uuid,
+        working_path=working_path,
+        file_root=file_root,
+        note=note,
+        free_flag=free_flag,
+        testset_value=testset_value,
+        additional_chain=additional_chain,
+        phase1_add_lr=phase1_add_lr,
+        phase1_mul_lr=phase1_mul_lr,
+        phase1_w_l2=phase1_w_l2,
+        w_plddt=w_plddt,
+        phase2_final_lr=phase2_final_lr,
+        init_recycling=init_recycling,
+        input_msa=input_msa,
+        template_pdb=template_pdb,
+        domain_segs=domain_segs,
+        voxel_spacing=voxel_spacing,
+    )
+    phase2_uuid = run_refinement(config=phase2_config)
+
+
+def run_both_phases_all_datasets() -> None:
+    args = parse_arguments()
+    datasets = args.systems
+
+    for file_root in datasets:
+        if args.only_phase1:
+            phase1_config = generate_phase1_config(
+                working_path=args.path,
+                file_root=file_root,
+                note=args.note,
+                free_flag=args.free_flag,
+                testset_value=args.testset_value,
+                additional_chain=args.additional_chain,
+                additive_learning_rate=args.phase1_add_lr,
+                multiplicative_learning_rate=args.phase1_mul_lr,
+                phase1_w_l2=args.phase1_w_l2,
+                phase2_final_lr=args.phase2_final_lr,
+                smooth_stage_epochs=args.smooth_stage_epochs,
+                init_recycling=args.init_recycling,
+                phase1_min_resol=args.phase1_min_resol,
+                template_pdb=args.template_pdb,
+                input_msa=args.input_msa,
+                domain_segs=args.domain_segs,
+                mse_uuid=args.mse_uuid,
+                voxel_spacing=args.voxel_spacing,
+                msa_subratio=args.msa_subratio,
+            )
+            phase1_uuid = run_refinement(config=phase1_config)
+
+        elif args.only_phase2:
+            phase2_config = generate_phase2_config(
+                phase1_uuid=args.phase1_uuid,
+                working_path=args.path,
+                free_flag=args.free_flag,
+                testset_value=args.testset_value,
+                file_root=file_root,
+                note=args.note,
+                additional_chain=args.additional_chain,
+                phase1_add_lr=args.phase1_add_lr,
+                phase1_mul_lr=args.phase1_mul_lr,
+                phase1_w_l2=args.phase1_w_l2,
+                w_plddt=args.w_plddt,
+                phase2_final_lr=args.phase2_final_lr,
+                init_recycling=args.init_recycling,
+                input_msa=arg.input_msa,
+                template_pdb=args.template_pdb,
+                domain_segs=args.domain_segs,
+                voxel_spacing=args.voxel_spacing,
+            )
+            phase2_uuid = run_refinement(config=phase2_config)
+
+        else:
+            run_both_phases_single_dataset(
+                working_path=args.path,
+                file_root=file_root,
+                note=args.note,
+                free_flag=args.free_flag,
+                testset_value=args.testset_value,
+                additional_chain=args.additional_chain,
+                phase1_add_lr=args.phase1_add_lr,
+                phase1_mul_lr=args.phase1_mul_lr,
+                phase1_w_l2=args.phase1_w_l2,
+                w_plddt=args.w_plddt,
+                smooth_stage_epochs=args.smooth_stage_epochs,
+                phase2_final_lr=args.phase2_final_lr,
+                init_recycling=args.init_recycling,
+                phase1_min_resol=args.phase1_min_resol,
+                template_pdb=args.template_pdb,
+                domain_segs=args.domain_segs,
+                mse_uuid=args.mse_uuid,
+                voxel_spacing=args.voxel_spacing,
+                msa_subratio=args.msa_subratio,
+                input_msa=args.input_msa,
+            )
+
+
+if __name__ == ""__main__"":
+    run_both_phases_all_datasets()
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/archived_scripts/run_mse.py",".py","3222","140","import argparse
+
+from rocket.refinement_mse import RocketMSERefinmentConfig, run_refinement_mse
+
+
+def parse_arguments():
+    """"""Parse commandline arguments""""""
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawTextHelpFormatter, description=__doc__
+    )
+
+    parser.add_argument(
+        ""-p"",
+        ""--path"",
+        default=""./benchmark_data/"",
+        help=(""Path to the parent folder""),
+    )
+
+    # Required arguments
+    parser.add_argument(
+        ""-sys"",
+        ""--systems"",
+        nargs=""+"",
+        help=(""PDB codes or filename roots for the dataset""),
+    )
+
+    parser.add_argument(
+        ""--add_lr"",
+        default=1e-3,
+        type=float,
+        help=(""additive learning rate""),
+    )
+
+    parser.add_argument(
+        ""--mul_lr"",
+        default=1e-3,
+        type=float,
+        help=(""multiplicative learning rate""),
+    )
+
+    parser.add_argument(
+        ""--num_of_runs"",
+        default=2,
+        type=int,
+        help=(""number of trials""),
+    )
+
+    parser.add_argument(
+        ""--n_step"",
+        default=200,
+        type=int,
+        help=(""number of steps""),
+    )
+
+    parser.add_argument(
+        ""--init_recycling"",
+        default=20,
+        type=int,
+        help=(""number of initial recycling""),
+    )
+
+    parser.add_argument(
+        ""--free_flag"",
+        default=""R-free-flags"",
+        type=str,
+        help=(""Column name of free flag""),
+    )
+
+    parser.add_argument(
+        ""--testset_value"",
+        default=1,
+        type=int,
+        help=(""Value for test set""),
+    )
+
+    parser.add_argument(
+        ""--note"",
+        default="""",
+        help=(""note""),
+    )
+
+    return parser.parse_args()
+
+
+def generate_mse_config(
+    *,
+    working_path: str,
+    file_root: str,
+    cuda_device: int = 0,
+    free_flag: str = ""R-free-flags"",
+    testset_value: int = 1,
+    num_of_runs: int = 1,
+    n_step: int = 50,
+    note: str = """",
+    add_lr: float = 0.05,
+    mul_lr: float = 1.0,
+    init_recycling: int = 20,
+) -> RocketMSERefinmentConfig:
+    mse_config = RocketMSERefinmentConfig(
+        file_root=file_root,
+        path=working_path,
+        init_recycling=init_recycling,
+        rbr_opt_algorithm=""lbfgs"",
+        rbr_lbfgs_learning_rate=150.0,
+        bias_version=3,
+        num_of_runs=num_of_runs,
+        iterations=n_step,
+        cuda_device=cuda_device,
+        additive_learning_rate=add_lr,
+        multiplicative_learning_rate=mul_lr,
+        free_flag=free_flag,
+        testset_value=testset_value,
+        note=""mse"" + note,
+    )
+
+    return mse_config
+
+
+def run_mse_all_datasets() -> None:
+    args = parse_arguments()
+    datasets = args.systems
+    for file_root in datasets:
+        mse_config = generate_mse_config(
+            working_path=args.path,
+            file_root=file_root,
+            note=args.note,
+            add_lr=args.add_lr,
+            mul_lr=args.mul_lr,
+            num_of_runs=args.num_of_runs,
+            n_step=args.n_step,
+            free_flag=args.free_flag,
+            testset_value=args.testset_value,
+            init_recycling=args.init_recycling,
+        )
+        phase1_uuid = run_refinement_mse(config=mse_config)
+
+
+if __name__ == ""__main__"":
+    run_mse_all_datasets()
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/archived_scripts/run_phase1.py",".py","8418","319","import argparse
+import glob
+import os
+
+from rocket.refinement_xray import RocketRefinmentConfig, run_refinement
+
+
+def int_or_none(value):
+    if value.lower() == ""none"":
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError(
+            f""Invalid value: {value}. Must be an integer or 'None'.""
+        )
+
+
+def float_or_none(value):
+    if value.lower() == ""none"":
+        return None
+    try:
+        return float(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError(
+            f""Invalid value: {value}. Must be an float or 'None'.""
+        )
+
+
+def parse_arguments():
+    """"""Parse commandline arguments""""""
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawTextHelpFormatter, description=__doc__
+    )
+
+    parser.add_argument(
+        ""-p"",
+        ""--path"",
+        default=""./benchmark_data/"",
+        help=(""Path to the parent folder""),
+    )
+
+    # Required arguments
+    parser.add_argument(
+        ""-sys"",
+        ""--systems"",
+        nargs=""+"",
+        help=(""PDB codes or filename roots for the dataset""),
+    )
+
+    parser.add_argument(
+        ""--template_pdb"",
+        default=None,
+        help=(""template model name in the path""),
+    )
+
+    parser.add_argument(
+        ""--domain_segs"",
+        type=int,
+        nargs=""*"",
+        default=None,
+        help=(""A list of resid as domain boundaries""),
+    )
+
+    parser.add_argument(
+        ""--free_flag"",
+        default=""R-free-flags"",
+        type=str,
+        help=(""Column name of free flag""),
+    )
+
+    parser.add_argument(
+        ""--testset_value"",
+        default=1,
+        type=int,
+        help=(""Value for test set""),
+    )
+
+    parser.add_argument(
+        ""--additional_chain"", action=""store_true"", help=(""Additional Chain in ASU"")
+    )
+
+    parser.add_argument(
+        ""--w_l2"",
+        default=1e-11,
+        type=float,
+        help=(""weight for L2 loss""),
+    )
+
+    parser.add_argument(
+        ""--sub_ratio"",
+        default=0.7,
+        type=float,
+        help=(""Sub ratio of reflectios for each iteratio""),
+    )
+
+    parser.add_argument(
+        ""--add_lr"",
+        default=0.05,
+        type=float,
+        help=(""additive learning rate""),
+    )
+
+    parser.add_argument(
+        ""--mul_lr"",
+        default=1.0,
+        type=float,
+        help=(""multiplicative learning rate""),
+    )
+
+    parser.add_argument(""--mse_uuid"", default=None, help=(""uuid for mse run""))
+
+    parser.add_argument(
+        ""--phase2_final_lr"",
+        default=1e-3,
+        type=float,
+        help=(""phase 2 final learning rate""),
+    )
+
+    parser.add_argument(
+        ""--smooth_stage_epochs"",
+        default=50,
+        type=int_or_none,
+        help=(""number of smooth stages in phase1""),
+    )
+    parser.add_argument(
+        ""--num_of_runs"",
+        default=3,
+        type=int,
+        help=(""number of trials""),
+    )
+
+    parser.add_argument(
+        ""--n_step"",
+        default=100,
+        type=int,
+        help=(""number of steps""),
+    )
+
+    parser.add_argument(""--refine_sigmaA"", action=""store_true"", help=(""refine sigmaAs""))
+
+    parser.add_argument(
+        ""--min_resolution"",
+        default=3.0,
+        type=float,
+        help=(""min resolution cut""),
+    )
+
+    parser.add_argument(
+        ""--init_recycling"",
+        default=20,
+        type=int,
+        help=(""number of initial recycling""),
+    )
+
+    parser.add_argument(
+        ""--note"",
+        default="""",
+        help=(""note""),
+    )
+
+    parser.add_argument(
+        ""--voxel_spacing"",
+        default=4.5,
+        type=float,
+        help=(""Voxel spacing for solvent percentage estimation""),
+    )
+
+    parser.add_argument(
+        ""--msa_subratio"",
+        default=None,
+        type=float_or_none,
+        help=(
+            ""MSA subsampling ratio, between 0.0 and 1.0. Default None, no subsampling.""
+        ),
+    )
+
+    parser.add_argument(
+        ""--input_msa"",
+        default=None,
+        help=(
+            ""path to msa file .a3m/.fasta for use, working path and system will prepend""
+        ),
+    )
+
+    parser.add_argument(
+        ""--bias_from_fullmsa"",
+        action=""store_true"",
+        help=(""Generate initial profile via biasing from full msa profile""),
+    )
+
+    parser.add_argument(
+        ""--chimera_profile"", action=""store_true"", help=(""Use chimera profile"")
+    )
+
+    return parser.parse_args()
+
+
+def generate_phase1_config(
+    *,
+    working_path: str,
+    file_root: str,
+    cuda_device: int = 0,
+    free_flag: str = ""R-free-flags"",
+    testset_value: int = 1,
+    additional_chain: bool = False,
+    w_l2: float = 1e-11,
+    num_of_runs: int = 1,
+    sub_ratio: float = 0.7,
+    n_step: int = 50,
+    init_recycling: int = 20,
+    min_resol: float = 3.0,
+    note: str = """",
+    refine_sigmaA: bool = True,
+    input_msa: str | None = None,
+    bias_from_fullmsa: bool = False,
+    chimera_profile: bool = False,
+    template_pdb: str | None = None,
+    domain_segs: list[int] | None = None,
+    add_lr: float = 0.05,
+    mul_lr: float = 1.0,
+    phase2_final_lr: float = 1e-3,
+    smooth_stage_epochs: int = 50,
+    mse_uuid: str | None = None,
+    voxel_spacing: float = 4.5,
+    msa_subratio: float | None = None,
+) -> RocketRefinmentConfig:
+    if mse_uuid is None:
+        starting_bias_path = None
+        starting_weights_path = None
+    else:
+        output_directory_path = f""{working_path}/{file_root}/outputs/{mse_uuid}""
+        mse_path = glob.glob(f""{output_directory_path}/mse*/"")[0]
+        starting_bias_path = glob.glob(os.path.join(mse_path, ""best_msa_bias*.pt""))[0]
+        starting_weights_path = glob.glob(
+            os.path.join(mse_path, ""best_feat_weights*.pt"")
+        )[0]
+
+    if template_pdb is not None:
+        template_pdb = f""{working_path}/{file_root}/{template_pdb}""
+
+    phase1_config = RocketRefinmentConfig(
+        file_root=file_root,
+        path=working_path,
+        init_recycling=init_recycling,
+        batch_sub_ratio=sub_ratio,
+        number_of_batches=1,
+        rbr_opt_algorithm=""lbfgs"",
+        rbr_lbfgs_learning_rate=150.0,
+        additional_chain=additional_chain,
+        domain_segs=domain_segs,
+        verbose=False,
+        bias_version=3,
+        num_of_runs=num_of_runs,
+        iterations=n_step,
+        # iterations=2,
+        input_msa=input_msa,
+        bias_from_fullmsa=bias_from_fullmsa,
+        chimera_profile=chimera_profile,
+        template_pdb=template_pdb,
+        cuda_device=cuda_device,
+        solvent=True,
+        sfc_scale=True,
+        refine_sigmaA=refine_sigmaA,
+        additive_learning_rate=add_lr,
+        multiplicative_learning_rate=mul_lr,
+        phase2_final_lr=phase2_final_lr,
+        smooth_stage_epochs=smooth_stage_epochs,
+        free_flag=free_flag,
+        testset_value=testset_value,
+        l2_weight=w_l2,
+        min_resolution=min_resol,
+        starting_bias=starting_bias_path,
+        starting_weights=starting_weights_path,
+        note=""phase1"" + note,
+        voxel_spacing=voxel_spacing,
+        msa_subratio=msa_subratio,
+    )
+
+    return phase1_config
+
+
+def run_phase1_all_datasets() -> None:
+    args = parse_arguments()
+    datasets = args.systems
+    for file_root in datasets:
+        phase1_config = generate_phase1_config(
+            working_path=args.path,
+            file_root=file_root,
+            note=args.note,
+            free_flag=args.free_flag,
+            testset_value=args.testset_value,
+            additional_chain=args.additional_chain,
+            domain_segs=args.domain_segs,
+            init_recycling=args.init_recycling,
+            w_l2=args.w_l2,
+            sub_ratio=args.sub_ratio,
+            add_lr=args.add_lr,
+            mul_lr=args.mul_lr,
+            num_of_runs=args.num_of_runs,
+            n_step=args.n_step,
+            input_msa=args.input_msa,
+            bias_from_fullmsa=args.bias_from_fullmsa,
+            chimera_profile=args.chimera_profile,
+            template_pdb=args.template_pdb,
+            refine_sigmaA=args.refine_sigmaA,
+            min_resol=args.min_resolution,
+            phase2_final_lr=args.phase2_final_lr,
+            smooth_stage_epochs=args.smooth_stage_epochs,
+            mse_uuid=args.mse_uuid,
+            voxel_spacing=args.voxel_spacing,
+            msa_subratio=args.msa_subratio,
+        )
+        phase1_uuid = run_refinement(config=phase1_config)
+
+
+if __name__ == ""__main__"":
+    run_phase1_all_datasets()
+","Python"
+"AlphaFold","alisiafadini/ROCKET","rocket/scripts/archived_scripts/run_plddtoptimize.py",".py","12294","405","import argparse
+import glob
+import os
+import time
+import uuid
+import warnings
+
+import numpy as np
+import torch
+from openfold.config import model_config
+from SFC_Torch import PDBParser
+from tqdm import tqdm
+
+import rocket
+from rocket import refinement_utils as rkrf_utils
+from rocket import utils as rk_utils
+
+PRESET = ""model_1""
+
+
+def int_or_none(value):
+    if value.lower() == ""none"":
+        return None
+    try:
+        return int(value)
+    except ValueError as err:
+        raise argparse.ArgumentTypeError(
+            f""Invalid value: {value}. Must be an integer or 'None'.""
+        ) from err
+
+
+def float_or_none(value):
+    if value.lower() == ""none"":
+        return None
+    try:
+        return float(value)
+    except ValueError as err:
+        raise argparse.ArgumentTypeError(
+            f""Invalid value: {value}. Must be an float or 'None'.""
+        ) from err
+
+
+def parse_arguments():
+    """"""Parse commandline arguments""""""
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawTextHelpFormatter, description=__doc__
+    )
+
+    parser.add_argument(
+        ""-p"",
+        ""--path"",
+        default=""./benchmark_data/"",
+        help=(""Path to the parent folder""),
+    )
+
+    # Required arguments
+    parser.add_argument(
+        ""-sys"",
+        ""--systems"",
+        nargs=""+"",
+        help=(""PDB codes or filename roots for the dataset""),
+    )
+
+    parser.add_argument(
+        ""--note"",
+        default="""",
+        help=(""note""),
+    )
+
+    parser.add_argument(
+        ""--domain_segs"",
+        type=int,
+        nargs=""*"",
+        default=None,
+        help=(""A list of resid as domain boundaries""),
+    )
+
+    parser.add_argument(
+        ""--init_recycling"",
+        default=20,
+        type=int,
+        help=(""number of initial recycling""),
+    )
+
+    parser.add_argument(
+        ""--phase1_add_lr"",
+        default=0.05,
+        type=float,
+        help=(""phase 1 additive learning rate""),
+    )
+
+    parser.add_argument(
+        ""--phase1_mul_lr"",
+        default=1.0,
+        type=float,
+        help=(""phase 1 multiplicative learning rate""),
+    )
+
+    parser.add_argument(
+        ""--phase1_w_l2"",
+        default=1e-11,
+        type=float,
+        help=(""phase 1 weights of L2 loss""),
+    )
+
+    parser.add_argument(
+        ""--phase2_final_lr"",
+        default=1e-3,
+        type=float,
+        help=(""phase 2 final learning rate""),
+    )
+
+    parser.add_argument(
+        ""--smooth_stage_epochs"",
+        default=50,
+        type=int_or_none,
+        help=(""number of smooth stages in phase1""),
+    )
+
+    return parser.parse_args()
+
+
+def run_plddt_optim(
+    working_path: str,
+    file_root: str,
+    note: str,
+    lr_a: float,
+    lr_m: float,
+    iterations: int,
+    init_recycling: int = 20,
+    phase2_final_lr: float = 1e-3,
+    weight_decay: float | None = 0.0001,
+    smooth_stage_epochs: int | None = 50,
+    l2_weight: float = 0.0,
+    cuda_device: int = 0,
+    starting_bias=None,
+    starting_weights=None,
+    uuid_hex=None,
+    domain_segs=None,
+):
+    device = f""cuda:{cuda_device}""
+    input_pdb = f""{working_path}/{file_root}/{file_root}-pred-aligned.pdb""
+
+    run_uuid = uuid.uuid4().hex if uuid_hex is None else uuid_hex
+
+    output_directory_path = f""{working_path}/{file_root}/outputs/{run_uuid}/{note}""
+    try:
+        os.makedirs(output_directory_path, exist_ok=True)
+    except FileExistsError:
+        print(
+            f""Warning: Directory '{output_directory_path}' already exists. Overwriting...""  # noqa: E501
+        )
+    print(
+        f""System: {file_root}, refinment run ID: {run_uuid!s}, Note: {note}"",
+        flush=True,
+    )
+    warnings.filterwarnings(""ignore"")
+
+    initial_model = PDBParser(input_pdb)
+    reference_pos = rk_utils.assert_tensor(
+        initial_model.atom_pos, arr_type=torch.float32, device=device
+    ).clone()
+    init_pos_bfactor = rk_utils.assert_tensor(
+        initial_model.atom_b_iso, arr_type=torch.float32, device=device
+    ).clone()
+    bfactor_weights = rk_utils.weighting_torch(init_pos_bfactor, cutoff2=20.0)
+
+    af_bias = rocket.MSABiasAFv3(model_config(PRESET, train=True), PRESET).to(device)
+    af_bias.freeze()  # Free all AF2 parameters to save time
+
+    device_processed_features, feature_key, features_at_it_start = (
+        rkrf_utils.init_processed_dict(
+            bias_version=3,
+            path=working_path,
+            file_root=file_root,
+            device=device,
+            template_pdb=None,
+            target_seq=None,
+            PRESET=PRESET,
+        )
+    )
+
+    device_processed_features, optimizer, bias_names = rkrf_utils.init_bias(
+        device_processed_features=device_processed_features,
+        bias_version=3,
+        device=device,
+        lr_a=lr_a,
+        lr_m=lr_m,
+        weight_decay=weight_decay,
+        starting_bias=starting_bias,
+        starting_weights=starting_weights,
+        recombination_bias=None,
+    )
+
+    L_plddt_it = []
+    all_pldtts = []
+    time_by_epoch = []
+    memory_by_epoch = []
+    best_plddt = 0.0
+    progress_bar = tqdm(
+        range(iterations),
+        desc=f""{file_root}, uuid: {run_uuid[:4]}"",
+    )
+
+    # Run smooth stage in phase 1
+    w_L2 = l2_weight
+    early_stopper = rkrf_utils.EarlyStopper(patience=100, min_delta=1.0)
+
+    if smooth_stage_epochs is not None:
+        lr_a_initial = lr_a
+        lr_m_initial = lr_m
+        w_L2_initial = w_L2
+        lr_stage1_final = phase2_final_lr
+
+        # Decay rates for each stage
+        decay_rate_stage1_add = (lr_stage1_final / lr_a) ** (1 / smooth_stage_epochs)
+        decay_rate_stage1_mul = (lr_stage1_final / lr_m) ** (1 / smooth_stage_epochs)
+
+    for iteration in progress_bar:
+        start_time = time.time()
+        optimizer.zero_grad()
+
+        # Avoid passing through graph a second time
+        device_processed_features[feature_key] = features_at_it_start.detach().clone()
+        # working_batch = copy.deepcopy(device_processed_features)
+        # for bias in bias_names:
+        #     working_batch[bias] = device_processed_features[bias].clone()
+
+        # AF pass
+        if iteration == 0:
+            af2_output, prevs = af_bias(
+                device_processed_features,
+                [None, None, None],
+                num_iters=init_recycling,
+                bias=False,
+            )
+            prevs = [tensor.detach() for tensor in prevs]
+
+            # # MH @ June 19: Fix the iteration 0 for phase 2 running
+            # print(""config.starting_bias"", config.starting_bias)
+            # if (config.starting_bias is not None) or (
+            #     config.starting_weights is not None
+            # ):
+            #     deep_copied_prevs = [tensor.clone().detach() for tensor in prevs]
+            #     af2_output, __ = af_bias(
+            #         device_processed_features,
+            #         deep_copied_prevs,
+            #         num_iters=1,
+            #         bias=True,
+            #     )
+        deep_copied_prevs = [tensor.clone().detach() for tensor in prevs]
+        af2_output, __ = af_bias(
+            device_processed_features, deep_copied_prevs, num_iters=1, bias=True
+        )
+
+        # pLDDT loss
+        L_plddt = -torch.mean(af2_output[""plddt""])
+
+        # Position Kabsch Alignment
+        aligned_xyz, plddts_res, pseudo_Bs = rkrf_utils.position_alignment(
+            af2_output=af2_output,
+            device_processed_features=device_processed_features,
+            cra_name=initial_model.cra_name,
+            best_pos=reference_pos,
+            exclude_res=None,
+            domain_segs=domain_segs,
+            reference_bfactor=init_pos_bfactor,
+        )
+        all_pldtts.append(plddts_res)
+        L_plddt_it.append(L_plddt.item())
+
+        initial_model.set_positions(rk_utils.assert_numpy(aligned_xyz.detach().clone()))
+        initial_model.set_biso(rk_utils.assert_numpy(pseudo_Bs.detach().clone()))
+        initial_model.savePDB(f""{output_directory_path!s}/{iteration}_preRBR.pdb"")
+
+        if L_plddt_it[-1] < best_plddt:
+            best_plddt = L_plddt_it[-1]
+            best_msa_bias = (
+                device_processed_features[""msa_feat_bias""].detach().cpu().clone()
+            )
+            best_feat_weights = (
+                device_processed_features[""msa_feat_weights""].detach().cpu().clone()
+            )
+            best_iter = iteration
+            # best_pos = aligned_xyz.detach().clone()
+
+        if w_L2 > 0.0:
+            # use
+            L2_loss = torch.sum(
+                bfactor_weights.unsqueeze(-1) * (aligned_xyz - reference_pos) ** 2
+            )  # / conf_best.shape[0]
+            loss = w_L2 * L2_loss + L_plddt
+            loss.backward()
+        else:
+            loss = L_plddt
+            loss.backward()
+            if early_stopper.early_stop(loss.item()):
+                break
+
+        # Do smooth in last several iterations of phase 1 instead of beginning of phase 2
+        if (""phase1"" in note) and (smooth_stage_epochs is not None):
+            if iteration > (iterations - smooth_stage_epochs):
+                lr_a = lr_a_initial * (decay_rate_stage1_add**iteration)
+                lr_m = lr_m_initial * (decay_rate_stage1_mul**iteration)
+                w_L2 = w_L2_initial * (1 - (iteration / smooth_stage_epochs))
+            # Update the learning rates in the optimizer
+            optimizer.param_groups[0][""lr""] = lr_a
+            optimizer.param_groups[1][""lr""] = lr_m
+            optimizer.step()
+        else:
+            optimizer.step()
+
+        time_by_epoch.append(time.time() - start_time)
+        memory_by_epoch.append(torch.cuda.max_memory_allocated() / 1024**3)
+        progress_bar.set_postfix(
+            plddt=f""{L_plddt.item():.2f}"",
+            memory=f""{torch.cuda.max_memory_allocated() / 1024**3:.1f}G"",
+        )
+
+    np.save(
+        f""{output_directory_path!s}/mean_it_plddt.npy"",
+        np.array(L_plddt_it),
+    )
+
+    np.save(
+        f""{output_directory_path!s}/plddt_res.npy"",
+        np.array(all_pldtts),
+    )
+
+    np.save(
+        f""{output_directory_path!s}/time_it.npy"",
+        rk_utils.assert_numpy(time_by_epoch),
+    )
+
+    np.save(
+        f""{output_directory_path!s}/memory_it.npy"",
+        rk_utils.assert_numpy(memory_by_epoch),
+    )
+
+    # Save the best msa_bias and feat_weights
+    torch.save(
+        best_msa_bias,
+        f""{output_directory_path!s}/best_msa_bias_{best_iter}.pt"",
+    )
+
+    torch.save(
+        best_feat_weights,
+        f""{output_directory_path!s}/best_feat_weights_{best_iter}.pt"",
+    )
+
+    return run_uuid
+
+
+def main():
+    args = parse_arguments()
+    datasets = args.systems
+
+    for file_root in datasets:
+        phase1_uuid = run_plddt_optim(
+            working_path=args.path,
+            file_root=file_root,
+            note=""phase1"" + args.note,
+            iterations=100,
+            lr_a=args.phase1_add_lr,
+            lr_m=args.phase1_mul_lr,
+            init_recycling=args.init_recycling,
+            weight_decay=0.0001,
+            smooth_stage_epochs=args.smooth_stage_epochs,
+            l2_weight=args.phase1_w_l2,
+            cuda_device=0,
+            phase2_final_lr=args.phase2_final_lr,
+            starting_bias=None,
+            starting_weights=None,
+            uuid_hex=None,
+            domain_segs=args.domain_segs,
+        )
+
+        output_directory_path = f""{args.path}/{file_root}/outputs/{phase1_uuid}""
+        phase1_path = glob.glob(f""{output_directory_path}/phase1*/"")[0]
+        starting_bias_path = glob.glob(os.path.join(phase1_path, ""best_msa_bias*.pt""))[
+            0
+        ]
+        starting_weights_path = glob.glob(
+            os.path.join(phase1_path, ""best_feat_weights*.pt"")
+        )[0]
+
+        phase2_uuid = run_plddt_optim(
+            working_path=args.path,
+            file_root=file_root,
+            note=""phase2"" + args.note,
+            iterations=500,
+            lr_a=args.phase2_final_lr,
+            lr_m=args.phase2_final_lr,
+            init_recycling=args.init_recycling,
+            weight_decay=None,
+            smooth_stage_epochs=None,
+            l2_weight=0.0,
+            cuda_device=0,
+            phase2_final_lr=args.phase2_final_lr,
+            starting_bias=starting_bias_path,
+            starting_weights=starting_weights_path,
+            uuid_hex=phase1_uuid,
+            domain_segs=args.domain_segs,
+        )
+","Python"
+"AlphaFold","inductive-bio/strong-docking-baseline","evaluate_results.py",".py","3756","100","# Uses the PoseBusters library to evaluate the results of the baselines.
+# It saves the results in the `results` directory.
+import argparse
+import multiprocessing
+import os
+from pathlib import Path
+
+import pandas as pd
+from posebusters import PoseBusters
+from rdkit import RDLogger
+from rdkit.Chem import PandasTools
+
+
+def bust_complex(base_path, complex_id, suffix, use_vina_order=False):
+    """"""
+    Bust predictions for the top pose of a complex.
+
+    The use_vina_order argument can be used to re-order the poses by the
+    minimizedAffinity property before busting the top pose. This is useful since
+    we've saved the poses in the gnina-ranked order.
+    """"""
+    RDLogger.DisableLog(""rdApp.*"")
+    if use_vina_order:
+        # save a copy of the poses with the vina order
+        poses = PandasTools.LoadSDF(
+            Path(base_path, complex_id, f""{complex_id}{suffix}.sdf"")
+        )
+        poses[""minimizedAffinity""] = poses[""minimizedAffinity""].astype(float)
+        vina_order = poses.sort_values(""minimizedAffinity"").reset_index(drop=True)
+        pred_file = Path(base_path, complex_id, f""{complex_id}{suffix}_vina_order.sdf"")
+        PandasTools.WriteSDF(
+            vina_order,
+            pred_file,
+            properties=list(poses.columns),
+        )
+    else:
+        pred_file = Path(base_path, complex_id, f""{complex_id}{suffix}.sdf"")
+    true_file = Path(base_path, complex_id, f""{complex_id}_ligand.sdf"")
+    receptor_file = Path(base_path, complex_id, f""{complex_id}_protein.pdb"")
+    buster = PoseBusters(top_n=1)
+    df = buster.bust([pred_file], true_file, receptor_file)
+    df = df.reset_index(drop=True).assign(complex_id=complex_id)
+    return df
+
+
+if __name__ == ""__main__"":
+    RDLogger.DisableLog(""rdApp.*"")
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        ""--base_path"",
+        type=str,
+        help=""dir containing posebusters_paper_data and posebusters_308_ids.csv"",
+    )
+    args = parser.parse_args()
+    base_path = args.base_path
+    if base_path is None:
+        base_path = os.path.dirname(os.path.abspath(__file__))
+    posebusters_308 = pd.read_csv(os.path.join(base_path, ""posebusters_308_ids.csv""))
+    posebusters_308[""complex_id""] = (
+        posebusters_308[""pdb_id""] + ""_"" + posebusters_308[""ccd_id""]
+    )
+    num_processes = multiprocessing.cpu_count()
+    os.makedirs(os.path.join(base_path, ""results""), exist_ok=True)
+    for name, args in {
+        ""vina_single_conformer"": (""_single_conf_poses"", True),
+        ""gnina_single_conformer"": (""_single_conf_poses"", False),
+        ""vina_multiple_conformers"": (""_multiple_confs_poses"", True),
+        ""gnina_multiple_conformers"": (""_multiple_confs_poses"", False),
+    }.items():
+        # PoseBusters is a bit slow, so parallelize
+        with multiprocessing.Pool(num_processes) as p:
+            results = p.starmap(
+                bust_complex,
+                [
+                    (
+                        Path(
+                            base_path,
+                            ""posebusters_paper_data/posebusters_benchmark_set"",
+                        ),
+                        complex_id,
+                        args[0],
+                        args[1],
+                    )
+                    for complex_id in posebusters_308[""complex_id""]
+                ],
+            )
+        full_df = pd.concat(results, ignore_index=True)
+        full_df.to_csv(
+            os.path.join(base_path, f""results/posebusters_results_{name}.csv""),
+            index=False,
+        )
+        full_df = full_df.set_index(""complex_id"")
+        print(""Method:"", name)
+        print(
+            ""PB-valid:"",
+            full_df.all(axis=1).mean(),
+            ""RMSD<2:"",
+            full_df[""rmsd_≤_2å""].mean(),
+        )
+","Python"
+"AlphaFold","inductive-bio/strong-docking-baseline","run_single_conformer_baseline.py",".py","3598","108","# runs smina/vina docking and gnina rescoring, using only a single
+# starting conformation.
+import argparse
+import os
+import shutil
+import subprocess
+
+import pandas as pd
+from rdkit import Chem
+from rdkit.Chem import AllChem, rdMolTransforms
+
+
+def protonate_receptor_and_ligand(folder, complex_id):
+    # This function is the same as in run_strong_baseline.py
+    if complex_id[:4] == ""8CSD"":
+        # 8CSD is already protonated and crashes reduce, so just copy it over
+        shutil.copy(
+            os.path.join(folder, f""{complex_id}_protein.pdb""),
+            os.path.join(folder, f""{complex_id}_H.pdb""),
+        )
+    else:
+        protein_in = os.path.join(folder, f""{complex_id}_protein.pdb"")
+        protein_out = os.path.join(folder, f""{complex_id}_H.pdb"")
+        with open(protein_out, ""w"") as f:
+            subprocess.run(
+                [""reduce"", ""-BUILD"", protein_in],
+                stdout=f,
+                stderr=subprocess.DEVNULL,
+                check=False,
+            )
+    ligand_in = os.path.join(folder, f""{complex_id}_ligand_start_conf.sdf"")
+    ligand_out = os.path.join(folder, f""{complex_id}_ligand_start_conf_H.sdf"")
+    subprocess.run([""obabel"", ligand_in, ""-O"", ligand_out, ""-p"", ""7.4""], check=False)
+
+
+def generate_conformer(folder, complex_id):
+    mol = Chem.MolFromMolFile(
+        os.path.join(folder, f""{complex_id}_ligand_start_conf_H.sdf"")
+    )
+    mol.RemoveAllConformers()
+    mol = Chem.AddHs(mol)
+    AllChem.EmbedMolecule(mol, randomSeed=1)
+    AllChem.UFFOptimizeMolecule(mol)
+    Chem.MolToMolFile(mol, os.path.join(folder, f""{complex_id}_ligand_single_conf.sdf""))
+
+
+def run_docking(folder, complex_id):
+    crystal_ligand = Chem.MolFromMolFile(
+        os.path.join(folder, f""{complex_id}_ligand.sdf"")
+    )
+    center = rdMolTransforms.ComputeCentroid(crystal_ligand.GetConformer())
+    subprocess.run(
+        [
+            ""gnina"",
+            ""-r"",
+            os.path.join(folder, f""{complex_id}_H.pdb""),
+            ""-l"",
+            os.path.join(folder, f""{complex_id}_ligand_single_conf.sdf""),
+            ""-o"",
+            os.path.join(folder, f""{complex_id}_single_conf_poses.sdf""),
+            ""--center_x"",  # bounding box matching PoseBusters methodology
+            str(center.x),
+            ""--center_y"",
+            str(center.y),
+            ""--center_z"",
+            str(center.z),
+            ""--size_x"",
+            ""25"",
+            ""--size_y"",
+            ""25"",
+            ""--size_z"",
+            ""25"",
+            ""--scoring"",
+            ""vina"",
+            ""--exhaustiveness"",
+            ""32"",
+            ""--num_modes"",
+            ""40"",
+            ""--seed"",
+            ""1"",
+        ],
+        check=False,
+    )
+
+
+if __name__ == ""__main__"":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        ""--base_path"",
+        type=str,
+        help=""dir containing posebusters_paper_data and posebusters_308_ids.csv"",
+    )
+    args = parser.parse_args()
+    base_path = args.base_path
+    if base_path is None:
+        base_path = os.path.dirname(os.path.abspath(__file__))
+    posebusters_308 = pd.read_csv(os.path.join(base_path, ""posebusters_308_ids.csv""))
+    posebusters_308[""complex_id""] = (
+        posebusters_308[""pdb_id""] + ""_"" + posebusters_308[""ccd_id""]
+    )
+    for complex_id in posebusters_308[""complex_id""]:
+        folder = os.path.join(
+            base_path, ""posebusters_paper_data/posebusters_benchmark_set"", complex_id
+        )
+        protonate_receptor_and_ligand(folder, complex_id)
+        generate_conformer(folder, complex_id)
+        run_docking(folder, complex_id)
+","Python"
+"AlphaFold","inductive-bio/strong-docking-baseline","run_strong_baseline.py",".py","4256","121","# Runs the full strong baseline, including smina/vina docking,
+# gnina rescoring, and an input conformational ensemble.
+import argparse
+import os
+import shutil
+import subprocess
+
+import pandas as pd
+from rdkit import Chem
+from rdkit.Chem import AllChem, PandasTools, rdMolTransforms
+
+
+def protonate_receptor_and_ligand(folder, complex_id):
+    # This function is the same as in run_single_conformer_baseline.py
+    if complex_id[:4] == ""8CSD"":
+        # 8CSD is already protonated and crashes reduce, so just copy it over
+        shutil.copy(
+            os.path.join(folder, f""{complex_id}_protein.pdb""),
+            os.path.join(folder, f""{complex_id}_H.pdb""),
+        )
+    else:
+        protein_in = os.path.join(folder, f""{complex_id}_protein.pdb"")
+        protein_out = os.path.join(folder, f""{complex_id}_H.pdb"")
+        with open(protein_out, ""w"") as f:
+            subprocess.run(
+                [""reduce"", ""-BUILD"", protein_in],
+                stdout=f,
+                stderr=subprocess.DEVNULL,
+            )
+    ligand_in = os.path.join(folder, f""{complex_id}_ligand_start_conf.sdf"")
+    ligand_out = os.path.join(folder, f""{complex_id}_ligand_start_conf_H.sdf"")
+    subprocess.run([""obabel"", ligand_in, ""-O"", ligand_out, ""-p"", ""7.4""])
+
+
+def generate_conformers(folder, complex_id, num_confs=8):
+    mol = Chem.MolFromMolFile(
+        os.path.join(folder, f""{complex_id}_ligand_start_conf_H.sdf"")
+    )
+    mol.RemoveAllConformers()
+    mol = Chem.AddHs(mol)
+    AllChem.EmbedMultipleConfs(mol, numConfs=num_confs, randomSeed=1)
+    AllChem.UFFOptimizeMoleculeConfs(mol)
+    with Chem.SDWriter(
+        os.path.join(folder, f""{complex_id}_ligand_multiple_confs.sdf"")
+    ) as writer:
+        for cid in range(mol.GetNumConformers()):
+            writer.write(mol, confId=cid)
+
+
+def run_docking(folder, complex_id):
+    crystal_ligand = Chem.MolFromMolFile(
+        os.path.join(folder, f""{complex_id}_ligand.sdf"")
+    )
+    center = rdMolTransforms.ComputeCentroid(crystal_ligand.GetConformer())
+    subprocess.run(
+        [
+            ""gnina"",
+            ""-r"",
+            os.path.join(folder, f""{complex_id}_H.pdb""),
+            ""-l"",
+            os.path.join(folder, f""{complex_id}_ligand_multiple_confs.sdf""),
+            ""-o"",
+            os.path.join(folder, f""{complex_id}_multiple_confs_poses.sdf""),
+            ""--center_x"",  # bounding box matching PoseBusters methodology
+            str(center.x),
+            ""--center_y"",
+            str(center.y),
+            ""--center_z"",
+            str(center.z),
+            ""--size_x"",
+            ""25"",
+            ""--size_y"",
+            ""25"",
+            ""--size_z"",
+            ""25"",
+            ""--scoring"",
+            ""vina"",
+            ""--exhaustiveness"",
+            ""4"",
+            ""--num_modes"",
+            ""10"",
+            ""--seed"",
+            ""1"",
+        ]
+    )
+    # sort the poses from the multiple conformation runs, so overall best is first
+    poses = PandasTools.LoadSDF(
+        os.path.join(folder, f""{complex_id}_multiple_confs_poses.sdf"")
+    )
+    poses[""CNNscore""] = poses[""CNNscore""].astype(float)
+    gnina_order = poses.sort_values(""CNNscore"", ascending=False).reset_index(drop=True)
+    PandasTools.WriteSDF(
+        gnina_order,
+        os.path.join(folder, f""{complex_id}_multiple_confs_poses.sdf""),
+        properties=list(poses.columns),
+    )
+
+
+if __name__ == ""__main__"":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        ""--base_path"",
+        type=str,
+        help=""dir containing posebusters_benchmark_set and posebusters_308_ids.csv"",
+    )
+    args = parser.parse_args()
+    base_path = args.base_path
+    if base_path is None:
+        base_path = os.path.dirname(os.path.abspath(__file__))
+    posebusters_308 = pd.read_csv(os.path.join(base_path, ""posebusters_308_ids.csv""))
+    posebusters_308[""complex_id""] = (
+        posebusters_308[""pdb_id""] + ""_"" + posebusters_308[""ccd_id""]
+    )
+    for complex_id in posebusters_308[""complex_id""]:
+        folder = os.path.join(
+            base_path, ""posebusters_paper_data/posebusters_benchmark_set"", complex_id
+        )
+        protonate_receptor_and_ligand(folder, complex_id)
+        generate_conformers(folder, complex_id)
+        run_docking(folder, complex_id)
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","align_ptm.py",".py","12131","334","# Import
+import os
+import sys
+import pickle
+import csv
+import sys
+import time
+import numpy as np
+import argparse
+from scipy.stats import rankdata
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.2.1_(2021Dec.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program align output pdb file  and extract pae plddt values from [result_model_ptm.pkl] to [.csv] "")
+print(""Thanks Dr. Yoshitaka Moriwaki (@Ag_smith) for initially showing how to export predicted aligned error in alphafold2."")
+print(""You need to change model_names to model_?_ptm from model_? at /Docker/run_docker.py."")
+print(""for Alphafold2.1.1"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(            description=""The program extract pae from [result_model.pkl] to [.csv]"")
+parser.add_argument('-i', default='result_model',   help='input XXXXX if [XXXXX_Y_ptm.pkl]; ex) result_model (def.)')
+parser.add_argument('-m', default='relaxed_model',  help='input ZZZZZ if [ZZZZZ_Y_ptm.pdb]; ex) result_model (def.)')
+parser.add_argument('-n', default='5',              help='input Y if you want open [XXXXX_1_ptm.pkl,XXXXX_2_ptm.pkl ... ,XXXXX_5_ptm.pkl]; ex) 5 (def.)')
+parser.add_argument('-d', default='',               help='ignored residue number for average pLDDTs caliculation to determined the ranking of models [1-5_56-75_105-135]; ex) """" (def.)')
+parser.add_argument('-al1', default=0,              help='Center the mid point of al1 and al3, the point (al1) shift on x-axis')
+parser.add_argument('-al2', default=0,              help='The point (al2) shift on xy-plane')
+parser.add_argument('-al3', default=0,              help='Center the mid point of al1 and al3, the point (al3) shift on x-asis and opozit site of al1')
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""_?_ptm.pkl"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+mname=str(args.m)
+print(""Input file name:""+str(mname)+""_?_ptm.pdb"")
+print(""It can be changed by [-m ""+iname+""]"")
+print("""")
+
+# Number of models
+namen=int(str(args.n))
+
+# Ignore residue
+dres=str(args.d)
+ures=dres.split(""_"")
+print(""Ignore residues:""+str(ures))
+sres=[]
+for i in range(len(ures)):
+    hres=[]
+    hres=ures[i].split(""-"")
+    sres.extend(hres)
+fres=list(filter(None,sres))
+mres=np.empty_like(fres)
+mres[::1]=0
+mres[::2]=1
+fres_f = np.array(fres).astype(np.float32)
+mres_f = mres.astype(np.float32)
+ares=fres_f-mres_f
+print(""ON/OFF pisition:""+str(ares))
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    
+    # Get sequene from features.pkl 
+    with open(cpass+""/features.pkl"", 'rb') as cn:
+        cnn=pickle.load(cn)
+        sequ=cnn['residue_index']
+        rein=np.array(list(str(cnn['sequence'][0])[2:-1]))
+        print(str(rein))
+        twoda=np.column_stack((sequ+1,rein))
+        cn.close()
+        pass
+    # Get sequence from features.pkl
+    
+    # Make array to determine the caliculation range of pLDDT average
+    eres=np.empty_like(rein)
+    for i in range(len(eres)):
+        cococo=0
+        for j in range(len(ares)):
+            if i > int(ares[j])-1:
+                cococo+=1
+                pass
+            pass
+        if cococo % 2 == 0:
+            eres[i]=1
+        else:
+            eres[i]=0
+        pass
+    # Make array to determine the caliculation range of pLDDT average
+    print(eres)
+    eres_f = eres.astype(np.float32)
+
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+
+    # Model alignment
+    import math
+    o4=int(len(eres)/4)
+    w4=int(o4*2)
+    t4=int(o4*3)
+    
+    if int(args.al1)>0:
+        if int(args.al1) < len(eres):
+            o4=int(args.al1)
+    if int(args.al1)>0:
+        if int(args.al2) < len(eres):
+            w4=int(args.al2)
+    if int(args.al1)>0:
+        if int(args.al3) < len(eres):
+            t4=int(args.al3)
+    
+    xyz1=np.zeros((4,3),dtype=float)
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        with open(cpass+""/""+mname+""_""+www+""_ptm.pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    if o4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[0,0] = float(line[30:38].strip())
+                            xyz1[0,1] = float(line[38:46].strip())
+                            xyz1[0,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    elif w4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[1,0] = float(line[30:38].strip())
+                            xyz1[1,1] = float(line[38:46].strip())
+                            xyz1[1,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    elif t4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[2,0] = float(line[30:38].strip())
+                            xyz1[2,1] = float(line[38:46].strip())
+                            xyz1[2,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    else:
+                        pass
+                    pass
+                else:
+                    pass
+                pass
+            pass
+        print(""------------"")
+        xyz1[3,0] = round((xyz1[0,0]+xyz1[2,0])/2,3)
+        xyz1[3,1] = round((xyz1[0,1]+xyz1[2,1])/2,3)
+        xyz1[3,2] = round((xyz1[0,2]+xyz1[2,2])/2,3)
+        xyzm=np.zeros((1,3),dtype=float)
+        xyzm[0,0] = xyz1[3,0]
+        xyzm[0,1] = xyz1[3,1]
+        xyzm[0,2] = xyz1[3,2]
+        print(""Initial xyz"")
+        print(xyz1)
+        xyz2=xyz1-xyzm
+        print(""Center xyz"")
+        #print(xyz2)
+        #print(""------------"")
+        # rotation z fit oy and ty to zero
+        if xyz2[0,1]>0:
+            pmy=-1
+            pass
+        else:
+            pmy=1
+            pass
+        distaxy=math.sqrt(math.pow(xyz2[0,0], 2)+math.pow(xyz2[0,1], 2))
+        radax=pmy*math.acos(xyz2[0,0]/distaxy)
+        rot1=np.zeros((3,3),dtype=float)
+        rot1[0,0]=math.cos(radax)
+        rot1[1,0]=-math.sin(radax)
+        rot1[0,1]=math.sin(radax)
+        rot1[1,1]=math.cos(radax)
+        rot1[2,2]=1
+        xyz3=np.dot(xyz2,rot1)
+        print(""rotation z fit 1y and 3y to zero"")
+        #print(xyz3)
+        #print(""------------"")
+        # rotation y fit ox to zero
+        if xyz3[0,2]>0:
+            pmz=-1
+            pass
+        else:
+            pmz=1
+            pass
+        dista1=math.sqrt(math.pow(xyz3[0,0], 2)+math.pow(xyz3[0,1], 2)+math.pow(xyz3[0,2], 2))
+        radaxy=pmz*math.acos(xyz3[0,0]/dista1)
+        rot2=np.zeros((3,3),dtype=float)
+        rot2[0,0]=math.cos(radaxy)
+        rot2[2,0]=-math.sin(radaxy)
+        rot2[0,2]=math.sin(radaxy)
+        rot2[2,2]=math.cos(radaxy)
+        rot2[1,1]=1
+        xyz4=np.dot(xyz3,rot2)
+        print(""rotation y fit 1z and 3z to zero"")
+        #print(xyz4)
+        #print(""------------"")
+        # rotation x fit wz to zero
+        if xyz4[1,2]>0:
+            pmyz=-1
+            pass
+        else:
+            pmyz=1
+            pass
+        distbbyz=math.sqrt(math.pow(xyz4[1,1], 2)+math.pow(xyz4[1,2], 2))
+        radbbyz=pmyz*math.acos(xyz4[1,1]/distbbyz)
+        rot3=np.zeros((3,3),dtype=float)
+        rot3[1,1]=math.cos(radbbyz)
+        rot3[2,1]=-math.sin(radbbyz)
+        rot3[1,2]=math.sin(radbbyz)
+        rot3[2,2]=math.cos(radbbyz)
+        rot3[0,0]=1
+        xyz5=np.dot(xyz4,rot3)
+        print(""rotation x fit 2z to zero"")
+        #print(xyz5)
+        #print(""------------"")
+        # Check all shift & roation 
+        xyz6=np.dot(np.dot(np.dot(xyz1-xyzm,rot1),rot2),rot3)
+        print(""Check all shift & roation"")
+        print(xyz6)
+        print(""------------"")
+        xyz=np.zeros((1,3),dtype=float)
+        liii=""""
+        with open(cpass+""/""+mname+""_""+www+""_ptm.pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    xyz[::1]=0
+                    xyz[0,0] = float(line[30:38].strip())
+                    xyz[0,1] = float(line[38:46].strip())
+                    xyz[0,2] = float(line[46:54].strip())
+                    xyzn=np.dot(np.dot(np.dot(xyz-xyzm,rot1),rot2),rot3)
+                    qxxl="" ""*(8-len(str(round(xyzn[0,0],4))))+str(round(xyzn[0,0],4))
+                    qyyl="" ""*(8-len(str(round(xyzn[0,1],4))))+str(round(xyzn[0,1],4))
+                    qzzl="" ""*(8-len(str(round(xyzn[0,2],4))))+str(round(xyzn[0,2],4))
+                    liii+=line[0:30]+qxxl+qyyl+qzzl+line[54:]
+                    pass
+                else:
+                    liii+=line
+                pass
+            pass
+        with open(cpass+""/align_""+str(lpass[-1])+""_m""+www+""_ptm.pdb"", mode='w') as i:
+            i.write(liii)
+            i.close()
+            pass
+        pass
+
+
+    
+    plddts=np.empty(namen)
+    # Repeat for the caliculation of all models
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        # Read pLDDT from result_model_?.pkl
+        with open(cpass+""/""+iname+""_""+www+""_ptm.pkl"", 'rb') as c1:
+            c1n=pickle.load(c1)
+            # Extract PAE
+            pae = c1n['predicted_aligned_error'].astype(np.float32)
+            np.savetxt(cpass+'/'+str(lpass[-1])+'_pae_m'+www+'_ptm.csv',pae,delimiter=',',fmt=""%s"")
+            print(""Save:""+cpass+'/'+str(lpass[-1])+'_pae_m'+www+'_ptm.csv')
+            # Extract PAE
+            c1n_f = c1n['plddt'].astype(np.float32)
+            # Caliculation of average pLDDT
+            na_mul=c1n_f*eres_f
+            plddts[i]=np.sum(na_mul)/np.sum(eres_f)
+            # Caliculation of average pLDDT
+            pld1=np.round(c1n['plddt'], decimals=2)
+            twoda=np.column_stack((twoda,pld1))
+            pd1=['{:.2f}'.format(n) for n in pld1.tolist()]
+            c1.close()
+            pass
+        # Read pLDDT from result_model_?.pkl
+        
+        # Write pLDDT in the PDB_Bfactor
+        print(""Save:""+cpass+""/align_""+str(lpass[-1])+""_m""+www+""_ptm.pdb"")
+        pass
+    print(""------------"")
+    
+    
+
+    
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    print(""number of calculated residues: ""+str(int(np.sum(eres_f)))+"" (Ignore: ""+str(ures)+"")"")
+    np.set_printoptions(formatter={'float': '{:.0f}'.format})
+    print(""Rank  :""+str(rankdata(-plddts)))
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+    twoda=np.column_stack((twoda,eres))
+    print(""plddts:""+str(plddts))
+    print(""------------"")
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    
+    # Write pLDDT in csv file  
+    np.savetxt(cpass+'/'+str(lpass[-1])+'_plddt.csv',twoda,delimiter=',',fmt=""%s"")
+    print(""Save:""+cpass+'/'+str(lpass[-1])+'_plddt.csv')
+    pass
+
+
+
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","pae2png.py",".py","4006","119","# Import
+import os
+import sys
+import pickle
+import csv
+import sys
+import time
+import numpy as np
+import argparse
+import matplotlib.pyplot as plt
+import seaborn as sns
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.2_(2021Jul.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program extract pae values from [result_model_?_ptm.pkl] to [.png] "")
+print(""Thanks Dr. Yoshitaka Moriwaki (@Ag_smith) for initially showing how to export predicted aligned error in alphafold2."")
+print(""You need to change model_names to model_?_ptm from model_? at Docker/run_docker.py"")
+print(""for Alphafold2"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(description=""The program extract plddt from [result_model.pkl] to [.csv]"")
+parser.add_argument('-i', default='result_model', help='input XXXXX if [XXXXX_Y.pkl]; ex) result_model (def.)')
+parser.add_argument('-n', default='5', help='input Y if you want open [XXXXX_1.pkl,XXXXX_2.pkl ... ,XXXXX_5.pkl]; ex) 5 (def.)')
+parser.add_argument('-o', default='p2c', help='input XXXXX if you want to name the output [XXXXX.csv]; ex) plddt (def.)')
+parser.add_argument('-c', default='Greens_r', help='color of heat map (PAE; ex) Greans_r (def.)')
+parser.add_argument('-s', default='None', help=""plt.show was skiped when -s 'Skip'"")
+parser.add_argument('-m', default=30, help=""vmax of sns.heatmap ex) -m 30 (def.)"")
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""_?_ptm.pkl"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+# Number of models
+namen=int(str(args.n))
+
+# Output file name
+oname=str(args.o)
+print(""Output file name:""+str(oname)+"".csv"")
+print(""It can be changed by [-o ""+oname+""]"")
+print("""")
+
+
+# Color
+cname=str(args.c)
+print(""Output file color:""+str(cname))
+print(""It can be changed by [-c ""+cname+""]"")
+print("""")
+
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    
+    # Get sequene from features.pkl 
+    with open(cpass+""/features.pkl"", 'rb') as cn:
+        cnn=pickle.load(cn)
+        sequ=cnn['residue_index']
+        eres=np.array(list(str(cnn['sequence'][0])[2:-1]))
+        cn.close()
+        pass
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+
+    
+    # Repeat for the caliculation of all models
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        # Read pLDDT from result_model_?_ptm.pkl
+        with open(cpass+""/""+iname+""_""+www+""_ptm.pkl"", 'rb') as c1:
+            c1n=pickle.load(c1)
+            # Extract PAE
+            pae = c1n['predicted_aligned_error'].astype(np.float32)
+            np.savetxt(cpass+'/'+oname+'_pae_'+www+'.csv',pae,delimiter=',',fmt=""%s"")
+            print(""Display:""+cpass+'/'+oname+'_pae_'+www+'.png')
+            plt.figure(figsize=(15, 12))
+            ax = sns.heatmap(pae, linewidth=0, cmap=cname, square=True, xticklabels=50, yticklabels=50, vmin=0, vmax=str(args.m))
+            plt.savefig(cpass+'/'+oname+'_pae_'+www+'.png')
+            if str(args.s)=='None':
+                plt.show()
+                pass
+            # Extract PAE
+            pass
+        # Read pLDDT from result_model_?_ptm.pkl
+        pass
+    pass
+
+
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","paem2png.py",".py","3774","111","# Import
+import os
+import sys
+import pickle
+import csv
+import sys
+import time
+import numpy as np
+import argparse
+import matplotlib.pyplot as plt
+import seaborn as sns
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.2.1_(2021Dec.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program extract pae values from [result_model_?_ptm.pkl] to [.png] "")
+print(""Thanks Dr. Yoshitaka Moriwaki (@Ag_smith) for initially showing how to export predicted aligned error in alphafold2."")
+print(""You need to change model_names to model_?_ptm from model_? at Docker/run_docker.py"")
+print(""for Alphafold2"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(description=""The program extract plddt from [result_model.pkl] to [.csv]"")
+parser.add_argument('-i', default='result_model', help='input XXXXX if [XXXXX_Y_multimer.pkl]; ex) result_model (def.)')
+parser.add_argument('-n', default='5', help='input Y if you want open [XXXXX_1.pkl,XXXXX_2.pkl ... ,XXXXX_5.pkl]; ex) 5 (def.)')
+parser.add_argument('-o', default='p2c', help='input XXXXX if you want to name the output [XXXXX.csv]; ex) plddt (def.)')
+parser.add_argument('-c', default='Greens_r', help='color of heat map (PAE; ex) Greans_r (def.)')
+parser.add_argument('-s', default='None', help=""plt.show was skiped when -s 'Skip'"")
+parser.add_argument('-m', default=30, help=""vmax of sns.heatmap ex) -m 30 (def.)"")
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""_?_multimer.pkl"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+# Number of models
+namen=int(str(args.n))
+
+# Output file name
+oname=str(args.o)
+print(""Output file name:""+str(oname)+"".csv"")
+print(""It can be changed by [-o ""+oname+""]"")
+print("""")
+
+
+# Color
+cname=str(args.c)
+print(""Output file color:""+str(cname))
+print(""It can be changed by [-c ""+cname+""]"")
+print("""")
+
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+
+    
+    # Repeat for the caliculation of all models
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        # Read pLDDT from result_model_?_ptm.pkl
+        with open(cpass+""/""+iname+""_""+www+""_multimer.pkl"", 'rb') as c1:
+            c1n=pickle.load(c1)
+            # Extract PAE
+            pae = c1n['predicted_aligned_error'].astype(np.float32)
+            np.savetxt(cpass+'/'+oname+'_pae_'+www+'.csv',pae,delimiter=',',fmt=""%s"")
+            print(""Display:""+cpass+'/'+oname+'_pae_'+www+'.png')
+            plt.figure(figsize=(15, 12))
+            ax = sns.heatmap(pae, linewidth=0, cmap=cname, square=True, xticklabels=50, yticklabels=50, vmin=0, vmax=str(args.m))
+            plt.savefig(cpass+'/'+oname+'_pae_'+www+'.png')
+            if str(args.s)=='None':
+                plt.show()
+                pass
+            # Extract PAE
+            pass
+        # Read pLDDT from result_model_?_ptm.pkl
+        pass
+    pass
+
+
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","ptm_docker.py",".py","2791","96","# Import
+import os
+import sys
+import sys
+import time
+import argparse
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.1_(2021Jul.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program make run_docker_ptm.py to extract pae value"")
+print(""for Alphafold2"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(description=""The program make run_docker_ptm for caliculate pae value in alphafold2"")
+parser.add_argument('-i', default='run_docker', help='input .py file name ; ex) run_docker (def.)')
+parser.add_argument('-o', default='run_docker_ptm', help='output .py file name ; ex) run_docker_ptm (def.)')
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""py"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+# Output file name
+oname=str(args.o)
+print(""Output file name:""+str(oname)+""py"")
+print(""It can be changed by [-o ""+oname+""]"")
+print("""")
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    cowco=6
+    liii=""""
+    with open(cpass+""/docker/run_docker.py"", mode='r') as g:
+        print(""Read:""+cpass+""/docker/run_docker.py"")
+        for line in g:
+            if cowco < 5.5:
+                print(cowco)
+                liii+=line[:12]+""_ptm""+line[12:]
+                cowco+=1
+                print(line)
+                print(line[:12]+""_ptm""+line[12:])
+                pass
+            else:
+                liii+=line
+                if line[0:13]==""model_names ="":
+                    cowco+=-5
+                    print(""model_name was found"")
+                pass
+            pass
+        g.close()
+        pass
+    with open(cpass+""/docker/run_docker_ptm.py"", mode='w') as i:
+        i.write(liii)
+        i.close()
+        pass
+    # Write pLDDT in the PDB_Bfactor
+    print(""Save:""+cpass+""/docker/run_docker_ptm.py"")
+    print(""------------"")
+    
+ 
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","plddt_align_ptm.py",".py","12914","356","# Import
+import os
+import sys
+import pickle
+import csv
+import sys
+import time
+import numpy as np
+import argparse
+from scipy.stats import rankdata
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.2_(2021Jul.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program extracts alignd model with plddt calue in b-factor using [result_model_?_ptm.pkl] and [.pdb] "")
+print(""The program extracts pae plddt values from [result_model_ptm.pkl] to [.csv] "")
+print(""Thanks Dr. Yoshitaka Moriwaki (@Ag_smith) for initially showing how to export predicted aligned error in alphafold2."")
+print(""You need to change model_names to model_?_ptm from model_? at /Docker/run_docker.py."")
+print(""for Alphafold2"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(description=""The program extract plddt from [result_model.pkl] to [.csv]"")
+parser.add_argument('-i', default='result_model', help='input XXXXX if [XXXXX_Y.pkl]; ex) result_model (def.)')
+parser.add_argument('-m', default='relaxed_model', help='input ZZZZZ if [ZZZZZ_Y.pdb]; ex) result_model (def.)')
+parser.add_argument('-n', default='5', help='input Y if you want open [XXXXX_1.pkl,XXXXX_2.pkl ... ,XXXXX_5.pkl]; ex) 5 (def.)')
+parser.add_argument('-o', default='plddt', help='input XXXXX if you want to name the output [XXXXX.csv]; ex) plddt (def.)')
+parser.add_argument('-d', default='', help='ignored residue number for average pLDDTs caliculation to determined the ranking of models [1-5_56-75_105-135]; ex) """" (def.)')
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""_?_ptm.pkl"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+mname=str(args.m)
+print(""Input file name:""+str(mname)+""_?_ptm.pdb"")
+print(""It can be changed by [-m ""+iname+""]"")
+print("""")
+
+# Number of models
+namen=int(str(args.n))
+
+# Output file name
+oname=str(args.o)
+print(""Output file name:""+str(oname)+"".csv"")
+print(""It can be changed by [-o ""+oname+""]"")
+print("""")
+
+# Ignore residue
+dres=str(args.d)
+ures=dres.split(""_"")
+print(""Ignore residues:""+str(ures))
+sres=[]
+for i in range(len(ures)):
+    hres=[]
+    hres=ures[i].split(""-"")
+    sres.extend(hres)
+fres=list(filter(None,sres))
+mres=np.empty_like(fres)
+mres[::1]=0
+mres[::2]=1
+fres_f = np.array(fres).astype(np.float32)
+mres_f = mres.astype(np.float32)
+ares=fres_f-mres_f
+print(""ON/OFF pisition:""+str(ares))
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    
+    # Get sequene from features.pkl 
+    with open(cpass+""/features.pkl"", 'rb') as cn:
+        cnn=pickle.load(cn)
+        sequ=cnn['residue_index']
+        rein=np.array(list(str(cnn['sequence'][0])[2:-1]))
+        twoda=np.column_stack((sequ+1,rein))
+        cn.close()
+        pass
+    # Get sequence from features.pkl
+    
+    # Make array to determine the caliculation range of pLDDT average
+    eres=np.empty_like(rein)
+    for i in range(len(eres)):
+        cococo=0
+        for j in range(len(ares)):
+            if i > int(ares[j])-1:
+                cococo+=1
+                pass
+            pass
+        if cococo % 2 == 0:
+            eres[i]=1
+        else:
+            eres[i]=0
+        pass
+    # Make array to determine the caliculation range of pLDDT average
+    print(eres)
+    eres_f = eres.astype(np.float32)
+
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+
+    # Model alignment
+    import math
+    o4=int(len(eres)/4)
+    w4=int(o4*2)
+    t4=int(o4*3)
+    xyz1=np.zeros((4,3),dtype=float)
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        with open(cpass+""/""+mname+""_""+www+""_ptm.pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    if o4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[0,0] = float(line[30:38].strip())
+                            xyz1[0,1] = float(line[38:46].strip())
+                            xyz1[0,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    elif w4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[1,0] = float(line[30:38].strip())
+                            xyz1[1,1] = float(line[38:46].strip())
+                            xyz1[1,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    elif t4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[2,0] = float(line[30:38].strip())
+                            xyz1[2,1] = float(line[38:46].strip())
+                            xyz1[2,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    else:
+                        pass
+                    pass
+                else:
+                    pass
+                pass
+            pass
+        print(""------------"")
+        xyz1[3,0] = round((xyz1[0,0]+xyz1[2,0])/2,3)
+        xyz1[3,1] = round((xyz1[0,1]+xyz1[2,1])/2,3)
+        xyz1[3,2] = round((xyz1[0,2]+xyz1[2,2])/2,3)
+        xyzm=np.zeros((1,3),dtype=float)
+        xyzm[0,0] = xyz1[3,0]
+        xyzm[0,1] = xyz1[3,1]
+        xyzm[0,2] = xyz1[3,2]
+        print(""Initial xyz"")
+        print(xyz1)
+        xyz2=xyz1-xyzm
+        print(""Center xyz"")
+        #print(xyz2)
+        #print(""------------"")
+        # rotation z fit oy and ty to zero
+        if xyz2[0,1]>0:
+            pmy=-1
+            pass
+        else:
+            pmy=1
+            pass
+        distaxy=math.sqrt(math.pow(xyz2[0,0], 2)+math.pow(xyz2[0,1], 2))
+        radax=pmy*math.acos(xyz2[0,0]/distaxy)
+        rot1=np.zeros((3,3),dtype=float)
+        rot1[0,0]=math.cos(radax)
+        rot1[1,0]=-math.sin(radax)
+        rot1[0,1]=math.sin(radax)
+        rot1[1,1]=math.cos(radax)
+        rot1[2,2]=1
+        xyz3=np.dot(xyz2,rot1)
+        print(""rotation z fit 1y and 3y to zero"")
+        #print(xyz3)
+        #print(""------------"")
+        # rotation y fit ox to zero
+        if xyz3[0,2]>0:
+            pmz=-1
+            pass
+        else:
+            pmz=1
+            pass
+        dista1=math.sqrt(math.pow(xyz3[0,0], 2)+math.pow(xyz3[0,1], 2)+math.pow(xyz3[0,2], 2))
+        radaxy=pmz*math.acos(xyz3[0,0]/dista1)
+        rot2=np.zeros((3,3),dtype=float)
+        rot2[0,0]=math.cos(radaxy)
+        rot2[2,0]=-math.sin(radaxy)
+        rot2[0,2]=math.sin(radaxy)
+        rot2[2,2]=math.cos(radaxy)
+        rot2[1,1]=1
+        xyz4=np.dot(xyz3,rot2)
+        print(""rotation y fit 1z and 3z to zero"")
+        #print(xyz4)
+        #print(""------------"")
+        # rotation x fit wz to zero
+        if xyz4[1,2]>0:
+            pmyz=-1
+            pass
+        else:
+            pmyz=1
+            pass
+        distbbyz=math.sqrt(math.pow(xyz4[1,1], 2)+math.pow(xyz4[1,2], 2))
+        radbbyz=pmyz*math.acos(xyz4[1,1]/distbbyz)
+        rot3=np.zeros((3,3),dtype=float)
+        rot3[1,1]=math.cos(radbbyz)
+        rot3[2,1]=-math.sin(radbbyz)
+        rot3[1,2]=math.sin(radbbyz)
+        rot3[2,2]=math.cos(radbbyz)
+        rot3[0,0]=1
+        xyz5=np.dot(xyz4,rot3)
+        print(""rotation x fit 2z to zero"")
+        #print(xyz5)
+        #print(""------------"")
+        # Check all shift & roation 
+        xyz6=np.dot(np.dot(np.dot(xyz1-xyzm,rot1),rot2),rot3)
+        print(""Check all shift & roation"")
+        print(xyz6)
+        print(""------------"")
+        xyz=np.zeros((1,3),dtype=float)
+        liii=""""
+        with open(cpass+""/""+mname+""_""+www+""_ptm.pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    xyz[::1]=0
+                    xyz[0,0] = float(line[30:38].strip())
+                    xyz[0,1] = float(line[38:46].strip())
+                    xyz[0,2] = float(line[46:54].strip())
+                    xyzn=np.dot(np.dot(np.dot(xyz-xyzm,rot1),rot2),rot3)
+                    qxxl="" ""*(8-len(str(round(xyzn[0,0],4))))+str(round(xyzn[0,0],4))
+                    qyyl="" ""*(8-len(str(round(xyzn[0,1],4))))+str(round(xyzn[0,1],4))
+                    qzzl="" ""*(8-len(str(round(xyzn[0,2],4))))+str(round(xyzn[0,2],4))
+                    liii+=line[0:30]+qxxl+qyyl+qzzl+line[54:]
+                    pass
+                else:
+                    liii+=line
+                pass
+            pass
+        with open(cpass+""/align_""+str(lpass[-1])+""_""+www+""_ptm.pdb"", mode='w') as i:
+            i.write(liii)
+            i.close()
+            pass
+        pass
+
+
+    
+    plddts=np.empty(namen)
+    # Repeat for the caliculation of all models
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        # Read pLDDT from result_model_?.pkl
+        with open(cpass+""/""+iname+""_""+www+""_ptm.pkl"", 'rb') as c1:
+            c1n=pickle.load(c1)
+            # Extract PAE
+            pae = c1n['predicted_aligned_error'].astype(np.float32)
+            np.savetxt(cpass+'/'+oname+'_pae_'+www+'.csv',pae,delimiter=',',fmt=""%s"")
+            print(""Save:""+cpass+'/'+oname+'_pae_'+www+'.csv')
+            # Extract PAE
+            c1n_f = c1n['plddt'].astype(np.float32)
+            # Caliculation of average pLDDT
+            na_mul=c1n_f*eres_f
+            plddts[i]=np.sum(na_mul)/np.sum(eres_f)
+            # Caliculation of average pLDDT
+            pld1=np.round(c1n['plddt'], decimals=2)
+            twoda=np.column_stack((twoda,pld1))
+            pd1=['{:.2f}'.format(n) for n in pld1.tolist()]
+            c1.close()
+            pass
+        # Read pLDDT from result_model_?.pkl
+        
+        ll1=""""
+        ss1=""""
+        # Write pLDDT in the PDB_Bfactor
+        with open(cpass+""/align_""+str(lpass[-1])+""_""+www+""_ptm.pdb"", mode='r') as g1:
+            for line in g1:
+                if  line[0:4]==""ATOM"":
+                    pdd1=pd1[int(float(line[22:26].strip())-1)]
+                    ll1+=line[0:60]+"" ""*(6-len(pdd1))+pdd1+line[66:]
+                    if int(eres[int(float(line[22:26].strip())-1)])==1:
+                        ss1+=line[0:60]+"" ""*(6-len(pdd1))+pdd1+line[66:]
+                    else:
+                        pass
+                    pass
+                else:
+                    ll1+=line
+                    ss1+=line
+                    pass
+                pass
+            g1.close()
+            pass
+        with open(cpass+""/align_""+str(lpass[-1])+""_""+www+""_ptm.pdb"", mode='w') as i:
+            i.write(ll1)
+            i.close()
+            pass
+        with open(cpass+""/""+str(lpass[-1])+""_""+www+""_pLDDT""+str(int(np.sum(na_mul)/np.sum(eres_f)))+""_ptm.pdb"", mode='w') as i:
+            i.write(ss1)
+            i.close()
+            pass
+        # Write pLDDT in the PDB_Bfactor
+        print(""Save:""+cpass+""/align_""+str(lpass[-1])+""_""+www+""_ptm.pdb"")
+        print(""Save:""+cpass+""/""+str(lpass[-1])+""_""+www+""_pLDDT""+str(int(np.sum(na_mul)/np.sum(eres_f)))+""_ptm.pdb"")
+        pass
+    print(""------------"")
+    
+    
+
+    
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    print(""number of calculated residues: ""+str(int(np.sum(eres_f)))+"" (Ignore: ""+str(ures)+"")"")
+    np.set_printoptions(formatter={'float': '{:.0f}'.format})
+    print(""Rank  :""+str(rankdata(-plddts)))
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+    twoda=np.column_stack((twoda,eres))
+    print(""plddts:""+str(plddts))
+    print(""------------"")
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    
+    # Write pLDDT in csv file  
+    np.savetxt(cpass+'/'+oname+'_plddt.csv',twoda,delimiter=',',fmt=""%s"")
+    print(""Save:""+cpass+'/'+oname+'_plddt.csv')
+    pass
+
+
+
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","align_multi.py",".py","13481","358","# Import
+import os
+import sys
+import pickle
+import csv
+import sys
+import time
+import numpy as np
+import argparse
+from scipy.stats import rankdata
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.2.1_(2021Dec.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program align output pdb file and extract pae plddt values from [result_model_multimer.pkl] to [.csv] "")
+print(""Thanks Dr. Yoshitaka Moriwaki (@Ag_smith) for initially showing how to export predicted aligned error in alphafold2."")
+print(""for Alphafold2.1.1"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(            description=""The program extract pae from [result_model.pkl] to [.csv]"")
+parser.add_argument('-i', default='result_model',   help='input XXXXX if [XXXXX_Y_ptm.pkl]; ex) result_model (def.)')
+parser.add_argument('-m', default='relaxed_model',  help='input ZZZZZ if [ZZZZZ_Y_ptm.pdb]; ex) result_model (def.)')
+parser.add_argument('-n', default='5',              help='input Y if you want open [XXXXX_1_ptm.pkl,XXXXX_2_ptm.pkl ... ,XXXXX_5_ptm.pkl]; ex) 5 (def.)')
+parser.add_argument('-d', default='',               help='!!this argument is not suport for chain number!!. ignored residue number for average pLDDTs caliculation to determined the ranking of models [1-5_56-75_105-135]; ex) """" (def.)')
+parser.add_argument('-alc', default=""1"",            help='Change chain number from first chain to other chain defalt: 1')
+parser.add_argument('-al1', default=0,              help='Center the mid point of al1 and al3, the point (al1) shift on x-axis')
+parser.add_argument('-al2', default=0,              help='The point (al2) shift on xy-plane')
+parser.add_argument('-al3', default=0,              help='Center the mid point of al1 and al3, the point (al3) shift on x-asis and opozit site of al1')
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""_?_multimer.pkl"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+mname=str(args.m)
+print(""Input file name:""+str(mname)+""_?_multimer.pdb"")
+print(""It can be changed by [-m ""+mname+""]"")
+print("""")
+
+# Number of models
+namen=int(str(args.n))
+
+# Output file name
+#oname=str(args.o)
+#print(""Output file name:""+oname+"".csv"")
+#print("""")
+
+# Ignore residue
+dres=str(args.d)
+ures=dres.split(""_"")
+print(""Ignore residues:""+str(ures))
+sres=[]
+for i in range(len(ures)):
+    hres=[]
+    hres=ures[i].split(""-"")
+    sres.extend(hres)
+fres=list(filter(None,sres))
+mres=np.empty_like(fres)
+mres[::1]=0
+mres[::2]=1
+fres_f = np.array(fres).astype(np.float32)
+mres_f = mres.astype(np.float32)
+ares=fres_f-mres_f
+print(""ON/OFF pisition:""+str(ares))
+
+
+# Number of models
+chn=int(str(args.alc))
+
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    
+    # Get sequene from features.pkl 
+    with open(cpass+""/features.pkl"", 'rb') as cn:
+        cnn=pickle.load(cn)
+        sequ=cnn['residue_index']
+        print(str(cnn['asym_id']))
+        rein=np.array(list(cnn['asym_id']))
+        twoda=rein
+        renn=np.array(list(cnn['residue_index']))
+        twoda=np.column_stack((twoda,renn+1))
+        aatp=np.array(list(cnn['aatype']))
+        aadic={0: ""A"", 1: ""R"", 2: ""N"", 3: ""D"", 4: ""C"", 5: ""Q"", 6: ""E"", 7: ""G"", 8: ""H"", 9: ""I"", 10: ""L"", 11: ""K"", 12: ""M"", 13: ""F"", 14: ""P"", 15: ""S"", 16: ""T"", 17: ""W"", 18: ""Y"", 19: ""V"", 20: ""X"", 21: ""X"", 22: ""X"", 23: ""X""}
+        aanp=np.array(list(aadic.values()))
+        aala=np.searchsorted(list(aadic), aatp)
+        twoda=np.column_stack((twoda,aanp[aala]))
+        print(str(aanp[aala]))
+        cn.close()
+        pass
+    # Get sequence from features.pkl
+    
+    # Make array to determine the caliculation range of pLDDT average
+    eres=np.empty_like(rein)
+    for i in range(len(eres)):
+        cococo=0
+        for j in range(len(ares)):
+            if i > int(ares[j])-1:
+                cococo+=1
+                pass
+            pass
+        if cococo % 2 == 0:
+            eres[i]=1
+        else:
+            eres[i]=0
+        pass
+    # Make array to determine the caliculation range of pLDDT average
+    print(eres)
+    eres_f = eres.astype(np.float32)
+
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+
+    # Model alignment
+    import math
+    f4=int(np.count_nonzero(rein == chn))
+    o4=int(f4/4)
+    w4=int(o4*2)
+    t4=int(o4*3)
+    novch={""1"":""A"", ""2"":""B"", ""3"":""C"", ""4"":""D"", ""5"":""E"", ""6"":""F"", ""7"":""G"", ""8"":""H"", ""9"":""I"", ""10"":""J"", ""11"":""K"", ""12"":""L"", ""13"":""M"", ""14"":""N"", ""15"":""O"", ""16"":""P"", ""17"":""Q"", ""18"":""R"", ""19"":""S"", ""20"":""T"", ""21"":""U"", 22:""V"", ""23"":""W"", ""24"":""X"", ""25"":""Y"", ""26"":""Z""}
+    cf=novch[args.alc]
+
+    if int(args.al1)>0:
+        if int(args.al1) < f4:
+            o4=int(args.al1)
+    if int(args.al1)>0:
+        if int(args.al2) < f4:
+            w4=int(args.al2)
+    if int(args.al1)>0:
+        if int(args.al3) < f4:
+            t4=int(args.al3)
+
+    xyz1=np.zeros((4,3),dtype=float)
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        with open(cpass+""/""+mname+""_""+www+""_multimer.pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    if line[21:22]==cf:
+                        if o4==int(float(line[22:26].strip())):
+                            if ""CA""==line[12:16].strip():
+                                print(line)
+                                xyz1[0,0] = float(line[30:38].strip())
+                                xyz1[0,1] = float(line[38:46].strip())
+                                xyz1[0,2] = float(line[46:54].strip())
+                                pass
+                            pass
+                        elif w4==int(float(line[22:26].strip())):
+                            if ""CA""==line[12:16].strip():
+                                print(line)
+                                xyz1[1,0] = float(line[30:38].strip())
+                                xyz1[1,1] = float(line[38:46].strip())
+                                xyz1[1,2] = float(line[46:54].strip())
+                                pass
+                            pass
+                        elif t4==int(float(line[22:26].strip())):
+                            if ""CA""==line[12:16].strip():
+                                print(line)
+                                xyz1[2,0] = float(line[30:38].strip())
+                                xyz1[2,1] = float(line[38:46].strip())
+                                xyz1[2,2] = float(line[46:54].strip())
+                                pass
+                            pass
+                        pass
+                    else:
+                        pass
+                    pass
+                else:
+                    pass
+                pass
+            pass
+        print(""------------"")
+        xyz1[3,0] = round((xyz1[0,0]+xyz1[2,0])/2,3)
+        xyz1[3,1] = round((xyz1[0,1]+xyz1[2,1])/2,3)
+        xyz1[3,2] = round((xyz1[0,2]+xyz1[2,2])/2,3)
+        xyzm=np.zeros((1,3),dtype=float)
+        xyzm[0,0] = xyz1[3,0]
+        xyzm[0,1] = xyz1[3,1]
+        xyzm[0,2] = xyz1[3,2]
+        print(""Initial xyz"")
+        print(xyz1)
+        xyz2=xyz1-xyzm
+        print(""Center xyz"")
+        #print(xyz2)
+        #print(""------------"")
+        # rotation z fit oy and ty to zero
+        if xyz2[0,1]>0:
+            pmy=-1
+            pass
+        else:
+            pmy=1
+            pass
+        distaxy=math.sqrt(math.pow(xyz2[0,0], 2)+math.pow(xyz2[0,1], 2))
+        radax=pmy*math.acos(xyz2[0,0]/distaxy)
+        rot1=np.zeros((3,3),dtype=float)
+        rot1[0,0]=math.cos(radax)
+        rot1[1,0]=-math.sin(radax)
+        rot1[0,1]=math.sin(radax)
+        rot1[1,1]=math.cos(radax)
+        rot1[2,2]=1
+        xyz3=np.dot(xyz2,rot1)
+        print(""rotation z fit 1y and 3y to zero"")
+        #print(xyz3)
+        #print(""------------"")
+        # rotation y fit ox to zero
+        if xyz3[0,2]>0:
+            pmz=-1
+            pass
+        else:
+            pmz=1
+            pass
+        dista1=math.sqrt(math.pow(xyz3[0,0], 2)+math.pow(xyz3[0,1], 2)+math.pow(xyz3[0,2], 2))
+        radaxy=pmz*math.acos(xyz3[0,0]/dista1)
+        rot2=np.zeros((3,3),dtype=float)
+        rot2[0,0]=math.cos(radaxy)
+        rot2[2,0]=-math.sin(radaxy)
+        rot2[0,2]=math.sin(radaxy)
+        rot2[2,2]=math.cos(radaxy)
+        rot2[1,1]=1
+        xyz4=np.dot(xyz3,rot2)
+        print(""rotation y fit 1z and 3z to zero"")
+        #print(xyz4)
+        #print(""------------"")
+        # rotation x fit wz to zero
+        if xyz4[1,2]>0:
+            pmyz=-1
+            pass
+        else:
+            pmyz=1
+            pass
+        distbbyz=math.sqrt(math.pow(xyz4[1,1], 2)+math.pow(xyz4[1,2], 2))
+        radbbyz=pmyz*math.acos(xyz4[1,1]/distbbyz)
+        rot3=np.zeros((3,3),dtype=float)
+        rot3[1,1]=math.cos(radbbyz)
+        rot3[2,1]=-math.sin(radbbyz)
+        rot3[1,2]=math.sin(radbbyz)
+        rot3[2,2]=math.cos(radbbyz)
+        rot3[0,0]=1
+        xyz5=np.dot(xyz4,rot3)
+        print(""rotation x fit 2z to zero"")
+        #print(xyz5)
+        #print(""------------"")
+        # Check all shift & roation 
+        xyz6=np.dot(np.dot(np.dot(xyz1-xyzm,rot1),rot2),rot3)
+        print(""Check all shift & roation"")
+        print(xyz6)
+        print(""------------"")
+        xyz=np.zeros((1,3),dtype=float)
+        liii=""""
+        with open(cpass+""/""+mname+""_""+www+""_multimer.pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    xyz[::1]=0
+                    xyz[0,0] = float(line[30:38].strip())
+                    xyz[0,1] = float(line[38:46].strip())
+                    xyz[0,2] = float(line[46:54].strip())
+                    xyzn=np.dot(np.dot(np.dot(xyz-xyzm,rot1),rot2),rot3)
+                    qxxl="" ""*(8-len(str(round(xyzn[0,0],4))))+str(round(xyzn[0,0],4))
+                    qyyl="" ""*(8-len(str(round(xyzn[0,1],4))))+str(round(xyzn[0,1],4))
+                    qzzl="" ""*(8-len(str(round(xyzn[0,2],4))))+str(round(xyzn[0,2],4))
+                    liii+=line[0:30]+qxxl+qyyl+qzzl+line[54:]
+                    pass
+                else:
+                    liii+=line
+                pass
+            pass
+        with open(cpass+""/align_""+str(lpass[-1])+""_m""+www+""_multi.pdb"", mode='w') as i:
+            i.write(liii)
+            i.close()
+            pass
+        pass
+
+
+    
+    plddts=np.empty(namen)
+    # Repeat for the caliculation of all models
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        # Read pLDDT from result_model_?.pkl
+        with open(cpass+""/""+iname+""_""+www+""_multimer.pkl"", 'rb') as c1:
+            c1n=pickle.load(c1)
+            # Extract PAE
+            pae = c1n['predicted_aligned_error'].astype(np.float32)
+            np.savetxt(cpass+'/'+str(lpass[-1])+'_pae_m'+www+'_multi.csv',pae,delimiter=',',fmt=""%s"")
+            print(""Save:""+cpass+'/'+str(lpass[-1])+'_pae_m'+www+'_multi.csv')
+            # Extract PAE
+            c1n_f = c1n['plddt'].astype(np.float32)
+            # Caliculation of average pLDDT
+            na_mul=c1n_f*eres_f
+            plddts[i]=np.sum(na_mul)/np.sum(eres_f)
+            # Caliculation of average pLDDT
+            pld1=np.round(c1n['plddt'], decimals=2)
+            twoda=np.column_stack((twoda,pld1))
+            pd1=['{:.2f}'.format(n) for n in pld1.tolist()]
+            c1.close()
+            pass
+        # Read pLDDT from result_model_?.pkl
+          
+        # Write pLDDT in the PDB_Bfactor
+        print(""Save:""+cpass+""/align_""+str(lpass[-1])+""_m""+www+""_multi.pdb"")
+#        print(""Save:""+cpass+""/""+str(lpass[-1])+""_""+www+""_pLDDT""+str(int(np.sum(na_mul)/np.sum(eres_f)))+""_ptm.pdb"")
+        pass
+    print(""------------"")
+    
+    
+
+    
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    print(""number of calculated residues: ""+str(int(np.sum(eres_f)))+"" (Ignore: ""+str(ures)+"")"")
+    np.set_printoptions(formatter={'float': '{:.0f}'.format})
+    print(""Rank  :""+str(rankdata(-plddts)))
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+    twoda=np.column_stack((twoda,eres))
+    print(""plddts:""+str(plddts))
+    print(""------------"")
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    
+    # Write pLDDT in csv file  
+    np.savetxt(cpass+'/'+str(lpass[-1])+'_plddt.csv',twoda,delimiter=',',fmt=""%s"")
+    print(""Save:""+cpass+'/'+str(lpass[-1])+'_plddt.csv')
+    pass
+
+
+
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","plddt_align.py",".py","12198","347","# Import
+import os
+import sys
+import pickle
+import csv
+import sys
+import time
+import numpy as np
+import argparse
+from scipy.stats import rankdata
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.2_(2021Jul.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program extract plddt values from [result_model.pkl] to [.csv] "")
+print(""for Alphafold2"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(description=""The program extract plddt from [result_model.pkl] to [.csv]"")
+parser.add_argument('-i', default='result_model', help='input XXXXX if [XXXXX_Y.pkl]; ex) result_model (def.)')
+parser.add_argument('-m', default='relaxed_model', help='input ZZZZZ if [ZZZZZ_Y.pdb]; ex) result_model (def.)')
+parser.add_argument('-n', default='5', help='input Y if you want open [XXXXX_1.pkl,XXXXX_2.pkl ... ,XXXXX_5.pkl]; ex) 5 (def.)')
+parser.add_argument('-o', default='plddt', help='input XXXXX if you want to name the output [XXXXX.csv]; ex) plddt (def.)')
+parser.add_argument('-d', default='', help='ignoreed residue number for average pLDDTs caliculation to determined the ranking of models [1-5_56-75_105-135]; ex) """" (def.)')
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""_?.pkl"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+mname=str(args.m)
+print(""Input file name:""+str(mname)+""_?.pdb"")
+print(""It can be changed by [-m ""+iname+""]"")
+print("""")
+
+# Number of models
+namen=int(str(args.n))
+
+# Output file name
+oname=str(args.o)
+print(""Output file name:""+str(oname)+"".csv"")
+print(""It can be changed by [-o ""+oname+""]"")
+print("""")
+
+# Igunore residue
+dres=str(args.d)
+ures=dres.split(""_"")
+print(""Igunore residues:""+str(ures))
+sres=[]
+for i in range(len(ures)):
+    hres=[]
+    hres=ures[i].split(""-"")
+    sres.extend(hres)
+fres=list(filter(None,sres))
+mres=np.empty_like(fres)
+mres[::1]=0
+mres[::2]=1
+fres_f = np.array(fres).astype(np.float32)
+mres_f = mres.astype(np.float32)
+ares=fres_f-mres_f
+print(""ON/OFF pisition:""+str(ares))
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    
+    # Get sequene from features.pkl 
+    with open(cpass+""/features.pkl"", 'rb') as cn:
+        cnn=pickle.load(cn)
+        sequ=cnn['residue_index']
+        rein=np.array(list(str(cnn['sequence'][0])[2:-1]))
+        twoda=np.column_stack((sequ+1,rein))
+        cn.close()
+        pass
+    # Get sequence from features.pkl
+    
+    # Make array to determine the caliculation range of pLDDT average
+    eres=np.empty_like(rein)
+    for i in range(len(eres)):
+        cococo=0
+        for j in range(len(ares)):
+            if i > int(ares[j])-1:
+                cococo+=1
+                pass
+            pass
+        if cococo % 2 == 0:
+            eres[i]=1
+        else:
+            eres[i]=0
+        pass
+    # Make array to determine the caliculation range of pLDDT average
+    print(eres)
+    eres_f = eres.astype(np.float32)
+
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+
+    # Model alignment
+    import math
+    o4=int(len(eres)/4)
+    w4=int(o4*2)
+    t4=int(o4*3)
+    xyz1=np.zeros((4,3),dtype=float)
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        with open(cpass+""/""+mname+""_""+www+"".pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    if o4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[0,0] = float(line[30:38].strip())
+                            xyz1[0,1] = float(line[38:46].strip())
+                            xyz1[0,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    elif w4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[1,0] = float(line[30:38].strip())
+                            xyz1[1,1] = float(line[38:46].strip())
+                            xyz1[1,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    elif t4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[2,0] = float(line[30:38].strip())
+                            xyz1[2,1] = float(line[38:46].strip())
+                            xyz1[2,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    else:
+                        pass
+                    pass
+                else:
+                    pass
+                pass
+            pass
+        print(""------------"")
+        xyz1[3,0] = round((xyz1[0,0]+xyz1[2,0])/2,3)
+        xyz1[3,1] = round((xyz1[0,1]+xyz1[2,1])/2,3)
+        xyz1[3,2] = round((xyz1[0,2]+xyz1[2,2])/2,3)
+        xyzm=np.zeros((1,3),dtype=float)
+        xyzm[0,0] = xyz1[3,0]
+        xyzm[0,1] = xyz1[3,1]
+        xyzm[0,2] = xyz1[3,2]
+        print(""Initial xyz"")
+        print(xyz1)
+        xyz2=xyz1-xyzm
+        print(""Center xyz"")
+        #print(xyz2)
+        #print(""------------"")
+        # rotation z fit oy and ty to zero
+        if xyz2[0,1]>0:
+            pmy=-1
+            pass
+        else:
+            pmy=1
+            pass
+        distaxy=math.sqrt(math.pow(xyz2[0,0], 2)+math.pow(xyz2[0,1], 2))
+        radax=pmy*math.acos(xyz2[0,0]/distaxy)
+        rot1=np.zeros((3,3),dtype=float)
+        rot1[0,0]=math.cos(radax)
+        rot1[1,0]=-math.sin(radax)
+        rot1[0,1]=math.sin(radax)
+        rot1[1,1]=math.cos(radax)
+        rot1[2,2]=1
+        xyz3=np.dot(xyz2,rot1)
+        print(""rotation z fit 1y and 3y to zero"")
+        #print(xyz3)
+        #print(""------------"")
+        # rotation y fit ox to zero
+        if xyz3[0,2]>0:
+            pmz=-1
+            pass
+        else:
+            pmz=1
+            pass
+        dista1=math.sqrt(math.pow(xyz3[0,0], 2)+math.pow(xyz3[0,1], 2)+math.pow(xyz3[0,2], 2))
+        radaxy=pmz*math.acos(xyz3[0,0]/dista1)
+        rot2=np.zeros((3,3),dtype=float)
+        rot2[0,0]=math.cos(radaxy)
+        rot2[2,0]=-math.sin(radaxy)
+        rot2[0,2]=math.sin(radaxy)
+        rot2[2,2]=math.cos(radaxy)
+        rot2[1,1]=1
+        xyz4=np.dot(xyz3,rot2)
+        print(""rotation y fit 1z and 3z to zero"")
+        #print(xyz4)
+        #print(""------------"")
+        # rotation x fit wz to zero
+        if xyz4[1,2]>0:
+            pmyz=-1
+            pass
+        else:
+            pmyz=1
+            pass
+        distbbyz=math.sqrt(math.pow(xyz4[1,1], 2)+math.pow(xyz4[1,2], 2))
+        radbbyz=pmyz*math.acos(xyz4[1,1]/distbbyz)
+        rot3=np.zeros((3,3),dtype=float)
+        rot3[1,1]=math.cos(radbbyz)
+        rot3[2,1]=-math.sin(radbbyz)
+        rot3[1,2]=math.sin(radbbyz)
+        rot3[2,2]=math.cos(radbbyz)
+        rot3[0,0]=1
+        xyz5=np.dot(xyz4,rot3)
+        print(""rotation x fit 2z to zero"")
+        #print(xyz5)
+        #print(""------------"")
+        # Check all shift & roation 
+        xyz6=np.dot(np.dot(np.dot(xyz1-xyzm,rot1),rot2),rot3)
+        print(""Check all shift & roation"")
+        print(xyz6)
+        print(""------------"")
+        xyz=np.zeros((1,3),dtype=float)
+        liii=""""
+        with open(cpass+""/""+mname+""_""+www+"".pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    xyz[::1]=0
+                    xyz[0,0] = float(line[30:38].strip())
+                    xyz[0,1] = float(line[38:46].strip())
+                    xyz[0,2] = float(line[46:54].strip())
+                    xyzn=np.dot(np.dot(np.dot(xyz-xyzm,rot1),rot2),rot3)
+                    qxxl="" ""*(8-len(str(round(xyzn[0,0],4))))+str(round(xyzn[0,0],4))
+                    qyyl="" ""*(8-len(str(round(xyzn[0,1],4))))+str(round(xyzn[0,1],4))
+                    qzzl="" ""*(8-len(str(round(xyzn[0,2],4))))+str(round(xyzn[0,2],4))
+                    liii+=line[0:30]+qxxl+qyyl+qzzl+line[54:]
+                    pass
+                else:
+                    liii+=line
+                pass
+            pass
+        with open(cpass+""/align_""+str(lpass[-1])+""_""+www+"".pdb"", mode='w') as i:
+            i.write(liii)
+            i.close()
+            pass
+        pass
+
+
+    
+    plddts=np.empty(namen)
+    # Repeat for the caliculation of all models
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        # Read pLDDT from result_model_?.pkl
+        with open(cpass+""/""+iname+""_""+www+"".pkl"", 'rb') as c1:
+            c1n=pickle.load(c1)
+            c1n_f = c1n['plddt'].astype(np.float32)
+            # Caliculation of average pLDDT
+            na_mul=c1n_f*eres_f
+            plddts[i]=np.sum(na_mul)/np.sum(eres_f)
+            # Caliculation of average pLDDT
+            pld1=np.round(c1n['plddt'], decimals=2)
+            twoda=np.column_stack((twoda,pld1))
+            pd1=['{:.2f}'.format(n) for n in pld1.tolist()]
+            c1.close()
+            pass
+        # Read pLDDT from result_model_?.pkl
+        
+        ll1=""""
+        ss1=""""
+        # Write pLDDT in the PDB_Bfactor
+        with open(cpass+""/align_""+str(lpass[-1])+""_""+www+"".pdb"", mode='r') as g1:
+            for line in g1:
+                if  line[0:4]==""ATOM"":
+                    pdd1=pd1[int(float(line[22:26].strip())-1)]
+                    ll1+=line[0:60]+"" ""*(6-len(pdd1))+pdd1+line[66:]
+                    if int(eres[int(float(line[22:26].strip())-1)])==1:
+                        ss1+=line[0:60]+"" ""*(6-len(pdd1))+pdd1+line[66:]
+                    else:
+                        pass
+                    pass
+                else:
+                    ll1+=line
+                    ss1+=line
+                    pass
+                pass
+            g1.close()
+            pass
+        with open(cpass+""/align_""+str(lpass[-1])+""_""+www+"".pdb"", mode='w') as i:
+            i.write(ll1)
+            i.close()
+            pass
+        with open(cpass+""/""+str(lpass[-1])+""_""+www+""_pLDDT""+str(int(np.sum(na_mul)/np.sum(eres_f)))+"".pdb"", mode='w') as i:
+            i.write(ss1)
+            i.close()
+            pass
+        # Write pLDDT in the PDB_Bfactor
+        print(""Save:""+cpass+""/align_""+str(lpass[-1])+""_""+www+"".pdb"")
+        print(""Save:""+cpass+""/""+str(lpass[-1])+""_""+www+""_pLDDT""+str(int(np.sum(na_mul)/np.sum(eres_f)))+"".pdb"")
+        pass
+    print(""------------"")
+    
+    
+
+    
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    print(""number of calculated residues: ""+str(int(np.sum(eres_f)))+"" (Ignore: ""+str(ures)+"")"")
+    np.set_printoptions(formatter={'float': '{:.0f}'.format})
+    print(""Rank  :""+str(rankdata(-plddts)))
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+    twoda=np.column_stack((twoda,eres))
+    print(""plddts:""+str(plddts))
+    print(""------------"")
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    
+    # Write pLDDT in csv file  
+    np.savetxt(cpass+'/'+oname+'.csv',twoda,delimiter=',',fmt=""%s"")
+    pass
+
+
+
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","align_mono.py",".py","11561","326","# Import
+import os
+import sys
+import pickle
+import csv
+import sys
+import time
+import numpy as np
+import argparse
+from scipy.stats import rankdata
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.2.1_(2021Dec.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program align the output of AF2.1_monomer"")
+print(""for Alphafold2.1.1"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(            description=""The program align the output of AF2.1_monomer"")
+parser.add_argument('-i', default='result_model',   help='input XXXXX if [XXXXX_Y.pkl]; ex) result_model (def.)')
+parser.add_argument('-m', default='relaxed_model',  help='input ZZZZZ if [ZZZZZ_Y.pdb]; ex) relaxed_model (def.)')
+parser.add_argument('-n', default='5',              help='input Y if you want open [XXXXX_1.pkl,XXXXX_2.pkl ... ,XXXXX_5.pkl]; ex) 5 (def.)')
+parser.add_argument('-d', default='',               help='ignoreed residue number for average pLDDTs caliculation to determined the ranking of models [1-5_56-75_105-135]; ex) """" (def.)')
+parser.add_argument('-al1', default=0,              help='Center the mid point of al1 and al3, the point (al1) shift on x-axis')
+parser.add_argument('-al2', default=0,              help='The point (al2) shift on xy-plane')
+parser.add_argument('-al3', default=0,              help='Center the mid point of al1 and al3, the point (al3) shift on x-asis and opozit site of al1')
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""_?.pkl"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+mname=str(args.m)
+print(""Input file name:""+str(mname)+""_?.pdb"")
+print(""It can be changed by [-m ""+mname+""]"")
+print("""")
+
+# Number of models
+namen=int(str(args.n))
+
+# Igunore residue
+dres=str(args.d)
+ures=dres.split(""_"")
+print(""Igunore residues:""+str(ures))
+sres=[]
+for i in range(len(ures)):
+    hres=[]
+    hres=ures[i].split(""-"")
+    sres.extend(hres)
+fres=list(filter(None,sres))
+mres=np.empty_like(fres)
+mres[::1]=0
+mres[::2]=1
+fres_f = np.array(fres).astype(np.float32)
+mres_f = mres.astype(np.float32)
+ares=fres_f-mres_f
+print(""ON/OFF pisition:""+str(ares))
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    
+    # Get sequene from features.pkl 
+    with open(cpass+""/features.pkl"", 'rb') as cn:
+        cnn=pickle.load(cn)
+        sequ=cnn['residue_index']
+        rein=np.array(list(str(cnn['sequence'][0])[2:-1]))
+        print(str(rein))
+        twoda=np.column_stack((sequ+1,rein))
+        cn.close()
+        pass
+    # Get sequence from features.pkl
+    
+    # Make array to determine the caliculation range of pLDDT average
+    eres=np.empty_like(rein)
+    for i in range(len(eres)):
+        cococo=0
+        for j in range(len(ares)):
+            if i > int(ares[j])-1:
+                cococo+=1
+                pass
+            pass
+        if cococo % 2 == 0:
+            eres[i]=1
+        else:
+            eres[i]=0
+        pass
+    # Make array to determine the caliculation range of pLDDT average
+    print(eres)
+    eres_f = eres.astype(np.float32)
+
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+
+    # Model alignment
+    import math
+    o4=int(len(eres)/4)
+    w4=int(o4*2)
+    t4=int(o4*3)
+    xyz1=np.zeros((4,3),dtype=float)
+    
+    if int(args.al1)>0:
+        if int(args.al1) < len(eres):
+            o4=int(args.al1)
+    if int(args.al1)>0:
+        if int(args.al2) < len(eres):
+            w4=int(args.al2)
+    if int(args.al1)>0:
+        if int(args.al3) < len(eres):
+            t4=int(args.al3)
+
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        with open(cpass+""/""+mname+""_""+www+"".pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    if o4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[0,0] = float(line[30:38].strip())
+                            xyz1[0,1] = float(line[38:46].strip())
+                            xyz1[0,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    elif w4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[1,0] = float(line[30:38].strip())
+                            xyz1[1,1] = float(line[38:46].strip())
+                            xyz1[1,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    elif t4==int(float(line[22:26].strip())):
+                        if ""CA""==line[12:16].strip():
+                            print(line)
+                            xyz1[2,0] = float(line[30:38].strip())
+                            xyz1[2,1] = float(line[38:46].strip())
+                            xyz1[2,2] = float(line[46:54].strip())
+                            pass
+                        pass
+                    else:
+                        pass
+                    pass
+                else:
+                    pass
+                pass
+            pass
+        print(""------------"")
+        xyz1[3,0] = round((xyz1[0,0]+xyz1[2,0])/2,3)
+        xyz1[3,1] = round((xyz1[0,1]+xyz1[2,1])/2,3)
+        xyz1[3,2] = round((xyz1[0,2]+xyz1[2,2])/2,3)
+        xyzm=np.zeros((1,3),dtype=float)
+        xyzm[0,0] = xyz1[3,0]
+        xyzm[0,1] = xyz1[3,1]
+        xyzm[0,2] = xyz1[3,2]
+        print(""Initial xyz"")
+        print(xyz1)
+        xyz2=xyz1-xyzm
+        print(""Center xyz"")
+        #print(xyz2)
+        #print(""------------"")
+        # rotation z fit oy and ty to zero
+        if xyz2[0,1]>0:
+            pmy=-1
+            pass
+        else:
+            pmy=1
+            pass
+        distaxy=math.sqrt(math.pow(xyz2[0,0], 2)+math.pow(xyz2[0,1], 2))
+        radax=pmy*math.acos(xyz2[0,0]/distaxy)
+        rot1=np.zeros((3,3),dtype=float)
+        rot1[0,0]=math.cos(radax)
+        rot1[1,0]=-math.sin(radax)
+        rot1[0,1]=math.sin(radax)
+        rot1[1,1]=math.cos(radax)
+        rot1[2,2]=1
+        xyz3=np.dot(xyz2,rot1)
+        print(""rotation z fit 1y and 3y to zero"")
+        #print(xyz3)
+        #print(""------------"")
+        # rotation y fit ox to zero
+        if xyz3[0,2]>0:
+            pmz=-1
+            pass
+        else:
+            pmz=1
+            pass
+        dista1=math.sqrt(math.pow(xyz3[0,0], 2)+math.pow(xyz3[0,1], 2)+math.pow(xyz3[0,2], 2))
+        radaxy=pmz*math.acos(xyz3[0,0]/dista1)
+        rot2=np.zeros((3,3),dtype=float)
+        rot2[0,0]=math.cos(radaxy)
+        rot2[2,0]=-math.sin(radaxy)
+        rot2[0,2]=math.sin(radaxy)
+        rot2[2,2]=math.cos(radaxy)
+        rot2[1,1]=1
+        xyz4=np.dot(xyz3,rot2)
+        print(""rotation y fit 1z and 3z to zero"")
+        #print(xyz4)
+        #print(""------------"")
+        # rotation x fit wz to zero
+        if xyz4[1,2]>0:
+            pmyz=-1
+            pass
+        else:
+            pmyz=1
+            pass
+        distbbyz=math.sqrt(math.pow(xyz4[1,1], 2)+math.pow(xyz4[1,2], 2))
+        radbbyz=pmyz*math.acos(xyz4[1,1]/distbbyz)
+        rot3=np.zeros((3,3),dtype=float)
+        rot3[1,1]=math.cos(radbbyz)
+        rot3[2,1]=-math.sin(radbbyz)
+        rot3[1,2]=math.sin(radbbyz)
+        rot3[2,2]=math.cos(radbbyz)
+        rot3[0,0]=1
+        xyz5=np.dot(xyz4,rot3)
+        print(""rotation x fit 2z to zero"")
+        #print(xyz5)
+        #print(""------------"")
+        # Check all shift & roation 
+        xyz6=np.dot(np.dot(np.dot(xyz1-xyzm,rot1),rot2),rot3)
+        print(""Check all shift & roation"")
+        print(xyz6)
+        print(""------------"")
+        xyz=np.zeros((1,3),dtype=float)
+        liii=""""
+        with open(cpass+""/""+mname+""_""+www+"".pdb"", mode='r') as g1:
+            for line in g1:
+                if line[0:4]==""ATOM"":
+                    xyz[::1]=0
+                    xyz[0,0] = float(line[30:38].strip())
+                    xyz[0,1] = float(line[38:46].strip())
+                    xyz[0,2] = float(line[46:54].strip())
+                    xyzn=np.dot(np.dot(np.dot(xyz-xyzm,rot1),rot2),rot3)
+                    qxxl="" ""*(8-len(str(round(xyzn[0,0],4))))+str(round(xyzn[0,0],4))
+                    qyyl="" ""*(8-len(str(round(xyzn[0,1],4))))+str(round(xyzn[0,1],4))
+                    qzzl="" ""*(8-len(str(round(xyzn[0,2],4))))+str(round(xyzn[0,2],4))
+                    liii+=line[0:30]+qxxl+qyyl+qzzl+line[54:]
+                    pass
+                else:
+                    liii+=line
+                pass
+            pass
+        with open(cpass+""/align_""+str(lpass[-1])+""_m""+www+"".pdb"", mode='w') as i:
+            i.write(liii)
+            i.close()
+            pass
+        pass
+
+
+    
+    plddts=np.empty(namen)
+    # Repeat for the caliculation of all models
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        # Read pLDDT from result_model_?.pkl
+        with open(cpass+""/""+iname+""_""+www+"".pkl"", 'rb') as c1:
+            c1n=pickle.load(c1)
+            c1n_f = c1n['plddt'].astype(np.float32)
+            # Caliculation of average pLDDT
+            na_mul=c1n_f*eres_f
+            plddts[i]=np.sum(na_mul)/np.sum(eres_f)
+            # Caliculation of average pLDDT
+            pld1=np.round(c1n['plddt'], decimals=2)
+            twoda=np.column_stack((twoda,pld1))
+            pd1=['{:.2f}'.format(n) for n in pld1.tolist()]
+            c1.close()
+            pass
+        # Read pLDDT from result_model_?.pkl
+        
+        print(""Save:""+cpass+""/align_""+str(lpass[-1])+""_m""+www+"".pdb"")
+#        print(""Save:""+cpass+""/""+str(lpass[-1])+""_""+www+""_pLDDT""+str(int(np.sum(na_mul)/np.sum(eres_f)))+"".pdb"")
+        pass
+    print(""------------"")
+    
+    
+
+    
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    print(""number of calculated residues: ""+str(int(np.sum(eres_f)))+"" (Ignore: ""+str(ures)+"")"")
+    np.set_printoptions(formatter={'float': '{:.0f}'.format})
+    print(""Rank  :""+str(rankdata(-plddts)))
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+    twoda=np.column_stack((twoda,eres))
+    print(""plddts:""+str(plddts))
+    print(""------------"")
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    
+    # Write pLDDT in csv file  
+    np.savetxt(cpass+'/'+str(lpass[-1])+'_plddt.csv',twoda,delimiter=',',fmt=""%s"")
+    print(""Save:""+cpass+'/'+str(lpass[-1])+'_plddt.csv')
+    pass
+
+
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","plddt2csv.py",".py","6330","187","# Import
+import os
+import sys
+import pickle
+import csv
+import sys
+import time
+import numpy as np
+import argparse
+from scipy.stats import rankdata
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.2_(2021Jul.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program extract plddt values from [result_model.pkl] to [.csv] "")
+print(""for Alphafold2"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(description=""The program extract plddt from [result_model.pkl] to [.csv]"")
+parser.add_argument('-i', default='result_model', help='input XXXXX if [XXXXX_Y.pkl]; ex) result_model (def.)')
+parser.add_argument('-n', default='5', help='input Y if you want open [XXXXX_1.pkl,XXXXX_2.pkl ... ,XXXXX_5.pkl]; ex) 5 (def.)')
+parser.add_argument('-o', default='plddt', help='input XXXXX if you want to name the output [XXXXX.csv]; ex) plddt (def.)')
+parser.add_argument('-d', default='', help='ignoreed residue number for average pLDDTs caliculation to determined the ranking of models [1-5_56-75_105-135]; ex) """" (def.)')
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""_?.pkl"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+# Number of models
+namen=int(str(args.n))
+
+# Output file name
+oname=str(args.o)
+print(""Output file name:""+str(oname)+"".csv"")
+print(""It can be changed by [-o ""+oname+""]"")
+print("""")
+
+# Igunore residue
+dres=str(args.d)
+ures=dres.split(""_"")
+print(""Igunore residues:""+str(ures))
+sres=[]
+for i in range(len(ures)):
+    hres=[]
+    hres=ures[i].split(""-"")
+    sres.extend(hres)
+fres=list(filter(None,sres))
+mres=np.empty_like(fres)
+mres[::1]=0
+mres[::2]=1
+fres_f = np.array(fres).astype(np.float32)
+mres_f = mres.astype(np.float32)
+ares=fres_f-mres_f
+print(""ON/OFF pisition:""+str(ares))
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    
+    # Get sequene from features.pkl 
+    with open(cpass+""/features.pkl"", 'rb') as cn:
+        cnn=pickle.load(cn)
+        sequ=cnn['residue_index']
+        rein=np.array(list(str(cnn['sequence'][0])[2:-1]))
+        twoda=np.column_stack((sequ+1,rein))
+        cn.close()
+        pass
+    # Get sequence from features.pkl
+    
+    # Make array to determine the caliculation range of pLDDT average
+    eres=np.empty_like(rein)
+    for i in range(len(eres)):
+        cococo=0
+        for j in range(len(ares)):
+            if i > int(ares[j])-1:
+                cococo+=1
+                pass
+            pass
+        if cococo % 2 == 0:
+            eres[i]=1
+        else:
+            eres[i]=0
+        pass
+    # Make array to determine the caliculation range of pLDDT average
+    print(eres)
+    eres_f = eres.astype(np.float32)
+    
+    plddts=np.empty(namen)
+    # Repeat for the caliculation of all models
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        # Read pLDDT from result_model_?.pkl
+        with open(cpass+""/""+iname+""_""+www+"".pkl"", 'rb') as c1:
+            c1n=pickle.load(c1)
+            c1n_f = c1n['plddt'].astype(np.float32)
+            # Caliculation of average pLDDT
+            na_mul=c1n_f*eres_f
+            plddts[i]=np.sum(na_mul)/np.sum(eres_f)
+            # Caliculation of average pLDDT
+            pld1=np.round(c1n['plddt'], decimals=2)
+            twoda=np.column_stack((twoda,pld1))
+            pd1=['{:.2f}'.format(n) for n in pld1.tolist()]
+            c1.close()
+            pass
+        # Read pLDDT from result_model_?.pkl
+        
+        ll1=""""
+        ss1=""""
+        # Write pLDDT in the PDB_Bfactor
+        with open(cpass+""/relaxed_model_""+www+"".pdb"", mode='r') as g1:
+            for line in g1:
+                if  line[0:4]==""ATOM"":
+                    pdd1=pd1[int(float(line[22:26].strip())-1)]
+                    ll1+=line[0:60]+"" ""*(6-len(pdd1))+pdd1+line[66:]
+                    if int(eres[int(float(line[22:26].strip())-1)])==1:
+                        ss1+=line[0:60]+"" ""*(6-len(pdd1))+pdd1+line[66:]
+                    else:
+                        pass
+                    pass
+                else:
+                    ll1+=line
+                    ss1+=line
+                    pass
+                pass
+            g1.close()
+            pass
+        with open(cpass+""/relaxed_""+str(lpass[-1])+""_""+www+"".pdb"", mode='w') as i:
+            i.write(ll1)
+            i.close()
+            pass
+        with open(cpass+""/""+str(lpass[-1])+""_""+www+""_pLDDT""+str(int(np.sum(na_mul)/np.sum(eres_f)))+"".pdb"", mode='w') as i:
+            i.write(ss1)
+            i.close()
+            pass
+        # Write pLDDT in the PDB_Bfactor
+        print(""Save:""+cpass+""/relaxed_""+str(lpass[-1])+""_""+www+"".pdb"")
+        print(""Save:""+cpass+""/""+str(lpass[-1])+""_""+www+""_pLDDT""+str(int(np.sum(na_mul)/np.sum(eres_f)))+"".pdb"")
+        pass
+    print(""------------"")
+    
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    print(""number of calculated residues: ""+str(int(np.sum(eres_f)))+"" (Ignore: ""+str(ures)+"")"")
+    print(""Rank  :""+str(rankdata(-plddts)))
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+    twoda=np.column_stack((twoda,eres))
+    print(""plddts:""+str(plddts))
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    
+    # Write pLDDT in csv file  
+    np.savetxt(cpass+'/'+oname+'.csv',twoda,delimiter=',',fmt=""%s"")
+    pass
+
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","CYP152N1/plddt2csv","pae2csv.py",".py","5720","170","# Import
+import os
+import sys
+import pickle
+import csv
+import sys
+import time
+import numpy as np
+import argparse
+from scipy.stats import rankdata
+# Import
+
+# Header
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(""------------"")
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Start:""+str(sys.argv))
+print(""Ver.2_(2021Jul.)"")
+print(""by Hiroki Onoda, YCU"")
+print(""------------"")
+print(""The program extract pae and plddt values from [result_model_?_ptm.pkl] to [.csv] "")
+print(""Thanks Dr. Yoshitaka Moriwaki (@Ag_smith) for initially showing how to export predicted aligned error in alphafold2."")
+print(""You need to change model name to model_?_ptm from model_? at Docker/run_docker.py"")
+print(""for Alphafold2"")
+print(""------------"")
+# Header
+
+# Argument & Help
+parser = argparse.ArgumentParser(description=""The program extract plddt from [result_model.pkl] to [.csv]"")
+parser.add_argument('-i', default='result_model', help='input XXXXX if [XXXXX_Y.pkl]; ex) result_model (def.)')
+parser.add_argument('-n', default='5', help='input Y if you want open [XXXXX_1.pkl,XXXXX_2.pkl ... ,XXXXX_5.pkl]; ex) 5 (def.)')
+parser.add_argument('-o', default='p2c', help='input XXXXX if you want to name the output [XXXXX.csv]; ex) plddt (def.)')
+parser.add_argument('-d', default='', help='ignored residue number for average pLDDTs caliculation to determined the ranking of models [1-5_56-75_105-135]; ex) """" (def.)')
+args = parser.parse_args()
+# Argument & Help
+
+#l----------------------------------------------l
+#l           Valiable information               l
+#l----------------------------------------------l
+
+# Input file name
+iname=str(args.i)
+print(""Input file name:""+str(iname)+""_?_ptm.pkl"")
+print(""It can be changed by [-i ""+iname+""]"")
+print("""")
+
+# Number of models
+namen=int(str(args.n))
+
+# Output file name
+oname=str(args.o)
+print(""Output file name:""+str(oname)+"".csv"")
+print(""It can be changed by [-o ""+oname+""]"")
+print("""")
+
+# Ignore residue
+dres=str(args.d)
+ures=dres.split(""_"")
+print(""Ignore residues:""+str(ures))
+sres=[]
+for i in range(len(ures)):
+    hres=[]
+    hres=ures[i].split(""-"")
+    sres.extend(hres)
+fres=list(filter(None,sres))
+mres=np.empty_like(fres)
+mres[::1]=0
+mres[::2]=1
+fres_f = np.array(fres).astype(np.float32)
+mres_f = mres.astype(np.float32)
+ares=fres_f-mres_f
+print(""ON/OFF pisition:""+str(ares))
+
+#l-----------------------------------------------l
+#l           Valiable information                l
+#l-----------------------------------------------l
+
+
+def read():    
+    cpass=os.getcwd()
+    lpass=cpass.split(""/"")
+    
+    # Get sequene from features.pkl 
+    with open(cpass+""/features.pkl"", 'rb') as cn:
+        cnn=pickle.load(cn)
+        sequ=cnn['residue_index']
+        rein=np.array(list(str(cnn['sequence'][0])[2:-1]))
+        twoda=np.column_stack((sequ+1,rein))
+        cn.close()
+        pass
+    # Get sequence from features.pkl
+    
+    # Make array to determine the caliculation range of pLDDT average
+    eres=np.empty_like(rein)
+    for i in range(len(eres)):
+        cococo=0
+        for j in range(len(ares)):
+            if i > int(ares[j])-1:
+                cococo+=1
+                pass
+            pass
+        if cococo % 2 == 0:
+            eres[i]=1
+        else:
+            eres[i]=0
+        pass
+    # Make array to determine the caliculation range of pLDDT average
+    print(eres)
+    eres_f = eres.astype(np.float32)
+
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+
+    
+    plddts=np.empty(namen)
+    # Repeat for the caliculation of all models
+    for i in range(namen):
+        www=str(int(float(i)+1))
+        # Read pLDDT from result_model_?.pkl
+        with open(cpass+""/""+iname+""_""+www+""_ptm.pkl"", 'rb') as c1:
+            c1n=pickle.load(c1)
+            # Extract PAE
+            pae = c1n['predicted_aligned_error'].astype(np.float32)
+            np.savetxt(cpass+'/'+oname+'_pae_'+www+'.csv',pae,delimiter=',',fmt=""%s"")
+            print(""Save:""+cpass+'/'+oname+'_pae_'+www+'.csv')
+            # Extract PAE
+            c1n_f = c1n['plddt'].astype(np.float32)
+            # Caliculation of average pLDDT
+            na_mul=c1n_f*eres_f
+            plddts[i]=np.sum(na_mul)/np.sum(eres_f)
+            # Caliculation of average pLDDT
+            pld1=np.round(c1n['plddt'], decimals=2)
+            twoda=np.column_stack((twoda,pld1))
+            pd1=['{:.2f}'.format(n) for n in pld1.tolist()]
+            c1.close()
+            pass
+        # Read pLDDT from result_model_?.pkl
+        pass
+    print(""------------"")
+    
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    print(""number of calculated residues: ""+str(int(np.sum(eres_f)))+"" (Ignore: ""+str(ures)+"")"")
+    np.set_printoptions(formatter={'float': '{:.0f}'.format})
+    print(""Rank  :""+str(rankdata(-plddts)))
+    np.set_printoptions(formatter={'float': '{:.1f}'.format})
+    twoda=np.column_stack((twoda,eres))
+    print(""plddts:""+str(plddts))
+    print(""------------"")
+    # Caliculation of pLDDT rank without specificic range (-d argument)
+    
+    # Write pLDDT in csv file  
+    np.savetxt(cpass+'/'+oname+'_plddt.csv',twoda,delimiter=',',fmt=""%s"")
+    print(""Save:""+cpass+'/'+oname+'_plddt.csv')
+    pass
+
+
+
+#l-----------------------------------------------l
+#l                   Execution                   l
+#l-----------------------------------------------l
+
+print(""------------"")
+read()
+print(""------------"")
+now = time.ctime()
+cnvtime = time.strptime(now)
+print(time.strftime(""%Y/%m/%d %H:%M"", cnvtime))
+print(""Finish:""+str(sys.argv))
+print(""------------"")
+","Python"
+"AlphaFold","jasperzuallaert/VIBFold","alphafold_job_script_multimer.sh",".sh","689","24","#!/bin/bash
+#PBS -N AlphaFold_multimer_script
+#PBS -l nodes=1:ppn=8:gpus=1
+#PBS -l mem=64gb
+#PBS -l walltime=24:0:0
+
+PROTEIN=SARSCOV2_VHH72
+
+module load AlphaFold/2.3.2-foss-2023a-CUDA-12.1.1
+export ALPHAFOLD_DATA_DIR=/arcanine/scratch/gent/apps/AlphaFold/20230310
+
+WORKDIR=$VSC_DATA/alphafold/runs/$PBS_JOBID-$PROTEIN
+mkdir -p $WORKDIR
+cp -a $PBS_O_WORKDIR/fastas/$PROTEIN.fasta $WORKDIR/
+cd $WORKDIR
+
+echo Running $PROTEIN.fasta, output found at $WORKDIR
+alphafold --fasta_paths=$PROTEIN.fasta \
+          --max_template_date=2999-01-01 \
+          --db_preset=full_dbs \
+          --output_dir=$PWD \
+          --model_preset=multimer \
+          --num_multimer_predictions_per_model=1
+","Shell"
+"AlphaFold","jasperzuallaert/VIBFold","alphafold_job_script.sh",".sh","633","26","#!/bin/bash
+#PBS -N AlphaFold_tutorial_script
+#PBS -l nodes=1:ppn=8:gpus=1
+#PBS -l mem=64gb
+#PBS -l walltime=24:0:0
+
+PROTEIN=rbd
+
+module load AlphaFold/2.3.2-foss-2023a-CUDA-12.1.1
+export ALPHAFOLD_DATA_DIR=/arcanine/scratch/gent/apps/AlphaFold/20230310
+
+WORKDIR=$VSC_DATA/alphafold/runs/$PBS_JOBID-$PROTEIN
+mkdir -p $WORKDIR
+cp -a $PBS_O_WORKDIR/fastas/$PROTEIN.fasta $WORKDIR/
+cd $WORKDIR
+
+echo Running $PROTEIN.fasta, output found at $WORKDIR
+alphafold --fasta_paths=$PROTEIN.fasta \
+          --max_template_date=2999-01-01 \
+          --db_preset=full_dbs \
+          --output_dir=$PWD \
+          --model_preset=monomer_ptm
+
+
+
+","Shell"
+"AlphaFold","jasperzuallaert/VIBFold","VIBFold_adapted_functions.py",".py","13478","344","import random
+from tqdm import tqdm
+import dataclasses
+import json
+import copy
+from alphafold.data import feature_processing, msa_pairing, msa_identifiers
+from alphafold.data import pipeline as alpha_pipeline
+from alphafold.data import parsers
+from alphafold.common import residue_constants
+from alphafold.data import pipeline_multimer
+import numpy as np
+import tarfile
+import requests
+import time
+import os
+
+# Copied from AlphaFold - should recheck where this comes from
+def process_multimer_features(features_for_chain):
+    all_chain_features = {}
+    for chain_id, chain_features in features_for_chain.items():
+        all_chain_features[chain_id] = pipeline_multimer.convert_monomer_features(
+            chain_features, chain_id
+        )
+
+    all_chain_features = pipeline_multimer.add_assembly_features(all_chain_features)
+    feature_processing.process_unmerged_features(all_chain_features)
+    np_chains_list = list(all_chain_features.values())
+    pair_msa_sequences = not feature_processing._is_homomer_or_monomer(np_chains_list)
+    chains = list(np_chains_list)
+    chain_keys = chains[0].keys()
+    updated_chains = []
+    for chain_num, chain in enumerate(chains):
+        new_chain = {k: v for k, v in chain.items() if ""_all_seq"" not in k}
+        for feature_name in chain_keys:
+            if feature_name.endswith(""_all_seq""):
+                feats_padded = msa_pairing.pad_features(
+                    chain[feature_name], feature_name
+                )
+                new_chain[feature_name] = feats_padded
+        new_chain[""num_alignments_all_seq""] = np.asarray(
+            len(np_chains_list[chain_num][""msa_all_seq""])
+        )
+        updated_chains.append(new_chain)
+    np_chains_list = updated_chains
+    np_chains_list = feature_processing.crop_chains(
+        np_chains_list,
+        msa_crop_size=feature_processing.MSA_CROP_SIZE,
+        pair_msa_sequences=pair_msa_sequences,
+        max_templates=feature_processing.MAX_TEMPLATES,
+    )
+
+    np_example = feature_processing.msa_pairing.merge_chain_features(
+        np_chains_list=np_chains_list,
+        pair_msa_sequences=pair_msa_sequences,
+        max_templates=feature_processing.MAX_TEMPLATES,
+    )
+    np_example = feature_processing.process_final(np_example)
+
+    np_example = pipeline_multimer.pad_msa(np_example, min_num_seq=512)
+    return np_example
+
+# Copied from AlphaFold, adapted code so that duplicate rows in the MSA are not deleted. This gave problems
+# when pairing MSAs
+def my_make_msa_features_keep_duplicates(msas):
+  if not msas:
+    raise ValueError('At least one MSA must be provided.')
+
+  int_msa = []
+  deletion_matrix = []
+  species_ids = []
+  for msa_index, msa in enumerate(msas):
+    if not msa:
+      raise ValueError(f'MSA {msa_index} must contain at least one sequence.')
+    for sequence_index, sequence in enumerate(msa.sequences):
+      int_msa.append(
+          [residue_constants.HHBLITS_AA_TO_ID[res] for res in sequence])
+      deletion_matrix.append(msa.deletion_matrix[sequence_index])
+      identifiers = msa_identifiers.get_identifiers(
+          msa.descriptions[sequence_index])
+      species_ids.append(identifiers.species_id.encode('utf-8'))
+
+  num_res = len(msas[0].sequences[0])
+  num_alignments = len(int_msa)
+  features = {}
+  features['deletion_matrix_int'] = np.array(deletion_matrix, dtype=np.int32)
+  features['msa'] = np.array(int_msa, dtype=np.int32)
+  features['num_alignments'] = np.array([num_alignments] * num_res, dtype=np.int32)
+  features['msa_species_identifiers'] = np.array(species_ids, dtype=np.object_)
+  return features
+
+# Copied from AlphaFold datapipeline package: modified the process function to use a seq_to_features_cache across
+# runs (multiple permutations), instead of within one run
+class Cached_DataPipeline(pipeline_multimer.DataPipeline):  # copied from AlphaFold repo, adapted caching
+    def __init__(self, monomer_data_pipeline, jackhmmer_binary_path, uniprot_database_path, use_precomputed_msas, seq_to_features_cache):
+        super(Cached_DataPipeline, self).__init__(monomer_data_pipeline=monomer_data_pipeline,
+                                                  jackhmmer_binary_path=jackhmmer_binary_path,
+                                                  uniprot_database_path=uniprot_database_path,
+                                                  use_precomputed_msas=use_precomputed_msas)
+        self.seq_to_features_cache = seq_to_features_cache
+
+    def process(self,
+                input_fasta_path: str,
+                msa_output_dir: str) -> alpha_pipeline.FeatureDict:
+        """"""Runs alignment tools on the input sequences and creates features.""""""
+        with open(input_fasta_path) as f:
+            input_fasta_str = f.read()
+        input_seqs, input_descs = parsers.parse_fasta(input_fasta_str)
+
+        chain_id_map = pipeline_multimer._make_chain_id_map(sequences=input_seqs, descriptions=input_descs)
+        chain_id_map_path = os.path.join(msa_output_dir, 'chain_id_map.json')
+        with open(chain_id_map_path, 'w') as f:
+            chain_id_map_dict = {chain_id: dataclasses.asdict(fasta_chain)
+                                 for chain_id, fasta_chain in chain_id_map.items()}
+            json.dump(chain_id_map_dict, f, indent=4, sort_keys=True)
+
+        all_chain_features = {}
+        is_homomer_or_monomer = len(set(input_seqs)) == 1
+        for chain_id, fasta_chain in chain_id_map.items():
+            if fasta_chain.sequence in self.seq_to_features_cache:
+                all_chain_features[chain_id] = copy.deepcopy(
+                    self.seq_to_features_cache[fasta_chain.sequence])
+                continue
+            chain_features = self._process_single_chain(
+                chain_id=chain_id,
+                sequence=fasta_chain.sequence,
+                description=fasta_chain.description,
+                msa_output_dir=msa_output_dir,
+                is_homomer_or_monomer=is_homomer_or_monomer)
+
+            chain_features = pipeline_multimer.convert_monomer_features(chain_features, chain_id=chain_id)
+            all_chain_features[chain_id] = chain_features
+            self.seq_to_features_cache[fasta_chain.sequence] = copy.deepcopy(chain_features)
+
+        all_chain_features = pipeline_multimer.add_assembly_features(all_chain_features)
+        np_example = feature_processing.pair_and_merge(all_chain_features=all_chain_features)
+        # Pad MSA to avoid zero-sized extra_msa.
+        np_example = pad_msa(np_example, 512)
+
+        # need this to
+
+        return np_example
+
+# Copied from AlphaFold repo, to use in the pipeline class
+def pad_msa(np_example, min_num_seq):
+  np_example = dict(np_example)
+  num_seq = np_example['msa'].shape[0]
+  if num_seq < min_num_seq:
+    for feat in ('msa', 'deletion_matrix', 'bert_mask', 'msa_mask'):
+      np_example[feat] = np.pad(
+          np_example[feat], ((0, min_num_seq - num_seq), (0, 0)))
+    np_example['cluster_bias_mask'] = np.pad(
+        np_example['cluster_bias_mask'], ((0, min_num_seq - num_seq),))
+  return np_example
+
+
+# Exact copy from ColabFold
+##########################################
+# call mmseqs2
+##########################################
+
+TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'
+
+def run_mmseqs2(x, prefix, use_env=True, use_filter=True,
+                use_templates=False, filter=None, use_pairing=False,
+                host_url=""https://api.colabfold.com""):
+  submission_endpoint = ""ticket/pair"" if use_pairing else ""ticket/msa""
+
+  def submit(seqs, mode, N=101):
+    n, query = N, """"
+    for seq in seqs:
+      query += f"">{n}\n{seq}\n""
+      n += 1
+
+    res = requests.post(f'{host_url}/{submission_endpoint}', data={'q':query,'mode': mode})
+    try:
+      out = res.json()
+    except ValueError:
+      print(f""Server didn't reply with json: {res.text}"")
+      out = {""status"":""ERROR""}
+    return out
+
+  def status(ID):
+    res = requests.get(f'{host_url}/ticket/{ID}')
+    try:
+      out = res.json()
+    except ValueError:
+      print(f""Server didn't reply with json: {res.text}"")
+      out = {""status"":""ERROR""}
+    return out
+
+  def download(ID, path):
+    res = requests.get(f'{host_url}/result/download/{ID}')
+    with open(path,""wb"") as out: out.write(res.content)
+
+  # process input x
+  seqs = [x] if isinstance(x, str) else x
+
+  # compatibility to old option
+  if filter is not None:
+    use_filter = filter
+
+  # setup mode
+  if use_filter:
+    mode = ""env"" if use_env else ""all""
+  else:
+    mode = ""env-nofilter"" if use_env else ""nofilter""
+
+  if use_pairing:
+    mode = """"
+    use_templates = False
+    use_env = False
+
+  # define path
+  path = f""{prefix}_{mode}""
+  if not os.path.isdir(path): os.mkdir(path)
+
+  # call mmseqs2 api
+  tar_gz_file = f'{path}/out.tar.gz'
+  N,REDO = 101,True
+
+  # deduplicate and keep track of order
+  seqs_unique = []
+  #TODO this might be slow for large sets
+  [seqs_unique.append(x) for x in seqs if x not in seqs_unique]
+  Ms = [N + seqs_unique.index(seq) for seq in seqs]
+  # lets do it!
+  if not os.path.isfile(tar_gz_file):
+    TIME_ESTIMATE = 150 * len(seqs_unique)
+    with tqdm(total=TIME_ESTIMATE, bar_format=TQDM_BAR_FORMAT) as pbar:
+      while REDO:
+        pbar.set_description(""SUBMIT"")
+
+        # Resubmit job until it goes through
+        out = submit(seqs_unique, mode, N)
+        while out[""status""] in [""UNKNOWN"", ""RATELIMIT""]:
+          sleep_time = 5 + random.randint(0, 5)
+          print(f""Sleeping for {sleep_time}s. Reason: {out['status']}"")
+          # resubmit
+          time.sleep(sleep_time)
+          out = submit(seqs_unique, mode, N)
+
+        if out[""status""] == ""ERROR"":
+          raise Exception(f'MMseqs2 API is giving errors. Please confirm your input is a valid protein sequence. If error persists, please try again an hour later.')
+
+        if out[""status""] == ""MAINTENANCE"":
+          raise Exception(f'MMseqs2 API is undergoing maintenance. Please try again in a few minutes.')
+
+        # wait for job to finish
+        ID,TIME = out[""id""],0
+        pbar.set_description(out[""status""])
+        while out[""status""] in [""UNKNOWN"",""RUNNING"",""PENDING""]:
+          t = 5 + random.randint(0,5)
+          print(f""Sleeping for {t}s. Reason: {out['status']}"")
+          time.sleep(t)
+          out = status(ID)
+          pbar.set_description(out[""status""])
+          if out[""status""] == ""RUNNING"":
+            TIME += t
+            pbar.update(n=t)
+          #if TIME > 900 and out[""status""] != ""COMPLETE"":
+          #  # something failed on the server side, need to resubmit
+          #  N += 1
+          #  break
+
+        if out[""status""] == ""COMPLETE"":
+          if TIME < TIME_ESTIMATE:
+            pbar.update(n=(TIME_ESTIMATE-TIME))
+          REDO = False
+
+        if out[""status""] == ""ERROR"":
+          REDO = False
+          raise Exception(f'MMseqs2 API is giving errors. Please confirm your input is a valid protein sequence. If error persists, please try again an hour later.')
+
+      # Download results
+      download(ID, tar_gz_file)
+
+  # prep list of a3m files
+  if use_pairing:
+    a3m_files = [f""{path}/pair.a3m""]
+  else:
+    a3m_files = [f""{path}/uniref.a3m""]
+    if use_env: a3m_files.append(f""{path}/bfd.mgnify30.metaeuk30.smag30.a3m"")
+
+  # extract a3m files
+  if any(not os.path.isfile(a3m_file) for a3m_file in a3m_files):
+    with tarfile.open(tar_gz_file) as tar_gz:
+      tar_gz.extractall(path)
+
+  # templates
+  if use_templates:
+    templates = {}
+    #print(""seq\tpdb\tcid\tevalue"")
+    for line in open(f""{path}/pdb70.m8"",""r""):
+      p = line.rstrip().split()
+      M,pdb,qid,e_value = p[0],p[1],p[2],p[10]
+      M = int(M)
+      if M not in templates: templates[M] = []
+      templates[M].append(pdb)
+      #if len(templates[M]) <= 20:
+      #  print(f""{int(M)-N}\t{pdb}\t{qid}\t{e_value}"")
+
+    template_paths = {}
+    for k,TMPL in templates.items():
+      TMPL_PATH = f""{prefix}_{mode}/templates_{k}""
+      if not os.path.isdir(TMPL_PATH):
+        os.mkdir(TMPL_PATH)
+        TMPL_LINE = "","".join(TMPL[:20])
+        os.system(f""curl -s -L {host_url}/template/{TMPL_LINE} | tar xzf - -C {TMPL_PATH}/"")
+        os.system(f""cp {TMPL_PATH}/pdb70_a3m.ffindex {TMPL_PATH}/pdb70_cs219.ffindex"")
+        os.system(f""touch {TMPL_PATH}/pdb70_cs219.ffdata"")
+      template_paths[k] = TMPL_PATH
+
+  # gather a3m lines
+  a3m_lines = {}
+  for a3m_file in a3m_files:
+    update_M,M = True,None
+    for line in open(a3m_file,""r""):
+      if len(line) > 0:
+        if ""\x00"" in line:
+          line = line.replace(""\x00"","""")
+          update_M = True
+        if line.startswith("">"") and update_M:
+          M = int(line[1:].rstrip())
+          update_M = False
+          if M not in a3m_lines: a3m_lines[M] = []
+        a3m_lines[M].append(line)
+
+  # return results
+
+  a3m_lines = ["""".join(a3m_lines[n]) for n in Ms]
+
+  if use_templates:
+    template_paths_ = []
+    for n in Ms:
+      if n not in template_paths:
+        template_paths_.append(None)
+        #print(f""{n-N}\tno_templates_found"")
+      else:
+        template_paths_.append(template_paths[n])
+    template_paths = template_paths_
+
+
+  return (a3m_lines, template_paths) if use_templates else a3m_lines
+","Python"
+"AlphaFold","jasperzuallaert/VIBFold","submit_vibfold.py",".py","4401","110","
+FASTA_FILE = 'fastas/test.fasta'        # location of fasta file between '' - absolute or relative path possible
+IS_COMPLEX = True                       # True or False
+MSA_MODE = 'mmseqs2_server'             # 'alphafold_default' or 'mmseqs2_server'
+SAVE_DIR = 'results/test'               # location of results directory between '' - abs or rel path possible
+DO_RELAX = 'best'                       # 'all', 'best' or 'none'
+NUM_RUNS_PER_MODEL = 1                  # number of runs per model, with different random seed
+USE_TEMPLATES = True                   # True, False
+MAX_RECYCLES = 3                        # default == 3
+
+
+import subprocess
+import os
+import time
+
+timestamp = time.strftime('%Y%m%d_%H%M%S') + '_'
+
+def submit(FASTA_FILE, IS_COMPLEX, MSA_MODE, SAVE_DIR, DO_RELAX, USE_TEMPLATES, MAX_RECYCLES):
+    assert ' ' not in FASTA_FILE, 'The name of your FASTA file cannot contain any spaces'
+    # automatically select accelgor/joltik based on output of 'ml'
+    module_info = subprocess.check_output('ml',shell=True).decode('utf-8')
+    cluster = 'accelgor' if 'accelgor' in module_info else \
+              'joltik' if 'joltik' in module_info else \
+              'litleo' if 'litleo' in module_info else \
+              'donphan' if 'donphan' in module_info else ''
+    if not cluster:
+        raise NotImplementedError('Cluster joltik/accelgor/donphan not found in ""ml"" output. Did you use ""module swap cluster/joltik"" (or other)?')
+
+    fasta_d = {}
+    seq = ''
+    ctr = 1
+    for line in open(FASTA_FILE):
+        if line.startswith('>'):
+            if seq:
+                fasta_d[prot_id] = seq
+                seq = ''
+            prot_id = f'{ctr}_{line.rstrip().lstrip("">"").replace("" "", ""_"").replace("":"", ""_"").replace(""("", """").replace("")"", """")}'
+            if '|' in prot_id: prot_id = prot_id.split('|')[1]
+            ctr+=1
+        elif line:
+            seq += line.rstrip()
+    if seq:
+        fasta_d[prot_id] = seq
+
+    all_seqs = {}
+    all_protnames = {}
+    if not IS_COMPLEX: # create one new FASTA file per entry
+        for prot_id, seq in fasta_d.items():
+            all_seqs[prot_id] = seq
+            all_protnames[prot_id] = prot_id
+    else: # create a copy of the multi-entry FASTA file
+        fasta_id = os.path.basename(FASTA_FILE).split('.')[0]
+        seqs = fasta_d.values()
+        all_protnames[fasta_id] = ':'.join(fasta_d.keys())
+        all_seqs[fasta_id] = ':'.join(seqs)
+
+    if not SAVE_DIR.startswith('/'):
+        SAVE_DIR = f'$PBS_O_WORKDIR/{SAVE_DIR}'
+
+        for prot_id, seq in all_seqs.items():
+            prot_names = all_protnames[prot_id]
+            run_save_dir = f'{SAVE_DIR}/{timestamp}_{prot_id}'
+            script_content = f'''#!/bin/bash
+#PBS -N VIBFold_{prot_id}
+#PBS -l nodes=1:ppn={12 if (cluster == 'accelgor' or cluster == 'litleo') else 8}{"",gpus=1"" if (cluster == 'accelgor' or cluster == 'joltik' or cluster == 'litleo') else """"}
+#PBS -l mem={125 if cluster == 'accelgor' else 64 if (cluster == 'joltik' or cluster == 'litleo') else 20}g
+#PBS -l walltime=48:00:00
+
+module load Python/3.11.3-GCCcore-12.3.0
+
+module load tqdm/4.66.1-GCCcore-12.3.0 
+module load matplotlib/3.7.2-gfbf-2023a
+module load AlphaFold/2.3.2-foss-2023a{""-CUDA-12.1.1"" if (cluster == 'accelgor' or cluster == 'joltik' or cluster == 'litleo') else """"}
+export ALPHAFOLD_DATA_DIR=/arcanine/scratch/gent/apps/AlphaFold/20230310
+PROTEIN={prot_id}
+
+jobname=""$PROTEIN""_""$PBS_JOBID""
+
+SAVEDIR={run_save_dir}
+mkdir -p $SAVEDIR
+
+cd $PBS_O_WORKDIR
+python VIBFold.py \
+ --seq {seq} \
+ --prot_names ""{prot_names}"" \
+ --jobname $jobname \
+ --save_dir $SAVEDIR \
+ --do_relax {DO_RELAX} \
+ {""--no_templates"" if not USE_TEMPLATES else """"} \
+ --msa_mode {MSA_MODE} \
+ --num_runs_per_model {NUM_RUNS_PER_MODEL} \
+ --max_recycles {MAX_RECYCLES} \
+ --do_gather_best
+'''
+
+            scriptname = 'submit_new.sh'
+            f = open(scriptname,'w')
+            print(script_content,file=f)
+            f.close()
+
+            print()
+            print(f'############# submitting {prot_id} #############')
+            subprocess.Popen(['echo',f'{prot_id}'],shell=False)
+            subprocess.Popen(['qsub',f'{scriptname}'],shell=False).wait()
+            subprocess.Popen(['rm',f'{scriptname}'],shell=False).wait()
+            print()
+
+if __name__ == ""__main__"":
+    submit(FASTA_FILE, IS_COMPLEX, MSA_MODE, SAVE_DIR, DO_RELAX, USE_TEMPLATES, MAX_RECYCLES)
+","Python"
+"AlphaFold","jasperzuallaert/VIBFold","VIBFold.py",".py","33906","626","import argparse
+import itertools
+import re
+import logging
+from alphafold.model import data as alpha_data, config as alpha_config
+from alphafold.common import protein as alpha_protein
+from alphafold.relax import relax
+from alphafold.model import model as alpha_model
+from random import randint
+from alphafold.data import templates as alpha_templates
+from alphafold.data.tools import hhsearch
+from alphafold.data.tools import hmmsearch
+from alphafold.data import pipeline as alpha_pipeline
+from alphafold.data import templates
+from alphafold.common import residue_constants
+import numpy as np
+from matplotlib import pyplot as plt
+import alphafold
+import json
+import os
+import shutil
+import VIBFold_adapted_functions as adapted
+from matplotlib.colors import ListedColormap
+
+MAX_NUM_PERMUTATIONS = 6 # to limit computational time
+ALPHAFOLD_DATA_DIR = os.environ['ALPHAFOLD_DATA_DIR']
+MAX_TEMPLATE_HITS = 20 # default alphafold setting
+MAX_UNIREF_HITS = 10000
+MAX_UNIPROT_HITS = 50000 # for multimer
+MAX_MGNIFY_HITS = 501
+jackhmmer_binary_path = shutil.which('jackhmmer')
+hhblits_binary_path=shutil.which('hhblits')
+hmmsearch_binary_path=shutil.which('hmmsearch')
+hmmbuild_binary_path=shutil.which('hmmbuild')
+hhsearch_binary_path=shutil.which('hhsearch')
+kalign_binary_path=shutil.which('kalign')
+uniref90_database_path=ALPHAFOLD_DATA_DIR + '/uniref90/uniref90.fasta'
+mgnify_database_path=ALPHAFOLD_DATA_DIR + '/mgnify/mgy_clusters_2022_05.fa'
+bfd_database_path=ALPHAFOLD_DATA_DIR + '/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt'
+template_mmcif_dir=ALPHAFOLD_DATA_DIR + '/pdb_mmcif/mmcif_files'
+obsolete_pdbs_path=ALPHAFOLD_DATA_DIR + '/pdb_mmcif/obsolete.dat'
+uniref30_database_path= ALPHAFOLD_DATA_DIR + '/uniref30/UniRef30_2021_03'
+pdb70_database_path=ALPHAFOLD_DATA_DIR + '/pdb70/pdb70'
+pdb_seqres_database_path=ALPHAFOLD_DATA_DIR + '/pdb_seqres/pdb_seqres.txt'
+uniprot_database_path = ALPHAFOLD_DATA_DIR + '/uniprot/uniprot.fasta' # for multimer
+
+def run_alphafold_advanced_complex(seq, prot_names, jobname, save_dir, use_templates, num_runs_per_model, do_relax, max_recycles=3, tolerance=0, msa_mode='alphafold_default', do_gather_best=False):
+    # process input parameters
+    sequences = seq.split(':')
+    prot_names = [name[:20] for name in prot_names.split(':')]
+    seq_idx = list(range(len(sequences)))
+    jobname = """".join(jobname.split())
+    jobname = re.sub(r'\W+', '', jobname)
+    use_env = True if msa_mode.startswith('mmseqs2') else False
+    model_used = 'monomer_ptm' if len(sequences) == 1 else 'multimer'
+    # Load model parameters, same for all permutations
+    model_params, model_runners_12, model_runners_345 = [], [], []
+    for _ in range(num_runs_per_model):
+        model_param, model_runner_12, model_runner_345 = prepare_models(model_used, max_recycles, tolerance)
+        model_params.append(model_param)
+        model_runners_12.append(model_runner_12)
+        model_runners_345.append(model_runner_345)
+    seq_to_msa_d = {}
+    # if multiple sequences are present in the query, a single run is done for each of the permutations
+    # Protein complexes with 'first A then B', will yield different results than 'first B then A'
+    for perm_idx, indices in enumerate(set(itertools.permutations(seq_idx))):
+        if perm_idx >= MAX_NUM_PERMUTATIONS:
+            break
+        query_sequences = [sequences[i] for i in indices]
+        query_prot_names = [prot_names[i] for i in indices]
+        # the output dir gets a permutation number if applicable
+        out_dir = f'{save_dir}/{jobname}' if len(sequences) == 1 else f'{save_dir}/{jobname}_permutation{perm_idx}'
+        out_dir = out_dir.rstrip('/')
+        os.makedirs(out_dir,exist_ok=True)
+
+        fasta_file = f'{out_dir}/query.fasta'
+        write_to_fasta = open(fasta_file, 'w')
+        for i, query_sequence in enumerate(query_sequences):
+            print(f'>chain_{i}',file=write_to_fasta)
+            print(query_sequence,file=write_to_fasta)
+        write_to_fasta.close()
+        print(open(fasta_file).read())
+
+        # set logging
+        logger = logging.Logger(f'perm{perm_idx}', level = logging.INFO)
+        fh = logging.FileHandler(filename=f'{out_dir}/info.log', mode='w')
+        fh.setFormatter(logging.Formatter(datefmt='%Y-%m-%d %H:%M:%S', fmt='%(asctime)s - %(message)s'))
+        logger.addHandler(fh)
+        logger.info(f'Parameters: num_sequences = {len(query_sequences)}')
+        logger.info(f'Parameters: model used = {model_used}')
+        logger.info(f'Parameters: use_amber = {do_relax}')
+        logger.info(f'Parameters: msa_mode = {msa_mode}')
+        logger.info(f'Parameters: use_templates = {use_templates}')
+        logger.info(f'Parameters: max_recycles = {max_recycles}')
+        logger.info(f'Parameters: recycling_tolerance = {tolerance}')
+        logger.info(f'Parameters: num_runs_per_model = {num_runs_per_model}')
+        logger.info(f'Started permutation # {perm_idx}')
+        print(f'Parameters: num_sequences = {len(query_sequences)}')
+        print(f'Parameters: model used = {model_used}')
+        print(f'Parameters: use_amber = {do_relax}')
+        print(f'Parameters: msa_mode = {msa_mode}')
+        print(f'Parameters: use_templates = {use_templates}')
+        print(f'Parameters: max_recycles = {max_recycles}')
+        print(f'Parameters: recycling_tolerance = {tolerance}')
+        print(f'Parameters: num_runs_per_model = {num_runs_per_model}')
+        print(f'Started permutation # {perm_idx}')
+
+        # Do MSA search
+        logger.info('Starting MSA search (+ templates if req)')
+        feature_dict = run_msa_search(msa_mode, query_sequences, fasta_file, seq_to_msa_d, use_templates, out_dir, jobname, logger)
+
+        # pickle.dump(feature_dict,file=open(out_dir+'/features_for_debugging.pkl','wb'))
+        if use_templates:
+            try:
+                log_template_info(feature_dict, logger)
+            except Exception as exx:
+                logger.info('Exception encountered during template logging. Feel free to contact jasper.zuallaert@vib-ugent.be about this. Error message:')
+                logger.info(exx)
+        else:
+            logger.info('No templates used.')
+        # Predict
+        logger.info('Starting predictions...')
+
+        unrelaxed_pdb_lines, unrelaxed_proteins, paes, plddts, ptms, iptms, model_names = predict_structures(logger,
+                                                                                                  model_params,
+                                                                                                  model_runners_12,
+                                                                                                  model_runners_345,
+                                                                                                  feature_dict,
+                                                                                                  model_used == 'multimer',
+                                                                                                  num_runs_per_model)
+        # rank models, relax, write pdb files
+        pae_plddt_per_model = rank_relax_write(logger, unrelaxed_pdb_lines, unrelaxed_proteins, plddts, paes, ptms, iptms, out_dir, jobname, do_relax, model_names, model_used=='multimer')
+        # generate output images
+
+        logger.info('Generating output images...')
+        generate_output_images(query_sequences, query_prot_names, pae_plddt_per_model, feature_dict['msa'], num_runs_per_model, out_dir, jobname)
+        # remove intermediate directories
+        if msa_mode.startswith('mmseqs2'):
+            os.popen(f'rm -rf {out_dir}/{jobname}_*{""env"" if use_env else """"}/')
+        else:
+            os.popen(f'rm -rf {out_dir}/{jobname}_*{""env"" if use_env else ""all""}/')
+        logger.info(f'Permutation {perm_idx} finished!')
+    # gather best prediction
+    logger.info('Gathering best prediction...')
+    if do_gather_best:
+        gather_best_prediction(save_dir, jobname, len(sequences) > 1)
+
+# Loads the models, and compiles them. Weights are loaded, but only at prediction time added to the model.
+# There is distinction between model_1 and model_3, because 1-2 and 3-4-5 have a different number of parameters
+def prepare_models(model_used, max_recycles, tolerance):
+    model_params = {}
+    model_runner_12, model_runner_345 = None, None
+    model_extension = 'ptm' if model_used == 'monomer_ptm' else 'multimer_v3'
+    for model_num in range(1,6):
+        model_name = f'model_{model_num}_{model_extension}'
+        model_params[model_name] = alpha_data.get_model_haiku_params(model_name=model_name, data_dir=ALPHAFOLD_DATA_DIR)
+        if model_num in (1,3):
+            model_config = alpha_config.model_config(model_name)
+            model_config.model.recycle_tol = tolerance
+            if model_extension == ""ptm"":
+                model_config.data.eval.num_ensemble = 1
+                model_config.data.common.num_recycle = max_recycles
+                model_config.model.num_recycle = max_recycles
+            else: # multimer
+                model_config.model.num_ensemble_eval = 1
+                model_config.model.num_recycle = max_recycles
+            if model_num == 1:
+                model_runner_12 = alpha_model.RunModel(model_config, model_params[model_name])
+            elif model_num == 3:
+                model_runner_345 = alpha_model.RunModel(model_config, model_params[model_name])
+    return model_params, model_runner_12, model_runner_345
+
+def run_msa_search(msa_type, query_sequences, query_fasta, seq_to_msa_d, use_templates, out_dir, jobname, logger):
+    run_multimer_system = len(query_sequences) > 1
+    max_template_hits = MAX_TEMPLATE_HITS if use_templates else 0
+    if msa_type == 'alphafold_default':
+        if run_multimer_system:
+            template_searcher = hmmsearch.Hmmsearch(binary_path=hmmsearch_binary_path, hmmbuild_binary_path=hmmbuild_binary_path, database_path=pdb_seqres_database_path)
+            template_featurizer = templates.HmmsearchHitFeaturizer(mmcif_dir=template_mmcif_dir, max_template_date='2100-10-28', max_hits=max_template_hits, kalign_binary_path=kalign_binary_path, release_dates_path=None, obsolete_pdbs_path=obsolete_pdbs_path)
+        else:
+            template_searcher = hhsearch.HHSearch(binary_path=hhsearch_binary_path, databases=[pdb70_database_path])
+            template_featurizer = templates.HhsearchHitFeaturizer(mmcif_dir=template_mmcif_dir, max_template_date='2100-10-28', max_hits=max_template_hits, kalign_binary_path=kalign_binary_path, release_dates_path=None, obsolete_pdbs_path=obsolete_pdbs_path)
+        logger.info('setting up data pipeline')
+        monomer_data_pipeline = alpha_pipeline.DataPipeline(
+            jackhmmer_binary_path=jackhmmer_binary_path,
+            hhblits_binary_path=hhblits_binary_path,
+            uniref90_database_path=uniref90_database_path,
+            mgnify_database_path=mgnify_database_path,
+            bfd_database_path=bfd_database_path,
+            uniref30_database_path=uniref30_database_path,
+            small_bfd_database_path=None,
+            template_searcher=template_searcher,
+            template_featurizer=template_featurizer,
+            use_small_bfd=False,
+            use_precomputed_msas=False)
+        if run_multimer_system:
+            data_pipeline = adapted.Cached_DataPipeline(
+                monomer_data_pipeline=monomer_data_pipeline,
+                jackhmmer_binary_path=jackhmmer_binary_path,
+                uniprot_database_path=uniprot_database_path,
+                use_precomputed_msas=False,
+                seq_to_features_cache=seq_to_msa_d
+            )
+        else:
+            data_pipeline = monomer_data_pipeline
+        msa_dir = f'{out_dir}/{jobname}_seq_all'
+        if not os.path.exists(msa_dir): os.mkdir(msa_dir)
+        feature_dict = data_pipeline.process(input_fasta_path=query_fasta, msa_output_dir=msa_dir)
+
+        return feature_dict
+    elif msa_type == 'mmseqs2_server':
+        if run_multimer_system:
+            # special stuff
+            if use_templates:
+                unpaired_a3m_lines, template_paths = adapted.run_mmseqs2(query_sequences, f'{out_dir}/{jobname}', True, use_templates=True, use_pairing=False)
+                paired_a3m_lines = adapted.run_mmseqs2(query_sequences, f'{out_dir}/{jobname}', True, use_templates=False, use_pairing=True)
+                template_features = []
+                for query_sequence, a3m_lines_unpaired, template_path in zip(query_sequences, unpaired_a3m_lines, template_paths):
+                    tt = None
+                    if template_path:
+                        try:
+                            tt = mk_template(query_sequence, a3m_lines_unpaired, template_path, logger)
+                        except RuntimeError as ex:
+                            print(f'Error in template construction for {template_path}')
+                            print(ex)
+                            logger.info(f'Error in template construction for {template_path}')
+                            logger.info(ex)
+                    if tt == None:
+                        tt = mk_placeholder_template(1,len(query_sequence))
+                    template_features.append(tt)
+            else:
+                unpaired_a3m_lines = adapted.run_mmseqs2(query_sequences, f'{out_dir}/{jobname}', True, use_templates=False, use_pairing=False)
+                paired_a3m_lines = adapted.run_mmseqs2(query_sequences, f'{out_dir}/{jobname}', True, use_templates=False, use_pairing=True)
+                template_features = [mk_placeholder_template(1,len(seq)) for seq in query_sequences]
+
+            features_for_chain = {}
+            chain_cnt = 0
+            for chain_seq, chain_unp_msa, chain_p_msa, chain_temp_feat in zip(query_sequences, unpaired_a3m_lines, paired_a3m_lines, template_features):
+                msa = alpha_pipeline.parsers.parse_a3m(chain_unp_msa)
+                feature_dict = {
+                    **alpha_pipeline.make_sequence_features(sequence=chain_seq, description=""none"", num_res=len(chain_seq)),
+                    **alpha_pipeline.make_msa_features([msa]),
+                    **chain_temp_feat
+                }
+
+                parsed_paired_msa = alpha_pipeline.parsers.parse_a3m(chain_p_msa)
+                paired_feature_dict = {
+                    f""{k}_all_seq"": v for k, v in adapted.my_make_msa_features_keep_duplicates([parsed_paired_msa]).items()
+                }
+                feature_dict.update(paired_feature_dict)
+
+                features_for_chain[chr(ord('A')+chain_cnt)] = feature_dict
+                chain_cnt += 1
+
+            return adapted.process_multimer_features(features_for_chain)
+
+        else:
+            query_sequence = query_sequences[0]
+            if use_templates:
+                a3m_lines_unpaired, template_paths = adapted.run_mmseqs2(query_sequence, f'{out_dir}/{jobname}', True, use_templates=True)
+                if template_paths[0] is not None:
+                    template_features = mk_template(query_sequence, a3m_lines_unpaired[0], template_paths[0], logger)
+                else:
+                    template_features = mk_placeholder_template(1, len(query_sequence))
+            else:
+                a3m_lines_unpaired = adapted.run_mmseqs2(query_sequence, f'{out_dir}/{jobname}', True, use_templates=False)
+                template_features = mk_placeholder_template(1, len(query_sequence))
+                print('bbb template_aatype',template_features['template_aatype'].shape if 'template_aatype' in template_features else 'not present')
+
+            msas = [alpha_pipeline.parsers.parse_a3m(a3m_lines_unpaired[0])]
+            feature_dict = {
+                **alpha_pipeline.make_sequence_features(sequence=query_sequence, description=""none"", num_res=len(query_sequence)),
+                **alpha_pipeline.make_msa_features(msas=msas),
+                **template_features
+            }
+
+            return feature_dict
+    else:
+        raise NotImplementedError(msa_type)
+
+# returns a filled in template dict
+# the dict contains:
+#   - 'template_aatype' - shape (num_templates, num_residues, 22)
+#   - 'template_all_atom_masks' - shape (num_templates, num_residues, 37)
+#   - 'template_all_atom_positions' - shape (num_templates, num_residues, 37, 3)
+#   - 'template_domain_names' - shape (num_templates, )
+#   - 'template_sum_probs' - shape (num_templates, 1)
+# Eventually, this dict is processed by AlphaFold code and turned into input features for AlphaFold
+def mk_template(query_sequence, a3m_lines, template_paths, logger):
+    # default settings
+    template_featurizer = alpha_templates.HhsearchHitFeaturizer(
+        mmcif_dir=template_paths,
+        max_template_date=""2100-01-01"",
+        max_hits=20,
+        kalign_binary_path=""kalign"",
+        release_dates_path=None,
+        obsolete_pdbs_path=None)
+    hhsearch_pdb70_runner = hhsearch.HHSearch(binary_path=""hhsearch"", databases=[f""{template_paths}/pdb70""])
+    hhsearch_result = hhsearch_pdb70_runner.query(a3m_lines)
+    hhsearch_hits = alphafold.data.parsers.parse_hhr(hhsearch_result)
+    templates_result = template_featurizer.get_templates(query_sequence,
+                                                         hhsearch_hits)
+
+    logger.info('Templates found:')
+    logger.info('\t'.join(['hit_id','query_start_idx', 'query_stop_idx', 'hit_start_idx', 'hit_stop_idx', 'hit_info']))
+    for hit in hhsearch_hits:
+        name = hit.name
+        id = name.split(' ')[0]
+        info = ' '.join(name.split(' ')[1:])
+        query_start, query_stop = min(x for x in hit.indices_query if x != -1), max(hit.indices_query)
+        hit_start, hit_stop = min(x for x in hit.indices_hit if x != -1), max(hit.indices_hit)
+        logger.info('\t'.join(str(x) for x in [id, query_start, query_stop, hit_start, hit_stop, info]))
+
+    # check for empty template - otherwise problems with shapes
+    if len(templates_result.features['template_aatype']) == 0:
+        return mk_placeholder_template(1, len(query_sequence))
+    else:
+        return templates_result.features
+
+# returns a template placeholder, with size None in the first dimension
+def mk_placeholder_template(num_templates_, num_res_):
+    print(f'Dummy template created ({num_templates_})') ### TMP
+    return {
+        'template_aatype': np.zeros([num_templates_, num_res_, 22], np.float32),
+        # 'template_all_atom_mask': np.zeros([num_templates_, num_res_, 37], np.float32),
+        'template_all_atom_masks': np.zeros([num_templates_, num_res_, 37], np.float32),
+        'template_all_atom_positions': np.zeros([num_templates_, num_res_, 37, 3], np.float32),  # 3d coords
+        'template_sequence': np.zeros(20),
+        'template_domain_names': np.zeros([num_templates_], np.float32),
+        'template_sum_probs': np.zeros([num_templates_, 1], np.float32),
+    }
+
+
+# For each model to run, collect:
+# - predicted structure (unrelaxed) in pdb lines
+# - predicted structure (unrelaxed) as an object
+# - predicted alignment error (PAE)
+# - predicted local distance difference test (LDDT)
+def predict_structures(logger, all_model_params, all_model_runners_12, all_model_runners_345, feature_dict, is_multimer, num_runs_per_model):
+    plddts, paes, ptms, iptms = [], [], [], []
+    model_names = []
+    unrelaxed_pdb_lines = []
+    unrelaxed_proteins = []
+    for k in range(num_runs_per_model):
+        model_runner_12 = all_model_runners_12[k]
+        model_runner_345 = all_model_runners_345[k]
+        model_params = all_model_params[k]
+        for model_name, params in model_params.items():
+            logger.info(f'running {model_name}')
+            # swap params to avoid recompiling
+            # note: models 1,2 have diff number of params compared to models 3,4,5
+            if any(str(m) in model_name for m in [1, 2]): model_runner = model_runner_12
+            if any(str(m) in model_name for m in [3, 4, 5]): model_runner = model_runner_345
+            model_runner.params = params
+            r = randint(0, 100000)
+            processed_feature_dict = model_runner.process_features(feature_dict, random_seed=r)
+            r = randint(0, 100000)
+            prediction_result = model_runner.predict(processed_feature_dict,random_seed=r)
+            if 'predicted_aligned_error' in prediction_result: paes.append(prediction_result['predicted_aligned_error'])
+            if 'plddt' in prediction_result: plddts.append(prediction_result['plddt'])
+            if 'ptm' in prediction_result: ptms.append(prediction_result['ptm'])
+            if 'iptm' in prediction_result: iptms.append(prediction_result['iptm'])
+            final_atom_mask = prediction_result[""structure_module""][""final_atom_mask""]
+            b_factors = prediction_result[""plddt""][:, None] * final_atom_mask
+
+            unrelaxed_protein = alpha_protein.from_prediction(processed_feature_dict, prediction_result, b_factors, remove_leading_feature_dimension = not is_multimer)
+            unrelaxed_pdb_lines.append(alpha_protein.to_pdb(unrelaxed_protein))
+            unrelaxed_proteins.append(unrelaxed_protein)
+            model_names.append(f'{model_name}x{k+1}')
+    return unrelaxed_pdb_lines, unrelaxed_proteins, paes, plddts, ptms, iptms, model_names
+
+# Rerank based on pLDDT, relax best model if desired, and write pdb files
+def rank_relax_write(logger, unrelaxed_pdb_lines, unrelaxed_proteins, plddts, paes, ptms, iptms, out_dir, jobname, do_relax, model_names, is_multimer):
+    logger.info(f'Reranking based on {""pLDDT"" if not is_multimer else ""0.2*PTM+0.8*iPTM""}...')
+    combined = []
+    if iptms: combined = [0.2*_ptm+0.8*_iptm for _ptm, _iptm in zip(ptms, iptms)]
+    if is_multimer:
+        rank = np.asarray(ptms).argsort()[::-1]
+    else:
+        rank = np.mean(plddts, -1).argsort()[::-1]
+    plddt_pae_per_model = {}
+    for n, r in enumerate(rank):
+        logger.info(f""rank_{n+1}_{model_names[r]} plddt={np.mean(plddts[r]):2.3f}, ptm={ptms[r]:2.3f}"" + (f"", iptm={iptms[r]:2.3f}, 0.2ptm+0.8iptm={combined[r]:2.3f}"" if iptms else """"))
+        unrelaxed_pdb_path = f'{out_dir}/{jobname}_unrelaxed_rank_{n+1:02d}_{model_names[r]}.pdb' if len(model_names)>9 else f'{out_dir}/{jobname}_unrelaxed_rank_{n+1}_{model_names[r]}.pdb'
+        with open(unrelaxed_pdb_path, 'w') as f:
+            f.write(unrelaxed_pdb_lines[r])
+        if (do_relax == 'best' and n == 0) or (do_relax == 'all'):
+            try:
+                amber_relaxer = relax.AmberRelaxation(max_iterations=0, tolerance=2.39, stiffness=10.0, exclude_residues=[], max_outer_iterations=20, use_gpu=True)
+                relaxed_pdb_str, _, _ = amber_relaxer.process(prot=unrelaxed_proteins[r])
+                relaxed_pdb_path = f'{out_dir}/{jobname}_relaxed_rank_{n+1:02d}_{model_names[r]}.pdb' if len(model_names)>9 else f'{out_dir}/{jobname}_relaxed_rank_{n+1}_{model_names[r]}.pdb'
+                with open(relaxed_pdb_path, 'w') as f:
+                    f.write(relaxed_pdb_str)
+            except ValueError:
+                print('Error during relaxation - skipped!')
+                logger.info('Error during relaxation - skipped!')
+        plddt_pae_per_model[f""rank_{n+1:0{len(str(len(rank)))}d}_{model_names[r]}""] = {""plddt"": plddts[r], ""ptm"": ptms[r], ""pae"": paes[r]}
+        if iptms: plddt_pae_per_model[f""rank_{n+1:0{len(str(len(rank)))}d}_{model_names[r]}""].update({'iptm':iptms[r], '0.2ptm+0.8iptm':combined[r]})
+        # write json file
+        if n == 0:
+            with open(f'{out_dir}/{jobname}_rank_{n+1}_{model_names[r]}.json', 'w') as f:
+                d = [{""predicted_aligned_error"": [[float(x) for x in l] for l in paes[r]],
+                     ""max_predicted_aligned_error"": float(np.max(paes[r])),
+                     }]
+                json.dump(d, f)
+    return plddt_pae_per_model
+
+# Generates images, with beautiful visualizations of:
+# - the MSA
+# - the pLDDT per model
+# - the PAE per model
+def generate_output_images(seqs, query_prot_names, pae_plddt_per_model, msa, num_runs_per_model, out_dir, jobname):
+    # gather MSA info
+    if len(seqs) > 1:
+        seq = ''.join(seqs)
+        map_d = {c: i for i, c in enumerate(residue_constants.restypes)}
+    else:
+        seq = seqs[0]
+        map_d = residue_constants.HHBLITS_AA_TO_ID
+    seq_by_indices = [map_d[c] for c in seq]
+    seqid = (np.array(seq_by_indices == msa).mean(-1))
+    seqid_sort = seqid.argsort()
+    non_gaps = (msa != 21).astype(float)
+    non_gaps[non_gaps == 0] = np.nan
+    final = non_gaps[seqid_sort] * seqid[seqid_sort, None]
+
+    ##################################################################
+    plt.figure(figsize=(14, 4), dpi=100)
+    ##################################################################
+    plt.subplot(1, 2, 1)
+    plt.title(""Sequence coverage"")
+    plt.imshow(final,
+               interpolation='nearest', aspect='auto',
+               cmap=""rainbow_r"", vmin=0, vmax=1, origin='lower')
+    plt.plot((msa != 21).sum(0), color='black')
+    plt.xlim(-0.5, msa.shape[1] - 0.5)
+    plt.ylim(-0.5, msa.shape[0] - 0.5)
+    plt.colorbar(label=""Sequence identity to query"", )
+    plt.xlabel(""Positions"")
+    plt.ylabel(""Sequences"")
+
+    ##################################################################
+    plt.subplot(1, 2, 2)
+    plt.title(""Predicted LDDT per position"")
+    for model_name, value in pae_plddt_per_model.items():
+        plt.plot(value[""plddt""], label=model_name)
+    plt.ylim(0, 100)
+    plt.ylabel(""Predicted LDDT"")
+    plt.xlabel(""Positions"")
+    plt.savefig(f""{out_dir}/{jobname}_coverage_LDDT.png"")
+    ##################################################################
+
+    ##################################################################
+    num_models = 5
+    fig = plt.figure(figsize=(3 * num_models, 2*num_runs_per_model), dpi=100)
+    for n, model_name in enumerate(sorted(pae_plddt_per_model.keys())):
+        value = pae_plddt_per_model[model_name]
+        if n == 0:
+            best_pae = value[""pae""]
+            best_name = model_name
+        plt.subplot(num_runs_per_model, num_models, n + 1)
+        plt.title(model_name)
+        plt.imshow(value[""pae""], label=model_name, cmap=""bwr"", vmin=0, vmax=30)
+        plt.colorbar()
+    fig.tight_layout()
+    plt.savefig(f""{out_dir}/{jobname}_PAE.png"")
+
+    #### single best PAE
+    print(f'best model: {best_name}')
+    plddt, ptm = np.mean(pae_plddt_per_model[best_name][""plddt""]), pae_plddt_per_model[best_name][""ptm""]
+    iptm = pae_plddt_per_model[best_name].get(""iptm"", -1)
+    fig = plt.figure(figsize=(6, 3), dpi=100)
+    plt.suptitle(f""{best_name}\npLDDT:{plddt:.2f} PTM:{ptm:.2f}""+(f"" iPTM:{iptm:.2f}"" if iptm != -1 else """"))
+
+    plt.subplot(1, 2, 1)
+    plt.imshow(best_pae, label=best_name, cmap=""bwr"", vmin=0, vmax=30)
+    # draw lines on x and y according to the length of strings in seqs
+    for i in range(1, len(seqs)):
+        plt.axhline(len(''.join(seqs[:i])) + 0.5, color='black')
+        plt.axvline(len(''.join(seqs[:i])) + 0.5, color='black')
+    plt.colorbar()
+
+    # add sequence labels in extra plot
+    plt.subplot(1, 2, 2)
+    new_np = np.zeros_like(best_pae)
+    colors = ['white',
+              '#FFDAB9',  # Peachpuff
+              '#ADD8E6',  # Light blue
+              '#FFD1DC',  # Pink
+              '#90EE90',  # Light green
+              '#FAFAD2',  # Light goldenrod yellow
+              '#FFECDB',  # Cream
+              '#E0FFFF',  # Light cyan
+              '#FFE4E1',  # Misty rose
+              '#F0FFF0',  # Honeydew
+              '#FFF0F5'  # Lavender blush
+              ][:len(seqs) + 1]
+
+    for i in range(len(seqs)):
+        before = len(''.join(seqs[:i]))
+        seqlen = len(seqs[i])
+        new_np[before:before + seqlen, before:before + seqlen] = i + 1
+        plt.text(before + seqlen / 2, before + seqlen / 2, query_prot_names[i], color='black', ha='center', va='center',
+                 fontsize=8)
+
+    for i in range(1, len(seqs)):
+        plt.axhline(len(''.join(seqs[:i])) + 0.5, color='black')
+        plt.axvline(len(''.join(seqs[:i])) + 0.5, color='black')
+
+    cmap = ListedColormap(colors)
+    plt.imshow(new_np, cmap=cmap)
+
+    fig.tight_layout()
+    iptm_str = f""_iptm{int(iptm*100):02d}"" if iptm != -1 else """"
+    plt.savefig(f""{out_dir}/best_PAE_plddt{int(plddt):02d}_ptm{int(ptm*100):02d}{iptm_str}.png"")
+    ##################################################################
+
+# gets a list of sequences from the fasta file (one for monomer, multiple for multimer)
+def get_sequences_from_fasta(fasta_file):
+    seqs = []
+    seq = ''
+    for line in open(fasta_file):
+        if line.startswith('>'):
+            if seq:
+                seqs.append(seq)
+                seq = ''
+        elif line:
+            seq += line.rstrip()
+    if seq:
+        seqs.append(seq)
+    return seqs
+
+def log_template_info(feature_dict, logger):
+    if 'template_domain_names' in feature_dict: # monomer
+        logger.info('Templates shown here are reduced to 4 later on in the pipeline.')
+
+    residue_idx = feature_dict['residue_index']
+    template_aatype = feature_dict['template_aatype']
+    if len(template_aatype.shape) == 3: # extra last dimension, one-hot encoded
+        template_aatype = template_aatype.argmax(axis=-1)
+    chain_starts = [idx for idx in range(len(residue_idx)) if residue_idx[idx] == 0]
+    chain_ids = np.zeros_like(template_aatype[0])
+    for chain_start_idx in chain_starts:
+        chain_ids[chain_start_idx:]+=1
+
+    logger.info('Templates found:')
+    for k, single_template_aatype in enumerate(template_aatype):
+        fros, tos = [], []
+        idx = 0
+        while True:
+            while idx < len(single_template_aatype) and single_template_aatype[idx] == 21:
+                idx += 1
+            if idx == len(single_template_aatype): # if this is the case, we are at the end of the sequence
+                break
+            chain_id = chain_ids[idx]
+            fros.append(idx)
+            while idx < len(single_template_aatype) and single_template_aatype[idx] != 21 and chain_id == chain_ids[idx]:
+                idx += 1
+            tos.append(idx-1)
+            if idx == len(single_template_aatype): # if this is the case, we are at the end of the sequence
+                break
+        for fro, to in zip(fros, tos):
+            chain_id = chain_ids[fro]
+            assert chain_id == chain_ids[to]
+            logger.info(f' ({k+1}) At chain #{chain_id}, positions [{residue_idx[fro]}, {residue_idx[to]}]')
+
+def gather_best_prediction(run_dir, jobname, is_multimer):
+    best_pdb, best_plddt, best_ptm = None, -1, -1
+    rerank_by = 'ptm' if is_multimer else 'plddt'
+    for subdir in os.listdir(run_dir):
+        subdir = run_dir + '/' + subdir
+        plddt, ptm = -1, -1
+        for line in open(subdir + '/info.log'):
+            if 'Reranking' in line and 'PTM' in line:
+                rerank_by = 'ptm'
+            if 'plddt=' in line:
+                plddt = float(line.split('=')[1].split(',')[0])
+                ptm = float(line.split('=')[2].split(',')[0].rstrip())
+                break
+        files = [file for file in os.listdir(subdir) if '_relaxed' in file]
+        if not files:
+            files = [file for file in os.listdir(subdir) if '_unrelaxed' in file]
+        if files:
+            pdb_file = subdir.rstrip('/') + '/' + files[0]
+        else:
+            pdb_file = f'pdb file missing from {subdir}'
+        if (rerank_by == 'ptm' and ptm > best_ptm) or (rerank_by == 'plddt' and plddt > best_plddt):
+            best_pdb, best_plddt, best_ptm = pdb_file, plddt, ptm
+
+    best_directory = run_dir.rstrip('/') + f'/best_{jobname}/'
+    if not os.path.exists(best_directory):
+        os.mkdir(best_directory)
+    os.system(f'cp {best_pdb} {best_directory}')
+    os.system(f'cp {best_pdb[:best_pdb.rfind(""/"")]}/best_PAE*.png {best_directory}/')
+
+
+if __name__ == ""__main__"":
+    import sys
+    print(sys.argv)
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--seq',help='the input sequence or sequences (in case of multiple, separate with "":"")')
+    parser.add_argument('--prot_names',help='the names of the proteins (in case of multiple, separate with "":"")')
+    parser.add_argument('--jobname',help='the name for the job, used for file naming')
+    parser.add_argument('--save_dir',help='the location where new directories (per permutation) will be created')
+    parser.add_argument('--max_recycles',type=int,default=3,help='the maximum number of recycles',required=False)
+    parser.add_argument('--tolerance',type=int,default=0,help='the tolerance level, decides when recycling stops',required=False)
+    parser.add_argument('--do_relax',dest='do_relax',required=True)
+    parser.add_argument('--num_runs_per_model',type=int,dest='num_runs_per_model',required=False,default=1)
+    parser.add_argument('--no_templates',dest='use_templates',action='store_false')
+    parser.set_defaults(use_templates=True)
+    parser.add_argument('--msa_mode',type=str,default='mmseqs2_server',help='choose one of ""mmseqs2_server"", ""mmseqs2_local"", ""alphafold_default"", ""single_sequence""',required=False)
+    parser.add_argument('--do_gather_best',dest='do_gather_best',action='store_true')
+    parser.set_defaults(do_gather_best=False)
+    args = parser.parse_args()
+    run_alphafold_advanced_complex(seq=args.seq,
+                                   prot_names=args.prot_names,
+                                   jobname=args.jobname,
+                                   save_dir=args.save_dir,
+                                   max_recycles=args.max_recycles,
+                                   tolerance=args.tolerance,
+                                   use_templates=args.use_templates,
+                                   num_runs_per_model=args.num_runs_per_model,
+                                   do_relax=args.do_relax,
+                                   msa_mode=args.msa_mode,
+                                   do_gather_best=args.do_gather_best)
+    print('Finished run!')","Python"
+"AlphaFold","jasperzuallaert/VIBFold","visualize_alphafold_results.py",".py","3583","80","import glob
+import math
+import os
+import numpy as np
+from matplotlib import pyplot as plt
+import argparse
+import pickle
+
+def get_pae_plddt(model_names):
+    out = {}
+    for i,name in enumerate(model_names):
+        d = pickle.load(open(name,'rb'))
+        basename = os.path.basename(name)
+        basename = basename[basename.index('model'):]
+        out[f'{basename}'] = {'plddt': d['plddt'], 'pae':d['predicted_aligned_error']}
+    return out
+
+def generate_output_images(feature_dict, out_dir, name, pae_plddt_per_model):
+    msa = feature_dict['msa']
+    seqid = (np.array(msa[0] == msa).mean(-1))
+    seqid_sort = seqid.argsort()
+    non_gaps = (msa != 21).astype(float)
+    non_gaps[non_gaps == 0] = np.nan
+    final = non_gaps[seqid_sort] * seqid[seqid_sort, None]
+
+    ##################################################################
+    plt.figure(figsize=(14, 4), dpi=100)
+    ##################################################################
+    plt.subplot(1, 2, 1)
+    plt.title(""Sequence coverage"")
+    plt.imshow(final,
+               interpolation='nearest', aspect='auto',
+               cmap=""rainbow_r"", vmin=0, vmax=1, origin='lower')
+    plt.plot((msa != 21).sum(0), color='black')
+    plt.xlim(-0.5, msa.shape[1] - 0.5)
+    plt.ylim(-0.5, msa.shape[0] - 0.5)
+    plt.colorbar(label=""Sequence identity to query"", )
+    plt.xlabel(""Positions"")
+    plt.ylabel(""Sequences"")
+
+    ##################################################################
+    plt.subplot(1, 2, 2)
+    plt.title(""Predicted LDDT per position"")
+    for model_name, value in pae_plddt_per_model.items():
+        plt.plot(value[""plddt""], label=model_name)
+    plt.ylim(0, 100)
+    plt.ylabel(""Predicted LDDT"")
+    plt.xlabel(""Positions"")
+    plt.savefig(f""{out_dir}/{name+('_' if name else '')}coverage_LDDT.png"")
+    ##################################################################
+
+    ##################################################################
+    num_models = 5 # columns
+    num_runs_per_model = math.ceil(len(model_names)/num_models)
+    fig = plt.figure(figsize=(3 * num_models, 2 * num_runs_per_model), dpi=100)
+    for n, (model_name, value) in enumerate(pae_plddt_per_model.items()):
+        plt.subplot(num_runs_per_model, num_models, n + 1)
+        plt.title(model_name)
+        plt.imshow(value[""pae""], label=model_name, cmap=""bwr"", vmin=0, vmax=30)
+        plt.colorbar()
+    fig.tight_layout()
+    plt.savefig(f""{out_dir}/{name+('_' if name else '')}PAE.png"")
+    ##################################################################
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--input_dir',dest='input_dir',required=True)
+parser.add_argument('--name',dest='name')
+parser.set_defaults(name='')
+parser.add_argument('--output_dir',dest='output_dir')
+parser.set_defaults(output_dir='')
+args = parser.parse_args()
+
+feature_dict = pickle.load(open(f'{args.input_dir}/features.pkl','rb'))
+# is_multimer = ('result_model_1_multimer.pkl' in [os.path.basename(f) for f in os.listdir(path=args.input_dir)])
+# is_ptm = ('result_model_1_ptm.pkl' in [os.path.basename(f) for f in os.listdir(path=args.input_dir)])
+# model_names = [f'{args.input_dir}/result_model_{f}{""_multimer"" if is_multimer else ""_ptm"" if is_ptm else """"}.pkl' for f in range(1,6)]
+model_names = sorted(glob.glob(f'{args.input_dir}/result_*.pkl'))
+
+pae_plddt_per_model = get_pae_plddt(model_names)
+generate_output_images(feature_dict, args.output_dir if args.output_dir else args.input_dir, args.name, pae_plddt_per_model)","Python"
+"AlphaFold","jasperzuallaert/VIBFold","submit_vibfold_interaction_candidates.py",".py","4810","111","MAIN_FASTA = 'fastas/test_main.fasta' # list of proteins, to interact with each of the proteins in CANDIDATES_FASTA
+CANDIDATES_FASTA = 'fastas/test_candidates.fasta' # list of proteins, to interact with each of the proteins in MAIN_FASTA
+
+MSA_MODE = 'mmseqs2_server'                # 'alphafold_default' or 'mmseqs2_server'
+SAVE_DIR = 'results/test'                # location of results directory between '' - abs or rel path possible
+DO_RELAX = 'none'                             # 'all', 'best' or 'none'
+USE_TEMPLATES = True                          # True, False
+MAX_RECYCLES = 3                              # default == 3
+NUM_RUNS_PER_MODEL = 5                  # number of runs per model, with different random seed
+
+# IS_COMPLEX = True # Fixed value, this is no longer considered
+
+import subprocess
+import os
+import time
+
+timestamp = time.strftime('%Y%m%d_%H%M%S') + '_'
+
+def submit(MAIN_FASTA, CANDIDATES_FASTA, MSA_MODE, SAVE_DIR, DO_RELAX, USE_TEMPLATES, MAX_RECYCLES, NUM_RUNS_PER_MODEL):
+    assert ' ' not in MAIN_FASTA, 'The name of your FASTA files cannot contain any spaces'
+    assert ' ' not in CANDIDATES_FASTA, 'The name of your FASTA files cannot contain any spaces'
+    # automatically select accelgor/joltik based on output of 'ml'
+    module_info = subprocess.check_output('ml',shell=True).decode('utf-8')
+    cluster = 'accelgor' if 'accelgor' in module_info else \
+              'joltik' if 'joltik' in module_info else ''
+    if not cluster:
+        raise NotImplementedError('Cluster joltik/accelgor not found in ""ml"" output. Did you use ""module swap cluster/joltik"" (or other)?')
+
+    def read_fasta(file):
+        fasta_d = {}
+        seq = ''
+        ctr = 1
+        for line in open(file):
+            if line.startswith('>'):
+                if seq:
+                    fasta_d[prot_id] = seq
+                    seq = ''
+                prot_id = f'{ctr}_{line.rstrip().lstrip("">"").replace("" "", ""_"").replace("":"", ""_"").replace(""("", """").replace("")"", """")}'
+                if '|' in prot_id: prot_id = prot_id.split('|')[1]
+                ctr+=1
+            elif line:
+                seq += line.rstrip()
+        if seq:
+            fasta_d[prot_id] = seq
+        return fasta_d
+
+    proteins_1 = read_fasta(MAIN_FASTA)
+    proteins_2 = read_fasta(CANDIDATES_FASTA)
+
+    all_interactions = {}
+    for prot1_id, seq1 in proteins_1.items():
+        for prot2_id, seq2 in proteins_2.items():
+            prot1_id = prot1_id.replace(' ', '_').replace(':', '_').replace('(', '').replace(')', '')
+            prot2_id = prot2_id.replace(' ', '_').replace(':', '_').replace('(', '').replace(')', '')
+            prot_names = f'{prot1_id}:{prot2_id}'
+            all_interactions[prot_names] = f'{seq1}:{seq2}'
+
+    if not SAVE_DIR.startswith('/'):
+        SAVE_DIR = f'$PBS_O_WORKDIR/{SAVE_DIR}'
+
+        for prot_names, seq in all_interactions.items():
+            run_save_dir = f'{SAVE_DIR}/{timestamp}_{prot_names.replace("":"", ""_"")}'
+            script_content = f'''#!/bin/bash
+#PBS -N interactions_VIBFold_{prot_names.replace("":"", ""_"")}
+#PBS -l nodes=1:ppn={12 if (cluster == 'accelgor' or cluster == 'litleo') else 8}{"",gpus=1"" if (cluster == 'accelgor' or cluster == 'joltik' or cluster == 'litleo') else """"}
+#PBS -l mem={125 if cluster == 'accelgor' else 64 if (cluster == 'joltik' or cluster == 'litleo') else 20}g
+#PBS -l walltime=48:00:00
+
+module load Python/3.11.3-GCCcore-12.3.0
+
+module load tqdm/4.66.1-GCCcore-12.3.0 
+module load matplotlib/3.7.2-gfbf-2023a
+module load AlphaFold/2.3.2-foss-2023a{""-CUDA-12.1.1"" if (cluster == 'accelgor' or cluster == 'joltik' or cluster == 'litleo') else """"}
+export ALPHAFOLD_DATA_DIR=/arcanine/scratch/gent/apps/AlphaFold/20230310
+
+PROTEIN={prot_names.replace("":"", ""_"")}
+
+jobname=""$PROTEIN""_""$PBS_JOBID""
+
+SAVEDIR={run_save_dir}
+mkdir -p $SAVEDIR
+
+cd $PBS_O_WORKDIR
+python VIBFold.py \
+ --seq {seq} \
+ --prot_names ""{prot_names}"" \
+ --jobname $jobname \
+ --save_dir $SAVEDIR \
+ --do_relax {DO_RELAX} \
+ {""--no_templates"" if not USE_TEMPLATES else """"} \
+ --msa_mode {MSA_MODE} \
+ --max_recycles {MAX_RECYCLES} \
+ --num_runs_per_model {NUM_RUNS_PER_MODEL} \
+ --do_gather_best
+'''
+
+            scriptname = 'submit_new.sh'
+            f = open(scriptname,'w')
+            print(script_content,file=f)
+            f.close()
+
+            print()
+            print(f'############# submitting {prot_names.replace("":"", ""_"")} #############')
+            subprocess.Popen(['echo',f'{prot_names.replace("":"", ""_"")}'],shell=False)
+            subprocess.Popen(['qsub',f'{scriptname}'],shell=False).wait()
+            subprocess.Popen(['rm',f'{scriptname}'],shell=False).wait()
+            print()
+
+if __name__ == ""__main__"":
+    submit(MAIN_FASTA, CANDIDATES_FASTA, MSA_MODE, SAVE_DIR, DO_RELAX, USE_TEMPLATES, MAX_RECYCLES, NUM_RUNS_PER_MODEL)
+","Python"
+"AlphaFold","jasperzuallaert/VIBFold","submit_vibfold_with_reservation.py",".py","4260","109","
+FASTA_FILE = 'fastas/NAME.fasta'        # location of fasta file between '' - absolute or relative path possible
+IS_COMPLEX = True                       # True or False
+MSA_MODE = 'mmseqs2_server'             # 'alphafold_default' or 'mmseqs2_server'
+SAVE_DIR = 'results/naa10_practical'               # location of results directory between '' - abs or rel path possible
+DO_RELAX = 'none'                       # 'all', 'best' or 'none'
+NUM_RUNS_PER_MODEL = 1                  # number of runs per model, with different random seed
+USE_TEMPLATES = True                   # True, False
+MAX_RECYCLES = 3                        # default == 3
+
+
+import subprocess
+import os
+import time
+
+timestamp = time.strftime('%Y%m%d_%H%M%S') + '_'
+
+def submit(FASTA_FILE, IS_COMPLEX, MSA_MODE, SAVE_DIR, DO_RELAX, USE_TEMPLATES, MAX_RECYCLES):
+    assert ' ' not in FASTA_FILE, 'The name of your FASTA file cannot contain any spaces'
+    # automatically select accelgor/joltik based on output of 'ml'
+    module_info = subprocess.check_output('ml',shell=True).decode('utf-8')
+    cluster = 'accelgor' if 'accelgor' in module_info else \
+              'joltik' if 'joltik' in module_info else \
+              'donphan' if 'donphan' in module_info else ''
+    if not cluster:
+        raise NotImplementedError('Cluster joltik/accelgor/donphan not found in ""ml"" output. Did you use ""module swap cluster/joltik"" (or other)?')
+
+    fasta_d = {}
+    seq = ''
+    ctr = 1
+    for line in open(FASTA_FILE):
+        if line.startswith('>'):
+            if seq:
+                fasta_d[prot_id] = seq
+                seq = ''
+            prot_id = f'{ctr}_{line.rstrip().lstrip("">"").replace("" "", ""_"").replace("":"", ""_"").replace(""("", """").replace("")"", """")}'
+            if '|' in prot_id: prot_id = prot_id.split('|')[1]
+            ctr+=1
+        elif line:
+            seq += line.rstrip()
+    if seq:
+        fasta_d[prot_id] = seq
+
+    all_seqs = {}
+    all_protnames = {}
+    if not IS_COMPLEX: # create one new FASTA file per entry
+        for prot_id, seq in fasta_d.items():
+            all_seqs[prot_id] = seq
+            all_protnames[prot_id] = prot_id
+    else: # create a copy of the multi-entry FASTA file
+        fasta_id = os.path.basename(FASTA_FILE).split('.')[0]
+        seqs = fasta_d.values()
+        all_protnames[fasta_id] = ':'.join(fasta_d.keys())
+        all_seqs[fasta_id] = ':'.join(seqs)
+
+    if not SAVE_DIR.startswith('/'):
+        SAVE_DIR = f'$PBS_O_WORKDIR/{SAVE_DIR}'
+
+        for prot_id, seq in all_seqs.items():
+            prot_names = all_protnames[prot_id]
+            run_save_dir = f'{SAVE_DIR}/{timestamp}_{prot_id}'
+            script_content = f'''#!/bin/bash
+#PBS -N VIBFold_{prot_id}
+#PBS -l nodes=1:ppn={12 if cluster=='accelgor' else 8}{"",gpus=1"" if cluster in ['accelgor','joltik'] else """"}
+#PBS -l mem={125 if cluster=='accelgor' else 64 if cluster=='joltik' else 20}g
+#PBS -l walltime=48:00:00
+
+module load Python/3.11.3-GCCcore-12.3.0
+
+module load tqdm/4.66.1-GCCcore-12.3.0 
+module load matplotlib/3.7.2-gfbf-2023a
+module load AlphaFold/2.3.2-foss-2023a{""-CUDA-12.1.1"" if cluster in ['accelgor','joltik'] else """"}
+export ALPHAFOLD_DATA_DIR=/arcanine/scratch/gent/apps/AlphaFold/20230310
+PROTEIN={prot_id}
+
+jobname=""$PROTEIN""_""$PBS_JOBID""
+
+SAVEDIR={run_save_dir}
+mkdir -p $SAVEDIR
+
+cd $PBS_O_WORKDIR
+python VIBFold.py \
+ --seq {seq} \
+ --prot_names ""{prot_names}"" \
+ --jobname $jobname \
+ --save_dir $SAVEDIR \
+ --do_relax {DO_RELAX} \
+ {""--no_templates"" if not USE_TEMPLATES else """"} \
+ --msa_mode {MSA_MODE} \
+ --num_runs_per_model {NUM_RUNS_PER_MODEL} \
+ --max_recycles {MAX_RECYCLES} \
+ --do_gather_best
+'''
+
+            scriptname = 'submit_new.sh'
+            f = open(scriptname,'w')
+            print(script_content,file=f)
+            f.close()
+
+            print()
+            print(f'############# submitting {prot_id} #############')
+            subprocess.Popen(['echo',f'{prot_id}'],shell=False)
+            subprocess.Popen(['qsub',f'{scriptname}', '--pass=reservation=D013637_2023'],shell=False).wait()
+            subprocess.Popen(['rm',f'{scriptname}'],shell=False).wait()
+            print()
+
+if __name__ == ""__main__"":
+    submit(FASTA_FILE, IS_COMPLEX, MSA_MODE, SAVE_DIR, DO_RELAX, USE_TEMPLATES, MAX_RECYCLES)
+","Python"
+"AlphaFold","jasperzuallaert/VIBFold","boltz_job_script.sh",".sh","371","14","#!/bin/bash
+#PBS -N Boltz_test
+#PBS -l nodes=1:ppn=8:gpus=1
+#PBS -l mem=32gb
+#PBS -l walltime=6:0:0
+
+# input file MUST have the file extension added here
+input_file=RBD_VHHE.yaml
+out_dir=results/RBD_VHHE_boltz_pred
+
+ml Boltz-1/0.4.1-foss-2023a-CUDA-12.1.1
+cd $PBS_O_WORKDIR
+boltz predict $input_file --write_full_pae --cache $VSC_DATA --out_dir $out_dir --use_msa_server
+","Shell"
+"AlphaFold","jasperzuallaert/VIBFold","visualize_boltz_results.py",".py","2925","74"," 
+import glob
+import math
+import os
+import numpy as np
+from matplotlib import pyplot as plt
+import argparse
+
+def get_pae_plddt(input_dir):
+    out = {}
+    
+    # Look for PAE and pLDDT files recursively in predictions directory
+    pae_files = sorted(glob.glob(f'{input_dir}/predictions/**/pae_*.npz', recursive=True))
+    plddt_files = sorted(glob.glob(f'{input_dir}/predictions/**/plddt_*.npz', recursive=True))
+    
+    if not pae_files or not plddt_files:
+        print(f""Warning: No PAE files found: {len(pae_files)}, No pLDDT files found: {len(plddt_files)}"")
+        print(f""Looking in: {input_dir}/predictions/**/"")
+        return out
+    
+    # For Boltz-1, there should be only one of each
+    pae_file = pae_files[0]
+    plddt_file = plddt_files[0]
+    
+    print(f""Loading PAE from: {pae_file}"")
+    print(f""Loading pLDDT from: {plddt_file}"")
+    
+    pae_data = np.load(pae_file)['pae']
+    plddt_data = np.load(plddt_file)['plddt']
+    
+    basename = os.path.basename(pae_file).replace('pae_', '').replace('.npz', '')
+    out[f'boltz_model_{basename}'] = {'plddt': plddt_data, 'pae': pae_data}
+    
+    return out
+
+def generate_output_images(out_dir, name, pae_plddt_per_model):
+    ##################################################################
+    plt.figure(figsize=(14, 4), dpi=100)
+    ##################################################################
+    plt.subplot(1, 1, 1)
+    plt.title(""Predicted LDDT per position"")
+    for model_name, value in pae_plddt_per_model.items():
+        plt.plot(value[""plddt""], label=model_name)
+    plt.ylim(0, 1)
+    plt.ylabel(""Predicted LDDT"")
+    plt.xlabel(""Positions"")
+    plt.legend()
+    plt.savefig(f""{out_dir}/{name+('_' if name else '')}LDDT.png"")
+    plt.close()
+    ##################################################################
+
+    ##################################################################
+    num_models = 1 # columns
+    num_runs_per_model = math.ceil(len(pae_plddt_per_model)/num_models)
+    fig = plt.figure(figsize=(3 * num_models, 2 * num_runs_per_model), dpi=100)
+    for n, (model_name, value) in enumerate(pae_plddt_per_model.items()):
+        plt.subplot(num_runs_per_model, num_models, n + 1)
+        plt.imshow(value[""pae""], label=model_name, cmap=""bwr"", vmin=0, vmax=30)
+        plt.colorbar()
+    fig.tight_layout()
+    plt.savefig(f""{out_dir}/{name+('_' if name else '')}PAE.png"")
+    plt.close()
+    ##################################################################
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--input_dir',dest='input_dir',required=True)
+parser.add_argument('--name',dest='name')
+parser.set_defaults(name='')
+parser.add_argument('--output_dir',dest='output_dir')
+parser.set_defaults(output_dir='')
+args = parser.parse_args()
+
+pae_plddt_per_model = get_pae_plddt(args.input_dir)
+generate_output_images(args.output_dir if args.output_dir else args.input_dir, args.name, pae_plddt_per_model)","Python"
+"AlphaFold","jasperzuallaert/VIBFold","generate_alphapulldown_scripts.sh",".sh","5352","142","#!/bin/bash
+
+# Check if the correct number of arguments is provided
+if [ ""$#"" -ne 4 ]; then
+  echo ""Usage: $0 output_directory fasta_location_1 fasta_location_2 number_of_predictions_per_model""
+  exit 1
+fi
+
+# Create the output directory if it doesn't exist
+mkdir -p ""$1""
+
+# Assign arguments to variables
+output_directory=`realpath $1`
+fasta_location_1=`realpath $2`
+fasta_location_2=`realpath $3`
+pred_per_model=$4
+
+# Function to count the number of entries in a fasta file
+count_entries() {
+  grep -c '^>' ""$1""
+}
+
+# Function to create a protein list from a fasta file
+create_protein_list() {
+  grep '^>' ""$1"" | sed 's/^>//' | sed 's/[|= #;]/_/g' > ""$2""
+}
+
+# Count entries in each fasta file
+count1=$(count_entries ""$fasta_location_1"")
+count2=$(count_entries ""$fasta_location_2"")
+total_count=$((count1 + count2))
+total_preds=$((count1 * count2))
+
+# Create protein lists
+protein_list_1=""${output_directory}/protein_list_1.txt""
+protein_list_2=""${output_directory}/protein_list_2.txt""
+
+create_protein_list ""$fasta_location_1"" ""$protein_list_1""
+create_protein_list ""$fasta_location_2"" ""$protein_list_2""
+
+# Create MSA job script
+msa_job_script=""${output_directory}/msa_job_script.sh""
+cat <<EOT > ""$msa_job_script""
+#PBS -N msa_pulldown
+#PBS -l nodes=1:ppn=4
+#PBS -l walltime=12:00:00
+#PBS -l mem=80gb
+
+module load AlphaPulldown/2.0.3-foss-2023a
+export ALPHAFOLD_DATA_DIR=/arcanine/scratch/gent/apps/AlphaFold/20230310
+cd $output_directory
+
+create_individual_features.py \
+  --fasta_paths=$fasta_location_1,$fasta_location_2 \
+  --data_dir=\$ALPHAFOLD_DATA_DIR \
+  --save_msa_files=False \
+  --output_dir=$output_directory/msas \
+  --use_precomputed_msas=False \
+  --max_template_date=2050-01-01 \
+  --skip_existing=True \
+  --uniref30_database_path=/arcanine/scratch/gent/apps/AlphaFold/20230310/uniref30/UniRef30_2021_03 \
+  --seq_index \${PBS_ARRAYID}
+EOT
+
+instr_file=$output_directory/instructions.txt
+echo """" > $instr_file
+# Print MSA job script command
+echo ""######################################"" >> $instr_file
+echo ""#####     STEP 1. MSA search     #####"" >> $instr_file
+echo ""######################################"" >> $instr_file
+echo "">>> To launch the MSA search, run: "" >> $instr_file
+echo ""          module swap cluster/doduo"" >> $instr_file
+echo ""          qsub -m ae $msa_job_script -t1-$total_count -o $output_directory/output_msa.log -e $output_directory/error_msa.log"" >> $instr_file
+echo "">>> Note that you can change the doduo cluster to any CPU cluster you wish"" >> $instr_file
+echo "">>> Wait until all jobs have been successfully completed - you will receive an email when finished."" >> $instr_file
+echo "" "" >> $instr_file
+
+# Create the GPU job script
+predict_job_script=""${output_directory}/predict_job_script.sh""
+cat <<EOT > ""$predict_job_script""
+#PBS -N predict_pulldown
+#PBS -l nodes=1:ppn=8,gpus=1
+#PBS -l mem=64g
+#PBS -l walltime=12:00:00
+
+module load AlphaPulldown/2.0.3-foss-2023a-CUDA-12.1.1
+
+cd $output_directory
+export EBROOTCOLABFOLD=\$PBS_O_WORKDIR/$output_directory
+export ALPHAFOLD_DATA_DIR=/arcanine/scratch/gent/apps/AlphaFold/20230310
+
+run_multimer_jobs.py --mode=pulldown \
+--num_cycle=3 \
+--num_predictions_per_model=$pred_per_model \
+--output_path=$output_directory/preds/ \
+--data_dir=\$ALPHAFOLD_DATA_DIR \
+--protein_lists=$protein_list_1,$protein_list_2 \
+--monomer_objects_dir=$output_directory/msas/ \
+--compress_result_pickles=True \
+--remove_result_pickles=True \
+--job_index=\${PBS_ARRAYID}
+EOT
+
+echo ""######################################"" >> $instr_file
+echo ""#####     STEP 2. Prediction     #####"" >> $instr_file
+echo ""######################################"" >> $instr_file
+echo "">>> To launch the prediction search, run: "" >> $instr_file
+echo ""          module swap cluster/joltik"" >> $instr_file
+echo ""          qsub -m ae $predict_job_script -t1-$total_preds -o $output_directory/output_predict.log -e $output_directory/output_predict.log"" >> $instr_file
+echo "">>> Note that you can change the joltik cluster to any GPU cluster you wish"" >> $instr_file
+echo "">>> You will receive an email when finished."" >> $instr_file
+echo "" "" >> $instr_file
+
+
+gather_results_script=""${output_directory}/gather_results_script.sh""
+cat <<EOT > ""$gather_results_script""
+#PBS -N gather_results_pulldown
+#PBS -l nodes=1:ppn=4
+#PBS -l walltime=12:00:00
+#PBS -l mem=16gb
+
+cd $output_directory
+
+apptainer exec /arcanine/scratch/gent/apps/AlphaPulldown/alpha-analysis_jax_0.4.sif run_get_good_pae.sh --cutoff=10 --output_dir=$output_directory/preds 
+EOT
+
+echo ""######################################"" >> $instr_file
+echo ""#####      STEP 3. Results       #####"" >> $instr_file
+echo ""######################################"" >> $instr_file
+echo "">>> Finally, you can gather results in a csv by running"" >> $instr_file
+echo ""          module swap cluster/doduo"" >> $instr_file
+echo ""          qsub -m ae $gather_results_script -o $output_directory/output_gather.log -e $output_directory/output_gather.log"" >> $instr_file
+echo "">>> Note that you can adjust the cutoff parameter in the file to include lower quality interactions as well"" >> $instr_file
+echo "">>> Note that you can change the doduo cluster to any CPU cluster you wish"" >> $instr_file
+echo "" "" >> $instr_file
+
+echo "">>> Outputs can be found in $output_directory/outputs."" >> $instr_file
+
+echo ""Instructions can be found at $instr_file as well""
+cat $instr_file
+
+","Shell"
+"AlphaFold","allanchen95/ESMPair","model_ori.py",".py","15770","439","# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .modules import (
+    TransformerLayer,
+    AxialTransformerLayer,
+    LearnedPositionalEmbedding,
+    SinusoidalPositionalEmbedding,
+    RobertaLMHead,
+    ESM1bLayerNorm,
+    ContactPredictionHead,
+)
+
+from .axial_attention import RowSelfAttention, ColumnSelfAttention
+
+
+class ProteinBertModel(nn.Module):
+    @classmethod
+    def add_args(cls, parser):
+        parser.add_argument(
+            ""--num_layers"", default=36, type=int, metavar=""N"", help=""number of layers""
+        )
+        parser.add_argument(
+            ""--embed_dim"", default=1280, type=int, metavar=""N"", help=""embedding dimension""
+        )
+        parser.add_argument(
+            ""--logit_bias"", action=""store_true"", help=""whether to apply bias to logits""
+        )
+        parser.add_argument(
+            ""--ffn_embed_dim"",
+            default=5120,
+            type=int,
+            metavar=""N"",
+            help=""embedding dimension for FFN"",
+        )
+        parser.add_argument(
+            ""--attention_heads"",
+            default=20,
+            type=int,
+            metavar=""N"",
+            help=""number of attention heads"",
+        )
+
+    def __init__(self, args, alphabet):
+        super().__init__()
+        self.args = args
+        self.alphabet_size = len(alphabet)
+        self.padding_idx = alphabet.padding_idx
+        self.mask_idx = alphabet.mask_idx
+        self.cls_idx = alphabet.cls_idx
+        self.eos_idx = alphabet.eos_idx
+        self.prepend_bos = alphabet.prepend_bos
+        self.append_eos = alphabet.append_eos
+        self.emb_layer_norm_before = getattr(self.args, ""emb_layer_norm_before"", False)
+        if self.args.arch == ""roberta_large"":
+            self.model_version = ""ESM-1b""
+            self._init_submodules_esm1b()
+        else:
+            self.model_version = ""ESM-1""
+            self._init_submodules_esm1()
+
+    def _init_submodules_common(self):
+        self.embed_tokens = nn.Embedding(
+            self.alphabet_size, self.args.embed_dim, padding_idx=self.padding_idx
+        )
+        self.layers = nn.ModuleList(
+            [
+                TransformerLayer(
+                    self.args.embed_dim,
+                    self.args.ffn_embed_dim,
+                    self.args.attention_heads,
+                    add_bias_kv=(self.model_version != ""ESM-1b""),
+                    use_esm1b_layer_norm=(self.model_version == ""ESM-1b""),
+                )
+                for _ in range(self.args.layers)
+            ]
+        )
+
+        self.contact_head = ContactPredictionHead(
+            self.args.layers * self.args.attention_heads,
+            self.prepend_bos,
+            self.append_eos,
+            eos_idx=self.eos_idx,
+        )
+
+    def _init_submodules_esm1b(self):
+        self._init_submodules_common()
+        self.embed_scale = 1
+        self.embed_positions = LearnedPositionalEmbedding(
+            self.args.max_positions, self.args.embed_dim, self.padding_idx
+        )
+        self.emb_layer_norm_before = (
+            ESM1bLayerNorm(self.args.embed_dim) if self.emb_layer_norm_before else None
+        )
+        self.emb_layer_norm_after = ESM1bLayerNorm(self.args.embed_dim)
+        self.lm_head = RobertaLMHead(
+            embed_dim=self.args.embed_dim,
+            output_dim=self.alphabet_size,
+            weight=self.embed_tokens.weight,
+        )
+
+    def _init_submodules_esm1(self):
+        self._init_submodules_common()
+        self.embed_scale = math.sqrt(self.args.embed_dim)
+        self.embed_positions = SinusoidalPositionalEmbedding(self.args.embed_dim, self.padding_idx)
+        self.embed_out = nn.Parameter(torch.zeros((self.alphabet_size, self.args.embed_dim)))
+        self.embed_out_bias = None
+        if self.args.final_bias:
+            self.embed_out_bias = nn.Parameter(torch.zeros(self.alphabet_size))
+
+    def forward(self, tokens, repr_layers=[], need_head_weights=False, return_contacts=False):
+        if return_contacts:
+            need_head_weights = True
+
+        assert tokens.ndim == 2
+        padding_mask = tokens.eq(self.padding_idx)  # B, T
+
+        x = self.embed_scale * self.embed_tokens(tokens)
+
+        if getattr(self.args, ""token_dropout"", False):
+            x.masked_fill_((tokens == self.mask_idx).unsqueeze(-1), 0.0)
+            # x: B x T x C
+            mask_ratio_train = 0.15 * 0.8
+            src_lengths = (~padding_mask).sum(-1)
+            mask_ratio_observed = (tokens == self.mask_idx).sum(-1).float() / src_lengths
+            x = x * (1 - mask_ratio_train) / (1 - mask_ratio_observed)[:, None, None]
+
+        x = x + self.embed_positions(tokens)
+
+        if self.model_version == ""ESM-1b"":
+            if self.emb_layer_norm_before:
+                x = self.emb_layer_norm_before(x)
+            if padding_mask is not None:
+                x = x * (1 - padding_mask.unsqueeze(-1).type_as(x))
+
+        repr_layers = set(repr_layers)
+        hidden_representations = {}
+        if 0 in repr_layers:
+            hidden_representations[0] = x
+
+        if need_head_weights:
+            attn_weights = []
+
+        # (B, T, E) => (T, B, E)
+        x = x.transpose(0, 1)
+
+        if not padding_mask.any():
+            padding_mask = None
+
+        for layer_idx, layer in enumerate(self.layers):
+            x, attn = layer(
+                x, self_attn_padding_mask=padding_mask, need_head_weights=need_head_weights
+            )
+            if (layer_idx + 1) in repr_layers:
+                hidden_representations[layer_idx + 1] = x.transpose(0, 1)
+            if need_head_weights:
+                # (H, B, T, T) => (B, H, T, T)
+                attn_weights.append(attn.transpose(1, 0))
+
+        if self.model_version == ""ESM-1b"":
+            x = self.emb_layer_norm_after(x)
+            x = x.transpose(0, 1)  # (T, B, E) => (B, T, E)
+
+            # last hidden representation should have layer norm applied
+            if (layer_idx + 1) in repr_layers:
+                hidden_representations[layer_idx + 1] = x
+            x = self.lm_head(x)
+        else:
+            x = F.linear(x, self.embed_out, bias=self.embed_out_bias)
+            x = x.transpose(0, 1)  # (T, B, E) => (B, T, E)
+
+        result = {""logits"": x, ""representations"": hidden_representations}
+        if need_head_weights:
+            # attentions: B x L x H x T x T
+            attentions = torch.stack(attn_weights, 1)
+            if self.model_version == ""ESM-1"":
+                # ESM-1 models have an additional null-token for attention, which we remove
+                attentions = attentions[..., :-1]
+            if padding_mask is not None:
+                attention_mask = 1 - padding_mask.type_as(attentions)
+                attention_mask = attention_mask.unsqueeze(1) * attention_mask.unsqueeze(2)
+                attentions = attentions * attention_mask[:, None, None, :, :]
+            result[""attentions""] = attentions
+            if return_contacts:
+                contacts = self.contact_head(tokens, attentions)
+                result[""contacts""] = contacts
+
+        return result
+
+    def predict_contacts(self, tokens):
+        return self(tokens, return_contacts=True)[""contacts""]
+
+    @property
+    def num_layers(self):
+        return self.args.layers
+
+
+class MSATransformer(nn.Module):
+    @classmethod
+    def add_args(cls, parser):
+        # fmt: off
+        parser.add_argument(
+            ""--num_layers"",
+            default=12,
+            type=int,
+            metavar=""N"",
+            help=""number of layers""
+        )
+        parser.add_argument(
+            ""--embed_dim"",
+            default=768,
+            type=int,
+            metavar=""N"",
+            help=""embedding dimension""
+        )
+        parser.add_argument(
+            ""--logit_bias"",
+            action=""store_true"",
+            help=""whether to apply bias to logits""
+        )
+        parser.add_argument(
+            ""--ffn_embed_dim"",
+            default=3072,
+            type=int,
+            metavar=""N"",
+            help=""embedding dimension for FFN"",
+        )
+        parser.add_argument(
+            ""--attention_heads"",
+            default=12,
+            type=int,
+            metavar=""N"",
+            help=""number of attention heads"",
+        )
+        parser.add_argument(
+            ""--dropout"",
+            default=0.1,
+            type=float,
+            help=""Dropout to apply.""
+        )
+        parser.add_argument(
+            ""--attention_dropout"",
+            default=0.1,
+            type=float,
+            help=""Dropout to apply.""
+        )
+        parser.add_argument(
+            ""--activation_dropout"",
+            default=0.1,
+            type=float,
+            help=""Dropout to apply.""
+        )
+        parser.add_argument(
+            ""--max_tokens_per_msa"",
+            default=2 ** 14,
+            type=int,
+            help=(
+                ""Used during inference to batch attention computations in a single ""
+                ""forward pass. This allows increased input sizes with less memory.""
+            ),
+        )
+        # fmt: on
+
+    def __init__(self, args, alphabet):
+        super().__init__()
+        self.args = args
+        self.alphabet_size = len(alphabet)
+        self.padding_idx = alphabet.padding_idx
+        self.mask_idx = alphabet.mask_idx
+        self.cls_idx = alphabet.cls_idx
+        self.eos_idx = alphabet.eos_idx
+        self.prepend_bos = alphabet.prepend_bos
+        self.append_eos = alphabet.append_eos
+
+        self.embed_tokens = nn.Embedding(
+            self.alphabet_size, self.args.embed_dim, padding_idx=self.padding_idx
+        )
+
+        if getattr(self.args, ""embed_positions_msa"", False):
+            emb_dim = getattr(self.args, ""embed_positions_msa_dim"", self.args.embed_dim)
+            self.msa_position_embedding = nn.Parameter(
+                0.01 * torch.randn(1, 1024, 1, emb_dim),
+                requires_grad=True,
+            )
+        else:
+            self.register_parameter(""msa_position_embedding"", None)
+
+        self.dropout_module = nn.Dropout(self.args.dropout)
+        self.layers = nn.ModuleList(
+            [
+                AxialTransformerLayer(
+                    self.args.embed_dim,
+                    self.args.ffn_embed_dim,
+                    self.args.attention_heads,
+                    self.args.dropout,
+                    self.args.attention_dropout,
+                    self.args.activation_dropout,
+                    getattr(self.args, ""max_tokens_per_msa"", self.args.max_tokens),
+                )
+                for _ in range(self.args.layers)
+            ]
+        )
+
+        self.contact_head = ContactPredictionHead(
+            self.args.layers * self.args.attention_heads,
+            self.prepend_bos,
+            self.append_eos,
+            eos_idx=self.eos_idx,
+        )
+        self.embed_positions = LearnedPositionalEmbedding(
+            self.args.max_positions,
+            self.args.embed_dim,
+            self.padding_idx,
+        )
+        self.emb_layer_norm_before = ESM1bLayerNorm(self.args.embed_dim)
+        self.emb_layer_norm_after = ESM1bLayerNorm(self.args.embed_dim)
+        self.lm_head = RobertaLMHead(
+            embed_dim=self.args.embed_dim,
+            output_dim=self.alphabet_size,
+            weight=self.embed_tokens.weight,
+        )
+
+    def forward(self, tokens, repr_layers=[], need_head_weights=False, return_contacts=False):
+        if return_contacts:
+            need_head_weights = True
+
+        assert tokens.ndim == 3
+        batch_size, num_alignments, seqlen = tokens.size()
+        padding_mask = tokens.eq(self.padding_idx)  # B, R, C
+        if not padding_mask.any():
+            padding_mask = None
+
+        x = self.embed_tokens(tokens)
+        x += self.embed_positions(tokens.view(batch_size * num_alignments, seqlen)).view(x.size())
+        if self.msa_position_embedding is not None:
+            if x.size(1) > 1024:
+                raise RuntimeError(
+                    ""Using model with MSA position embedding trained on maximum MSA ""
+                    f""depth of 1024, but received {x.size(1)} alignments.""
+                )
+            x += self.msa_position_embedding[:, :num_alignments]
+
+        x = self.emb_layer_norm_before(x)
+
+        x = self.dropout_module(x)
+
+        if padding_mask is not None:
+            x = x * (1 - padding_mask.unsqueeze(-1).type_as(x))
+
+        repr_layers = set(repr_layers)
+        hidden_representations = {}
+        if 0 in repr_layers:
+            hidden_representations[0] = x
+            
+
+        if need_head_weights:
+            row_attn_weights = []
+            col_attn_weights = []
+
+        # B x R x C x D -> R x C x B x D
+        x = x.permute(1, 2, 0, 3)
+
+        for layer_idx, layer in enumerate(self.layers):
+            x = layer(
+                x,
+                self_attn_padding_mask=padding_mask,
+                need_head_weights=need_head_weights,
+            )
+            if need_head_weights:
+                x, col_attn, _ = x
+                if layer_idx == 0:
+                    col_attn_weights = symmetrize(col_attn.permute(2, 0, 1, 3, 4))
+                else:
+                    col_attn_weights += symmetrize(col_attn.permute(2, 0, 1, 3, 4))
+            # if need_head_weights:
+            #     x, col_attn, row_attn = x
+            #     # H x C x B x R x R -> B x H x C x R x R
+            #     col_attn_weights.append(col_attn.permute(2, 0, 1, 3, 4))
+            #     # H x B x C x C -> B x H x C x C
+            #     row_attn_weights.append(row_attn.permute(1, 0, 2, 3))
+            if (layer_idx + 1) in repr_layers:
+                hidden_representations[layer_idx + 1] = x.permute(2, 0, 1, 3)
+
+
+
+        x = self.emb_layer_norm_after(x)
+        x = x.permute(2, 0, 1, 3)  # R x C x B x D -> B x R x C x D
+
+        # last hidden representation should have layer norm applied
+        if (layer_idx + 1) in repr_layers:
+            hidden_representations[layer_idx + 1] = x
+        x = self.lm_head(x)
+
+        result = {""logits"": x, ""representations"": hidden_representations}
+        if need_head_weights:
+            # # col_attentions: B x L x H x C x R x R
+            # col_attentions = torch.stack(col_attn_weights, 1)
+            # # row_attentions: B x L x H x C x C
+            # row_attentions = torch.stack(row_attn_weights, 1)
+            # result[""col_attentions""] = col_attentions
+            # result[""row_attentions""] = row_attentions
+            result[""col_attentions""] = col_attn_weights.sum(1)
+            # if return_contacts:
+            #     contacts = self.contact_head(tokens, row_attentions)
+            #     result[""contacts""] = contacts
+
+        return result
+
+    def predict_contacts(self, tokens):
+        return self(tokens, return_contacts=True)[""contacts""]
+
+    @property
+    def num_layers(self):
+        return self.args.layers
+
+    def max_tokens_per_msa_(self, value: int) -> None:
+        """"""The MSA Transformer automatically batches attention computations when
+        gradients are disabled to allow you to pass in larger MSAs at test time than
+        you can fit in GPU memory. By default this occurs when more than 2^14 tokens
+        are passed in the input MSA. You can set this value to infinity to disable
+        this behavior.
+        """"""
+        for module in self.modules():
+            if isinstance(module, (RowSelfAttention, ColumnSelfAttention)):
+                module.max_tokens_per_msa = value
+
+def symmetrize(x):
+    ""Make layer symmetric in final two dimensions, used for contact prediction.""
+    # print(x.size())
+    # exit()
+    return x + x.transpose(-1, -2)","Python"
+"AlphaFold","allanchen95/ESMPair","msa_transformer.py",".py","8777","252","import torch
+import torch.nn as nn
+
+from ..modules import (
+    AxialTransformerLayer,
+    LearnedPositionalEmbedding,
+    RobertaLMHead,
+    ESM1bLayerNorm,
+    ContactPredictionHead,
+)
+
+from ..axial_attention import RowSelfAttention, ColumnSelfAttention
+
+
+
+class MSATransformer(nn.Module):
+    @classmethod
+    def add_args(cls, parser):
+        # fmt: off
+        parser.add_argument(
+            ""--num_layers"",
+            default=12,
+            type=int,
+            metavar=""N"",
+            help=""number of layers""
+        )
+        parser.add_argument(
+            ""--embed_dim"",
+            default=768,
+            type=int,
+            metavar=""N"",
+            help=""embedding dimension""
+        )
+        parser.add_argument(
+            ""--logit_bias"",
+            action=""store_true"",
+            help=""whether to apply bias to logits""
+        )
+        parser.add_argument(
+            ""--ffn_embed_dim"",
+            default=3072,
+            type=int,
+            metavar=""N"",
+            help=""embedding dimension for FFN"",
+        )
+        parser.add_argument(
+            ""--attention_heads"",
+            default=12,
+            type=int,
+            metavar=""N"",
+            help=""number of attention heads"",
+        )
+        parser.add_argument(
+            ""--dropout"",
+            default=0.1,
+            type=float,
+            help=""Dropout to apply.""
+        )
+        parser.add_argument(
+            ""--attention_dropout"",
+            default=0.1,
+            type=float,
+            help=""Dropout to apply.""
+        )
+        parser.add_argument(
+            ""--activation_dropout"",
+            default=0.1,
+            type=float,
+            help=""Dropout to apply.""
+        )
+        parser.add_argument(
+            ""--max_tokens_per_msa"",
+            default=2 ** 14,
+            type=int,
+            help=(
+                ""Used during inference to batch attention computations in a single ""
+                ""forward pass. This allows increased input sizes with less memory.""
+            ),
+        )
+        # fmt: on
+
+    def __init__(self, args, alphabet):
+        super().__init__()
+        self.args = args
+        self.alphabet_size = len(alphabet)
+        self.padding_idx = alphabet.padding_idx
+        self.mask_idx = alphabet.mask_idx
+        self.cls_idx = alphabet.cls_idx
+        self.eos_idx = alphabet.eos_idx
+        self.prepend_bos = alphabet.prepend_bos
+        self.append_eos = alphabet.append_eos
+
+        self.embed_tokens = nn.Embedding(
+            self.alphabet_size, self.args.embed_dim, padding_idx=self.padding_idx
+        )
+
+        if getattr(self.args, ""embed_positions_msa"", False):
+            emb_dim = getattr(self.args, ""embed_positions_msa_dim"", self.args.embed_dim)
+            self.msa_position_embedding = nn.Parameter(
+                0.01 * torch.randn(1, 1024, 1, emb_dim),
+                requires_grad=True,
+            )
+        else:
+            self.register_parameter(""msa_position_embedding"", None)
+
+        self.dropout_module = nn.Dropout(self.args.dropout)
+        self.layers = nn.ModuleList(
+            [
+                AxialTransformerLayer(
+                    self.args.embed_dim,
+                    self.args.ffn_embed_dim,
+                    self.args.attention_heads,
+                    self.args.dropout,
+                    self.args.attention_dropout,
+                    self.args.activation_dropout,
+                    getattr(self.args, ""max_tokens_per_msa"", self.args.max_tokens),
+                )
+                for _ in range(self.args.layers)
+            ]
+        )
+
+        self.contact_head = ContactPredictionHead(
+            self.args.layers * self.args.attention_heads,
+            self.prepend_bos,
+            self.append_eos,
+            eos_idx=self.eos_idx,
+        )
+        self.embed_positions = LearnedPositionalEmbedding(
+            self.args.max_positions,
+            self.args.embed_dim,
+            self.padding_idx,
+        )
+        self.emb_layer_norm_before = ESM1bLayerNorm(self.args.embed_dim)
+        self.emb_layer_norm_after = ESM1bLayerNorm(self.args.embed_dim)
+        self.lm_head = RobertaLMHead(
+            embed_dim=self.args.embed_dim,
+            output_dim=self.alphabet_size,
+            weight=self.embed_tokens.weight,
+        )
+
+    def forward(self, tokens, repr_layers=[], need_head_weights=False, return_contacts=False):
+        if return_contacts:
+            need_head_weights = True
+
+        assert tokens.ndim == 3
+        batch_size, num_alignments, seqlen = tokens.size()
+        padding_mask = tokens.eq(self.padding_idx)  # B, R, C
+        if not padding_mask.any():
+            padding_mask = None
+
+        x = self.embed_tokens(tokens)
+        x += self.embed_positions(tokens.view(batch_size * num_alignments, seqlen)).view(x.size())
+        if self.msa_position_embedding is not None:
+            if x.size(1) > 1024:
+                raise RuntimeError(
+                    ""Using model with MSA position embedding trained on maximum MSA ""
+                    f""depth of 1024, but received {x.size(1)} alignments.""
+                )
+            x += self.msa_position_embedding[:, :num_alignments]
+
+        x = self.emb_layer_norm_before(x)
+
+        x = self.dropout_module(x)
+
+        if padding_mask is not None:
+            x = x * (1 - padding_mask.unsqueeze(-1).type_as(x))
+
+        repr_layers = set(repr_layers)
+        hidden_representations = {}
+        if 0 in repr_layers:
+            hidden_representations[0] = x
+
+        if need_head_weights:
+            row_attn_weights = []
+            col_attn_weights = []
+
+        # B x R x C x D -> R x C x B x D
+        x = x.permute(1, 2, 0, 3)
+
+        for layer_idx, layer in enumerate(self.layers):
+            x = layer(
+                x,
+                self_attn_padding_mask=padding_mask,
+                need_head_weights=need_head_weights,
+            )
+            # if need_head_weights:
+            #     x, col_attn, row_attn = x
+            #     # H x C x B x R x R -> B x H x C x R x R
+            #     col_attn_weights.append(col_attn.permute(2, 0, 1, 3, 4))
+            #     # H x B x C x C -> B x H x C x C
+            #     row_attn_weights.append(row_attn.permute(1, 0, 2, 3))
+            
+            # directly sum col_attn_weights to reduce memory cost
+            # col_attn_weights: B x H x C x R x R
+            if need_head_weights:
+                x, col_attn, _ = x
+                if layer_idx == 0:
+                    col_attn_weights = symmetrize(col_attn.permute(2, 0, 1, 3, 4))
+                else:
+                    col_attn_weights += symmetrize(col_attn.permute(2, 0, 1, 3, 4))
+            if (layer_idx + 1) in repr_layers:
+                hidden_representations[layer_idx + 1] = x.permute(2, 0, 1, 3)
+
+        x = self.emb_layer_norm_after(x)
+        x = x.permute(2, 0, 1, 3)  # R x C x B x D -> B x R x C x D
+
+        # last hidden representation should have layer norm applied
+        if (layer_idx + 1) in repr_layers:
+            hidden_representations[layer_idx + 1] = x
+        x = self.lm_head(x)
+
+        result = {""logits"": x, ""representations"": hidden_representations}
+        if need_head_weights:
+            
+            # # col_attentions: B x L x H x C x R x R
+            # col_attentions = torch.stack(col_attn_weights, 1)
+            # # row_attentions: B x L x H x C x C
+            # row_attentions = torch.stack(row_attn_weights, 1)
+            # result[""col_attentions""] = col_attentions
+            # result[""row_attentions""] = row_attentions
+            
+            
+            # B x H x C x R x R -> B x C x R x R
+            result[""col_attentions""] = col_attn_weights.sum(1)
+            
+            # if return_contacts:
+            #     contacts = self.contact_head(tokens, row_attentions)
+            #     result[""contacts""] = contacts
+
+        return result
+
+    def predict_contacts(self, tokens):
+        return self(tokens, return_contacts=True)[""contacts""]
+
+    @property
+    def num_layers(self):
+        return self.args.layers
+
+    def max_tokens_per_msa_(self, value: int) -> None:
+        """"""The MSA Transformer automatically batches attention computations when
+        gradients are disabled to allow you to pass in larger MSAs at test time than
+        you can fit in GPU memory. By default this occurs when more than 2^14 tokens
+        are passed in the input MSA. You can set this value to infinity to disable
+        this behavior.
+        """"""
+        for module in self.modules():
+            if isinstance(module, (RowSelfAttention, ColumnSelfAttention)):
+                module.max_tokens_per_msa = value
+
+def symmetrize(x):
+    ""Make layer symmetric in final two dimensions, used for contact prediction.""
+    return x + x.transpose(-1, -2)","Python"
+"AlphaFold","allanchen95/ESMPair","colattn_pair.py",".py","3116","100","import os
+import json
+from tqdm import tqdm
+import numpy as np
+from msa_pair.data import (
+    species_processing, row_processing, pairing_pipeline,
+)
+import esm
+
+
+msa_transformer, msa_alphabet = esm.pretrained.esm_msa1b_t12_100M_UR50S()
+msa_batch_converter = msa_alphabet.get_batch_converter()
+
+def compute_scores(input_dir, dst_path, tag, max_num_msas, is_cpu=False):
+    from msa_pair.data import esm_scoring
+
+    species_dict, msas_dict, _, _ = species_processing.pair_species(
+        input_dir, names=['uniref90.a3m'], chain_ids=['A', 'B']
+        # input_dir, names=['uniprot.a3m'], chain_ids=['A', 'B']
+        )
+    esm_scorer = esm_scoring.EsmScoring(msa_transformer, msa_batch_converter, tag)
+    sequences_scores = esm_scorer.score_sequences(species_dict, msas_dict, max_num_msas=max_num_msas)
+    with open(dst_path, 'wt') as fh:
+        json.dump(sequences_scores, fh, indent=4, sort_keys=True)
+
+
+def pair_rows(input_dir, src_score_path, dst_pr_path, tag, overwrite=False):
+
+
+    with open(src_score_path) as fh:
+        sequences_scores = json.load(fh)
+
+    species_dict, msas_dict, _, _ = species_processing.pair_species(
+        input_dir, names=['uniref90.a3m'], chain_ids=['A', 'B']
+        # input_dir, names=['uniprot.a3m'], chain_ids=['A', 'B']
+    )
+    paired_rows_dict = row_processing.create_paired_rows_dict(
+        species_dict, msas_dict, sequences_scores
+    )
+    # print(paired_rows_dict)
+    # print(paired_rows_dict[""A""])
+    # print(paired_rows_dict[""A""][:10])
+    # print(paired_rows_dict[""B""][:10])
+    # exit()
+
+    with open(dst_pr_path, 'wt') as fh:
+        json.dump(paired_rows_dict, fh, indent=4)
+
+
+def process(input_dir, src_pr_path, dst_path, overwrite=False):
+    if not overwrite and os.path.exists(dst_path):
+        return
+
+    pipeline = pairing_pipeline.PairingPipeline()
+
+    with open(src_pr_path) as fh:
+        paired_rows_dict = json.load(fh)
+
+    try:
+        np_example = pipeline.process(input_dir, paired_rows_dict)
+    except IOError as e:
+        print(e)
+        return
+
+    np.savez(dst_path, **np_example)
+
+if __name__ == '__main__':
+    # python colattn_pair.py ./dataset/ 4 512 
+    import sys
+    import logging
+    logging.basicConfig(level=logging.INFO)
+    
+    # use column attention for pairing
+    tag = 'col'
+    
+    # .a3m path
+    input_root = sys.argv[1]
+    
+    # device id
+    device_id = sys.argv[2]
+    
+    # max_msa for each batch: default 512
+    max_per_msa = 512
+    total_dir_list = os.listdir(input_root)
+
+    os.environ['CUDA_VISIBLE_DEVICES'] = str(device_id)
+    err_dirs = []
+    for name in tqdm(total_dir_list):
+        input_dir = os.path.join(input_root, name)
+        
+        # calculate and save the column attention score
+        score_path = os.path.join(input_dir, f'{tag}_scores_{max_per_msa}.json')
+        if not os.path.exists(score_path):
+            compute_scores(input_dir, score_path, tag, int(max_per_msa))
+        
+        # 
+        pr_path = os.path.join(input_dir, f'{tag}_pr_{max_per_msa}.json')
+        if not os.path.exists(pr_path):
+            pair_rows(input_dir, score_path, pr_path, tag)
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/setup.py",".py","232","13","from setuptools import find_packages
+from setuptools import setup
+
+setup(
+    name='msa_pair',
+    packages=find_packages(),
+    install_requires=[
+        'pandas',
+        'scipy',
+        'requests',
+        'biopython',
+    ],
+)","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/__init__.py",".py","0","0","","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/runner/model_preset_runner.py",".py","6309","191","import os
+import time
+import random
+import logging
+from typing import Mapping, Optional, Sequence, List
+
+import jax
+import tree
+import numpy as np
+
+from alphafold.data import pipeline_multimer, msa_pairing
+from alphafold.model import config, data, model
+# from msa_pair.runner import model, modules_multimer
+
+logger = logging.getLogger(__file__)
+
+
+def clear_mem(device=None):
+    '''remove all data from device'''
+    backend = jax.lib.xla_bridge.get_backend(device)
+    if hasattr(backend,'live_buffers'):
+        for buf in backend.live_buffers():
+            buf.delete()
+
+
+def _is_params_transferable(old_params, next_params):
+    def _get_all_keys(params):
+        all_keys = []
+        for path in params.keys():
+            for k in params[path].keys():
+                all_keys.append(f'{path}/{k}')
+        return tuple(sorted(all_keys))
+
+    return _get_all_keys(old_params) == _get_all_keys(next_params)
+
+
+class ModelPresetRunner:
+    def __init__(
+        self,
+        database: str,
+        model_preset: str = 'multimer',
+        allow_params_transfer: bool = True,
+        cache_params: bool = True,
+        ignore_unpaired_sequences: bool = True,
+    ):
+        assert model_preset == 'multimer', 'Only supports preset multimer'
+
+        self.model_preset = model_preset
+        self.database = database
+        self.allow_params_transfer = allow_params_transfer
+        self.cache_params = cache_params
+
+        self.params_dict = {}
+        # Check model parameters
+        first_params, first_model_name = None, None
+        first_config = None
+
+        self.avail_model_names = []
+        for model_name in config.MODEL_PRESETS[model_preset]:
+            try:
+                params = data.get_model_haiku_params(
+                    model_name, self.database
+                )
+                if first_params is None:
+                    first_model_name = model_name
+                    first_params = params
+                    first_config = config.model_config(model_name)
+                elif self.allow_params_transfer:
+                    if not _is_params_transferable(first_params, params):
+                        continue
+                    if first_config != config.model_config(model_name):
+                        continue
+                self.avail_model_names.append(model_name)
+            except FileNotFoundError as e:
+                continue
+
+        assert len(self.avail_model_names) >= 1
+
+        # print(f'{len(self.avail_model_names)} models are available')
+        # print(f'Build RunModel {first_model_name}')
+        self.running_model = model.RunModel(first_config, first_params)
+
+        self.ignore_unpaired_sequences = ignore_unpaired_sequences
+
+    def predict(
+        self,
+        feat: Mapping[str, np.ndarray],
+        rng_seed: Optional[int] = None,
+        model_names: Optional[List[str]] = None,
+        num_predictions_per_model: int = 5,
+        model_index: str = None,
+    ):
+        if rng_seed is not None:
+            rng = np.random.default_rng(rng_seed)
+        else:
+            rng = np.random.default_rng(random.randrange(1, 2**24))
+
+        if model_names is None:
+            model_names = self.avail_model_names
+        else:
+            model_names = [
+                model_name for model_name in model_names if model_name in 
+                self.avail_model_names
+            ]
+
+        if model_index is not None:
+            model_names = [self.avail_model_names[int(model_index)]]
+
+
+        print(f""#models: {len(model_names)} Used model {model_index} for predicting {num_predictions_per_model} number."")
+        outputs = {}
+        for model_name in model_names:
+            for pred_num in range(num_predictions_per_model):
+                seed = int(rng.integers(1, 2**24))
+                result, timing = self.run_model(
+                    feat, model_name, seed
+                )
+                outputs[f'{model_name}_{pred_num}'] = {
+                    'result': result,
+                    'timing': timing,
+                    'seed': seed,
+                }
+            logger.info(tree.map_structure(lambda x: x.shape, result))
+
+        return outputs
+
+    def run_model(
+        self,
+        feat: Mapping[str, np.ndarray],
+        model_name: str,
+        random_seed: int,
+    ):
+        t0 = time.time()
+
+        if not self.cache_params or model_name not in self.params_dict:
+            params = data.get_model_haiku_params(model_name, self.database)
+            if self.cache_params:
+                self.params_dict[model_name] = params
+        else:
+            params = self.params_dict[model_name]
+
+        if self.running_model is not None and self.allow_params_transfer:
+            logger.info(f'Transfer {model_name} params to the running model')
+            for path in params.keys():
+                self.running_model.params[path] = params[path]
+
+        logger.info(
+            f'Start prediction using {model_name} with seed {random_seed}'
+        )
+        if self.ignore_unpaired_sequences:
+            feat = self._remove_unpaired_sequences(feat)
+        result = self.running_model.predict(feat, random_seed)
+        t1 = time.time()
+
+        logger.info(
+            f'Finish prediction using {model_name} in {t1 - t0} seconds'
+        )
+        # exit()
+        timing = t1 - t0
+
+        return result, timing
+
+    def _remove_unpaired_sequences(
+        self,
+        feat: Mapping[str, np.ndarray],
+    ):
+        paired_sequence_mask = 1
+        for chain_id in np.unique(feat['asym_id']):
+            if chain_id:
+                chain_mask = feat['asym_id'] == chain_id
+                paired_sequence_mask *= np.sum(
+                    feat['msa'][:,chain_mask] != msa_pairing.MSA_GAP_IDX,
+                    axis=-1,
+                ) > 0
+        paired_sequence_mask = paired_sequence_mask.astype(bool)
+        for key, value in feat.items():
+            if key in (
+                'msa', 
+                'deletion_matrix',
+                'bert_mask',
+                'msa_mask', 
+                'cluster_bias_mask',
+            ):
+                feat[key] = value[paired_sequence_mask]
+            elif key in ('num_alignments',):
+                feat[key] = np.sum(paired_sequence_mask)
+
+        feat = pipeline_multimer.pad_msa(feat, 512)
+
+        return feat
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/runner/model.py",".py","6673","180","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Code for constructing the model.""""""
+from typing import Any, Mapping, Optional, Union
+
+from absl import logging
+from alphafold.common import confidence
+from alphafold.model import features
+from alphafold.model import modules
+from msa_pair.runner import modules_multimer
+import haiku as hk
+import jax
+import ml_collections
+import numpy as np
+import tensorflow.compat.v1 as tf
+import tree
+
+
+def get_confidence_metrics(
+    prediction_result: Mapping[str, Any],
+    multimer_mode: bool) -> Mapping[str, Any]:
+  """"""Post processes prediction_result to get confidence metrics.""""""
+  confidence_metrics = {}
+  confidence_metrics['plddt'] = confidence.compute_plddt(
+      prediction_result['predicted_lddt']['logits'])
+  if 'predicted_aligned_error' in prediction_result:
+    confidence_metrics.update(confidence.compute_predicted_aligned_error(
+        logits=prediction_result['predicted_aligned_error']['logits'],
+        breaks=prediction_result['predicted_aligned_error']['breaks']))
+    confidence_metrics['ptm'] = confidence.predicted_tm_score(
+        logits=prediction_result['predicted_aligned_error']['logits'],
+        breaks=prediction_result['predicted_aligned_error']['breaks'],
+        asym_id=None)
+    if multimer_mode:
+      # Compute the ipTM only for the multimer model.
+      confidence_metrics['iptm'] = confidence.predicted_tm_score(
+          logits=prediction_result['predicted_aligned_error']['logits'],
+          breaks=prediction_result['predicted_aligned_error']['breaks'],
+          asym_id=prediction_result['predicted_aligned_error']['asym_id'],
+          interface=True)
+      confidence_metrics['ranking_confidence'] = (
+          0.8 * confidence_metrics['iptm'] + 0.2 * confidence_metrics['ptm'])
+
+  if not multimer_mode:
+    # Monomer models use mean pLDDT for model ranking.
+    confidence_metrics['ranking_confidence'] = np.mean(
+        confidence_metrics['plddt'])
+
+  return confidence_metrics
+
+
+class RunModel:
+  """"""Container for JAX model.""""""
+
+  def __init__(self,
+               config: ml_collections.ConfigDict,
+               params: Optional[Mapping[str, Mapping[str, np.ndarray]]] = None):
+    self.config = config
+    self.params = params
+    self.multimer_mode = config.model.global_config.multimer_mode
+    if self.multimer_mode:
+      def _forward_fn(batch):
+        model = modules_multimer.AlphaFold(self.config.model)
+        return model(
+            batch,
+            return_representations=True,
+            is_training=False)
+    else:
+      def _forward_fn(batch):
+        model = modules.AlphaFold(self.config.model)
+        return model(
+            batch,
+            is_training=False,
+            compute_loss=False,
+            ensemble_representations=True)
+
+    self.apply = jax.jit(hk.transform(_forward_fn).apply)
+    self.init = jax.jit(hk.transform(_forward_fn).init)
+
+  def init_params(self, feat: features.FeatureDict, random_seed: int = 0):
+    """"""Initializes the model parameters.
+
+    If none were provided when this class was instantiated then the parameters
+    are randomly initialized.
+
+    Args:
+      feat: A dictionary of NumPy feature arrays as output by
+        RunModel.process_features.
+      random_seed: A random seed to use to initialize the parameters if none
+        were set when this class was initialized.
+    """"""
+    if not self.params:
+      # Init params randomly.
+      rng = jax.random.PRNGKey(random_seed)
+      self.params = hk.data_structures.to_mutable_dict(
+          self.init(rng, feat))
+      logging.warning('Initialized parameters randomly')
+
+  def process_features(
+      self,
+      raw_features: Union[tf.train.Example, features.FeatureDict],
+      random_seed: int) -> features.FeatureDict:
+    """"""Processes features to prepare for feeding them into the model.
+
+    Args:
+      raw_features: The output of the data pipeline either as a dict of NumPy
+        arrays or as a tf.train.Example.
+      random_seed: The random seed to use when processing the features.
+
+    Returns:
+      A dict of NumPy feature arrays suitable for feeding into the model.
+    """"""
+
+    if self.multimer_mode:
+      return raw_features
+
+    # Single-chain mode.
+    if isinstance(raw_features, dict):
+      return features.np_example_to_features(
+          np_example=raw_features,
+          config=self.config,
+          random_seed=random_seed)
+    else:
+      return features.tf_example_to_features(
+          tf_example=raw_features,
+          config=self.config,
+          random_seed=random_seed)
+
+  def eval_shape(self, feat: features.FeatureDict) -> jax.ShapeDtypeStruct:
+    self.init_params(feat)
+    logging.info('Running eval_shape with shape(feat) = %s',
+                 tree.map_structure(lambda x: x.shape, feat))
+    shape = jax.eval_shape(self.apply, self.params, jax.random.PRNGKey(0), feat)
+    logging.info('Output shape was %s', shape)
+    return shape
+
+  def predict(self,
+              feat: features.FeatureDict,
+              random_seed: int,
+              ) -> Mapping[str, Any]:
+    """"""Makes a prediction by inferencing the model on the provided features.
+
+    Args:
+      feat: A dictionary of NumPy feature arrays as output by
+        RunModel.process_features.
+      random_seed: The random seed to use when running the model. In the
+        multimer model this controls the MSA sampling.
+
+    Returns:
+      A dictionary of model outputs.
+    """"""
+    self.init_params(feat)
+    print('Running predict with shape(feat) = %s',
+                 tree.map_structure(lambda x: x.shape, feat))
+    # exit()
+    result = self.apply(self.params, jax.random.PRNGKey(random_seed), feat)
+    # exit()
+    # This block is to ensure benchmark timings are accurate. Some blocking is
+    # already happening when computing get_confidence_metrics, and this ensures
+    # all outputs are blocked on.
+    jax.tree_map(lambda x: x.block_until_ready(), result)
+    result.update(
+        get_confidence_metrics(result, multimer_mode=self.multimer_mode))
+    logging.info('Output shape was %s',
+                 tree.map_structure(lambda x: x.shape, result))
+    return result
+
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/runner/modules_multimer.py",".py","38002","1080","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Core modules, which have been refactored in AlphaFold-Multimer.
+
+The main difference is that MSA sampling pipeline is moved inside the JAX model
+for easier implementation of recycling and ensembling.
+
+Lower-level modules up to EvoformerIteration are reused from modules.py.
+""""""
+
+import functools
+from typing import Sequence
+
+from alphafold.common import residue_constants
+from alphafold.model import all_atom_multimer
+from alphafold.model import common_modules
+from alphafold.model import folding_multimer
+from alphafold.model import geometry
+from alphafold.model import layer_stack
+from alphafold.model import prng
+from alphafold.model import utils
+import tree
+from jax.experimental.host_callback import call
+from jax.experimental.host_callback import id_print
+from msa_pair.runner import modules
+
+import haiku as hk
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+
+def reduce_fn(x, mode):
+  if mode == 'none' or mode is None:
+    return jnp.asarray(x)
+  elif mode == 'sum':
+    return jnp.asarray(x).sum()
+  elif mode == 'mean':
+    return jnp.mean(jnp.asarray(x))
+  else:
+    raise ValueError('Unsupported reduction option.')
+
+
+def gumbel_noise(key: jnp.ndarray, shape: Sequence[int]) -> jnp.ndarray:
+  """"""Generate Gumbel Noise of given Shape.
+
+  This generates samples from Gumbel(0, 1).
+
+  Args:
+    key: Jax random number key.
+    shape: Shape of noise to return.
+
+  Returns:
+    Gumbel noise of given shape.
+  """"""
+  epsilon = 1e-6
+  uniform = utils.padding_consistent_rng(jax.random.uniform)
+  uniform_noise = uniform(
+      key, shape=shape, dtype=jnp.float32, minval=0., maxval=1.)
+  gumbel = -jnp.log(-jnp.log(uniform_noise + epsilon) + epsilon)
+  return gumbel
+
+
+def gumbel_max_sample(key: jnp.ndarray, logits: jnp.ndarray) -> jnp.ndarray:
+  """"""Samples from a probability distribution given by 'logits'.
+
+  This uses Gumbel-max trick to implement the sampling in an efficient manner.
+
+  Args:
+    key: prng key.
+    logits: Logarithm of probabilities to sample from, probabilities can be
+      unnormalized.
+
+  Returns:
+    Sample from logprobs in one-hot form.
+  """"""
+  z = gumbel_noise(key, logits.shape)
+  return jax.nn.one_hot(
+      jnp.argmax(logits + z, axis=-1),
+      logits.shape[-1],
+      dtype=logits.dtype)
+
+
+def gumbel_argsort_sample_idx(key: jnp.ndarray,
+                              logits: jnp.ndarray) -> jnp.ndarray:
+  """"""Samples with replacement from a distribution given by 'logits'.
+
+  This uses Gumbel trick to implement the sampling an efficient manner. For a
+  distribution over k items this samples k times without replacement, so this
+  is effectively sampling a random permutation with probabilities over the
+  permutations derived from the logprobs.
+
+  Args:
+    key: prng key.
+    logits: Logarithm of probabilities to sample from, probabilities can be
+      unnormalized.
+
+  Returns:
+    Sample from logprobs in one-hot form.
+  """"""
+  z = gumbel_noise(key, logits.shape)
+  # This construction is equivalent to jnp.argsort, but using a non stable sort,
+  # since stable sort's aren't supported by jax2tf.
+  axis = len(logits.shape) - 1
+  iota = jax.lax.broadcasted_iota(jnp.int64, logits.shape, axis)
+  _, perm = jax.lax.sort_key_val(
+      logits + z, iota, dimension=-1, is_stable=False)
+  return perm[::-1]
+
+
+def make_masked_msa(batch, key, config, epsilon=1e-6):
+  """"""Create data for BERT on raw MSA.""""""
+  # Add a random amino acid uniformly.
+  random_aa = jnp.array([0.05] * 20 + [0., 0.], dtype=jnp.float32)
+
+  categorical_probs = (
+      config.uniform_prob * random_aa +
+      config.profile_prob * batch['msa_profile'] +
+      config.same_prob * jax.nn.one_hot(batch['msa'], 22))
+
+  # Put all remaining probability on [MASK] which is a new column.
+  pad_shapes = [[0, 0] for _ in range(len(categorical_probs.shape))]
+  pad_shapes[-1][1] = 1
+  mask_prob = 1. - config.profile_prob - config.same_prob - config.uniform_prob
+  assert mask_prob >= 0.
+  categorical_probs = jnp.pad(
+      categorical_probs, pad_shapes, constant_values=mask_prob)
+  sh = batch['msa'].shape
+  key, mask_subkey, gumbel_subkey = key.split(3)
+  uniform = utils.padding_consistent_rng(jax.random.uniform)
+  mask_position = uniform(mask_subkey.get(), sh) < config.replace_fraction
+  mask_position *= batch['msa_mask']
+
+  logits = jnp.log(categorical_probs + epsilon)
+  bert_msa = gumbel_max_sample(gumbel_subkey.get(), logits)
+  bert_msa = jnp.where(mask_position,
+                       jnp.argmax(bert_msa, axis=-1), batch['msa'])
+  bert_msa *= batch['msa_mask']
+
+  # Mix real and masked MSA.
+  if 'bert_mask' in batch:
+    batch['bert_mask'] *= mask_position.astype(jnp.float32)
+  else:
+    batch['bert_mask'] = mask_position.astype(jnp.float32)
+  batch['true_msa'] = batch['msa']
+  batch['msa'] = bert_msa
+
+  return batch
+
+
+def nearest_neighbor_clusters(batch, gap_agreement_weight=0.):
+  """"""Assign each extra MSA sequence to its nearest neighbor in sampled MSA.""""""
+
+  # Determine how much weight we assign to each agreement.  In theory, we could
+  # use a full blosum matrix here, but right now let's just down-weight gap
+  # agreement because it could be spurious.
+  # Never put weight on agreeing on BERT mask.
+
+  weights = jnp.array(
+      [1.] * 21 + [gap_agreement_weight] + [0.], dtype=jnp.float32)
+
+  msa_mask = batch['msa_mask']
+  msa_one_hot = jax.nn.one_hot(batch['msa'], 23)
+
+  extra_mask = batch['extra_msa_mask']
+  extra_one_hot = jax.nn.one_hot(batch['extra_msa'], 23)
+
+  msa_one_hot_masked = msa_mask[:, :, None] * msa_one_hot
+  extra_one_hot_masked = extra_mask[:, :, None] * extra_one_hot
+
+  agreement = jnp.einsum('mrc, nrc->nm', extra_one_hot_masked,
+                         weights * msa_one_hot_masked)
+
+  cluster_assignment = jax.nn.softmax(1e3 * agreement, axis=0)
+  cluster_assignment *= jnp.einsum('mr, nr->mn', msa_mask, extra_mask)
+
+  cluster_count = jnp.sum(cluster_assignment, axis=-1)
+  cluster_count += 1.  # We always include the sequence itself.
+
+  msa_sum = jnp.einsum('nm, mrc->nrc', cluster_assignment, extra_one_hot_masked)
+  msa_sum += msa_one_hot_masked
+
+  cluster_profile = msa_sum / cluster_count[:, None, None]
+
+  extra_deletion_matrix = batch['extra_deletion_matrix']
+  deletion_matrix = batch['deletion_matrix']
+
+  del_sum = jnp.einsum('nm, mc->nc', cluster_assignment,
+                       extra_mask * extra_deletion_matrix)
+  del_sum += deletion_matrix  # Original sequence.
+  cluster_deletion_mean = del_sum / cluster_count[:, None]
+
+  return cluster_profile, cluster_deletion_mean
+
+
+def create_msa_feat(batch):
+  """"""Create and concatenate MSA features.""""""
+  msa_1hot = jax.nn.one_hot(batch['msa'], 23)
+  deletion_matrix = batch['deletion_matrix']
+  has_deletion = jnp.clip(deletion_matrix, 0., 1.)[..., None]
+  deletion_value = (jnp.arctan(deletion_matrix / 3.) * (2. / jnp.pi))[..., None]
+
+  deletion_mean_value = (jnp.arctan(batch['cluster_deletion_mean'] / 3.) *
+                         (2. / jnp.pi))[..., None]
+
+  msa_feat = [
+      msa_1hot,
+      has_deletion,
+      deletion_value,
+      batch['cluster_profile'],
+      deletion_mean_value
+  ]
+
+  return jnp.concatenate(msa_feat, axis=-1)
+
+
+def create_extra_msa_feature(batch, num_extra_msa):
+  """"""Expand extra_msa into 1hot and concat with other extra msa features.
+
+  We do this as late as possible as the one_hot extra msa can be very large.
+
+  Args:
+    batch: a dictionary with the following keys:
+     * 'extra_msa': [num_seq, num_res] MSA that wasn't selected as a cluster
+       centre. Note - This isn't one-hotted.
+     * 'extra_deletion_matrix': [num_seq, num_res] Number of deletions at given
+        position.
+    num_extra_msa: Number of extra msa to use.
+
+  Returns:
+    Concatenated tensor of extra MSA features.
+  """"""
+  # 23 = 20 amino acids + 'X' for unknown + gap + bert mask
+  extra_msa = batch['extra_msa'][:num_extra_msa]
+  deletion_matrix = batch['extra_deletion_matrix'][:num_extra_msa]
+  msa_1hot = jax.nn.one_hot(extra_msa, 23)
+  has_deletion = jnp.clip(deletion_matrix, 0., 1.)[..., None]
+  deletion_value = (jnp.arctan(deletion_matrix / 3.) * (2. / jnp.pi))[..., None]
+  extra_msa_mask = batch['extra_msa_mask'][:num_extra_msa]
+  return jnp.concatenate([msa_1hot, has_deletion, deletion_value],
+                         axis=-1), extra_msa_mask
+
+
+def sample_msa(key, batch, max_seq):
+  """"""Sample MSA randomly, remaining sequences are stored as `extra_*`.
+
+  Args:
+    key: safe key for random number generation.
+    batch: batch to sample msa from.
+    max_seq: number of sequences to sample.
+  Returns:
+    Protein with sampled msa.
+  """"""
+  # Sample uniformly among sequences with at least one non-masked position.
+  logits = (jnp.clip(jnp.sum(batch['msa_mask'], axis=-1), 0., 1.) - 1.) * 1e6
+  # The cluster_bias_mask can be used to preserve the first row (target
+  # sequence) for each chain, for example.
+  if 'cluster_bias_mask' not in batch:
+    cluster_bias_mask = jnp.pad(
+        jnp.zeros(batch['msa'].shape[0] - 1), (1, 0), constant_values=1.)
+  else:
+    cluster_bias_mask = batch['cluster_bias_mask']
+
+  logits += cluster_bias_mask * 1e6
+  index_order = gumbel_argsort_sample_idx(key.get(), logits)
+#   print(id_print(index_order))
+#   call(lambda x: print(f""There are {x} true bools""), index_order[:6])
+#   exit()
+  sel_idx = extra_idx = index_order
+#   extra_idx = index_order[index_order.shape[0]:]
+#   print(extra_idx)
+
+  for k in ['msa', 'deletion_matrix', 'msa_mask', 'bert_mask']:
+    if k in batch:
+      batch['extra_' + k] = batch[k][extra_idx]
+      batch[k] = batch[k][sel_idx]
+
+  return batch
+
+
+def make_msa_profile(batch):
+  """"""Compute the MSA profile.""""""
+
+  # Compute the profile for every residue (over all MSA sequences).
+  return utils.mask_mean(
+      batch['msa_mask'][:, :, None], jax.nn.one_hot(batch['msa'], 22), axis=0)
+
+
+class AlphaFoldIteration(hk.Module):
+  """"""A single recycling iteration of AlphaFold architecture.
+
+  Computes ensembled (averaged) representations from the provided features.
+  These representations are then passed to the various heads
+  that have been requested by the configuration file.
+  """"""
+
+  def __init__(self, config, global_config, name='alphafold_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+    # print(config)
+    # print(global_config)
+  def __call__(self,
+               batch,
+               is_training,
+               return_representations=False,
+               safe_key=None):
+
+    if is_training:
+      num_ensemble = np.asarray(self.config.num_ensemble_train)
+    else:
+      num_ensemble = np.asarray(self.config.num_ensemble_eval)
+
+    # Compute representations for each MSA sample and average.
+    embedding_module = EmbeddingsAndEvoformer(
+        self.config.embeddings_and_evoformer, self.global_config)
+    repr_shape = hk.eval_shape(
+        lambda: embedding_module(batch, is_training))
+    representations = {
+        k: jnp.zeros(v.shape, v.dtype) for (k, v) in repr_shape.items()
+    }
+
+    print(representations)
+    exit()
+    def ensemble_body(x, unused_y):
+      """"""Add into representations ensemble.""""""
+      del unused_y
+      representations, safe_key = x
+      safe_key, safe_subkey = safe_key.split()
+      representations_update = embedding_module(
+          batch, is_training, safe_key=safe_subkey)
+
+      for k in representations:
+        if k not in {'msa', 'true_msa', 'bert_mask'}:
+          representations[k] += representations_update[k] * (
+              1. / num_ensemble).astype(representations[k].dtype)
+        else:
+          representations[k] = representations_update[k]
+
+      return (representations, safe_key), None
+
+    (representations, _), _ = hk.scan(
+        ensemble_body, (representations, safe_key), None, length=num_ensemble)
+
+    self.representations = representations
+    ret = {}
+    ret['representations'] = representations
+    print(representations)
+    print(""embedding complete!"")
+    exit()
+    return ret
+
+
+class AlphaFold(hk.Module):
+  """"""AlphaFold-Multimer model with recycling.
+  """"""
+
+  def __init__(self, config, name='alphafold'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = config.global_config
+
+  def __call__(
+      self,
+      batch,
+      is_training,
+      return_representations=False,
+      safe_key=None):
+
+    c = self.config
+    impl = AlphaFoldIteration(c, self.global_config)
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+    elif isinstance(safe_key, jnp.ndarray):
+      safe_key = prng.SafeKey(safe_key)
+
+    assert isinstance(batch, dict)
+    num_res = batch['aatype'].shape[0]
+
+    def get_prev(ret):
+      new_prev = {
+          'prev_pos':
+              ret['structure_module']['final_atom_positions'],
+          'prev_msa_first_row': ret['representations']['msa_first_row'],
+          'prev_pair': ret['representations']['pair'],
+      }
+      return jax.tree_map(jax.lax.stop_gradient, new_prev)
+
+    def apply_network(prev, safe_key):
+      recycled_batch = {**batch, **prev}
+      return impl(
+          batch=recycled_batch,
+          is_training=is_training,
+          safe_key=safe_key)
+
+    prev = {}
+    emb_config = self.config.embeddings_and_evoformer
+    if emb_config.recycle_pos:
+      prev['prev_pos'] = jnp.zeros(
+          [num_res, residue_constants.atom_type_num, 3])
+    if emb_config.recycle_features:
+      prev['prev_msa_first_row'] = jnp.zeros(
+          [num_res, emb_config.msa_channel])
+      prev['prev_pair'] = jnp.zeros(
+          [num_res, num_res, emb_config.pair_channel])
+    self.config.num_recycle = 0
+    # print(""recycle: cuurr"", self.config.num_recycle)
+    if self.config.num_recycle:
+      if 'num_iter_recycling' in batch:
+        # Training time: num_iter_recycling is in batch.
+        # Value for each ensemble batch is the same, so arbitrarily taking 0-th.
+        num_iter = batch['num_iter_recycling'][0]
+
+        # Add insurance that even when ensembling, we will not run more
+        # recyclings than the model is configured to run.
+        num_iter = jnp.minimum(num_iter, c.num_recycle)
+      else:
+        # Eval mode or tests: use the maximum number of iterations.
+        num_iter = c.num_recycle
+
+      def recycle_body(i, x):
+        del i
+        prev, safe_key = x
+        safe_key1, safe_key2 = safe_key.split() if c.resample_msa_in_recycling else safe_key.duplicate()  # pylint: disable=line-too-long
+        ret = apply_network(prev=prev, safe_key=safe_key2)
+        return get_prev(ret), safe_key1
+
+      prev, safe_key = hk.fori_loop(0, num_iter, recycle_body, (prev, safe_key))
+
+    # Run extra iteration.
+    ret = apply_network(prev=prev, safe_key=safe_key)
+
+    if not return_representations:
+      del ret['representations']
+    return ret
+
+
+class EmbeddingsAndEvoformer(hk.Module):
+  """"""Embeds the input data and runs Evoformer.
+
+  Produces the MSA, single and pair representations.
+  """"""
+
+  def __init__(self, config, global_config, name='evoformer'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def _relative_encoding(self, batch):
+    """"""Add relative position encodings.
+
+    For position (i, j), the value is (i-j) clipped to [-k, k] and one-hotted.
+
+    When not using 'use_chain_relative' the residue indices are used as is, e.g.
+    for heteromers relative positions will be computed using the positions in
+    the corresponding chains.
+
+    When using 'use_chain_relative' we add an extra bin that denotes
+    'different chain'. Furthermore we also provide the relative chain index
+    (i.e. sym_id) clipped and one-hotted to the network. And an extra feature
+    which denotes whether they belong to the same chain type, i.e. it's 0 if
+    they are in different heteromer chains and 1 otherwise.
+
+    Args:
+      batch: batch.
+    Returns:
+      Feature embedding using the features as described before.
+    """"""
+    c = self.config
+    rel_feats = []
+    pos = batch['residue_index']
+    asym_id = batch['asym_id']
+    asym_id_same = jnp.equal(asym_id[:, None], asym_id[None, :])
+    offset = pos[:, None] - pos[None, :]
+
+    clipped_offset = jnp.clip(
+        offset + c.max_relative_idx, a_min=0, a_max=2 * c.max_relative_idx)
+
+    if c.use_chain_relative:
+
+      final_offset = jnp.where(asym_id_same, clipped_offset,
+                               (2 * c.max_relative_idx + 1) *
+                               jnp.ones_like(clipped_offset))
+
+      rel_pos = jax.nn.one_hot(final_offset, 2 * c.max_relative_idx + 2)
+
+      rel_feats.append(rel_pos)
+
+      entity_id = batch['entity_id']
+      entity_id_same = jnp.equal(entity_id[:, None], entity_id[None, :])
+      rel_feats.append(entity_id_same.astype(rel_pos.dtype)[..., None])
+
+      sym_id = batch['sym_id']
+      rel_sym_id = sym_id[:, None] - sym_id[None, :]
+
+      max_rel_chain = c.max_relative_chain
+
+      clipped_rel_chain = jnp.clip(
+          rel_sym_id + max_rel_chain, a_min=0, a_max=2 * max_rel_chain)
+
+      final_rel_chain = jnp.where(entity_id_same, clipped_rel_chain,
+                                  (2 * max_rel_chain + 1) *
+                                  jnp.ones_like(clipped_rel_chain))
+      rel_chain = jax.nn.one_hot(final_rel_chain, 2 * c.max_relative_chain + 2)
+
+      rel_feats.append(rel_chain)
+
+    else:
+      rel_pos = jax.nn.one_hot(clipped_offset, 2 * c.max_relative_idx + 1)
+      rel_feats.append(rel_pos)
+
+    rel_feat = jnp.concatenate(rel_feats, axis=-1)
+
+    return common_modules.Linear(
+        c.pair_channel,
+        name='position_activations')(
+            rel_feat)
+
+  def __call__(self, batch, is_training, safe_key=None):
+
+    c = self.config
+    gc = self.global_config
+
+    batch = dict(batch)
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    output = {}
+
+    batch['msa_profile'] = make_msa_profile(batch)
+    target_feat = jax.nn.one_hot(batch['aatype'], 21)
+
+    preprocess_1d = common_modules.Linear(
+        c.msa_channel, name='preprocess_1d')(
+            target_feat)
+
+
+    safe_key, sample_key, mask_key = safe_key.split(3)
+    # print(""config: "", c.num_msa, c.masked_msa)
+    # print(sample_key)
+    # print(batch)
+    # exit()
+
+    # without msa sampling
+    batch = sample_msa(sample_key, batch, c.num_msa)
+    batch = make_masked_msa(batch, mask_key, c.masked_msa)
+    (batch['cluster_profile'],
+     batch['cluster_deletion_mean']) = nearest_neighbor_clusters(batch)
+
+    msa_feat = create_msa_feat(batch)
+
+    preprocess_msa = common_modules.Linear(
+        c.msa_channel, name='preprocess_msa')(
+            msa_feat)
+    msa_activations = jnp.expand_dims(preprocess_1d, axis=0) + preprocess_msa
+    left_single = common_modules.Linear(
+        c.pair_channel, name='left_single')(
+            target_feat)
+    right_single = common_modules.Linear(
+        c.pair_channel, name='right_single')(
+            target_feat)
+    pair_activations = left_single[:, None] + right_single[None]
+    mask_2d = batch['seq_mask'][:, None] * batch['seq_mask'][None, :]
+    mask_2d = mask_2d.astype(jnp.float32)
+
+    if c.recycle_pos:
+      prev_pseudo_beta = modules.pseudo_beta_fn(
+          batch['aatype'], batch['prev_pos'], None)
+
+      dgram = modules.dgram_from_positions(
+          prev_pseudo_beta, **self.config.prev_pos)
+      pair_activations += common_modules.Linear(
+          c.pair_channel, name='prev_pos_linear')(
+              dgram)
+    if c.recycle_features:
+      prev_msa_first_row = hk.LayerNorm(
+          axis=[-1],
+          create_scale=True,
+          create_offset=True,
+          name='prev_msa_first_row_norm')(
+              batch['prev_msa_first_row'])
+      msa_activations = msa_activations.at[0].add(prev_msa_first_row)
+    #   print(""adddd: "", msa_activations)
+
+      pair_activations += hk.LayerNorm(
+          axis=[-1],
+          create_scale=True,
+          create_offset=True,
+          name='prev_pair_norm')(
+              batch['prev_pair'])
+
+    if c.max_relative_idx:
+      pair_activations += self._relative_encoding(batch)
+
+    if c.template.enabled:
+      template_module = TemplateEmbedding(c.template, gc)
+      template_batch = {
+          'template_aatype': batch['template_aatype'],
+          'template_all_atom_positions': batch['template_all_atom_positions'],
+          'template_all_atom_mask': batch['template_all_atom_mask']
+      }
+      # Construct a mask such that only intra-chain template features are
+      # computed, since all templates are for each chain individually.
+      multichain_mask = batch['asym_id'][:, None] == batch['asym_id'][None, :]
+      safe_key, safe_subkey = safe_key.split()
+      template_act = template_module(
+          query_embedding=pair_activations,
+          template_batch=template_batch,
+          padding_mask_2d=mask_2d,
+          multichain_mask_2d=multichain_mask,
+          is_training=is_training,
+          safe_key=safe_subkey)
+      pair_activations += template_act
+
+    # Extra MSA stack.
+    # (extra_msa_feat,
+    #  extra_msa_mask) = create_extra_msa_feature(batch, c.num_extra_msa)
+    # extra_msa_activations = common_modules.Linear(
+    #     c.extra_msa_channel,
+    #     name='extra_msa_activations')(
+    #         extra_msa_feat)
+    # extra_msa_mask = extra_msa_mask.astype(jnp.float32)
+
+    # extra_evoformer_input = {
+    #     'msa': extra_msa_activations,
+    #     'pair': pair_activations,
+    # }
+    # extra_masks = {'msa': extra_msa_mask, 'pair': mask_2d}
+
+    # extra_evoformer_iteration = modules.EvoformerIteration(
+    #     c.evoformer, gc, is_extra_msa=True, name='extra_msa_stack')
+
+    # def extra_evoformer_fn(x):
+    #   act, safe_key = x
+    #   safe_key, safe_subkey = safe_key.split()
+    #   extra_evoformer_output = extra_evoformer_iteration(
+    #       activations=act,
+    #       masks=extra_masks,
+    #       is_training=is_training,
+    #       safe_key=safe_subkey)
+    #   return (extra_evoformer_output, safe_key)
+
+    # if gc.use_remat:
+    #   extra_evoformer_fn = hk.remat(extra_evoformer_fn)
+
+    # safe_key, safe_subkey = safe_key.split()
+    # extra_evoformer_stack = layer_stack.layer_stack(
+    #     c.extra_msa_stack_num_block)(
+    #         extra_evoformer_fn)
+    # extra_evoformer_output, safe_key = extra_evoformer_stack(
+    #     (extra_evoformer_input, safe_subkey))
+
+    # pair_activations = extra_evoformer_output['pair']
+    # Get the size of the MSA before potentially adding templates, so we
+    # can crop out the templates later.
+    num_msa_sequences = msa_activations.shape[0]
+    # print(""num:"", num_msa_sequences)
+    evoformer_input = {
+        'msa': msa_activations,
+        'pair': pair_activations,
+    }
+    evoformer_masks = {'msa': batch['msa_mask'].astype(jnp.float32),
+                       'pair': mask_2d}
+
+    if c.template.enabled:
+      template_features, template_masks = (
+          template_embedding_1d(batch=batch, num_channel=c.msa_channel))
+      evoformer_input['msa'] = jnp.concatenate(
+          [evoformer_input['msa'], template_features], axis=0)
+      evoformer_masks['msa'] = jnp.concatenate(
+          [evoformer_masks['msa'], template_masks], axis=0)
+
+    evoformer_iteration = modules.EvoformerIteration(
+        c.evoformer, gc, is_extra_msa=False, name='evoformer_iteration')
+    def evoformer_fn(x):
+      act, safe_key = x
+      safe_key, safe_subkey = safe_key.split()
+      evoformer_output = evoformer_iteration(
+          activations=act,
+          masks=evoformer_masks,
+          is_training=is_training,
+          safe_key=safe_subkey)
+      return (evoformer_output, safe_key)
+
+    if gc.use_remat:
+      evoformer_fn = hk.remat(evoformer_fn)
+
+    safe_key, safe_subkey = safe_key.split()
+    evoformer_stack = layer_stack.layer_stack(c.evoformer_num_block)(
+        evoformer_fn)
+
+    def run_evoformer(evoformer_input):
+      evoformer_output, _ = evoformer_stack((evoformer_input, safe_subkey))
+      return evoformer_output
+
+    evoformer_output = run_evoformer(evoformer_input)
+
+    msa_activations = evoformer_output['msa']
+    pair_activations = evoformer_output['pair']
+    single_activations = common_modules.Linear(
+        c.seq_channel, name='single_activations')(
+            msa_activations[0])
+
+    output.update({
+        'single':
+            single_activations,
+        'pair':
+            pair_activations,
+        # Crop away template rows such that they are not used in MaskedMsaHead.
+        'msa':
+            msa_activations[:num_msa_sequences, :, :],
+        'msa_first_row':
+            msa_activations[0],
+    })
+    return output
+
+
+class TemplateEmbedding(hk.Module):
+  """"""Embed a set of templates.""""""
+
+  def __init__(self, config, global_config, name='template_embedding'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, query_embedding, template_batch, padding_mask_2d,
+               multichain_mask_2d, is_training,
+               safe_key=None):
+    """"""Generate an embedding for a set of templates.
+
+    Args:
+      query_embedding: [num_res, num_res, num_channel] a query tensor that will
+        be used to attend over the templates to remove the num_templates
+        dimension.
+      template_batch: A dictionary containing:
+        `template_aatype`: [num_templates, num_res] aatype for each template.
+        `template_all_atom_positions`: [num_templates, num_res, 37, 3] atom
+          positions for all templates.
+        `template_all_atom_mask`: [num_templates, num_res, 37] mask for each
+          template.
+      padding_mask_2d: [num_res, num_res] Pair mask for attention operations.
+      multichain_mask_2d: [num_res, num_res] Mask indicating which residue pairs
+        are intra-chain, used to mask out residue distance based features
+        between chains.
+      is_training: bool indicating where we are running in training mode.
+      safe_key: random key generator.
+
+    Returns:
+      An embedding of size [num_res, num_res, num_channels]
+    """"""
+    c = self.config
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    num_templates = template_batch['template_aatype'].shape[0]
+    num_res, _, query_num_channels = query_embedding.shape
+
+    # Embed each template separately.
+    template_embedder = SingleTemplateEmbedding(self.config, self.global_config)
+    def partial_template_embedder(template_aatype,
+                                  template_all_atom_positions,
+                                  template_all_atom_mask,
+                                  unsafe_key):
+      safe_key = prng.SafeKey(unsafe_key)
+      return template_embedder(query_embedding,
+                               template_aatype,
+                               template_all_atom_positions,
+                               template_all_atom_mask,
+                               padding_mask_2d,
+                               multichain_mask_2d,
+                               is_training,
+                               safe_key)
+
+    safe_key, unsafe_key = safe_key.split()
+    unsafe_keys = jax.random.split(unsafe_key._key, num_templates)
+
+    def scan_fn(carry, x):
+      return carry + partial_template_embedder(*x), None
+
+    scan_init = jnp.zeros((num_res, num_res, c.num_channels),
+                          dtype=query_embedding.dtype)
+    summed_template_embeddings, _ = hk.scan(
+        scan_fn, scan_init,
+        (template_batch['template_aatype'],
+         template_batch['template_all_atom_positions'],
+         template_batch['template_all_atom_mask'], unsafe_keys))
+
+    embedding = summed_template_embeddings / num_templates
+    embedding = jax.nn.relu(embedding)
+    embedding = common_modules.Linear(
+        query_num_channels,
+        initializer='relu',
+        name='output_linear')(embedding)
+
+    return embedding
+
+
+class SingleTemplateEmbedding(hk.Module):
+  """"""Embed a single template.""""""
+
+  def __init__(self, config, global_config, name='single_template_embedding'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, query_embedding, template_aatype,
+               template_all_atom_positions, template_all_atom_mask,
+               padding_mask_2d, multichain_mask_2d, is_training,
+               safe_key):
+    """"""Build the single template embedding graph.
+
+    Args:
+      query_embedding: (num_res, num_res, num_channels) - embedding of the
+        query sequence/msa.
+      template_aatype: [num_res] aatype for each template.
+      template_all_atom_positions: [num_res, 37, 3] atom positions for all
+        templates.
+      template_all_atom_mask: [num_res, 37] mask for each template.
+      padding_mask_2d: Padding mask (Note: this doesn't care if a template
+        exists, unlike the template_pseudo_beta_mask).
+      multichain_mask_2d: A mask indicating intra-chain residue pairs, used
+        to mask out between chain distances/features when templates are for
+        single chains.
+      is_training: Are we in training mode.
+      safe_key: Random key generator.
+
+    Returns:
+      A template embedding (num_res, num_res, num_channels).
+    """"""
+    gc = self.global_config
+    c = self.config
+    assert padding_mask_2d.dtype == query_embedding.dtype
+    dtype = query_embedding.dtype
+    num_channels = self.config.num_channels
+
+    def construct_input(query_embedding, template_aatype,
+                        template_all_atom_positions, template_all_atom_mask,
+                        multichain_mask_2d):
+
+      # Compute distogram feature for the template.
+      template_positions, pseudo_beta_mask = modules.pseudo_beta_fn(
+          template_aatype, template_all_atom_positions, template_all_atom_mask)
+      pseudo_beta_mask_2d = (pseudo_beta_mask[:, None] *
+                             pseudo_beta_mask[None, :])
+      pseudo_beta_mask_2d *= multichain_mask_2d
+      template_dgram = modules.dgram_from_positions(
+          template_positions, **self.config.dgram_features)
+      template_dgram *= pseudo_beta_mask_2d[..., None]
+      template_dgram = template_dgram.astype(dtype)
+      pseudo_beta_mask_2d = pseudo_beta_mask_2d.astype(dtype)
+      to_concat = [(template_dgram, 1), (pseudo_beta_mask_2d, 0)]
+
+      aatype = jax.nn.one_hot(template_aatype, 22, axis=-1, dtype=dtype)
+      to_concat.append((aatype[None, :, :], 1))
+      to_concat.append((aatype[:, None, :], 1))
+
+      # Compute a feature representing the normalized vector between each
+      # backbone affine - i.e. in each residues local frame, what direction are
+      # each of the other residues.
+      raw_atom_pos = template_all_atom_positions
+
+      atom_pos = geometry.Vec3Array.from_array(raw_atom_pos)
+      rigid, backbone_mask = folding_multimer.make_backbone_affine(
+          atom_pos,
+          template_all_atom_mask,
+          template_aatype)
+      points = rigid.translation
+      rigid_vec = rigid[:, None].inverse().apply_to_point(points)
+      unit_vector = rigid_vec.normalized()
+      unit_vector = [unit_vector.x, unit_vector.y, unit_vector.z]
+
+      backbone_mask_2d = backbone_mask[:, None] * backbone_mask[None, :]
+      backbone_mask_2d *= multichain_mask_2d
+      unit_vector = [x*backbone_mask_2d for x in unit_vector]
+
+      # Note that the backbone_mask takes into account C, CA and N (unlike
+      # pseudo beta mask which just needs CB) so we add both masks as features.
+      to_concat.extend([(x, 0) for x in unit_vector])
+      to_concat.append((backbone_mask_2d, 0))
+
+      query_embedding = hk.LayerNorm(
+          axis=[-1],
+          create_scale=True,
+          create_offset=True,
+          name='query_embedding_norm')(
+              query_embedding)
+      # Allow the template embedder to see the query embedding.  Note this
+      # contains the position relative feature, so this is how the network knows
+      # which residues are next to each other.
+      to_concat.append((query_embedding, 1))
+
+      act = 0
+
+      for i, (x, n_input_dims) in enumerate(to_concat):
+
+        act += common_modules.Linear(
+            num_channels,
+            num_input_dims=n_input_dims,
+            initializer='relu',
+            name=f'template_pair_embedding_{i}')(x)
+      return act
+
+    act = construct_input(query_embedding, template_aatype,
+                          template_all_atom_positions, template_all_atom_mask,
+                          multichain_mask_2d)
+
+    template_iteration = TemplateEmbeddingIteration(
+        c.template_pair_stack, gc, name='template_embedding_iteration')
+
+    def template_iteration_fn(x):
+      act, safe_key = x
+
+      safe_key, safe_subkey = safe_key.split()
+      act = template_iteration(
+          act=act,
+          pair_mask=padding_mask_2d,
+          is_training=is_training,
+          safe_key=safe_subkey)
+      return (act, safe_key)
+
+    if gc.use_remat:
+      template_iteration_fn = hk.remat(template_iteration_fn)
+
+    safe_key, safe_subkey = safe_key.split()
+    template_stack = layer_stack.layer_stack(
+        c.template_pair_stack.num_block)(
+            template_iteration_fn)
+    act, safe_key = template_stack((act, safe_subkey))
+
+    act = hk.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='output_layer_norm')(
+            act)
+    return act
+
+
+class TemplateEmbeddingIteration(hk.Module):
+  """"""Single Iteration of Template Embedding.""""""
+
+  def __init__(self, config, global_config,
+               name='template_embedding_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, act, pair_mask, is_training=True,
+               safe_key=None):
+    """"""Build a single iteration of the template embedder.
+
+    Args:
+      act: [num_res, num_res, num_channel] Input pairwise activations.
+      pair_mask: [num_res, num_res] padding mask.
+      is_training: Whether to run in training mode.
+      safe_key: Safe pseudo-random generator key.
+
+    Returns:
+      [num_res, num_res, num_channel] tensor of activations.
+    """"""
+    c = self.config
+    gc = self.global_config
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    dropout_wrapper_fn = functools.partial(
+        modules.dropout_wrapper,
+        is_training=is_training,
+        global_config=gc)
+
+    safe_key, *sub_keys = safe_key.split(20)
+    sub_keys = iter(sub_keys)
+
+    act = dropout_wrapper_fn(
+        modules.TriangleMultiplication(c.triangle_multiplication_outgoing, gc,
+                                       name='triangle_multiplication_outgoing'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    act = dropout_wrapper_fn(
+        modules.TriangleMultiplication(c.triangle_multiplication_incoming, gc,
+                                       name='triangle_multiplication_incoming'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    act = dropout_wrapper_fn(
+        modules.TriangleAttention(c.triangle_attention_starting_node, gc,
+                                  name='triangle_attention_starting_node'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    act = dropout_wrapper_fn(
+        modules.TriangleAttention(c.triangle_attention_ending_node, gc,
+                                  name='triangle_attention_ending_node'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    act = dropout_wrapper_fn(
+        modules.Transition(c.pair_transition, gc,
+                           name='pair_transition'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    return act
+
+
+def template_embedding_1d(batch, num_channel):
+  """"""Embed templates into an (num_res, num_templates, num_channels) embedding.
+
+  Args:
+    batch: A batch containing:
+      template_aatype, (num_templates, num_res) aatype for the templates.
+      template_all_atom_positions, (num_templates, num_residues, 37, 3) atom
+        positions for the templates.
+      template_all_atom_mask, (num_templates, num_residues, 37) atom mask for
+        each template.
+    num_channel: The number of channels in the output.
+
+  Returns:
+    An embedding of shape (num_templates, num_res, num_channels) and a mask of
+    shape (num_templates, num_res).
+  """"""
+
+  # Embed the templates aatypes.
+  aatype_one_hot = jax.nn.one_hot(batch['template_aatype'], 22, axis=-1)
+
+  num_templates = batch['template_aatype'].shape[0]
+  all_chi_angles = []
+  all_chi_masks = []
+  for i in range(num_templates):
+    atom_pos = geometry.Vec3Array.from_array(
+        batch['template_all_atom_positions'][i, :, :, :])
+    template_chi_angles, template_chi_mask = all_atom_multimer.compute_chi_angles(
+        atom_pos,
+        batch['template_all_atom_mask'][i, :, :],
+        batch['template_aatype'][i, :])
+    all_chi_angles.append(template_chi_angles)
+    all_chi_masks.append(template_chi_mask)
+  chi_angles = jnp.stack(all_chi_angles, axis=0)
+  chi_mask = jnp.stack(all_chi_masks, axis=0)
+
+  template_features = jnp.concatenate([
+      aatype_one_hot,
+      jnp.sin(chi_angles) * chi_mask,
+      jnp.cos(chi_angles) * chi_mask,
+      chi_mask], axis=-1)
+
+  template_mask = chi_mask[:, :, 0]
+
+  template_activations = common_modules.Linear(
+      num_channel,
+      initializer='relu',
+      name='template_single_embedding')(
+          template_features)
+  template_activations = jax.nn.relu(template_activations)
+  template_activations = common_modules.Linear(
+      num_channel,
+      initializer='relu',
+      name='template_projection')(
+          template_activations)
+  return template_activations, template_mask
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/runner/evo_preset_runner.py",".py","6034","185","import os
+import time
+import random
+import logging
+from typing import Mapping, Optional, Sequence, List
+
+import jax
+import tree
+import numpy as np
+
+from alphafold.data import pipeline_multimer, msa_pairing
+from alphafold.model import config, data
+from msa_pair.runner import model, modules_multimer
+
+logger = logging.getLogger(__file__)
+
+
+def clear_mem(device=None):
+    '''remove all data from device'''
+    backend = jax.lib.xla_bridge.get_backend(device)
+    if hasattr(backend,'live_buffers'):
+        for buf in backend.live_buffers():
+            buf.delete()
+
+
+def _is_params_transferable(old_params, next_params):
+    def _get_all_keys(params):
+        all_keys = []
+        for path in params.keys():
+            for k in params[path].keys():
+                all_keys.append(f'{path}/{k}')
+        return tuple(sorted(all_keys))
+
+    return _get_all_keys(old_params) == _get_all_keys(next_params)
+
+
+class ModelPresetRunner:
+    def __init__(
+        self,
+        database: str,
+        model_preset: str = 'multimer',
+        allow_params_transfer: bool = True,
+        cache_params: bool = True,
+        ignore_unpaired_sequences: bool = True,
+    ):
+        assert model_preset == 'multimer', 'Only supports preset multimer'
+
+        self.model_preset = model_preset
+        self.database = database
+        self.allow_params_transfer = allow_params_transfer
+        self.cache_params = cache_params
+
+        self.params_dict = {}
+        # Check model parameters
+        first_params, first_model_name = None, None
+        first_config = None
+
+        self.avail_model_names = []
+        for model_name in config.MODEL_PRESETS[model_preset]:
+            try:
+                params = data.get_model_haiku_params(
+                    model_name, self.database
+                )
+                if first_params is None:
+                    first_model_name = model_name
+                    first_params = params
+                    first_config = config.model_config(model_name)
+                elif self.allow_params_transfer:
+                    if not _is_params_transferable(first_params, params):
+                        continue
+                    if first_config != config.model_config(model_name):
+                        continue
+                self.avail_model_names.append(model_name)
+            except FileNotFoundError as e:
+                continue
+
+        assert len(self.avail_model_names) >= 1
+
+        print(f'{len(self.avail_model_names)} models are available')
+        print(f'Build RunModel {first_model_name}')
+        self.running_model = model.RunModel(first_config, first_params)
+
+        self.ignore_unpaired_sequences = ignore_unpaired_sequences
+
+    def predict(
+        self,
+        feat: Mapping[str, np.ndarray],
+        rng_seed: Optional[int] = None,
+        model_names: Optional[List[str]] = None,
+        num_predictions_per_model: int = 5,
+    ):
+        if rng_seed is not None:
+            rng = np.random.default_rng(rng_seed)
+        else:
+            rng = np.random.default_rng(random.randrange(1, 2**24))
+
+        if model_names is None:
+            model_names = self.avail_model_names
+        else:
+            model_names = [
+                model_name for model_name in model_names if model_name in 
+                self.avail_model_names
+            ]
+
+        outputs = {}
+        for model_name in model_names:
+            for pred_num in range(num_predictions_per_model):
+                seed = int(rng.integers(1, 2**24))
+                result, timing = self.run_model(
+                    feat, model_name, seed
+                )
+                outputs[f'{model_name}_{pred_num}'] = {
+                    'result': result,
+                    'timing': timing,
+                    'seed': seed,
+                }
+            logger.info(tree.map_structure(lambda x: x.shape, result))
+
+        return outputs
+
+    def run_model(
+        self,
+        feat: Mapping[str, np.ndarray],
+        model_name: str,
+        random_seed: int,
+    ):
+        t0 = time.time()
+
+        if not self.cache_params or model_name not in self.params_dict:
+            params = data.get_model_haiku_params(model_name, self.database)
+            if self.cache_params:
+                self.params_dict[model_name] = params
+        else:
+            params = self.params_dict[model_name]
+
+        if self.running_model is not None and self.allow_params_transfer:
+            logger.info(f'Transfer {model_name} params to the running model')
+            for path in params.keys():
+                self.running_model.params[path] = params[path]
+
+        logger.info(
+            f'Start prediction using {model_name} with seed {random_seed}'
+        )
+        if self.ignore_unpaired_sequences:
+            feat = self._remove_unpaired_sequences(feat)
+        result = self.running_model.predict(feat, random_seed)
+        t1 = time.time()
+
+        logger.info(
+            f'Finish prediction using {model_name} in {t1 - t0} seconds'
+        )
+        # exit()
+        timing = t1 - t0
+
+        return result, timing
+
+    def _remove_unpaired_sequences(
+        self,
+        feat: Mapping[str, np.ndarray],
+    ):
+        paired_sequence_mask = 1
+        for chain_id in np.unique(feat['asym_id']):
+            if chain_id:
+                chain_mask = feat['asym_id'] == chain_id
+                paired_sequence_mask *= np.sum(
+                    feat['msa'][:,chain_mask] != msa_pairing.MSA_GAP_IDX,
+                    axis=-1,
+                ) > 0
+        paired_sequence_mask = paired_sequence_mask.astype(bool)
+        for key, value in feat.items():
+            if key in (
+                'msa', 
+                'deletion_matrix',
+                'bert_mask',
+                'msa_mask', 
+                'cluster_bias_mask',
+            ):
+                feat[key] = value[paired_sequence_mask]
+            elif key in ('num_alignments',):
+                feat[key] = np.sum(paired_sequence_mask)
+
+        feat = pipeline_multimer.pad_msa(feat, 512)
+
+        return feat
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/runner/utils.py",".py","1673","57","import json
+from time import time
+
+from alphafold.common import protein
+from alphafold.common import confidence
+
+def move_to_tensor(feat):
+    import torch
+
+    new_feat = {}
+    for key, value in feat.items():
+        new_feat[key] = torch.from_numpy(value).cuda()
+    return new_feat
+
+def write_pdb(
+    output_pdb: str, processed_feature_dict, ret, plddt=None, is_multimer=True,
+):
+    unrelaxed_protein = protein.from_prediction(
+        features=processed_feature_dict,
+        result=ret,
+        b_factors=plddt,
+        remove_leading_feature_dimension=not is_multimer,
+    )
+
+    pdb_string = protein.to_pdb(unrelaxed_protein)
+
+    with open(output_pdb, 'wt') as fh:
+        fh.write(pdb_string)
+
+def write_ranking(output_ranking: str, ret, timing, random_seed=None):
+    stat = {
+        'confidence': float(ret['ranking_confidence']),
+        'timing': timing,
+    }
+    if 'iptm' in ret:
+        stat['iptm'] = float(ret['iptm'])
+    if 'ptm' in ret:
+        stat['ptm'] = float(ret['ptm'])
+    if random_seed is not None:
+        stat['seed'] = float(random_seed)
+
+    with open(output_ranking, 'wt') as fh:
+        json.dump(stat, fh, indent=2, sort_keys=True)
+
+def get_iptm(prediction_result, asym_id):
+    confidence_metrics = {}
+    if 'predicted_aligned_error' in prediction_result:
+        # Compute the ipTM only for the multimer model.
+        confidence_metrics['iptm'] = confidence.predicted_tm_score(
+            logits=prediction_result['predicted_aligned_error']['logits'],
+            breaks=prediction_result['predicted_aligned_error']['breaks'],
+            asym_id=asym_id,
+            interface=True,
+        )
+
+    return confidence_metrics
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/runner/modules.py",".py","71765","2114","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Modules and code used in the core part of AlphaFold.
+
+The structure generation code is in 'folding.py'.
+""""""
+import functools
+from alphafold.common import residue_constants
+from alphafold.model import all_atom
+from alphafold.model import common_modules
+from alphafold.model import folding
+from alphafold.model import layer_stack
+from alphafold.model import lddt
+from alphafold.model import mapping
+from alphafold.model import prng
+from alphafold.model import quat_affine
+from alphafold.model import utils
+import haiku as hk
+import jax
+import jax.numpy as jnp
+
+
+def softmax_cross_entropy(logits, labels):
+  """"""Computes softmax cross entropy given logits and one-hot class labels.""""""
+  loss = -jnp.sum(labels * jax.nn.log_softmax(logits), axis=-1)
+  return jnp.asarray(loss)
+
+
+def sigmoid_cross_entropy(logits, labels):
+  """"""Computes sigmoid cross entropy given logits and multiple class labels.""""""
+  log_p = jax.nn.log_sigmoid(logits)
+  # log(1 - sigmoid(x)) = log_sigmoid(-x), the latter is more numerically stable
+  log_not_p = jax.nn.log_sigmoid(-logits)
+  loss = -labels * log_p - (1. - labels) * log_not_p
+  return jnp.asarray(loss)
+
+
+def apply_dropout(*, tensor, safe_key, rate, is_training, broadcast_dim=None):
+  """"""Applies dropout to a tensor.""""""
+  if is_training and rate != 0.0:
+    shape = list(tensor.shape)
+    if broadcast_dim is not None:
+      shape[broadcast_dim] = 1
+    keep_rate = 1.0 - rate
+    keep = jax.random.bernoulli(safe_key.get(), keep_rate, shape=shape)
+    return keep * tensor / keep_rate
+  else:
+    return tensor
+
+
+def dropout_wrapper(module,
+                    input_act,
+                    mask,
+                    safe_key,
+                    global_config,
+                    output_act=None,
+                    is_training=True,
+                    **kwargs):
+  """"""Applies module + dropout + residual update.""""""
+  if output_act is None:
+    output_act = input_act
+
+  gc = global_config
+  residual = module(input_act, mask, is_training=is_training, **kwargs)
+  dropout_rate = 0.0 if gc.deterministic else module.config.dropout_rate
+
+  if module.config.shared_dropout:
+    if module.config.orientation == 'per_row':
+      broadcast_dim = 0
+    else:
+      broadcast_dim = 1
+  else:
+    broadcast_dim = None
+
+  residual = apply_dropout(tensor=residual,
+                           safe_key=safe_key,
+                           rate=dropout_rate,
+                           is_training=is_training,
+                           broadcast_dim=broadcast_dim)
+
+  new_act = output_act + residual
+
+  return new_act
+
+
+def create_extra_msa_feature(batch):
+  """"""Expand extra_msa into 1hot and concat with other extra msa features.
+
+  We do this as late as possible as the one_hot extra msa can be very large.
+
+  Arguments:
+    batch: a dictionary with the following keys:
+     * 'extra_msa': [N_extra_seq, N_res] MSA that wasn't selected as a cluster
+       centre. Note, that this is not one-hot encoded.
+     * 'extra_has_deletion': [N_extra_seq, N_res] Whether there is a deletion to
+       the left of each position in the extra MSA.
+     * 'extra_deletion_value': [N_extra_seq, N_res] The number of deletions to
+       the left of each position in the extra MSA.
+
+  Returns:
+    Concatenated tensor of extra MSA features.
+  """"""
+  # 23 = 20 amino acids + 'X' for unknown + gap + bert mask
+  msa_1hot = jax.nn.one_hot(batch['extra_msa'], 23)
+  msa_feat = [msa_1hot,
+              jnp.expand_dims(batch['extra_has_deletion'], axis=-1),
+              jnp.expand_dims(batch['extra_deletion_value'], axis=-1)]
+  return jnp.concatenate(msa_feat, axis=-1)
+
+
+class AlphaFoldIteration(hk.Module):
+  """"""A single recycling iteration of AlphaFold architecture.
+
+  Computes ensembled (averaged) representations from the provided features.
+  These representations are then passed to the various heads
+  that have been requested by the configuration file. Each head also returns a
+  loss which is combined as a weighted sum to produce the total loss.
+
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 3-22
+  """"""
+
+  def __init__(self, config, global_config, name='alphafold_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               ensembled_batch,
+               non_ensembled_batch,
+               is_training,
+               compute_loss=False,
+               ensemble_representations=False,
+               return_representations=False):
+
+    num_ensemble = jnp.asarray(ensembled_batch['seq_length'].shape[0])
+
+    if not ensemble_representations:
+      assert ensembled_batch['seq_length'].shape[0] == 1
+
+    def slice_batch(i):
+      b = {k: v[i] for k, v in ensembled_batch.items()}
+      b.update(non_ensembled_batch)
+      return b
+
+    # Compute representations for each batch element and average.
+    evoformer_module = EmbeddingsAndEvoformer(
+        self.config.embeddings_and_evoformer, self.global_config)
+    batch0 = slice_batch(0)
+    representations = evoformer_module(batch0, is_training)
+
+    # MSA representations are not ensembled so
+    # we don't pass tensor into the loop.
+    msa_representation = representations['msa']
+    del representations['msa']
+
+    # Average the representations (except MSA) over the batch dimension.
+    if ensemble_representations:
+      def body(x):
+        """"""Add one element to the representations ensemble.""""""
+        i, current_representations = x
+        feats = slice_batch(i)
+        representations_update = evoformer_module(
+            feats, is_training)
+
+        new_representations = {}
+        for k in current_representations:
+          new_representations[k] = (
+              current_representations[k] + representations_update[k])
+        return i+1, new_representations
+
+      if hk.running_init():
+        # When initializing the Haiku module, run one iteration of the
+        # while_loop to initialize the Haiku modules used in `body`.
+        _, representations = body((1, representations))
+      else:
+        _, representations = hk.while_loop(
+            lambda x: x[0] < num_ensemble,
+            body,
+            (1, representations))
+
+      for k in representations:
+        if k != 'msa':
+          representations[k] /= num_ensemble.astype(representations[k].dtype)
+
+    representations['msa'] = msa_representation
+    batch = batch0  # We are not ensembled from here on.
+
+    heads = {}
+    for head_name, head_config in sorted(self.config.heads.items()):
+      if not head_config.weight:
+        continue  # Do not instantiate zero-weight heads.
+
+      head_factory = {
+          'masked_msa': MaskedMsaHead,
+          'distogram': DistogramHead,
+          'structure_module': functools.partial(
+              folding.StructureModule, compute_loss=compute_loss),
+          'predicted_lddt': PredictedLDDTHead,
+          'predicted_aligned_error': PredictedAlignedErrorHead,
+          'experimentally_resolved': ExperimentallyResolvedHead,
+      }[head_name]
+      heads[head_name] = (head_config,
+                          head_factory(head_config, self.global_config))
+
+    total_loss = 0.
+    ret = {}
+    ret['representations'] = representations
+
+    def loss(module, head_config, ret, name, filter_ret=True):
+      if filter_ret:
+        value = ret[name]
+      else:
+        value = ret
+      loss_output = module.loss(value, batch)
+      ret[name].update(loss_output)
+      loss = head_config.weight * ret[name]['loss']
+      return loss
+
+    for name, (head_config, module) in heads.items():
+      # Skip PredictedLDDTHead and PredictedAlignedErrorHead until
+      # StructureModule is executed.
+      if name in ('predicted_lddt', 'predicted_aligned_error'):
+        continue
+      else:
+        ret[name] = module(representations, batch, is_training)
+        if 'representations' in ret[name]:
+          # Extra representations from the head. Used by the structure module
+          # to provide activations for the PredictedLDDTHead.
+          representations.update(ret[name].pop('representations'))
+      if compute_loss:
+        total_loss += loss(module, head_config, ret, name)
+
+    if self.config.heads.get('predicted_lddt.weight', 0.0):
+      # Add PredictedLDDTHead after StructureModule executes.
+      name = 'predicted_lddt'
+      # Feed all previous results to give access to structure_module result.
+      head_config, module = heads[name]
+      ret[name] = module(representations, batch, is_training)
+      if compute_loss:
+        total_loss += loss(module, head_config, ret, name, filter_ret=False)
+
+    if ('predicted_aligned_error' in self.config.heads
+        and self.config.heads.get('predicted_aligned_error.weight', 0.0)):
+      # Add PredictedAlignedErrorHead after StructureModule executes.
+      name = 'predicted_aligned_error'
+      # Feed all previous results to give access to structure_module result.
+      head_config, module = heads[name]
+      ret[name] = module(representations, batch, is_training)
+      if compute_loss:
+        total_loss += loss(module, head_config, ret, name, filter_ret=False)
+
+    if compute_loss:
+      return ret, total_loss
+    else:
+      return ret
+
+
+class AlphaFold(hk.Module):
+  """"""AlphaFold model with recycling.
+
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference""
+  """"""
+
+  def __init__(self, config, name='alphafold'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = config.global_config
+
+  def __call__(
+      self,
+      batch,
+      is_training,
+      compute_loss=False,
+      ensemble_representations=False,
+      return_representations=False):
+    """"""Run the AlphaFold model.
+
+    Arguments:
+      batch: Dictionary with inputs to the AlphaFold model.
+      is_training: Whether the system is in training or inference mode.
+      compute_loss: Whether to compute losses (requires extra features
+        to be present in the batch and knowing the true structure).
+      ensemble_representations: Whether to use ensembling of representations.
+      return_representations: Whether to also return the intermediate
+        representations.
+
+    Returns:
+      When compute_loss is True:
+        a tuple of loss and output of AlphaFoldIteration.
+      When compute_loss is False:
+        just output of AlphaFoldIteration.
+
+      The output of AlphaFoldIteration is a nested dictionary containing
+      predictions from the various heads.
+    """"""
+
+    impl = AlphaFoldIteration(self.config, self.global_config)
+    batch_size, num_residues = batch['aatype'].shape
+
+    def get_prev(ret):
+      new_prev = {
+          'prev_pos':
+              ret['structure_module']['final_atom_positions'],
+          'prev_msa_first_row': ret['representations']['msa_first_row'],
+          'prev_pair': ret['representations']['pair'],
+      }
+      return jax.tree_map(jax.lax.stop_gradient, new_prev)
+
+    def do_call(prev,
+                recycle_idx,
+                compute_loss=compute_loss):
+      if self.config.resample_msa_in_recycling:
+        num_ensemble = batch_size // (self.config.num_recycle + 1)
+        def slice_recycle_idx(x):
+          start = recycle_idx * num_ensemble
+          size = num_ensemble
+          return jax.lax.dynamic_slice_in_dim(x, start, size, axis=0)
+        ensembled_batch = jax.tree_map(slice_recycle_idx, batch)
+      else:
+        num_ensemble = batch_size
+        ensembled_batch = batch
+
+      non_ensembled_batch = jax.tree_map(lambda x: x, prev)
+
+      return impl(
+          ensembled_batch=ensembled_batch,
+          non_ensembled_batch=non_ensembled_batch,
+          is_training=is_training,
+          compute_loss=compute_loss,
+          ensemble_representations=ensemble_representations)
+
+    prev = {}
+    emb_config = self.config.embeddings_and_evoformer
+    if emb_config.recycle_pos:
+      prev['prev_pos'] = jnp.zeros(
+          [num_residues, residue_constants.atom_type_num, 3])
+    if emb_config.recycle_features:
+      prev['prev_msa_first_row'] = jnp.zeros(
+          [num_residues, emb_config.msa_channel])
+      prev['prev_pair'] = jnp.zeros(
+          [num_residues, num_residues, emb_config.pair_channel])
+
+    if self.config.num_recycle:
+      if 'num_iter_recycling' in batch:
+        # Training time: num_iter_recycling is in batch.
+        # The value for each ensemble batch is the same, so arbitrarily taking
+        # 0-th.
+        num_iter = batch['num_iter_recycling'][0]
+
+        # Add insurance that we will not run more
+        # recyclings than the model is configured to run.
+        num_iter = jnp.minimum(num_iter, self.config.num_recycle)
+      else:
+        # Eval mode or tests: use the maximum number of iterations.
+        num_iter = self.config.num_recycle
+
+      body = lambda x: (x[0] + 1,  # pylint: disable=g-long-lambda
+                        get_prev(do_call(x[1], recycle_idx=x[0],
+                                         compute_loss=False)))
+      if hk.running_init():
+        # When initializing the Haiku module, run one iteration of the
+        # while_loop to initialize the Haiku modules used in `body`.
+        _, prev = body((0, prev))
+      else:
+        _, prev = hk.while_loop(
+            lambda x: x[0] < num_iter,
+            body,
+            (0, prev))
+    else:
+      num_iter = 0
+
+    ret = do_call(prev=prev, recycle_idx=num_iter)
+    if compute_loss:
+      ret = ret[0], [ret[1]]
+
+    if not return_representations:
+      del (ret[0] if compute_loss else ret)['representations']  # pytype: disable=unsupported-operands
+    return ret
+
+
+class TemplatePairStack(hk.Module):
+  """"""Pair stack for the templates.
+
+  Jumper et al. (2021) Suppl. Alg. 16 ""TemplatePairStack""
+  """"""
+
+  def __init__(self, config, global_config, name='template_pair_stack'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, pair_act, pair_mask, is_training, safe_key=None):
+    """"""Builds TemplatePairStack module.
+
+    Arguments:
+      pair_act: Pair activations for single template, shape [N_res, N_res, c_t].
+      pair_mask: Pair mask, shape [N_res, N_res].
+      is_training: Whether the module is in training mode.
+      safe_key: Safe key object encapsulating the random number generation key.
+
+    Returns:
+      Updated pair_act, shape [N_res, N_res, c_t].
+    """"""
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    gc = self.global_config
+    c = self.config
+
+    if not c.num_block:
+      return pair_act
+
+    def block(x):
+      """"""One block of the template pair stack.""""""
+      pair_act, safe_key = x
+
+      dropout_wrapper_fn = functools.partial(
+          dropout_wrapper, is_training=is_training, global_config=gc)
+
+      safe_key, *sub_keys = safe_key.split(6)
+      sub_keys = iter(sub_keys)
+
+      pair_act = dropout_wrapper_fn(
+          TriangleAttention(c.triangle_attention_starting_node, gc,
+                            name='triangle_attention_starting_node'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+      pair_act = dropout_wrapper_fn(
+          TriangleAttention(c.triangle_attention_ending_node, gc,
+                            name='triangle_attention_ending_node'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+      pair_act = dropout_wrapper_fn(
+          TriangleMultiplication(c.triangle_multiplication_outgoing, gc,
+                                 name='triangle_multiplication_outgoing'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+      pair_act = dropout_wrapper_fn(
+          TriangleMultiplication(c.triangle_multiplication_incoming, gc,
+                                 name='triangle_multiplication_incoming'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+      pair_act = dropout_wrapper_fn(
+          Transition(c.pair_transition, gc, name='pair_transition'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+
+      return pair_act, safe_key
+
+    if gc.use_remat:
+      block = hk.remat(block)
+
+    res_stack = layer_stack.layer_stack(c.num_block)(block)
+    pair_act, safe_key = res_stack((pair_act, safe_key))
+    return pair_act
+
+
+class Transition(hk.Module):
+  """"""Transition layer.
+
+  Jumper et al. (2021) Suppl. Alg. 9 ""MSATransition""
+  Jumper et al. (2021) Suppl. Alg. 15 ""PairTransition""
+  """"""
+
+  def __init__(self, config, global_config, name='transition_block'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, act, mask, is_training=True):
+    """"""Builds Transition module.
+
+    Arguments:
+      act: A tensor of queries of size [batch_size, N_res, N_channel].
+      mask: A tensor denoting the mask of size [batch_size, N_res].
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      A float32 tensor of size [batch_size, N_res, N_channel].
+    """"""
+    _, _, nc = act.shape
+
+    num_intermediate = int(nc * self.config.num_intermediate_factor)
+    mask = jnp.expand_dims(mask, axis=-1)
+
+    act = hk.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='input_layer_norm')(
+            act)
+
+    transition_module = hk.Sequential([
+        common_modules.Linear(
+            num_intermediate,
+            initializer='relu',
+            name='transition1'), jax.nn.relu,
+        common_modules.Linear(
+            nc,
+            initializer=utils.final_init(self.global_config),
+            name='transition2')
+    ])
+
+    act = mapping.inference_subbatch(
+        transition_module,
+        self.global_config.subbatch_size,
+        batched_args=[act],
+        nonbatched_args=[],
+        low_memory=not is_training)
+
+    return act
+
+
+def glorot_uniform():
+  return hk.initializers.VarianceScaling(scale=1.0,
+                                         mode='fan_avg',
+                                         distribution='uniform')
+
+
+class Attention(hk.Module):
+  """"""Multihead attention.""""""
+
+  def __init__(self, config, global_config, output_dim, name='attention'):
+    super().__init__(name=name)
+
+    self.config = config
+    self.global_config = global_config
+    self.output_dim = output_dim
+
+  def __call__(self, q_data, m_data, bias, nonbatched_bias=None):
+    """"""Builds Attention module.
+
+    Arguments:
+      q_data: A tensor of queries, shape [batch_size, N_queries, q_channels].
+      m_data: A tensor of memories from which the keys and values are
+        projected, shape [batch_size, N_keys, m_channels].
+      bias: A bias for the attention, shape [batch_size, N_queries, N_keys].
+      nonbatched_bias: Shared bias, shape [N_queries, N_keys].
+
+    Returns:
+      A float32 tensor of shape [batch_size, N_queries, output_dim].
+    """"""
+    # Sensible default for when the config keys are missing
+    key_dim = self.config.get('key_dim', int(q_data.shape[-1]))
+    value_dim = self.config.get('value_dim', int(m_data.shape[-1]))
+    num_head = self.config.num_head
+    assert key_dim % num_head == 0
+    assert value_dim % num_head == 0
+    key_dim = key_dim // num_head
+    value_dim = value_dim // num_head
+
+    q_weights = hk.get_parameter(
+        'query_w', shape=(q_data.shape[-1], num_head, key_dim),
+        init=glorot_uniform())
+    k_weights = hk.get_parameter(
+        'key_w', shape=(m_data.shape[-1], num_head, key_dim),
+        init=glorot_uniform())
+    v_weights = hk.get_parameter(
+        'value_w', shape=(m_data.shape[-1], num_head, value_dim),
+        init=glorot_uniform())
+
+    q = jnp.einsum('bqa,ahc->bqhc', q_data, q_weights) * key_dim**(-0.5)
+    k = jnp.einsum('bka,ahc->bkhc', m_data, k_weights)
+    v = jnp.einsum('bka,ahc->bkhc', m_data, v_weights)
+    logits = jnp.einsum('bqhc,bkhc->bhqk', q, k) + bias
+    # print(""init_q: "", q_data, ""k"", k, ""logits: "", logits)
+    if nonbatched_bias is not None:
+      logits += jnp.expand_dims(nonbatched_bias, axis=0)
+    weights = jax.nn.softmax(logits)
+    weighted_avg = jnp.einsum('bhqk,bkhc->bqhc', weights, v)
+
+    if self.global_config.zero_init:
+      init = hk.initializers.Constant(0.0)
+    else:
+      init = glorot_uniform()
+
+    if self.config.gating:
+      gating_weights = hk.get_parameter(
+          'gating_w',
+          shape=(q_data.shape[-1], num_head, value_dim),
+          init=hk.initializers.Constant(0.0))
+      gating_bias = hk.get_parameter(
+          'gating_b',
+          shape=(num_head, value_dim),
+          init=hk.initializers.Constant(1.0))
+
+      gate_values = jnp.einsum('bqc, chv->bqhv', q_data,
+                               gating_weights) + gating_bias
+
+      gate_values = jax.nn.sigmoid(gate_values)
+
+      weighted_avg *= gate_values
+
+    o_weights = hk.get_parameter(
+        'output_w', shape=(num_head, value_dim, self.output_dim),
+        init=init)
+    o_bias = hk.get_parameter('output_b', shape=(self.output_dim,),
+                              init=hk.initializers.Constant(0.0))
+
+    output = jnp.einsum('bqhc,hco->bqo', weighted_avg, o_weights) + o_bias
+
+
+    # logits: [Residues, head, num_msa, num_msa]
+    return output, logits
+
+
+class GlobalAttention(hk.Module):
+  """"""Global attention.
+
+  Jumper et al. (2021) Suppl. Alg. 19 ""MSAColumnGlobalAttention"" lines 2-7
+  """"""
+
+  def __init__(self, config, global_config, output_dim, name='attention'):
+    super().__init__(name=name)
+
+    self.config = config
+    self.global_config = global_config
+    self.output_dim = output_dim
+
+  def __call__(self, q_data, m_data, q_mask):
+    """"""Builds GlobalAttention module.
+
+    Arguments:
+      q_data: A tensor of queries with size [batch_size, N_queries,
+        q_channels]
+      m_data: A tensor of memories from which the keys and values
+        projected. Size [batch_size, N_keys, m_channels]
+      q_mask: A binary mask for q_data with zeros in the padded sequence
+        elements and ones otherwise. Size [batch_size, N_queries, q_channels]
+        (or broadcastable to this shape).
+
+    Returns:
+      A float32 tensor of size [batch_size, N_queries, output_dim].
+    """"""
+    # Sensible default for when the config keys are missing
+    key_dim = self.config.get('key_dim', int(q_data.shape[-1]))
+    value_dim = self.config.get('value_dim', int(m_data.shape[-1]))
+    num_head = self.config.num_head
+    assert key_dim % num_head == 0
+    assert value_dim % num_head == 0
+    key_dim = key_dim // num_head
+    value_dim = value_dim // num_head
+
+    q_weights = hk.get_parameter(
+        'query_w', shape=(q_data.shape[-1], num_head, key_dim),
+        init=glorot_uniform())
+    k_weights = hk.get_parameter(
+        'key_w', shape=(m_data.shape[-1], key_dim),
+        init=glorot_uniform())
+    v_weights = hk.get_parameter(
+        'value_w', shape=(m_data.shape[-1], value_dim),
+        init=glorot_uniform())
+
+    v = jnp.einsum('bka,ac->bkc', m_data, v_weights)
+
+    q_avg = utils.mask_mean(q_mask, q_data, axis=1)
+
+    q = jnp.einsum('ba,ahc->bhc', q_avg, q_weights) * key_dim**(-0.5)
+    k = jnp.einsum('bka,ac->bkc', m_data, k_weights)
+    bias = (1e9 * (q_mask[:, None, :, 0] - 1.))
+    logits = jnp.einsum('bhc,bkc->bhk', q, k) + bias
+    weights = jax.nn.softmax(logits)
+    weighted_avg = jnp.einsum('bhk,bkc->bhc', weights, v)
+
+    if self.global_config.zero_init:
+      init = hk.initializers.Constant(0.0)
+    else:
+      init = glorot_uniform()
+
+    o_weights = hk.get_parameter(
+        'output_w', shape=(num_head, value_dim, self.output_dim),
+        init=init)
+    o_bias = hk.get_parameter('output_b', shape=(self.output_dim,),
+                              init=hk.initializers.Constant(0.0))
+
+    if self.config.gating:
+      gating_weights = hk.get_parameter(
+          'gating_w',
+          shape=(q_data.shape[-1], num_head, value_dim),
+          init=hk.initializers.Constant(0.0))
+      gating_bias = hk.get_parameter(
+          'gating_b',
+          shape=(num_head, value_dim),
+          init=hk.initializers.Constant(1.0))
+
+      gate_values = jnp.einsum('bqc, chv->bqhv', q_data, gating_weights)
+      gate_values = jax.nn.sigmoid(gate_values + gating_bias)
+      weighted_avg = weighted_avg[:, None] * gate_values
+      output = jnp.einsum('bqhc,hco->bqo', weighted_avg, o_weights) + o_bias
+    else:
+      output = jnp.einsum('bhc,hco->bo', weighted_avg, o_weights) + o_bias
+      output = output[:, None]
+    return output
+
+
+class MSARowAttentionWithPairBias(hk.Module):
+  """"""MSA per-row attention biased by the pair representation.
+
+  Jumper et al. (2021) Suppl. Alg. 7 ""MSARowAttentionWithPairBias""
+  """"""
+
+  def __init__(self, config, global_config,
+               name='msa_row_attention_with_pair_bias'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               msa_act,
+               msa_mask,
+               pair_act,
+               is_training=False):
+    """"""Builds MSARowAttentionWithPairBias module.
+
+    Arguments:
+      msa_act: [N_seq, N_res, c_m] MSA representation.
+      msa_mask: [N_seq, N_res] mask of non-padded regions.
+      pair_act: [N_res, N_res, c_z] pair representation.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to msa_act, shape [N_seq, N_res, c_m].
+    """"""
+    c = self.config
+
+    assert len(msa_act.shape) == 3
+    assert len(msa_mask.shape) == 2
+    assert c.orientation == 'per_row'
+
+    bias = (1e9 * (msa_mask - 1.))[:, None, None, :]
+    assert len(bias.shape) == 4
+
+    msa_act = hk.LayerNorm(
+        axis=[-1], create_scale=True, create_offset=True, name='query_norm')(
+            msa_act)
+
+    pair_act = hk.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='feat_2d_norm')(
+            pair_act)
+
+    init_factor = 1. / jnp.sqrt(int(pair_act.shape[-1]))
+    weights = hk.get_parameter(
+        'feat_2d_weights',
+        shape=(pair_act.shape[-1], c.num_head),
+        init=hk.initializers.RandomNormal(stddev=init_factor))
+    nonbatched_bias = jnp.einsum('qkc,ch->hqk', pair_act, weights)
+
+    attn_mod = Attention(
+        c, self.global_config, msa_act.shape[-1])
+    msa_act, col_attn = mapping.inference_subbatch(
+        attn_mod,
+        self.global_config.subbatch_size,
+        batched_args=[msa_act, msa_act, bias],
+        nonbatched_args=[nonbatched_bias],
+        low_memory=not is_training)
+
+    return msa_act
+
+
+class MSAColumnAttention(hk.Module):
+  """"""MSA per-column attention.
+
+  Jumper et al. (2021) Suppl. Alg. 8 ""MSAColumnAttention""
+  """"""
+
+  def __init__(self, config, global_config, name='msa_column_attention'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               msa_act,
+               msa_mask,
+               is_training=False):
+    """"""Builds MSAColumnAttention module.
+
+    Arguments:
+      msa_act: [N_seq, N_res, c_m] MSA representation.
+      msa_mask: [N_seq, N_res] mask of non-padded regions.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to msa_act, shape [N_seq, N_res, c_m]
+    """"""
+    c = self.config
+    # print(""before: "", msa_act)
+
+    assert len(msa_act.shape) == 3
+    assert len(msa_mask.shape) == 2
+    assert c.orientation == 'per_column'
+
+    msa_act = jnp.swapaxes(msa_act, -2, -3)
+    msa_mask = jnp.swapaxes(msa_mask, -1, -2)
+
+    bias = (1e9 * (msa_mask - 1.))[:, None, None, :]
+    assert len(bias.shape) == 4
+
+    msa_act = hk.LayerNorm(
+        axis=[-1], create_scale=True, create_offset=True, name='query_norm')(
+            msa_act)
+    attn_mod = Attention(
+        c, self.global_config, msa_act.shape[-1])
+    # print(""self.global_config.subbatch_size,"", self.global_config.subbatch_size)
+    self.global_config.subbatch_size = 256
+    msa_act, col_attns = mapping.inference_subbatch(
+        attn_mod,
+        self.global_config.subbatch_size,
+        batched_args=[msa_act, msa_act, bias],
+        nonbatched_args=[],
+        low_memory=not is_training)
+
+    msa_act = jnp.swapaxes(msa_act, -2, -3)
+    # print(""attn: "", attn_mod)
+    print(msa_act, col_attns)
+    exit()
+    return msa_act
+
+
+class MSAColumnGlobalAttention(hk.Module):
+  """"""MSA per-column global attention.
+
+  Jumper et al. (2021) Suppl. Alg. 19 ""MSAColumnGlobalAttention""
+  """"""
+
+  def __init__(self, config, global_config, name='msa_column_global_attention'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               msa_act,
+               msa_mask,
+               is_training=False):
+    """"""Builds MSAColumnGlobalAttention module.
+
+    Arguments:
+      msa_act: [N_seq, N_res, c_m] MSA representation.
+      msa_mask: [N_seq, N_res] mask of non-padded regions.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to msa_act, shape [N_seq, N_res, c_m].
+    """"""
+    c = self.config
+
+    assert len(msa_act.shape) == 3
+    assert len(msa_mask.shape) == 2
+    assert c.orientation == 'per_column'
+
+    msa_act = jnp.swapaxes(msa_act, -2, -3)
+    msa_mask = jnp.swapaxes(msa_mask, -1, -2)
+
+    bias = (1e9 * (msa_mask - 1.))[:, None, None, :]
+    assert len(bias.shape) == 4
+
+    msa_act = hk.LayerNorm(
+        axis=[-1], create_scale=True, create_offset=True, name='query_norm')(
+            msa_act)
+
+    attn_mod = GlobalAttention(
+        c, self.global_config, msa_act.shape[-1],
+        name='attention')
+    # [N_seq, N_res, 1]
+    msa_mask = jnp.expand_dims(msa_mask, axis=-1)
+    msa_act = mapping.inference_subbatch(
+        attn_mod,
+        self.global_config.subbatch_size,
+        batched_args=[msa_act, msa_act, msa_mask],
+        nonbatched_args=[],
+        low_memory=not is_training)
+
+    msa_act = jnp.swapaxes(msa_act, -2, -3)
+
+    return msa_act
+
+
+class TriangleAttention(hk.Module):
+  """"""Triangle Attention.
+
+  Jumper et al. (2021) Suppl. Alg. 13 ""TriangleAttentionStartingNode""
+  Jumper et al. (2021) Suppl. Alg. 14 ""TriangleAttentionEndingNode""
+  """"""
+
+  def __init__(self, config, global_config, name='triangle_attention'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, pair_act, pair_mask, is_training=False):
+    """"""Builds TriangleAttention module.
+
+    Arguments:
+      pair_act: [N_res, N_res, c_z] pair activations tensor
+      pair_mask: [N_res, N_res] mask of non-padded regions in the tensor.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to pair_act, shape [N_res, N_res, c_z].
+    """"""
+    c = self.config
+
+    assert len(pair_act.shape) == 3
+    assert len(pair_mask.shape) == 2
+    assert c.orientation in ['per_row', 'per_column']
+
+    if c.orientation == 'per_column':
+      pair_act = jnp.swapaxes(pair_act, -2, -3)
+      pair_mask = jnp.swapaxes(pair_mask, -1, -2)
+
+    bias = (1e9 * (pair_mask - 1.))[:, None, None, :]
+    assert len(bias.shape) == 4
+
+    pair_act = hk.LayerNorm(
+        axis=[-1], create_scale=True, create_offset=True, name='query_norm')(
+            pair_act)
+
+    init_factor = 1. / jnp.sqrt(int(pair_act.shape[-1]))
+    weights = hk.get_parameter(
+        'feat_2d_weights',
+        shape=(pair_act.shape[-1], c.num_head),
+        init=hk.initializers.RandomNormal(stddev=init_factor))
+    nonbatched_bias = jnp.einsum('qkc,ch->hqk', pair_act, weights)
+
+    attn_mod = Attention(
+        c, self.global_config, pair_act.shape[-1])
+    pair_act, col_attn = mapping.inference_subbatch(
+        attn_mod,
+        self.global_config.subbatch_size,
+        batched_args=[pair_act, pair_act, bias],
+        nonbatched_args=[nonbatched_bias],
+        low_memory=not is_training)
+
+    if c.orientation == 'per_column':
+      pair_act = jnp.swapaxes(pair_act, -2, -3)
+
+    return pair_act
+
+
+class MaskedMsaHead(hk.Module):
+  """"""Head to predict MSA at the masked locations.
+
+  The MaskedMsaHead employs a BERT-style objective to reconstruct a masked
+  version of the full MSA, based on a linear projection of
+  the MSA representation.
+  Jumper et al. (2021) Suppl. Sec. 1.9.9 ""Masked MSA prediction""
+  """"""
+
+  def __init__(self, config, global_config, name='masked_msa_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+    if global_config.multimer_mode:
+      self.num_output = len(residue_constants.restypes_with_x_and_gap)
+    else:
+      self.num_output = config.num_output
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds MaskedMsaHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'msa': MSA representation, shape [N_seq, N_res, c_m].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing:
+        * 'logits': logits of shape [N_seq, N_res, N_aatype] with
+            (unnormalized) log probabilies of predicted aatype at position.
+    """"""
+    del batch
+    logits = common_modules.Linear(
+        self.num_output,
+        initializer=utils.final_init(self.global_config),
+        name='logits')(
+            representations['msa'])
+    return dict(logits=logits)
+
+  def loss(self, value, batch):
+    errors = softmax_cross_entropy(
+        labels=jax.nn.one_hot(batch['true_msa'], num_classes=self.num_output),
+        logits=value['logits'])
+    loss = (jnp.sum(errors * batch['bert_mask'], axis=(-2, -1)) /
+            (1e-8 + jnp.sum(batch['bert_mask'], axis=(-2, -1))))
+    return {'loss': loss}
+
+
+class PredictedLDDTHead(hk.Module):
+  """"""Head to predict the per-residue LDDT to be used as a confidence measure.
+
+  Jumper et al. (2021) Suppl. Sec. 1.9.6 ""Model confidence prediction (pLDDT)""
+  Jumper et al. (2021) Suppl. Alg. 29 ""predictPerResidueLDDT_Ca""
+  """"""
+
+  def __init__(self, config, global_config, name='predicted_lddt_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds PredictedLDDTHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'structure_module': Single representation from the structure module,
+             shape [N_res, c_s].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing :
+        * 'logits': logits of shape [N_res, N_bins] with
+            (unnormalized) log probabilies of binned predicted lDDT.
+    """"""
+    act = representations['structure_module']
+
+    act = hk.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='input_layer_norm')(
+            act)
+
+    act = common_modules.Linear(
+        self.config.num_channels,
+        initializer='relu',
+        name='act_0')(
+            act)
+    act = jax.nn.relu(act)
+
+    act = common_modules.Linear(
+        self.config.num_channels,
+        initializer='relu',
+        name='act_1')(
+            act)
+    act = jax.nn.relu(act)
+
+    logits = common_modules.Linear(
+        self.config.num_bins,
+        initializer=utils.final_init(self.global_config),
+        name='logits')(
+            act)
+    # Shape (batch_size, num_res, num_bins)
+    return dict(logits=logits)
+
+  def loss(self, value, batch):
+    # Shape (num_res, 37, 3)
+    pred_all_atom_pos = value['structure_module']['final_atom_positions']
+    # Shape (num_res, 37, 3)
+    true_all_atom_pos = batch['all_atom_positions']
+    # Shape (num_res, 37)
+    all_atom_mask = batch['all_atom_mask']
+
+    # Shape (num_res,)
+    lddt_ca = lddt.lddt(
+        # Shape (batch_size, num_res, 3)
+        predicted_points=pred_all_atom_pos[None, :, 1, :],
+        # Shape (batch_size, num_res, 3)
+        true_points=true_all_atom_pos[None, :, 1, :],
+        # Shape (batch_size, num_res, 1)
+        true_points_mask=all_atom_mask[None, :, 1:2].astype(jnp.float32),
+        cutoff=15.,
+        per_residue=True)
+    lddt_ca = jax.lax.stop_gradient(lddt_ca)
+
+    num_bins = self.config.num_bins
+    bin_index = jnp.floor(lddt_ca * num_bins).astype(jnp.int32)
+
+    # protect against out of range for lddt_ca == 1
+    bin_index = jnp.minimum(bin_index, num_bins - 1)
+    lddt_ca_one_hot = jax.nn.one_hot(bin_index, num_classes=num_bins)
+
+    # Shape (num_res, num_channel)
+    logits = value['predicted_lddt']['logits']
+    errors = softmax_cross_entropy(labels=lddt_ca_one_hot, logits=logits)
+
+    # Shape (num_res,)
+    mask_ca = all_atom_mask[:, residue_constants.atom_order['CA']]
+    mask_ca = mask_ca.astype(jnp.float32)
+    loss = jnp.sum(errors * mask_ca) / (jnp.sum(mask_ca) + 1e-8)
+
+    if self.config.filter_by_resolution:
+      # NMR & distillation have resolution = 0
+      loss *= ((batch['resolution'] >= self.config.min_resolution)
+               & (batch['resolution'] <= self.config.max_resolution)).astype(
+                   jnp.float32)
+
+    output = {'loss': loss}
+    return output
+
+
+class PredictedAlignedErrorHead(hk.Module):
+  """"""Head to predict the distance errors in the backbone alignment frames.
+
+  Can be used to compute predicted TM-Score.
+  Jumper et al. (2021) Suppl. Sec. 1.9.7 ""TM-score prediction""
+  """"""
+
+  def __init__(self, config, global_config,
+               name='predicted_aligned_error_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds PredictedAlignedErrorHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'pair': pair representation, shape [N_res, N_res, c_z].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing:
+        * logits: logits for aligned error, shape [N_res, N_res, N_bins].
+        * bin_breaks: array containing bin breaks, shape [N_bins - 1].
+    """"""
+
+    act = representations['pair']
+
+    # Shape (num_res, num_res, num_bins)
+    logits = common_modules.Linear(
+        self.config.num_bins,
+        initializer=utils.final_init(self.global_config),
+        name='logits')(act)
+    # Shape (num_bins,)
+    breaks = jnp.linspace(
+        0., self.config.max_error_bin, self.config.num_bins - 1)
+    return dict(logits=logits, breaks=breaks)
+
+  def loss(self, value, batch):
+    # Shape (num_res, 7)
+    predicted_affine = quat_affine.QuatAffine.from_tensor(
+        value['structure_module']['final_affines'])
+    # Shape (num_res, 7)
+    true_affine = quat_affine.QuatAffine.from_tensor(
+        batch['backbone_affine_tensor'])
+    # Shape (num_res)
+    mask = batch['backbone_affine_mask']
+    # Shape (num_res, num_res)
+    square_mask = mask[:, None] * mask[None, :]
+    num_bins = self.config.num_bins
+    # (1, num_bins - 1)
+    breaks = value['predicted_aligned_error']['breaks']
+    # (1, num_bins)
+    logits = value['predicted_aligned_error']['logits']
+
+    # Compute the squared error for each alignment.
+    def _local_frame_points(affine):
+      points = [jnp.expand_dims(x, axis=-2) for x in affine.translation]
+      return affine.invert_point(points, extra_dims=1)
+    error_dist2_xyz = [
+        jnp.square(a - b)
+        for a, b in zip(_local_frame_points(predicted_affine),
+                        _local_frame_points(true_affine))]
+    error_dist2 = sum(error_dist2_xyz)
+    # Shape (num_res, num_res)
+    # First num_res are alignment frames, second num_res are the residues.
+    error_dist2 = jax.lax.stop_gradient(error_dist2)
+
+    sq_breaks = jnp.square(breaks)
+    true_bins = jnp.sum((
+        error_dist2[..., None] > sq_breaks).astype(jnp.int32), axis=-1)
+
+    errors = softmax_cross_entropy(
+        labels=jax.nn.one_hot(true_bins, num_bins, axis=-1), logits=logits)
+
+    loss = (jnp.sum(errors * square_mask, axis=(-2, -1)) /
+            (1e-8 + jnp.sum(square_mask, axis=(-2, -1))))
+
+    if self.config.filter_by_resolution:
+      # NMR & distillation have resolution = 0
+      loss *= ((batch['resolution'] >= self.config.min_resolution)
+               & (batch['resolution'] <= self.config.max_resolution)).astype(
+                   jnp.float32)
+
+    output = {'loss': loss}
+    return output
+
+
+class ExperimentallyResolvedHead(hk.Module):
+  """"""Predicts if an atom is experimentally resolved in a high-res structure.
+
+  Only trained on high-resolution X-ray crystals & cryo-EM.
+  Jumper et al. (2021) Suppl. Sec. 1.9.10 '""Experimentally resolved"" prediction'
+  """"""
+
+  def __init__(self, config, global_config,
+               name='experimentally_resolved_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds ExperimentallyResolvedHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'single': Single representation, shape [N_res, c_s].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing:
+        * 'logits': logits of shape [N_res, 37],
+            log probability that an atom is resolved in atom37 representation,
+            can be converted to probability by applying sigmoid.
+    """"""
+    logits = common_modules.Linear(
+        37,  # atom_exists.shape[-1]
+        initializer=utils.final_init(self.global_config),
+        name='logits')(representations['single'])
+    return dict(logits=logits)
+
+  def loss(self, value, batch):
+    logits = value['logits']
+    assert len(logits.shape) == 2
+
+    # Does the atom appear in the amino acid?
+    atom_exists = batch['atom37_atom_exists']
+    # Is the atom resolved in the experiment? Subset of atom_exists,
+    # *except for OXT*
+    all_atom_mask = batch['all_atom_mask'].astype(jnp.float32)
+
+    xent = sigmoid_cross_entropy(labels=all_atom_mask, logits=logits)
+    loss = jnp.sum(xent * atom_exists) / (1e-8 + jnp.sum(atom_exists))
+
+    if self.config.filter_by_resolution:
+      # NMR & distillation examples have resolution = 0.
+      loss *= ((batch['resolution'] >= self.config.min_resolution)
+               & (batch['resolution'] <= self.config.max_resolution)).astype(
+                   jnp.float32)
+
+    output = {'loss': loss}
+    return output
+
+
+class TriangleMultiplication(hk.Module):
+  """"""Triangle multiplication layer (""outgoing"" or ""incoming"").
+
+  Jumper et al. (2021) Suppl. Alg. 11 ""TriangleMultiplicationOutgoing""
+  Jumper et al. (2021) Suppl. Alg. 12 ""TriangleMultiplicationIncoming""
+  """"""
+
+  def __init__(self, config, global_config, name='triangle_multiplication'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, act, mask, is_training=True):
+    """"""Builds TriangleMultiplication module.
+
+    Arguments:
+      act: Pair activations, shape [N_res, N_res, c_z]
+      mask: Pair mask, shape [N_res, N_res].
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Outputs, same shape/type as act.
+    """"""
+    del is_training
+    c = self.config
+    gc = self.global_config
+
+    mask = mask[..., None]
+
+    act = hk.LayerNorm(axis=[-1], create_scale=True, create_offset=True,
+                       name='layer_norm_input')(act)
+    input_act = act
+
+    left_projection = common_modules.Linear(
+        c.num_intermediate_channel,
+        name='left_projection')
+    left_proj_act = mask * left_projection(act)
+
+    right_projection = common_modules.Linear(
+        c.num_intermediate_channel,
+        name='right_projection')
+    right_proj_act = mask * right_projection(act)
+
+    left_gate_values = jax.nn.sigmoid(common_modules.Linear(
+        c.num_intermediate_channel,
+        bias_init=1.,
+        initializer=utils.final_init(gc),
+        name='left_gate')(act))
+
+    right_gate_values = jax.nn.sigmoid(common_modules.Linear(
+        c.num_intermediate_channel,
+        bias_init=1.,
+        initializer=utils.final_init(gc),
+        name='right_gate')(act))
+
+    left_proj_act *= left_gate_values
+    right_proj_act *= right_gate_values
+
+    # ""Outgoing"" edges equation: 'ikc,jkc->ijc'
+    # ""Incoming"" edges equation: 'kjc,kic->ijc'
+    # Note on the Suppl. Alg. 11 & 12 notation:
+    # For the ""outgoing"" edges, a = left_proj_act and b = right_proj_act
+    # For the ""incoming"" edges, it's swapped:
+    #   b = left_proj_act and a = right_proj_act
+    act = jnp.einsum(c.equation, left_proj_act, right_proj_act)
+
+    act = hk.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='center_layer_norm')(
+            act)
+
+    output_channel = int(input_act.shape[-1])
+
+    act = common_modules.Linear(
+        output_channel,
+        initializer=utils.final_init(gc),
+        name='output_projection')(act)
+
+    gate_values = jax.nn.sigmoid(common_modules.Linear(
+        output_channel,
+        bias_init=1.,
+        initializer=utils.final_init(gc),
+        name='gating_linear')(input_act))
+    act *= gate_values
+
+    return act
+
+
+class DistogramHead(hk.Module):
+  """"""Head to predict a distogram.
+
+  Jumper et al. (2021) Suppl. Sec. 1.9.8 ""Distogram prediction""
+  """"""
+
+  def __init__(self, config, global_config, name='distogram_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds DistogramHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'pair': pair representation, shape [N_res, N_res, c_z].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing:
+        * logits: logits for distogram, shape [N_res, N_res, N_bins].
+        * bin_breaks: array containing bin breaks, shape [N_bins - 1,].
+    """"""
+    half_logits = common_modules.Linear(
+        self.config.num_bins,
+        initializer=utils.final_init(self.global_config),
+        name='half_logits')(
+            representations['pair'])
+
+    logits = half_logits + jnp.swapaxes(half_logits, -2, -3)
+    breaks = jnp.linspace(self.config.first_break, self.config.last_break,
+                          self.config.num_bins - 1)
+
+    return dict(logits=logits, bin_edges=breaks)
+
+  def loss(self, value, batch):
+    return _distogram_log_loss(value['logits'], value['bin_edges'],
+                               batch, self.config.num_bins)
+
+
+def _distogram_log_loss(logits, bin_edges, batch, num_bins):
+  """"""Log loss of a distogram.""""""
+
+  assert len(logits.shape) == 3
+  positions = batch['pseudo_beta']
+  mask = batch['pseudo_beta_mask']
+
+  assert positions.shape[-1] == 3
+
+  sq_breaks = jnp.square(bin_edges)
+
+  dist2 = jnp.sum(
+      jnp.square(
+          jnp.expand_dims(positions, axis=-2) -
+          jnp.expand_dims(positions, axis=-3)),
+      axis=-1,
+      keepdims=True)
+
+  true_bins = jnp.sum(dist2 > sq_breaks, axis=-1)
+
+  errors = softmax_cross_entropy(
+      labels=jax.nn.one_hot(true_bins, num_bins), logits=logits)
+
+  square_mask = jnp.expand_dims(mask, axis=-2) * jnp.expand_dims(mask, axis=-1)
+
+  avg_error = (
+      jnp.sum(errors * square_mask, axis=(-2, -1)) /
+      (1e-6 + jnp.sum(square_mask, axis=(-2, -1))))
+  dist2 = dist2[..., 0]
+  return dict(loss=avg_error, true_dist=jnp.sqrt(1e-6 + dist2))
+
+
+class OuterProductMean(hk.Module):
+  """"""Computes mean outer product.
+
+  Jumper et al. (2021) Suppl. Alg. 10 ""OuterProductMean""
+  """"""
+
+  def __init__(self,
+               config,
+               global_config,
+               num_output_channel,
+               name='outer_product_mean'):
+    super().__init__(name=name)
+    self.global_config = global_config
+    self.config = config
+    self.num_output_channel = num_output_channel
+
+  def __call__(self, act, mask, is_training=True):
+    """"""Builds OuterProductMean module.
+
+    Arguments:
+      act: MSA representation, shape [N_seq, N_res, c_m].
+      mask: MSA mask, shape [N_seq, N_res].
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to pair representation, shape [N_res, N_res, c_z].
+    """"""
+    gc = self.global_config
+    c = self.config
+
+    mask = mask[..., None]
+    act = hk.LayerNorm([-1], True, True, name='layer_norm_input')(act)
+
+    left_act = mask * common_modules.Linear(
+        c.num_outer_channel,
+        initializer='linear',
+        name='left_projection')(
+            act)
+
+    right_act = mask * common_modules.Linear(
+        c.num_outer_channel,
+        initializer='linear',
+        name='right_projection')(
+            act)
+
+    if gc.zero_init:
+      init_w = hk.initializers.Constant(0.0)
+    else:
+      init_w = hk.initializers.VarianceScaling(scale=2., mode='fan_in')
+
+    output_w = hk.get_parameter(
+        'output_w',
+        shape=(c.num_outer_channel, c.num_outer_channel,
+               self.num_output_channel),
+        init=init_w)
+    output_b = hk.get_parameter(
+        'output_b', shape=(self.num_output_channel,),
+        init=hk.initializers.Constant(0.0))
+
+    def compute_chunk(left_act):
+      # This is equivalent to
+      #
+      # act = jnp.einsum('abc,ade->dceb', left_act, right_act)
+      # act = jnp.einsum('dceb,cef->bdf', act, output_w) + output_b
+      #
+      # but faster.
+      left_act = jnp.transpose(left_act, [0, 2, 1])
+      act = jnp.einsum('acb,ade->dceb', left_act, right_act)
+      act = jnp.einsum('dceb,cef->dbf', act, output_w) + output_b
+      return jnp.transpose(act, [1, 0, 2])
+
+    act = mapping.inference_subbatch(
+        compute_chunk,
+        c.chunk_size,
+        batched_args=[left_act],
+        nonbatched_args=[],
+        low_memory=True,
+        input_subbatch_dim=1,
+        output_subbatch_dim=0)
+
+    epsilon = 1e-3
+    norm = jnp.einsum('abc,adc->bdc', mask, mask)
+    act /= epsilon + norm
+
+    return act
+
+
+def dgram_from_positions(positions, num_bins, min_bin, max_bin):
+  """"""Compute distogram from amino acid positions.
+
+  Arguments:
+    positions: [N_res, 3] Position coordinates.
+    num_bins: The number of bins in the distogram.
+    min_bin: The left edge of the first bin.
+    max_bin: The left edge of the final bin. The final bin catches
+        everything larger than `max_bin`.
+
+  Returns:
+    Distogram with the specified number of bins.
+  """"""
+
+  def squared_difference(x, y):
+    return jnp.square(x - y)
+
+  lower_breaks = jnp.linspace(min_bin, max_bin, num_bins)
+  lower_breaks = jnp.square(lower_breaks)
+  upper_breaks = jnp.concatenate([lower_breaks[1:],
+                                  jnp.array([1e8], dtype=jnp.float32)], axis=-1)
+  dist2 = jnp.sum(
+      squared_difference(
+          jnp.expand_dims(positions, axis=-2),
+          jnp.expand_dims(positions, axis=-3)),
+      axis=-1, keepdims=True)
+
+  dgram = ((dist2 > lower_breaks).astype(jnp.float32) *
+           (dist2 < upper_breaks).astype(jnp.float32))
+  return dgram
+
+
+def pseudo_beta_fn(aatype, all_atom_positions, all_atom_masks):
+  """"""Create pseudo beta features.""""""
+
+  is_gly = jnp.equal(aatype, residue_constants.restype_order['G'])
+  ca_idx = residue_constants.atom_order['CA']
+  cb_idx = residue_constants.atom_order['CB']
+  pseudo_beta = jnp.where(
+      jnp.tile(is_gly[..., None], [1] * len(is_gly.shape) + [3]),
+      all_atom_positions[..., ca_idx, :],
+      all_atom_positions[..., cb_idx, :])
+
+  if all_atom_masks is not None:
+    pseudo_beta_mask = jnp.where(
+        is_gly, all_atom_masks[..., ca_idx], all_atom_masks[..., cb_idx])
+    pseudo_beta_mask = pseudo_beta_mask.astype(jnp.float32)
+    return pseudo_beta, pseudo_beta_mask
+  else:
+    return pseudo_beta
+
+
+class EvoformerIteration(hk.Module):
+  """"""Single iteration (block) of Evoformer stack.
+
+  Jumper et al. (2021) Suppl. Alg. 6 ""EvoformerStack"" lines 2-10
+  """"""
+
+  def __init__(self, config, global_config, is_extra_msa,
+               name='evoformer_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+    self.is_extra_msa = is_extra_msa
+
+  def __call__(self, activations, masks, is_training=True, safe_key=None):
+    """"""Builds EvoformerIteration module.
+
+    Arguments:
+      activations: Dictionary containing activations:
+        * 'msa': MSA activations, shape [N_seq, N_res, c_m].
+        * 'pair': pair activations, shape [N_res, N_res, c_z].
+      masks: Dictionary of masks:
+        * 'msa': MSA mask, shape [N_seq, N_res].
+        * 'pair': pair mask, shape [N_res, N_res].
+      is_training: Whether the module is in training mode.
+      safe_key: prng.SafeKey encapsulating rng key.
+
+    Returns:
+      Outputs, same shape/type as act.
+    """"""
+    c = self.config
+    gc = self.global_config
+
+    msa_act, pair_act = activations['msa'], activations['pair']
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    msa_mask, pair_mask = masks['msa'], masks['pair']
+
+    dropout_wrapper_fn = functools.partial(
+        dropout_wrapper,
+        is_training=is_training,
+        global_config=gc)
+
+    safe_key, *sub_keys = safe_key.split(10)
+    sub_keys = iter(sub_keys)
+
+    outer_module = OuterProductMean(
+        config=c.outer_product_mean,
+        global_config=self.global_config,
+        num_output_channel=int(pair_act.shape[-1]),
+        name='outer_product_mean')
+    if c.outer_product_mean.first:
+      pair_act = dropout_wrapper_fn(
+          outer_module,
+          msa_act,
+          msa_mask,
+          safe_key=next(sub_keys),
+          output_act=pair_act)
+
+    msa_act = dropout_wrapper_fn(
+        MSARowAttentionWithPairBias(
+            c.msa_row_attention_with_pair_bias, gc,
+            name='msa_row_attention_with_pair_bias'),
+        msa_act,
+        msa_mask,
+        safe_key=next(sub_keys),
+        pair_act=pair_act)
+    # print(""self.is_extra_msa:"", self.is_extra_msa)
+    if not self.is_extra_msa:
+      attn_mod = MSAColumnAttention(
+          c.msa_column_attention, gc, name='msa_column_attention')
+    else:
+      attn_mod = MSAColumnGlobalAttention(
+          c.msa_column_attention, gc, name='msa_column_global_attention')
+    # msa_act = dropout_wrapper_fn(
+    #     attn_mod,
+    #     msa_act,
+    #     msa_mask,
+    #     safe_key=next(sub_keys))
+    msa_act, col_attn = attn_mod(msa_act, msa_mask)
+    print(msa_act, col_attn)
+    exit()
+
+    msa_act = dropout_wrapper_fn(
+        Transition(c.msa_transition, gc, name='msa_transition'),
+        msa_act,
+        msa_mask,
+        safe_key=next(sub_keys))
+
+    if not c.outer_product_mean.first:
+      pair_act = dropout_wrapper_fn(
+          outer_module,
+          msa_act,
+          msa_mask,
+          safe_key=next(sub_keys),
+          output_act=pair_act)
+
+    pair_act = dropout_wrapper_fn(
+        TriangleMultiplication(c.triangle_multiplication_outgoing, gc,
+                               name='triangle_multiplication_outgoing'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+    pair_act = dropout_wrapper_fn(
+        TriangleMultiplication(c.triangle_multiplication_incoming, gc,
+                               name='triangle_multiplication_incoming'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    pair_act = dropout_wrapper_fn(
+        TriangleAttention(c.triangle_attention_starting_node, gc,
+                          name='triangle_attention_starting_node'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+    pair_act = dropout_wrapper_fn(
+        TriangleAttention(c.triangle_attention_ending_node, gc,
+                          name='triangle_attention_ending_node'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    pair_act = dropout_wrapper_fn(
+        Transition(c.pair_transition, gc, name='pair_transition'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    return {'msa': msa_act, 'pair': pair_act}
+
+
+class EmbeddingsAndEvoformer(hk.Module):
+  """"""Embeds the input data and runs Evoformer.
+
+  Produces the MSA, single and pair representations.
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 5-18
+  """"""
+
+  def __init__(self, config, global_config, name='evoformer'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, batch, is_training, safe_key=None):
+
+    c = self.config
+    gc = self.global_config
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    # Embed clustered MSA.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 5
+    # Jumper et al. (2021) Suppl. Alg. 3 ""InputEmbedder""
+    preprocess_1d = common_modules.Linear(
+        c.msa_channel, name='preprocess_1d')(
+            batch['target_feat'])
+
+    preprocess_msa = common_modules.Linear(
+        c.msa_channel, name='preprocess_msa')(
+            batch['msa_feat'])
+
+    msa_activations = jnp.expand_dims(preprocess_1d, axis=0) + preprocess_msa
+
+    left_single = common_modules.Linear(
+        c.pair_channel, name='left_single')(
+            batch['target_feat'])
+    right_single = common_modules.Linear(
+        c.pair_channel, name='right_single')(
+            batch['target_feat'])
+    pair_activations = left_single[:, None] + right_single[None]
+    mask_2d = batch['seq_mask'][:, None] * batch['seq_mask'][None, :]
+
+    # Inject previous outputs for recycling.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 6
+    # Jumper et al. (2021) Suppl. Alg. 32 ""RecyclingEmbedder""
+    if c.recycle_pos:
+      prev_pseudo_beta = pseudo_beta_fn(
+          batch['aatype'], batch['prev_pos'], None)
+      dgram = dgram_from_positions(prev_pseudo_beta, **self.config.prev_pos)
+      pair_activations += common_modules.Linear(
+          c.pair_channel, name='prev_pos_linear')(
+              dgram)
+
+    if c.recycle_features:
+      prev_msa_first_row = hk.LayerNorm(
+          axis=[-1],
+          create_scale=True,
+          create_offset=True,
+          name='prev_msa_first_row_norm')(
+              batch['prev_msa_first_row'])
+      msa_activations = msa_activations.at[0].add(prev_msa_first_row)
+
+      pair_activations += hk.LayerNorm(
+          axis=[-1],
+          create_scale=True,
+          create_offset=True,
+          name='prev_pair_norm')(
+              batch['prev_pair'])
+
+    # Relative position encoding.
+    # Jumper et al. (2021) Suppl. Alg. 4 ""relpos""
+    # Jumper et al. (2021) Suppl. Alg. 5 ""one_hot""
+    if c.max_relative_feature:
+      # Add one-hot-encoded clipped residue distances to the pair activations.
+      pos = batch['residue_index']
+      offset = pos[:, None] - pos[None, :]
+      rel_pos = jax.nn.one_hot(
+          jnp.clip(
+              offset + c.max_relative_feature,
+              a_min=0,
+              a_max=2 * c.max_relative_feature),
+          2 * c.max_relative_feature + 1)
+      pair_activations += common_modules.Linear(
+          c.pair_channel, name='pair_activiations')(
+              rel_pos)
+
+    # Embed templates into the pair activations.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 9-13
+    if c.template.enabled:
+      template_batch = {k: batch[k] for k in batch if k.startswith('template_')}
+      template_pair_representation = TemplateEmbedding(c.template, gc)(
+          pair_activations,
+          template_batch,
+          mask_2d,
+          is_training=is_training)
+
+      pair_activations += template_pair_representation
+
+    # Embed extra MSA features.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 14-16
+    extra_msa_feat = create_extra_msa_feature(batch)
+    extra_msa_activations = common_modules.Linear(
+        c.extra_msa_channel,
+        name='extra_msa_activations')(
+            extra_msa_feat)
+
+    # Extra MSA Stack.
+    # Jumper et al. (2021) Suppl. Alg. 18 ""ExtraMsaStack""
+    extra_msa_stack_input = {
+        'msa': extra_msa_activations,
+        'pair': pair_activations,
+    }
+
+    extra_msa_stack_iteration = EvoformerIteration(
+        c.evoformer, gc, is_extra_msa=True, name='extra_msa_stack')
+
+    def extra_msa_stack_fn(x):
+      act, safe_key = x
+      safe_key, safe_subkey = safe_key.split()
+      extra_evoformer_output = extra_msa_stack_iteration(
+          activations=act,
+          masks={
+              'msa': batch['extra_msa_mask'],
+              'pair': mask_2d
+          },
+          is_training=is_training,
+          safe_key=safe_subkey)
+      return (extra_evoformer_output, safe_key)
+
+    if gc.use_remat:
+      extra_msa_stack_fn = hk.remat(extra_msa_stack_fn)
+
+    extra_msa_stack = layer_stack.layer_stack(
+        c.extra_msa_stack_num_block)(
+            extra_msa_stack_fn)
+    extra_msa_output, safe_key = extra_msa_stack(
+        (extra_msa_stack_input, safe_key))
+
+    pair_activations = extra_msa_output['pair']
+
+    evoformer_input = {
+        'msa': msa_activations,
+        'pair': pair_activations,
+    }
+
+    evoformer_masks = {'msa': batch['msa_mask'], 'pair': mask_2d}
+
+    # Append num_templ rows to msa_activations with template embeddings.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 7-8
+    if c.template.enabled and c.template.embed_torsion_angles:
+      num_templ, num_res = batch['template_aatype'].shape
+
+      # Embed the templates aatypes.
+      aatype_one_hot = jax.nn.one_hot(batch['template_aatype'], 22, axis=-1)
+
+      # Embed the templates aatype, torsion angles and masks.
+      # Shape (templates, residues, msa_channels)
+      ret = all_atom.atom37_to_torsion_angles(
+          aatype=batch['template_aatype'],
+          all_atom_pos=batch['template_all_atom_positions'],
+          all_atom_mask=batch['template_all_atom_masks'],
+          # Ensure consistent behaviour during testing:
+          placeholder_for_undefined=not gc.zero_init)
+
+      template_features = jnp.concatenate([
+          aatype_one_hot,
+          jnp.reshape(
+              ret['torsion_angles_sin_cos'], [num_templ, num_res, 14]),
+          jnp.reshape(
+              ret['alt_torsion_angles_sin_cos'], [num_templ, num_res, 14]),
+          ret['torsion_angles_mask']], axis=-1)
+
+      template_activations = common_modules.Linear(
+          c.msa_channel,
+          initializer='relu',
+          name='template_single_embedding')(
+              template_features)
+      template_activations = jax.nn.relu(template_activations)
+      template_activations = common_modules.Linear(
+          c.msa_channel,
+          initializer='relu',
+          name='template_projection')(
+              template_activations)
+
+      # Concatenate the templates to the msa.
+      evoformer_input['msa'] = jnp.concatenate(
+          [evoformer_input['msa'], template_activations], axis=0)
+      # Concatenate templates masks to the msa masks.
+      # Use mask from the psi angle, as it only depends on the backbone atoms
+      # from a single residue.
+      torsion_angle_mask = ret['torsion_angles_mask'][:, :, 2]
+      torsion_angle_mask = torsion_angle_mask.astype(
+          evoformer_masks['msa'].dtype)
+      evoformer_masks['msa'] = jnp.concatenate(
+          [evoformer_masks['msa'], torsion_angle_mask], axis=0)
+
+    # Main trunk of the network
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 17-18
+    evoformer_iteration = EvoformerIteration(
+        c.evoformer, gc, is_extra_msa=False, name='evoformer_iteration')
+
+    def evoformer_fn(x):
+      act, safe_key = x
+      safe_key, safe_subkey = safe_key.split()
+      evoformer_output = evoformer_iteration(
+          activations=act,
+          masks=evoformer_masks,
+          is_training=is_training,
+          safe_key=safe_subkey)
+      return (evoformer_output, safe_key)
+
+    if gc.use_remat:
+      evoformer_fn = hk.remat(evoformer_fn)
+
+    evoformer_stack = layer_stack.layer_stack(c.evoformer_num_block)(
+        evoformer_fn)
+    evoformer_output, safe_key = evoformer_stack(
+        (evoformer_input, safe_key))
+
+    msa_activations = evoformer_output['msa']
+    pair_activations = evoformer_output['pair']
+
+    single_activations = common_modules.Linear(
+        c.seq_channel, name='single_activations')(
+            msa_activations[0])
+
+    num_sequences = batch['msa_feat'].shape[0]
+    output = {
+        'single': single_activations,
+        'pair': pair_activations,
+        # Crop away template rows such that they are not used in MaskedMsaHead.
+        'msa': msa_activations[:num_sequences, :, :],
+        'msa_first_row': msa_activations[0],
+    }
+
+    return output
+
+
+class SingleTemplateEmbedding(hk.Module):
+  """"""Embeds a single template.
+
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 9+11
+  """"""
+
+  def __init__(self, config, global_config, name='single_template_embedding'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, query_embedding, batch, mask_2d, is_training):
+    """"""Build the single template embedding.
+
+    Arguments:
+      query_embedding: Query pair representation, shape [N_res, N_res, c_z].
+      batch: A batch of template features (note the template dimension has been
+        stripped out as this module only runs over a single template).
+      mask_2d: Padding mask (Note: this doesn't care if a template exists,
+        unlike the template_pseudo_beta_mask).
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      A template embedding [N_res, N_res, c_z].
+    """"""
+    assert mask_2d.dtype == query_embedding.dtype
+    dtype = query_embedding.dtype
+    num_res = batch['template_aatype'].shape[0]
+    num_channels = (self.config.template_pair_stack
+                    .triangle_attention_ending_node.value_dim)
+    template_mask = batch['template_pseudo_beta_mask']
+    template_mask_2d = template_mask[:, None] * template_mask[None, :]
+    template_mask_2d = template_mask_2d.astype(dtype)
+
+    template_dgram = dgram_from_positions(batch['template_pseudo_beta'],
+                                          **self.config.dgram_features)
+    template_dgram = template_dgram.astype(dtype)
+
+    to_concat = [template_dgram, template_mask_2d[:, :, None]]
+
+    aatype = jax.nn.one_hot(batch['template_aatype'], 22, axis=-1, dtype=dtype)
+
+    to_concat.append(jnp.tile(aatype[None, :, :], [num_res, 1, 1]))
+    to_concat.append(jnp.tile(aatype[:, None, :], [1, num_res, 1]))
+
+    n, ca, c = [residue_constants.atom_order[a] for a in ('N', 'CA', 'C')]
+    rot, trans = quat_affine.make_transform_from_reference(
+        n_xyz=batch['template_all_atom_positions'][:, n],
+        ca_xyz=batch['template_all_atom_positions'][:, ca],
+        c_xyz=batch['template_all_atom_positions'][:, c])
+    affines = quat_affine.QuatAffine(
+        quaternion=quat_affine.rot_to_quat(rot, unstack_inputs=True),
+        translation=trans,
+        rotation=rot,
+        unstack_inputs=True)
+    points = [jnp.expand_dims(x, axis=-2) for x in affines.translation]
+    affine_vec = affines.invert_point(points, extra_dims=1)
+    inv_distance_scalar = jax.lax.rsqrt(
+        1e-6 + sum([jnp.square(x) for x in affine_vec]))
+
+    # Backbone affine mask: whether the residue has C, CA, N
+    # (the template mask defined above only considers pseudo CB).
+    template_mask = (
+        batch['template_all_atom_masks'][..., n] *
+        batch['template_all_atom_masks'][..., ca] *
+        batch['template_all_atom_masks'][..., c])
+    template_mask_2d = template_mask[:, None] * template_mask[None, :]
+
+    inv_distance_scalar *= template_mask_2d.astype(inv_distance_scalar.dtype)
+
+    unit_vector = [(x * inv_distance_scalar)[..., None] for x in affine_vec]
+
+    unit_vector = [x.astype(dtype) for x in unit_vector]
+    template_mask_2d = template_mask_2d.astype(dtype)
+    if not self.config.use_template_unit_vector:
+      unit_vector = [jnp.zeros_like(x) for x in unit_vector]
+    to_concat.extend(unit_vector)
+
+    to_concat.append(template_mask_2d[..., None])
+
+    act = jnp.concatenate(to_concat, axis=-1)
+
+    # Mask out non-template regions so we don't get arbitrary values in the
+    # distogram for these regions.
+    act *= template_mask_2d[..., None]
+
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 9
+    act = common_modules.Linear(
+        num_channels,
+        initializer='relu',
+        name='embedding2d')(
+            act)
+
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 11
+    act = TemplatePairStack(
+        self.config.template_pair_stack, self.global_config)(
+            act, mask_2d, is_training)
+
+    act = hk.LayerNorm([-1], True, True, name='output_layer_norm')(act)
+    return act
+
+
+class TemplateEmbedding(hk.Module):
+  """"""Embeds a set of templates.
+
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 9-12
+  Jumper et al. (2021) Suppl. Alg. 17 ""TemplatePointwiseAttention""
+  """"""
+
+  def __init__(self, config, global_config, name='template_embedding'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, query_embedding, template_batch, mask_2d, is_training):
+    """"""Build TemplateEmbedding module.
+
+    Arguments:
+      query_embedding: Query pair representation, shape [N_res, N_res, c_z].
+      template_batch: A batch of template features.
+      mask_2d: Padding mask (Note: this doesn't care if a template exists,
+        unlike the template_pseudo_beta_mask).
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      A template embedding [N_res, N_res, c_z].
+    """"""
+
+    num_templates = template_batch['template_mask'].shape[0]
+    num_channels = (self.config.template_pair_stack
+                    .triangle_attention_ending_node.value_dim)
+    num_res = query_embedding.shape[0]
+
+    dtype = query_embedding.dtype
+    template_mask = template_batch['template_mask']
+    template_mask = template_mask.astype(dtype)
+
+    query_num_channels = query_embedding.shape[-1]
+
+    # Make sure the weights are shared across templates by constructing the
+    # embedder here.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 9-12
+    template_embedder = SingleTemplateEmbedding(self.config, self.global_config)
+
+    def map_fn(batch):
+      return template_embedder(query_embedding, batch, mask_2d, is_training)
+
+    template_pair_representation = mapping.sharded_map(map_fn, in_axes=0)(
+        template_batch)
+
+    # Cross attend from the query to the templates along the residue
+    # dimension by flattening everything else into the batch dimension.
+    # Jumper et al. (2021) Suppl. Alg. 17 ""TemplatePointwiseAttention""
+    flat_query = jnp.reshape(query_embedding,
+                             [num_res * num_res, 1, query_num_channels])
+
+    flat_templates = jnp.reshape(
+        jnp.transpose(template_pair_representation, [1, 2, 0, 3]),
+        [num_res * num_res, num_templates, num_channels])
+
+    bias = (1e9 * (template_mask[None, None, None, :] - 1.))
+
+    template_pointwise_attention_module = Attention(
+        self.config.attention, self.global_config, query_num_channels)
+    nonbatched_args = [bias]
+    batched_args = [flat_query, flat_templates]
+
+    embedding, col_attn = mapping.inference_subbatch(
+        template_pointwise_attention_module,
+        self.config.subbatch_size,
+        batched_args=batched_args,
+        nonbatched_args=nonbatched_args,
+        low_memory=not is_training)
+    embedding = jnp.reshape(embedding,
+                            [num_res, num_res, query_num_channels])
+
+    # No gradients if no templates.
+    embedding *= (jnp.sum(template_mask) > 0.).astype(embedding.dtype)
+
+    return embedding
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/common/pdb_utils.py",".py","8034","238","import io
+import gzip
+import dataclasses
+from typing import Mapping, Set
+
+import torch
+import numpy as np
+from Bio.PDB import PDBParser
+from Bio.PDB.Model import Model
+from Bio.PDB.Chain import Chain
+from Bio.PDB.Residue import Residue
+from Bio.PDB.Atom import Atom
+from alphafold.common import protein, residue_constants
+
+
+def trim_pdb_by_residue_index(query_pdb: str, target_pdb: str) -> str:
+    tp = build_from_pdb_string(
+        read_pdb_string(query_pdb),
+        chain_residue_index=build_chain_residue_index(
+            read_pdb_string(target_pdb)
+        ),
+        output_model=True
+    )
+    return tp
+
+def assign_residue_index(assigning, query_chains, target_chains):
+    new_query_chains = {}
+    for qi, ti, qidx, tidx in assigning:
+        qchain = dataclasses.asdict(query_chains[qi])
+        tchain = dataclasses.asdict(target_chains[ti])
+        for k in qchain:
+            if k == 'residue_index':
+                qchain[k] = tchain[k][tidx]
+            elif k == 'chain_index':
+                t = protein.PDB_CHAIN_IDS.index(ti)
+                qchain[k] = np.full(len(tchain[k][tidx]), t)
+            else:
+                qchain[k] = qchain[k][qidx]
+        new_query_chains[ti] = protein.Protein(**qchain)
+    return new_query_chains
+
+def merge_chains(
+    chains: Mapping[str, protein.Protein],
+    only_backbone: bool = False,
+) -> protein.Protein:
+    ca_atom_order = residue_constants.atom_order['CA']
+    p = None
+    for _, chain in chains.items():
+        chain = dataclasses.asdict(chain)
+        if p is not None:
+            for k in p:
+                p[k] = np.concatenate([p[k], chain[k]], axis=0)
+        else:
+            p = chain
+    if only_backbone:
+        ca_mask = p['atom_mask'][:,ca_atom_order]
+        atom_mask = np.zeros(p['atom_mask'].shape)
+        for atom_type in ('CA', 'N', 'C'):
+            atom_order = residue_constants.atom_order[atom_type]
+            atom_mask[:,atom_order] = p['atom_mask'][:,atom_order]
+        p['atom_mask'] = atom_mask
+
+    return protein.Protein(**p)
+
+def read_pdb_string(path):
+    if path.endswith('.gz'):
+        with gzip.open(path) as fh:
+            pdb_string = fh.read().decode()
+    else:
+        with open(path) as fh:
+            pdb_string = fh.read()
+    return pdb_string
+
+def from_pdb_string(pdb_string):
+    pdb_fh = io.StringIO(pdb_string)
+    parser = PDBParser(QUIET=True)
+    structure = parser.get_structure('none', pdb_fh)
+    models = list(structure.get_models())
+    model = models[0]
+    chains_result = {}
+    chain_ids = []
+    for chain in model:
+        chains_result[chain.id] = from_chain(chain)
+        chain_ids += chains_result[chain.id]['chain_ids']
+    unique_chain_ids = np.unique(chain_ids)
+    chain_id_mapping = {cid: n for n, cid in enumerate(unique_chain_ids)}
+
+    chains = {}
+    for chain_id, chain_result in chains_result.items():
+        chains[chain_id] = protein.Protein(
+            atom_positions=np.array(chain_result['atom_positions']),
+            atom_mask=np.array(chain_result['atom_mask']),
+            aatype=np.array(chain_result['aatype']),
+            residue_index=np.array(chain_result['residue_index']),
+            chain_index=np.array([
+                chain_id_mapping[cid] for cid in chain_result['chain_ids']
+            ]),
+            b_factors=np.array(chain_result['b_factors'])
+        )
+
+    return chains
+
+def build_chain_residue_index(pdb_string):
+    pdb_fh = io.StringIO(pdb_string)
+    parser = PDBParser(QUIET=True)
+    structure = parser.get_structure('none', pdb_fh)
+    models = list(structure.get_models())
+    model = models[0]
+    chain_residue_index = {}
+    for chain in model:
+        if (chain_residue_index is not None and chain.id in chain_residue_index):
+            continue
+        chain_residue_index[chain.id] = set()
+        for res in chain:
+            if res.id[0] != ' ': # remove hetatom
+                continue
+            if res.id[2] != ' ':
+                continue
+            chain_residue_index[chain.id].add(res.id)
+    return chain_residue_index
+
+def build_from_pdb_string(
+    pdb_string,
+    chain_residue_index: Mapping[str, Set[int]] = None,
+    min_length_cutoff=0,
+    output_model=False,
+):
+    pdb_fh = io.StringIO(pdb_string)
+    parser = PDBParser(QUIET=True)
+    structure = parser.get_structure('none', pdb_fh)
+    models = list(structure.get_models())
+    chains = {}
+    chains_counter = {}
+    if output_model:
+        new_model = Model(0)
+    for model in models:
+        for chain in model:
+            if (
+                chain_residue_index is not None 
+                and chain.id not in chain_residue_index
+            ):
+                continue
+            new_chain = Chain(chain.id)
+            for res in chain:
+                if res.id[0] != ' ': # remove hetatom
+                    continue
+                if res.id[2] != ' ':
+                    continue
+                res_id = res.id
+                if (
+                    chain_residue_index is not None
+                    and res_id not in chain_residue_index[chain.id]
+                ):
+                    continue
+                if new_chain.has_id(res_id):
+                    continue
+                new_res = Residue(res.id, res.resname, res.segid)
+                for atom in res:
+                    new_atom = Atom(
+                        atom.name,
+                        atom.coord,
+                        atom.bfactor,
+                        atom.occupancy,
+                        atom.altloc,
+                        atom.fullname,
+                        atom.serial_number,
+                        atom.element
+                    )
+                    new_res.add(new_atom)
+                new_chain.add(new_res)
+
+            if len(new_chain) < min_length_cutoff:
+                # too few experimentally resolved residues
+                continue
+
+            if output_model:
+                new_model.add(new_chain)
+            else:
+                if chain.id not in chains_counter:
+                    chains_counter[chain.id] = 0
+                chains_counter[chain.id] += 1
+                chains[f'{chain.id}{chains_counter[chain.id]}'] = new_chain
+
+    if output_model:
+        return new_model
+    else:
+        return chains
+
+def from_chain(chain):
+    atom_positions = []
+    aatype = []
+    atom_mask = []
+    residue_index = []
+    chain_ids = []
+    b_factors = []
+    for res in chain:
+        if res.id[0] != ' ': # remove hetatom
+            continue
+        if res.id[2] != ' ':
+            print(
+                f'PDB contains an insertion code at chain {chain.id} and res'
+                f' index {res.id[1]}. This insertion is skipped.'
+            )
+            continue
+        res_shortname = residue_constants.restype_3to1.get(res.resname, 'X')
+        restype_idx = residue_constants.restype_order.get(
+            res_shortname, residue_constants.restype_num
+        )
+        pos = np.zeros((residue_constants.atom_type_num, 3))
+        mask = np.zeros((residue_constants.atom_type_num,))
+        res_b_factors = np.zeros((residue_constants.atom_type_num,))
+        for atom in res:
+            if atom.name not in residue_constants.atom_types:
+                continue
+            pos[residue_constants.atom_order[atom.name]] = atom.coord
+            mask[residue_constants.atom_order[atom.name]] = 1.
+            res_b_factors[residue_constants.atom_order[atom.name]] = \
+                atom.bfactor
+        if np.sum(mask) < 0.5:
+            # If no known atom positions are reported for the residue then skip
+            # it
+            continue
+        aatype.append(restype_idx)
+        atom_positions.append(pos)
+        atom_mask.append(mask)
+        residue_index.append(res.id[1])
+        chain_ids.append(chain.id)
+        b_factors.append(res_b_factors)
+
+    return {
+      'atom_positions': atom_positions,
+      'aatype': aatype,
+      'atom_mask': atom_mask,
+      'residue_index': residue_index,
+      'chain_ids': chain_ids,
+      'b_factors': b_factors,
+    }
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/common/sequence_utils.py",".py","1375","47","import numpy as np
+
+from Bio import pairwise2
+from alphafold.common import protein, residue_constants
+
+def aatype_to_sequence(aatype):
+    sequence = ''.join(
+        residue_constants.restypes_with_x_and_gap[aa] for aa in aatype)
+    return sequence
+
+
+x_order = residue_constants.restype_order_with_x['X']
+def sequence_to_aatype(sequence):
+    aatype = np.array(
+        [residue_constants.restype_order_with_x.get(w, x_order) for w in 
+         sequence],
+        dtype=np.int64)
+    return aatype
+
+
+def global_align(srcseq, tgtseq, gap_penalty=-2.):
+    def _get_alnidx(seqA, seqB):
+        srcidx, tgtidx = [], []
+        ai, bj = 0, 0
+        for a, b in zip(seqA, seqB):
+            if a != '-' and b != '-':
+                srcidx.append(ai)
+                tgtidx.append(bj)
+            if a != '-':
+                ai += 1
+            if b != '-':
+                bj += 1
+        srcidx = np.array(srcidx, dtype=np.int64)
+        tgtidx = np.array(tgtidx, dtype=np.int64)
+        return srcidx, tgtidx
+    srcseq = ''.join([_ for _ in srcseq if _ != '-'])
+    tgtseq = ''.join([_ for _ in tgtseq if _ != '-'])
+
+    aln = pairwise2.align.globalms(srcseq, tgtseq, 2, -1, gap_penalty, -0.5)
+
+    if len(aln) >= 1:
+        aln = aln[0]
+        srcidx, tgtidx = _get_alnidx(aln.seqA, aln.seqB)
+        return aln, srcidx, tgtidx
+    else:
+        return None, None, None
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/species_processing.py",".py","9961","314","import os
+import json
+import time
+from tqdm import tqdm
+from typing import Sequence, Dict
+from collections import defaultdict
+
+import numpy as np
+import pandas as pd
+
+from alphafold.data import parsers, pipeline, msa_identifiers, msa_pairing
+from alphafold.common import residue_constants
+
+from msa_pair.data import msa_processing
+
+
+
+def get_uniref_species(description):
+    temp = description[1:]
+    if temp.find('TaxID=')!=-1:
+        n_index = temp.index('n=')
+        temp = temp[n_index:].split(maxsplit=1)[-1]
+        TaxID_index = temp.index('TaxID=')
+        Tax,[TaxID,RepID] = temp[:TaxID_index].strip(),temp[TaxID_index:].split()
+        Tax = Tax.split('=')[1]
+        TaxID = int(TaxID.split('=')[1])
+        RepID = RepID.split('=')[1]
+        return str(TaxID)
+    else:
+        return ''
+
+def make_msa_features(msas: Sequence[parsers.Msa]):
+    """"""Constructs a feature dict of MSA features.""""""
+    if not msas:
+      raise ValueError('At least one MSA must be provided.')
+
+    int_msa = []
+    deletion_matrix = []
+    species_ids = []
+    seen_sequences = set()
+    sequences = []
+    descriptions = []
+    for msa_index, msa in enumerate(msas):
+        if not msa:
+            raise ValueError(
+                f'MSA {msa_index} must contain at least one sequence.'
+            )
+        for sequence_index, sequence in enumerate(msa.sequences):
+            if sequence in seen_sequences:
+                continue
+            seen_sequences.add(sequence)
+            int_msa.append(
+                [residue_constants.HHBLITS_AA_TO_ID[res] for res in sequence]
+            )
+            
+            #--------------------------------------------------------------------
+            # # for MSA searched from uniprotKB
+            # identifiers = msa_identifiers.get_identifiers(
+            #     msa.descriptions[sequence_index]
+            # )
+            # species_ids.append(identifiers.species_id.encode('utf-8'))
+
+            
+            # for MSA seached from uniref
+            species_idf = get_uniref_species(msa.descriptions[sequence_index]) 
+            species_ids.append(species_idf.encode('utf-8'))
+            
+            #--------------------------------------------------------------------
+            
+            deletion_matrix.append(msa.deletion_matrix[sequence_index])
+            sequences.append(sequence)
+            descriptions.append(msa.descriptions[sequence_index])
+
+    processed_msa = parsers.Msa(
+        sequences=sequences,
+        descriptions=descriptions,
+        deletion_matrix=deletion_matrix,
+    )
+
+    num_res = len(msas[0].sequences[0])
+    num_alignments = len(int_msa)
+    features = {}
+    features['deletion_matrix_int'] = np.array(
+        deletion_matrix, dtype=np.int32
+    )
+    features['msa'] = np.array(int_msa, dtype=np.int32)
+    features['num_alignments'] = np.array(
+        [num_alignments] * num_res, dtype=np.int32)
+    features['msa_species_identifiers'] = np.array(
+        species_ids, dtype=np.object_
+    )
+
+    return features, processed_msa
+
+
+def make_msa_df(chain_features):
+    """"""Construct DataFrame for species processing
+    """"""
+    chain_msa = chain_features['msa']
+    # print(chain_msa)
+    # exit()
+    query_seq = chain_msa[0]
+    per_seq_similarity = np.sum(
+        query_seq[None] == chain_msa, axis=-1
+    ) / float(len(query_seq))
+    per_seq_gap = np.sum(chain_msa == 21, axis=-1) / float(len(query_seq))
+    msa_df = pd.DataFrame({
+        'msa_species_identifiers':
+            chain_features['msa_species_identifiers'],
+        'msa_row':
+            np.arange(len(chain_features['msa_species_identifiers'])),
+        'msa_similarity': per_seq_similarity,
+        'gap': per_seq_gap
+    })
+    return msa_df
+
+
+def create_species_dict(msa_df: pd.DataFrame) -> Dict[bytes, pd.DataFrame]:
+    species_lookup = {}
+    for species, species_df in msa_df.groupby('msa_species_identifiers'):
+        species_lookup[species] = species_df
+    return species_lookup
+
+
+def parse(
+    input_dir: str,
+    names: Sequence[str],
+    chain_ids=['A', 'B'], 
+    pair_species=False,
+):
+    """"""Parse all MSAs in the directory
+    """"""
+    grouped_paths = {
+        chain_id: 
+            [ os.path.join(input_dir, chain_id, name) for name in names ]
+        for chain_id in chain_ids
+    }
+    # print(grouped_paths)
+    if any(
+        not all(os.path.exists(_) for _ in paths) for paths in 
+        grouped_paths.values()
+    ):
+        raise IOError('Some files do not exist')
+
+    msas_dict = {}
+    msa_feats_dict = {}
+    if pair_species:
+        all_species_dict = defaultdict(dict)
+    for chain_id, paths in grouped_paths.items():
+        msas = []
+        for path in paths:
+            with open(path) as fh:
+                a3m_str = fh.read()
+                msa = parsers.parse_a3m(a3m_str)
+            msas.append(msa)
+        msa_feat, processed_msa = make_msa_features(msas)
+
+        if pair_species:
+            msa_df = make_msa_df(msa_feat)
+            species_dict = create_species_dict(msa_df)
+            for spec, df in species_dict.items():
+                if spec == b'':
+                    continue
+                all_species_dict[spec][chain_id] = df
+
+        msas_dict[chain_id] = processed_msa
+        msa_feats_dict[chain_id] = msa_feat
+    
+    if pair_species:
+        return all_species_dict, msas_dict, msa_feats_dict
+    else:
+        return msas_dict, msa_feats_dict
+
+
+def parse_pairs(
+    pairs: list,
+    pair_species=False,
+):
+    msas_dict = {}
+    msa_feats_dict = {}
+    chain_ids = [""A"", ""B""]
+
+    if pair_species:
+        all_species_dict = defaultdict(dict)
+    for i in range(2): # 0 or 1
+        chain_id = chain_ids[i]
+        msas = []
+        descriptions = [pair[i][0] for pair in pairs]
+        sequences = [pair[i][1] for pair in pairs]
+
+        # for desc, seq in zip(descriptions, sequences):
+        msas.append(parsers.convert_seq_desc_to_Msa(sequences, descriptions))
+        msa_feat, processed_msa = make_msa_features(msas)
+
+        if pair_species:
+            msa_df = make_msa_df(msa_feat)
+            species_dict = create_species_dict(msa_df)
+            for spec, df in species_dict.items():
+                if spec == b'':
+                    continue
+                all_species_dict[spec][chain_id] = df
+
+        msas_dict[chain_id] = processed_msa
+        msa_feats_dict[chain_id] = msa_feat
+    
+    if pair_species:
+        return all_species_dict, msas_dict, msa_feats_dict
+    else:
+        return msas_dict, msa_feats_dict
+
+
+def pair_species(
+    input_dir: str,
+    names: Sequence[str] = ['uniprot.a3m'],
+    chain_ids=['A', 'B'],
+):
+    all_species_dict, msas_dict, msa_feats_dict = parse(
+        input_dir,
+        names,
+        chain_ids=chain_ids,
+        pair_species=True,
+    )
+
+    matched_species_dict = {}
+    for spec, dfs in all_species_dict.items():
+        if len(dfs) < 2:
+            continue
+        matched_species_dict[spec] = dfs
+    num_residues = {}
+    for chain_id, msa_feat in msa_feats_dict.items():
+        num_residues[chain_id] = msa_feat['msa'].shape[1]
+
+    fixed = {}
+    unfixed = {}
+    for spec, dfs in matched_species_dict.items():
+        num_seqs = [(chain_id, len(df)) for chain_id, df in dfs.items()]
+        if max(_[1] for _ in num_seqs) == 1:
+            fixed[spec.decode()] = dict(num_seqs)
+        else:
+            unfixed[spec.decode()] = dict(num_seqs)
+
+    species_stats = {
+        'num_species': {'fixed': len(fixed), 'unfixed': len(unfixed)},
+        'num_sequences': {'fixed': fixed, 'unfixed': unfixed},
+        'num_residues': num_residues,
+    }
+    print(f""matched_species: {len(matched_species_dict)} fixed: {len(fixed)} unfixed: {len(unfixed)}"")
+    return matched_species_dict, msas_dict, msa_feats_dict, species_stats
+
+
+def process_paired_msas(matched_species_dict, msas_dict):
+    processed_msas_dict = {}
+    for chain_id, msa in msas_dict.items():
+        rows = []
+        for spec, dfs in matched_species_dict.items():
+            rows += list(dfs[chain_id].msa_row.values)
+        rows = sorted(rows)
+        if 0 not in rows:
+            rows = [0] + rows
+        msa = msa_processing._build_msa(msa, rows)
+        processed_msas_dict[chain_id] = msa
+
+    return processed_msas_dict
+
+def dump_msa_to_a3m(dst_path, msa):
+    with open(dst_path, 'wt') as fh:
+        for desc, seq in zip(msa.descriptions, msa.sequences):
+            fh.write(f'>{desc}\n{seq}\n')
+
+def read_include_file(include_file):
+    included_names = set()
+    with open(include_file) as fh:
+        for line in fh:
+            line = line.strip()
+            if line:
+                name = line.split()[0]
+                included_names.add(name)
+
+    return included_names
+
+
+def process_batch(src_root, dst_root, include_file=None):
+    names = sorted(os.listdir(src_root))
+    if include_file is not None:
+        included_names = read_include_file(include_file)
+        names = [name for name in names if name in included_names]
+
+    for name in tqdm(names):
+        input_dir = os.path.join(src_root, name)
+        output_dir = os.path.join(dst_root, name)
+        output_stats_path = os.path.join(output_dir, 'species_stats.json')
+        if os.path.exists(output_stats_path):
+            continue 
+        result = pair_species(input_dir)
+        if result is None:
+            continue
+
+        os.makedirs(output_dir, exist_ok=True)
+
+        processed_msas_dict = process_paired_msas(result[0], result[1])
+        for chain_id, msa in processed_msas_dict.items():
+            dst_chain_dir = os.path.join(output_dir, chain_id)
+            os.makedirs(dst_chain_dir, exist_ok=True)
+            dump_msa_to_a3m(os.path.join(dst_chain_dir, 'uniprot.a3m'), msa)
+
+        with open(output_stats_path, 'wt') as fh:
+            json.dump(result[-1], fh, indent=2, sort_keys=True)
+
+
+if __name__ == '__main__':
+    import sys
+    include_file = None if len(sys.argv) <= 3 else sys.argv[3]
+    process_batch(sys.argv[1], sys.argv[2], include_file)
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/msa_processing.py",".py","3132","106","import copy
+
+from typing import Sequence, Mapping, List
+
+from alphafold.data import parsers, msa_pairing, feature_processing
+from alphafold.common import residue_constants
+
+
+def _build_msa(input_msa, rows):
+    return parsers.Msa(
+        sequences = [input_msa.sequences[i] for i in rows],
+        deletion_matrix = [input_msa.deletion_matrix[i] for i in rows],
+        descriptions = [input_msa.descriptions[i] for i in rows],
+    )
+
+class _MsaSubset:
+    def __init__(self, main_msa: parsers.Msa, rows: Sequence[int]):
+        self.msa_subset = {}
+        for r in sorted(set(rows)):
+            self.msa_subset[r] = {
+                key: getattr(main_msa, key)[r] for key in [
+                    'sequences', 'descriptions', 'deletion_matrix'
+                ]
+            }
+
+
+    def __add__(self, next_subset):
+        this_subset = copy.deepcopy(self)
+        for r, v in next_subset.msa_subset.items():
+            if r in this_subset.msa_subset:
+                assert v['sequences'] == this_subset.msa_subset[r]['sequences']
+            else:
+                this_subset.msa_subset[r] = v
+
+        return this_subset
+
+    def build_msa(self):
+        rows_sorted = self.rows
+        return parsers.Msa(
+            sequences=[self.msa_subset[r]['sequences'] for r in rows_sorted],
+            deletion_matrix=[
+                self.msa_subset[r]['deletion_matrix'] for r in rows_sorted
+            ],
+            descriptions=[
+                self.msa_subset[r]['descriptions'] for r in rows_sorted
+            ],
+        )
+
+    @property
+    def rows(self):
+        return sorted(self.msa_subset)
+
+    def __len__(self):
+        return len(self.msa_subset)
+
+class MsaBlock:
+    def __init__(
+        self,
+        msas_dict: Mapping[str, parsers.Msa],
+        rows_dict: Mapping[str, List[int]],
+    ):
+        assert len(set(msas_dict) ^ set(rows_dict)) == 0
+        self.msa_subsets = {
+            chain_id: _MsaSubset(msa, rows_dict[chain_id]) for chain_id, msa
+            in msas_dict.items()
+        }
+
+    def __add__(self, next_block):
+        this_block = copy.deepcopy(self)
+        for chain_id, msa_subset in next_block.msa_subsets.items():
+            if chain_id in self.msa_subsets:
+                this_block.msa_subsets[chain_id] += msa_subset
+            else:
+                this_block.msa_subsets[chain_id] = msa_subset
+
+        return this_block
+
+    def get_msas(self):
+        return {
+            chain_id: msa_subset.build_msa() for chain_id, msa_subset in 
+            self.msa_subsets.items()
+        }
+
+    def get_rows(self):
+        return {
+            chain_id: msa_subset.rows for chain_id, msa_subset in 
+            self.msa_subsets.items()
+        }
+
+    def get_lengths(self):
+        return {
+            chain_id: len(msa_subset) for chain_id, msa_subset in 
+            self.msa_subsets.items()
+        }
+
+
+def create_paired_rows(chains, rows_dict):
+    paired_rows = []
+    for chain in chains:
+        chain_id = str(chain['auth_chain_id'])
+        paired_rows.append(rows_dict[chain_id])
+    
+    paired_rows = np.concatenate(paired_rows, axis=0).T
+
+    return paired_rows
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/row_processing.py",".py","6487","185","from contextlib import suppress
+import os
+import json
+from typing import List, Mapping
+from collections import defaultdict
+import numpy as np
+np.set_printoptions(threshold=np.inf)
+np.set_printoptions(suppress = True)
+
+from alphafold.data import parsers, msa_pairing, feature_processing
+from alphafold.common import residue_constants
+from scipy.sparse import csr_matrix
+from scipy.sparse.csgraph import min_weight_full_bipartite_matching
+from operator import itemgetter
+
+def _upgrade_sequences_scores(sequence_scores):
+    processed_scores = {}
+    for result in sequence_scores.values():
+        desc = result['description']
+        score = result['score']
+        processed_scores[desc] = score
+
+    return processed_scores
+
+def create_paired_rows_dict(
+    species_dict,
+    msas_dict,
+    sequences_scores,
+    chain_ids: List[str] = ['A', 'B'],
+) -> Mapping[str, List[int]]:
+
+    # upgrade sequences scores 
+    for chain_id in chain_ids:
+        sequences_scores[chain_id] = _upgrade_sequences_scores(
+            sequences_scores[chain_id]
+        )
+
+    paired_rows_dict = {chain_id: [0] for chain_id in chain_ids}
+    # pair_scores = [ np.full((1, len(chain_ids)), 1e6) ]
+    pair_scores = [ np.full((1, len(chain_ids)), -1e6) ] # reverse
+    
+
+    spec2ind2score = defaultdict(list)
+    for spec, dfs in species_dict.items():
+        if spec == b'':
+            continue
+        # spec = b'CERCE'
+        # dfs = species_dict[spec]
+
+        # find and sort scores
+        scores_ = {}
+        for chain_id, df in dfs.items():
+            chain_scores_ = []
+            rows = df.msa_row.values
+            # print(rows)
+            for r in rows:
+                desc = msas_dict[chain_id].descriptions[r].split()[0]
+                if desc in sequences_scores[chain_id]:
+                    s = sequences_scores[chain_id][desc]
+                    chain_scores_.append((int(r), s))
+                # if int(r) == 90:
+                #     print(dfs['A'])
+                #     print(dfs['B'])
+                #     print(desc)
+                #     print(chain_scores_)
+                    # exit()
+            # print(chain_scores_)
+            if len(chain_scores_) >= 1:
+                scores_[chain_id] = sorted(
+                    chain_scores_, key=lambda v: v[-1], reverse=True,
+                )
+        # print(scores_)
+        
+        # exit()
+
+        # match rows within the species
+        if len(scores_) > 1:
+            num_seqs = min(len(v) for v in scores_.values())
+            pair_scores_ = []
+            for chain_id in chain_ids:
+                tmp = {}
+                if chain_id in scores_:
+                    chain_rows_ = [
+                        _[0] for _ in scores_[chain_id][:num_seqs]
+                    ]
+                    chain_scores_ = [
+                        _[-1] for _ in scores_[chain_id][:num_seqs]
+                    ]
+                else:
+                    chain_rows_ = [-1] * num_seqs
+                    chain_scores_ = [0.] * num_seqs
+                tmp[chain_id] = scores_[chain_id][:num_seqs]
+                spec2ind2score[spec].append(tmp)
+                paired_rows_dict[chain_id] += chain_rows_
+                pair_scores_ += [np.array(chain_scores_)[:,None]]
+            pair_scores.append(np.concatenate(pair_scores_, axis=-1))
+    # sort rows by their pair scores
+    pair_scores = np.concatenate(pair_scores, axis=0)
+    # inds_sorted = np.argsort(np.sum(pair_scores, axis=-1))[::-1]
+    inds_sorted = np.argsort(np.sum(pair_scores, axis=-1)) # reverse
+    # print(np.sum(pair_scores, axis=-1)[inds_sorted])
+    # print(inds_sorted[:10])
+    # # print(np.sum(pair_scores, axis=-1)[inds_sorted][:10])
+    
+    paired_rows_dict  = {
+        chain_id: [rows[i] for i in inds_sorted] for chain_id, rows in 
+        paired_rows_dict.items()
+    }
+    assert len(pair_scores) == len(paired_rows_dict[chain_ids[0]])
+    # check the first row is always zero (that is, the first sequence is 
+    # always the query sequence)
+    assert all(rows[0] == 0 for rows in paired_rows_dict.values())
+
+    return paired_rows_dict
+
+
+
+def find_alignment(rowsA, rowsB, sims, tag):
+    ori_sims = sims
+    lenx, leny = sims.shape
+    # print(sims.shape, len(rowsA), len(rowsB))
+    assert (lenx == len(rowsA)) and (leny == len(rowsB))
+    num_seqs = min(len(rowsA), len(rowsB))
+    alignments = []
+    if tag == 'local':
+        sims = sims.reshape(-1)
+        index = np.argsort(-sims)
+        det_x = set()
+        det_y = set()
+        for each in index:
+            row, col = int(each/leny), each % leny
+            if row in det_x or col in det_y:
+                continue
+            det_x.add(row)
+            det_y.add(col)
+            alignments.append((rowsA[row], rowsB[col], sims[each]))
+        assert len(alignments) == num_seqs
+        # print(alignments)
+        # exit()
+    elif tag =='global':
+        tmp_align = []
+        sims = csr_matrix(sims)
+        rows, cols = min_weight_full_bipartite_matching(sims, maximize = True)
+        sims = sims.toarray()
+        assert len(rows) == len(cols) == num_seqs
+        for x, y in zip(rows, cols):
+            tmp_align.append((rowsA[x], rowsB[y], sims[x][y]))
+        alignments = sorted(tmp_align, key=itemgetter(2), reverse=True)
+    else:
+        raise ValueError(f""No such strategy: {tag}!"")
+    
+    return alignments, num_seqs
+            
+
+
+
+def create_inter_paired_rows_dict(
+    sequences_scores,
+    tag,
+    chain_ids: List[str] = ['A', 'B'],
+) -> Mapping[str, List[int]]:
+
+    paired_rows_dict = {chain_id: [0] for chain_id in chain_ids}
+    pair_scores = [1e6]
+    for spec, info in sequences_scores.items():
+        if spec == b'':
+            continue
+        rowsA, rowsB, sims = info['rowsA'], info['rowsB'], info['sims']
+
+        alignments, num_seqs = find_alignment(rowsA, rowsB, sims, tag)        
+
+        paired_rows_dict['A'] += [_[0] for _ in alignments]
+        paired_rows_dict['B'] += [_[1] for _ in alignments]
+        pair_scores += [_[2] for _ in alignments]
+    inds_sorted = np.argsort(-np.array(pair_scores))
+    paired_rows_dict  = {
+        chain_id: [int(rows[i]) for i in inds_sorted] for chain_id, rows in 
+        paired_rows_dict.items()
+    }
+    assert len(pair_scores) == len(paired_rows_dict[chain_ids[0]])
+    # check the first row is always zero (that is, the first sequence is 
+    # always the query sequence)
+    assert all(rows[0] == 0 for rows in paired_rows_dict.values())
+
+    return paired_rows_dict","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/pairing_pipeline_v2.py",".py","6218","154","import os
+import copy
+import json
+import logging
+import argparse
+
+from typing import Mapping, List
+
+from tqdm import tqdm
+
+import tree
+import numpy as np
+from alphafold.data import (
+    msa_pairing, pipeline, pipeline_multimer, feature_processing
+)
+from alphafold.common import residue_constants
+
+from msa_pair.data import species_processing
+
+logger = logging.getLogger(__file__)
+
+def _make_all_seq_msa_features(msa_feats):
+    return {
+        f'{k}_all_seq': v for k, v in msa_feats.items() if k in (
+            msa_pairing.MSA_FEATURES + ('msa_species_identifiers',)
+        )
+    }
+
+def _make_empty_templates_features(num_res):
+    """"""Construct a default template with all zeros.""""""                           
+    return {
+        'template_aatype':
+            np.zeros(
+                (1, num_res, len(residue_constants.restypes_with_x_and_gap)),
+                np.float32
+            ),
+        'template_all_atom_masks':
+            np.zeros(
+                (1, num_res, residue_constants.atom_type_num), np.float32
+            ),
+        'template_all_atom_positions':
+            np.zeros(
+                (1, num_res, residue_constants.atom_type_num, 3), np.float32
+            ),
+        'template_domain_names': np.array([''.encode()], dtype=object),
+        'template_sequence': np.array([''.encode()], dtype=object),
+        'template_sum_probs': np.array([0], dtype=np.float32),
+    }
+
+def build_paired_rows(auth_chain_ids, paired_rows_dict):
+    paired_rows = []
+    all_rows = [paired_rows_dict[chain_id] for chain_id in auth_chain_ids]
+    num_rows = len(all_rows[0])
+    for i in range(num_rows):
+        paired_rows.append([rows[i] for rows in all_rows])
+    paired_rows = np.array(paired_rows)
+    assert paired_rows.shape == (num_rows, len(auth_chain_ids)), paired_rows.shape
+    return paired_rows
+
+
+class PairingPipeline:
+    def process(self, pairs):
+        logger.info(f'Start building')
+        
+        # load paired msas
+        # msa_feats_dict: dict_keys(['deletion_matrix_int', 'msa', 'num_alignments', 'msa_species_identifiers'])
+        msas_all_seq_dict, msa_all_seq_feats_dict = species_processing.parse_pairs(
+            pairs
+        )
+
+        # msas_dict: {A/B:{sequences:[n_seq, seq_length], descriptions:[n_seq, -1]}}
+        # print('%s',tree.map_structure(lambda x: x.shape, msa_feats_dict))
+        # build merged feature
+        chains_dict = {}
+        for chain_id, msa in msas_all_seq_dict.items():
+            seq, desc = msa.sequences[0], msa.descriptions[0]  # parimary seq
+            num_res = len(seq)
+            chain = {
+                **_make_all_seq_msa_features(msa_all_seq_feats_dict[chain_id]),  # 'deletion_matrix_int_all_seq', 'msa_all_seq', 'num_alignments_all_seq', 'msa_species_identifiers_all_seq'
+                # **msa_feats_dict[chain_id],   # 'deletion_matrix_int', 'msa_all', 'num_alignments', 'msa_species_identifiers'
+                **pipeline.make_sequence_features(seq, desc, num_res),  # 'aatype', 'between_segment_residues', 'domain_name', 'residue_index', 'seq_length', 'sequence'
+                **_make_empty_templates_features(num_res),  # 'template_aatype', 'template_all_atom_masks', 'template_all_atom_positions', 'template_domain_names', 'template_sequence', 'template_sum_probs'
+            }
+            # sequence key is the primary sequence
+
+            # 'auth_chain_id'
+            # only change the feature 'aatype' 'template_aatype' 'template_all_atom_masks' 'template_all_atom_mask
+            chains_dict[chain_id] = pipeline_multimer.convert_monomer_features(
+                chain, chain_id=chain_id
+            )
+
+        # for heterodiamer (A[""sequence""] != B[""sequence""]), A,B -> A_1,B_1
+        chains_dict = pipeline_multimer.add_assembly_features(chains_dict)
+        np_example = self.pair_and_merge(chains_dict)
+        np_example = pipeline_multimer.pad_msa(np_example, 512)
+        logger.info(f""Done building"")
+        return np_example
+
+    def pair_and_merge(
+        self,
+        chains_dict: Mapping[str, pipeline.FeatureDict],
+        # paired_rows_dict: Mapping[str, List[int]],
+    ) -> pipeline.FeatureDict:
+
+        feature_processing.process_unmerged_features(chains_dict)
+        chains = list(chains_dict.values())
+
+        # auth_chain_ids = [str(chain['auth_chain_id']) for chain in chains]
+        # paired_rows = build_paired_rows(auth_chain_ids, paired_rows_dict)
+        # chains = self.create_paired_features(paired_rows, chains)
+        for k in range(len(chains)):
+            chains[k]['num_alignments_all_seq'] = np.asarray(
+                chains[k][""msa_all_seq""].shape[0]
+            )
+
+        # chains = msa_pairing.deduplicate_unpaired_sequences(chains)
+        chains = feature_processing.crop_chains_v2(
+            chains,
+            msa_crop_size=feature_processing.MSA_CROP_SIZE,
+            max_templates=feature_processing.MAX_TEMPLATES,
+        )
+
+        np_example = msa_pairing.merge_chain_features(
+            np_chains_list=chains,
+            pair_msa_sequences=True,
+            max_templates=feature_processing.MAX_TEMPLATES,
+        )
+
+        np_example = feature_processing.process_final(np_example)
+        logger.info(tree.map_structure(lambda x: x.shape, np_example))
+
+        return np_example
+
+    def create_paired_features(self, paired_rows, chains):
+        chain_keys = chains[0].keys()
+        updated_chains = []
+        for chain_num, chain in enumerate(chains):
+            new_chain = {k: v for k, v in chain.items() if '_all_seq' not in k}
+            for feature_name in chain_keys:
+                if feature_name.endswith('_all_seq'):
+                    feats_padded = msa_pairing.pad_features(
+                        chain[feature_name], feature_name
+                    )
+                    new_chain[feature_name] = \
+                        feats_padded[paired_rows[:, chain_num]]
+            new_chain['num_alignments_all_seq'] = np.asarray(
+                len(paired_rows[:, chain_num])
+            )
+            updated_chains.append(new_chain)
+        # print(""****************************"")
+        # print('%s',tree.map_structure(lambda x: x.shape, updated_chains))
+        # exit()
+        return updated_chains
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/pairing_pipeline.py",".py","8127","198","import os
+import copy
+import json
+import logging
+import argparse
+
+from typing import Mapping, List
+from sympy import sequence
+
+from tqdm import tqdm
+
+import tree
+import numpy as np
+from alphafold.data import (
+    msa_pairing, pipeline, pipeline_multimer, feature_processing
+)
+from alphafold.common import residue_constants
+
+from msa_pair.data import species_processing
+from copy import deepcopy
+
+logger = logging.getLogger(__file__)
+
+def _make_all_seq_msa_features(msa_feats):
+    return {
+        f'{k}_all_seq': v for k, v in msa_feats.items() if k in (
+            msa_pairing.MSA_FEATURES + ('msa_species_identifiers',)
+        )
+    }
+
+def _make_empty_templates_features(num_res):
+    """"""Construct a default template with all zeros.""""""                           
+    return {
+        'template_aatype':
+            np.zeros(
+                (1, num_res, len(residue_constants.restypes_with_x_and_gap)),
+                np.float32
+            ),
+        'template_all_atom_masks':
+            np.zeros(
+                (1, num_res, residue_constants.atom_type_num), np.float32
+            ),
+        'template_all_atom_positions':
+            np.zeros(
+                (1, num_res, residue_constants.atom_type_num, 3), np.float32
+            ),
+        'template_domain_names': np.array([''.encode()], dtype=object),
+        'template_sequence': np.array([''.encode()], dtype=object),
+        'template_sum_probs': np.array([0], dtype=np.float32),
+    }
+
+def build_paired_rows(auth_chain_ids, paired_rows_dict):
+    paired_rows = []
+    all_rows = [paired_rows_dict[chain_id] for chain_id in auth_chain_ids]
+    num_rows = len(all_rows[0])
+    for i in range(num_rows):
+        paired_rows.append([rows[i] for rows in all_rows])
+    paired_rows = np.array(paired_rows)
+    assert paired_rows.shape == (num_rows, len(auth_chain_ids)), paired_rows.shape
+    return paired_rows
+
+
+
+# def make_fixed_length(np_example, min_seq_l=1024):
+#     if np_example['seq_length'] >= min_seq_l:
+#         return np_example
+    
+#     np_example = deepcopy(np_example)
+#     for k, v in np_example.items():
+#         if not isinstance(v, int):
+#             v_shape = v.shape
+
+#         if k in ['seq_length']:
+#             np_example[k] = np.array(min_seq_l)
+#         elif k in ['msa', 'deletion_matrix', 'bert_mask', 'msa_mask']:
+#             np_example[k] = np.pad(v, ((0, 0), (0, min_seq_l - v_shape[-1])))
+#         elif k in ['residue_index', 'asym_id', 'sym_id', 'entity_id', 'entity_mask', 'seq_mask', 'aatype']:
+#             np_example[k] = np.pad(v, (0, min_seq_l - v_shape[-1]))
+#         elif k in ['template_aatype']:
+#             np_example[k] = np.pad(v, ((0, 0), (0, min_seq_l - v_shape[-1])))
+#         elif k in ['template_all_atom_mask']:
+#             np_example[k] = np.pad(v, ((0, 0), (0, min_seq_l - v_shape[1]), (0, 0)))
+#         elif k in ['template_all_atom_positions']:
+#             np_example[k] = np.pad(v, ((0, 0), (0, min_seq_l - v_shape[1]), (0, 0), (0, 0)))
+#         elif k in ['all_atom_mask']:
+#             np_example[k] = np.pad(v, ((0, min_seq_l - v_shape[0]), (0, 0)))
+#         elif k in ['all_atom_positions']:
+#             np_example[k] = np.pad(v, ((0, min_seq_l - v_shape[0]), (0, 0), (0, 0)))
+
+#     return np_example
+
+
+
+class PairingPipeline:
+    def process(self, input_dir, paired_rows_dict, padding = True):
+        logger.info(f'Build into {input_dir}')
+        # load paired msas
+        msas_all_seq_dict, msa_all_seq_feats_dict = species_processing.parse(
+            input_dir, names=['uniprot.a3m'], pair_species=False
+        )
+
+        # print('%s',
+        #         tree.map_structure(lambda x: x.shape, msa_all_seq_feats_dict))
+        # exit()
+        # load unpaired msas
+        msas_dict, msa_feats_dict = species_processing.parse( 
+            input_dir, names=['uniclust30.a3m'], pair_species=False
+        )
+        # msas_dict, msa_feats_dict = species_processing.parse( 
+        #     input_dir, names=['uniref90.a3m'], pair_species=False
+        # )
+
+        # msas_dict: {A/B:{sequences:[n_seq, seq_length], descriptions:[n_seq, -1]}}
+        # print('%s',tree.map_structure(lambda x: x.shape, msa_feats_dict))
+        # build merged feature
+        chains_dict = {}
+        for chain_id, msa in msas_dict.items():
+            seq, desc = msa.sequences[0], msa.descriptions[0]  # primary seq and desc
+            num_res = len(seq)  # seq length
+            chain = {
+                **_make_all_seq_msa_features(msa_all_seq_feats_dict[chain_id]),  # 'deletion_matrix_int_all_seq', 'msa_all_seq', 'num_alignments_all_seq', 'msa_species_identifiers_all_seq'
+                **msa_feats_dict[chain_id],   # 'deletion_matrix_int', 'msa_all', 'num_alignments', 'msa_species_identifiers'
+                **pipeline.make_sequence_features(seq, desc, num_res),  # 'aatype', 'between_segment_residues', 'domain_name', 'residue_index', 'seq_length', 'sequence'
+                **_make_empty_templates_features(num_res),  # 'template_aatype', 'template_all_atom_masks', 'template_all_atom_positions', 'template_domain_names', 'template_sequence', 'template_sum_probs'
+            }
+
+            chains_dict[chain_id] = pipeline_multimer.convert_monomer_features(
+                chain, chain_id=chain_id
+            )
+
+        chains_dict = pipeline_multimer.add_assembly_features(chains_dict)
+
+        np_example = self.pair_and_merge(chains_dict, paired_rows_dict)
+        np_example = pipeline_multimer.pad_msa(np_example, 512)
+        logger.info(f""Done building {input_dir}"")
+        # if padding:
+        #     np_example = make_fixed_length(np_example)
+        return np_example
+
+    def pair_and_merge(
+        self,
+        chains_dict: Mapping[str, pipeline.FeatureDict],
+        paired_rows_dict: Mapping[str, List[int]],
+    ) -> pipeline.FeatureDict:
+
+        feature_processing.process_unmerged_features(chains_dict)
+        chains = list(chains_dict.values())
+
+        auth_chain_ids = [str(chain['auth_chain_id']) for chain in chains]
+        paired_rows = build_paired_rows(auth_chain_ids, paired_rows_dict)  # [n_pairs, 2]
+        # num_alignments_all_seq
+        chains = self.create_paired_features(paired_rows, chains)
+        chains = msa_pairing.deduplicate_unpaired_sequences(chains)
+        chains = feature_processing.crop_chains(
+            chains,
+            msa_crop_size=feature_processing.MSA_CROP_SIZE,
+            pair_msa_sequences=True,
+            max_templates=feature_processing.MAX_TEMPLATES,
+        )
+        # print(feature_processing.MSA_CROP_SIZE)
+        # print('-------------',tree.map_structure(lambda x: x.shape, chains))
+        # exit()
+        np_example = msa_pairing.merge_chain_features(
+            np_chains_list=chains,
+            pair_msa_sequences=True,
+            max_templates=feature_processing.MAX_TEMPLATES,
+        )
+        np_example = feature_processing.process_final(np_example)
+        logger.info(tree.map_structure(lambda x: x.shape, np_example))
+        return np_example
+
+    def create_paired_features(self, paired_rows, chains):
+        # print(paired_rows)
+        # print(chains)
+        # print('%s',tree.map_structure(lambda x: x.shape, chains))
+        # exit()
+        
+        chain_keys = chains[0].keys()
+        updated_chains = []
+
+        for chain_num, chain in enumerate(chains):
+            new_chain = {k: v for k, v in chain.items() if '_all_seq' not in k}
+            for feature_name in chain_keys:
+                if feature_name.endswith('_all_seq'):
+                    feats_padded = msa_pairing.pad_features(
+                        chain[feature_name], feature_name
+                    )
+                    new_chain[feature_name] = \
+                        feats_padded[paired_rows[:, chain_num]]  # only take paired seq
+            new_chain['num_alignments_all_seq'] = np.asarray(
+                len(paired_rows[:, chain_num])
+            )
+            updated_chains.append(new_chain)
+        # print(""****************************"")
+        # print('%s',tree.map_structure(lambda x: x.shape, updated_chains))
+        # exit()
+        return updated_chains
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/megatron_scoring.py",".py","7351","199","from asyncio import FastChildWatcher
+from importlib.machinery import all_suffixes
+import string
+from tkinter.tix import Tree
+from typing import List, Tuple, Mapping
+
+from tqdm import tqdm
+import torch
+import pandas as pd
+from alphafold.data import parsers
+import torch.nn.functional as F
+
+from msa_pair.data.msa_processing import MsaBlock
+
+class EsmScoring:
+    def __init__(self, msa_transformer, msa_batch_converter):
+        self.msa_transformer = msa_transformer.eval()
+        self.msa_batch_converter = msa_batch_converter
+        deletekeys = dict.fromkeys(string.ascii_lowercase)
+        deletekeys["".""] = None
+        deletekeys[""*""] = None
+        self.translation = str.maketrans(deletekeys)
+        # self.inter_tag = inter_tag
+        self.is_cpu = False
+        # self.tag = tag
+
+    def set_device(self, is_cpu):
+        self.is_cpu = is_cpu
+        return self.is_cpu
+
+
+    def _read_msa(
+        self,
+        input_msa: parsers.Msa,
+        nseq: int
+    ) -> List[Tuple[str, str]]:
+        def remove_insertions(sequence: str) -> str:
+            """""" Removes any insertions into the sequence. Needed to load 
+                aligned sequences in an MSA.
+            """"""
+            return sequence.translate(self.translation)
+        input_msa = [
+            (desc, seq) for desc, seq in zip(
+                input_msa.descriptions[:nseq], input_msa.sequences[:nseq]
+            )
+        ]
+        return [ (desc, remove_insertions(seq)) for desc, seq in input_msa ]
+
+    def score(self, input_msa: parsers.Msa, max_num_msas: int, is_cpu = False, repr_layers=[]):
+        """"""Compute the ColAttn scores
+        """"""
+        assert max_num_msas <= 1024
+        msa_data = [ self._read_msa(input_msa, max_num_msas) ]
+        msa_batch_labels, msa_batch_strs, msa_batch_tokens = \
+            self.msa_batch_converter(msa_data)
+        if not is_cpu:
+            msa_transformer = self.msa_transformer.cuda()
+            msa_batch_tokens = msa_batch_tokens.cuda()
+        else:
+            msa_transformer = self.msa_transformer.cpu()
+            msa_batch_tokens = msa_batch_tokens.cpu()
+        # print(repr_layers)
+        # exit()
+        with torch.no_grad():
+            all_info = msa_transformer(
+                msa_batch_tokens, repr_layers = repr_layers, need_head_weights=True
+            )
+            col_attention = all_info['col_attentions']
+            B, C, R, R = col_attention.size()
+            # B, C, R
+            col_attention = col_attention[:, :, 0, :]
+            col_attention = col_attention.mean(-2).cpu().numpy()
+
+        return col_attention[0][1:] # R - 1
+
+    def score_sequences(
+        self,
+        species_dict: Mapping[str, Mapping[str, pd.DataFrame]],
+        msas_dict: Mapping[str, parsers.Msa],
+        take_num_seqs: int = 128,
+        max_num_msas: int = 512,
+        repr_layers: list = [],
+        max_num_species: int = -1,
+        show_progress: bool = True,
+    ):
+        """"""Compute the scores of sequences that are paired by species
+        Args:
+            take_num_seqs: max number of sequence per species
+            max_num_msas: max number of sequence in an MsaBlock
+            max_num_species: max number of species to be processed
+        """"""
+        msa_blocks = self._build_msa_blocks(
+            species_dict, msas_dict, take_num_seqs=take_num_seqs
+        )
+
+        cur_msa_block = MsaBlock(
+            msas_dict, {chain_id: [0] for chain_id in msas_dict}
+        )
+        sequences_scores = {
+            chain_id: {
+                '0': {
+                    'description': str(msa.descriptions[0]),
+                    'score': 1e6,
+                    'block_num': -1,
+                }
+            } for chain_id, msa in msas_dict.items()
+        }
+        # print(repr_layers)
+        # exit()
+        def _score_cur_block():
+            if not hasattr(_score_cur_block, 'block_num'):
+                _score_cur_block.block_num = 0
+            _score_cur_block.block_num += 1
+            chain_msas = cur_msa_block.get_msas()
+            rows = cur_msa_block.get_rows()
+            for chain_id, chain_msa in chain_msas.items():   
+                try:
+                    scores_ = self.score(chain_msa, max_num_msas, is_cpu = False, repr_layers=repr_layers)
+                except:
+                    scores_ = self.score(chain_msa, max_num_msas, is_cpu = True, repr_layers=repr_layers)
+                rows_ = rows[chain_id]
+                # print(len(scores_), len(rows_))
+                assert len(scores_) + 1 == len(rows_)
+                for i, (r, s) in enumerate(zip(rows_[1:], scores_), start=1):
+                    r = str(int(r))
+                    assert r not in sequences_scores[chain_id]
+                    # if r in sequences_scores[chain_id]:
+                    #     print(""orig:"", sequences_scores[chain_id][r])
+                    #     print(""cur: "",  {
+                    #     'description': 
+                    #         str(chain_msa.descriptions[i]).split()[0],
+                    #     'score': float(s),
+                    #     'block_num': _score_cur_block.block_num,
+                    #     })
+                    #     print(r)
+
+                    sequences_scores[chain_id][r] = {
+                        'description': 
+                            str(chain_msa.descriptions[i]).split()[0],
+                        'score': float(s),
+                        'block_num': _score_cur_block.block_num,
+                    }
+
+        all_msa_blocks = list(msa_blocks.items())
+        if max_num_species > 0:
+            all_msa_blocks = all_msa_blocks[:max_num_species]
+        if show_progress:
+            progress = tqdm(all_msa_blocks)
+        else:
+            progress = all_msa_blocks
+
+        for spec, msa_block in progress:
+            cur_lengths = cur_msa_block.get_lengths()
+            next_lengths = {
+                chain_id:
+                this_length if chain_id not in cur_lengths else
+                this_length + cur_lengths[chain_id]
+                for chain_id, this_length in msa_block.get_lengths().items()
+            }
+            # print(next_lengths, max_num_msas)
+            if max(next_lengths.values()) >= max_num_msas:
+                _score_cur_block()
+                cur_msa_block = MsaBlock(
+                    msas_dict, {chain_id: [0] for chain_id in msas_dict}
+                )
+            cur_msa_block += msa_block
+
+        if max(cur_msa_block.get_lengths().values()) > 1:
+            _score_cur_block()
+
+        return sequences_scores
+
+    def _build_msa_blocks(
+        self, species_dict, msas_dict, gap_cutoff=0.4, take_num_seqs=128,
+    ):
+        def _filter_rows(df):
+            df = df.sort_values('msa_similarity', axis=0, ascending=False)
+            rows = df.msa_row[df.gap <= gap_cutoff].iloc[:take_num_seqs].values
+            return rows.astype(int)
+
+        msa_blocks = {}
+        for spec, dfs in species_dict.items():
+            rows_dict = {}
+            if spec == b'':
+                continue
+
+            for chain_id, df in dfs.items():
+                rows = _filter_rows(df)
+                if len(rows) < 1:
+                    continue
+                rows_dict[chain_id] = rows
+
+            if len(rows_dict) < 2:
+                continue
+
+            msa_blocks[spec] = MsaBlock(msas_dict, rows_dict)
+
+        return msa_blocks
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/esm_scoring.py",".py","12303","324","from asyncio import FastChildWatcher
+from importlib.machinery import all_suffixes
+import string
+from tkinter.tix import Tree
+from typing import List, Tuple, Mapping
+
+from tqdm import tqdm
+import torch
+import pandas as pd
+from alphafold.data import parsers
+import torch.nn.functional as F
+
+from msa_pair.data.msa_processing import MsaBlock
+
+class EsmScoring:
+    def __init__(self, msa_transformer, msa_batch_converter, tag, inter_tag=False):
+        self.msa_transformer = msa_transformer.eval()
+        self.msa_batch_converter = msa_batch_converter
+        deletekeys = dict.fromkeys(string.ascii_lowercase)
+        deletekeys["".""] = None
+        deletekeys[""*""] = None
+        self.translation = str.maketrans(deletekeys)
+        self.inter_tag = inter_tag
+        self.is_cpu = False
+        self.tag = tag
+
+    def set_device(self, is_cpu):
+        self.is_cpu = is_cpu
+        return self.is_cpu
+
+
+    def _read_msa(
+        self,
+        input_msa: parsers.Msa,
+        nseq: int
+    ) -> List[Tuple[str, str]]:
+        def remove_insertions(sequence: str) -> str:
+            """""" Removes any insertions into the sequence. Needed to load 
+                aligned sequences in an MSA.
+            """"""
+            return sequence.translate(self.translation)
+        input_msa = [
+            (desc, seq) for desc, seq in zip(
+                input_msa.descriptions[:nseq], input_msa.sequences[:nseq]
+            )
+        ]
+        return [ (desc, remove_insertions(seq)) for desc, seq in input_msa ]
+
+    def sim_score(self, input_msa: parsers.Msa, max_num_msas: int, is_cpu = False, repr_layers=[12]):
+        """"""Compute the Cosim scores
+        """"""
+        assert max_num_msas <= 1024
+        msa_data = [ self._read_msa(input_msa, max_num_msas) ]
+        msa_batch_labels, msa_batch_strs, msa_batch_tokens = \
+            self.msa_batch_converter(msa_data)
+        if not is_cpu:
+            msa_transformer = self.msa_transformer.cuda()
+            msa_batch_tokens = msa_batch_tokens.cuda()
+        else:
+            msa_transformer = self.msa_transformer.cpu()
+            msa_batch_tokens = msa_batch_tokens.cpu()
+
+        with torch.no_grad():
+            repre = msa_transformer(
+                msa_batch_tokens, 
+                repr_layers=repr_layers
+            )['representations'][repr_layers[0]]
+            repre = repre.mean(-2)
+            target_emb = F.normalize(repre[:, :1], p=2, dim=-1)
+            msas_emb = F.normalize(repre[:,1:], p=2,dim=-1)
+            # print(target_emb.size(), msas_emb.size())
+            if self.inter_tag:
+                return msas_emb
+            else:
+                target2sim = torch.bmm(target_emb, msas_emb.transpose(-1,-2)).reshape(-1).cpu().numpy()
+                return target2sim
+
+
+    def score(self, input_msa: parsers.Msa, max_num_msas: int, is_cpu = False, repr_layers=[]):
+        """"""Compute the ColAttn scores
+        """"""
+        assert max_num_msas <= 1024
+        msa_data = [ self._read_msa(input_msa, max_num_msas) ]
+        msa_batch_labels, msa_batch_strs, msa_batch_tokens = \
+            self.msa_batch_converter(msa_data)
+        if not is_cpu:
+            msa_transformer = self.msa_transformer.cuda()
+            msa_batch_tokens = msa_batch_tokens.cuda()
+        else:
+            msa_transformer = self.msa_transformer.cpu()
+            msa_batch_tokens = msa_batch_tokens.cpu()
+        with torch.no_grad():
+            all_info = msa_transformer(
+                msa_batch_tokens, need_head_weights=True
+            )
+            col_attention = all_info['col_attentions']
+            B, C, R, R = col_attention.size()
+            # B, C, R
+            col_attention = col_attention[:, :, 0, :]
+            col_attention = col_attention.mean(-2).cpu().numpy()
+
+        return col_attention[0][1:] # R - 1
+
+    def score_sequences(
+        self,
+        species_dict: Mapping[str, Mapping[str, pd.DataFrame]],
+        msas_dict: Mapping[str, parsers.Msa],
+        take_num_seqs: int = 128,
+        max_num_msas: int = 256,
+        max_num_species: int = -1,
+        show_progress: bool = True,
+    ):
+        """"""Compute the scores of sequences that are paired by species
+        Args:
+            take_num_seqs: max number of sequence per species
+            max_num_msas: max number of sequence in an MsaBlock
+            max_num_species: max number of species to be processed
+        """"""
+        msa_blocks = self._build_msa_blocks(
+            species_dict, msas_dict, take_num_seqs=take_num_seqs
+        )
+
+        cur_msa_block = MsaBlock(
+            msas_dict, {chain_id: [0] for chain_id in msas_dict}
+        )
+        sequences_scores = {
+            chain_id: {
+                '0': {
+                    'description': str(msa.descriptions[0]),
+                    'score': 1e6,
+                    'block_num': -1,
+                }
+            } for chain_id, msa in msas_dict.items()
+        }
+        def _score_cur_block():
+            if not hasattr(_score_cur_block, 'block_num'):
+                _score_cur_block.block_num = 0
+            _score_cur_block.block_num += 1
+            chain_msas = cur_msa_block.get_msas()
+            rows = cur_msa_block.get_rows()
+            for chain_id, chain_msa in chain_msas.items():
+                if self.tag == 'sim':
+                    try:
+                        scores_ = self.sim_score(chain_msa, max_num_msas, is_cpu = False)
+                    except:
+                        scores_ = self.sim_score(chain_msa, max_num_msas, is_cpu = True)
+                elif self.tag == 'col':
+                    try:
+                        scores_ = self.score(chain_msa, max_num_msas, is_cpu = False)
+                    except:
+                        scores_ = self.score(chain_msa, max_num_msas, is_cpu = True)
+                else:
+                    raise ValueError(f""No such metrics {self.tag} !"")
+                rows_ = rows[chain_id]
+                # print(len(scores_), len(rows_))
+                assert len(scores_) + 1 == len(rows_)
+                for i, (r, s) in enumerate(zip(rows_[1:], scores_), start=1):
+                    r = str(int(r))
+                    assert r not in sequences_scores[chain_id]
+                    # if r in sequences_scores[chain_id]:
+                    #     print(""orig:"", sequences_scores[chain_id][r])
+                    #     print(""cur: "",  {
+                    #     'description': 
+                    #         str(chain_msa.descriptions[i]).split()[0],
+                    #     'score': float(s),
+                    #     'block_num': _score_cur_block.block_num,
+                    #     })
+                    #     print(r)
+
+                    sequences_scores[chain_id][r] = {
+                        'description': 
+                            str(chain_msa.descriptions[i]).split()[0],
+                        'score': float(s),
+                        'block_num': _score_cur_block.block_num,
+                    }
+
+        all_msa_blocks = list(msa_blocks.items())
+        if max_num_species > 0:
+            all_msa_blocks = all_msa_blocks[:max_num_species]
+        if show_progress:
+            progress = tqdm(all_msa_blocks)
+        else:
+            progress = all_msa_blocks
+
+        for spec, msa_block in progress:
+            cur_lengths = cur_msa_block.get_lengths()
+            next_lengths = {
+                chain_id:
+                this_length if chain_id not in cur_lengths else
+                this_length + cur_lengths[chain_id]
+                for chain_id, this_length in msa_block.get_lengths().items()
+            }
+            # print(next_lengths, max_num_msas)
+            if max(next_lengths.values()) >= max_num_msas:
+                _score_cur_block()
+                cur_msa_block = MsaBlock(
+                    msas_dict, {chain_id: [0] for chain_id in msas_dict}
+                )
+            cur_msa_block += msa_block
+
+        if max(cur_msa_block.get_lengths().values()) > 1:
+            _score_cur_block()
+
+        return sequences_scores
+
+    def _build_msa_blocks(
+        self, species_dict, msas_dict, gap_cutoff=0.4, take_num_seqs=128,
+    ):
+        def _filter_rows(df):
+            df = df.sort_values('msa_similarity', axis=0, ascending=False)
+            rows = df.msa_row[df.gap <= gap_cutoff].iloc[:take_num_seqs].values
+            return rows.astype(int)
+
+        msa_blocks = {}
+        for spec, dfs in species_dict.items():
+            rows_dict = {}
+            if spec == b'':
+                continue
+
+            for chain_id, df in dfs.items():
+                rows = _filter_rows(df)
+                if len(rows) < 1:
+                    continue
+                rows_dict[chain_id] = rows
+
+            if len(rows_dict) < 2:
+                continue
+
+            msa_blocks[spec] = MsaBlock(msas_dict, rows_dict)
+
+        return msa_blocks
+
+    def score_inter_sequences(
+        self,
+        species_dict: Mapping[str, Mapping[str, pd.DataFrame]],
+        msas_dict: Mapping[str, parsers.Msa],
+        take_num_seqs: int = 128,
+        max_num_msas: int = 256,
+        max_num_species: int = -1,
+        show_progress: bool = True,
+    ):
+        """"""Compute the scores of sequences that are paired by species
+        Args:
+            take_num_seqs: max number of sequence per species
+            max_num_msas: max number of sequence in an MsaBlock
+            max_num_species: max number of species to be processed
+        """"""
+        msa_blocks = self._build_msa_blocks(
+            species_dict, msas_dict, take_num_seqs=take_num_seqs
+        )
+
+        cur_msa_block = MsaBlock(
+            msas_dict, {chain_id: [0] for chain_id in msas_dict}
+        )
+        cur_spec_len = []
+        sequences_scores = {}
+        def _score_cur_block():
+            if not hasattr(_score_cur_block, 'block_num'):
+                _score_cur_block.block_num = 0
+            _score_cur_block.block_num += 1
+            chain_msas = cur_msa_block.get_msas()
+            rows = cur_msa_block.get_rows()
+            chain2emb = {}
+            for chain_id, chain_msa in chain_msas.items():
+                try:
+                    seqEmb = self.sim_score(chain_msa, max_num_msas)
+                except:
+                    seqEmb = self.sim_score(chain_msa, max_num_msas, True)
+                chain2emb[chain_id] = seqEmb
+
+            cur_sa = 0
+            cur_sb = 0
+
+            for each in cur_spec_len:
+                spec, chainLen = each
+                Alen, Blen = chainLen['A'], chainLen['B'] 
+                seqA_emb = chain2emb['A'][:, cur_sa:(cur_sa+Alen)]
+                seqB_emb = chain2emb['B'][:, cur_sb:(cur_sb+Blen)]
+
+                inter_sims = torch.bmm(seqA_emb, seqB_emb.transpose(-1,-2)).squeeze(0).cpu().numpy()
+
+                # print(inter_sims.shape)
+                rowsA = rows['A'][(cur_sa + 1) : (cur_sa + Alen + 1)]
+                rowsB = rows['B'][(cur_sb + 1) : (cur_sb + Blen + 1)]
+
+                cur_sa += Alen
+                cur_sb += Blen
+
+                assert spec not in sequences_scores
+                sequences_scores[spec]={
+                    ""rowsA"": rowsA,
+                    ""rowsB"": rowsB,
+                    ""sims"": inter_sims
+                }
+
+        all_msa_blocks = list(msa_blocks.items())
+        if max_num_species > 0:
+            all_msa_blocks = all_msa_blocks[:max_num_species]
+        if show_progress:
+            progress = tqdm(all_msa_blocks)
+        else:
+            progress = all_msa_blocks
+
+        for spec, msa_block in progress:
+            cur_lengths = cur_msa_block.get_lengths()
+            next_lengths = {
+                chain_id:
+                this_length if chain_id not in cur_lengths else
+                this_length + cur_lengths[chain_id]
+                for chain_id, this_length in msa_block.get_lengths().items()
+            }
+            if max(next_lengths.values()) >= max_num_msas:
+                _score_cur_block()
+                cur_msa_block = MsaBlock(
+                    msas_dict, {chain_id: [0] for chain_id in msas_dict}
+                )
+                cur_spec_len = []
+            cur_msa_block += msa_block
+            cur_spec_len.append((spec, msa_block.get_lengths()))
+
+        if max(cur_msa_block.get_lengths().values()) > 1:
+            _score_cur_block()
+
+        return sequences_scores","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/esm_pairing.py",".py","3024","89","import os
+import json
+from typing import List, Mapping
+
+import numpy as np
+
+from alphafold.data import parsers, msa_pairing, feature_processing
+from alphafold.common import residue_constants
+
+def _upgrade_sequences_scores(sequence_scores):
+    processed_scores = {}
+    for result in sequence_scores.values():
+        desc = result['description']
+        score = result['score']
+        processed_scores[desc] = score
+
+    return processed_scores
+
+def create_paired_rows_dict(
+    species_dict,
+    msas_dict,
+    sequences_scores,
+    chain_ids: List[str] = ['A', 'B'],
+) -> Mapping[str, List[int]]:
+
+    # upgrade sequences scores 
+    for chain_id in chain_ids:
+        sequences_scores[chain_id] = _upgrade_sequences_scores(
+            sequences_scores[chain_id]
+        )
+
+    paired_rows_dict = {chain_id: [0] for chain_id in chain_ids}
+    pair_scores = [ np.full((1, len(chain_ids)), 1e6) ]
+    for spec, dfs in species_dict.items():
+        if spec == b'':
+            continue
+
+        # find and sort scores
+        scores_ = {}
+        for chain_id, df in dfs.items():
+            chain_scores_ = []
+            rows = df.msa_row.values
+            for r in rows:
+                desc = msas_dict[chain_id].descriptions[r].split()[0]
+                if desc in sequences_scores[chain_id]:
+                    s = sequences_scores[chain_id][desc]
+                    chain_scores_.append((int(r), s))
+
+            if len(chain_scores_) >= 1:
+                scores_[chain_id] = sorted(
+                    chain_scores_, key=lambda v: v[-1], reverse=True,
+                )
+
+        # match rows within the species
+        if len(scores_) > 1:
+            num_seqs = min(len(v) for v in scores_.values())
+            pair_scores_ = []
+            for chain_id in chain_ids:
+                if chain_id in scores_:
+                    chain_rows_ = [
+                        _[0] for _ in scores_[chain_id][:num_seqs]
+                    ]
+                    chain_scores_ = [
+                        _[-1] for _ in scores_[chain_id][:num_seqs]
+                    ]
+                else:
+                    chain_rows_ = [-1] * num_seqs
+                    chain_scores_ = [0.] * num_seqs
+
+                paired_rows_dict[chain_id] += chain_rows_
+                pair_scores_ += [np.array(chain_scores_)[:,None]]
+
+            pair_scores.append(np.concatenate(pair_scores_, axis=-1))
+
+    # sort rows by their pair scores
+    pair_scores = np.concatenate(pair_scores, axis=0)
+    # inds_sorted = np.argsort(np.sum(pair_scores, axis=-1))[::-1]
+    inds_sorted = np.argsort(np.sum(pair_scores, axis=-1))
+    paired_rows_dict  = {
+        chain_id: [rows[i] for i in inds_sorted] for chain_id, rows in 
+        paired_rows_dict.items()
+    }
+    assert len(pair_scores) == len(paired_rows_dict[chain_ids[0]])
+    # check the first row is always zero (that is, the first sequence is 
+    # always the query sequence)
+    assert all(rows[0] == 0 for rows in paired_rows_dict.values())
+
+    return paired_rows_dict
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/alphafold_pipeline.py",".py","3894","104","import os
+import copy
+import json
+import logging
+import dataclasses
+
+import numpy as np
+from alphafold.data import (
+    pipeline, pipeline_multimer, parsers, msa_pairing, feature_processing
+)
+
+from msa_pair.data import pairing_pipeline
+
+logger = logging.getLogger(__file__)
+
+class AlphaFoldPipeline:
+    def _all_seq_msa_features(self, hit_path, sequence):
+        with open(hit_path, 'rt') as fh:
+            a3m_str = fh.read()
+        msa = parsers.parse_a3m(a3m_str)
+        assert msa.sequences[0] == sequence
+        all_seq_features = pipeline.make_msa_features([msa])
+        valid_feats = msa_pairing.MSA_FEATURES + (
+            'msa_species_identifiers',
+        )
+        feats = {
+            f'{k}_all_seq': v for k, v in all_seq_features.items()
+            if k in valid_feats
+        }
+
+        return feats
+
+    def process(self, input_dir, chain_ids=['A', 'B']):
+        input_fasta_path = os.path.join(input_dir, 'multimer.fasta')
+        with open(input_fasta_path) as f:
+            input_fasta_str = f.read()
+        input_seqs, input_descs = parsers.parse_fasta(input_fasta_str)
+
+        chain_id_map = pipeline_multimer._make_chain_id_map(
+            sequences=input_seqs,
+            descriptions=input_descs
+        )
+        chain_id_map_path = os.path.join(input_dir, 'chain_id_map.json')
+        with open(chain_id_map_path, 'w') as f:
+            chain_id_map_dict = {
+                chain_id: dataclasses.asdict(fasta_chain)
+                for chain_id, fasta_chain in chain_id_map.items()
+            }
+            json.dump(chain_id_map_dict, f, indent=4, sort_keys=True)
+
+        all_chain_features = {}
+        sequence_features = {}
+        is_homomer_or_monomer = len(set(input_seqs)) == 1
+        for chain_id, fasta_chain in chain_id_map.items():
+            if fasta_chain.sequence in sequence_features:
+                all_chain_features[chain_id] = copy.deepcopy(
+                    sequence_features[fasta_chain.sequence]
+                )
+                continue
+            num_res = len(fasta_chain.sequence)
+            sequence_features = pipeline.make_sequence_features(
+                sequence=fasta_chain.sequence,
+                description=fasta_chain.description,
+                num_res=num_res
+            )
+            uniclust_path = os.path.join(input_dir, chain_id, 'uniclust30.a3m')
+            # uniclust_path = os.path.join(input_dir, chain_id, 'uniref90.a3m')
+            with open(uniclust_path) as fh:
+                a3m_str = fh.read()
+                uniclust_msa = parsers.parse_a3m(a3m_str)
+            assert uniclust_msa.sequences[0] == fasta_chain.sequence
+            msa_features = pipeline.make_msa_features((uniclust_msa,))
+            # uniprot_hits.a3m
+            uniprot_path = os.path.join(input_dir, chain_id, 'uniprot.a3m')
+            # uniprot_path = os.path.join(input_dir, chain_id, 'uniprot_hits.a3m')
+            msa_all_seq_features = self._all_seq_msa_features(
+                uniprot_path, fasta_chain.sequence
+            )
+
+            chain_features = {
+                **msa_all_seq_features,
+                **sequence_features,
+                **msa_features,
+                **pairing_pipeline._make_empty_templates_features(num_res),
+            }
+            chain_features = pipeline_multimer.convert_monomer_features(
+                chain_features, chain_id=chain_id
+            )
+            all_chain_features[chain_id] = chain_features
+            sequence_features[fasta_chain.sequence] = chain_features
+
+        all_chain_features = pipeline_multimer.add_assembly_features(
+            all_chain_features
+        )
+
+        np_example = feature_processing.pair_and_merge(
+            all_chain_features=all_chain_features
+        )
+
+        # Pad MSA to avoid zero-sized extra_msa.
+        np_example = pipeline_multimer.pad_msa(np_example, 512)
+
+        return np_example
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/evo_pipeline/species_processing.py",".py","3253","97","import os
+import string
+from collections import defaultdict
+from msa_pair.data import species_processing
+from alphafold.data import parsers
+from Bio import SeqIO
+from typing import List, Tuple
+import itertools
+import string
+import numpy as np
+import json
+
+deletekeys = dict.fromkeys(string.ascii_lowercase)
+deletekeys["".""] = None
+deletekeys[""*""] = None
+translation = str.maketrans(deletekeys)
+
+
+def convert_seq_desc_to_Msa(sequences, descriptions):
+    deletion_matrix = []
+    for msa_sequence in sequences:
+        deletion_vec = []
+        deletion_count = 0
+        for j in msa_sequence:
+            if j.islower():
+                deletion_count += 1
+            else:
+                deletion_vec.append(deletion_count)
+                deletion_count = 0
+        deletion_matrix.append(deletion_vec)
+
+    # Make the MSA matrix out of aligned (deletion-free) sequences.
+    deletion_table = str.maketrans('', '', string.ascii_lowercase)
+    aligned_sequences = [s.translate(deletion_table) for s in sequences]
+    return parsers.Msa(sequences=aligned_sequences,
+                        deletion_matrix=deletion_matrix,
+                        descriptions=descriptions)
+
+
+def read_sequence(filename: str) -> Tuple[str, str]:
+    """""" Reads the first (reference) sequences from a fasta or MSA file.""""""
+    record = next(SeqIO.parse(filename, ""fasta""))
+    return record.description, str(record.seq)
+
+def remove_insertions(sequence: str) -> str:
+    """""" Removes any insertions into the sequence. Needed to load aligned sequences in an MSA. """"""
+    return sequence.translate(translation)
+
+def read_msa(filename: str, nseq: int) -> List[Tuple[str, str]]:
+    """""" Reads the first nseq sequences from an MSA file, automatically removes insertions.""""""
+    return [(record.description, remove_insertions(str(record.seq)))
+            for record in itertools.islice(SeqIO.parse(filename, ""fasta""), nseq)]
+
+def parse_pairs(
+    input_dir: str,
+    paired_row_dict: list,
+    chain_ids=['A', 'B'], 
+    pair_species=False,
+):
+
+    grouped_paths = {
+        chain_id: 
+            os.path.join(input_dir, chain_id, 'uniprot.a3m')
+        for chain_id in chain_ids
+    }
+    msas_dict = {}
+    msa_feats_dict = {}
+    chain_ids = [""A"", ""B""]
+
+    if pair_species:
+        all_species_dict = defaultdict(dict)
+    for chain_id, paths in grouped_paths.items():
+        msas = []
+        msa = read_msa(paths, nseq=100000) 
+        msa = [msa[_] for _ in paired_row_dict[chain_id]]
+        descriptions = [_[0] for _ in msa]
+        sequences = [_[1] for _ in msa]
+        msas.append(convert_seq_desc_to_Msa(sequences, descriptions))
+        msa_feat, processed_msa = species_processing.make_msa_features(msas)
+
+        if pair_species:
+            msa_df = species_processing.make_msa_df(msa_feat)
+            species_dict = species_processing.create_species_dict(msa_df)
+            for spec, df in species_dict.items():
+                if spec == b'':
+                    continue
+                all_species_dict[spec][chain_id] = df
+
+        msas_dict[chain_id] = processed_msa
+        msa_feats_dict[chain_id] = msa_feat
+    
+    if pair_species:
+        return all_species_dict, msas_dict, msa_feats_dict
+    else:
+        return msas_dict, msa_feats_dict
+
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/evo_pipeline/model_preset_runner.py",".py","6167","189","import os
+import time
+import random
+import logging
+from typing import Mapping, Optional, Sequence, List
+
+import jax
+import tree
+import numpy as np
+
+from alphafold.data import pipeline_multimer, msa_pairing
+from alphafold.model import config, data, model
+# from msa_pair.runner import model, modules_multimer
+
+logger = logging.getLogger(__file__)
+
+
+def clear_mem(device=None):
+    '''remove all data from device'''
+    backend = jax.lib.xla_bridge.get_backend(device)
+    if hasattr(backend,'live_buffers'):
+        for buf in backend.live_buffers():
+            buf.delete()
+
+
+def _is_params_transferable(old_params, next_params):
+    def _get_all_keys(params):
+        all_keys = []
+        for path in params.keys():
+            for k in params[path].keys():
+                all_keys.append(f'{path}/{k}')
+        return tuple(sorted(all_keys))
+
+    return _get_all_keys(old_params) == _get_all_keys(next_params)
+
+
+class ModelPresetRunner:
+    def __init__(
+        self,
+        database: str,
+        model_preset: str = 'multimer',
+        allow_params_transfer: bool = True,
+        cache_params: bool = True,
+        ignore_unpaired_sequences: bool = True,
+    ):
+        assert model_preset == 'multimer', 'Only supports preset multimer'
+
+        self.model_preset = model_preset
+        self.database = database
+        self.allow_params_transfer = allow_params_transfer
+        self.cache_params = cache_params
+
+        self.params_dict = {}
+        # Check model parameters
+        first_params, first_model_name = None, None
+        first_config = None
+
+        self.avail_model_names = []
+        for ind, model_name in enumerate(config.MODEL_PRESETS[model_preset]):
+            try:
+                params = data.get_model_haiku_params(
+                    model_name, self.database
+                )
+                if first_params is None:
+                    first_model_name = model_name
+                    first_params = params
+                    first_config = config.model_config(model_name)
+                    print(ind)
+                elif self.allow_params_transfer:
+                    if not _is_params_transferable(first_params, params):
+                        continue
+                    if first_config != config.model_config(model_name):
+                        continue
+                self.avail_model_names.append(model_name)
+            except FileNotFoundError as e:
+                continue
+
+        assert len(self.avail_model_names) >= 1
+
+        print(type(first_config))
+        # first_config[""num_recycle""] = 1
+
+        print(f'{len(self.avail_model_names)} models are available')
+        print(f'Build RunModel {first_model_name}')
+        self.running_model = model.RunModel(first_config, first_params)
+
+        self.ignore_unpaired_sequences = ignore_unpaired_sequences
+
+    def predict(
+        self,
+        feat: Mapping[str, np.ndarray],
+        rng_seed: Optional[int] = None,
+        model_names: Optional[List[str]] = None,
+        num_predictions_per_model: int = 5,
+    ):
+        if rng_seed is not None:
+            rng = np.random.default_rng(rng_seed)
+        else:
+            rng = np.random.default_rng(random.randrange(1, 2**24))
+
+        if model_names is None:
+            model_names = self.avail_model_names
+        else:
+            model_names = [
+                model_name for model_name in model_names if model_name in 
+                self.avail_model_names
+            ]
+
+        outputs = {}
+        for model_name in model_names:
+            for pred_num in range(num_predictions_per_model):
+                seed = int(rng.integers(1, 2**24))
+                result, timing = self.run_model(
+                    feat, model_name, seed
+                )
+                outputs[f'{model_name}_{pred_num}'] = {
+                    'result': result,
+                    'timing': timing,
+                    'seed': seed,
+                }
+            logger.info(tree.map_structure(lambda x: x.shape, result))
+
+        return outputs
+
+    def run_model(
+        self,
+        feat: Mapping[str, np.ndarray],
+        model_name: str,
+        random_seed: int,
+    ):
+        t0 = time.time()
+
+        if not self.cache_params or model_name not in self.params_dict:
+            params = data.get_model_haiku_params(model_name, self.database)
+            if self.cache_params:
+                self.params_dict[model_name] = params
+        else:
+            params = self.params_dict[model_name]
+
+        if self.running_model is not None and self.allow_params_transfer:
+            logger.info(f'Transfer {model_name} params to the running model')
+            for path in params.keys():
+                self.running_model.params[path] = params[path]
+
+        logger.info(
+            f'Start prediction using {model_name} with seed {random_seed}'
+        )
+        if self.ignore_unpaired_sequences:
+            feat = self._remove_unpaired_sequences(feat)
+        result = self.running_model.predict(feat, random_seed)
+        t1 = time.time()
+
+        logger.info(
+            f'Finish prediction using {model_name} in {t1 - t0} seconds'
+        )
+        # exit()
+        timing = t1 - t0
+
+        return result, timing
+
+    def _remove_unpaired_sequences(
+        self,
+        feat: Mapping[str, np.ndarray],
+    ):
+        paired_sequence_mask = 1
+        for chain_id in np.unique(feat['asym_id']):
+            if chain_id:
+                chain_mask = feat['asym_id'] == chain_id
+                paired_sequence_mask *= np.sum(
+                    feat['msa'][:,chain_mask] != msa_pairing.MSA_GAP_IDX,
+                    axis=-1,
+                ) > 0
+        paired_sequence_mask = paired_sequence_mask.astype(bool)
+        for key, value in feat.items():
+            if key in (
+                'msa', 
+                'deletion_matrix',
+                'bert_mask',
+                'msa_mask', 
+                'cluster_bias_mask',
+            ):
+                feat[key] = value[paired_sequence_mask]
+            elif key in ('num_alignments',):
+                feat[key] = np.sum(paired_sequence_mask)
+
+        feat = pipeline_multimer.pad_msa(feat, 512)
+
+        return feat
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/evo_pipeline/pair_process.py",".py","4836","124","import os
+import copy
+import json
+import logging
+import argparse
+
+from typing import Mapping, List
+
+from tqdm import tqdm
+
+import tree
+import numpy as np
+from alphafold.data import (
+   pipeline, pipeline_multimer
+)
+from alphafold.common import residue_constants
+
+from msa_pair.data.evo_pipeline.species_processing import parse_pairs
+from msa_pair.data.evo_pipeline import feature_processing
+from msa_pair.data.evo_pipeline import msa_pairing
+
+logger = logging.getLogger(__file__)
+
+def _make_all_seq_msa_features(msa_feats):
+    return {
+        f'{k}_all_seq': v for k, v in msa_feats.items() if k in (
+            msa_pairing.MSA_FEATURES + ('msa_species_identifiers',)
+        )
+    }
+
+
+def _make_empty_templates_features(num_res):
+    """"""Construct a default template with all zeros.""""""                           
+    return {
+        'template_aatype':
+            np.zeros(
+                (1, num_res, len(residue_constants.restypes_with_x_and_gap)),
+                np.float32
+            ),
+        'template_all_atom_masks':
+            np.zeros(
+                (1, num_res, residue_constants.atom_type_num), np.float32
+            ),
+        'template_all_atom_positions':
+            np.zeros(
+                (1, num_res, residue_constants.atom_type_num, 3), np.float32
+            ),
+        'template_domain_names': np.array([''.encode()], dtype=object),
+        'template_sequence': np.array([''.encode()], dtype=object),
+        'template_sum_probs': np.array([0], dtype=np.float32),
+    }
+
+
+class PairingPipeline:
+    def process(self, input_dir, paired_rows_dict):
+        logger.info(f'Start building')
+        # load paired msas
+        # msa_feats_dict: dict_keys(['deletion_matrix_int', 'msa', 'num_alignments', 'msa_species_identifiers'])
+        msas_all_seq_dict, msa_all_seq_feats_dict = parse_pairs(
+            input_dir, paired_rows_dict
+        )
+
+        # msas_dict: {A/B:{sequences:[n_seq, seq_length], descriptions:[n_seq, -1]}}
+        # build merged feature
+        chains_dict = {}
+        for chain_id, msa in msas_all_seq_dict.items():
+            seq, desc = msa.sequences[0], msa.descriptions[0]  # parimary seq
+            num_res = len(seq)
+            chain = {
+                **_make_all_seq_msa_features(msa_all_seq_feats_dict[chain_id]),  # 'deletion_matrix_int_all_seq', 'msa_all_seq', 'num_alignments_all_seq', 'msa_species_identifiers_all_seq'
+                # **msa_feats_dict[chain_id],   # 'deletion_matrix_int', 'msa_all', 'num_alignments', 'msa_species_identifiers'
+                **pipeline.make_sequence_features(seq, desc, num_res),  # 'aatype', 'between_segment_residues', 'domain_name', 'residue_index', 'seq_length', 'sequence'
+                **_make_empty_templates_features(num_res),  # 'template_aatype', 'template_all_atom_masks', 'template_all_atom_positions', 'template_domain_names', 'template_sequence', 'template_sum_probs'
+            }
+            # sequence key is the primary sequence
+
+            # 'auth_chain_id'
+            # only change the feature 'aatype' 'template_aatype' 'template_all_atom_masks' 'template_all_atom_mask
+            chains_dict[chain_id] = pipeline_multimer.convert_monomer_features(
+                chain, chain_id=chain_id
+            )
+
+        # for heterodimer (A[""sequence""] != B[""sequence""]), A,B -> A_1,B_1
+        chains_dict = pipeline_multimer.add_assembly_features(chains_dict)
+        np_example = self.pair_and_merge(chains_dict)
+        # np_example = pipeline_multimer.pad_msa(np_example, 256)
+
+        return np_example
+
+    def pair_and_merge(
+        self,
+        chains_dict: Mapping[str, pipeline.FeatureDict],
+    ) -> pipeline.FeatureDict:
+
+        feature_processing.process_unmerged_features(chains_dict)
+        chains = list(chains_dict.values())
+
+        # auth_chain_ids = [str(chain['auth_chain_id']) for chain in chains]
+        # paired_rows = build_paired_rows(auth_chain_ids, paired_rows_dict)
+        # chains = self.create_paired_features(paired_rows, chains)
+        for k in range(len(chains)):
+            chains[k]['num_alignments_all_seq'] = np.asarray(
+                chains[k][""msa_all_seq""].shape[0]
+            )
+
+        # chains = msa_pairing.deduplicate_unpaired_sequences(chains)
+        chains = feature_processing.crop_chains(
+            chains,
+            msa_crop_size=feature_processing.MSA_CROP_SIZE,
+            max_templates=feature_processing.MAX_TEMPLATES,
+            pair_msa_sequences=True,
+        )
+
+        np_example = msa_pairing.merge_chain_features(
+            np_chains_list=chains,
+            pair_msa_sequences=True,
+            max_templates=feature_processing.MAX_TEMPLATES,
+        )
+
+        np_example = feature_processing.process_final(np_example)
+        logger.info(tree.map_structure(lambda x: x.shape, np_example))
+
+        return np_example
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/evo_pipeline/inference.py",".py","2913","98","import pair_process
+
+""""""AlphaFold protein structure prediction.""""""
+import os
+import sys
+import time
+import random
+import logging
+import argparse
+from tqdm import tqdm
+
+import torch
+import numpy as np
+from alphafold.common import residue_constants
+from alphafold.model import model as alphafold_model
+
+from msa_pair.runner import utils
+import model_preset_runner
+
+logger = logging.getLogger(__file__)
+
+
+@torch.no_grad()
+def run_alphafold(
+    processed_feature_dict,
+    model_runner,
+    random_seed: int,
+    max_num_res: int = -1,
+    num_predictions_per_model: int = 1,
+):
+    num_res = len(processed_feature_dict['aatype'])
+    if max_num_res >= 0 and num_res > max_num_res:
+        logger.warning(f'Too many residues {num_res}\n')
+        return
+
+    all_outputs = model_runner.predict(
+        processed_feature_dict,
+        rng_seed=random_seed,
+        num_predictions_per_model=num_predictions_per_model,
+    )
+
+    return all_outputs
+
+
+""""""for testing""""""
+from Bio import SeqIO
+from typing import List, Tuple
+import itertools
+import string
+import json
+
+deletekeys = dict.fromkeys(string.ascii_lowercase)
+deletekeys["".""] = None
+deletekeys[""*""] = None
+translation = str.maketrans(deletekeys)
+
+def read_sequence(filename: str) -> Tuple[str, str]:
+    """""" Reads the first (reference) sequences from a fasta or MSA file.""""""
+    record = next(SeqIO.parse(filename, ""fasta""))
+    return record.description, str(record.seq)
+
+def remove_insertions(sequence: str) -> str:
+    """""" Removes any insertions into the sequence. Needed to load aligned sequences in an MSA. """"""
+    return sequence.translate(translation)
+
+def read_msa(filename: str, nseq: int) -> List[Tuple[str, str]]:
+    """""" Reads the first nseq sequences from an MSA file, automatically removes insertions.""""""
+    return [(record.description, remove_insertions(str(record.seq)))
+            for record in itertools.islice(SeqIO.parse(filename, ""fasta""), nseq)]
+
+def read_pair(filename: str):
+    with open(filename) as file:
+        json_dict = json.load(file)
+        return json_dict[""A""], json_dict[""B""]
+
+if __name__ == ""__main__"":
+    input_dir = ""/root/dataset/Old_PLM_MSA/data/5xeq""
+    msa_A = read_msa(input_dir + ""/A/uniprot.a3m"", nseq=5000)
+    msa_B = read_msa(input_dir + ""/B/uniprot.a3m"", nseq=5000)
+
+    msa_A, msa_B = msa_A[:100], msa_B[:100]
+    msa_pair = [(A, B) for A, B in zip(msa_A, msa_B)]
+    cur_pipeline = pair_process.PairingPipeline()
+    np_example = cur_pipeline.process(msa_pair)
+    print(np_example.keys())
+
+    os.environ['XLA_PYTHON_CLIENT_PREALLOCATE'] = 'false'
+    os.environ['CUDA_VISIBLE_DEVICES'] = ""7""
+
+    model_runner = model_preset_runner.ModelPresetRunner(
+        ""/root/dataset/af2_database/"",
+        ignore_unpaired_sequences=False,
+    )
+
+    num_predictions_per_model = 1
+    seed = random.randrange(1, 2**24)
+    prediction = run_alphafold(np_example, model_runner, seed, num_predictions_per_model)
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/evo_pipeline/msa_pairing.py",".py","16976","453","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Pairing logic for multimer data pipeline.""""""
+
+import collections
+import functools
+import string
+from typing import Any, Dict, Iterable, List, Sequence
+
+from alphafold.common import residue_constants
+from alphafold.data import pipeline
+import numpy as np
+import pandas as pd
+import scipy.linalg
+# from alphafold.data import (
+#    msa_pairing
+# )
+
+MSA_GAP_IDX = residue_constants.restypes_with_x_and_gap.index('-')
+SEQUENCE_GAP_CUTOFF = 0.5
+SEQUENCE_SIMILARITY_CUTOFF = 0.9
+
+MSA_PAD_VALUES = {'msa_all_seq': MSA_GAP_IDX,
+                  'msa_mask_all_seq': 1,
+                  'deletion_matrix_all_seq': 0,
+                  'deletion_matrix_int_all_seq': 0,
+                  'msa': MSA_GAP_IDX,
+                  'msa_mask': 1,
+                  'deletion_matrix': 0,
+                  'deletion_matrix_int': 0}
+
+MSA_FEATURES = ('msa', 'msa_mask', 'deletion_matrix', 'deletion_matrix_int')
+SEQ_FEATURES = ('residue_index', 'aatype', 'all_atom_positions',
+                'all_atom_mask', 'seq_mask', 'between_segment_residues',
+                'has_alt_locations', 'has_hetatoms', 'asym_id', 'entity_id',
+                'sym_id', 'entity_mask', 'deletion_mean',
+                'prediction_atom_mask',
+                'literature_positions', 'atom_indices_to_group_indices',
+                'rigid_group_default_frame')
+TEMPLATE_FEATURES = ('template_aatype', 'template_all_atom_positions',
+                     'template_all_atom_mask')
+CHAIN_FEATURES = ('num_alignments', 'seq_length')
+
+
+def create_paired_features(
+    chains: Iterable[pipeline.FeatureDict]) ->  List[pipeline.FeatureDict]:
+  """"""Returns the original chains with paired NUM_SEQ features.
+
+  Args:
+    chains:  A list of feature dictionaries for each chain.
+
+  Returns:
+    A list of feature dictionaries with sequence features including only
+    rows to be paired.
+  """"""
+  chains = list(chains)
+  chain_keys = chains[0].keys()
+
+  if len(chains) < 2:
+    return chains
+  else:
+    updated_chains = []
+    paired_chains_to_paired_row_indices = pair_sequences(chains)
+    paired_rows = reorder_paired_rows(
+        paired_chains_to_paired_row_indices)
+
+    for chain_num, chain in enumerate(chains):
+      new_chain = {k: v for k, v in chain.items() if '_all_seq' not in k}
+      for feature_name in chain_keys:
+        if feature_name.endswith('_all_seq'):
+          feats_padded = pad_features(chain[feature_name], feature_name)
+          new_chain[feature_name] = feats_padded[paired_rows[:, chain_num]]
+      new_chain['num_alignments_all_seq'] = np.asarray(
+          len(paired_rows[:, chain_num]))
+      updated_chains.append(new_chain)
+    return updated_chains
+
+
+def pad_features(feature: np.ndarray, feature_name: str) -> np.ndarray:
+  """"""Add a 'padding' row at the end of the features list.
+
+  The padding row will be selected as a 'paired' row in the case of partial
+  alignment - for the chain that doesn't have paired alignment.
+
+  Args:
+    feature: The feature to be padded.
+    feature_name: The name of the feature to be padded.
+
+  Returns:
+    The feature with an additional padding row.
+  """"""
+  assert feature.dtype != np.dtype(np.string_)
+  if feature_name in ('msa_all_seq', 'msa_mask_all_seq',
+                      'deletion_matrix_all_seq', 'deletion_matrix_int_all_seq'):
+    num_res = feature.shape[1]
+    padding = MSA_PAD_VALUES[feature_name] * np.ones([1, num_res],
+                                                     feature.dtype)
+  elif feature_name == 'msa_species_identifiers_all_seq':
+    padding = [b'']
+  else:
+    return feature
+  feats_padded = np.concatenate([feature, padding], axis=0)
+  return feats_padded
+
+
+def _make_msa_df(chain_features: pipeline.FeatureDict) -> pd.DataFrame:
+  """"""Makes dataframe with msa features needed for msa pairing.""""""
+  chain_msa = chain_features['msa_all_seq']
+  query_seq = chain_msa[0]
+  per_seq_similarity = np.sum(
+      query_seq[None] == chain_msa, axis=-1) / float(len(query_seq))
+  per_seq_gap = np.sum(chain_msa == 21, axis=-1) / float(len(query_seq))
+  msa_df = pd.DataFrame({
+      'msa_species_identifiers':
+          chain_features['msa_species_identifiers_all_seq'],
+      'msa_row':
+          np.arange(len(
+              chain_features['msa_species_identifiers_all_seq'])),
+      'msa_similarity': per_seq_similarity,
+      'gap': per_seq_gap
+  })
+  return msa_df
+
+
+def _create_species_dict(msa_df: pd.DataFrame) -> Dict[bytes, pd.DataFrame]:
+  """"""Creates mapping from species to msa dataframe of that species.""""""
+  species_lookup = {}
+  for species, species_df in msa_df.groupby('msa_species_identifiers'):
+    species_lookup[species] = species_df
+  return species_lookup
+
+
+def _match_rows_by_sequence_similarity(this_species_msa_dfs: List[pd.DataFrame]
+                                       ) -> List[List[int]]:
+  """"""Finds MSA sequence pairings across chains based on sequence similarity.
+
+  Each chain's MSA sequences are first sorted by their sequence similarity to
+  their respective target sequence. The sequences are then paired, starting
+  from the sequences most similar to their target sequence.
+
+  Args:
+    this_species_msa_dfs: a list of dataframes containing MSA features for
+      sequences for a specific species.
+
+  Returns:
+   A list of lists, each containing M indices corresponding to paired MSA rows,
+   where M is the number of chains.
+  """"""
+  all_paired_msa_rows = []
+
+  num_seqs = [len(species_df) for species_df in this_species_msa_dfs
+              if species_df is not None]
+  take_num_seqs = np.min(num_seqs)
+
+  sort_by_similarity = (
+      lambda x: x.sort_values('msa_similarity', axis=0, ascending=False))
+
+  for species_df in this_species_msa_dfs:
+    if species_df is not None:
+      species_df_sorted = sort_by_similarity(species_df)
+      msa_rows = species_df_sorted.msa_row.iloc[:take_num_seqs].values
+    else:
+      msa_rows = [-1] * take_num_seqs  # take the last 'padding' row
+    all_paired_msa_rows.append(msa_rows)
+  all_paired_msa_rows = list(np.array(all_paired_msa_rows).transpose())
+  return all_paired_msa_rows
+
+
+def pair_sequences(examples: List[pipeline.FeatureDict]
+                   ) -> Dict[int, np.ndarray]:
+  """"""Returns indices for paired MSA sequences across chains.""""""
+
+  num_examples = len(examples)
+
+  all_chain_species_dict = []
+  common_species = set()
+  for chain_features in examples:
+    msa_df = _make_msa_df(chain_features)
+    species_dict = _create_species_dict(msa_df)
+    all_chain_species_dict.append(species_dict)
+    common_species.update(set(species_dict))
+
+  common_species = sorted(common_species)
+  common_species.remove(b'')  # Remove target sequence species.
+
+  all_paired_msa_rows = [np.zeros(len(examples), int)]
+  all_paired_msa_rows_dict = {k: [] for k in range(num_examples)}
+  all_paired_msa_rows_dict[num_examples] = [np.zeros(len(examples), int)]
+
+  for species in common_species:
+    if not species:
+      continue
+    this_species_msa_dfs = []
+    species_dfs_present = 0
+    for species_dict in all_chain_species_dict:
+      if species in species_dict:
+        this_species_msa_dfs.append(species_dict[species])
+        species_dfs_present += 1
+      else:
+        this_species_msa_dfs.append(None)
+
+    # Skip species that are present in only one chain.
+    if species_dfs_present <= 1:
+      continue
+
+    if np.any(
+        np.array([len(species_df) for species_df in
+                  this_species_msa_dfs if
+                  isinstance(species_df, pd.DataFrame)]) > 600):
+      continue
+
+    paired_msa_rows = _match_rows_by_sequence_similarity(this_species_msa_dfs)
+    all_paired_msa_rows.extend(paired_msa_rows)
+    all_paired_msa_rows_dict[species_dfs_present].extend(paired_msa_rows)
+  all_paired_msa_rows_dict = {
+      num_examples: np.array(paired_msa_rows) for
+      num_examples, paired_msa_rows in all_paired_msa_rows_dict.items()
+  }
+  return all_paired_msa_rows_dict
+
+
+def reorder_paired_rows(all_paired_msa_rows_dict: Dict[int, np.ndarray]
+                        ) -> np.ndarray:
+  """"""Creates a list of indices of paired MSA rows across chains.
+
+  Args:
+    all_paired_msa_rows_dict: a mapping from the number of paired chains to the
+      paired indices.
+
+  Returns:
+    a list of lists, each containing indices of paired MSA rows across chains.
+    The paired-index lists are ordered by:
+      1) the number of chains in the paired alignment, i.e, all-chain pairings
+         will come first.
+      2) e-values
+  """"""
+  all_paired_msa_rows = []
+
+  for num_pairings in sorted(all_paired_msa_rows_dict, reverse=True):
+    paired_rows = all_paired_msa_rows_dict[num_pairings]
+    paired_rows_product = abs(np.array([np.prod(rows) for rows in paired_rows]))
+    paired_rows_sort_index = np.argsort(paired_rows_product)
+    all_paired_msa_rows.extend(paired_rows[paired_rows_sort_index])
+
+  return np.array(all_paired_msa_rows)
+
+
+def block_diag(*arrs: np.ndarray, pad_value: float = 0.0) -> np.ndarray:
+  """"""Like scipy.linalg.block_diag but with an optional padding value.""""""
+  ones_arrs = [np.ones_like(x) for x in arrs]
+  off_diag_mask = 1.0 - scipy.linalg.block_diag(*ones_arrs)
+  diag = scipy.linalg.block_diag(*arrs)
+  diag += (off_diag_mask * pad_value).astype(diag.dtype)
+  return diag
+
+
+def _correct_post_merged_feats(
+    np_example: pipeline.FeatureDict,
+    np_chains_list: Sequence[pipeline.FeatureDict],
+    pair_msa_sequences: bool) -> pipeline.FeatureDict:
+  """"""Adds features that need to be computed/recomputed post merging.""""""
+
+  np_example['seq_length'] = np.asarray(np_example['aatype'].shape[0],
+                                        dtype=np.int32)
+  np_example['num_alignments'] = np.asarray(np_example['msa'].shape[0],
+                                            dtype=np.int32)
+
+  if not pair_msa_sequences:
+    # Generate a bias that is 1 for the first row of every block in the
+    # block diagonal MSA - i.e. make sure the cluster stack always includes
+    # the query sequences for each chain (since the first row is the query
+    # sequence).
+    cluster_bias_masks = []
+    for chain in np_chains_list:
+      mask = np.zeros(chain['msa'].shape[0])
+      mask[0] = 1
+      cluster_bias_masks.append(mask)
+    np_example['cluster_bias_mask'] = np.concatenate(cluster_bias_masks)
+
+    # Initialize Bert mask with masked out off diagonals.
+    msa_masks = [np.ones(x['msa'].shape, dtype=np.float32)
+                 for x in np_chains_list]
+
+    np_example['bert_mask'] = block_diag(
+        *msa_masks, pad_value=0)
+  else:
+    np_example['cluster_bias_mask'] = np.zeros(np_example['msa'].shape[0])
+    np_example['cluster_bias_mask'][0] = 1
+
+    if np_example[""msa""].shape == np_example[""msa_all_seq""].shape:
+        msa_masks_all_seq = [np.ones(x['msa_all_seq'].shape, dtype=np.float32) for
+                                x in np_chains_list]
+        msa_mask_all_seq = np.concatenate(msa_masks_all_seq, axis=1)
+        np_example['bert_mask'] = msa_mask_all_seq
+
+    else:
+        # Initialize Bert mask with masked out off diagonals.
+        msa_masks = [np.ones(x['msa'].shape, dtype=np.float32) for
+                    x in np_chains_list]
+        msa_masks_all_seq = [np.ones(x['msa_all_seq'].shape, dtype=np.float32) for
+                            x in np_chains_list]
+
+        msa_mask_block_diag = block_diag(
+            *msa_masks, pad_value=0)
+        msa_mask_all_seq = np.concatenate(msa_masks_all_seq, axis=1)
+        np_example['bert_mask'] = np.concatenate(
+            [msa_mask_all_seq, msa_mask_block_diag], axis=0)
+  return np_example
+
+
+def _pad_templates(chains: Sequence[pipeline.FeatureDict],
+                   max_templates: int) -> Sequence[pipeline.FeatureDict]:
+  """"""For each chain pad the number of templates to a fixed size.
+
+  Args:
+    chains: A list of protein chains.
+    max_templates: Each chain will be padded to have this many templates.
+
+  Returns:
+    The list of chains, updated to have template features padded to
+    max_templates.
+  """"""
+  for chain in chains:
+    for k, v in chain.items():
+      if k in TEMPLATE_FEATURES:
+        padding = np.zeros_like(v.shape)
+        padding[0] = max_templates - v.shape[0]
+        padding = [(0, p) for p in padding]
+        chain[k] = np.pad(v, padding, mode='constant')
+  return chains
+
+
+def _merge_features_from_multiple_chains(
+    chains: Sequence[pipeline.FeatureDict],
+    pair_msa_sequences: bool) -> pipeline.FeatureDict:
+  """"""Merge features from multiple chains.
+
+  Args:
+    chains: A list of feature dictionaries that we want to merge.
+    pair_msa_sequences: Whether to concatenate MSA features along the
+      num_res dimension (if True), or to block diagonalize them (if False).
+
+  Returns:
+    A feature dictionary for the merged example.
+  """"""
+  merged_example = {}
+  for feature_name in chains[0]:
+    feats = [x[feature_name] for x in chains]
+    feature_name_split = feature_name.split('_all_seq')[0]
+    if feature_name_split in MSA_FEATURES:
+      if pair_msa_sequences or '_all_seq' in feature_name:
+        merged_example[feature_name] = np.concatenate(feats, axis=1)
+      else:
+        merged_example[feature_name] = block_diag(
+            *feats, pad_value=MSA_PAD_VALUES[feature_name])
+    elif feature_name_split in SEQ_FEATURES:
+      merged_example[feature_name] = np.concatenate(feats, axis=0)
+    elif feature_name_split in TEMPLATE_FEATURES:
+      merged_example[feature_name] = np.concatenate(feats, axis=1)
+    elif feature_name_split in CHAIN_FEATURES:
+      merged_example[feature_name] = np.sum(x for x in feats).astype(np.int32)
+    else:
+      merged_example[feature_name] = feats[0]
+  return merged_example
+
+
+def _merge_homomers_dense_msa(
+    chains: Iterable[pipeline.FeatureDict]) -> Sequence[pipeline.FeatureDict]:
+  """"""Merge all identical chains, making the resulting MSA dense.
+
+  Args:
+    chains: An iterable of features for each chain.
+
+  Returns:
+    A list of feature dictionaries.  All features with the same entity_id
+    will be merged - MSA features will be concatenated along the num_res
+    dimension - making them dense.
+  """"""
+  entity_chains = collections.defaultdict(list)
+  for chain in chains:
+    entity_id = chain['entity_id'][0]
+    entity_chains[entity_id].append(chain)
+
+  grouped_chains = []
+  for entity_id in sorted(entity_chains):
+    chains = entity_chains[entity_id]
+    grouped_chains.append(chains)
+  chains = [
+      _merge_features_from_multiple_chains(chains, pair_msa_sequences=True)
+      for chains in grouped_chains]
+  return chains
+
+
+def _concatenate_paired_and_unpaired_features(
+    example: pipeline.FeatureDict) -> pipeline.FeatureDict:
+    """"""Merges paired and block-diagonalised features.""""""
+    features = MSA_FEATURES
+    for feature_name in features:
+        if feature_name in example:
+            feat = example[feature_name]
+            feat_all_seq = example[feature_name + '_all_seq']
+            merged_feat = np.concatenate([feat_all_seq, feat], axis=0)
+            example[feature_name] = merged_feat
+        elif feature_name + ""_all_seq"" in example:
+            feat_all_seq = example[feature_name + '_all_seq']
+            example[feature_name] = feat_all_seq
+    example['num_alignments'] = np.array(example['msa'].shape[0],
+                                        dtype=np.int32)
+    return example
+
+
+def merge_chain_features(np_chains_list: List[pipeline.FeatureDict],
+                         pair_msa_sequences: bool,
+                         max_templates: int) -> pipeline.FeatureDict:
+    """"""Merges features for multiple chains to single FeatureDict.
+
+    Args:
+        np_chains_list: List of FeatureDicts for each chain.
+        pair_msa_sequences: Whether to merge paired MSAs.
+        max_templates: The maximum number of templates to include.
+
+    Returns:
+        Single FeatureDict for entire complex.
+    """"""
+    np_chains_list = _pad_templates(
+        np_chains_list, max_templates=max_templates)
+    np_chains_list = _merge_homomers_dense_msa(np_chains_list)
+    # Unpaired MSA features will be always block-diagonalised; paired MSA
+    # features will be concatenated.
+    np_example = _merge_features_from_multiple_chains(
+        np_chains_list, pair_msa_sequences=False)
+    if pair_msa_sequences:
+        np_example = _concatenate_paired_and_unpaired_features(np_example)
+    np_example = _correct_post_merged_feats(
+        np_example=np_example,
+        np_chains_list=np_chains_list,
+        pair_msa_sequences=pair_msa_sequences)
+
+    return np_example
+
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/evo_pipeline/feature_processing.py",".py","6331","168","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Feature processing logic for multimer data pipeline.""""""
+
+from typing import Iterable, MutableMapping, List
+
+from alphafold.common import residue_constants
+from alphafold.data import msa_pairing
+from alphafold.data import pipeline
+import numpy as np
+
+REQUIRED_FEATURES = frozenset({
+    'aatype', 'all_atom_mask', 'all_atom_positions', 'all_chains_entity_ids',
+    'all_crops_all_chains_mask', 'all_crops_all_chains_positions',
+    'all_crops_all_chains_residue_ids', 'assembly_num_chains', 'asym_id',
+    'bert_mask', 'cluster_bias_mask', 'deletion_matrix', 'deletion_mean',
+    'entity_id', 'entity_mask', 'mem_peak', 'msa', 'msa_mask', 'num_alignments',
+    'num_templates', 'queue_size', 'residue_index', 'resolution',
+    'seq_length', 'seq_mask', 'sym_id', 'template_aatype',
+    'template_all_atom_mask', 'template_all_atom_positions'
+})
+
+MAX_TEMPLATES = 4
+MSA_CROP_SIZE = 2048
+
+
+def crop_chains(
+    chains_list: List[pipeline.FeatureDict],
+    msa_crop_size: int,
+    pair_msa_sequences: bool,
+    max_templates: int) -> List[pipeline.FeatureDict]:
+  """"""Crops the MSAs for a set of chains.
+
+  Args:
+    chains_list: A list of chains to be cropped.
+    msa_crop_size: The total number of sequences to crop from the MSA.
+    pair_msa_sequences: Whether we are operating in sequence-pairing mode.
+    max_templates: The maximum templates to use per chain.
+
+  Returns:
+    The chains cropped.
+  """"""
+
+  # Apply the cropping.
+  cropped_chains = []
+  for chain in chains_list:
+    cropped_chain = _crop_single_chain(
+        chain,
+        msa_crop_size=msa_crop_size,
+        pair_msa_sequences=pair_msa_sequences,
+        max_templates=max_templates)
+    cropped_chains.append(cropped_chain)
+
+  return cropped_chains
+
+
+def _crop_single_chain(chain: pipeline.FeatureDict,
+                       msa_crop_size: int,
+                       pair_msa_sequences: bool,
+                       max_templates: int) -> pipeline.FeatureDict:
+    """"""Crops msa sequences to `msa_crop_size`.""""""
+    msa_size_all_seq = chain['num_alignments_all_seq']
+    msa_crop_size_all_seq = np.minimum(msa_size_all_seq, msa_crop_size // 2)
+
+    include_templates = 'template_aatype' in chain and max_templates
+    if include_templates:
+        num_templates = chain['template_aatype'].shape[0]
+        templates_crop_size = np.minimum(num_templates, max_templates)
+
+    for k in chain:
+        k_split = k.split('_all_seq')[0]
+        if k_split in msa_pairing.TEMPLATE_FEATURES:
+            chain[k] = chain[k][:templates_crop_size, :]
+        elif k_split in msa_pairing.MSA_FEATURES:
+            # if '_all_seq' in k and pair_msa_sequences:
+            chain[k] = chain[k][:msa_crop_size_all_seq, :]
+
+    chain['num_alignments'] = np.asarray(msa_crop_size, dtype=np.int32)
+    if include_templates:
+        chain['num_templates'] = np.asarray(templates_crop_size, dtype=np.int32)
+    if pair_msa_sequences:
+        chain['num_alignments_all_seq'] = np.asarray(
+            msa_crop_size_all_seq, dtype=np.int32)
+    return chain
+
+
+def process_final(np_example: pipeline.FeatureDict) -> pipeline.FeatureDict:
+    """"""Final processing steps in data pipeline, after merging and pairing.""""""
+    np_example = _correct_msa_restypes(np_example)
+    np_example = _make_seq_mask(np_example)
+    np_example = _make_msa_mask(np_example)
+    np_example = _filter_features(np_example)
+    return np_example
+
+
+def _correct_msa_restypes(np_example):
+  """"""Correct MSA restype to have the same order as residue_constants.""""""
+  new_order_list = residue_constants.MAP_HHBLITS_AATYPE_TO_OUR_AATYPE
+  np_example['msa'] = np.take(new_order_list, np_example['msa'], axis=0)
+  np_example['msa'] = np_example['msa'].astype(np.int32)
+  return np_example
+
+
+def _make_seq_mask(np_example):
+  np_example['seq_mask'] = (np_example['entity_id'] > 0).astype(np.float32)
+  return np_example
+
+
+def _make_msa_mask(np_example):
+  """"""Mask features are all ones, but will later be zero-padded.""""""
+
+  np_example['msa_mask'] = np.ones_like(np_example['msa'], dtype=np.float32)
+
+  seq_mask = (np_example['entity_id'] > 0).astype(np.float32)
+  np_example['msa_mask'] *= seq_mask[None]
+
+  return np_example
+
+
+def _filter_features(np_example: pipeline.FeatureDict) -> pipeline.FeatureDict:
+  """"""Filters features of example to only those requested.""""""
+  return {k: v for (k, v) in np_example.items() if k in REQUIRED_FEATURES}
+
+
+def process_unmerged_features(
+    all_chain_features: MutableMapping[str, pipeline.FeatureDict]):
+  """"""Postprocessing stage for per-chain features before merging.""""""
+  num_chains = len(all_chain_features)
+  for chain_features in all_chain_features.values():
+    
+    if 'deletion_matrix_int' in chain_features:
+        # Convert deletion matrices to float.
+        chain_features['deletion_matrix'] = np.asarray(
+            chain_features.pop('deletion_matrix_int'), dtype=np.float32)
+        chain_features['deletion_mean'] = np.mean(
+            chain_features['deletion_matrix'], axis=0)
+
+    if 'deletion_matrix_int_all_seq' in chain_features:
+      chain_features['deletion_matrix_all_seq'] = np.asarray(
+          chain_features.pop('deletion_matrix_int_all_seq'), dtype=np.float32)
+
+    # Add all_atom_mask and dummy all_atom_positions based on aatype.
+    all_atom_mask = residue_constants.STANDARD_ATOM_MASK[
+        chain_features['aatype']]
+    chain_features['all_atom_mask'] = all_atom_mask
+    chain_features['all_atom_positions'] = np.zeros(
+        list(all_atom_mask.shape) + [3])
+
+    # Add assembly_num_chains.
+    chain_features['assembly_num_chains'] = np.asarray(num_chains)
+
+  # Add entity_mask.
+  for chain_features in all_chain_features.values():
+    chain_features['entity_mask'] = (
+        chain_features['entity_id'] != 0).astype(np.int32)
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/ena/ena_pairing.py",".py","13116","381","import os
+import json
+import math
+import string
+import logging
+import functools
+import itertools
+from typing import List, Any, Callable, Mapping, Set
+from collections import defaultdict
+
+from tqdm import tqdm
+from alphafold.data import msa_identifiers, parsers
+
+# from repair.msa import msa_df
+
+logger = logging.getLogger(__file__)
+
+def get_wgs_loci_path(ena_repo, wgs_name,):
+    for name in [wgs_name, wgs_name[:6]]:
+        path = os.path.join(ena_repo, f'{name}.json')
+        if os.path.exists(path):
+            return path
+     
+class EnaPairing:
+    def __init__(self, targets_dirs: List[str], ena_repo=None):
+        self.targets_dict = self._get_targets_lookup(targets_dirs)
+        self.targets_lookup = {}
+        self.ena_repo = ena_repo
+
+    def lookup_loci(self, set_name):
+        path = get_wgs_loci_path(self.ena_repo, set_name)
+        if path is not None:
+            with open(path) as fh:
+                all_locus = json.load(fh)
+            for name, locus in all_locus.items():
+                name = name.split('.')[0]
+                if name == set_name:
+                    return {
+                        loci_name.split('.')[0]: loc for loci_name, loc in 
+                        locus.items()
+                    }
+
+    def _get_targets_lookup(self, targets_dirs):
+        targets_dict = defaultdict(list)
+        for targets_dir in targets_dirs:
+            for filename in os.listdir(targets_dir):
+                shortname = filename.split('.')[0].split('/')[-1]
+                targets_dict[shortname].append(
+                    os.path.join(targets_dir, filename)
+                )
+        return targets_dict
+
+
+    def lookup_target(self, ac):
+        shortname = ac[3:6]
+        if shortname not in self.targets_dict:
+            return
+
+        # load target
+        if shortname not in self.targets_lookup:
+            self.targets_lookup[shortname] = {}
+            for p in self.targets_dict[shortname]:
+                with open(p) as fh:
+                    targets_ = json.load(fh)
+            self.targets_lookup[shortname].update(targets_)
+        else:
+            targets_ = self.targets_lookup[shortname]
+
+        if ac not in targets_:
+            return
+
+        return targets_[ac]
+
+
+    def read_msa(self, src_path):
+        with open(src_path) as fh:
+            a3m_str = fh.read()
+        msa = parsers.parse_a3m(a3m_str)
+        return msa
+
+
+    def parse_paired_accessions(self, input_dir, chain_ids):
+        msas_dict = {}
+        for chain_id in chain_ids:
+            msa = self.read_msa(
+                os.path.join(input_dir, chain_id, 'uniprot.a3m')
+            )
+            msas_dict[chain_id] = msa
+
+        grouped_paired_acs = defaultdict(lambda :defaultdict(set))
+        ac_to_row = defaultdict(dict)
+        ac_to_cds = {}
+        for chain_id, msa in msas_dict.items():
+            for r, desc in tqdm(list(enumerate(msa.descriptions))):
+            # for r, desc in enumerate(msa.descriptions):
+                if r == 0:
+                    continue
+                identifiers = msa_identifiers._extract_sequence_identifier(
+                    desc
+                ).split('|')
+                ac = identifiers[1]
+                ac_to_row[chain_id][ac] = r
+                targets = self.lookup_target(ac)
+                if targets is None:
+                    continue
+                set_names = targets['EMBL'].split(',')
+                for set_name in set_names:
+                    grouped_paired_acs[set_name][chain_id].add(ac)
+                cds_names = targets['EMBL-CDS']
+                cds_names = [_.split('.')[0] for _ in cds_names.split(',')]
+                ac_to_cds[ac] = cds_names
+        # clear targets
+        self.targets_lookup = {}
+        # filter unpaired
+        for target in list(grouped_paired_acs.keys()):
+            paired_acs = grouped_paired_acs[target]
+            if len(paired_acs) <= 1:
+                del grouped_paired_acs[target]
+
+        return grouped_paired_acs, ac_to_row, ac_to_cds
+
+
+    def find_paired_accessions(
+        self,
+        grouped_paired_acs: Mapping[str, Mapping[str, Set[str]]],
+        ac_to_row: Mapping[str, Mapping[str, int]],
+        ac_to_cds: Mapping[str, str],
+        chain_ids: List[str],
+        find_matches: Callable,
+    ):
+        # find rows
+        paired_rows = {chain_id: [] for chain_id in chain_ids}
+        request_paired_acs = {}
+        request_ac_to_cds = {}
+        for target, paired_acs in grouped_paired_acs.items():
+            accession_id_lists = [
+                list(paired_acs[chain_id]) for chain_id in chain_ids
+            ]
+            accession_tuples = find_matches(accession_id_lists)
+            # update paired rows
+            for paired_ac in accession_tuples:
+                for i, (chain_id, ac) in enumerate(zip(chain_ids, paired_ac)):
+                    paired_rows[chain_id].append(ac_to_row[chain_id][ac])
+                    if ac in accession_id_lists[i]:
+                        accession_id_lists[i].remove(ac)
+            # update paired acs
+            paired_acs = {
+                chain_id: ids for chain_id, ids in
+                zip(chain_ids, accession_id_lists) if len(ids) > 0
+            }
+            if len(paired_acs) > 1:
+                request_paired_acs[target] = paired_acs
+                for acs in paired_acs.values():
+                    for ac in acs:
+                        request_ac_to_cds[ac] = ac_to_cds[ac]
+
+        return request_paired_acs, request_ac_to_cds, paired_rows
+
+
+    def pair_rows(self, input_dir):
+        chain_ids = ['A', 'B']
+        grouped_paired_acs, ac_to_row, ac_to_cds = self.parse_paired_accessions(
+            input_dir, chain_ids,
+        )
+
+        request_paired_acs, request_ac_to_cds, paired_rows = \
+            self.find_paired_accessions(
+                grouped_paired_acs,
+                ac_to_row,
+                ac_to_cds,
+                chain_ids,
+                _find_all_exact_accession_matches,
+                # _find_all_accession_matches,
+            )
+
+        def get_num_rows(chain_id=chain_ids[0]) -> int:
+            return len(paired_rows[chain_id])
+
+        logger.info(f'Before loci pairing: {input_dir} {get_num_rows()}')
+
+        def calc_locus_diff(id_a, id_b, wgs) -> int:
+            v_a = [wgs[_] for _ in ac_to_cds[id_a] if _ in wgs]
+            v_b = [wgs[_] for _ in ac_to_cds[id_b] if _ in wgs]
+            if len(v_a) == 0 or len(v_b) == 0: 
+                return math.inf
+            return min(abs(a[0] - b[0]) for a, b in itertools.product(v_a, v_b))
+
+
+        # wgs_names = tqdm(list(request_paired_acs.keys()))
+        wgs_names = request_paired_acs.keys()
+        for wgs_name in wgs_names:
+            paired_acs = request_paired_acs[wgs_name]
+            wgs = self.lookup_loci(wgs_name)
+            if not wgs:
+                continue
+            wgs_paired_acs = {} 
+            for chain_id, acs in paired_acs.items():
+                acs = [ac for ac in acs if ac in ac_to_cds]
+                if len(acs) > 0:
+                    wgs_paired_acs[chain_id] = acs
+            if len(wgs_paired_acs) <= 1:
+                continue
+
+            wgs_paired_acs = {wgs_name: wgs_paired_acs}
+            _find_all_locus_matches = functools.partial(
+                _find_all_accession_matches,
+                diff_cutoff=20,
+                _calc_id_diff=lambda a, b: calc_locus_diff(a, b, wgs),
+            )
+            _, _, wgs_paired_rows = self.find_paired_accessions(
+                wgs_paired_acs,
+                ac_to_row,
+                ac_to_cds,
+                chain_ids,
+                _find_all_locus_matches,
+            )
+            for chain_id in paired_rows:
+                paired_rows[chain_id] += wgs_paired_rows[chain_id]
+
+        assert all(
+            get_num_rows(chain_ids[i]) == get_num_rows() for i in 
+            range(1,len(paired_rows))
+        )
+
+        logger.info(f'After loci pairing: {input_dir} {get_num_rows()}')
+
+        return paired_rows
+
+    def export_paired_accessions(self, input_dir):
+        chain_ids = ['A', 'B']
+        grouped_paired_acs, ac_to_row, ac_to_cds = self.parse_paired_accessions(
+            input_dir, chain_ids
+        )
+        request_paired_acs, request_ac_to_cds, paired_rows = \
+            self.find_paired_accessions(
+                grouped_paired_acs,
+                ac_to_row,
+                ac_to_cds,
+                chain_ids,
+                _find_all_exact_accession_matches,
+            )
+
+        def get_num_rows(chain_id=chain_ids[0]) -> int:
+            return len(paired_rows[chain_id])
+
+        logger.info(f'{get_num_rows()}')
+
+        format_paired_acs = {}
+        for target, paired_acs in request_paired_acs.items():
+            format_paired_acs[target] = {
+                chain_id: ','.join(acs) for chain_id, acs in paired_acs.items()
+            }
+        logger.warning(len(request_paired_acs))
+
+        return {
+            'uniprot_accessions': format_paired_acs,
+            'embl_cds': request_ac_to_cds,
+        }
+
+
+""""""From AlphaFold-v2.1.2
+""""""
+ALPHA_ACCESSION_ID_MAP = {x: y for y, x in enumerate(string.ascii_uppercase)}
+ALPHANUM_ACCESSION_ID_MAP = {
+    chr: num for num, chr in enumerate(string.ascii_uppercase + string.digits)
+}  # A-Z,0-9
+NUM_ACCESSION_ID_MAP = {str(x): x for x in range(10)}
+
+@functools.lru_cache(maxsize=65536)
+def encode_accession(accession_id: str) -> int:
+    """"""Map accession codes to the serial order in which they were assigned.""""""
+    alpha = ALPHA_ACCESSION_ID_MAP        # A-Z
+    alphanum = ALPHANUM_ACCESSION_ID_MAP  # A-Z,0-9
+    num = NUM_ACCESSION_ID_MAP            # 0-9
+
+    coding = 0
+
+    # This is based on the uniprot accession id format
+    # https://www.uniprot.org/help/accession_numbers
+    if accession_id[0] in {'O', 'P', 'Q'}:
+        bases = (alpha, num, alphanum, alphanum, alphanum, num)
+    elif len(accession_id) == 6:
+        bases = (alpha, num, alpha, alphanum, alphanum, num)
+    elif len(accession_id) == 10:
+        bases = (
+            alpha, num, alpha, alphanum, alphanum, num, alpha, alphanum,
+            alphanum, num
+        )
+
+    product = 1
+    for place, base in zip(reversed(accession_id), reversed(bases)):
+        coding += base[place] * product
+        product *= len(base)
+
+    return coding
+
+
+def calc_accession_diff(id_a, id_b) -> int:
+    return abs(encode_accession(id_a) - encode_accession(id_b))
+
+def _find_all_accession_matches(
+    accession_id_lists: List[List[str]],
+    diff_cutoff: int = 20, # **strictly** less than diff_cutoff
+    _calc_id_diff: Callable = calc_accession_diff,
+) -> List[List[Any]]:
+    """"""Finds accession id matches across the chains based on their difference.
+    """"""
+    all_accession_tuples = []
+    current_tuple = []
+    tokens_used_in_answer = set()
+
+    def _matches_all_in_current_tuple(inp, diff_cutoff) -> bool:
+        return all((_calc_id_diff(s, inp) < diff_cutoff for s in current_tuple))
+
+    def _all_tokens_not_used_before() -> bool:
+        return all((s not in tokens_used_in_answer for s in current_tuple))
+
+    def dfs(level, accession_id, diff_cutoff=diff_cutoff) -> None:
+        if level == len(accession_id_lists) - 1:
+            if _all_tokens_not_used_before():
+                all_accession_tuples.append(list(current_tuple))
+                for s in current_tuple:
+                    tokens_used_in_answer.add(s)
+            return
+
+        if level == -1:
+            new_list = accession_id_lists[level+1]
+        else:
+            new_list = [
+                (_calc_id_diff(accession_id, s), s) for s in 
+                accession_id_lists[level+1]
+            ]
+            new_list = sorted(new_list)
+            new_list = [s for d, s in new_list]
+
+        for s in new_list:
+            if (
+                _matches_all_in_current_tuple(s, diff_cutoff)
+                and s not in tokens_used_in_answer
+            ):
+                current_tuple.append(s)
+                dfs(level + 1, s)
+                current_tuple.pop()
+
+    dfs(-1, '')
+
+    return all_accession_tuples
+
+def _find_all_exact_accession_matches(accession_id_lists):
+    return _find_all_accession_matches(
+        accession_id_lists,
+        diff_cutoff=1,
+        _calc_id_diff=calc_accession_diff,
+    )
+
+def filter_names(names, include_file):
+    included_names = set()
+    with open(include_file) as fh:
+        for line in fh:
+            line = line.strip()
+            if line:
+                name = line.split()[0]
+                included_names.add(name)
+
+    return [name for name in names if name in included_names]
+
+
+def batch_process(names, input_root, use_tqdm):
+    if use_tqdm:
+        names = tqdm(names)
+    for name in names:
+        ena_pairing = EnaPairing(['idmappings'], 'ena_repo')
+        # logger.info(f'Start pairing {name}')
+        sub_dir = os.path.join(input_root, name)
+        pr_path = os.path.join(sub_dir, 'ena_pr.json')
+        if os.path.exists(pr_path):
+            continue 
+        paired_rows = ena_pairing.pair_rows(sub_dir)
+        with open(pr_path, 'wt') as fh:
+            json.dump(paired_rows, fh, indent=2)
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/ena/ena_downloader.py",".py","8913","307","import os
+import re
+import gzip
+import json
+import time
+import ftplib
+import logging
+import functools
+import itertools
+import urllib.request
+import multiprocessing as mp
+from typing import Mapping, List, Any
+from collections import defaultdict, OrderedDict
+
+from tqdm import tqdm
+
+from repair.ena import ena_pairing
+
+EMBL_EXT = '.cds.gz'
+FTP_BASE = 'ftp.ebi.ac.uk'
+EMBL_VIEW_URL_BASE = 'https://www.ebi.ac.uk/ena/browser/api/embl'
+BASE = '/pub/databases/ena/coding'
+SET_TYPES = ['wgs', 'tsa', 'tls']
+STATUSES = ['public', 'suppressed']
+
+EMBL_WORDS = { 'ID', 'PA', 'OS', 'FT', '//' }
+
+logger = logging.getLogger(__file__)
+
+
+def get_basename(filename, stem=False):
+    filename = filename.split('/')[-1]
+    if stem:
+        filename = filename.split('.')[0]
+    return filename
+
+def format_wgs_url(
+    accession: str,
+    prefices: List[str] = ['wgs/public', 'wgs/suppressed'],
+):
+    sub_dir = accession[:3].lower()
+    filename = f'{accession[:6]}{EMBL_EXT}'
+    for prefix in prefices:
+        url = (
+            f'https://{FTP_BASE}/{BASE.strip(""/"")}/{prefix}/{sub_dir}/{filename}'
+        )
+        try:
+            response = urllib.request.urlopen(url)
+        except Exception as e:
+            continue
+        return url
+
+def format_sequence_url(accession):
+    url = f'{EMBL_VIEW_URL_BASE}/{accession}'
+    try:
+        response = urllib.request.urlopen(url)
+        if url == response.url: # ""sequence"" target
+            return url
+        elif not response.url.endswith('dat.gz'):
+            print(url, response.url)
+    except Exception as e:
+        return
+
+def batch_get_urls(is_master, acs):
+    # if is_master:
+    #     acs = tqdm(acs)
+    urls = []
+    for ac in acs:
+        for g in [format_wgs_url, format_sequence_url]:
+            url = g(ac)
+            if url is not None:
+                break
+        else:
+            logger.info(f'[W] Cannot find exact match to {ac} to download.')
+        if url is not None:
+            urls.append(url)
+    return urls
+
+
+def retrieve_url(url, dst_file):
+    try:
+        urllib.request.urlretrieve(url, dst_file)
+        ret_code = 0
+    except Exception as e:
+        logger.error(f'[E] {e}')
+        ret_code = -1
+
+    return ret_code
+
+def download_record(url: str, dst_dir: str):
+    dst_dat_file = os.path.join(dst_dir, get_basename(url))
+    ret_code = retrieve_url(url, dst_dat_file)
+    if ret_code == 0:
+        return dst_dat_file
+
+
+START_SEGMENT_PATTERN = re.compile(""<(\d+)\.\.>?\d+"")
+END_SEGMENT_PATTERN = re.compile(""<?\d+\.\.>(\d+)"")
+SEGMENT_PATTERN = re.compile(""<?(\d+)\.\.>?(\d+)"")
+
+
+def batch_download_and_parse(
+    is_master: bool, urls: List[Any], dst_dir: str
+):
+    # if is_master:
+    #     urls = tqdm(urls)
+
+    for url in urls:
+        _download_and_parse(url, dst_dir, remove_dat_file=True)
+
+
+def _download_and_parse(
+    url: str,
+    dst_dir: str,
+    remove_dat_file: bool = False,
+):
+    dst_file = os.path.join(
+        dst_dir,
+        os.path.basename(url).split('.')[0] + '.json'
+    )
+    if os.path.exists(dst_file):
+        return
+    dst_dat_file = download_record(url, dst_dir,)
+    if dst_dat_file is None:
+        logger.warning(f'[I] No exact match to {url} can be downloaded')
+        return
+
+    if os.path.exists(dst_dat_file):
+        if dst_dat_file.endswith('.gz'):
+            try:
+                with gzip.open(dst_dat_file, 'rb') as fh:
+                    src_str = fh.read().decode()
+            except Exception as e:
+                print(url, e)
+                return -1
+            cds_sorted = parse_wgs_cds(src_str)
+        else:
+            with open(dst_dat_file, 'rt') as fh:
+                src_str = fh.read()
+            cds_sorted = parse_sequence_cds(src_str)
+
+        with open(dst_file, 'wt') as fh:
+            json.dump(cds_sorted, fh, indent=2, sort_keys=False)
+
+    if remove_dat_file:
+        if os.path.exists(dst_dat_file):
+            os.remove(dst_dat_file)
+
+
+def parse_cds(value):
+    start, end = None, None
+    m = re.search(START_SEGMENT_PATTERN, value['CDS'])
+    if m is not None:
+        start = int(m.group(1))
+
+    m = re.search(END_SEGMENT_PATTERN, value['CDS'])
+    if m is not None:
+        end = int(m.group(1))
+
+    if start is None or end is None:
+        m = re.findall(SEGMENT_PATTERN, value['CDS'])
+        start = int(m[0][0])
+        end = int(m[-1][-1])
+
+    return start, end
+
+
+def parse_sequence_cds(src_str: str):
+    cds_data = defaultdict(dict)
+    all_cds = []
+    cds_flag = False
+    sequence_id = None
+    for line in src_str.split('\n'):
+        line = line.strip()
+        prefix = line[:2]
+        fields = line.split()
+        if prefix == 'ID':
+            sequence_id = fields[1].split(';')[0].strip()
+        elif prefix == 'FT':
+            if fields[1] == 'CDS' and line.startswith(""FT   CDS""):
+                all_cds.append({})
+                all_cds[-1]['CDS'] = ''
+                cds_flag = True
+            elif fields[1].startswith('/'):
+                cds_flag = False
+                if fields[1].startswith('/protein_id'):
+                    cds_id = fields[1].split('=')[-1].strip('""')
+                    all_cds[-1]['ID'] = cds_id
+
+            if cds_flag:
+                all_cds[-1]['CDS'] += fields[-1]
+
+    assert sequence_id is not None
+    grouped_cds = {sequence_id: []}
+    for value in all_cds:
+        try:
+            if 'ID' not in value:
+                continue
+            cds_id = value['ID']
+            start, end = parse_cds(value)
+            grouped_cds[sequence_id].append((cds_id, start, end))
+        except Exception:
+            raise ValueError(f'Cannot parse {m}\n : {value}\n')
+
+    cds_sorted = OrderedDict()
+    cds_list = grouped_cds[sequence_id]
+    if len(cds_list) > 1:
+        cds_sorted[sequence_id] = {
+            v[0]: (i,) + v[1:] for i, v in 
+            enumerate(sorted(cds_list, key=lambda v: v[1]))
+        }
+
+    return cds_sorted
+
+
+def parse_wgs_cds(src_str: str, dst_file: str = None):
+    cds_data = defaultdict(dict)
+    cds_flag = False
+    cds_id = None
+    for line in src_str.split('\n'):
+        line = line.strip()
+        prefix = line[:2]
+        fields = line.split()
+        if prefix == 'ID':
+            assert not cds_flag
+            cds_id = fields[1].split(';')[0].strip()
+            cds_data[cds_id] = {}
+        elif prefix == 'PA':
+            assert cds_id is not None
+            cds_data[cds_id]['PA'] = fields[1].strip(';')
+        elif prefix == 'FT':
+            assert cds_id is not None
+            if fields[1] == 'CDS' and line.startswith(""FT   CDS""):
+                cds_flag = True
+                cds_data[cds_id]['CDS'] = ''
+            elif fields[1].startswith('/'):
+                cds_flag = False
+
+            if cds_flag:
+                cds_data[cds_id]['CDS'] += fields[-1]
+        elif prefix == '//':
+            assert cds_id is not None
+            cds_id = None
+
+    grouped_cds = defaultdict(list)
+    for cds_id, value in cds_data.items():
+        try:
+            set_id = value['PA']
+            start, end = parse_cds(value)
+            grouped_cds[set_id].append((cds_id, start, end))
+        except Exception:
+            raise ValueError(f'Cannot parse {m}\n{set_id}, {cds_id}: {value}\n')
+
+    cds_sorted = OrderedDict()
+    for set_id in sorted(grouped_cds.keys()):
+        cds_list = grouped_cds[set_id]
+        if len(cds_list) > 1:
+            cds_sorted[set_id] = {
+                v[0]: (i,) + v[1:] for i, v in 
+                enumerate(sorted(cds_list, key=lambda v: v[1]))
+            }
+
+    return cds_sorted
+
+
+def download_requests(src_file: str, dst_repo: str, max_ncpu: int = 20):
+    with open(src_file) as fh:
+        wgs_acs = json.load(fh)['uniprot_accessions']
+
+    acs = []
+    for ac in wgs_acs:
+        path = ena_pairing.get_wgs_loci_path(dst_repo, ac)
+        if path is None:
+            acs.append(ac)
+
+    ncpu = min(len(acs), max_ncpu)
+    if ncpu > 1:
+        urls = set()
+        with mp.Pool(ncpu) as pool:
+            results = []
+            for i in range(ncpu):
+                acs_ = [acs[j] for j in range(i, len(acs), ncpu)]
+                result = pool.apply_async(
+                    batch_get_urls, (i==0, acs_),
+                )
+                results.append(result)
+
+            for result in results:
+                urls.update(result.get())
+    else:
+        urls = batch_get_urls(True, acs)
+
+    logger.warning(f'{len(urls)} to be downloaded')
+    ncpu = min(len(urls), max_ncpu)
+    if ncpu > 1:
+        with mp.Pool(ncpu) as pool:
+            results = []
+            for i in range(ncpu):
+                urls_ = [urls[j] for j in range(i, len(urls), ncpu)]
+                result = pool.apply_async(
+                    batch_download_and_parse, (i==0, urls_, dst_repo),
+                )
+                results.append(result)
+            [ result.get() for result in results ]
+    else:
+        batch_download_and_parse(True, urls, dst_repo)
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/data/ena/ena_idmapping_parsing.py",".py","2807","94","import os
+import json
+import mmap
+import time
+import logging
+from collections import defaultdict
+
+from tqdm import tqdm
+
+logger = logging.getLogger(__file__)
+
+
+def parse_idmapping_file(
+    idmapping_file: str,
+    dst_file: str = None,
+    use_mmap: bool = False,
+):
+    accessions = {}
+    t0 = time.time()
+    # Read accessions
+    with open(idmapping_file) as fh:
+        if use_mmap:
+            mm = mmap.mmap(fh.fileno(), 0, prot=mmap.PROT_READ)
+            lines = [line.decode() for line in mm.read().split(b'\n')]
+            progress = tqdm(lines)
+        else:
+            progress = tqdm(fh)
+        for line in iterator:
+            line = line.strip()
+            fields = line.split()
+            accession = fields[0]
+            key = fields[1]
+            target = fields[2]
+            if key in ('EMBL', 'EMBL-CDS',):
+                if accession not in accessions:
+                    accessions[accession] = {
+                        'EMBL': [],
+                        'EMBL-CDS': [],
+                    }
+                accessions[accession][key].append(target)
+
+    t1 = time.time()
+
+    if t1 - t0 > 3*60:
+        logger.warning(
+            f'[W] Read {len(accessions)} accessions in {t1-t0:.2f}s'
+        )
+
+    return accessions
+
+
+def split_src_file(accessions, dst_dir: str):
+    os.makedirs(dst_dir, exist_ok=True)
+    split_accessions = defaultdict(dict)
+    ac_keys = list(accessions.keys())
+    for ac in tqdm(ac_keys):
+        ac_dict = accessions[ac]
+        split_accessions[ac[3:6]][ac] = {
+            k: ','.join(vs) for k, vs in ac_dict.items()
+        }
+
+    logger.warning(len(split_accessions))
+    prefices = list(split_accessions.keys())
+    for prefix in tqdm(prefices):
+        sub_accessions = split_accessions[prefix]
+        output_path = os.path.join(dst_dir, f'{prefix}.json')
+        with open(output_path, 'wt') as fh:
+            json.dump(sub_accessions, fh, indent=2)
+
+
+def update_legacy(src_dir: str):
+    for src_filename in tqdm(os.listdir(src_dir)):
+        src_path = os.path.join(src_dir, src_filename)
+        if not src_filename.endswith('.json'):
+            continue
+        with open(src_path, 'rt') as fh:
+            src_data = json.load(fh)
+        dst_data = {}
+        for key, values in src_data.items():
+            if isinstance(values, str):
+                dst_data[key] = values
+                continue
+            values = sorted([v['EMBL'] for v in values if 'EMBL' in v])
+            if len(values) > 0:
+                dst_data[key] = ','.join(values)
+        with open(src_path, 'wt') as fh:
+            src_data = json.dump(dst_data, fh, indent=2)
+
+if __name__ == '__main__':
+    import sys
+    parser = IdMappingParser()
+    accessions = parse_idmapping_file(sys.argv[1])
+    split_src_file(accessions, sys.argv[2])
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/assess/multimer_assess.py",".py","11764","345","import os
+import io
+import sys
+import copy
+import json
+import math
+import logging
+import argparse
+import tempfile
+import itertools
+import subprocess
+from typing import Mapping, Any
+from collections import defaultdict
+
+import numpy as np
+from Bio.PDB.Model import Model
+from Bio.PDB.Chain import Chain
+from Bio.PDB.PDBIO import PDBIO
+from Bio.PDB.PDBParser import PDBParser
+from alphafold.common import residue_constants, protein
+
+from msa_pair.common import sequence_utils, pdb_utils
+
+logger = logging.getLogger(__file__)
+
+
+def _decode_binary_output(output):
+    msg = []
+    for line in output.decode().split('\n'):
+        msg.append(line)
+    return '\n'.join(msg)
+
+class MultimerAssess:
+    def __init__(self, dockq_binary_path):
+        self.dockq_binary_path = dockq_binary_path
+        assert os.path.exists(self.dockq_binary_path)
+
+    @classmethod
+    def add_args(cls, parser):
+        group = parser.add_argument_group('AlphaFold Evaluation')
+        group.add_argument('--query-pdb', type=str)
+        group.add_argument('--truth-pdb', type=str)
+
+    def _dockq(
+        self, query_pdb: str, truth_pdb: str, receptor_chain: str
+    ) -> Mapping[str, Any]:
+        cmd_paths = [query_pdb, truth_pdb]
+        cmd = (
+            [self.dockq_binary_path] + 
+            cmd_paths +
+            [
+                '-native_chain1', receptor_chain, 
+                '-model_chain1', receptor_chain, '-no_needle'
+            ]
+        )
+        # print(cmd)
+        # exit()
+        process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        output, stderr = process.communicate()
+        retcode = process.wait()
+        if retcode:
+            msg = _decode_binary_output(stderr)
+            if 'length of native is zero' in msg:
+                logger.info(
+                   ""###########################                           \n""
+                   ""Error during running DockQ:                           \n""
+                   f""{msg.strip()}                                        \n""
+                   ""--------------------------                            \n""
+                   ""the reason may be that the common_interface defined in\n"" 
+                   ""DockQ is empty                                        \n""
+                   ""##########################                              ""
+                )
+            else:
+                raise RuntimeError(msg)
+
+        def _get_score(line):
+            return float(line.split()[1])
+
+        result = {}
+        lines = []
+        # print(output)
+        for line in output.decode().split('\n'):
+            if line.startswith('Fnat'):
+                result['fnat'] = _get_score(line)
+            elif line.startswith('Fnonnat'):
+                result['fnonnat'] = _get_score(line)
+            elif line.startswith('iRMS'):
+                result['irms'] = _get_score(line)
+            elif line.startswith('LRMS'):
+                result['lrms'] = _get_score(line)
+            elif line.startswith('DockQ'):
+                result['dockq'] = _get_score(line)
+            lines.append(line)
+
+        if 'dockq' not in result:
+            result = None
+            logger.warning(cmd + lines)
+
+        return result
+
+
+    def align_residue_index(
+        self, query_pdb: str, truth_pdb: str, output_pdb_dir: str, suffix: str
+    ):
+        query_chains = pdb_utils.from_pdb_string(
+            pdb_utils.read_pdb_string(query_pdb)
+        )
+        if len(query_chains) <= 1:
+            raise ValueError(query_pdb)
+
+        truth_chains = pdb_utils.from_pdb_string(
+            pdb_utils.read_pdb_string(truth_pdb)
+        )
+        if len(truth_chains) <= 1:
+            return
+
+        # Align every chains
+        alns = defaultdict(dict)
+        alns_score = defaultdict(dict)
+        for qchain in query_chains.keys():
+            query_seq = sequence_utils.aatype_to_sequence(
+                query_chains[qchain].aatype
+            )
+            for tchain in truth_chains.keys():
+                truth_seq = sequence_utils.aatype_to_sequence(
+                    truth_chains[tchain].aatype
+                )
+                aln, qidx, tidx = sequence_utils.global_align(
+                    query_seq, truth_seq
+                )
+                if aln is None or aln.score < 5:
+                    continue
+                alns[qchain][tchain] = (aln.score, qidx, tidx)
+                alns_score[qchain][tchain] = aln.score
+
+        if len(alns_score) < 2:
+            logger.info(
+                f'Cannot align {query_pdb} to {truth_pdb}: {alns_score}'
+            )
+            return
+
+        # Find unambiguous assignments
+        final_assignment = defaultdict(dict)
+        for qchain in list(alns):
+            if len(alns[qchain]) == 1:
+                for tchain in alns[qchain]:
+                    if tchain in final_assignment:
+                        logger.info(
+                            f'Cannot align {query_pdb} to {truth_pdb}: '
+                            f'{alns_score}'
+                        )
+                        return
+                    final_assignment[tchain][qchain] = alns[qchain][tchain]
+                del alns[qchain]
+
+        # Resolve ambiguous assignments
+        results = []
+        if len(alns) > 0:
+            # try all possible permutations
+            for qchain in list(alns):
+                for tchain in final_assignment:
+                    if tchain in alns[qchain]:
+                        del alns[qchain][tchain]
+            qchains = [qchain for qchain in alns]
+            tuples = [list(alns[qchain]) for qchain in qchains]
+            n = 0
+            for tchains in itertools.product(*tuples):
+                if len(set(tchains)) < len(tchains): # ignore this combination
+                    continue
+                final_assignment_ = copy.deepcopy(final_assignment)
+                for t, q in zip(tchains, qchains):
+                    final_assignment_[t][q] = alns[q][t]
+                output_pdb = os.path.join(
+                    output_pdb_dir, f'model_{n}_to_{suffix}.pdb'
+                )
+                receptor_chain = self._build_new_pdb(
+                    final_assignment_, query_chains, truth_chains, output_pdb
+                )
+                results.append((receptor_chain, output_pdb))
+                n += 1
+        else:
+            output_pdb = os.path.join(
+                output_pdb_dir, f'model_0_to_{suffix}.pdb'
+            )
+            receptor_chain = self._build_new_pdb(
+                final_assignment, query_chains, truth_chains, output_pdb
+            )
+            results.append((receptor_chain, output_pdb))
+
+        if len(results) < 1:
+            logger.warning(f'Empty results, the alns_score is {alns_score}')
+            return
+
+        return results
+
+    def _build_new_pdb(
+        self,
+        final_assignment, query_chains, truth_chains,
+        output_pdb: str,
+        only_backbone: bool = False
+    ):
+        assigning = []
+        receptor_chain = None
+        max_score = 0
+        for tid in final_assignment:
+            for qid, (s, qidx, tidx) in final_assignment[tid].items():
+                if s > max_score:
+                    max_score = s
+                    receptor_chain = tid
+                assigning.append((qid, tid, qidx, tidx))
+
+        new_query_chains = pdb_utils.assign_residue_index(
+            assigning, query_chains, truth_chains
+        )
+
+        if len(new_query_chains) < 2:
+            raise RuntimeError(output_pdb, len(query_chains), len(truth_chains))
+
+        new_query_structure = pdb_utils.merge_chains(
+            new_query_chains, only_backbone=only_backbone
+        )
+
+        pdb_string = protein.to_pdb(new_query_structure)
+        p = protein.from_pdb_string(pdb_string)
+        with open(output_pdb, 'wt') as fh:
+            fh.write(pdb_string)
+
+        return receptor_chain
+
+    def build_models(self, truth_pdb: str, output_prefix: str):
+        pdb_str = pdb_utils.read_pdb_string(truth_pdb)
+        pdb_fh = io.StringIO(pdb_str)
+        parser = PDBParser(QUIET=True)
+        structure = parser.get_structure('none', pdb_fh)
+        models = list(structure.get_models())
+        # print(models)
+
+        build_full_model =  len(models) > 1
+        if build_full_model:
+            full_model = Model(0)
+
+        output_models = {}
+        num_chains = 0
+        for model in models:
+            pdb_io = PDBIO()
+            pdb_io.set_structure(model)
+            output_path = f'{output_prefix}_{model.id}.pdb'
+            # print(list(pdb_io))
+            # exit()
+            with open(output_path, 'wt') as fh:
+                pdb_io.save(fh)
+            output_models[model.id] = output_path
+            # build a model that includes all chains
+            if build_full_model:
+                chains = sorted(model, key=lambda chain: chain.id)
+                PDB_CHAIN_IDS = sorted(protein.PDB_CHAIN_IDS)
+                for chain in model:
+                    chain.id = PDB_CHAIN_IDS[num_chains]
+                    num_chains += 1
+                    full_model.add(chain)
+
+        if build_full_model:
+            pdb_io = PDBIO()
+            pdb_io.set_structure(full_model)
+            output_path = f'{output_prefix}_full.pdb'
+            with open(output_path, 'wt') as fh:
+                pdb_io.save(fh)
+            output_models['full'] = output_path
+
+        return output_models
+
+
+    def assess(
+        self,
+        query_pdb: str, truth_pdb: str, receptor_chain: str
+    ):
+        # print(query_pdb, truth_pdb)
+        query_model, gt_model = trim_common_residues(query_pdb, truth_pdb)
+        with tempfile.NamedTemporaryFile('w+t') as gt_fp:
+            pdb_io = PDBIO()
+            pdb_io.set_structure(gt_model)
+            pdb_io.save(gt_fp)
+
+            with tempfile.NamedTemporaryFile('w+t') as query_fp:
+                pdb_io = PDBIO()
+                pdb_io.set_structure(query_model)
+                pdb_io.save(query_fp)
+                try:
+                    result = self._dockq(
+                        query_fp.name, gt_fp.name, receptor_chain
+                    )
+                except RuntimeError as e:
+                    raise RuntimeError(query_pdb, truth_pdb)
+        return result
+
+def get_residues(pdb_str):
+    pdb_fh = io.StringIO(pdb_str)
+    parser = PDBParser(QUIET=True)
+    structure = parser.get_structure('none', pdb_fh)
+    models = list(structure.get_models())
+    assert len(models) == 1
+    model = models[0]
+    residues = {}
+    for chain in model:
+        for res in chain:
+            if res.id[2] != ' ' or res.id[0] != ' ':
+                continue
+            name = f'{chain.id}_{res.id[1]}'
+            residues[name] = res
+
+    return residues
+
+def build_model_from_residues(residues):
+    new_model = Model(0)
+    chains = {}
+    for res_id, res in residues.items():
+        chain_id, res_id = res_id.split('_')
+        if chain_id not in chains:
+            chains[chain_id] = Chain(chain_id)
+        chains[chain_id].add(res)
+
+    for chain in chains.values():
+        new_model.add(chain)
+
+    return new_model
+
+
+def trim_common_residues(query_pdb: str, truth_pdb: str):
+    truth_residues = get_residues(pdb_utils.read_pdb_string(truth_pdb))
+    query_residues = get_residues(pdb_utils.read_pdb_string(query_pdb))
+    common_res_ids = set(query_residues.keys()) & set(truth_residues.keys())
+
+    truth_model = build_model_from_residues(dict(
+        (res_id, res) for res_id, res in truth_residues.items() if res_id in 
+        common_res_ids
+    ))
+    query_model = build_model_from_residues(dict(
+        (res_id, res) for res_id, res in query_residues.items() if res_id in 
+        common_res_ids
+    ))
+
+    return query_model, truth_model
+","Python"
+"AlphaFold","allanchen95/ESMPair","msa_pair/msa_pair/assess/monomer_assess.py",".py","3296","112","import os
+import io
+import sys
+import copy
+import json
+import math
+import logging
+import argparse
+import tempfile
+import itertools
+import subprocess
+from typing import Mapping, Any
+from collections import defaultdict
+
+import numpy as np
+from Bio.PDB.Model import Model
+from Bio.PDB.Chain import Chain
+from Bio.PDB.PDBIO import PDBIO
+from Bio.PDB.PDBParser import PDBParser
+from alphafold.common import residue_constants, protein
+
+logger = logging.getLogger(__file__)
+
+
+def _decode_binary_output(output):
+    msg = []
+    for line in output.decode().split('\n'):
+        msg.append(line)
+    return '\n'.join(msg)
+
+class MonomerAssess:
+    def __init__(self, tmalign_binary_path):
+        self.tmalign_binary_path = tmalign_binary_path
+
+    @classmethod
+    def add_args(cls, parser):
+        group = parser.add_argument_group('AlphaFold Evaluation')
+        group.add_argument('--query-pdb', type=str)
+        group.add_argument('--truth-pdb', type=str)
+
+    def _run_tmalign(
+        self, query_pdb: str, truth_pdb: str
+    ) -> Mapping[str, Any]:
+        cmd_paths = [query_pdb, truth_pdb]
+        cmd = (
+            [self.tmalign_binary_path] + 
+            cmd_paths
+        )
+        process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        output, stderr = process.communicate()
+        retcode = process.wait()
+        if retcode:
+            msg = _decode_binary_output(stderr)
+            if 'Warning! Cannot parse file' in msg:
+                logger.warning(msg)
+                return
+            raise RuntimeError(msg)
+
+        def _get_score(line):
+            return float(line.split()[1])
+
+        result = {}
+        for line in output.decode().split('\n'):
+            if line.startswith('TM-score='):
+                result['TMscore'] = float(line.split()[1])
+                break
+
+        return result
+
+
+    def assess(
+        self,
+        query_pdb: str,
+        truth_pdb: str,
+    ):
+        parser = PDBParser(QUIET=True)
+        def _get_chains(pdb_file):
+            chains = {}
+            structure = parser.get_structure('', pdb_file)
+            assert len(structure) == 1
+            for chain in structure[0]:
+                chains[chain.id] = chain
+            return chains
+
+        query_chains = _get_chains(query_pdb)
+        truth_chains = _get_chains(truth_pdb)
+        common_chains = set(list(query_chains)) & set(list(truth_chains))
+
+        results = {}
+        for chain_id in common_chains:
+            with tempfile.NamedTemporaryFile('w+t') as gt_fp:
+                pdb_io = PDBIO()
+                gt_model = truth_chains[chain_id]
+                pdb_io.set_structure(gt_model)
+                pdb_io.save(gt_fp)
+
+                with tempfile.NamedTemporaryFile('w+t') as query_fp:
+                    pdb_io = PDBIO()
+                    query_model = query_chains[chain_id]
+                    pdb_io.set_structure(query_model)
+                    pdb_io.save(query_fp)
+                    try:
+                        result = self._run_tmalign(query_fp.name, gt_fp.name)
+                    except RuntimeError as e:
+                        raise RuntimeError(query_pdb, truth_pdb)
+                if result:
+                    results[chain_id] = result
+
+        return results
+","Python"
+"AlphaFold","Zuricho/AlphaFold3_Result_Visualize","vis_pae.py",".py","6207","171","#!/usr/bin/env python3
+
+import json
+import os
+import sys
+
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib as mpl
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+mpl.rcParams[""font.size""] = 12
+mpl.rcParams[""font.family""] = ""Arial""
+
+
+
+# helper functions
+
+def hide_axes_frame(ax):
+    """"""
+    Hide the frame of the given matplotlib axis.
+    
+    Parameters:
+    ax (matplotlib.axes.Axes): The axis object whose frame will be made invisible.
+    """"""
+    # Hide the axes frame
+    for spine in ax.spines.values():
+        spine.set_visible(False)
+    
+    # Optionally, you might also want to hide the ticks and labels if needed
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+def process_token_chains(token_chain_ids):
+    """"""
+    Process token chains to assign numerical indices and find start and end indices for each unique token.
+    
+    Parameters:
+    token_chain_ids (list): List of characters representing token chains.
+    
+    Returns:
+    dict, dict, dict, np.ndarray: Three dictionaries mapping characters to their numerical index, start index,
+                                  and end index, plus a numpy array of numerical indices.
+    """"""
+    # Convert list to numpy array if not already
+    token_chain_ids = np.array(token_chain_ids)
+    
+    # Find unique chains and create a mapping to numerical indices
+    unique_chains = np.unique(token_chain_ids)
+    chain_to_num = {char: i for i, char in enumerate(unique_chains)}
+    
+    # Convert token chains to numerical indices
+    token_chain_nums = np.array([chain_to_num[char] for char in token_chain_ids]).reshape(1, -1)
+    
+    # Find the start and end index for each character
+    chain_to_start_index = {}
+    chain_to_end_index = {}
+    
+    for char in unique_chains:
+        indices = np.where(token_chain_ids == char)[0]
+        chain_to_start_index[char] = indices[0]
+        chain_to_end_index[char] = indices[-1]
+
+    return chain_to_num, chain_to_start_index, chain_to_end_index, token_chain_nums
+
+
+def main(alphafold_prediction_name):
+    # get the file names
+    json_name_full = [os.path.join(alphafold_prediction_name, f""{alphafold_prediction_name}_full_data_{i}.json"") for i in range(5)]
+    json_name_confidence = [os.path.join(alphafold_prediction_name, f""{alphafold_prediction_name}_summary_confidences_{i}.json"") for i in range(5)]
+
+
+    # load the data
+    json_data_full = [json.load(open(i)) for i in json_name_full]
+    json_data_confidence = [json.load(open(i)) for i in json_name_confidence]
+
+    for model_num in range(5):
+
+
+        json_data_full[model_num].keys()
+        # atom_chain_ids, atom_plddts, contact_probs, pae, token_chain_ids, token_res_ids
+
+        json_data_confidence[model_num].keys()
+        # chain_iptm, chain_pair_iptm, chain_pair_pae_min, chain_ptm, fraction_disordered, has_clash, iptm, num_recycles, ptm, ranking_score
+
+
+        # processing the data
+        # chain num
+        chain_to_num, chain_to_start_index, chain_to_end_index, token_chain_nums = process_token_chains(json_data_full[model_num][""token_chain_ids""])
+
+        # get xticks data
+        token_res_ids = json_data_full[model_num][""token_res_ids""]
+        xticks_loc = []
+        xticks_present = []
+        for i in range(len(token_res_ids)):
+            if token_res_ids == 1 or token_res_ids[i]%200 == 0:
+                xticks_loc.append(i)
+                xticks_present.append(token_res_ids[i])
+
+
+        # Assuming 'json_data_full' and 'model_num' are already defined and available
+        fig, ax = plt.subplots(figsize=(4, 4))
+
+        # Display the data
+        pae_array = np.array(json_data_full[model_num][""pae""])
+        image = ax.imshow(pae_array, cmap=""Greens_r"", vmin=0, vmax=30)
+
+        # ax.set_xticks(xticks_loc, xticks_present)
+        # ax.set_xticks([])
+        # ax.set_xticks(np.arange(0, len(token_res_ids), 200))
+        ax.set_yticks([])
+        # set the frame to dashed line
+        for spine in ax.spines.values():
+            spine.set_linestyle(""--"")
+            spine.set_linewidth(1)
+            spine.set_color(""k"")
+
+
+        # Create an axes on the right side of ax, which will match the height of ax
+        divider = make_axes_locatable(ax)
+        ax_colorbar = divider.append_axes(""right"", size=""5%"", pad=0.2)
+        ax_topbar = divider.append_axes(""top"", size=""8%"", pad=0.03)
+        ax_leftbar = divider.append_axes(""left"", size=""8%"", pad=0.03)
+
+
+        # topbar
+        ax_topbar.imshow(token_chain_nums, cmap=""tab10"", aspect=""auto"", alpha=0.7)
+        hide_axes_frame(ax_topbar)
+
+
+        # leftbar
+        ax_leftbar.imshow(token_chain_nums.T, cmap=""tab10"", aspect=""auto"", alpha=0.7)
+        hide_axes_frame(ax_leftbar)
+
+        # colorbar
+        colorbar = fig.colorbar(image, cax=ax_colorbar, label=""PAE (Å)"")
+
+
+        # plot a axhline at the start and end of each token
+        for char, start_index in chain_to_start_index.items():
+            if start_index != 0:
+                ax.axhline(start_index - 0.5, color=""k"", linewidth=1, linestyle=""--"")
+                ax.axvline(start_index - 0.5, color=""k"", linewidth=1, linestyle=""--"")
+                ax_topbar.axvline(start_index - 0.5, color=""w"", linewidth=1, linestyle=""-"")
+                ax_leftbar.axhline(start_index - 0.5, color=""w"", linewidth=1, linestyle=""-"")
+
+        # Adding text annotations at the center of each token chain
+        for char in chain_to_start_index:
+            start_index = chain_to_start_index[char]
+            end_index = chain_to_end_index[char]
+            center_index = (start_index + end_index) / 2
+            # Add text to top bar
+            ax_topbar.text(center_index, 0, char, color='#222222', ha='center', va='center')
+            # Add text to left bar
+            ax_leftbar.text(0, center_index, char, color='#222222', ha='center', va='center')
+
+        # Show the plot
+        plt.savefig(f""{alphafold_prediction_name}/figure_pae_{model_num}.png"", dpi=300, bbox_inches=""tight"", transparent=False)
+
+
+
+
+
+if __name__ == ""__main__"":
+    if len(sys.argv) < 2:
+        print(""Usage: python vis_pae.py <alphafold_prediction_directory>"")
+        sys.exit(1)
+    alphafold_prediction_name = sys.argv[1]
+    main(alphafold_prediction_name)
+","Python"
+"AlphaFold","prehensilecode/alphafold_singularity","example_slurm_job.sh",".sh","2552","81","#!/bin/bash
+
+# Copyright 2023 David Chin
+#
+# This file is part of alphafold_singularity.
+#
+# alphafold_singularity is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# alphafold_singularity is distributed in the hope that it will be
+# useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with alphafold_singularity. If not, see <https://www.gnu.org/licenses/>.
+
+#SBATCH --partition=gpu
+#SBATCH --time=2:00:00
+#SBATCH --gpus=4
+#SBATCH --cpus-per-gpu=12
+#SBATCH --mem-per-gpu=36G
+
+### NOTE
+### This job script cannot be used without modification for your specific environment.
+
+module load python/gcc/3.11
+module load alphafold/2.3.2-1
+
+### Check values of some environment variables
+echo INFO: SLURM_GPUS_ON_NODE=$SLURM_GPUS_ON_NODE
+echo INFO: SLURM_JOB_GPUS=$SLURM_JOB_GPUS
+echo INFO: SLURM_STEP_GPUS=$SLURM_STEP_GPUS
+echo INFO: ALPHAFOLD_DIR=$ALPHAFOLD_DIR
+echo INFO: ALPHAFOLD_DATADIR=$ALPHAFOLD_DATADIR
+echo INFO: TMP=$TMP
+
+###
+### README This runs AlphaFold 2.3.2 on the T1050.fasta file
+###
+
+# AlphaFold should use all GPU devices available to the job by default.
+#
+# To run the CASP14 evaluation, use:
+#   --model_preset=monomer_casp14
+#   --db_preset=full_dbs (or delete the line; default is ""full_dbs"")
+#
+# On a test system with 4x Tesla V100-SXM2, this took about 50 minutes.
+#
+# To benchmark, running multiple JAX model evaluations (NB this 
+# significantly increases run time):
+#   --benchmark
+#
+# On a test system with 4x Tesla V100-SXM2, this took about 6 hours.
+
+# Create output directory in $TMP (which is cleaned up by Slurm at end
+# of job).
+output_dir=$TMP/output
+mkdir -p $output_dir
+
+echo INFO: output_dir=$output_dir
+
+# Run AlphaFold; default is to use GPUs
+python3 ${ALPHAFOLD_DIR}/singularity/run_singularity.py \
+    --use_gpu \
+    --output_dir=$output_dir \
+    --data_dir=${ALPHAFOLD_DATADIR} \
+    --fasta_paths=T1050.fasta \
+    --max_template_date=2020-05-14 \
+    --model_preset=monomer \
+    --db_preset=reduced_dbs
+
+echo INFO: AlphaFold returned $?
+
+### Copy Alphafold output back to directory where ""sbatch"" command was issued.
+mkdir $SLURM_SUBMIT_DIR/Output-$SLURM_JOB_ID
+cp -R $output_dir $SLURM_SUBMIT_DIR/Output-$SLURM_JOB_ID
+
+","Shell"
+"AlphaFold","prehensilecode/alphafold_singularity","run_singularity.py",".py","11698","298","#!/usr/bin/env python3
+# Copyright 2023 David Chin
+#
+# This file is part of alphafold_singularity.
+#
+# alphafold_singularity is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# alphafold_singularity is distributed in the hope that it will be
+# useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with alphafold_singularity. If not, see <https://www.gnu.org/licenses/>.
+
+""""""Singularity launch script for Alphafold Singularity image.""""""
+
+import os
+import sys
+import pathlib
+import signal
+from typing import Tuple
+
+from absl import app
+from absl import flags
+from absl import logging
+from spython.main import Client
+
+import tempfile
+import subprocess
+
+
+#### USER CONFIGURATION ####
+
+# Path to AlphaFold Singularity image. This relies on
+# the environment variable ALPHAFOLD_DIR which is the
+# directory where AlphaFold is installed.
+singularity_image = Client.load(os.path.join(os.environ['ALPHAFOLD_DIR'], 'alphafold.sif'))
+
+# tmp directory
+if 'TMP' in os.environ:
+    tmp_dir = os.environ['TMP']
+elif 'TMPDIR' in os.environ:
+    tmp_dir = os.environ['TMPDIR']
+else:
+    tmp_dir = '/tmp'
+
+# Default path to a directory that will store the results.
+output_dir_default = tempfile.mkdtemp(dir=tmp_dir, prefix='alphafold')
+
+logging.info(f'INFO: tmp_dir = {tmp_dir}')
+logging.info(f'INFO: output_dir_default = {output_dir_default}')
+
+#### END USER CONFIGURATION ####
+
+### These flags correspond to the flags defined in ../run_alphafold.py
+flags.DEFINE_bool(
+    'use_gpu', True, 'Enable NVIDIA runtime to run with GPUs.')
+flags.DEFINE_enum(
+    'models_to_relax', 'best', ['best', 'all', 'none'],
+    'The models to run the final relaxation step on. '
+    'If `all`, all models are relaxed, which may be time '
+    'consuming. If `best`, only the most confident model is '
+    'relaxed. If `none`, relaxation is not run. Turning off '
+    'relaxation might result in predictions with '
+    'distracting stereochemical violations but might help '
+    'in case you are having issues with the relaxation '
+    'stage.')
+flags.DEFINE_bool(
+    'enable_gpu_relax', True, 'Run relax on GPU if GPU is enabled.')
+flags.DEFINE_string(
+    'gpu_devices', 'all',
+    'Comma separated list of devices to pass to NVIDIA_VISIBLE_DEVICES.')
+flags.DEFINE_list(
+    'fasta_paths', None, 'Paths to FASTA files, each containing a prediction '
+    'target that will be folded one after another. If a FASTA file contains '
+    'multiple sequences, then it will be folded as a multimer. Paths should be '
+    'separated by commas. All FASTA paths must have a unique basename as the '
+    'basename is used to name the output directories for each prediction.')
+flags.DEFINE_string(
+    'output_dir', output_dir_default,
+    'Path to a directory that will store the results.')
+flags.DEFINE_string(
+    'data_dir', None,
+    'Path to directory with supporting data: AlphaFold parameters and genetic '
+    'and template databases. Set to the target of download_all_databases.sh.')
+flags.DEFINE_string(
+    'docker_image_name', 'alphafold', 'Name of the AlphaFold Docker image.')
+flags.DEFINE_string(
+    'max_template_date', None,
+    'Maximum template release date to consider (ISO-8601 format: YYYY-MM-DD). '
+    'Important if folding historical test sets.')
+flags.DEFINE_enum(
+    'db_preset', 'full_dbs', ['full_dbs', 'reduced_dbs'],
+    'Choose preset MSA database configuration - smaller genetic database '
+    'config (reduced_dbs) or full genetic database config (full_dbs)')
+flags.DEFINE_enum(
+    'model_preset', 'monomer',
+    ['monomer', 'monomer_casp14', 'monomer_ptm', 'multimer'],
+    'Choose preset model configuration - the monomer model, the monomer model '
+    'with extra ensembling, monomer model with pTM head, or multimer model')
+flags.DEFINE_integer('num_multimer_predictions_per_model', 5, 'How many '
+                     'predictions (each with a different random seed) will be '
+                     'generated per model. E.g. if this is 2 and there are 5 '
+                     'models then there will be 10 predictions per input. '
+                     'Note: this FLAG only applies if model_preset=multimer')
+flags.DEFINE_boolean(
+    'benchmark', False,
+    'Run multiple JAX model evaluations to obtain a timing that excludes the '
+    'compilation time, which should be more indicative of the time required '
+    'for inferencing many proteins.')
+flags.DEFINE_boolean(
+    'use_precomputed_msas', False,
+    'Whether to read MSAs that have been written to disk instead of running '
+    'the MSA tools. The MSA files are looked up in the output directory, so it '
+    'must stay the same between multiple runs that are to reuse the MSAs. '
+    'WARNING: This will not check if the sequence, database or configuration '
+    'have changed.')
+flags.DEFINE_string(
+    'docker_user', f'{os.geteuid()}:{os.getegid()}',
+    'UID:GID with which to run the Docker container. The output directories '
+    'will be owned by this user:group. By default, this is the current user. '
+    'Valid options are: uid or uid:gid, non-numeric values are not recognised '
+    'by Docker unless that user has been created within the container.')
+
+FLAGS = flags.FLAGS
+
+_ROOT_MOUNT_DIRECTORY = '/mnt/'
+
+
+def _create_bind(bind_name: str, path: str) -> Tuple[str, str]:
+  """"""Create a bind point for each file and directory used by the model.""""""
+  path = os.path.abspath(path)
+  source_path = os.path.dirname(path) if bind_name != 'data_dir' else path
+  target_path = os.path.join(_ROOT_MOUNT_DIRECTORY, bind_name)
+
+  logging.info('Binding %s -> %s', source_path, target_path)
+
+  # NOTE singularity binds are read-only by default
+  if bind_name == 'data_dir':
+    data_path = target_path
+  else:
+    data_path = f'{os.path.join(target_path, os.path.basename(path))}'
+
+  return (f'{source_path}:{target_path}', f'{data_path}')
+
+
+def main(argv):
+  if len(argv) > 1:
+    raise app.UsageError('Too many command-line arguments.')
+
+  # You can individually override the following paths if you have placed the
+  # data in locations other than the FLAGS.data_dir.
+
+  # Path to the Uniref90 database for use by JackHMMER.
+  uniref90_database_path = os.path.join(
+      FLAGS.data_dir, 'uniref90', 'uniref90.fasta')
+
+  # Path to the Uniprot database for use by JackHMMER.
+  uniprot_database_path = os.path.join(
+      FLAGS.data_dir, 'uniprot', 'uniprot.fasta')
+
+  # Path to the MGnify database for use by JackHMMER.
+  mgnify_database_path = os.path.join(
+      FLAGS.data_dir, 'mgnify', 'mgy_clusters_2022_05.fa')
+
+  # Path to the BFD database for use by HHblits.
+  bfd_database_path = os.path.join(
+      FLAGS.data_dir, 'bfd',
+      'bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt')
+
+  # Path to the Small BFD database for use by JackHMMER.
+  small_bfd_database_path = os.path.join(
+      FLAGS.data_dir, 'small_bfd', 'bfd-first_non_consensus_sequences.fasta')
+
+  # Path to the Uniref30 database for use by HHblits.
+  uniref30_database_path = os.path.join(
+      FLAGS.data_dir, 'uniref30', 'UniRef30_2021_03')
+
+  # Path to the PDB70 database for use by HHsearch.
+  pdb70_database_path = os.path.join(FLAGS.data_dir, 'pdb70', 'pdb70')
+
+  # Path to the PDB seqres database for use by hmmsearch.
+  pdb_seqres_database_path = os.path.join(
+      FLAGS.data_dir, 'pdb_seqres', 'pdb_seqres.txt')
+
+  # Path to a directory with template mmCIF structures, each named <pdb_id>.cif.
+  template_mmcif_dir = os.path.join(FLAGS.data_dir, 'pdb_mmcif', 'mmcif_files')
+
+  # Path to a file mapping obsolete PDB IDs to their replacements.
+  obsolete_pdbs_path = os.path.join(FLAGS.data_dir, 'pdb_mmcif', 'obsolete.dat')
+
+  alphafold_path = pathlib.Path(__file__).parent.parent
+  data_dir_path = pathlib.Path(FLAGS.data_dir)
+  if alphafold_path == data_dir_path or alphafold_path in data_dir_path.parents:
+    raise app.UsageError(
+        f'The download directory {FLAGS.data_dir} should not be a subdirectory '
+        f'in the AlphaFold repository directory. If it is, the Singularity build is '
+        f'slow since the large databases are copied during the image creation.')
+
+  binds = []
+  command_args = []
+
+  # Mount each fasta path as a unique target directory.
+  target_fasta_paths = []
+  for i, fasta_path in enumerate(FLAGS.fasta_paths):
+    bind, target_path = _create_bind(f'fasta_path_{i}', fasta_path)
+    binds.append(bind)
+    target_fasta_paths.append(target_path)
+  command_args.append(f'--fasta_paths={"","".join(target_fasta_paths)}')
+
+  database_paths = [
+      ('uniref90_database_path', uniref90_database_path),
+      ('mgnify_database_path', mgnify_database_path),
+      ('data_dir', FLAGS.data_dir),
+      ('template_mmcif_dir', template_mmcif_dir),
+      ('obsolete_pdbs_path', obsolete_pdbs_path),
+  ]
+
+  if FLAGS.model_preset == 'multimer':
+    database_paths.append(('uniprot_database_path', uniprot_database_path))
+    database_paths.append(('pdb_seqres_database_path',
+                           pdb_seqres_database_path))
+  else:
+    database_paths.append(('pdb70_database_path', pdb70_database_path))
+
+  if FLAGS.db_preset == 'reduced_dbs':
+    database_paths.append(('small_bfd_database_path', small_bfd_database_path))
+  else:
+    database_paths.extend([
+        ('uniref30_database_path', uniref30_database_path),
+        ('bfd_database_path', bfd_database_path),
+    ])
+
+  # NB for binds:
+  #    - first arg = path on host
+  #    - second arg = path in container
+  for name, path in database_paths:
+    if path:
+      bind, target_path = _create_bind(name, path)
+      binds.append(bind)
+      command_args.append(f'--{name}={target_path}')
+
+  output_target_path = os.path.join(_ROOT_MOUNT_DIRECTORY, 'output')
+  binds.append(f'{FLAGS.output_dir}:{output_target_path}')
+  logging.info('Binding %s -> %s', FLAGS.output_dir, output_target_path)
+
+  tmp_target_path = '/tmp'
+  binds.append(f'{tmp_dir}:{tmp_target_path}')
+  logging.info('Binding %s -> %s', tmp_dir, tmp_target_path)
+
+  use_gpu_relax = FLAGS.enable_gpu_relax and FLAGS.use_gpu
+
+  command_args.extend([
+      f'--output_dir={output_target_path}',
+      f'--max_template_date={FLAGS.max_template_date}',
+      f'--db_preset={FLAGS.db_preset}',
+      f'--model_preset={FLAGS.model_preset}',
+      f'--benchmark={FLAGS.benchmark}',
+      f'--use_precomputed_msas={FLAGS.use_precomputed_msas}',
+      f'--num_multimer_predictions_per_model={FLAGS.num_multimer_predictions_per_model}',
+      f'--models_to_relax={FLAGS.models_to_relax}',
+      f'--use_gpu_relax={use_gpu_relax}',
+      '--logtostderr',
+  ])
+
+  options = [
+    '--bind', f'{"","".join(binds)}',
+    '--env', f'NVIDIA_VISIBLE_DEVICES={FLAGS.gpu_devices}',
+    # The following flags allow us to make predictions on proteins that
+    # would typically be too long to fit into GPU memory.
+    '--env', 'TF_FORCE_UNIFIED_MEMORY=1',
+    '--env', 'XLA_PYTHON_CLIENT_MEM_FRACTION=4.0',
+  ]
+
+  # Run the container.
+  # Result is a dict with keys ""message"" (value = all output as a single string),
+  # and ""return_code"" (value = integer return code)
+  result = Client.run(
+             singularity_image,
+             command_args,
+             nv=True if FLAGS.use_gpu else None,
+             return_result=True,
+             options=options
+           )
+
+
+if __name__ == '__main__':
+  flags.mark_flags_as_required([
+      'data_dir',
+      'fasta_paths',
+      'max_template_date',
+  ])
+  app.run(main)
+","Python"
+"AlphaFold","sbhakat/AF-cryptic-pocket","af-md.sh",".sh","1750","52","for i in {1..32}; do
+
+mkdir Model-${i}
+cp AF-structures/prot${i}.pdb Model-${i}/prot.pdb
+cd Model-${i}
+cp ../tleap.all .
+cp ../subst .
+subst 'CYS A  49' 'CYX A  49' prot.pdb 
+subst 'CYS A  54' 'CYX A  54' prot.pdb
+subst 'CYS A 251' 'CYX A 251' prot.pdb 
+subst 'CYS A 287' 'CYX A 287' prot.pdb
+subst 'ASP A 216' 'ASH A 216' prot.pdb
+tleap -s -f tleap.all
+sander -O -i ../inputs/min.in -o min.out -p com_solvated.top -c com_solvated.crd -ref com_solvated.crd -r Partial_Mini.rst
+sander -O -i ../inputs/full-min.in -o full-min.out -p com_solvated.top -c Partial_Mini.rst -r Full_Mini.rst
+ambpdb -p com_solvated.top -c Full_Mini.rst > Full_Mini.pdb
+echo 0 | gmx trjconv -s Full_Mini.pdb -f Full_Mini.pdb -o Full-min.gro
+acpype -p com_solvated.top -x com_solvated.crd -b gmx
+
+cd gmx.amb2gmx
+
+echo q | gmx make_ndx -f gmx_GMX.gro
+echo 4 | gmx genrestr -f gmx_GMX.gro -fc 500 500 500 -n index.ndx
+gmx grompp -f ../../inputs/em.mdp -c ../Full-min.gro -p gmx_GMX.top -o em.tpr -maxwarn 1
+gmx mdrun -ntmpi 1 -v -deffnm em
+
+sleep 1s
+
+gmx grompp -f ../../inputs/nvt.mdp -c em.gro -r em.gro -p gmx_GMX.top -o nvt.tpr -maxwarn 1
+
+sleep 1s
+
+gmx mdrun -s nvt.tpr -o nvt.trr -x nvt.xtc -cpo nvt.cpt -c nvtout.gro -e nvt.edr -g nvt.log -nb gpu -bonded gpu -pme gpu -pin on -v
+
+sleep 1s
+
+gmx grompp -f ../../inputs/npt.mdp -c nvtout.gro -r nvtout.gro -t nvt.cpt -p gmx_GMX.top -o npt.tpr -maxwarn 1
+
+sleep 1s
+
+gmx mdrun -s npt.tpr -o npt.trr -x npt.xtc -cpo npt.cpt -c nptout.gro -e npt.edr -g npt.log -nb gpu -bonded gpu -pme gpu -pin on -v
+
+sleep 1s
+
+gmx grompp -f ../../inputs/md.mdp -c nptout.gro -t npt.cpt -p gmx_GMX.top -o md.tpr -maxwarn 1
+
+sleep 1s
+
+gmx mdrun -s md.tpr -v -nb gpu -bonded gpu -pme gpu -nstlist 400 -update gpu -plumed plumed.dat
+cd ../..
+done
+","Shell"
+"AlphaFold","sbhakat/AF-cryptic-pocket","Metadynamics/reweight.sh",".sh","67","2","plumed driver --plumed plumed-reweight.dat --noatoms > plumed.out 
+","Shell"
+"AlphaFold","sbhakat/AF-cryptic-pocket","Trp-msm-crypticpocket/bayesian-msm.ipynb",".ipynb","2110252","1356","{
+ ""cells"": [
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 1,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""import matplotlib.pylab as plt\n"",
+    ""from IPython.display import set_matplotlib_formats\n"",
+    ""set_matplotlib_formats('retina', quality=100)\n"",
+    ""plt.rcParams[\""figure.figsize\""] = (10,8)\n"",
+    ""\n"",
+    ""import matplotlib as mpl\n"",
+    ""mpl.rcParams.update(mpl.rcParamsDefault)\n"",
+    ""plt.style.use(['seaborn-poster'])""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 2,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""import pyemma\n"",
+    ""import pickle\n"",
+    ""import numpy as np\n"",
+    ""from msmbuilder.utils import load,dump\n"",
+    ""\n"",
+    ""%matplotlib inline\n"",
+    ""import matplotlib.pyplot as plt""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 3,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""with open('raw-features.pkl', 'rb') as f:\n"",
+    ""     features = pickle.load(f)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 4,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""data"": {
+      ""text/plain"": [
+       ""5001""
+      ]
+     },
+     ""execution_count"": 4,
+     ""metadata"": {},
+     ""output_type"": ""execute_result""
+    }
+   ],
+   ""source"": [
+    ""features[0].shape[0] ""
+   ]
+  },
+  {
+   ""cell_type"": ""markdown"",
+   ""metadata"": {},
+   ""source"": [
+    ""## Trp Angle distributions""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 22,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAABo4AAALACAYAAACthYB+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAABYlAAAWJQFJUiTwAAEAAElEQVR4nOzddXhcVfoH8O8di7u7e9KkSZum7i0VoC3FCoWixd2h2GKL7C67wG8XWZzF3d2pG6VC3T31NI3d3x+RZjJ2Z+bOlZnv53n22TIZOdfOPfe857xHEEURRERERERERERERERERAa1C0BERERERERERERERETawMARERERERERERERERERAWDgiIiIiIiIiIiIiIiIiDowcEREREREREREREREREQAGDgiIiIiIiIiIiIiIiKiDgwcEREREREREREREREREQAGjoiIiIiIiIiIiIiIiKgDA0dEREREREREREREREQEgIEjIiIiIiIiIiIiIiIi6sDAEREREREREREREREREQFg4IiIiIiIiIiIiIiIiIg6MHBEREREREREREREREREAACT2gUg7RIEYT2ASAAbVC4KERERERERERERERFJlw3goCiKOe5+kIEjciYyJCQktqSkJFbtghARERERERERERERkTQrVqzA0aNHPfosA0fkzIaSkpLYBQsWqF0OIiIiIiIiIiIiIiKSqKamBgsXLtzgyWe5xhEREREREREREREREREBYOCIiIiIiIiIiIiIiIiIOjBwRERERERERERERERERAAYOCIiIiIiIiIiIiIiIqIODBwRERERERERERERERERAAaOiIiIiIiIiIiIiIiIqAMDR0RERERERERERERERASAgSMiIkUca2mFKIoQRRHr9xzBzoONaheJiIhIEa1tIhZv3o9vV+7EocZmtYtDRAoQRREfLdmG29/7Hf/9eT2vfYU1NLVg3oZ67Dl8DADQ0tqGhZv2YXN9A0RRVLl05GtNLW04cJTXXKfWNhG/bzmABRvr0dzapnZxvHKgoRm/bzmAFp1vh6/sPnQM367cie0Hjrr92QNHm/H+oq14+bcN2LKvQbYyNTa3oqnF9nit230Yb8zbhPkb6hWtlxuaWhT7LdI/k9oFIPJ3Bxub8eS3a7B4836UpUbhhPJkNDa3oiozGpHBZrWLRz7W2NyKm95eii/+2IGWNhGtbccbBBN6peDvp1XBYtJ2DL+xuRWiCIRYjGoXxa+0tLbhwc9W4qMl2xAVYsbMoXmYWpOudrFIA1rbRBxpauE9IkC9t2gLPlm6A3FhFswYmI3i5Ai8+OsGfLpsB2JDLbhgcA76ZseqXUzJGptbMfPlBfjhz90AgLgwC169qB+KkyMlfX73oWP4eOk21B9pwqiSJFRmRNu8p7VNxCuzN2LO+r3IT4zA+QOzcaylDcu2HkB5WhSSIoPl3CRNW7H9IJZvO4iqzGjkxocBAARB8Oi7WttEGA2efZZ8p6GpBcu3HURBYgSiQt27T+w40Ii/f/UnVu08hL7ZMbh2dCFCLd51CcxdX4/3Fm2ByWDA1Jr0rmv04S9W4f++X9v1vns/Xo73Lx+IKjvXMEnT2dnn6pj9unYPZr68AIca298/tSYdv67Zg20H2geuTemdhr9O7YUjx1pw+/vLMHvtXuQmhOG28SWICDbh25W70NTShrK0KAwpSHBaD/y2di9en7cJLa0iptakY3hxIgCgrU3ExvoGpEWHaP5Zx56t+4/ijbmbsOvQMYwuTcLIkiS1iySJKIr4+9er8cyP69DY0orBBQl4YlpvVdqUR461YMHGfdhY34CW1jbUZMWgV3q04uU41NiMGc/Pw4KN+wAABYnheO2iOiREBCleFnf8umYPXpu7CU0tbTilJh1jy5Lx1Pdr8MgXqyCKQGyYBS+eV4uK9Cin37Nm12E8+sUqrN51CLU5sR3XufX5sGVfA2avq0d6TAj6ZMXAZHT/mm1oasHRplbEhUvbr21tIgwGAaIoYtXOQ5i9di+2H2xERVoUxpenwOBB++ODxVtx3ZtLuvpc7phQggsH50r67O5Dx3DG079h7e4jHV/2B4YUJuD5GX09bgs1tbThlneX4uMl22E0CDizNhN3TCiBwSDghreW4O0FW7ree2ZtJh6YXN7VZtuyrwFz1tUjyGzA2LJkmD04Jj0t23oAV7++CGt3H0FuQhj+flqV3Xa1LzQ0teDhz1dhzvp65CeG44YxhciKC/P6e1ta27B06wGIItArPUqW/UTWBI42IUcEQVhQXV1dvWDBArWLoluiKOLUf/+G+R2NFHuGFSXg0qF56Jcbp2DJyNdEUcTLszfizg/+cPo+dxozQPuNceWOQ4gPD0Jy1PGOsKaWNry/eCv+3HEIfbJjMbYsyWFHUeesp+0HGlGdGeMwICSKIh76bCVe+m0jmlvbcEJ5Mh6ZWukXAaQdBxrx2pyN2Lq/ESNLEjG+IkWx3/5k6XZ8/scOfLRkm83fXr6gFoMLEhQrC8mnsbkVwWbvr41nf1qHx79ejcNNLeifG4cnp1UjJsxi9Z7Pl+3Af39Zj6NNrTi5KhUXDMrxuGPYE21tIt5euAVzOxr+0+uyEBYU2GORGptbsbm+AbkJ4Vi3+zAiQ8wOgxXHWloRZDp+roiiiCNNrQgPMuHFXzfgrg+P3zfCg0wYV56Mt7o9WAabDXjvsoEoSWkPvDS3tmHJ5v1IjAhGRmwIBEHoejibu74eBUnhuG60PA9nnnhz3mbc9M5Sq9cGF8Tj5Qv6ufzsrkONOPXfv2Hj3vZRn0aDgKfOqsbYsmSr993yzlK8Pm+zw++5cFAOSlMjUZwciZKUCEWvF1eOtbTCbDB41EHS09++XIV/frvG6rW06BCc0z8LFw/JlbzdDU0tuOntpfhmxS7ER1hwzchCnMKBDZrw3apduPSVBWhsboNBAO45uRzT67IkfbaxuRVj/v4jNtUfH0U9tDABL55f63F5fl69B+e9MBfNre19CsFmA169sA5lqZGovOdLHLMzwvrtS/qjj4zB7831DViwcR9yE8JQkRbl0fV9qLEZ367chb9+thJNrW2oTI/GxUNyNfN81tTShlveWYoPl2yDQRBwSk0a7ptUYbczs61NxOCHv8PW/c5H299zUhlen7cZK7YfdPn7i+8cjehQi83rs9ftxfTn5nQdf0EAnp7eB/HhFlz00gLsOXwMoRYjHpxSgZOr0mw+L4oiPv19B+ZtqEdxcgQm9U6TpS3lrZ0HGzH5yV+6Am0A8MDkCkzrl6liqaT5fNkOXPKKdf/N1Jp0PHpqpaTPNza34uHPV+GHP3chMzYU14wq9KhjednWAzj7uTnY32A96+nWccWYOTQPALD38DF8uXwnDje2YHRpErLjfdNO+cfXf+IfX6+2eX1qTTr65cTilOp0h/fghZv24fGvV3cNfqlIi0J6TAgig804sTIVgwriZS1re4YSYO6Geqtry5Gc+DB8d8Mwh38/1NiMEY/9gN2HjnW9VpMVgxHFifh9ywGUpkbiWEsrnvzueJB/bFkSnphWLbkDvq1NxL0fL8erczaiuVXE4IJ4PHVWNfY3NMNoEJASFYz6I014/JvVWLH9ILbsO4qWNhFHjrWgPDUKW/cftamvTq1JxyMSz9lOjc2t6H3vVzja3Gr1+m+3jkBKVIjLzz/x7Wo8+uWfNq+fPzAHd55Y6lZZOl3z+iK8v9j6mf8vk8qREROCGc/Ps3n/J1cNQllqFOZtqMcFL8zDwY7gf3FyBN6/fKDk+vFQYzNEwCpg3NTShpr7vuoaUNBpcEE8DjW24NJheRhT6rgPyVvnvzAP367c1fXfiRFB+PaGYQj34hlyf0MTpj83F79vPQAAKEmJxMsX1CJeYvAykNTU1GDhwoULRVGscfezDByRQwwceW/1zkMY/fcfXb4vyGTAx1cOQkFShEe/c6ylFS/8sgFLtx5ARVoUzu2frZvO/c31DVi7+zB6Z8YgKsR2JFT7KMatMBkEq1GMWvfSbxtcBo06bXhogsv3HD7WgrOenYMlm/d3vXbJ0DzcNLYIAHD+i/Pw/ardXX+7eEgubhtfYvM9rW0ibnv3d7wxv72DLTrUjOfO7YMPFm/DT6v3IDM2FNeOLkRVRjTenL8ZN71t3dln73sPNDTj5zV70NzaBhEiGppaMaQgARmxoQDag11b9h1FRmyoJkYu7z18DJOe+gWb6483UG8bX4yLh+R59b31R5qw40AjipIjHG6nq/NidGkSnjmnj1flUFJDU4vXI5X1pmen/5LN+3Hdm4uxdvcRRIeaMa48BRVpURhVkohEN2c5/Lp2D6Y9M8fqtRPKkvHv6TVW7zn72TnoNnnR7QC0M1v3H8X8DfUoTIpAcbL9DvZZ7y/Dy7M3dv13VUY03r6kf9foxJbWNqzbcwRZcaFW+6q7o02t+HrFTmzZdxSDC+JRnuZ8tKSvtLWJ+G7VLqzYfhDVmTHon9feSbipvgFhQSZJDx5vztuMWR8ss+kgPakyFWf1y8TPa/YgKTIYtTmxuPODZZi3YR9So4Nx18QymIwCbn9vGbbuP4rytEis2nHIZScBAEQEmfD7PWOxZtchTHtmDnZ1dAic3icDD0ypwAU97gkpUcH46rqhXj2c9bR1/1GYDYLL87z8ri9w+JhtSowld43BfR8vx/d/7sbuQ8fQLycWZ9dlYXRpUteD8bM/rcN9n6yw+lxlehQ+uGJQ138fbGxG9b1foaVN2jPNZcPycNMJxZLe645Djc2484M/8POaPciJC8PN44pQk+W4c/xYSytue3cZPvl9G4LNRpw3IAfDixOw8+Ax1OXG2owGPtrUijW7DqMgKdxux8G2/Ucx4KFvHf7e306rxJRqacGf695YjHcXbe36b0EA/ntuXwBAdnwYsuNCnXYs7DrUCJPBgNiOoPf2A0fx9fKdsJgMGFmS5PS6amppw7JtB5AQHtTVjvBnOw404pc1e5AYGYTanNiuOrOltQ3//HYNvl25E2nRIbhieAGKUyJQ85evujqSOkntFPtu5S6c94JtR9Xc20a6fb/qdPFL8/Hl8p1Wr51SnY6xZUm4+GX7z5ATe6XgiWnVWLJ5P774YweiQsw4uSrNakCUVB8u2Yar/reo67+n9cvE/ZPK0dTahh0HGpEUGYzVOw8jNyGsa4BDY3MrgkyGrnO4/kgTpj0zGyt3HLL67mCzAR9cPghFyZ49n8np8a9X4+9fW3dojipJwnkDs1GTFWNVJ8xdX4/T/vObrL9fmhKJT68ejLY2EWt3H0ZiRDCiQs0onvUZGpttg4OCAPTsZvrkqkGIDDYjyGxAYkT7sb7v4+V49uf1Xe8ZXBCPF86rtduOPtTYjFnvL8OPq/cgIzYUN40tQpDJgE9/39Ex2zQc48pTMKwoAat3HkZ4sAk5HgYinvt5Pf7y8XKr13Ljw/Ctkw56T7S0tmH1rsMItRgRZDJ6dA30NOnJX7C42/Nip+X3ju1qs3fO9LCnZ/0fEWTCF9cOQWq08zpm+baDeHfhFjS1tuHkqjTc98lyLNpkWw4A+PCKgUiICMLp/5ndFcgOtRjx8gW1Tu+bUjW1tGHD3iPIjgtDc2sbyu76wun7ZwzIxt0nlVm9duRYC+ZuqMdFL8532r64ZVwxLhnq+BnyQEMzIoJNkgaHvD53E574bg0ONDTjkJ12kyPf3zAMf+48hI+WbkeYxYiz+mV1zUKyF0iU4rlz+0ieZff2gi244a0lDv9emRGNXQcbsf2Ae6n6f755ONJjpLcDPli8FVe/vtjm9atG5OO6MUUuP599yyd2X48KMWPRrNGSjuHm+gZ8uXwnLEYB+xqa8bevbANRzqTHhKA4OQJfr9hl87eUqGB8f+MwBJmMONTYjD2Hm2zaY82tbbj57aX4oGOA6sReKXhkaiXMRgET/vkzlrsYKOBNkMyRvYeP4X9zN9kNyj0xrTcm9kr1+Lsf/GwF/vPDOqvXLhiUg1kT5d0Gf8DAEfkEA0fe+9tXf+Kf39iObrHnyhH5uF7CDc2entF7AJhUlYpT+2RgYL70UTC/rd2Lh79Yic31DRhSkIB7J5U77WQ62tSKRZv2QQTQLyfWrSnNoihapbAIMhnwzDl9MKTw+GyLn1bvxnnPz+tqrAWbDXjtojpUZ8ZI/h21nPCPH20eQB35+ebhSIsOwe5Dx5AQEWS3M+bc/87tGunU3Zsz+8NiMmDSk79YvW4yCFh452jUH27Cf39Zj+0HGjGiOBHJkcF2Ow26iwgy4cvrhuC6N5bgt3V7bf7+zqX9uxr1m/Y24MxnZtuMEgo2G/DfGX1xtKkV17y+GIeOtSAm1Iwnp1VjgBvnpDs+XLINT323BgeONuPEylTcNLbI5pzcuPcIZn3wB37ssS8TI4Iw57aREAQBh4+14Ilv12D59oOoSo/CzKF5NrMpth84it+3HEBZWhRSo4Lx189X4T8/roUoAqlRwXjpgn7ITwy3KWPFXV+4fBCQEkiUS2NzK/7x9Wr8tnYPchPCcfXIAkmj/ZZvO4hr3liEP3ceRnZcKB47rVKWBz25HGhoRpDZIOuo1Z9W78adH/yBjXuPoHdmDP5+WhUiQ0wY+sj3dnPIJ0YE4fWL65CbYHse7DjQiFkfLMOiTftRmhqJu08sRW5COGY8P9eqs7/TugfGdz2s2JtZkRYdgns6Hnj758V5PPvn/UVbcd2bi7uCUhcNzsFt40us6qSDjc3ofe9XVmk3AeC1i/phQF68TXqcx8+o6hpl3NnmbGxuw7n/nYu5G+q7Pn/R4BzcPsE3jfwFG+vx4eJtsJgMOKUmvStFmiiKuOGtpXhn4fHZPHFhFqTHhnYF6U+pTsdfT6lweH/bXN+AIY98Z9NBpoR/ndkbL/+20Wo/Au2jom9773eb95/TPwu3TyixCuY1tbRh3Z7DAID8hHCb7TzU2Iwf/9yDw8eaMbQwEclRwTjY2IyZLy3ouj+MLE7E/51dA5NBwHM/r8eXy3cgKTIYM4fkITkqGH3v/9qt7RpcEI/nzu0Li8ng8CF+5V9OwKodh2AQBGysP4IrXltk932O/HjjcCRGBuGhz1bilzV7kB0fhmtHFaI0VVr6PHt6tsVCLUZ8e/0wJEcFo7G5FY9/sxqz1+1FXkI4rh1diBd/3YCnf1zn8PvqcmNx49j24NMHi7fixreWoqm1DaEWI546qxrDihK73nuwsRl3f/gH3l241eH39Qy4AcAf2w5g4ab9KEmOQE1WDARBQFubiNzbPnW6rTMGZOOuE0vR0NQ+07Kzk/doUysue3UBvuuox06sTMXMIbmY/twc7OsYdZ4aFYzXL+6PzDjbzqA1uw5j+nNzujqXokLMuG9SOYYWJaieurOhqQXbDzQiNz5MttG4c9fX47zn5+JIU/vo6P65cXhuRh+EWky484NleOm3jVbvr86MxkI7HbHXjCrANaMKu/77oyXb8P6irQg2GzG9fxbqOmbNnPTEz1i65YDN5++bVI6zJc5a6snRNfr4GVV2O/A6PXduH8x8eUFXGz81KhhvXzrAbue0KIp47uf1eGPeZhgNAib3TsPZdVn4Y9tBuwGSs+sy8c6CrVajzs1GATeOLcJva/fi5zV7EBcWhJtOKMKU6nQ8/eNaPPDpSrvlPLM2Aw9O6eVwO1pa2zB/4z5sqm9AXU6c3fPaE53PSd+u2IXS1Ei8t8jxtZ2bEIbXLqxDTJgZ578wD7+ssW27y+G5c/vgghfnd/33oPx4/Lxmj8ffN7I4Ed+stO0c/b+zqnFCebLNdXbRS/PxVY8gpSt5CWH47OohNqnyWttENDa32rSXDjY2I8xiQp6DOnDN/eOs7pNrd7enAFu7+zD65cThlnHFVt/Z3NqGpVv2IzLYjPzEcKtten3uJtzyrvW9ujYnFs/P6Ou0Hffcz+vx+txNMAgCzq7LxPT+2QDan3F+Wr0Hd7y/zO7nrhqRj0m903DDW0vw+9YDKE6OxAOTK6zSnDU2t6J41uc2n+0+S6i72ev24p0FW7Bs20FJM9e6G12aZHM8hxcl4Pnz2mdAvjlvM16avQFNLW04tSYDFw6WNrv+6+U7ce0b7c+e4UEmHGlqcdlGMxsFLLpzTFe/xweLt+KuD/+wmS3lzD9Or8LJVak4eLQFUaFmbNrbgEtfXYA/th1EfLgFd55YhpMqHXeQ/7JmD856do7Dv7vr4am9MLFXCkrvdB40c6bn+d5p2dYD+GbFLsSGmTG+IgUnPfGLyxmO3siJD8NFg3NRlhqJV+dsxKHGFpxclYoTyq0zhjjqe+t+XnXX1iZi5Y5DONTYjLK0KJQ7CTB+c/1QmA2Grpn99izbegDTnpltM7hDTmNKk1CYFIGnvl+DNhHITwzHC+f17QqwPfldeyrD7qbXZeHT37dj75EmSb/RGWQWRREHjjbjn9+swferdiE1OgTXji5w65n/6+U7ceFL8x3+PTsuFN/fOBxAex32w5+7ERlsxsiSREQEm7Fyx0Es3LgfxSkR6J0RbbPvHbVBlOxP0QsGjsgnGDjynqOKzBFnFZwoili35wg21TegJqs9cPLVHzsxf2M9/jfXfnoWo0HAc+f2wbCiRKzYfhCvzdnU1ak+utR6BMnm+gaM+tsPViOmx5Qm4WkHsx+27GvAjOfnYc2u9g6n4uQIvH5xnd00BvYs23oAE//1s9VrnZ337dsLzHxlgU2DcmRxItJiQrB652H0zYnFZcPyNJHSoCd3j32n1KhgPHFWtVVwbM/hY+hzn/2Ot5lDc7F21xF8vcK9BylX7j25zOHMmMhgE+bfMRo7DjRi2KPfwdEgrILEcGyqb7A6p8KDTFgwa5TDWQjuaG5tQ2NzKyKCzZizbi9Of3q21d8vHZaHm7uNKncVzPvt1hGYt2Gf1chVABiYH4dXLujX1VB5Y94m3Pru713bPaI40SZwW5MVg3cuHWD12verdtmdkt5T93qg+2eKkyNwy7hiq85CTxw51oK56+txrKUNb8zb1NXB16n7qPSDjc02nXWtbSLqHvzGKuVBmMWIeXeMUn320eFjLbjitYX44c/dsBgNmDEwG7ecUOx1J9+ug40Y/PB3dlPuOHN2XSbum1Rh9Zooihjz9x+xuqPuBNpn/k3slYJXZm+y+z0vnl+LvtkxCLWYXNYtOfFheO2ifg5Hn3+zYic+W9a+fs4ZtZldo3GbW9vQ+96vbGaGfHntEBR2zIZtaxPx9E/r8NBnth1sNVkxeP3iOpTe+bnNjJmPrxyEeRvq8fSP63C0uRVmo8Hq/Okk58ypTj/+uRsXvDjPqkyVGdE41twKi8lgtxO1p3P6Z+Gc/tnISzjeYXzkWAs272vAOwu24Jmf1rv4Bt/ISwg7noddotrsWDx/Xl8EmQy48e2lVp2RFWlReG5Gn66R4HsPH8OZz8zGnzvbz9XIYBOuGllgMwMIaD/+/XPj8MR3a2z+5onJvdPw11N6ofCOz+z+vTg5QvLgDHsuHZaHTXsb8Mnv223+FmI24olpvd1az2J/QxOq7v3K5vWIYJNNShCgfdSolJG3nanI7vpgmdW9tvNeajIYcNeHy/DanE0O78XdPXVWNb5esRPp0SEwGASr1D2dwaDmVtHhfrcnItiES4bm4bJheXjo85U2Iz8d6ZMVg6LkCFwzqrBrnYmznp1tt9M7PSYEr19c59bIYzk9/eNaPPLFKjS3ikiPCcGL59ciz86gAKk603Nd/tpCm789OKUC48tTMOjhb+2eO/b0z43D/y6uAwC8s2ALru828ttiMuD1i9sHXY17/Ce7nbulKZH45KpBXfXbsZZW/PTnHmyqb8CA/Din65E5uif9/fRKXPuG4xHofbNjMG+DdSrvmqwYPD29xmZ9jNfmbLIbDPeWIADPnmMdDLHnxrFFCA8yYWxZMpIijw/wamltw9WvL+6qR8xGAf86szfK06Lw+bId2HmwETnx4fht3V6EBxlRmR6N5tY27G9oxuiyJKv92tTShoWb9uFwYwv6Zsei8t4v3doWR0EYPRtSmIDnzu0Ds9GAA0ebUXmPe/ukU3FyBD6/Zgi+Wr4TF/XowBxcEI9/ndkbrW0iLn11Ieaur3fwLe1eu7Aftuw7iuqsGCRFBmH4oz9gz+Hj7Zm8hDAMLkjAtv1H21NLLd7WNaNmZHEinjyrGsFmo92ydIoMNuGXW0Z0zTptaxPx6pyN+G3dXszbsM+m/TStXyZem2O//dhTcmQwdhw8fu+JCDLh3AHZmLN+r8312FPPfoqfV+/BjOfnSp7tK9UnVw3Cec/P65pJ3ekvk5yn5dy0twHvLNyCxyUO2u3pmXP6YHRpEjbuPYKhj3zv0Xd0yogNscpsAbTfz7+9fljXAL11uw/j9Xmb8ce2AxhXnoLFm/dbrXcjB7NRkDSL3ZH4cAvenNkfuQnh2HWoEc2tIpZu3o9LX7W9d6nhsVMrrdLoPvrFKrvt0FElSXj2XOs+raNNrbj45fn4abV7we/KjGg8M70GiZHBaG0T8dR3a/DVip1IjAjC8m0HrdJbKunxM6owtDABNfd9bTO4z10Te6UgLSYEr/y2sWtgS3dlqZH4Y1t7W6JXehRuOaEYA/Lj8cIv6/HG/PZz+MzaDIwqSXI6Ex5oH/z4yy0j8OvaPbjwxflo6Pi94uQIjC1LtrqezxuYjbtOPD4z8FhLK4rusA10Awwc2cPAEfkEA0fecTRix5mxZe3pO2ZNLLUKhrS1iZj1wTK8KrFR2N2Y0iTcOLYIU5761Wqmw70nl2FMaTJ+XL0b0SFmLNq832oB205/3DPW7qgne6Pee3bUO3PV/xbhQztrvJxYmYr5G+rR2NzaNTrVGWfBLaXMWbcXX6/YifjwIEyuTkNiRLDHgaNOFw7KwbM/r0dJSiRCLcauxTztyYkPw/o97nUeeisrLrRrzQl3PT+jb9fCuZ4QRRH/+Ho1nvlpHY61tGF4UQIsHakqevr4ykEoT4tymLO4u+FFCTZBlE6VGdHYuu8ookJMkjtqP7lqEESxvUNGEICBD30rqTE5qSoVt44vwYeLt+H+T207aLt35K/dfRi/rt2LzNhQDMiLc5mLetfBRpz93JyujmBHHphcgX//sBab6huQGx+Gf5xR1bWY7W9r9+LMZ2bbfObRUysxVeU1MG59d6lNIL37jBdPORuN7MqGhyZgf0MTvlmxC0eaWpAYEexRyojoUDNePK8WJ/eYXWiPxWTAn/eNs3n9ujcXW81ICA8y4bOrByMjNhTfrtyJ81+w7cSYUp2Gv51Whfkb6jH1345T32TGhmLWxFKHHSFSLZw1uiu9VVtb+yjz7//chYyYUFwwKAffrNyFeevrUZAUgQsH5zhNebXrUCPOe35e18ONt3ITwvDS+bX4Y9tBXPvG4q6HG72JD7cgOtTSNfCju84gWZDJgA+XbLMZtehMeJDJbko6Tw3Mj/PZyPnanFiXHYTPntMHo0qTrPLEb9hzBPd89AcWbtqPA0ebMa48GWPKkpAcGWK3XvSlJ6dV42hzq9P0MO769vqhSI0Ocbv9CrR3unly/ecmhOHzq4fAIAD5tzsOWJ3VLxP3T65w+PdOrW0i9hw+hrcXbMHCjftQlByBmUPyEBVqPQiiubUNZqMBDU0tECA4TPG8ZPN+m3q3PC0SH185WMLW2WpsbsVjX66SNeDcfc2wyU/9YpMeanpdFv4yqRyj/vaD3eseAP5ychmm989GU0sbLn55ftfsV4MA/O20Kkzqbf8+6qi9+9iplVYBLKmCzQY8dVY1RhQnobG5FS/8usHuYAU1WYwG3H1SGRZu2udxR6/FZMCzHZkW9jc04aKX5rvsuA9E5/bPwj0nl2PRpn2Y/NSvHn+PvdktnSb0SsEnS20HEThjNAgYUhDv8LnBkc7rLP+2T10GXIqTI/CXSeX4eMk2vNhj9qEafr1lhNWMwEtfWYDPltk+e/lK97V8RFG0GhT2x7YDmPbMHLsZAKS6cWwR5qyvt8lKIaebTijCZcPysWlvA4Y/9r3XHfxKqMmKQW1OLJ77aT2aWt0bQOdrvdKj8MDkCqREBSMuvH0W+b9/sO3P6pn2GwCe/2U97vlouc17pTitTzoenlqJBz5d4XTmuNJSo4JVC1zZkxsfhnUS+qiuGVWAp75fiyYJAzS/u2EYsuNC8eiXq6zW5eqJgSNbDByRTzBwZJ8oijjY2ILdh44hPSYEwWYjvvxjB575aR3mbdiHoYUJeOiUivZFHiWsb+TIo6dWYnRJEqJCzXbXvXDHzKG5kkeA9vTZ1YO7FuDuzt6DYlFSBL64dojL72xpbXPaOeCuebeP6hqtqrT3F23FtW8utpoCP7gg3u3RK4HEXlrGltY2vL94G/7YdgBVGdGY2CsVLW1teG3OJizbehBVGVE4ozYTZqMBny/bjktekT7S6eMrB9nMblNSbkIY7j6xDOf8d67kz1hMBqeNpxfO64sjx1px1euLuh46RpUk4qmzamzScXTnqEHtSkyoGXNuG4Wjza0OR3yOLE7EczP6uv3dcrJXL+UlhOGb64cBaD/Pnv15PX5duxe58WGYOTTX4cycw8daMG9DPSxGA25993erxcTdMfe2kTj96dmyBHfL0yKxbKv7QZAJvVJw0eBcm5SWQPuDcnVmjNNO7xkDsvHCrxtc/s75A3Pw31+86wztnxuHVy7sB6NBwL0fLXf5fS+eX4uBeXEwGQ0QRRFP/7gOby/YYjWjS059smKwfPtB3QaNyDNGg4CxZUl2BygA1qMvlVKbHYst+xpk7SSYMSAbN51Q5FFqG0/rJ6B9FH9paqTdWVvdXTe6EKEWIyb0SrFbd3+weCvu/Wi5TTqWstRIfHD5QJiMBvy58xBueGuJ1WxDk0HAyVVpeGBKuc2M6MteXWD3uM+5bSSSOtYFOtjYjN/W7kVksBkRwSYs2rQPhUkRqM2JhSAIONbSirs/XI7/zXV/AJgUw4oS8EJHGh5naVuGPfIdNjgY9NPZhnc0iGD9g+Ptzt71dqCUPUmRQfjXmdWyr9OjNbXZsZjePwtX9pjpTtbWPzge8zbs84vzQRCAn28egYEuRuFrVfd05b649l156fxaPPHdGizfdhD5ieG4ckQ+hhcl4oa3lzhN1aol6x8cj/4Pfms184u8d3ZdJkItJruBnAkVKXjyrGqr17w9f5ffO9arNIDkmYsG5yApMthu9oPufrhxGLLiPFvjzl8xcEQ+wcDRcd+t2oXHv16N3YeOYffhY10dukMLEzCyJNFuSq87J5bi3o89G8XQ3fiKZGzd39i13oLSvrhmCFrbRCzYtA/FyRHokxWDA0ebHT7cS4nu28u96o1RJUl46JQKSYuYd7dlXwNCzEablBjuGPP3H1zO3iBrJ1am4lBjM5ZvO4jKjGicUp1mNxDUc0R4Z6PvxH/9jN+3uk4vFYhmDMhGXW4cIoJN6JsdaxNE8qaR/OCU9llIjmaadR/xrBZH2/fdDcOQEx+Gm99eijfmH5+RlBkbik+uGtSVDmRzfQPmb6yHxWjEg5+twJZ93ufrvmZUgVU6KC2yGA2aGkU4sVcK/nZaFWr+8pXkxYFfOK8vNu5twF0f2k+xSUSuDS9KwD/P7I2Kuz1LCeWpQfnxeHBKBQY//J2k9ydHBuOtS/ojI/Z46rqNe49gxGM/OBzB/dpF/VCbHYsBD31rkwKp0/WjC3HlyAKr1xzdVzpnNC/YuA8zX56PPYftrx2gRAqxUSWJePbcvk4HZv1neg1mvuz8mW7dA+Mx+f9+dfrMkRIVjKy4UMwckofhxYmqdB5TYPnzvnGYt6Fe1vVfyDNmo4D/zuiLwQUJvPZJV3qlRyEjNrRrAEr/B/UZvKX2WXDOsvEA7W2Vb64fqnoafS3xJnDEvUgkwbHmNiy28xD1w5+78YOD6cxyBI0AOBzdqpSx/7CeNVWYFI5ptZmSP3/kWAvu+egP/LR6D7LiQnHj2GI8KdMaCJ2+XrETfe7bifcuG4De3dYGcuTA0WZc9OJ8qwXFK9OjcKSpFafWpNtd/NOe1jaRQSMPfNQtReFXy3c6TB3RM43QJ79vx637Ghg0cuKFXzd0zQypyYrBi+fX4uDRZizYuM/ugtPuuPVd5+sLSJlerpZT//0r/ndRnVXQCAA21Tfg25W7cHJVGt5esAU3vr3E5QK67tJ60AiApoJGAPDx0u0YVpQoOWgEADOen9eV4o6IPPPdqt2Kph7q1NzaJnk9HwDYcbARr8/bhBvHHk+P/O3KXU7T/kx7Zg5eOr/WYdAIAB776k+MLU9GQY9F7O3p/PNfP1vpMGgEQJF1Z4yG9sK8u8jxiHtXQSMAyL3tU5fv2X6gEdsPNGL2uno8dmql9EISeWjAQ984vcZIOc2tIq5+fTHe7bGOK5HWLd1yAEu3HHA7LSVpj6ugEdDeVvnf3M24YFCOAiXyf5xxRA5xxtFxCzbuwyn/53le5UDSff2V1jYRl7yywCowEGox+izFT9/sGLx1ieuG7G3v/e5yEdGld49BZLDZ6XuONrWi5E731wEgz51dl4lXZvsm1Ys/qkiLwrJtB2QPhtiTHReK728c7vsfclYGD0c/RgSZ3ApSEBGRfGpzYnHDmCK3U1GtfWA8jAYBm/Y2YMgjrmcrSRml2umXW0YgLTrE4X3lr6dU4ISyFFTeq+zsLHuCTAakRYdIWkuAiIiIKBBwraPjvJlx5HwVbSICACSqtH6OHp32n9+weuchnPXsbOTd9qnNbBJfrgshdVFZV0EjALj7gz/w3apdeGfBFvy2di/2N9iOdDvWwjUulMagkXt+36pM0AgANuxtQEOTPoMvDBoREaln7vp6rN/j/gzu699cDFEUcflr0tY9lBo0AoCBD33rdCbtze/8romgEQAca2lj0IiIiIiIZMdUdUQSuLt2TiDb39CM0X//0fUbfeTNeZuRHhuCj5Zsw8a9DRhSmICLBud2pfGQ6t1FW21SfiRFBuHLa4ciKqR9JpKWU3MRqeGXNXsxujRJld9uc5KiiIiItO3md5ynQ7Xn/cXbMLk63WcpbAvvsL9eEBERERFpW3NrG8xGzpfxFvcgkQQhFiMighhn1YOb3lmKac/Mwf/mbsava/fioc9W4p6P5FksfefBY5j1/rKu/z7GwBGRled+Xqfab7cy9S4RUcC5+e2laheBiIiIiDTmX99of61hPWDgiEiijNhQtYtAHnp7wRbZZgd9uGQbnvxuDURRZOCIqIf9Dc2q/bazRdGJiMg/7TjYqHYRiIiIiEhjXpvLZQ7kwMARkUSlqZFqF4E81NDUio+Xbuv4t/drmTzyxSrUPfgNGpu5xhFRd5EdaRzV0NzKQC4RERERERFRoNtzuAn/+WEtB5h6ibm3iCSKVrFDlLx33ZtLEGw24re1e2X5vp0Hj2Hiv36W5buI/EVksHrNCjYIiYiIiIiIiAgAXp2zCTOH5qldDF1j4IhIolCLUe0ikJcue3Wh2kUg8msWk3oTmZtbGTgiIiIiIiIiIqAqI1rtIugeU9URSXSw0fsUZ0RE/sxoUK9ZsWBjvWq/TURERERERETaMbIkUe0i6B4DR0QSHTyq3qLvRER6YDIIqv32C79uUO23iYiIiIjclZ8YrnYRiIj8UlyYBaNLk9Quhu4xcEQk0biKFLWLQESkaUYVA0ez13HGERERERHpx19PqVC7CEREfunek8sRauEKPd5i4IhIorrcWLWLQEREREQkSZCK684REZFzBgHIT4zA7eNL1C4KEZFf+d9FdZjQi4P/5cCnCSKJIoLNuHRYntrFICLSrJbWNrWLQEREHWpzOOiJiDw3c2iu2kVQ3I1jixT7reFFiYgKMeOCQTm4aHCOYr9LROTPcuPDOPBfRgwcEbnh+tGFOLkqVe1iEBFpUnObqNpvWziynojIyinV6WoXgYg0xN2gyC0nFPuoJNpVnByhyO+cVJmKf5xRBQAwGATcPqFUkd+l45IjgxEdapb8/qqMaN8VhoicSo8Jkfzep8+pgSCol0Lf37CXhcgNJqMBfz+tCu9fPhD/PLM3Zg4JvFFYRIHojgkleP1idaY7v3Npf8V/01NqzjiKCpH+4EekR1pb3DU3IQyPnlqpWCeb3E6uSkXvzGi1i+FTceEWXDiIo9jJP7xyQT/e6z10y7hiLLhjFC4fno/HTq1ETEdneUValNPPCYKAlKhgJYrokfjwIESHmjGyOBE3ji3Cn/eNw9fXDcF/Z/TByOJEj76zOjMGGbG2HZR3TCjBGxfXYfatI70tNjY8NAH/PLM3IoKVPZ/HlCbh6+uGKPqbWjauIhnfXDcUufFhkt5/3sBsDMyPs3n9+fP6YsNDE+Quno0bxhT6/DcCzak1vhtg84/Tq3z23Xo2qSoV71w6ALePL8FL59dK+kxOfBgenFIhaT3lL64ZgvxEfT6baBVXiSJyk8EgoCojGlUZ0ShPjcR/flyndpFIp2YMyMYLv25QuxgB6fEzqvDlHzvxye/bXb63LDUSFw5uDxLX5cbhnpOOoc99X/u6iPjg8oGoSIuCwSDgqhH5+Oe3a3z+m52uHJGPN+dvxs6Dx9z6XEurejOOTihLxsuzNyr6mxsemoCt+49i4EPfKvq7FJiSIoMwMD8Ov6zZq3ZRsHDWaMSGWQAAz/7kXjvo4iG5qM2ORasoYubLC3xRPElGlSThxMr2WeSTn/oFizbtV60svmIyGBAWJN/jnkEAVJxYSgEsLsyCutxYRASbcOBos9rF0Y3BBfF44bxaq862U2rSMbl3Gg42NiM61IK82z5Fq5ML26DhUdvz7xhl81p+YgTyEyOQGx+O5dsPYvuBRre+02wy4LFTq3Dhi/NwsLEFggDcMKao61kAADJjQ7GpvsHr8ivNaBDYodpNXJgFceFBuOmEIlzyykKX7zcZDHju3L74YPFW/LnzMPrlxGJ0aZJPZjZkxIbgn2f0xs6Djdi4twH98+LQKz0aj375p9PPRQSZcKy1DU0tgZs+/NpRhfj71873E9C+j68eVYC3FmyRvQxTqtMwqXcarnljsezfLdV7lw1Ar/Ro5N32qWpl6EkQgDNqM1GTFYOarBjpnwMwuCABL5zXF8/8tB4//rnb4XuDzZwfIzfuUSIvxIUFefX5UItRppKo77WL+vnke9c+MB5p0dKnpepJkISbmsVowIwB2b4vjAKuHaWNUVI3ji3CyVVpeOy0Sknvb+4xiyY+PAjzbh/l00XHx5YloTIjGoaOB/3Lhuf77Ld6Kk+LxPVjivDRFYPwl0nlbn22ScUZRxHB6oyF8df6SW5vzuyPNfePU7sYbgmT+R4d1xFo8cbdJ5Y5/FtlRjTOG5gNs7G93hhcEI+Jbs6SlHo+m4yed5IMzI/HqNIkjC5JwqgS9WZRDe82Gn1iL/9MQ2z24jjZc/0Y5db+IOpkMgi466QymIwGXO+DEfdDCxMwtkw7MzrlnFXw/Iy+dkdoGwwCokOl3ZPGliXLVh45nVTpvN7Ojg/Dl9cOwdPTa/DKBf3w443DJY1WNxkE1ObEYu7to/DuZQOw4I7RuLxHO9yb82WSk7T3V40s8Ph7pVCrrewrT51VjRO8OD8n9U4DALcCP8FmI07vm4lZE0sxpizZ6rORMu7fv07phd6ZMTihPAUzh+ahV3q0tA8K7YM8pDqzNsOtcumhU/6CwTl4+QLnM1km907DF9cMQXpMqFe/lRsfZrev5goFn93tuWNCCXpnxsBoEHD+QPszz8vTImX5rbPrMiW/9++nVaEu13bWnlSDCxLw0vm1uPtEx6k9g0z+08eqFdq/6ok0LMqNnLj2PD+jb1euTk87H3MkTq32pXUPjMeAvHiffLfRICA3Qf1t9AUpN7VTatJxet8MRPQYMZyfGG634XaxhtMnDim0f46UpUa63bnpjc7GXbDZKGldnGY7s2gSIoLw403DPS6DqwdXAdZ/DzYbsXDWaI9/zx2vXlgHAEiMDMb0uiyH0+ztBb7bRPWGoqs5CF7JdFf20qd0unZUIS4anIMLBuXAYlSniffltUMQ3qO+qkyPQm1OLEwylenJadU4s1b6Q0pPwWYDBubH4a1LHKeBLEgMx8sXyjsg4p1LB2DWxFK3H9I7iaLztbyeO7cP7jqxDEvuGoOFs0bj5Qv64dQ+7v3Wp1cNlpTex5sR6J1Bd4NBwDPn1LgdoJbD1Jp0m/PUldIUeR6wlSSlk9Qdp/f17Nwl8lSoxYjvbhjWFSQYXuRZ+jFHLhuWhxfPr8V/pvfx+Ds86bhOinQ++LBEpvpGyn3XVaqmc/pnyVIWuZ0m4f4WEWzGmLJkDCqIR2ZcKJ6eXoPECOf73tyxz4LNRlRnxnTNru3Om3vg9P7ZDv/mTgesJ87XaOpSe/tYivEVKfj39Bq8d9mArr6U3pnRklLonj8wpytoYJRpxtAdMq1TlRYdgn5edK73fI50JD8xHPdNqnDru7PjtN8vEx5kQv/cOKeBvKGFCQi1eB/oEwTg7pPK8OlVgzGhVwpuHVeMebePQm5CuEffN6kq1eOBa7FhFowpTcJnVw+2miEZGWJ/O8Nk2P6Tq1Iln/fVmdFdwVp3jauwvs/OcBAMA/QR3NQb7lEiL53uZqdMd/1y4/DTTcOx5K4xHndCf3fDMI9/Xy4GmTsmOv3fWdXt36/hFAnekDJjZXpdFkpSIvHWpf1x4aAcnFmbif9dVIevrxuKlX8Zh1cu6Ic+WTEYWZyIn24ajtvGl2DFvSfI9sDpSqUbi4RWpEXZHel2z0lleGJaNRJcPMjJYXBBvFXankem9nL5GUdT/ZMig/HuZQPcLsMDkyvw883Dcf/kcoeBPnsP6bFhFnx0xSDU5ca6/ZtSTe6dZrN+wPDiRJuZEkMLExAXbvuQp2LcSJaglckg4Oy6TLeD1T1HmvlqRGdadAj+c7bjzq2rRxXg9gmlmDWxFEvuGoMvrhmCP++Tb5bPGBdr7Hx4xUAUJkXgxfP7oiojGuFBJowoTsQz53reIWdPeVokHpxS4dG1MCg/Hiv/Mg6vXliHvtmOP//v6TWozozBGTJ2lCdGBuGCQTl4cIrrescT8eHtdWioxdTVCTO0MAGPnlqJoqQIpEWH4NJheXjhvL52P28Q2gfESLnlhpiPP9Re7eYI6e73PkEQcGbfDLvrlvQcMCGXh6ZU2NT9ooT649OrB8vy+0MKE2T5nk6nVKfD5KAd1tomSjqeUvnTTHkl9c2Wno4lEKXHhGDhrNG4ZVyx1etjSpMw/45RyIg9PiI8OtQi6wx2b1sOIWYj7phY4vbaS3NuG4U+TtL0XDJUuYFgMwZmO/17dnwYHppS4dOZ9p7wZL2rkSVJmHPbSPx+9xiH75EScHc0QyU/0XVnsbP0TIkRwR6vzeTK8KIEFCVpL03dVSMLMPvWkV49u/bOjMEvt4zA6vvH4b3LBuL/zq5BcuTxtbn65cTiuxuG4ax+mRhcEI97TirDTSccn0FrkOnUPrl3qtV6lMmRwfjoikFupeQCgP9dVOf5wA8Rku/7T0+vcft3etbTjkyp9ixAAECWPgGT0YD7JzsOisnVNqrNaQ/wlaZG4slp1Zg5NM+r8vfPi8OCWaPx9iX9scjNQaMLZ43G0+f0sbmWHAUSpQyglSLYbMRUCWtFXePhvdsgwK0Bg8FmtlXl5l9zVYlU4Gz0txSCIPjNQq/jK5Lx6e873P6cvbV+okLMGNmRwkaJuJHFaMB5g7Lxnx+UW7Oq+4OwPX85uQylqe03/uLkSNwx0XY0x6CCeAwqsJ7JE2Ix4q1L+uOTpduwYW8DVu88hG9W7oIotk+hL06JxNz19V6X/61L+qNPVgxybnWdN/fGsUUwGQ24fXwJbnn3967XJ1SkoDqzvTF945gi3PTOUpvPBpsNaGyWJwVazxzuJ1elYX9DM16ZvRGb6htwzE6Q6MoRjqeaV2fG4PkZfXHTO0ux+9Ax9MmKwSsX9sPAh77F3iNNVu+d3DsNN44tQmrHiLiz+mVBFEX8sGo3Vu081PW+tOgQ9M2x36FdkR6F1y/uj+xbPpG8za5Mr8vChr1HUJcbZzeQFRVixhsz++Phz1di7e7DqMuNw63jSzD+8Z9s3qtm4MiT3p8wixHxEUG4eEguJlakwmIyIMRixKi//eDW95xclYbIYDM+XrodEcEmnFGbgbs//AOz13l/nXUKMRvx883DJafTCLEYUSRhxKVUX1/XvtBowe2f2p2F9/Yl/bvSaNRkxeL9ywdCFEWf5H0P6ei8fmhKL5z17Bxs3X9U8mf/7+xqq/+eUp2GdxdutXlfZxDm9L4ZeG/RVrt1g7tCZHiQ8WR9mak16VYPdKt2HLL7vhPK20fzubqOz67LtOpoGFyYgKTIIKs10QYXxOOn1Xvsfr7nbFuT0YDLh+fhgU9Xdr0WHWrG/y6qww1vLcEf2w46L5AbPrxioPR0Lz6SHReKH2X8vkdP7YXPlm1HS1Orzd/kXuNAqYE8140uxN++cr0+gV6cOyAb8zbs8+o7ptdlwWQU8PwvG+QplEY8MrVX18zIS4bm4ZKheWhpbcOxljaH63OlxciXItabQScZsSF4dGol0mNCEWw24ID0W5FTgiDgpMpUbNl3FI98scrj7xleJC1IXZxsv8O+++fPqM3EpN5p2Lr/KEY+5l4bqbsfbxyOj3/fhoc/93y7OrV6eOwEQUBEsHfP3gUOAkSTe6chPtyCm9/53e7fpXjyrGrc89Ef+N/czR5/R3dp0SG4ZFgeTuuT7pM2maeW3j0Gkd2OwyNTe+Hc/861eX5yR+dssZz4MHx7w1DMXV+PyBAzeqVFOQ0kSF1+wNXuCzIZ8fT0Gvy58zD2HjmG6swYBJuNePXCfpjy1K9Yvl1aeyYzzrv0afmJ4Vi65YDL9yV2C65JNSg/HmWpkS7bZmfXZWHVjkNd74sNs+D8gdku12gC2p+97/zgD6vXTqpMxU+rd2Nfg/Q17k6sTMWV/1sk+f2euMDFLL6arBgs2Oje/T/YbEQfJ4PbtOj+yeWIDDbj+1W7kBYTgt2HjmFlt+eNstRI1Dro33AmIsiE+yaXu5VSUGuDHPwBA0dEfiA+PAh7Dru3iL07KtKicOHgHFz9+mKbv3VPh3TewBx8u3KXy07+7osrP35GFU6uSkNcmAWPdXQSWIwGPDilomsUhBIdFanRwTizbyae+2k9WhRa+blvdgziwiwOG8jOUhm4Eh5kwul9j4/MONDQjPV7j6A0JRI7DjTi1P/8atXJ566qjGj0zoiGIAgYXZqEr5bvdPje3IQwXDi4vVF1Rm0mqjKjMXvtXuQkhGNwfnzXjLXJ1Wn4Ze0efLB4W9dnz6zNxIwB2Zj6f7/i0LEWj8vbyd7iv+cOyMa5HTNGTv/Pb5jTLagWZjF2BTAdGV6ciHm3Wy/Oe/nwfNz78fKu/+6VHoX7J5fbTIkXBAEvX1iLez5ajiWb96M0JRKzJpZ2Pfgo4Z6TylzOGsxPDMfT51jPGrF3WYoqJoxzt/Nn3QPjIQj2R41KmX0QE2o7M6v7mimXDsvH7HVz3SqTM5mxoao+8HfWw+3/b7t/7F1bvihvYVI4EiPaH3Sz48Pw403DsWL7QUz8188uPzu9Lsums+j8gTk2gaP+uXFdAzp6Z8bg9YvrMPmpX70uuxz7w1E6FXdm5xQmhSMjNgSb6617OS8ekufysxcOysHNPUabhgeZ8MbF/fHIl6uweuch9M2Oxa3jS1B+1xd2v8PeCMcLB+UiKTIYHy3ZhriwIFwxIh8ZsaF459IBmL9hH85+bo7k7XNkak06KtKivP4eLbl6ZAEEoT2l77Kttp04ZpkfnpWqgrTTtem9B6dUYGKvVLy7cCu+XbnL6XuLkiKsBpJ015nSceGm/Viyeb/cxVTUwlmjsX7PYZSlRtkdGWwyGmRLbepKjMR1fno6pTrdaq1MqamhpBIEAZcPz8elQ/PwypyNNp2onf5+eiWufWOJ3b91fw5wZebQXJvBc+f1SAUUbDYiz8P0S52iw8woT5WnHlYzPfL4ihTc9t7vNoNKTuuTgWCzwWHgSEqmhmCzEQ9O6YXrxxShz31fe13WB6ZUYGiPma43ji3yKijZU3y4BRcPybUaAOJKzyumPC0Kv906En9sO4BT//2b18/joRYThklMbVmRFoWEiCDsPuR9f4ogCB0Dt44P3go2G3Fan3Tc/dFyxx+UiwDcMKYI5/zX9TOIJ+sgmowGvDGzP/7783qs3X3Y6rm9u/iwILx9yQD8tm4PDjW2YFB+PFrbREmBo0m907B131G88OsGNLe2YXhRIh6cUoGNexvw4Gcr8OfOQ171Y8jl+tGFLmcZXjE8H+e9ME+hEimv8wwKMhlx54mluLNj7aG2NhGvzd2EOevrUZAYjnP6Z7k9E+jWccW4YFCOw/bAtaMK8fevrc+nnPgwTQXI/QVDcURe0mPF5M7aF9GhZnx05SCHU267L5DdNzsW7146EJcNc9z5dGJlKpbePRZfXTsE6x4Yj5Or2qcxXzmyAD/fPBzPz+iLX24ZgfEVx9e88VEmPCsi2jsh/zO9BrkJYbCYDBhZnIiLBvsuF7TRIOCBKe7lFfZUVKgZVRnRsJgMyIwLxfuXD3T43ncu7Y+/TCrHHRNKHL7n5Qtqu27iD0yuQGV6+0Og2Sjg8uF5WP/geHx+zWAsuGMUvr1+mNUI8+LkSMwYmIOhhQlWAQuz0YDHz+iNX24ZgU+uGoR1D4zHg1MqUJQcgVvGS5sW74qrh8x/n12D8RXJiAk1o09WDF66oJ9H083PH9S+KOdFg3Nw36RyvHJhP4d5lBMjgvHktGr8fPMIPH1OH5cz0QDgNg/2x19OLrN5rTg5wuNUk/YCumrOOHLnty0mAwwGwWH9LeWruueOtmdoYQI+uWqQV2vxdKf2raZzhomjTo9wien5pC4cHGQy2CzmGmYx2uRiNxoElKdFoTDJ+YNbalQwLrJzzMrTovDA5IquQFFVRjT+cUaV1Xt6Z8Z4vWC1O2k9HRHRPsLdXp1032Tp6wQJgoBHp1Za5VC/dFheVz3uyBXD83GHg8B2dnwYnpxWjS+vHYr7J1c4XT/I3khAg0HAyVVpePbcvvjr1F5d9WCw2Wgzq9Zd900qxxsX1+HhU3p53Ga7s2PGr6u1QLxhENwfJdlZD9801vaeEBFkQlVGtKwd2v6aOtiXOu8BD06p6EofYzQIbq1TOaFbm/jaUd7VRVoQG2ZBTVasJtLJSEmv0930uiw8dmolHpaQ6lgOBoOAc5wMJAs2Ga3Oj06lKZFds0iluHFMEWYMyEZ8eBDyEsLw8Cm9HKbVnF7n+ZpHBkGQLeDj7jp1cgqxGPHIqZVWs2//MqkcCRFBiAg24+YTvH9uMTvJn3ZKtXf3otP6ZNjcb0YWJ+I+D9ccvHVcSdegHm9YTAb0zozpmvWtFINB8HjbpRpR7HwgomxEoC43ziZY2FNVRrSk9ZbtCQ8y4aqRBXj8jN4O32M0CgixGDGiOKl9kHB4EBIjg9FPwqwTAcCt40uw5K4xWHTnGDw3oy/CgkwoTY3Eyxf0w5zbRrn8DiVcKeHZYFhRgtWspHQXM2Y9bbMNzHe8JpYnTbcXz6/FFA/XIwLar6mz67LwrzN746qRBYj2YJBGanSI00EkJ1Wl2jxXnu3F/Ykc44wjIj9QmBTu1oyj2beNxKJN+5AVF4pRf3OcMMVsFPC3jtF09kaTA7DJq1+aGonS1EgYDQL+9e0am/cfbmxGeJAJBXZyLKfHhDqYhur7jorOxvPIkiSMLElCa5sIo0HAk9/ZboMc4sMtiA8LwlgPFtSVQ0qU40ZLXFgQpte1N+rmbajHF39Yzya6Yni+1aj9hIggfHDFIGzbfxTRoeauAImj1BeupEWHdC1w2unUmgws3rQfby3YAqB9RsBpfdMdjrJ0NJPL1eKrMWEWPHVWjUfl7mlwQQIGF8i7lkWnU6rT8eb8LViz6zAAaen8JvRKxQu/bsDa3UcAtHdSXj7ccRo+V+xdlaoGjtx47ywnQVFA2nZcOtT17Iyy1Cg8OKUCY8uSMON570abeTvK11udHcbXjS7EGU/PtvpbUmQQSiXmpr9jQqlNSsr4cAsOHG22SoE3c0gurhtThFkTS7Bq5yFsrj+K2uxYRIW6l15mYH4cptakY1hhImIcXP/T+mXi9L4ZONTY7PDBxtu70DkSH2Sy40KxYW+Dw78LgoDLh+VZjVotTo7ACDfXROiXG4e5t4/Cks37kR0f1pVCs/033PoqtymZQiIhIkjSQ6Szaz45MrhrMMu5A7Lx+bIdssyA7WlS7zSc1S8Lf/l4ORZLnFHS2QSry41DXW6sVXrMK0bkyz57VanAkT/Gp5Iig/HZ1YOxub4BMWEWhFmM+MfXq/Hm/M0wGQVMr8vCKTXp+GXtHptZkN3XoOmf5/mC6W9f0h9T//2bx5+Xg6vOTCnkOj0uGJTjdgf1X2ToXJZz7TxBaL/Wf127pyuFU25CmMO17BwxGQ24+6Qy3HViqcsA+2XD8/Dy7I0eldcgeL+uFACkRAU7TBenlJMqUzE4Px7Lth1AcXKk1aCOsCDvg6ImJ7NBrh1dgDnr92LLPs/yIyZEBOGNmf1x/yfLsam+AYMLEnDXiaUQAdz/yQocbT6e+jQy2ISDjc7veUaDIGu9rUYGg7FlyXju3D644MX5Dt/jzSZmxoViSGECfvxztxffIo3FZMDT59Tg2xW7sH7vEfTJisW/f1jbNes1IsiEWROdPwvZ486AWkfjEp86qxo1LmbSddZBwWajJgYY2CM1/bQgCJg1sRSXDcvDrkPHUJQUgdzbXKf5d9e0WvkCJrFhFgwtTMDQwgT87fQqnPivn/H7VtepD5WWEx+G1y/uj5dnb8DuQ00YV56MU3w4wCuQMXBE5EMPn9ILeYnhOOX/pKW4ObM2E/+bu8nt37lqZAF+XbtX8vtjwywYWZKENidTwC8Zmodx5cldo6Rb7KxpAcBhp0TnujU9udu5BTjuQBhfkYyDR1uwfPtBVKZHYdWOQ9h2oNHt7wfaR0p11zmCzFedF9NqMz2e6eFr3dMuXDYsH7+u3YtDHQ8MGbEhmNbP/gyK1Gj5cs73ZDEZ8MiplbhjQimONLV0/dZ7i7bZbYCPLU/GG/M22wQ8L5HQ2a8HceFBeOeSAfhqxU7sb2jCiOJEjHCRcz42zII3Z/bHR0u2YdehYxhZkuT2Yq1WdJyq7jQXnTauUtUZBLh1/Q4tTEBadIhba/H0dKmTmZxK6KwT+2bHYkrvNLy7qL1j02QQcM9JZZJncpzcOxVfLt+Jr1e0B6STIoPwv4vqsKm+AU//uA71R5owoSKlK6gpCAKKkyNdBqIdHbJJVWmY3Nv1Q4TRIDgdDZcpYSagPeMrknFSZSpOKLcdEW7PjWOL8eOfu/HGfMdrG8wYmIOchHB8v2oXMmJCMaU6zaP1GsKCTBiQbzubx9cBYKVSUAHtqTilcFZ3vXVJfyRHtY+kLk+LwnuXD8THS7fh3YVbsanecZDPEWdXSk1WDN6/fCA21zdg8MPfufyuznrIYjLghfNq8dGSbVi/5wgG5NmufygHg9De6f36PHnW3nDEUX3SLyfWKp2sHnWfVXzt6EJcM6rAanvvm1SOppY2fL1iJ+LCgnD1yAL07bbWQZDJiGfP6YMLX3LcuWlPXJjF49HlcuoeBFPLtaMKUZkR5XYQq/ui954yGwW3Zzm5UpISiS+uHYLvV+5GiMWIIYUJHq+fK+VenhIVglvHFePBz6SnJetkEARJ6YBPqU7HOwu32P2bySDgbjfaHb4UE2bx2SAxZ4H/9JhQfHntELz820aXx8HRXqrKiMZblwywef3F82txyztLsW7PEZSnReIfp/fGJ0u326SE6s5gkHZcpVIoa7wNZwMr5fDPM6ow64M/8NES++ndAHi0DoyVjgMeZDJiXLfZiNWZ0ViyZT92HDiGutxYxLkZNC9LjcRlw6QPOHTUdxQXHoSHp/bCTW/brmvsz+LCg9ze5878/fRK/PjnHjQ2t2Jy7zSM8XAw8qXD8vB/36+1eu0KNwaWql0Pl6ZG4sEpyswADmQMHBH5yKD8eJzWNwPr9xyR/JlbTijG2l2HMXeDew/FfbJiMLYsyWZmiCsGg4ARxYk2Odf/O6OPzXTq5lb7sxmMDjpPBxfEIz7cgj2Hj8/6MAjtHfructQ/mx0Xhpu6pQLYe/iYwxEshUnhyIoLs7sWT0JEEOpyPR/B6a7bxhfbTZmkNHuNtlCLEdnxxzs1KjOi8elVg/HNip0IsRgxqiRJ1kaPu6JCzVYzDkIdjPaJDDZjel0WXvh1Q9drg/LjVV8UXU5RoWbJnQ99OgJEceFBmDFQ+mgxZzQ348iN33bVeebqq9zdTEEQ8PQ5NZjwT9fr8DhSlurZDD65dG6z0SDg0VMrcVZdFjbsOYLanFhJ6RU7BZmMeOYc24WDcxPCJeeid1Y+XxlfkYJb3/sdTS3OZ/b15MkMRinPYJ0jAZXk7rNhalSw3cEcnsw4OqEsGZ//scOtz9Rmx2K4F+cUANTl2p7f+YnhuGZUIXLiw+yu/eiKlHM1IzYUZ/XLxKtznA8m6n5Mgs1GnNrHNigu5zO9IAgu06z4ktlowLR+mXjNxX7pNGNANt6Yt9lq9LycokLMOHBU+kLd9vTsdAm1mPDEtGq0tLZ1jOK3PYAp0e6nhDp3QLbTAOmdE0ut1maUm9ko4OGpvby+Jl0JDzLhsIsZgVd7kO4vNSrYaQpnKSZUpOCsukyfLHqeGBHsclCMnEItngchpbTXipMj8OstI/DJ0u1YueMQLh2Wh30NTdiw5wjqcuPcanfolav1Z0ItJswcmoc+2TF4/pcN+Hjpdll+tzYnFt/eMAyNza1dsz1O75vhNHBkFAS0uPkQ4KzDWa3nCV/3gUeHWvCvM3vj4NFm/OBg5tH53gbXHew7k9GAmizP6p7i5Ah8cPlAuwN/Hj6ll00mgZhQs08HlBJQmxMnaWCcK1ePLMD63UfwxfIdMArtAxvO6a+NdG8aGBtAHRg4IvIxd+q7qFAz3rykP7buP4oQsxERwSbM21CP7fsbcf1b9lNyAe0NgSemVeOn1buxdtcRlKVGYvsB55/p9MDkCsx4fi5W7jgEk0HARUNy7T7UOVqg0tFoKJPRgP87uwYzX16A+iNNCLMY8eApvTzKfxzpYCR1z4eWuPAg3DepHHe8v8zmvRaTAU9Pr8H6PUfw0+o9ePSLVTh0rAXT+mXiutGFCPHiAcgdE3ulSFqAXAljSpPwWGSQ1eKSp9ak23SqZ8SGyhZskJuzBsVdJ5aiOisG8zfUoyg5AqdUpzsMdPq7s+rkWWenO3sPfCrGjWQd6ejqqzz5qdKUSGTEhmBzvfWso3Hlydh2oBG90qJQnRXtMP1i9/09sVeKTQeBs7XlqjOjsXDTfvcL3U33/WswCKjJivF4xpq9hYO1LsRixP2TynHTO0t92qGhhYckucpw87him8BKRVoUwjxYl+LW8cWSA0exYRbcc1IZRpYkSr63OzqmznLNDytKhNEgOEzl6y5P8toH4ppD02pdB46CTAZcMTwfV44swNiyZJz5zGyn73emd2Y0FtmpP28cW4RLhubhwNFmzF1fj0teWeDxb9jjbGaeJykI++XEOq27zh+Ug96Z0Zj8lLQsCe764PJBKJVpAISj095kEPCf6TW47NWFXgf0untoSgUm9U7zOmXSk2dVy1Si7vRVB7TPOHL9PhEiUqNDcFGPdb/6+iDopig3GhCOAis9U/TVZMWiJisWHy/9xKui9dT9fE+OCraabd6T0QC4Oa5Gl+S65Tr6ntrsWMkz1JXUOzPa4T1pTFkS/vltiFXaxHMHZHv1zK1ErabmTJnRpUl2BzMD8MnGO/vKYLMR/55egwMNzTAZBY/a6OT/eFYQaVD39V0G5LWnGnn+1/VYtvWg1fuuG13Y9W+z0YARxUkY0W0tTimBo+So9pzrW/YdRUyYxeFCo/kO8kifWJnq8Lv7Zsdi3u2jsGHvEaTHhHicIuOCwTlda9t0N7XGdmSdo+a4gPZRm7kJ4chNCMe5A7Il/baci0pHBJvw6KmVsn2ft6JDLXjn0gH4v+/XYlN9A4YWJuA8jQaIPCEIAk6qTMVJTs7RQPDktGpM6CX/Q4i95wE5gzfukvOXfZFyTxAE/Pfcvrjs1YVYvesw4sOD8PDUCqvZnd/1mP3pyOXD8/HLmuPrGWTGhmK6k9Fhlw7Lx0VupjXqSc3ZZFpxap8MDCqIx5LN+3HJKwsV/32ljoFcvzO2LBmDC+Lx0+o9ANrzwd863rMFw93pKL90aJ7TtolcokLMOLky1WFHmrs8qXd8MRbi7hNLrdbQ6snXnS1n1mY67ZwrT4ty+Lenp9egrmMNoM5BR97uo9rsWGyuP2q1lqjRIODM2kwYDYLLtRN9oef6olIIguDyDOuVHo2SlEis2H7QxTu1SRCAgfnxWHDHKKzYfggnPuH5LN/u+ufFuQwayTuzT77v8hkPCynXGkeBYlRJIr5eYd02vGZUoYN32yfX+fTIqZUO73fy3xf8+yxx1M4akC9DBhSF64/oUAvevmQAXvxtAzbXN2B4USKmVKc5/UxufJhCpdOm8wZkOw4cSST3YXZ3DVkKLAwcKURov5vWARgFoD+AUgCJAAwA9gH4A8C3AP4riqJ7uThIk+TueJw5JA9Xv76oK+dvQkQQJvd2flO2l77u+tG2jU1BEFxO+S9IDEdOfJhV6j2DAJztYiaD0SB4vah7UVIEhhYmWE3pnlSV2rXmgBUHLTEtPITdN6lccws8pseE4v7JFWoXQ3ZqrrWjlplDc/GfH9ZZvVaQGO6ToBFgP6iqVk7y9t+WMbe6j0ZNFiRF4KvrhmLfkSZEh5o9ftAuSYnEZ1cPwXerdiHYbMDwokSn6/OMKknEDWMK8e8f1rlM4eNIjAqdo+7okxWDNbsO27wud6qMlKgQpESF4MTKVKc56v2Ru2drsNmI587ti/kb6rH9QCMG5Md5vH6Ar+/hDgeduPjdv07thaLkCMxZX4/8xHAEmQz417drZC+fI76YcWRUcA0qm982CJhUlYoFm/bZ/XvnvX3GgGyrVLSdsuLCbGape7ue5ElVqRhXkYKZL8/HzoPHEBFkwiOnVloFjJRuY3oy4whwPLijs/xGg4BXL+yHf36zGsu3HURlRhTmbdiHxZv3e1hS29/wpc7NMxkNDge8kboMgoCMWNf3gdIUxwFiPZDrdL/35HKs3zMHa3e3P3+fXZeJcR6kfZeD0SDAINhv6xs9uMCdfcJfU9W5/H2dzSDslBwVjJtPkD4wqCYrBhFBJhzy8JlE7+ytL0q29Ho9+CMGjhQgCMJJAP4PgKPhj8kd/xsJYJYgCLNEUXxUqfKRd5RqYJxYmYr48CB88ccORIW0r23iKthzzahCzF1f3zUqvSgpAmf28yxllSAIeHp6DS56aT427G1ARLAJ90+uQHqM73NMd64P8vrczR0PstE4rY/9nK6OZxypLxBTyviaw10aeHEjnFSZihd/3YDG5uNRj9N9mO/e3r5XN1Wdij/uJjmCMMlRwTizVlp9LggCrhhRgJlD87B820Gc/OQvbv3W0MIEh7NRteKCQTl4fd5mq9eiQ80+W7/unP5Z+HjpNp+cd2rfKuT8fYvJ4NcPyGajATOH5mHm0PZUkS/9tsHj7/LVA7K736rW6dc/Nw4XD81Fv9w4h6k1O6+3s+sybQJH2XGhKEyyDRZ4EzcqTYlEaUokBEHA7FtHYsu+o0iNDlE97a3Jxdonjjga3NG9fRobZsHdJ5V1/ffZz86x+5lx5cn4de3erpRwp/fJQJso2s0QoAa161Gl6G07BaH9eTQ7LhQb9jbYfU98eBAG5Cm39qyWpUaH4OvrhmLNrsOICbMgXsV1ZgHH7Xy560QdNenJA4Ig4N/Ta3CWg/uLImVQ7ZfbOVoj0Rfl8vY+4WxArtr7kZSh7V4A/1EK66DRWgC/ANgE4CiAHAAnAkgCEAzgEUEQUkRRvF7pgpJ8Oh9u5WzQ98+LQ383GtIlKZH48tqh+OHP3QgPMmJQgXedfwVJEfjuhmHYefAYEiKCFH1wDjIZJaWXc9iJp4EnK7U7Gsi/laVG4ZUL+uH5Xzdg35EmTOyVijNrlVsoGYCq0Rs5ZzuplnLPx1WE2WhAVIh7qQgG5cfj76dX+aZAMspPDMfVIwvw+DerAQAWowGPTq30Wb3bNzsWj5/RG099twYrdxyS7XudlVap25iegrD2eLKfHK5x5OZ3eZOux5OZsmrm6JfbyxfUdq2h4Gqz8hMjcO/JZbjv4xVoam1DYkQQnphWbXd/SN1HBYnh+Ne03rjk5QVoaRPRJysGsyaWdn1eyux8pZgM7s84EoT24Jo95zlpXzvafWWpkfjbaVVYsHEfUqODkRMfhj+2HVQkcOSoTN1flzV1nMJdY3oYZe1pCTuvpyfPqsb5L8yzWmcVAJIig/Cf6X28nikoRVp0CLbut153MkeDKbQEQUBBkudrQsp5Pjm6VwaZDLLej9RMfe2c9q9NveidGe3wb1JOJbNRQHOreueJt6e72p8ncgcDR8o5BOAZAM+Loris5x8FQQgG8A8AMzteuk4QhI9FUfxOuSKSP0qICMLUGvuzczwhCIL9FHEa4TANh4ffJ+dNmTOO5OfoYUirjxu+1ic7Fn0UWjjY3gOiuvtd2q8PLUzw+ptGlSS5eId2uRtIeeXCfj4qibwEQcC1owsxtSYda3YdRlVGtM/T63Wuoba5vgGDH/Z9c02z/SgK0ENHKuBZuh5v6GOvSNO9bkpx0M7svij8Of2zcWpNBrbsa0BeQrjDjmapbS8RQHFyJL6/cbj0QndQ+jiYPZxxFBcehLrcWMxeV9/1mskg4Kw6x2vkORNiMWJQwfEZhc7Wn1JC9zqSbW5tK0uNwm+3jMS6Pe3r4JoMArYfaER6TIhiAfGLBufYrOc2c0iuIr/tb4LMngWzHVGruaN2W0O71Zb2CjYwPx7fr9rt+o0+EshtcqVo93oIPOolsQ4snwLIFkXxentBIwAQRbFRFMVLAHzW7eUrFCkdkR+Re8IR71dE9tnro5NznSF3Sf1pKZ0Crrbj0mH67Vjw90Z4RmwohhcnKromk9wjo4NM9tfCCzIp02z393PEHkezfdztRPLmVPBZqjqdHM/uncVjSpPtnu/nDcyx+u8QixEFSRFOr0F/nOxt8mIdqiemVWNwQTxMBgFZcaF48qxqj2ZZuHu7V/o89MPD7ncMBgH5ieEINhthMhqQERuq6CzKcwdk4+qRBUiKDEJqVDBuHFvk0xTP/sxRu8VTgdopr93t1l7BLhzk3bOYXtpGcvBpvRpA+zGQccaRAkRRXOrG2/8JYFzHv/v7oDgks9x4+4uvdk6/VXvkCmnf+QNz8N9f1lu9dgYfXKTh5aUau2scqfhc4SjYU5wcgZU7DsFiNODKEfmS1ltxth3XjCpATZZvZnUpcTq7M+MoL0F7KVu0SM6OaUFoXz+p5/otQPvrStBux4Xy3H3W9maWgyep6vxViMWIWRNLccf7x8fbXTwkF9keBDj8ceaJyYtKJz48CC9f0A9NLW2wSAhGO+pwUvNsdfRs1b2oej7u7hRdra3U8e7t0jlT+ZpRBV3/7WtqXDdKHKsgk0HWc1Grqer84bzXAyn9ZxHB6nZl++pckFoPsY+RlMTAkfZ07z3mqpA6MKI4EeFBJhw+1mL1+tkepn0g7zhcp0DZYrjlwsE5+HrFTmyqb18kNiUqGJcOy1O5VPqm1QcOf2Kvwarmbrf320aDgM+vGYIt+xoQFxaEEIu0EZGONuPOiaU4f1COg7/qgzuptG4cW+zDkvgPuTsoc+LDMKwowSoFx9DCBE2uvaAUX3fWyFV3BUKnklLbeHZdFvrnxWHhxn0oSYlEWWqkR98jtbzetBuUXmvK7MGMo54llBI0sve5TlpvZsm6xpGE7wqAS99v+dNacWrxZMaRs45v1VLVqXwqqPX75/TPwku/bXTyDvkLpvfAh9bvgURyYuBIe9K6/Vu9pJ0kmcVkwONnVOHSVxeiqaUNggDce1IZUqJC1C5aQHKcqk67jZPU6BB8dOUg/Lx6D1ra2jCkIEHRNEv+iI0537M740j5YnRps/PjnUVMj3FvQXNH50+sH1yXUuvCKb3TMLpUv2s5KUnu24sgCPj32TV46bcNWLLlAHqlReHcAdmavo/pXV8Ha8ONLUt263vCgjx/tPJdqjr9njd5CeHIS7A/s18qPc88ccRoEFCaEonl2w9avX7/5HLc/p7drOiqU6KTsPu9W8/nPfmBADv/PFnjiGyp9fw6c2gevlu1C5vrjzp4h/89WKsduNJTX0VhYgSWbT3o+o0yC6xaVNsYONKe07r9+yfVSkFuGVmShEWzRmPZ1gMoTIqw6vQPsHaj6hyNGPX0MCh1/KJCzJjQK0WZH/MjvLzUY69TRs2ZXvbSPHl+/drfDrnXsulJiY4uKanqLEYDHjutkh1vErkzi8u19u8KNhtx8RDOPFVKn6wYpEWHYOv+450mIWYjTqpKdet7hhclwmIyoKmlTe4ikof8MXAEANeOLsSlryxAS8eoiZKUSEysSJU9cORo96mZWtFPD6lH1LpPq93pqnVxDgYaqTFzWIkjZTEa5L0uNdqp7q9nfVp0CD65ajAG//U7HDjarHZxpM3y9NPZYVo8xy4emot3F21VuxikIg4N0BBBEMoAnN/tpf8o9LsRgiCk9vwfAHNbGx98pQoLMqFfbhxnimiUpzd3PhhpW2SI2e7roV6M+iZp7F0ZWktV52mHir3ZS4B/LLIuZRseP6OKQSM3+GvHtA0Vt9OdX/bk3DUYBLxwXl+UpLSnQ8uOC8UL5/VFZLD9e4wjIRYjLhrsWTpLvaxx5It20Rgfzm6UWm97s/fVuDJGlybhoysH4caxRXhkai+8fnEdokIdn6+et4Pt0+JoaX+piv1kMwLayJJEBNuZheOvqcilpr7sztn16mjdUvKdyGAzxpW7N8vaG3qvr709Rb3dfiX3X1FShONy8I4VENizphGCIIQBeAVAZ4v/PVEUv1fo568HcJe9P+zcuVOhIhDJg+3MwHL+wBy8NmeTzetn1maoUJrAYj9VnYozjuxc/J42ZR3NnJJ3Zok6nDXwjQYB5w3IxgkKPjj6g4AJHPn5DbYgKQKfXT0YDU0tCLV4/oh0w5giGA0G/POb1TKWzn8lRgThphN8t56a5ECiDk/vkpTIrmCnrzjaf1rcXX5eReneiZXuzeDUsyCTEbdPKMWs94/PAJzWL9NpB6we1GTFYMHGfTavB3kQOHImPSYUq3YekvU7pVC7NRcozUkt6L6vy1Ij8cc2ZVOx6el+JQiChHWwfPG7iv4cOcHAkQYIgmAA8DKAqo6XtgC4SLUCEelYYmSQ3ddz473LkU/alJcQhtGlSfhq+fEg9+TeaVxjTAGam3Fk5zVPO/QdbYbPU9X59Ntd/8jiO0cjws0ZFgQYZOwv4UOS+rwJGgHtD9hjSpPcDhx5Mmoz2Oz+guTekmOAwKiSRFw6LA8HjjajNicO4T6cJazEjCN/5nD3uXnD9/e6bUhhAl6ft1nx39Xybj27LhOvztkEUQQq0qJw94mlahdJUdPrstA3OwbzNuxDcXIEajJjdD+b+9KhebjwpflWrw0uiIfJaJB15sEt44tx3vPzZPs+vVA7mKCn01PO8+3EylTFA0eOaPUYaLRYpBAGjlQmtLce/gNgcsdLBwFMEkVxr3qlItKvsWXJCDIZcKzH+gIXD81VqUTkS4Ig4Mlp1Xhn4RYs23oAlRnRmNI7Te1iBQS7axypUI5O9tLLedr4dvTg5hczjpxsAoNGntF7R5BkOtlOLZTSk13lSUAmVqfpkRMiglCTFavIb0lZ1y0w+P9+8NmaExK+98LBObIFjvRQ1Uop432TKnDDmCIcPNqCjNiQwLlXdlOcHIniZN/OCnRJxt0+siQRFwzKwX9/WQ9RbF+z6YHJFfL9QIcBeXHonxuH39Zpq0vM389htQNXasmOc3/tMbVTzWnlTPTzS4I6MHCkvicAXNjx70MAThBFcYHCZXgMwNN2Xv88KSlJ/pYAkQ8Fm424Y0IJZn3wR9dr5w3MRq6Hi5HyZqh9FpMBZ9Zmql2MgGOvL85Rijcl2PttT2cctTlY5MgfOiDDLSYIgu3D4VUjC9QpkB9Q87xXlJrbqf9Lzyfiwl0HjtytBgUB6J0ZjUWb9lu9HtExK0iOUb51uXFef4dUSuTf9+e2oqNt02Ktp2YVlZ8YgTsmlOC+T1aoVwgNig61IDpUnwFusiUIAmZNLMXlw/Ox9/Ax5CWE+2Q2fpDJiP/O6Isv/tiBdXuOKJb6Ve26XO3fd0yzBfOYt1sUKE3/TgG2udQDA0cqEgThXwAu6/jPwwDGiaL4m9LlEEXxENqDVlYEQWg2yJl/hUgh0/tnoy43DvM3tqcGqMqI9niEUEKE/dR3RIHOXmecqqnq7M048vC7Gppb7b4ealE+LZTcDAYB5/bPxgu/buh6LdRixMlVgbP2gNz8bQSqn22Obrgb4Ai1GFGRFuWTslw8OBeXvrrQ6rXLR+QDkCdV3bDCRK+/QyrJSxwFWi+QZA7WOHJzdwVCtXLh4FyUpkZi2jNzFPtN1tekhtgwi82MV7nPxRCLEZM6skgEypqB2r0Naa9gcp5vrEe1igdGKxg4UklH0OiKjv88AmC8KIq/qFgk8hHeiNRRkBSBAhkWIB1blgyLyYCmHqnviAKevRlHypei22/b/rqn9W+rgxlHYT5chwNQ7n5xx4QSRAab8NWKXUiJCsZlw/KQl8B14DwVZjEiIzYEm+uPWr1+z0llbn+XFpoM2u24kEav7S53AzKn9cmQtMaRu8dTFIFxFSm49+QyvPDrBhxrbsMp1WmYOUSelL8WkwFRodpLizm6NEntImiSFq8nR8F636Wqk/7FkTKkfFVilpy3tF9C6qSH80kvuCeVocX7Tk9qpkZtf6Nvft9dGikG+RgDRyoQBOEJAJd3/GcDgAmiKP6kYpGIyIFgsxG3jSvG3R8t73rtnP5ZeOm3jSqWikh99hqKao7YbrMT25V7JkhEsH80m0xGA64bU4TrxhSpXRS/IAgCLhyUi7s+PJ4iNTUqGOPKk1UslX/RW8eXr8tbmBSOOyf6dqH5c/pn45z+2Tave7tt6dEhXn3eFwQBmF6X7dXntU7uMsox80xueg96EwUSbdab6hZKm/sE8MV+0e62ShNo95tA216y5h89IDoiCMKTOJ6erjNo9IOKRSIiF2YMzEFdXhzmb2hPfVeTFeNR4EjKWgREemGvwe8vM44c8fWMI9KvcwdkIzkqGF8t34mUqGCc3jcDiZHBaheLdMSdgMzFQ/Ikryuhtc4ZX6yH4Y1QixH3nlyOzLhQtYuiSY6Oltup6jRy2HMTPFvzVCqlt1Mr+5WI/Jn/RQ26151qVKMMxLjG+5t2sAdEQXaCRhNFUfxevRKREvxt7YNAVZwcieLkSI8/H2YxoiYzRsYSEanLYKdu09oaR/bKKIWj9JRhFh+nqtPZrAqyNrYsGWPLvJtlxDaD97gHfcvbmSZaihv9cOMwpESFwGLimq6OOKqS1OzzknoKTa1Jx9sLtli9du2oQvkLFIB4q9IPpY5VIJwS/n7e+/v2yclnqeoC4koivWErWSEOgkbfqVgkIlLQY6dVam6ULZE37DWY29RMVWfnpz294mbZSQFVkBiOEIvr9USI/JaKPQp668zQW3m783XZPQ3o+0JWXJgsQSM9dPTIXUI9jJa+88RSDMqPB9A+IOSSoXmY2CvF7e9R+uhq6BIh8hkt1puBfu0pWa87O/5aPDd68nZfeXuu6WEfkf/gjCMFCIJwG44HjQDgGwA1giDUSPj4G6IobvZNyYjIU3dMKMF9n6yQ9N7XLuqHAXnxPi4RkbLsNVjV7Uiyl6rOs0b1xIoUvPjrBqzZdRhA+wj5K0bke1U6It3TQ09xgFCzu8DbzgotBY7INT13TkUGm/HKhf1Qf6QJoRYjgs2+H/yh9P7S8/EhIlLP8bqTs/1dS46yn3471YfrVvKoaAcDR8roOSf+xI7/STEfAANHRBpzak2G5MBReVqUj0tDpDyttbHtzjjysIwxYRa8ObM/Pl66DbsOHsPw4kTUZPk+1aTW9ikpj6cAaZ3XqeoUznfBetU7jlPVuXseyHcg3D2msWFcY1RuDFjph1JHSum61mJk8iS56el+qXZZ1f59pZ3RNwOPfLHK5vWz+mWqUBpSGmtbIh8LsHtKwIgKNUt+L0fXUqAQVZyRYO+3vckOGRtmwTn9s3HD2CJFgkZEmqdmqjp33qvTe663ARm9MCp8fBIiguy+fumwPEXLoTZPr4vzB+XYfX1qdbo3xfEJn605oc8qhUjT3Lmuzh9oWw/dOr5YxtJI4+91gaKp6pzsS3/fz85I3Xal91FceBCuGVVg9doVw/ORGGl/JhL5F844UoAoijMAzFC5GESkEqU7SYiUYC8gam/Wj1Lsr3HEa49INkxVJ5mvb/u+/H5X9aa39arSgb0gkxGTe6fhvUVbu71mwNQaGQMffnyrqc6MQUFiOFZ3pG4FgKqMaOQnhqtYKvu0UEUp3uT343OPqNMNYwuxfs9hfLdqNwwCMKU6HdPrsmT/HV5OjvjfnuleV/vf1vnGNaMKMbwoEUu37Ed5WhSqMqLVLhIphIEjIiIPzRiQjRd+3eDyfUqnZSFSgr3OkR0HG3GgodmtGXlysddfpLeYrc6KS0QyUnxtFMG2o10QgHHlyT79XW9mgnrqwSkVCLEY8f3KXUiLCcE1owqRl6C9wIcWGQ0CXruoDo99uQrLth1AVUY0bhxT7HYAUM77MQeFEEmnXLDed78TajHh+fNqsfvQMVhMBkSFKP+coQQtBL/t017B9H4f0O6xdq4yIxqVCgWM9JpBwB8xcETkY6zv/Nc1owowf2M9lm096PR9nHFE/sjRWT3ise/xyoX9UJISqWh57Keq47VH+qLpU1bNVHVu/Lam96ETSqeq65sVi4ONzVi541DXaxN7pSLGx+vBGFWIHAWbjXhgcoXiv6sl3uz1hIggPHRKL9nK4is+S1WneFBXB5WYDopI/sdR6lGl6D1YoRfcy65xH5GSOA6eiMhD0aEWfHj5IDw/o6/T96nRSULka446NvYeacJfP1+pcGn0O3KLSDd4kUnm684lOfqVLSYDXr2wH2YOzcXwogTcdEIRHju10udl0kWnuJv8b4v0SQtVlB+e3kQ+ocVLRe37k3brD/kLpvamevv73t5vtHusiWxxxhERkRcMBgFDChMQEWzCocYWu+9RuxFK5AvO4qHfr9qtXEE62ButzzSRRKQXaoxkjgsPwq3jShT9zWg/TTFEpAY+YZBW8HHXn2kgKu9DPHe1iYdFOxg4IvIxTmn2f0aDgElVaXh59ka1i0KkIOd1W2NzK75ftQuvz9sMoyDgzNpMjCpNwoGGZjz0+Uos3rwfpSmRuPmEIiRGBrv8tXkb6nH6f35DmwiMKE7EtaMKUZEe1fX3tjZ7JdRZ/auz4pL8NP3wqmaqOh+9l9znKKWeAGldS1eMyJe1PKQPcl6Xmq4nAwQPgX7weiGp9HSuqF1W9X9fRweLdI+BIyIiGdx1YikDRxRQXLVXT37iF6zaeXztjO9W7cJz5/bFP75ZjSWb9wMAVmw/iIWb9uGra4fAZLQ/PehYSytmvrzAahbTtyt3Yd76enx53RCkRIUAcDDjiG1qIvloIQ+UTgTi87wgCC7PkcEF8ShPjXL6Hj3SQweODoqoWe7sOzkGrPBQUSDQYr3pskTaK7KslGzmOTv+SpwbWjz/AO2WiwIbA0dERDJw1OlN5K9cNWu7B40AoE0Eznthns371u85ggUb96FfbpzV6z+t3o37P1lhtXB7d4eOtaD/g9+iPC0SiRHBmL2u3raMbHwTkR9SczalJ799Vr9MFKdE4tSadBgY0Sdyyp2+W7ZzSCt4Jvoz/z66rEaJnGPgiIiIiNwmZyP73o+X45OrBnf999rdh3HBC/PR1Gon/1wPy7YeBHDQ7t/09hygu9R6JDtNnwN6ebLWSzn9jKO9Hmox4v7JFYqWhbRHzgAHr3D1MWClHzxS5D3tzTjXexXESfyu6f0Y+xMOkSfyMVZ4ROSPDDJWbn9sO4jvVu1CY3MrAODDxdskBY1cMXJkO5FfYFtKvwKhc0QPp6emg9Ia59YaazLsZh4pCgRaPM9dXb9aLLNeOduXSuxnrR5LqeXSavnJPzFwREQkk5tPKLZ5bWB+nJ13Eumf3B255z0/D6P+9gMOHG3G49+sluU7LSY2c4hkEwgRAJn4+oFei4E0LZaJSI/cSlXns1IQEXXy75pGjYEVbDORnrBHhYhIJlNr0pGXENb13yFmI64cUaBiiYh8p837CUE2tuw7itP/85ts32fW2dpjfIggIr0qS42y+/rdJ5UqXBLSIjlvb7xXqo+HQD+Uul6YvtCfceAQKY9VinZwjSMiH2N9FzgSIoLwzqUD8PWKXdjf0ISRJUnIiQ9z/UEiHfp96wGffO/KHYdk+y6LzgJHRJpuNKj4BOfOaFAt70JnRJ10zDgqZ6jFiCnVaXh34dau1+LDgzCqJEmpopET7IDxghv7jruZSBo91kkMjilDym4O9PSrPBVJSQwcERHJKDrUgqk16WoXg8jntu4/qnYRXDKb2Komkg1T1UkWqA/0D03phdSoEPy0Zg9y4kJxxYh8xIUHqV0snwvU403q47lHJJ9AD0Y4Jv9+Ubvusvp9DR12tfcLkT0MHBEREZFf0tuMIz4rEAUuvXRYOSunxWTADWOLcMPYIgVLRIFHH9cKkTYoc73wqvRnHDhEytNLuzgQ6KtHhUiPWN8REalCb2scEWm6yaDmMEh3UkVpeifqn15S6pG2BMp1ye0kkoZp37RHT4dET2X1BQZVSEnsUSEiIiK/xMARkYyYqo7ILnbg+Delj687v8Zzj0g+roIR/n61KdnMcxY4VCKoqNXAE+t00iL2qBAREZFfWrPrsNpFIKKA5NsHfzVHarNTg8i3GKInOSl1u9BqRzzJwb8Prn9vHZH3GDgiIiIiv7Rq5yG1i+AWpu0gTZ8DagYr3ElVxy4AIs2R87rUcjUZKF2Q2j4GRCQv7YWz9V4FcRK/BHo/yH6EgSMiH2MHBhERERG5gx2z+qGHY6WHMmqV0vvOrVR1PK5EiuH15j+02kcn+RzTZvHJTzFwRERERH6pLjdW7SIQUQCSo3PJ2WhU9hcQ+S8ORCc9YlDFn/n3wVVjtj+vF9ITBo6IiIjIL51Zm6l2EdzChwjiKWAfR+AT6Zuc16WWL/FAqX+0OlqfbPFIBRbfHG+Gs0l5rLu0g4EjIh8LlAcIIiKtmVCRonYRiIj8isgOJBt6aOqzo99z3HNEgcFVv40e6tFAuUN73cem/UPpFPsYSUkMHBEREZHfGVaUAJORzRwiUp6vn+fZYUBEgO77PsmP6CGoQp7y72Orpa3TUlmIOrFHhYiIiPxKUVIEHphcoXYx3MaHBSL73Mk/z+vIt9g5SGpTYz0KssZDoB+8XrTHl7OCmKqO/AXrLu0wqV0AIn/H6o6I/FFiRBB2HTqm+O8+fEov3PTOUrt/m3f7KDQ0tSAzNpSNTdIlnraBiyngyJdYt3iOgWuiwOAPzw7etCT0tfneFVbtTRW9bPKpXX4KLJxxRERERG67dXyxzWuV6VFufceY0iTJ7z1/YA7WPzgep/XNcPiehIggZMWF+cWDHxGRI5z1ozE8HKQWnnukFQFwLsr1eKHVXeVtMEOvtPTYqKWyEHVi4IiIiIjcNr4iBSOKE7v+OzLYhHtOLnfrO/55Zm9cNSLf5ftMBgFn1WX6fUDIzzePKGB4UlcxGEQkDa8UIul4vWiP/uIzPIvkxmc+0hOmqiMiIiK3BZmMeOacPliyZT92HTyGfjmxiAmzuPUdwWYjrhtThMqMaFzw4nyH7/v32TXISwjv+u8z+mbg9Xmbrd4z2o3ZS0RaxeCBfe7sFT6ME2lPoFyX/j7AhYi0LVDWOPK2qmVdrX08QtrBwBGRj/GmRET+ymgQUJ0Z4/X3DMyPd/i36XVZGNUjKHRmbSY+WLwNR5tbAQBmo4Bz+md5XQ4i0mL3QGDSavORazHZ0kPAV6vnkx4ovevcCpTr4Nwj0gtXV5NcV5svr1reoQMD+xhJSQwcERERkaqCzUaMLE7ENyt3SXp/ZUY03rqkP95ZuAXNrW2YVJWGPtmxPi6lEvgQQOQP5LiSna01wP4CIv/Fjl+Sk1L3C96W/Jl/H11tBeC1VBaidgwcERERkeqiQ+2nuXP0wFueFoXytCgflohIeVoICGigCDbc2S/a6gDwP9y/pDYt1JOOaLhosuJodyJtCpRUdeT/eJvRDoPaBSDyd6zviIg8xzqUiAKRVh+YmarOllaPVXdqB/z0HGjQctG1XDYivXF5PengeguUO7S3h0LtQ+lsVrkUapefAgsDR0RERKQ6R52Reu5sIiLylNNUdcoVg4iIdEypoDHb6/7Mv4+tJ6eur/YILyPSIgaOiIiISHWRwWa7r4cFGRUuiXr4sEBkn9qzJdzlz9ey3o4F+R8tX19aLpucAmQziXzCl7OCmKpOGd7ukUC5V5B/YOCIyMd4UyAicu3cAdl2X5/WL0vZghCpiE0G6sT2o37o4VCpfT7pYR85ouVgqXZLRqQ/Wr7WpfImoKH2fcId3s5w09O22qP38kvhD9ejv2DgiIiIiGQzviLZo89lx4XihDLrz55UmYq06BA5ikVEpCtOU9XxWZqIiDQkEG5LcnVka3Vfebvujl5p9XgQaYVJ7QIQERGR/zi1JgOf/r7D7c8JgoB/TeuNdxZswe9bD6AyPRpTqtN8UELt4oMLkX16C5RwlCSR72j5+tJy2eSktzo5kPFYaY/+UtXxJFIK9zRpEQNHREREJJvhxYl46qxqvDpnI3YdPIaRJUn49w9rbd53Vr9Mm9fMRgPOqM3EGUoUlEiL+MTo9wJ1RC+pS+2qhZ3XvuFtuiYiOo6XkyPaa7h4e6j0HuTXe/ml4PWoHQwcEflYIFTqRETdja9IwfiKlK7/3rb/KD5csq3rvw0CMM1O4IiIiNpp9YFZ1GAHktrYee/neHiJXAqEalCubfTlruId2gMBcO4SeYOBIyIiIvKph06pgEEAvlmxCynRwbhudCHKUqPULpbmsPORyD84u5SlXubOZyaxrqAApuHTn7dxInJFf8EdVmxK4bMgaREDR0RERORToRYT/nFGb4iiyAYxkROcpUxax3OUtEp/nbHeU6tJxXqASH5yXFW+uTL9r3bl46j28RBph2YDR4IgZKDjXBFFcZPKxSHyHGs8IiIAHEVFpAd67x7wl1RqrC71Qw/HSu0y6jnQoPa+I9IDPV/jnVxtga+3UI7Wi3+0gFzTe73s7XqXet9+0hfNBo4A/AnAgva6T8vlJCIiIvIanwGIqJOzTgV2GBDZ4mVBZIv3C+3R3yHRX4nd4UnQ01d7xL/3NOmV1gMyvG6IiIiIKCBooYNHA0Ww4c5+8YdRz0TkGK9w9WnhXkWkV76cFcRLUxpv95O3x5B1KOmJQe0CEBERERGRNgRKmhOtY6eCfujjUKlbSj2fz1ouupbLRqQ7vKAc0F7LkIOEAgAPsWYwcETkY3p+UCIiIiIi5TlNVadcMWz4yxpSRL7A5z7SGqU62APh3JdrrdYA2FW64slh5TGkQMLAEREREZEGBMJDN2mfFk9DvY0s5bVM5Dtydd6S53gEiDynv+EXvOJ78tUx5O2NtMirNY4EQbhTroLYofX1l4iIiIiIZKOF50X9dWjoi7OZRN1ptfNAb0E8aqf2+aTns0bLgSoNF41Id3h/c8QPW4Y6P9SBUPfzetQOb4Mzd8MvaxEi+bC6IyIiIiK5qNmRzVR1tgKhA4ek0XKQiQKTUqdkIJz5cu3LQNhXvibnee3JV3n781IHERFpgVyp6lj3EREREXmBI6tIC7R4FvpTX6zUbWGnApF9flQd6JY/1clEStPf7Z0XvFJYt5IWyZUOToT8tYn+6lMiIiIiIg9pYbQ6G+Dec3Yc9R4QYoCbtErnl5aHeD0SyUXtJph2r2b/q129bct4u0fUPteI3OHtjKMdOF6/nSSKokGu/wFo8rJsRJqghU4gIiIiItIPNh/1RPsHS/USql4Az7lTdB1vJpF3ePJ7zf/CM/qgx/66QBjEo8PD4re8DRzN6/bvvl5+FxEREVHAYgOZyD5/ujTkSFXnT/uDyF2OriFeF0S22LaUT+DuysDdcke4RyiQeBs4mt/t3328/C4iIiIiooClhQ4eDRRB97gPiZQXiKP11btnsJYjkhuvKuV4W3f66n4TCDOJSH/kmnEkAKjx8ruIiIiIiEhFeu98FXW/Be20EEQkafRwrNROxaPnzjB3dp0ezgUiX9DzNd5J7S3QbutFeyUL9Lo2ELY/ADZRN+SacSQCSBAEIcPL7wsIgiDkCoLwgCAIiwVBqBcEoUEQhLWCILwmCMJ4tctH8mKFR0REROQ5tTu91eA0VZ2Ku8NfAnPkfwKvliByzR8COloh172XR0RbPDmu3h5DZ208Iq0xefNhURT3CIKwCUBmx0t9AWz2ulTtXgZglum7NEMQhMsBPAIgpMefcjv+d6YgCO8DOFcUxYMKF4+IiIiIApjeOzTYSUbk3xxd44HYD6dWbReAsXwi2eivrvK/C97rwI8spbDD/3Y1+QGvAkcd+gEI7vh3vQzfBwAQRfFiub5LKwRBuATAE91eWgrgcwANACoBnIj2YzIJwHuCIIwTRbFJ6XISERERkfK08Lyovw4Na1qYEeOsU1XqKFOtdswyMGdLD3tED2XUKnfOeV4fFKi0es9yRyDObpZG/XaVv/H2VAuEM5XXo3Z4HTgSRXGnHAXxd4Ig5AF4vNtLt4qi+FCP9/QG8BmAJAAjAFwP4EHFCkk+wfqOiIiIyHNsSllj25L0RolzlpcFkS3eL+Qkz87kIfGenEEFT76Jx5ACibdrHJF09wKwdPz7tZ5BIwAQRXERgHO6vXSLIAjRCpSNiIiIVMaHe9ICvZ+GWh/xz+ucyDu8ho7jiGwi/dHf/B3/q2dYdxJJx8CRAgRBCAcwpeM/RbQHkewSRfFLALM7/jMS7WnriIiIiMjPaeE5Vn8dGtY0karOSScLF0QmNWihbvE1LVxa7uznQDgmRHqi9iWp9u87poXaNTBIPQcY+CIlMXCkjDE4vg7UUlEUV7l4/1vd/j3ZN0UipWh95CsREREREXmGHTiu6XkP+erwMohMSlDq2tPzNa4VrBKkk/N84y1cm3hctIOBI2VUd/v3zxLe/1O3f/eWuSxERESkQRxoQFqgxbPQrVH8mtyC46Rui7NOZTW3UQszuiiwOTr7tX3lE5HeBW5Htv9teOAeSyL3mdQuQIAo6/bv1RLev6bbvzMEQYgURfGgzGXqIghCBIAIO38yt7W1+epniYiIiMiK+k+yeg8LaCGw4axDgrMMiHxDC5eW0jW4+ncMIv+hdjCB1zNxBjNpEQNHykju9u8trt4siuI+QRCOAAjreCkJgM8CRwCuB3CXvT/s3LnThz9LRERERHrAR1llabXvQOszutSghz2i9nFjZ5h/YQBcP5S69HiNe0+7l5X2Sibv6aa/c1d/JXZfIGyjXjBVnTK6z+Y5IvEzDQ4+TzrDNhQREUnB+wVpmZrdBu50SKndQe6KHKnq1NxELczoogDn4PzX9pVPRHrHOobkwuA76QkDR8oI6fbvJomfaez271AZy0JERERERETkNzTRD6dwz7JaA0440IVIftq9rLRbMk95u0WauN8QKYSBI2Uc7fZvi8TPBHf7d4PDd8njMQBpdv73e1JSko9/moiIiIgAbXfGabhomuNsX0kdZarVc0HrM7rUoNVj1Z0eyqhVvtp3PCbkT/zhfFb7/qbdYIR2S6ZX3l4v/nC9uRII26gXXONIGYe6/TvM4busdZ9ldMjhu2QgiuIhe78hCEKzwcDYIhERkRLYQCYtY7cBEXlKidub3m6hTFVEytDblaFdXMdJO+QM8nlyWHkmUCBhVEAZO7r9O93VmwVBiIZ1gGmn3AUiIiIiIiJlsd+JyDuOOgy1EIdResaC2jMkiCgQ+F89w7YYkXQMHCljebd/F0h4f363f28RRfGgzOUhIiIiIo3R8nOslsvWnaiF7mMnO4uzDPwPO+/9m6+OLzsuyZ/4xems8kZodx+y4aI1nP1GSvJJ4EgQhEcFQWAavOMWdvv3QAnvH9zt34tkLgspjHU6ERER6R27DYjIU3wessUgMimB155+sEqQTs7zmpeIVvHIaIWvZhxdB+BXQRByffT9evMFgMaOf1cKglDo4v1Tu/37Pd8UiYiIiLSEo9ZJC/R+Fmr9OtJ7J54mZnRRQNPyNaR02bS8L4j8TeBebv645epuEwcOkJ74MlVdDYBFgiBM8+Fv6IIoiocBvN/xnwKAWY7eKwjCKAADOv7zULfPEREREZEf00LqCb0/y2o9sCFLZ4G2N5E0SANVCxH5MX+oY9TeBj/YhUTkh3wVOGru+P8IAC8LgvC8IAihPvotvbgTx/fL2YIg3NjzDYIgVAJ4qdtLfxVFcZ8ShSMiIiIiIu9pfdaTN/x52zyldmejHuj5vOHxJT3j6asf2h0Tor2SyXleqzFoi/cV17iPtMNXgaMBANZ1/FsAcA6ABR2BEa8JglAgCEK4HN+lFFEUVwO4tttLDwuCsFgQhIcEQbhTEIR3AMwDkNLx9x8APKp0OUl+en5QIiIi5bCBTOQ9rbe7ZLnOtb2JRD7l6PTnZUFEvsR2uv/gsSSSzieBI1EUFwDoDeC1bi8XAZgtCMJVMvzEEwD2C4KwSobvUowoik8CuArd1jsCcDOAewBMAWDueP0jACeLonhM8UISERERkSr4HOu9gEhVR0Q2tHBpsQ6nwKX/s1/tLVD79x3TbsmIyPd8tsaRKIqHRVE8G8D5ABrQ3pYLAvB3QRA+FAQhzouvT0d72XO8L6myRFH8F4ByAH8FsBTAfrQHkjYAeAPARFEUTxJF8YBaZSQiIiIi6o7dBtJxJCtpjRbWT9MrX+05HhJSAq99/dBC8Ns+7ZZMDrxCiJzzWeCokyiKLwDog/YgSacJAJYIgjDU3e8TBGEggBK011675Sij0kRRXCuK4i2iKFaKohgjimKIKIo5oiieIYriJ2qXj+TFthoREUnB2wVpmV66DbSeqk4qzkwivyLjZemoI1xvV74c1zifM4mUo4f2RcAECr3czADZS7rGY6QdPg8cAYAoiqsA9APwJI4f/1QAXwuCcK8gCE7LIQhCjCAIwwVBuA/Ax93+tNonBSYiIiIiIt3Reqo6vffpaH3/UuDSwpkZMJ22RH5I7etXjl8XfTLqhPWa3Dg4iPTEpNQPiaLYBOBKQRC+AvA8gBgARgC3AxguCMKZoihuEQQhE0AV2tdI6vz/jG5fJeB4u/BVZUpPRERERORbWu5z1HDRNMfZvpLaWaDlc4Gs6eFY6aCImuWrzmQ9nDekf0qdZjyfiYj8k2KBo06iKH4oCEIvAK8DGIj2e9kAAMsEQWhBe0Cpp563IQHAOwCe9WVZieTANhQREUnBh27SMr0MjtRDKhk94/4lT/D+ZkuWVHW8HokoAHlb93UfEKDG/Yn3RNfUngFIxykSOBIEIQrts4cqO/6/CkAprJ9BI118zRYAizv+96koirPlLSUREREREemZ1lOpKf0cLHfHstb3L/k/LfclabhoROQlLdc9RES+4rPAkSAIuQBuADAOQKazt3b7d/cnkdkA3kVHsEgUxb1yl5GIiIiISCu0PHpcuyXTF1ny2rvxHQz0EMAOTyLyLX+oYvxhG4iI5OaTwJEgCBkAfgaQBOf170G0B4YWAcgFcCLaH4UEtM9Oek4UxW98UUYiIiIibeEjK2mXXsIPWgi++XN6DS3sX63hPvFvPLqkZ358O/I72m1nabdkcuA9XJt4VLTDVzOOrgCQDOsaZifaA0SLACwEsEgUxXXdPyQIwhUAHgFgARAK4BlBEEYBmCmK4iEflZXIp/y584CIiIhIS7Q+w0aWZqEb38EOEdICOc9CLZ/Riqei1PLOICLyEW/rPladRNL5KnA0vtu/vwdwhSiKy119SBTFJwRB+AnA6wCK0H49nw6gryAIZ4qiON8XhSUiIiIiUpuWOwE1XDRdkSVVnTu/p/FAGhER6Z8/DJZVexO0uwe1WzIi8j2Dj743teP/jwI4RUrQqJMoiksAVAN4vtvLeQB+EQThBvmKSEREREREJC92sQQWtTsbpeDMM8/56vg6+l5R6egy+TVe++Q9/66T9HAPJ1KTrwJHMWivXZaJorjP3Q+LonhUFMULAEwDcKjju8wA/ioIwmeCICTIWloiH+J9iIiIpOCDC5H3tN5JxuucApGcsxG0fA25U//IER/S8r4g8jd6uN78YeaXFN5uZYDsJl3jMdIOXwWO7gXwEYDfvfkSURRfR/vso+4p6sYAWCIIwkhvvpuIiIiIiPyL1lOz6X0ygdb3L5HeBUrHL/kXfzhrtT7wRArfzFjU/34hIs/5JHAkiuLdoihOEkXxIhm+ax2AgQAe7fZyMoAvBEF4wNvvJyIiIiIiIvKEHvr59VBGrfJVIIfHhJTA84yIiLzhqxlHshJFsUUUxZsAjAewu+NlA4Cb1SsVkTRsrBERkRS8XZCW6WWeiRZGDPtz208L+5f0R96zRsPnoBtFkyVVnZb3BREpLlBmLHq7naw7tY/HSDt0ETjqJIriFwAqAXytdlmIiIiIiEhbtJ5KLUD6dIiIKID4w73N1TbooSPbN6nqiCiQ6SpwBACiKO4URXEMgFsBtKpdHiIiIiIiOWi540XDRdMV9un4Hz10Jmq/hIFHy/U9EREREaDDwFEnURT/CmCQ2uUgIiIikkOgpJcgfdJLvEMLnfhaKAMRKc+d27gsqepY1RBRN755ltBLC1C67ruJ9SiRc7oNHAGAKIpz1S4DkSvsCCQiIiJSBlPV9fg9BrFIA+Q87/loRURq0EPdEyip6nRwKMhLerjeAoWuA0dERERERP5Cy5382i2ZvsjSp+PGd2g9kEYK4QVMFJCU6nzVcvuFvMVj25O3g8MDJL5HfoKBIyIiIiIN4GMZaZlennE10XmlgSKQcjgqljq5cyo4Om/cmTHAU4+IfE8vLUDPeNJuDJSZXUQAA0dEREREROQntD7DRpYggxvfoYlAGgU8noe22O9IRHILlGUS9L6Zei8/BRYGjoiIiIiINEDLD5IaLpquKN1ZrPVAGhFZC5SOX/Iv/nDautoGPWyjb2bC6GDDichnGDgiIiIiIiJSkR46pMg+PRw6zvhRhjtBH1lS1fGwkgsMRBLZ6n5Z8BIhco6BIyIiIiIN4IMLkX/w5Fr21UwkBgxIC3h/s8VUdUQkt0AJFLJt4/8C5FTWBQaOiIiIiIiI/BBT1RHpS6B0/BJpjatghB6CFb5JVUdEgYyBIyIiIiIiDWB/IZH+6OG61UMZ/YE7u1meY8IDS87xDCFyzpO6mAF+CiQMHBERERFpgB5GMhKRa7ySicgVTgwgIrn5JqDhf5WVt89cnNlFgYSBIyIiIiIiIgVwkCoREfkbf7i3udoGf9hGv8Fj4fc4oFI7GDgiIiIiItIAPiT5P1kGqao40JVrJtmj/etW+yX0D+xYJq3hOUne40nUE1PVUSBh4IiIiIhIA/gMQuQ9Bt+ISA8c3fPdSYHEdgOR/ugvzZneyuta97rTk3aj/o4hkecYOCIiIiIiIr+ghRkxzkaiytLR68Z3yB1IY2COPMEAhy32O5I/4b2BlMR7iv/jMdYOBo6IiIiIiDSAD0n+T+nOYi0E0ogChRyd50yBRHJiQEc6V3tKrj3py2vcNzNheA71xHqaAgkDR0REREREBED/6Tf02knGPgj90sOxYyeX9siSqk6mshCRcvTezvIHVqnqPKhIeQwpkDBwREREREREfkELM2w86cz1VR+EXgNpRP6O/Y5EJLdAGSQQGFsZ2ALkVNYFBo6IiIiIiAhA4HQ6BAotBNKIAiWAKUf1yTqY5KTU6eQPp62ra0+ubdRfqjrqifU0BRIGjoiIiIiINICPod7Tawc1+yD0Sw+HTg9lDDSypKpjxUFE5LbubUXWokTOMXBEREREpAHs/yHynhZm2HiWL1/+cgD6DaQRERGRe3wTTFa/XaU1nNlFgYSBIyIiIiIiIj+khUAaEQdG2GK/I/kTf7jGXW+CH2ykn+BsS//HgU/awcAREREREZEG8DmYSH/00IGlgyJSB3fOJx5WcoXnCHnP/86i7tWsJ/dHPdz3ieTCwBERERGRBvAhhIjkxhGbFCj0ljpIjjWOiEh/eI3rH48hBRIGjoiIiIiIiGTiLFijdHyYqepICwIlfOnO9c1+RyJt4fgt/eChIlIOA0dERERERJrAR2F/x85i/6OHqzYQZp75y6xdt1LV+ccmky/xHJGNXNebv9RVeubtEeAxpEDCwBERERGRBvARhLSA6TfUwT4IosDCVHVEgYnXuNa43wDz9hjyFHCNM+a1g4EjIiIiIiIimXgSBPJVJ0IgzDQh0gp3rjd2HBJpC2eREBHZYuCIiIiIiIgAsOPE33DEJmkB6xXp3EpVx8AwucBzRD5y7UnWh95Texd6ewzVLr8esO7SDgaOiIiIiDSADxGkhXOAKVTUoYVjLwUDUbZ0cez0UMYAw1R1RIGJ1ziRa2xvagcDR0RERERERCpiqjoi/dNFEFEGAbKZRAQA7MAnCmgMHBEREREREQCmUPE3co/YZCCKPMGzxpaeJx3ouOgBh7d0+cjVPmI7y3tsi/g/HmPtYOCIiIiIiIgAMIWKWtiPpF966Nzg+eWfeFyJyPdY0ZDymKpOOxg4IiIiItIAPXQ+EpFvMFUdkTSOzmgtBL3dudr0HPTRcdGJVKeFuoqISCoGjoiIiIiICABTqMhBS7uQIzbJ3/jLGa3nvmMdFz3gaOh2RCQbLbWzyDc48Ek7GDgiIiIiIiIA+h8Jq9cHTbc6QfR9iPyOHjqw1C6iEvvIX4Le/rIdFFh03nSQRK4rk9c4EekJA0dEREREGsDnSCLvcYaNNb0G0ogc0XKqOnc4uufrbTuIAoVcVyavcSLX2J7XDgaOiIiIiIgIAEfCysGTYE3PfiSn3+HG1/PBm/yNls9od+pP9h2TP2HTgYjIPzFwREREREREADgSVisY8CE5qR0QVuL31d5GubizHX6yyeRD/nJdaAFT1REphzPmtYOBIyIiIiINYPOYKHD5qh+JD94UKPQW9GaqOiJ9Yao6IuVwAJV2mNQuQCAQBMEEYAiAkQBqAZQAiAfQBmAvgKUAvgTwoiiK+1UqJhERERERqcCtVHVEpEmBctUGynYSEaDtBKFE5GsMHPmYIAgzATwAINbBW9I7/jcewN2CIFwliuLLSpWPiIiIiKgTU6h4T45dKNdIS47YpEARiHWXWtvMWkU/Au+q0L5ArKvkxl3o/ziASjsYOPK93jgeNBIBrADwK4CtAFoBFAI4CUAkgGgALwmCEC2K4r+ULyoRERGphu1j0gCmUFEHO0H0Sw/HTgdFJCIKCPprZ/EOQsrjwCftYOBIGbsBPIX2VHTre/5REIRoAC8AOLnjpUcFQfhSFMVVipWQiIiIiIhU4at+JI7YJH/j6IzWQmesHoKIcgiQzSRSVKDUH0SkLwa1CxAAngOQLYri3faCRgDQsa7RqWhf6wgALAAuVqZ4RERERETtmELFe1ragxyxSf7GX85oOeJcatU1/nIMAgFv6fqhgdi3bnBQDJFyGDjyMVEU54mi2CDhfc0A/q/bS/19VyoiIiLSGj4EkRZoYdR+IGLnnn7pIdiqgyJ6TQ/HgYiIdRWRa3wu1g4GjrSl+4ykONVKQUREREREitFLqjrOYLLFYKuytJ2qTvr1pue+Yx0XnUh1WqiriLSO7U3tYOBIW9K6/Xu3aqUgIiIiooDEkbDaIFfAhw/e5G/85YyWJVWdStW1vxyDQMBR+0RE5A2T2gUgK6d1+/dPSv2oIAgRACLs/Mnc1tamVDGIiIiISGUcCes9T4JvPT+i1YAPOyFt6SHYGgjHTQ/HQQp/2Q4ifyPXlclr3Hty7kIeDm0KhHaLXjBwpBGCIIwBMLbjP1sA/FfBn78ewF32/rBz504Fi0FERBS4+OBCRHLjg7fvMdiqLC2nqnOHo3u+3raDKFDIdWXyGtcWHg5t0uoAqkDEVHUaIAhCMoDnur30L1EUV6tVHiIiIiIKTBwJq46eHRdMVUdkH89o9fEuQSQ/7Ta/WOvKjcEq0pOAnnEkCMKDACbL+JV3iaL4hptlCAHwPoD0jpcWA7hVxjIREREREUnCkbDek6PvhwEfIvcw6K0c1k46otBlwaaD97gPpWNt7/84Y147AjpwBCAFQJGM3xfjzpsFQbAAeAdAv46XtgCYLIriMRnLJMVjAJ628/rnSUlJFQqXhYiIKCCxeUxaxj5Z3/LV/uWDNwGBcf0GYtA7ADeZiBQXADcQhQXCPdlbHEClHYEeOFKNIAhmAG8CGNfx0nYAI0VR3KB0WURRPATgUM/XBUFoNhiYzZCIiIgo0LGD0rd8laqOyN/wylAfjwH1xI5w73EfEpEWBXTgSBTFGQBmKP27HUGjNwCc3PHSDgDDRVH8U+myEBERERGRfOTo/OFISyL7/OXKkCMYr1ZHs78cg0DAYIR+cICOdExNSqQcTidRWLegUefaSjsBjBBFcZV6pSIiIiK18SGItIynp29x/xIREZE32JZwH/cZkXMBPeNIad3S003qeGkX2oNGK1QrFBERERGRCxwJ61vcv0TS+Esfn547K3VcdCLNkmW2MtsSbuM+I3KOgSOFdASN3sLx9HS70R40Wq5eqYiIiIiISGvkWuOIKe/I3/jLGa3nzkodFz3gMMinH3quE/RGz4F7IqUxVZ0CnASN/lCvVERERKQlfIYhLeNDtnSepJ3s+REGfEhOgXD9Mt0rEVFg8La27x6k461Dm+QaQEXeY+DIx5wEjZapVyoiIiIiIuk4Elaf+OBN/sbRGS3qrJLSc2eljotORGRFZ7eOgMEBVNrBVHW+9ySOB40A4FMAJwiCcIKEzz4tiuJB3xSLiIiIiMgaR+1rA1PVEdnHM5pIOt7T9YOHSjnc10TSMXDke4U9/vtcNz77NgAGjoiIiIhIEXobte+vGPAhOQXCzDN2kCuHtROR/Nj8ks7b6p6p6oikY6o6IiIiIg3ggwtpGc9PfQqEgAEFFn9JVUdEJDe21dzHWweRc5xx5GOiKA5TuwxERERERN7gg7Vv9dy/Wk1Vx5lQRMS+af3gsdIPOYI+bKspg9cVBRLOOCIiIiIiItIQBmiI7POXK0PPHbw6LjqRZum5Tgg0PFQUSBg4IiIiItIAppQiLWP6E9/y1f6Vu15hPaVPvH6JiPxfoNT1cq5pFyj7jMhTDBwREREREZFTHAnrW75KVUfkb/zlytBzZ6WOi06kWUxVpw5P9hnrQAokDBwRERERERERkeaxX1R9PAb6oVSAkgEL73EfKsfb64KHigIJA0dEREREROSUnkfH60HP/cs1jkhOvHyJiPwf22rSdA/ScZ8ROcfAEREREREROcWRsESkBezjUx+PAfXEznfvMVWdOpiqjsg5Bo6IiIiIiIg0hGscEdnHflEi6XgvIbLFVHVE0jFwRERERERETnE0sbKYqo7kJPACJiLye6zqpWGqOiLpGDgiIiIiIiKnmP6EiLSAfXzHcTYJEZF32L4lco6BIyIiIiIiIg2Rq0OYM5eI/Bevb3KFsykCC4Mg0nh7XfCyokDCwBERERERETnFzidlsUOYyL/puYNXx0Un0iw91wl6422qOh4qCiQMHBEREREREfkhprIigKOjiYgCAQf5EJHcGDgiIiIiIiJSUc+Rxgz4EPk3PXfw6rjoRJolR53AWUvSdN/Xnuwz1oEUSBg4IiIiIiIiIiLNY7+o+ngMiOTHoI9+8FBRIGHgiIiIiIiISEV6nn1A2sfzi4jI/7Gudx/3GZFzDBwREREREZFTHAlLRFrAPr7j1EppyWOgH+wU1w+mqlMHU9UROcfAEREREREREbkkMkELqYxn4HG8HomIiMiXGDgiIiIiIiKnOGqZSL8EXsBERH6PVb003WcZcZ8ROcfAEREREREROcX0JwSolxqLqBPPwON4PRIREZEvMXBERERERERERKQjTFVHrigVXOTgEtITzjIiko6BIyIiIiIicooP2cpihzARERGR/BjoJJKOgSMiIiIiIiIiIh1hqjrSCg4uISLyTwwcERERERERaQg7hImIyFsM6AQWzqSRhtcFkXQMHBERERERERERERGpgEEf/eChokDCwBEREREREREREXnt1nHFaheBKCBxJg0RyY2BIyIiIiIiIiIi8tqpfTLULgKR7jDoow5PZnrxUFEgYeCISCVp0SFqF4GIiIiI/Nj4imS7r184OEfhkhBRIDitTzpiwyxqF4OIiIhkwMARkQLOH2j7cH7d6EIVSkJEREREgSIrLgz9cmJ7vBaK/nlxKpWIiPxZeJBZ7SIQadrYMvsDOmqyYu2+rpQB+fH2X/fz9oK/z/RKigy2+3pOfJjCJSG9YuCISAE3nVCECRUpMBkEhFqMuGRoHqZUp6ldLCIiIiIr2Q4eJJMdPHhqTajFpHYRfK5/rnudOM+e2wfn9M9CaUokTqlOx/8uqkOQyeij0hEREZEjJ1WlItRifQ9OjQq2GeShtDGlSYgItm5DRQabMKYsSaUS+a+ZQ/Lsvl6SEiH7b02oSIHFaNv1f+GgXNl/i/wTA0dECgg2G/HkWdVYctcYLL5zDG4ZVwzB34c2EBGRW4LM9ptlpSmRCpeEApm9WdJmo4CTqlJVKI17LCYDRpdqu4OjJivG7uu12dI7jILN7gV9IoLNuPfkcnx69WA8dlolUpkuWVaOgpUFieEKl4QCjQgPFufwsRMrU9QuAqkgMpgzzaSKDDbjhfNqu2Z8lKRE4sXza2EweN8/1NeNtkRPwWYjXjy/FpmxoQCAzNhQvHB+rd8PNHE0I8eXplSnIaxH8HBgfhwSI+QvS4jFiFknllq9NnNoLjLjQmX/LfJPDBwRKSgsyASLiZcdERHZCjYb7XYe3zCWqU39zSNTe9m8FhNqRk6c+mkjMmJDccXwfKvXZk0sVX0mj0lCh8qVw/PdDqoo7YTyZJvOghCzESdWWgfmIkPs7+8ZA7J9VTRJUqLsd2rkB3CQJDbMghI7Af5bxhUrXpYHp1TYvOYoWKlXjjr5xldoI2ARFWLbgX5KdbrNa+FB9q/xIDt12F9OLrN5LTbMgiQfdDJK4Sz4XJURrVxBSDNSo0OQl2Dbhsmy0zl9Tv8sJYokOyntEKlqc2Lx3Q3DsPzesfjs6sEoSJJnpknP9pu7qjNj8ONNw7HkzjH48abhqM7U1/2j5/0uKTLI7vssxuP1bHiQCaNKEt37nWzv9ktSZDBePL8WNVkxiAk1Y0KvFDw1rcbmfdkyBXem12Xh6+uG4uGpvfDxlYNwywnKt08ccXQvNHKgvWawB5uIiIhII/46tRdSu3XMzhiQjeFF7j3MkPaNLElCeox1x9v0/tmyjDaVw/VjCvHJVYPw6KmV+Pq6oTinf7baRcJ1Y2wDqA9NqcBTZ1Xj6pEFePXCfrhyZIEKJbPPXsqZWRNLEWw24rkZfREf3r54fFyYBc+e2wchPYJJ0+uy7X7vBYNsZ4Qp6YTyZATZGQQV6ClP7p9cbtX5Mbl3GoapUHefWJlq1XEWYjbiprFFiv2+vTVc3ZlNJ0VqdIjdmbiXDLWf+keq28bbdqRNrbEN+Lhy8RDra8FkEDCtX6bN+64eZbuvDAJwUqXt7M7RpclddUan0/tmqHbPKEuNRJqd4NErF/RjVg2V3GsnuJifGA6znRRVvvLQKb2sBkacWZuB52f0teq8T4kK1vT9oq+DgEBadIhNu00O7g7KuavHzJHuLhmah17pUd4WCQAQFer7GWQ32rk32XvNkVPt1M89A2f3nFRu85606BBkxFofy8dOq8KY0iQEmw3ITQjDyS5m2V85wvv2Zp/sWLxz6QAsunMMnpxWbXefX2WnXevpWun5ieE4rU8GytOiNFVP2xvwEh9uQV5C4A5I0hr/TwJOREREpBM58WH46eYRWLH9IJIig5EQYX+kHOlbbJgFb8zsj5d/24jN+xowtDDB7gOwWgRBQFlqFMpS5emAkMMlQ/Kwv6EZby/YArNRwDn9s3F63wwIgqCZmQbdXTe6EDOen4ejza0AgOLkCEzp3b6+ZV1uHObeNgrbDhxFalSI3c7f5KhgnNE3A6/P29z12pTqNGTEqptaJNhsxF8mlePmd5ZC7MiSdeWI/IBPeVKdGYNf/p+9uw6P4lr/AP6deAIhWLDg7u6UFgr1W++tG3X59fbW7ba37i63LdLSQo1Spy3uEiDBJcSJO3Hd3fP7I0JkZXZ3bHe/n+fpUzI7O3N2dmfmzHnPec+TZyMmtQhRnUIxrHu4Lg0z7YMD8M0d07AzqQB5pTWYPTTSagO/Wq6c1Bvf7UlDdkk1gPqgyd1nKd9I/NH1E3Drl3uQXlSFoAA/PHH+cIyOcu96dfOM/tiWUIBtCQUAgEGR7VwKut03ZxD8/ST8cTALHcMCcccZA62O+hoTFYFZg7tgR2Jh07Lrp/W1OmKpR0QIvr9rBpZsT0FmcRXOHhaJW3QcfShJEj68bjxu/XIvyqpNkCTgifOH44whXXUrk6+7cExPLNmegpOFlU3L7nUzmOqsKf07Y9fT8xCbegp9OodhUGQ7SJKEP/81G5tP5EMCMGdYJLq0N27ddsGsAdibeqrN8ofOGWqIxvbLJ0RhRUwGjmeXNi27f+4gXDe1L3p38qz78F1nDkRyfgV+P5gJALhkXFSbwLs9z18yCiVVddh0Ig/tggNw/5zBmDu8ZYeNOcMiMWNgF+xKrr/O+kn184+3/i4jQgOx8ObJMFsE/P0kCCEQ2T4YX+5MhdnSMiXo7WcMwMS+HV34xM67fEIUsoqrsHTnSdSZLbh8QhTud3NUmdHMGRaJET07tPhN33PWIMN0piNAEsJ4eXHJGCRJip04ceLE2NhYvYtCRERERASLRUCSYIgGHEdOFlZgU1weOrULwtnDuyHcyTkgLBaB1UdzcDC9GKOjInDhmJ7wN8iDdHpRJfalncLInh0wuFt7j/g+SBtZxVX4/WAWiivrcP7oHqqlLhNCILWwEj0jQhRLUSmEQEJeOSprzRgTFaH6+VZVa8aPsek4nl2GKf074bLxUR7VWFZjMuNoVikGdm2HjmFBjt9Aqsorq8Yv+zKRW1qD+SO7YeYgBvJcsT2hAD/EpGNnYgGmD+rSECgwTsq2suo6bIzLQ1FFLeYO64b+XfVPc+yOyloThKif1sEVVbVmBAf42bx2VteZsTEuD2lFlZg9pKtTnaLKqutQUlWH8JBA7Es7hYFd26GfDmmlhRCwCBimDqi04spa/LQvE+lF9Z3pWgcAyX2TJk3Cvn379gkh2uZEdICBI7KJgSMiIiIiIiIiIiIiIs/jTuCIcxwRERERERERERERERERAAaOiIiIiIiIiIiIiIiIqAEDR0RERERERERERERERASAgSMiIiIiIiIiIiIiIiJqwMARERERERERERERERERAWDgiIiIiIiIiIiIiIiIiBowcEREREREREREREREREQAAEkIoXcZyKAkSSoMDQ3tPGLECL2LQkREREREREREREREMh0/fhxVVVVFQoguzr6XgSOySZKkFAAdAKTqXBQj8QPQvdnfuQAsOpWFiDwfrylEpDReV4hIabyuEJHSeF0hIqXxumJdfwClQogBzr6RgSMiJ0iS1AtAZrNFUUKILL3KQ0SejdcUIlIarytEpDReV4hIabyuEJHSeF1RHuc4IiIiIiIiIiIiIiIiIgAMHBEREREREREREREREVEDBo6IiIiIiIiIiIiIiIgIAANHRERERERERERERERE1ICBIyIiIiIiIiIiIiIiIgIABOhdACIPUwbghVZ/ExG5itcUIlIarytEpDReV4hIabyuEJHSeF1RmCSE0LsMREREREREREREREREZABMVUdEREREREREREREREQAGDgiIiIiIiIiIiIiIiKiBgwcEREREREREREREREREQAGjoiIiIiIiIiIiIiIiKgBA0dEREREREREREREREQEgIEjIiIiIiIiIiIiIiIiasDAEREREREREREREREREQFg4IiIiIiIiIiIiIiIiIgaMHBEREREREREREREREREABg4IiIiIiIiIiIiIiIiogYMHBEREREREREREREREREABo6IiIiIiIiIiIiIiIioAQNHREREREREREREREREBICBIyIiIiIiIiIiIiIiImrAwBEREREREREREREREREBYOCIiIiIiIiIiIiIiIiIGjBwRERERERERERERERERAAYOCIiIiIiIiIiIiIiIqIGDBwRERERERERERERERERAAaOiIiIiIiIiIiIiIiIqAEDR0RERERERERERERERAQACNC7AGRckiSlAOgAIFXnohARERERERERERERkXz9AZQKIQY4+0YGjjQiSZIEYDqA+QBmABgJoBvqR32dAnAUwEYAXwghcvQqZysdQkNDO48YMaKz3gUhIiIiIiIiIiIiIiJ5jh8/jqqqKpfeKwkhFC4OtSZJ0iUAPgXQS8bq1QCeFUK8rW6pHJMkKXbixIkTY2Nj9S4KERERERERERERERHJNGnSJOzbt2+fEGKSs+/liCNtjETLoFESgB0A0gBUARgA4GIA3QGEAHhLkqSeQohHtC4oERERERERERERERH5LgaOtFMGYBGAL4UQR1q/KElSCID3AdzdsOhhSZJWCSE2aVdEIiIiIiIiIiIiIiLyZX56F8BH/AWgvxDiEWtBIwAQQlQLIe4B8Hezxf+nSemIiIiIiIiIiIiIiIjAwJEmhBCHhBBFMlf/sNm/Z6hRHiIiIiIiIiIiIiIiImsYODKelGb/7qJbKYiIiIiIiIiIiIiIyOcwcGQ8Uc3+na9bKYiIiIiIiIiIiIiIyOcwcGQ8Vzf79zbdSkFERERERERERERERD4nQO8C0GmSJI0CcFuzRZ9rtN9wAOFWXgq0WCxaFIGIiLxYelElvt2ThrzSGpw7qjvOG9VD7yIREREREREREZENDBwZhCRJ7QAsBxDYsOgXIcRmjXb/CID/WnshNzdXoyIQEZE3yimpxj8/24Wc0moAwE/7MvDSpaNw04z++haMiIiIiIiIiIisYqo6A5AkyQ/AMgDjGxZlALhTtwIREREpZNWhrKagUaMvdqTqUxgiIiIiIiIiInKII450JkmShPqUdJc3LCoFcJkQolC/UhEREbnnVEUtPtmUiMXbU9q8llJQAZPZggB/9l8hIiIiIiIiIjIaBo709zGAOxr+XQbgfCFErMZleAfAQivLV3fv3n2MxmUhIiIPV2e24LpF0YjLKbO5jtCwPEREREREREREJB8DRzqSJOkjAPc1/FkO4AIhxC6tyyGEKEN90KoFSZLq/PzYG5yIiJyzeFuK3aARAAhGjoiIiIiIiIiIDIlRAZ00BI3+r+HPCgAXCiF26FgkIiIit2WXVOGN1XEO17MwckREREREREREZEgccaQDSZI+BnB/w5+VAC4SQmzTsUhERESK+P1Alt5FICIiIiIiIiIiNzBwpDFJkj7B6fR0jUGjLToWiYiISDHvrIuXtR5HHBERERERERERGRNT1WnIStDoH0KIzfqViIiISFlCZkDIwrgREREREREREZEhMXCkERtBo006FomIiEhxcgcSccQREREREREREZExMVWdBiRJehqng0YAsAHAJEmSJsl4+w9CiHR1SkZERKQsuQEhxo2IiIiIiIiIiIyJgSNtDG3198UN/8kRA4CBIyIi8ghyU9DJTWlHRERERERERETaYqo6IiIi0hznOCIiIiIiIiIiMiaOONKAEOJWALfqXAwiIiLFWSwC1SYzwoKcq1I0prTLLa3Ge+vicTynDJP6dsIj5w5Fu2BWT4iIiIiIiIiI9MKWGSIiInLJ0h0p+GBDAkqrTZg9pCs+uHaC7PcKAdSYzLh2YTRSCioAAAfTi3EitxTf3DFdrSITEREREREREZEDTFVHRERETtuZVIDn/ziGU5V1MFsENp/Ix9O/HJb9fosQiEk91RQ0arQjsRAZpyqVLi4REREREREREcnEwBERERE5beHW5DbL/jyULfv92xIK8NHGBKuvrXJiO0REREREREREpCwGjoiIiMhpm0/ku/X+d9eegATJ6msN0x8REREREREREZEOOMcRERERaS6rpBpZJdVWX6uoMWlcGiIiIiIiIiIiasQRR0RERGQoH29KxLx3NuNIZoneRSEiIiIiIiIi8jkMHBEREZHhJOVX4KYlu1FntuhdFCIiIiIiIiIin8LAERERERnSqco6bIzL07sYREREREREREQ+hYEjIiIiMqydiQV6F4GIiIiIiIiIyKcwcERERESGJfQuABERERERERGRj2HgiIiIiAzLIhg6IiIiIiIiIiLSEgNHREREZFiMGxERERERERERaYuBIyIiIjIsCwNHRERERERERESaYuCIiIiIDIyRIyIiIiIiIiIiLTFwRERERIZlsehdAiIiIiIiIiIi3xKgdwGIiIiIbLHInOTIZLbgnXXx2HA8Fz0iQvF/cwdj6oDOKpeOiIiIiIiIiMj7MHBEREREhiV3jqMXVx3D17tOAgDic8uxN6UIq/51BgZFtlexdERERERERERE3oep6oiIiMiwiitrseF4LlIKKiBsjD4yW0RT0KhRVZ0Zvx3I0qKIRERERERERERehYEjIiIiMqwNcXm4/asYzH17M17967jV4FFJVZ3V9364IUHt4hEREREREREReR0GjoiIiMgjLNqWgsOZJW2W2xqJREREREREREREzmPgiIiIiDzG/zYltVnGsBERERERERERkXIC9C4AERERkVwxJ4ua/i2EgBCAhSOOiIiIiIiIiIgUw8AREREReQwh6gNGH29MxNfRJ2EyW3Dm0Ei9i0VERERERERE5DUYOCIiIiKPYRECj6w4iJ/3ZzYt++1Alo4lIiIiIiIiIiLyLpzjiIiIiDzGqcq6FkEjIiIiIiIiIiJSFgNHREREREREREREREREBICp6oiIFFVSWYcNcbkoqarD2cO7oV+XdnoXiYiIiIiIiIiIiEg2Bo6IiBRSUF6DaxdGIzGvHADw1poTWLpgKqYO6KxzyYiIiIiIiIiIiIjkYao6IiKFrIzNaAoaAUBlrRkfbkjQsUREREREREREREREzmHgiIhIIa//Hddm2fbEAh1KQkREREREREREROQaBo6IiIiIiIiIiIiIiIgIAANHRERERERERERERERE1ICBIyIiIiIiIiIiIiIiIgLAwBERERERERERERERERE1YOCIiIiIiIiIiIiIiIiIADBwRERERERERERERERERA0YOCIiIiIiIiIiIiIiIiIADBwRERERERERERERERFRAwaOiIiIiIiIiIiIiIiICAADR0REROSlggJYzSEiIiIiIiIichZbVIiIiMgrRYQG6l0EIiIiIiIiIiKPw8AREREReSUGjoiIiIiIiIiInMfAEREREXmlYKaqIyIiIiIiIiJyGltUiIiIyCtZhN4lICIiIiIiIiLyPAwcERERkVeyMHJEREREREREROQ0Bo6IiIjIK1kEA0dERERERERERM5i4IiIiIi8kpmBIyIiIiIiIiIipzFwRERERERERERERERERAAYOCIiUp3gqAciffDUIyIiIiIiIiJyGgNHREQqY9yIvJEk6V0Cx3jqERERERERERE5j4EjIiKVsfGavFG7oAC9i0BERERERERERCpgqw8RkZuEEJA8YfgFkYLCgvxRXmPSuxh2MU2kdUIIfLEjFeuO5aBnRCjunD0QI3t10LtYRKSx5PxyvP53HOJzyzB1QGc8c9FIRIQG6l0sIiIiIiIyAAaOiIhcJITA++sTsCImHQH+tgNH9Y3XDCyRd2kXHACU1ehdDLsYNrLu7bUn8MmmpKa/N8blYdUDZ6BP5zAdS0VEWiqvMeHahdHIa7iOpxZW4mRhJX64e4bOJSMiIiIiIiNgqjoiIhct3ZmKDzYkILukGulFVTbXY+M1eaOwIH+9i0AuEELg291pLZaVVNXhr8PZOpWIiPSwMS6vKWjUaHdKEdKLKnUqERERERERGQkDRxqSJKmrJEnnSZL0tCRJP0mSdFKSJNHsvzl6l5GI5PtkU6Ks9Zgti7xRaKDxA0c899oqqzHhVGVdm+Wv/R2nQ2mISC8LtyZZXb41IV/jkhARERERkRExVZ1GJEm6B8CnepeDiJRTUF4raz3BMUfkhTp4wDwYPPeIiIhIC/llNfhiRwqS8soxY1AX3DyjP/z9mKqaiIiIPBcDR9oJsbKsrGG58VvfiMhlHPVAREREnoB1FiLnVdaacP2iaCTklQMA1h7LRXxuOV67YozOJSMiIiJyHVPVaaccwBYA7wK4AcBwABEAsvQsFBERkSuEg9bFa6f00agktrEBtC0eEyIiImVFJxc2BY0arYxNR2WtSacSERERKc9RGwB5HwaONCKEWCyEmCOEeEQI8a0Q4oTgGUfkE3imk6/pEBKA168cq3cxeO4RETlJYmYtIqe9+MexNsvqzAJb4zlnGBEReb6k/HJc/dkuDH92Na76dCcScsv0LhJphIEjIiIicpq9mExIoL9m5SDnsFGYiOxhwJ3IeXVm6ycOzyciIvJ0JrMFNyzajT2pRagxWRBz8hSuX7wbtSaL3kUjDTBwRESkMmG3iZ3I+4QG1QeObps1QOeSEBGRNRIYRSZSG58AiIjI0+1IKkROaXWLZfllNdjCUbU+gYEjIiKVsbcheSN7v+vQhhFHV06KQrsg50Yf9e0c5k6xWmBG2LZ4SIiIiIiIiEiO9cdyrS5fczRH45KQHhg4IkiSFC5JUq/W/wEItFg49JDIXWynJV9z04x+AIBRvSLww90zcOP0vrLf+8i5Q9UqFhERERERERERyRCgdwHIEB4B8F9rL+TmWo8sU0slVXV4Y3UcYlNPYXjPcDx23jD07qRcr3nybBz1QN7I1q+6XZA/Lh7Xq+nv0VEReDlqDP5z0Uic+eYm5JXVWH1fkL8fbp3VH5eM64Xk/Ap8sCFBtTL6Ms5xRES+prrOjFf+PI6NcXmI6hSKf88fgpmDuupdLI9RXmPC4m3JOJJZigl9O+L2MwZwLkMiIiIfx2Yu38DAEZEC7vhqL/amngIAnMgtQ+zJU1j/8Fl8qCIAbLwm3/LtndPRISSwzfKQQH88eu4wPP7TIavvO/jfc5vmRrpv7iAkF1Tgz0NZkCQJZgvPIqWwgk9EvubpXw7j532ZAIDM4ios+HIv/n5wNgZGtte5ZMZnsQgs+HJP03PO+uO5iD15Cl/cOkXnkhEREZEW2PHQtzFVHZGbUgsqmh6mGmWcqsLOpAKdSkRGw4Za8kbWRtL1igjBuD4dbb7H3896rTM00L8paAQAwQH++Oi6Cdj/7Lk48Nw52P30PBfL6NLbvBuPCRH5kBqTuSlodHqZBStjM3QqkWc5nlPa5jlnY1we0osqdSoRERERGYHgg6VPYOCIAOAdAFFW/jvcvXt3PcvlEf4+Yn1CuMXbUjQuCRkW76fkIyQH3ZEC/K2/brER4YkIC0R4SCAiQtuOYJKDlVkiIt+WV2o9Per/NidpXBLP9NmWZKvLv9uTpnFJiIiIiEhrTFVHEEKUAShrvVySpDo/P8YWHWHDJBGRPH42AkuOrqJ6pP2srjNje0IBcsuqceaQSPTp7B3z1vGeRURaEkIgt7QG3cKD4Wdj1CkZl9lisb7cA4b0CiHw9a6TWHUoCxGhQbhtVn/MHMy5rYiIiIjkYuCISCXMA0qN2FBLVC/ARqOhtbR3rc0b3g0b4vKc2p+r7VoVNSbc2mxOh5BAPyy+eQrOGOL5DU4e0NZHRAZQUlmHTSfyUF1nxtzh3dC9Q4jT2zicUYJ7lscis7gKncIC8dZV4zB/JLMZeBJPvmcs3paCV/463vT31oR8rLxnBsb27qhfoYg83Ka4PHy4MQF5pTU4d1R3PHXBCAQFsLMxkTdj06Zv4xWeiEhlnvzQTWSLK79rW3McydnWbWcMsBl4ssXVU+/Pw9kt5nSorrPgrTVxLm7NWOwdk8pak2blICJjEgBySqpx6Sfb8e8fDuDJnw/j/Pe34nh2qVPbMVsEFizdi8ziKgDAqco63PtNLIoqalUoNWlN8oBmpK92pbb4u9ZkwY8x2s5txWcA8iZHs0pw17IY7E8rRmZxFb7ckYoXVx3Vu1hEpBfe43wCA0dERCrj/ZR8haORlrYCR7bmOGpu1uCu+P6u6a4Uy2kvrzrWZtnBjBLUmqyn7PEk9kZ3jX9hHd5YHSdrBBgReTZ71+tl0alILaxs+vtUZR0+2ZTo1PajkwtRUN5yfqE6s8CPMelObYfIVRmnqtosWxZ9UoeSEHmHFXvTUWduWUdcHp0Gi4X1RiJv5mgeY/JuDBwREamMjbDkjVxJwWg7cCTv/ZP7d8bVk3vL3p+rp15ptfWRNzUms2sb9BC1Zgs+3ZyEtcdy9S4KEanM3vXxk01JbZatOpTt1PaPZJZYXb75RL5T2yEiImP4apf1wKuJgSMiIq/FwBERkQyZxVVYdSgLiXllTgeCWJUmX+HqiCNnOHf6KXv2ecWIIxnrvLcuXvVyEJF3s3U/kDPCVEnsu0NaYGds8mVaX9eJiEg7AXoXgIjI6H7el4FHfjzY1Pjwr7MH4+Fzh8l+P+vS5I1c+V0H+bvfX0XPTo21Zi8IHMk4fnE5ZeoXhIh0pXZDt605cFgl8iysw8rD40S+jIEjIt/EM983MHCkIUmSVlpZHNns3y9IktQ6f8MKIcQKFYtFRHbUmMx4+pfDLR4IP9yYiCsnOZEui7dU8hGOJssODfJ3ex89IoJlr6v0c2xNnRcEjng9IiIN2AxM8RJERAYRl1OK3w9kwd9PwiXjemFI93C9i+SRzExVR0TktRg40taVDl4/08qyI2oUhIjkWX8sD9VWGosXb0vRoTRExuFKUCY00P3A0Y3T+1mdf8MapR9ja7wgVR0RkRZsTaSseao6O3eC25buxZBu7XHH7IGIDJffKYGoNaaq8zz7007hhsW7UVlbP3/l0h2p+O6u6RgdFaFzyTwP40ZEvolzefsGznFE5EFKq+uw7lguYk8WweQFKZM8QXZJldXlJ3KdSOXE+6mq6swWrIzNwPO/H8Wv+zPZ601HjhpOlBhx1DMiFHecMcDt7biixmTWZb+K4ulBRBrwhAFHG+Py8PnWZFy3KBqVtSa9i+NRGCghT7d0Z2pT0AgAympMWLbrpI4l8lwWPnsREXktjjjSkBCCVWxyWXxuGa5bGI3CiloAwMxBXbD4lskIC+JpbHTLd6fh4XOG6l0MrySEwL9/OIA/D2U3LduZVIA3rxqnY6l8gyspz5QYcQQAz1w0AvNGdMeRzBKUVNXh402JVtdztReUn2S996Q3jDjioz0R2eVm79GdSQXYkViALfGts2/X03zEkYzdJeaVY3dyEeYO76Z+gYjIEH47kNVm2Q8x6XjjqrE6lMazmTnqgIjIa3HEEZGHePWv401BIwDYmVSIn/dl6lgi3+ZMFPjTzYkcxquSlIKKFkEjAFgRk4Hc0mqdSuTbHJ0XSow4AupTIM0Y1AV3njkQ0wd2sbmeq2ddUID16pFXzHHESxGRRyqrrsO3u9Pw2t/HsTOpQO/iWLV0RwquX7Qbn2xKwpHMUqvraN0xXe7uXvrzmKrlIN/EeQXJF3DEEZF34yhj38bAEZGH2Hyibc/N//zKKbD04kz1uM4sUNQs6EfKWbzd+lxT3+5O07gkvseVAERIgDKBoxblUKFRJtDfevWo1uwFqeqIyONU1Jhw45I9ePqXw/h8SzKuX7Qby3al6l2sFswWgfc3JDhe0aDRazZ8kjvYqEa+TIsRRxaLwNGsEiTmlbNDJpFB8Ez0DcxxRUSkAbZHqKO0qs7qcs5VoA9bk6E38vOTMCiyHZLyK1osf+L84S7v096zo6vPlTbn5vCC85i9n4k8z5b4fBxML26x7MONibhxej+H111blG7nPpJZguJK6/fk5jJOWZ87koyJ9wwickTt+WWLKmpx4+LdOJZdP5J19pCuWHjTZMUyGRARkW0ccUREXulYVimWRZ9ETGqRKr2SyqoZmCDf5upZdcfsgS3+7to+GP8Y21Pzcri0Ly9oP/OGz0BkZGaLwLLok7j/2314f308iivdH3H8rJUR5vllNUjKL3d5m0pfCqrr5I3ILKyoVeSYyMWe6URE6rKonMn57bUnmoJGALAtoQBf7rSedYKIiJTFEUdE5HW+3JGCF/44nav+5hn98MIlo1zulWvN8WzrufttYQoLdbA5yFjk/Myvm9oXXdoFYc3RXHRtH4Rrp/ZFn85hLu/TXqOg0g2GWk/qrgbP/wRExvafX4/guz2n06WuO5aLn+6diZBA13tGF9pId1tr8swzemtCAS4Z10vvYrSgZB2RiMiXqJ2qzloK8jdXn8B9cwarul8iqicpPk6dPAlHHBF5IbNF4GB6MbYl5Ptcyq6qWjNe+zuuxbKvd51skxpLazuTCnXdv69hA5AG3HhGPHdUD7xz9Tg8deEIDOjaTrViuFpEW78fz2yiJSKtlFXX4ceY9BbLjmaVYm9qkSr7cyeNmNJ3SWfuu2+0qqcREZHn8oaOVUREZB0DR0RepqrWjJuW7Maln+zATUv2YN47W5BSoG/QREurj2aj1tR2vPxnW5J0KM1pD/9wgOlSyPt5ebzOG05hXoeI1LMxLg8mK3M9vK5SoMSd01npK4Ez15Zas8p5jZrhFU8dXn67JyInWDiZL5FXs9U3iI+VvoGBIyI3aXGxdOZh/Ie9aS1Gt2SXVPtUz87CcuvpXNIKK13anlLfr8kicKDVxNZEnswwE2arMOTIduXYIJ/ZDV7wEYgMy2S2foLJnf/HWZ7ay7udASc0ZyCE1PDLvky9i0CkOrVT1RERkX4YOCJSiZJ5QM1O9OJ5vtncPo1WH81RrCyeygiN3Lml1XoXwfvo/7VSM3o0vNnLjqR4j3qFt0dE3sXWNUKt9KnutNXpGSgJC9Juml22Z5KeNsTl6V0EItU501ZBRESeRdHAkSRJYyVJel6SpB8kSfpbkqSvJEm6V5Kk7i5s629JksySJPnWBC3kNZRsI2BdTD+cKscz8WtTn1Ea46YN6IKgAGX7wdj6/Xy9KxUlVXWK7ktrRvneiHyJWvckNU5nLS4R7YKNN+LIE1XWmrA9oQAncsq8YkQsEXkmi3bZR4mISGOKdPeSJKk9gIUArrHy8o0A3pYk6UMALwohqpzZtBLlI/J0npqKhFri10jeTq1e9faEBvnjn5N645vdaW1eU7ohLTq5CDcu3o3v75qOdsHa9ZgnIt/mJ1nvROSpwYJQDUccyeZhT50ncspww+JoFDSkaL5wTA98cO0EBPor25HCQ39imlMy0wSRp2GqOiLvZusOxzPfN7hda5ckqR2ADQAmo/73JHD6d9X4OwoF8DiASyRJulYIcdjd/RL5EiXqYkIIm4262xLyse5YLiLbB+Oqyb3RMyIUZotA7MlTSMovR0WNCceyS9E5LAjXTu2Dwd3CrW4nv6wGOxIL0DEsENMHdkFIoOf3KGU92NiMkILQVxnpyL946WjrgSMXt2cvAHY4swRb4vNx4ZieLm5dXzxniNSjViDHT5KsdiJSY0S6Fs3fgX5aNrJ75zXvv78faQoaAcBfh3Nw3qhsXDo+SpP9c0R+S/burfaewYi8AVPVEXm3v49w6gtfpkR3r7cBTMHpWrkEIAFAIYB+AJq3rIwAEC1J0tVCiD8V2DeRT1CiF4/ZIhDg3/ahZUVMOh5feajp7x9i0vHTvTPxxuo4/GxlQtef9mXg5/tmYUDXdi2WH84owQ2Lo1FafTq75AuXjMLZw7uhT+cwt8vvLiMEgAxQBN/B53Nd6HXY/f0kXDKuF34/mKXJ/v7z6xHPDRzJvBBtjMvF2cOdzjRM1EKNyYzdyUXIKanGrCFdEdUxVO8i6cLdNmNb71cjUOXqFp15n5Zt6Eao/ynNYhGITi5qs/zN1Sc0Cxx543FVixAMtJF3Y3YUIu+VW1qNzGJnEoeRt3FrLLskSf0B3InTzwpbAAwXQgwTQswUQkQBmAngD5wejRQK4GdJkqyltSMiK5SojNWZrW/j8y1JLf7OOFWFl1Ydsxo0AoBTlXX4dX/b195cE9ciaAQA//39KM56axNWHdKmMRfQJ1WWXKxTkzfxhBRJrhbR0VWkqKLWwRruqTGZ8eGGBNy4eDde/OMY8stqFNu23ENy97JYHM8uVWy/5Huq68y4fWkMbv5iDx7/6RDmvbMZOxML9C6WR7KVBsv4V2H9yT1Gxq09tlVnY0IRozXsCCGwdEcKLv14O65bGI3VXtxjmanqyJdZOOKIyGt9t6dtVg/yLe4mQb612TaiAZwjhIhvvoIQIloIcSmAmwBUor7+HghguSRJt7q5fyKfIBSYcLLW3HIjFouAyWxBUn5Fm3VXHcq2u60PNiS0WbYtwXpjkEUAz/12VPcKJauz3skDYhc+Rc+4rbV9N6aOKamsg8ks/0Kqd/z54R8O4t118dieWIAvdqTgukXRqK4za1qGOrPggwK5Zc3RHGxvFiiqrrPg1b+P61gi9al1S7I94kilHbrAucumdhdZb+wJb7LRGUxLcu6TX+86ief/OIaDGSXYlVyI+76JxQ4fDB7r/20RqYtzHBF5r7VHc22+5gkdScl97gaOZjf79wNCCJOtFYUQ36B+9FEm6utP/gAWS5J0r5tlIPJ6yow4qm80zSutxk1LdmP4c6tx7vtb3d6uHEUVtTiaZb/nemJeOe74ai9mv7kRD/9wAMWVrvXoN3J/P84toh32/FSf0X7N1r7x6joL/vnZTox7cS0mvLQOX+5I0bxcziqqqMVfR1oG7xPzyrE3tW1aIlc4U8H/etdJRfZJvum/vx9ts+xIZimqarUNgmrKxunl7j3Jz0YrvVv1Q4Uj5ExVpx13A0dFFbVYczQHJ3LKHN4T3NnT0p2pLf62CGB5tO/dV9iwRt7OxiBIIvICeneoJP25O8fR8Ib/pwkh9jlaWQhxWJKkmQDWAhiG+sDVx5IkBQsh3nezLEReS4lePI2Bozu/jsHBjBIAQLKV0UZqqay1GVdGRY0J1y2KbkrHlF6UibSiSqy8d6Zi+zfCQ5sBikCkGGu/ZyMG7PamngIAlFWb8MIfxzA6KgJT+nd28C79PsfqIzlWj+0bq+Mwe0ik29vnZYi0UlxZZ3V5ncWCUPhrXBrPpsqIIx+plMj9mEZOddyarVR1cuxILMDtX+1FdV39Nq6f1hcvXzoafn7OjhlzvH5KQdvnDF+cYNs3zjTyZRxxROSbeOb7BndHHHVC/W9FdhdeIUQG6kcqHWxYJAF4R5KkJ9wsC5HXUmLE0amKOqQWVDQFjbQWHhJo87VNJ/LazOERc/IUTha2fOA0mS0oqqhFrcn2A7MHPfeTAvicQo3kNvq1ntfNUzT/rQsh8N66eJzxxkbMe2czljnRg5vnjOcorzEh9mQRymtsd7zwRN78G7Q1stjduomtEUdG6BRjdN442tudEUdP/nyoKWgEAN/uTsMeF0a0euNxdQefP8iX6Z2SnojUw/sbuTviqFGQMysLIQolSZoLYA2AqagPHr3aMPLoRYXKROTxakxm7EwsxIH0Yre3deGH29AhRKlT3nn+dnoyLtpmPfa8+UQ+bpnZDgCwLSEfD35/AEUVtejXJQyvXTEGMwd1BQBU1ZoRGmS/97Kr1VklH4xZpdYOKzjqs/Z79oTjvv54nsN1jP45Fm9LaTHX3LO/HkHXdkG4YExPHUulP7NFYFdSIeJzyzB1QGeMjorQu0guW3UoCw/9cAB1ZoFAfwnvXTMe/xjbS+9ikU5sXZLcaqvT8UKn5Z69MbZW58Scfc0l5ZcjvaiqzfJ318Vjxd0z3C2WT7P3O/PG3yBRcwwkExF5L3dbkQsA9AbgdEuFEKJEkqT5AP4CcAbqnyH+K0lSoBDiWTfLReTxquvMuOOrmBYTS9uzM7EAL646Zned0mp1ei3L6fHqzqipqloz7lkWi4qGeRFOFlbi0RUH8d414/H0L4eRlF+B4T3C8f614w2YKOs09gzWXm5pNfanFWN4j3D079pO7+KQiox87jtDTkqqjzcltnl94bZkmYEj77wOWSwCj/14ED/vz2xa9uKlo3DzjP76FcpF5TWmpqARANSZBR764QDmDOuG9sH6dQAhHdm6LqhwPrtaVfH0Ko4n3UNMLkYMbaWPjD15yultGTE1rVGxUd03CSGw6lA29qYWYWj3cFw1qTdCAr0zTaunX/+JyDbe78ndp8841AeO+kuSFCmEyHfmzUKIckmSzgfwB4C5qK+zPy1JklMjmIi80dpjubKDRtklVViwdC9q7KRwU1p1nbmp8iunsuhO4GhHYkFT0KhRVkk1rlkY3fR3XE4ZblqyB/ecNcjl/ZDnsfcw/sfBLDz4/f6mHtkPzhuCh84ZqlHJfIDRnhK9vE7b/GiXVLVt/NufVixvOwb72pRyJKukRdAIAN74Ow7XTumLoAB3MzPLV1VrRnCAn9PzhTT3y/7MpqBRozqzwC/7M3HT9H7uFlF/XvobBNQ7v2z9mjz1fNZysJMzx8hsESisqEG38BD1CqQAk4sjjlzhqb8xrdn7TfMY+qaX/zyOJdtPZ9VYfSQHSxdMQYC/dnUSIiJ32a2z8f7mE9y9a+1r9u/zXNmAEKISwIWoT1vX6FEAc1wvFpHne/GPo7LX/XlfpqZBIwAY98Ja/LA3DYC8CTHjc8ua/i2EQH5ZDSwWgZ/3ZeCgjVR8jSN0tiXIi0nnl9Vgh8xgG3k3k9mCJ3861CKNzwcbEqxO1EzK8aTJxe3R81OovW9vrd9/tLHtKKyKWjO2xDvVp8llJZV1uOWLPRj9/BpMfXU9ljsx71Rrx7JKnVruaZTofS+EMMQo3vIaE5755TDmvbMZ9yyLRbKNe4y710ZbgUg1joCXXMabyP29JeSVY+JL6zD1lQ2Y/+4WJOeXq1wy17UOLMul1XdrtghNg1tERlNeY8JXO1NbLNueWKDbXMPu2pFYgKs/32XzdQPcjskH7U4uxKM/HsSjPx5EdHKh3sUh8lrujjjaCODxhn8vALDclY0IIWokSboEwAoAl6L+OYijjsinFZTXyl53aauKqRZqTBY88dNhTB/YBT0iHPfMfOiHg/D388OgyHa4d/k+pBVVyt5XRJj8y4GtSgMrtL5l04n8NqPUAGDJ9mS8fNkYHUrkfYx2SnnLMHrbqeqUOeKfbUlSZDtGk2qjwd7a6Cw1PPnzoaYgVUF5Lf7z6xEM6xGOKf07a7J/T+LuHNqfb0nC0p2pqDVZcMXEKDx1wQi3Rni5475v9mFrw/eelK9exwQ/GxcGd0Zz26JFfUnL67Uzn6fxepGYV457lsdi7UNnqVQq95gsygZl7N1fnAk2CSHw1poT+HZPGszunuhuMkJgmXzX34ezraaUfG9dPJbfMU2HErnur8PZuO+bfXbX4dlGWtuZWIBbvtzT1JHitwOZWLpgKmYN7qpzyYi8j7uBo20AKgCEAThLkqQRQojjrmxICFEnSdJVAL4BcDV4/yGSLb+sRrd9f7kjFU+cP1zWuq/+eRwCArml8srbeBFQutfiqYpaPPPrYUQnF2FwZHs8fdEIjO/TUdF9WMNnWPfsSCzA17tSUVlrxhUTo3D5hN42180ubjv5MwAczy6zutzb5JfVYM3RHFTWmjB/RHcMjGyvyX51Hamj4M69rcd9o8S8cvy8L9PxiuSUOrMFfx/JabN84dZkFwNH3n2zcCfY8duBTLz2d1zT34u2paBjWBDunztYiaI5Jbe0uilopDablyTv/qkowtVDFJ9bjsS8cgzups390xkujziysdze1pw5XZfvTsP/Nntn5wR3+Gr9P6WgAiti0lFcWYsLx/TE7CGRNtetrjMjOb8CQ7q3R6AXpHKrtpEJpLRam84sSvqiWbo9WxioJa19uyetxb2wzizw7Z40Bo5U4KWPxeQEtwJHQogqSZL+RH2gRwLwIoB/urE9syRJ1wOoAnCLO2UjIm1siMvFY+cNk7VuTmm1U9tuTMtTaWXkiC1yHorvXh6LPSlFAIA9FUW4afFubH5sDrq0D3aqfM7i5Liui0ktwq3NehVtSyhAnVn47MO4PZnFVbj6s13IbAievb8+Actun4pJ/ZQd+eDNx95bRi81tzOxANcv3q13MbyKEAIpBRU2R9CuO5arcYk8gzuBo082tU1J+MGGBF0CR86kxnX3imIrmK3GiCMtaDvHkevHKLWgwpCBI1c7VCmZTtbapt5fF6/Y9t1lpFPDF+v/JwsrcNWnO1FYUZ9B4/u96Xj/mvG4dHxUm3V/3peBJ38+jFqTBeEhAVh082RMH9hF6yKTDTEnTzlcx/d+4aS3VYey2yz781A2Prleh8J4Ozt1B1+8v/kiJbpz/AvAlIb/XnV3Y0IIixBiAYBrUJ/+7jZ3t0mkJr172Fh0TgWRXlQla44jV/wYmwGgvhea2xrKmFVc1RQ0alRWY7Ja+SDj+GlfRpsetiv2pttc31bjiN7nqxa+35PWFDQC6gOvn2rUA1jPkTpK7lrfz6H8zo9kluDWpXsV364nUOucrzNbcP+3+3D2O1tw65dKH1vvC1w2585XEp/bdt6ZWo3neNSD7Xua8vsqrlS/R7ymgSPtdqUZaymwjKAxSEAt+UDVs41f9me2+D0IYX3kSl5pNR758WDTdbys2oR7lsfqnupQLb74WyDyFJnFVTicUeK11x8iV7kdOBJC5AkhYhv+269EoRq2+6MQ4ishxFdKbZPIGxmht+n3e9JU23Z5jcmpwJGj3pT704qtLl+8PdnqcgMcXgLw3Z62QSI5PeBa84Wv86ONbXvkrz+ep/h+jNbDyGvSy9mc48j1Ta6MzXC5cd3W3EG+7rcDWfjrcNv0dMow1rmlNCPUW2ypqDFhT0oRiivtN4CnFVY6NVeju9cnW1M4uXMsbRVpRYztThmeyJ2f2/505+sZWqhTOIWzNzLuVcY3vL8+oc2ygxklbZYt353W5hwtrqzTLA2oWrylSiqXgW/rRA6ZLQIPrziAWa9vxMUfb8fZ72xGxin5dTwib+fuHEdEpDMj1NPeWnNCtW1X1ZqdmkjbVkX9YEYJ1h3LRZUSo5dcpEelWghhN5iWXVKFL7an4GRhJc4cGokbpvVVNJWJ2mwdUs/5BN7Fg346dnnJx2iydGeqy+89570t+N8Nk3DOyO7KFUgFWv/2Xv7zmLY79CJG7ci54Xgu7v1mH2pNFvhJwEuXjcYN0/q1WKey1oS7l8ViW4L8NHWA+79PWyMR1TiUmTbmCFTS3tRTuP/bfSitqsMl43rhn5P7qLg3d1IjJuHf84cabs4Vk405jlz9nbHRV13eenizS6rgJ0no3iHEpffHnjyFDze0DTAB9XMyzh3ezZ3i6cpbv3PbfO8Tk3sqakx4c3UcdqcUYUj3cDx67lD069JOl7L8cTCrxRywJwsr8d/fjmLJrVN0KY/ReNtzMTmPgSMiN+n9sGWEnruuTtIrh4BQ7DPe+XWMItvxBJtP5OH1v+OQVlSJMwZ3xVtXjUNEWGCLdUoq63D157uQXlTfSLT2WC7Siirx9IUj9CiysljDUZ0BLj0taDkvkZpBCtvztOlzwOvMAq/8eczwgSMt5JfV4Pk/jmL/yVOapPPyVkZMGVprsuDB7w80jcyzCOCZX45g/ojuLRpFP9uc5HTQSAm2rjlGOpTOXKPyy2rwZ0OK4G0JBaiuM+OmGf3VKZebx2hTXB7OHdVDmcIoxGSxPuIowNbQtAau3boM9CNzgpGuM0YqixIqa024d/k+bGkYFXTuyO748LoJCAn0l72Nr3am4r+/H7X5utFGtRtZVa0ZOxILUFRZi7OGRsoO5JVW1+Hn2AykFlZi9pCumDeivp5XXmNCWKA//BxcT5rzsp84aeC+b05fQ+JyyrA3pQjrHzkL7YO1b6J+9a/jbZZtiFM+W4ensvfcy3PfNzBwROThvP5iLbT5jLb2oWQDsVbfVWpBBe76Oha1DalM1h7LRfX3+/H1bVNbrLc5Pq8paNTo291peOy8YYbrXUueQcvgTZt9O7Hr6jqzUw0cWsgrrcbzfxxVMf2Z61ILK5FXWo1uLvYq9gZCCNzyxR4cyy7VuyhOKyyvwZqjuSivqcP8Ed0xMLK9ruUxYr1lY1wuymtMbZYvjz6JR84d1vT3h1ZSgWrBz+YFzoAH0wXf7E5TLXDk7gi3fWnFhgsc2eqw5e8ocMRONaqxd2i94yw97aONiU0NvkD9c8aircl4YN4QWe83mS14W8VsFUag1alWWl2Hm5bswcH0YgBAeHAAlt0xDeP7dLT7vqpaM25cvBuHGtIHLt2ZirvOHIgjmSWITi5ERGggHj53GG6a3s/udhp522/cF5VV12FHYgEACbMGd0F4SKDD97gqr7S6xTUEAHJKq7H5RB7+MbaXavu1WZ6yGs33CdQ/j0oSEBxgrGdSotYYOCJSidx0X0IIlNWY0MHFm7MRG2CUJABNJii0dRyVPL5afVU/xKQ3BY0abY3PR3FlLTqGBTUte3zloTbvLa8xIS67DGN6R6heTiXYDPhpWwyf5MnXnhUx6bjZTiOl1ukahRC4+Ys9iMsps7OOhgWywqx3ARxwpnhCCCTlV6BTWCC6tA+W9Z7j2WUaBo2U+/3lllbj6s934WRhfa7299Yl4KvbpmLqgM6K7cNZzowirq4z48MNCfWpTLqpF/BKyrc+l9eBhsY4d6kVVDdq2j9n2bv2OaOixoSdSYWorDXhzCGR6NQuyO3RHkYcLWJ7xJFynX4cpTo2OiN9awb8Cbnl081JbZa9sy5eduBoT0oRyqwE6pvztmOmlp9jM5qCRgBQVmPC22tOYPkd0+y+b1tCflPQqNHCrafn+z1VWYdnfz2CkT3DFS0vGVNWcRWuXRjdNHdj385h+P6u6ejVMVSV/W22MYfZhxsSdAkcaa3WZMGTPx/CqoPZ8PeTcO3UPnj2opFOjfLTkt2OEQa4VmcWV6GwvAajekU47EBDrmHgiEglQggcySyBRQibF7HdyYV4dOVBpBdVYVBkO3x03USM7NXBuf0Y6tFIeUIAJm9pGdGItQc6oH7UwPhmgaMak/dOruzJjR2eTM/D7sy+n/vtqN3AkcN9ufzOto5kluC7PWkOG071vgoq2SCpp9zSaty0ZDfic8sBANdP64uXLx3t8GFt7TEtR4Ip921/vye9KWgEAFV1ZnyyKRFTB0y18y51OXNL//f3B7D6aP2xjz15yuV9niyswNtr4xGfU4YpAzrhyQtGtEiHYvRbhq3Tzwjpio3gl/0Z+GrnyRaBvsjwYHx353S3zyYjHmNbI46UaC9JyC3Ds78dwdHMUozv2xH5Nnpit95VrRfXKUlZFbWO55s13lmnDKWf25//o+18i9sTHadTfcHK+6z5bEuy45WgXuOxEMLqaGBS1udbkpqCRgCQVlSJhVuT8fwlo1TZn80x1N564rfy8caE03MqmYEvd6RiYGR72SP8qJ7ZIvDYyoNNx7JP51B8e8d09OkcpnPJvA8DR0Qq2ZZQgG0J2wEAo6M6YPnt01qM9iivMWHB0r2obKg8J+VX4OYv9mD30/OcipT7QkzFbKNnpaex1Ws141QlYlJPYVBke4yO6uB20EOS3Kt4Gb0BzR3eXiEtqqjVbF/GO5Se98N9b108PrAxMbTReEsHrud+O9IUNALq03NOH9gFl4zzzh6O762Pb7OsdXoQrcltiC+qqG0KGrmjosaEaxdGI7ukGgBwIrcMJwsrsex2+z2yAePcM2yNWDJK+fT09a5UPPdb27lS8stq8OGGBFw3ta9b2zdb6ke+fbo5CbEnT2FYj3DcP3cwOrcLcvxmlZhsBI4CHKQZdjTyrcZkxnWLdqOgvD5Y5Mx8Xu+ua3ut0ZOhzg0jlYUI9WnB5Fh3LFfWemp0ZP3jYBZeXHXMZvCalPPVrpNtli3dmYqbZvTDqoP18xFeNLYnBis08ttWW4fRLpVqjby1lvb4ow0Jhg0cGbVD7qpDWacDcADSi6rw7G9HsHSBfp3jvJV3dB8lMrgjmaV4r9UD1V+Hs5uCRo0Kymsw5vk1OOFEyg53euB6AgHh1IgjR6kP9CQAWFp9llWHsnDWW5vx7x8O4OKPt+PZ346olhZF7nZtz6VgRNY/k0d9BIXklVXjqk936loGHzzsLssrq/aYoBFgvIc5uVo/7Kw52rYR5M3VcVoVhyD/XrRRoYmJt8TnNwWNGm1LKEBOs2Vqz8/m7j3JVuDWU89LJX0TnWbztd8PZrndoGkRAv/37X58sCEB2xMLsGR7Cq5fFI06s36dmmylqnO3/rYtvqApaOSsz7ZYH+1uRNcu3IXX/j6u2UgGb88OQW0Z/TlE6TTwSj+6JueX48Hv9zNopLPLPt6B99bH47318bj8kx04klni+E0y2B5xZKxrpZbF0WueJTncvZy1bv9Syut/t31+23xC385x3oqBIyKNfLXrJO74Kgal1XUAgI3HrTeIVNaace3CXbK3e8+yWEXKZ1Qb4/KQcapK9f1kFlfh/fXxqDG1DOYpeZt7fOUhjH5+De7/Zh/Ka0wwWwT+8+uRFpX35dFpOOxmpczdKbS9JCOVz/l5XyaSC6zP06EGo1XulXxId7QtJXpe2WvstEbv423EdE1KcXSPyS+rUeVBpLiyFtV1jlP2eBu5z49KndIfW+nZCQBb4h0HpozS4Guzd64Xn5dyrIhJx4lcB52t3DxEeWXVWH+8ZcA5LqdM145btlLVBTgYGuro1vXLgUz7K3gQe+dudHIRPt+SjNuX7tXkHErMK3e8kg+Rc2339Eubp5ffWUp/3OXRaT6RVcXomnfILasx4audqaruz2hfuTc/+zRXXWfGtoR87E4uVDTt7I8x6Zjz1iaMe3EtHv3xoOLPPK07hZF62DxIpKH1x3PxxMpDAOw3zp+qrJO9zSovb3R65pcjSNGoMfz99Qn413f7Vd1HZa0Zfx7OxuMrD2JPShGKrXzXH9lo5JLL3UZtzxpxZJ3nfwLnWet1ozkv+O0A2nwMZwPiuj+66F4AffywNw1TX13fYu4Ud1XUmLDgyz2Y8NI6jH1hLV5edczjAgA1JrPLPQjlPohreTlRe1/ubt7W+32lUQMASirr8MPeNHyyKRHHs0uxO7kQjzfUqe1x9wj9ddh6usTWmQS0ZGu0k7uTQjsKPHmb3SlFSG02B5xarl0YjQoDZ0Qg24QQOFVR63H3aK0pfXx+2Otc5yrSxo+xGYpsx1MeF30heJldUoXz39+Km5bswTULo3HFpztQXCk/9b2tThrRyYV4bOUhpBZWoqzahJWxGXhplby51ch4GDgi0tjfR3JQa7IYNleor1tzNBd5Zc3T16jjr8M5yLWRX1puPmlnya3Te1K7AZ/jqJGSP1u101YBxhnJIJdnlfY0dxozSqrq8NTPhxW/zrz613FsOpEPIeonlF+8PaVFjm5bjFBtqKo14/5v9mHM82sx5ZX1WLI9xeltyJ220JXPm1lchR9j0rErqRCmhsZ1d74+xb57d788G293J1ua0r+n9CL1GuBPVdTin5/vxBM/HcZba07gko+346Yle2S9V616gtKpnpxhcjJwVGuy2HxPi/c786MwwgXJDrnf+7e7287t4Qp7z3Umi8CmE8qk3iTt7E0twhlvbMKEl9bhzLc2YX+a/FGGBj89DI/tJN7N5tdrsIcNX+ic8+GGhBYdKI5kluKLVnV7V05Ha6PTvtmtTUCYgX7lMXBEpINqk9m5hzPS1NRXNuDZX48oOlTXmpIq2yPLVsSku7xd278sub28Pf+36Q2fwRPpedQ1HZ2gxEacrdPqXAf2xTr4ytgMVXobWntwkjOxvBG+gxf+OIo/D2ej1mRBYUUtXlp1DJudbBCVGzR1NoC7+UQe5r69GY+tPITrFkXj3m/2yb6P286371QRVGP0+QAKy2vwxE+H3dqGvRFsvx/MQnzu6XRfdWaBWplRs7Jq+aP4nWHW8djLTVVnMlvwzC+HMf7FtRj/4jq89vdxm9usrjM7N2LJIL89d2lVX1y6I1WT/XgCOYdcQKC8xoR1x3Kx4Xiu5iO2qmrNWPDlXmQW148OTy+qwq1f7lX92ZDIF9iq33nHXcV1esyd+N2etm1OH7bKfuNKh8q/j1gfra0FXxgppjVVAkeSJL0tSVKAGtsm8gZ+kuR2OglS17Lok3j5z2OqVmDsNfi07unhDFsPZPJHHHnvb9OX6xFKNzB6SZuRbjzt8Bl9hJQal63EPAdzpyiosXHK6L7f2/YBc+HW5KZ/ZxZXYfWRHLufR+61w5nvdMPx3DaNeuuO5WJLfL5XpC61OceRxuWwZYONeTudYS0QU2e24Hh2Kf77+1GXt3vvN/vcKZZNak32LIfJxrA9v1bPFp9tScI3u9NQWWtGeY0JOxILbW7zoR8OIMDfG84WY9Kibn0kswTf70nD8exS1fflDjmHIqu4Chd8sBV3fh2D27+KwcUfbbeZqUENfx3ORnmrYFVJVR02HHcvK4S31p299XOROmy3VRjrh6T1iKOJL63DzsQCTffpyKmKWuxJLVJse1p8x74wUkxrao04ehjATkmSBqq0fSKPZhGCQ9g9wNe7TspK7eEqe7e0uBz7DZb25pfQIs2WUdg6hkareBqBFodEz+uakr97R5/D1c9ZUlmHxLxyl36fNSZLizSaWvOGU8ro14Xj2aU4mF6sSQosJY/FzqT6xuhlu1Ix6/WNuGd5LGa9vtHm+mo80N3+VYzV5a/I7ABisxFDodCMapdGg/ykH//J8VxDjrT+XUQnF2LSS+twwQfb3N62Gky6pqqTN+LovfUJsrf595EclFY7MaqDDzJOUftwvbsuHv/4aDue/PkwLvhgGz7bkqTuDl0k996zPDoN6UWnOyAkF1Rg8bZkO+9Q1nYbjbe7U+Q1oPrSsxigfOci3zp61MggVZomWt/my6pNuHt5rC4jj6xJyC3DOe9tsbuOs1V6LZ5xGDhSnpqjgiYB2C9J0r1CiG9V3A+RxxHCyTzipJu316o3+bEr97SqWjMeW3kQa4/lol2QP+45axDuPmuQvP3JLpf+N1shBNKLqpCYX4aJfTs5/f5TleqkpvFkFiHgBwlC1Kf4CQ7wd2t7RhuBom2qOud2JoTAq38dx5LtKbAIYFBkO3RpH+zUNjKLqzD1lQ0Y16ejU+9TirG+bdc4/6yi7X1aywZyiwCUHFxQUlkne1SI3O9BiR76qYWVGNGzg8P1PLWRz2jXYXc0H0RjMltwz/JY5wIZGtN1jiMb+zZbBJLzy9G/Szv4+UlOlzE2Vf4cLkZngKpsC2qOOMotrcaHG1oGCd9cHYfrpvRFRFigavt1hUW4fr1dtC0Fz1w0UuESkRIUP98885ZMMtkcRW2w67YeAYiyahM2xuXhvFE9nHpfVa0ZhzKK0b9rO3TvEKJIWd5ZG4+C8lpFttXIZBFwswnCIaP9jryBWoGjuoZthwNYJknSOQDuF0KoN2sqkQcRQiDjlGekpSFjeeWvY1h1KBtA/WTHr/0dh4GR7XHOyO6nV3IzVZ3eeWGFEHhrzQn8b3N9b8mgANuDY40Q5FJCYXkN8spqMLhbewT6qzMY2CKA7/ak4f318ThVWYe5wyLxztXj0T5YuaqAtzznKf05NsblYdG20+knk/IrkJRf4dK2DqYXK1Qq5zh7rpVV1+GzLUk4lFGCcb074t45g9BOwd9aY288Z84XT79eKNnuaLYIRVPm/hibLvveIfdB3Aj9a5T6ybj7WWy9Xe/7tZKap6rblliAYoN3ANGzR6utfSfklePsd7aga/tgLLp5ktPbdeaSYIDT06P4qTiz9LJdJ9ssswhg5b4M3H7GAPV27AJPuQ+7+/s2WlA/vagSRzJLMKZ3BHp3CtO7OA7x+uLdbM7baLDzRqgw8EdOmtu47DKnAkexJ4tw6xd7UdaQXvP/5g7GI+cOdXsOv9VHlZ+nyN1ON8eySvHrgUy79xKOOFKeWoGjmQC+BzAI9deFmwFMlyTpWiHEQXc3LknSEADZQohyhysTGdCXO1KxK9l2nnHyDa7c0pZHt51UfdHW5KbAkcUi3J64ddmuVFTVmTGuT0dcM7kPAlQKZFiTXlSJV/483qKiYu/zOH0MDVaREELg9dVxWLQ1GRYBRHUMxZJbJ2N4D8c95J21O6UQT/18evLyNUdzEfLLYXxw7QSXtmewQ+n0Q+baozk418neXI1qzRaHDe8Wi8BHGxPxx6EsJOZ5fnXFme9bCIEFX+5FzMn63uvbEgrw8aZE/Hv+EFwyrhcGRraXtZ3Yk0XYnVKEod3CMWdYJAL8/WCxCLy46hhWxmYAAK6e3Af/uWiErO05+6xihMCFWlx5qLL3sJtcID8QKrfhUMtRQLa+67yyGgBAdZ0ZS3emalae1tydu9ATNG9MOOEgXa8R6DniyNH3XlBeg7uWxTq9XWcamYz+05PbAKlVIEPNEUdpRdb75uaUGK+TogAYFdDYF9tT8OKqY01/v3TpKMX34U33IlKfp9RpXKkrV9WasSU+D9kl1ThzaCQGtXrmkZPm1tnbxcMrDjYFjQDg402JmD+yO8ZrkKUiIa8ceaXV6CZzlJO1+SzlOpBejOsXRaOy1mx3PW/qVGUUqgSOhBCxkiRNAPAZgOsbFg8DEC1J0hNCiA/d3MXHAOZJkpQkhBjm5raINPfBBvk5x8l7KfWw2nzCwpf/PO72/r5q6Lm4IiYDu5OL8OF1tgMLuaXV2BKfj46hgThjSFeEBbl2WymtrsOqg9l4+pfDjlduZvOJfJf2ZxQ7Egvx+ZaWE8v/55cjWHnvTMX31Xw/jX47kIX3rxnvdo+kRkptR4t9v/Z3nM3AkZxtfbA+Hg+fa7sK8smmRLy3Xr1Ul3o6mlWCd9fGI6WgArMGd8XTF45AaNDpvAPxueVNQaPm3l+fgCXbUvD93dMxqldEi9cS88rx3Z40nKqoxfmjeyC1sAKv/hXX9Po/xvbEh9dOwJLtKS0a8L/YkYJeHeU9rDjbk9Gb27ZcafS297D3x4Es2duRu2u1LydyAlMpBRX4ZvdJrDuW69b9Zn9aMVbEpOOqib3hp+BIL3d657pSCiGEatf55nUUI/UWlSTrjVl6NkzIqc/lNwQ91VJebcIzvxzGxrg89OoYquq+vIGa9SNbv4Y6G3Nh6clAp7aqjJL+tLC8Bi/9eazFsuf/OGZjbdf5yNdKCrF1fhjt+uBsXaSixoRbvtjT9AwU5O+Hz26aiLOHn84MI6f+7Uw1MSG3DCcL23YeuHd5LHY9NU/+hlyUUlCBqa9uwNWTe+O1K8Y6zGZgduO+tGzXSYdBI8BYdUhvodocRw2jgW6UJGk9gI8AhAEIBvCeJEnzASwQQrg65KI3AD8Axhp7TT6JlyUyiqpaM5bvbpuuolHjb7XGZMbXO22v19zvB7Pw5AXDrTYKHEwvxo1LdqOsYQ6C0VEdsPz2aegYFoSMU5VYezQX/n4SzhvVAz0ibDfsbk8owO1f7UWNmyOlXCGEwJLtKVgWfRJ1JguumdIX/5o3WJEH/GNZpdiRWIA+ncMwZ1gkQgLbJvRdY2UIeMzJU0713JHL1kS/QrjWQOvp176UggrklVWjW7hrx/nDjYl2A0df7Up1sWTG1FgHzyurxvWLdqOkqj6NVHJBBfLLavDZTafTIn25I8XaJgAAZTUmLN2Rirf+Oa5p2cnCCvzzs51Nc5P9vD+zzftWHcrGqcpaRCe3nZj63XXxsvJ523uOuPSTHcgoqsRZwyLx8mWjERYU4NUjjlzp8WfvYbd5T0dH5KTpAJQL3B3PLrW6XG7Q5ZlfjihSjsdXHsKRzBK8eOlop9+rRiOL0a7hzX9fRnrml2D9WJks+k1erdbhqXViQu4vml3ns0uq1SiOW4z0GwKcawhUytKdqXj+EuVHl7jDaKmovN33e9PbnAtqjJbcmVSAihoTpg7o3GJeQZPZgopaMyJCnZtrS8+OaKQ+T/l6nT1T1hzNadFxrtZswZurT7QIHNXJqDs48/vPs9FJJLukGsn55bKzPLT22ZYkp9ZfEZOBGYO64PIJve2uJ2fElS0/7cuQtZ4aKQZ9nWqBo0ZCiKWSJO1Cfeq6xlaCiwAclCTpBiHEFme2J0nSLAAjUH8ee3ZXcyLyac4+1DrqYbotId9+WreGtz/w7X6sPZYre7/f70mz2kD+9toTTUEjADiSWYqVsRmYNbgrrlsU3TQ/wUcbE7Hi7ulWKy5CCDy84oAuQSMA+PVAZotRWu+tj0d+eTVevmyMW9v9ZX8GHl5xsOmYzx7SFYtvmYzgVrNBLou2HsBLKaiQHTgqq67DtgTrQSE5LELAT6EmWg95DmiiZsOS0pOJ6q2xseevQ9lNQaNGq4/moLS6Dh1C6hsGHPX0+jE2o0Xg6LcDWU1BI3t2JFrvb1RZa0aKjFRpFXaCG41zR/28LxPVdWb874ZJhukxrAa5wZtDGcX4+0gOUgsqMDoqwvEb5Ozbxq6FECirMTX9jrzRt7vT8Oh5w5z+jLbTumjbCOtqRwM5mgczjTQPip8kWb2mWSz1HV++3JGC0uo6XDyuF26a3k+TBk+1Dk94cIDqI5W8laNvXc1UdUY6XxwRwr264gfrE9AhNAAXjempeAcrLWj9VSW7OJ+ms37el4mf99V3+nn18jG4flpfLN6WjA/WJ6C81oRpAzrj0xsmoVO7IFnb85TAArnG5hxHBruWOTtyxVrmlLicMlTWmpqyssgZcePM73/ziTybr/1xMBsPzh9i83V7zwJvrI6z+Zot769PcBg40iLNL0ccKU/1wBEACCFOSJI0DcA7AO5HfdCnF4D1kiS9BuB5IWzHBSVJ6gRgPIB5De9vxHxfROSxnO115+hGK6enaHpRpVNBIwCoqrM+JNhasOLlP4/jiolRLSa1Liivwct/HscXt05ps/6B9GKbPWW0YC192/LoNAzv0QE3Tu/n0jaFEHj977gWD4fbEgqwI7GgqcdRakEF/vv7UZvbkHtMCsprcN3CaCS4MYeOnF/h/rRT+HZ3GirrzLh0XC+cO6qH4Sr3rjxkFpTXWB2pIndTR7NK2qRc81aNl58315yw+vrRzFLMGNTFpW2/u069lH6Nv1KLReC2pXtlveevwzmorDUZvuGius6M4AA/lxqq5Ty4rT2a02KelL+PKDNJrrVrx/60U3h4xUGkFFSgT+dQvH/NBKQUqtvg1TwwqFXvZpNFYPWRHFw9uY8i23PnKuxSqjo39udI8064b681TppPWz+NzOIq3LZ0b1Pda2/qKdSaLLhj9kDVy6RWo4iW17xDGcV4b108ThZV4swhkXjyguFWR2a7ylg1FM/rWGNUjSmAF25Nxs/3zUTPCJXSJLoZrDd6/UFNr/51HL07hbbomBedXISnfj7cYnQ6+S6bnWG0LYZDzt5qq+ust8U0r3PLGXEkt6PBVztTsWib7SwP762Ptxs4slcWV6oZjSnz0m3Muwe4N8eRXAwcKU+TwBEACCFqATwgSdI6AF8C6ATAH8AzAOZKknSdECJDkqS+qA8STWj2/+ZPV80zBnyjTemJiPTnaGivo3ZAAYHv96Y5vd+dSYV46udDCA7wx9WT+2Bkrw5212/scdbcxrg8/H4wC5eM69VieW6ptkGj1ocozsYE3C+tOoarJvV2qREjKb/c6ud6+c/jOHt4d9SZLbh+UTSy7KR2kVvh+SY6za2gkZx9HckswfWLdjcFEP88lI0Prh1vdV1Pe1B+/e84LLt9WtsXZH6Of3y0HW9eORb/bNYIXF5jwsurlM8fr7fGxhJbvxejfveN5T6SVYKDGSWy35ddUm3Yhr7C8ho8+P0B7EouRLfwYDx5wXBcOj7KqW2sP56LS8ZFtZibqjmLRbQIGimp9S+oxmTGrV/ubRrJll5UhQVf7kGwgo3IRlJtozMGAKyIScfSHamoNplx5cTeuG/OILtBLW9KVdd4bUmzkqtfT/bmiWndYWdZ9ElFAkfHskqx6UQeIsODcd6oHm3SPKn13eVolHJuefRJ/OfX0ykgk/MrEHOyCFP7d0F+eQ3OH9UDF43tafW9NSYzjmWVYkDXdugY1nb0QlWtGQu3JmOHjfS8rWkVNNZjjiMjqh+16P6xyC6pxsqYDDwwz3ajqDtspgdVZW/KU3M+OkfKa0y45cs9bZavPpoDs0U4nAMFYKDV+3nGN6xUAKL5VuR03IpJPYWPzQkY0j0cZw/vhkB/v7bbFAKfbEp0q1wmlebBiznZNq14I3fmOJJLzzkovZVmgaNGQojfJUkai/rUdbNQf9WYCeCIJEkm1AeUWmt9ZZEA/ARgsZplJSJSk7M3NXuBI4tFOO4FJ1ybKPdoVimOZtXPEbEyNgMr7p7hMHhkzXO/HcFFY3rKemDQW43JgjVHc5xujAWAqlrrvXca00XsSiq0GzRyRmPPS3c4+tmsjM1oM+psefRJwz08u5JWzFaKP7lbEqI++HRlswnv//XdfmyMs502wFP9EJOO66b0tXndat47zkgp3iyifl6mW7+UN9rIE/z7hwNNc5Zll1TjoR8OYGj38BbzCjjyxE+H8fWuk/jmjmlWG19f+eu4lXcpo/WD+IqYjDbpD0urTUC1/HmT3KXlL9bWg/raozl4fOWhpr/fWnMCIYH+uP0M21O6ap+qTkCto9XYmLJke9uRwJ7C2gTVzlp3LBf3Lo9tqvN9sT0FP9w1AxFhp4NHan3tFTImnVZC86BRoyOZpTiSWV/X/ONgFgrKR+GWmf1brBOTWoQFS/eirLp+ROhTFwxH9w4hWH0kB5HhwbhlZn88//tRp9L3anUOqVr1NVqFzA4BodgV5J118aoFjtylxc+qstb2PbIxrahenXpsff46swX+ftp1CqmuM2PJ9hTsO3kKo3p1wB1nDvTqdLieztF5czSrBC+vOo6EPOsdP+u3oVzQVI0AhJxgzfrjuVh/vD5DzPmjeuCTGya2aT9JL6pyO2tLnRPzGjrD3qCqc9/fgkvG9cLj5w9H1/bBNtc7mlWCPSlFGNItHDMGdXGq/choWVG8gSaBI0mSIlA/emhcw//HAxiJltUcR0+7GQAONPz3lxAiWtlSErmG1yVylbO9WEx2bu4jnlvtcJ4gsxBuP0CU15iwIibdpcl2iyvrsDe1CNMHupbOSmsPfn8AncKCcObQSKfe5+gY/yxjYkcth1g72tXSnaltlu1NPYWBke3aLNczYKDXw3FhRS1O5JZhRM8OKKqo9cqgEVCf1nHJthSbAWyjxoP/tzkRT/3cNue4HqrrzFh1KNutbZRamdPMIoBrF0bjwHPnOPWwfDSrFN/tSce9cwa1WG4yW/BjTLpb5bRnV1IhZg+pv64m5ZfjWSuNyN7MZOOJ+ssdqW2WfbYlyW7gqPF0FEKgtMrUIrjgyP60YtnrNlI1VV3DzSjjVJWKezG+99fHt7jOxuWUYdXhLNwwrXn6XO9/+PhqV2qLwJEQAg98t79pbk0hgFf/ajkHw9e7rM8baQSqznHkQb8HX3lutpWOSan5PdKLKnHdIsfNYUarmsn9/Eo1/P/ft/uw/nh9vXxDXB62JhTgp3tnekQnRm9mO1Wd7d9HSWUdbli8u0U6fGssAvBX6OuVOx+oI80vB85eA1cfzcGhjGJM6NtyfIWclHeOuNKhWA577RjVdRasiMnAwfQS/P3g7KaOl821HpV8+YQovNNsblzH+3euvORY2zFvCpEkaaAkSf+TJCkFQBGAjQDeA3AL6gNIjU82Ek7f00Sz/3YBeAzAOQAihRB9hRCXCCGeY9CIiLyBsxUHezd3R0EjoD4QosSzpbVAglynKmrdL4BC7AXiGt3xdQyyS5RtxLJWQWpNgbqgbC4HqbykUmbtocDZB8rGB+ED6acUKZNR2Rv1uHRnatOxPJQpPyWc2tKLXD9/lUzzYjJbcM/yWDz640G3tpNnI71nSVUdXvvb+YlsrU1+W1JVVz/iRyX/25yEA+nFAICfYh0H0rWgZeDZ1nm0K7mwzbL8ht6ktn6LAsCmuDxMf20Dxr24Fue+twWJbqYv1UvjdVSL/PdqumnJbtywOBq/H8xy+r1CiKYR3s0980vL4KqWdQS9NI7SbnQ4swTZGqXSU4Ofm60umcVVePD7/ej/5J/o/+Sf2HQiD0IImC3Co46LgHFT2yqlxmS22SHiRG4ZiisdPwsdzSrBJ5sS8cX2FDzw3X6c995W/Pv7/cgtrf+u31sfbzfIvnz3SeSVVRvuWF+/eDde++s4Shw0/ishq7iqKWjU6EB6MY4YqI7qq2z9LO3d/tcczXEYNAKU7Xyp2KaabceV8r23PqHtJhUonK2OTO6SU7QTuWU4kFHcZnmd2YLXWz3P/LI/E4edOG85x5HyVBlxJElSHwDbAXSH/Y4OpagfQbQfwEAAF6OhPoH64NISIcQGNcpIpBRPf8Al/Ti64f95KLtFjnd3b+5FFbXYnWI756wz8l0cGq33A0zzQ14tI9hWa7Lgx5gM/MuJVBiOPqOcIeqOritl1XX49/cHZJfJHkWvYDp+v67uuqLWhPCGtBXxuWX4729HEZ/rXMOrkhN6e6pVh7LRq2Mo7j1rEI5nt2349DQXfLANXdu1TeHmqoMZxdh8Il+BLdk+Y7/ckYIH5w1Bu2D3qvda1Gp+3Z+J8X064n+bkzTYm7E0D1bXmiyIy6mfr8UVa47kIOZkUVPvyvjccty2dC+2PDZHlfkt1KzyNj7oe3pP0cYRgTsSC+EvSTbn6rFG7mf3pBEm7miecijTYCPRhBCorrPYnCeuNXfOxxqTGVd/tguZxaePwYIv92JA13Y4VVkrqzHVKDw9hdChjBJYLMJuJ7DVR3LsbuPTLUl46oIRNl//63A2Hvhuf5vROSdyy7AruRA7njjb6nyyzT3321F8tjkJ/V28t6jlYHoxDqYX4/OtyYjqGIrhPcLx1IUjMLhb+xbrKXH3+jHGeseUTzcn4bObJimwB8/g6PeqB3udYWz5YkeKrG0rGTRQIwDhyjYzT7VNg6tEXUmtOY7k1lGW7zqJia1GUm1PKEB5TdvOax9tbBs8s4WBI+WpNeLo/wD0aLUsF8BqAK8B+CeAwUKIjkKIOUKIh4QQlwL4F4Ba1F8zwgAskiTpW0mSwlUqJ5HbPtwg/yJG1JyjG/7iVnn+lbi5N/bydteUV9a79D69Jmq1Ru7kjN/tSVN0v3J6IT++8hCe+vmw1fzlVbVmjHl+LTYolBLN1cqVt1TJKmrq53SoqjXjuoXRVnv9OxLYkBNB79/3a38dt5vzXm3Ldp3Ez/vtN2Z4ilqTRbG5yADgvXXK1BXsna51ZuFWqsTM4io8vvIgLvtkh8vbkGvpzlSkFlQ4XlEjWp65jaOHY1KLMPnldbjk4x0Y/+I6l7a1J7WoTV0irahSsXt9a2oGLBo/h1KpYYzg2z3OpU6T26guZ5S5N2h+ONS+vRZX1uJIZond0ehmi0BaYSVWxKRj6qsbMPr5NbhpyW5Zo+ndSVW3Nb6gRdCoUUpBhUcFjQD9A8MmswVb4vOxeJtrc6kdSC/G5Z/ubDMvX3Mv/2l/jsDPt9jf9ztrT9hM6ZZbWoP3rYw+sCarpBo7k5yv02ols7gKG+LycM3nu9o0FCtxvpttdLj0lU6/W+Pzcd57WzHiudVY8OUeFJa7Nx+OklwZcST3GcuZr3dXUiHmv7vF9rbkb8qu5nUnV66BSfkVbeoHSgRH1DoV5G7X2gj84irr99MUJ54ZfOQU15Racxxd2OzfmwH8nxDimKM3CSE+liRpG4DvAQxD/TXlGgBTJEm6TggRo0ZhiVylVJ5i8k2Obvit5x9QawJDLRknbKRMbmBrlJrn57s9aThVUdumV9y2BCVGLZzmcqY6K2/U8/t19SGz8WF17bEcFLqYSlGI+tFK/9uU6FohFPL51mQcyy7Fwpsm48VVx7A1Pr8pqKWFqjozXlrlsLrnk1wdpdmao9O11sUG5cpaE65duMut1H7Ounahb2aeNlsEhBC4/9t9TSkBHdUnnT2Lj2SWtMmHrwQ1H8Ybj4E39RTdkehco62cT26xCPx2wPk0eJ5Iq1/CB+sT8MGGeFgE0LV9ML66bQpG9YpAWmElfoxNR1m1CSGB/vh+b1qbQM22hAJZKUjduRM709Pa8IR+82GaLQIPrTiIP1xII9ncwfRifLYlCVdOjMLx7DKM79MRfTqHNb3uzv2+tLoOSfn2G0g/1rmuqbTCilqsO5aDyyf0dnkba4/m4I9D2QgPCcD1U/tidFSEgiVUnsUikF1ajZ4dQlQZDZRxqhJ3fB3TVCfcdCIf932zDz/cPUPxfbnC9jOb7au+3KO0ZHsKxvfpiOkDu9hNPV5YXoMFS/egus52vdmZ+kiOnc5mLat4rt3ZdiYVYuagLtgYl4fYk6cUCa6qVd+S20TqTFuqo+tiy/17Tz3SKNQKHPVq+H8VgCuFELKT/gshDkqSNBHAxwAWNCweBGCHJEnPCCHeVrao2pMkaSCAO1AfYOsLIARANoDdAJYLIf7SsXjkhCwrvb+I5HIm7rh0Rwqe/8PzG2TvWhaLoy+c15RKSesBGoczS5CYV47B3dqrFvhV8jOtPpqDsuo6hIcEYvWRbKyIyXBrRIE1rqYNUWtCTVe5OtqnMSD77W7XR5btTCrEC38cNUQv8G0JBbhhcTT2uTDxPRmfo4chVyd83pVUqGnQCABySo0zL4eWowVNFoF9acXItTFfVWt1ZovT95WqOrPd1404qqdpjiMDlk0rjm7HGacqsXibvHQ93sAiBPxVDjLsTytGzMnTTRUF5TV4ZMVBLLp5Mq74dCcKZPTS3xCXh6iOoXbXcadtuMJK2h5PpWeaxYMZxbKDRo6uuZ9uTsKnrVKtrnrgDLcDFnKzIXibz7cktwgcFZTL78j1y/4MPPTD6eDt7weysPJeYwRIrNmZVIB/fXcABeU16No+GB9fPwHTB3aBEPXzlfWMCHG7TvJjTEabjkS7U4qQV1qNbh1C3Nq2Emx9PPsjjuRt+601JwAAV0yMwttXjbMZmPtlf6bdoFF9eeSdj0II3LRkt6ztuFrF+d/mRGyJz8fCra6NlrRGrQCL3Ou8tWkYlCiSD1cjVaNWqrpOqA+lHnEmaNRICFElhLgdwPUAyhq2FQjgDUmS/pYkKVLR0mpIkqT7ARwB8BTq53HqBCAU9XM8XQfgT0mSfpEkqYN+pSQ5TGYLzn9/q97FIA8mpzJSUlWHvw9ne0XQqFHz9I56dAg5570tWBmbYXOCcncp3f4Yn1uO1UdycM/yfYoHjQDX1U+BSAAAiQJJREFUK1fWRsAZKBOhbPllNXjutyNuzf/1yaZEQwSNGnlC0OiVP4/hkJVJUb2VUo1ljq6ZjQ/IQggk5smfq6vxQZvUZ7ZYkF7UNl+9LeNfWIujWc7NG/bqX3F2Ozd9tSvVqe1p4fQcR777xG/vs686lIWz3tqMpTtTtSuQzloeDnUqGM2DRo3icsrw3rp4WUGjRmXV9lPG/XogCx+sT3ApRWdZteuBI2sp7tS2I7HA5mtqnN75ZTXYkVhgN30cANkp3lx19ee7UO0gaG9LelEllu1KxS9eku7XWXE5ZS6/9+tdLVOClteY8Mu+TNVClBaLsDoHixxVtWbc8VVM07WloLwGty/di80n8jDllQ2Y+fpGTH11A6JdSJvd3Ac2plJIcKJeqCZb14Hmi6tqzdgUl4ffD2ahyIWMED/vy7Rbd1oZa30OrObkPiMfzSq1e2ybb8fVOs6OxEKXU2zaolaARe521ZpjyZfrkWpRa8TRiwDGA3Arn44Q4ntJkvYA+A7AlIbF5wI4KEnSTUKIDW6VUmOSJN2D+pFUjQ6hft6nStQHkS5G/XdyGYBfJEm6QAjhWt4cUt0rfx1HRa1rlUMiQN7D09b4fNmTQXqKz7cm46kLbU8KqzYhgJdWHcMv983UfN/2HqbtWRGTrnBJTnN1xFGtwVInutqkdPMXe9zetx4NM55u0bYUfLXrJJYumOJ4ZWry3rp4u6/7SxKqas24a1kMtiW4dr3xRVoGvZ3ttOBqXfO9dfF465/jbL7mCjWfxS/5eAdeumw0e4ra8J9fj/jcaCw9G3+cna+vVEZw57318XhvfTx6dwrFF7dOwdDujqdxrjNbkOdG6rOvd6XiqQtGoLrOjEB/P5dHpcp1PLsUC5butfm6gLLX2y+2p+DFZily+3UJQ48OIRgTFYF/nzMU7YNPN3elFMhrNHe1XlxZa8bwZ1c7/b7Yk6dwyxd7XA5GeItakwVBAX5OB99ap3YH6p81Hzh7sNX13fn5rYhJxxt/x6GoshZT+nfGR9dNQHcnRvD8dTgbla3u6RW1Ztz65elzJr+sPpgU++w5CAn0d7qMsSdd7winFZuBo4YXSirrcMOSaBzJrA/8dGkX5DAwbM1HGxOw8ObJLpfT2j1ICIHc0hpEhgc3XU83n7DfsbN55zF3bmtKVwFcvdYptV1r9WEliqTW5/Jlqow4EkI8L4S4TAhxpwLbSgYwC0DzFHU9AKyRJOlVd7evFUmSBgH4oNmip4QQ44QQTwghXhBCXAFgKoDchtfPBvCI1uUkeYQQ+N1H8ouTeuQ8ED/982GrFWJvodcIlZKqOuzQYcLYGxbbHsZujxojjRq5Wgm1NiGzXnnrG3ZOHqbWZMHSHal6F0MTrs491NzRzBKsPZZrdx1/P+CLHSkMGjlJy8uHVo3/P9rpTSunkVsPz/56BLFWRoD4CnvVQmv3XF/iiSOabck4VYXrFkY7DBScLKzAdW7OBbc1vgD3f7sPY59fi0kvr8P/Nqs7P84v+zPt3u+EEIpeb19sNa/iycJK7E4pwuLtKbj1iz0tGhDltiUKoW1GhA83JPh80AgA1h+vr984Ezgq0fC6eCSzBI+vPITCiloIAexJKcK0VzfgzDc34VeZgebdKfKePStqzVh9JMelci7ZbvwOp7ZOr8bl3+1NawoaAfXzYLmSKSS10PkRns21zqR2IqcMc97ejOmvbcCEF9di1aH69kBH14vmryflG2PUF6DiiCOZG25eH258jxJF8rE+NppQa8SRooQQJgCPS5K0AcBXALqhPuj1BICn9SybE14EENTw72+FEK+3XkEIsV+SpJsBrGlY9KQkSZ8KIYo1KiPJVGcWLk+iTtTILOOpxNE8BeS6fJXm1/C0Ti565psnchQI8RaphfJTk9lyMKPE4Tp+kuR02rlcA801pKmG1svKWhOe/e2oZrs12vxwzuD9Ql1Mr9KSNx+PwopabDiei0vHR1l9PTm/HFd9tsulFE3NHc8uxfHs+gbY2koL3lx9AoMi2+O8UT3c2q4tjubfEIBmkfqYk6dwIL0YE/p2qt+3zJ/T5vg8/LTPcRorpWyJdytJj9dIaUjj6MxpP+GltSqVpi1bGUDSiirx0IoDGNC1Hcb16Wh3G850sNudUoTLJli/Ptjz12HXAk5asjUipHHx63/HKbQf995vaRF4Frjz6xikNaQaLq024cHvD2Biw/XFnmd+OYz8shpU11lwItf1tIxKUzr1HVAfDDqcKS+9ckF5DXYmFuDFVceQUlCBmYO6YNrALm6XwZvrDnpRa44jVQgh1qA+pdt6vcviDEmS2gO4ouFPgfogklVCiLUAGrsWdUB92joyGGsTuRE5S84EqGrNw6O3RVuTcfMXe/DAt/t1K0Oth+TVVXu49eGMEjz4/X5cvygaX+1MbbE/Z+ZIAfTtEazraCcig7jvm31Ov+ff3x/wuIC3Iho+8xsKNVDIZfbgOqQnB730csdXe2X3oOfRbcnbr0ut52Zp7oe96W4HjWxZss31EQnujp4VApr+0C//386mf8tNK3zb0hi1ikN2NI44aBx5JOs9dn5LSl8/ft5ne1SREMCXiqeWV/5EMco11eaII6MUsMH76xOaApqHM0uagkaNzBaB7/akOfym1h/Pw8GMEkMFjQ6mF9sdme6q+e9ukR14j8spw/WLdyMupww1Jgs2nchXJGjowdVsw/KowBEACCFyhRDnAngKgKd0xT8XQGPy00NCCEddQX9s9u/L1SkSuaOmjlcjct9iDxhKrpZX/jqOrfH5us6TU6fSvpWu877wxzHHK7nh9q9i8NuBLOxMKsR/fz+KDzfUpzH5bk8a5r+7RdV9K8mb0tgQucqVzga7kgsRn2ech1mtfWWn8VYNBpsezin70nw3jZyr1h/Pa9OrNzm/HB+sT8C76+KR0KwhyWiNZnpr3hHHG2/x9j7T5w5G7rhjT6rtOVCq68zYlpCPnYkFqDGdbmrZlpCPs9/ejBHPOT+HT3NCp3GLJ3J89x7nKcxCIKekGo+tPKTI9vJtzA2m1vPCrwpPY2Cv8bv5uWkEFovAkcwSHMkskZWmzOYcRwqXy93trT+ei8s+2YETOWU2ryGuphTU2/d701TZbmOgTU8ccaQ8j0hVZ40Q4g1JkjbpXQ6ZJjb793YZ629r9u8JCpeF3HAwvRhP/3IYR7PkDb8kIuPylMDR4UzH6amU9NmWJNx91kC88IfzqZsYvCFqae7bm/HmVWP1LoZDPvmMpdP1ypNHrb+95gTmDuumdzE8zttr4/F/Zw8BABzLKsW1C3c1zTO1ZFsyvrlzOsb36cgRR63weGgrr7Qa1y6MRnJDw9/wHuH45o5pMFkEbv8qRpG5+qDx/EGNlkWnar9TOywWAT8/SfZcIL7AIupH2inlhxjr21pzNBcP/XAAfTqF4rIJURgY2R6F5TXYm3oKfTqHYkSPDvDzU6eC4MxzkrUQ65HMEjz640GcyC3D8B4d8PY/x2JUrwhV9i9XSWUdbv5id1M65XG9I/DhdROwK6kQhRW1mD+iO4b1CG/1Lm0iR/Y6Y0gyD0ZJVR2+3X0So6KsH2dJAtZ5YNrt7xU814zGJ59pVOaxgSMAEELs0bsMMo1q9u8EGes3n7WyjyRJHYQQqkUqJEkKB9D6ag4AgRYPfrhVWmWtCTct2W3YCYWJyDmth5srpazasyewrqozY/iz7vUo1QNjVmREKQUVuHHxbr2LQdbo9GBpsujV5959OSU+Oh+WgpZFp7Z4lqioNWPpjhS8f+0ECD52tdD8eMht5PMkRvtIH29KbAoaAfVphBZuS0aHkEBlgkYAEvPL8eIq7eaUA+obj5dHq9O73lUvrjqG5y8ZpWvmBaMpKK/B7uRCTfb1y/76tHNf7EjFv+cPwTtr45vmFb5iQhTe+uc4+KsUPJKrMaYohEB+WQ0C/f3wj49O90E/nl2Km5bsQfRT8xAUoH0iqYLyGlTUmPDN7rQWc3AezCjBWW9tbvr7g/UJWHjzJMxp1ulEqxFH9jgzwverXSfRKyLE5utad/JUQkiAv9fOpc0RR8rz6MCRB2k++6TDhI9CiFOSJFUAaNewqDsANYe4PALgv9ZeyM31vOi5WnYnFzFoRORFNp+QNxmtnMeG4spalFWb0KdzGF5cpW5qOSPTc54hozXAEDWqUajBjZSnR2/vPw9le+yoHbOVh3GlGpR9xXd72vby/fVAVn3gyEMDimrx9uMhQWoaedKcWiPiHbE259LnW5LRp3OoYvu4beleVGuc8n3Gaxs13Z8c3+w+icfPHwYzRxw1+XZ3GgZFtnO8ooLKa0x4+c/jLZb9vD8Tl06IwllDIxXfn1MjjkR9isW7l8UgtdB6Z8eiilpsPpGHc0f1sPq6GkxmCx7/6ZDdOZ+aqzVb8OGGhJaBI7UK10pSfgUu+nAbbp3ZH/+c3AclVXXoEBKAilozSqqc6+iZ5WUdZ0KDvDdw9MfBLOSWViMowA9BAX7o16Udojoqdx/zRQwcaaP5aB65SR8rcTpwZG00EGns1wPybo5E5F2ySqrxwh9Hcfbwbpg9pOVDhMUi8NzvR/DN7jQIAYztHYE45lEnIjK8d9fF443V7k/C64pHfzyoy37d1bqRs6SqDjct4Yg6uRz1cGYn2Za8vU19T2oRRj+/Bj0iQvDoucNw4ZieAICnfz6seVm0ml9L66ARAOSUGq/Bt84ssDOxEBP6dtS7KIZSVWuMhuwPNyS4HDjKK63G7wezUFhRi/NG9cD4Ph2bXitzohOyRQjc8fVepBdV2V1vS3y+poGjFTEZsoNGjfalFbf42+aIIxWuQ0ezSvHYykOKzZ3lLUID/fUugmoWb09pMZf4o+cObUoXTK7Rfkyjb2oe3qyV+Z7mNZwwBctCLooIDdS7CESkky93pOKmJXuwPLplb8zfDmZieXRaUwX4UIbnDVVXklo5weXQc7QTEXmenNJqFFbIrZZ7JqVHVLXe3lc7U33+vifXir3pmPLKBrvrML1KS4/9eNBwk8ArrbLWjOT8Cvzft/twNKsEVbVm/BjrMEGJolbGZuDMt2xPHS23fpWYV65UkXyCQH0AiU4zyqiO2JOnXHpfbmk1rvxsJ17+8zg+3ZyEKz/diTVHcwDUj85ddShb9rZ+2Z/pMGikh9f+Pu54JQdsjSb1xLMhPtfY173z39+KTzcntQnKhQZ5b+CoNT1SOXobHkFtNL/iB8l8T/MkmupMxHHaOwCirPx3uHv37irv2nMwcERErSteb6+J17E0xqNzOnAiImqmdWq56joz7vgqxuXttY5DvbuO90C5Hv/pEArKa+yu44mNZmraEJeH1/+uHxXo7UE1iwCWR59EXI6a2enbikktwqM/HrTbQC03ZeB938QqVSyfEBTgp1taQrLP1fTXv7YK9pgtAp9uTsKRzBLMe3ezMoVrpc5sQXRyIfannYJJg9+TM6OmbLE94sjtTVMrcTlleGN1HD7bktxieUig74QCgvx957OqhanqtNE8b5HcxK3NRxmpmvdICFFmbR+SJNX5+fEkaxQewtOFyNdlFlcht7QGPSJCsD/tFDKLjdcTTE9+Ok40xDmOiIhaMpkFmmcj+XpXKtYfd33+Us7HoS42mrX15Y5U/PfiUZqlUtPTd3vSrc6Bpaaf9ik3usnoPe+NJjjAj3MgGpQQQF5ZNbqFhzheuZnX/m6b/vZAejGuWxiNshp15speEZOBFTH15/GArtrOEeUqd+oh5Jqvd6Xi3jmDmv7296EH56AA3xldpRZGBbSR0+zfvR2tLElSR7QMMPHKagAhXpwHlIjkqzNbkJhXjhsXc16H1vQcceQ71V8iInlMlpaNkq/+5d6cTq23R8qSO7LDF3Fghjq0DlTRacEccWRo1y2MRrlCwR61gkatpRTInU5de82D/78dyLK+DgQ7qKgku1UaSMmnAkcMe7iLR1Abx5r9W86sXIOb/TtDCKHtmHWyygc6uilmYGQ7LLllMib364R+XThFF3mX1/+Ow6pDWagwyASuRuJLlVAiIqM7lFGi6DxHbM9RF581bPP2VHXke/wkCbUccWRYSfkV2JFYoHcxFKXnZVRO/UEI4IU/jqpfGPKp9PIMHLmPube0sa/Zv2fJWH92s3/vV7gs5CKTlz8thwT6obpOucrrvBHdMW9E/RxZ897ZjKR84/aAIXLGn4ezgcN6l8KY9Bz2rlVvPiIiT3HD4t0Y3K09vrljGrp3cC7lDmmPsRHb0orUnvKXSFsCQE0dO6EZ2fO/H8V5o3roXQzF6BmArzGZERZkv/nZZBH4eV+mRiXybXqml9ca5zhyH4+gNtYAaBwbOE6SpKEO1r+q2b9/UadI5Cwle2wa0RtXjlVt29595IiokZ7T4q05kuN4JSIiH5OYV46X/zyudzHIgZLKOly3KFrvYhjWN9En9S6Cz0ov4nyeakgtqEAVA0eGVl5jwtqjOfhkU6LeRVGEnoGj+7/Z53CuOrNFKJYekGyrNVkQc/KU3sXQTFCA7wTJ1MLAkQaEEOUAfm34UwLwrK11JUmaD2Bmw59lzd5HOvP2EUdzhnXDQAcTKs4f0Q0bHjkLXy6YolGpiMiT6JmqrriqTrd9ExEZ2R8Hrc8nQMbxwqqjhp6fQk8Wi0BWq/kZiDzdv384gNfcnHeO1FVWbcJdy2Lx1poTehdFEbUmC4ora3XZ96YT+YjPLddl39TSIz8e1LsImgry51z17mLgSDvPAWhs1bpRkqTHWq8gSdI4AF83W/SGEMJ3QsEG5+25tSNCA/H93dNtvh77n/lYfMsUDIpsj8j2wfY31vpQ6XDoJvbtiK7tg3DFhCg8c+EI7QtA5IP0HPbOCYaJiLRRXWfGir3pehfDqzA9j22fbU3Suwhey5fmuTCiE7lleheBfMhdy2Ix/sV1uPrzXSgsr9F8/59v4bVcT9cvisazvx7xuc5EnOPIfZzjSCNCiARJkh4C8HHDojclSboBwGoAlQDGAbgYQGDD61sAvK15Qckmk9l7A0ejozoAALqFh+DmGf3w9a626SDCQwKb/u3o4muAuBF+vq/ldGKXT4xCXHYZbvpiN3PIE6lEzwaIOi++RhMRGUVBeQ2uXxTNnsOkmTdXe0dvfyIiI9iTUoSrPtuFTY/O0XS/zA6hr51JhdiZVKh3MTTHwJH7eAQ1JIT4BMC/0Gy+IwBPAHgBwBU4HTT6A8ClQgjtuwGQTWaLd/Zm95OA++YMbvr72il9EdCq9ffS8b1aXHBbv+6Io3y2SnvsvGFtlnVtH4wzhnRFp7AgTctC5Et8aaJNIiJf9PmWJAaNiLwEu9wQ+aaUggr0f/JPTVOkbozLw6/7ObqWtBXkz7CHuzjiSGNCiI8kSfoLwJ0ALgDQF0AIgBwAuwEsE0L8qWMRyQazlw1TefYfI5FfVoNzRnbHpH6dmpaP7NUBn9wwEe+ti0d2STXmDe+GVy4f0+K9gQa++EZ1DMUVE6Nsvs6UDETqYdyIiMiY3lytzFwai7alKLIdItKflz3eEpGT5r69WdP9PbTigKb7I+KII/cxcKQDIUQSgCcb/iMPYbJ4T8365hn9cPsZA2y+ft6oHjhvVA8IIaxOdt8jIgQRoYEokTnc2J0j17dzGNKKKu2uc+XE3ujeIRgdwwJxybgo9IgIsbM2W7aJ1MIRR0RExvS/zZxbgIiIiPTDYDVpzdlsSdQWA0dEMlm8JHA0sGs73D93sOMVAatBI6B+xNGtM/vjgw0JVl9vnZrOnQrC6n/Pxu6UIgT4SVh9JAff7E5rs84/xvXE3GHdZG1vcLd2KNBhMkgiX6BnteysoZHYEp+vYwmIiIiIiIiIyAj8GThyG8dsEcnkDSOOPrh2PP56cDa6d7A3Ikeeh84ZipcvG231tacvHOH29huFBQVg7rBumD0kEvecNajN6x1CAjB7cFfZ23v03LbzHxGR57t+Wl+9i0BEREREREREBuDHwJHbGDgikskbRhydOSQSIYH+im3vxun98I+xPVss69M5FDNbBXKEQlOv9ukchmf/MbLp7+AAP3x43QQEODHn0oS+ndqUmYg838ieHfQuAhEREREREREZgD9T6buNqeqIZDLCiKPO7YLQuV0QEvPKXXp/u2DlT/l3rh6HgV3bITq5CIO7t8f9cwejvQr7aXT7GQNw2fheiM8tx9jeEU5/Jn8/Ce9fMx7XTOmDxLxyvPDHMZVKSkRaYp2QiIiIyLHKWhPCgtgURERE3s2Pw2XcxtoCkUwWA8zkJ4SAqyMtLxrbE0EByl81gwP88bCD9G9KH7ou7YMxo32wy+8P8PfD7CGRmD0kEhvj8rAtoUDB0hGRHvwYOSIiIiJy6PalMfj2zml6F4OIiEhVHHHkPsbeiGQymQ0QOAIguTD9/IVjeuCNK8cqXyAv8DqPC5FX4MSXRERERI7tSi5EXE6Z3sUgIiJSFdsI3McRR0QyVdWZ9S4CAMDswvCd/90wSYWSyGeAwVo2RXUM1bsIRKQAdiYiIiIikmfJ9hS9i0BERKQqPwaO3MYRR0QyVdbqHzgSwhgp85TGazkRuYup6oiIiIjkWRmboXcRiIiIVMU2AvcxcEQkU0WNSe8iAAAsFu8KHJ09vBsW3TxZ72IQkYdjpZCIiIiIiIiIAM5xpASmqiOSyRgjjoTTqerOGdldpdIoY8ktkyHxYk5EbuLIRSIiIiIiIiICAD8Ol3EbDyGRTBW1+o84EgAsFvnr+0nAdVP7qFYeuYSdYBeDRkTeQ8/TmdcSIiIiIiIiIgI44kgJHHFEJEN1nRm5JdV6FwNwMMdR8qsXYkdSAX7Ymw6LEPjnpD6YO7ybhgW0zruS6xGRLXpOwcYRR0REREREREQEAP5sJHAbA0dEMmyJz0eFEVLVATDbmeNIkoDZQyIxe0ikdoWSwVZj8pT+nbQtCBF5Lc5xRERERERERESSxKwkSmCqOiIZVh3K1rsIAOpTvj10zlCbrxv1oihsjDm6c/ZAjUtCRN6KvYmIjCOA5yMREREREemEaeqUwcARkQyT+nbE6KgOim836dULMWeYc6ODzhnZXfFy6MWogS4i8jy8nJCn6tIuSO8iKI7nIxERERER6cWPHdkUwcARkQy3zhqAVQ/MxsuXjVZ0u/5+Eh6cN0T2+gJA1/bB+Oek3m1eG9s7QsGSKevisb2sLh8Y2a7p3/ecNajN609eMFy1MjUX1TFUk/0QkXrUSFXHxm/SQqC/91XHzxpqrJS5RERERETkOzjiSBne96RKpKLrpva1uvzyCVEub3Ns746yG1ga5wp6+sIRGNq9fdPyQH8JD823ncJObzfN6Ndm4vqh3dtjUOTpz/DgvCGYN7wbgPrG2ovH9cJtswZoUr5/zRusyX6ISD1qBI5W3jNT8W16o6AAPwzu1t7ximSVv59ktUOIJ7txej+9i0BELvj9/2bpXQQiIiIitzGVvTIYOCJygr+fhN/ub/lAFREaiNevHOPWNj+/aRLevGqsw3Ub5wrq1C4IP94zE29eORaPnTcMqx6YjbkNQRcj6telHd67ZjwiQgMBAIO7tcdnN05qsU5okD+W3DoFe5+Zj33/OQcfXTcBQQHaXKKuntwHd84egNBAf032R0TKU6NeOKlfJ+U36oUemDsYP949Q+9ieCx/PwmPn6/NCFut9O4UhlcvH8O5jog8zIieHfDTvbyeExERkWfjY4gyAvQuAJGnGdenI1JeuxBZJdXo2j4IwQHuBxtCAv1x9eQ+eHzlIbvrNY44AuoDVldP6eP2vrVy6fgo/GNsLxRW1KBbeIjN9SLDgzUsVT1JkvDMRSPx6HnDMOw/qzXfP5Ga+nQORXpRld7FUB3nTNOPn5+ETu2CMLxHOOJyyvQujscJ8JN0ufep7fppfXHZhF5IKajARR9u17s4RCSDnyRhXO+OeheDiIiIyC0ccaQMjjgicoEkSYjqGCoraLTt8bmK7Xd0lHHnMZLD30+yGzTSmxJBQCKjuXZKX/xyH1OuuWpY93C9i2B4jaNKzh3VQ+eSeCZPeqiZMbCLU+uHBQVgVC/PrrsQ+RI/CQjwwnnXiIiIyLd40jOWkbFWSKSyAH/lLlaPnGvceYyIyJgkCZjQV5uUa2rMM6S3x84bpncRDK/xe5/Qp6O+BfFQ7UM8IwFAoL+Eu88aKHNt4XgVIjIcjt4lIiIib2Dh44giGDgiUpm/Qg9gl47vhWkDnOvpS+q6bHwvvYvg8bq2D/KJER3PXzxSt31L0K4RaMqAzprtSytnDOmqdxFUN6JnB7fe3zj/3uwhXdG5XZASRfIpHUIC9S6CQ/fOGYSf7p2JOcOMO58i+Z55Bp7f0xOdN6q73kUgIiIiUkRRRa3eRfAKDBwRqczPieGRL146yuZr7149nkMtDeaNq8bqXQSPt+WxuRjRU73A0cZHzlJt287Qs7dLY+xaiwa22V4YZPH26+6TFwzHT/fOwPwRrv8+zJb6/wf4++GLW6egV4RxU5IaUYdQYweOLhnXC0+cPxxjPXzek4Fd2+ldBFLYklun4MBz5+DoC+fpXRSv8MrlY5r+PTrKvQ4FRERERNbcfdZArH/4TDx8jroZldihURkMHBGpzJnUTZeMsz2CxdsbLz0R50Rq64qJURjXW/58Fu2CA1RNaDQwsj02PzpHxT3IY9YxctR45XhUg5Rr3Tt4X8DA3SvvnbMHKFIOtVwyrhfCggIwf4TrPc0t4vTve3yfjtjx5NmIfmoeXm3WCEm2XTSmp95FsMuVgdMRocZ7UPPGwDYBHcOC0C44wCdGL6uta/vgpn+r3ZhDREREvumeMwdhcLdw/GveEAQqOLVHa1W1ZtW27UsYOCJSmTOp6jqGGa+hxddcMNq5yd2vn9ZXpZJ4pnevHo9ld0yTte5/nUjfFhke7HglG/oboJe5ScfAUWPQ2d10ZI5M89A0dQEOgvLuztt09eQ+6ODEHDbBAdpVza6a1Bu9Ooa6vZ3WgVFJktAjIgRXTIzCmUMj3d6+s2YO8py0rl3bB2OeG6O9tODsGTAmKsLpa/YDZw92ci/Oq2Oic6/WPIBN7psz1NjXJSIiIvJMzbMyqVl9e+rC4ept3IcwcESkkJcvG91mWe9OoegQ6hmTXlO9q6f0cWr9/148EjdM64uu7YMxsmcHRCnQCOvp5DS0dwgJwIVO9LJf9cAZ7hRJd2aLRbd9X6LRXFxBGgY8XNE+2Pq1uGNYEHpYGSn1UkPqUHenqRvSPRwr752Ju84ciOum9sG3d0zDrTP721xfq3nJzx7ezep9q7XhPcJx95kD7a5jKzAaEuiPL2+dgol9O7pSRNma91T717whePKC4R4xSnds7wh8e+c0BPob+9xxRs+IELx3zbg2ywfYCeDfOrM/endS/95pNjOw4M347SrLz0/CTdP76V0MIiIi8jLNO26qWX+7YRrrMUpgizaRQs4f3QOfb01CelFV07I7Zw+EpFUrICkiLNC59HPBAf545fIxTXnhX151DIu3p6hRNI9h7xc/rHs4+nUJw4PzhzSlNZPTy8TTOxIXlOszMeN5o7qjW7g26eO0HCnjihcvHYWHVxxss3zmoC4Y1asDXvs7rmlZjw4hOG9U/ehDJa7hQ7uH4+kLRzT9PWNQFyzdmWp13U5hQcguqXZ7n7Y8ecFwXDq+F3pGyGuolyQJIQ6uixY7Izn8/SRMG9gF+9KKnSmmbFP6d8JnN07CgfRiDOkWjr5dwgAAi2+ZjAVf7lVln0r5/f88IyAu9xz4+8HZGNY93Orcjs9cOAJ3fB3TZvlXt03FmUO64seYDLfL6cjo3hH4ISZd9f2QPoSnVxQMKCTQ2Pd1IiIi8jxadfDzgH6EHoG1QSKFdG0fjB/vnomH5g/FtVP6YNHNk3GLnV7lZEwM9LnP3oijNQ+diYU3T8aoXvLnQQKAjmHGnjzeEa1+Vv26hOHeOYMwd1gkHj13KD68boI2OwZw3VT90zaOtJGO76IxPXH5hCirIwLvPmsg7j5rED64djwuGdcLd585ED/eMwPdVJyvyd515oVLRqm2X6B+RIi1oJG9JldHzbFmBw22zgbknSEE0KV9MOaN6N4UNAKAucO64evbpqq2X2prRM8OVoNGADB7aFecPfx06qsAPwmf3TgJZw2NhCRJql8jA/wkXDLWtdGX7YL8cd+cQXbnoST9MW4kz5tXjpW9bliQ9/cx1bLar8XISm8kScC/5w/hJOc6+/SGiXjifKZ9IiL3uZsKXi627SnD+2uDRBrqERGCB+cP0bsYpIFxfTrqXYQmQ7q1R0Jeud7FaKL0/fmC0T0cjngwunNGdseXO1JV38/Ll43G7CHazykDQLf9NnfNlD747+9HWyxbMKs//nPRSEiShPevHY8FX+5FeY0JQP3k341BzEvHR+HS8VGal7m1M4Z0xZioCBzOLFFl+306hzleqRk5p7O9EUcAEBqk3vlrb16TM4dG4v1rxuPfPxxQbf++QIlLenCAPz67cRJ2JRcivagSswZ3bZG+Ts0HyAA/Ce9cPc6l1MFxL50PoD7t4gPf7Ve6aKQgX44bhQb6I8BPQlnDvc2eq6f0weM/HZK13XbBnl33kuP9a8bj442JKCivwanKOlX3de7IHvhih29nJXDW5ROicNOMfpjYtxNMZoGPNyXqXSSfde6oHvD3k1BjMuP99QlNyzu3C0JRhT6ZFYjIM/m3mOPIl2twnoGBIyKiZuS2Xd0603q+1En9Ommaqm5Ezw6GG4KrZPtf/y5hePMq+b1jjeifk3pjUr9OGNY9HCdyy1TbzyXjemHGwC5211kwq79qASwjzHF0y8z+CA7wwx+HstAhJBC3zOyP6c2OyZT+nRHzn/k4lFGCAV3bITI8WMfSWhcWFIDld0zDD3vT8OpfcY7f4ITuHYIxQYWgt9lB4MjW/FJKcPSocdmEKPSICMG1C6NVKwPJExTgh7OGWg8w+6l0+ejSLgibH5uD8BDXRq0277RgL0hJ+vPl7+fqyb3x3MWj8P3eNDzzyxGb6/27oXPbY+cNw1trTrR47YoJbTtOtFPx2m0UjZ1GhBC4/H87cSC9WLV9NZ+Pjxx79+pxuGJib72L4bTrp/XFt7vT9C6G4hobeh+cNwRd2wdjw/Fc9IgIxW2z+uOc97ZqXp6f75uJzFNVmNSvE2a+vlHz/ROR65q3X/lu7c1zeH9tkMjDXDC6B/4+ktNi2bxm6V1IXfYe6W6d2R+lVXW4aGxPzBvR3eo680Z0R4eQAJRWO+71qYTQQD/Umi2a7EsuZ3uO26ssfHz9RJcb/IzivrmDERzgj2W3T8XUVzcoss3f7p+Fsb0jkFtag90phejbOQxje3d0mC/4tlkDVAkcjeplPUWcHq6d2hfX2kmbFxLoj6kDOmtYIusGdm2H5IKKFsvmj6i/1keEBuKuMwfhjjMG4mhWKTJOVeKVv44j41SVtU3J0jEsEP+7YZJLQ/YdvcNRqjo1RxzJaSue2r8zuoUHI6+spsXyG6b1xTce3Lhz4LlzMP7FdervSIO2TmfuG8/9YyTmj+iOu5fH4nh2qd1137l6nGL3EPaINDZfDhxZRH2j7mXjo+wGjq6YUN8If/OMflh/PBf7G+ae69M5FA+fO7TN+p3CfCc1mCRJGNKtvaqBI63mdPAW3VVMGayWHU+ejaiOoYYMHK164Az846Ptbm9HkiTcOL0fbpyu36TzQQF+mNi3Eyb27eRw1Dv5ru4dgpFbWuN4RdIcU8h5Fv27BxNRC1dP7tMiAi9J9emXSF+B/hKev2QU3r1mvM2gEVBfkf3i1imalSsk0B+SFq16TjBWafS16oEzmtIxdesQgmHdw2W9LzjAD7ueOtvm6/5+EiRJQo+IEFw6PgoT+naS1SDRp3OYKvNFnTeqh+LbNJKLxvZUfJsLZvVvs+yGaS0fwv38JIzpHYELxvREl/bujY6KeWY+JvXr5NJ7Hc5x5OChfVBke5f2K4ecxnw/Pwn/u2Fi028/yN8Pr14+BvecNajNuqEelBYzOECbsmpxj3HmAXJwt/Yt5rOy5uJxvfD1bVMxZ5hyHW8sxuqjQa34cNyoKWhmb4TQj/fMaDpvwkMC8ePdM/DTvTOx/PZpWPfQWejdqe05NWdYJIINMJrYW3Qz4ChnI+vfLJ0pAAgP6JdubS5No+jbJQy3zRqgdzEUx/Znau3s4d1wy4x+WHH3DL2Lopk5wyIxJsq5OaSNwpfrb56CI46IDGbu8G5YeNNk/BCTDotF4J+T++BcL2+UNRIlKp+T+2s3miE00L9pvhajcHbE0RUTo/DHwSyrr3lyReKC0T0wulUFztHIjEa3zuqPnhHqPHz2ighFscJ5/L39me3lS0cjv6wGe1KKFNvmjdP7wWQR+GlfBkIC/HHzzP6Ya2d0qbvHOMDffuOfrcaOCX07Otz2nGH257ca2bMDencKdWvElC1yLxGT+3dGzDPzkZBXjn5dwpomfX/g7MH4aGP9nAl+EvDMRSPw8cZE5JRWK1K+m2f0w9e7TiqyrdbsXWrvnzsIY6IiEBEahOsWuZemT4tGGVc64tt6yxtXjsE1U2yPOnSVL49o8QS+/PXI+ej9u7RshA/w93PYmSAsKAALZg3AZ1uSmpZN7NsRkiQh9uQpV4rq0y4c0xPP/3FM72J4hNFRHQwdhPFEfpKEZ/8xwivm2WrZydbbn0LIWVp24jWKpQum4obFTMtN6mDgiMiA5o/sjvkjbY9qIfV0aWe9N+CswV01Lok8IUH+mleY/zG2J1Ydyrb5urPFmTVI3rHt2j4YBeVth5uPiYrA4cwS53aqAWvHwVY6hVcuH42aOgsS88sxfWAXXOxghIs7DWTBgcr3Hvb2Z7ZO7YKw4u4Z+GRTYpt5IVwlSRIWzBqABTJ7f7pzjO8+c6DDdWYN7oqOYYFtgoq3nzEAvx6wHtgF6ueQmT3EfuDIz0/Cm1eOxfWLd8srsBOcacwP8PfDiJ4t0yo+fM5QXDyuF45llWJcn44Y0LUdBIBnf7Wd7mlcn444KCOd0Wc3TkLfzmGqBY7sjTJ87LzhAIBdSYWq7FtpRhs5a40vZMP519mDcdOM/pjyynrN933xuF42O5HIoVYqwfvmDMItM/tjmkKpZtUga+Sli6fYE+cPw6heHRCdXIjB3drjqkm9cfeyWNc2ZnBqn+JhPjBnlFJeuGRUm2VGCQ77+0kOR1or5e1/jkNEaCDGREVg+mvuXYMk1Nc954/ohvXH85QpoE48oc5ApJXGeYZ5XpBaOPaciKiZ/l3bYWCr1AhAfa90LV03tS9eurTtQ1NrIQH+TlUR+jlI7yOHo7RktgJZtnoOBtlJg9I8LcUzFw1v8/q0AZ2x/I5pdsujF2uVt07trM8XENk+GLedMQCvXj4Gl4zrpWow0Nbk9O7wld5+es734OoRbh8cgMsntp30vDV/PwnvXTO+xfn45AXDMdBBmrllt09DoIPRTAAwc3BXvH/NeIfrOcvdhiRJkjC0ezgumxDVlFbyxml9myaRb+0/F43AbVbSDFpz/uge8FOxph3o74fhPdqmv2x+v5rQt6PVVFOfXD9R9n6Mdnbr1XZ4hYzzyNMJ6NcR4I0rx7j1fjV+Fz06hODx84cbfq4VOddBV+/TkiTh4nG98MrlY7Bg1gCEhwQ6PbKc6nGKI3lGR3XApH76z0Vpzb/nD8GqB87QbH9XTeqNc0Z2R7tg91PTNp63WtbZx/fpqNm+iIzqvFHqdgh//LxhALy/Iyfph4EjIqJW3r56HMKb9Qq8+8yBmNjXtblBXNUhJKBNmjNrQoP8nKokPHvRSDdKVU/OXDqzh7QdRfTkBW0DP440bwy5aEwvzG82v1SnsEA8d/FIj3oQf/ictpNPhwT64Uwngznu5Hm/YVo/jzpmVM/ZB/2Lx/XCDdP64vu7pmN4jw6O3wBg7rBuiP3PfHxzxzTseWae1TmAmjt7eDeM7CVv2wAQGiS/4UNuXvJ2Qcr34JYkCf+ePxSHnz8X0weebry6aGxP3DyjPy4dH4X/XDRC1racaWC9aIzzc2k9OG8IApqd0MN7hOPeOae/t5BA/zbzJPbrEobZQ+WPojXqg+hVk3pbXT6+jzr367OHd0MXG8F/Z3jSPFpamT6wM8KCAjClv+vfnRqpBD3lXinnsyv5WYx6TXDWQ/Pb1snU8sT5w9kbXKah3eTNB6qHu88c1GbkshaUCPY0bkLLX+G5KjWYdwjl6D3yHJ/fNBlXT7ZeZ3WHJAGXje+FW2b2b/jbOPeYqyb1xmtXuNchiIyDV1winVgb1ULGMLFvJ+x5Zj4OpBejX5cw9NIpx3aIjMalXh1DcSyrVNb2/m/uYJw1LBKXju+F3+ykngKA4AA/1JiszwQupyH05ctG4/pFu5FZXD+nyZUTe+NCFxpFmwsK8MPCmybhWHYp8stqMLl/J4SHBKLCYHM8NbIW3JncvxOm9u+MPamn58q544yBsr5rpUSGB+O9a8bj8ZWHbH7HZF3ndoG67dvZR4GPrpvg0n7CQwJlp+Z0tkzOtOt2CpN3rB8+V72Gv/CQQHx/1wxknKpEcIA/IptNbH7H7IFYczQHe1Ptz/PhzDG6Zkof/HnYdhpQay4Y0xO/dArD1oR8RLYPxgVjejTN39To+YtHYUDXdtiRWIgBXcNw+xkD0SFEv9+yUi6bEIW31pxAVZ25admw7uEYZmUUlhJCAv3x7Z3Tcd77W93aztIFU3DNQmPmoRdCnxFmjQ3q/714FP7x0XaXtqFG5igjNcLYI2vEEYMWLQzvEY4bprecC63OrE6daGDXdrhyUpTXBNzUZiuFrxEy1en1HSoR+D094sj9bcl1sqBSle0270hI5IrhPcIRl1Om2f7UuL3s+885LbKZGKWzS4CfhGum9EG/ztYz3cyzM6dvc/+5aARe/vO4kkUjF3HEEZEG7jijbQX4X/Osp8EhYwgN8seMQV10CxoB9Q1gXdtbn3Op0TWT++D+uY7T6IWHBOCyCb0Q6O+H964ej7/+NRuLbp6M964ZZ2N9242Kciol/bq0w5bH5uCX+2Zi+xNz8c7V42SNVHLEz0/C6KgIzB3eramMSmxXK8EB/vhywRS8dNlo3DqzPz69YSIeUbHh25ZLx0fh4H/Pxfd3TVdke77SGDJXZkVXDd5xjJVt9pnQt6Mmo0F7dwprETRqNEPG/GxRnazfQ+6f23Y015lDI7Hs9qlNf3cMC8S3dzpOxTmmdwTunzsYV0/pY/Xa7edXP5/W4lsm45mLRqJHRH3aLbkpWLVocHZmFGWfhmPauV0Qli6YgmHdwxHgJ2HagM74YoG6EyIP6xGOsb0djwa2Z9rALrhlRj+FSqQss06TiDT2Sh8dFYGNj5zl0jbun2N/hKQrPOW6KydoJvGpv8mimyfjp3tntqljZ5yqsvu+AV3bIfX1i5Dy2oWI/c98Wft688qx+OnemegWHsIUfzJcMLoHRtkYyezKqFyjuXR8L5fep8Rvp3ETtrZ1w7S+iqfhUyNdr58EhyPiiRz57MZJNl9To4O33FHRw3uE46bp8uqIrVPgq3GHGRMVgTevGitr3UGR7TBnWCQW3TIZU/p3RrcOIW0ySISHBOAhKxlYrHHUecdW5gFSHkccEWng0fOGIb+8Bn8fzkFwgB9undXf5YojeYZ5w7thQ5wbE49K9Y19j503FE/8dNjmal3aB2PW4K7o3Sm0xQPvrMFdcNP0flh1KBsdwwJx/dR+GNyQ+sHPT8LIXh0wslcHbIzLtbFl25UbuT1wA/z9MMHNRl05VSx3nqXOGNwV2xMLXN8AgIjQQJRU1clev11wgOwKoZpCAv0xrLsyPfN9pSdzcIA/bpjWF9/sTtN830Y8xs42Mcttk75kXC9Z2/7qtql250hT28xBXfDhhgSrrzWmuAsLCsCFY3rgr8M5Ta8FBfjhqkl9rL5v9pBIpL5+UdPfNSaz1fWUcOvM/lh7NBcncu33uJzYr2OLv+cMi8TmE/ktll07xfrnUdqQbu1bzLs1bWAXrHnoTJjMFgTImGtLCUqkRLt2al/8vC8TZQYbMWu2CM1H2QT5++HyCafnj7LXccWei8b2wjvr4lFWrdwx9ZR2fiHjN6nkR/GUkVjWnDG4K84ZaX20wuwhXRF70vYo0sa0oHI//0VjeuLqZtdGD+rnpLl/zRuC4T3Ccc7I7vCzcaBG9eqg+SgBpd115sD60cWHsjWvSzoacdQ+OMDlznh3zh6ARdtSWiy7fEIULCqMsnj4nKHoY2MkA5FcAvXTEXy+NbnF8uf+MRIXj+uFX/dnIrukGpnFlVhz1FZ7iXxmmcOiI8OD8dJlo7Es+qTT+xjQtT02taqfu+uPhmDy4ysP2V1vSv9O+PGemW2WTx3QGcdePA87EwtRWl2HM4Z0Rbdw9+eNXPfQmRjcrT1Wxma4vS1yjH2PiDQQEuiPD66dgEPPn4v9z52DR84d5tEPXeTYPXMGKdLgcM2UvjZ7VUU1jIYKCfTHD3fPwBUTozCqVwfcMqMfPr9pMs4f3RMfXz8RL182xuY8JLYao+3VbdT45bpzrNzphbf8jmlWJ5eXq3+XsDbzhyhJ7cuEM8fu9jMG2Jzk1pcuZzfqFfTzkWMcHOAnqydp/y5huqdbm9rf9uTdV0483QvuravG4YqJUejaPgjj+3TEklsmY4DM3oxq9lDv0j4Yv94/C18umILPbpyEPU/PQ0hgy0eD4AA/XDyuZUeX1vOkBQf44Z+T3bsO2mv3DmuYG6tP51D874aJVtfRKmgEAJMVmLR9RM8O+Om+mbj7rIGGGn1kMgvNLzWLbpmMjmGne826+pOPDA/G8tunYcbALgqVrOX5N87BJO/u1CXcJa+TjXLfrCffjuyNbpw33H76q+bXGTnHvHXaV444su3hc4biwjE9EWjnWi5JEpbdPg2Xju+FvjYCB1dMjLK6XCnufoVCADMHdcUrlzue++PWhnlLAGV+O433bVvXAne6RNwys3/TcylQPyL4nrMGKdL55ezh3bDrqbPxvxsmYv3DZ+H/zmbWFlLGv+cPxfwR3SFJ9RlMrp7cGzfP6IfI8GDceeZAPHfxSJwhM323I3JHdDemkXcliLtgVn+n3wMA3TvYz3DjyNjeEfjQTor0sKAAzB/ZHVdM7K1I0Cgk0A9DuodDkiTcMK2v4zeQ2zjiiEhDWs5jQvqa0r8z/vi/M1zO1X/Z+NMPPuP7OE6LE9UxFO9ePd75HdmokwghIEnWG/PUmIB6WHfrPQjlTCLu7+bD1OtXjsVln+xw+n3j+nTEB9eMx3d7tB99othX4MShE8L29+FLTSHOHPt/yUwFJocRj7HTcxzJWGfTo3PQq2Mo4h2Mgnn2HyOd3Lvy/PwkBPpLqDO3/WTNG2baBQe4dn2G+g2NoUH+mDvsdArGz26chAe+24+yahPCQwLw0XUT2syZdM7I7li6YCp+2Z+JIH8/XD2lDyb1U2d0ad/OYVj/8FnILa1G706hhuh0c8vM/li6M7XFso5hgbh8QhS+3JFq9T3WDO0ejqcuGAEA+GqX8z1LW1swq79T+7dGjfu7I2cNjWzxt9xvuHmjaqNxfTriu7um42RhBa78dCcKymvdKtu/559uoLxhWl8cTC+2ut45I7tjSLf2uo2EkPO9KTnaxQCnocvsHarRUR2s9kBvFOh/+oM7OuTBAX64pFV2CU8+bkYRGR6MD66tb6DcfCIPd30di9qGyUOiOobi0XOHoXuHEHy6OUmV/Td2uPvH2J5YdajlnIRy0iY1H3Xw9IXD8epfcVbX8/dr2SCqxPnbeP+0tSmLGxPF9e4Uhj8eOAMb4/JQa7Jg3ohu6N4hRLG5VHtGhKLnGP3Sx5P23rxyLMpqTHhp1TFVti+EQGiQPxbfMhmnKmrh7y9Z7ZCmVL1Tzshg4HTg6I7ZA/D5Fuv3IltcGYkXFOCHt64ah5u/2OP0ewFg+xNz0buTtiMAm3d8XjBrgC6ZQHwNA0dERCoZ6mIasLG9I1r0XFWzHcdWo6RF1AdkTFZ2LneotTOevGA4bv1yb4tl3TsEY2j39jbecZq79bnxfTrix3tm4J+f7ZL9np4RIfjt/lkNBXBv//ZIUHcyYGeOnYBANxs9kjqE6jvyQ0tBAfIO2uwhXXHvHOUCR97A0bUs+ql5TfPv2DvKY6IiMFPG/EJaGNi1vcNUb+7Qup1xzrBu2P/sOUgtrET/LmE2R/KcOTQSZ7Zq8HeHrQdqSap/qDVSWpoBXdvhifOH443V9Q1+QQH1cweeNTQSgyLbY3tCASxCYO0x91ObOOOJ84cjt7S6RVpEZ9WnqlOwUC6Q00jz/+3deXxcZd3///cnSbNvzdqkSZO26b7vG6ULpUChlH0vm2wCKoIgIAiK4P27Ub/qLSq3guiNCwoooggCiiyyyFL2fS/QQoHSllJK2+v3xzlpTpJZkzOZSfJ6Ph7n0TNnrrnmmnTONedcn2vJH5DVblRfR02VRbrh83O18qqH9MYHiS3Ovnh0jf4RmGK4uiRPiwMjUA6Z3qjPtu/Q7x9erdxs05IxtaopzdPg8kJNHVKuK/6ZmobqRCRynRjmdKeZHP8oys3Wo1/fXdfc95q+/bfOjfKx/lZmpvOWjVF2lunHEQIPZYFrnVgN+ZVFufr+YZNVnNe+qSUTAt/ptHxSvW5+/O3Q8ls4qkY3njpXtz29RmUFA7R8Ur1qS/N1zh6jVDggW9+9/YXQ3qtV63/hMXObdfsza3c28hbmZncK9ES6XQoGefcaX6ef/usVffBx+wD3kIpCnbfXaI0I3EeG2YkkFSOOJG+UUcfgWViBo1Q7eFqDCnKz9fuH39SWz3pHmRM1srZYL6zdlO5iJOWQ6Q06ZEajHnjl/ZS9R/D73nGtoKCwzr1E20+2+ufMOXuMTjpw1BUPnrebBhbl6lv7jdcFf3qq3XOxZlZoFRwxHrZE/vItNcX625fma68f3JOycoDAEQCkTFd7h/3yuJk9dnMZ7V2cc8rOMm2LcJGTisWz5w6v0pIxNbrjWa/RJsuk85eNSejvkEia8YNL9dRbG9odC66pUF+eXC+24PDxhSNrIl7Y7T0hdeuYpWHAkZzzFqO9aVX7m/7sLNM+E3v/gsWJGl5drOqSPL238dNOz2WZN0//gVMbQm/o7gtT3MSaIkhqX2fGSnntCbNUkNs/RvCm4789JztLLTXxg/Y9IVO/9Z9fOFwHTh2sF9/dpAkNZTt7qR41u0lHzW7Sa+s+7vHAUf6AbP34yGn6+NNt+tLvVumOZ5N//0i/+WGZ3FiuVR1G7BwdYZq+WP/ne40fpKK8HB0+c4gmNMQejd1UWaQzdx+pM65bFbds81oq9aMjpuj/+9tzeuCVD9RSU6wzl45sFyiQvGkaj5wVeWrBdK5fk+r1IDvnlVxmJfk5Udeeunj5WF12y3M7R4101+mLRygvJ7tbn/ekXYfpp/96uVPD/xlL2hb0rizO05CKwk6BybP3GKXPLxgedZ2eeS2Vuu+l1DWGZrIvLxkRauBIksYPLtP4we3rAjPT6LrIU3R3V+v/6ozmCv3hlDm6adXbys4yrZhcr3H1beXIMos4EjD4nWqsKNTvT56tX93/utZu2KKlYwdp+aT6iGs3hnn+RqurUtFRcXx9abuAfFf0RNWak2365orx+uqeozXuott64B17TnZW71idpHWmkxnNA/W1Zd6sAqlcxzTR73tYv+2JBo6OmOlN/ZydZTp0eqOue/jNiOkijbpO1qJR1TuDZvtNGawbH12tR99YL8nrhHHOnqPi5pHoSKpUyqTOZX0VgSMASJGuBH/2m1zfqddLtDluC0NoOI1WRCdvEeDOTePRpyubP6LrIwByc7L04yOn6d8vr9Nr6z7WvJaqdj3tumvl7CZ99YYndz725jFuW5Mj2enugtM5zBpaocHlBXpr/Sc7j1UU5Wq3MTWRXpoUizZfYEiSGT12yPRGjR5Uor0n1OmvT7ZNz3HyrsO6vJh5b2RmOmPJCH3tj229spoqC3XB3mM1o3lgynpeJfMV3W9yyEHLKN/BZL+Z8b5uiX4dOzbm9mX9vYd6OsX7TaspzVdNaeS52ru6wHgYivJyNKaupEuBox07XKgjU4KOmDmkXeAoNztL+03pvB5JrGnXfnLUtKTeM5HTx0w6YmaTCnNz9I0V45PKPyhaoKAnJDJVXaiBoyTT/8/hUzqNKm+1bEKdXl33cZena1wwslr7TanXS+9u0pxhVdqlG9eircoLc3XYzCH6TWD6m5nNFZ3WefzSbiP0lesf3/kTObauVCvnNMX8LnxzxXgd8bMHtHZDpCvsvuu0RcMTXtsvDOWFqb9OmNhQrokN5RGf8zr7dD4vOzayttSU6JsJ1DuxrgVyonT0iyb6bBPh328cMqNRP/zHSzHTnLZoeFpHbEpt90Pp/O1OlUxo2E/EqguXatPWbe3WysrPSX8nsbB+2w+a1rizg2w0BQOytef4ts6YtWXR1wOKdP3UHcV5OfrNibP175fXad3GrZo/skp1ZfE71mbCzCg5ffC8zTQEjgAgRcL6DdtlRJVys7M69cY8f+8x3c476igGF/1CKS8nW7OHVeiBVz5od/zUbk7LlZuTpYWjaqT4nVuSduiMITKZbnxstQpzc7RydpPmDG9bQDvZzljBhVmzsky/PmGWzrnhCT3+5nqNrS/VZftPSOmaZmHdBHRcuySaCYPLNKbOW4Ty+4dN1rIJdXpuzQZNbRqohSFOV9VbHDmrSS3Vxbr7xfc0pKJQyybUpS14tuvIat3/8rqd6+zk5mTp8JmZuVBovO/tZ4E6LjfKFGk1Jd1bwBVI1PHzhnb5tTnZ6b2J7WoD4LYdLmXduw+Z0ajcnCz98bG3VJyXo6NmN2nqkM5rY4U18kSScmL8uB88rUGbP9uu/ScP1pKxtVHTJSpVMd5EGoUTuSYId6qrxNNObiz3ru2iZiZdtHycxtSV6v5X3u80qjle3t89ZJKqihP/XYg38rXVt1aM1+TGcj382gcaWVuiI2c1dWpUPnBag5qrCvXP595TfXmB9p5YF3GNjKDh1cW655zFWvXmep3660e1blPfDyDdceauGl5d3KMdIaYNGaiKotxO08B1V6Kf4Vv7jdc5NzzR7lh2lnUaHRWGHx0xVWdf/7g2btkWdUR8UE/+OjUMLIy5/t4+E+v0hcUj0h44aq1i6auTPmWFA1TWIeDbUBE5cBFtfdHkJPb67v52nrCLdy25cFS1qorz2tX5xXk5mjC4TA+//oGGVxfrouXjVB24zzlq1hD98M4XO+X5g8Mmd+rIEIb8AdntpugNunj5WF18c/v1purK8lWSl7qQQrR761GD2ncu7osB30xD4AgAUqQrN0iRLmEKc3N02MxG/SrQG3NMXalmD62MkDo5URdIdS5qw+22HTt0+UGTdOwvHtLL732sAdmmLy4e0S4Qk4kOmdGoQ2Y0Rnwu2RFHe4xrf1HVXFWk3588Rzt2uFB7Haf6Mig3J0tLx9Z2mlLp6mOn67an1urJtz7SpMZynbPHqJ3f5wHZWdp7Yp327kfT00Uya1ilZg3rue98SX7kS7ZFo6r1hcUtuvHRtyR5izNPa+rcGNsdyybWRewxunJ25CmbuqIkL0d1gZ51TZWFqivL1zsfbWmX7psrxoX2nqnUW3p4Zrp0jrgaV9/1qY56+iZ2YIfGlq7GXlLR4zxovymD4/aSrSnJV1nBAH30yWftjl+8fGzS77dwVHXEBqZfHj9TC0Lu9JCq6UR/dMQUffWGJzv9PYISW+MoTInldsycJp23LH4np6ws02Ezh+iwmUO0aFRNQtMLPnj+bqqNMuLPK2H3PnGWPzI9ODo9kmlNFZrWFH8diKDcnCzNHFqh5srCfhE4aqkJbwaBRGVlmS5aPlZfvm5VwqOZE5Hot2q3MTWdgjj7Txmckk5le44fpCVjavT2+i1qGFigYeffEjP95+YP1Y2PvdXp+FGzh4TQGN/Z1/cZGzVw9KMjpob+fl3ROpNEsveDvUFvvhwtzR+gKUPK9Zg/fVqr0xa16PpHVmv1h59EfmHAXuMH6W9PdV77saIosQ4HyV7OlebnaIM/Neug0nwdPadZkheU+e2Js3TRn5/WM+9s0NQhA3Xp/uNVV1agbdt3RFxTtKY0XyfOH6qf3fPqzmPHzWvWisnhjDZK5qux5/g6XXHXy+3qtKNmN6X0On1MXUnEYPg5e7TvZcyIo9QjcAQAGSRaY9PFy8dp9CCvN2ZLdbGOntMUzhofMaaqizYn8vYdTo0VhbrjzAV644PNqirOU1EKe5v0hGQbfCqj9G7tqalqwrwHuPygSfrsusd070vrVFGUq7P3GK3Fo2uj9jhCepy2qEW3Pd0+wGcmrZg8WBVFuZqRwAKmXTWqtqTTOmGDyws0tyW5wFmsm9cDpg5ud9NkZjpr6SidHZgGaEbzQC0Y2f0pIJF5on030nkr2J2b4VgjXVLh4n3bB1S7GrjctsOlvce1N5VsQ7uGkoqi3HbTtySqKC9HB01r1G8faptybPSgEs0aGn59maqf/z3H12n3sYO0ZsMWXfvA6/rJXZ175icS8OvpEUdHzhrSpan/dh9bG3E9rI5iBY1i6c2NqJI3TfXmrdt3/ovoVkwerEkN5Xrw1ffVXFmk03/7WNzROLHMHFqR8HV+ZXGefnfSbF3xz5f02rqPtcsIr5NPquRkZ2lIZWLrfIytK9WkxnI9HjjHZjQP1PDqYj23ZmPoZesNU+621qF9YT3RnhYtMBOWc/YYraOuenDndIKDSvN14NQGDa8u1hd++1jc15+8YHin8k1r8kYkJiKZ78SsoRX6zsGTdPsza3d2zgxOaTyitkS/OXF2p9dFChq1On/ZGC0cVaMnVn+kCYPLNC/Je6+wDCrL1+9PnqNf3f+a3lm/RUvG1urAqeEEsMoLB2j95s6dY3Kzs3TR8rH60u9W7fz/33tCnWZ2uIbrDXVMb9e7W/oAoI/53C6Rp8bJyjIdMWuIjpgV7hRU0XpkOidFu4Zp/eE2MzVV9tx85amUTMDnjCUj4icKSU9cB5UVDtAvjpupT7dtV252FhdfGWp8fVmnRbUPntaQ8I1Pd5iZfnncTF3612f16Bsfamx9qc7ba4zykpx7PNYUQV9f3nkk0UHTGtRSU6x7XnhPQyoLtfvY2nAC5r3MjOaB+s9rH7Y7dlEXRl9ksqjfjZCroy8ubom73sLOt+7Ge/fkiKPFo2u05/hB7Y51deTQ9h3hTRPXHeftNUY1Jfn6x3PvavDAAp2yYJgGxZjrP5Zv7TdeY+pK9MAr76ulpkTHzm1OSa//ZRPqdNktz4Wer+R9nwaXF0QNTiUyoqKnf9q3bkvsu9TxOrQoL0fXnjBLdzyzVm+t/0SX3/Z8l96/r17KPH7RUq3f/JmqinM159v/0JoNW+K/KEUmDC7Tk299lLb3T0RzVZGa/bWVrv3cLH35ulV65p0NcV7l2Wdinf7yhLemZ2VRri5JMhA6vLpY3ztkclKvCUOk6c2DzEy/On6mrvjnS3py9Uea2Fim0xe19Ovr/2Snqjtg6uCdI/0z3bTmgXp+bfgBwVY/OWqams/9a8rynzO8Urd/eVf94ZHVKsnP0UHTGlRTkq/GisKEAkeTG8t14T5jdfltz2nLZzs0oqZY3z90csLvn8xpcebuI9VYUajjo7TndIWZaV5Llea1dH/9vu4aWlWkiyLcr3XXJSvGd/q/rCrO1fDqYo2oLdHYulI98MoHaq4q1MzmipiBNqQGgSMAyBBTh5RrzKCuT43TFdEbIZz2Gl+na/79WqfnekuwaERNccJpE23kK87L0T4T67tapIyWbBAAPSsry/Tzo2fotw+9oefWbNC0poE6aFrsKXTCVFmcp+8lcaOVjOHVRVHPwcmN5SmZx7s3OWPJSB1/zX/0qd8QO3pQifYLaZqKTNFTowC+tGSkNn26XVff92rctN3pedwT02YMry7Sfx80SZMayjrdRHd1qrrtO1xKRnmdsmB4Uumzskwn7jpMJ+46rNvvnZ1lOnpO887pYlKlYWBhp+B+2KJ9JxOaqi7ERuFEvt4d1yBIRnFezs4pDbsaOIqmlw840oDsrJ1rYJy3bHToU7ElKjc7S2cuHanjfvGfnn/zLho1qES3fGm+tny2XaMvvDVu+v85fIq+tNsIrd3wqaY3D0zp2qVh+saKcTrvxifbHVs8uv1o7bKCATo/wjSSvX1EXle1drZItJ5cMLK61wSOjp83VL958I34Cbugp67Ph1UX66t7ju7y6z+3y1AdNXuI1m3aqsHlkddNiibWtWBwDcIDpgzW9BTO/pCog6Y16PpHVqe7GElZOKpaY+pK9WwgqH/KguE7O/YOqy7WsOrE23UQPgJHAJBmC0dVa3x9mU5eMKzHpjprFe0C2cmbQ/eX97/W7iZiaFVRtxoDUuXQ6Y267uE32x374m6JjwyKNaf1JSvG6dan16i6OE/H7zJULUkEpFKlv97Y9XcFudmh9mLraVGnI+vHvVwTMa+lSn/70nz947l3VVWcp8VjauIuwN5XhP3NyM4yfX35WP3h4Te18dNtKXvvnOzUf6f3Gl8XdT2zro84Ss2Py5d377mRuun0vyun63u3v6Cr7o0fmOyKaN+qnl5TLZH1gzquwRCth3609ftSpg9dP62YPFijB5Xq3pfWqamiUCf86uGUv+cPD5+idzds0cJR1WqpKdH8EVW658V1UdOPzsB7hvwB2dp3Ur3+/PjbUdOct9domZlG1JZoRG3mfYZYDpg6WH9/eo3++fx7kqTa0jxdsHf8tcYyVU9cIib7m5lMx5KVs5tUV56v/7413CB4olpqinXOnqO69f41JXl6N8I0j6cs6H7njrBF+03Jy8lOOmgkRf+/HlxeoN+dNFsPvvqBhlYVaXJjeY+vbxnJ0XOa9Lcn39HH/lSmhbnZmjOsUnc+926aSxZdSf4A/fbEWbrh0bf05gebtWBktRaNZmryTELgCADS7JrjZqbtvaNe3zhvZNF3Dpqkr9/0lD7eul2NFQW6cuW0Hi1foi7YZ4zWbNiiu198T3k5WTp+3lDtMzHx9RBiLUexck6zVqa4p3I0XuNMH2rlQL8W7b48A+6zMl5f723X08HwP542V0u+d3fMNN0bcZTeaTS62sFh+w6XkkBufxnRWpSXowv3GRta4Gj3sR3WGozR2afVgpHV+tcL74Xy/tEk8hVpHRXT6ri5Q/XHx95qd64vHVubslEc0TtG9a1rqlGDSnqsQ9ch0xu076T2o+6Pmt0UM3DUk9M7J2PlnCb95Ym3I47WWjSqWsfMbe7xMoUlLydbVx0zQ8+t2agPN2/VtKbeM1oqbItGVe8MoMWS7CytyVwfXLR8rHKys9IWOJKkUxe26KBpDXpp7Sb9+qE39Fd/CsZEHTajUactbtE51z+hO599VwW52Tpp/rAurT0Ypkj/vxfuE+5UztHuUZzz1nxurEhsbbGeMrGhXDeeOk83P/62djinfSfX6/an10YMHGVSR9TywtyoSzYg/QgcAUA/Fu26t7Xn1YHTGrTv5Hqt3bBFg8sLMnZkQEn+AP3y+Jn6aPNnys/NSrqRKtaIo3T66l6jdclfnul0PBNHfQHxROvRmUjvdSBMLTUlWjZhkG55MvqCztaN2E+6g6ErJtfr4j8/vXMKlURtS9FUdUheTUmeztur/dQ8saYXbnXyrsM6BY4OmBLu1JbzR1QnvRj6hIYyfffgSfrObc/rvU2fav6Ial1+8KRQyxVUVhB5VGZtadfWykqFDL30jGp0hOm0l3YMbgYcP2+o9hg3KOrz6TSjuUI/OmKqrvzXy/pw82fae2Kd9plYp6LcHDVVFmbs/U6isrJMY+t7dvrz7hhcXqC31n/S5devmFyvm1a1H0F24NQGfWm3EXrhZw/EzTvZEUe5OYldIKyc3bRzKtmRtcV6Ye2mpN6nu+aPaFsXp6YkXzUl+bo5yaCR5K0BlZeTrR8cNkXbtu9QdpZlxDny9eXj9NyaB/TOR95ab3uMqw19KudonzMdU4QmyutQMGrn49ufXpvG0qAvYFUpAOjX4vdeHZCdpYaBveMmqqxwQJd6NmfC0PJI9plY12nI/d4T61ScR78P9D7R7rF6QdWCNEnl7873Dpms4+Y1R3/vbuSd7t/LkvwBumz/CUmfW2Pqek9DY19lJv3iuBn651cWdhplmMgaR3NbqnTJinGqLslTbnaW9hhXq0v2Gx9qGfedXK/8Ack3IxwwtUH3nbtYT31jD1197IyowZ0wLJswSAMiTBl56sKWlL1nXxepcT1WXff15WPTXhfGsmxCnW46fRfdfc4ifXXP0RpXX6bmqqKMLnNfMj0w1eo5e46KkTK+o+c0tauTCnOzddTsIRpSWah/nb0w7usnJbFWzzFzmpSdYPUXHOF47NyeH01x1OymTse6cssbPPdzsrMy5hwZWlWku85eqOtOmq07ztxVPz1qWsJBvUQl0mED6OsIHPUQM6s3s+VmdrGZ/cXM3jEzF9ia011GAD1v7wnpHeI9sDDyTfv0KOsm9FXRLoAjNTr0pNrSfP3mhNlaPLpGw6qKdMycJn03hT10gZTiHgtRRJvqY86wypS9Z/6AbF20fFzU57szVV0mOGRGox48f7d2PY7jWTm7KfRAbkVRbrgZ9nFXHTNdi0bVqChCB5Fo/zUdG7BWzmnWQ+fvpicuXqorV06PmFd3FOfl6OpjZqimw3R0iTCzHpm6sDA3R19c3H6atH0n1WfkmjuJGlZVFPP5c/fq+uLxgBT9vqe7Qd79I4x6PG1xWxB3+cT6Ts8nY1pTha4/Za5O2nWYTt51mK4/Za6mDPHuZXPiRHnMpEOmNyb0PifvOkwX7DM24ZHywar5iFlD9NOjpmq/yd37rImYP6JKPzpiSsQRf13pLJnJo2vycrI1a1ilWmpKUhLQivb36k2Bo15+OYsMQJflHmBm/yXpq+kuB4DMkmXeRWQ6DasuVlNloV5/f3O742csGZmmEqXP9KaBevj1D9sd+1bIvXS7YkJDma4+dka6iwF0W7S1JTKl52KY+uJnSqXpTQNVXZKn9zosvnx8Guc7727gaFrTQD3S4Tfl/GXhNewmUryaknwtHFUTcw2SVl9ZOlKNFYXavHVbCKVrc+bu/e96oqtOWzRci0ZFXxA6K0oDVqT2KzNL6bomc1uq9OD5u2noebek7D266wu7jdCMoRV6+LUPNGpQqRaNqo76N8w0kxvLterN9e2OfWWP2KMyDprWoBseWa0X303NdFi9qJ20TzLr/H+wW8gLyA+vLlZVca7Wbdra7vhl+0/oVr7fXDFO6zdv1d0vrlNhbrZOW9TSrq7LyjKdtftIfff2Fzq9Ni/Bemz84DKNH1yWVLmyzPtsHddki+ThC5aoqthL19W10vYcX6c9x9dpzYYteuCVD7qURzw1JXn6v8/Nivp8V65tXIpP/lMXDk9p/t0R7e+VycE0IGyMOOoZkSZTTs0vBYCMEq2n79zhlfrxkdM0ryXxnsCp8u39J7Qb3n/4zEbNGlqRxhKlx3nLRrebAm7W0Aotn5T6XmFAfzFzaOTRIysjTKWB/iUry/Sjw6eoxK+Ds8xbUHponB72qdTd2N8XFrcoN9DTeWhVkfaf0tDNUoXvypXTdPfZi3S6PzqjO2uOPf+tPXX4zCEqGJCt4rwcnbTrMB2Z5g4yvcU1x83Q2XuMjhl0jvZUVxsxu6snAuTHz+scPG6pKY6QMrLZwyp1+uIR2n1sbdyRB5nkR0dMUXNl20jMI2cN0Z5x1guqKs7TDafO1YnzUxNw70097Pui0xd1nmbx2BjTrXZFVpZ1ms5xXH2pFoyq7la+JfkD9IvjZurxi5Zq1deX6pQFnQMFB02P/Pv4+Qhpw/LYhUt12MzEfqNag0ZS4kHUxVECe135nQ1r9G5XAkepPPeHVRXpmLnNKcu/u+KtB92b9f5P0GbviZ1n8TlmDveXYWHEUc/4UNLtkh5p3Zxzr5pZXzpXAURw1tJRWvXGem381OvBO35wqa793CyVF2bO1C1zW6p0/7m76T+vfaDmqiKNqCnul73lpzVV6B9nLdB9L69TVXGeZg6t6JHpVID+YmhVkSY1lOnx1R/tPFaan5P2KTuRGWYNq9TDFy7RM29v0LDq4pSuf5KI7v4MLhxVo5tOn6c7n12rgUW52nPcIFUWJz+1VzQzE+zgEauncMGA7E5T2XT1c88fUaW8nGx9+4AJ+sa+45Rl8acIgmdyY7kWxhhp1Cpqz+cdYZcocxwwdbB+/eDr+nRb24c8PMGG3t5q+aR6NQws1D/OWqjn125UVXFeQiMiJKk0f4DOXzZGtz29Vm98sDn+C5JAD/v0OmPJSH223enmx99WacEAnTh/qOaP6F5AJ5Ljdxmq4TXF+tfz72lIRYH2n9IQ2tqqsfKpKyvQsgmDdMuTa3Yemzm0QmNTuPZeWYQp2xeOqtZdz7/X7thZHUbOJnIuVBXnadeRkf9/kv2dvWz/CVo8ukaLv3uXNm/dHjNtvKJ1bY2j5F+TqD+dPk+l+em93osl+u9u76kQ+0O7zgm7DNVdz72rj/3zo6IoVysJHIWGwFEPcM59I91lAJAekxvLdfuZC/SvF95VeWGudmmpCn2u+TAMLMrV0jg9GfuDmtL8jOwRDvQVPz9mhs7/45N66NUPNLK2WF/fZ1zEG3f0T3k52TvXJUi37oy8aTWmrlRjutHoNbBwgD7c/FnE5+YO7/6I5VTdVIe9OHVft+f4xK6/on0j0zXiqCeMH1ymXx0/U9f8+zWt3/yZlk+q1+EzE1uPpLea3FguyRv90ZX6w8z04yOn6thf/EfrNn0a/wUJ6gs97Huz7CzTuXuN7pG1rBaMrNaCKEGPVPr+oVM0vel1PfrGhxpTV6rj5jX3+PSSZywZqUde+3Bnp88RNcU6vMPI2VgdMrKzTOPqS3X5QZM0IKTOE8lMbR9vWrmurXGUunM/k4NGUvT1vUanMKCJ5E0ZMlA3nb6L/vbkOxqQk6W9J9RFXT8Vycu81ksA6GMGleXr0Bl9u3ckACSiuiRPPzt6erqLEZqx9aV6fu3GTscT7R2OzJUJS6FE6yV6/rLRXWr86eiIPj5yI10irR0Zy/YEey5H63hUXpA5o9hTYdawSs0aFnmqU0Q2fnCZHjx/N7383iYNKsvXxIv/nu4iAXHl5mTp+F2G6niFO93iodMbdd3Db7Y7Fm0aucmN5brty7vqn8+/q5L8AVo4qrpTcCNajT2oNF/3fnVR3NG2XR0AksjL4sV4ujL6JFVxo9L8zG+OnthQFnENTtZvzDwtNcX6wm4j0l2MPonuYAAAAEAXRJqnvzQ/R/OG08jZ23VlHYCeMrK2JOG0sRp8mkNcQ4rBCG2SXbct0YXHl0+qjxgwPC3C2idAdpZpZG2JCgeEM+1yGFMzLRlT2+kY64ki1Q6Z0dBuJGyWxe44UV9eoCNnNWnfSfURR8REq7MTnaK1qyOaEwn6xDtLuzIIKlUjjs5YkvnBFzPTRcvHtvvtXT6pXjOa+9960Oi/Mj/ECwAAAGSgkbXFOmnXYfrfu1+R5DXUXbr/BNZ26QMyIW6UyiLMHha50SMTPndvV1Oan1T6RNvjywoG6Jg5zbr6vld3Hls0qlrj6pkyB9GFtb5FGEt6HDqjUXc+t3ZnoDk7y3TwNKaIRmpNa6rQb0+cpev+86a2btuhA6Y2RF1/KBHR4iiZsJZMvFE82V0oY5iBo9byHTZziI6d2xxavqm0z8R6jasv04OvvK/mqiLNaK4IZdR3uiXaaQUgcAQAAAB0gZnpvL1G68CpDXph7UZNbx6ourKCdBcLIciEBqBokrnVT3b9mzDWdurvSpJcyzKZRrkL9xmjaU0D9fDrH2jMoFKtmFLf42uAoHcJ69sRxlpau4+t1c9WTtfvH35T2VmmQ2c0dqsBH0jUtKYKTWsKZ5RItCBqopcNqZyq7sJ9xsZ8vqky+ZHGYQSNJem1/9p759SsvS3wMrSqSENDHKUN9CZ0h4TMrMTM6jtukgbs2LEj3cUDAADIWGamUYNKtHxSPUEjhCqM2FXUntFdaE6+5YvzI07PiPbmtVSpKLfz9GDRFtlOplHOzLT3xDpdtHycDpnRqLyccKYhQ+YIuxd4WDHwsIq1ZGyt/vfo6frJUdO0cFTkdWaATBYtiJrouXbkrOSmM231lT1GxXx+wuAyzR1eFTPNsgl1ystJrhl4TohrzGVnWa8LGvV2i6LUs4exBjcSROAIknSWpLcibBPWrl2bznIBAAAA/VJtlCnPkm30iaQrjclj60tVEmUanDBGI/QVuTlZOnNp+wa+pWNrNXVIecT0vXm6mN0iLDC/32TWrMkkiYyenDOsUgdObVBTZWHUNL35ewqEqbsdMhaOqlZtaV67Y2Pq4k85umxCXcQOCEfMGqIL9h6jaz83SwUROi0EFeRm69sHTEionJI3gnb3sZ3XJkPvMaauRKMHtV8bs6o4T4sj/H4DkfTrqerM7NuS9g8xy4ucc9eFmB8AAACAfujcvUZr5VUPtTtWkpfDosy9wOd2GapJDWV64JX31VJTosWja3T6bx6NmDZVC4/3hENnNOofz7+7syE1J8t0yIzG9BYKSWmuLNR3D5mk+nJvxOwJv3xYdzzbufNoWNNVAb1dtFMh0YE0+QOy9buT5uiSvzyjZ9/ZoKlNA3Xx8nH6wZ0v6NoH3miX9pg5baOTqkvy9OsTZun/3f6CXl33sea1VOn8ZWPiBos6OmBqg2558h3d8ey7nZ5rqSnW5k+36e2PtmhweYF+cNhk5Q/o/sjWiQ1l3c4DXWNm+tXxM3XhTU/pkdfXa0xdiS5aPjbp7w36r34dOJJUJyn2eM/kDAwxLwAAAAApdOE+Y3XJX55pd2xSY3l6CtPBrKGVmjOsUve/8v7OY6cvbtGA7MRHHCXb1htvcEIGL/2UcaY3V2h6IMjX2jDf0cDC3J4qUuiWjhukq46ZrusfWa2crCwdNqMx7lRJ6Hkzmyv00GsftDv2xcUt2m1MrcYPLms3dVS0xu/eHOAEwhRt9F0yayMOrSrS1cfOaHfs5F2H65/Pvae31n8iSRpcXqAT5g9rl2b84DJd1eF1XVFdEnlE87QhA/VfB07Q+x9vVWVRbmjrPR41u2vT8yEcNaX5unLl9HQXA71Ufw8cwfNdSf8b4fittbW1iY9jBQAAAHqRFZPr9esHXtcr6z6W5I2Y+MKiljSXypObk6Wrj52hvz75jl5+b5PmDa/SLiOSa5SPOqUOAaAed/y8obrm36+1O2YmHTStIT0FCsni0bVaPJqpjDLZ1/Yeo6OuelAbt2yTJM0fUaXPL2yJ2OM8K0rlQNgI8KTqd7WxolB//eIuuufFdZKkXUdUq6ww8tp4qWRmqirOi58wjpaaYu1wTkfMHKJDpjMSFeit+nXgyDl3rKRj01yMtHPObZS0seNxM/ssK4tlsAAAANA3VRXn6frPz9Vfn3xH72/6VEv8HviZoiA3u1uBhfGDI6+bsOuI6ojHozUax1t/gcEI8Q2pLNSRs4bo1w+2TUX0+QXDVd6LRxyhd5jUWK5/nb1I/355nWpK8jVlSHnUkYvRbv85xwFPtNF3YfTHKC/M1fJJ6VsnLsxOJXecuSC8zACkTb8OHAEAAADo3yqKcrWyj06jMnd4laqKc7Vu09adx3KyTAdH6f2bnWXadWS17n7hvXbHz9p9ZErL2V98a7/xWjpukJ5++yNNbizXnGGV6S4S+omKolztMzF+g7RFaf6ONj1XJMV5NDOh74o+4qg3DeUlEgwgMQwnAQAAAIA+KDvL9LOjp6u21Jt2piQ/R1ccOVUVRdFHuXz7gAkaVl0kyet9fMIuQ7XbmBrvcSh9qvsvM9OCkdU6dWGL5g6v6mUNjegPon0lo42yiDQ64oK9x4RZJCCjRAu59IXanJ8kAB3RFQQAAAAA0iTSCJ8Dpg4OLf8pQwbqgfN20+oPP1F9eYGys2K3DA0uL9CdZy7Qy+99rOrivHZrLDQMLIj4mrFxprID0DtEXeMoSmv5hXuP0fNrNuiFtZskSftOqu/163YBsUQbfRft3MlETD0JIFEEjgAAAAAgTQ6f0ah7XnxvZ0POgGzTwdPCXUjazNRYUZhU+paa4k7Hdx9bq4IB2frks+3tjh8zt7m7RQSQAQ6c1qA/P/52p+N7TaiLmL6mNF+3fmlXPb92o8oKBqi+PHJwGegrok9V17PlAICewFR1AAAAAJAme02o00+PmqalY2u1z8Q6XXPcTM0Znplr3+QPyNZlB4xXcNDSWbuPTCooBSBzzR1eqcEdgj/Dqos0pbE86muyskxj6koJGqFfcFEmq+tNU48OKsuPeLy2NPJxAP0XI456gJlVS/pJnGQ/NrPNHY79yDl3V2pKBQAAACAT7DFukPYYNyjdxUjI/lMaNHd4lR57Y73G1JWoqbIo3UUCEJIB2Vn63UmzdfGfn9ZTb3+kSQ3l+saKccqKM8Ul0F9MbhwY8XhvmqLxiFlD9P07Xux0/MhZTWkoDYBMRuCoZxRJOjBOmr0iHPtLCsoCAAAAAF1WW5qvPcf3jkAXgOQ0VhTqqmNnpLsYQEYaNahEo2pL9PzajTuPFQzI1v5TwlubMNVqSvJ16sLh+vFdL+88durC4aouyUtjqQBkIgJHAAAAAAAAABDH1cfN0JnXrdIjr3+o4dXF+uaKcaooyk13sZJy9h6jtHh0jZ5Y/ZEmNpRpWlPkkVQA+jcCRz3AOfeaJMZ2AwAAAAAAAL3U4PICXXfyHG3bvkM52b1z6Xgz0/TmCk1vrkh3UQBksN5ZwwEAAAAAAABAGvTWoBEAJIpaDgAAAAAAoIdMGRJ5WqimyqIeLgkAAEBkBI4AAAAAAAB6yNFzmjodK8nL0cJR1WkoDQB0zWmLhnc6NmdYZRpKAiAVCBwBAAAAAAD0kIaBhbpo+didj3NzsvSDwydrAFNfAehFDp7WqKri3J2Pc7JMJ8wfmsYSAQhTTroLAAAAAAAA0J8cN2+o9p1UrxfWbtKEhjIV59E8A6B3aa4q0g2fn6s/PvaWNm7ZpmUT6jStKfJUnAB6H65MAAAAAAAAelhlcZ7mFOeluxgA0GVNlUU6Y8nIdBcDQAowDhoAAAAAAAAAAACSCBwBAAAAAAAAAADAR+AIAAAAAAAAAAAAkggcAQAAAAAAAAAAwEfgCAAAAAAAAAAAAJIIHAEAAAAAAAAAAMBH4AgAAAAAAAAAAACSJHPOpbsMyFBm9n5BQUHFmDFj0l0UAAAAAAAAAACQoGeffVaffPLJB865ymRfS+AIUZnZq5JKJb2W5qJkkixJtYHHayXtSFNZAPR+1CkAwka9AiBs1CsAwka9AiBs1CuRNUva4JwbmuwLCRwBSTCzeklvBQ4Nds69na7yAOjdqFMAhI16BUDYqFcAhI16BUDYqFfCxxpHAAAAAAAAAAAAkETgCAAAAAAAAAAAAD4CRwAAAAAAAAAAAJBE4AgAAAAAAAAAAAA+AkcAAAAAAAAAAACQJOWkuwBAL7NR0jc6PAaArqJOARA26hUAYaNeARA26hUAYaNeCZk559JdBgAAAAAAAAAAAGQApqoDAAAAAAAAAACAJAJHAAAAAAAAAAAA8BE4AgAAAAAAAAAAgCQCRwAAAAAAAAAAAPAROAIAAAAAAAAAAIAkAkcAAAAAAAAAAADwETgCAAAAAAAAAACAJAJHAAAAAAAAAAAA8BE4AgAAAAAAAAAAgCQCRwAAAAAAAAAAAPAROAIAAAAAAAAAAIAkAkcAAAAAAAAAAADwETgCAAAAAAAAAACAJAJHAAAAAAAAAAAA8BE4AgAAAAAAAAAAgCQCRwAAAAAAAAAAAPAROAIAAAAAAAAAAIAkAkcAAAAAAAAAAADwETgCAAAAAAAAAACAJAJHAAAAAAAAAAAA8BE4AgAAAAAAAAAAgCQCRwAAAAAAAAAAAPAROAISYGbDzOwyM1tlZh+Y2WYze9nMfmNmy9JdPgCJM88cM7vQzG4xs9f8c3qLmb1jZneY2flmNijJfLPM7DAzu8nMXvfze9fMHjSzr5lZbRfKOtHMfmBmT5vZR2a2ycxeMLOfmdm8LuRXamZnmNnd/mf91MxWm9nfzewEM8tNNk8Asfnn8VYzc4GtOcHXhn7Omtky//rlZb/u+8C/vrnUzIZ1IT+ukYAeYGbFZna8f53xsn9NsMHMXjSz283sAjObnUA+eWZ2ol+PrPbrlXf8euYMMyvtQtl2MbOf+9com/xrlqfN7PtmNrEL+Q3yr50e9K+ltvjXVjf511q0YwBdZGblZnaamf3VzN70f7e3mtl7Znafmf23mY1PIj/qFKAPMrMqM9vDvLaRG/xzJng/s7ALefbLNhML+f6rJ5lzLt1lADKamZ0m6XJJBTGS/UnSMc65DT1SKABdYmb7SvqJpPoEkm+RdKFz7jsJ5Nsg6XeSYl2YfCDpBOfcHxPIzyR9U9J5krJjJP1fSac75z5LIM9dJV0rqTFGsqckHeqceyZefgDiM7McSQ9JmtLhqaHOudfivDbUc9bMyiX9UtK+MZJtlnSWc+6n8fLz8+QaCegBZnaopO8p/vXL68655hj5jJd3vTIuRh5vSDrSOXdvAuXKlXSFpBNiJNsm6TLn3EXx8vPzPFDe9U1FjGT3SDrcOfdWInkC8JjZ/vLOr6o4SZ2f7gux7jOoU4C+ycxOkdduEssi59xdSeTZ79pMUnH/1dMIHAExRKgsn5B0q7wTe5Kk5ZJy/Of+IWkv59zWHi0kgISZ2bmSvh049LKk++Td0Hwiaai88zrY0+V7zrmzYuQ50M9jjH/oE0k3Snpe0kBJKyS19iLZJmm5c+7WOOX8L0lfDRz6t6R/+a+fJWl3SeY/d62ko12MH3Qzmy7pLklF/qE1km7w/22WdKCkcv+5tyXNcc69EauMAOIzswvl3dBslRTsnRYzcBT2OWtmeZJuk7TAP7RN0s2SHvffY09JEwIvOdE59/M4n41rJKAHmNl5ki4LHHpO0t3yzn2TVCevXthF0nvRAkfmjXS8X1LriOr18uqV1/w8Dgg8t1HSAufcYzHKZZJ+Lelw/5CT9Hd5wfIcefXN3MBLLnXOXRDns+4t6Sa1NQC94j/+UNIov4ytgeqnJM13zq2PlScAj5ktl9eZo3V0zWZJf5F3nn0qaYikvdRWD0jSdc65w6Lk1yzqFKBPMrMzJP2/Doc3SsqXNMB/nHDgqD+2maTi/istnHNsbGwRNknD5V1AOX87N0KaKfIqkdY056W73GxsbNE3SedK2iDpu5LGR0mTL+mngfPaybsoipbnVYF0z0pq7vB8tryec61p3pVUGiO/+YG02+T10OuYZomkTYF0h8fIL0deI1Nr2hslFXRIUynvQq41zW3p/r9iY+vtm7wbgdbriK93qFOaY7wu9HNW0oWBtO9ImhIhzbmBNFvilJFrJDa2HtgkHRs4h1ZL2jNG2jxJs2M8f2cgr3slVXZ4vkDSHwNpnpaUHSO/lYG0GyUtiZDmKP9apjXdnBj5lUt6P5D2io7vL6/hJlg/Xpnu/yM2tt6wyQsWvRE4d26SVBUhXb6kb3W4ZtklSp7UKWxsfXSTN+rvLnntJkfIC7SavMBw6/myMIn8+l2biUK+/0rbdyHdBWBjy9RNXm+X1hP41zHSLQ2k+0hSebrLzsbGFnmTNFFSRYJpbwmc2zdESTNa0nY/zVZJ46Kky/JvqFrz+2aM9w1ejFwaI91JgXSvSsqKku7EQLoXJRVGSTdI3tDw1rSL0/3/xcbWWzf/5uNh/1x6Ul7PvEQDR6Ges/KmZtkYSLd7jPf+TSDdr2Kk4xqJjS3Fm6QGeT34WxtQGruR1+6Bc/F9SbVR0hX69U5r2uOjpMuW9Hog3Ykx3vuyQLq7Y6S7NJDunhjXNeP9a67WxqIR6f6/YmPL9E3S7MD5tVExGmT99MH7lk73I9QpbGz9c1MXAkfqh20mSsH9V7o2FoADIjCzYnnDliW/woqW1jn3d0kP+A9LJe2X0sIB6DLn3BPOuQ8STP7DwP6cKGmOVNt0D9c7556O8r47JF0SOLQyUjozG662KRg2S4q1vtLV8nofS15vuV2jpDs6sH+5c25zlDKukXRllNcBSM5XJU2TtEPS51wCc2oHhH3O7i+p2N+/3zl3e4z3/qa86x5JOtDMCjsm4BoJ6DFnSirz97/inHuzG3kF64crnXNrIyXy65vgtUe0emWhvGmtJOlNedck0Vwu75pGkub701u1409RFbw2usS/dopUxqfkTR0jeY3NR8Z4bwCe5sD+Uy7+uoP3BPYjrYdEnQIgUf2xzSTU+690InAERLZU3jBtSXrCOfd8nPR/COzvn5oiAehhrwb2K6OkWRHY/32c/G6X13NYkprNbEqc/G53zn0YLTPn3DZ50z+06lT3mFm12i6qnKTr45QxWJetMDOuE4Akmdk4eVPTSdIPnHMPJfHaVJyzCddTzrnn5M3xL3m9hPeIkIxrJCDFzKxA0nH+w/XyFpPual5Z8tYcaxXveuV6tTVgzDezSI3GwXrlRufc9miZ+dcydwYORaoHpqhtIeoPJd0Rp4zUK0ByPgnsRzqnO6oO7L8efII6BUCS+mObSdj3X2lDgxAQ2dTA/r0JpA/2yIlUsQHofQYH9t/r+KS/2OHYwKGYdYXfg+bfgUOR6oqw655JavutfyaB0Var5A2plrx5wZsTKAMAn5llS/qFpFx5weeYizZHkIpzNux6hWskIPVmq20B5gecc1vNrMnM/tvMnjGzj83sI3//x2Y2MUZew9Q2cmmjpCdivbFz7n156w9IXn0UKe9U1iv/jjYyIEp+Y80sN4EyAP3ZA/KmYZOkFjPbN1pCMxsm6WD/4WfqHLimTgGQkH7cZtJn7pcIHAGRjQvsv5hA+pcC+41mVhpyeQD0vEMC+/dEeH60vOkMJGm9c25dAnkG64pxEZ7vTt3T7fz8C7XgSKtIeQKI7mxJM/z9E6NNcxBDqOesmZWpfRC8x+sVcY0EdMXswP6LZnaYvPXSzpY0Rl6P1FJ///OSVpnZd6P0eg2esy8n0IAqxa8Hgo1A6bheeU/eummSt6bcqATKAPRb/lRyPwkc+r2Z/Y+ZTTOzCjMrMrMxZnauvCBTqby1SE50zr3SITvqFACJ6ndtJim6/0obAkdAZIMC+6ujpvL5QyM/DhyqDb1EAHqMP9XU8YFDV0ZIllQ94QuuTzAowvPJ5hnMr8LMBnQzv455RiojgAjMbIyki/2HVzvn7oyRPJqwz9ng403OuY8UX6j1FNdIQJeMCOxPl/R/kkoktc6t/zVJ31NbL36TtyZSsGG4Vaj1it97eGCSeYZ9/dMxHdcrQHxnSvqxv58n6XRJD0t6X9ImSc9I+ra88/sWSfOdc7+MkA91CoBE9cc2k1Tcf6UNgSMgspLA/sdRU7UX7FVcEjUVgIxmZkWSrpXUekHxR+fcXRGSpqKeSDbPjqMZOuZJXQb0gMAUdXnyGnbP6mJWYZ+zmVBPJZIngPaCjahz5PWA/72kFufcKc65y5xzZ0kar/ZTYp5kZnt3yCuV9UqieVKvAGnmnNvmnDtN0jxJt8ZI+oak+yS9EOV56hQAicqEe5GebjPpU/UPgSMgsoLA/tYEX7MlsF8YYlkA9BB/ipf/kzTZP7Ra0olRkqeinkg2zy0dHnfMk7oM6BlnSZrl75/mnFvfxXzCPmczoZ5KJE8A7XVsNHhK0lHOuXYNEM65Hc65SyX9KnD4vA6vTWW9kmie1CtABjCz2ZIulbf4+sfyAtIXywtA/1zS2/LWMLpU0tNmNitCNtQpABKVCfciPd1m0qfqn5x0FwDIUJ8E9hNdGDE/sJ/smgYA0szMTN70L/v7hzZI2s9f0DWSVNQTn0gqSiLP/A6PO+ZJXQakmJmNkvQN/+GNzrkbu5Fd2OdsquqpsPME0N4nHR5f7pz7LEb6yyQd7e/PNbOB/jSRHfMKu15pzbNjo0wy+XXMk3oFSAEzWylvdHS2pNslHdFxvRF/CqdL5a2nVi/pVjOb6JwLTqNEnQIgUf2xzaRP1T+MOAIi2xjYL4qaqr1gVHhj1FQAMtWPJJ3g72+UtKdz7pEY6VNRTySbZ8feKB3zpC4DUsgfpfgLeRf76yWd1s0swz5nM6GeSiRPAO11PE/+ESuxc+55eSMFJG+9oylR8gq7Xkk0T+oVII38Ti4/kxc0elVe57hOi9Q75z5zzp0j6Q/+oXJJ3+yQjDoFQKIy4V6kp9tM+lT9Q+AIiGxNYL8hXmIzK1f7CmFt2AUCkDpm9j+STvUfbpK0l3Pu/jgvS6qeiJAuUj2RbJ7BNB9G6I2cijICaHOcvPVHJOks59yaWIkTEPY5G3xcbGZl3cxP4hoJ6AnvBPad2oJCsQQXdK4K7IdarzjnPpUXKE8mz7CvfxLJE0CbL8hbh1GSrnTOxevR/r3A/n5+R5lW1CkAEtUf20xScf+VNgSOgMieCeyPSCB9S2B/tXNuQ8jlAZAiftDodP/hx5KWOefuS+Clz0va4e+Xm1lVrMS+YF3xdITnu1P3dDs//6ZwWJw8AbRpDOxfZWYu2tbhda8Gnrs4cDzUc9ZfaynY4Nzj9Yq4RgK6InjuOX+LJ1qa4Dk7rEMDcDSZfr1SJam1IWa7vGsyANHNCew/mUD6JwL75WofjKZOAZCoftdmkqL7r7QhcARE9mhgf14C6ecH9h8LuSwAUsTMfqS2oNFmSXs75+5J5LXOuS1qf5ERs67wLzDmBg5FqivCrntWqa0haYyZDYyT3yS1Lcj9kbypLAD0nFUK/5wNu17hGglIvYcD+1ny1hqJJ9hb9d3A/svy6gdJKpU0IVYmZlYhaaz/cIekxyMkS2W9MsdfdzLR/J7xRywAiK4ksJ9IILqjHYF96hQACenHbSZ95n6JwBEQ2W1qW5BxkpmNjJP+oMD+H1NTJABhMrMr1LYeSWvQ6F9JZnNTYP/gOGl3k9R6EfK6c+7RCGmC+e3uT/EUkZllS9o/cKhT3eOce0/Sv/2HWZIOjFPGYF12k3NuR9SUACTvRuOXCW5BNwSOr2o9mKJzNuF6yr/eaW0A+kTe9VBHXCMBKeace0Je42yr3WKl98/Dwf7D7Qo0WPj1wl8CyeNdrxwob50kSbo30jooal+vHOBfk0QrW7mkJYFDkeqBR9U21V6F4nxeUa8AyQqexxMTSB9M86mkD1ofUKcASFJ/bDMJ+/4rbQgcARE45zZJ+pP/0CRdGC2tmS1RW0R8Y+B1ADKUHzRqXdNos6R9nHN3dSGrX6utB97BZjYmyvtlqX098n+R0jnnXpL0gP+wSNJZMd77OLVNk/W6pLujpAu+19lmVhCljLWSTg4c+lWM9wYgyTn3J+fcsYlsHV76lcBzf+rwXNjn7B/lTcMpSfPMLFbjydfV1rhzg3Pu444JuEYCeswvAvtfMbMBMdJ+LbB/R4QpIYP1yilmVhMpE7++OTtwKFq9cpekN/39IZKOjVG2r6ht0ed7nXOdeuY655ykawOHLow2QsDMxqqtEWa7vGsxALE9GNg/Kdq1RUDwHuTeCA2j1CkAEtUf20xCvf9KK+ccGxtbhE3ePJRb1Tav+NkR0kySN3dla5qvpbvcbGxssTdJVwTO2Y8lLepmfr8I5PeMpKYOz2dL+p9AmvcklcXIb0Eg7WeSDo+QZjd5jbCt6Y6Mkd8ASS8E0l4vqaBDmgpJ9wTS3J7u/yc2tr62Bc4vJ6k5RrrQz1lJFwXSvi1pUoQ05wTSfCppaIz8uEZiY0vxJq9hdHXgHPqdpKIOabIknR9Is13S3Cj5/TOQ7h5JFR2eL5A3GrI1zbOScmKU75hA2g2SFkdIc4SkbYF082LkN1DeqIbWtD+UlN0hTZN/rdWa5mfp/n9iY+sNm/+bvD1w7vxNUmWEdLmSvtPhmuWAKHlSp7Cx9bNN0muB82VhEq/rd20mCvn+K12b+QUFEIGZnSbpR4FDj0u6Vd4IhUmSlsurYCTpX5L2cMyHC2QsMztf0qWBQzcreq+Tjq5zzr3Z8aCZVUq6T9Io/9BmSTfKWwhyoKQVkob7z22TtJ9z7q9xynm5vN50re6VV8dslzRL0lK19Ur5rbyLoKg/6GY2U97NXWvvvHfk3citkdQsbzh265DwNZLmOOdei1VGAMkxs+A5OjTWORb2OWtm+ZJul7SLf+gzSX+Wt/h1kaQ95F3XtDrFOXdlnM/DNRKQYmY2X9LfJeX7h9bI68X6pqRKScskBXvuXuic+1aUvIZJul9S68iAD+U1jLwuaZC8eqXOf26TvAahR2KUzeQFsw7xDzl506s8JClH0q5qq3Mk6b+cc+fF+bwr5NV1rdNUvSxvupcP5V1nHaC2evEZSbs45z6MlScAj5n9l6SvBg5tkjfl3LPy7lGaJe2t9muqXeecOyxKftQpQB9mZtdHOLyX2s6Zu+UFeIJ+75z7fYS8+l2bSSruv9KBwBEQh5l9QdJ/q+2GLZKbJa10zn0UIw2ANDOza+T1ZuuKRS7KdHZmNkTejc6cGK//UNKJzrkb4r2Rf+N0mbypHaLO8S3pKkmnOue2JpDnQnlTNgyOkewZSYc6556Klx+A5CQTOPLTL1SI56y/0OuvJO0TI9kn8kYPXREvPz9PrpGAFDOzxfLWQ2uIkWyLpHOdcz+Ik9dEedcrEaeJ8a2W17gSt2ONmeVJ+om8qWCi2S6vgfeCePn5eR4s6Uq1Nc5E8m95dd/qGGkAdOB3ortI3siiWJy83v9nx7rPoE4B+q4O9y6J+oZz7uIo+fW7NpNU3H/1NAJHQALMbLikE+VF14fIayBZI2+u4P+LFwkHkBlSFTjy886SdKikwyVNllQrb2j0q/J6lvzMObcmmTc0s0mSTpA3zLpB3gXR2/J69/zCOXdvkvmVSfqcvN51LfJuoNbJu/j5g6RfMiIASI1kA0f+a0I/Z81sH0lHyeuJN0heg/Mbkm6R9HPn3MtJ5sc1EpBiZlYib82P/eX11q2Wd43xirwRST92zr2VYF558q6FDpY0VlKVvIaal+T1/v2567xGUrw858tr6J0vb7TCdnmNxXdIuso593iS+Q2SV6/sK2mopBJJayWtktdr+DoXeTFqAHGYWYO8OmCRvDpgoLx7jPWSXpQ3FdPVzrkXEsyPOgXog8IOHPl59ss2k7Dvv3oSgSMAAAAAAAAAAABI8hbTBAAAAAAAAAAAAAgcAQAAAAAAAAAAwEPgCAAAAAAAAAAAAJIIHAEAAAAAAAAAAMBH4AgAAAAAAAAAAACSCBwBAAAAAAAAAADAR+AIAAAAAAAAAAAAkggcAQAAAAAAAAAAwEfgCAAAAAAAAAAAAJIIHAEAAAAAAAAAAMBH4AgAAAAAAAAAAACSCBwBAAAAAAAAAADAR+AIAAAAAAAAAAAAkggcAQAAAAAAAAAAwEfgCAAAAAAAAAAAAJIIHAEAAADATmZ2l5k5fzs23eUBAAAAgJ5G4AgAAAAAECozmxYIwN2W7vIAAAAASByBIwAAAAB9jpldEwhcXJzu8vRD+wb2/5y2UgAAAABIGoEjAAAAAEDYCBwBAAAAvVROugsAAAAAAJnCObcw3WXo7cysUdJk/+Eq59ybaSwOAAAAgCQx4ggAAAAAEKblgf2b01YKAAAAAF1C4AgAAAAAECamqQMAAAB6MQJHAAAAAPoMM3Nm5iQdEzh8UevxjluE198VeP7YKO/RHCkPMxtsZheZ2SNmts7MPjWzl83sCjMbEiEfM7P9zexPZva2mW31X3enma00M+vC59/FzL5vZqvM7F2/DGvM7D4zu9DMBiWbZ5LvXyxpof/wbUmPdDO/awJ/64sDxxeZ2a/N7EUz+8TMPvT/7t80s4ok8h9hZpea2T2Bv9enZva+/zf8rZl9ycyGdedzAAAAAL2JOdfpXgkAAAAAeqVIwaBYnHPtgjNmdpekBf7D45xz10R4j2ZJrwbzMLP9JF0jqSzKW22UtIdz7n4/j4GSfi9pSYzi3SzpIOfc1nifww9M/VTSXnGSfizpPOfc/8TLsyvM7EBJ1/sP/9c5d3I387tGbUHAb0i6XNKPJR0d42UfSNrbOfdAjHxN0iWSvqrE1/6tdc69m2BaAAAAoNdK9AIZAAAAAHqD2/x/J0iq9/dflvRSqt7QzHaXdIO8GR22SnpS0gZJwyQ1+clKJN1qZpMkrZV0u6Rp/nOr/TLmS5osKc8/vlzSdyR9Mc77T5R0q6S6wOFPJD0j6SNJVZLG++UrkvRDM6txzl3YpQ8cWyqnqcuWF5Ta03+8TtILkrZLGiup0j9eIelvZjbOOfd2lLy+IelrHY697m+fyfv/Gibvb9eKGTsAAADQLxA4AgAAANBnOOf2lDqNVLnWOXdxCt/2t/6/l0j6jnNuQ+sTZrZc0m8kFUsqlXSBpE/lBY2ekHSqc+6+QPoKSVdLWuEfOtXMfuCceznSG5tZubyRSa1Bo9XyRtFcHxypZGY18oIlp/iHLjCz+51zt3T1Q0coS5akZf7DzZLuDCtv3ynyAjkvyQum3eac2xF475Ml/VDefW65vP+Pz0UoZ62kcwOHbpZ0pnOuU3DRH122r9r+bgAAAECfR48pAAAAAOieSkknOee+HgwaSZJz7mZJZwQOHSMvCPG0pPnBoJGf/gNJh6ptKrxsSUfFeO/vSmpdP+lZSVOcc7/pOL2dc+5d59znJV0UfG1X1lGKYa7aRujc7pzbEmLeUlvQaI5z7m+tQSNJcs7tcM79RFJwFNWhZlYYIZ+lkgb4+6/Kmw4w4og059xrzrkfShoniWnqAAAA0C8QOAIAAACA7rnTOXdVjOevlbTJ38+Rdx92cscgUyvn3KeSgvntEimdmdVLWuk/3CHpcOfcujhlvURegEmSRkvaLU76ZKRymrpWJ8X5jFdIag1YFUmaEiFNQ2D/oUTWkHKeHfHSAQAAAH0BgSMAAAAA6J6fxXrSDwStChx6tuNIowgeCOyPiZLmMLWNnLnTOfd4nDzlnHPyps5rlYrA0Q5Jfwkx31YvOOf+GSuBc26j2v+tI/3tgiOhxvvT3AEAAADwcYEMAAAAAN1zfwJp3gnsPxA1VeT0A6Ok2TWw/48E8mz1ZGB/WhKvi8rMRkga5T980DmXimnd4gXbWq0O7Ef62/0nsD9O0i/MrC5COgAAAKBfykl3AQAAAACgl1uTQJrN3UgfaZ0eSZoQ2D/CzBYmkK8kVQT2qxN8TTzBaepuDinPjhL5u0nSx4H9SH+7+yQ9JGmm//hoSUea2b2S7pR0j6QHUrBGEwAAANArEDgCAAAAgG5IZI2cDpJNH01lYH+C2geSElUWUll6Yn2jrvzdrOMB55wzswPlTac3yT+cLWmBv0nSp2Z2j7xp/X7jTzcIAAAA9AtMVQcAAAAAvVNRCHl0+57QzCokzfMfvuKce7q7eaaac261pOmSTpQ3+sh1SJInaYmkqyW9YGaLeraEAAAAQPoQOAIAAACA3ml9YP8455x1YWsOoRzL5I3YkVI3TV3onHPbnHM/d87Nkjdl34GSvi9pVYekQyT9zcxmCgAAAOgHCBwBAAAAQO+0NrBfk7ZS9Mw0dSnlnHvfOXejc+7LzrkpkpokXS5ph58kT9JlaSsgAAAA0IMIHAEAAADoi3YE9jutc9NHPBDYn5OOApjZAEl7+A/XS7o7HeUIm3PuDefcOZIuDRxeYGZ56SoTAAAA0FMIHAEAAADoiz4O7BekrRSpdWtgf08zG5SGMiyUVOrv3+qc25aGMqTSjYH9HEmV6SoIAAAA0FMIHAEAAADoi9YE9lvSVorU+pOkV/39fElXmFlPj67qddPUJfk3Ku3w+MMwywIAAABkIgJHAAAAAPqiRwP7S81sbNpKkiL+6J6vBA4dIOl3ZlYe63Vmlm1me5jZ381sVDeLsdz/d5ukv3Uzr57yfTP7bzMbGiuRmRVJ+mbg0IPOuU9SWzQAAAAg/XLSXQAAAAAASIE7Jb0rqUZSkaQnzOwxeSORtrcmcs7tl5bShcQ5d6OZfVvSef6hQyTtZWa/k7fe0NvygjrlkoZJmiZvTaJqP32XRyiZ2URJTf7De5xz67uaVw8rk3SMpLPN7CFJd0l6XN735RNJFZKmSzpOUmPgdd/q2WICAAAA6UHgCAAAAECf45zbamafk/QHedO4ZcsLBvQ5zrnzzew9SZfL+5wlkk70t1TqddPURTDT32Jxks5xzv2lB8oDAAAApB1T1QEAAADok/yG/kmSvi9v6rr1Cow26kucc/9P0jhJ/ydpc5zkb0m6StJCSc934217a+DoSkk/l/RmnHQ7JN0haZ5z7jspLxUAAACQIcw5l+4yAAAAAABCYma5kmZLGiGpUt5MExskvSHpGefcSyG8xyB50+CZpKedc+O7m2c6mFmDpAnyptwbKO/zbJD0qqT/OOfeTWPxAAAAgLRgqjoAAAAA6EOcc1vlrW90dwrfZrna1ke6OYXvk1LOudWSVqe7HAAAAEAmYao6AAAAAECyeus0dQAAAADiYMQRAAAAACBZ90h6RN6aUQ+muSwAAAAAQsQaRwAAAAAAAAAAAJDEVHUAAAAAAAAAAADwETgCAAAAAAAAAACAJAJHAAAAAAAAAAAA8BE4AgAAAAAAAAAAgCQCRwAAAAAAAAAAAPAROAIAAAAAAAAAAIAkAkcAAAAAAAAAAADwETgCAAAAAAAAAACAJAJHAAAAAAAAAAAA8BE4AgAAAAAAAAAAgCQCRwAAAAAAAAAAAPAROAIAAAAAAAAAAIAkAkcAAAAAAAAAAADwETgCAAAAAAAAAACAJAJHAAAAAAAAAAAA8P3/+ayNCOAAqM8AAAAASUVORK5CYII=\n"",
+      ""text/plain"": [
+       ""<Figure size 864x360 with 2 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 352,
+       ""width"": 839
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, axes = plt.subplots(2, 1, figsize=(12, 5), sharex=True)\n"",
+    ""x = 0.1 * np.arange(features[5].shape[0])\n"",
+    ""for i, (ax, tic) in enumerate(zip(axes.flat, features[5].T)):\n"",
+    ""    ax.plot(x*20, tic)\n"",
+    ""    ax.set_ylabel('$\\chi$ {}'.format(i + 1))\n"",
+    ""axes[-1].set_xlabel('time / ns')\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 21,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 864x360 with 2 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 352,
+       ""width"": 839
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, axes = plt.subplots(2, 1, figsize=(12, 5), sharex=True)\n"",
+    ""x = 0.1 * np.arange(features[6].shape[0])\n"",
+    ""for i, (ax, tic) in enumerate(zip(axes.flat, features[6].T)):\n"",
+    ""    ax.plot(x*20, tic)\n"",
+    ""    ax.set_ylabel('$\\chi$ {}'.format(i + 1))\n"",
+    ""axes[-1].set_xlabel('time / ns')\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 24,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 864x360 with 2 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 352,
+       ""width"": 839
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, axes = plt.subplots(2, 1, figsize=(12, 5), sharex=True)\n"",
+    ""x = 0.1 * np.arange(features[7].shape[0])\n"",
+    ""for i, (ax, tic) in enumerate(zip(axes.flat, features[7].T)):\n"",
+    ""    ax.plot(x*20, tic)\n"",
+    ""    ax.set_ylabel('$\\chi$ {}'.format(i + 1))\n"",
+    ""axes[-1].set_xlabel('time / ns')\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 25,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 864x360 with 2 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 352,
+       ""width"": 839
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, axes = plt.subplots(2, 1, figsize=(12, 5), sharex=True)\n"",
+    ""x = 0.1 * np.arange(features[8].shape[0])\n"",
+    ""for i, (ax, tic) in enumerate(zip(axes.flat, features[8].T)):\n"",
+    ""    ax.plot(x*20, tic)\n"",
+    ""    ax.set_ylabel('$\\chi$ {}'.format(i + 1))\n"",
+    ""axes[-1].set_xlabel('time / ns')\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 26,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 864x360 with 2 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 352,
+       ""width"": 839
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, axes = plt.subplots(2, 1, figsize=(12, 5), sharex=True)\n"",
+    ""x = 0.1 * np.arange(features[9].shape[0])\n"",
+    ""for i, (ax, tic) in enumerate(zip(axes.flat, features[9].T)):\n"",
+    ""    ax.plot(x*20, tic)\n"",
+    ""    ax.set_ylabel('$\\chi$ {}'.format(i + 1))\n"",
+    ""axes[-1].set_xlabel('time / ns')\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 27,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 864x360 with 2 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 352,
+       ""width"": 839
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, axes = plt.subplots(2, 1, figsize=(12, 5), sharex=True)\n"",
+    ""x = 0.1 * np.arange(features[10].shape[0])\n"",
+    ""for i, (ax, tic) in enumerate(zip(axes.flat, features[10].T)):\n"",
+    ""    ax.plot(x*20, tic)\n"",
+    ""    ax.set_ylabel('$\\chi$ {}'.format(i + 1))\n"",
+    ""axes[-1].set_xlabel('time / ns')\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 5,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""with open('features.pkl', 'rb') as a:\n"",
+    ""     transfeatures = pickle.load(a)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 6,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""with open('scaled-transformed-features.pkl', 'rb') as b:\n"",
+    ""     scaletransfeatures = pickle.load(b)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 7,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""#cocatenate features\n"",
+    ""features_concatenated = np.concatenate(features)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 11,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""data"": {
+      ""text/plain"": [
+       ""(1600320, 2)""
+      ]
+     },
+     ""execution_count"": 11,
+     ""metadata"": {},
+     ""output_type"": ""execute_result""
+    }
+   ],
+   ""source"": [
+    ""features_concatenatedtenated.shape""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 8,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""#cocatenate transformed features\n"",
+    ""transfeatures_concatenated = np.concatenate(transfeatures)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 9,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""#cocatenate scaled features\n"",
+    ""scaletransfeatures_concatenated = np.concatenate(scaletransfeatures)""
+   ]
+  },
+  {
+   ""cell_type"": ""markdown"",
+   ""metadata"": {},
+   ""source"": [
+    ""## Clustering""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 54,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""initialize kmeans++ centers:   0%|          | 0/200 [00:00<?, ?it/s]\n"",
+      ""initialize kmeans++ centers: 100%|██████████| 200/200 [00:16<00:00, 11.49it/s]\n"",
+      ""kmeans iterations:   1%|▏         | 1/75 [00:17<21:41, 17.59s/it]\u001b[A\n"",
+      ""kmeans iterations:   3%|▎         | 2/75 [00:18<15:19, 12.59s/it]\u001b[A\n"",
+      ""kmeans iterations:   4%|▍         | 3/75 [00:19<10:53,  9.08s/it]\u001b[A\n"",
+      ""kmeans iterations:   5%|▌         | 4/75 [00:20<07:51,  6.64s/it]\u001b[A\n"",
+      ""kmeans iterations:   7%|▋         | 5/75 [00:21<05:45,  4.93s/it]\u001b[A\n"",
+      ""kmeans iterations:   8%|▊         | 6/75 [00:22<04:17,  3.74s/it]\u001b[A\n"",
+      ""kmeans iterations:   9%|▉         | 7/75 [00:23<03:18,  2.91s/it]\u001b[A\n"",
+      ""kmeans iterations:  11%|█         | 8/75 [00:24<02:36,  2.34s/it]\u001b[A\n"",
+      ""kmeans iterations:  12%|█▏        | 9/75 [00:25<02:07,  1.93s/it]\u001b[A\n"",
+      ""kmeans iterations:  13%|█▎        | 10/75 [00:26<01:47,  1.65s/it]\u001b[A\n"",
+      ""kmeans iterations:  15%|█▍        | 11/75 [00:27<01:32,  1.45s/it]\u001b[A\n"",
+      ""kmeans iterations:  16%|█▌        | 12/75 [00:28<01:21,  1.29s/it]\u001b[A\n"",
+      ""kmeans iterations:  17%|█▋        | 13/75 [00:29<01:14,  1.21s/it]\u001b[A\n"",
+      ""kmeans iterations:  19%|█▊        | 14/75 [00:30<01:09,  1.14s/it]\u001b[A\n"",
+      ""kmeans iterations:  20%|██        | 15/75 [00:31<01:06,  1.11s/it]\u001b[A\n"",
+      ""kmeans iterations:  21%|██▏       | 16/75 [00:32<01:03,  1.08s/it]\u001b[A\n"",
+      ""kmeans iterations:  23%|██▎       | 17/75 [00:33<01:01,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  24%|██▍       | 18/75 [00:34<00:59,  1.04s/it]\u001b[A\n"",
+      ""initialize kmeans++ centers: 100%|██████████| 200/200 [00:36<00:00, 11.49it/s]\n"",
+      ""kmeans iterations:  27%|██▋       | 20/75 [00:36<00:58,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  28%|██▊       | 21/75 [00:37<00:57,  1.07s/it]\u001b[A\n"",
+      ""kmeans iterations:  29%|██▉       | 22/75 [00:38<00:56,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  31%|███       | 23/75 [00:39<00:55,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  32%|███▏      | 24/75 [00:40<00:55,  1.08s/it]\u001b[A\n"",
+      ""kmeans iterations:  33%|███▎      | 25/75 [00:41<00:52,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  35%|███▍      | 26/75 [00:42<00:52,  1.07s/it]\u001b[A\n"",
+      ""kmeans iterations:  36%|███▌      | 27/75 [00:43<00:50,  1.05s/it]\u001b[A\n"",
+      ""kmeans iterations:  37%|███▋      | 28/75 [00:44<00:49,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  39%|███▊      | 29/75 [00:45<00:48,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  40%|████      | 30/75 [00:46<00:47,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  41%|████▏     | 31/75 [00:48<00:46,  1.07s/it]\u001b[A\n"",
+      ""kmeans iterations:  43%|████▎     | 32/75 [00:49<00:45,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  44%|████▍     | 33/75 [00:50<00:44,  1.06s/it]\u001b[A\n"",
+      ""kmeans iterations:  45%|████▌     | 34/75 [00:51<00:43,  1.07s/it]\u001b[A\n"",
+      ""kmeans iterations:  47%|████▋     | 35/75 [00:52<00:42,  1.07s/it]\u001b[A\n"",
+      ""kmeans iterations:  48%|████▊     | 36/75 [00:53<00:41,  1.07s/it]\u001b[A\n"",
+      ""kmeans iterations:  49%|████▉     | 37/75 [00:54<00:42,  1.12s/it]\u001b[A\n"",
+      ""kmeans iterations:  51%|█████     | 38/75 [00:55<00:42,  1.14s/it]\u001b[A\n"",
+      ""kmeans iterations:  52%|█████▏    | 39/75 [00:56<00:39,  1.11s/it]\u001b[A\n"",
+      ""kmeans iterations:  53%|█████▎    | 40/75 [00:57<00:38,  1.10s/it]\u001b[A\n"",
+      ""kmeans iterations:  55%|█████▍    | 41/75 [00:59<00:37,  1.11s/it]\u001b[A\n"",
+      ""kmeans iterations:  56%|█████▌    | 42/75 [01:00<00:36,  1.10s/it]\u001b[A\n"",
+      ""kmeans iterations:  57%|█████▋    | 43/75 [01:01<00:35,  1.12s/it]\u001b[A\n"",
+      ""kmeans iterations:  59%|█████▊    | 44/75 [01:02<00:33,  1.09s/it]\u001b[A\n"",
+      ""kmeans iterations:  60%|██████    | 45/75 [01:03<00:32,  1.10s/it]\u001b[A\n"",
+      ""kmeans iterations:  61%|██████▏   | 46/75 [01:04<00:31,  1.10s/it]\u001b[A\n"",
+      ""kmeans iterations:  63%|██████▎   | 47/75 [01:05<00:30,  1.09s/it]\u001b[A\n"",
+      ""kmeans iterations:  64%|██████▍   | 48/75 [01:06<00:29,  1.09s/it]\u001b[A\n"",
+      ""kmeans iterations:  65%|██████▌   | 49/75 [01:07<00:28,  1.08s/it]\u001b[A\n"",
+      ""kmeans iterations:  67%|██████▋   | 50/75 [01:08<00:27,  1.09s/it]\u001b[A\n"",
+      ""kmeans iterations:  68%|██████▊   | 51/75 [01:09<00:26,  1.09s/it]\u001b[A\n"",
+      ""kmeans iterations:  69%|██████▉   | 52/75 [01:11<00:25,  1.10s/it]\u001b[A\n"",
+      ""kmeans iterations:  71%|███████   | 53/75 [01:12<00:24,  1.10s/it]\u001b[A\n"",
+      ""kmeans iterations:  72%|███████▏  | 54/75 [01:13<00:23,  1.11s/it]\u001b[A\n"",
+      ""kmeans iterations:  73%|███████▎  | 55/75 [01:14<00:22,  1.11s/it]\u001b[A\n"",
+      ""kmeans iterations:  75%|███████▍  | 56/75 [01:15<00:21,  1.11s/it]\u001b[A\n"",
+      ""kmeans iterations:  76%|███████▌  | 57/75 [01:16<00:20,  1.11s/it]\u001b[A\n"",
+      ""kmeans iterations:  77%|███████▋  | 58/75 [01:17<00:18,  1.09s/it]\u001b[A\n"",
+      ""kmeans iterations:  79%|███████▊  | 59/75 [01:18<00:17,  1.10s/it]\u001b[A\n"",
+      ""kmeans iterations:  80%|████████  | 60/75 [01:19<00:16,  1.10s/it]\u001b[A\n"",
+      ""kmeans iterations:  81%|████████▏ | 61/75 [01:21<00:15,  1.10s/it]\u001b[A\n"",
+      ""kmeans iterations:  83%|████████▎ | 62/75 [01:22<00:14,  1.13s/it]\u001b[A\n"",
+      ""kmeans iterations:  84%|████████▍ | 63/75 [01:23<00:13,  1.15s/it]\u001b[A\n"",
+      ""kmeans iterations:  85%|████████▌ | 64/75 [01:24<00:13,  1.20s/it]\u001b[A\n"",
+      ""kmeans iterations:  87%|████████▋ | 65/75 [01:26<00:12,  1.24s/it]\u001b[A\n"",
+      ""kmeans iterations:  88%|████████▊ | 66/75 [01:27<00:10,  1.22s/it]\u001b[A\n"",
+      ""kmeans iterations:  89%|████████▉ | 67/75 [01:28<00:09,  1.20s/it]\u001b[A\n"",
+      ""kmeans iterations:  91%|█████████ | 68/75 [01:29<00:08,  1.18s/it]\u001b[A\n"",
+      ""kmeans iterations:  92%|█████████▏| 69/75 [01:30<00:06,  1.15s/it]\u001b[A\n"",
+      ""kmeans iterations:  93%|█████████▎| 70/75 [01:31<00:05,  1.14s/it]\u001b[A\n"",
+      ""kmeans iterations:  95%|█████████▍| 71/75 [01:32<00:04,  1.14s/it]\u001b[A\n"",
+      ""kmeans iterations:  96%|█████████▌| 72/75 [01:33<00:03,  1.14s/it]\u001b[A\n"",
+      ""kmeans iterations:  97%|█████████▋| 73/75 [01:35<00:02,  1.15s/it]\u001b[A\n"",
+      ""kmeans iterations:  99%|█████████▊| 74/75 [01:36<00:01,  1.15s/it]\u001b[A\n"",
+      ""kmeans iterations: 100%|██████████| 75/75 [01:37<00:00,  1.17s/it]\u001b[A/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/deeptime/clustering/_kmeans.py:466: UserWarning: Algorithm did not reach convergence criterion of 1e-05 in 75 iterations. Consider increasing max_iter.\n"",
+      ""  warnings.warn(f\""Algorithm did not reach convergence criterion\""\n"",
+      ""100%|██████████| 200/200 [01:37<00:00,  2.05it/s]                             \n"",
+      ""\n"",
+      ""100%|██████████| 75/75 [01:37<00:00,  1.30s/it]                   \u001b[A""
+     ]
+    },
+    {
+     ""name"": ""stdout"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""25-09-22 21:29:14 pyemma.coordinates.clustering.kmeans.KmeansClustering[11] WARNING  Algorithm did not reach convergence criterion of 1e-05 in 75 iterations. Consider increasing max_iter.\n""
+     ]
+    },
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""\n"",
+      ""100%|██████████| 320/320 [00:02<00:00, 148.63it/s]                                    \n""
+     ]
+    }
+   ],
+   ""source"": [
+    ""cluster = pyemma.coordinates.cluster_kmeans(transfeatures, k=200, max_iter=75, fixed_seed=1)\n"",
+    ""dtrajs_concatenated = np.concatenate(cluster.dtrajs)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 55,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 720x576 with 1 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 566,
+       ""width"": 710
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, ax = plt.subplots(figsize=(10, 8))\n"",
+    ""pyemma.plots.plot_density(\n"",
+    ""    *features_concatenated[:, :2].T, ax=ax, cbar=False, alpha=0.3)\n"",
+    ""ax.scatter(*cluster.clustercenters[:, :2].T, s=5, c='C1')\n"",
+    ""ax.set_xlabel('Trp $\\chi1$')\n"",
+    ""ax.set_ylabel('Trp $\\chi2$')\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""markdown"",
+   ""metadata"": {},
+   ""source"": [
+    ""## ITS""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 12,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""100%|██████████| 8/8 [06:16<00:00, 47.03s/it]                         \n""
+     ]
+    },
+    {
+     ""data"": {
+      ""text/plain"": [
+       ""Text(0, 0.5, 'timescale /ns')""
+      ]
+     },
+     ""execution_count"": 12,
+     ""metadata"": {},
+     ""output_type"": ""execute_result""
+    },
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 720x576 with 1 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 507,
+       ""width"": 653
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, ax = plt.subplots(figsize=(10, 8))\n"",
+    ""its = pyemma.msm.its(cluster.dtrajs, lags=[10, 100, 200, 300, 400, 1000, 2000, 3000], nits=3, errors='bayes')\n"",
+    ""pyemma.plots.plot_implied_timescales(its, units='ns', dt=1/50);\n"",
+    ""ax.set_xlabel('lag time (ns)', fontsize=25)\n"",
+    ""ax.set_ylabel('timescale /ns', fontsize=25)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 30,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""100%|██████████| 8/8 [07:30<00:00, 56.25s/it]                         \n""
+     ]
+    },
+    {
+     ""data"": {
+      ""text/plain"": [
+       ""Text(0, 0.5, 'timescale /ns')""
+      ]
+     },
+     ""execution_count"": 30,
+     ""metadata"": {},
+     ""output_type"": ""execute_result""
+    },
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 720x576 with 1 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 507,
+       ""width"": 660
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, ax = plt.subplots(figsize=(10, 8))\n"",
+    ""its = pyemma.msm.its(cluster.dtrajs, lags=[10, 100, 200, 300, 400, 500, 800, 1000], nits=3, errors='bayes')\n"",
+    ""pyemma.plots.plot_implied_timescales(its, units='ns', dt=1/50);\n"",
+    ""ax.set_xlabel('lag time (ns)', fontsize=25)\n"",
+    ""ax.set_ylabel('timescale /ns', fontsize=25)""
+   ]
+  },
+  {
+   ""cell_type"": ""markdown"",
+   ""metadata"": {},
+   ""source"": [
+    ""## MSM""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 68,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""18224it [00:54, 335.16it/s]                                                                                                             \n"",
+      ""100%|██████████| 100/100 [00:04<00:00, 20.63it/s]                                                                  ""
+     ]
+    },
+    {
+     ""name"": ""stdout"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""fraction of states used = 1.00\n"",
+      ""fraction of counts used = 1.00\n""
+     ]
+    },
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""\n""
+     ]
+    }
+   ],
+   ""source"": [
+    ""lag = 6*50\n"",
+    ""msm = pyemma.msm.bayesian_markov_model(cluster.dtrajs, lag=lag)\n"",
+    ""print('fraction of states used = {:.2f}'.format(msm.active_state_fraction))\n"",
+    ""print('fraction of counts used = {:.2f}'.format(msm.active_count_fraction))""
+   ]
+  },
+  {
+   ""cell_type"": ""markdown"",
+   ""metadata"": {},
+   ""source"": [
+    ""## Free Energy Surface""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 69,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 720x288 with 4 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 277,
+       ""width"": 707
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, axes = plt.subplots(1, 2, figsize=(10, 4), sharex=True, sharey=True)\n"",
+    ""pyemma.plots.plot_contour(\n"",
+    ""    *features_concatenated[:, :2].T,\n"",
+    ""    msm.pi[np.concatenate(msm.dtrajs_active)],\n"",
+    ""    ax=axes[0],\n"",
+    ""    mask=True,\n"",
+    ""    cbar_label='stationary distribution')\n"",
+    ""pyemma.plots.plot_free_energy(\n"",
+    ""    *features_concatenated[:, :2].T,\n"",
+    ""    weights=np.concatenate(msm.trajectory_weights()),\n"",
+    ""    ax=axes[1],\n"",
+    ""    legacy=False)\n"",
+    ""for ax in axes.flat:\n"",
+    ""    ax.set_xlabel('Trp $\\chi1$')\n"",
+    ""axes[0].set_ylabel('Trp $\\chi2$')\n"",
+    ""axes[0].set_title('Stationary distribution', fontweight='bold')\n"",
+    ""axes[1].set_title('Reweighted free energy surface', fontweight='bold')\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 70,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 720x576 with 2 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 567,
+       ""width"": 703
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, ax = plt.subplots(figsize=(10, 8))\n"",
+    ""pyemma.plots.plot_free_energy(*features_concatenated[:, :2].T, weights=np.concatenate(msm.trajectory_weights()), ax=ax, legacy=False, alpha=0.8)\n"",
+    ""ax.set_xlabel('Trp $\\chi1$ (radian)', fontsize=30)\n"",
+    ""ax.set_ylabel('Trp $\\chi2$ (radian)', fontsize=30)\n"",
+    ""ax.set_xlim(-np.pi, np.pi)\n"",
+    ""ax.set_ylim(-np.pi, np.pi)\n"",
+    ""ax.set_aspect('equal')\n"",
+    ""\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""markdown"",
+   ""metadata"": {},
+   ""source"": [
+    ""## PCCA""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 71,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""data"": {
+      ""text/plain"": [
+       ""PCCA(P=array([[2.33586e-02, 0.00000e+00, ..., 1.90558e-02, 3.46157e-03],\n"",
+       ""       [0.00000e+00, 3.10314e-02, ..., 0.00000e+00, 7.69427e-08],\n"",
+       ""       ...,\n"",
+       ""       [2.36801e-02, 0.00000e+00, ..., 2.10649e-02, 2.63510e-03],\n"",
+       ""       [9.03877e-03, 3.13857e-04, ..., 5.53701e-03, 1.76045e-02]]),\n"",
+       ""   m=6)""
+      ]
+     },
+     ""execution_count"": 71,
+     ""metadata"": {},
+     ""output_type"": ""execute_result""
+    }
+   ],
+   ""source"": [
+    ""nstates = 6\n"",
+    ""msm.pcca(nstates)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 72,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAACGUAAAHtCAYAAAC6K1GLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAABYlAAAWJQFJUiTwAAEAAElEQVR4nOzdedxtY/3/8df7OOYhRITqGMpUfEUKDSdJKIkoMqRS+aa5FJVCacD3961onkQkmYpkKB3J1NfUIfNM5uHgTI7jfH5/XGvb695nD2vP0/v5eOzHve51X3td6z7DZ691rc/1uRQRmJmZmZmZmZmZmZmZmZmZmVlnTer3CZiZmZmZmZmZmZmZmZmZmZmNIidlmJmZmZmZmZmZmZmZmZmZmXWBkzLMzMzMzMzMzMzMzMzMzMzMusBJGWZmZmZmZmZmZmZmZmZmZmZd4KQMMzMzMzMzMzMzMzMzMzMzsy5wUoaZmZmZmZmZmZmZmZmZmZlZFzgpw8zMzMzMzMzMzMzMzMzMzKwLnJRhZmZmZmZmZmZmZmZmZmZm1gVOyjAzMzMzMzMzMzMzMzMzMzPrAidlmJmZmZmZmZmZmZmZmZmZmXWBkzLMzMzMzMzMzMzMzMzMzMzMusBJGWZmZmZmZmZmZmZmZmZmZmZd4KQMMzMzMzMzMzMzMzMzMzMzsy5wUoaZmZmZmZmZmZmZmZmZmZlZFzgpw8zMzMzMzMzMzMzMzMzMzKwLnJRhZmZmZmZmZmZmZmZmZmZm1gWT+30CZmZmZmZmZmZmZjY4JP0y23w6Ij7V15MxMzMzM2uTpLWBtYEVgDnAQ8A1ETGvJ/1HRC/6MTMz6yhJryer+BQRf+/z6ZiZDSVJKwNLAkTEPX0+HTOznpE0CViZ9LBxdp12LwD2ArYAVgJmALcDZ0XE5T04VTOzvpC0AAjgsYh4Ub/Px8xsnElaA3gF6Xo0/yDx2b6emJnZgJP0QuDTwAeBVas0mQucCxwREVd39VyclGFmZsNI0hxgMSAiwpWfzGxsSHonsAuwPrAc8DBwOXBSRPyryWP9GdgWx1IzGxOS3gZ8AXgDsEi2ezpwVEScVNF2V+CnwAtqHG4a8OGIuKM7Z2tm1j9ZUgbAo07KMDPrPUmLAB8CPgWsV6XJbOAc4NCIuLGX52Zm1i+SVgF+ln37n4j47zpt3wycBLwIUO5HUeX7AL4REYd29ITz5+OkDDMzG0ZZUsbipAeJizRqb2Y27CS9GPg9abb287tJNw1kX38PfDoiHip4zD8Db8Ox1MzGgKQjgINK31b8OICfRMTHsra7AKeQKrNFxXvyAzj3A1Mj4rZunbeZWT+4UoaZWWdJ+kK2eUdEnNqg7YuAs4DNaPwg8TngUxHxow6erpnZQJK0OynRIoDDIuLwGu22AC4ke4bEwmMAeaWfB3B0RHyxoyddOicnZZiZ2TByUoaZjRNJKwFXAFMo3yRUG5gJ4BFgn4g4v8BxnZRhZmNB0geBn2ff1hqQCeD9wB+BO0nrzJba3gfcS6qasR7lZA0BVwOvCQ+wmNmAkPRcJw6Tfa0V21xpzcysCblkt/MiYoc67ZYBrgReTvX7/7z8WMD+EfGzGu3MzEaCpJ8AHybFvY0j4voqbRYFbgFeRjlOXgGcAFwFPAYsAaxJqiC8D7AM5Xi6XURc0Olzn9TpA5qZmZmZWcf9mHSjUDIHuAA4GbiMiYPlLwL+JOmjvTs9M7PBJWlp4CjKJUnnAb8EDiCVgz6dchw9FNiXckLGDcCWEfHSiNgqIl4JvBj4CeXB8U2y95iZDQp14FXkWGZm1nnHAK/Iff8IcBgwFViXdO25J3A2E5M2/lfSWj09UzOz3tss+/pUtYSMzD6UEzIWAB+NiC0i4ocRcUVE3BYR10fEWRHxCWAD4P+y9wqoWn2jXa6UYWZmQ8mVMsxsXEh6JTCd8gPDk4EDImJGrs1qwBdJDxhLg+QBfDEijq5zbFfKMLORl6uSEcDjwNYRcV1Fm52A00jx835gdeBuYJN8vK14z/8An8mOe3lEbNWt38HMrBm52djQveQJXz+amTWhSKWMLKniZsoTqs8D3hsRT9dovxNwIrBktuuH2QNGM7ORJOlxUgXLKyPitTXanAm8kxRzvxIR3ypw3BWAG0mT3QJ4WUTc16nzBnCJOTMz6xpJv+zi4Rft4rHNzAbJPrntP0XEnpUNIuJ+4FOSTgN+C6xKGoD/jqSlI+Kw3pyqmdlAeltu+6DKhAyAiPiDpOOAD5ISMgI4uFZCRubLwF7AysDrJC3foL2ZWT/8Bbikhfd9jRQL55CqDZmZWfftDSxCir/XAztHxDO1GmfXsPsDx5feL+mTXlbPzEbYMtnXJ+u02ST7Ogf43yIHjYgnJP2QVD0T4PWkiXEd46QMMzPrpn2pvf6smZkVs2Vu+3P1GkbE3yVtTipjujEpMeOrkpaKiC928RzNzAbZf2VfnyHNJKzlN6SkDEhLnJxW76ARMVfSqcB/Z7s2Af7W+mmamXXMX4BtSPfjWwO3kyqoPVX0AJK+lm3OdoKvmVnPvCm3/eV6CRklEfEbSZ8hXYsuSxoLuLY7p2dm1nczgBcCy9dpszLpOnh6RMxt4thX5LZXbfrMGpjUuImZmVnbOrGerdeuNbNxtTbpRuK2iLi1UeOI+A/wRuAf2S4Bn5f03a6doZnZYCuVH72pwYDMv7KvAdwYEc8WOPY/c9tew9vMBkJEbAt8iDRoPQn4CHCDpHf387zMzKyhl2dfZwN/buJ9v89tv6pzp2NmNnAeII11ri2p1nOi2dnXZhIyKtt3vFK7K2WYmVkvBPAgacZhp7ysg8cyMxtkK2Rf7y36hoh4WtK2wJnAtqSblU9IWiwiPtb5UzQzG2il8qaPNWg3I7fdqG1Jfo3ZFxQ9ITOzbouIX0k6B/ghsDOwGnCKpLOAj3d6jWwzM+uIFSknCD/XxPumVxzDzGxUXUlKPlueNCntoipt7iTFwnWaPHa+/YOtnFw9rpRhZmbddDflqhafjIg1O/UilZ82MxsHpZnaSzXzpmw2+DuBP2a7BHxU0s87eG5mZsOgNNul7kyXirW3i1TJgLRGbcmSzZyUmVm3RcRDEfFuYDfSwLKAHUlVMz5ZZ3ahmZn1x4Ls64wm3/dkbnuZmq3MzIZffpnRb9Zoc0b2dXVJWzdx7Pfntm9o6qwKcFKGmZl105W57c36dhZmZsPtEdIA+hrNvjEi5gHvBk7Ndgn4gKRfexDezMZIqerFC7tw7Pyg96wuHN/MrG0RcRqwAfBr0vXgMsD/ApdJ2qif52ZmZhPcn31talJGRXtPZDOzUXYe5YSJ10n6WZU2P6M8DvAzSas1OqikLwOvJ1UrujMirurEyeY5KcPMzLrp/3LbTsowM2tN6UZjdUkvafbNWcnT3YETs10C9sq+93KGZjYOStXb1irQ9ursdUvBY6+S2364yfMyM+uZiJgRER8A3gbcRYqLrwGulPRtSUv08/zMzAyAy0nxec0m35e/Jn28c6djZjZYsnHO/XO7PijpMklb5to8AuwHPAdMAa6VtL+k5SqPJ+k1kk4HDs/t/k43zt1JGWZm1k2lShkCNu3niZiZDbF81aEdWjlARCwA9gF+mdv9XuDNbZyXmdmwuDH7uoSkV9ZrGBGbRcRrIuLTBY+dn2F+RysnZ2bWSxFxAfBK4BjSTMDJwIHA9ZLe2s9zMzMbE2+T9Fy1F2kCBcCqkl7cxDE3zm3f07lTNTMbPBHxD+AjuV2bAxdLulXSTyQdACwCHEt6NrUS8APgMUk3S7pU0lWSHiMlw+2UtQM4JyKqVd9om5MyzMysm64iDfIE8AJJ6/T5fMzMhtGFue0PtnqQSPYDfkj5RsP3A2Y2Dqbntt/Y4WO/Kfv6HPCvDh/bzKwrImJ2RHwKeANwE+VZ2edKOkHSSn09QTOz0acaL0jjqNDcpIy35Lavb/vszMwGXET8gjQBbSblGLo2qULG94HfA5+i/HxKpESNlwOvBTYBVmBi/P09aRnorvAgrJmZdU1EPAncTvmDrZNLmHwDOIyJZaXMzEbRpcAT2fZmkl7XzsEi4uPA/5DicjRobmY2Ci7NvgrYsVMHlTSFdH0bwHURMadTxzYz64WIuIw0u/oIYD4pTr6PlKgB5QFqMzPrjPzDv3o/F+nBYuMDSusC/0W6Jn0gIh5s8xzNzIZCRJwIbAj8gfIYpyq+Pt8894KJY6J3AXtGxHsjYl53ztZrSJuZWZdFxCu6dNwjunFcM7NBExHzJZ0JfCDb9XWgrdLSEXGgpNnAIW2enpnZMJgOHEQalOnkAMvnsq8Czuvgcc3MeiYingUOkfR74BekpUdXoDyj0MzMOmPNJtsXnURxYPZVwLQm+zAzG2oRcR+ws6Q1gQ8BbyMtM7oota9lFwB3An8DTgf+EhHzu32uivDkODMzMzOzQSZpcWCZ7NuIiMc7dNzXAEtlB72oE8c0MxsXWeWixbNvb4iIR/p5PmZm7ZI0iZRwdiiwZLb70Yh4Ud9OyszM6pK0AenhI6RKGQ/383zMzPpN0mLA+sBKwPLAEsAs0lInjwI3RcTcnp+XkzLMzMzMzMzMzMzMDEDSCsBy2bfPZTMQzczMzMysRU7KMDMzMzMzMzMzMzMzMzMzM+uCSf0+ATMzMzMzMzMzMzMzMzMzM7NR5KQMMzMzMzMzMzMzMzMzMzMzsy5wUoaZmZmZmZmZmZmZmZmZmZlZFzgpw8zMzMzMzMzMzMzMzMzMzKwLnJRhZmZmZmZmZmZmZmZmZmZm1gVOyjAzMzMzMzMzMzMzMzMzMzPrAidlmJmZmZmZmZmZmZmZmZmZmXWBkzLMzMzMzMzMzMzMzMzMzMzMusBJGWZmZmZmZmZmZmZmZmZmZmZd4KQMMzMzMzMzMzMzMzMzMzMzsy5wUoaZmZmZmZmZmZmZmZmZmZlZFzgpw8zMzMzMzMzMzMzMzMzMzKwLnJRhZmZmZmZmZmZmZmZmZmZm1gVOyjAzMzMzMzMzMzMzMzMzMzPrgsn9PgEzMxtvkpYE3g28AVgfWAFYClDBQ0RErN2l0zMzGwqOpWZm7XEcNbNx47hnZjZ4HJvNzNo3qLHUSRlmZtY3kvYHvgUs1+ohgOjcGZmZDR/HUjOz9jiOmtm4cdwzMxs8js1mZu0b5FjqpAwzM+sLSd8ADqZ4dqKZmVVwLDUza4/jqJmNG8c9M7PB49hsZta+QY+lTsowM7Oek/Ra4EuUMw7nAqcBFwP3AbP6dGpmZkPDsdTMrD2Oo2Y2bhz3zMwGj2OzmVn7hiGWOinDzMz64WO57RuBt0fEXX06FzOzYeVYambWHsdRMxs3jntmZoPHsdnMrH0DH0sV4SWmzMystyTdAUwhZS3+V0Rc198zMjMbPo6lZmbtcRw1s3HjuGdmNngcm83M2jcMsdRJGWZm1nOSZgOLAzdHxAb9Ph8zs2HkWGpm1h7HUTMbN457ZmaDx7HZzKx9wxBLJ/X7BMzMbCzNzr7+p69nYWY23BxLzcza4zhqZuPGcc/MbPA4NpuZtW/gY6mTMszMrB/uBgSs0O8TMTMbYo6lZmbtcRw1s3HjuGdmNngcm83M2jfwsdRJGWZm1g9/zL6+UtIyfT0TM7Ph5VhqZtYex1EzGzeOe2Zmg8ex2cysfQMfS52UYWZm/fBz4GlgUeCTfT4XM7Nh5VhqZtYex1EzGzeOe2Zmg8ex2cysfQMfS52UYWZmPRcR/wH2J5WT+pqkHft8SmZmQ8ex1MysPY6jZjZuHPfMzAaPY7OZWfuGIZY6KcPMzPoiIn4L7Ak8B5wh6ZeSXivJn01mZgU5lpqZtcdx1MzGjeOemdngcWw2M2vfoMdSRUS/z8HMzMaMpDty364MLA2UPpDmAY9lX4uIiFi7g6dnZjYUHEvNzNrjOGpm48Zxz8xs8Dg2m5m1bxhiqZMyzMys5yQtoPyBOOFH2deiH04ifUAu0pETMzMbIo6lZmbtcRw1s3HjuGdmNngcm83M2jcMsXRypw9oZmZWkFr8mZmZlTmWmpm1x3HUzMaN456Z2eBxbDYza99Ax1InZZiZWT+8ud8nYGY2AhxLzcza4zhqZuPGcc/MbPA4NpuZtW/gY6mXLzEzMzMzMzMzMzMzMzMzMzPrgkn9PgEzMzMzMzMzMzMzMzMzMzOzUeSkDDMzMzMzMzMzMzMzMzMzM7MucFKGmZmZmZmZmZmZmZmZmZmZWRdM7vcJmJmZlUhaA3gdsA6wArA4MAN4BLgKuDoi5vXtBM3MhoBjqZlZexxHzWzcOO6ZmQ0ex2Yzs/YNUixVRPSiHzMzs5ok7Q18Enh1g6azgBOA/4mIO7p+YmZmQ8Sx1MysPY6jZjZuHPfMzAaPY7OZWfsGMZY6KcPMzPpG0mrAb4A3lXYBkX3Ny+8LYA7wuYj4SS/O08xskDmWmpm1x3HUzMaN456Z2eBxbDYza98gx1InZZiZWV9IWhn4B6lsVP4DMYC7gUeBecCywJrAMrmflz5ID4yI/9erczYzGzSOpWZm7XEcNbNx47hnZjZ4HJvNzNo36LHUSRlmZtYXks4GdqD8gfd/wHeBsyPi6SrtXwnsA3wMWJLyh+QWEfHPHp22mdlAcSw1M2uP46iZjRvHPTOzwePYbGbWvkGPpU7KMDOznpP0JuBvpA84gC9HxLcLvncK8CdgPdKH5LSI2Lob52lmNsgcS83M2uM4ambjxnHPzGzwODabmbVvGGLppE4f0MzMrID35Lb/t+iHI0BE3AVsCzyV7XqjpFU6eG5mZsPCsdTMrD2Oo2Y2bhz3zMwGj2OzmVn7Bj6WOinDzMz64U3Z13nA15t9c0T8B/hp9q2AN3TovMzMholjqZlZexxHzWzcOO6ZmQ0ex2Yzs/YNfCx1UoaZmfXDi0llpK6PiCdbPMbfc9urtX9KZmZDx7HUzKw9jqNmNm4c98zMBo9js5lZ+wY+ljopw8zM+mGp7OvTbRwj/94l2ziOmdmwciw1M2uP46iZjRvHPTOzwePYbGbWvoGPpU7KMDOzfniUVAJqrTaOsWbF8czMxo1jqZlZexxHzWzcOO6ZmQ0ex2Yzs/YNfCx1UoaZmfXDLdnXl0jassVjvK/K8czMxoljqZlZexxHzWzcOO6ZmQ0ex2Yzs/YNfCx1UoaZmfXDObntn0haoZk3S/oQ8Nbs2yeBSzt1YmZmQ8Sx1MysPY6jZjZuHPfMzAaPY7OZWfsGPpY6KcPMzPrhONIHG8AGwKWSXt/oTZKWlHQE8JNsVwA/iojnunKWZmaD7TgcS83M2nEcjqNmNl6Ow3HPzGzQHIdjs5lZu45jwGOpIqLTxzQzM2tI0v7AD0kfcsq+XgucDUwHHgPmAcuS1gF7HfBOYLmsPcAdwH9FxMxenruZ2aBwLDUza4/jqJmNG8c9M7PB49hsZta+QY+lTsowM7O+kfQN4EtM/JCs+5Zc2/8Ab4yIO7t6kmZmA86x1MysPY6jZjZuHPfMzAaPY7OZWfsGOZZ6+RIzM+ubiPgKsDPwQLZLlDMS89tUbP8W2Ng3GmZmjqVmZu1yHDWzceO4Z2Y2eBybzczaN8ix1JUyzMys7yRNBnYhfVi+FphS0WQOcDXwd+BXEXFbT0/QzGwIOJaambXHcdTMxo3jnpnZ4HFsNjNr3yDGUidlmJnZwJG0CLA8sDjwZETM6u8ZmZkNH8dSM7P2OI6a2bhx3DMzGzyOzWZm7RuEWOqkDDMzMzMzMzMzMzMzMzMzM7MumNTvEzAzMzMzMzMzMzMzMzMzMzMbRU7KMDMzMzMzMzMzMzMzMzMzM+sCJ2WYmZmZWUOS1pL0TUnXSnpc0mxJt0s6SdIOXepzkqTdJf1B0t2S5kp6WNIVkr4saZUmjrWapB0lHSrpbEkPSIrca0qL5/g2Sb+SdL2kGZLmS3pS0o2STpS0S7ZmoZmZmZmZmVnfDfv9fXa8lSR9SdI0SQ9Jmpcd70pJhzd7j5+d326STpZ0p6RZkmZKulXSryW9ralf2MzMrIIiot/nYGZmI0jSL3PfRkR8qMbP2jXh2GbWeZIOAI4ClqzT7Ezg/RHxVIf6XAM4GdiqTrPHgf0i4owGx/o28MUGXa4ZEXc1cX6rAycBbyzQ/Dpg94i4oejxc/04lpqZtcFx1MzGjeOemdUz7Pf32fH2A74HLFWn2WzgoIg4psDx1gN+B2zUoOkfgX0j4olGx6zSh2OzmVmbhj2WOinDzMy6QtIC4PkPmYhYpNbP2pU/tpl1lqT9gR/ldk0HziUNcGwM7AhMzn52IbB9RMxrs88VgEuA9bNdc4DTgZuBFYCdgLWyn80HdoyIc+sc77vApyp2Pw6smPu+cFKGpOWAq4G1c7svAa4BHgJWATYFtsj9/DFg44j4T5E+cn05lpqZtcFx1MzGjeOemdUyIvf3nwOOzu26BzgbuA94AfAm4HW5n38mIr5b53gvBy4DXpjteiY73nWkeLl+do6lJJbLgG0iYnatY9box7HZzKxNwx5LnZRhNUm6E1gOuKvPp2LdNQV4KiLWrPZDSScC67Vw3JsiYs92TsyGW/YhWBJVPiA7JQb5ZsOxdCxMoTtxFPocSyWtDdwALJbtOjgivl3RZhPgz6REBIAvRcS32uz3F8AHs29vIg0E3ZX7+SLA94GPZbseAdapNYtH0tdIM3KuKr0i4k5J+QvhZpIyjgC+lOt754i4pEq7qcCplAd3fhER+xXpI3eMsY+ljqNjYwq+JrUucBxNHEvHxhRqxNJhvia15jjudYfj6NiYgu/vB/b+XtKrgGuBSdmuo7NzfLai3U6kypZLAc8Bm0TEdTXO7wpg8+zbfwHvqhwbkLQacEau3dERcWC937tKP47NOJaOkSn4mtS6YNhj6eTGTWyMLbfkkkuuuP7666/YuKkNqxtvvJE5c+bUa7Ie8OoenY6NlsNa/NmocSwdcSMeRw+nPGBzUuWADUBEXCNpH+C8bNdBkn4UETNa6TArG7pv9u2zwK6VAyIR8ZykT5Bm8mwFrAx8HvhqtWNGRKdjzrtz21+slpCR9TtN0kHAz7Jd27fQl2Op4+hYGPFYav3lOJo4lo6BBrHUcXR8OO51h+PoGBjxa9JRuL//IuWEjLNqJUZExB8kfQb4CbAIabmW7aqc3zaUEy1mA++IiPuqHO9+STsCt5CqcXxS0rERcXeNX70ax+bEsXQM+JrUumioY6mTMqyeu9Zff/0Vr7rqqn6fh3XRpptuytVXX31Xv8/DRk+9h6BdeEA6yBxLR9yoxlFJywC7ZN8GaQCnqog4X9LlpBKhywHvAo5rses9KQ+ynBoR/67R5wJJXyeVWgXYmxpJGV0wJbd9aYO2F+e2V2q2I8dSwHF0LBSNpZMaNcjp5BQJG16Oo89zLB0Do3pdas1x3Osax9ExMKpxdITu7/MTHf63Qd+/BL5NWiJlW0mrV1lONH+8U6slZOTO8WFJJwAfJyW3vA8oXEXEsfl5jqVjoEgsbebeHnx/b8mwx9Jm/92bmZmZ2XjYFlgi254eETc3aP/73PbObfS7U277lAZtLwBmZNtTslKrvZBP92+UaLFybruZWTRmZmZmVkHSWpK+KelaSY9Lmi3pdkknSdqhS31OkrS7pD9IulvSXEkPS7pC0pclrdL4KBOOt5KkL0maJukhSfOy410p6XBJU7rxe5jZWBv6+3tJywP56gp1n+pHxHzSciQAopyUkrd20eNlrsxt71qgvZmZ2fOclGFmZmbWZSJNo2jmpb6c6QT5UoL/KNA+XxGipeQISYsDGxTtNyIWMLFSRa+SMvK/62clVf3rkjSJVHa15PiunpWZDbxePUyUtJSkqZIOlPQ7SVdLuifrb46kByT9VdIhkl5W8JiTJW0t6QhJF0i6L3swOVvSvZL+JOlT2YB5u+c/SdKlkiL3OrTd45qNuyG9Jn2epAOA64GDSWXuVwCWBNYC9gD+JOkMSct1sM81gL8DvwXeCbwUWJyUeLs58A3gBkmFHlpK2o+UqHsE8CbgRcCi2fE2BQ4B/p2V8jezATW5ydcAGIX7+yUrvq+7zkyVNptW+Xn+mM0e71WSFi3wHjOrIJqPo4N0TWrWqgG5JjCzQedS0dZJkt6YbT4eEde3eIwNyGaoR8TfO3VuZgNmkqTVavzs6Yh4uot9b5jbvrVA+9ty2y+RtFxEPNVkn+uR1nsFmBERjzbZ74Y1W3XWEcAOpHPdBbhI0tHANcDDwCqkQa8vAFtk7zkbOLKTJ+FYauOm9DCxqGdItZkHRfYw8SgWHlBeK3vtIelM4P0txM9KuwAn1Pn5qtlra+Arkr4DfC0iqv6RSfoo8E0mzk7MWyN77QAcKumTEVGv/0Y+Qzl+do3jqNnwkLQ/cGxu13RSmfvZpASNHUnjnO8CzpC0fUTMa7PPFYDzgfWzXXOA04GbSQkhO5Hi94rAKZJ2jIhzqx0rO97ngKNzu+4hXSPeB7yAlKTxOmAp4PuSFomI77bzO1Q5B8c9s/7x/X1z/Vbe3z9e8f1LgdsbHO+lue1XVvn5YzXaFjneosC6pGTBtjg2m5m1bxhiqZMyzMysH6aRnpOcRxq8b8URpJlKgT/PbHStAlSueVpyGHBoF/teNbddc13Vkoh4QtIsYOls1ypAs4M2TfWZubfG+7smIq6QtCNpxuQLgDdkr2puBH4MHFPrYWcbpuFYajYU+vEwMfMMqWzzjaR4OZM0w3tN4K3A6qRcl0NIcfujNY6zCeWEjMiOdynpM+o54BWkWLIcsDxwvKTlI+KYZk9Y0iuAr2ffzqO5XJxmTcNx1GzgSVob+F5u18ER8e2KNpsAfybFsq2BzwHfarProyknZNwEbB8Rd+X6PBD4PvAx0v//4yWtU+3BpaRXMTFB92jgSxHxbEW7nYCTSIkZR0v6a0Rc1+bvkTcNxz2zfvH9fWM17+8j4hlJ1wGvyna9C/ifWgeStC4TK3VUGy+4klRpCVKi3SENzq+yKtKqdCApA8dmM7NOmMaAx1IvX2JmZsNMuHqZDYEhLRW9bG57VsH3zK7x/kHusyUR8WfSzJ/DSA89q3kGuAK4uAsJGZ3kWGrWRTUeJm4cEV+MiMMiYhdSCfyHsp+XHia248rsOMtFxGsjYt+IOCQivhMRh0fEB4ApwEG593wkN7OkmkdIMW/tiNgwIj4cEYdGxNcjYm/gZcAfcu2PzgbDC8uWffolqZrITaQZ6cPAcdSGwpBekwIcTjlB66TKhAyAiLgG2Ce366B2llOStB6wb/bts8Cu+YSMrM/ngE8Al2S7Vmbi0nV5X6Q8DntWRBxYmZCRHfMPpGpBkGaYH9Xir9Btjns2toa07P6o3N//Lrf95SyZdyGSlgB+wsQ/+mpLW50OzM+2X5Ul21WVJVlvWbG7Y8tldYhjsw2FIb4mtfHQtVjqpAwza0jAEk28/AFpZjYS8uX1i87WnpvbXmpI+mxJNsj/JdLA++LAZaRB8y9lXy/L9u8LXCnpa706N7NR1ezAzQBdk/b8YWJE3BQRf6tXbSMi5kfEd4BTc7t3r9H8F8CULAnjzhrHmwHsRqoCAul3/kiTp/4pYCvSioj7UTvpzczGhKRlSEsyQZqxdnitthFxPnB59u1ypFnUrdqT8rjpqRHx7xp9LqBc3Qdg7xrH2z63/b8N+v4l8ES2va2k1Ru0NzNrZFTu748hLf0EaRmpyyR9WtIUSZMlrShpZ9L9+JsaHS9LtstXsztS0q8lbS5pKUlLSnq1pJ8APyJdo+Z/l56NQZiZ2fBzUoaZmQ2r0sONTpT2NhtUD5FKy1d71SzT2SFzcttFS8cvkdueXbPVYPXZNEkvAa4izYx8BnhLRGwZEV+IiG9lX7cE3kJa93YScKikT/Ti/JrkWGrWRX18mNiMC3Pba1ZrEBH/FxENY2w26/tHuV1bFD0JSeuQSoUC/DAiLqnXfoA4jpp117aUr/emR8TNDdr/PrddWWa+GTvltk9p0PYCYEa2PSVbSuV5WZLdirldV9U7WETMJy09BSnHcJc6zfvBcc/GWhszvH1/32af2fJQOwIPZrtWJCW63UmqavQYqfrFf5GqvOWrwtVafuVAJlZ724dU8XJWdg5XUU40/gzwZIFj9oNjs5lZ+7oaS52UYWZmw2rt7OuMfp6EWRFtDNosiIj7a7ye7vJp54+/dM1WE+VnibRyfv3osxUnAGtl23tFxIXVGmX787MlvyGpZ0usFORYatZd/XqY2Iz8g8JOJLflK2m8sMgbJInysiX3AAd34Dx6xXHUhsaQlop+dW77HwXaX5zb3qRmqzokLQ5sULTfrFrGpXX6XbLi+zk0lm+zaYH2veS4Z9Ya3993oM+ImE6Ks7+gelW1BcCZpMSMB3P7Z9Q43nzSdfcBlKtwVLodeHtEfJ+Jy6pUPWafODbb0BjSa1IbD12NpZO7cVAzM7NukrQ38ArSjNOb+nw6ZqMqP3ixRqPG2QzA/EDLQ93us0q7VvpsiqTNSGVQAW6KiD/Xax8R50i6GViXNPN9G+CM7p5lMY6lNmxKAzfNtB8APX+Y2AxJK5KWCSmZ1oHD5svsP1LwPZ8A3pBtfzQiZnbgPLrOcdTGyCRJq9X42dNdfpi4YW771gLtb8ttv0TSctnM6masByySbc+IiEeb7HfDip89XvH9S0kP+Op5aW77lQX67wnHPbOhNVL39xHxILCfpE+RKrNNISXAPQRcEhH/AZC0du5tNT9DIiKAH0r6EfAqYCPS8ihPAzdGxBXZ8VZjYjWPIp9LXefYbNYfktYi3U/vQLp2WwJ4gFRt5zcRcU4X+pwEvAfYg5R8tgqpas+dwB+Bn0dEw5gt6ZXAa4DNgI2BFwErkRLPniYlqf0TOLnWZLQGxxfwdlLFty2AVUl/Pg8D/yElNE8DzssqbvZdL2KpkzLMxtk5mxdqNonmBsCfAZ5r5XxsJEmq96G9eYOfTzgU6QZrLSbOuqz7QNSs+xb0+wS65QbKpfNfXqD9Ornt+1oY/Aa4mfQHOglYXtJKBQbB8/1WXeu7w/Kl+K8r+J7ppKQMKPZnuRDHUhttXY2j/XyQCP15mFiXpCWAl5CWWDoIeFn2o1tI1Sra9Z7c9sU1W5XPZy3gW9m3v4mIcztwDtX6cRy1EdfVWLoKafC0msOAQ7vY96q57fsaNY6IJyTNovwwsTRQ3bU+M/fWeD8R8Yyk60gP+iBdY9dcqkDSukys1LFqrbb1OO6ZNatYHBXNP1QZgGThkby/j4hZwF/qNPmv3PZlBY4XpPv36QWOd3dEPNDomJUcm230jew46QSSDgCOYuGKaGtlrz0knQm8v1P39JLWAE4Gtqr40crZa3Pgs5L2i4hGE8KupZyEXGmF7LUx8GFJFwH7REStakKV5/lq4MekpI9KL81eWwCfIy2heleR41b0MZSx1EkZZuOqlJDxpJNnreumkrILK4n04f6mKj+rR7nj3Qf8tOUzM2tbsYm8Qzpoc3Vuu/Jiv5o35LavaaXDiJgr6QbKswG3YuLarhNk2eFbtttvk/KlSqvFtkZavTudWqM/x1Kz+vr5IBH68zBxgiwJo1Gp/GnAe7KB7Xb62hZ4W/btfBokeeSWLVmKVFXj0+3038BUHEdtZI30g8T8tVfRGDWbchxtZem4Vvus9v6S31FOyviypLMi4pbKRlnM/gkT/+iXK3gOlabiuGdmydjd32fx9G25XZ1I/H1XB443FcdmG1kjfU36PEn7A8fmdk0nxYTZpESGHUm/4ruAMyRtHxHz2uxzBeB8YP1s1xzgdFIC3ArATqTEghWBUyTtWHDCwx2kBI07gSdIf4kvAl4LvI70R/8m4B+SNouIhxuc51tIsb50Lf4Q8Nfs+HNIYySrAa/P+mnVVIYwljopw8zMeqHWdVOr11PPAWcDn4mIGS0ew8zqOw+YSyott7GkV1QbOM7ZNbfdzvIcf6A8aLMbdQZtSLO8V8i2746Iq+u07ZT8zJ6NCr4n367pmTQ5jqU2gornKTVbvW0SA1G9rR8PE5vxMHBARJza7oEkrUpa27vkmIhoVB3kAMqDJZ+MiMfaPY8GHEfNhk9+9mHRwey5ue2lBqTPY4CPkGYGrgBcJunrwJmkgd/lSPHwq6SZ2KXr8FrHK8pxz6yQkZ/ZPY739x+knNR2TURc3s7Bsmvd3XO7ftjO4Zrc34hjs1mPZMsifS+36+CI+HZFm01IlRZWAbYmVYT4Fu05mnJCxk3A9hFxV67PA4HvAx8jPfs/XtI6dap07AVcWC/JQtLmpMSP1UnVNr9Niq212q8PnEW6lp4HHAj8qNryJNkEjVdTfMnTql02ub+RrsdSJ2WYjZuCS5bkDen63TY4PlDxfWlGZADXA/+v4HEWkB5mPAhc14Ny42Z1DMVS922JiJlZmb3dSf9vDwH2rtZW0jaUZ7Q8TRpcbtWJwMGk56m7SToiIm6s0uek7JxKTmijz2ZckdteT9K2EXF+rcaS3kF56RKAv7fYr2OpjaCRH/yG/jxMrPQsaTCkZFnSOqlvI81MOVnSicBnW02KkLQkKfaX1gG/lhTL671nTdKgDsBZEXFyK303wXHURlDP4uhDpPWmq+n2/4F8pZ+iQxNL5LZn12zVwz4j4ilJO5IejK5KmsX4v9mr0iPAEcB3s+9brZjkuGdWSHOxtNlx0tJ7+mnc7u+zZaC+kdt1aJvHW4RUxaiUMH16RNRa4qQRx2YbQaMfR3MOp3z6J1UmZABExDWS9iFd9wEcJOlHrT7ol7QesG/27bPArvmEjKzP5yR9glSpYyvSciafJyX8LqTI/XdE/FPSR0mJCpDi+H4RsdBfeBbHf00aAwngXRFRcwmQbLmoqxqdQx1DGUudlGFmZl0VEb+u3CepVMr6P9V+bjbYmk/IGOKbja8C7wYWBfaSND0ijso3kLQxcHxu13ci4onKA0maCvyt9H1EVP0VI+JGSceTbjYWA07LyvzdnTvWIqRB6lJJ1UdJGeNdFxH/knQVsGm260RJu0bERZVts8Gs/J/NWRFxb2W7gv06ltqIGYsHidCfh4kTRMRzVImRWUnnw4AvAPsAr5W0ZUQ83szxJS0GnEYqbwppxvfOEfFMnfeIVFVjadLDxv9ups9WOI6atXVNuiAi7u/0+RSUj9VL12w1UT6hrZVY35U+I2J6NnPyG6TZiYtXNFkA/JFURSi/dMCMgudQ2Z/jnllDY5EkXDIS9/eS9gBuiYiqD/MkbQ/8nHLVjV9HxB/rHG8DUoWi06pdv0paHfgx8I5s1yO0ce3q2Gw2vCQtA+ySfRukBI2qIuJ8SZeTlgBZjrSUyXEtdr0nKbkN4NSI+HeNPhdkldhKy5bsTY2kjCZcmNtehpTs8VCVdu8AXpNtH1cvIaMThjWWOinD6nvyplRZYYd/9vtMrBNaqJJh1iV/J124tJpVPmTG6ibfRkhE3CrpM5TXSTxS0p4svE7iotnPL6IzyRGfB7YgVZhYH7hBUuU6iWtnbecD+0bEk7UOJmll4EcN+vyhpMqHn8dGxLQqbfcHppEG6VcCpkm6BLiEtP7iCqQBpS1y73kI+GSDc2jWGMbSSQ1b2ehqsXpbPx8kQn8eJhYSEXOBL0paCvg4KeYeTZ1ypJUkLQqcAmyf7XoAeEvlrJ0q9gfenG1/ISL+08Spd9KYxVFwLB0lY3OP8WBue42arTKSlmdivK02aNzRPqu0q9lnRDwI7CfpU6RrxSmkGYUPAZeU4mFWGruk0VJQzRjDuNdpjqM2nEbl/h54O3CSpNtJ9+B3kGaOv5i0TMAGubZ/BD7a4PxWI1X0+Imki0gzrGcAy5P+TLamfBvyMPDWeuX+WzSGsdmxdHSMzTUpwLaUJ1FMj4ibG7T/PSkpA2BnWk/K2Cm3fUqDthdQjmFTJG0SEde02C+k6m55c6q2SsumlDQag+2WgY+lTsows4a8fIl1WkRM7fc5mFkxEfGDrATdkWTrz2avSmcBe9ebGd1En49J2hY4mTR4sxRpNmGlJ4APR8SfGhxyadKMoHq2r7Lv7Cr7iIgrJb2VNINonWz3VtmrmmuA9xV4SNkUx1IbXmM1aNOPh4nN+hZpVraAPSV9PCIaVujIEjJ+R3mA6EHgzQ3WJy/9jkdm3/4d+GmL5902x1GzoXADaWYhwMsLtF8nt31fnXW067mZ8tOi5SWtFBGPNtFv1dmLeRExC/hLnSb/ldu+rNHxinLcM8tr7Zp0iCthjsr9fcnalJM5Ks0FjgIOj4j5BY+3DCnh4+01fn4B8N8RcXvB4xXm2GzjZojj6Ktz2/8o0P7i3PYmrXQoaXEmJpvV7TerlnEpsEOu33aSMr6Q27662rV1do6lSRezgKslLU1Kinsv6Rp+CVJi22WkZV/OauOcqhqGWOqkDDMbC5LWAvYjfRi9lPQh8ABwBfCbiDing30tQvqg3JRULntT0g1OaU3xizr1ASFpI+BKylnsAGu2+uAv+7CcDqyV2/2BiDiu1XM0Gy3NL10CQ32zAUBEHCPpHODDpOSFUhx9kBRHT2hi4KRon/dIej3p4n0P0sD0KqRZ43eSZrz8LJtt2HMRcZmkV5Iy3Xci3ZitSnqYOgu4H/g/4FTg7GrrLZrZWOjHw8SmRMT9kh4llSFdjDSDse7arrmEjJ2zXQ8BWxeYKQRpxs4y2fYbgQVpNZOGvibpa9n23RExpcibzEbTWD1IvDq3XSsBNi+/7EdLA9ARMVfSDcArc/3+oVb77AHnlu32mzveEsDbcrvOrdXWzKxZI3B/fyjwT2AqsF52nGVIy4rcAZxDeuB3T8HTuyw7r6mk0vurkSpiziTd118M/D4i/lbrAGbjq+dDXZMkrVbjZ09HRLeXKN0wt12kktltue2XSFquhXv89YBFsu0ZBRKFK/vdsGarKrJnWy8kPdP6b1IFJUh/2QfXeNurKd9m3JH1eToLJ869LHvtLumvwHuaXT512Dkpw2xcjPHSJZIOIGVHL1nxo7Wy1x6SzgTe36GB7/+Qbgi6StJkUsmrRRs0bca3mZiQYR0zk/LzB7Phk80GOSh7tfL+aTQ5rp8lMvw2e7UsS1Tr+DOFbNbQydnLzAoZu/yknj9MbFF+bGCRmq2YsGTJu7JdD5MSMm7szqmZ2Zg7jzTjeQlgY0mvaFCRZ9fc9hlt9PsHykkZu1EnKQN4C6kEP6SksavrtC3ig6S1xwGuiYjL2zyemXWQaP6hygAkuE0w5Pf3twHfz15tyyoXnULjJQHMrP9WIT17qeYwUtJWN62a276vUeOIeELSLMrVMFcBmn3+1FSfmXtrvL8qSSeTktNqeZxUAfj8Gj/PT0BZipRQ/GLSUid/JFWRWwx4PSkBDtL184WSXpctrToWnJRhZiNN0v6U10qEVAWicq3EyaRB5TMkbR8R89rsdomK74O0jtcKCzdty8Gk8lPzaH7C00IkvZFUuppOHdPMzKyzvO7s8JtEr2Z4D8jgd78eJhYmaW0mXqfWHOjJEjJ+T3nJkkdICRk3NNHlTODXBdu+nvLsmn8B12bbRWYHmdkIiIiZ2SSK3Umh/RBg72ptJW1DuWLF08CZbXR9IumeexKwm6QjqiWfZVUyDsntOqGNPpG0LvCN3K5D2zmedYuvSc3MzFo1xMlty+a2ZxV8z2zKSRnL1mvY4T6rvb9ZAfwAODgi6pWPzo8nlO7f/w28PSLuzjeUtD1pTGFp0vO5rwMHtnGOQ8VJGVbMOZvDDv/s91lYO3b4Z8vVMiaxcJZBo/aDIBtg/l5u18ER8e2KNpsAfyZlKW4NfI60rnY7bgFuJ5V9vpI0Q3IX4FdtHvd5kl4FfCX79ghSJmg7x1sK+CXp+uZC0gzJN7VzzAb9PdfBw0VE+PPMBtqQloq2AedYajb4+vgwsRn568h/R8T91RrVScj4dzOdZeVW9y3SVtJxlAd1zoyIQ5vpq8DxxzSO+mHi8GstwW2IB8C/CrybVCVyL0nTI+KofANJGwPH53Z9JyKeqDyQpKnA8yXoI6LqrxgRN0o6nhSvFgNOyyZxPD+wnJV3/i7lKkePAkfX+iUk7QHcEhFVl4jKBql/Tnlg+9cR8cdax2vF+MY9M7PBNb6x2dekw6/1SRdDKl+JvejE3nwViKUGtM/fkJ5jASxOqnLxRuBVwMeBqZIOiIi/13h/ZeLHHOCdlQkZABHxZ0mfID2LAvjvLPl5RoHzrGsYYumQBGcbCL9dD2bNhP2KVsgx67vDKT8HPakyIQMgIq6RtA9pFiPAQZJ+1M6HQEQslP1ScJ3sQrJlS35F+t2uJyWRtJWUkR1jbVIW5UeAX7R5vEZEyrQckDG+XplJunZasd8nYi1bhvT3aDYQxjSWlm74PXhjQ6OnDxMlvQA4jfRg8C8RMb/aSUlaibTE35653QtdL2dtayVkXF+t/RAZ0zgKHgS3YRIRt0r6DOUqmEdK2pOFq2CWlva8iDrJEU34PLAFsC6wPnCDpNOBm0mJEztRThybD+wbEU/WOd7bgZMk3Q5cQlpz+1nSwPfWwAa5tn8EPtqB36HSGMe9TvM16fBrPcHNky6sw8Y4Nvua1JryELBZjZ893YP+5+S2i34U5Oc7z67Zqo99RsTZwNmV+yW9jVQF7pXAXyXtGhHVlvSbU/H9yRFxR50ujydVyFidVDFjKp2ZlDLwsdRJGdaUx6b/hxf2+yTMCpC0DKk6BaRAfHitthFxvqTLgdeR1m19F3Bcl0+xHV8ENiVdtX4oIp5tJ+lD0utJGY8AX42I2zuZRFKv6xbfF22+fwA8jhMzzKxDxjiW2vDqzQD4oPzj7sPDRJHWZ30L8LikK4AbSRcgC4AXkma8TGXiH+lPI+I3NY75A8oJGQDnANtJ2q7A+fw0IppdN7eXxjiOehDchkdE/CBbKuRIsiWhslels4C9I+KZDvT5mKRtgZNJyRlLAXtVafoE8OGI+FPBQ69NOZmj0lxSwtzhtZLqOmCM456Z2cAa49jsa9Jx00Zy24JalR17JJ/4sXTNVhPlK1W0kjjSjz4BiIjzJL0DuIyUT/ArSWtWSUKu7OPCBsd9TtJFwPuyXa+mc5VCBzqWOinDmnLLzeku1MbLkA6Ab0s5I3B6RNzcoP3vSUkZADszoEkZkjYkzbYE+F5EtLWukKQlSaWiJgH/Ryq92gtrNtF2EWB5YCNSwsw7SP/MjiMl20SN95kNjEk0f7Ph21ErYMxjqQdubHj0+GFi/v/zisD22auWJ4FDIuKYOm1eUfH9+5s4n1OBQU3KGPM4auNm2Gd3R8Qxks4BPkyKay8lxdQHgSuAE5pIjCja5z3ZRIb3AnsA/0Va/vRp4E5SRYufRcSDBQ53KPBPUlLcetlxliFVH7qDlPB2UkTc08nfoYLjXsf5mtTM2ubYbDYc8td7azRqLGl5JiZSPNTtPqu0a6XP50XEPyVdALyNVCluN9Jye3kPVHxfZLmFfJuVWj/DCQY+ljopw5p23pbplvxtl/rz3Qbaq3Pb/yjQ/uLc9iYdPpeOyNarLS1bcifwlQ4c9gjg5aSSqR+KiE6uu1VTtfXECrgaOE7SVqQkmvcDiogPdPTkemIe6Xpq1X6fiJkNMcdS8CC4DZNePUyMiCclrU5KUt6SVBVjTdIAyiTSg8QHgH8B5wOnRUQvSr0OHMdRcPl9GzYRcTtwUPZq5f3TaDLXJCIWAL/NXi2LiNuA72evvnDc6xZfk44T0fxDlUFKcLPB49gMvia1IXED6QE+pGcqjayT276vxQqSN1O+0Fhe0koR8WgT/f67hT4rTSclZUD1ySWVfRR5eNzxB8zDEEudlGEtcUKGFTBJ0mo1fvZ0DwZ+N8xt31qg/W257ZdIWm4AyywfCLwm2/5wRLSyBtnzJG0JfCr79jsRcV07x+uViLgkK5t1ObCPpMsj4if9Pi+zUSdpLWA/YAfKDxIfID1I/E1EnNOFPicB72HirMSnKM9K/HlEFMr4zj6TNs1em2Vf85lRa0bEXW2c61RgV+BNpHXBlyXNeiz9GU0D/hwRs1rto5McS20YDWn1tgl69TAxK+l6HB2q/hYRUztxnBb63RfYtx99NzJacdSD32bW2GjFPbPxNuz399nxViU9PNuGNA5cWid4BmnpvouAX0fEnQWPN5m0XN+ulMcLlgRmAvcAVwK/i4jzi55jL4xWbPY16bgY4uS2q3PbWxVo/4bc9jWtdBgRcyXdALwy1+8farXPYu2W7fZbIf/XtUiVn9/JxPXai1T0yLd5uMXz6phexVJHOTPrllWA/9R4fa4H/ecftDUslxQRTwD5B2WrdPyM2iBpfVKpU4BfRsRf2zzeEpSXLbkR+EZbJ9hjEXE1aZaSgK9mFxtmA21yk69BIukA4HrgYFJG9AqkwYm1SAMqf5J0hqTlOtjnGsDfSf/X30kaKFocWBnYnBS3bpC0c4FjfZv0+fNH4GvA2+lQqRpJa0s6D/gbcADpJumFpGfHq5MSQA4gZVu/ptZx+mE0YukQnrKZjYzRiKM2TkrJbc28BmQA3AaE414t/mMYJ8MeS4f9/j473v6kCXbfJiVlvDg73uKkMd2ppHv/myQdJqnuX0G2XPRVpGX3difNgF+WNDyzPKm8/QeB8yT9vc5ExL5wbDbrmfOAudn2xpIql/mstGtu+4w2+s0nYezWoO1bSHEd4O4sPrQrP5650LO2iAgm/n5vqXewrCL8m3K7/tnW2XVIL2Kpg7MV9sx1N/PUWBa1tWZvNgbkRmPZ3HbRWcn5yhPL1mzVY7llSxYnlbfuRFLLN4B1SaWv9mtz3fJ+KWXtr0q62RoyXrrEhkM22HEsaZAGUsm6I0mJYmcA87P97wLOkNTsUuXV+lyBVFK/lHU+BzgR+Crwv6Q1tyFlYJ8iabsGh1yiyr7HO3CeGwGXkpYIgDQj5zTgW8CXge8Bp5Bm1QyqIY+lZmZ9N+Rx1MNCZta0IY97ZuNrFO7vJX0M+BGwdLbrCeAE0ljnN4DfAE9mP1ss6+dbdY73UlJly42yXZGd73eBQ4Afk/6cSt4AXCRpmXrn2QdDHpt9TWqDLyJmAmdm34oUI6qStA3lihVP597XihMpr/GzWzaBt1qfkyrO6YQ2+iwd863A63O7alUL+lVue/esIlMt+1CulPE4KQYPiq7G0kGbiGmDau5crr++3ydh1pQlc9vzCr5nbm57qQ6eS7s+B7w22z4gIma0czBJrwM+k337g4i4tJ3j9dH9ue11gAv7dSLFzaP4P0ez/pO0NimxoOTgiPh2RZtNgD+TZqNsTYpZNQc8CjoaKN1g3ARsn19aRNKBpLW4P0a6nj1e0jp1lp16AriANPPlKuCqiLhTUsvrsUl6EfAX0syeAI4Avl1reRJJG5CWMxk0QxhLbVxNornlSzysZz3iOGpDo9k4WnqPWQXHPbMhNAr395KWJyWRlPwU+Fz2oDTfbjlSUsUHsl0HSvpRRNxd5fy+BayUbd8K7BwR/67S966kB5xLkGLfpxmsysOOzTY0ml2atPSeAfFV4N3AosBekqZHxFH5BpI2Bo7P7fpOVqmdinZTSZV3AYiIqr9mRNwo6XjS0p6LAadJ2j4f07KJvd+lvGTKo6T4uxBJx5KqDZ0YEVXHKrMEj72AH+R2/zUirqxxjpdIOpOU1Lck8EdJb6+Mu1ni3fdzu46KiPxk6X7raix1UoYVc/MtPPpov0/ChsxDpJLt1fSi5sqc3HbRz/j8TOqB+CCQtC5wWPbt6RFxepvHW5yUtTgJuBv4Untn2Ff5Moor1GxlNgCGeAD8cMqnflLlgA1ARFwjaR9SCT+Ag7LBjhmtdChpPdJNBsCzwK75AZusz+ckfYJUanUrUmLE50k3RguJiMOq7W/Tj7J+AT4WET+u1zgibujCOXSCY6mZWXscR81s3Dju2VgTzT9UGZCHiaNwf78d5QoZd5LuxZ+r8ns8JekjwJuBKaQhlm2Bn1Wc3yKkB4glH62WkJEd81RJ/0WqigmwPYOVlDHksXkBAzMSZlZHRNwq6TOkqkMAR0raEziX9ExpY2BHUtIGwEXUSI5o0ueBLUjVz9cnLfl0OnAz6f/8TsDaWdv5wL4R8WS1A5GqVBwAHC3pKuBfwAPZ+S+dHefNpKWhSm6nnOhWy38Dr8revyFwY5aocQPp8+f12XFLzgeOYrB0NZY6KcMKufm6YVzZwDql2czF7EZjQUTcX79lV+UTP5au2WqifHWMvi/Wk2Uj/oqULDKD9EHZrsOB9bLtj1Zmkg+ZfDnDx/p2FoVVVsl4EC9hYoMsK8W5S/ZtkOJHVRFxvqTLgdeRLl7fBRzXYtd7Ur4TP7XOgMgCSV8n3fQA7E2NpIxOy5YtKf3Z/K1RQsaAG7JYaqNhQeMmZsNjyOOoB8BtuGSlkPcDdgBeSrpffgC4AvhNRJxT5+2t9jkJeA+wB/BfpBnkT5EeCP4R+HlEPNTE8VYF3g9sQxqwXjH70QzgRtLg/a8j4s7O/AYdN+Rxz6xkfK5JR+j+fkpu+4pqCRm5Y87Pfo/Se1aq0mxlJo4HN6omfHFuu9rx+smx2YbGkFfKICJ+kF0fHkm6Ft04e1U6C9i7E0vHR8RjkrYFTiYlZyxFqmRR6QngwxHxpzqHK30ALgJsnr3q+R3wqUbXuxHxYLZsy4mkpVuWJF0/V3Mc8N/14nifdDWW+s7bGrvpJu66a+Ku87YcpBBoVtWDue01arbKZOXv8skbhQdUuugDpA9YSKX4HqzXuJGs6sbnsm9PiIjz6rUfZJK2Bj6S21W1bJZZ5w1zHlPTtqVcQWh6RNzcoP3vc9s7t9HvTrntUxq0vYA0eA0wJSu12gsfy23/qEd9dtxoxNLxGUi10SBpLUnflHStpMclzZZ0u6STJO3Q4b5WlrSnpJ9LulLSY5KelTRD0g2SjpO0naSmbu4kLS/pAEl/knRv9jvMk/SIpEskHSnplU0e822SfiXp+uz85kt6UtKNkk6UtEs2k3GgjEYcteHU+uff5CZfg0TSAcD1wMGkge8VSIO9a5EGfP8k6YysbH2n+lwD+DvwW+CdpESQxUkP8jYnzZK+QVKh619J+5PKRX+blJTx4ux4i5OSPaYCXwNuknRYszG62xz3avE1qQ28Ubm/z1dGLpIUsXJuu9rSJXMqvm90zEbH6wvHZuuf8f38i4hjgFcC3wGmk+LXXOAuUhLDOyLinXWqVbTS5z2kahPvIyV83EuaBfoY6f/9V4ENIuK0Bod6Hyn54FukahV3ALNIf6Ezs+OeBxwKrBcRuxdNQM6qIb2BlNB8GunPYy5pEvRNpGWnNo+ID0TE3CLH7JVexNJBu7+yAfTMo9ULBpy3pXjbpS0vxT5GBmTm0TmNkt1Gzg2Uy8+9vED7dXLb91Vbt7APXpLb/oWkXxR83525cZvDIuLQbPvFpOxHgL0l7V3weL+S9Kts+6KImFrwfR2TDcKvSBp4ey9pVtEipOz+6yPi2l6fU2eU8mxcMaO+c0gT4YbXkGaAvzq3/Y8C7fMzRlpKjsiWWNqgaL/ZbJpLKf8D2QS4ppW+m7R9bvvvkhYllWTdi1RCcDnS2o1XkgazfhsRfb9THd1YOiDXWgNvUP6cWv+v0GL1toGRPUw8ivQAMW+t7LVHVtrz/e1ei0r6M/BWytd+eS/IXuuT4sDlkvaJiFsLHHdn0iBKtQHrlbLXlsDnJf0U+EREPFvneKsDJwFvrPLj5bLXeqRBo+sk7d7P5aBGO47CYMSIQeY/p37KkhmOze2azsJloieTxgHOyNbZnld5nCb7XIE0UL1+tmsOUFkmei1SXDhF0o4RcW61Y2XH+xgT1+V+Ajib8oO9Kdnv8QLSR95XSckaB7Xze7RjdONeNwzKtdagG/4/J9/fF9Ol+/v8eU2VtGlEXFWj/9cCb8q+fRxYaNZ4RDwp6TpSuX1Ik9k+W+N4SwCfzO06vs6v01WjG5t9rVXc8MfSURARt5Ou01q6VouIaTT5EZGNL/42e7UkS4Y4j/JSVR2VnePvmZjgN3D6EUudlGHWVX1//jLOrs5tb1Wg/Rty2714oDfWJLVblqp0sTKXiTPWzUbNJEmr1fjZ0xHRzaWWNsxtN3xQR5rxV/ISScu18FBxPcoPEGdExKNN9rthzVYdIunFpBmSkLK8FwMuZ+IgF8Dq2Wsn0sPJd0VER2fSOJZacb4m7bc+PEx8M+V4OptU1v9aUsLYMqRqbFOzn78OuFjS6yPiNmqQtCNwKuXRv9mkh4l3AM+QYuP2pGxTAR8Flgd2r3G85Ugl+tfO7b6EdC3+EGnG+KaUK8e9ipQIt3FE/Kf+r1+M46jZcJC0NvC93K6DI+LbFW02Af5Mih1bkx6sfavNro+mnJBxE7B9Nvuv1OeBwPdJ//8nA8dLWqfaNXBWnfPI3K6fkipizqxotxzwXcprdh8o6Ueduo503LP+GvtrUt/fN9fvQvf3EXG1pLMoXztfKOkY0qz0u0kx6mWk6kkfz9o8Dbyvzmz1w0jXuACfkbQO6TPnBlIyx2qkseWDcuf0k4j4TYHfpxDHZmvO8MdS0fzD6QFIbrMBNwyx1EkZZtbQJMr17Yq2HwDnkYLnEsDGkl4REbfUab9rbvuMrp5ZcdcCvy7Y9v257dMor7FwbW7/g00cbzvSYBakwfHSTdFNBd/fiEgZh+1cTz0A7BsRl3TmlGwwdXxJ6GGzClDrwdNhpDJy3ZIv4XJfo8YR8YSkWZSXgiqttd21PjP31nh/t+SrLz1LGvzfEJhP+gd7NSm2bUZ6ODmJtPb4PyS9OiIe6eC5OJaaDYE+Pky8DPghcHpEzK5yXluQZnyvmvX7C8qzCSvbTiLN7i5d6v8R+FDl4Ho2g/ArwJezXe+VdGxEVJsZ+UXKCRmPADtXi0WSppIGyl+YvQ4D9qv6GzfPcdQKGv7Bb0j/gZud3T0g9/eHUz71kypjKEBEXCNpH8oz/g7KkhlmtNKhpPVIldAgXfPtmk/IyPp8TtInSMl1W5HK2n+eVOGi0naUr5PvBD5WbQ3tiHhK0kdIyXVTSH8F2wI/a+X3qMJxz6x/fH/fWJH7+/eRxjd3IVVV+zLla8+8OaQlUw6pNyYcEadJ+gDwY1J1oh2zVzVXAf8bESfW+yVa4NhsZta+gY+lTsqwhu66q99nMGxGY7Bm2EXEzKz88+6kIHwIUHW5DknbkMosQ8qePrMHp9hQRJxJwXORlE/K+HzlYFF2vJsoDyo1Ot40ykkZP4+I44q8r0mtfDg+QboBOgP4TZdnEXRQkJZ3s+IqkzHOpLwi0fAZ0vKmy+a2ZxV8z2zKgzbL1mvY4T6rvb9bVshtr5i97gd2iIh/5RtK2ow0i3wVYA3Sw9HdOnw+YxRL63HpzoWN3jXpEC9f0vOHicB2WSnUmiLismw5kktJf1xvlPSqiLiuSvPNKS+tNxPYu9psyawM6leyRIpStbrtqV6u+t257S/WGvSIiGmSDqL8QHL7au3a4DhqdYxeLB02kpYhPXiDdGN1eK22EXG+pMtJFYCWI91AHNdi13tSvrg4NSL+XaPPBZK+Tqp+BGncoVpSxpTc9hXVEjJyx5yf/R6l91RbMqodjntd42vShY1eHB3SGd4jc3+fjfnuSkpYO5x0nVrNbaRr0Htr/Dx/zOMk/R34NHAA1f8jP0lKer6i0fFa5NhsdYxeLDXrkoGOpU7KsPqemVs3KeO8LcXbLo2enc7w8k1Zn3yVNNi7KLCXpOkRcVS+gaSNmbgG4Hci4onKA2UDy38rfR8RA3A/NdTWbLL9PFIpx5kNW9qIclJLHyyZ2y76FzA3t73UkPTZrMqBoQB2q0zIAIiIKyXtAVyY7Xp3gcpNzXAstSb5mrTX+vUwsVFCRq7d5ZL+Cbw227UFUC0pY0pu+/oC5asvppyUUethYv6YlxY4XkknH046jk7gGGEDaVvKxTunR8TNDdr/nhRHAXam9aSMnXLbpzRoewEwg7Rk0xRJm0RE5bKoc3LbReLYyrntTi6B57hnA8CfN30wavf325OuqzclLTFyNuUqv+sA7yAtffd94ABJ72iwTN/qpEol7812/QX4P9LkvReRKtltRFoS5cOSPh4RPy/4OxXh2DyBY8SoG9LJazb4Bj6WOinD6np2rjPwbHhnJUbErZI+Q3n97iMl7cnC63cvmv38ItKasW2R9B7gPRW7X5bb3lDSqRU/JyJ2rdw3qjq1Hu7waBRLH6Q3qy4Ms9mk8dR9+3savfcQaRmMaro9AyI/cFz0YyC/2tVCpfIHtM9mzan4flpE1HyYGBF/yz1kFbAD0JGkjPGLpWZDqV8PE5txJ+WkjBfWaNONh4lzSCWiS8es92fTlYeTjqPWmuF9UDCkA+Cvzm1Xq7pTKZ/EtUkrHUpaHNigaL9ZtYxLSdd5pX4rkzLy5zVV0qYRcVWN/l9LeTmpx4E/FT33Rhz3emF4Y4QV00Ys9f19B/qU9GXgG9m3vwH2j4hZFW2WAX4E7AWsC1wgaaNqs5+zCXt/IV2P3kVaUu/aKu3eS1o2ZXHgp5Iejog/Fvy96nJsttb486bfJK1FWlpzB+ClpBj2AKmizm8iouPrcmdLi74H2IO0XHJpeak7ScuM/jwiHipwnFcCryF9Lm1MSkBbiTQZ7WngHuCfwMkRcWGt41Qc8xWkMZA3Aq8kVQ1ekpS8fCdwCfCriJhe6Jdt0jDEUidlWF1zKh87VJjZ01zM0kPNYf6g6d/vcOcp/1d1/7yFakKMloj4QfZBdSTpQ3Hj7FXpLFIZ5mc60O0GTCzHXGmlBj8366KZwDL9PokGGl2vHpd93be7p7GQx2vsb1wxqo3ypgsi4v4m39op+cGKpWu2mig/k6WVQaV+9Nmsyj6K3JhcSPkh66vrNbRhMOzXpPlEweH6HYY0UbjnDxNbsHpu+5EabS4H5pM+ztaR9M5ag9DZwFRpqaZngZNrHPNiyut1f1bSpRGx0Idqdi3/+dyu4yvb2DCay8TnLoOoUWL1sH8eNGWSpNVq/OzpLpdL3zC3fWuB9vmZ0C+RtFyB6j6V1gMWybZnRMSjTfa7YeUPI+JqSWeR4t5k4EJJxwC/IyWbiTSZYw/STOzJpOvO90XEk02ev42F0vyjj/f1LFrX72vSvkxE9P19m31KejPlhIzLgH2rLQeVLXGyL6lqxutIFdo+CxxWcbxFSUnRKwHPATtGxPXVTiwififphcAPSDH7/0k6OyI8q3WojcL13Cj8DsNH0gHAUUysCgSwVvbaQ9KZwPtbuBat1ecapPvrrSp+tHL22px0b71fRJzR4HDXUr7erbRC9tqYVB3oImCfiLinxnmtRVr6Y6Max1spe70G+LSk44BPjuOSS07K6BFJIl0AbEMqCbsBKfNoEmm9mn+TBux/GREP9us8KzVKyni0yG1pRwzLtU298+zf73DUMrWHpJ9o8Hc8CiLiGEnnAB8mlbcrZS0+SMpaPCEiOjbzxGxwzcx9HfTEjFqO62PftaptDstnVNPy1yNrNGosaXkmDrQ0zMput88q7Vrps1kPVHx/X4H35Nt0ek1wsyqKxqWxmFnTzweJ0J+HiYVlpZq3zO26uFq7iHhI0o+AT2S7TpH0M9IH853AM6Rr7J1IA97LkT44PxIRd9To/gjSjKJFSEu8XCTpaNLs8odJM35eDXyBdA8NqTT1kU3/ojZg5ua+DnpiRi39vP7rS9+rAP+p8bPDSCXfuyVfUrDhdVdEPCFpFuXr0tLswa71mbm3xvvz3keaZb0LKU5+OXtVmkNaMuWQDi57ZzbAxuKatN9G5f7+c7nt71VLyCiJiOckfY/yBIldqEjKIF27vjzbvqBWQkbOz4DvkAbV1iY9sKysjGRDY1jG8wbzmVM7fU+i+YpDg/QpIWl/ytmRANNZuDr7ZNKSpGdI2j4i2lqbW9IKwPnA+tmuOcDppIqTK5Di2VrAiqT79R0j4twCh76DlKBxJ+lZ9QLSs+vXUq76+ybgH5I2i4iHqxzjRUxMyHiENCnlFuBJ0vX4WylXotsXeLmkbSIiv2zVyHNSRg9IeiepXFatwcBVs9dbgEMkHRIRbS+h0AlPLYBbboZXrLvwzx59BJ7q2vBgPaUL9WHOAOztzcb5s2r/rMhf4ZDOSpwgIm4HDsperbx/GgV/tYg4lO4OSlXrs6N/7BExtZPHs8aVFPqnlKgxKEkaHa/q1kG1rp0H+e+3LTeQbh6gPEhRzzq57ftafIh4M+UPyeUlrVRgZmK+33+30GezbqY8WxyK/QMY2X8k42dBxfawX5P22tg9SIT+PExsxlGUZ8dc1GB5lc9mbT9GKtv8capPz51P+kA/LCL+WetgEXGFpB2B3wIvAN6Qvaq5EfgxcEy1aho2CkpjccOYpDE8DxOHdPmSZXPbdUY3JphNOY4uW69hh/us9v7nZTO3dyWVdT6cNJuxmttIA9n31vi5jb1jK7Y/XrFvUKpnDOoDz/bOq41KmP00Kvf3W+S2rytwDvkS+dV+76aOFxHPSrqRNNu7dEwnZYyEUbi/H55r0mEmaW3ge7ldB0fEtyvabAL8mXQ/vzUpoexbbXZ9NOWEjJuA7SPirlyfBwLfJ92vTwaOl7ROnfi9F3BhjSSL0jE3JyV+rA68BPg28MEazRcAp5KS1y6sVkVI0n6kZ+WTSdU+Dga+Vqv/UeT/ob2xARMTMm4nlVz9Bikj/ueUMz+XAI6S9D89PcMmzHsmJWTMLHpbOjYG9UbDbDhI2kzSNyVdIOkuSU9KmivpIUnXSfq1pA9JamVQzZ5Pvsh/39M1qLrguH6fQGGlAfBmXgMwaHN1bruyLF41+QdpLQ1KZNnRNxTtNytpn5/h3fXBkCyzPT9YU2TGT75NzZudTnAstVHWbCwdgDgKXXqw1wmS9iSVyYeUSPG5Os2JiPkRcQApNtebcXMPaa3YhrO7I+LPpGUCDiNV26jmGVJ1u4t7kZDhONptlROh5lbZNwh8fz9A8iWhi84wzP+jWqpmq/70uT2pUtDmpPURjwe+mr2Oz/a9ijSofo2kdWocp2Mc92wwOO522ajc3+fjULPXhdX+kbVzvFrH7AjH5m6r9lc3iHFoEM9p7B1OOc/5pMqEDICIuAbYJ7froKwCUUskrUd5He9ngV3zCRlZn8+RKlteku1amYnLgFae48n1EjKyNv8EPprbtVsWqyvdDWwQEe+NiL/UWtYpIn4OfCW3a/8ax+uYQYulrpTRO0+TMoR+Va0MlqQlgO9S/gf+WaU1yf7Wu1Ms5qmnUkJG76pkDMsHZLN6l7l4QQRv1YAMS5tVkPRa4Bhg0/zu3PbKpHL/G5AyOL8r6VjS7MtBHME1GxXnUa4rvrGkVzQon7xrbrvRuoX1/AF4Zba9W/Z9LW8hlegDuDsirq7TtpNOBzbJncMRDdpvnduuOWu8HY6lvTAs16TNnlMvZ9PkZx6NjX48TGxI0hbAL3K7vhIRVxV43+tIMe9NpCSTP5EG2+eT1uregVQy9QjgAEm7RMQVdY63PPAl0mybxUlrg/+DVDZ1BeD1pBmM+wL7SDo8IirLTneE46hZXQ8Bm9X4WbeXgcovulq00Ee+5Mrsmq163KekL5MmaAH8Btg/ImZVtFmGNINwL2Bd4AJJG3VjuS3HvWF1bMF9/TbI13xjeU06Kvf3jwIvzrY3IlVTqydfTr9yKdLS8aq1rUrSoqSE4nrHbItjs7VneKplDOPD6ew6bZfs2yAlaFQVEedLupy0BMhypGpFx7XY9Z6U/2JPjYiqlYIjYoGkr1OeRLE3KfG3HRfmtpchxaAJy0tFxAMUj4c/JF0PTyYte7IOBSZ0NGtQY+lw/O8cfucAUyLic7XWJYuIuRGxP6mkTclA1Jp76qlUHaP0evzxfi1b0st/rgsqXkXattqP2fiS9EVS9uampA/F0muhprn9S5PWFr9W0kt6cZ7DL18Ro5fLlEzLvRo5h9aWLjmO3lXMeGmP+hkMETETODP7VsAhtdpK2obyjJanc+9rxYmUPyB3k7R+tUZZJnX+nE5oo89mnUjKTAeYmj3crErSmymXRH0WOKvTJ+NYOup8Tdqmh0ilNqu9elGdsB8PE+uStBFwNikJAtKDwSMLvG9vUsLEVOAvpHvc90bEYRFxRER8mJSYcVT2ltWAc2vFmGz/VaTZPM8Ab4mILSPiCxHxrezrlqQB+sdJN4SHSvpEK793g9/NcbQn8mNbvVympBf39+3E4Ga1PjZSKrnfzCv7B78gIu6v8ep2Ukb++EvXbDVRPqGtlfPreJ/ZNWEpIeMyYN/KhAx4/hp8X+DybNcU0vJRHeW4Nyp6OXRcNI6W2rbTx2AbxkqYI3R/n0/2/US9GdaSFgE+ndt1UYPjvVXSBrWOl/ko5eoas4ErG7RvimNzP/iZU+vG8vHytpRvZKY3WP4T4Pe57Z3b6Hen3PYpDdpeAMzItqcoLaXSjhUrvp9TtVVB2b1DPiHuhe0cr5pBjqXDmIw0dCJieuNWz/s+qZQhTFzTrG+mz4eVHoBlstvQubWKynZF5brdvTKWGdM1NbvubL9vNGw4SPoM5bXUSiUCHwLOB64HHiMN0C9LmnG5OWm2ZOmf2CuAv0t6dUQ80avztm5oJRljuAzp+t2QsqnfDSwK7CVpekQclW8gaWNSqeWS71T7PylpKvB8BbCIqPorRsSNko4nDUYvBpwmafuIuDt3rEVIFcZKJVUfJa2t2BMRcaekH5AGeAT8XtIOldd8kjYFfpvb9cuI6Oja4I6lveLrwkEwieZiaTZEtCAi7u/G+RTUj4eJNUnakJRQURpY+R3pwWDdcs2S1iVVflwEuBN4V0QslDASEc8CX5A0hTQbcnnS7KEPVDnsCaS4BLBXRFxYpQ0RcWGWEPKnbNc3JB3XqQfBjqPjZiwHj4fdg7nthsvGZRV48vH2oRpNO9ZnlXbV+swvEfW9rMR0VRHxnKTvkWZWQpqR2bEqQY57o2QUK2S4glsXjcL9/S9Js80hLYfyC0kHVF6XZrPZfwq8tnQqwI+rHO984D+khO1FgLMkvSsirqtsKGmPivP6RUR07EmJY3Mv9euZk42AV+e2/1Gg/cW57ZaSIyQtTqrmUKjfrFrGpaQqlqV+21nu+Qu57asjoq0p+9nvs1Ju1yPtHK/K8Qc6ljopY/DcmdvueIZQKx4H7noAVqvMhxob9W4GhudD+5WkiGM2CCS9Avgm5Q/GB0iDVL+vteZY9r7Vs/ftnb33paRZrh/s6gl3xDyafyzfCTMbfN9NUylWJaNd+/agj/EUEbdmF7Ol0b4jJe1JKoM3G9gY2JE0qANp5kknkiM+T0pOXRdYH7hB0unAzaRypjsBa2dt55MeKD5Z62CSViaVga7nh5IqHzAeGxHTarT/Cmn20OakAZyrJP2JtFavSCW+tycN7ABMZ+JgfNvGM5aOMz9IHFL9eJhY69gbkEqPrpztOpWUDFHzwWDOJyhX1vhJtYSMCv+PlJQB8C5JH8rHJUmbkZZAAbgpIv5ceYC8iDhH0s2kz4XlgG1or5R26TwcR/uml9W1iz54G5YHiWPnBsoP4F5eoP06ue37Whw4vply/e/lJa0UEY82eE++32olpfMTrxZ62FdFPtm3yO9diOPesBvEJIzx02yicOk9/TYK9/cRcZak3wHvzXbtC+wo6Wzgtmzfy7PfY4XcW4+KiIWqWkTEHEn7k6qBLEJ6QHetpL8A/0caRHsRqXJbfnmTm4CvFfz9G3JsHhf5a9JuPnMahIhTXxtxdJKk1Wo0eboHFdw2zG3fWqD9bbntl0haroVr0/Uojy3OKHBNWtnvhjVbVZElyr2QVGXiv0nxFNI/zIObOVYNO1POTbgfuL0DxwSGI5Y6KWPwrJ7b7miGUDseBVbsW4WMZtp26wOn2lpcnUjI6N0H5EYvg+vvbtzOrEc+ShrYD+AO4E1FZrFGxH+A90v6N/DtbPeekj4fEY937WyHVrMJGDPpzvImUyknZ0zN7S9aIWNeB8+lXYsxWOfTfRHxg6wk6JFk689mr0pnAXt3YqZIRDwmaVvgZNLgzVKk9f0qPQF8OCL+VOVneUuTZgTVs32VfWfXOcdZkrYnrZ+zI+m6eicmlhQs+TPwvmolqtvkWNoTRa/5SteL3VzDtdoAznBdk46hfjxMXEiWkPE30qAywOnAHhExv+Ah2nmYuDxpJszDbRyvdMx1s+1OPaB0HO2JZhMwSkved0tlnB6eyRbtGtLqbVfntrcq0P4Nue2WZgVGxFxJN5Dmt5T6/UOt9tm18pa5XdX6XTa3Xbc6URWd/EfquDe0/h/N/Q8+ls4ub5K/zu3WNal124jc3+9NSlz+OOkf4QuB99do+yxwKOVZ09XO72xJ7wJ+DqySHXPb7FXNX4F9OjyD2rG5J5qNU0USKNrRrWdOI20VUnWbag4j/X/vplVz2/c1ahwRT0iaRXnixSpAs/f4TfWZyVfpXbVmq4ykkyknu1XzOGlc8/yC/dfqZ0nKy/kB/KxR1c4mDXws9ejb4HlPbvvimq06SNKyklarfAGLlv43rFTvACNvQcXXyu1OHLv7NtooLUQ6pYX3ljIXi74GMbBIWkvSNyVdK+lxSbMl3S7pJEk7ND5CU30tIulVkvaVdKyky7L+IntNa/J4krSFpEMknSPprux4cyU9IOkvkr4kqeEHbJ0+NpV0pKSrJT0k6Zns2NdI+oWkvSR1sl7OdrntDzdbVjwijqS8FuRkUsZ6X9WLpQsWDMMFdTcqaEyr+NqqXlb36I5hXHM2LyKOIQ1Kf4f0UGwG6YnJXaTS9++IiHfWq1bRQp/3kMrHvY80IHQvKSPmMdK6rV8FNoiI0zrVZwvn+HhEvJMU004gZXfPIs0yuiPbt21E7BARM7pwCiMVS+vH0SIT+QdBr+P98F2TjqGeP0yspLRkST4h40xg9yYSMqC9h4mw8D+yTh+vVSMVR2EUYmm3K2hUu7+3AXce5X8YG2cz4OrZNbfdTkWdfBLGbjVbJW+hPCP77oi4ukqb/KzGjar8vFK+zQMF2hc1cnGv09qPo90aFWvmY7sbFTUcP0fFsN/fR8SzEfEpUtWNb5KeoTycHe8ZUqW6v5EqWawVEd9s9NAvIs4mJUd/mHStfCdpMOo50p/PdNJSfm+OiG26sDziyMXm4b8m7XasG41nTq0a4nHS/H1s0YlX+SqTy9ZsNVh9lgTpouJlEXFeG8cp+T7lykj30vmlqAc+lrpSxgDJBsvy5VB+0qOuP0eNclvzSIsNr1h09eOu6Mcaf4P/wdWKjbJH6neNWZ6spAOAo4AlK360VvbaQ9KZwPs7NBvxP6Ssx7ZJeiep5H6tslyrZq+3AIdIOiQiCn+YSXoRad3GPeoc+79IsekDpBnhnfAS0of6fXWWBmjkeMplr1/SiZNqU81Y+tBDjaqKtZxPM4Sm0dyyJvNoPPh0HL1dwqQ0O2nsKmbcDhyUvVp5/zSavIfKSsv9Nnu1LCLuarbvJo9/HumBQa+NWiytE0cfrra7x/q97vRoXp82o9kZ3gMyaFN6mLgE2cPEiLilTvtOPUwEJiRklJYs+QPwnoh4tslDPUq5OsVGpApA9eQfJj5DmllTebxqbYses1MPKEctjkJbsXQQ0+s7oVfxs5uVksZXRMzM7td3J4X2Q0izpBciaRvKFSueJj1Ya9WJpBLNk4DdJB0RETdW6XNSdk4lJ9Q43hWUKyd9QlLNMspZ2ehP53ZdVK1di0Yx7nXagF6TziMN5X+WwVnGpLJyxvgY9ocqw3x/nzveLcCXO3Gs7HgzSdUyft6pYzZhFGOzr0kXMn6xcgTlny8VHRjOZ50vNaB9/oaUIAep0sSLgTcCryJVJZoq6YCI+HvB/heitHzWftm380mVOzs9E3PgY+mwXz+MDElLk/7hl9ZsO6ONfzQds4D685MPnNnJyjLDoBsfnL0buNlss/T1jvPh+mxfM3n2w0hpXcD83ep0Fl4rcTJpcOQMSdtHRLtPWitr7QYpq3qFhZs2tAETEzJuBy4B7gHmAGuSfodVsn6PkvTiiPhcowNLeinwF8oD7LNIgz3XAU+Syv+9GNgMaDQbqVmllOh21gzLv3cYUqz7qLQkSZHrnG4tYZI3rQvH7HRp1moe7PLxzZrmWDq2unVNCqM7ANYffXyYWC0h44/Abi0kZEB6mFhacuQjkr4fEXPqtM9fi/6jyoPHK3Lb60natl4pVEnvoLx0CUDLg0EVHEd7qnSbVKQaRreXMIFhv79vxZAuXwJpBvW7SWNme0maHhFH5RtI2pg0iFrynWql5SVNJcVGACKi6q8YETdKOp6U/b0YcFo2XvD8wrBZ8sR3KVc5epTaM/5+STkpYyvgF9ngdn4mI5KWAX4KvLZ0KsCPaxyzFY571mGdjqW9uib1w1EbKI7NPTdICWXjd03ahodIzyqqeboH/efvgYteVudvambXbNXHPrNqQQst4SzpbaSE41cCf5W0a0TUXNKvFkn7AP+T2/WxiLik2eMUMPCx1EkZAyDLqj+BNBsd0rpAH+7bCeU8B9wCvGIWrFalWsZRy6jLiRnNfnB06sNmkD6U23fVO9MYw2KLp+83ehlwd0rMaGVEdlhIWhv4Xm7XwRHx7Yo2m5Bm+q0CbE0aQK65zmBBt5CC91WkDMOrgV2AX7V4vKdJJfJ+FRHXV/5Q0hKkgaCPZrs+K+nsiPhbZduK95xHOSHjp8CXIuKxGu3XpLMfQvcBG9Je+az8e4uup9YnQUpkbXYIdNQtRmeqTcyjtWvadhX/+ywtA9WMkbx1sk4bs1jaT/26JrUR0fOHiTUSMnZtMSEDUlmqT5L+Ya8FnC5pr8prR0mLkcpI5yt+/LDyYBHxL0lXAZtmu07MBngWmg2eJavk/2zOioh7K9u1yHF0glGNXaN1fz9av0sxEXFrNruuNOHiSEl7svCEi9JEp4voTDnkz5MS0tYllcm/QdLpwM2kSRc7US7BPB/Yt1a5/4g4S9LvKK/XvS+wo6SzgduyfS/Pfo/8hI6jIuJKOsdxb6z0YvKCmXWAY/ME3b4m7df1rq9JS0TzD6ezG98FXVg+qBn5xI+i6wvkK1W0kjjSjz6BVBk4myBxGemv7FeS1mxmeStJe5CSk0tjF5+IiJ+1ek4NDHwsdVJGn0kSaZmSnbNdTwHvqvVgtEv+h/RAttK5Aa+6jfREudbaCYOnGx/ao/WBuVFW+Hfe3alMQiOiuTlKAzKTBuBwys9BT6pMyACIiGuyTL1S2fmDJP0oIma02mlEbF65L/1Xb8k5wE8jouaiMxExF9g/q3yxfbb74+QG7Ks4Algv2/5ORNQtVxgRdxY/5UIuIH1AvkrS8i3+eZfKSM2ns+VcW1Uzlq6yykqvSpu1EjMepHtLmLRS9aJUUaPdihlTqV8VYzKdScqY2aHjmA2dUYuldeLoi17V65Npn69JF9beuQ/p8iU9f5goaXngQsoJGU+TKlN8qsA16b0R8bsqv8O/JB0FfDHbtR1wV/Yw8UZSDJkCvJ2Jt46/i4jTa/S1P+lCYWlgJWCapEtIVeGeID2UfAPlCh2QZkZ9stEv0YRRi6MwUrG0VFGj0xUzhj2WjqeI+EE2qelIsiWhslels4C9I+KZDvT5mKRtgZNJsWgpYK8qTZ8grVv9pwaH3JsUxz5O+of4QuD9Ndo+CxxK+5NGKo1i3Ou0NuNoNx8mfraF93QqMWOUYmd7v4cnXVgXjGJsHqFr0m5V8BmluDo28mWU12jUOLs3zydSPNTtPqu0a6XP50XEPyVdALyNdI++GwWXeZL0XlJBgkWyXZ+OiG6uwTbwsdRJGf13LOV1dJ4GtouIq3p5AhHxNFWypSQ9P4vqSmDqLFimaB5W2wbhUrWXH4q9n5G00UYwbx6dW415wGQlP3fJvg1SgkZVEXG+pMuB1wHLkUqKHtflUywkIqY30fz7lJMytqjVSNLKwAHZt7cCX2nt7Nry0+wcFiX93TQ1uC7pZaTKIAGcFhGPNnhL19WLpZMmlf5/97paRj6potNLtDVrKtUTNNqtlpGvkvEN+vPP2axvRiqW1o+ji1R5R6/0+7rUAzWjoMcPE5cHXpT7fllSQm4RFwELJWUARMRBkp4irQ29GOlCY/caxwngGODAWh1FxJWS3kqqgrFOtnur7FXNNcD7IuKuBr9DM0YqjsKgxtJ8UkWRpUuG3eBWHGljVuJAiIhjJJ1Dqi67PfBS0j+wB0nJZycUSIxots97JL2eVOFiD1KV21VI/8/uJFUi+llENFzrMKtW9ClJPyAlY7yBVIVjeVIceYKU6DYN+GVEdGOm88jFvU4bzDgKE+91+12J09enZh02crF5MGPpIFyfjfYzpzFwA+Xl6F5ep13JOrnt+yLiqRb6vJnyX+byklYq8H883++/W+iz0nRSUgZUH8dYSJaQcSLlhIzPRcT36rylEwY+lvp/ZB9JOgb4WPbtTGD7iLisj6dU02xSYkZ/9Psi3zcaQ2pbyqN/0yPi5gbtf5/b3rlmq8GWr2bxwjrtPgRki9nws4iY371Tqi4ibiLNtBRwgKQjsvV4G5K0AanIy7LAPZQTTIaEKzpM1G5+aL+TTYqb3OTLrJHxjqX9MC7Xg+Pye/ZeRBxDWov1O6RBjRmkJ9R3kRIh3hER72ymFGivRcQ3SaX6vwL8lZTiPZc0o/sR4FLS77deRHwqIupe+GT3v68kPeg8mbQM4FOkZfOeAm4izazZCdgsi3ud/H0cR8eO7++HXUTcHhEHRcTGEbFCRCwZEWtGxO5FEjIiYlpEqPQq2OeCiPhtFqNfGhGLR8RKEfGaiPh6kYSMiuPdEhFfjog3RsQq2fGWiIgXR8TWEXF4lxIyHPdGwpGkyZujzrHaxodjcz/0O8aM9zVpqQpmM68BSRS+OrddazJB3hty29e00mFWJf2Gov1mk0G2bLffCvmh6oaxKVuyJJ+QcWBE/L8OnEddwxBLnZTRJ1lCRql23Cxgh4i4pI+n1NBdfel1nD6YBvd3bfZDckA+IF+d2/5HgfYX57Y36fC59Mrque1H6rTbPrf9dyXvlXSupAckPZN9PU/Sf0tavOaR2hAR3wX+G3gGOAj4t6RPSVpXFbW1JS0vaVtJvyJdSKxF+nt9fbX11i1vJv1PXJja4OetzvDJV8kwG0+Opb0yCNdp4z1oA0N7TTpBLx4mRsRd+TZNvqYWOIf7IuKIiNgmIlbLfofFIuJFEbFV9vvd0sSfyTMRcXJE7BER60bECyJicvZ1/YjYJyL+GBFd+Q/gONorcxmPKhkl4x2vbbA57g2zb5Dug5uY7LHg4Q6fg69JYfgnXUhaS9I3JV0r6XFJsyXdLukkSTt0qc9JknaX9AdJd0uaK+lhSVdI+rKkVQoc41BJ0eLr0CrHm9LG8e7q5J+PY3MvjVMMG6fftSfOo3xTs7GkVzRov2tu+4w2+v1Dbnu3Bm3fQlpmBODuiLi6XuOCXpPbrps4nCVk5Jcs+WJEtLw8a7MGPZYO4jXByJN0LOUsm9nA2yPi4jpvsb6ZlPvqD7Ahs2Fu+9YC7W/Lbb9E0nItlpPqp/fktqvGlCwzcLPcrkeA84FtKpqumr22Bb4g6V0R8a9mTkbSHQWbzidVNXkF8P+y17OSZpBGGpYlLSvz/KFJJaReBlwsKSJi7WbOzYroVEWPqRXb0zp0XEgTjCt5CZNukbQWacm1HSiXin6AVCr6NxFxThf6nESKbflS0U9RLhX984gotDaipNWATbPXZtnXVXNN1owOlMTPzvkfTFxG6rCIOLTF4zmWGhOvScHXpWbFOY4OiiXob1LGpIrt8YyjpeS2Zt9jw8Vxr996NQey4BImV189cRSoLb2+JnXp/W6QdABwFLBkxY/Wyl57SDoTeH+nxkYlrUGqilY5w3vl7LU58FlJ+0VEOw8u67mnn8dzbLYyP3MaVhExM4uPu5P+7x0C7F2traRtKFeseBo4s42uTwQOJv2j2U3SERFxY5U+J2XnVHJCG32WjvlW4PW5XefXaVstIePIds+hoo+hjqVOyugxpXUjS0uWlBIyLurjKVlhvfiQHKmbjUnZA7Bqno60rlw35R+0NSz7GRFPSJoFLJ3tKj34GwqSNgQ+mNv1kxpNVweWyn1/HOUyWn8llZx+FngV8E7SMidTSBU1XtPMrMfsfVGwbb5daazwRdl+VbQrtV2D8oflkFu1cZOWLUPzlTKanHnTtsmt9Tf38fR1iWU6ejbdMInmB8AH6dNg2AdtJH2bVL6uFz7DxISMdk3BsdR6bqSuSc2m4Dha0Dj9v/cguI20KTjujaivkCYiQHrW0Ogucx5cfnkHkzIMhvv+XtL+wLG5XdOBc0nPKTYGdiQN0rwLOEPS9tFgOboCfa5Aeoi3frZrDnA6cDNpNvdOpHGFFYFTJO0YEefWONz5FB/keh3w7mx7FhOXri55HDiw4PEWI/0HLMXGXxV8X8kUHJttIeP5zGnIE4W/SootiwJ7SZoeEUflG0jaGDg+t+s71SovSJoK/K30fZ1qmDdKOh7Yl/RHd1oWn+/OHWsR4LuUn/U8ClStUJEVDrgNODEiqlZczxI89gJ+kNv914i4skb7yoSMgzqdkJGZwhDHUidl9FCVhIx3RMS0/p1R+w6c2Y1/l/kPoX4PlAzeB1YnzXumq4dfBfhPjZ8dBhza1d5TplvJrILvmU05KWPZeg0HiaSlgd+QLgQAzqgTW1ao+P4NpOSTXSLirxXHXRs4h5RNuBwpI/M1NKfd66XK9w/Q9degK92jtpKw0MmEjGkUq5axWJV+H872zcx+XvpdZqb9s7OlSxZbDCblLuUXfBUmHd7eaTdltO93R2DQBlJmdKXHs/d3TFa28OvZtwWnrhU7dIffP4KxtBvXa524Ju3UtWTlcfp9jdwfzQ7cjOA/dGud42jflKpjVPso7qVSzOzl/f1ojyfYwHPcGxnfyG3nq0LOI92G1bg6mnkX3HMPz9z/GHxJLP7NTty3+pp0mGXjfN/L7To4Ir5d0WYT4M+kcd2tgc8B32qz66Mp39vfBGyfr1Ip6UDg+6TnJpOB4yWtU23CR0RcSppQ1pCks3PfnlJtgmDWR6Gy+pJ2pRwLnwZOKfK+ysO08J567x/R2Dyo9/ed4mvEYRYRt0r6DOWx0iMl7cnCY6WlZzUXUTDONPB50iSwdUkx9QZJlWOlpcoO84F9I+LJGsdag7Saw9GSrgL+RaqGXHo+tjbwZuDFuffcDnyg2sEkvYGJCRk3AM9J+nyB3+vSLLY3Y2hjqZMyeqRGQsbf6rxl4LwSWGmliftOfLnY89ZuPoxq9cOxWx9svSjPN3gfys1mgA/I2edncxd9OJivp7tUzVYDJMtYPIFU1h9SVZAP13lLtWST/SsTMiCteS5pJ9KH8mLAZpK2iYi/FDy9NxdsZ13VTJWMblXHmMbCiRml/SX5S5J5wMMw9yaYNw/mz4fJk2G5jbKfzYAFdc515syJxcesZaMwaJN5ArgAuKr0iog7JXXsIiaLx78kff7cBFxLKmfYLsfSQrpx/ZQfqBnEweZuDyQN3jWpWYscRwdCO0uXzKU7SR3jtyTUkM9KtOIc90ZKvjrGNyp+VqNaxoKHU4WMezq9WgP0PjGj29f5Y+Vwyv9gTqq8tweIiGsk7QOcl+06SNKPImJGKx1KWo80sxtSZd5dK5cNjYjnJH2C9CBzK1JlzM+TZqO3JKvevF1u189bPVbOh3LbJ0dE0UmAJY7NhXX7XnQcnzlZJ0XED7JxwCNJNyobZ69KZwF7R0Tb06Mj4jFJ25KqCm9Ben61V5WmTwAfjog/1Tlc6R/bIqRKxJs36P53wKfqLCG9NuWEDIANSBWXiziMgsl2maGOpU7K6AFJX6KckAFpiYBNJW1a4O2/i4h7u3NmxS0FbP1iWK3WYhQdNWgXxsM/IL3pH4Or3jlxKGXeMzC3u5Uy+m1ObrvouFN+pG92B8+lKySJtEzJztmup4B3RcRjdd42p+L7O0gf5FVFxE1ZxmXpweI7gEJJGV6aqZrFqP7P8UG6u4RJUZWJDn08r7k3wfXXl79fbDHYaD1gBjz1eErUqGX+fHhgf3jxj7t9lhRNZBniAfCRGLSJiMNaOZcmfSo7lwXAftRPkCvMsdTKql2TDtp1cyPDdr42ChxHm9GNe98laC8hY9gN/3jCoJG0FulaawfgpaR/ZA8AVwC/iYhzutDnJOA9wB6kCRGl5U7vBP4I/LzOIHXpGIcCX2vxFA6LiEOLNnbc67de/r+vUS3jssvhqqt55snyENAzHauWUc34XeMN20MVScsAu2TfBulev6qIOF/S5aTlP5YjVcU8rsWu96T8H+LUiPh3jT4XSPo6aaY5wN60kZRBms1dekB4YwuzsCeQ9BJg29yuppM8HJv7bdDiVK+vEQcrwU00H0cHZJz0eRFxjKRzSON/21O+Ln2QdF16QoPEiFb6vEfS64H3MvG69GnK16U/i4gHGxzqfcCbstemwDrZcZYkPRd7glTt4jJSEtrNnfw92jHssXTYrh+G1Ssqvt8xexVxJdD3pIx3AJttBostuvDPbn6fWPekQSzd3ukPmny5015kgZd0/sO5RwkZD1F71cqFysV1Qb6PpWu2mihfHaMX59iuY0mDUZDOd7uIuKrBeyp/r79FRKP/wBdSTsp4dXOnaP2zDM1VyeiVaUysmpFXuix5HG65BZ7JJTw8Mw/m3pG26yVkzJ1Zft8D+5f3dyRBY1XSdfV4GMNBm5ZJWgc4Ivv2hxFxiaSOJGVYMwb1wVc3r0m7rbvXpOOolw8TJa1MGjx+M2mwZk1SjJ4F3A/8k5Sce16B68FWHig+FhEr1WuQG+CeCmwEvIx07f40cA9wOWkw65Im+jWroxSTe/mZ0elYOmgPFXpH0gGkWXdLVvxorey1h6QzgffXqaDWbJ9rkGLlVhU/Wjl7bQ58VtJ+EXFGJ/qsohvlDmyo5KtlVKpSLWPO7AkJGd3Tq1jqa9IO2JbyZLTpBR6w/Z50fw9pMthxLfa7U2670XIfFwAzgOWBKZI2iYhrmu0wm8T2wdyuXzR7jCo+QPkf33UR8c8OHNPqGsf7++F+5jSOIuJ24KDs1cr7p9FkvklELAB+m71aEhFzSZPrzmvUtuDxjqP1z4mx4qQMq2sp0lP1d64DyyzT77Pph1ofTsM7AFJKyJg3DzbaCJa6rHFJiBbX714QEfe3eJqdkH9yukajxpKWZ2LyRt1ZLv0m6RjKFXhmkkr7X1bgrZVPlO8r8J58m7oD69ZIvf9Jg1Ito1K75zW1yr5pNfaX3AJPV0koue8+WHHFifsmT4ZJuT/Xed1agqVSr/rpq7EZtGlHNuBTWrbkHuDgXvZv3TYoD74G4Zq0/4NiQ7qk3vN6+TBR0p+BtzKxhGjJC7LX+sD7gcsl7RMRt7bTZ5PntxxpAOi1VB+EWiF7bQx8VNKfgA81molundD//+vVtbuESbXfaVB/1+5pNo6W3jMIJO1Pee1ugOksvHb3ZFJy8BmSto+Iti7aJa0AnE95Wb05QOXa3WsBKwKnSNoxIs6tdqzsOEWz5l8HvDvbnkW6zjaroUa1jCrar5YxCBGhU7F7UK7zeyY/yeofBdpfnNvepJUOJS1OKmFfqN9s4sWlpOTlUr+t3N9PJcVmSNU3j2/hGM/L7vk/kNvViSQPG2uDcH/fX0NcUdisLU7K6IGI2JdyGe6hsiyw7WTY7DX1241PtYzSMXups79DKSGjZFmGYJ2O1txAGowBeHmB9uvktu/r1KyabsgSMj6efTsL2KHo7MGIeErSvcBLSruKvK35s7SFNXup2Wu9TjKYVvtHt91Uff9DD6dlTPJZgovl/lwXzINZ/YhojW8LhvRmY5wGbdrxCeAN2fZHI2IQS9SMkUF9wDYK16TWjj48THwz5YSM2aRKHNcCj5LKaW1BOUPydcDFkl4fEbcVPP7vSFUd66n3obwU5UQ+gCdJ68heTyqVukJ2fqU70bcDF2Xn+GjBczQrYLjv78eFpLWB7+V2HVy5rJ6kTYA/k0ovbw18DvhWm10fTTkh4ybSZIi7cn0eCHyfNGFiMnC8pHWqjSdkpfMLlc+XdHbu21MiYhgqedoEvf6/XqeaZNeN3zVpGwlukyTVWhz86S7/X98wt10kETd/TfgSScu1MFa6HuXr0RkFr+Hy/W5Ys1V9++W2/xgRj7R4nJJtgCnZ9jPAb9o8ng29Ubi/9zWpWT84KcPqWnZp2G7r+m0GMxnDKs3LliupnES+7NLw0Kzen08PXJ3briwzWs0bctu9fqBXmKRjgQOyb2cDb4+Ii+u8pZorKSdlNKwiUtHm4Sb7MqDYI/leV8kYgUoPkyfDEv0o49TTPzsP2jTXb6uDNi3JliEoDfb/ps7MSOuJbgwojN8gs3VeHx8mXgb8EDg9IhZKkJC0BWnG96pZv78grSlbxLlZidJ2nQv8BPhTRDxb5Rx3BE4iJZKsC/wPqbqHdY0HZ0fdkA4EHk75huqkyhgKEBHXSNqHchnmgyT9KCJmtNKhpPUoT7B6Ftg1n5CR9fmcpE+Qkuu2Ii1n8nnaWFIvu/bfLrfr560ey/qp07G01tIlmemXT/z+8surt7N+WwX4T42fHQYc2sW+84NODavmRsQTkmZRriq8CtDs/X1TfWbyy7g3PVCWVULeJberEzH0Q7ntMyPisQ4c0xryNamZjZ4hvRcz64d+lbXrzAXI3Gdaf69orlDsAMzuhjQQU6pxu7GkV0TELXXa75rb7tY6sG2R9APKS5aUEjIuauFQp5OWFgDYWpIarCOeT80qvGaipDfmv4+Iv9f6Wbvyxx5O3UjIaDRZf4CTMtbZCB76y8L7l11mANbS6vmfmwdtGmtr0KZVuWVLlgIeAT7dpX4cS63C2JVafl6LS+oNgp4/TAS2y9anrSkiLpO0M2nmtoA3SnpVRFzXYp/NeBrYPCL+r8E5niVpP+DkbNf7JH06Ip4o2pHjaL/N7dBxOj0LfLjv78eJpGUoP2ALUkytKiLOl3Q5qRLPcqTqQ8e12PWelP/CTo2If9foc4Gkr5OSzAD2po2kDFKJ/FKS8o1ZhY2mOO71W4//n991G/xl4v3zM7Ofq9p0sUEv4DlEhvChyrK57aLT82ZTvr9ftl7DDvdZ7f1F7Ul5GPte0tJRLZO0IuVKzNBGkodjc78N6j30eF6Tiubj6ADd31sfDXssHcLrBxskna+SMagfjsOvskLGqIuImdma3LuTPrMPIQ2OLETSNsCW2bdPA2f24BSbUiUh4x2NBtrr+APlstBrAe+lPNBd2e+6lNeyhZTQUdQ0ykufBBM/c/I/a1flsW2gEzKmUnfpEgBeCcteDk9nv8ez2fkuv3z9t9UKdC/+ceGz65YhXb5kXAZtWnUA5Rnln+zibJlpOJb2ga9JF+YHia3o18PEoteJEXG5pH8Cr812bQF0PSkjImYBdRMyck4BvktKvJtMWtKkmQH2aTiOFtTp/+dFEjKqJVsM+R+jddq2lB+wTY+Imxu0/z3l5ZF2pvWkjJ1y26c0aHsBMANYHpgiaZOIaLoCZ5b0+8Hcrl80e4zMNBz3RkSDChkA06dz5/SJBRRftDJMXnThppq8yMI729KPh4m+Jm3RkrntooNC+Q/ypYakz3xVi19FRLv/QPcCFs+27wL+2saxpuHYXNCwLw1iZl00jSGOpb6KMWuK/8sMma+SyowC7JWt9zqBpI2B43O7vlNt5p2kqZKi9OrO6VZXIyHjb60eL1vu4LDcrp9IWmihoqzU9h8oP0s+LyJaqYEpaj9fVodeNlKWgilTyt/OmJFed9xR/221kjIe2L9D5zV2xmXQpmmS1gRKM93PioiqiW2d7hbH0jrG7Rpt3H7fodbKw8SSnWu26qw7c9sv7FGfhWUV3e7K7Wr1HB1Hh1anq2SMr0mkm7tmXgPwifPq3PY/CrTPL++5SSsdSloc2KBov9lDv3xFi5b6JWWwr5VtP8vEsYpWOO713AD8j6lnUZfK6LOHgNVrvP6ny33PyW0X/YeQL5y80FJ4g9anpFdTjr9BqmzZrnySxy8bVBouyrHZKgz4Z4fVJGktSd+UdK2kxyXNlnS7pJMk7dClPidJ2l3SHyTdLWmupIclXSHpy5JWKXicyZK2lnSEpAsk3Zcda7akeyX9SdKnsmWhmj3Ht0n6laTrJc2QNF/Sk5JulHSipF0ktZspOpSxdMgz5mz0jG855toW4A/m1kTErZI+Axyb7TpS0p6ksqKzSeu+7giU5g9cBBzdbr+S3gO8p2L3y3LbG0o6tcr57lq5T9KXKCdkQMrI3lTSpgVO5XcRcW+Nnx1LWpbknaSZmH+V9BfSQNJ84JXZz0o3Q/+hvJ5uUfdQOzOx3s+sY5ahcdWMRroxaDOVxtUyMs/Og8cfT9szZ8K668HiVc5pwTyY1coYwcB7CNisxs+errG/U0Z+0KYV2QzGX5AqgjwF/HeXu3Qs7Qtfky6s/9ekYiiXL+n5w8QWrJ7bfqTgez4s6XPAFNK19GPATaRr1V9ExEMdPcPWzrHEcdRqcKxvwiRJq9X42dNZ4n+3bJjbvrVA+9ty2y+RtFxENLuk3nqUlxCZERGPNtnvhjVb1bdfbvuPEdFsvCtx3BsZX6FQtYwCFlsMWHQUHgX0/5q0lODW7HuABRFxf6fPp6B8nF66ZquJ8pMeWonzve4zn0Dxl4i4u8n3TyDpNcBG2bcLgF+1czwcm82e1+y9fek9g0TSAcBRTJxgBinBdi1gj6yS+/tbuBat1ecapIrnW1X8aOXstTnwWUn7RcQZdY7zUeCbwIo1mqyRvXYADpX0yYg4ocD5rQ6cBFRbRmS57LUe8D7gOkm7R8QNjY5bYahj6ShcidlIGsTBkdL59OPc+nvD0ezNxiClkETEDyRNAo4kPbjbOHtVOgvYOyKe6UC3GzBxyY9KKzX4ed4rKr7fMXsVcSVp/cSFRMRzkt4L/JC0Zi3ANtmr0j+BXSPiwYL9lvqY0srPrBOaTcaYR3eSL6qZRkrKaODhh9PXefNgfjY7cv78VC1j/fXgwQdh1VXL7eut0fTsPLjyHWl7s7NbOOf2iZbXSvSgTff7bNb+wJuz7S9ExH+62Zlj6SAYtOvS8b0mbVE/HyRCfx4mFpYNmmyZ23VxrbYVtqz4frXstTVwiKTDSBXo2h4QkfQ64CXZt/NI16aFOY720xKkglalr63oVpWMfsWzfAwfKquQEvWrOQw4tIt95y76ua9R44h4QtIsyteSq5ASabvWZyZ/771qzVY1ZLMQd8nt+nmzxyhx3BtVjRM0nnqqfAv90pdO/JmWrHxm1AmlWDqM16SDdH3fE/kxvTUaNc5iUv6evJWE26b6rNKucJ+SliA95CtpOYbm5JM8zouIop8HVTk291MpTg3avT34mnQ4Sdqf8kRggOksPBF4MmlJ0jMkbR8Rba0nLmkF0jKe62e75pCWmr+ZtEz9TqRkkBWBUyTtGBHn1jjcJpQTMgK4kTRZ9z/Ac6RnUqXJvMsDx0taPiKOqXN+y5EmPa+d230JcA0pnq8CbEpaMhXgVcDfJW3czNjqsMdSJ2VYQ4tVWYOw+wbtwzFvkM/NqomIYySdA3wY2B54KWlk8EHgCuCEiPhTH0+xLyJiLvBBST8D3k96Ur4aabbjw6Q/m98Bp3eoPJ8NpHm5r5WJGd1K1JjW4OfXw0MPV//RnVlSxuWXp6SM7baDSQ3Oc2a71UJK7unQcYbGSA/atCL7HY/Mvv078NNu9meDYlCv/Qb1vAZOPx8kQn8eJjbjKMqzwS8qsLwKpOvEf5AGf54CliUNqGxDmiW0BPAt4OVMHMxuWladKF/J7rfdTFKxbimakJEfp+zFcNWwxtHWz1vAYk3+0ar/q8csm9ueVfA9synH0WXrNexwn9XeX9SelCvA3UsadDfLaVwxY/q/YN6zsNSSE5MyulslY1hj6di5gfRwENI1WiPr5Lbva/H662bKT5yXl7RSgcpD+X7/3URfu5IeHEKq4HZmE+9diKSlgD1yuzqR5GF9N6jxalDPq5FhPe/2ZEu+fy+36+CI+HZFm02AP5Pu57cGPke6R27H0ZQTMm4Cto+Iu3J9Hgh8n1R1fTIpkWKdOvH7EdKE3V9HxJ2VP8zGQI8jJXsAHC3p/DpjBl+knJDxCLBzRFxS5bhTgVNJy5K+kDQus19lu1HlpAxraJll609AtsF33paDVtyp9yLiduCg7NXK+6dRsEpWRBxKhwb4I2Jfml82pNk+LgMu62Yf1i9FkxHyQX4A1ph94Pr09dlclYyS2bPhjjt44Ip7edEq97LIdtvVP9az89J7rBWjPmjTiuVJpWggleJbkJ4XNvQ1SV/Ltu8ehsxts+5ob9BGai5hXM8yCIUr+/EwsZBsWb/SYPN80kBRPZeTBpQuioiF/jIlrQx8l/IsxQ9KuiIi2klg+xLl0qxPAYe0cSwbaPMqtj1cZc/LT+8vOjqVzwRaqmarweozn8T2q2px1qye+fNh+h3lf7DrTIeNsoUXNLndZdtHTZvXpAxlgtvVue3KsvfVvCG3fU0rHUbEXEk3kJZILvX7h1rts0rH+WpszfSbj6EntDsjHdiNNEMcUkLyWW0ez8xymr23h4G5vwc4nPIA+kmVCRkAEXGNpH2A87JdB0n6UUTMaKVDSetRfkb0LKmq+V0VfT4n6ROkSh1bkZYz+Tzw1SqH/AXw2YioOWgeETMk7Uaqxr4R6Xf+CLXHDfKV4b9YLSEjO+40SQcBP8t2bV/rHEaRa9NYQ2u+fvXGjWyklW42ir6cAmKNSPpl7vWyfp/PeJqXe+X3leSTMx7vyRk9b9bMlExRy+WX8/jjcNONwNVXw203wX01Jh93rEpGe6Q0O6mZV7Fn/V3Vl0EbUjJIoX7bHLQZeo6lZkOhHw/2GpK0BWkgpuQrEXFVvfdExLkR8bdaDwoj4pGI2BPIrzV7mKTFWzzHXYCv53Z9JCKqLs3XKsfRQTafhZcuGYzrujH1ELB6jdf/dLnvObntohnkS+S2W8nQ7mmfkl5NKiMN6XHDL5t5f5N9Oe6NmvnzmT0LHn0k/cMrvS7Ppt4sthiwVFcuJ2y4nEf5GnNjSZXLJVfaNbd9Rhv95pMwdmvQ9i2kEvyQJjNcXa9xSTZr/U25XZ1euuT4iHi2A8esybHZbDhIWobycnNBStCoKiLOJ01sgJTk9a42ut6T8vP8UyOi6qS07F49fw+9d412/1cvISPX7lngR7ldW9RqC0zJbV/a4ND5ZVNXanQeRQ1DLPXUA6trqaWALbdk3ftP5bFHg0cbzVUdaaWYN1qTFZZaiuJz9sw6Z1/ShcvDEfHBPp9LD4g0ljcMZYeqLWPSSVNpvHxJfbde/lj5m7//HVZfAxZfDF7xClhhxYmNKyttWDNKgzZLkA3aRMQtddp3ctCmNJNmN+rMpKHFQZs2zAR+XbDt6ymX7fsXcG223cmrqX0Zq1g67Dq1VuxoXpN20UPAZjV+9nQP+u/Hw8S6JG0EnA2UkiV+Q3lppk74NLAzqbLQqqTKQhc0cwBJ2wAnUc73PiIiftfBcyzZF8fRPqt1fdzta9LxjKWaBIs1mSalBcACFkTE/V05qcbysXrpmq0myj+BbiXW97rP/MO/v0TE3U2+vxn74rg3Wp6Zx+w5MHvOxN3TH4f774c116mokvH/loPPdmolsEmMWxwdVhExU9KZwO6k66tDqPGwLrsOK01+eJr2lgI5ETiY9I9lN0lHRMSNVfqcxMSKaCdUtqnjg5SvGa+o9bCyqCxhJT/p5Be12nbQvjg2j6nxvCYdYttSvl+fXmD5z98Dr8u2dyYtB9KKnXLbpzRoewEwg1Ttd4qkTSKinUls+aVNXlin3RzKYwwrkaoh17JybruT1737MuCx1JUyrK7Jyy0FU6bAllvywi3W7ffptMgfaLUst2z2d2zWe6VBqlv7ehY9U/q4HYClQQrp9nlObfmdc+54gHnPlL//92VPM+eaG3nu6n/BdddPbDxrZo/W3+p/SYtuiIiZlAdfSoM2VXVh0Kb04b2bpPWrNWpz0KYlEfFoROxb5AX8I/fWM3M/+3wHT2nMYqmNOyk9TCz6yioOLYiI+2u8epGU0Y+HiTVJ2hD4C1DKYvwdsG9EdKwQbEQ8nvVRUm82zUKyNWb/QHlA538i4isdObmFOY721XwmVm8rXbdVVnPLc7WMMfRgbnuNRo2z9a/z8fahbvdZpV3hPiUtQXnZJ+jMDO96HPdGzXPzmT27epHIyy8DFu32/f34PV6QYPKizb0GoBImpBL2pYoPe0k6sLKBpI2B43O7vhMRT1RpN1VSlF61OswSMErHWww4rXL2sqRFgO9RToR4FDi6yC+UvXff3K5OV8m4JCJu6sAxG3FsHjp+5tSOIY6jr85t/6Nmq7J8RYhNaraqI6s8uUHRfrNqGflKFS31m5NfSuGROu3yv+tnVWO952w8Nz82eny1di0a+Fg6fldN1pxlsyWMt9wSttoylbwbe6Pz32aLty1b/js2660Hsq+DcTnVU4MQSFtJVOjVEibXL7QUyZM3PfD8647bF37H83kXlUuezO745OIaGn8uNPsgMfcwsd9GbtBmxIxxLK00jgMi/bomHcc/67b042FirWNvAFxIeVbKqcBeEfFcp/rIuS23vUrRN0l6E6mKRykx5X87nMxWyXG0r6pdkw5DZTnrsfzSdi8v0H6d3PZ9EdFKSYCbKX/gLS+pSFnlfL/NzNLelTSTEeAx2ktuLsJxr6t6fJ20YB63nnt7/QKRi1YUyn52PnxnFCZo+Zq0WRFxK/CZ3K4jJV0r6duSvirpNOD/gBdnP7+Iztxnf57yjOn1gRsknSDpK5L+J/vZx7OfzyclDD9Z8NjbA6tl2zOBk9s5UUmTgX1yu7qdKFfi2Dz2RueZU5dNkrRajVcvHnRtmNsu8uA/f1/8EknLtdDnekCp7NWMiChSgTff74Y1WxXzntz2xTVbwRFAaWxhF+AiSe+U9BJJi0t6qaR3kZJKSpU/zqazVTsHPpZ6+RIrbqWVWPP1q8NTT3HzlSnh6Ob3iXVP6tikqi7qVLnofurc7zBlCqy7nmC77eCEvzds32yJ06y8qVk9VwGvyF7Gg6Tq3r0ywIPdD1RUu3h6JnfcMXHXYosWOE6tKhlXvgM2O7vl06s4kw4dZ3BFxK2SPgMcm+06UtKewLmkkvobAzsCpb+VTg7abAGsS3nQ5nTSYM0KpIv30tIgDQdtJK3MxDUQq/mhpMpMnmMjYlrzp98zjqVDZxSuSdsxliWub6C8dmyvHiYuJEvI+BvwomzX6cAeEdGtdb6avknMEjL+RDkp5fsR8dmOntXCHEcn6GWMKlXJ6Ld+xaX+fB4ImNzkSOAAjGjml6fbqkD7fMn5lko1R8RcSTdQXlJvK+osqZfN+Nsyt6uZfvMzsk+IiG7/x3DcGzp17jvPP5t77mnhkJUTGsZOe7FfoumJi3qGFq6OOi8ifpDFrCPJlirNXpXOAvaOiGeq/KzZPh+TtC0pYWILUvLtXlWaPgF8OCL+1MTh8zH0lKziZzveTnmA7mnS0gO94Ng8wbDcNw/LedYzdL/DKsB/avzsMODQLvefH8C/r2arTEQ8IWkW5XvcVYBm7/Gb6jNzb433NyWL3W/Lvp0P/LJW24i4QtKOwG+BF5Cuyd9Qo/mNwI+BYzpZtZMhiKVD9b/NBsCWW8IWW7Laixs3tW5oLdvhbZdOjGvrbrcmTJ2asjPM+uM32deVJG3X1zPpi8Xo3wP9dgZful0t4y64uaIq5KyZ3HcvE14P5wqlzXs2l3sxe3ZKxqi3bMkz8+CSbbtx8iMrIn4AfBKYm+3aGPgi6WZnF8oJGWcBO3Vq0Ia0TuNl2a7SoM3Xgc9STsh4Ati9wKDN0sC7q7zytq/y8ynt/B49MOax1PrHGbhN6PnDxErZkiX5hIwzSbGzWwkZMDG5pGG1j2zJknMoD1YdGxGf6vxpLcRxtOvm13i1c006KkuYtBpHx24o7zxy16GSGg2y7prbPqONfvNJGLs1aPsWUuIwwN0RcXW9xiWS1gbelNvVixnZjntd1+lrpMk1X3H5FRNaziNF2NnZq1YFjZjfjSJZ/eBr0lZExDGkpLPvANOBGaQ4exdpabt3RMQ7m6hWUaTPe4DXk5ZrOov0wHAeqULQlaQqnRtExGlFjylpFeAduV2dXrrktxExqwPHLMKx2fqo99ekUpp018xrQCoK56txFI0P+QlgrVTz6EefSFoV+EVu1zFZxaWaIuLPpMoehwG1xoefAa4ALu5wQgYMQSwduzs5a9OUKbDxRiy71atYbLHms4Ktv5ZbFlZaiZSQsdlm/T4dG2PZB/S5pIlXx2Y3UtZRtQZu6unzjMW5N6X1bvOvKmY+DbPnwIwZ6VVa7eS5+x6Ac8+FCy9svHRJ24kZi9FMcs0Q32wAozNoM2ocS23cNBtLBySO9uthIlA1IeMPwHsi4tna72q7zxWAbXK7rqjVNms/lVQho1RL/YcR8YmunFyF/8/emYfJUVX9//OdJJMQQggxJCwBY9i3RBAREBARUPzJJqAgi6igKOorAgq+iogLq74q4IYisgqyKYqCiAFRwIUlYNjDFrYAYSBhgCHJ+f1xq6maTlV3VXdVd3X3/TxPPVNdfeve2z0zp+4999zv8Xa0ncSNoYYiR6/QiBO8txYgg13PVwYvBXwtqaykHQkVKxbSXCqQCwi/7H0kbZDQZl9Vn87L0MbHCcVIbjWzLGlPGsLbvVaQt7u9P/HQ+HCdZfFieBJ3PIbTLR8YCN58fXHk6CUb60nCzB4ys2PMbKaZrWRmy5nZW8wszaYHzGyWmalypGxzqZldFPgO1jSz0WY2yczebmbfNLOn69cyrL5nzGxUpB8317+rbp27Rer7VLP1ZWjX22ZPm+mt8WUTLBc5T/tAfTVy3kj+sJa3KWk53Di6koL1DuDYFPdNAL6CU0Aejdtsd2pw7dTg9WjgYODfkr6etW+16ARb6tOXeBpjq615y4Kid0yXnc6RX75mazc23uq9wWRtUpp0qCESjMmSvuTV+mVajaTpwCHA+4E1cRJ9T+GcxOeb2dU5tjUC2BB4G7B58HMm4QP0BjPbvsG6c/0ckt4L7Au8HfeQHYeLuHwSt7PzMuC3BeUa/yjOAb858C9JXwQuN7PO+MfKhYozemKL2+xn+Bgu7UbZIvs5APffD6OrHPRV0X+Dr8D8ZyC6sWfRQlhlCjz9DMDz9I+CjTarqv61PB1P7VQ6aR9m9hBwTHA0cv8sMipgB/bgouBoGDN7JGvbzWJmB+MmGUXjbamnjWSVOu29P0szWyTpStx4q7KYeGBc2ZwXE6MBGSsHl34H7FNkQEbAdwl34zyLS20VS0JAxuFFdi4Gb0ffoJ37dir7u9MwrsiOdDWV4Las95SA43AqZqOAAyTNNrNTowUkzQTOjVw62cxeqK4osDt/rbxOWkw0s3sknYsbz/UDl0naxcwejdQ1Avg+ocrRc6RM5Rfce3DkUitUMip4u9ct7LYbXHnBGy+fJlTJWAQ8WXHdRgIxukclI0qL5fcFI0dkv8fjqYO3zR1Hr+95bzINVIb1JgA5sbxncP8jcSxsuEPpeSVyntY5PCZyXmcXYfvblNSPWxN6R3BpHrBnPWVkSWsAs4DpOLnt3czs+phyO+BSQ00Ejpe0INgMmBeltqU+KMPTGCuOd6lMNryk3T1JSbc9ILNPNqZNA95XSsWewpF0OC4Sb7mqt6YHx36Bs/yjOeXtfgKXHyxX8vwcklYHLgS2i3l7fHCsj9uhfpekfc1sTnOfYFj7xwWn1wHr4QJCLgaek3QL8BAuv1qqh6WZnZBX37qfkSwblBGlopbRqqCD7XHjtbvdyzoSTAMDUIkJnDAhvD7viVAxA2CjefNg6lRqMvuDMOPyTL3t1YAMTznxtjRKp4z1iuhn5wQK9zAtX0xMCMjYu9GADElHA6sCPzGz+xPKvAn4HnBQ5PLxZhYbsh0XkAF8tpH+NYq3o+2mMiaNG5e2ekzaTlvacbm8W46ZPSDpCOCM4NIpkvbH7YQbxG2C2JUwrd4NpAyOqMNRwFY4+7ABMEfS5cB9uHQluxOm1VsMHJxBOW4XYLXgfBHw6xz6Wxdv97qMtbdkm20u4KabYOg1J2e4GJiP2yJ7E8Dg4DKBGDo+b7Vw6Kwxaaf009MreNtcTS+Pi/yYtA5LzezJNrYfDfxYPrHUcKJKFY0EjrSsTUmjgEtw41Rwm4HfE2x2q8d5uDUqgAPiAjIAzOx6SQfifAEA35J0jpk1HVTTCbbUB2V4GmfatHb3oI2U/uE0jGnTYL311ZO/M0mHETpuwMnuVztuRgJ7AFcEO1+a3VI/puq14ebGKy1bNB15fg5J43FOqrUil/+Oy1v+DC6g5G045xPAJsCNkmaa2RONfoYqjsd9LxUMt29gZYbng0xLB082WqmSUaGec7sVDvDtg5+zgMXw4L3xxRJSmCxYMDwoY+7cGvEcuatkZKevgQjwPr+TxlOf4/G2tMPI28lRhjFp6xw3WW1pWexoqxcTA8nQ6wkDMhbiVNX+R/W3vD9uZhfHXF8eOAI4QtK9uDRSjwZ1j8ONF3diuPPnHDP7UUIf12F4QMaTuJRYR6bo491m9qd6hVJyPN6OtpF+3Fo0xKtktCooo5MWEnsXMzszSBVyCm7OPTM4qrkKOLDebr6UbT4vaWdcwMRWOJt1QEzRF4BD00j+R/hE5PySIE1LKzgeb/cKpPVjs9Gbb8LY/9wVO0a6Cfjj75css0fLjlfOgRmdNib1dt9TOo7H22aPt02dQDTNUp3dgG/MzaOBFM8U3WZMuVRtBgEZF+OCjivtvjtpU0bVvZsD7wpe3hukEUnEzK6WdB8ucGI8Lv1p0+lb6QBb6oMyPI0z9pR29yADRTiL2/2ATP+Z1rvQ4Odp7fWydKoDXNJawA8il441s5OqymwK/BEXiLADcCRwYpNN34+LuvsPzmF9G/BB4JeNVFbA5/gyYUDGszj5qb/HtLs9cCnwpuD4Bi51Sl4k/aVk/QsqYotHD1BxcMcFLAwSrwixgGKCSGbDYHb1toGBMDBj6LW6Ihs54BUyPKXE29Kep91j0iz0rpOpxYuJE4DJkdcrAN9Oee8NOEdMLdYPjiQGga/j0pgksTrDAzhWw303afgVLqAlL7wdBcqxoFZN0ph0Ed2XwqQ1AW7qa0Aqug8oSbYDMztd0tXAobgdfJWUnk/jgs/OyxgYkabNxyRtA3wY2A94K27evRB4GKdEdJaZPZ1YSRVBfuuoY7iVqUvA273uYuxYxo93qT77WTbE7ZxbWyWc2ztjPL/pwlMQ3jYD5RyTJtERyhIZaU2AmwQjM65OlySl3hzcpliAdVKUXztyPq9Blfb7CH8xEyRNMrPnMrT733oNRAIy9gwuPQPsYGb3pezjVpHzu1LeMxsXlAHpvsu0lNqW+qAMTw9ReUB004Myw0Ny550L7UlJOYHQg3dhdSADgJndLukg4Jrg0jGSfmxmA402amZbVF9LseOvFnl/jr0i51+OC8gI6pwl6RjgrODSLnHlGuRXOdblaSl5B2bMg6fqBtzGsmhRGJQxMOCOscvDuHHA3Xc7OY0ZM+rUcg5uOBS34a2aVXCf3+MpDd6WAp03tuvxMWkP047FxBz5AS7YeEvg7bidN5NwSnCvAs8Dd+IUOs6LS71SUrwd7Vh6OTCjdwPcAMzsIeCY4Gjk/llkdMoGOagvCo6mMbNnCNWRWo23e4XRprHQyJFMnuKCMuJ4MOE2O979GxSTyqRddOM429MjeNvcsXSj3fHz+xrcFjl/Z4ry20bOb2+kQTN7VdIcYONIu79NKh9sBtk6bbuRlCV7BJfm4wIy7snQzRWiXc5wX4W8Jjelt6U+KMPj6RXWPBsGv9TuXrQMSeNw6hTgHgSJUkNmdm2QU2pLnFzSHriV2rZT0OeYFjn/R50u/C1yPqlO2dSY2cfyqquzaUfqkjzIMTBj6f3w7PyaRaI7UOKiqAdfgXlBrMSEQPT3r9ctYerUx1ln4kRYefKyNwFMnUrLhkINRIBnjt/19BzelhZNby96FUcTu2n6sqkiqYR+pFYsJgb5XnN9igRBFr8Pjjzqm0UJnnTejlYowz/LSOJTmNSiGwMzPJ5i8XavE/ksw7PZVtHfz8iRsPbasBnwGC5/7qvB27WkrbTccjn1ETpv7NxEf/383pMz3jZXKMOY1OOpyTW4R+wYYKakdeuk99g7ct5Meo7fEgZl7EONoAzgPbjNEwCPmtltSQWDgIzfEKYseRYXkDEnY/+iyh31dkjGlXsqY3uxdIItzdXKSZoh6XhJF0v6o6RfSfp0IMuXta4/SloiKeus3NMKCk1dUvTDN68Jgh8klJydcQ9HgNkppJZ+EznfM7FU6ynic0T3T9QLtFg5cv5onbKeUjGmfhHAObKrvQktjNkcGKhbpL8/POKY95QL4Z0PzBuCwZfh/vvh+uvh2evuTK544rQGOtypgTQeT7fSyeMxPyb1eDy9QDNBE34fUTKN2f6KVHSWoyRS0R5PySnHeOwD67ogjGh+sO1WrXHDypPg8rRrJ55uQtJ0Sd+RdIekBZIGJT0k6UJJ7y+ozT5J+0r6raRHJb0qab6kWyX9byNrSEG9kyR9VtK1kh6R9IqkFyTdK+n3ko6StEmG+iTpA5LOlnRPUNcrQZ//Iem04P12KR55GqIcdro+ndLPCo2PSaP+3jRHGcakZrYIuDJ4KeBrSWUl7UioWLEwcl8jXEDoRNpH0gYJbfZV9em8Gv1LCsiom+4khlsj5+tLqinbL+kDhKlLAG5soM2OJJf/cEnjJF2Ik0H5Gi76Z2ecFvgZwFxJJ0rKGn4rfBypx5OS4qLRK7sSUz8gyzF22CxyflOK8lFFiE1z7kszFPE5omW+qITcKsFD/KjIpXNTtO/pSPoZ7vSutw05wzblekz8Ye33R/czbhxvHP2RKe/QkFPJWAQMRQ6Aodfcsfj1hHrXmApUK2icHxyeODrdaSNpNUm7BgHEv5f0lCSLHNMy9m0NSZ+QdJ6kOyUNSHo9+G7ukPQTSWmkDD2lphyDms6ik3ZIejye8jNUv0gulMneL8XbUo/HM5zPpio1YwasvZzLjwawDTB2OXjyiWXLauQIWG01GD8+t16WC29Hk5B0OHA3cCwwE7ejejlgOrAf8AdJV0jK7Y9D0lTcottFwG64P9PRuM1gWwDfAuZIyrRRTtJngQeA04GdgDfjdilNwC34/T/g1OD9NPVthltcvAr4GC7OaUJQ55rAVsCRwfurZ+mrx9OZeFsaw3FAxeN8gKSjqwtImsnwtZST41J8Sto+6ptMajBIJVKprx+4TNKbq+oagUs7WkmZ8hxwWlx9NQIy7k7qQy3M7E7gP5FLF0h6V0LbOzL8u7nKzB5vpN1OpOltB5KWB/4CbI4LoDDCQIrKH9FywJeA3STta2Z3Nduup9spUvIuT2dLpa6yPJxKle+rT9JqCe8tNLOFBbe/UeT8gRTlo2k215A03sxeyrlPjVDE5/g28H5gBC41yg2STsMF1s0HpuCCQb6Em2yAk6rOTSJH0nbB6YJGH/aSNiRQ+jCznommzJ9oKAOEQ4Mh4oMvcgzIqDDjcpj9wfrlGJ7KBGDB8w266tecHnlxQIYbFzTSGn0aHlCS9p6yEDhtTsWN6aJMD479JF0JfDQv2xk4bX7NsjkaVyZ03HxR0iFmVlMCUNJJwJdz6td4nFzhO4gPHl4pOGYCn5L0B+ATQe7wXPG2FEo29smIH5NmRRltaRl20njKjbejrWIcLoy2ESpj1QLGoMtQNltai07oo6eMeLtXFOUYk94baKtuyfCfDz4Eq60OmvSmsPDIkTB2LGx3fY49KIMdjf4eivm9dPL8XtJhDM+HMxv4EzCIm8PuinMM7QFcIWkXM2sqQlLSSsC1QGVn9yvA5cB9uLnz7ji/wkTgEkm7mtmf6tQp4Ezg05HLtwN/B57BBXysCqxN6Nus18/34FICLB9cega37vVw0OdVgNVw8U4JeXIbw9vmVtEpaZbKYEs9SZjZA5KOILSlp0jan2VtaeVJcQMJwREZOQpnz9bD2dM5kqpt6VpB2cXAwWb2YkJdZxIGZABcDbxP0vtS9ONnCb7fw4BZOBs6CZgl6e84u/xC0MdtGW6TnwE+n6LNVHSCLc1DC/I04O2EARjCLRw+j4tMjIqkbQDcIulDZvaHHNr2tIvBLxWcwsSTjqSJRdWkY/BLrehMNVOAmFh8AL4BHF9w+6tEzufVK2xmL0h6mXDgPQUoQ1BG7p/DzG6VtCsuOn1F3MNwW+K5B/gJcLqZJUZrNsAs3HPjGlyASCN8Gxddb3SUtvFEGl3Yz84YwkyyaRhJOod3Abm7swRm9MNg4BJY3IhrYMpkYFqNAufjAjVmMzy9Xat+b+WiS5w2cfl8FtBYPpqxhP5NgBeBf+B2GlUmGdvjxsfgdubcIGkbM4vmWMyDWfSsLfV0BhUnkncqeUrLLHrWjkad0mVYTKzOXBv9KpOCMgoYk7aV6t9B5fdS/ftp3JZmDW6r3OPpKmbRs3avCFq5wPdZhk/LhjMwAI895s5XWw62fAVmBHsRnnwiCMhYLbJ3amSRv7oyLnxGbWnZ+tYaJK2F20Vd4VgzO6mqzKbAH3H+xB1wqhAnNtn0aYRz+3uBXczskUibRwM/BD6DsynnSlq7zoaPrxMGZMwBPm5mt8YVlDSO4TL5cWU2wKlfLIcbeBwN/NjMltFfDQJCNsPtLM+LWfSsbS7bmNSzrK30Y9JqzOzMQGX8FJzPcWZwVHMVcKCZvZZDm88HaUF+jQtsGEv8TsMXgEPrrMGvW/X6oxm6cikx62Zm9m9JO+FUMNYOLr+TZTfbVbgd+Ej0eZADsyi5LW2qwkDm+VDCgIwbgE+Z2f2RMlvipLB2DcotB1wu6SAzu7iZ9j0eT4W4B2DkITl2HAw2ujOpY3clrhA5fznlPYOEwQwr1CrYQgr5HGb2R0nr4yIYj8FFkFfzGk6y7285B2TkSTn+2rqGFiljZKG//w1f0eLFML+O1kA/MPR6HZs1dWqKhmdXvX4sct5tCwDJdJHT5gXgzzgpvf8A/zGzh2tJA6bgT8BPgT8kOGp2BS7E/cGsB3yXbJOcVuJtqScnliacezxdT4fb0U51fi+id8ZlUWd4byNpOnAIztG6Js4R/hRu7nq+mV1dQJt9wIdwsv5vJdz88DDwO+DnjaiiSZoE7Itz/K4b1PsqbtfggzjH8jUlVRzucLuXF638n0wIyBgxkv5Ry86BN4xsk+wfjQvImDSpsN4Np922yo9JEziB0MlzYfXcHsDMbpd0EG5BC+AYST82s4FGGgx8jwcHL18H9q5egDOzJZI+h1vQfCdOGfMoXIqAuDo3Bf43eHkfsHWN3eCY2SKGy+pX19cH/Aq3bmXAHmb2xxr1Wa362kwH2mb/P9pZ+DFpBTM7XdLVuDXyXQjHpU/jxqXn5S1OYGaPSdoG+DDDx6ULCcelZ5nZ03m2m6F/N0vaGNgTt6FuM9ym4+Vxa1tPAv/CBXb83szK+odUmC1tNsrjYNx/oAG3ADuZ2bDtDWZ2C7B7IN/yE1z0zijgfEnLmdk5TfbB0w68SkZJiIserbZjVwMzYOyTMPhIS3pVEqIS+2l3bEclBcbm2JdmKORzSJoAfAX4OC4g42bgJsJd3tvgIi4PBg6SdIKZfSNLxz1JtFJtIU4lo/KYrszDk/6s+kkOyCjAAZ6kkjF1KptufhsA/7pliQu4GA1DQ8vup6SpXp0fOY+KJ1TUMgYj12p9N/Gob9nUK2nuKQFd4bTJ2X4tBLYws3/VKmRmV0k6BBfBDvARSV+IyyHpaYZy/KN40lDWuXZraeVioqSVgZ2Bd+OcNW8BxhM6Q/6Js1HXpA3ADRYQ3xY5NidMXQ/wbjOb1USf34ZzMO2Iy9M9ATd4ehq4DfgrcLWZ9aZ8Va608n+y1gaB6JgqbnRXXaZo2mmrkjZbeCp0ekq9qno/C3wTZ+eijAmurYdTXPsAToXN44lhELbakuWfeZrlH3iQkSNeiZ3hb/kOkgMybtwh5xQmZSYnm6oGhEbavFQeqEVUHC+Gm+vHYmbXSroFpxA5HqeKeU6DTe9POGm71Mz+m9DmUknfxG1+ADiQhPk98DXCda1P1grISMkHCJUuz6kVkOEpGj+/Lwdp1pw8AGb2EG7D6zEN3j+LjE+IIJDhouBoCDPbvtF7U9T9Gm7s/Ot6ZXuRZoMyonL3n6sOyIhiZhdImg38AedcGQH8PAjM+HGT/fB0HUUa+bxlsNr9QKrV/lJC6f0ngUcK702EZ3BO2jgWtqD9VyLnab14UXn7wcRSrSX3zyFpDdyOm+k4J/duZrbMDFzSDsBvcCvUx0taYGanp+xDK6gXVVByGsmakCf1/pzarJARZbPN3M9bwjXw/v5lU5f0AxP6Yeg1t0uofzQsWACrvjjgcuUCjIr7XOdXvZ7AcJnsatWMRbT/91c8Xea0yQ0zexkX1Z2GS4Dv46LCR+IcPdcW07OG6XBb2sl0mzRrvTFp80jZAtxKot72Bq1cTJT0R2An3Ly7mhWDYwOcgs8tgZLlA3XqPAwoZO4uaTLOXu4X8/YqwfFWXEDxx2j8GVME3o42RTOBwr1G87Y0qx2t3FMGuiSlXkX2/kxC2X1w8s1/x/lRRuNSQa/N8JzbZcLbvWVo15huCPr63Zx50iRc7OKyrL7VGq3tVltpt5+2tOxM6C+cbWb31Sn/G8K0nXvS+Nhr98j5JXXK/hkYwDllpkna1MxujxYIAuV2C17OMbMbG+xXlM9Ezjt5ncrb5rp0kn1od1+Lnd9LMLKD05d4uppCbWmzQRnrBz8fM7Pb6hU2s7skbY2b0KyHG7GeIWm0mX2/yb54PCnJe6JUdrmmSr7ISTB2ljsdzDulfSxLzezJVjSUQDTwY/nEUsOJqkq0InAkDUV8jvNwjiOAA+ICMgDM7HpJB+KC6QC+JekcMyvLd7NW8HOgnZ3oHMqw87BB3kg3EgnKCJzJg8HwqJ9lt5iNHAm33AobvWsurDw5rGtMLT2NcdTX21hMj8hld4XTpp2YmUl6BLeYCPCmNnYnCW9LPZ4W0IbFxHcTBmQM4pQ47gCewz3AtiLceb0l8DdJ25jZgzXqHBNzbWFwPaNLLUTSmsB1wDrBpZdxqVHvAl7E2c5VcQHf1blvy0CH29F2B4f1R37GjVc7YKzqKZwuSqkH8HXCgIw5wMfN7Na4gkGQ9HpNfYJi6HC71w1U7b+ZtjZMW5u11/krAy+41J/jV4Rx42DNNYG1146txdNTbBY5vylF+b9FzjdtpEFJo4EN07YbbLz4B05RrtJu9fw+GnR8Y9DORsDhOB/G6jjZ2Edx48szzezhOn18d/DyZeA2ScsDn8Kpt62DG+vOx6kMX2hmV9X6HG2kw21zu8ekZaPsa04eT9dSqC1tNihjJdzOycQHWzVmNk/Stjgn+ltx0izfDQIzTm6yPx6PJ5F+QuGKmhs3lqFPMKZ6P1+d8iUgmjdramKpgCCdRzToIXM+2ILI9XNI2hx4V/Dy3nqSfGZ2taT7cI6g8Tgp6dSSrEURBIusi3sG3dvm7nQ4SY7uFjvAZ1yenMIkgclT4JHHw9CIaIhEdAfgf294no12Cj7PWtOBaU10FFygbLYhlOTUPbLe02a6xWnTblaPnD/btl7E4G1pu/FOp16hjYuJNwM/Ai43szj1tK1wO75XCdr9BeE4MY5FuGCJ/0SO+3H+gDc30kFJY3DpryoBGT8DvmJmzyeUfwuwpJG2isDb0TzppxwbO70DvKR0RUq9wNb/b/DyPmDrWrL7ZrYIZ2tLg7d7ZSHeXu5ywJt44cHnWbzYbVLoHwXLv7lOXHjPpC6pRTbb39eA6lDgK+2TtFpCkYUFb4LaKHJeUx0tIBqou4ak8Q0oua1PGEAxYGZpdglG290o5v0tI+cPSDoCOJnhAcKVNFAzgc9L+oqZnZbQ3maEz5e5QZuXEy7KVXhzcOwr6S/Ah8qUTs/bZo/H42meVtjSZoMyKmRaZjCz5yW9GzdR2gIXmPGdIDAjURrb42meopzfneK42dj9GLsDDH6pvV0pnjm4nYYQOnlrEd02MC+v/LM5kPfniMqf3pWyD7MJd+ek6cMwJNWa4W9R5/1hVeHkvqczfLe5z/VYl8TsYjQWfNF+hYhx42DyyjDvceeOqtWj+c/CRkOB02r69Bols7A2Lmaq8OAV77TJ1m6c06ZtSNoSqGgFDwH/bKIub0vbQieM76J0ypi0Qrb+Zg1wK0FwW4WWLyYC7wvy0yZiZjdL2hP4B842bCdpEzOLHSOa2c+Bn1dfV3Nf9LcJFThPNrOauXhr7XSsh7ejSZQllVIjaUraPyZtP8Xa0co97aTLUup9jdAX+8laARl54O1eN1ER2xqi5vx+nw+x0u23weCgi8oAmDCh4L7F0Wlj0pYxBXgi4b1vAMcX2PYqkfN59Qqb2QuSXibc+DUFyDq/z9RmwOMJ91eI+iX3ALYNzh8GrsJtTlsVp0L3ZlywxqmSRplZXMBztL6xOFu+Ki5d1e+A/+IGKNsQqsy9B7he0pZm9mrKz/UG3jYnUZYxaSN0ar/zJr3t78QxqadcdKotbTYo4znczu1Vs95oZi9K2hG4GvdQE/D14AH5tSb75cmbsae4n92/kN/lTAp+1lOD7wqiKZXemaL8tpHzMu2yzvtzrBA5twb608isevuEtoRTXKq1IzMOReqbh9tR2QFMDH4uiPycmFA2D7LMC8uyM7E2U1cPYyrGBkl6+vvDFCZDuBl09Y6VyStHXowdSz7MDlor8ncIeKdNGuo5bdpCkC88uhvnoiYD/rbH21JCZ0enO3m908bR6b/H+rRrMbFeQEak3C2S/gm8I7i0FekDd5tC0so4qWlwwX9fLbjJ7fF2lNbb0UUZynbGmLRcdL8dpUtS6kmaCuwWvJxjZjc22K8sbI+3ewVRbUtbuZhYw05OWQ3WfM4FZQC8NgRLYoI4VkuK++9VMtpShTEvWe5pM1F/4Msp7xkknN+vUKtgzm3G3V9hpch5xQf6feBLZvZ65Q1JRwbXK+mivinpajO7s0Z9FXWM/wL/z8wejRaUtAvuGbM8ToXjm8DRdT5PHNvjbXNAt8zvi6LTAtw6qa/5IGk6cAhOwXdN3Jj1KVz60PPN7OoC2uwDPgTsh8tGUfG/PowLJvu5mdVVgZc0EtgOF2i2BS5l3yTcL/J5nPP7WuBXTWwWifb5JoZvGP6GmR3fRLXb04G2tNnRYkW+Y1rgUMlEIMP3PuCvwSUBX5Hk05iUiUpARpRCgzN6z3iXHclJHqY9ShK1eA3hqvRMSfXyT+8dOW97eo4IeX+O6K7zGSn7EC33VMp7qlHVkXQ9zQFOtvpKYLtmBwWtp/BF/IIYGTnaw6rvWIPNNqu90WdoyNmhCv2jYKOZI5JvaIpaCiTDETByRLajBKa0CAdKGdssiq8QBtO9hNsZ2Sw9bkvjpi5FjhujdfsgCk/DNLKYWGHPYrq0DFH1iToa57nyCaASSnmWmaV/sDZOj9vRKN6u9SJSA2PS9g9KOyKlHk51qFa7OxEqwt0YtLORpB9JelDSK5JekHSHpNOCdE154O1e7rTTfn6x+SpGjIS1NwsPT68QTUydNgIyutunkR0uRbRZPee/xsyOiAZkAJjZEC7494bg0gjiAyiq63sF2K06ICOo84/A5yKXPh2kkW4Eb5vbOr/3tJsOHZMOQ9LhwN3AsbhArZUIFRf2A/4g6QpJ43NscypuHHkRLth3TdycemVcYMW3gDmBImatej6FUxb6C85/uSMu/fLo4DNMxQWafB94OEjr0QxHMDwgIy86zpY2u7JyG+6XBfBe4PysFZjZoKT34z7oe4PLR+G3R5STsae0UC2jiEjJTpbB8mTBzBZJuhLYF2dUv4aTEV2GQLVn6+DlQpw9KgUFfI5bI+frS9rZzK5Nal/SBwhTl0DgPMrIx6qrBc7GRR7eDXwvZT1LcYu0TwN3FZy2IWeKCgqoRWVdYxzZdiiWlIXuM7x5szcxefLz3FjjLzGqlDFhAjmqY1QzRJcPV7rFadNyJH0Qt2umwifN7PGk8inxtnQYnbZjpBo/Jm2EPmWTOO0rh9Om5YuJDbB65PzZFrUJsEvk/MZAYehDOHs3ExfJugC3Q+dK4Gwze62J9rwdTaQVNqmSaqTWuLSrx1Wdjk+pl63duJR6W0bOH5B0BHAyTlq/whic2sZM4POSvmJmUeW1rHi7VzitGJOeQWr7uGggVMlIYuYMYPMm++RpkGdI/vKL/r96JXKedkQ9JnJe5w+rZW2+UvX6O0kVmZlJOpFwt/T7JcnMojurq+v7tZnNrdG/c3Fz/dVxihnbk92P7G1zW/FrTp7mkXQYYW4xcHPWP+Hs1kxcCqWROPXLKyTtEgSLNdPmSjjlig2CS68AlwP34QJCdscFhEwELpG0q5n9Ka4unK+hsnPUgHtwAcZP4AIT1sUFfYzHjU3PlTTBzE5voN/rEvpIh8gvF3hH2tJmgzKuByor9B+jgaAMADN7TdJuODnA3XFfWuFJ2j0p6Fu9fpn8G6WzneydwMbAv9vdiVZwHLAXzslxgKTZZnZqtICkmbgBdYWTzeyF6ookbU+o6oOZtdLNn9vnMLM7Jf0HeFtw6QJJe5vZDdVlgyCPaJ1XNbKoaGa/iqn77OD0ibj3u5/KGkNZqDcmHMnwx3JBk40Zl8PsD8a/9+KA+zl2LMutuIjJk92azPobwPz5MBQs0VSnLgF4du5CVl6/qI2/hQe8eKdN8W3mSmA7LySMsv62mV3cbL3elrYDPybtEtq5kAjtWUxMjaTVCYN6YXhQSGFIGsHw59uzOAfTjlVFVwmOnYEvSdojRnY6Fd6OxlEmO9eIj3IRYbBHnpTpeykNPqVefeql1Fsncr4Hoez+w8BVuHH/qjgn/ptx8/9TgzTPJ6bswzC83esWPgvEqBjH8VxV/NDofqAf1lgzvDZuc9qpgNkNZA0UrtwDLDWzJwvoUhqiY97lE0sNJ7rpoZExcxFtRq+9ynCVojhuxO1aGolbtHwLEA26qG7j+lqVmdkSSTcAHwkubUbGoAxvm+PwYy9P5yBpLeAHkUvHmtlJVWU2Bf6IG4fuABwJNDSei3AaYUDGvcAuZvZIpM2jgR8Cn8HZvHMlrV3Dn/As8CNcepKHq98MlIDOIUzpd5qka1Oof0br6MMFSiwX9PkO3ObjpulUW9rsCOxvuAiSscC7JG1gZvc0UpGZvS5pb+AC3O6YuFwwHk8OVB7weS8odtLgYX0YOw0GH2l3RwrFzCq7TypRi6dI2p9loxYrO1NuwD3cmkLSh3B2LMqbI+cbSbo0pr97V18Lruf9OQ4DZuEmRJOAWZL+DvwdeAE3SdmW4ZJSzwCfr1FnVm7E2fnZOdbpGUYeChm1hgktjAIfGoKnnw5frzCOVaa4KIxx42DuXLcZaNFCGIws6VfSmDzyCKy8fpqGGokHHSSN7VdffMBIvXvwTptWtJkbQQDfbwnl+L9rZl8tsMket6WdNPaKw49JW0Q7FxKhPYuJWTiVcDf4DVkcLE2yOsPt9zmEC5R/wTnYXwc2we3QGQ1MwylqvN3M7s+pHz1uR1tB0aptlbqLCM7oPqQGxqTtVx1qNL1dxY6WJaXeSpHzir37PvClqOy+pCOD658OLn1T0tWNBqTF4O1e7rRi7JUicG1ocNmgjApTollp16x6s7KmvTX54sekJSPiVGFqvcLBYlx0Tv5M0W3GlItrM5pW+Zl66e/M7BVJC4DJwaVJDA/KqE7TnCYQL1pmUoryafC2uXCKtklFze+7kw4dk1Y4gdCJfGF1QAaAmd0u6SBcanqAYyT9uNGUGJLWBw4OXr4O7B0NyAjaXCLpc7i1onfiUpochdvwW80vgC+aWeLmNjMbkLQPbnf3DNxn/iQuwCQt/xP0ZSlwCHBohnsbofS2tKmgjOCh9gfc4qNwf4z7NFHfEkkfwe2S/GgzffMUyNiU0dlNU/TAvYgFxU6acGwOPJKqZNbFRJVo7GFmZwYReafgdlPPDI5qrgIObFISucKGOGWLJCbVeX8Z8vwcZvZvSTvhVDDWDi6/MzjiuB34SPWDvhnMbPu86upcJtYv0laq1THiKMCOzrjc/YwqZixYVlVk1TXClDD9/UuYPx8WLXIBGhXGxblC625nGSL7rstOsfuZ6RanTUuQ9C7g94SLjP9nZkcV2aa3pVC8w6MVY7teH5OmR33ZdiWWZEzajsXEVARBvvsFLxeTzbnSLCtVvd4WF3zyQTP7S/SNYCfS1TgJ1fG4jRxvz6MT3o5C6xzHnZZOrwhpa0+DdEtKvWp7fo2ZHVFdyMyGghzlG+Ik90cARwMHpOxHTbzdK4qibelXcWniG2DV1XBrKfX4Bz4wo6uZg1PpgeHKPUmsHTmf16By232Ek50JkialSAcVbfe/Me//F6g4jNJu6q1VrrqNNHXmvpnY22Zo3Zi002ySH5OWCUnjGG6DTkgqa2bXSroFl8JuPM4Gn9Ng0/sT/jFcamZx9hEzWyrpm7jNvAAHEhOUYWb/StNoIKbwY+DHwaWtapWPImlt4NvByx+Z2d8lFRqU0Qm2NA+tss/jdtdADpbBzJYCH5N0NSXJC+7xZKNTJhwzYOysdneiJZjZ6YFNORSXu3pNXGDD08CtwHlm9oc2djEVeX4OM7tZ0sbAnjgJqs1wOzmXxy0YPAn8C7gU+H1gmz0dSac5wGOYPz9VsXHjYGqwPD+UObwquso3QLagjK4V9+oWp03hBAEZfyBcRP2hmX2xHX3xFEUnPgY7ZUza9bRjMbEukrbC7Y6p8FUz+08RbSUQF2xyWHVABoCZPSRpd+BO3AN7c0k7mtl1RXfS4/G8gU+p13ybr1S9/k5SRWZmkk7EBWUAvF+SzKxrJx6etDQYmNFWum9MmjVQuHJPm7ktcp60KSvKtpHz2xtp0MxelTQHl0e70u5vk8oHm9GikUFx7Ubzca8iaWQttQxJY4BoPttqB9PDuPzClZ1TaTaHRMukc1h5PE3Tfba0Q9mZcMw3O4XS5G9wQRng1mHOabDd3SPnl9Qp+2ecc3sCME3SpmbWkB0PiKY2SZUfXJII05Y8BhzbRPtdRdNBGWY2nwIePmb2m7zr9HhC/EMs8Ge2uxMtw8weAo4Jjkbun4VTBEpT9ngKksJu9nNU1fUa8OvgKDWS1gTeg5PwXgDMylG22tMQBdvRGZc7tYwFC1z6kpRMnAgjR8K8SEbnkSMJPSYDAzCxer5ePRxahFs3S+tlSZG+pIGcsyWQ5esWp02hBClL/kC4cHqGmf1Pq/uRBm9Ly4gfk7aAdi4kQnsWE2siaQZO2aeihXc+qZPV50b14uRcaoxJzexeSZcT5p/9ANDyoAxvR3uR7rLTfQ2MSfvcmNSn1Gu+zei1VwlzRiRxI07FaCROXegtDJfcbwne7vUKW1P/T9LT4VyDsz1jgJmS1q3zvxxNsXxFE+3+lnB+vw815vc4W1NRU3vUzG6LKfNnQnnTMbg/3htr1LkdodNnfozcv0m6AvhEpA8XJFUmaQRhwBzAP2u0XRjeNns6nSbGpO1ms8j5TSnK/y1yvmkjDUoajVNQS9VuoJbxD+D9kXab8ZeuHjl/NuU9nyP0E3/KzEq5a7QdtjQPpYxlkHQacEy9nF4eT3tpf4hy+9kY+uqbgayLiSVYSPSUnGAh9Yu4f8QlwPfidv0E5U7FPchHVL33G+BQM2vFgkqPkeYfvgi5/RieyRb3OXIkrDIFBl+OzXoC//437DyZ4T7TyTEFs5BH1qNS0i1Om8KICcj4kZl9roXte1vaFRRpS7trMVGC/lHZytPehURoz2JiIpI2wgUzVHYDXgwc3Ibd19Wf668p+nA9YVDGZrUKpsXb0W4hi8KZpwPplpR6T0Xfr+czDVJGLyCcrEwih6AMb/d6kOXTim7lnbokSpeNSQk2f2S8p52Y2SJJV+LGUgK+hpO1XwZJOxL+QSwErmyi6QtwO6T7gH0kfdvM7olpsy/oU4Xz4ioLbOOvgUOCS18hISgj2Kkd3Z2d5Kf4JWFQxr6SvmVmSfb2IEJ7vwCYlVAuE942dwt+vakF9ElaLeG9hS34+98ocv5AivIPRs7XkDS+AWXh9Qn/3wdSKApXt7tRYql0fChy/rfEUgGSpgMnBi/PN7M/1SqfJ51gS4uyEl8E/hF8+R5PCemeiUBzTGL4RjyPp2Vsh9uReSKwZQ0n/AnAEbggQlUd+wBXBQ9RT+5kDFcuggUL4OWYQNqxTSi5P/IIPDYXlg6ER9N0p4pwEMV8ZfCy4rSJpQCnTeVBvY+kDRLaTOW0KYqEgIzDW9kHvC3tAvyYtAdox2JiUt0b4gIbVg4uXQocYGZL8mojA09XvZ6X4p5omUk59cPb0VLTTynGpB1D1/4JzomctzqlHgQp9TK2G5dSL3ot7QSiiImGt3u9xoQZKQp5lYwe4Tjg9eD8AElHVxeQNBM4N3LpZDN7Iabc9pKsciQ1GARgVOrrBy6T9OaqukYAPyDcVf0ccFqNz/F1XOplgPdK+p6kYaHbkvqBM4Dtg0uvACcn9PHvhD6M5YDfVfcxqPN9wA8jl041s7xU7bxt9nQRhf4JTgGeSDiOLLLhgFUi53XnsIH9fDlyaUrRbQZENKSH3Z8JSTsD7w1eLsalJKlVvpK2ZCxOVeMLjbbdIKW3pUX+d7wNuF3SRwpsw+PxNEUf6TfseTy5smPkPHYhNZgAHY1zRBlu4ngn4e4g4SZsnymum71KIUJa2UlKWzK9yZjP+fNd3ZWDRoS9FkSOiXXKhru7sxwlUR3qFqdNrsQFZACfbVX7Ebwt9XQJXe03bMdi4jIEARl/JdxxfTmwX7vULYPPFXUUpVl4LGJx0tvRrqCUarilpEPHpG1Jqcdw+12z3ZQp9f4dOV9FUs1Jl6QxDM/bnVfqaG/3eolVV8NtsPV4wMwewC1CVThF0h2STpJ0nKTLgH8Bqwbv30A+8+yjcMFuABsAcySdJ+mrkr4bvFeZTy/Gqbi9WONzPIlTtqgEzx0B3Cfp+5KOlfRD4H5CG2U4+fyHa/Tx08BDwflGwD2SLgz6eIKk64E/EspzXYvbZZ0X3jZ3BX7TRWoEI0dkO9ouOeRYIXL+cmKp4USDt1ZILFWuNpG0CvCLyKXTg+dILQ4nTPH0eTN7vpG2m6D0trSoVZfXg7pXAM6TtBNweI6Rg56up7tk7crLUtKYgT7BmNF1iw0r7/HUoZLbfSkuH2QchwCjcA/Hx4D3VlInSDocOB33kPwCLvrdkwsl3ZE4MRL4MH063HwLLHHrSJMj2UcqsvYTJsTfmh9pA5M7GzN7QNIRhP9jp0jaH/gTboA/E9gV978K+TpttgLWI3TaXI5z1qwE7A6sFZSt67SRtDLw4zpt/khS9Vj1DDObVVXXOgwPyHgSeAQ4UvVXLe7OWbbP21JPl9DV4/6WLyZWE6QsuZ4wIONKYN8SpBv9N7BGcJ4mPUC0TF6Lk96Olpq0Y1KfvqTL6ZaUen/GRRCNw32WrUmQ3A/YjtBhM9/MHknX7bp4u9dLrJyXsJQnStaUepV7yoCZnRkEkp1CYFeDo5qrgAPNrOl8rWb2fLDb+te4ef5Y4ICYoi/gJOP/kKLOi4P5949wO2XeAvxPTNGXgjovqVPf04EC6AU4+7wcsF9C8XOAT+esNudtc0soes2pqzcbZKCr5/fLRc4TdhMuw6uR80bkn1vepqTlcH6Dyhz8Doang4q75y3AScHLq8zs11nbzYHS29KigjK2xj1k18J1/iBgS0n7mtmdzVYeOMOfCmS1PZ4G8A9Ij6fNVBZT55rZKwll9oqcfyXqeAsmkbvjoh/fImmDuJyUnnF0zc7BddcNz6dOhZkz4Dbn61xu6pt48+QhXpm/kIFAn2HixDAYY9U1RpAv83Hr8BVyU5YvJV3itFme4TYljl1irv0+5trqDJ/QrIb7btLwK1xAS154W9rx+DFpFiTozxAoXBLnd7sWE4E3AjL+Spiy5LfAh8zs9eS7WsblwJ7B+Q6SVENeFGCHyPk/c+qDt6MtoYvGpKWmOx3gZrZI0pXAvoQp9Q6MK1tASr1jcQ/rfSR9O+7/O21KPTN7RdKvcY5ggK+QEJQRSD9HHd9NPw8ieLvniWHr+kU8XYOZnS7pauBQ3Dx4TdxY9WngVuC8NIERGdt8TNI2wIdxwQ5vxcn4LwQeBn4HnGVm1SnuatV5saS/Ah8HdgOm4wI0XsRt6Lga+ImZLUhZ3yOStsXZwA/jlOBXwW1AfgJns39uZv9K28cMeNvs8aTjGcKF92oWtqD96P9n2gjyMZHzRoQLWtpmkP7pMuAdwaV5wJ61/L3B2PUXOP/rSzj1oXZQeltaiBfQzP4DbApcGLm8HnCLpM/n0MQZwICk++qW9ORAuyb23knt8XQxk3HRiLGr2ZJWJdTYHMQNBKq5PHL+1jw7lz+p55QdRAtt9MSJTh2jcgBsvHH4/sqTYf31WW7jtYbdNmElWHXaaBjbSBByEvNxY9GhyFFfTb0vWEjMcpRJdcjMTsftFDwZmA0M4BYZHwEuBj5gZrvVUqtooM3HgG2Aj+ACPh7HfeHP43ZXHwdsaGZx9qFX6DFb6sekns4j2EhwZfCyspgYS86LiXEBGb8D9ilJQAa4AJFKuqvpOOd3LJLWY7jz5PKkshnpMTsK7bOli+ocaTd9VeNVMrIgwchR2Y6SBLh1S0q9rxPKTr9X0vckDdtvHzjCzwC2Dy69ghuD50UP2r28aZcd/Wqb2vV0I2b2kJkdY2YzzWwlM1vOzN5iZvumVKqYZWaqHCnbXGpmFwW+gzXNbLSZTTKzt5vZN7MEZETqnG9mJ5nZ1ma2ipn1m9nKZraNmX0nbUBGVR9/Y2Z7B9/HcmY23sw2MLNPFRSQAT1pm7szmNSTjib8pEvN7MmEoxVBGdE2lk95T9Qx3UgfW9ZmMC69hHDj2lPAe1Ioth0GvDs4/5KZPZG2zZwpvS0tLGl84Hw6QNJ1OLmPscBo4P8CZ9PHrPF8MlNx3tG35NJZj8fj8bSaysAgKWKx4tQy4AYzi/PSRneZrpJXx7qPeo/6diuX12BqoJC2yirQ37/se+usC68PwZRAjX3sWFadFkkrMrrqnrFjYdw4WD2NQnoc8wiDMnoPM3sIOCY4Grl/FhkzQJrZUuCi4GiYYPKQy5JCI5+jQLwt9Xg6g+NwAQWjcHPk2WY2LAd1lsVEXKAFAElO8ISAjL1LFJCBmS2U9A3g+8Gln0qab2bXR8tJWgsXwFF5sF9jZrfk1A1vR1tGmg1aUd9hCdPpedqGdUlKPTN7UtIncJvY+oAjgD0k/Q7nPF4Vt9u7EvxhwKfM7OEcPksFb/c6mrWT3+p/MuZajfKehqkEuGW9x+OpgbfNLaOoFCZ+M0ePEA0eq+tgljSB4YEUjcgtZ2ozplyqNoOAjItx49tKu++uo/RZ+YwVBeEbgZ+l7GMRlN6WFhaUUcHMzpF0M05+uiJ1/f+AOyXtb2Y3ZKlP0jtxEyEDns21s54Oouj8X54o6ssoFV3CMYik6TiZ0PcTyvI9hZPlO9/Mri6gzT7gQwyX5XuJUJbv52aW+kEsaRLwSWBnnB1cCbdb/TGcJN/ZKaIWq+scj5P5+yCwDk7m71lgDi4q8tyEh1OzvIp7SK6Y8H40n3pSnt1m87H1CPUc2tVBGYUPDdKz0kQXjDE1Yby5ycYwvyql/Ns2cz/vvnv49aEhV8/kybDShAY7VAnKaADByKxfrXfaeOrjbWnb8WPSViItG6NXr3wZaPViYuAUuZ4wIGMhbsz7P6r/pTxuZhfXqPvSmMsrR86/Ial6nn6JJefxPgOXlmQ3YDzwl2Bjxz9wg5SNg/cq8qtPAAfX+xAZ8Ha0ZSSlL6n8U1emHP4r9MRj3ZFSryK3D/Aj3Pz7LcD/xBR9KagzyX42ird7Hc2MhOsbAtdB/01u7guw6mqEm0E9Hk/J8bbZ01OoL9vcvnJPCZgD7BGcr5OifDQ6cp6ZvdRAm/fhHE99wARJk8zsuQzt/rdeA5GAjEp60WeAHcwsTbaKCYTyhdsBS1P4HQC+LunrwfmjZjYtzU11KL0tbcnKi5ndJ+kdwHeBw3EBFasB10k6ETg+2AkZi6SVcAua7wnur/BAYZ32eDxdg6TDgVOB5aremh4c+wU5aj/a4IMxrs2pOMfNO6veWjk4tgC+KOkQM6ubH1bSIThZ1OoHQaW+twFHSjomSDOQpo/bAecDa1S9tXpw7IRz3n/YzOakqTMDzwLTgHUT8oe/L3Ke9ICMPlyToh89meinVLsSp0zGqY4lsP76sHgxLIioUU6c6JQwBgdh7tzh5SdPhgkT6jQaDbrox5mIeTHveTylwNtSj6dDaPFi4gSGP0BXAL6d8t4bcM6YJPaq8R44J0w1d8dcA8DMlkj6MG5x8mPB5R2Do5p/4tQ+8swL5+1o2xmKOR9LqcakXUQHO8ABl1JP0tXAoThZ5cqGi6dxwWfnpQmMyNjmY5K2waVYim64WEi44eKsLLYpCMz4K26DxG64ScdE4EWc4/1q4CdZZfdT4u1eR1MryGKG2wlQCcpYPSmAw+PxlBBvmz2ezuC2yHn1uk8c0SCA2xtp0MxelTQHt2Gh0u5vk8oHfoetI5dqthtJWbJHcGk+LiDjnkb622ZKb0tbth022Gn9OUl/Bn6J2+E9Avhf4N2S9jOzeZLWxE1wNo38jC4YijB5+wWt6b2nfDSzI7FEHgVP4Ug6jHBXIsBslt2VOBL30LlC0i7NKkMEgWTX4tQswBnvaonTitPlEkm7mtmfatR3JMN3Sz4G/B63Urwi8C5gS5z38oeSRpjZ9+v0cXOco6cin/U0LofW07gH1144h/7GwJ8lbWVmj9X/9Km5M2hnRZwz7Q2lEknbEkrAvgwk5WuM5vP1q+WJ1NvFPZJSqWM0y9iEANaVJzsP9OCgc1IleqMHgp8VMzCOXk1X4ukIvC1tO35M6klPOxYTOwEzexX4uKSzgI8C2+M2cYzC2aVbcYEil8c4VZrF29GWMQM3FatFdBo2LrGUp7fp5JR6VXXOB04Kjlbi7V5XshSYBBvuQJguarOU925dv4hnGJ0e4OYpJd42ezydwTU4JYUxwExJ69ZJ77F35Lzuxtwa/JYwKGMfagRl4MQNVgrOHzWz25IKBgEZvyFMWfIsLiAjywbdRcCvUpbdhtCe3QncEZzXU/5IS+ltactXYczsd5JmEO4gF270d7ekxYR/LFGqJ0vCLR7+vMi+esqAl4QuAxL0Z8iVWBap6CD/9A8il441s5OqymwK/BG302UH4EjgxCabPo0wIONeYJdoWhFJRwM/BD6Ds8PnSlo7TqVD0iaEObkqdX+lOh+4pN1xeWnHAqdJ+ouZ3RXXOUkjcQoZlYCMK4D9zeyVSJkv43b8bI1zip8FvDfVp0/HVYQP+59JOhD4Oy5Q5uzgugFXmdmShDo2j5w/mGPfeoxGdiGW1Jswqt+lPIkjmgJlYMCpZrzBEO5fZxBeqmxGC36OH0ce46++jHa0co/HUwdvS1uGH5OWgay2tIx2tBWLicG4s5BPb2aFfatmdjNwc1H1J+DtaOnIEh/vAzc8ngbwdq+jqTcmrQRlDNYo4/F4Soi3zZ6eQsDIEdnvaTdmtihQXN8X16WvAQfGlZW0I2Hk40LgyiaavgA4FjcQ2EfSt+OULAKVjK9FLp2XVGGNgIy66U6iBKlUDk5TVtI5hIERV5rZ8VnaSkHpbWlLVlUkrSjpXZI+L+ls3BfzdtyHr+x0GY/bNa6YA9w21d8D3wK2NrN9Ctgl44mlnYtveTq/+yjtQqKnKE4gXHG+sDogA8DMbgcOilw6JsjD3RCS1id8CL2Ok1h+pKrNJcDncA8EcOlHjkqo8suEf7hXmdnR1QEZQZ2/BY4IXo7ApWtJ4mPAesH5g8AB0YCMoL7ncWoZLwSXdpa0Q406s/JrQvmBVYHrcIoit+BURCr8X9zNconJ3h+8XIyLgiwxq7S7AzlSMjs6diyMG+eOKZPjr0+fDitEnPYDA04to3LUCrp4dW7yex5P++kxW+rHpB6PJ3d6zI5CZ9ifId4IkE3EB2Q0guR2d2c5yrLpwpMbPWj38qbMdnRtnDLRminKbo1XyWiMymJilsObUk8detA2l9mWZsHP73uQ43DrPgAHBBtwhyFpJnBu5NLJZvZCTLntJVnlSGowCMCo1NcPXCYpquiApBG4DcqVlCnPMVx9PVo2KSAjMfVoh1B6W1qYUoak6bhFxoosa2LRyHn0j+4WnNz/HcAdwQKhx+PxpELSOOCDwUvDBWjEYmbXSroFlwJkPC6VyTkNNr0/4Ujs0qTIQjNbKumbuFQq4CIqj4spukvkPPZhEeFsnPTpSrggitXN7ImYctEglFPNLHYLhZk9LemnhDs5DwKur9OHVJjZoKQDcBJS0XwTRvhc+J6Z/Tuhih1wkQ4G3FYdVOKJkvdCYslYe32nbvFy1Z/xJjNglRrBMAMDMGGCO391EYwZIFY1ZGjICdJ5KmO7Q3CD04rk/lM4WfnzzezqGrc32mYf8CGG5+9+iTB/98/N7JmUda0GvC04Ng9+Rv9I3lIdRJey3tE4+7gPsCEu0G4B8ABuLHt2nBJSHnhb6vF4PM3h7WiZGcTt24nDB2R4PI3i7V6nk3Z+PxmXHa2p7LyeLqaT5/fBTuuPZmj6P2a2edKbkrYH/pqhPoBN8ly89La5Uymhn9RTOGb2gKQjgDOCS6dI2h+3zjOIU2XYFZeOE+AGEoIjMnIUsBVus+0GwBxJlwP34daDdidUoVgMHGxmLybUdSZhQAY42/M+Se9L0Y+fFeXnbJZOsKWFBGVIWgO4CfdgrRUI+hIu6OJ2XJTKroRfzkzgF2b2lyL66Ok1/AOyB9mZcCl1tpndV6f8b3BBGQB70nhQRvRhdkmdsn8GBoAJwDRJmwbKHQAEih1RT+R/alVmZosl3YnLwy1cUMrp0TKSVibcCmHApXX6+BvCoIzdJfUF+XSbxsxulPQO4Du439fooN8P4R6OP65x+5HBTwE9l3vdE2UajJ8K4+fBU/Oq3prmfj7yyLK3DQ0NPx8zn+FjtQivLoIxMc7/Vxe5e5csrttL9UH/6LrFlrmnLEg6HKfAs1zVW9ODY79Avu+jeQ3MJU0lTHcXZeXg2AL4oqRDzKxmXkZJJ+GUh3JF0sZBHzeqemuV4NgWOELS/mZ2U97tg7elnUeJ/rE7kKy2tEx21FNevB1tFbMzlh/CpSf2ARgeT954u9cLjAQmAU8mvO8VMnqZTp/fdyveNnt6iU73k5rZmUGg2Sm4NaiZwVHNVcCBZvZaDm0+L2lnnC3dCufIPiCm6AvAoWZWyxasW/U6S6Dbpbi1/VJSdltalFLGZwmjSSo8gwu+uB24DbjdzIZpgkv6LG5A0I/7gzoryLvzKTNbWFBfPZ4CqDwhuiP3uJTRAV4OTb7NIudpFsL+FjnftJEGg93SG6ZtN1DL+AehJNKmOBtZoXpylCYyL1rmbTHvzyT8A51jZvV0ge/A5TxbgSB4BMgtn0OgJLJ7IK+1MvCqmQ2kuPUk4OTg/K68+uOpRRtGvn0nwNI4AZnK+xMI45aGCNXJgNH9MH59nDP/kWXv7a9SxXhpAfVlsquYN88FZbze3buPJB1GGP0NblWlOvp7JE5l6ApJu5hZU1+KpJWAa3GR3+BsW3X093TcH8AlknY1sz/F1RUQp3eygOQtuGn6OA0XXFdR2xgALsP9wa2KC4xbBbfr6GpJ74oG3uWJt6We2tTLPe7xeLwdbQUzyB6YMciyQRntCNLonvm9BCMzegJLMr/35Iy3e71AraCMdtA9Y9JOXkzskvl9lJ/gFtpq8XSG7v4buDhFuacy1Jkab5s9temeMWk3YGanS7oaOJQwY8QYnM25FTivTmBEI20+Jmkb4MMMVx1aSKg6dJaZZbF7XUeZbWlRQRnvj5zPAj5rZnPq3WRmZ0j6Gy7SZz1cNMqHgbdL2q+GpIjHU4OSjHp7j75AKj6OhS0ItIruWn4gRfkHI+drSBrfQDT4+sCI4HzAzJ7L2G71TuvqFeI1qT/RiKaL2jjm/UzfSxA48jDOi1q5P7egjEg7S8gwSTKzG/PuQ/fS4Y6PmoEZk5PvmzABF9+5KP79cRGH/suD8MKC8HolrUktlg65oAyA1+srZXQqktbC5SOscKyZnVRVZlPgj7hJwA64qOITm2z6NEKHzb3ALtHUIkG+xh8Cn8GNZ8+VtHYNu/0CLoDiP5XDzB6ula8xBb8gDMj4O7B7NN2epKOAC3HOrBWA8yXNCOxdIXhbWnb8mNTjKTvejpaNRbjxnFfL8IR4yf188Xav08gyvx+LC8xI45pqFR3un+hwumh+H+ViM5vVZP+i/NfM8kgz0BTeNncCfn7vATN7CKcyfky9sgn3z6J2tom4e5YCFwVHQ5jZ9o3e2wxmdjBwcAvbK50tLcpyVBZiXwH2ShOQUcHM7sTtcP9l5PJawN8D57anp+j0h1un978ppgBPJBxH1rgvL1aJnM9LLBVgZi8AL0cuTSm6zYDHE+4nkLWKRuTtUasiSesxXKljlZhiufbR0yuU0Jb1jaOmyEFfjYCNsWOHbxF8eREsXuyOgQH3E1zak7jUJ+ACMgYH3bG0vlNJcuIcWY6S7Eo8AadgBnBhtcMGIFB/OChy6Zgg/VJDSFqfcID+OrB31GETtLkE+BwuGAJc1HPiONHMvmFmO5vZsWZ2qZk93Gj/gj7uhHNQgQug2ysakBG0+QqwP2Hw3YZkc8J7SkUJ7WAmOr3/3YOk6ZK+I+kOSQskDUp6SNKFkt5fv4ZMbY2QtImkgyWdIenmoD0LjlkN1jtB0uGS/iDp8aDOIUnPSvq7pFOC9E5Z6hwt6VBJ10qaJ+k1SU9JulHSFySNb6Svnm5gMHLugzN6nUBy/27gWNyO7pVwCpPTcQETf5B0RZ42I5DcvxHn+N4NFwgymlBu/1u4nN575tWmx5MfcfNin7qkh+mK+b3H4+l8OthP6vE0RVFKGSvhUpfcHSx0ZiJwYn9C0p9xElQrAKOAkyW9BzjIzJ7Ns8OestJs9HS7HdDdEf3dp2WV/uuVLwErRM5fTiw1nEFg+Zj7i24z7v4KFwObBOf/K+kqM7u/upCkMcBPGR5ZGeeIKqKPHk9rGZa2pMIEmDLZpROpvAZXbuUqR9TyY2vXv2CBC7aYHUhsDw3B5lsOL/N42pimzkXSOFwKDnDjuhOSyprZtZJuAbbE2Z49gHMabHp/wgf4pYHkXFybSyV9Eye1CnAgUCPfTa5EnVQ/TdoZaWaDkk7DjWcr951ddOc8ReDHpGVAGcekZXPatCF/9xM0FmicSLDo+DPc1ttqJgXH1sBRkn4GfM7MXq9T58Y4tcxq1bhVgmNb4AhJ+5tZmrSEnq5iEW5cl+Gf35NIVjtauacMeMl9jweyj+nG42zoQO49aYwuGZPSQCqoQnqSoX0/v/d4cqTd83uPx9OpFBWUcQJOzq+pwAkz+7Wkf+Ki0d8eXN4ZuFPSgWb2l6Z66fF4upmoszutI+bVyHmdVduWtXk68EncbpyVgJuDScqVOKWL8cC7cBOVtwb1jalRXzu+F09b6fCFxOrUJW8EZEyoKjjOqWOMqf6zHgmrTg3Ox8JLKYIpBgfh3//mxbudSMyKg4PDgzKemgcvDqT8AB3NzoT2ZLaZ3Ven/G9wThuAPWncabN75PySOmX/jPMwTgCmSdo02NlTGIF89a6RS/X6eCnwY5wfbltJk1Kmt/J4PF1EOxYTCW14BcPZzJUaqUzSrjibVhkcDAK/x6W2ew03Xt0FF0gh4FM4+7xvjTqn4Wx5RY1tALgMeARYFbd4sEpQ99WS3lW0nfcUxewm7l1ETYW0ltAdC4mdipfc93iaYRJhUIZXyehh/Pze4/F4PJ42U0hQhpkdn2NdcyW9E/gOYcqDVYBrJJ1iZl/Jqy1PmcjD4eEjFtvMM0BS7tOFLWj/lch52r1AUcf1YGKpFrZpZi8FDvBrcLZvIvB/wVHNs8C3ge8Hr+McQS37XiRFd4ObmX0i4b1mGVa3J0o3Oo8n46Sr4/58p+Lm79XDm6nBtXEujClFYEYlIAPglblPsdzs28I3h7KvkUnQPyr7PW1ms8h5mp3Jf4ucb9pIg5JGMzwNU812g900/8DlFK+0W7TTZjqwYnC+kDqrTGb2vKR7cJ+rD5gBXJ+2MW9Ly0A32lJPK2njYuL9uF3Y/wH+DdyGC3L4Za2b4ggC0s4knGT9DvhEdZBZoN72VeB/g0sflnRGDYWLXxAGZPwd2D2aDipIYXohLlhlBeB8STMCmeu0ffd2tO00E5BRwacu6XFSSe5LOgg3dwYnuf9jMxtopMG0kvuSPocLrnsnoeR+W3d3e7vXrTQ6Jp0EPEljbi5PHH5+n44Wze+/KumnOMePgOdxA49rgV82oD63taS/4wLyxuGcTI/i0lidY2Z31bi3Jt42l4FuWHPqDv+EgJEjst/j8XS6LS1KKSNXzGwx8CVJfwF+hVuR6QO+DPigDI+nnCw1syfb2H408GP5xFLDiapANBI4UkibZjY7cNR/CzgAl782ylKcY/xwnLxzhYFW9TGBg3E7Mit8osZ7zeInG91K3wmhWkbfOOrvkowb2ozE+XD7cUOIOkEZs4cvHAwNwXL//nd4YZVVaCF9klZLeG+hmRUZ5BaVkX8gRfkHI+drSBrfgANkfaAyLRtIqSgRbbda+r4Iom08ZGZpZsQPEjqjNiJDUAbelnYB7XbadA9ZHeAlcH5XaPliYlDnFtXX1PiXsgWwRnC+CDgwzsab2as45/j2uAVKcOoZyzjhJe2EC0ABWADsFQ3ICOp7RdL+wJ3A2jhb+lGypYI6GG9HPU3TRzc4wTtxIdFL7jfEwXi75xnGWJy4qqfN+Pl9tnbTzO/fU/V6anC8HzhB0v+Y2Tkp6qmwTnBUWDk4Nge+KOkC4NMN/q4OxttmT9N0x5i0W5A0HTgEZ3PWxG1ufQq4FTjfzK4uoM0+4EPAfriH+xTc5tyHcWtEP09Ks1xVz0hgO5wd3QIXjDYJ9wcWDXD7VVa/RBCUdxCwD24OvzJuzv8ALhXg2U2kbD2YDralHRGUUcHMrpE0EzgP2LHd/fGUEf9QKgL1wZjqMIA65UtANPfq1MRSAZImMDxIoe6Dq9k2Y8oltmlmTwOHSPofYCtgGi4VyTPA383sCXhjJ2aFuElWYX1MoOLCi3sY5uXey/NB6xlGOf6ZQyY3cW9lLWwijF8FXkpIz7xwEUvuXza18yv3h8oZyy1eDFPT/vs0zRTgiYT3vgEcX2Db0eiTuvIiZvaCpJcJbWllUlBYmwGPR85bETHTjj56W9pxlG1MWrb+9A5tXEzMm2mR87tTOFD+RhiUMSmhzEGR858mOY7MbFDSacBPIvdl3QHj7WhHMgPnC1yz3R3xtBcvud8Y3u55CMeAzcyl86Tnx6R+fl+fLHPnx4B/4AI5XsbZ4M2Ad+PWvcYDv5S0hpl9M0XbgzjltruA53Cb4qbjnkNTgjL7AxtL2rbBwAxvmzuSiu0qm5/U004kHQ6cyvB08eDsxnRgP0lXAh9tIgChus2pwK8J59oVKgFkW+ACyA4xsytq1PMpXHaKpN2P0QC34yV93szOS9nHjYM+VgfWrRIc2wJHSNq/hqJm3WaCnx1nSzsqKAMgcNTsLOnLQJqHqafnKNPDsecnG+1kDs6RDcMjnJNYO3I+r8EH5X2EI7QJkialiAKPthu78yaKmb0MXFejyFsj5zfHvD8ncl73ewkiL6dHLtXtY4RvNPiep+2UyY4CfZWAiglNVBJNdzKZ4fFJEeal8BOMzD58kmBkh+1KxMnEV3g55T2DhE6bFWoVzLnNuPuLotV99La0YymZLfW0i3YtJuZNNAVeUpBFlJUj549WvxmMMXeNXKq34Hkp8GOcg2XblOPsCt6OdjQz2t2BCH5+3ya85H52vN3zBLzhompzP7oL9UF/hs1rlXvaTDfN768GzjSzf8W9KenNwM8JN/WeIOmfZnZNXHncrvYDcapIr8bUNxr4Ak7BeCQuZdVPgY/U/ijL4G1zR9P+f+KQzh+TdqgdfQNJhwFnRC7NxqmmDeJsxK44e7EHcIWkXcwsez7s4W2uhBsnbhBcegWnOnEfsBIuoHg6LtDiEkm7mtmf4urCjVUrARkG3IMLcnsCWAKsC+yGC26bAJwraYKZnV6nj9NwwcqVoLoB4DLgEWBV3IaVVXBR91dLelcDgcwdbUs7LiijgpmdLOmv7e6Hp2z4iEXPG9wWOa+OHIwjmvajoR0tZvaqpDnAxpF2f5tUPnBGb91su5H6xgDvjVyKe+jegXvQCthA0kpm9kKNamcSToJexMlgpcLMEh+Ctd7zeJblqwwf5zbLZBg/EV5d5F7298NgMO9/onZQxnLjRrQ6fUk7iUZ6p504RB0YYxNLlavNrLS0j96WdiplHJN2geNG2Rw3JQhugzYsJhbELcBinA9hbUm7mdnv4goGEq77BC9fx+2SqWY6sGJwvhDnxErEzJ6XdA9ukbQPt1KfKhWUt6MeT0hWO1q5p814yf2MeLvnKTedPybtULpmfm9mNYN5zexRSbvg0gJWUuWdRJgmsLr8fbhFzaT6XgNOlvQs8Ivg8r6STjGzO2r1paoeb5s7ljLO7z3tIlAq/0Hk0rHVKUqDVPR/xKns7AAcCZzYZNOnEQZk3AvsYmaPRNo8Gvgh8BncvP1cSWvXGAc/C/wIl55kmTWfQFn+HEL1uNMkXVtno8kvCAMy/g7sHk1RKuko4EJcsMoKwPmSZpjZkhp1DqPTbWlHWxIz+2e7++Dx1Kej/82A0HGT9iiB0wbcQLsykJ8pad065feOnCdKO6UgGoSxT2Ipx3twUYwAj5rZbbUKp+DjuOhFgNvN7JbqAmb2LC7qEdwf51516ox+L781Mz9z7gnK+GvOW251qgvG6I8oaMybx5KBUH1yYMAdw7vRctnXZ4DVE47vFtx2dFd0f2Kp4YyJnA8mlipXm1nphD56PJ6QPkmrJRytUNdpejEx5/40RKBY+ePIpUsknS7pbZImSlpe0gaSjsEFcIzHOd8PNbO5MVVGv5eHUo4xsy54ekrDkzFHGmLjftpM58/vG6SdtjSz5D7Dd2RPSSqbV5sBWSX3f43bdX0scDJuV+Hi4P2K5P7XUrbt8Xg6Az+/L75NAMxsMW5hsiI//1ZJaZSUa9V5NqFPVdT3+3o8BdLZY1IpdMumPUqy5gQuJWnFpl1YHZABEKg/RNN1HhMEOTSEpPWBg4OXrwN7RwMygjaXAJ/DBUOAU688KqHKXwDTzOz4uICMoL4BnJ2rbKDoBz5Zo487EQbCLQD2igZkBHW+gksDVZnbbwh8NKnObqSz/3M9XUwzf5plW0wsW396AzNbBFwZvBSQ6MyQtCOhYsXCyH2NcAHhL30fSRvEFQpUMqJ9SpWTKwlJ6+EcOhWOr1E82tbRkqrznlXqnAJ8KnLp3IY76PE0zURgXI71LXJpUfr6YVxQ79xwzWjwZfdy7lyYPz9y29jGhBiamGwsNbMnE45G8pdmIVr/8omlhhP9ghrpXzvazEon9NFTCvwYsCRUcnfHHUe2oP12LCYWxRdxO2nA5dj+LPBvnOT+IlyavBNxQcdXA9ua2a8S6ip6wdNTKubD4puGH3W5HB65vPCeZadnbXs7bWk70tsVKbm/hZm92cz2M7OvmdlJZnaMme2MS28aTVd6gqT3xlfl8aSlZ+1WYUguq2mWw8/vWz93DnZz3xm5tFUz9QVEVTryqM/jaRBv29uBpHG4FBzggr5OSCprZtfiNiyAC7jdo4mm9ydcNL3UzGJTzAebHb4ZuXRgQrl/mVndwDcze53hmzNq2b1oEMpPg40dcXUO4lQ/4u7renxQhsfj6WaOw0UOAhwQSDgNQ9JMhgcbnByXzkPS9pKsciQ1aGb3ROrrBy4LchlG6xqBk7iqpEx5juEPouq295P0thrv74KTb66obvwqSU464GzCnZrrAudVB2ZImojL3f2m4NJ1ZvaXGnV6Skk3BbhV1HzzYBEupV3AhAkALJkfBu/OnQvzHg+OtEtF3cfTkfO6X34Q8R11tMQOvvNsM6ZcI21mpRP66PHEUDa7np0+Qf+o9EdfOXbStGMxsRDMbLGZHY5L0ZeUmxbcDvC/A/fXKNM134snDQfBLbcMP6gjfHr55e74XinEYrqGJhYS20lXSe6b2b+SKjCzR4HK/L7CMrsvPZ7OpvPHpB1Kr87vo0preQQ7512fp6V0k5/U0yZ2JlT0mV0nlQfAbyLnezbR7u6R85opnHDqawPB+bQglUozRJU03hRXINiAvGvkUr0+XkqoZLStpEmNd6+zGNnuDng8xRB9SPrYo2apOMCzlC8DZvaApCOAM4JLp0jaH+dEHgRm4h4WlU93AzWCIzJwFC5qcD1cnq85ki7H5SdcCfcQXSsouxg42MxerFHf/wMulPQQzsE9FxdssipOEmrDSNnfMVzdYhnM7HVJBwB/xTmL9gK2lnQZbsI0LbhWCfJ4Gji07qf2JLPg7nb3oEEqtrTddnQRYfqSRcD8GmXTUOVX7euHoeHXFr0Mg4HQ5v33w/Tp7vzNQzE+2SWLl73WHcwhjOJOI/O5duR8XgO5u8HZyUqyzgmSJqXI4R1tNzZSPGfmRM6nS+pLIbvf6j56cqWZvNd+TOppy2JiYUjaEvg28C5cMMUfcHZxMW4M+X5gelDmcEkfNLNbY6rqqu/Fk4L5VeO3R26CaRNway/RX+c/gUFevOmu8NIXxYpTV4AddoC3Xll0T2vgnfFtouck9yV9BrgHp/r5VknrmFmaFFiersaPScuCMvpJK/e0mV6d3ydurCtJfZ6Ooiy2tPPHpBKMHJH9nhKwWeQ8jfzf3yLnDQVHSBrN8PWfmu2a2VJJ/8DNzSvt3t5I2wGrR86fTSgzHVgxOF9ImPIkqY/PS7oH97n6gBkMD0ruWnxQhqfENDPZKAud3v/Ox8zODCL1TsE5SWYGRzVXAQea2Ws5tPm8pJ1xOWK3wnkZD4gp+gIuz/YfUla9FmEwRzWvAqcCJwR5E+v18Z+S/h9wPu7BuipOgrqaOcCHq3OUeTIy9Hr9MqWmModuJxVf6GRcYEaUej7PtH7UZGYHgpdv3rLq32vevFS/30r6kiyUYLJxW+T8nSnKbxs5b2iwb2avSpoDbBxp97dJ5QP7vnXkUjOTjLQ8BLyIm2yMBzZhuCTqMALlocrkaWmtsp56lMEWNUM7+9/TY9JngM0T3mtFOqG2LezljaQDgV8CI3C7bz5S7ViXNAoXkHE0sBrwJ0kzzOzxquq65nvxNMhttzm1sglTcRvOABbDrZfD68PjdFZceXSre9e1NDEmbact7UnJfUl3Am8NLm1FqHbpaTt+TNpc25420avz+2iQRx7KG3nX52k53bDm1NP0SVot4b2FLUgFtVHkPM3YLKqus4ak8Q0Eua2Pm4MDDKQIbqtud6PEUun4UOT8bwllom08lGLzGrg+VvylG+GDMjyeCn6y4elszOx0SVfj1B52AdbEOXWfBm4FzssQGJG2zcckbQN8GNgP50yZgnPOPIxTtDjLzJ5OrCTkeNyWse1xD+EpwDhcZOJcXF7aC83ssYx9nCVpI+ATuFxoa+PUMZ7DBWP8BpcKpaFAFUlzG7mvAczMkoJVSsGSxZ0aSF+GiUp1AMZElt1QW0sdHZoNyli0CO6vDLOfXwBTI2qa8+d38O+3LtfgAr7GADMlrWtmtb7svSPnVzTR7m8JnTb7UMNpA7yHUNXnUTO7rUbZXAgizn+Py+cIro+1Ai32wu1yBLgp5eTpDbwt9XhC1Af9GdZm5aYAS83syYK6lIa2LuzlhaT1gLNwzqCHgT3ictAGOWe/JGkazj5OwOXZ/VhV0ZZ9L96OVlOi+fFNN7lx1VuDoIzFl7PkD39kUWT4t+LKo+HYV+HiwF93xx5tUsto95i47bTTlvay5P5bg/NMEvne7nk8nhh6bn4vaW1COwrOB9ws+zRan7fN1ZRoTNoQnd7/jmUK8ETCe9/AraMUySqR87oJr83sBUkvE45NpwBZgzIytRkQ3RSxSmKpOgQbj98bvFwMnJ1QtGV97HRb6oMyPCWm550enhwxs4eAY4KjkftnES6qpb1nKXBRcDSMmT0I/DA4ciVIm/K94MibaaST9Yv7XqvvSyqjlG20FSt9DzuN6nHaAMkpTfpZNihjILHmBQuGv376KTfiHAmMWwGuueo13rvCXBjr1oWefXpJ1/5+zWyRpCuBfXH/a18DDowrK2lHwh0tC4Erm2j6AuBY3Ox2H0nfNrN7YtrsC/pU4bwm2szKeYRBGYdJ+qGZLfNHKGk53G7xCuc20NY0vC1tM35M6mmKdiwmFsHngEpIzE/jAjKq+B6h03oPSZ+o2i3TygXPaXg7Wk6GhmDuXHjrLGAIfve7YQEZAKy3rvs5bVpr++YpE15yPzvTUt7v7V5PUYZNF92BBCM7LH1Jr83vJY0EfkRow+4ys/uarPOjwDaRS5dmrGIa3jaXgGbsYBnsaLvbzwcp24aLyj0lYIXI+csp7xkknOOvUKtgzm3G3Z8aSasAv4hcOr1GOr1W9nEaHWxLfSiXpwfwf+bNUtmVmPaQ/8o9IUpxgHvIVY64+4gpV46hWKlpdqBehoH+uBRlJuM24qZRxFjEMkEZLy14Q8d5/jPuGBcMlecDCwhDPu6+G56993l48kl3pKQvkIrOcvSV4y/8OKCSn+UASUdXF5A0k+HBBieb2Qsx5baXZJUjqcHAQVOprx+4TNKbq+oaAfyAUFL1OeC0lJ+paczsGmBW8PJNQR8nVvVxOVyKqMriwb3Arxps0ttSj6dzmRM5b9ViYhFsFTm/K0X5aA7ZCcCkqvej38v0wBFfj2YWPL0dfYMSTtZu+h1cezkv3pTwp3XHHjA6GOe1RSUDSvm9NUCHjknbIrnPcDtVs92SSu57u9d1dMP83tNmOn5+L+l7kr4uaY2kNoP3rgJ2ilw+NqHsdpIuk7SNFL/kK6lf0pE41bgKvzGz/yT1oQbeNr9BJ46tona0Xf3vxO+tq1gucl4t5ZzEq5HzsYmlStRm4NO8knBjxB0k2NGAVvexY22pV8rwpKAdht5PFDyeLuDdKcqsDvwfzlEvnOPrauBu3CTsNWA8MB3YAvh/uIe04RRIfpZ7rz0dSGUtfBwuhKIWAzGX3LURU1dl4Oan3rg89Nrw0rcsdK8n/A52221Jg33tLMzsAUlHAGcEl06RtD/wJ1xE80xgV6CyT+gG8gmOOAq3ALgesAEwR9LluF2LKwG7AxUJucXAwYHyTyySVgZ+XKfNH0mq3vl9RqCUFMcngJtxUUHbAA9KuhR4FCfnshewalB2EXCAmS2u04c4vC19g053PrSz/2XY0dOztHwxsSCiO1ca2TFS/Qf4EPAisCLOPm1CjVRQQeBbJd/s0lplY/B2tN1cPqPm20uu/cuyChkeT4iX3M8uue/tXqH4MWlzbfsxabvokvn9ROAI4OuS7sSNl+cF/V8R2BTYIfIZAI6vkba6D5fS+YPAU5JuxeXIHcAFkUwHdma4ZOts4JA0H7wKb5vbjrc/XcAzwOYJ77Ui9ecrkfO0+bLHRM7rKU62vU1J/cBlwDuCS/OAPeukuG9lHzvalvqgDE9JqUwQ/IPS4+lUzOyGWu9LmgFcgns4Pgh82syur3PPeODrwBdwkosvm9knc+lwgWSVtcyPvBweneB0mkj6MV+EVxe9EZThZLGfSiw6kL32rsDMzgx2/51C4AwPjmquAg6sM0hP2+bzQd7CX+OcN2OBA2KKvgAcWsPBUmF5XJBELXaJufb7Gn2cK2mnoI8b4JxJh8YUnQfs3+AuGm9LS0E3OI87vf8O6Q1ho9TlS0C7FhPz5jlCpY8ZwB/rlI+uwr9GVdSkmS2V9HvCVFD7UDvQYi/CHSs3pUgjEG3L29F288HZdQMzUtE2lQxPO/GS+9kl973d61a6YUzaHWQdk1buKQNdMr8HZyPfyvAAtmoWAF8ws7R2eVXCdFlxGHAO8D9mlnnx19vmMpDXmlMn+EnLjQQjM65OB3Z0qZmlly7On+j//vKJpYYTVYFoJHCkZW1KGoWzQxUf6VPAe8zskTq3tqyPnW5LW2o9JC0n6Z2SDpZ0hKRjJH1a0l6S3tLKvniy0MkDfv+AzAMJRo9R6qMsEw1PeZE0DhdxuTJOfnrLeg9HADN7ycyOBD6Fm4B9QtJnCu1sHmQdZeZKp9vBLNsmx+ECXKfjAjQqR5QJw1++MBCer7IKW25FLGl11xLpgxH9IzIdZfrVmdnpuJ2CJ+N2hQzgFhkfAS4GPmBmu9VSq2igzcdwChQfwTmEHsf9Kp4H/o2TXt3QzC7Lq80G+jgbtxPnU8B1wJNBH58B/g4cCWxkZjcW0X7P2VI/JvV0IGa2iHBRsLKYGEvOi4l5E92l/clAzrQWR0bObzKzuH/gqIP8MEmT4yoK2orKa58bV64Res+OtpEPzq5fxlM8nTsm9ZL7OeHtXh74MWnjdPJ31z10+Pz+y7gg5tOAv+LUNp7HKWy8iFuAuwSnZLFGioCMfwDvCuq9HBck/ATu+3gVtyD5V+CbwDpm9vFGAjLq4W2zx9MxPB05n5pYKkDSBIYHKTSSki5TmzHlUrUZBGRcjFMvqrT77jqbSiq0pI/16ARb2pJVIknvBz6Dk3oaUaPck8DZwI/MLJdfgicvqgfNrRrEd0sUeJbP0S2f2eOpyYE4aUIDDolzltXCzH4uaU9c1OZXJf0kwdlfDvpHw5wPha833A74bNu6k412O22ijKN+kEZlPLc1bi0rbvvKBGAAlg7BC8PTnYzYbCbcfCeLXoZFi5yHYIjeVcmIYmYPAccERyP3zyJjXr7g//qi4GiYIKK7kJDBYOfQz2iPTGhv2VLAj0mbxY9J28RxOKWHUbjFxNlmdmq0QJbFRJxjGAAza1U49DnA53F/GNOByyUdYGbPV/WvH/gOwxU/fhRXoZldI2kWsD3wJtyC5+5m9sbDOQjIOJ9QpeNe4Fc5fJ4K3o6WaqxXg7arZFTnEPe2tJV4yf1c6UG7VwR+TNoc3o62m06d3wdrRpcFR9OY2RBwY3C0kx60zXHd65BxaVvxY9I2M4dQUWedGuUqrB05n2dmLzXQ5n24X14fMEHSpBTKkdF2/1uvgUhAxp7BpWeAHTKotc2JnE+X1JfCBmXqY0pKb0sLDcqQtArwC+B9lUsJRS14b3Xgq8DnJR1pZmcX2b92IWk6Llrz/cCaOKmwp3C7j843s6vb2L2S0asPCp++xdP17Bv8fMTM/tlgHRfhHpBTcFHtf61dvI30R/xqK03EBQU8hnsElJ3KmK8MpFHNmIgL3gA3Rq5+pA7wRpq6gQFYvHj429OnM/T6nTzyCMwbcqUrQRkVtYzBl7P12uMpkN6ypW2lW8ZkWT9HycakAo3KkBNMr9cv0wLatZgo6UPAh6ouR3d5byTp0pj+7h1z7U5Jp+J2EYKb4z8SpCC5B7cYOQ2Xi3W1yK0Xm9nlNbr5CeBmYDJu9+SDQZ8exeXu3gsnJQ1uIHCAmS2Oq6hBvB0t1VgvhokT3c879ihBYEaFRmxpSexoB+Ml93PD2z1PCeiCMenIxH2nCfcsKaYvnm7B22ZPSpoZV5bIlmad20NZ5ve3Rc7fmaL8tpHz2xtp0MxelTQHp3BUafe3SeWD8fLWkUs1242kLNkjuDQfF5CxTNq+GjyEUytaERgPbEKN9KSSJgIbBi+X1iqbkdLb0sKCMgJJv78Ab2HZYIyXcROW14AVcFIiUVYEzpK0hpl9o6g+tgNJhwOnAtVyrxW99f2CXJkfbTBqqkWU3HFTOkrwoPN4ykUlYvGRJup4rKq+8k82NtwxONmyhY12uv1Jo45Rq9z7WTYwIwivWLCgujAMDTF3Lsx7yo1AF+BWmaIabENVc4CRo4T7c66FYETWYdfSFPV6epzetKXD6JQxaVn76RcKW0U7FhNxTo69arw/qc77wzCzYyS9hMu12o97+O6bVBw4neFpR+LqnCtpJ9yC5wa4neeHxhSdB+xvZv9J29+UeDtaYlac/iaYMKHd3Qho1l5W398u+9vZY1IzO13S1Tg7sQvhRqencRudzstbWcLMHpO0DfBhYD9cMMUUXJqph4HfAWeZ2dOJlTi+jLPxWwJvwwWwTcL5QF8GnsU5+q8FLjKzwTw/RwRv9wqhVWO9Zu1Gu8ekSbYvrU30Y1dP19Kjtrn6f7rdNqrT8PawDVyDS200Bpgpad066T2iGx6uaKLd3xIGZexDjaAM4D24eTXAo2Z2W1LBICDjN4QpS57FBWTMSbonDjNbGmzY2D/Sx1qBFnsRxg3clEL5Iy2lt6WFBGUEzqZLcEEGlZnbHJxs6R/N7OGq8ssDb8flFDsIt0NIwHGSbjOzq4roZ6uRdBjh7ihwOduqd0eNxEUkXSFpl0BCqwR06qC30ud2PczTTDZqfbdpyxWMBKPiUgAklR+iLE6bCu1QqAls4YcY7rh5idBx8/N6qZokHY9zfDfCN8zs+IR618WllNoO90CfigsWGwj693fgl2ZWVPLnNwU/V6pZqjYTYuorOZ/EpavM8P9UCso4KUobrFHNJ4FvwUsLYDDezzn4sgvGGOINTQ0WEyplzFsI85+ByVOCC2PGAK800BePp2l60JZ26pgU2mtLm3V0l2RM2uG0YzExb8zsO5LOBT4KvBsX+LESLk3pAPAA8Dfg7JS5ZzGz2ZI2DercJ6hzEm4jx4O4/N4/L2jTQg/aUWiLA/zyGdnvmTZt+Os79nA/S6OYAeUJtugdvOR+0/So3cubTv5fL+P8vpqSB2lk9ZMC6FXK5iv1lApvmzuKdq85JdHIvL2Tn2etx8wWBZvq98WNJ7+GS5mxDJJ2JFSsWIjLs90oFwDH4n5h+0j6dpySRbAe9bXIpUTVtRoBGY2mEjmPMCjjMEk/NLP5Me0ux/DNG+dWl2mC0tvSopQyDsAFWVRGGicAJyTlXjGzl4FZwCxJ38UtVq6N+6P+P1wkeUcjaS3gB5FLx5rZSVVlNgX+iFu43QE4EjixZZ2siTfMjZGUYzLuetx3XO0o8zRCOxRqJE3F7firlrFaOTi2AL4o6RAzayZKshaPVV8IglOuAJK8opOC4+3AFySdA3zezBbm3Lf5wBrAxpKm1AtOSWCnyPmz+XSraM7Axb9MbXdHOpxx9Ysk8jP3Y2Ag/u3+0LGS1MoAMHeuO19/A2DMaHxQhqdN9KAt9eOhxkgzJq3lUCrJmFR9MDpLoPASyvY308rFxCA49/hG2qlT7zzg28GRV52v4R7SP8urzpT0oB2FZJtQHlZceTRMjRkzly4gw+PpOHrU7uVNucYXnUOzz5/q+/3vwdM1eNsMdNbYqkx9zbrmFKVdm4Azzu2hTPP743BKD6OAAyTNNrNTowUkzWR4sMHJZvZCdUWStieixGBmsXN9M7sn2BxxMG6352XBpv5HI3WNAL5PmDLlORLSotYIyLg79hOnwMyukTQL2B4XzHCZpN3N7A2p6iAg43xgneDSvcCvGm0zhtLb0qKCMvaLnH8/JrrFQQAA1RBJREFUaad2HGZ2XxBBNBsn4fcWSVua2S0597HVnEC4NfrC6oAMADO7XdJBOAkcgGMk/djMBlrUxwyU6aFTj07qqydv2qFQI2klnOToBsGlV3A7/O7DRentjgsGmQhcImlXM/tTQnXXkl4OYEtCCeqXcQ/WaiYzPCDjWeAm4H5c3q8puAdPJafXwcA6knY0s1dT9iMNt+EekCNwg4PYiNIkJG2Ey0FeIW8p62KYcyNs+JF296LDqP7zH5dwPYkYEZyXFiQHZUSYgPuHqQ7pXQDc/wAsXgIb7b4W8Hz9bvQp+2Sj73X8ThpPHXrTlg6jk8Z5ndRXj6dn8Ha0rEyf3u4eVNElC4l+TOrxdq8gOmmcV8a+lmKRzeNpJz1qm/3/fvOU0aZ3N2b2gKQjCNecTpG0P8uuOY0K3r+BhOCIjBwFbAWsh1t3miOpes1praDsYuBgM3sxoa4zCQMywDnQ3yfpfSn68bMaG5s/AdyMc6lvAzwo6VLgUWAV3NrVqkHZRcABZrY4RZtpKb0tLSooo7LgN4QLRsiEmT0u6afAl4JLmwAdG5QhaRzwweClUeM7MbNrJd2CW1wdj1soPqfgLnpaQlLEYpxsYMkGJFkdNyVx2rRRoeY0woCMe4FdzOyRSJtHAz8EPoOzw+dKWjvuYWZm/8Dlu6hLkLerwiU11C2WApcCZwHXx6kYSToE+HHQv3fi5LEaTaMSx3mED/6PSHoN+IKZ1V1pl7QdcDFO7tuAu82sVo4yT8+xCBe8cW/MewO1AzJGLjs0WkSYuoTgfOg1GBoC1l8fl+3H42kL3pZ6cqQDxqQeT/54O9ou7guz28ybB/Pnw5NPutfbbw+st+7w8q8Nweslye46jDR20ttST6nwds/TYZTQhkowKuOyikQZfKWe0uJtsyclSTaxw8akItYHW/eekmBmZwapQk7B/e/NDI5qrgIODJQhm23zeUk749TZtwLG4rJWVPMCcGid1KhVky0+mqErlwKxQRlmNlfSTkEfN8AFixwaU3QesL+Z5R30UHpbWlQY1URcp++qEYlTjxur6utkdsb9IgFmm9l9dcpHd7fvWUyXPK0n7UOvWkY6engykkqhBjgocukYSRMabVDS+jh1CYDXgb2jARlBm0uAzxGu5K6Mi3RsGEmrAdFIxp8nFH0U2NDMPmxm19VIK/Vz4KuRS4cFA41cMLPLgT8TDqc+houcPEnSuyS9ka9L0mhJ60s6SNIfcZJekytVAYfn1S9PJ1MJxIi+Bqd38f7IMZQclDFyJPT3875d3MtBYG7wcyhyDKM/407DDkbSdEnfkXSHpAWSBiU9JOlCSe8vqM0+SftK+q2kRyW9Kmm+pFsl/a+kKQ3UOUPSDyT9V9KLkhZJul/SWZKqU07Vq2ukpL0kXRTU8ZKk1yW9IOlOSb8IJkyF4G0plMqpUJey9TWLjGlJxqSSs7tpD5XIa+MpJd6Otoknn+SeO19743jyCbjjDrj8dndce23CffOXSUncRmo5xPsSypXAjnp6Hm/3iqJs47xalK2vWfvjbWkedMv8PqaNXSRZ9GiyvlWD7yda5/bN9rMab5s9jZM2SKOE8/sOx8xOBzYGTsapsw8ArwKP4Bb3P2BmuzWxRh7X5mM4BYqP4AI+Hse5q58H/o1LrbKhmV2WV5sN9HE2sCnwKeA64Mmgj8/g1sOOBDYysxsTK2m87dLb0qKUMuYDU3Hy+Y0SvbdMM+9G2CxyflOK8n+LnG+ac19yomLEO8Fox+36ayXR3F1lm/h0L2qfQs3+hH9wl5rZfxPaXCrpmzhZK3BSSsc12Ca4B8yI4PyeQGEjrt2ngKdS1vkj4Fu4Z8VkYG1cmpO82Bf3kNwM9zuaDBwdHMgtpCxm2WdV5aG6FDjMzNLY1ZLyWPBzzbb2orNIm7YE3J/O1lXXvkpoGqJFR76xiLfOR94OF/yLuYQDkKb3ZVYWEjPdM9hsq7kh6XDgVGC5qremB8d+kq4EPlpDwi5rm1NxkdXVgRIrB8cWwBclHWJmV6SoT7hnwbGE9rLCOsFxiKSfAZ81s9fr1LcRcCHDU0JVmBAcM4CPS/obsK+ZPVmvnw3gbWnbx3qdQpox6dKqch5PT+DtaCvm96+HqrRP3fU8d1dlK/79E6GzZOi/sE9cHYODcPaa8PHH4t5tA83YyjbZ2g4fk3pyw9u9QvBj0nQ0Myb1328edMP8PqGNFYGfNdXRZfkpbqd3K/C22a85ZcCvOZUBM3sIOCY4Grl/Fhk1QIJNthcFR0OY2faN3puy/tdw9jhvm5yGUtvSooIy7sXlbVmrXsEarB05r6csUXY2ipw/kKL8g5HzNSSNz2sAFIekFYAVYt4atXTpkjp3t/vhUzaqBw5ZvpvogzTpPu8kz0AjCjVbBud70nhQRjQX1yV1yv4ZF0E5AZgmadNAuSMTwULjxyOXfpG1jjjMbKGk53D5vgDeVKt8A/W/EESXfxc4JLhcPQgZFb0l8v5jwKfM7Jo8+9QMtW1pN0hUttLeR1Uv4tQv0rJ2/SIVKruqATbemI/s+C++cl180UFgYAgWZe1OhyLpMMI8ieCiv6vzJI7EBbRdIWkXM2sqjkXSSsC1hKmgXgGq8yROx6mpXSJpVzP7U1xdEU4Evhx5/Q9cXsfFwDuAnXA25pPAWEkHmVnsP6+kNYFZwKTgkuFs+hxcdPrquIigSsDGtsANgZ3P9S+nm2ypH5PmTfQ7afS78WNST/fTTXYUmrWlBfLyIpY88jgAt93WwP0vDgS541pJkh1NY//SzO89nvbQbXYvb3pjTNrKfnbhmLSDA9y6aH4fx/dwG4WHCJWTm+n3gbjvA5wa8qgaxZum22xzacekHUl0TJnVjpZ0TKq+Buyo90N46lN2W1rUf+EFwc/VJb2nwToqOWweTdrx3UGsEjmfV6+wmb3AcKWQpqW76nAk8ETMsckzz3S6SEkFb6ybojOloluuUCNpNLBh2naDqMaofWtUGWd73OQF3CTh3AbrGUbweSZFLj2bR71RzGyRmX0K99l/ipOxSmIJcDNO+mqDMk00ApJt6fNB2ripUxn+p1mhyN1+JRpwt5RxyW/NuNwpY0SPqonAhAnuNzU1pqYhXHjIYDN6YB2CpLWAH0QuHWtmM83sy2b2DTP7IG5HS+V/dwfc/0KznEbosLkXJ713gJl908y+iMt9+KPg/ZHAuZLG1/gc2xIGZCwBDjCzd5rZV8zsODN7Ly6Yr/JbPQAXWZ3EiYT28QFgEzN7r5kdYWbfMrNPm9lM3EbfV4NyawNfSPXpM9JFttSPST1dTyuloiWNkLSJpIMlnSHp5qC9ivTyrBzbmiFpqEraeVoT9S0ffC/R+g7Oq7/VdJEdhaZsaYE26uOPcdttLiBj8JUG7n9hIDw/u5NU5mqNxXt1nN4crbSjkTY7TnK/Hl1m9/KmB8aknl6kW+b3cUh6L+GGtW8322FJqxB+V7/Eye8XTpfZ5nKOSXOlU/pZDz8m9XQXZbalRSll/Br4HPA24CxJ25lZ3WCECpK+gsuLYwzf0dipRCMC0y7hDALLx9zfY3Ra9Fse/e2ah2CfpNUS3ltoZgsLbr8dCjXrE0riD5jZcxnb3SixVG0OiZz/zszyCp7Yk/A58STwUE71LkOQa+zTwKeDHehr46LlRwMv4R6cd5nZq8m1lBgzWLwYxscFZHQSnbLrJwXjagRtBEyfCFsugBuBBZHrQ8GxaBGwcBEsTWH3G9pJU4oAtxMId5hcaGYnVRcws9slHQRUBq3HSPqxmQ000qCk9YGDg5evA3ub2SNVbS6R9DncTp534uROjyI5DVS03yeb2QXVBczsOklfxA3WAb4j6eIggC7avxG4XUMVPlUjVdWlkt4K/G9waRdcWqhC6HpbWpcibVSnjUnzoN532YbvJKstLYcdfYM2SEU/QfEB/kgaiVOZy3P34EmEQcctw9vRYnnkkZTlAAYGXJTsa0PwyiC83CMSZUXTuWNSwEvuF4G3e0XQKWPSbpnft2OcLre5I+s97adb5vfVbYwHzgpeXoPbrPaNRvob4Sc4W/g0Lrggs7JxM3jb7BmOX3PyeBqhjLa0kKAMMxuStBdwHe5D/kvSl3AP+0RtomAnzXeAD+OszDfM7DdF9LHFRCeLaeW+on8EY3PsSwEUOYjPc1DdqslGdRtZPkNXPRyn4BzBcXwDOL7g9jMr1Eh6mTAYagrOMBfWZsDjCfenQtIE4IORSz/PWkdCvcsxfOHwrCQZ/7wxs8coVjqi9SxeDHPnwoyWry10KHEBE2kd8fWDLepy8y3c/V+YPAU2XgS3DTmvReUBXvFgDA0BD891iwVdiKRxhPbFcA6cWMzsWkm34NJAjccFLZzTYNP7Ez4QL60R8LBU0jdxUqsABxLjtAl2A20dvBzE7dJJ4mzgaziRlGnAdrg0JVFWZvjYrJ6iW1SJaVJiqZzpSlvaVrphTJrlnjT39lqQSnO0QyqaMJVfBcOlzss7L/axuB0oeUlFbwccHrzMpc5G6F072v5FuvuBf512A2//2i4ubUlUJaOlxH0PPTu/bztecr94etfueYqlGVvox6R50S3z+wS+C6yB2wz7KZqMgJG0P2F66s8GPuNmqmyK3rXN7R+TpsOvOTVEhwcKezqPstjSQv4bg2jK7YEfAs/hFjfPAZ6WdFEg7XeYpI9L+h9J35f0D9yO8Q8H1fwGeFTSQbWOIvpfAFFxzrSWJupAKzrp3Hdxuc+rj7umTJlccNOejkB9MGZM+kOleNA3qlATd3+Z29yf0F48jnMY5cEPgbUi9dZaxPQ4km3pckvhnnupbc6LGhPk7aAoq8MjQzDGYx+v+fZT19+zzLUJOE/rRMIH+WJwWz5fey19253FzoT2ZbaZ3VenfDSQds8m2t09cn5JnbJ/xi0wAkyTFJcGKlrfn4M0cbGY2WIgusMx7nNUi67XC7RYOXL+aJ2yvY4fkxZKWe1399NGqej7cbu7jwbejXucfTGHet9A0ibAV4OXeUhFj8UFyAm4Hicj6slGV9jS7/2BMCAjTiWjo1KYJOHtclq85L6nxeRgR4v6/+4Gu5HmM5TCr9htdMv8fhiSdiJUEP6KmTU15w7SUVWeN1eY2WXN1NfjdMWY1OOpRaen1ZO0mqRdJR0v6feSnlJOKUmD+reXS6V6l6TnJL0maZ6kfwXX95a0fP2auoei0pecg4u4rGA4p8qbgA8FRxyKlK9VLlrvuQ33snVE0zSk/QOL7sAsNM1DkEZimTYkvd7XNyLmjjgqA2o/aK5PtdyU/84Koh0KNe1o8xOR819Wy+w3gqQjCCc0i4H9zMzrBdehli1lqfHKi68to7G7LI8B3eBgzpvqP79xMddyYmiIuXOXvTwx0mL0n/vFBUtYmqgBFkENyJu2PwI8mm/nphTlo4oQdZ0ncUgaDWyYtt1gN80/gMpEZ1OWlRVt5HN8LlJfdZsvSroL2CS4dCQJi5ySxgCfj1zqhHFr2/Bj0lbTgSlZ+jLupulrux2t0HKp6KDOLaqv5bnLL0hb8kvcZ7sbOJHmpaJPxAUGDwKfBH7RZH09R362NF87+puNs/3tXQs8ddnNrPqONXLtR77E2dGSP386c0wKXnLf00LysaPQGbu8y9DHHhiTVu5pL90yv4/WvwKhDb2Z4WpKjfIj3BrWAKFym6cB/Py+lTQ7Ju0wG1wSOj2tnqSTgC/n0a+YutfC2dOdY96uBGhtjrOz72ZZleKupUhrpqoj6XrWMkn3lJmnI+dT6xUO0hFEgzeeSSjq6Sj66MiJRuM8Q3w07Oq4SNmiaYdCTUvblLQZ4cTIcLsKmyJwYkV/P58xs783W6/Hkw/jyCU9SYU1Y/5l+vtZd73w5eQpYbRUf3DMD15PXTW7H6YB+oKo5bijEXWdLGwUOX8gRfkHI+drZN0lGLA+UJmdD5jZcxnb3Sjm/WY+R1x9MNxZfoSk30l6j6RVJY2W9BZJBwD/Bt4elPupmZ2fon2Pp2CSxqTe0VUEWaWigVuClxWp6DLzZeBtuD+mT5jZ681UJmkb4LPBy+PM7KEm++cpEfvcnT0T4vd+VkBHciNPm+ntby3aaEdTS+4D34xcOjBDG9WS+x5Pi2mn/cnbT9oRttTP77O1mzQfr3Aq8Gbc3plPNLtRTdK+hM+bo8zsqWbq83haQ4eOSSuBwlmOcgQKA8PS6lUCMmYDpwDH4xR4FwfX98Cl1csjzWclrV4lIOMV4AJcMPD/AZVthpW0eu+rU2V1ulOABTn0cwYu1XMlIGMAuAy3AeN/cWpEl1CCVCLtoCiljBsZrpTR68whnAiuk6L82pHzeXlFUXnaSd4PtEp9LQrwyJrjyz0gl5rZk0V1KQXtUKhpdZtRlYzrcpDo249QLhrgc2Z2Vo1bPB1B3sFgZXB0FCvcsvKOM+m/6U4Axo1z20nitnNstlnMxfyZAjyR8N43cIP9olglcj6vXuEgz+rLhPZvCpB1DJOpzYDHE+5vtM5ofRMljapeaDSzyyR9DPgJMBqXw3zXhPr+A/yfmV2Qom2Pp8No8Zi0M2lEKnrL4HxPGs/fXSiSNiLcCf4DM/tnk/UthxuH9gH/Ar7fVAc9XcHZwGdvepw3bxOjlvHxdvrwvO1rMe2yo41I7k8gkNw3s8Td3RAvud+sRLSnF+ipzV4ZKIOfIhV+fl+fevN7ACTtgFNVA/iWmS2bhzYDkiYDpwcv/2JmXq3N0wEUYfv8c6YeCWn1TqoqsynwR5ztrKTVO7HJpqvT6u0SVXGTdDQuJf1nCNPqrV1jffkF3Bj2P5XDzB6W1PDafmBLr8OpdhguNd9JZvZyQvkNgWcbba8TKSQow8y2L6LeDua2yHm1rEwc20bOa07iup+8I6bLKHnlU5kURDsUajK1GVMudZuBJP5HIpd+nvbehPo+DJxHGMH+BTPLQ/bP05WUQeI0jkqwRgo1jYpKxppnw2MfH/7eZpux8cZ3cvfdLh5t81Xhppj9ERtvnKFrWYPbKve0l+hOndjBcwyDhLa0kZ0+jbYZd3+jdVarFq1ATKS4mZ0j6UbgCzi5vbh/ihdxMqq3pmjXU2qSxqTRhEZZ/sfbNSat1V4HjEkbCxRuNy2Xii4aSSMI05Y8DHw1h2q/jdvA8Dpup2Oa5GCeLmBesESTtCXrySfcFtjhF4PY/28FLq2vLq4u0Way2Pi+yM8WOMA7c0zqJfc9nkJpx/w+TXtl9TvQqba0W+b3FQWlX+A2ld0FLJPSqgHOBCYRptDzdDXdtuaU9Fna3a+upSvS6plZESnzfhy0C06B/Se1CpvZnAL6UGr8f2NruAZ4NTifKWndOuX3jpzXzPvjyUK7Ivzi/s2a+dfz/7YpiRr0VinU3Ef4hzZB0qSM7cbKoSawN24XDsDzwJUZ7h1GEJBxAWFAxpFm9oMat3gaYLmpb6I4gap65Gk3llb9bAVJaUui1zKoZ8SlLYkyqp91dgh3ZI5dbtml1uKzlpSCaE7EocRSw3k1cj42sVRr28xa56tVr2M/h6TVcTuZKlLT1+Gi3r+C2+E9G1gRJ8V/t6RDlq3F09lU/zml/ZNtF3nnlO2YMWk7ZaKhPVLRRXM0YWqmQ82skbR/byBpa+B/gpcnm9ldzdTnKS9xKUzuf9EdWXjq8SU8+nHxwL1LeODeVsfv1JvfZxkjd4wdBS+5X2rJfU+v0enz+6T+x9nSrGPSjrKrraZb5vfgUgRMA5aQTwq9DxGux3zNzObWKu/xDKesa05Zx6Qttp8SjOrPdrQ/uK3b0+o1RZC2pPLd/LVeQEav4kcqLcDMFhEumAr4WlJZSTsCWwcvF9LEQmv3UMSfaRnmu3Gfqwz96hparlBjZq8yPBikZruS+gj/37O2G01dcp6ZNbQSFKQsiQZkHG1m32ukLk8d1l2XnlnK72RGBb+jHXdkalq9m2J5Blg94fhuwW2/EjlP+8cbzUfYyCJdEW1mrbM6p+IydUqaCdyBm9w8CbzNzHYys6+Y2YlmdoSZzQT2BV7DpTj5maTdUrTvKS3dOCZtg/Ol9VRkouOOI1vQfmapaIbvJJySe4+aQNIGhNLaZ5vZX5qsbwxh2pJ7gG811UFPRzEwAPcDdwevs6z23H8/PPKIO/68TfsdtPG028bnSjttaTvsaMdI7ns83UHXj0cr+Pl9k21K2h44LHj5AzP7VwP9itY3iVCt6F8MT0ng6Wq6cX4Pfs2pcBpJq1dhzybabSStHgRp9ZpoNwufiZz/uEVtdhyFbNmVFJVD+YWZJeVK6yWOA/YCRgEHSJptZqdGCwQO/nMjl04OJpOerqFDH4CVyMUs5dtPRaFmDIFCjZndX6N8Xgo1vwUqSQ32CV4n8R5gpeD8UTO7rUbZNwjylr0rcqmh1CVBQEY0ZcmXzey0Rury1KZvhGD6dOrPQYdwG6zWrlOuoV7QsTYolhQpSrIStXOj+nn7Disw79yFDEX2XAzhfovzcHLbqQM31JfNjlbugaVm9mS2G3NjYeR8+cRSw4mupyxMLNXaNhdG6kpTZ/Wa0LA6JY3CTaom4Xbm7GpmdxODmV0s6U04KVQB35P0e78bstOpFQdZsRJlp0P/BLPaUpXCwd8OqehCiKQtGY1L25fHQuy3gPVwf5SHmNlrOdTpyYViZOP3udv4zcbi/vtgYPFwizoB98efaGWffJIlQ0u4P41WQstocfqRZml8TNpOvOS+x9O1dIDdjEUwIuuyisDP75tqU9LyhDZ0LjU2vmbgTJzUvk+h5+lw2j5ey4YEozsuDRR0YVq9HNklcn5j4D89GDgA2ACnFvIc8G+cX/WiXvSPFvWfejzwdeDzuAjQnsfMHgCOiFw6RdIdkk6SdJyky3DRmKsG798AdODiaCf8D5VlR2B13u6y9Ks7aKNCzQWEv9x9gt2EcW32VfXpvAxtfJxgNgfcmiRXVYuEgIxTstbjScmY6o33SQzS2OaDdtAue1UrTUlSmpMUJDinhxJWBQaBu4Nl+L4R8WW6gKcj53XDTyRNYLijpZExYKY2Y8rFtZm1zmiZF2KkUHcnTIv156SAjAhnEf7hroXL7egpHD8mTY8fkxZMO6Sii+JI4B3B+eGN5sOtIGlLwjnymWb2j2bq83QO8+bB/YudSkaUCcHPoegReQo/cO8S7r9/+Phsp5uMnW5aNi1K8VQ/Z7wtLRAvue/pYPyYtDG8HS2AbpjfHwNMD84/mUMKvfcAHwpenuRT6JUZb0vT0/Vj0l5MT1p0Wr2mkbQqsGbwciFut9ItwM+A7XDBb6NxylC7A+cD/5H05qL7VjaK+m+sPBDvN7PFBbXRcZjZmbhAlcpEbSbwZeAbuFw7o4LrVwG7+11C3UYnDB66juNwkc7gFGqOri6QVqFG0vaSrHIkNRhIj1bq6wcuq364BLsMf0CYMuU5UgZhBfceHLmUWSUjJiDjGB+QUTCjRwfe41oBBZV9gUO4gNEyU8bBfAHKGQlUfkv33hP8WkenDbrpOKLpmNZJLBUSlXiZZ2YvNdDmfYQPzAmBlGiWduOC1Jr5HHH1bRU5r+u0CZztUVnqNH3wlJY06zIVK1FWem5M2k6ZaGiPVHTuSFoPN28FuNzMLm+yvtE41Y0+4FHgK8310FMMxdiL+19021sXxLw3geFBGfPnA4ODMDDAI4+4gI4K7QnGqEcZx8m54CX3m2wzb8l9j6f7yOOZ06Jxbl+wwzvL0df2Hd7dML9fI3J+XdRPW+WzfTh6U9X7ByfU97Wk+oI6o77dv0beOyfFZ/J4CiTJ7nXtmLQX05MWllYvR6LPldeBP+JURRYDv8MJOXwD+APhH+1bgZskrdyC/pWGQtKXAE/hohbL7I1sC2Z2uqSrgUNxci5r4iZuTwO3AueZ2R/a2EWPZ1n6MspJtX+iATiFGklHEOYGPEXS/sCfcE6SmcCuhAFReSnUHIVbtFsPJ800R9LluMnISrhowLWCsouBg83sxZR17wKsFpwvAn6dpWOStmV4QMYcYImko1Lc/g+/g7FB3viXuI0wqB/cY3Jx5LzC5i3olAeApw5LLeEc/Q1V7ujvJ7CPry57Q5TOlOWLplR6Z4ry20bOG5LFM7NXJc0hTAP1TmqkgQpUh7aOXIpr9zbgI5H66tn5ep8jGnnfyGpQz62I9y6dksqkg8hqS9V2mWhoj1R0rgS29pe4eesAcHgO1Z6A2/ED8KlA5c7TI9TKKTmh6vVP/gtvveV5xsX89/x5G5U0MKMRWjQ8EDAqoyvQDUm95H4TbRYkue/xeDxZ6Jb5vcfjSUUxqQhzQ4KRWcekbfeTQhel1cuZlSLnE4PjSeD9ZnZntKCkzYHf4wJUpgI/AvZpQR9LQVFBGXfhFhzXqlewFzGzh3ByW8e0uy/5U2JDXzqazTnr13TSYGZnBoP6U3CO5JnES8dfBRyYh0KNmT0vaWdcwMRWOOfMATFFXwAOzRiI9YnI+SUNOLDXIgzIAJeP7NSU934D8EEZzfDgbbD2dsDk4EJ0fNRJcYxlHNgvolVqGf24EWP/aFhu+qrQ90q9WzqVa3DRJmOAmZLWNbNa6yh7R86vaKLd3xI6bfahhtMGeA/hwP9RM7stpsxvCQMxdpI0IUlyP1Aj2jNyKe5zRGUCZ9ToW6XOUYQLj+CClz2eEuHHpAXTDqnovPkYoUrQkWb2dK3C9QhUNyq7mM4zs2uaqc9TJMWM97KMeq8Hrr0GNt6kkK4UQBnHyR2Pl9z3eAqlLHYrOiYtS5+6im6Y39+Uss1xwF6R17+KnD9YdR59rxZ7Ez5briF8TqTtk6cpvD1oHX5+X4duSquXJ9WBHwbsUx2QAWBm/w6U3K8PLu2V4pnUNRQVlHERsAewmqStzOzmgtrxeBrAD+x7jXYo1JjZY5K2AT4M7IeTY5qC2zHzME626awsTm1JU4APRC5lTl3iaTNDQziVsQmVC+3rS9cwjtppYfJnKi6spn8UsO66wDLjy67AzBZJuhLYF7er72vAgXFlJe1IuKNlIXBlE01fAByLe1jvI+nbQWqo6jb7GL7L8Ly4yszsQUm3AFvinChHkrw78WOEEqaPAjfGlLk1cr6TpA3NbE5MuQqfIpycDFL+/ERdQieM9co4Ji1jnzqeObi5MbROKjpvotLOv5D0i5T3PaxwN9M3zOz44HxVwiDhAyXFPlti+KWkXwbnN5jZ9inv83Q4Nz0H65Z+2NxsgFuLUF8g9ZbxnvbSDjtakdzvI5DcT5G/O4vkfqpOVKVO/ZiZnZPqRk+JaPv/Tw/RQhvcgTu8u2F+b2Y/J4UvVNI0IkEZZnZwXDkzu4mUQRVBCqpKUMZJZjYrzX0eT+vpkDFp4zxDssR0K1QmuyKtXgFU71icVUtx3cz+GvHVCng/tQUVu4aigjKuwDmcNwfOkPQuL0fq8eRN1z9gc6VZhZpgsJ1pBmVmS3FBahc10mZMfc8QplpptI5zgHPy6E8RSFoHeBuwMrAi0GdmJ7S3V0WwuH4RT0qaHF6s+hOXwiSO1acC99A/ariUdmULXP9oYOLEdO1IDTjASyHLdxzOmTEKOEDSbDMbpq4jaSZwbuTSyUHORKrKbQ/8tfLazGI/oJndI+lc4GDcZOMySbuY2aORukYA3yeUVH2O2mlJjgFmVc4lzTGzYbZZ0nuA/4tc+l8zWxJT17W4XJWr4xYVr5K0h5ndVV0wiPyO9usXeSgy1aN3bGktfHBBYzTynVXu8ePSBFouFe1pHm9H28dYQk05cAOBae3pSkaatYF+fl8DL7nfArzdK4qixqTeZiyLH5OmoFvm9z2Dt82e7HTImLRxP2kvpifthJSo1W1cH1tq2TJbBueb5dud4ZTJlhYSlGFmiyV9GPgLbnf4jZI+aWZ+Z2DX4ycb6cnj87TqIdkHY8bULxct7/GkJMiv+1lcfvLVY4os84CUdDFut5EBHzKzJwrtZO4M4VUy8qaA1CXbbcfGG93D3f91I8O5uN/aZHrnt2dmD0g6AjgjuHSKpP2BP+EirWcCuxIGjN1APs6To3BS+esBGwBzJF2O27W4ErA7YZq8xcDBZvZijc9xg6TTgnpHAhdK+kzQ3yXAO4CdCYPvLgIuTKjrFUmH4XYLjcBJUd8h6TrgX7hIock46dVoepN7ga+n/wqy0Zu2tB2MYbgKZDfQQWPsrI6bcgS3tUsqOk/uIL2080cj55cRRk/eEbn+dIb63odTmwP4O6Hk9L0p70+Nt6NxtCfALeqRmwDskGYZvivoRr9HLnjJfceD5Iy3e55yEbV/3q9YBN0yv+92vG2Ow685tRb/vdSgG9LqFUF1quZ5Ke6JlpmUY1+A8trSQoIyJB0UnJ4OHI8LzLhV0p3A34CHgJdI+Z9tZufWL+XxdCp+ouHpXSRtClxMOPmqXj0x4rkF5xgz4ADg5EI6WBj1lvQrYlN54wfVsdRQy9hop1W57ban2HgN4PGY39zcuUX3ru2Y2ZnB7r9TCJzhwVHNVcCBeShBmNnzknYGfo1z3ozF/a9X8wJwaMoUVF/COXiOxgVTbBMc1fwC+IyZJdkfzOz3kvbASadOwf1z7RwccfwFOChuh1Ee9K4t9XjKTxulonPDzK4kZV8kRYMyjjKzR2Lquxe3WzJNfbMIgzJ+XpR0v7ejreVvZmybEDQ1FVg38npy7u65oin5/L4D1du85H4xeLvXSvxiYmtpwffSgba0QhfN77sSb5s9+VHyMWnn0g1p9YrgPpzPtRJzkOhTjZCmTEOU2ZYW9Z95DvBLXCTlONwHEO4B/1mcNPQvgjL1jrML6qOnMIoa+Hb6g6QvcuRdr8fTeUjaGLdQuRbuGSFc0N6VQD0ZsnMIc4B8sJge5kgld3N/P72jsVAU4yhEFSOJyaGA9gSGJ+6bPBleueXOdPVUcs5mOUritAEws9NxOwVPBmYDA7gdi4/gBrkfMLPd8tzNYmaP4YImPoJzCD2O+wd6Hhe5dBywoZldlrI+M7NjcXJ1ZwD34Jz1g7idh2cD25rZIWZW9x/VzH6Pm+QcirNbD+N2hC/BfT+zgbOAd5vZjkXJK/aULc1MUWPSDOphpSRpTNrsmNKPSWtwHPB6cH6ApKOrC2SRipZklaOY7vYW3o6Wi6nAhBXDY+h1GCo88VcjFDG399Sg5XY0CMCo1FeR3H9zVV0jgB/QYZL73u55yoO3pe2gG+b33Yi3zfXwa07xFGVHC/5eOtdP2pa0erhgkFTttiOtXuBHjaZ1TqPoES0zP6++lN2WFqKUERD3H1KK/xqPx5ORvowR4H3+X91Tm2BwcBFundtwD+1Pmtmtwft/BFZLut/MXpB0A04mdjNJK5Za2rCvD5bPGkjg1TJaSg21jKHXl73WD0yYALfcklCgCzGzh4BjgqOR+2eRcSxoZktxtuKiRtpMqPNO4HM51bUIt+ux7s7HIug5W9qRDDE8nMvTFB06Jm2XVLSkDwEfqrocXVDcSNKlMf3du/pat+LtaBqK2eEdp5YxEVhtxWXLDgzA5CnLXu9O/Fg9Di+5nx/e7nk8OVBZTMx6T4nolvl9QjuPkPM6lJlNy7O+arxt9ng6hm5Iq1cUlwObRvrw7Trld4ic/zOPDnSCLS0qKONGCpQe8XQCnSDN1578uMXgHTeejuPDwEa4Z8VsYBszezljHf/APSD7gBm49FjlpE8wupFFuQcZrjZWJno73+vkFdrdA48H6DVb2hAVW5W3nRqDm4fnQVF9bAd+TJpEO6SigQ2JyODHMKnO+72At6OpaM3ceVrG8jv9v9EMF0Y4KKmop4KX3M/aZjdK7nu71xaKGu/l7Set1Nnp+DGpp+PwtjkVZV7P6UY/qbel1XRDWr0CuQCnejQK2F7SVmZ2c1xBSe/Gja3BqeFdlVMfSm9LCwnKMLPti6jX48mPpZGf7XpIdsvD2eNpiD0j559p4OEIw/OhrUPXTTb6KS5NRzcNqluXyqS/H/qDpBb9o2qXXYYOdoB7So23pR1PGWyxH5O2CjM7XdLVuLRHuwBr4hYWnwZuBc7rkAW9bsLb0TYSVcsYB0xdPr5c/+iECvaqVpQ9l/YFZnhb2graYUfN7DFJ2+CcvPsBbwWm4JzrDwO/A84ys6fzbLdAvN3zxODHpB5Pm/G2ua3k7Sf1a0516Ww/6XG4zQ2jcGn1ZpvZqdECWdLqAX+tvDaz2A9pZvdIOhc4mDCt3i5m9mikrhHA92lTWj0ze1jSmcAXcAErv5H0fjObHS0n6W0MV0w628wez6kbpbelRaYv8Xg8Ho8niUpejnlJEZMpeD5yvlJiqY6lk+Tuyxypni9jg5/DFgf6euOze0qJt6VtJU+1DE8qsjpuyuO0eYNWSkWb2fHA8Y200yhJTqQm6ts+z/pi8Ha0JKxGshL82OWWvbbFFsC67yuyS56S4iX3m8bbva6jmxYTO4TOXkz0lBNvmz2eDqFb0upJWhn4cZ02fyRpsOraGcF4Oo6v4tRBtgBWB/4j6Q/Abbgx7ua4wOoRQfnZwJF1+pCF0tvSpoIyJJ0dnN5lZv+XQ388XUUnpDDxpKILHOCSpgOHAO8n3E3zFG43zflmdnUBbfbh8nhHd9O8RLib5udm9kyKes4BPpqh6f+Y2eb1i8W2tTzuYTg9cvljZnZOI/XVYApORuqhJuqIytF2UgRDSirL/08Dq7SzI71Nf/8bqhiJuzT7ymfzPD2Dt6Uej8fTHN6OpqaY+f3fzHiPxPQa3ql114Mnnxx+bcUPvif3vvQEUnL0S617PN2Et3sej8dTPrxtTo1fc/K0ny5Jq7c89dOZ7hJz7fc1+viypF2Ac3CBKSNxwSK7xxT/I/CRBtUskii9LW1WKeNg3Ae8BvBBGR6Pp5RIOhw4FajeYzU9OPYLcoF91MxeyqnNqbgH5Dur3lo5OLYAvijpEDO7Io82c+IkhgdkFMXi4Gczz6GJkfNl5L86m3F09fyprKz6E3jqsOHXVpzAxpu405v+BkORYVmmFCYSjPI7aTy5421patq148/bco+n5Hg7WgKmAmMTUpeMGwfrbPkm+m8LNyy9efoI2Gbf1nSuLfhFAU+heLvXVrwKhcfjicXbZk9v0QV+Up9WL7GPC4DdJL0X2B+nnLEKTinjaeDvuO/mzwU0X3pb6tOXeArGTzZah3fcxCHpMEIpKXAqENVSUiOBPYArglxcQ022uRJwLU5GCuAVoFpKajrOwF8iaVcz+1PK6n9C/Ui/hh66krYDDg9eDlHsStJ8YAXgLU3UsWnk/KnmutNKqhW/4hhbv4ineF5eBMCMGe7lP/8JuEuMHFlDOcPjaR09bEs95aXAMan6sjlu5Ochnrp4O1oCptV4b4stgLFjefM6i8KLu7wPH/Tm8TSMt3ueHqFIP6lgRNZllXItJnpKh7fNmfBrTq3DrznVopPT6hWdNs/MrsEJOrSS0ttSH5ThKRj/cGwdBT4cO9QBLmkt4AeRS8ea2UlVZTbFSSVNAXbA5bA6scmmTyMMyLgX2CV4yFXaPBr4IfAZnB0+V9LaKVU6Lq6Rs6thJI0FzsY9iK/H5fV6V97tRLgdl+NsNUmbmNldDdSxd/DTcBGWncHSudC3ccKb/ZGjaPyguiYvL4J58+CZ+YyYuioAkyc/xYJgk2YmlYwuoZPTQFXVOQP4BLAjbnPuCOBJXI7Hc8wssz2RJOD/AR/ESQiugvt+5gNPAP8AZgHXmNnrWeuvQe/a0o6gVxcM/bPF01F4O1oCJqyY/N7MzYJ0w1Mmhxff+tZC+9PVdMGuRE/TeLvn8Xg6en4vaWPg7cDmuA13k4FJuIW4hcBjwD+BX5vZ9SnqWxnYMqjzbbjvYxJuM93rwLO4TX5XAxflpbJchbfNmSjH2kNvUNSGC59Sz1MIpbel3np5ehj/598DnEC4InJhdUAGgJndDhwUuXSMpAmNNihpfVxqJ3AD972jARlBm0uAzxEa9ZWBoxptMydOxD2wBoFPtqC96OTuhKw3SzoY2Aj3cPyPmT2XU7+KZ2AAF6sTx1h8vGQbiaYumTfPHS8OxBadPCVj3X2C0f3Zjr7yTDaCNFB3A8finB4r4VJCTcc5VP4g6QpJ43NscypwIy7yezecY2Q0YQqobwFzJO2Zsj5J+iZwG/B5YENgPC6H4jo4h9RNkn4qKXXYjaTNcI6rq4CPAesDE3BOrTVxQRpHBu+vnrbelPSuLc1MUeO+MQXV6/F4WoS3oyVms82A1VZrdzc8nm7D2722UtSY1Ps4l8UHCifRBfP7O3Abyz6DSxu9TvAZRgY/Z+LSCfxF0ixJa9ap70RcUMjXcEEqG+M2WvTj/AXTgj7/BHhQ0t7x1TSFt81dg7fHHk8bKb0t9RbCUzKWEg6ao+fV+D9dT20kjcPtWAZnRBONsJldC9wSvByPS2XSKPsT/oFeamb/TWhzKfDNyKUDm2izKYI8ZJ8NXh4XyG4VzUXA48H5bpK+k/ZGSbsCZ0YunZxnx1pDXAqTcbj53riq66s0UP+rwUHkZ1F0oT1+fcgFZAzGp5qZ+Cboj24wfH1xbLluIZIGarng0mzgFOB44ArCfH174NJANS0PEEkD9c7g0ivABcBxwP8Bc4PrlTRQ70tR7YnAV3HKGODUK07E2eJrcc8KcIFpZwfqF/X6+R6cY+ntwaVngAuBbwdtnYFLXzU/Rf8aocdtaZFcFzmI/ExLln+DLrSjnkQkTZf0HUl3SFogaVDSQ5IulPT+nNsaIWkTSQdLOkPSzUF7Fhyzmqg7188h6b2SfinpbkkDkhZLelHSPZIukPRBSSPq15QZb0dT04itujA4iPxcliMGLPb6Fltkaeug+kU6Br+QWItW2tFIm32S9pX0W0mPSnpV0nxJt0r6X0mpQrYlbSzpY5LOlHSTpPuDz/B68PMOST+TtEMRnyPA272OYinL+kqLwo9JU9PBmy66aH5PcN/lwHdx8++vAN8Hbiac378Lt/liclwFVQzg1IN/ivs+jsEFi1yGU+AAF0RyiaSPpOxjWrxtTk0jtsqvOXk8PULpbanfjuspkGYeYq1yQvgHbSoUTDaylG8/OxNuX51tZvfVKf8bnFQdwJ7AOQ22u3vk/JI6Zf+MG/BPAKZJ2jRQ7mgZkpbDRZf3Af/CTV4Kx8xek3QE7nsH+HKwuPk94K8x/ZyE223+MVx0eh9ugnWdmV3eij43R7UkW9z/09iE60WSVwqTLrGlq/7EqWU8Hh+QMXYsjBsHkye79CVjKy6M14oOfGkf6pI0UJK2Bb4cvFwCfNTMLqgqsyNwJW4nzAEE0qRJHZS0AU79YjlgCDga+HFcepIgwGMznOxpbvSeLW2UZm1U1oCMrPh8uKnpzDHpGwS7Ek8ldIJXmB4c+0m6Emej8pBFfgJnm3Mlz88haXXcav12MW+PD471gY8Ad0na18zmNPcJQrwdbRXJARlJrLsOLLfuGsu+MXkyLvtYHN0SmFFgmsG+jHa0ck9JaIMdrezu/jXhYmKFlQl3eH9R0iFmdkWd6u4gDBCuZiUiO7wl3QAcZGaPNdr3OLzdayfNjveK9pX6MWm30y3ze9x8/XozS9z8IGkLXMDG6sAawEnAxxOKnwucjvMfx0aKyqkq/wzYB5f6+UeSrjKzhXHls+Jtc6vwa06locPHpJ5y0gm21AdleHoYP9nocjaLnN+UovzfIuebNtKgpNE4OfxU7ZrZUkn/wEnjVdqtF5TxVUk/xXkiBTyPi2q/FvhlA46nb+Nk/l4HPhGkVmkJZna5pGNwUYeGywW5jMdW0mLcZ33jUvDzXuDDRfczF0b0udX8RCoqGdU0opIRJW2wQDOO3y60pfPmxV6eOBEmTHDBGRBJYbI0xXenvip5jRSoFN9rqjRQkg4CrgkuHSPpx2Y20EiDSpkGStLncE7rd/5/9s47bJKqyv+f8zIMMAQHJEkcgmQBUZGkoiCKSlJQREBE1F3FhKLgui6YRd01obuigiBBDASVJPADBBRRRJQhCDKkAQaBIQ0wzMz5/XGr6Xp7OlR1VXWF/n6e5z5vdfWte2/12/29oc49h3YYqM/0KDbe7q90GmREZV5sZkcQdsUAfNHMfhp5Nups4wTwY8IDAQf2dvfze91TtLDz517vZ2GstFTUhAIfJtaY2K7EFjcAFxDcZ20F7EGYn+9N2JW4u7vPz1htZ3wdJxgErzhsgXnehwWX2JcTQui1uIowHn6A8DDgJYRFEoAXAVeY2Vbufu+w99CJdDQJoxmTfHSu8z/Tw8e63fY9Mr14G7qPm0+mOUYZohtl6Ghsd3frYeJThId8txC0dC+CMUhrd/ce7n5BgqL/STDQuAN4hNBxrgq8nLBZxGjv7n5pvwePwyDdE+NBgWNSze8TU8T83t3PGFSvu//RzN4H/Do6tV9kPLfYl8Ldr0hQ3lwzO4gwLl0LeB6wO4M35CVG2lwltE4qkmFm6xPCIb+BEJZpaeA+Qpjjn7j7eX0uH7bOCeCthHBTWxPmzY8RxpXnAj9w9wcSlrUGYc79EoLmvITJDyTW69TsAeWtTdgsvTOwJbAuYfPb48BdBG/1p7j7VUnLTEvVtVTqIAqknyuovNBXuE3lPosJM1ujR1p+BPVvHjv+R4L8t8WO17bh4iZuQnvXy9yEMafi9W7eM1ebXYCNCG4VliFMBN5A8HBxt4W4V4kwsx2AD0cvv+Luf0t6bV64+1eBfQkPCCyWoO1qcKLLe+cC2w87KRw9EzAxtZ14uOP9fjaS96esq7leG0bCs/ND6sK0ZdqGGNOWhVVWX4JVVi/Ck3o1sIaEgYp2A+0QvZxH2KXTix8BLaucGXTfuQ3wJtohS07qZ5AxCsZHS4dlFGPSpWk//x7G65GMGJpMj12JW7n7J939WHd/M2GndWvhpLUrMSu3EnZ3Hwm8muCd7YhhCyvgPj5J2yDjQWAnd9/J3T/o7p+P/u4Qtf2hKN/zgWOHvYdeSEeTkFan0nvHaLHWWvD8rbt4yVh2OVhzi6HLrReVm9+XSok62rm7ezN3P9DdP+fuRxDm5t+N3m/t7u63lnAgsJq7b+Dub3H3j7v7F9z9S+7+0UjztiN4OoL27u7cke6VxSjWSevguViMmqbM71Nyaex4OYKxx9C4+zOEMKgt1stSXo86pM19aRlLpNEq6Vo2NCbtReTB7e/A0QSjshUJz2vWJxhM/MbMzhryOVOvOtcihFE+neDZYR1gKdre2z4PzDSzfRKU9WXCmPNc4L+ANzLkDlEzW8HMfg/cCfyAMObdkmDANoW2N7j3EYyOf20Jw/8NQ5W1NC9PGRuaWa+diZlx956DBNEk0naQeXQIslwskNVoLyR0ciwhNl+RxDuQ7tveY7j7I2b2JMFyD9oWhoXVGXF37HhQp3cXYfB/G/AkYWF9G8JC9RTCROlEM1vb3T/XqxAAM1uadtiSmwgddilE1osXEzrlA4EtmGyl2GIewc3Uf7v7Yu6m6sU8YA5hjAZhbtiNtAYZwyANTMrUpWLHS5bXjhHSlDBQ8fJ+6+6P9CrM3ReY2VnAB6NT+wCXdcn6/tjx9wa0cSSMp5YWRdpwJZ3OCERhTBgsneLzro5705HvSozK3LbznGUL6ZL3fbwldvzJXrtl3P2yaKfLCdGp3Ydq/QCko/0ofjH7o3Pb3sJ7bj5ecgr9l7HkLWMgZkPs7q6Elmp3d5fd3VmR7o2atP/CMtZJRYNpyvw+DSt1vH4qQ1ndylw87m0OSJv7MQoDCz1zGgn1HZMCjfHg1m1x5WEW184kTKPdZwA8SniO9XeCV7gVCd4zWhvc3ghcbmY7JdzYnJqqamleRhkbECxpikJGGY1nUIdaZEfWqlsdZU/quQAe98bxZMJr5tE2yhjGm8ewdXa7Ps55wPHufm23N81sXYIF4q7Rqc+a2R/d/cJu+SM+D2xM+AEcFll7l4aHsCtfBb4aDTA2J+yEXJYwIXuAMGl8trRG5s4cwsaqvEjiIeNpinl4OB46mnauMAkDpqQcdpUvpU0JAzXMfbSMMha7j6iNr45ePglcZ2bLEgb5byOEhFqa8CP/PeHBwa8S1JuZ8dTSvBlkkHEx7e42b8ZDS8eNtLsSzewPhMWM1q7EkwpuYiIKuo8ZseOru7wfJ97HrDwg79BIR/MgiYeM04ADCqpfhhlNo0QdTby728w+R1iIh7C7O+vGtW67uxO5oU6LdK+qaJ200mh+n4gRhXnuxydix9d5+pDPkzCzbQkPFVtclqW8fkib8yCJAUfRWiodbSI9PLh9uSPPi4HzCRt/Wx7cvpSx6k4PbrvHDYbN7EjgW4SNZC0Pbhv20b5HCMZwf24ld7/DzLxH/iRcQAgL/Ztu+mRmexAmg8sRnk19HXhnhvr6UkUtzcsooyiMtisRMfb06sgmYu+PO4rhHWOZ2HFSK8T4U+1pVanT3ftakrv7nWa2O2FH0Gui01+mvUNoEma2HfDR6OXx7j5oEXykRLvYk0wQG0AvDxl5k8RgIw/9aMCEY50fBdvZ768x+fyUKUyb1jbMmLoULJy/cBQtmoji+3XjcXd/vMC6M4eBGmLRo4gwUFnuo1t58WD2/4zy/JK2C/4W60ZpfzO7BHiru3fGLiqM8dLSUdPPMGNpNBYDjUknUdauxLwp4j6eIrhahWBo0a/MuLvpOwfUnQvS0SIYbLDx0bkOP1qn+5tTp5IsRFRTDDOkpRHa3Z3P7u6BSPfqRr/5t/QjULnPQfP7dPUmCfP8HGa2BOFh20uAfyfsVIfwJTg6TVlReUZ4cPdCQn9yBO3naaf6iMJAS5vLIo9nTg1YJwUqqKVl0xQPbnmGBX0c2LbXpuJYnb8ys8MIYVYBDjCzj/TzapwXVdHSvBTBCkpCIMFPS2U6+geANXukr4+g/viiRdL97XEXAsO4oCujTiC43CdYQbYM2bY2sxd25ous1E8kfFHuBD41bJ2iaiT1gNHPQKMy+lEtVl0VVl+dVbbbgO22g+22C7HO588PKfUOmXS0QkF1S3nEye5H6jBQTPYSNExswCLCQKUtM17eSmbWGawmrq3TCFbgGxD6gJ8SJjufZ/KumV2AS6PQUaK2pA1rMixNGfsW0KfYRHgomzRZJfq1ke9KLIgi7iOe5wjrEVvFzCYIi0ktTk5QvyiNpB4w+hhoHHpX9/NbbEHyaZboilkYu6ZJ5buKrsXubiZ7/Mmq37nu7hZNI+lYMes4SGPSAtD8fjBpwjxjZmeYmUc7uxcQ1qPPo22Q8TDwBne/KEnlZvb6WHmLCA8arwP+k7Z35W/RfjgqKsug3/6ijr9ipNRzTJragxvwh+hly4PbsCT24AbEw9oflKHOxLj7k4MMMmKcSTtm+xTaIU3GgryeIlzg7m8YnE2IIhnGYi9+TVMsFwugtQCeJj8scvfZRTUpAXHr8mV75ppM3FPFMNbpZdT5HO5+i5n9Fdg6OrU9i1u/f5ZgqQ7wPnd/IkudQgQaaDH93tnBW8a0abDKqrDUVJgxg2WWWw7++U+emhP7uS69DAN/vml1tHVNuTQlDFTaMjsN5JYnLOS0WDF23PKOcSPwRneftHs78mL0M8JnshVhYnRkgjaI0tiV7MYXWcekImfK3JEI5exKLIIi7uMLBPfUSxAWti43s68R3FTPISz+b0N4OLl9dM2vgePSN1/UnmWXgxnbDMh0MM2z2alM/6Dd3enqLXV3t2gCSX/7WsssBc3vi66z2/VpceB4QliBvNY+/wK8y93/mlN5ohbomVOgMmPSshlHD2654u5uZrNoG949v8TmjJwmqIEQGWh1iq0kGsT9seO1BmU2s+lMNqQYJl5rqjq75MsjRmx8IWiSFbuZbUzb8v4Ud+8a3kSMO8NqYcN09OytgxX2qqvCitODcQbA+uvDMx3RiZZaqvPqptCUMFBpy+x0J9NZZufC0FPAnp0GGQDufj7wwdipf4/6G1FZRuUNoxONSQukzB2JUM6uxCLI/T7c/RrCg8dHo1OvAM4B7iJo8Z3AWQSDjJuADxP0Nmn/IOpMp7eMGTMI64qDOJhmhC5pUZnFb+3uHkypu7tF0xiVN4xeZWpM2kCaMr/v5CeEjQ9HAp8mGGL8jeCF/XDg92b2yoR1A9wcK++ThPDQ5xPa/2LgCjP7dGRMJ0qjDvokLW0o4+jBrQjWjB0/WForSqBQf9tCqNMpg8os2pTNTNouoRYL49GFDWPH9wy5I/EW2k9VppvZygl21MTr7ep2KiXe570X0N7tc5CZJXVfdaKZnRgdX+7uOye5KIqbNhLcvWlb4oagX1iSOEVET2iK1XeMqVNh9dVDivPPf/LUo8+MsiUPAC/t8V7Ru7ubEgbqKdpGd0nK7PyRdJbZGdP7DHf/Z5/yTiZ4yFgzasfOwNkJ2gFIS/OjYRpVCwoYk5ql9N5WvntTytmVWASF3Ie7nx/Fx/034Cigm6XjM8A1wO/cvd9YtyvS0VHTJyzJJJKGOUnDyTTLIKMA0upo65py0e7ulEj3qozGpI3ASB/GNEip5vc51+nuvyZ4UpuEmb0OOAXYArjEzPZ193MSlDcL+FqX8tYAfgi8njC/fxHwtkHldZQhbR4bGrhOmvf8vp5jUhgDD25FY2bbAWtHL+cDf0x5fa21VEYZokY0rSMTBXNd7HjHBPlfETseyp2Tuz9tZjMJA/5WvT0H/FF87B2y1ttB3MgjD88bWTiJ/kYieeE0z09xjIGbrEQRrLpq+Nu50PJEl3XRJM+Hhp9slBkKqilhoB6PlZWkzM7dOJ1ldr6+tF9h7r7QzC6n/fRpG1IYZSAtFaLulLErsQgKuY/Ie9CngEMJBhm/J+z8eYQQLmongqeMQ4CDzeyz7n5smoYjHc0JzcdFaTR5d/efouOlCJsoXkl40Hc4sLOZfcDdr0hYf5yTkO6JoWnaw8RKbV7T/L74OgFw9wvN7E2EseUUwoaz9dz90QGX9ipvtpntFZW3DfBWM/tNygd2JyFtHiFlehwSBVJ2eNLUHtzM7EnaGrgakNYoo3APbqPCzIzJhm+nD2GkchI11lIZZYga0bRJQY2o567ECwmLIksDW5nZRu5+a5/8+8aOz8pQ7zm0jTL2o49RBrALYbEZ4E53v65P3oGY2YbA1rFT13RkuR/4ccLiXk/bzetVtK0rb07brJT5m4kv7HJy1YQX30+Fxk7jw7QUa7eLuv1/G0FTwkDFf0RrAX9OUd4j7v5sx/v3dbxOMiGK51k5Qf5OpKWihlQm5myZOxKhnF2JRZD7fZjZ2sBlwPoEN/17uvtihm5m9hpCLN6VgGPM7GF3/3bCNjxXTMr8YjHyno+fRipvGaslHTuLgtDu7pzrzHt3dxeke2JImrb2Wpkxadk0ZX6fGHf/o5n9FngdYf11P+AHGcqbb2ZfBU6PTr2X9A/spM0jI+lvX8+cakYrpF43jgWOKbj+cfPgljefor2B+jHgP4csp7ZaKqMMUTDq1EaPJhsA7v6EmZ0N7E8Q6f8EuobrMLNdaXuseJx0O5g7ORU4mvCP2M/MvuDuN3Wpc4LJnc4pGerEzKYA36XdIf3N3W+J53H3mwm7DJOUdxlto4wfuPtJQzTrCkZjtVh9FnX+JqcCG+VcydIkC2HSslXKkzHX+cX+v42hKWGgZtI2WEt7H93K6zyXROeyaKG0NBc0Jm0EZrBkakPhMnckQok7BHOmiPs4hWCQAXBgN4MMAHe/NAq795vo1OfN7KQUu6CkoyPlAJKHMEnIssvBjG0G52tk6JKc5/c2kU5HW9dod/co6gRy290t3assScekephYaYbX0jJpyvw+LTcQjDIAtsqpvBZpy5M2jw2l/94LoDJj0rJpqge3wjGzNxPCP7V4r7vf3St/H2qtpTLKEDUjLvx5iHAlhFwUx2eAtwBLAgea2Q3u/tV4BjPbislWzV9x90c6CzKznYH/13rt7l2t8dz9JjM7mWD8MBX4hZnt7u53xspaAvgG7ZAp/6JLvMIo738DjwI/6tVJRbsMvw+8Nnb66G55R4m771x2GyrDwkWwKBozTUwFZgDLpSggb28ZrXFZ3sYZDWKzM2HmW/MrL+2DxNY15dKUMFDX0d6KuyM99DbGoPu4g7Cje6XodZIdP/E8cxLkfw5paZ4kWbTeFbg4QVnxPLsO3SIxFpSxK7EIcr0PM3sp8Kro5c3ufn6/8tz9PDO7BdgYWIHww0vk3U46midFeMto0cdrxou2AKbnWK+oGdrdnXJ3t3Sv6uStpa21Uq1x9kYb2GjO/D4t8edfS5RZnrQ5T4rSUXIuVzSQRnpwK5poU/RptDcUf8HdfzpMWXXXUhlliIYR7zTH2aI8b8vFoXYllo67/8PMPgp8Jzp1nJm9A7iA0BltBexBMNoAuJzBD+uS8HFC7OuNgU2BmWb2S4KF+IrAXsAGUd4FwCF9dr2sBHwU+C8z+ythQnJP1P7nAS8GXhO7B4Bj3P03nQWJkpk7N/xdaVVgkzJbkoCWLo79osXirLc+y8yLxrLzI0Ob5o6mmhIG6hza2v5aM5vu7nO7FRYZze0TO7XYfbi7m9lZwLtjbTi1VwOjMl8VO/XHXnlFFUhikJGEtGPSpqIFcMrZlVgEed/H9rHjvyVsww2E8XXSNoi6c+hd0UFSz+An00xvGWOPdnfns7tb1Iq8xk8ak4rnaMr8Pi0vix0nCT066vJELdAzp0CO83sDpqRcUA2PnMoOTzpWHtzyINrsfA6wVHTq6+7+6dIaVDJ5KEM1nr6KClP2oD/p17zsdooicPfjgQ/Rdg2wFfBJQoyxN9M2ZvgVsJe7P5NDnQ8BuxHcjULoBA8kuGc6grZBxiPA/gkNKIzgfv9dhLAnXwKOIizStO7hYeBgdz826z2IAnjiiZCYTthENZVkxq1JPWQkCV2Slm762e3coo6/DWGzMxc/t9qqsPkWsNFG7dRQ3P0J2uGcWmGgulJAGKjWl2k/M9u0R52JwkC5+23AH6KXywIf61P3u4C1o+M7CS7xunFi7Hh/M1u/Rz4IT4daOycfBi7rk1cURhUWRDQmHVNGviuxIPK+j3hc22Fcj+qHUhqDPvqcQ5cA3Q0t+hlfpA3vXnVy7MNaC+BpUvmrfqXs7iYYgySqtya7u0UlKHNMOtHxtxcNnd/nSQ21tCnz+zSY2WuBnWKnLspY3rLAJ/IqT2RlkEYVrWFpNVXkxCJ3n90jjcL4YOw8uGXBzF4F/Jq2kcj/uPvHy2pPFcg6ElwvSodkb4oQeTPBeC9+V+HhQzVw928TrLK/QthtMpfwBHsW8FPgTe6+Z8oYrYPqvIsw8D+AYPBxNyHm10PAnwihVTZz918MKOqTBOv0rxHCp9wSlbGAENbkNuBM4DBgbXfPPGkRRTOsl4z7B2dJTRJDjjRaOgYsuxxsuglsuSVssklISZgwWGpqujRR/go4QauejY4PNLMjOzOkCQNlZt5KvSp095ti5bXCQK3bUdYSwDdJEAYq4qj4sZm9vUv7dgH+J3bqP9x9YY82XkV7YWoZ4NzONkZlvh74VuzUV929dLeBYtRoTJpfUSm1tBo62tqVCNGuxAH589qVmDd530d8x/mWCdsQz3dfwmtEYzgYecEYW8rS0fhu7v0G5K3D7m5RKYoY8yUpc5zn9uN8789R+/m9mX3HzD5iZqv0qtPMJszsYOCXsdOXuPufuuR9g5n90Mxe3Ku8KN/mwCVAqw96OmqzGDvGfX4/9sSNdkftwQ0iD24p683Dg1tqIoOM39A2SvmWux9RRluqRCaH2+5+Z14NEU2nCJdNSctU55eZiQlYZunB+eL5K4a73054KHfUoLw9rr+MlHbt7r4IOD1KQ+HuDwC/iNLIqHtsrnoxlWCv04ukxhhLU4y3jE66aeqYuKefGj3ka7HkVHi23/+u/jQkDBTufrmZfS0qdwpwmpm9P2rvQuDlBA9HLZ0/ncFbff8deFHUjs2Bm8zsbMIEbSrBMO/VsfwXAV8ddOOiKOI7/vIep1wM7JqiDWKccPcnIm3Yn/auxIO65c15V2KuFHAf18SONzGz3dy9525DM3sT7dAl0NuTkRgJ/bT0AIrxltFJ07xhiF6UqKOnAkcTvuz7mdkXooeLnXVWfne3qBJ1GA+Oyfx+DGnI/H4t4APA18zsz8BfCca68wgP/jYgzMNfELvmdoJXzG5MBQ4FDjWzWcC1Uf7HCGsHqxOM5OKGcguB97r7PxLcuyiUfmPSYbUs7TMn6eVQ2MTkNdak15RPKR7czGwm7VBQO9InFFRBHtxSEYUs+Q1tDxnfcfcPj7odVaS5UdDFmJB1YV0TDSGqgpm9lBBS5mUES9MVCbHGHgXmEAY9VwBnjsgdWQW5n+ThTPoRN+B4OnauF9JJIHjJiLNU840yIISBigb0xxHFn6V7XOtfAQflFQbKzHYDziAs3rTCQHXyCPCehGGgPkFY4DmS4AJ6JyYvdrf4IfB+d+/rTt/d748W/k8lTHaWARbzwBFxEvDvvTxv5Im0NCu7Eows0uZNapjRi0osLoji+AzwFsIC94FmdoO7TzLSSrMrkeA9DQB3H6U7kNzuw93/Gi2kvyQ6daqZ7evul3fmjbQ2Xuav3P3ujPfSE+noKIkbcJwWOzcsB9P+qpyMPGt0ob4L4CPXUXe/ycxOJngHbu3u3j2+QS3a3f0NEu7uJni6PNXdH+yRZ4Iw5j0+drrr7u48ke5VkTTrlfG8i2LneqH5fWbqq6VNmN+3vsBLANtGqR8/BT4cbXrrVx7AjCj14x+E9YKkk8ahkTaXiZ45iZ60PLgtTeTBzd1v7ZM/Tw9uLaOM/ehjlEExHtwS08Ug47vu/sFRtqGjPZXSUhlliIJI2/EU2VF1dqCd9aiTFKJMzOzlwLdpL8rDZK8kqwArA5sRJm3fiBa0jo1i/daMaV3ODfKWUTb9dLTbe9VYbMidtIsuk7AQRzbtNRXB3b9tZucB7wF2B9YhTEDuJ+x2PiWhYUSaOu8ys52AtxGMHbYGViPserwDOBc4wd0TuZOJjCyONrMzCCGfdiHsslkCmE0YgJ/o7lemaOMsM3sF4SHB2wg6tjrBJey9UZk/cPdrk5Y5LOOnpUkpcpyXdh1u0JhUDMQseC1Kk78ClLUr0czeCry143TcXfTmZvbzLu3dt/NcdD7v+/g34DLCrsaVgcvM7CrgKsKi/IqEB53bx655APhQnzKHRjqaJ0m9ZQzjUSNuaCFvGeOCdncXg3RvlIxy7XHQfFzz+3Gn5vP7A4BXReklBBf9qxE2ScwjjCFnAr8HznD3Wwa061wz2wJ4LcHAY3NgbWB5gkeMxwjhr6+L2niRuy9IceupkTbnSZnPnEQTGUcPbmnoYZDxgVG2IdaWSmqpjDLEGNNtUqHJhhCjxMw+CXyB0CH2e3LSes8JC1afAPYxs9cWuVMyd9bZBNgkYeaWR4yk4UsgeQiTzjwpwhMB3Sc1DTdwW265wXkaTl3DQHUp869AbhbaURt/FqVSGDstHQs0Jm0aZexKJCwuvKXP+ysPeH8x8rwPd/9T5KL/ZNoxb3ektxvYvwAHuPusNG1OgnS0Hy0tGsU4L62XjLhnjIO7nBOLkda4rXVNBdDu7nyR7tWBpHPsBs/Dq4qRftNFNaT0Oeo6v48elF0YpVxw9xuBG/MqLwvS5kHUYe1xIva3yDCqNafGY1Ia4MGtCLoZZACHj6r+jrZUVktllCEKYNgOZphOdZi6iu68+1mY15Sa7koU1Sba6fSl6GUrTMADhHi5fwceAp4hWKevT1i02ol2Z7kRcIWZbdNtUFNNtunzXus3VmWPGUnJY7KRxO3qCJFRhqgo46mlSem2GJKENCFMnoj+7p2i/Batdk10OZcHDRyT1pwydiUWQZ734e6/j3Yn7kPYcb4NwTJ1WeBJgieja4GfA7+OFvNzRTraZPIIYVKxMemYo93d+SDdK4uqPkzUmFSIKiBtHkTVnzkVzT3R37VKbYVojAc3zGwV4HsD6vyumc3rOPedyDAvXtYLmWyQMZvgZehjNvhZ4d/d/YJBmZJSdS2VUYYogNZAfpQ7atLQrT1V7GiFaC5mthHwRdod433Ax4Cf9VtsN7M1o+sOiq5dB/g6cGihDc7KEhMwfTqDQ1N2I63HjKTeMlreFvM0NihCSytgTd7PKG369PD/HcTEEBbgEzJwE/0ZOy1NTVw/ilgEf4IQGn5Yeu2ayUvzqrrwnwGbSGkoXL0x/ih3Jbr7McAxw9SToOxM99FR1jOEXehnZC0rLdLRNKSd3ycNYQJt4+S8yGqI0Y2yx6QN1PQh0e7ubEj3yqbo3/IwOqUxqRBlI21OQtWfOXWjiLHjPZRrmCFNh0Z4cIOwEWKQ58zdu5z7dZdzazI5ZvsahM8mCT8mGLRkpg5aWr1VKtFAivqa5bULO2/0sxIiAe8DloqO/wls6+4/HbT70d3vdfd3EhbgWu6n3mFmKxXa2qwssRSskHbAnCZsyTDMZ3ivHGM0+N7szP4PAFdYK/x/hSiH8dLSzOQ9RrsN7stilDFKxki3hUiHdHQgo9CPqcC+Q1x3co/jPGnY/L7lBTNNkifMpiHdK52G6Uoqyh6T5vTZtwyFU2npOP/fRQKkzZWhqs+cGuYhwyyEgUqTKjYmdfdvA1sAXwFuAOYSdkrOIoShe5O779nPW8UQdd5F8OpwAMHg427CAv9DwJ8IoVU2c/df5FVnzai8lmo0IEQmFjG5o+38bS/qkmeU5DXZSLlwU7EOUlSS18eO3+Pus9Nc7O7HEVx/QfD6tEteDSuGJQmD57x3AXYjjZeMPMiqb910tHOHTsla2it0yZQphP/rkt3fF6J4xkxLq8T8YJDx7HyCB8myGTQmjecpQ0s17RSVRTqamqS/56ReMmDypqoy6TYm7Xy/zPm9ELkg3SuFUehGFcZbveb33fJIS4WIIW1OTRU0r0XeenZPx/E9He9fCVwapTKo0mdfLu5+u7sf5e5bufuK7r6Mu6/n7vsnCann7pe5u7VSwjoXufvpkcHHOu6+lLuv7O4vc/fPJQip1ypnVrzuFOmkQfeRMh2SpL0JqbyW6tcjCqDza5W0U0rbeQ3b2U0w2dXVsHSbVHQ73yu/GCVmtr6ZfdHMrjezh81snpndbmanmdkbCqpzwsz2N7NzzOxOM3vazOaY2TVm9h9mtlrCcrYws3eZ2fFmdqWZ3Rrdw7PR3+vN7Ptm9poh22lm9iYz+5GZ3WRmj5jZU1Gbrzazr0Xv5/nkeW2CK6h7OmOQpSC+HW7tzC0qFCNdmJDVaYctKYJhPWS0mCA/LW3RS1MrwErf6n5+hdUJhjYJxszalSiKYcy0NC3D6tPFCfK0DDKAu4b1Zpi3jrYYNCatMTIUFvkjHe1LN43KW1uWY3jD5YM7UhZ6aWeV5vdawhO5IN0bOUWM97pR9jppJw0ciwpRHNLmgYzqmdMw5LlOek/H387znZRlmCFEJam8lk7Ju0Ax7miRoHoozpeZfQD4KrBMx1vrR+ntZnY28E53fyynOtcixPfaseOtVaK0LXCEmR3m7mcNKO56YIke760Ypa2A95jZ5cDBkSurJO3cBvhf4GVd3l4nStsTYm+tR3C/lQcLo7+3Zygjfu3CnrlqR7dF6aShTIbxkvEwUBWvhkm0qux43nHWKLsBQkhLe9JNJ3IcDz2RqJsdEYM8ZFQFjUlFJZGOFsIwXjKuAF5ZQFuGocFa1XIVnfYa0SSke6VTpQeJeTLMmLSM+X0OY1JjCC3NVmXemNn6wGHAGwhrf0sD9wHXAD9x9/MKqHMCeCvwdmBrYDXgMeAO4FzgB+7+QIJyphAGDbsQ1lc3BVYm/GMfIoQRuAj4sbvPTdi2tYHdgJ2BLYF1gWWBx4G7gD8Ap7j7VUnKGwJpc19GqRNVWndsMK0NF2mvEaI/lddSGWWImlOVTnKYCVUV2t18zOzfgO/ETt0AXADMIxgy7EHQwr2Bs8xsd3fP5EbAzFYkDP43jU49BfwSuIVgQLEXwRhkJeBMM9vD3S9IUPQ/CQYadwCPEL5QqwIvB7YjTPFeBVxpZi919zkD2rkLcA5hkgHwAHBJVP5TBFcNaxDilK2aoH1puAfYHFg+Qxnxa3uZC9eQIgwk4oYY3b7eVTLMSEJLS0eooyt9Cx7+UOz1qqTzflJ/6rxo01HmlsC7gV0J8WeWAGYT3NOdlHWRxcyWJfQ168dOv6ube78ckJaOlJghxsMPd7x1KKzzo9E2JxMakwoRIR3tySi0odNLRpUMM5JQwphUBm4iO9K9kTLqcVYZupSVOra53tR585qZvQ/4Ir0XsdaK0huAY8zsQ+5+Sp/yVgAuJKytdnviG98M9z4z+w3w7rTrEAmQNleKqjxzSvpvjHvLGMqR9hBoTCoqSeW1VEYZIkd6dVRJOzAJeWUxgykpLBcrYrVoZhsA34ydOtrdv9yR58XA+YQHfa8heIT4Usaqv0bbIONmYHd3nxWr80jgW8D7CTp8splt2GeicyBwaT8jCzPblmD4sSbBrdKXgZ7+1M1sU+BXhAnYfOBI4Hvu/myXvAZsAzzYq7wh+C2hg3yRmU1Parnewauivwtox/pqKElDmSwd/U3iMUNkY62U+SdgIq1r7ipMAAN1XrSJlWfAZ4GjWdz70AujdJiZfR84vJseJuTLTDbIKBJpaVeyjkl3jf7Gw5jcD/NvG75JhVKnMXSd2loMdTVwM7NjgP8asgnHuvsxPcrdiLAr8ZXAFoQOdhlgbtS+q4AT3f2GIesehHQ0NUm09IDobzePGVNpG2IMG7ZEjDN11dGonNx3dw+BdK900qyTQn3GTnUa52Vta33n9w3YvPZi2gYZDtwEXA3cS9jRvBGwJ7ACMJ2w5jrd3b/do7xphI1uLR6Nyvs7YUPcigTvGS0Pw28ELjezndz9XwluPynS5p7omVMzMdI/nq7GMydRaSqvpdUYDQjxHHX6SqqtNeCztFf6Tus0yABw978wOQDxUWY2fdgKzWwT4JDo5bPAvnGDjKjOhcAHCYvMEB4ufrxXme5+xiCvF+7+R+B9sVP7RQtH3do4AfyYsODtwN7u/q1eDyA98Gd3f7JfG1LyfcLnsyTh/5QKM1uXcL8O/CLniVCJFOUlY34sicxMn06Y248HsUWblkHGDcBxwDHAWbRdsexNWLTJ/IQltmjTMsh4CjgV+AzwPwTPQdBetHl9gmK/BHyatkHG1dG5z0V1eXT+vcCPIiOOtO1+JfCB6OUofnDS0kKJa+dtcP/97SRKwmg/0E2SqrVoExm4/Z1gHLYVYZF3GSLjNuA3ZnZWtGMvrzrXIrgfOJ2wQL0OsBRt47bPAzPNbJ+86uzCYvF+zGx9M/srYTH+28B+hIX65QmrcysTFr8/AvzVzE40syy7XXohHS2UA7qca3nHmEo7dEkVqNOcOUtb0+potbS0zjoa7e5ueaf8FMEKdM2orGVo7+z+BnCHmR2U1z10IN0bGXXSFTEO9Ni8tpW7f9Ldj3X3NxN0rWVk1tq8lpXOzWubufuB7v45dz+CYEjx3ej91ua1fjr+IHAssIG7b+7u73H3Y6LyDiKEHjknXr+ZbTygjRcA+wCruPsb3P0T7v6l6O+2BP1/Isq7MfD1ZLeeGGlzodRJj9NuAiuTOn2uYkyovJbqVyNyQl8lUS3MbDngzdFLp48Iu/tFhNiAECyp985Q9Tto/yB+7u439qhzEeFBYIs8FlzivsqWIywSdeNNtC28T3L383OoOxXufjPwScIK3wfM7Atm1rlzvStmthlh+/LyhEX+D/S/YhxZmvCcfMGgjBWgRv3HSt8KcWMn8o7mU12asmhjZq8gaA6E3TMHuvuO7v4pd/+Mu7+OsFO7ZXx2ILB/mgab2TTgRwRduxT4fZrrh0FaWjR3tdNdiz1TFkNTI93PkQYYuF1E8KyWJP0idt2TwM+6lLcqIV53iwcJn8NXCA8rvwnMjL1/CHC+mS1NjkhHe1HU77RliNFKQiSnATraubt7JvADwoPFzwA/IXjfgPbu7g9mvYdOpHvjQJljrTqN8+rU1txowua1HwIzIiOMO7pliHZG70foJyDc83t7lPc4sK277+7uZ/fZsPYrgpemFgdEfUQuSJt7MZa/U1Ejos0GXzSz683sYTObZ2a3m9lpZvaGguqcMLP9zewcM7vTzJ42szlmdo2Z/YeZrTZEmVua2TfN7EYze9TMnjCzW83sBDPr9GA8qKwpZvYWMzs9KuMxM3vWzB4xs7+a2Q/NbLe0bUxCHbRU4UuEGBuyuOqaoB0WIWn+0tmNdqNvcPdbBuT/GW13dfsAJw1Z716x4zMH5P0twTXzdGCGmb04mvwMS6ebhad65Ht/7Ph7GerLhLt/w8yeIixmHQW8xcy+R7BOv9XdW7vWiSaA2xJ2Px1A6L+uBN7u7o+Muu31IM0m/SI8dDSUFZKGkumktSsx7TWlk2jRxswOJsRhhbBo871hXS4nXbSJFqm3IiyStxZtPtOj2Hi7v+Lup3a5j4vN7Ajg/6JTXzSzn0ZGdEn4ErABwe3rewmLRYUjLe0kxzHIE1UNVyLqRg8Dt1qF1HP3qwkehgZiZr+OvTzT3R/vkXUR8HPgBEKovsX01swOI4xXpxD0/miGD6PSFelo0SwXOx40FnplkQ1pGOPlirsJOhrxIMGw+MfdHiZGGnMS7XWFr5nZRQnWM1Ih3RsFlVgXE4VRv/l92s1rZvYHwjppa/PaSUNWnXjzmpl9jqBDEDavLTa/d/drk1Tq7s9GutZa99y+R74ngURlEtZ5v0GIMTyFsOHtooTXDkTaLOrJsGPS+uloJ6ZQz93K25wQw3LLLm9Pj9KWwKFm9jtgf3efPaidaai6lsooQ9Scuk9yFlH/e6gs28SOr0yQ/3ex4xcPU6GZLQVslrTeaMJxNcFFaaveLEYZn4gdX9ets4/a+Oro5ZPAdWa2LMEt09sIHe3SwBzCLu/TImvw1JjZPwfnAsKOpqUJO9//O0rPmtlcgmXB8oRJ4HNFEyaQ6wK/MzN39w2GaeNoGRQ+RIYR6Wlp6Ci19BOETWzNpymLNtEi/g7Ry3mExfVe/Aj4T4K/yBmEp0OXDWqwme0EHB69/Iy7327po5/0KltaWhYPP5w87zo/Kq4dI6EuY9K0CzeVWbRpioFbknrXAOI7xX/QI+udBC9IfR80uvsPzOz5tI3r/s3Mjk1hMCcdTU3eWjAOHjHKGJMOS20XwJugoz8EjnD3eb3qdPe5ZrYf8CfCgnVrd3cqT3TSPVEeWY3FWtePSkvHysBtHDevxY3fnp+hHCCEdzazWQSjjNRlSpvTIq8/6YmGGPM+AdOOK7cpDcfaHtxa3EBYn5xHGBfuQXj+vjfBg9vu7p4pzLG1Pbi1DIafAn5JCAm6IkFv16ftwW0Pd7+gW1kxvkTbszCEjRiXE3To5cBrCRrzXmCamR0cN2roaN86hDXUlaNTTtD1mcBDhLB9O9A22HgFcHmk9U+QkLprqYwyRA6U2UnVYdGjSox0sjERLcp24/E+O+byYvPY8T8S5I9vh13bzFYYwoJxE9oWhXM9WcypeL2b98zVhcj10vOBlwD/TujsIfyTj+5x2Ta0F7P+GdX5S8Lu7jjrRml/M7sEeKu7p3g6BYQHml076S7E87VWCleNzltHvlbetWh3ljVhDjK+6CSvRZtRstzgLM2gKYs28fJ+28/S2d0XmNlZBNepEO7jsn4NMLNlCMYcE4QdNt8Y0Oa0zEBampASx4R3HVpjw4wydHR8FsCbYuCWgnfRHg/fFHnY6FbvfcB9Ccv8LvB5wvrFqsCGwK0p2jQD6WiJZI4gMSLqOCYdD5qio3nv7h7ADKR7onZIRwtmHDevrRk7fjBDOXmVOQNpc00o85nTPRmunRUMMkbO+MzvoTke3GzxUM/v7PQsbGa7AmcDyxJCPZ8HnN6jfV+ibZDxD2CfbuNnM9sXOIWw5rwh8BHCfD8pM6ixluppthBDo0WbAawG3NsjpdrlMSTxGAMDRzPRQ7onY6dSx95KW2fE3T2u74qZnWFmbmZOsPZ7gNAZtgwyHgbe4O693Oe9MHY8jbBwtAHBsvKnhMWjzzP5IeQuwKU2XAxvGyJ1Xt+vvJoxh/AvqhpVbFOV2XuIa4wwHk6TSv+K12LRhsnu9LvVW/R9fIGgrc8C7/YQDzdvpKWiD40fU9adYQzcWuyTod5hDNwgMnAbpsLI9emhsVO5hHGKjLnjxs7D7HSUjtaCK8puQM0YmyW9sdHRGHns7pbuiREzTmPSWs7vM29eG6LOkW5e68JbY8e/65krIWa2HbB29HI+8MdhihkidV7frzwx1vR0xlVBWs/H06TKfMUTeXADDo6dOioKlTEUST24ETaZXRWdanlw60WiUM/AEbFTXzSzxSYh0ebhvWOn3tfHoPnnwNdjp3bv08Ze1FZL5SlD5EDZ3irKrj8ro27/MJaLrU4yTf7SWT52/GTPXJOZR7D667y+6Dq7XZ8WB44nWGb2c/e0Yuy45R3jRuCN7n5nPKOZ7U5Y0FqW4Hbrc8CRKdr06hR5x4gFZTdA1IsyvQ41xeNQlvvouwhkZjsAH45efsXd/5ag/LRISxNT8piw1t4yQGPSwqiFgVtOuxJ3JrhLhbBQdPIQZSxGdD8rx06l3ZUoHRXiOdLqaOuaUhknHW2RdXe3dG+sqfs66agZG6/CqTevmdmTtNdJVwPSzu8L37zWCzPbDXhd9HIBwbvl0ETGx/FQqKcPsd4hbRYFMg/mJVlCE1loige3AkI9r8LkuJVdPWbGiI/XV+6Zqzu11lIZZQghmsoyseOk8bqejh0PE/x4FHX+hBBfFmAp4AWEjvBFwOHAzmb2AXfvtc2s0/DjKWDPToMMAHc/P4qP25q4/LuZfSFpTF53vzxJPtHiYcoNbVJ2/Vlp7MJTy+tQN44Fjimw7qYs2qQtM17eSma2pLs/25kp8h7UCltyE+lc7SVGWipEZhRSb3S7Eg+LHZ/r7nm5id6H9trFbOD2NBdLR9NS9pjqCsL0pq6U/fkVhgyF09Vb6u5u6Z4oh/FyXz8kZc7vx2bzmpmtzmSPbd929yT9Rz8+BewYHT9GeECZCmlzWsoeU5Vdf1pmT3457xMw7bgR1j82fYBCPXcP9fxUx+uV6d3fQTDiaLHYc6l+1F1L66QqQlQM/XwG8ABhd0e39PU+1+VFvCNIuhUoHp5jGH9fhdfp7r92969F6Qvufri7bwm8nrCDZgvgEjPbq0cRnR3kGe7+zz5Vnky7A12WsANSZKbOxg9iOGrplq+MBZQi6kxbZqcW97qPzwMbE2adh7n7MwnKFoVT8iLAXYcOzpM7eY5JG7mIopB6yci0KzFyxfrm2KkfpC2jR7nLMNno7QR3V5xsIUZPmVo6FjraIu/d3WIUdBuLlT2mKrv+rFS9/bWc3zd189okorHj2YQd3QDXA0enLaejzDcTvAe3eK+7390rvxDZWGtwlsVYwGJGGZWnlmGgoCYe3BhxqGd3fxSIew/uOT+INrl9KHYqFw+bdUFPlcUQ9JpsVH3AXGWq/tmlnWwYwCJ3n90jFb0jESBex7I9c00mPtgfpo1l1AmAu18IvInwZZoCnGhmz+uStbOOSweUuxCIWx9u0yuvyIOHS6r3iSiVgYYiFaYpizZpy3y64/ViZUaxZD8avTze3Qe55ROF0Es/ShhXnXlmO4kCGWpMWjZNMXAbxDtoGxvfDVw0RBnd+BbtkHt309+tqkjNBNV6mDif5N1/3oyLgVstF8DHRUeL2t0tSqPKWiDGkEZuXotjZlOBXwAvj07dA+yTZQOFme0KnEa7M/yCu/902PJEP/TMKRmzWHy8PBvmdfm5zPvECNozcibMbI0eKUto+KRk9uA2RJ11CfV8bOz4o2Z2rpntYmYvMLOlzGw9MzuQ4AX+ZVG+/3P3nySovzEofIkYkngnuajLuaxlq7MVmbk/djzQxDTa3Rc3pHig6Dq75Bumzudw9z+a2W8Ju2pWBPZj8V2K93W8TrLrJ54nbYwv0ZXOUCFlGWO06l5QYv15UjfXgol4AHhpj/eKNnBryqLNU7T1PUmZS3e8nlRmZKF+IuHLdifBjakojQLHpOv8KLHni3NOaz+v2evj+VQvGkNTDNwG8e7Y8YnR7pxMmNlHaYdEWQC83d3LsiJtKK2x00TsdVnMpzljUpEzY6GjRezuFqOicx6at5bWaZ00z7ZWfX4/1GOVMuf3jd68ZmZLElz67x6dug/Yxd1nJS2jS5k7A+cQwkcDfN3dPz1seSIJRT5zagqzor/xqHJJnXo1gjLDQIFCPUOPUM/u/gszexfwvwTd3CNK3fgz8D/ufmqCuhuFjDLEEFR9UFxX9LnmzExg7+j4hQnybxg7vmeImLMAt9D+R043s5UTWC7G671xiDo7uYG2q9OturzfWUcS989yEZ07net6K7G4oUZWWmUOYh7leckYJ1q7u9NeE7wO5d+eRDRl0ebxWFlJyuxcRO8s87MEK3WA9+kBYZlUYOz0xBNw8cWcG4vO2St+WH2owOeaL2UufkNzDNx6Ymbb0HZh6uTgat/MDmZyyMP3u/tVWcsVgyjiwd8rgSsS5JNBRsWRoXCBdRaxu1tUgUaNpxJSF+OR0ihzft/YzWuRQcZPaU/F7gde7e63JqyzW5mvAn5Ne33gf9xd5ve1pk4Gbr2YQ9soYznC13MOzOvxGGPKFIKNwjGFtyw9Q6+Tls2w3tRaeloVD255hHpe7MGDu59kZlcAHwE+QPfB0KPA74FrEtTbOGSUIYRIQNpOshId5HWx4x0T5H9F7PgvPXP1wd2fNrOZwBaxes/pld/MJoAdstbbQVzXl+jy/h1MfvqfZFIUzzNnyHYlInIztibwPNqW6ANx9yQrvRWhNScdOsxwQgYZZLTeL/t5ct0nRI2mKYs299P+wa1FsMZOWt4jcctvM9uYdlzEU6LQUZVjPLS0AjzxBM/85Gdc2jcQmMiXCdKNSSeg3MVvaI6BWz/iXjIudvc7U14/CTN7O8GwozWp+KC7n5ClzCHaMOY6OsoHiWWFK+mkrmPStA8YZChctTqL2N09DNI9IRpPIzevxQwy9olOPQC8xt1vGaK9rTJfBfyGtv5/y92PGLa8LEibx9G4LSlzCOPoPj+pqWnHfCIBTfHglkeo58UePpjZmgQroLdFpy4GriWMjVcFXgNsCRwOvMfMDnf3Tk/vuVMlLZVRhhiCojvDuiyG1KWdY8uFhM5iaWArM9togIX0vrHjszLUew5to4z96GOUAexCCDMCcKe7X9cnb1JeFjtezPWUu7uZnUV78XwXoKebKDNbAnhV7NQfc2hjZx1rESwn9wI2Ir1Vj1Or/mwuwZo5ThnhS4bZMCba7E3wLtxomrJoMxPYOjpOex+d5b2AtsHbQWZ2UILyAE40sxOj48vdfeeE1yVm/LQUyl6geeYnP+Okk+CPnYHBRo7GpBWnKQZuXTGzpYEDYqcyLaiY2duAU2hr7Ufc/TtZykxR9xjqaCdF6MmgdSx5yBADaayOFrG7Ow3SvbzQQ8P6k9bALa2hcOuaUmnc5rWYUdve0ak5BIOMm4Zpb1TmzgSDjNZDzO+4+4eHLW/INkibCxmT1mXenDQ6xWyYOzccdjO+mFLzr0Bv5AkznzpzDfUMYGZbEYwwVia4dNnH3a/vku9twI8JxhHfN7M57n5ugjakoqpaWvpoQNSZRVSnM6tKO+pC83/6kTv5s6OXBvxnr7xmtivtQf/jZHvSeirtL+R+ZrZpjzonOtp0SoY6W2W+FtgpduqiHllPjB3vb2br9yn2YNqLSw8Dlw3dwC6Y2aHAzcAngI0JX04bItWM1tjxYUZrkDE/Sg8TPGSU7SVjnGjtSkyTSv9ql7JoQzCiSFRvwkWbkd/HqBlfLW1R0Jj0rkMXP3frrc+l006rgkFG3Wn+mJTJmjZqAzeIDNxS1psmpN6+wPTo+CEyjKOjxZlTaRtkfMzdvzlseSnrHlMd7Ra3exTMj6WmojWKHGmkjhaxuzsN46t7RVLUOmld9KQu7RxbWpvXINq8NiB/npvXWuw3IG/izWuRhv6MtkHGgwQNndnrmkF0Mcj4rrt/cNjyhmyDtLlSWlJ2W+YTnn23UsyY+d7ZMDtKc7o4ti7FS0aa+f3Q66SL3H12jzQKo4ymeHBLW2bfUM8xTV4ZWAjs0c0gA8Ddfwq0vA8Z8N/R+m5uVFlLx2IVTORJ6ytTdodUBer88xmb/99ngJbb+QPN7MjODJEF38mxU19x90e65NvZzLyVelUYWWO3ypsK/MLM1u0oawngm7Qf/P0L+Fq38szsO2b2ETNbpVedZjYRxd3+Zez0Je7+px5tvIr2gvkywLmdbYzKfT3wrdipr7p7bu4VzOxAwm7KabQ7un/RniQ6cCfBgiD+pfUo3R29f1debRoNnV4yRsUTsdTr33j16JrzHHlr6djo2yhoyqJNvLzXRrsnuxLp8z6xU533cT/BmjtJiu+QvCp2/oK+d5SS8dXScrjztKueS1feWXZrWkxQ73Fp42mKgVsv4qFLTnH3oZ6yRyFL4gYZR7r7fw9T1hB1S0dHbpDRopeXjFy7yoTEdXR+l9QUZCichKJ1NLa7uzXuzLy7Ow3SPVEMRYxJNb/PiyZtXos9/Gt5GWoZZKQxLO4sc2cWN8j4wLDlDdmGMdZmPXNqE3e89S+Cx+VWShhVvDQvGWPx/2uKB7e0ZfYM9RyxF23j6d+6+98HlHcC7d2iGwBbJWhDIqqupVq9Ew2iDNEfl8nGBMFDUdJUDWlx938AH42dOs7MrjezL5vZZ8zsF4SYVi+I3r+cHsYRKfk4YWcNwKbATDM7xcw+bWZfj947PHp/AXCIuz/ao6y1gP8B7jOza8zs+2Z2rJl90sw+a2anEvya/Zj20/7bgXcNaOO/R/kANgduMrPTojZ+1swuBc6PlXkR8NWE9z8QM3se0HJF7YSHpi9091UJ/4fwhvt67r4ysALwWsJOohZ/B7Zx9/XyalfxrE8In1YGc2NJHjKyc3bZDSicpizauPttwB+il8sCH+tT97uAtaPjO+nwue7uN7v7IUkSwSK7xQ9i7325T/2pGF8tjTPCsdMVV3DaqTyXevFuK/3hVQ6M6nNNW0/ah4mV+F80xcBtMcxsAyaHuRsqdElkkBEPWfJJd89jTJ6kbunoJEY1j1tANcOW9Lv/Jhlm1I5G6WgRu7vTIN0riiqu51WxTVVlmM9qSspUCZqwea2XQcagB4A96WaQQXvddiSMrzZX4xlC9Wg9/55LMMRopWH3Sh6TvUm5Y6TX0UrM75viwS3LfXQrb/vY8d8GFRYZdcSNkZO0YSB10NLKjAhE1ekVWy9tzD0hRou7Hx89uDuOYDGyFd0t734FHOTuz+RQ50NmthtwBqFDmgYc2CXrI8B73P03fYpr/cCWALaNUj9+CnzY3ftaXbr7/dFD1FMJD1KXAd7eI/tJwL+7+8IBdafh3YROz4GL3X2ffpkjDx2XAJeY2f8BvwBeD1xqZtvl8X8bDVvSNrKMhy1ZieLCmLR291XZECPvvmQR1ZvYtSYbaa8pnc8AbwGWJCza3ODukwy00izaAP+v9drdu96gu99kZicDh9BetNnd3Z/zSxAt2nyDBIs2EUfRDr90lJnNdPfTO9q3C8EIrsV/5Kx7RTCGWlrSmPT3f+Ca027nNj2TEylx9yfM7Gxgf9oGbgd1y1uAgdvRhB/Hfmb2hW47sDOG1DuUdmd1zTC7E3sYZByXtpwMjKGOQjnz+JaAVtEYI04/oW+9l9Qd9CjGpM1fj2mSjhaxu3sIxlT38qafjo77Wum43391cfd/mNlHaT+wOs7M3kFwUTWPsF66B2H+D/luXtue4EK+tXntl4QHjSsSNHGDKO+gzWvH09ZQgPOA10fefgfx/c4Homb2QiYbZMwGZgEfs8HG9n9397zce0mbJ1ElHSlrjXEOwSgjTmyc+uAceHIePPlECFUyN8q7URfb1XnzFg8+IYalFA9uZjYT2CJW7zm98if04HYdcECsvEFaP+g+lo83eUBZ3cjrB195LZVRhkjBRILjMqlKO7Iyio5+vFyCufu3zew84D3A7sA6BAON+4FrCK6W+xlGDFPnXWa2E/A2grHD1sBqhIWhO4BzgRPc/f6ehQQOIOxAfBXwEoJV4moEI4p5BMOOmcDvgTM8RfxZd59lZq8gPHB9W1T+6gSr+XsJO8R/4O7XJi0zBbvEjo9Oc6G7X2ZmexEmh1sCX6T/zveKsHf0d53o70od73e+zou5BZWbJ3XUor1jxzX4+g1JQxZtcPfLzexrUblTgNPM7P1RexcCLwd2o/1w8XTgtBzuo2jGUEthZGPSdX4Edx0KZ57JX658kpPOz7f46jPKMWnjaYqBW7wdS0Rlt0jtJaOLQcZRIzbIgLHU0YmOv/2Ox42nB2cBwoJ4GXG6uxH/fyUZU8tQuCwdLWJ395CMoe4VRT/tzFNLq/RwMgl5t7WKY9IJ0vcD1ehfG7B5rfOJ8ztTNOXnQOcu9TWZ/Lh6DcJnk4Q8w5OOsTZXfUxaVjv+1eVc5BFy1kyYPRsemRuMMwCWi5xddzPKePyJERlljMUzp5YHt6WJPLi5+6198ufpwa1llLEffYwySB7quTVmfa2ZTXf3ud0Ks8GhnmHyF3bLPm1rlbkksEns1H2DrklI5bVURhkiAaPueOo02ahLO3uR9H/bchWdlEos2kzC3W8n7JQ+asjrLyPljbn7IsKDvdMH5e1TxtOEzv7CYcsYUP4iwsLQz4oovw+tQcScAa5dJ6I2TsLdrzSznwFvBd5tZkf7kDHMm80TVNtDRpFU0VtGPWnAok2LTxAMOI4kPADcKUqd/BB4v7sPY9k9asZMS8v5TZ9z2pNc+pfkjut/WMpXp+5j0qTUc0zaFAO3DnYnLFpDGGyckaZhkWFw3CBjJrDQzD6e4PKr3f3qNPX1Ycx0tAxeCVxM9T1kpCWpYcYox6TNHfs2REdz3d2dAene2NBcTRDZqPnmtaYyhtqsZ069OZveKxDT4dZbg1HGA3O4d1aISLRgYRh+rLvDLNhss8Uvu/UA2GhUe4+S/G/Tzu1b15RLUzy4ufttZvYHYDvaoZ57ha3uG+o54prY8WvNbDPvH5rvfbS9a8wD/tQnbxoqr6UyyhBCCFEGzye4kbqty3vxFdtlgCd7lHEuoYNcHtgZuCjH9uXM9BLqXAm4h3Txr3cYnEV0YXqCPPWcbLRowqJNZGRxtJmdARxGsJ5ei/BAcDZhUnGiu1+Z530UzJhpaQmcfTbnJnAwedfgLDVFBm550SADtxbvjh2f6e5prUA3oG2QAbAZ8NUeeTs5FsjLKEM6KkRNaICO5r27e1ike5nR2Gj0aEyaNzXevLbzsNf2KO8yqrH4Im0WMfqt5c4JBhnz5/OPm55l7lyY/wxMXQqmLUPwitFi3rzw96l5BbZ1LKm9B7eIPEM9X0TwvL4mYZ7/KzPb293/1pkx8pgZb9cPcwwTUnktlVGGEJkoysJSkw3ReFr9z1Nd3ns8drwq4eFrN+6OHa/TI88YczPJvGTEB/qXEcYaTUFamid1XbTpUuZfgQ/mVV6fenYuug6kpYVz/mmLzZm70m22N1rqtOtnfGmCgRuAma0GvCl2KnXokgohHS2cvLx6l80CFl9Cq6K3jEHIUHiIOpu2u1u6NzZUSXuaiB6riFyRNhdOQ+bL1weHAs/OfpDZs+GJx2HBQpiyBMyY0ZH3kbnh7/xo7Xek3jKaS0M8uOUa6tndnzKzfyN4A1kCWB+43swuBq4lPKRYlbBBLh7e5Gbgv5J/BAOpvJZq9CAqyLAdpCYbQtSIucAqtN1UxXkwdrwhvTvIeDS8lfNpVpN4OGG+KriS1sNEIYZkLtLSwni3DX4INZ/wFCjuKWMJMxbWIvpNUqo0xq5n+JI4TTBwc/cHaC8wDVvGScBJebQnI3ORjlaMMpepliaEiO5F57hZS2plUFcdHZHBbhLmIt2rGZorB6o0JhUid+Yiba4oZWjPW4Ezu5yfA9dfD8DMmTD7Xpj/bHCIMWUKrLoasCAar86fD09WOaR17Q2F6+7BrUVuoZ7d/ddmtjdh08ZqhB/OblHqxiXAwd08iGRgLhXXUo1khBAJaHWSSVN1OkhRWW4nfFG6WRvG3Vq9pk8Z8QHC4z1ziR7MJ11oE5GNtDoqLRWJkJaWyHyCh4zyvWQIITIgHa0UMnIongnSj0m1dNgwpHu1Q79BIcYAabMYilnRY+UFC4K9xrPn/xbund32kiEKw92/DWwBfAW4gWAQ8DQwC/gp8CZ337Oft4oh6ryL8Fs/gGDwcTdheeoh4E+E0CqbufsvEpbn7n408BKC54+bCPoxj7Dc9SPgFe5+mLsPfJDg7r8mGDy8h+A14w6Cl4yFhM/nBuAE4NXuvqu7z05048mpvJZqVCcqiL6WQowB10d/VzezTovD/xc7freZrdp5sZmtA7w/dmqx+GRiEAuohpcM0M4fIYbm+uivtLQAfjjA28VdsSSEqC3XR3+lo4L+XjJ6IUNnUTuuj/5K94QYGhm4idy5PvorbS6MOv0Gu3nJWJw5c8LT/1kPwD0PwMx74bzzgBv/Dk/NK7KBIsLdb3f3o9x9K3df0d2Xcff13H3/JJ4q3P0yd7dWSljnInc/PTL4WMfdl3L3ld39Ze7+uWFC6rn7X939g+6+mbuv4O7LuvsL3f3d7n5lyrKecPcfuPs+7r6+uy/v7lOiz2crd39v5LmuCK6P/lZWS+ukREJUjEXoQaIQQxPvBF8ffyNyR9vq7J8PXG1mB5nZplF6L3A1IVYawL3AVUU3uH7s0Oe9Ki0cS0eFyIC0tERuI4QuKZ9xGpPKe5vIHelo4bx+cBamUL6XjGEMMqpi4CxEKqR7oiDGaUwqRO5Im0VEP4OM9tjzicdhzlz4F3Arwf3AbcCtt4Jf/fsQvqTSGO05QNKk+b0YSOW1tOxZrxA9mEAD+SpR//jdZrY+cBjwBoL7oqWB+4BrgJ+4+3kF1DlBCAL3dmBrQiytxwhum84FfhDF5E5S1hoEN1IvAV4a/V09lmU9d581RBtfB+wPvAxYC1gOeBKYDVwH/AI4x90Xpi17ABcSVj6XJrjb+knH+x8Ffk+IZbYevWOOO/CJAtrXcLSAPHrqHStRVBZpacH80J132+K/xbuoikHGKJAdv2g00lHRg6aOlzUmFdK9eqJ1UiEajrRZ9GA+IZIEwFxYbjm45x5m39fOkXjUOjXtGFCI2lF5LZVRhhCi8ZjZB4CvAst0vLV+lN5uZmcD73T3x3Kqcy3gDGDHjrdWidK2wBFmdpi7nzWgrC8Dn8yjXbEy1wROA17Z5e0VorQJofP6m5nt7+4z86rf3R83s/+M6lhkZtPcfV7s/T+b2f7AKSz+f2uxCDjK3c/Iq13NYweCgWcdKGKRSQ8S86Tuxm2xMrcE3g3sSjBGW4JgiHY5cJK7J7KCNrONgN0IOrpFVNYyhBiJdxCsqU909xvStC8N0tLyuK3sBgghckE6OipeD1zQ4726L0stoP73IMYJ6Z6oL1Wa39ffwK3u8/u8N6+Z2VTgRbGyXhK9XjLK8mN3PyRpeWmRNo+KOhq4zaVtlAGsvQ73XnjjpBxzor+LxWLoZNWBOYSoNXXQUs0chciMHiRWGTP7N+A7sVM3EFYE5wFbAXsQtHBv4Cwz293dM/n3MrMVgYuATaNTTwG/BG4huD/ai2AMshJwppnt4e69VikhTIw6eTi6fpj2rUB4+LhB7PRVwF+ABwiTopcA20fvvQi4wsy2cvd7h6mzG+7+9QHv/9LMriVYMO5GmCQuSXh4ehnwzSIfdjaXQV/vy4Cdi2+GqBV1N26LyjPgs8DRBEOMOC+M0mFm9n3gcHd/tkc56wNnAVv2qGrlKL0M+IiZnQR8yN0fH9TGYZCWFk/cW8bDBBW9q9QW9aOOi0zjRZ0XwM1sC4K2vZQwjl6VoHfLA48Tfhp/BM5w90uHaKcBbwTeTBiHrk74fOYQXIdeTdCtC3tp9DBIR6vKxQT7yVGzNL1DmXSOo5M+kNP8Pk/qrKNRWYV4wUyDdK+u1GmcV6e2jh91n9/nvXktWid9kPSWNrkibRaTeSthk/9cJvnC2Hgj/vXQ+UD4ws4hhDABmAYseBbmPQnLdha36qow7bhCW5yO+hu3iWpSdS2VUYaoMFUfwBe5sLKo4PLHAzPbAPhm7NTR7v7ljjwvBs4nLKq8BvgY8KWMVX+NtkHGzcDu8UUVMzsS+BbwfoIOn2xmG/aZ6DwC/Bb4cyu5+x1m5kO275O0DTIeBPbptjPczHYGfk6IsfV84FjC4tfIcPe7gSNGWWdzaS0iV80V87ho3QTpJxvV+GwaYtwGQdvjCzdXEwzUFgAvB15LmOG9F5hmZge7ezedXZXJBhkPEmIS3go8SuhPXgtsFr1/CPBCM9vV3YcJWJ8ZaWl+JPWQcaQZX+369SmCuFZUeeycB2m1tBo62qLuC+DA9Sxu1NZixShtBbzHzC4HDnb3RDZMZrYN8L8Eo49O1onS9oSx+nrArCTl5oV0tAyWG3F9cTv4pOPl+bQ1KX7cSZXm96343WmvqQZ119EivGAWhXSvKYxSf8ZpTFpfLW3I/D7XzWt0n2QsBJ4AnjdkmYUgbc6Dqj9zemvseC6LjUunT2f6dJgWjYRiPjT4FzBnPvzrIVj2kbmw4vQQsmTJqTB9ZcJP//CiGj6W1N1YOFZmLl6F+5S/LKG/WT92+l3uflKWcoelTC2VUYZoGFVa7GgSE3Qf7/bLXwk+S3tQfVqnQQaAu//FzA4mxJsCOMrMvufuc4ep0Mw2ITyAA3gW2Ldzl4u7LzSzDxImOzsSFnI+DnymW5nufuwwbenDW2LHn+zVqbr7ZWZ2FHBCdGr3nNshRkrSxeVRL4C3KGJCpD4hK00xbjOzV9BeAF9IWKg/tSPPrsDZhA0FBwLnAaf3aN8igtHaCcCl7r7YF9jMDgO+F7VvR4KHjv/qd9Oi2txFMqOMbSl5i5WoJA1ZAG/xT4KBxh0E4+FFBIO1lwPbEZ46vAq40sxe6u5zepTTaucuwDm0N3Q9AFwSlf8UYQf5GsBOJPDKK+pEvyWpaYSv2vp98hTBEwnz9TPCEEXQEB3N+0GiEGOE5vdZacr8nvw3ry0C/h4vjzDW/QSawwugHP35fM93Vn4+rLU23HADzIuNdOYRzDjmzoV175sdjDJWXRWmTAGmF9nYIaivcVuLuhsLR+Xl4lU4AV9m9BO7SiKjjBFgZlMI8cZ3IfwoNiW4eV0EPESYSF5EiE02t6RmiqGpsmXl+GJmyxFcHwM4oXPpirtfZGZ/ICwir0BYxDlpyKrfQXuU9nN3v7FbJndfZGafox1c+SB6GGUUwIzY8dUD8v4udrxy/k0R1WIKwSjjZkLoNZEvtRx2NcK4jTD4b/GVToOMqMyLzewI4P+iU180s592Mbi4E9jM3W/pdx/u/gMze36s7n8zs2O7GXCIenAbgwNAAew5FV7fKDNGLYBnpUEL4AcSDNF6GlmY2baEB5ZrAmsTNPDQPvk3BX5FWMiaDxwJfK/bYk+0YLQNwUORqDWDxkRTqd7CcZzO3mABNR3n1YYG6WjeDxKFSIDGcuI5GjG/z3vzWqTZL+o8b1atB8Bi3Oi9uW7Z6UuyxhrPMm0aMH+ySfECYP584F9RUJNpaxTYxvGlIcbCkJ9X4X7tfiXwgejl2Fu2a0RWMGb2Pto7fT5FcP+yJrAUYeFpLYJrm28Ad5jZQeW0tEnoWYcAQjyo1i6UGwY9PAN+FjveJ0O9e8WOzxyQ97cEA1aAGdEi0ih4KnY8yNBildjxnXk1wMwWRuk3Gco4KyqjavE4KkiSMV/LIEOIQFrjNuAP0cuWcduwJDZuAz4XO9V1DBUt4u8QvZxHWFzvxY+Ae6LjGQSj2s5670vQp7T4Lu2Z9KrAhgmvS4S0dHTcT/CU0Y+dorTvfrDSSnDnoVrEy59W3NmkqTL/g0QL4MDBsVNHmdn0YStMugAOfBBoeU1rLYB3xd3PGOT1wt3/CLwvdmq/yL1qtzZOAD8mzIsd2Nvdv9Vr940H/uzuT/ZrQxqko1VkOeplkFE30upoZbS0KTp6rLvv5u5Hu/vP3f2OYds3LNI9IfKgflralPl9U5E214EKPXNaairzn4GpS4XV3Hmx9Bzz58Ps2dELGQ/nSQ9j4a3c/ZPRWO/NhM35rRAiLWPhrHQaC2/m7ge6++fc/QhgI8I6JLSNhVfocx+dXoUPdPcd3f1T7v4Zd38d4Rlba/59ILB/mgab2TTCWqsBlwK/T3N9WuqgpTLKKJ4X03ZD6MBM4AfAsQRrz58Q4v1AWHk4ObIMFaJC1HIBfJvY8ZUJ8sc9QgxlHGFmSwGbJa03mnDEPVWMyigjfq9HWA/T72ihPL6gdHKObbCOv1nKqcQXrtoMGkNMIyyAx40ybi6uOaIuNMW4LV7eb939kV6FufsCIO7eL8t94O6PE8J6tnh+lvK6IC0dEYMMMgD2XD6kqWNt8y86GdMF8Etjx8sx2cg3zpuAl0XHJ7n7+TnUnRbpaKVoGWRMj51LosCjoJcxRt2NNKrPmOpokUj3hBhPmjK/byrSZpGKeU+FqCRTmWyUMWlkeu/sbpdWhPoZt8VohLEwCb0KA0fETn2x16aLHnwJ2IDw9XxviuuGpfJaKqOM0fAgwQhjA3ff3N3f4+7HRBZMBwHrEmLotviamW1cSktFhaiQ9eVwTJjZGj3S8iOof/PY8T8S5I+HiV+7nxVhHzahHXtrrrv/q1/mLvVu3jNXvnyBYP0IYXHrcjPb08zWNrOlzGwdM9ubYFTSmjz9GjhuRO0TI6fTIEPkzwTpJxulD9OaYtw28vtoEd1P3CORXO43lG2BffcNSYgOxnEBfKWO1091zRXc/bf4XsY6RW3ot1NvOsFYuI4soL+BRu3n92UyjjoqhBB505T5vRBjzuSxdDcX2Jdd1u/67/R7UwygKcbCeXsV7lHHTsDh0cvPuPvtSa5rOqWv9o8BPwRmREYYXd0SRjHZ9iPEHYLwJGYUVkMiF/Qz6sFqwL09Uh7umgaxeuz4np65IqKd03FXyKsVXWfE3T2uLwx3v4YQ1+zR6NQrCIZhdwFPE8KUnAVsD9wEfBjYM2vcswJoGcAs7Jtr7NlhwPtTaHYot9ovgJdp4NYU47Ys95HVWG4f2jPm2UAVJyDS0hzYdxTmpgJ5b0tGBRbAPxE7vi6K0z2JqI2vjl4+CVxnZsua2RFmdo2ZPWxm88xslpmdbmZ7ZGxTkUhHE/H6Ae9PpRoGGb0MlZsyXq7lrsRx1NGqI90TJVGV+b0RpnlpkoHm91XdvNYUpM2N4piO1y0tmQrb7zDJQ2frnZXDu9z1JDw7+0F48dYodEnuNMVYuFCvwma2DMGYYwK4FvjGoGsqRKFaqqfJBePu17r7vAT5nmXy7qDti2tVnRj3r2iVJhu1WrQBiE9mksadjv9Wh5kMlVHnUETuoTchePF5pke2Z4BrgN+5u4+qbSloGbE8Xmorak9VPGSMu973pEwDt6YYt6UtM17eSma2ZMJ2TCKagHw+duoEaWl9+Vuff92GwJ57jq4t/SlKS6syJh0KeW8reAHczJYws1XNbHczOxf4UPTWIuDoHpdtQ/sp9z+jOv8KfJ3gfGZFYBmCV8n9gXPN7GIz6/TCUQWko4kZ5CWjbnTarA/yllFr9CAxXb1Nf5Ao3SuNusyb69LOkaP5/WBGvnmtQUibG0trQ100fdpxB6ZPb7/bemeN6PUTwB+vATbbcnRNTE0tDYWhOcbCRd/HF4AXEkKtvDsKrVIXCtVSmUlVi7gnjbxjjteUuiwAT1Cfto4Ny8SOk66MPR07HmabVhl1DkUUw+xTwKHAUsDvCR3wI4RF8J0IxmGHAAeb2Wfd/dhRtW8QZrYpYQDghIV8MRRTqI5RRtNpTTbSXlMqwxqaLdvl+qLr7Hb9sGV2GtMuDzycsC1xvkWImwhhYamfK8BSkJYmZwnr/ntcCdgTJu1SEZWjtfjdjWNZfAtS3qReADezJ2lr6WrAYp4m8qwzItUCuJmdAbytT5aHgQMil63deGHseBpwAfACQqiTc4EbCR3nTsDOUb5dgEvNbDt3j4+hS0M6mgctAZ1eZiM6WI6wnN3JVCZP81ptn0/6cV7tKFNLG6mjdUW6JwRofl94nd2uF32QNjeVY6IUM8gAYCrP23AV4EGWI0ympgJrxXIstzxw60zYaJAH5doxYWZr9HjvcXcv2igps7FwN0+SA6iVV2Ez24HgeR3gK+7+twTlV4JRaKmMMqrFmrFjxRwXdecB4KU93huFxW48dnXSmdLSseOBHm4qUmdqzGxt4DJgfcKC+Z7ufmmXfK8huNhaCTjGzB52928PUd9n+ry94YD3JxVFMHzZkOAqbAlCB3lF2jaNFxf3ON8aslcJGbhVjKYYt6Uts/NB3zRSGmWY2UeBw6KXC4C3u3u3pztpypSWVoydCB/ivruX3ZJxIu0CeOmL3zB+C+AOHA8cPUD3VowdtwzYbgTe6O53xjOa2e6EMemywFaEGLlHpm2YdLSq1NVAuGrj6KToQWLBdXa7vjSke02kTvNlze8rRlPm97VH2izS0fsR7nLLhpAlaxBGd/Gc06YBF1/cRKMMbbpIRuFehaPoD5Mws6Vphy25ickehHOlrloqo4xq8dbY8e965sqZyNVktwnjkosWafCcHE02Oljk7rNLrD9u+LFsz1yTiQ/2hzEcKaPOYTiFYJABcGA3gwwAd7/UzA4CfhOd+ryZnTSExekxhI6sEyMswv9XyvLiPM3k0E+lUS8tbXnIqOti8lhRpoFbU4zbnqKtyUnKXLrjdar7MLODCe73W7zf3a9KU0YPjqHhWlovHYU9l4fNNoPV++yFvfNQY90fjTpqjcakFaOpC+A/Af4UHS9F8HLxSuBFwOHAzmb2AXfvtZDR+Vt/imAofGdnRnc/38w+SFjcAfh3M/uCu89N0M44x9BwHYUqa2k3Q+GpVMtDRl6MheeMUdJUHR0FxzAGupc31dXRLCxCIUUqgeb3xddZB45hDLS5mVpaBp8Gjuv6zpQlw0h6LdoBTqYAG0W/tkdve5DnMY9qjkuN9I+nSzcUhuYYCxflVfjzwMaEgcdh7v5MgrKH5RhqqKUyyqgIZrYb8Lro5QLaC06j4GP0+II+8MADI2xGnmiykS8TpOu8K/HZ3x87XqtnrogonEfckGKYL3+qOrvkK/wHZ2YvBV4VvbzZ3c/vl9/dzzOzWwid6QrArsBZw1Sd8nwS5hBikt02MOdoqJGWyiBj9Ay9K7FMA7emGLc9HisrSZmdi+iJ78PM3k4Yw7W07YPufkLS65NUkfJ8EqqkpbXR0Q2BPfdU2JKaIO9tBdTp7r8Gft153sxeRzAA3gK4xMz2dfdzBrQR4Ax37+ce9GSCh4w1CVq+M3D2oHZ2oek6CpXV0l1Z3DBjOsmWpe4C1sm7QQNIGsJkbNCDxOLrLIpx0L28qaiOiuow9MNEze+Lr7MujIM2N1BLy3rm1DkUmQtrrMGqqz7IjHvDywW0R65rRP74n7fO8xjTcWuRNMVYOHevwma2HfDR6OXx7n51gnKzUjstlVFGBTCz1YEfxk59292TxPERQvRmJrB3dPzCPvlabBg7vmeI2F4At9AenU03s5UTxPiK13vjEHWmZfvYcdJ4XjcQjDIg2WfZyY+7nHsnwZJxNr3ja3SyiGC5eT9wHXBJNzdZopPOBfCWl4wk3EwIWyfGlKYYt91P2y3fWsCfU5T3SFKdMbO3ER5EtuI8fsTdv5Pk2oRISyvEvsggoxyGCl8i722jqRMAd7/QzN4E/J4w6DjRzNZz90f7tBGgq+e2WLkLzexy4IDo1DakN8qQjlaKOnrJaK1XDtKhKncQepBY4TqLQLrXOLJ4RNMGtjGnKfP7JiBtFtl4YA5svTVbb/1XAFa9F+65F2ZG/g6mLgnTlgG234FgrtEotOkinzpz9SpsZksBJxIGGncCn0rWzEzUUkvH2ijDzL4E7JNjkf/l7j9N2YZlCItJrQHH9cDRObap5sj9shia62LHOybI/4rY8V+GqdDdnzazmYSdga16u+0MBMDMJoB4YLeh6k1J3DXVMP7UU/8g3f1dnefM7J3R4d+6vS+KpK5xu0UJNMW4bSawdXSc9j4SGctFBhmn0jbI+Ji7fzPJtUmRlpbLQneWsGBovxKw5+7Jry0nhImoEGO3AO7ufzSz3xI8Qa4I7Af8oCPbfR2vk8SxjedZeYh2SUcrhcakIjFjp6N5Id0TQsRoyvy+9kibq0CdnznNhafC8/Dnbbkum82/kxkz4PrrYfZfYG6Ua80ZS8LLt41eVdEwo5YehaE5xsJ5exX+LO2dne9z924uB3Olrlo67uaxLyDs/s4rrZimcjObCvwCeHl06h5gn4Lj7HTj6wQ3sJ3pb6utttqIm9KNcf+aVoFWJ5k0VSK+14W03SptZWYbDci/b+x4mPAcLeJGGPsNyLsLbd24092v65c5J+KTny0TXhPP17mAnoVKfFFypMJaumuUxtoWs2TS6mgltLQU4zbCYlGiehMatxV6H1HIkrhBxpHu/t8J6smL0r8oOVJhHQ2GGQvd2RBYffWB2YVoEde0US+AQ7QAnrLePBbAb4gdb9Xl/c46klguFWXd1CQdhUpraWtMuhwal4oUjKuOFknTdC9vKqyjENZJtVZaLprfJ6Gg+X2TKf1LkjM10NIaMndu+3j6dKYtA9Onh7TZmrDRVFhnHWC1VctpX/NpirFw2jJ7ehU2s40J4YoATnH3CxO2sSgqraU1VZ76Y2ZLAmcCrX129wG7uPusUbfF3R9399mdCXh2YqIqX5GqtEPUhcga7+zopQH/2Suvme1Ke9D/OMPFp25xKu3Fm/3MbNMedU50tOmUDHWm4ZrY8SZmtlu/zJH76Y1jp67IoxHuPhGlN+RRXhWoh5ZqR6JIRVOM2+LlvTaaEHXFzJZgshe1vvcRGWTEQ5Z80t2/NqDNudE0La2HjsKeVfZKL6rIuC6Ax5+4L9Hl/TuYHIM27ULQnGEa1UnTdBTqoqXbUe0QH91oSjxuPUhMQkV0tBCaqHt5Uw8dFSI1TZnfN5ImanM9tLQq7UjKE5ONMjpY4wWw5ZYwY8bIGjSONMVYOMt9dJb3Atpz/oPMzHsl4FWx606MvXdZgjYMpA5aWjfVyRV3P8TdLcf0v0nqjQwyfgrsFZ26H3i1u99a1L0KMaZ8BmhZ7R1oZkd2ZjCzrYCTY6e+4u6PdMm3c0cH0hV3vylW3lTgF2a2bkdZSwDfpL1Y9C9gJA/x3P2vwJ9jp041s1d1yxsZq8Q/m1+5+91Ftk8UzUuRYYZISlOM29z9NuAP0ctlaVtvd+NdwNrR8Z30MUTrYZBxXJ+yRUPYd9BSoiiQCdI9SKzEdHdcF8BfFjteLDSJuzuT72+XfoVF4+f4mPWPmVonKkCnB1whejKuOiqEELnRlPm9EGPNvMHP8+tjkJF2bl+Z+X1TjIVHfh8iIH+RIyZmkNHahfkA8Bp3v6W8VtWBusb4EmXi7v8ws48C34lOHWdm7wAuAOYRXCnvASwZvX85+RhHfBzYnuBhYlNgppn9kmDVuCLBIGuDKO8C4BB3f7RXYWa2CvC9AXV+18zmdZz7jrtf1iXvvwGXER5OrgxcZmZXAVcBj0RtfEV0Dy0eAD40oA2FYmbrAasBD8uIbVhuLrsBCahzXMd+GOmHXaXvSoRg3PYWgk4eaGY3uPtX4xnSGLcB/6/12t273qC732RmJwOH0DZu293d74yVtQTwDZIbtx1F0D2Ao8xspruf3tG+XYD/iZ36D3df2K2wLgYZR9XFIENamp2pKTd3r/ujoiIuiDrg7k+Y2dnA/rQXwA/qlreABfCjCR3rfmb2hch4uLPO3BfAzey1wE6xUxf1yHoi8O7oeH8z+7y7/7NH3oNpe8p4mLamjxzpaB7cVXYDUjLIS0bdvH7Ui3HU0aoh3WsKZTzM0vx+8jWl05T5vUDanA910qf58Mjcyac224xl586FBQvYbP69zH+m85pphEcgIkdaxsJLExkLD/j95WksvEV0vB+TjYc7SepVuKWzrzWz6e4+t1thCbwK3w/8uE974ryeoFsQnkXdFh2X9tBi1Foqo4wREgtZsnd0ag7BIGOxSZ2oK02ebCydMn81cPfjo0WS44g6S7rHtf4VcJC7LzZ8GaLOh6KwIGcQDBumAQd2yfoI8B53/82AIpclTJr6sXuXc7/u0b4/RYvlJ9N2PbUjva0i/wIc4DmHVzKzl9JeFbg22jHZLd+ehEHCBrFz9wGfT+qhSAzLJmU3QJRMU4zb3P1yM/taVO4U4DQze3/U3oXAy4HdaHdgpwOndSvLzF7BZIOMmcBCM/t4gvu62t2vTpAvMdLS0XLnodUZ4/SnqWPS2lL7BXAz+w5hweRUd3+wR54Jwpj3+NjpS9z9Tz3aeFX0oHVvYBngXDN7Y7yNUbmvB74VO/VVd89tdVE6WgfWKane5YAnerzXzxBjfoI8ZdEKX5L2mtKpvY5WCeleE9A4T6SnKfP7AjavYWYfAF7dcXqz2PHOZvbzjvfnuPv7B7QjMdLmOlCWp4aPwPxPwbMdhsJTp8Km4Wu6CsD8+Tx5x4MhwsmUKYThS5WNMur3eLopxsLufpuZ/YEQV7LlVbiXB6W+XoXd/WbCeHkgUZiSllHGD9z9pCTXpaHqWlq/b31NiQwyfkY7ZMmDBIOMmb2vEsNTCVdGoiK4+7fN7DzgPQTjhXUIBhr3A9cApyQwjEhb511mthPwNuDtwNaEDudxQgztc4ET3P3+POtN0b7fm9kWBCvHvYBtgNUJnfCTwGzgWuDnwK/dPdcZv5ltTnA77YTOcbse+d5KeDBqTF4NXAM43sw2dveP5tk2UQX0MLFKNMS4DeAThAWeIwkGFTsxeSd3ix8C7+81aCcM1peIvd4M+GqPvJ0cC+RmlCEtrT7ykpE3aR8mVuJBYlMWwNcCPgB8zcz+DPwVuC9q/7JROa8mxJNtcTthAacf/w68KLp+c+CmaJFrJuGfvROTF8gvIrnmDkQ6KvKhtbS2oNRWNJmG6GghDxLTIt0bV8pcJ23i/L62Bm5Nmd/nunkt4mUDylw3SnHu7JZxGKTNYmhmzIClpsKCBfDsfJadehsLZt4Lyy1HGKNOY7DXN5GSphgL5+pVuArUQUtllDEC+hhk3Fheq+pGnQbwdWrr+ODutxM6mqOGvP4yUs6gIkOG06M0NJGHitxnb9HE6owojZo3xI6/3y2DmS1H2Gk5QehIF8sCfMjMLnT3C/JvohB5Ut9FG2iGcVtkZHG0mZ0BHEZw57cWwcBiNsHS+0R3vzLP+ygYaemIWfdHLm8ZYigasADe+jItAWwbpX78FPiwuz8woI33RzuITiXsIlqGoPndOAn495wXgaSjYgh6jek6l9jm98kr0tIAHYViHiSmRbrXCDTOE8PThPl9A5E2l0KNtHTqF+nqjGCpjrHmhhvyvJVXhu1bDho0Fs2bphgL5+lVuEJUXktllFEwfQwy/l5eq4RIywTpOnB5KhEDeXnsuNcC0yHA8wmd41PAB4FfAisQFuLeRugkP00Y9IiBbEKJIdpSUqOJ0ZhQZ+O2jjL/StCTYa8/ifBgsApISyvOnYeavGWI56j5AvgBwKui9BJCCLzVCEYU8wgPJGcCvwfOcPdbUrRxVhQa6i1RO19C8OD2LHAvwWjuB+5+bdIyUyAdLYV1gLvKbkRClgMeznB9fGdimpCgRWGkXwqsjjFizXW0Kkj3xpJFaK1OxKnz/L6IzWvufggJ3e8XhLRZpGfJHs9rVlkVVmtF35lCNR8Dp33e1LqmGjTEWBjy8ypcFSqvpVX8NTaN42kbZACcB7w+ios7iO+7+2PFNKuOtEQ3yUO6sicbepgoxAA2jv7e5+5zeuR5W+z48+5+YnT8qJkdCGxJsArd3szWdPd7C2prw6iTYYYQYgDS0hJoGVnUw2NG08ak9QxfEqeuC+Du/jRwYZRyJ2rjz6I0SqSjpZHGMOOuKH8V0G7DsqmrjkblzEpbdwFI9xpDmnXSsmnimLS+Bm6ikkibS6NOz5w6WHZa+3jF6TA/MgbeeusyWjN2NMFYuIFehSuvpTLKKJ6NOl6/M8W1PwdklCGEaCJrEqwRu8ZfjNxItSwbFwEnxN9394VRHLUvRadeQthJKRKR1DDj5ihvWTRp4abe4UtEZZGWCiFENqSjpVIXjxkrkc1bhhCVQro3tlTsYaIQIo60WQxmxkkw65Bw3OklY401YOpUmDIFmAE8MdKmjSt1NhbuKDOTV+EU9exccBWV11KNxEQN0ddWiAawbPS31whxR4LhoAPXuPtDXfLcEDteN8e2CSFEXZCWlkjSsCTle9TQ2FmIPkhHRUbqttepZSicJpXdj4mcke41jrqM9erSTiFKQdpcOjXTqCldxqDTNoOpWxOiWlQdjUlFIVReS+s2e6wdI7D8GXPineWiHufLIo8d3lW4D2iCq2hROVo/jmV6vP+K2PHlPfI8GjteLnOLxpZOTxg39zgvhKgg0tKKEDfQiBthJDXcqD4ak4rGIh0tnZa3jM7wJHd15KkCvfSndX7+qBoiRBake42myuukTUKeMEXuSJsrRQ20dKkODZq+BrBG9GLeqFsjRFWovJZWSEWESEuvr6++1kLUgEcIM9L1ery/a+z4dz3yLBs7XpBHo0QTqUqfMEF6C/CqtF1UGGlpBeg0vGiOIYYQY4F0tPJUxSBDiMYg3RsbmjifbOI9CQFImytEXZ85rVp2A4SoApXX0qoriRAp0NdZiBoxM/q7hpltGX/DzNYHXha9XAhc2aOMF8SOFeR5KOQNQ4iaIy2tMDLOEKIWSEcrSx2MMaaQfKf00kU2JAUyFBbSveZS1weJdURu90XuSJsrSw00dPp02l4y6oIRxtJpknRUDKTyWloDRRGiG5pojJa0k43qdZBmtr6ZfdHMrjezh81snpndbmanmdkbCqpzwsz2N7NzzOxOM3vazOaY2TVm9h9mttoQZW5pZt80sxvN7FEze8LMbjWzE8xsxyHKW8HMPmJmV5jZfWb2jJndY2YXmdlhZpbWH2NSLokdH29mK0TtWQr4DuFL5MAV7t4rBtiLY8d3FNLKRtPLIGOTPu+VQVZdzxpGSrSQjvYsrywdBWlp6fQyvJBBhuiFtLRneRqTjjW9DDCqZJixUsbrn86lFUI6mgPSvUaidVKRDmlpz/I0Jh1raqClM06CJTu/hp0GGdNQBJvRIC3tWZ60tAdT8i5QCJEni6hUp19TzOwDwFdZPJbU+lF6u5mdDbzT3R/Lqc61gDOAzk5rlShtCxxhZoe5+1kJyjPgs8DRwBIdb78wSoeZ2feBw9392QRlvhL4CbB2x1trRum1wIfN7G3uPrPz+oz8GPgPwv9kB+BuM7uRcB/xFc/v9Skj7m7qhpzbJ0TO1DvmrHS0Z5ll6ihIS0ViJshmpFaVMWlaLa2OjoK0tE+ZGpOKGtLNS8ZUYH4JbUmDxqRD1Fl5HU2JdE+USFPGpPVGWtqzTI1JRT2YEnusO20a3b1kTAN6PXMWeSAt7VmmtLQPMsoQolCyTDY0ycgDM/s3ghVcixuAC4B5wFbAHgQt3Bs4y8x2d/dMK2lmtiJwEbBpdOop4JfALcCKwF6Ejnkl4Ewz28PdLxhQ7JeAT8ZeXw1cTohr9XJCZ2bAe4FpZnawu/fcpmtmLwXOox0j637gF9HfGcBbgOnAFsBvzWx7d79r0L0nxd1nm9kngW8TrBOXj+6jZa0IcKm7/6JH+zcHNo/y/sPd/5VX20TTkJZmRTras42l6ihIS8WokI7mgbS0Zxs1JhU1YjmGX9yuSviS+iIdzQfpnqg3VRmXttzup72mfKSlPduoMamoD6t9F+Z+JBxPXZXuBrfT6G4wfHiRLUtB7Q2FpaXd2ygtHYCMMoQQCZgg3SJSNSZJZrYB8M3YqaPd/csdeV4MnA+sBrwG+BihM8rC12h3jjcDu7v7rFidRwLfAt5P0OGTzWzDXhaTZvYK2p3jQoJ15akdeXYFziZ0eAcSOr/Te5Q3hWCt2OoczwLe4e5PxfJ8EjiXYFG4BnAC8LrBt54cdz/ezJ4CvgI8n8kjq58B7+lz+QdbTSX8/4ToQjW0qM5IR6utoyAtFaIOSEurraXSUSGqj3S0u44Oi3RP1BPN77MiLdWYVAiRHWmptDQLGs0IUUn008yJz9I2uTyts3MEcPe/AAfHTh1lZtOHrdDMNgEOiV4+C+wb7xyjOhcSBP6q6NQqwMf7FBtv91c6O8eozIuBI2Knvmhmvb5I7wI2jo5vAw6Md45ReQ8RLBcfiU7tZmav6dPGoXD3HwEvAF4JHAC8GVjX3d82wK3XP4Fjo3RC3u0SIn9aO2nSpEpYgEtHu1MZHY3qkpaKMWGCIElJU2XG1NLS7lRGS6Wjoliq5CVDY9Kk1ERHh0a6J8RYIi3tjsakYkyoipeM2iMt7Y60NAGVWaUSorlMoJ/a6DGz5QhiC8Hd0Gd75XX3i4A/RC9XILiVGpZ30P6H/9zdb+xR5yLgc7FTB3XLF1le7hC9nEewiOzFj4B7ouMZhE6nG/EBwVfdfV6PNt4P/F+P63LD3Re4+5Xufoa7n+3u9yS45jh3PzZKecceE5VjAmnp6JGO1kdHo7qkpWIAw2ipdDcr0tL6aKl0VCRjuSildbcshkU62ldHMyHdE+XQhDFpy+1+mlSugZu0VGNS0TCmfyMkNiu5IcNSPx0FaSnS0sxUbUQjRIPRz23E7EZ7S9IN7n7LgPw/ix3vk6HevWLHZw7I+1tgbnQ8I3Jr1a+837r7I13yAKGjIbiFarHYfZjZKrQ7XAd+PqCN8c9lryJ26AghKot0VDoqhMiOtFRaKhqJvoIjRDqa7T6EEAKkpaAxqWgku5XdgHFDWiotzcTY3KgQIgtpLRfLt1oEtokdX5kg/+9ix906qoGY2VJMNk/tW29kuXj1gHrzvo+taGv/THd/eEB51wOPR8fTCdaQQpRIXYcutbQAl45KR8XYs6jsBnSgMWkSpKVCiN5oTJqEmuioEA0g6fy+imPS2oWCkpZqTCpEhailjoK0tFd50tKETCm7AUKMFy1dGjSZWER9Hzw+x4SZrdHjvcfd/fEe7+XF5rHjfyTIf1vseG0zW2FAfKlubAIsER3Pdfd/pax38y7vZ7mPzOW5+yIzuwPYMnb9PxO0Q4gCSaqljaBMLZWOSkdFY5GORmhM2r1eaakQiUiqpU/T3lBXWzQmTVfvKHRUiIYwwZiMSUFaWkUt1ZhUNICWt4yLYufiBrZPROe+Axw+wnYVgub30tJaI6MM0Y8ZN910Ey95yUvKbocokJtuugkGWKKF78HL0pa5GnBvjyzHAsckLnA4Vo8dJ4kX9YiZPQksG51aDUjbQaaqM+LuHtcPW2a8vJXMbEl3fzZDea0yWx1ktzbmgpkZoQNeC3gesFTSa9395KLalQPS0oZThI7Gyi1TS6WjNdNRaKyWSkfHAI1JA9LSgWVqTDo80tKR4V3OjWZn3yAt1Zi0mDojRq2judFg3csb6egYoPl9YIy0VGPS0SMtLYzOn+jC6O+C2LkTR9KSho5JQVoK0tJMyChD9OOxp556iuuuu25WwvwTBFFp8QD1MnUe1/bPoH9HcHP0PUjbniWBF6S9KEeWjx0/mfCaebQ7yOX7Zcy5zm7XD1vmvI7XywMPd7xOU15nmcN8Ln0xs5cBRwBvpP35p8GBKk820mhp3XUI6n8Pw7R/BsXoKJSrpdLR9vWV1lFovJZqTFqv9kO1tFRj0uR1drt+2DJrp6UN11HQmLRu91DE/F5j0uLr7Hb9sGUO0tHMjIHu5Y3GpPVqP1RrTArS0qR1drt+2DI1Jq0eGpOWeg93D84yGY1JJyMtbV8vLR0CGWWInrj7emnyR26D4lZqL3X32fm2qjjU/u64+zuGbM8xwIuy1p+BZWLH8xNe83TseFpF6kxb5tMdr6cxuYMs43PpiZl9FjiaMMAbtH3ME+SpHGm0tO46BPW/hyLaP6yORu05hvK0VDraLrOyOgrN11KNSevVfqiWlmpMKi1NQtN1FDQmpWb3UCUdjdpzDBqTZq0zbx3NxDjoXt5oTFqv9oO0tANpabtMjUlLRGPSet2DdHQxpKXtMqWlQyCjDCFEUXwd+H6P94qO7QXwVOx4asJr4oF+O63/yqrzKdqWfEnK7AxW3FlmGZ9LV8zsSODTsVNPA38HNgBWJHSIVxAsJdcCVo3ytfwB/5HFBwRCNI0ytVQ62r3MyugoSEuFSIDGpPnU2VgtlY4KkQiNSbPXmbeODo10T4jSkJZmr1NjUmmzGG80v8+nTmlpSVoqowwhRCG4++OMpiPsRbzupO6J4hZ5w7S9iDofj5WVpMxOq8LOMsv4XBbDzFYHPhu9dOB44Gh3f9LMzgdeB+Dur45dswFwGPBhQuyvpYAD3P2OPNokRBUpWUulo93LrISOgrRUiCRoTCot7Yd0VIhkaEyaS5156+hQSPeEKA9paS51akzavkbaLMYOze+lpf2og5ZOFFGoEEJUgPtjx2sNymxm05ncYTxQdJ1d8nWrM22Z8TyPuPuzGcvrzDfM59KNwwgdnANnuPuH3L1vvDF3v93djwa2Ae4CtgIuMbPn5dQmIcRkpKPV1lGQlgpRB6Sl1dZS6agQ1Uc62l1Hh0W6J8R4Ii3VmFQIkR1pqbQ0EzLKEEI0lZmx4xcmyL9h7Pged39siDpvARZFx9PNbOWU9d7Y5f0s95G5PDObANYfUOYwvDp2fGyaC939ZuANwLPAusA3cmqTEGIy0tFq6yhIS4WoA9LSamupdFSI6iMd1fhRCJEdaanGpEKI7EhLpaWZkFGGEKKpXBc73jFB/lfEjv8yTIXu/jSTO6C+9Uadzw4D6s37Pq6nHR9rUzNbcUB5WxHiawE8CuTltmnj6O897n5rr0xmtkS38+5+E/ATwIC3mtlyObVLCNFGOlptHQVpqRB1QFpabS2VjgpRfaSjQ95HD6R7Qown0lKNSYUQ2ZGWSkszMSXvAsVY8ziTrY/KjO00DGp/s7gQeBpYGtjKzDbqJ8TAvrHjszLUew6wRXS8X/S6F7sArQ7qTne/rkuec4CvRcevNbPp7j63W2FRZ7JP7NRi9+HuD5rZ1YTOdgJ4C/CDPm2Mfy7nuPuinjnTsRKho57V5b24+6tlgCd6lHEBcCjhf7wz8Ouc2lYmTfgd1/0e6t7+PJGOVltHQVrai7r/juvefmjGPeSFtLTaWiod7U4TfsN1v4e6tz9PpKPZ7qMT6d7oqPvvuO7th2bcQ15ISzUmrSNN+A3X/R7q3v68kZZKS7Ph7kpKSkqNTMDpBBF24JQ++XaN5XsMWDFDnZsCC6OyngE27ZFvArgiVu/n+pT5+4T5DovlmwUs0SPf+2L5bgGW6ZFvNeBfsby75Pi/eSr6nH7b5b2fEFxyLQQ27FPGTrF87yv7+6ak1MQkHa2ujkblS0uVlGqQpKXV1VLpqJJSPZJ0tLuODnlf0j0lpTFN0lKNSZWUlLInaam0NEtS+BIhRJP5DG0LuAPN7MjODGa2FXBy7NRX3P2RLvl2NjNvpV4VenBx1CpvKvALM1u3o6wlgG/Sdvv0L9qWid04Kn5sZm/v0r5dgP+JnfoPd1/Yo7wfAf+IjjcCTjGzZTrKWwn4OfD86NTF7n5Jnzam5eHo7wpd3rs/drxJnzKeFzse5BJLCDEc0tHuVEFHQVoqRF2QlnanCloqHRWiHkhH80O6J8T4Ii3tjsakQog0SEu7Iy1NgMKXCCEai7v/w8w+CnwnOnWcmb2D4IJoHiF21R7AktH7l9O/o0rKx4HtCTGsNgVmmtkvCRaCKwJ7ARtEeRcAh7j7o33u43Iz+1pU7hTgNDN7f9TehcDLgd0Isa4gWGue1qe8Z83sQOD/AdMI7qR2MLNfEDqnGdG5VqdzP/CeFPefhH8ALwDW6/LeDbHj19HbRdSuseO5+TRLCBFHOtqzvCroKEhLhagF0tKe5VVBS6WjQtQA6WiuSPeEGFOkpT3L05hUCJEYaWnP8qSlScjb9YaSkpJS1RLwQYLrIu+TzgWe16eMneP5E9S5DnD1gDofBt6S8B4M+BKhQ+1X5g+AqQnL3Bm4Z0B5NwJbFPA/+TptN1Brdby3RnSfCwmuvV7Y5foXA0/Gyti27O+ZklKTk3S07z2VoqNR/dJSJaUaJWlp33vSmFRJSWlgko7m8hlK95SUxjxJS/vek8akSkpKiZK0tO89SUt7JIsqEkKIRmNmGxAs73YndF5LE6zxriHE/vrNgOt3Jlj5AeDu1jNz+5oJ4G3A24GtCfGyHgfuIHTIJ7j7/T0L6F7mVoQ4XrsAawFLALMJscJOdPcrU5b3PODdwJuBDQmWiv8CZgI/A37s7s+kKTNhvW8EfkXohP/N3U/oeP9c4E3Ry0eAbwB/il6/AvgAsHx0/a3uvmnebRRCTEY62rO8UnQ0qltaKkTNkJb2LE9jUiFEIqSj2ZDuCSFAWtqnPI1JhRCJkZb2LE9a2quNMsoQQggxasxsKWAOoZO72t136nh/A+AvwLIEi83Ozqo1QFkI7O7uFxfbYiGEqB7SUiGEyIZ0VAgxbkj3hBCiekibhRAiO3XQ0il5FyiEEEIMwt2fMbP3EeKcuZlNc/d5sfdvN7PdgZ8TrD27WYnOAw7VREMIMa5IS4UQIhvSUSHEuCHdE0KI6iFtFkKI7NRBS+UpQwghRGUxs+WAQ4HdCC7AliS4zroM+L67P1Be64QQoh5IS4UQIhvSUSHEuCHdE0KI6iFtFkKI7JSppTLKEEIIIYQQQgghhBBCCCGEEEIIIYQogImyGyCEEEIIIYQQQgghhBBCCCGEEEII0USmlN0AIYQQ44eZrRMdPuXuDw5ZxsrANAB3vyuvtgkhRF2QlgohRDako0KIcUO6J4QQ1UPaLIQQ2amDlip8iRBCiJFjZosABy5w9zcOWcZZwJ6Au7uMDIUQY4e0VAghsiEdFUKMG9I9IYSoHtJmIYTITh20VOIshBCiTKzk64UQoglIS4UQIhvSUSHEuCHdE0KI6iFtFkKI7FRWSyeKKlgIIYQQQgghhBBCCCGEEEIIIYQQYpyRUYYQQoi60vL2tKDUVgghRL2RlgohRDako0KIcUO6J4QQ1UPaLIQQ2SlUS2WUIYQQoq6sHf19rNRWCCFEvZGWCiFENqSjQohxQ7onhBDVQ9oshBDZKVRLZZQhhBCidpjZzsCWgAO3ltoYIYSoKdJSIYTIhnRUCDFuSPeEEKJ6SJuFECI7o9DSKYOzCCGEEMNjZj/q8/aLBrw/qShgGWBDYOvY+UuGbJoQQtQGaakQQmRDOiqEGDeke0IIUT2kzUIIkZ26aqm5exHlCiGEEACY2SKCdeGk09HfLJ2QAY8AW7j7fRnKEUKIyiMtFUKIbEhHhRDjhnRPCCGqh7RZCCGyU1ctVfgSIYQQo8A6Uq/zadL1wG6aaAghxghpqRBCZEM6KoQYN6R7QghRPaTNQgiRndppqcKXCCGEKJpju5z7L4LF4u3AqQnLWQQ8CdwPXOfuN+fTPCGEqAXSUiGEyIZ0VAgxbkj3hBCiekibhRAiO7XUUoUvEUIIMXJi7qUudPc3lN0eIYSoI9JSIYTIhnRUCDFuSPeEEKJ6SJuFECI7ddBSecoQQghRBncROsgHym6IEELUGGmpEEJkQzoqhBg3pHtCCFE9pM1CCJGdymupPGUIIYQQQgghhBBCCCGEEEIIIYQQQhTARNkNEPXBzKaY2WvM7Atm9lszu8fMnjazeWZ2t5n9xsw+bGbTC6jbU6b5Zna7mZ1mZoW4qTGzCTPb38zOMbM7o89ijpldY2b/YWarDbjezGx7M/tPMzvPzGZFn+XTZnafmV1sZp8ys9VzbveslJ/l1/KsX4hxp2Za+mCVdTQqQ1oqxJhRMx2t/Jg0KkNaKsSYUTMt1Zi0d73SUSFKomY6qjFp/3qlpUKUhLR0sTbpmZMQDUaeMkQizOx9wBeBlRJknwt8yN1PybH+rF/Us4F3uvtjOTQHM1sLOAPYsU+2h4HD3P2sLtfvCXwPWCNBdU8D/+nuuXRUZjYLWDfFJV9394/nUbcQSYgGhasAzwMm3P2KkpuUGzXX0rOpkI5GZUhLhehBU7W05joK0tLOumchLRUVpak6CrXX0rORjsbrnoV0VOREk3Uvb2quoyAt7ax7FtJSUVGarM3S0snomZMQxVEVLZ1SRqWilryYdufowE3A1cC9wEJgI2BPYAVgOnCymU1392/n3I5HCB11i+2At8Re3wfcDNwCrAbsQfie7w2cZWa7u/v8LA0wsxWBi4BNo1NPAb+M6lwR2AtYn/B5nWlme7j7BR3FbMbkzvF24CpCzKOngPWitq8GLA181cxe4O4fy9L2LhyZIM+1OdcpxGKY2cuBDwCvAV4Qe8vp0leZ2dHA8tHLL7j7k4U3Mh+qqKW9dPRZwmf/SqqpoyAtFWISY6KlVdRRqO+YFKSlQjzHmOgoVFNLNSbNjnRUpGaMdC9vqqijoDFpHkhLRemMkTZLSyP0zEmI/Kmklrq7ktLABPwvMAc4BlivR57pBOtAj9IzwMY51d8qc1bs3AZRHa33jupy3YuB+2N5js6hLT+MlXcTMKPj/SWA42N55gArdOQ5CngM+DqwRY96lo4+d4+lV+fQ/lmt8sr+XikpEQbVpxMG2q20KJYW9rju6633gUPKvo8U91spLa2zjkb5pKVKSj5eWlo1HY3OSUuHvwdpqVIl0jjpaNTuSmmpdDTTPUhHlYZK46Z7BXx+ldLR6Jy0dPh7kJYqVSKNmzZLSyeVqWdOSko5pSpraekfjlI9EvAyYFqCfEsCf40J+tdzqr9bB3lq7Pypfa7dLZbvUWB6hnZsEv0gHZgPbN4j3wRwZazez3a8vyWwUsI6z4uV84scPkt1kEqVSARXUX/t0ik+DMwb0EFuEOsgzy/7XlLcc6W0tM46GuWRliqNfRo3La2ajkbnpKXD34e0VKn0NG46GrW7UloqHc30WUpHlVKncdS9Aj7DSulodE5aOvx9SEuVSk/jqM3S0ufK0jMnJaWcUtW1dAIhEuDu17r7vAT5niXErWqxfRHtMbPlgDe3qgU+26dNFwF/iF6uQHArNSzvgOd+Nz939xt71LkI+Fzs1EEd79/g7g8nrPNbseNCPk8hSuLHwIsAA54AjgbWdveVgMv7XejutwPXR9e+wsyWLLap+VAlLa27jkZ5pKVCjJmWVklHQVqa8Bohqs5Y6ShUS0ulo0KUwtjpXt5USUdBWprwGiGqzthps7T0OfTMSYj8qLSWyihDFMEdsePnF1THbgRXSwA3uPstA/L/LHa8T4Z694odnzkg72+BudHxDDN78ZB1juLzFGKkmNkrCDEBHXgI2M7dv+Lu96Yo5rLo7zIES+CmUfRvf5x0FKSlooFISweiMWlAWipED6SjidCYVDoqGoR0rxQ0Jg1IS4XogbQ5EdLSgJ45CdGDOmipjDJEEawZO34w57JXMrPfEKydWqxjZj80s937XPe72PFQHZWZLQVsFjt1Zb/8keXi1VnrpcDP08x+aWZ3m9kzZvaomf3DzE41s7eZ2RJ51iVEB++IHX/I3WcOUcb1seONszWnkhSqpcBXYq83MbObBmhpnXUUpKWimUhL+6MxKdJSIQYgHR2MxqTSUdEspHujR2NSpKVCDEDaPBhpKXrmJMQAKq+lMsoQRfDW2PHveuYajuWBNwDLxc6tCBwKnGdm15rZC7tcd1vseG0zW2GIujcBWp3GXHf/V4Jr4vVuPkSdUOznuQ+wFjCV4GZrQ+AA4AzgZjN7Wc71CdHildHfR4GfDlnGA7HjVbI1p5IUraUbxl4vRdC4flpaZx0FaaloJtLS/mhM2r1eaakQbaSjg9GYdPF6paOizkj3Ro/GpN3rlZYK0UbaPBhpafd69cxJiDaV19IpeRcoxhsz2w14XfRyAfCjHItfBFwLXAe8CVg7On8PQeQBXgpca2Y7ufvfWxe6+yNm9iSwbHRqNeCxlPWvHju+J+E1d/e4PhFmtjmh82/xf2nL6MMNhM/zbuBZwmeyE7BN9P6GwJVm9gZ3vyTHeoUAeAHBjdTMyMJ3GJ6IHS/bM1cNGZGWziD87gEuBNYBNo1eL6alddVRkJaKRiMt7YHGpIshLRWiO9LRPmhMOgnpqGgK0r0RojHpYkhLheiOtLkP0tLF0DMnIbpTeS2VUYbIDTNbHfhh7NS33f0fORV/FHCiu8+J6npl7L33EKzufkCwXHoecK6ZbebuT8fyzaP9I1p+iDbEr3ky4TXzelw/EDNbFvgJsGR06ix3vyxNGT34OnCOu9/Vo96dgJOB9Qif68/NbBN3f6BbfiGGZKno7zMZyoj/ph7PUE6lGJWWmtnfaS+Af8PdLzCzPemvpbXSUZCWisYjLe2CxqRdkZYK0R3paA80Jl0M6ahoCtK9EaExaVekpUJ0R9rcA2lpV/TMSYjuVF5LZZTRAMzsSwSXQHnxX+6eyrWLmS0DnE3bevB64Oi8GuTuX+k4tUzseH60cLMrIZ7WsgRxfx/wzVi+eGc5bYhmTKoz4TVD1WlmE8ApwNbRqXsIA4HMuPu3B7x/pZm9AvgTwdJyOmGA8tE86hci4kGC5fEaGcqIx/TKHPtuDLV0MU1z93MHaGltdBSkpWIsqJSWjqGOQsPHpCAtFY2nUjoKY6mlGpNmQDoqhqByupc3Y6ijoDFpJqSlogJUTpulpc3TUumoGAMqp6WdyCijGbyAyV+UrKyYJrOZTQV+Abw8OnUPsI+7Z7FGGsRTseOpAO5+g5l9E/hUdP6tTO4gl44dx60Jh64zAanrNDMjuIxqDXoeA/Z294cS1pkZd7/XzD4DfD86tR/qIEW+3EroIF9oZqsNaRX7xtjxn3Jo07hpaVdNG6CltdBRkJaKsaFqWjpuOgoNHpOCtFSMBVXTURg/LdWYtGCko6KDKupe3oybjoLGpIUjLRUFU0VtlpbSHC2VjooxoYpaOomJvAsU44WZLQmcCewenboP2MXdZxVcddxtTDyuz5mx420j678WcavBYdzO9KqzH8PU+R3gsNg1r3f3Pye8Nk9+Toi/BLCmma1TQhtEc7kg+msMMfgys5cDuxK+o3e5+205tm3klKSl/TStl5bWRUdBWirGA2lphMakA5GWCtEd6WgMjUn7Ih0VTUG6VyAakw5EWipEd6TNMaSlA9EzJyG6U3ktlVFGA3D3Q9zdckz/m6TeqHP8KbBXdOp+4NXufmtR9xrj/tjxWrHj+I9kCvB8ADObzuRObRgLqV519iOeb2CdZvZt4P3RyyeA3d399wnryhV3fwSIW0qu1iuvEENwKu04eUeY2Rv7ZY5jZusCZ8RO9XWPlpQx1NJ+mraYltZFR0FaKsaKSmnpGOpoq64WjRmTgrRUjA2V0lEYSy3VmHQESEdFjMrpXt6MoY626mqhMWlBSEtFgVROm6WlzdFS6agYIyqnpZ3IKEMMRaxzbLk7egB4jbvfMqImzIwdvzB27J0ZIzaMHd/j7o8NUectwKLoeLqZrZzgmni9N/bLGHWOh0cvnwTe4O5XpW5lvvT6PIXIhLvfDxxHsFpcAjjLzL5iZi/odY2ZPc/MPgRcC6xD+H7eAXx3BE0uhJK1tJeOQvfffuV1FKSlYryQlpauo9DAMSlIS8X4IB0NaEwqHRXjg3SvGDQmlZYKkQVpc0BaqmdOQmShDloqowyRmpj7qFbnOIfQOd40wmZcFzveMXYc75AW0ra6e0Xs/F+GqdDdn2Zyx7xjr7wAkRurHZLUa2bfod05zgPe6O6/G6adeRFZej4/dmoYS08h+vF54Je0O8mPA3eb2Uzgpa1MZnapmf0d+BfwP8DK0TVPEmLfPT3qhudBBbS0l45Cdy2ttI5G+aWlYhwZWy2tgI5Cw8akUX5pqRg3xlZHoRJaqjHpCJCOig7GWvfypgI6ChqTjgRpqSiYsdZmaWnXehdDz5yEGEiltVRGGSIVUef4M2Dv6NSDhM5xZs+LiuFCoPWj2MrMNoqO94vludbdW1aG+8bOn5Wh3nNix/v1zBXYBVgxOr7T3a/rlsnMjgc+EL1sdY6XZ2hjXryFtkbc5+53ldkY0Tzc3YG3E2LaWZQmgI2BlWhbzb4K2JTQiVp07i7gVe7+91G2OS8qoqW9dBS6a2lldRSkpWJ8GVctrYiOQoPGpCAtFePJuOooVEZLNSYdDdJR8RzjrHt5UxEdBY1JR4W0VBTGOGuztFTPnITIi8prqbsrKSVKwJLA2dGX1gnWiluU2J7TY205BdgceDx27ogo366xc48BK2aoc1OCNaQDzwCb9sg3AVwRq/dzPfIdH8vzJCE+WhX+1y8A7o217Vtlt0mp2Ql4JfCb6Pe1qE96GDgWeF7Zbc5wr5XR0k4djc4tpqVV1tEor7RUScnHR0urpKNRe2o/Jo3ySkuVxj6Ni45G91oZLdWYtPDPVzqq1DONk+4V8NlVRkej9mhMWuznKy1VGlkaJ22WluqZk5JSUamKWlr6h6JUj1RE5wjsHCvP++T7E8FCcOmO8y8E5sfKiHeOdwLLAFsBs2Pn/yNLW6K8J8byzgTW7Xh/CeDbsTwPdvsx59k5AjPi7Qdm9Mh3IXAosEKfsrYH/tExqFi97O+g0ngkgvuyvYBPE9xGfZ8QB+xjBPdtU8puY8b7q5SWdtHRHxLcxsW1dNuq6miUV1qqpNSRmqylVdPR6Hytx6RRXmmpklIsNVlHo/urlJZ20VGNSaWjSiNOTde9Aj6vSulodF5j0sllSUuVap+ars3S0kl5c9FS6aiS0uKpSlpqUYOE6IuZfR94T+zUj4GkLly+7+6PdSlzZ+D/tV67u3XmifK1vqRPAH+I6n2IYMH0OoK1U5xnCIs4qwN7EDp3gMuB17n7M8O2Jcr7fOAqgrsbCO6ffgncQnAdtRewQfTeAkL8od90lPEp4AuxU78iWDkm4afufndHeTOAO2Kn1nP3WV3aPgtYl/AZ/RG4gTDYeRZYFdiJWFyl6Pwb3f23CdsmhOhDRbV0W4JWdvI0QeteSQV1NCpHWirEmFFRHa3tmDQqR1oqxJhRUS3VmLRd3gyko0JUmorqqMakk8ubgbRUiEojLZ2UV8+chBgHyrZQUapHAi5jslVcmjSjR5k7x/P1qXvYeuPpXPq4nknallj+dYCrB9T5MPCWHteflOFedu5S3oyEn/msFPXcCLy07O+eklKTUs21tFI6GpUhLVVSGrNUcx2Vlk7OJy1VUiop1VxLpaPtfNJRJaWSUs11VFo6OZ+0VEmppCQtXSy/njkpKTU8TUGI6vNiYLsobQasAqwMLAXMJbiNmklw4fQiQue1NHA/cA0hJu1iFthZcPe7zGwn4G3A24GtgdUI7qzuIHTIJ7j7/XnWmwO7EdzxbAdsSbBUXBmYBjxKiOl1DcFt2Pnu7uU0UwhRAIO09H6Ce77pBJde0tHeSEuFGE80Js0XaakQ44nGpPkhHRViPNGYNF+kpUKMJ9LS/JCOCpEQhS8RQgghhBBCCCGEEEIIIYQQQgghhCgAecoQQghRCczsBcCmhDh504CecfY6cfeTi2qXEELUCWmpEEJkQzoqhBg3pHtCCFE9pM1CCJGdqmmpPGUIIYQoDTNbFvgY8E5CnLphcHeXkaEQYmyRlgohRDako0KIcUO6J4QQ1UPaLIQQ2amylkqchRBClIKZbQGcB6zZOlVic4QQopZIS4UQIhvSUSHEuCHdE0KI6iFtFkKI7FRdS2WUIYQQYuSY2UrAJcAqgNPuHO8B7gPmldQ0IYSoDdJSIYTIhnRUCDFuSPeEEKJ6SJuFECI7ddBSGWUIIYQogyNpd46LgOOA77r7vaW2Sggh6oW0VAghsiEdFUKMG9I9IYSoHtJmIYTITuW1VEYZQgghymCP2PG/ufsPS2uJEELUF2mpEEJkQzoqhBg3pHtCCFE9pM1CCJGdymupuXvZbRBCCDFmmNkTwDLAfe6+VtntEUKIOiItFUKIbEhHhRDjhnRPCCGqh7RZCCGyUwctnSi7AUIIIcaSVjyvW0pthRBC1BtpqRBCZEM6KoQYN6R7QghRPaTNQgiRncprqYwyhBBClMGs6O+0MhshhBA1Z1b0V1oqhBDDMSv6Kx0VQowLs6K/0j0hhKgOs6K/0mYhhBieWdHfymqpjDKEEEKUwcUEy8UtzGxq2Y0RQoiaIi0VQohsSEeFEOOGdE8IIaqHtFkIIbJTeS2VUYYQQogy+DbwLMFq8T0lt0UIIeqKtFQIIbIhHRVCjBvSPSGEqB7SZiGEyE7ltVRGGUIIIUaOu98GHE2wXDzOzF5TcpOEEKJ2SEuFECIb0lEhxLgh3RNCiOohbRZCiOzUQUtllCGEEKIU3P2/gaOApYALzex/zeylZqa+SQghEiItFUKIbEhHhRDjhnRPCCGqh7RZCCGyU3UtNXcvuw1CCCHGGDN7LfArYMno1HzgoehvEtzdNyiibUIIURekpUIIkQ3pqBBi3JDuCSFE9ZA2CyFEdqqqpTLKEEIIURpm9hHgP4CVWqeiv0k7JyN0kEvk3DQhhKgN0lIhhMiGdFQIMW5I94QQonpIm4UQIjtV1tIpeRcohBBCJMHMjgM+RtTJ0e4c6TgWQgjRA2mpEEJkQzoqhBg3pHtCCFE9pM1CCJGdqmupjDJEasxsBnBHAUX/2N0PKaDcRmFmqwAvBV4W+7t6LMux7n5MCU0TIjFmtjvwcdrWiY8BZwLXAPcB80pq2siQlpaLtFQ0gXHXUulouUhHRRMYdx0FaWnZSEvFqJHu5Y90tFyko6IJSJulpWUjLRVNoA5aKqMMIWqCma0O/AFYt+y2CJEDh8eOrwT2dveHy2qMGB+kpaJhSEvFyJGOioYhHRWlIC0VJSLdE41AOioahrRZlIK0VDSMymupjDLEMDwFXJgg3+tix7cDtw3I/7ehWzQeLI06R9Ecto3+LgTeXrXOcURIS8tBWiqaxLhrqXS0HKSjokmMu46CtLQspKWiLKR7+SMdLQfpqGgS0mZpaVlIS0WTqLyWyihDpMbdHwBePyifmXns5U/k3ihXHgT+DPwJuBY4p9zmCJGa5QlupP7q7veW3ZgykJZWAmmpqDtjraXS0UogHRV1Z6x1FKSlFUFaKkbJ2Ote3khHK4F0VNSdsddmaWklkJaKulN5LZVRhhD14WFgP+Bad78z/oaZldMiIYbnfmBtQlwvIUaJtFQ0CWmpKAPpqGgS0lFRFtJSURbSPdEUpKOiSUibRVlIS0WTqLyWyihDiJrg7o8BPy+7HULkxExgHUInKcTIkJaKhiEtFSNHOioahnRUlIK0VJSIdE80AumoaBjSZlEK0lLRMCqvpRNlN0CIbpjZZWbmUTokOrekmb3VzM4ys9vM7Mno/WMSXLuUmR1sZheZ2V1m9rSZzTazC8zsnWa2RM7tPyaq/2Ez+7uZHWdm6yS47iVm9kys/f+dZ7uEqBA/if5uYGabldqSBiMtlZaKxiMtLRjpqHRUNB7p6AiQlkpLRaWQ7tUQ6ah0VDQeafMIkJZKS0XjqbyWylOGqAVmtj5wBvCyIa5dl2Dt99KOt14QpdcBHzCzt7r7rIxNbfHi6O+KUdocOMjMXuHut/Vo5/KEe5wanboOOCqn9ghRNX4KvB/YAfiOme3m7gtKblPjkZYK0TikpSNGOipE45COloC0VIhSke41AOmoEI1D2lwC0lIhGkfltVSeMkQdWAm4hHbnOBv4HXAN8MiAa5cHLqbdOd4LXAH8GZgfy/cy4FIzWyOnNv8LuBZ4KnZudeDjfa75HrBhdPwEsL+7z++TX4ja4u4LgbcCNwGvAs4zs8q6lWoI0lIhGoa0dORIR4VoGNLRUpCWClEi0r1GIB0VomFIm0tBWipEw6iDlspThqgDxxA6ur8Ch7v7la03zGwqsFqfaz8DrAzcCbwX+K27e3TtitH7H4nyrgf8ENg9a4Pd/d1RHc8nWEzuHL3VtezI5dU7Yqfe7+7/yNoOIaqKmR0cHX6X8BvfBbjdzH4L/B64n8mD2L64+8l5t7GBHIO0VIhGIS0dOccgHRWiUUhHS+EYpKVClIZ0rxEcg3RUiEYhbS6FY5CWCtEo6qClMsoQdWB54Abgle7+WPyNyKrv7j7XrgzMAV7l7nd2XPsI8FEze4zQUQK83sze5O6/zqPh7v6QmR0O/D06tY6ZrRjVDYCZbQx8J3bZKe5+Sh71C1FhTgK849wU4PVRSoMDmmwMRloqRPM4CWnpKJGOCtE8TkI6OmqkpUKUy0lI9+qOdFSI5nES0uZRIy0VonmcRMW1VOFLRF14b2fnmIJPdnaOHXwWmBl7/f4h6+mKu98IPBA7tXXrwMyWIsT0WjY69Y+86xeiwlhH6nYuaRLJkJYK0TykpaNFOipE85COjh5pqRDlIt2rP9JRIZqHtHn0SEuFaB6V1lJ5yhB14K/ufs2Q1z4MnNovg7svNLPv0rYc3M3MlnX3J4essxt/oW2JtRXw/6Ljr9HuMOcTYno9kWO9QlSVK1jcalEUi7RUiOYhLR0t0lEhmod0dPRIS4UoF+le/ZGOCtE8pM2jR1oqRPOovJbKKEPUgd9luPZid382Qb7zY8dLANtkrLeTeAe5NYCZ7QkcHstzlLtfl2OdQlQWd9+57DaMIdJSIRqGtHTkSEeFaBjS0VKQlgpRItK9RiAdFaJhSJtLQVoqRMOog5YqfImoA7dnuPbvg7MAcAcQt1J8YYY6uxHv+LY2s7WAE2PnzgO+kXOdQggRR1oqhBDZkI4KIUR2pKVCCJEN6agQQmRHWiqEGDkyyhB1YNi4XgAPJcnk7g48Eju1YoY6u/GX2PFmhJheK0Wv7wMOidoghBBFIS0VQohsSEeFECI70lIhhMiGdFQIIbIjLRVCjBwZZYg6sCjDtfNT5H0mdrxUhjq78U/aHf2SwI7R8SLgQHd/MOf6hBCiE2mpEEJkQzoqhBDZkZYKIUQ2pKNCCJEdaakQYuTIKEM0neWHzPtono2ILBKv7/LWl9390jzrEkKIApCWCiFENqSjQgiRHWmpEEJkQzoqhBDZkZYKIYZCRhmi6ayXJJOZLQesEjs1p4C2/KXj9e+B/yqgHiGEyBtpqRBCZEM6KoQQ2ZGWCiFENqSjQgiRHWmpEGIoZJQhms62CfO9DLDY6+sKaMv6sePHgbe7+4IC6hFCiLyRlgohRDako0IIkR1pqRBCZEM6KoQQ2ZGWCiGGQkYZoulsa2brD87G22PHs9399jwbYWaHA3vETi1w9zvzrEMIIQpEWiqEENmQjgohRHakpUIIkQ3pqBBCZEdaKoQYChlliKZjwBf7ZjDbGHhn7NSJuTbAbCvgax2nVzSzGXnWI4QQBSItFUKIbEhHhRAiO9JSIYTIhnRUCCGyIy0VQgyFjDLEOPA2M/t0tzfMbG3gXGBqdOox4Pi8KjazacAZwFJd3t46r3qEEGIESEuFECIb0lEhhMiOtFQIIbIhHRVCiOxIS4UQqZFRhmg6ZwIOfM7Mfmdmh5nZzmb2RjP7CvA3YKNY/o+7+3051v9tYJPo+CngD7H3Xpy2MDM7wcye7kwd2T7dLY+ZrTvkPQghhLRUWiqEyIZ0VDoqhMiOtFRaKoTIhnRUOiqEyI60VFoqxFBMKbsBQhTM+cBM4Bhgpyj14nPufkJeFZvZ/sChsVMfBp4HbBe93nqIYpekuwVknCWitFiThqhPCCFAWjqpSUPUJ4QQ0tFYk4aoTwghQFo6qUlD1CeEENLRWJOGqE8IIUBaOqlJQ9QnxNgiTxmi8bj7scD+wJ09sswC9nH3z+RVp5mtD/xf7NSZUed7fexcaqtFIYQoC2mpEEJkQzoqhBDZkZYKIUQ2pKNCCJEdaakQYhjM3ctugxC5YmaXAa+KXr7L3U+KzhuwI7AxsCrwMMGV1O89xx+CmS0JXAlsG526A3ixuz9qZisDD8ayr+zuD+VVtxBC5IW0VAghsiEdFUKI7EhLhRAiG9JRIYTIjrRUCJEHCl8ixoaoE7wySkXyBdqd4wLg7e7+aNSGf5nZPcBa0ftbA5cU3B4hhMgNaakQQmRDOiqEENmRlgohRDako0IIkR1pqRAiDQpfIkSOmNnrgI/HTn3a3a/pyHZ97HiXwhslhBA1Q1oqhBDZkI4KIUR2pKVCCJEN6agQQmRHWipEc5BRhhA5YWarAycDFp36LXBcl6zXx44/YGY7Fdw0IYSoDdJSIYTIhnRUCCGyIy0VQohsSEeFECI70lIhmoWMMoTIgSh22MmEuGEADwAH9Ygbdl7seAXgd2Y208wuMrONC26qEEJUFmmpEEJkQzoqxP9v545tGoiCKIq+LYcK3ABugZDYFbgCMnpxAaQEdEGKnTpHQ0JgWZYIhpGs1TnRarUr/ehFVx/6bClAjx0F6LOlsD6iDPgf+yTb3+dK8lxVp1sfVtVHksPV64ckj0m+xk4IcP9sKUCPHQXos6UAPXYUoM+WwsqIMqBpWZZNkpeLV69V9fbHb09JdknekxyTfCf5rKrzzCkB7pstBeixowB9thSgx44C9NlSWKfl9k03AAAAAAAAAAB0uCkDAAAAAAAAAGCAKAMAAAAAAAAAYIAoAwAAAAAAAABggCgDAAAAAAAAAGCAKAMAAAAAAAAAYIAoAwAAAAAAAABggCgDAAAAAAAAAGCAKAMAAAAAAAAAYIAoAwAAAAAAAABggCgDAAAAAAAAAGCAKAMAAAAAAAAAYIAoAwAAAAAAAABggCgDAAAAAAAAAGCAKAMAAAAAAAAAYMAP4JzZsJZI7Z0AAAAASUVORK5CYII=\n"",
+      ""text/plain"": [
+       ""<Figure size 1080x216 with 12 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 246,
+       ""width"": 1074
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, axes = plt.subplots(1, 6, figsize=(15, 3), sharex=True, sharey=True)\n"",
+    ""for i, ax in enumerate(axes.flat):\n"",
+    ""    pyemma.plots.plot_contour(\n"",
+    ""        *features_concatenated[:, :2].T,\n"",
+    ""        msm.metastable_distributions[i][np.concatenate(msm.dtrajs_active)],\n"",
+    ""        ax=ax,\n"",
+    ""        cmap='afmhot_r',\n"",
+    ""        mask=True,\n"",
+    ""        cbar_label='metastable distribution {}'.format(i + 1))\n"",
+    ""    ax.set_xlabel('Trp $\\chi1$')\n"",
+    ""axes[0].set_ylabel('Trp $\\chi2$')\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 73,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 720x576 with 2 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 567,
+       ""width"": 695
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""metastable_traj = msm.metastable_assignments[np.concatenate(msm.dtrajs_active)]\n"",
+    ""\n"",
+    ""fig, ax = plt.subplots(figsize=(10, 8))\n"",
+    ""_, _, misc = pyemma.plots.plot_state_map(\n"",
+    ""    *features_concatenated[:, :2].T, metastable_traj, ax=ax)\n"",
+    ""ax.set_xlabel('Trp $\\chi1$ (radian)', fontsize=30)\n"",
+    ""ax.set_ylabel('Trp $\\chi2$ (radian)', fontsize=30)\n"",
+    ""misc['cbar'].set_ticklabels([r'$\\mathcal{S}_%d$' % (i + 1)\n"",
+    ""                             for i in range(nstates)])\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""markdown"",
+   ""metadata"": {},
+   ""source"": [
+    ""## MFPT""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 74,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stdout"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""MFPT (ns)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""text/html"": [
+       ""<div>\n"",
+       ""<style scoped>\n"",
+       ""    .dataframe tbody tr th:only-of-type {\n"",
+       ""        vertical-align: middle;\n"",
+       ""    }\n"",
+       ""\n"",
+       ""    .dataframe tbody tr th {\n"",
+       ""        vertical-align: top;\n"",
+       ""    }\n"",
+       ""\n"",
+       ""    .dataframe thead th {\n"",
+       ""        text-align: right;\n"",
+       ""    }\n"",
+       ""</style>\n"",
+       ""<table border=\""1\"" class=\""dataframe\"">\n"",
+       ""  <thead>\n"",
+       ""    <tr style=\""text-align: right;\"">\n"",
+       ""      <th></th>\n"",
+       ""      <th>1</th>\n"",
+       ""      <th>2</th>\n"",
+       ""      <th>3</th>\n"",
+       ""      <th>4</th>\n"",
+       ""      <th>5</th>\n"",
+       ""      <th>6</th>\n"",
+       ""    </tr>\n"",
+       ""  </thead>\n"",
+       ""  <tbody>\n"",
+       ""    <tr>\n"",
+       ""      <th>1</th>\n"",
+       ""      <td>0.00</td>\n"",
+       ""      <td>332190.50</td>\n"",
+       ""      <td>170897.79</td>\n"",
+       ""      <td>28902.07</td>\n"",
+       ""      <td>36332.93</td>\n"",
+       ""      <td>2322.17</td>\n"",
+       ""    </tr>\n"",
+       ""    <tr>\n"",
+       ""      <th>2</th>\n"",
+       ""      <td>642000.76</td>\n"",
+       ""      <td>0.00</td>\n"",
+       ""      <td>157260.18</td>\n"",
+       ""      <td>25455.83</td>\n"",
+       ""      <td>29406.40</td>\n"",
+       ""      <td>3612.48</td>\n"",
+       ""    </tr>\n"",
+       ""    <tr>\n"",
+       ""      <th>3</th>\n"",
+       ""      <td>1186529.58</td>\n"",
+       ""      <td>782175.46</td>\n"",
+       ""      <td>0.00</td>\n"",
+       ""      <td>1040.20</td>\n"",
+       ""      <td>31087.81</td>\n"",
+       ""      <td>2432.98</td>\n"",
+       ""    </tr>\n"",
+       ""    <tr>\n"",
+       ""      <th>4</th>\n"",
+       ""      <td>1201932.70</td>\n"",
+       ""      <td>811507.50</td>\n"",
+       ""      <td>156325.61</td>\n"",
+       ""      <td>0.00</td>\n"",
+       ""      <td>30915.47</td>\n"",
+       ""      <td>2230.61</td>\n"",
+       ""    </tr>\n"",
+       ""    <tr>\n"",
+       ""      <th>5</th>\n"",
+       ""      <td>1201301.09</td>\n"",
+       ""      <td>806590.60</td>\n"",
+       ""      <td>179586.05</td>\n"",
+       ""      <td>22517.64</td>\n"",
+       ""      <td>0.00</td>\n"",
+       ""      <td>6558.18</td>\n"",
+       ""    </tr>\n"",
+       ""    <tr>\n"",
+       ""      <th>6</th>\n"",
+       ""      <td>1206631.75</td>\n"",
+       ""      <td>822453.60</td>\n"",
+       ""      <td>190349.37</td>\n"",
+       ""      <td>33472.71</td>\n"",
+       ""      <td>45957.24</td>\n"",
+       ""      <td>0.00</td>\n"",
+       ""    </tr>\n"",
+       ""  </tbody>\n"",
+       ""</table>\n"",
+       ""</div>""
+      ],
+      ""text/plain"": [
+       ""            1          2          3         4         5        6\n"",
+       ""1        0.00  332190.50  170897.79  28902.07  36332.93  2322.17\n"",
+       ""2   642000.76       0.00  157260.18  25455.83  29406.40  3612.48\n"",
+       ""3  1186529.58  782175.46       0.00   1040.20  31087.81  2432.98\n"",
+       ""4  1201932.70  811507.50  156325.61      0.00  30915.47  2230.61\n"",
+       ""5  1201301.09  806590.60  179586.05  22517.64      0.00  6558.18\n"",
+       ""6  1206631.75  822453.60  190349.37  33472.71  45957.24     0.00""
+      ]
+     },
+     ""execution_count"": 74,
+     ""metadata"": {},
+     ""output_type"": ""execute_result""
+    }
+   ],
+   ""source"": [
+    ""from itertools import product\n"",
+    ""\n"",
+    ""mfpt = np.zeros((nstates, nstates))\n"",
+    ""for i, j in product(range(nstates), repeat=2):\n"",
+    ""    mfpt[i, j] = msm.mfpt(\n"",
+    ""        msm.metastable_sets[i],\n"",
+    ""        msm.metastable_sets[j])\n"",
+    ""\n"",
+    ""from pandas import DataFrame\n"",
+    ""print('MFPT (ns)')\n"",
+    ""DataFrame(np.round(mfpt /50, decimals=2), index=range(1, nstates + 1), columns=range(1, nstates + 1))""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 75,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""normal = msm.metastable_sets[5]""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 76,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""flip = msm.metastable_sets[4]""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 77,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stdout"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""MFPT N1 -> F1: (45997.2 ± 3574.7) ns\n"",
+      ""MFPT F1 -> N1: (6508.2 ± 516.0) ns\n""
+     ]
+    }
+   ],
+   ""source"": [
+    ""print('MFPT N1 -> F1: ({:6.1f} ± {:5.1f}) ns'.format(\n"",
+    ""    msm.sample_mean('mfpt', normal, flip) /50, msm.sample_std('mfpt', normal, flip) /50 ))\n"",
+    ""print('MFPT F1 -> N1: ({:.1f} ± {:5.1f}) ns'.format(\n"",
+    ""    msm.sample_mean('mfpt', flip, normal) /50, msm.sample_std('mfpt', flip, normal) /50))""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 78,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stdout"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""state\tπ\t\tG/kT\n"",
+      ""1\t0.000199\t8.522936\n"",
+      ""2\t0.000999\t6.908295\n"",
+      ""3\t0.001035\t6.873310\n"",
+      ""4\t0.001206\t6.720110\n"",
+      ""5\t0.123649\t2.090304\n"",
+      ""6\t0.872911\t0.135922\n""
+     ]
+    }
+   ],
+   ""source"": [
+    ""print('state\\tπ\\t\\tG/kT')\n"",
+    ""for i, s in enumerate(msm.metastable_sets):\n"",
+    ""    p = msm.pi[s].sum()\n"",
+    ""    print('{}\\t{:f}\\t{:f}'.format(i + 1, p, -np.log(p)))""
+   ]
+  },
+  {
+   ""cell_type"": ""markdown"",
+   ""metadata"": {},
+   ""source"": [
+    ""## TPT""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 24,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""flux = pyemma.msm.tpt(msm, normal, flip)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 25,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""data"": {
+      ""text/plain"": [
+       ""<bound method ReactiveFlux.pathways of ReactiveFlux(A=array([ 1,  8, 12, 19, 20, 29, 31, 33, 34, 35, 38, 39, 56, 57, 62, 66, 67,\n"",
+       ""       68, 74, 83, 85, 94, 95, 99]),\n"",
+       ""       B=array([ 3,  9, 18, 36, 42, 47, 78, 89, 92, 97]),\n"",
+       ""       dt_model=[TimeUnit 300.0 step],\n"",
+       ""       flux=array([[0.00000e+00, 0.00000e+00, ..., 3.48093e-12, 0.00000e+00],\n"",
+       ""       [0.00000e+00, 0.00000e+00, ..., 0.00000e+00, 0.00000e+00],\n"",
+       ""       ...,\n"",
+       ""       [0.00000e+00, 0.00000e+00, ..., 0.00000e+00, 0.00000e+00],\n"",
+       ""       [0.00000e+00, 0.00000e+00, ..., 0.00000e+00, 0.00000e+00]]),\n"",
+       ""       gross_flux=array([[0.00000e+00, 0.00000e+00, ..., 8.63913e-10, 0.00000e+00],\n"",
+       ""       [0.00000e+00, 0.00000e+00, ..., 0.00000e+00, 0.00000e+00],\n"",
+       ""       ...,\n"",
+       ""       [8.60432e-10, 0.00000e+00, ..., 0.00000e+00, 0.00000e+00],\n"",
+       ""       [0.00000e+00, 0.00000e+00, ..., 0.00000e+00, 0.00000e+00]]),\n"",
+       ""       mu=array([3.30370e-05, 2.95548e-02, ..., 1.80496e-05, 4.28261e-02]),\n"",
+       ""       qminus=array([0.60827, 1.     , ..., 0.60731, 1.     ]),\n"",
+       ""       qplus=array([0.39173, 0.     , ..., 0.39269, 0.     ]))>""
+      ]
+     },
+     ""execution_count"": 25,
+     ""metadata"": {},
+     ""output_type"": ""execute_result""
+    }
+   ],
+   ""source"": [
+    ""flux.pathways""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 32,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": []
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 26,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/IPython/core/pylabtools.py:132: MatplotlibDeprecationWarning: print_figure() got unexpected keyword argument \""quality\"" which is no longer supported as of 3.3 and will become an error two minor releases later\n"",
+      ""  fig.canvas.print_figure(bytes_io, **kw)\n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 720x576 with 2 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""image/png"": {
+       ""height"": 567,
+       ""width"": 703
+      },
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""fig, ax = plt.subplots(figsize=(10, 8))\n"",
+    ""\n"",
+    ""pyemma.plots.plot_contour(\n"",
+    ""    *features_concatenated[:, :2].T,\n"",
+    ""    flux.committor[dtrajs_concatenated],\n"",
+    ""    cmap='BrBG',\n"",
+    ""    ax=ax,\n"",
+    ""    mask=True,\n"",
+    ""    cbar_label=r'committor $\\mathcal{Closed}_%d \\to \\mathcal{Open}_%d$' % (\n"",
+    ""        5 + 1, 4 + 1))\n"",
+    ""ax.set_xlabel('Trp $\\chi1$ (radian)', fontsize=30)\n"",
+    ""ax.set_ylabel('Trp $\\chi2$ (radian)', fontsize=30)\n"",
+    ""fig.tight_layout()""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 28,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""data"": {
+      ""text/plain"": [
+       ""array([0.        , 0.        , 0.        , ..., 0.56783079, 0.54586445,\n"",
+       ""       0.54586445])""
+      ]
+     },
+     ""execution_count"": 28,
+     ""metadata"": {},
+     ""output_type"": ""execute_result""
+    }
+   ],
+   ""source"": [
+    ""flux.committor[dtrajs_concatenated]""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": null,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": []
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 27,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": [
+    ""cg, cgflux = flux.coarse_grain(msm.metastable_sets)""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 28,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""ename"": ""NameError"",
+     ""evalue"": ""name 'path_fluxes' is not defined"",
+     ""output_type"": ""error"",
+     ""traceback"": [
+      ""\u001b[0;31m---------------------------------------------------------------------------\u001b[0m"",
+      ""\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)"",
+      ""\u001b[0;32m<ipython-input-28-e4c5aa91e98b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpath_fluxes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m"",
+      ""\u001b[0;31mNameError\u001b[0m: name 'path_fluxes' is not defined""
+     ]
+    }
+   ],
+   ""source"": [
+    ""path_fluxes""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 27,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stdout"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""percentage       \tpath\n"",
+      ""-------------------------------------\n"",
+      ""0.769  \t [1 5 6]\n"",
+      ""0.218  \t [1 6]\n"",
+      ""0.007  \t [1 2 3 6]\n"",
+      ""0.006  \t [1 4 5 6]\n""
+     ]
+    }
+   ],
+   ""source"": [
+    ""paths, path_fluxes = cgflux.pathways(fraction=0.99)\n"",
+    ""print('percentage       \\tpath')\n"",
+    ""print('-------------------------------------')\n"",
+    ""for i in range(len(paths)):\n"",
+    ""    print(np.round(path_fluxes[i] / np.sum(path_fluxes), 3),' \\t', paths[i] + 1)""
+   ]
+  },
+  {
+   ""cell_type"": ""markdown"",
+   ""metadata"": {},
+   ""source"": [
+    ""## CK Test""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": 24,
+   ""metadata"": {},
+   ""outputs"": [
+    {
+     ""name"": ""stderr"",
+     ""output_type"": ""stream"",
+     ""text"": [
+      ""100%|██████████| 4/4 [01:57<00:00, 29.39s/it]                         \n""
+     ]
+    },
+    {
+     ""data"": {
+      ""image/png"": ""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\n"",
+      ""text/plain"": [
+       ""<Figure size 720x720 with 36 Axes>""
+      ]
+     },
+     ""metadata"": {
+      ""needs_background"": ""light""
+     },
+     ""output_type"": ""display_data""
+    }
+   ],
+   ""source"": [
+    ""nstates = 6\n"",
+    ""cktest = msm.cktest(nstates, mlags=5)\n"",
+    ""pyemma.plots.plot_cktest(cktest, dt=1/50, units='ns');""
+   ]
+  },
+  {
+   ""cell_type"": ""code"",
+   ""execution_count"": null,
+   ""metadata"": {},
+   ""outputs"": [],
+   ""source"": []
+  }
+ ],
+ ""metadata"": {
+  ""kernelspec"": {
+   ""display_name"": ""Python 3"",
+   ""language"": ""python"",
+   ""name"": ""python3""
+  },
+  ""language_info"": {
+   ""codemirror_mode"": {
+    ""name"": ""ipython"",
+    ""version"": 3
+   },
+   ""file_extension"": "".py"",
+   ""mimetype"": ""text/x-python"",
+   ""name"": ""python"",
+   ""nbconvert_exporter"": ""python"",
+   ""pygments_lexer"": ""ipython3"",
+   ""version"": ""3.6.15""
+  }
+ },
+ ""nbformat"": 4,
+ ""nbformat_minor"": 4
+}
+","Unknown"
+"AlphaFold","sbhakat/AF-cryptic-pocket","Trp-msm-crypticpocket/feature-gen.py",".py","1716","57","#msmbuilder imports 
+from msmbuilder.dataset import dataset
+from msmbuilder.featurizer import ContactFeaturizer
+from msmbuilder.featurizer import DihedralFeaturizer
+from msmbuilder.decomposition import tICA
+from msmbuilder.cluster import MiniBatchKMeans
+from msmbuilder.msm import ContinuousTimeMSM
+from msmbuilder.utils import verbosedump,verboseload
+from msmbuilder.cluster import KCenters
+from msmbuilder.utils import load,dump
+
+#other imports
+import os,glob,shutil
+import numpy as np
+import mdtraj as md
+import pandas as pd 
+import pickle
+#prettier plots
+
+#Loading the trajectory
+ref = md.load('prot.pdb')
+#a = ref.top.select(""resid 73 to 87"")
+b = ref.top.select(""resid 42"")
+#c = np.concatenate((b, a), axis=None)
+
+## Path to .xtc files
+ds = dataset(""../*.xtc"", topology=""prot.pdb"", atom_indices=b, stride=20)
+
+
+#Featurization
+featurizer = DihedralFeaturizer(types=['chi1', 'chi2'])
+dump(featurizer,""transformed_raw_featurizer.pkl"")
+
+#from msmbuilder.utils import load,dump
+f=DihedralFeaturizer(types=['chi1', 'chi2'], sincos=False)
+dump(f,""raw_featurizer.pkl"")
+
+#featurizer = DihedralFeaturizer(types=['chi1', 'chi2'], resids= 73,74,75,76,77,78,79,80,81,82,83)
+diheds = featurizer.fit_transform(ds)
+dump(diheds, ""features.pkl"")
+                            
+dihedsraw = f.fit_transform(ds)
+dump(dihedsraw, ""raw-features.pkl"")     
+#print(ds[0].shape)
+print(diheds[0].shape)
+
+# this basically maps every feature to atom indices. 
+#df1 = pd.DataFrame(featurizer.describe_features(ds))
+#dump(df1, ""feature_descriptor.pkl"")
+
+#Robust scaling
+from msmbuilder.preprocessing import RobustScaler
+scaler = RobustScaler()
+scaled_diheds = scaler.fit_transform(diheds)
+
+dump(scaled_diheds, ""scaled-transformed-features.pkl"")
+","Python"
+"AlphaFold","benjaminlozanow/pdb_data_download","unzip_flatten.sh",".sh","1547","53","#!/bin/bash
+
+##################################################################
+# Adapted script from: 
+# https://github.com/deepmind/alphafold/blob/main/scripts/download_pdb_mmcif.sh
+# Description: Unzips and flattens files from the PDB (mmCIFs for AlphaFold).
+# Example: ./unzip_flatten.sh absolute/path/to/the/downloaded/directory/mmCIF
+####################################################################
+# 
+#
+# Usage: bash download_pdb_mmcif.sh /path/to/download/directory
+set -e
+
+if [[ $# -eq 0 ]]; then
+    echo ""Error: download directory must be provided as an input argument.""
+    exit 1
+fi
+
+if ! command -v aria2c &> /dev/null ; then
+    echo ""Error: aria2c could not be found. Please install aria2c (sudo apt install aria2).""
+    exit 1
+fi
+
+if ! command -v rsync &> /dev/null ; then
+    echo ""Error: rsync could not be found. Please install rsync.""
+    exit 1
+fi
+
+DOWNLOAD_DIR=""$1""
+ROOT_DIR=""${DOWNLOAD_DIR%/*}/data""
+RAW_DIR=""${ROOT_DIR}/raw""
+FILES_DIR=""${ROOT_DIR}/files""
+
+mkdir -p ""${RAW_DIR}""
+mv ""${DOWNLOAD_DIR}""/* ${RAW_DIR}
+
+echo ""Unzipping files...""
+find ""${RAW_DIR}/"" -type f -iname ""*.gz"" -exec gunzip {} +
+
+echo ""Flattening files...""
+mkdir -p ""${FILES_DIR}""
+find ""${RAW_DIR}"" -type d -empty -delete  # Delete empty directories.
+for subdir in ""${RAW_DIR}""/*; do
+  mv ""${subdir}/""*.* ""${FILES_DIR}""
+done
+
+echo ""Deleting empty folders...""
+rm -r $RAW_DIR
+rm -r $DOWNLOAD_DIR
+
+# Uncomment if you are trying to download de mmCIF data for alphafold
+# aria2c ""ftp://ftp.wwpdb.org/pub/pdb/data/status/obsolete.dat"" --dir=""${ROOT_DIR}""
+","Shell"
+"AlphaFold","benjaminlozanow/pdb_data_download","download_pdb.sh",".sh","3239","92","#!/usr/bin/env bash
+
+##################################################################
+# Adapted script from: 
+# https://github.com/kajeagentspi/Datahoarder/blob/master/theripper.sh
+# Description: Alternative method (to rsync) to download files from 
+# https://files.wwpdb.org/pub/pdb/data/structures/divided/ using wget spider and aria2
+# Example: ./download_pdb.sh ""https://files.wwpdb.org/pub/pdb/data/structures/divided/mmCIF"" 
+####################################################################
+
+set -e
+
+URI=$1
+URL=$URI""/""
+echo ""This URL should end with a /:""
+echo $URL
+ROOT_PATH=${URI%/*}
+echo ""This URL should NOT end with a /:""
+echo $ROOT_PATH
+LIST=./list.txt
+MAX_CONNECTIONS_PER_SERVER=16
+USER_AGENT=""Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36""
+
+usage() {
+	cat <<EOF
+Uses wget's spider with aria2c's parallel for downloading open
+directories.
+Usage: $SCRIPT_NAME [options] URL PATH
+EOF
+}
+
+spider() {
+	local logfile=./opendir.log
+	wget -o $logfile -e robots=off -r --no-parent --spider -U ""$USER_AGENT"" ""$URL"" || true
+	# Grabs all lines with the pattern --2017-07-12 15:40:31-- then from the results removes everthing that ends in / (meaning it's a directory
+	# then removes pattern from every line
+	grep -B 2 -E '... 404 Not Found|... 403 Forbidden|... 301 Moved Permanently' $logfile | \
+	grep -i '^--[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]--' | \
+	grep '[^'/']$'  | sed -e 's/^--[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]--  //g' > $logfile.tmp
+	while read line; do
+		sed -i ""\|$line|d"" $logfile
+	done < $logfile.tmp
+	cat $logfile | grep -i '^--[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]--' | \
+	grep '[^'/']$'  | sed -e 's/^--[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]--  //g' | \
+	# Filter URLs that are compressed UNIX files
+	grep '.*\.gz$' > $LIST
+	#Delete the folder made by wget (deletes all empty directories in the directory this script is run)
+	find . -type d -empty -delete
+}
+
+download() {
+	while read link; do
+		#urldecode the links
+		DECODED_LINK=$(echo $link | printf ""%b\n"" ""$(sed 's/+/ /g; s/%\([0-9a-f][0-9a-f]\)/\\x\1/g;')"";)
+		DECODED_ROOT_PATH=$(echo $ROOT_PATH | printf ""%b\n"" ""$(sed 's/+/ /g; s/%\([0-9a-f][0-9a-f]\)/\\x\1/g;')"";)
+		# Remove text after last /
+		FULL_PATH=$(echo $DECODED_LINK | sed 's%/[^/]*$%/%')
+		FILE_PATH=${FULL_PATH#${DECODED_ROOT_PATH}/}
+		echo ""${link}"" >> link.down
+		echo "" dir=$FILE_PATH"" >> link.down
+		echo "" continue=true"" >> link.down
+		echo "" max-connection-per-server=$MAX_CONNECTIONS_PER_SERVER"" >> link.down
+		echo "" split=16"" >> link.down
+		echo "" user-agent=$USER_AGENT"" >> link.down
+		echo "" header=Accept: text/html"" >> link.down
+		echo -e "" min-split-size=1M\n"" >> link.down
+	done  < $LIST
+	#Download links
+	aria2c -i link.down -j 16
+
+}
+
+if [[ -z $1 || $# -ge 2 ]]; then
+	usage
+	exit 1
+fi
+
+# Comment spider or download if you want to perform analysis separetly
+echo ""Creating list of urls...""
+spider
+echo ""Index created!""
+
+echo ""Downloading...""
+download
+
+# Cleanup removes temporal files
+# rm opendir.log
+# rm opendir.log.tmp
+# rm list.txt
+# rm link.down
+
+","Shell"
+"AlphaFold","piercelab/tcrmodel2","run_tcrmodel2_ub_tcr.py",".py","7832","207","# Load required packages
+import os
+import sys
+import pandas as pd
+import json
+from absl import flags
+from absl import app
+from glob import glob
+import subprocess 
+from anarci import anarci
+
+from scripts import seq_utils,pdb_utils,tcr_utils,parse_tcr_seq
+
+# input
+flags.DEFINE_string('output_dir', ""experiments/"", 'Path to output directory.')
+flags.DEFINE_string('tcra_seq', None, 'TCR alpha sequence')
+flags.DEFINE_string('tcrb_seq', None, 'TCR beta sequence')
+flags.DEFINE_string('job_id', ""test001"", 'Job id')
+flags.DEFINE_string('ignore_pdbs_string', None, ""Currently not supported"")
+flags.DEFINE_string('max_template_date', ""2100-01-01"", ""Max template date, ""
+                    ""format yyyy-mm-dd. Default to 2100-01-01."")
+flags.DEFINE_bool('relax_structures', False, ""Run amber minimization ""
+                  ""on the structures"")
+flags.DEFINE_string(""tp_db"", ""data/databases"" , 
+                    ""Customized TCR pMHC database path"")
+flags.DEFINE_string(""ori_db"", None,
+                    ""Path to the database with pdb_mmcif database"")
+
+FLAGS = flags.FLAGS
+
+def main(_argv):
+    output_dir=FLAGS.output_dir
+    tcra_seq=FLAGS.tcra_seq
+    tcrb_seq=FLAGS.tcrb_seq
+    job_id=FLAGS.job_id
+    max_template_date=FLAGS.max_template_date
+    relax_structures=FLAGS.relax_structures
+    tp_db=FLAGS.tp_db
+    ori_db=FLAGS.ori_db
+
+    if len(max_template_date)==0:
+        max_template_date=""2100-01-01""
+
+    models_to_relax=""none""
+    if relax_structures==True:
+        models_to_relax=""all""
+
+    # create output directory
+    out_dir=os.path.join(output_dir,job_id)
+
+    # make output directory
+    os.makedirs(out_dir, exist_ok=True)
+
+    # trim tcr sequence to variable domain only
+    anarci_tcra=anarci([('tcra', tcra_seq)], scheme=""aho"", output=False)
+    anarci_tcrb=anarci([('tcrb', tcrb_seq)], scheme=""aho"", output=False)
+    tcra_seq="""".join([item[-1] for item in anarci_tcra[0][0][0][0] if item[-1] != '-'])
+    tcrb_seq="""".join([item[-1] for item in anarci_tcrb[0][0][0][0] if item[-1] != '-'])
+
+    # create fasta files 
+    fasta_fn=os.path.join(out_dir, ""%s.fasta"" % job_id)
+    fasta="">TCRa\n%s\n"" % tcra_seq
+    fasta+="">TCRb\n%s\n"" % tcrb_seq
+    with open(fasta_fn,'w+') as fh:
+        fh.write(fasta)
+
+    # create status file and update it
+    status_file=os.path.join(out_dir,""modeling_status.txt"")
+
+    ###################
+    # build structure #
+    ###################
+    databases=(f""--uniref90_database_path={tp_db}/uniref90.tcrmhc.fasta "" 
+            f""--mgnify_database_path={tp_db}/mgnify.fasta ""
+            f""--template_mmcif_dir={ori_db}/pdb_mmcif/mmcif_files/ ""
+            f""--obsolete_pdbs_path={ori_db}/pdb_mmcif/obsolete.dat ""
+            f""--small_bfd_database_path={tp_db}/small_bfd.tcrmhc.fasta ""
+            f""--pdb_seqres_database_path={tp_db}/pdb_seqres.txt ""
+            f""--uniprot_database_path={tp_db}/uniprot.tcrmhc.fasta ""
+            f""--data_dir={ori_db}"")
+    cmd=(f""python run_alphafold_tcrmodel2.3.py --db_preset=reduced_dbs ""
+         f""--fasta_paths={out_dir}/{job_id}.fasta "" 
+         f""--model_preset=multimer --output_dir={out_dir} {databases} ""
+         f""--max_template_date={max_template_date} ""
+         f""--use_gpu_relax={relax_structures} --models_to_relax={models_to_relax} ""
+         ""--use_precomputed_msas=True --num_multimer_predictions_per_model=1 "" 
+         f""--save_template_names --status_file={status_file}"")
+    subprocess.run(cmd, shell=True)
+
+    # renumber chains to start with A if not relax_structures
+    if not relax_structures:
+        models_list = [i for i in glob(f""{out_dir}/{job_id}/*.pdb"") if os.path.basename(i).startswith('ranked')]
+        for pdb_fn in models_list:
+            pdb=[]
+            with open(pdb_fn) as fh:
+                for line in fh:
+                    if line[0:4] == 'ATOM':
+                        pdb.append(line.rstrip())
+            pdb_renum=pdb_utils.rename_chains_start_A_and_1(pdb)
+            pdb_renum_fn = pdb_fn.replace('.pdb', '_renum.pdb')
+            with open(pdb_renum_fn,'w+') as fh:
+                fh.write(""\n"".join(pdb_renum))
+            subprocess.run(""mv %s %s"" % (pdb_renum_fn, pdb_fn), shell=True)
+
+
+    ####################
+    # Parse statistics #
+    ####################
+    out_json={}
+    
+    #get scores
+    items=['model_confidence','plddt','ptm','iptm']
+
+    with open(""%s/%s/model_scores.txt"" % (out_dir, job_id)) as fh:
+        for idx, line in enumerate(fh):
+            scores=line.rstrip().split(""\t"")
+            out_json[""ranked_%d"" % (idx)]={
+                items[0]:float(scores[0]),
+                items[1]:float(scores[1]),
+                items[2]:float(scores[2]),
+                items[3]:float(scores[3])
+            }
+
+    #get templates
+    def get_template(tmplt_path):
+        tmplts=[]
+        N=0
+        with open(tmplt_path) as fh:
+            for line in fh:
+                if N==4:
+                    break
+                tmplts.append(line.rstrip())
+                N+=1
+        return tmplts
+
+    tmplt_path_prefix=""%s/%s/msas"" % (out_dir, job_id)
+    out_json[""tcra_tmplts""]=get_template(""%s/A/template_names.txt"" % tmplt_path_prefix)
+    out_json[""tcrb_tmplts""]=get_template(""%s/B/template_names.txt"" % tmplt_path_prefix)
+
+
+    # clean up unwanted files
+    subprocess.run(""mv %s/%s/ranked*pdb %s/; "" % (out_dir, job_id, out_dir), shell=True)
+    subprocess.run(""rm -rf %s/%s*; "" % (out_dir, job_id), shell=True)
+
+
+    ####################
+    # # Renumber output  #
+    ####################
+    
+    models_list = [i for i in glob('%s/*' % (out_dir)) if os.path.basename(i).startswith('ranked')]
+    for model in models_list:
+        tcr_utils.renumber_tcr_pdb(model, '%s/%s' % (out_dir, os.path.basename(model)))
+
+    # align all to ranked_0's pMHC
+    try:
+        models_list = [i for i in glob(f""{out_dir}/*.pdb"") if os.path.basename(i).startswith('ranked')]
+        ref=""%s/ranked_0.pdb"" % out_dir
+        for pdb in models_list:
+            pdb_aln = pdb.replace('.pdb', '_aln.pdb')
+            pdb_utils.align_pdbs(ref, pdb, pdb_aln)
+            subprocess.run(""mv %s %s"" % (pdb_aln, pdb), shell=True)
+    except:
+        print(""unable to align pdbs"")
+
+    #parse tcr template sequences
+    tcr_out_json={}
+    for chain in ""ab"":
+        tcr_key = f""tcr{chain}_seqs""
+        tcr_out_json[tcr_key] = {}
+        for pdb_chain in out_json[f""tcr{chain}_tmplts""]:
+            in_seq = parse_tcr_seq.get_seq(pdb_chain)
+            tcr_out_json[tcr_key][pdb_chain] = parse_tcr_seq.parse_tcr(in_seq)
+
+    tcr_out_json[""tcra_user""] = parse_tcr_seq.parse_tcr(tcra_seq)
+    tcr_out_json[""tcrb_user""] = parse_tcr_seq.parse_tcr(tcrb_seq)
+
+
+    tcr_json_output_path = os.path.join(out_dir, 'tcr_seqs.json')
+    with open(tcr_json_output_path, 'w') as f:
+        f.write(json.dumps(tcr_out_json, indent=4))
+
+
+    #get CDR3s confidence scores 
+    def get_cdr3_conf(pdb_path):
+       import MDAnalysis as mda
+       pdb_u = mda.Universe(pdb_path)
+       cdr3a_bfactors_avg = pdb_u.select_atoms('chainID D and resid 106:139').atoms.bfactors.mean()
+       cdr3b_bfactors_avg = pdb_u.select_atoms('chainID E and resid 106:139').atoms.bfactors.mean()
+       return cdr3a_bfactors_avg, cdr3b_bfactors_avg
+
+    models_list = [i for i in glob('%s/*' % (out_dir)) if os.path.basename(i).startswith('ranked')]
+    for model in models_list:
+       cdr3a_bfactors_avg, cdr3b_bfactors_avg = get_cdr3_conf(model)
+       out_json[os.path.basename(model).split('.pdb')[0]]['cdr3a_plddt'] = cdr3a_bfactors_avg
+       out_json[os.path.basename(model).split('.pdb')[0]]['cdr3b_plddt'] = cdr3b_bfactors_avg
+
+    json_output_path = os.path.join(out_dir, 'statistics.json')
+    with open(json_output_path, 'w') as f:
+        f.write(json.dumps(out_json, indent=4))
+
+
+if __name__ == '__main__':
+    try:
+        app.run(main)
+    except SystemExit:
+        pass
+","Python"
+"AlphaFold","piercelab/tcrmodel2","run_tcrmodel2.py",".py","17009","408","# Load required packages
+# import pandas as pd
+import json
+import os
+import subprocess
+import sys
+from glob import glob
+
+from absl import app, flags
+from anarci import anarci
+
+from scripts import parse_tcr_seq, pdb_utils, pmhc_templates, seq_utils, tcr_utils
+
+# import shutil
+
+
+
+# input
+flags.DEFINE_string('output_dir', ""experiments/"", 
+                    'Path to output directory.')
+flags.DEFINE_string('tcra_seq', None, 'TCR alpha sequence')
+flags.DEFINE_string('tcrb_seq', None, 'TCR beta sequence')
+flags.DEFINE_string('pep_seq', None, 'Peptide sequence')
+flags.DEFINE_string('mhca_seq', None, 'MHC alpha sequence. If your target is a class I '
+                    'TCR-pMHC complex, then this input should contain the alpha 1 and '
+                     'alpha 2 domain sequence. If your target is a class II TCR-pMHC '
+                     'complex, then this input should contain alpha 1 domain sequence. '
+                     'If your input has more than the above-mentioned domain(s), the function '
+                     'seq_utils.trim_mhc will trim the input sequence down to the desired domains.')
+flags.DEFINE_string('mhcb_seq', None, 'MHC beta sequence. Leave this argument blank, or '
+                    'leave it out completely if your target is a class I TCR-pMHC complex. '
+                    'If your target is a class II TCR-pMHC complex, this input should '
+                    'contain beta 1 domain sequence. If your input has more than the '
+                    'above-mentioned domain(s), the function seq_utils.trim_mhc will '
+                    'trim the input sequence down to the desired domains.')
+flags.DEFINE_string('job_id', ""test001"", 'Job id')
+flags.DEFINE_string('ignore_pdbs_string', None, ""Do not use these pdbs as pmhc ""
+                    ""templates, comma seperated pdb string, no space in between. ""
+                    ""Can be upper or lower case. "")
+flags.DEFINE_string('max_template_date', ""2100-01-01"", ""Max template date, ""
+                    ""format yyyy-mm-dd. Default to 2100-01-01."")
+flags.DEFINE_bool('relax_structures', False, ""Run amber minimization ""
+                  ""on the structures"")
+flags.DEFINE_string(""tp_db"", ""data/databases"" , 
+                    ""Customized TCR pMHC database path"")
+flags.DEFINE_string(""ori_db"", None,
+                    ""Path to AlphaFold database with pdb_mmcif and params"")
+
+FLAGS = flags.FLAGS
+
+def main(_argv):
+    output_dir=FLAGS.output_dir
+    tcra_seq=FLAGS.tcra_seq
+    tcrb_seq=FLAGS.tcrb_seq
+    pep_seq=FLAGS.pep_seq
+    mhca_seq=FLAGS.mhca_seq
+    mhcb_seq=FLAGS.mhcb_seq
+    job_id=FLAGS.job_id
+    ignore_pdbs_string=FLAGS.ignore_pdbs_string
+    max_template_date=FLAGS.max_template_date
+    relax_structures=FLAGS.relax_structures
+    tp_db=FLAGS.tp_db
+    ori_db=FLAGS.ori_db
+
+    if len(max_template_date)==0:
+        max_template_date=""2100-01-01""
+        
+    models_to_relax=""none""
+    if relax_structures==True:
+        models_to_relax=""all""
+    # process ignore_pdb list
+    ignore_pdbs=[]
+    if ignore_pdbs_string:
+        try:
+            ignore_pdbs=[pdb.lower() for pdb in ignore_pdbs_string.split("","")]
+        except:
+            ignore_pdbs=[]
+
+    # create output directory
+    out_dir=os.path.join(output_dir,job_id)
+    os.makedirs(out_dir, exist_ok=True)
+
+    # check MHC class of the complex
+    mhc_cls=1
+    if mhcb_seq:
+        mhc_cls=2
+
+    # check peptide length of the user input
+    pep_len = len(pep_seq)
+    if mhc_cls==1:
+        if pep_len < 8 or pep_len > 15:
+            print(f""It looks like your input peptide is {pep_len} amino acids long. For class I TCR-pMHC complexes, kindly ensure the peptide length is between 8-15."")
+            sys.exit()
+    else:
+        if pep_len != 11:
+            print(f""It looks like your input peptide is {pep_len} amino acids (aa) long. For class II TCR-pMHC complexes, kindly ensure that the peptide input is 11 aa in length. Specifically, it should consist of a 9 aa core with an additional 1 aa at both the N-terminal and C-terminal of the core peptide."")
+            sys.exit()
+    
+    # trim tcr sequence to variable domain only
+    anarci_tcra=anarci([('tcra', tcra_seq)], scheme=""aho"", output=False)
+    anarci_tcrb=anarci([('tcrb', tcrb_seq)], scheme=""aho"", output=False)
+    tcra_seq="""".join([item[-1] for item in anarci_tcra[0][0][0][0] if item[-1] != '-'])
+    tcrb_seq="""".join([item[-1] for item in anarci_tcrb[0][0][0][0] if item[-1] != '-'])
+
+    # trim mhc sequence to relevant domains only
+    if mhc_cls==1:
+        try:
+            mhca_seq=seq_utils.trim_mhc(mhca_seq, ""1"", ""."", out_dir)
+        except:
+            print(""Fail to identify alpha 1 and alpha 2 domain sequence in the 'mhca_seq' ""
+                  ""input of your class I MHC target."")
+            sys.exit()
+    else:
+        try:
+            mhca_seq=seq_utils.trim_mhc(mhca_seq, ""2"", ""."", out_dir)
+        except:
+            print(""Fail to identify alpha 1 domain sequence in the 'mhca_seq' ""
+                  ""input of your class II MHC target. If your input target is a class I ""
+                  ""TCR-pMHC complex, then mhcb_seq variable should be left empty or left ""
+                  ""out completely."")
+            sys.exit()
+        try:
+            mhcb_seq=seq_utils.trim_mhc(mhcb_seq, ""3"", ""."", out_dir)
+        except:
+            print(""Fail to identify beta 1 domain sequence in the 'mhcb_seq' ""
+                  ""input of your class II MHC target. If your input target is a class I ""
+                  ""TCR-pMHC complex, then mhcb_seq variable should be left empty or left ""
+                  ""out completely."")
+            sys.exit()
+
+    # build pmhc templates
+    if mhc_cls==1:
+        pmhc_templates.gen_align_file_cls1(pep_seq, mhca_seq, out_dir, ignore_pdbs, max_template_date)
+    else:
+        pmhc_templates.gen_align_file_corep1_cls2(pep_seq, mhca_seq, mhcb_seq, out_dir, ignore_pdbs, max_template_date)
+
+    # create status file and update it
+    status_file=os.path.join(out_dir,""modeling_status.txt"")
+    with open(status_file, 'w') as fh:
+        fh.write(""Template features for pMHC created! Now generating MSA features and TCR template features...\n"")
+
+    # create fasta files 
+    fasta_fn=os.path.join(out_dir, ""%s.fasta"" % job_id)
+    pmhc_oc_fasta_fn=os.path.join(out_dir, ""%s_pmhc_oc.fasta"" % job_id)
+
+    fasta="">TCRa\n%s\n"" % tcra_seq
+    fasta+="">TCRb\n%s\n"" % tcrb_seq
+    fasta+="">Peptide\n%s\n"" % pep_seq
+    fasta+="">MHCa\n%s\n"" % mhca_seq
+    if mhc_cls==2:
+        fasta+="">MHCb\n%s\n"" % mhcb_seq
+
+    pmhc_oc_fasta="">TCRa\n%s\n"" % tcra_seq
+    pmhc_oc_fasta+="">TCRb\n%s\n"" % tcrb_seq
+    pmhc_oc_fasta+="">pMHC\n%s:%s"" % (pep_seq, mhca_seq)
+    if mhc_cls==2:
+        pmhc_oc_fasta+="":%s\n"" % mhcb_seq
+
+    with open(fasta_fn,'w+') as fh:
+        fh.write(fasta)
+    with open(pmhc_oc_fasta_fn,'w+') as fh:
+        fh.write(pmhc_oc_fasta)
+
+    ###############
+    # build MSA #
+    ###############
+
+    template_string="",,,""
+    if mhc_cls==2:
+        template_string="",,,,""
+    databases=(f""--uniref90_database_path={tp_db}/uniref90.tcrmhc.fasta "" 
+            f""--mgnify_database_path={tp_db}/mgnify.fasta ""
+            f""--template_mmcif_dir={ori_db}/pdb_mmcif/mmcif_files/ ""
+            f""--obsolete_pdbs_path={ori_db}/pdb_mmcif/obsolete.dat ""
+            f""--small_bfd_database_path={tp_db}/small_bfd.tcrmhc.fasta ""
+            f""--pdb_seqres_database_path={tp_db}/pdb_seqres.txt ""
+            f""--uniprot_database_path={tp_db}/uniprot.tcrmhc.fasta ""
+            f""--data_dir={ori_db}"")
+    cmd=(f""python run_alphafold_tcrmodel2.3.py --db_preset=reduced_dbs ""
+         f""--fasta_paths={out_dir}/{job_id}.fasta ""
+         f""--model_preset=multimer --output_dir={out_dir} {databases} ""
+         f""--max_template_date={max_template_date} --use_gpu_relax=False ""
+         f""--save_msa_features_only --gen_feats_only ""
+         f""--models_to_relax=none --feature_prefix=msa ""
+         f""--save_template_names --use_custom_templates ""
+         f""--template_alignfile={template_string}"")
+    subprocess.run(cmd, shell=True)
+
+    # remove unwanted files to save space
+    subprocess.run(""rm -rf %s/%s/msas/"" % (out_dir, job_id), shell=True)
+
+    ###################
+    # build structure #
+    ###################
+    # model_log_output=os.path.join(out_dir, ""modeling_log.txt"")
+    cmd=(f""python run_alphafold_tcrmodel2.3.py --db_preset=reduced_dbs ""
+         f""--fasta_paths={out_dir}/{job_id}_pmhc_oc.fasta ""
+         f""--model_preset=multimer --output_dir={out_dir} {databases} ""
+         ""--use_custom_templates --template_alignfile=UseDefaultTemplate,""
+         f""UseDefaultTemplate,{out_dir}/pmhc_alignment.tsv ""
+         f""--max_template_date={max_template_date} ""
+         f""--use_gpu_relax={relax_structures} ""
+         f""--models_to_relax={models_to_relax} --use_precomputed_msas=True ""
+         ""--num_multimer_predictions_per_model=1  --save_template_names ""
+         ""--has_gap_chn_brk --msa_mode=single_sequence --iptm_interface=1:1:2 ""
+         f""--substitute_msa={out_dir}/{job_id}/msa_features.pkl ""
+         f""--status_file={status_file}"" )
+    subprocess.run(cmd, shell=True)
+
+    # renumber chains to start with A if not relax_structures
+    if not relax_structures:
+        models_list = [i for i in glob(f""{out_dir}/{job_id}_pmhc_oc/*.pdb"") if os.path.basename(i).startswith('ranked')]
+        for pdb_fn in models_list:
+            pdb=[]
+            with open(pdb_fn) as fh:
+                for line in fh:
+                    if line[0:4] == 'ATOM':
+                        pdb.append(line.rstrip())
+            pdb_renum=pdb_utils.rename_chains_start_A_and_1(pdb)
+            pdb_renum_fn = pdb_fn.replace('.pdb', '_renum.pdb')
+            with open(pdb_renum_fn,'w+') as fh:
+                fh.write(""\n"".join(pdb_renum))
+            subprocess.run(""mv %s %s"" % (pdb_renum_fn, pdb_fn), shell=True)
+
+
+    ####################
+    # Parse statistics #
+    ####################
+    out_json={}
+    
+    #get scores
+    items=['ranking_confidence','plddt','ptm','iptm','tcr-pmhc_iptm']
+
+    with open(""%s/%s_pmhc_oc/model_scores.txt"" % (out_dir, job_id)) as fh:
+        for idx, line in enumerate(fh):
+            scores=line.rstrip().split(""\t"")
+            out_json[""ranked_%d"" % (idx)]={
+                items[0]:float(scores[0]),
+                items[1]:float(scores[1]),
+                items[2]:float(scores[2]),
+                items[3]:float(scores[3]),
+                items[4]:float(scores[4])
+                }
+
+    #get templates
+    def get_template(tmplt_path):
+        tmplts=[]
+        N=0
+        with open(tmplt_path) as fh:
+            for line in fh:
+                if N==4:
+                    break
+                tmplts.append(line.rstrip())
+                N+=1
+        return tmplts
+
+    tmplt_path_prefix=""%s/%s_pmhc_oc/msas"" % (out_dir, job_id)
+    out_json[""tcra_tmplts""]=get_template(""%s/A/template_names.txt"" % tmplt_path_prefix)
+    out_json[""tcrb_tmplts""]=get_template(""%s/B/template_names.txt"" % tmplt_path_prefix)
+    out_json[""pmhc_tmplts""]=get_template(""%s/C/template_names.txt"" % tmplt_path_prefix)
+
+    json_output_path = os.path.join(out_dir, 'statistics.json')
+    with open(json_output_path, 'w') as f:
+        f.write(json.dumps(out_json, indent=4))
+
+    # clean up unwanted files
+    subprocess.run(""mv %s/%s_pmhc_oc/ranked*pdb %s/; "" % (out_dir, job_id, out_dir), shell=True)
+    subprocess.run(""rm -rf %s/%s*; "" % (out_dir, job_id), shell=True)
+    subprocess.run(""rm %s/pmhc_alignment.tsv; "" % (out_dir), shell=True)
+    
+        
+    ####################
+    # Renumber output  #
+    ####################
+    
+    models_list = [i for i in glob('%s/*' % (out_dir)) if os.path.basename(i).startswith('ranked')]
+    for model in models_list:
+        tcr_utils.renumber_pdb(model, '%s/%s' % (out_dir, os.path.basename(model)), mhc_cls)   
+
+    # align all to ranked_0's pMHC
+    try:
+        models_list = [i for i in glob(f""{out_dir}/*.pdb"") if os.path.basename(i).startswith('ranked')]
+        ref=""%s/ranked_0.pdb"" % out_dir
+        for pdb in models_list:
+            pdb_aln = pdb.replace('.pdb', '_aln.pdb')
+            pdb_utils.align_pdbs_by_pmhc(ref, pdb, pdb_aln, mhc_cls)
+            subprocess.run(""mv %s %s"" % (pdb_aln, pdb), shell=True)
+    except:
+        print(""unable to align pdbs"")
+
+
+    #get CDR3s confidence scores 
+    def get_cdr3_conf(pdb_path):
+       import MDAnalysis as mda
+       pdb_u = mda.Universe(pdb_path)
+       cdr3a_bfactors_avg = pdb_u.select_atoms('chainID D and resid 106:139').atoms.bfactors.mean()
+       cdr3b_bfactors_avg = pdb_u.select_atoms('chainID E and resid 106:139').atoms.bfactors.mean()
+       return cdr3a_bfactors_avg, cdr3b_bfactors_avg
+
+    models_list = [i for i in glob('%s/*' % (out_dir)) if os.path.basename(i).startswith('ranked')]
+    for model in models_list:
+       cdr3a_bfactors_avg, cdr3b_bfactors_avg = get_cdr3_conf(model)
+       out_json[os.path.basename(model).split('.pdb')[0]]['cdr3a_plddt'] = cdr3a_bfactors_avg
+       out_json[os.path.basename(model).split('.pdb')[0]]['cdr3b_plddt'] = cdr3b_bfactors_avg
+
+    ## Calculating iplddt score
+     
+    def calc_iplddt(pdb_file):
+         
+         chn1= ""ABC""
+         chn2= ""DE""
+         dis_cut=4
+         lowest=-1.00
+         
+         try:
+             with open(pdb_file, 'r') as file:
+                 pdb_lines = file.readlines()
+         except IOError:
+             sys.exit(f""unable to open file: {pdb_file}"")
+         
+         chn1int = {char: 1 for char in chn1}
+         chn2int = {char: 1 for char in chn2}
+         
+         dis_cutoff = float(dis_cut) ** 2 
+         
+         chn1_int_plddt = {}
+         chn2_int_plddt = {}
+             
+         for line in pdb_lines:
+                 if not line.startswith(""ATOM""):
+                     continue
+                 if line[12] == ""H"" or line[13] == ""H"":
+                     continue
+                 res_num = line[22:27].strip()
+                 chn_id = line[21].strip()
+                 res_id = line[17:20].strip()
+                 atm_id = line[12:16].strip()
+                 plddt1 = float(line[60:66].strip())
+                 
+                 if chn1int.get(chn_id) == 1:
+                     x1 = float(line[30:38].strip())
+                     y1 = float(line[38:46].strip())
+                     z1 = float(line[46:54].strip())
+                     
+                     for line2 in pdb_lines:
+                         if not line2.startswith(""ATOM""):
+                             continue
+                         if line2[12] == ""H"" or line2[13] == ""H"":
+                             continue
+                         
+                         chn2 = line2[21].strip()
+                         res_num2 = line2[22:27].strip()
+                         res_id2 = line2[17:20].strip()
+                         atm_id = line2[12:16].strip()
+                         plddt2 = float(line2[60:66].strip())
+                         
+                         if chn2int.get(chn2) == 1:
+                             x2 = float(line2[30:38].strip())
+                             y2 = float(line2[38:46].strip())
+                             z2 = float(line2[46:54].strip())
+                             dist = ((x1 - x2)**2) + ((y1 - y2)**2) + ((z1 - z2)**2)
+                             if dist < dis_cutoff:
+                                 chn1_int_plddt[f""{res_num}\t{chn_id}\t{res_id}""] = plddt1
+                                 chn2_int_plddt[f""{res_num2}\t{chn2}\t{res_id2}""] = plddt2
+                             
+         weighted_sum = sum(chn1_int_plddt.values()) + sum(chn2_int_plddt.values())
+         counts = len(chn1_int_plddt) + len(chn2_int_plddt)
+         
+         final_score = lowest if counts == 0 else weighted_sum / counts
+         final_score = ""{:.2f}"".format(final_score)
+         
+         return final_score
+    
+    models_list = [i for i in glob('%s/*' % (out_dir)) if os.path.basename(i).startswith('ranked')]
+    for model in models_list:
+       iplddt_score = calc_iplddt(model)
+       out_json[os.path.basename(model).split('.pdb')[0]]['IpLDDT'] = iplddt_score
+    
+    #write statistics
+    json_output_path = os.path.join(out_dir, 'statistics.json')
+    with open(json_output_path, 'w') as f:
+        f.write(json.dumps(out_json, indent=4))
+
+    tcr_out_json = {}
+    #parse tcr template sequences
+    for chain in ""ab"":
+        tcr_key = f""tcr{chain}_seqs""
+        tcr_out_json[tcr_key] = {}
+        for pdb_chain in out_json[f""tcr{chain}_tmplts""]:
+            in_seq = parse_tcr_seq.get_seq(pdb_chain)
+            tcr_out_json[tcr_key][pdb_chain] = parse_tcr_seq.parse_tcr(in_seq)
+
+    tcr_out_json[""tcra_user""] = parse_tcr_seq.parse_tcr(tcra_seq)
+    tcr_out_json[""tcrb_user""] = parse_tcr_seq.parse_tcr(tcrb_seq)
+
+    tcr_json_output_path = os.path.join(out_dir, 'tcr_seqs.json')
+    with open(tcr_json_output_path, 'w') as f:
+        f.write(json.dumps(tcr_out_json, indent=4))
+
+
+
+if __name__ == '__main__':
+    try:
+        app.run(main)
+    except SystemExit:
+        pass
+    
+","Python"
+"AlphaFold","piercelab/tcrmodel2","run_alphafold_tcrmodel2.3.py",".py","30340","713","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Full AlphaFold protein structure prediction script.""""""
+import enum
+import json
+import os
+import pathlib
+import pickle
+import random
+import shutil
+import sys
+import time
+from typing import Any, Dict, Mapping, Union
+
+from absl import app
+from absl import flags
+from absl import logging
+from alphafold.common import protein
+from alphafold.common import residue_constants
+from alphafold.data import pipeline
+from alphafold.data import pipeline_multimer
+from alphafold.data import pipeline_custom_templates
+from alphafold.data import pipeline_multimer_custom_templates
+from alphafold.data import templates
+from alphafold.data.tools import hhsearch
+from alphafold.data.tools import hmmsearch
+from alphafold.model import config
+from alphafold.model import data
+from alphafold.model import model
+from alphafold.relax import relax
+
+import jax.numpy as jnp
+import numpy as np
+import pickle as pkl
+
+# Internal import (7716).
+
+logging.set_verbosity(logging.INFO)
+
+
+@enum.unique
+class ModelsToRelax(enum.Enum):
+  ALL = 0
+  BEST = 1
+  NONE = 2
+
+flags.DEFINE_list(
+    'fasta_paths', None, 'Paths to FASTA files, each containing a prediction '
+    'target that will be folded one after another. If a FASTA file contains '
+    'multiple sequences, then it will be folded as a multimer. Paths should be '
+    'separated by commas. All FASTA paths must have a unique basename as the '
+    'basename is used to name the output directories for each prediction.')
+
+flags.DEFINE_string('data_dir', None, 
+                    'Path to directory of supporting data.')
+flags.DEFINE_string('output_dir', None, 'Path to a directory that will '
+                    'store the results.')
+flags.DEFINE_string('jackhmmer_binary_path', shutil.which('jackhmmer'),
+                    'Path to the JackHMMER executable.')
+flags.DEFINE_string('hhblits_binary_path', shutil.which('hhblits'),
+                    'Path to the HHblits executable.')
+flags.DEFINE_string('hhsearch_binary_path', shutil.which('hhsearch'),
+                    'Path to the HHsearch executable.')
+flags.DEFINE_string('hmmsearch_binary_path', shutil.which('hmmsearch'),
+                    'Path to the hmmsearch executable.')
+flags.DEFINE_string('hmmbuild_binary_path', shutil.which('hmmbuild'),
+                    'Path to the hmmbuild executable.')
+flags.DEFINE_string('kalign_binary_path', shutil.which('kalign'),
+                    'Path to the Kalign executable.')
+flags.DEFINE_string('uniref90_database_path',None, 
+                    'Path to the Uniref90 database for use by JackHMMER.')
+flags.DEFINE_string('mgnify_database_path', None,
+                    'Path to the MGnify database for use by JackHMMER.')
+flags.DEFINE_string('bfd_database_path', None, 'Path to the BFD '
+                    'database for use by HHblits.')
+flags.DEFINE_string('small_bfd_database_path', None, 'Path to the small '
+                    'version of BFD used with the ""reduced_dbs"" preset.')
+flags.DEFINE_string('uniref30_database_path', None, 'Path to the UniRef30 '
+                    'database for use by HHblits.')
+flags.DEFINE_string('uniprot_database_path', None, 'Path to the Uniprot '
+                    'database for use by JackHMMer.')
+flags.DEFINE_string('pdb70_database_path', None, 'Path to the PDB70 '
+                    'database for use by HHsearch.')
+flags.DEFINE_string('pdb_seqres_database_path',None, 'Path to the PDB '
+                    'seqres database for use by hmmsearch.')
+flags.DEFINE_string('template_mmcif_dir', None, 'Path to a directory with '
+                    'template mmCIF structures, each named <pdb_id>.cif')
+flags.DEFINE_string('max_template_date', None, 'Maximum template release date '
+                    'to consider. Important if folding historical test sets.')
+flags.DEFINE_string('obsolete_pdbs_path', None, 'Path to file containing a '
+                    'mapping from obsolete PDB IDs to the PDB IDs of their '
+                    'replacements.')
+flags.DEFINE_enum('db_preset', 'full_dbs',
+                  ['full_dbs', 'reduced_dbs'],
+                  'Choose preset MSA database configuration - '
+                  'smaller genetic database config (reduced_dbs) or '
+                  'full genetic database config  (full_dbs)')
+flags.DEFINE_enum('model_preset', 'monomer',
+                  ['monomer', 'monomer_casp14', 'monomer_ptm', 'multimer'],
+                  'Choose preset model configuration - the monomer model, '
+                  'the monomer model with extra ensembling, monomer model with '
+                  'pTM head, or multimer model')
+flags.DEFINE_boolean('benchmark', False, 'Run multiple JAX model evaluations '
+                     'to obtain a timing that excludes the compilation time, '
+                     'which should be more indicative of the time required for '
+                     'inferencing many proteins.')
+flags.DEFINE_integer('random_seed', None, 'The random seed for the data '
+                     'pipeline. By default, this is randomly generated. Note '
+                     'that even if this is set, Alphafold may still not be '
+                     'deterministic, because processes like GPU inference are '
+                     'nondeterministic.')
+flags.DEFINE_integer('num_multimer_predictions_per_model', 5, 'How many '
+                     'predictions (each with a different random seed) will be '
+                     'generated per model. E.g. if this is 2 and there are 5 '
+                     'models then there will be 10 predictions per input. '
+                     'Note: this FLAG only applies if model_preset=multimer')
+flags.DEFINE_boolean('use_precomputed_msas', True, 'Whether to read MSAs that '
+                     'have been written to disk instead of running the MSA '
+                     'tools. The MSA files are looked up in the output '
+                     'directory, so it must stay the same between multiple '
+                     'runs that are to reuse the MSAs. WARNING: This will not '
+                     'check if the sequence, database or configuration have '
+                     'changed.')
+flags.DEFINE_enum_class('models_to_relax', ModelsToRelax.BEST, ModelsToRelax,
+                        'The models to run the final relaxation step on. '
+                        'If `all`, all models are relaxed, which may be time '
+                        'consuming. If `best`, only the most confident model '
+                        'is relaxed. If `none`, relaxation is not run. Turning '
+                        'off relaxation might result in predictions with '
+                        'distracting stereochemical violations but might help '
+                        'in case you are having issues with the relaxation '
+                        'stage.')
+flags.DEFINE_boolean('use_gpu_relax', None, 'Whether to relax on GPU. '
+                     'Relax on GPU can be much faster than CPU, so it is '
+                     'recommended to enable if possible. GPUs must be available'
+                     ' if this setting is enabled.')
+flags.DEFINE_boolean('use_custom_templates', False, 'Whether to use custom '
+                    'templates or not.')
+flags.DEFINE_string('template_alignfile', None, 'The path to the custom template'
+                    'files. If the target is a monomer, provide the template path '
+                    'as-is. If a multimer, provide all template alignment files '
+                    'the order they appear in the target, comma seperated. Leave '
+                    'the path blank if no template should be used for a chain. '
+                    'Write ""UseDefaultTemplate"" to use default alphafold pipeline '
+                    'for generating the template for that chain.')
+flags.DEFINE_string('msa_mode', None, 'Type ""single_sequence"" to not use any MSA')
+flags.DEFINE_integer('num_recycle', 3, 'How many recycles')
+flags.DEFINE_integer('num_ensemble', 1, 'How many ensembling iteractions')
+flags.DEFINE_enum('use_custom_MSA_database', ""none"", [""none"", ""add"", ""only""], 'Whether to use custom '
+                    'MSA database or not.')
+flags.DEFINE_string('MSA_database', None, 'The path to the custom MSA database'
+                    'files. If the target is a monomer, provide the template path '
+                    'as-is. If a multimer, provide all template alignment files '
+                    'the order they appear in the target, comma seperated.')
+flags.DEFINE_string('run_model_names', None, 'Specify parameter name to run. This'
+                    'is comma seperated alphafold parameter name. Only specified'
+                    'model names will be run.')
+flags.DEFINE_boolean('save_msa_fasta', False, 'Save msa features or not.')
+flags.DEFINE_boolean('gen_feats_only', False, 'Only generate features and do not'
+                    ' produce structure predictions.')
+flags.DEFINE_boolean('save_template_names', False, 'Save template id to txt file.')
+flags.DEFINE_boolean('has_gap_chn_brk', False, 'Have chain breaks introduced by "":"".')
+flags.DEFINE_string('substitute_msa', None, 'Path to feature.pkl whose MSA will '
+                    'be used to substitute whatever MSA that will be generated by '
+                    'this prediction round.')
+flags.DEFINE_boolean('msa_for_template_query_seq_only', True, 'msa_for_template_query_seq_only')
+flags.DEFINE_string('iptm_interface', None, 'iptm_interface')
+flags.DEFINE_string('feature_prefix', None, 'Feature prefix')
+flags.DEFINE_boolean('save_ranked_pdb_only', False, 'Do not save result pkl files '
+                     'or unrelaxed pdbs, or relaxed pdbs that are not ranked.')
+flags.DEFINE_boolean('save_msa_features_only', False, 'Only save msa related features.')
+flags.DEFINE_string(""status_file"", None, 'Status report file path.')
+
+
+FLAGS = flags.FLAGS
+
+MAX_TEMPLATE_HITS = 20
+RELAX_MAX_ITERATIONS = 0
+RELAX_ENERGY_TOLERANCE = 2.39
+RELAX_STIFFNESS = 10.0
+RELAX_EXCLUDE_RESIDUES = []
+RELAX_MAX_OUTER_ITERATIONS = 3
+
+
+def _check_flag(flag_name: str,
+                other_flag_name: str,
+                should_be_set: bool):
+  if should_be_set != bool(FLAGS[flag_name].value):
+    verb = 'be' if should_be_set else 'not be'
+    raise ValueError(f'{flag_name} must {verb} set when running with '
+                     f'""--{other_flag_name}={FLAGS[other_flag_name].value}"".')
+
+
+def _jnp_to_np(output: Dict[str, Any]) -> Dict[str, Any]:
+  """"""Recursively changes jax arrays to numpy arrays.""""""
+  for k, v in output.items():
+    if isinstance(v, dict):
+      output[k] = _jnp_to_np(v)
+    elif isinstance(v, jnp.ndarray):
+      output[k] = np.array(v)
+  return output
+
+
+def interface_parser(interfaces_string):
+  interfaces=[]
+  for interface in interfaces_string.split("",""):
+    interfaces.append([int(i) for i in interface.split("":"")])
+  return interfaces
+
+def gen_res_str(res):
+    res_len = len(str(res))
+    res_str = """"
+    for i in range(4-res_len):
+        res_str += "" ""
+    res_str += str(res) + "" ""
+    return res_str
+
+def predict_structure(
+    fasta_path: str,
+    fasta_name: str,
+    output_dir_base: str,
+    data_pipeline: Union[pipeline.DataPipeline, pipeline_multimer.DataPipeline, pipeline_custom_templates.DataPipeline],
+    model_runners: Dict[str, model.RunModel],
+    amber_relaxer: None,
+    benchmark: bool,
+    random_seed: int,
+    models_to_relax: ModelsToRelax,
+    use_custom_templates: bool,
+    template_alignfile: str,
+    msa_mode: str,
+    use_custom_MSA_database: str,
+    MSA_database: str,
+    save_msa_fasta: bool,
+    gen_feats_only: bool,
+    save_template_names: bool,
+    has_gap_chn_brk: bool,
+    substitute_msa: str,
+    msa_for_template_query_seq_only: bool,
+    iptm_interface: str,
+    feature_prefix: str,
+    save_ranked_pdb_only: bool,
+    save_msa_features_only: bool,
+    status_file: str):
+  """"""Predicts structure using AlphaFold for the given sequence.""""""
+  logging.info('Predicting %s', fasta_name)
+  timings = {}
+  output_dir = os.path.join(output_dir_base, fasta_name)
+  if not os.path.exists(output_dir):
+    os.makedirs(output_dir)
+  msa_output_dir = os.path.join(output_dir, 'msas')
+  if not os.path.exists(msa_output_dir):
+    os.makedirs(msa_output_dir)
+
+  # Get features.
+  t_0 = time.time()
+  if use_custom_templates or use_custom_MSA_database!=""none"":
+    feature_dict = data_pipeline.process(
+        input_fasta_path=fasta_path,
+        msa_output_dir=msa_output_dir,
+        use_custom_templates=use_custom_templates,
+        template_alignfile=template_alignfile,
+        msa_mode=msa_mode,
+        use_custom_MSA_database=use_custom_MSA_database,
+        MSA_database=MSA_database,
+        save_msa_fasta=save_msa_fasta,
+        save_template_names=save_template_names,
+        msa_for_template_query_seq_only=msa_for_template_query_seq_only)
+  else:
+    feature_dict = data_pipeline.process(
+      input_fasta_path=fasta_path,
+      msa_output_dir=msa_output_dir,
+      save_msa_fasta=save_msa_fasta,
+      save_template_names=save_template_names,
+      msa_for_template_query_seq_only=msa_for_template_query_seq_only)
+  timings['features'] = time.time() - t_0
+
+  # # Write out features as a pickled dictionary.
+  if not save_ranked_pdb_only:
+    features_output_path = os.path.join(output_dir, 'features.pkl')
+    if feature_prefix:
+      features_output_path = os.path.join(output_dir, '%s_features.pkl' % feature_prefix)
+    if save_msa_features_only:
+      key_save=['msa','deletion_matrix','cluster_bias_mask','bert_mask','msa_mask']
+      feature_dict_new={}
+      for key in key_save:
+        feature_dict_new[key]=feature_dict[key]
+      feature_dict=feature_dict_new
+    with open(features_output_path, 'wb') as f:
+      pickle.dump(feature_dict, f, protocol=4)
+
+
+  
+  if save_msa_fasta:
+    with open(os.path.join(output_dir, ""all_msa_feat_gaptoU.fasta""), 'w+') as fh:
+    # fh.write("">query""+""\n""+input_sequence+""\n"")
+      counter=1
+      for seq in feature_dict['msa']:
+          seq=[residue_constants.ID_TO_HHBLITS_AA[num] for num in seq]
+          counter+=1
+          fh.write("">seq_""+str(counter)+""\n"")
+          out="""".join(seq).replace(""-"",""U"")
+          fh.write(out+""\n"")
+
+  if gen_feats_only:
+    return 
+  if status_file:
+    with open(status_file,""a"") as fh:
+      fh.write(""All MSA and template features generated! Working on models now...\n"")
+
+  if substitute_msa:
+    keys_substitute=['msa','deletion_matrix','cluster_bias_mask','bert_mask','msa_mask']
+    with open(substitute_msa, 'rb') as fh:
+      substitute_feature_dict = pkl.load(fh)
+    for key in keys_substitute:
+      feature_dict[key]=substitute_feature_dict[key]
+      
+  unrelaxed_pdbs = {}
+  unrelaxed_proteins = {}
+  relaxed_pdbs = {}
+  ranking_confidences = {}
+  model_scores = {}
+  relax_metrics = {}
+
+  # Run the models.
+  num_models = len(model_runners)
+  for model_index, (model_name, model_runner) in enumerate(
+      model_runners.items()):
+    logging.info('Running model %s on %s', model_name, fasta_name)
+    t_0 = time.time()
+    model_random_seed = model_index + random_seed * num_models
+    processed_feature_dict = model_runner.process_features(
+        feature_dict, random_seed=model_random_seed)
+    timings[f'process_features_{model_name}'] = time.time() - t_0
+
+    interfaces=[]
+    if iptm_interface:
+      interfaces=interface_parser(iptm_interface)
+
+    t_0 = time.time()
+    prediction_result = model_runner.predict(processed_feature_dict,
+                                             random_seed=model_random_seed,
+                                             interfaces=interfaces)
+
+    t_diff = time.time() - t_0
+    timings[f'predict_and_compile_{model_name}'] = t_diff
+    logging.info(
+        'Total JAX model %s on %s predict time (includes compilation time, see --benchmark): %.1fs',
+        model_name, fasta_name, t_diff)
+
+    if benchmark:
+      t_0 = time.time()
+      model_runner.predict(processed_feature_dict,
+                           random_seed=model_random_seed)
+      t_diff = time.time() - t_0
+      timings[f'predict_benchmark_{model_name}'] = t_diff
+      logging.info(
+          'Total JAX model %s on %s predict time (excludes compilation time): %.1fs',
+          model_name, fasta_name, t_diff)
+
+    plddt = prediction_result['plddt']
+    ranking_confidences[model_name] = prediction_result['ranking_confidence']
+    model_scores[model_name] = [prediction_result['ranking_confidence'], np.mean(prediction_result['plddt'])]
+    if 'iptm' in prediction_result:
+      model_scores[model_name].append(prediction_result['ptm'])
+      model_scores[model_name].append(prediction_result['iptm'])
+    if ""custom_iptm"" in prediction_result:
+      for score in prediction_result['custom_iptm']:
+        model_scores[model_name].append(score)
+
+
+
+    if not save_ranked_pdb_only:
+      # Remove jax dependency from results.
+      np_prediction_result = _jnp_to_np(dict(prediction_result))
+      result_output_path = os.path.join(output_dir, f'result_{model_name}.pkl')
+      with open(result_output_path, 'wb') as f:
+        pickle.dump(np_prediction_result, f, protocol=4)
+    else:
+      text_output_path = os.path.join(output_dir, 'model_%d_done' % model_index)
+      with open(text_output_path,'w') as fh:
+        fh.write("""")
+        
+    if status_file:
+      if model_index < 4:
+        with open(status_file,""a"") as fh:
+          fh.write(""Model %d generated! Currently working on model %d...\n"" % (model_index+1, model_index+2))
+      else:
+        with open(status_file,""a"") as fh:
+          fh.write(""Model %d generated! Wrapping things up now!\n"" % (model_index+1))
+
+    # Add the predicted LDDT in the b-factor column.
+    # Note that higher predicted LDDT value means higher model confidence.
+    plddt_b_factors = np.repeat(
+        plddt[:, None], residue_constants.atom_type_num, axis=-1)
+    
+    unrelaxed_protein = protein.from_prediction(
+        features=processed_feature_dict,
+        result=prediction_result,
+        b_factors=plddt_b_factors,
+        remove_leading_feature_dimension=not model_runner.multimer_mode)
+
+
+    if has_gap_chn_brk:
+      #break chain
+      prev_res=0
+      new_res=0
+      curr_chn=0
+      chn_idx_adj=[]
+      new_res_index=[]
+      for res in unrelaxed_protein.residue_index:
+          if res-prev_res>199:
+              prev_res=res
+              curr_chn+=1
+              chn_idx_adj.append(curr_chn)
+              new_res=1
+          else:
+              prev_res=res
+              chn_idx_adj.append(curr_chn)
+              new_res+=1
+          new_res_index.append(new_res)
+      chain_index=np.add(unrelaxed_protein.chain_index, np.array(chn_idx_adj))
+      unrelaxed_protein= protein.Protein(
+        aatype=unrelaxed_protein.aatype,
+        atom_positions=unrelaxed_protein.atom_positions,
+        atom_mask=unrelaxed_protein.atom_mask,
+        residue_index=np.array(new_res_index,dtype=np.int32),
+        chain_index=np.array(chain_index,dtype=np.int32),
+        b_factors=unrelaxed_protein.b_factors) 
+
+    unrelaxed_proteins[model_name] = unrelaxed_protein
+    unrelaxed_pdbs[model_name] = protein.to_pdb(unrelaxed_protein)
+    
+    if not save_ranked_pdb_only:
+      unrelaxed_pdb_path = os.path.join(output_dir, f'unrelaxed_{model_name}.pdb')
+      with open(unrelaxed_pdb_path, 'w') as f:
+        f.write(unrelaxed_pdbs[model_name])
+
+
+
+  # Rank by model confidence.
+  ranked_order = [
+      model_name for model_name, confidence in
+      sorted(ranking_confidences.items(), key=lambda x: x[1], reverse=True)]
+
+  # Relax predictions.
+  if models_to_relax == ModelsToRelax.BEST:
+    to_relax = [ranked_order[0]]
+  elif models_to_relax == ModelsToRelax.ALL:
+    to_relax = ranked_order
+  elif models_to_relax == ModelsToRelax.NONE:
+    to_relax = []
+
+  for model_name in to_relax:
+    t_0 = time.time()
+    relaxed_pdb_str, _, violations = amber_relaxer.process(
+        prot=unrelaxed_proteins[model_name])
+    relax_metrics[model_name] = {
+        'remaining_violations': violations,
+        'remaining_violations_count': sum(violations)
+    }
+    timings[f'relax_{model_name}'] = time.time() - t_0
+
+    relaxed_pdbs[model_name] = relaxed_pdb_str
+
+    if not save_ranked_pdb_only:
+      relaxed_output_path = os.path.join(
+          output_dir, f'relaxed_{model_name}.pdb')
+      with open(relaxed_output_path, 'w') as f:
+        f.write(relaxed_pdb_str)
+
+  # Write out relaxed PDBs in rank order.
+  for idx, model_name in enumerate(ranked_order):
+    ranked_output_path = os.path.join(output_dir, f'ranked_{idx}.pdb')
+    with open(ranked_output_path, 'w') as f:
+      if model_name in relaxed_pdbs:
+        f.write(relaxed_pdbs[model_name])
+      else:
+        f.write(unrelaxed_pdbs[model_name])
+
+  model_scores_output=""""
+  for model in ranked_order:
+    model_scores_output+=""%s\n"" % ""\t"".join(map(str,model_scores[model]))
+  model_scores_output_path = os.path.join(output_dir, f'model_scores.txt')
+  with open(model_scores_output_path, 'w') as f:
+    f.write(model_scores_output)
+
+  ranking_output_path = os.path.join(output_dir, 'ranking_debug.json')
+  with open(ranking_output_path, 'w') as f:
+    label = 'iptm+ptm' if 'iptm' in prediction_result else 'plddts'
+    f.write(json.dumps(
+        {label: ranking_confidences, 'order': ranked_order}, indent=4))
+
+  logging.info('Final timings for %s: %s', fasta_name, timings)
+
+  timings_output_path = os.path.join(output_dir, 'timings.json')
+  with open(timings_output_path, 'w') as f:
+    f.write(json.dumps(timings, indent=4))
+  if models_to_relax != ModelsToRelax.NONE:
+    relax_metrics_path = os.path.join(output_dir, 'relax_metrics.json')
+    with open(relax_metrics_path, 'w') as f:
+      f.write(json.dumps(relax_metrics, indent=4))
+
+
+def main(argv):
+  if len(argv) > 1:
+    raise app.UsageError('Too many command-line arguments.')
+
+  for tool_name in (
+      'jackhmmer', 'hhblits', 'hhsearch', 'hmmsearch', 'hmmbuild', 'kalign'):
+    if not FLAGS[f'{tool_name}_binary_path'].value:
+      raise ValueError(f'Could not find path to the ""{tool_name}"" binary. Make '
+                       'sure it is installed on your system.')
+    
+  if FLAGS.gen_feats_only:
+    os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+
+  use_small_bfd = FLAGS.db_preset == 'reduced_dbs'
+  # _check_flag('small_bfd_database_path', 'db_preset',
+  #             should_be_set=use_small_bfd)
+  # _check_flag('bfd_database_path', 'db_preset',
+  #             should_be_set=not use_small_bfd)
+  # _check_flag('uniref30_database_path', 'db_preset',
+  #             should_be_set=not use_small_bfd)
+
+  run_multimer_system = 'multimer' in FLAGS.model_preset
+  # _check_flag('pdb70_database_path', 'model_preset',
+  #             should_be_set=not run_multimer_system)
+  # _check_flag('pdb_seqres_database_path', 'model_preset',
+  #             should_be_set=run_multimer_system)
+  # _check_flag('uniprot_database_path', 'model_preset',
+  #             should_be_set=run_multimer_system)
+
+  if FLAGS.model_preset == 'monomer_casp14':
+    num_ensemble = 8
+  else:
+    num_ensemble = 1
+
+  # Check for duplicate FASTA file names.
+  fasta_names = [pathlib.Path(p).stem for p in FLAGS.fasta_paths]
+  if len(fasta_names) != len(set(fasta_names)):
+    raise ValueError('All FASTA paths must have a unique basename.')
+
+  if run_multimer_system:
+    template_searcher = hmmsearch.Hmmsearch(
+        binary_path=FLAGS.hmmsearch_binary_path,
+        hmmbuild_binary_path=FLAGS.hmmbuild_binary_path,
+        database_path=FLAGS.pdb_seqres_database_path)
+    template_featurizer = templates.HmmsearchHitFeaturizer(
+        mmcif_dir=FLAGS.template_mmcif_dir,
+        max_template_date=FLAGS.max_template_date,
+        max_hits=MAX_TEMPLATE_HITS,
+        kalign_binary_path=FLAGS.kalign_binary_path,
+        release_dates_path=None,
+        obsolete_pdbs_path=FLAGS.obsolete_pdbs_path)
+  else:
+    template_searcher = hhsearch.HHSearch(
+        binary_path=FLAGS.hhsearch_binary_path,
+        databases=[FLAGS.pdb70_database_path])
+    template_featurizer = templates.HhsearchHitFeaturizer(
+        mmcif_dir=FLAGS.template_mmcif_dir,
+        max_template_date=FLAGS.max_template_date,
+        max_hits=MAX_TEMPLATE_HITS,
+        kalign_binary_path=FLAGS.kalign_binary_path,
+        release_dates_path=None,
+        obsolete_pdbs_path=FLAGS.obsolete_pdbs_path)
+
+  if FLAGS.use_custom_templates or FLAGS.use_custom_MSA_database!=""none"":
+    monomer_data_pipeline = pipeline_custom_templates.DataPipeline(
+        jackhmmer_binary_path=FLAGS.jackhmmer_binary_path,
+        hhblits_binary_path=FLAGS.hhblits_binary_path,
+        uniref90_database_path=FLAGS.uniref90_database_path,
+        mgnify_database_path=FLAGS.mgnify_database_path,
+        bfd_database_path=FLAGS.bfd_database_path,
+        uniref30_database_path=FLAGS.uniref30_database_path,
+        small_bfd_database_path=FLAGS.small_bfd_database_path,
+        template_searcher=template_searcher,
+        template_featurizer=template_featurizer,
+        use_small_bfd=use_small_bfd,
+        use_precomputed_msas=FLAGS.use_precomputed_msas)
+  else:
+    monomer_data_pipeline = pipeline.DataPipeline(
+        jackhmmer_binary_path=FLAGS.jackhmmer_binary_path,
+        hhblits_binary_path=FLAGS.hhblits_binary_path,
+        uniref90_database_path=FLAGS.uniref90_database_path,
+        mgnify_database_path=FLAGS.mgnify_database_path,
+        bfd_database_path=FLAGS.bfd_database_path,
+        uniref30_database_path=FLAGS.uniref30_database_path,
+        small_bfd_database_path=FLAGS.small_bfd_database_path,
+        template_searcher=template_searcher,
+        template_featurizer=template_featurizer,
+        use_small_bfd=use_small_bfd,
+        use_precomputed_msas=FLAGS.use_precomputed_msas)
+
+  if run_multimer_system:
+    num_predictions_per_model = FLAGS.num_multimer_predictions_per_model
+    if FLAGS.use_custom_templates or FLAGS.use_custom_MSA_database!=""none"":
+      data_pipeline = pipeline_multimer_custom_templates.DataPipeline(
+          monomer_data_pipeline=monomer_data_pipeline,
+          jackhmmer_binary_path=FLAGS.jackhmmer_binary_path,
+          uniprot_database_path=FLAGS.uniprot_database_path,
+          use_precomputed_msas=FLAGS.use_precomputed_msas)
+    else:
+      data_pipeline = pipeline_multimer.DataPipeline(
+          monomer_data_pipeline=monomer_data_pipeline,
+          jackhmmer_binary_path=FLAGS.jackhmmer_binary_path,
+          uniprot_database_path=FLAGS.uniprot_database_path,
+          use_precomputed_msas=FLAGS.use_precomputed_msas)
+  else:
+    num_predictions_per_model = 1
+    data_pipeline = monomer_data_pipeline
+
+  num_recycle=FLAGS.num_recycle
+  num_ensemble=FLAGS.num_ensemble
+
+  model_runners = {}
+  model_names = config.MODEL_PRESETS[FLAGS.model_preset]
+  for model_name in model_names:
+    if FLAGS.run_model_names and model_name not in FLAGS.run_model_names.split("",""):
+        continue
+    model_config = config.model_config(model_name)
+    if run_multimer_system:
+      # model_config.model.num_ensemble_eval = num_ensemble
+      model_config.model.num_recycle = num_recycle
+      model_config.model.num_ensemble_train = num_ensemble
+      model_config.model.num_ensemble_eval = num_ensemble
+    else:
+      model_config.data.common.num_recycle = num_recycle
+      model_config.model.num_recycle = num_recycle
+      model_config.data.eval.num_ensemble = num_ensemble
+    
+    model_params = data.get_model_haiku_params(
+        model_name=model_name, data_dir=FLAGS.data_dir)
+    model_runner = model.RunModel(model_config, model_params)
+    for i in range(num_predictions_per_model):
+      model_runners[f'{model_name}_pred_{i}'] = model_runner
+
+  logging.info('Have %d models: %s', len(model_runners),
+               list(model_runners.keys()))
+
+  if FLAGS.models_to_relax!=""none"":
+    amber_relaxer = relax.AmberRelaxation(
+        max_iterations=RELAX_MAX_ITERATIONS,
+        tolerance=RELAX_ENERGY_TOLERANCE,
+        stiffness=RELAX_STIFFNESS,
+        exclude_residues=RELAX_EXCLUDE_RESIDUES,
+        max_outer_iterations=RELAX_MAX_OUTER_ITERATIONS,
+        use_gpu=FLAGS.use_gpu_relax)
+  else:
+    amber_relaxer = None
+
+  random_seed = FLAGS.random_seed
+  if random_seed is None:
+    random_seed = random.randrange(sys.maxsize // len(model_runners))
+  logging.info('Using random seed %d for the data pipeline', random_seed)
+
+  # Predict structure for each of the sequences.
+  for i, fasta_path in enumerate(FLAGS.fasta_paths):
+    fasta_name = fasta_names[i]
+    predict_structure(
+        fasta_path=fasta_path,
+        fasta_name=fasta_name,
+        output_dir_base=FLAGS.output_dir,
+        data_pipeline=data_pipeline,
+        model_runners=model_runners,
+        amber_relaxer=amber_relaxer,
+        benchmark=FLAGS.benchmark,
+        random_seed=random_seed,
+        models_to_relax=FLAGS.models_to_relax,
+        use_custom_templates=FLAGS.use_custom_templates,
+        template_alignfile=FLAGS.template_alignfile,
+        msa_mode=FLAGS.msa_mode,
+        use_custom_MSA_database=FLAGS.use_custom_MSA_database,
+        MSA_database=FLAGS.MSA_database,
+        save_msa_fasta=FLAGS.save_msa_fasta,
+        gen_feats_only=FLAGS.gen_feats_only,
+        save_template_names=FLAGS.save_template_names,
+        has_gap_chn_brk=FLAGS.has_gap_chn_brk,
+        substitute_msa=FLAGS.substitute_msa,
+        msa_for_template_query_seq_only=FLAGS.msa_for_template_query_seq_only,
+        iptm_interface=FLAGS.iptm_interface,
+        feature_prefix=FLAGS.feature_prefix,
+        save_ranked_pdb_only=FLAGS.save_ranked_pdb_only,
+        save_msa_features_only=FLAGS.save_msa_features_only,
+        status_file=FLAGS.status_file)
+
+
+if __name__ == '__main__':
+  flags.mark_flags_as_required([
+      'fasta_paths',
+      'output_dir',
+      'data_dir',
+      'uniref90_database_path',
+      'mgnify_database_path',
+      'template_mmcif_dir',
+      'max_template_date',
+      'obsolete_pdbs_path',
+      'use_gpu_relax',
+  ])
+
+  app.run(main)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","singularity/run_tcrmodel2_singularity.sh",".sh","893","23","
+#!/bin/bash
+
+#databases path
+ALPHAFOLD_DB=/path/to/alphafold_db
+
+#singularity sif
+ALPHAFOLD_SIF=/path/to/tcrmodel2.sif
+
+#output directory
+OUTPUT_DIR=/path/to/output_directory
+
+# run tcrmodel singularity
+singularity run --nv -B $ALPHAFOLD_DB  $ALPHAFOLD_SIF \
+    --job_id=test_clsI_6kzw \
+    --output_dir=$OUTPUT_DIR \
+    --tcra_seq=AQEVTQIPAALSVPEGENLVLNCSFTDSAIYNLQWFRQDPGKGLTSLLLIQSSQREQTSGRLNASLDKSSGRSTLYIAASQPGDSATYLCAVTNQAGTALIFGKGTTLSVSS \
+    --tcrb_seq=NAGVTQTPKFQVLKTGQSMTLQCSQDMNHEYMSWYRQDPGMGLRLIHYSVGAGITDQGEVPNGYNVSRSTTEDFPLRLLSAAPSQTSVYFCASSYSIRGSRGEQFFGPGTRLTVL \
+    --pep_seq=RLPAKAPLL \
+    --mhca_seq=SHSLKYFHTSVSRPGRGEPRFISVGYVDDTQFVRFDNDAASPRMVPRAPWMEQEGSEYWDRETRSARDTAQIFRVNLRTLRGYYNQSEAGSHTLQWMHGCELGPDGRFLRGYEQFAYDGKDYLTLNEDLRSWTAVDTAAQISEQKSNDASEAEHQRAYLEDTCVE \
+    --ori_db=$ALPHAFOLD_DB \
+    --tp_db=/opt/tcrmodel2/data/databases \
+    --relax_structures=True","Shell"
+"AlphaFold","piercelab/tcrmodel2","alphafold/__init__.py",".py","663","15","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""An implementation of the inference pipeline of AlphaFold v2.0.""""""
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/features.py",".py","3692","105","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Code to generate processed features.""""""
+import copy
+from typing import List, Mapping, Tuple
+
+from alphafold.model.tf import input_pipeline
+from alphafold.model.tf import proteins_dataset
+
+import ml_collections
+import numpy as np
+import tensorflow.compat.v1 as tf
+
+FeatureDict = Mapping[str, np.ndarray]
+
+
+def make_data_config(
+    config: ml_collections.ConfigDict,
+    num_res: int,
+    ) -> Tuple[ml_collections.ConfigDict, List[str]]:
+  """"""Makes a data config for the input pipeline.""""""
+  cfg = copy.deepcopy(config.data)
+
+  feature_names = cfg.common.unsupervised_features
+  if cfg.common.use_templates:
+    feature_names += cfg.common.template_features
+
+  with cfg.unlocked():
+    cfg.eval.crop_size = num_res
+
+  return cfg, feature_names
+
+
+def tf_example_to_features(tf_example: tf.train.Example,
+                           config: ml_collections.ConfigDict,
+                           random_seed: int = 0) -> FeatureDict:
+  """"""Converts tf_example to numpy feature dictionary.""""""
+  num_res = int(tf_example.features.feature['seq_length'].int64_list.value[0])
+  cfg, feature_names = make_data_config(config, num_res=num_res)
+
+  if 'deletion_matrix_int' in set(tf_example.features.feature):
+    deletion_matrix_int = (
+        tf_example.features.feature['deletion_matrix_int'].int64_list.value)
+    feat = tf.train.Feature(float_list=tf.train.FloatList(
+        value=map(float, deletion_matrix_int)))
+    tf_example.features.feature['deletion_matrix'].CopyFrom(feat)
+    del tf_example.features.feature['deletion_matrix_int']
+
+  tf_graph = tf.Graph()
+  with tf_graph.as_default(), tf.device('/device:CPU:0'):
+    tf.compat.v1.set_random_seed(random_seed)
+    tensor_dict = proteins_dataset.create_tensor_dict(
+        raw_data=tf_example.SerializeToString(),
+        features=feature_names)
+    processed_batch = input_pipeline.process_tensors_from_config(
+        tensor_dict, cfg)
+
+  tf_graph.finalize()
+
+  with tf.Session(graph=tf_graph) as sess:
+    features = sess.run(processed_batch)
+
+  return {k: v for k, v in features.items() if v.dtype != 'O'}
+
+
+def np_example_to_features(np_example: FeatureDict,
+                           config: ml_collections.ConfigDict,
+                           random_seed: int = 0) -> FeatureDict:
+  """"""Preprocesses NumPy feature dict using TF pipeline.""""""
+  np_example = dict(np_example)
+  num_res = int(np_example['seq_length'][0])
+  cfg, feature_names = make_data_config(config, num_res=num_res)
+
+  if 'deletion_matrix_int' in np_example:
+    np_example['deletion_matrix'] = (
+        np_example.pop('deletion_matrix_int').astype(np.float32))
+
+  tf_graph = tf.Graph()
+  with tf_graph.as_default(), tf.device('/device:CPU:0'):
+    tf.compat.v1.set_random_seed(random_seed)
+    tensor_dict = proteins_dataset.np_to_tensor_dict(
+        np_example=np_example, features=feature_names)
+
+    processed_batch = input_pipeline.process_tensors_from_config(
+        tensor_dict, cfg)
+
+  tf_graph.finalize()
+
+  with tf.Session(graph=tf_graph) as sess:
+    features = sess.run(processed_batch)
+
+  return {k: v for k, v in features.items() if v.dtype != 'O'}
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/r3.py",".py","10935","321","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Transformations for 3D coordinates.
+
+This Module contains objects for representing Vectors (Vecs), Rotation Matrices
+(Rots) and proper Rigid transformation (Rigids). These are represented as
+named tuples with arrays for each entry, for example a set of
+[N, M] points would be represented as a Vecs object with arrays of shape [N, M]
+for x, y and z.
+
+This is being done to improve readability by making it very clear what objects
+are geometric objects rather than relying on comments and array shapes.
+Another reason for this is to avoid using matrix
+multiplication primitives like matmul or einsum, on modern accelerator hardware
+these can end up on specialized cores such as tensor cores on GPU or the MXU on
+cloud TPUs, this often involves lower computational precision which can be
+problematic for coordinate geometry. Also these cores are typically optimized
+for larger matrices than 3 dimensional, this code is written to avoid any
+unintended use of these cores on both GPUs and TPUs.
+""""""
+
+import collections
+from typing import List
+from alphafold.model import quat_affine
+import jax.numpy as jnp
+import tree
+
+# Array of 3-component vectors, stored as individual array for
+# each component.
+Vecs = collections.namedtuple('Vecs', ['x', 'y', 'z'])
+
+# Array of 3x3 rotation matrices, stored as individual array for
+# each component.
+Rots = collections.namedtuple('Rots', ['xx', 'xy', 'xz',
+                                       'yx', 'yy', 'yz',
+                                       'zx', 'zy', 'zz'])
+# Array of rigid 3D transformations, stored as array of rotations and
+# array of translations.
+Rigids = collections.namedtuple('Rigids', ['rot', 'trans'])
+
+
+def squared_difference(x, y):
+  return jnp.square(x - y)
+
+
+def invert_rigids(r: Rigids) -> Rigids:
+  """"""Computes group inverse of rigid transformations 'r'.""""""
+  inv_rots = invert_rots(r.rot)
+  t = rots_mul_vecs(inv_rots, r.trans)
+  inv_trans = Vecs(-t.x, -t.y, -t.z)
+  return Rigids(inv_rots, inv_trans)
+
+
+def invert_rots(m: Rots) -> Rots:
+  """"""Computes inverse of rotations 'm'.""""""
+  return Rots(m.xx, m.yx, m.zx,
+              m.xy, m.yy, m.zy,
+              m.xz, m.yz, m.zz)
+
+
+def rigids_from_3_points(
+    point_on_neg_x_axis: Vecs,  # shape (...)
+    origin: Vecs,  # shape (...)
+    point_on_xy_plane: Vecs,  # shape (...)
+) -> Rigids:  # shape (...)
+  """"""Create Rigids from 3 points.
+
+  Jumper et al. (2021) Suppl. Alg. 21 ""rigidFrom3Points""
+  This creates a set of rigid transformations from 3 points by Gram Schmidt
+  orthogonalization.
+
+  Args:
+    point_on_neg_x_axis: Vecs corresponding to points on the negative x axis
+    origin: Origin of resulting rigid transformations
+    point_on_xy_plane: Vecs corresponding to points in the xy plane
+  Returns:
+    Rigid transformations from global frame to local frames derived from
+    the input points.
+  """"""
+  m = rots_from_two_vecs(
+      e0_unnormalized=vecs_sub(origin, point_on_neg_x_axis),
+      e1_unnormalized=vecs_sub(point_on_xy_plane, origin))
+
+  return Rigids(rot=m, trans=origin)
+
+
+def rigids_from_list(l: List[jnp.ndarray]) -> Rigids:
+  """"""Converts flat list of arrays to rigid transformations.""""""
+  assert len(l) == 12
+  return Rigids(Rots(*(l[:9])), Vecs(*(l[9:])))
+
+
+def rigids_from_quataffine(a: quat_affine.QuatAffine) -> Rigids:
+  """"""Converts QuatAffine object to the corresponding Rigids object.""""""
+  return Rigids(Rots(*tree.flatten(a.rotation)),
+                Vecs(*a.translation))
+
+
+def rigids_from_tensor4x4(
+    m: jnp.ndarray  # shape (..., 4, 4)
+) -> Rigids:  # shape (...)
+  """"""Construct Rigids object from an 4x4 array.
+
+  Here the 4x4 is representing the transformation in homogeneous coordinates.
+
+  Args:
+    m: Array representing transformations in homogeneous coordinates.
+  Returns:
+    Rigids object corresponding to transformations m
+  """"""
+  assert m.shape[-1] == 4
+  assert m.shape[-2] == 4
+  return Rigids(
+      Rots(m[..., 0, 0], m[..., 0, 1], m[..., 0, 2],
+           m[..., 1, 0], m[..., 1, 1], m[..., 1, 2],
+           m[..., 2, 0], m[..., 2, 1], m[..., 2, 2]),
+      Vecs(m[..., 0, 3], m[..., 1, 3], m[..., 2, 3]))
+
+
+def rigids_from_tensor_flat9(
+    m: jnp.ndarray  # shape (..., 9)
+) -> Rigids:  # shape (...)
+  """"""Flat9 encoding: first two columns of rotation matrix + translation.""""""
+  assert m.shape[-1] == 9
+  e0 = Vecs(m[..., 0], m[..., 1], m[..., 2])
+  e1 = Vecs(m[..., 3], m[..., 4], m[..., 5])
+  trans = Vecs(m[..., 6], m[..., 7], m[..., 8])
+  return Rigids(rot=rots_from_two_vecs(e0, e1),
+                trans=trans)
+
+
+def rigids_from_tensor_flat12(
+    m: jnp.ndarray  # shape (..., 12)
+) -> Rigids:  # shape (...)
+  """"""Flat12 encoding: rotation matrix (9 floats) + translation (3 floats).""""""
+  assert m.shape[-1] == 12
+  x = jnp.moveaxis(m, -1, 0)  # Unstack
+  return Rigids(Rots(*x[:9]), Vecs(*x[9:]))
+
+
+def rigids_mul_rigids(a: Rigids, b: Rigids) -> Rigids:
+  """"""Group composition of Rigids 'a' and 'b'.""""""
+  return Rigids(
+      rots_mul_rots(a.rot, b.rot),
+      vecs_add(a.trans, rots_mul_vecs(a.rot, b.trans)))
+
+
+def rigids_mul_rots(r: Rigids, m: Rots) -> Rigids:
+  """"""Compose rigid transformations 'r' with rotations 'm'.""""""
+  return Rigids(rots_mul_rots(r.rot, m), r.trans)
+
+
+def rigids_mul_vecs(r: Rigids, v: Vecs) -> Vecs:
+  """"""Apply rigid transforms 'r' to points 'v'.""""""
+  return vecs_add(rots_mul_vecs(r.rot, v), r.trans)
+
+
+def rigids_to_list(r: Rigids) -> List[jnp.ndarray]:
+  """"""Turn Rigids into flat list, inverse of 'rigids_from_list'.""""""
+  return list(r.rot) + list(r.trans)
+
+
+def rigids_to_quataffine(r: Rigids) -> quat_affine.QuatAffine:
+  """"""Convert Rigids r into QuatAffine, inverse of 'rigids_from_quataffine'.""""""
+  return quat_affine.QuatAffine(
+      quaternion=None,
+      rotation=[[r.rot.xx, r.rot.xy, r.rot.xz],
+                [r.rot.yx, r.rot.yy, r.rot.yz],
+                [r.rot.zx, r.rot.zy, r.rot.zz]],
+      translation=[r.trans.x, r.trans.y, r.trans.z])
+
+
+def rigids_to_tensor_flat9(
+    r: Rigids  # shape (...)
+) -> jnp.ndarray:  # shape (..., 9)
+  """"""Flat9 encoding: first two columns of rotation matrix + translation.""""""
+  return jnp.stack(
+      [r.rot.xx, r.rot.yx, r.rot.zx, r.rot.xy, r.rot.yy, r.rot.zy]
+      + list(r.trans), axis=-1)
+
+
+def rigids_to_tensor_flat12(
+    r: Rigids  # shape (...)
+) -> jnp.ndarray:  # shape (..., 12)
+  """"""Flat12 encoding: rotation matrix (9 floats) + translation (3 floats).""""""
+  return jnp.stack(list(r.rot) + list(r.trans), axis=-1)
+
+
+def rots_from_tensor3x3(
+    m: jnp.ndarray,  # shape (..., 3, 3)
+) -> Rots:  # shape (...)
+  """"""Convert rotations represented as (3, 3) array to Rots.""""""
+  assert m.shape[-1] == 3
+  assert m.shape[-2] == 3
+  return Rots(m[..., 0, 0], m[..., 0, 1], m[..., 0, 2],
+              m[..., 1, 0], m[..., 1, 1], m[..., 1, 2],
+              m[..., 2, 0], m[..., 2, 1], m[..., 2, 2])
+
+
+def rots_from_two_vecs(e0_unnormalized: Vecs, e1_unnormalized: Vecs) -> Rots:
+  """"""Create rotation matrices from unnormalized vectors for the x and y-axes.
+
+  This creates a rotation matrix from two vectors using Gram-Schmidt
+  orthogonalization.
+
+  Args:
+    e0_unnormalized: vectors lying along x-axis of resulting rotation
+    e1_unnormalized: vectors lying in xy-plane of resulting rotation
+  Returns:
+    Rotations resulting from Gram-Schmidt procedure.
+  """"""
+  # Normalize the unit vector for the x-axis, e0.
+  e0 = vecs_robust_normalize(e0_unnormalized)
+
+  # make e1 perpendicular to e0.
+  c = vecs_dot_vecs(e1_unnormalized, e0)
+  e1 = Vecs(e1_unnormalized.x - c * e0.x,
+            e1_unnormalized.y - c * e0.y,
+            e1_unnormalized.z - c * e0.z)
+  e1 = vecs_robust_normalize(e1)
+
+  # Compute e2 as cross product of e0 and e1.
+  e2 = vecs_cross_vecs(e0, e1)
+
+  return Rots(e0.x, e1.x, e2.x, e0.y, e1.y, e2.y, e0.z, e1.z, e2.z)
+
+
+def rots_mul_rots(a: Rots, b: Rots) -> Rots:
+  """"""Composition of rotations 'a' and 'b'.""""""
+  c0 = rots_mul_vecs(a, Vecs(b.xx, b.yx, b.zx))
+  c1 = rots_mul_vecs(a, Vecs(b.xy, b.yy, b.zy))
+  c2 = rots_mul_vecs(a, Vecs(b.xz, b.yz, b.zz))
+  return Rots(c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z)
+
+
+def rots_mul_vecs(m: Rots, v: Vecs) -> Vecs:
+  """"""Apply rotations 'm' to vectors 'v'.""""""
+  return Vecs(m.xx * v.x + m.xy * v.y + m.xz * v.z,
+              m.yx * v.x + m.yy * v.y + m.yz * v.z,
+              m.zx * v.x + m.zy * v.y + m.zz * v.z)
+
+
+def vecs_add(v1: Vecs, v2: Vecs) -> Vecs:
+  """"""Add two vectors 'v1' and 'v2'.""""""
+  return Vecs(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z)
+
+
+def vecs_dot_vecs(v1: Vecs, v2: Vecs) -> jnp.ndarray:
+  """"""Dot product of vectors 'v1' and 'v2'.""""""
+  return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z
+
+
+def vecs_cross_vecs(v1: Vecs, v2: Vecs) -> Vecs:
+  """"""Cross product of vectors 'v1' and 'v2'.""""""
+  return Vecs(v1.y * v2.z - v1.z * v2.y,
+              v1.z * v2.x - v1.x * v2.z,
+              v1.x * v2.y - v1.y * v2.x)
+
+
+def vecs_from_tensor(x: jnp.ndarray  # shape (..., 3)
+                    ) -> Vecs:  # shape (...)
+  """"""Converts from tensor of shape (3,) to Vecs.""""""
+  num_components = x.shape[-1]
+  assert num_components == 3
+  return Vecs(x[..., 0], x[..., 1], x[..., 2])
+
+
+def vecs_robust_normalize(v: Vecs, epsilon: float = 1e-8) -> Vecs:
+  """"""Normalizes vectors 'v'.
+
+  Args:
+    v: vectors to be normalized.
+    epsilon: small regularizer added to squared norm before taking square root.
+  Returns:
+    normalized vectors
+  """"""
+  norms = vecs_robust_norm(v, epsilon)
+  return Vecs(v.x / norms, v.y / norms, v.z / norms)
+
+
+def vecs_robust_norm(v: Vecs, epsilon: float = 1e-8) -> jnp.ndarray:
+  """"""Computes norm of vectors 'v'.
+
+  Args:
+    v: vectors to be normalized.
+    epsilon: small regularizer added to squared norm before taking square root.
+  Returns:
+    norm of 'v'
+  """"""
+  return jnp.sqrt(jnp.square(v.x) + jnp.square(v.y) + jnp.square(v.z) + epsilon)
+
+
+def vecs_sub(v1: Vecs, v2: Vecs) -> Vecs:
+  """"""Computes v1 - v2.""""""
+  return Vecs(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)
+
+
+def vecs_squared_distance(v1: Vecs, v2: Vecs) -> jnp.ndarray:
+  """"""Computes squared euclidean difference between 'v1' and 'v2'.""""""
+  return (squared_difference(v1.x, v2.x) +
+          squared_difference(v1.y, v2.y) +
+          squared_difference(v1.z, v2.z))
+
+
+def vecs_to_tensor(v: Vecs  # shape (...)
+                  ) -> jnp.ndarray:  # shape(..., 3)
+  """"""Converts 'v' to tensor with shape 3, inverse of 'vecs_from_tensor'.""""""
+  return jnp.stack([v.x, v.y, v.z], axis=-1)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/model.py",".py","7290","193","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Code for constructing the model.""""""
+from typing import Any, Mapping, Optional, Union
+
+from absl import logging
+from alphafold.common import confidence
+from alphafold.model import features
+from alphafold.model import modules
+from alphafold.model import modules_multimer
+import haiku as hk
+import jax
+import ml_collections
+import numpy as np
+import tensorflow.compat.v1 as tf
+import tree
+
+
+def get_confidence_metrics(
+    prediction_result: Mapping[str, Any],
+    multimer_mode: bool,
+    interfaces: list) -> Mapping[str, Any]:
+  """"""Post processes prediction_result to get confidence metrics.""""""
+  confidence_metrics = {}
+  confidence_metrics['plddt'] = confidence.compute_plddt(
+      prediction_result['predicted_lddt']['logits'])
+  if 'predicted_aligned_error' in prediction_result:
+    confidence_metrics.update(confidence.compute_predicted_aligned_error(
+        logits=prediction_result['predicted_aligned_error']['logits'],
+        breaks=prediction_result['predicted_aligned_error']['breaks']))
+    confidence_metrics['ptm'] = confidence.predicted_tm_score(
+        logits=prediction_result['predicted_aligned_error']['logits'],
+        breaks=prediction_result['predicted_aligned_error']['breaks'],
+        asym_id=None)
+    
+    if len(interfaces)!=0:
+      iptm=[]
+      for interface in interfaces:
+        new_asym_id=prediction_result['predicted_aligned_error']['asym_id']
+        for old_index, new_index in enumerate(interface):
+          new_asym_id=np.where(new_asym_id==old_index+1, new_index, new_asym_id)
+        iptm.append(confidence.predicted_tm_score(
+              logits=prediction_result['predicted_aligned_error']['logits'],
+              breaks=prediction_result['predicted_aligned_error']['breaks'],
+              asym_id=new_asym_id,
+              interface=True))
+      confidence_metrics['custom_iptm'] = iptm
+
+    if multimer_mode:
+      # Compute the ipTM only for the multimer model.
+      confidence_metrics['iptm'] = confidence.predicted_tm_score(
+          logits=prediction_result['predicted_aligned_error']['logits'],
+          breaks=prediction_result['predicted_aligned_error']['breaks'],
+          asym_id=prediction_result['predicted_aligned_error']['asym_id'],
+          interface=True)
+      confidence_metrics['ranking_confidence'] = (
+          0.8 * confidence_metrics['iptm'] + 0.2 * confidence_metrics['ptm'])
+
+  if not multimer_mode:
+    # Monomer models use mean pLDDT for model ranking.
+    confidence_metrics['ranking_confidence'] = np.mean(
+        confidence_metrics['plddt'])
+
+  return confidence_metrics
+
+
+class RunModel:
+  """"""Container for JAX model.""""""
+
+  def __init__(self,
+               config: ml_collections.ConfigDict,
+               params: Optional[Mapping[str, Mapping[str, np.ndarray]]] = None):
+    self.config = config
+    self.params = params
+    self.multimer_mode = config.model.global_config.multimer_mode
+
+    if self.multimer_mode:
+      def _forward_fn(batch):
+        model = modules_multimer.AlphaFold(self.config.model)
+        return model(
+            batch,
+            is_training=False)
+    else:
+      def _forward_fn(batch):
+        model = modules.AlphaFold(self.config.model)
+        return model(
+            batch,
+            is_training=False,
+            compute_loss=False,
+            ensemble_representations=True)
+
+    self.apply = jax.jit(hk.transform(_forward_fn).apply)
+    self.init = jax.jit(hk.transform(_forward_fn).init)
+
+  def init_params(self, feat: features.FeatureDict, random_seed: int = 0):
+    """"""Initializes the model parameters.
+
+    If none were provided when this class was instantiated then the parameters
+    are randomly initialized.
+
+    Args:
+      feat: A dictionary of NumPy feature arrays as output by
+        RunModel.process_features.
+      random_seed: A random seed to use to initialize the parameters if none
+        were set when this class was initialized.
+    """"""
+    if not self.params:
+      # Init params randomly.
+      rng = jax.random.PRNGKey(random_seed)
+      self.params = hk.data_structures.to_mutable_dict(
+          self.init(rng, feat))
+      logging.warning('Initialized parameters randomly')
+
+  def process_features(
+      self,
+      raw_features: Union[tf.train.Example, features.FeatureDict],
+      random_seed: int) -> features.FeatureDict:
+    """"""Processes features to prepare for feeding them into the model.
+
+    Args:
+      raw_features: The output of the data pipeline either as a dict of NumPy
+        arrays or as a tf.train.Example.
+      random_seed: The random seed to use when processing the features.
+
+    Returns:
+      A dict of NumPy feature arrays suitable for feeding into the model.
+    """"""
+
+    if self.multimer_mode:
+      return raw_features
+
+    # Single-chain mode.
+    if isinstance(raw_features, dict):
+      return features.np_example_to_features(
+          np_example=raw_features,
+          config=self.config,
+          random_seed=random_seed)
+    else:
+      return features.tf_example_to_features(
+          tf_example=raw_features,
+          config=self.config,
+          random_seed=random_seed)
+
+  def eval_shape(self, feat: features.FeatureDict) -> jax.ShapeDtypeStruct:
+    self.init_params(feat)
+    logging.info('Running eval_shape with shape(feat) = %s',
+                 tree.map_structure(lambda x: x.shape, feat))
+    shape = jax.eval_shape(self.apply, self.params, jax.random.PRNGKey(0), feat)
+    logging.info('Output shape was %s', shape)
+    return shape
+
+  def predict(self,
+              feat: features.FeatureDict,
+              random_seed: int,
+              interfaces: list) -> Mapping[str, Any]:
+    """"""Makes a prediction by inferencing the model on the provided features.
+
+    Args:
+      feat: A dictionary of NumPy feature arrays as output by
+        RunModel.process_features.
+      random_seed: The random seed to use when running the model. In the
+        multimer model this controls the MSA sampling.
+
+    Returns:
+      A dictionary of model outputs.
+    """"""
+    self.init_params(feat)
+    logging.info('Running predict with shape(feat) = %s',
+                 tree.map_structure(lambda x: x.shape, feat))
+    result = self.apply(self.params, jax.random.PRNGKey(random_seed), feat)
+
+    # This block is to ensure benchmark timings are accurate. Some blocking is
+    # already happening when computing get_confidence_metrics, and this ensures
+    # all outputs are blocked on.
+    jax.tree_map(lambda x: x.block_until_ready(), result)
+    result.update(
+        get_confidence_metrics(result, multimer_mode=self.multimer_mode, interfaces=interfaces))
+    logging.info('Output shape was %s',
+                 tree.map_structure(lambda x: x.shape, result))
+    return result
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/lddt_test.py",".py","2384","80","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for lddt.""""""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+from alphafold.model import lddt
+import numpy as np
+
+
+class LddtTest(parameterized.TestCase, absltest.TestCase):
+
+  @parameterized.named_parameters(
+      ('same',
+       [[0, 0, 0], [5, 0, 0], [10, 0, 0]],
+       [[0, 0, 0], [5, 0, 0], [10, 0, 0]],
+       [1, 1, 1]),
+      ('all_shifted',
+       [[0, 0, 0], [5, 0, 0], [10, 0, 0]],
+       [[-1, 0, 0], [4, 0, 0], [9, 0, 0]],
+       [1, 1, 1]),
+      ('all_rotated',
+       [[0, 0, 0], [5, 0, 0], [10, 0, 0]],
+       [[0, 0, 0], [0, 5, 0], [0, 10, 0]],
+       [1, 1, 1]),
+      ('half_a_dist',
+       [[0, 0, 0], [5, 0, 0]],
+       [[0, 0, 0], [5.5-1e-5, 0, 0]],
+       [1, 1]),
+      ('one_a_dist',
+       [[0, 0, 0], [5, 0, 0]],
+       [[0, 0, 0], [6-1e-5, 0, 0]],
+       [0.75, 0.75]),
+      ('two_a_dist',
+       [[0, 0, 0], [5, 0, 0]],
+       [[0, 0, 0], [7-1e-5, 0, 0]],
+       [0.5, 0.5]),
+      ('four_a_dist',
+       [[0, 0, 0], [5, 0, 0]],
+       [[0, 0, 0], [9-1e-5, 0, 0]],
+       [0.25, 0.25],),
+      ('five_a_dist',
+       [[0, 0, 0], [16-1e-5, 0, 0]],
+       [[0, 0, 0], [11, 0, 0]],
+       [0, 0]),
+      ('no_pairs',
+       [[0, 0, 0], [20, 0, 0]],
+       [[0, 0, 0], [25-1e-5, 0, 0]],
+       [1, 1]),
+  )
+  def test_lddt(
+      self, predicted_pos, true_pos, exp_lddt):
+    predicted_pos = np.array([predicted_pos], dtype=np.float32)
+    true_points_mask = np.array([[[1]] * len(true_pos)], dtype=np.float32)
+    true_pos = np.array([true_pos], dtype=np.float32)
+    cutoff = 15.0
+    per_residue = True
+
+    result = lddt.lddt(
+        predicted_pos, true_pos, true_points_mask, cutoff,
+        per_residue)
+
+    np.testing.assert_almost_equal(result, [exp_lddt], decimal=4)
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/all_atom_multimer.py",".py","40135","969","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Ops for all atom representations.""""""
+
+from typing import Dict, Text
+
+from alphafold.common import residue_constants
+from alphafold.model import geometry
+from alphafold.model import utils
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+
+def squared_difference(x, y):
+  return jnp.square(x - y)
+
+
+def _make_chi_atom_indices():
+  """"""Returns atom indices needed to compute chi angles for all residue types.
+
+  Returns:
+    A tensor of shape [residue_types=21, chis=4, atoms=4]. The residue types are
+    in the order specified in residue_constants.restypes + unknown residue type
+    at the end. For chi angles which are not defined on the residue, the
+    positions indices are by default set to 0.
+  """"""
+  chi_atom_indices = []
+  for residue_name in residue_constants.restypes:
+    residue_name = residue_constants.restype_1to3[residue_name]
+    residue_chi_angles = residue_constants.chi_angles_atoms[residue_name]
+    atom_indices = []
+    for chi_angle in residue_chi_angles:
+      atom_indices.append(
+          [residue_constants.atom_order[atom] for atom in chi_angle])
+    for _ in range(4 - len(atom_indices)):
+      atom_indices.append([0, 0, 0, 0])  # For chi angles not defined on the AA.
+    chi_atom_indices.append(atom_indices)
+
+  chi_atom_indices.append([[0, 0, 0, 0]] * 4)  # For UNKNOWN residue.
+
+  return np.array(chi_atom_indices)
+
+
+def _make_renaming_matrices():
+  """"""Matrices to map atoms to symmetry partners in ambiguous case.""""""
+  # As the atom naming is ambiguous for 7 of the 20 amino acids, provide
+  # alternative groundtruth coordinates where the naming is swapped
+  restype_3 = [
+      residue_constants.restype_1to3[res] for res in residue_constants.restypes
+  ]
+  restype_3 += ['UNK']
+  # Matrices for renaming ambiguous atoms.
+  all_matrices = {res: np.eye(14, dtype=np.float32) for res in restype_3}
+  for resname, swap in residue_constants.residue_atom_renaming_swaps.items():
+    correspondences = np.arange(14)
+    for source_atom_swap, target_atom_swap in swap.items():
+      source_index = residue_constants.restype_name_to_atom14_names[
+          resname].index(source_atom_swap)
+      target_index = residue_constants.restype_name_to_atom14_names[
+          resname].index(target_atom_swap)
+      correspondences[source_index] = target_index
+      correspondences[target_index] = source_index
+      renaming_matrix = np.zeros((14, 14), dtype=np.float32)
+      for index, correspondence in enumerate(correspondences):
+        renaming_matrix[index, correspondence] = 1.
+    all_matrices[resname] = renaming_matrix.astype(np.float32)
+  renaming_matrices = np.stack([all_matrices[restype] for restype in restype_3])
+  return renaming_matrices
+
+
+def _make_restype_atom37_mask():
+  """"""Mask of which atoms are present for which residue type in atom37.""""""
+  # create the corresponding mask
+  restype_atom37_mask = np.zeros([21, 37], dtype=np.float32)
+  for restype, restype_letter in enumerate(residue_constants.restypes):
+    restype_name = residue_constants.restype_1to3[restype_letter]
+    atom_names = residue_constants.residue_atoms[restype_name]
+    for atom_name in atom_names:
+      atom_type = residue_constants.atom_order[atom_name]
+      restype_atom37_mask[restype, atom_type] = 1
+  return restype_atom37_mask
+
+
+def _make_restype_atom14_mask():
+  """"""Mask of which atoms are present for which residue type in atom14.""""""
+  restype_atom14_mask = []
+
+  for rt in residue_constants.restypes:
+    atom_names = residue_constants.restype_name_to_atom14_names[
+        residue_constants.restype_1to3[rt]]
+    restype_atom14_mask.append([(1. if name else 0.) for name in atom_names])
+
+  restype_atom14_mask.append([0.] * 14)
+  restype_atom14_mask = np.array(restype_atom14_mask, dtype=np.float32)
+  return restype_atom14_mask
+
+
+def _make_restype_atom37_to_atom14():
+  """"""Map from atom37 to atom14 per residue type.""""""
+  restype_atom37_to_atom14 = []  # mapping (restype, atom37) --> atom14
+  for rt in residue_constants.restypes:
+    atom_names = residue_constants.restype_name_to_atom14_names[
+        residue_constants.restype_1to3[rt]]
+    atom_name_to_idx14 = {name: i for i, name in enumerate(atom_names)}
+    restype_atom37_to_atom14.append([
+        (atom_name_to_idx14[name] if name in atom_name_to_idx14 else 0)
+        for name in residue_constants.atom_types
+    ])
+
+  restype_atom37_to_atom14.append([0] * 37)
+  restype_atom37_to_atom14 = np.array(restype_atom37_to_atom14, dtype=np.int32)
+  return restype_atom37_to_atom14
+
+
+def _make_restype_atom14_to_atom37():
+  """"""Map from atom14 to atom37 per residue type.""""""
+  restype_atom14_to_atom37 = []  # mapping (restype, atom14) --> atom37
+  for rt in residue_constants.restypes:
+    atom_names = residue_constants.restype_name_to_atom14_names[
+        residue_constants.restype_1to3[rt]]
+    restype_atom14_to_atom37.append([
+        (residue_constants.atom_order[name] if name else 0)
+        for name in atom_names
+    ])
+  # Add dummy mapping for restype 'UNK'
+  restype_atom14_to_atom37.append([0] * 14)
+  restype_atom14_to_atom37 = np.array(restype_atom14_to_atom37, dtype=np.int32)
+  return restype_atom14_to_atom37
+
+
+def _make_restype_atom14_is_ambiguous():
+  """"""Mask which atoms are ambiguous in atom14.""""""
+  # create an ambiguous atoms mask.  shape: (21, 14)
+  restype_atom14_is_ambiguous = np.zeros((21, 14), dtype=np.float32)
+  for resname, swap in residue_constants.residue_atom_renaming_swaps.items():
+    for atom_name1, atom_name2 in swap.items():
+      restype = residue_constants.restype_order[
+          residue_constants.restype_3to1[resname]]
+      atom_idx1 = residue_constants.restype_name_to_atom14_names[resname].index(
+          atom_name1)
+      atom_idx2 = residue_constants.restype_name_to_atom14_names[resname].index(
+          atom_name2)
+      restype_atom14_is_ambiguous[restype, atom_idx1] = 1
+      restype_atom14_is_ambiguous[restype, atom_idx2] = 1
+
+  return restype_atom14_is_ambiguous
+
+
+def _make_restype_rigidgroup_base_atom37_idx():
+  """"""Create Map from rigidgroups to atom37 indices.""""""
+  # Create an array with the atom names.
+  # shape (num_restypes, num_rigidgroups, 3_atoms): (21, 8, 3)
+  base_atom_names = np.full([21, 8, 3], '', dtype=object)
+
+  # 0: backbone frame
+  base_atom_names[:, 0, :] = ['C', 'CA', 'N']
+
+  # 3: 'psi-group'
+  base_atom_names[:, 3, :] = ['CA', 'C', 'O']
+
+  # 4,5,6,7: 'chi1,2,3,4-group'
+  for restype, restype_letter in enumerate(residue_constants.restypes):
+    resname = residue_constants.restype_1to3[restype_letter]
+    for chi_idx in range(4):
+      if residue_constants.chi_angles_mask[restype][chi_idx]:
+        atom_names = residue_constants.chi_angles_atoms[resname][chi_idx]
+        base_atom_names[restype, chi_idx + 4, :] = atom_names[1:]
+
+  # Translate atom names into atom37 indices.
+  lookuptable = residue_constants.atom_order.copy()
+  lookuptable[''] = 0
+  restype_rigidgroup_base_atom37_idx = np.vectorize(lambda x: lookuptable[x])(
+      base_atom_names)
+  return restype_rigidgroup_base_atom37_idx
+
+
+CHI_ATOM_INDICES = _make_chi_atom_indices()
+RENAMING_MATRICES = _make_renaming_matrices()
+RESTYPE_ATOM14_TO_ATOM37 = _make_restype_atom14_to_atom37()
+RESTYPE_ATOM37_TO_ATOM14 = _make_restype_atom37_to_atom14()
+RESTYPE_ATOM37_MASK = _make_restype_atom37_mask()
+RESTYPE_ATOM14_MASK = _make_restype_atom14_mask()
+RESTYPE_ATOM14_IS_AMBIGUOUS = _make_restype_atom14_is_ambiguous()
+RESTYPE_RIGIDGROUP_BASE_ATOM37_IDX = _make_restype_rigidgroup_base_atom37_idx()
+
+# Create mask for existing rigid groups.
+RESTYPE_RIGIDGROUP_MASK = np.zeros([21, 8], dtype=np.float32)
+RESTYPE_RIGIDGROUP_MASK[:, 0] = 1
+RESTYPE_RIGIDGROUP_MASK[:, 3] = 1
+RESTYPE_RIGIDGROUP_MASK[:20, 4:] = residue_constants.chi_angles_mask
+
+
+def get_atom37_mask(aatype):
+  return utils.batched_gather(jnp.asarray(RESTYPE_ATOM37_MASK), aatype)
+
+
+def get_atom14_mask(aatype):
+  return utils.batched_gather(jnp.asarray(RESTYPE_ATOM14_MASK), aatype)
+
+
+def get_atom14_is_ambiguous(aatype):
+  return utils.batched_gather(jnp.asarray(RESTYPE_ATOM14_IS_AMBIGUOUS), aatype)
+
+
+def get_atom14_to_atom37_map(aatype):
+  return utils.batched_gather(jnp.asarray(RESTYPE_ATOM14_TO_ATOM37), aatype)
+
+
+def get_atom37_to_atom14_map(aatype):
+  return utils.batched_gather(jnp.asarray(RESTYPE_ATOM37_TO_ATOM14), aatype)
+
+
+def atom14_to_atom37(atom14_data: jnp.ndarray,  # (N, 14, ...)
+                     aatype: jnp.ndarray
+                    ) -> jnp.ndarray:  # (N, 37, ...)
+  """"""Convert atom14 to atom37 representation.""""""
+  assert len(atom14_data.shape) in [2, 3]
+  idx_atom37_to_atom14 = get_atom37_to_atom14_map(aatype)
+  atom37_data = utils.batched_gather(
+      atom14_data, idx_atom37_to_atom14, batch_dims=1)
+  atom37_mask = get_atom37_mask(aatype)
+  if len(atom14_data.shape) == 2:
+    atom37_data *= atom37_mask
+  elif len(atom14_data.shape) == 3:
+    atom37_data *= atom37_mask[:, :, None].astype(atom37_data.dtype)
+  return atom37_data
+
+
+def atom37_to_atom14(aatype, all_atom_pos, all_atom_mask):
+  """"""Convert Atom37 positions to Atom14 positions.""""""
+  residx_atom14_to_atom37 = utils.batched_gather(
+      jnp.asarray(RESTYPE_ATOM14_TO_ATOM37), aatype)
+  atom14_mask = utils.batched_gather(
+      all_atom_mask, residx_atom14_to_atom37, batch_dims=1).astype(jnp.float32)
+  # create a mask for known groundtruth positions
+  atom14_mask *= utils.batched_gather(jnp.asarray(RESTYPE_ATOM14_MASK), aatype)
+  # gather the groundtruth positions
+  atom14_positions = jax.tree_map(
+      lambda x: utils.batched_gather(x, residx_atom14_to_atom37, batch_dims=1),
+      all_atom_pos)
+  atom14_positions = atom14_mask * atom14_positions
+  return atom14_positions, atom14_mask
+
+
+def get_alt_atom14(aatype, positions: geometry.Vec3Array, mask):
+  """"""Get alternative atom14 positions.""""""
+  # pick the transformation matrices for the given residue sequence
+  # shape (num_res, 14, 14)
+  renaming_transform = utils.batched_gather(
+      jnp.asarray(RENAMING_MATRICES), aatype)
+
+  alternative_positions = jax.tree_map(
+      lambda x: jnp.sum(x, axis=1), positions[:, :, None] * renaming_transform)
+
+  # Create the mask for the alternative ground truth (differs from the
+  # ground truth mask, if only one of the atoms in an ambiguous pair has a
+  # ground truth position)
+  alternative_mask = jnp.sum(mask[..., None] * renaming_transform, axis=1)
+
+  return alternative_positions, alternative_mask
+
+
+def atom37_to_frames(
+    aatype: jnp.ndarray,  # (...)
+    all_atom_positions: geometry.Vec3Array,  # (..., 37)
+    all_atom_mask: jnp.ndarray,  # (..., 37)
+) -> Dict[Text, jnp.ndarray]:
+  """"""Computes the frames for the up to 8 rigid groups for each residue.""""""
+  # 0: 'backbone group',
+  # 1: 'pre-omega-group', (empty)
+  # 2: 'phi-group', (currently empty, because it defines only hydrogens)
+  # 3: 'psi-group',
+  # 4,5,6,7: 'chi1,2,3,4-group'
+  aatype_in_shape = aatype.shape
+
+  # If there is a batch axis, just flatten it away, and reshape everything
+  # back at the end of the function.
+  aatype = jnp.reshape(aatype, [-1])
+  all_atom_positions = jax.tree_map(lambda x: jnp.reshape(x, [-1, 37]),
+                                    all_atom_positions)
+  all_atom_mask = jnp.reshape(all_atom_mask, [-1, 37])
+
+  # Compute the gather indices for all residues in the chain.
+  # shape (N, 8, 3)
+  residx_rigidgroup_base_atom37_idx = utils.batched_gather(
+      RESTYPE_RIGIDGROUP_BASE_ATOM37_IDX, aatype)
+
+  # Gather the base atom positions for each rigid group.
+  base_atom_pos = jax.tree_map(
+      lambda x: utils.batched_gather(  # pylint: disable=g-long-lambda
+          x, residx_rigidgroup_base_atom37_idx, batch_dims=1),
+      all_atom_positions)
+
+  # Compute the Rigids.
+  point_on_neg_x_axis = base_atom_pos[:, :, 0]
+  origin = base_atom_pos[:, :, 1]
+  point_on_xy_plane = base_atom_pos[:, :, 2]
+  gt_rotation = geometry.Rot3Array.from_two_vectors(
+      origin - point_on_neg_x_axis, point_on_xy_plane - origin)
+
+  gt_frames = geometry.Rigid3Array(gt_rotation, origin)
+
+  # Compute a mask whether the group exists.
+  # (N, 8)
+  group_exists = utils.batched_gather(RESTYPE_RIGIDGROUP_MASK, aatype)
+
+  # Compute a mask whether ground truth exists for the group
+  gt_atoms_exist = utils.batched_gather(  # shape (N, 8, 3)
+      all_atom_mask.astype(jnp.float32),
+      residx_rigidgroup_base_atom37_idx,
+      batch_dims=1)
+  gt_exists = jnp.min(gt_atoms_exist, axis=-1) * group_exists  # (N, 8)
+
+  # Adapt backbone frame to old convention (mirror x-axis and z-axis).
+  rots = np.tile(np.eye(3, dtype=np.float32), [8, 1, 1])
+  rots[0, 0, 0] = -1
+  rots[0, 2, 2] = -1
+  gt_frames = gt_frames.compose_rotation(
+      geometry.Rot3Array.from_array(rots))
+
+  # The frames for ambiguous rigid groups are just rotated by 180 degree around
+  # the x-axis. The ambiguous group is always the last chi-group.
+  restype_rigidgroup_is_ambiguous = np.zeros([21, 8], dtype=np.float32)
+  restype_rigidgroup_rots = np.tile(np.eye(3, dtype=np.float32), [21, 8, 1, 1])
+
+  for resname, _ in residue_constants.residue_atom_renaming_swaps.items():
+    restype = residue_constants.restype_order[
+        residue_constants.restype_3to1[resname]]
+    chi_idx = int(sum(residue_constants.chi_angles_mask[restype]) - 1)
+    restype_rigidgroup_is_ambiguous[restype, chi_idx + 4] = 1
+    restype_rigidgroup_rots[restype, chi_idx + 4, 1, 1] = -1
+    restype_rigidgroup_rots[restype, chi_idx + 4, 2, 2] = -1
+
+  # Gather the ambiguity information for each residue.
+  residx_rigidgroup_is_ambiguous = utils.batched_gather(
+      restype_rigidgroup_is_ambiguous, aatype)
+  ambiguity_rot = utils.batched_gather(restype_rigidgroup_rots, aatype)
+  ambiguity_rot = geometry.Rot3Array.from_array(ambiguity_rot)
+
+  # Create the alternative ground truth frames.
+  alt_gt_frames = gt_frames.compose_rotation(ambiguity_rot)
+
+  fix_shape = lambda x: jnp.reshape(x, aatype_in_shape + (8,))
+
+  # reshape back to original residue layout
+  gt_frames = jax.tree_map(fix_shape, gt_frames)
+  gt_exists = fix_shape(gt_exists)
+  group_exists = fix_shape(group_exists)
+  residx_rigidgroup_is_ambiguous = fix_shape(residx_rigidgroup_is_ambiguous)
+  alt_gt_frames = jax.tree_map(fix_shape, alt_gt_frames)
+
+  return {
+      'rigidgroups_gt_frames': gt_frames,  # Rigid (..., 8)
+      'rigidgroups_gt_exists': gt_exists,  # (..., 8)
+      'rigidgroups_group_exists': group_exists,  # (..., 8)
+      'rigidgroups_group_is_ambiguous':
+          residx_rigidgroup_is_ambiguous,  # (..., 8)
+      'rigidgroups_alt_gt_frames': alt_gt_frames,  # Rigid (..., 8)
+  }
+
+
+def torsion_angles_to_frames(
+    aatype: jnp.ndarray,  # (N)
+    backb_to_global: geometry.Rigid3Array,  # (N)
+    torsion_angles_sin_cos: jnp.ndarray  # (N, 7, 2)
+) -> geometry.Rigid3Array:  # (N, 8)
+  """"""Compute rigid group frames from torsion angles.""""""
+  assert len(aatype.shape) == 1, (
+      f'Expected array of rank 1, got array with shape: {aatype.shape}.')
+  assert len(backb_to_global.rotation.shape) == 1, (
+      f'Expected array of rank 1, got array with shape: '
+      f'{backb_to_global.rotation.shape}')
+  assert len(torsion_angles_sin_cos.shape) == 3, (
+      f'Expected array of rank 3, got array with shape: '
+      f'{torsion_angles_sin_cos.shape}')
+  assert torsion_angles_sin_cos.shape[1] == 7, (
+      f'wrong shape {torsion_angles_sin_cos.shape}')
+  assert torsion_angles_sin_cos.shape[2] == 2, (
+      f'wrong shape {torsion_angles_sin_cos.shape}')
+
+  # Gather the default frames for all rigid groups.
+  # geometry.Rigid3Array with shape (N, 8)
+  m = utils.batched_gather(residue_constants.restype_rigid_group_default_frame,
+                           aatype)
+  default_frames = geometry.Rigid3Array.from_array4x4(m)
+
+  # Create the rotation matrices according to the given angles (each frame is
+  # defined such that its rotation is around the x-axis).
+  sin_angles = torsion_angles_sin_cos[..., 0]
+  cos_angles = torsion_angles_sin_cos[..., 1]
+
+  # insert zero rotation for backbone group.
+  num_residues, = aatype.shape
+  sin_angles = jnp.concatenate([jnp.zeros([num_residues, 1]), sin_angles],
+                               axis=-1)
+  cos_angles = jnp.concatenate([jnp.ones([num_residues, 1]), cos_angles],
+                               axis=-1)
+  zeros = jnp.zeros_like(sin_angles)
+  ones = jnp.ones_like(sin_angles)
+
+  # all_rots are geometry.Rot3Array with shape (N, 8)
+  all_rots = geometry.Rot3Array(ones, zeros, zeros,
+                                zeros, cos_angles, -sin_angles,
+                                zeros, sin_angles, cos_angles)
+
+  # Apply rotations to the frames.
+  all_frames = default_frames.compose_rotation(all_rots)
+
+  # chi2, chi3, and chi4 frames do not transform to the backbone frame but to
+  # the previous frame. So chain them up accordingly.
+
+  chi1_frame_to_backb = all_frames[:, 4]
+  chi2_frame_to_backb = chi1_frame_to_backb @ all_frames[:, 5]
+  chi3_frame_to_backb = chi2_frame_to_backb @ all_frames[:, 6]
+  chi4_frame_to_backb = chi3_frame_to_backb @ all_frames[:, 7]
+
+  all_frames_to_backb = jax.tree_map(
+      lambda *x: jnp.concatenate(x, axis=-1), all_frames[:, 0:5],
+      chi2_frame_to_backb[:, None], chi3_frame_to_backb[:, None],
+      chi4_frame_to_backb[:, None])
+
+  # Create the global frames.
+  # shape (N, 8)
+  all_frames_to_global = backb_to_global[:, None] @ all_frames_to_backb
+
+  return all_frames_to_global
+
+
+def frames_and_literature_positions_to_atom14_pos(
+    aatype: jnp.ndarray,  # (N)
+    all_frames_to_global: geometry.Rigid3Array  # (N, 8)
+) -> geometry.Vec3Array:  # (N, 14)
+  """"""Put atom literature positions (atom14 encoding) in each rigid group.""""""
+
+  # Pick the appropriate transform for every atom.
+  residx_to_group_idx = utils.batched_gather(
+      residue_constants.restype_atom14_to_rigid_group, aatype)
+  group_mask = jax.nn.one_hot(
+      residx_to_group_idx, num_classes=8)  # shape (N, 14, 8)
+
+  # geometry.Rigid3Array with shape (N, 14)
+  map_atoms_to_global = jax.tree_map(
+      lambda x: jnp.sum(x[:, None, :] * group_mask, axis=-1),
+      all_frames_to_global)
+
+  # Gather the literature atom positions for each residue.
+  # geometry.Vec3Array with shape (N, 14)
+  lit_positions = geometry.Vec3Array.from_array(
+      utils.batched_gather(
+          residue_constants.restype_atom14_rigid_group_positions, aatype))
+
+  # Transform each atom from its local frame to the global frame.
+  # geometry.Vec3Array with shape (N, 14)
+  pred_positions = map_atoms_to_global.apply_to_point(lit_positions)
+
+  # Mask out non-existing atoms.
+  mask = utils.batched_gather(residue_constants.restype_atom14_mask, aatype)
+  pred_positions = pred_positions * mask
+
+  return pred_positions
+
+
+def extreme_ca_ca_distance_violations(
+    positions: geometry.Vec3Array,  # (N, 37(14))
+    mask: jnp.ndarray,  # (N, 37(14))
+    residue_index: jnp.ndarray,  # (N)
+    max_angstrom_tolerance=1.5
+    ) -> jnp.ndarray:
+  """"""Counts residues whose Ca is a large distance from its neighbor.""""""
+  this_ca_pos = positions[:-1, 1]  # (N - 1,)
+  this_ca_mask = mask[:-1, 1]         # (N - 1)
+  next_ca_pos = positions[1:, 1]  # (N - 1,)
+  next_ca_mask = mask[1:, 1]  # (N - 1)
+  has_no_gap_mask = ((residue_index[1:] - residue_index[:-1]) == 1.0).astype(
+      jnp.float32)
+  ca_ca_distance = geometry.euclidean_distance(this_ca_pos, next_ca_pos, 1e-6)
+  violations = (ca_ca_distance -
+                residue_constants.ca_ca) > max_angstrom_tolerance
+  mask = this_ca_mask * next_ca_mask * has_no_gap_mask
+  return utils.mask_mean(mask=mask, value=violations)
+
+
+def between_residue_bond_loss(
+    pred_atom_positions: geometry.Vec3Array,  # (N, 37(14))
+    pred_atom_mask: jnp.ndarray,  # (N, 37(14))
+    residue_index: jnp.ndarray,  # (N)
+    aatype: jnp.ndarray,  # (N)
+    tolerance_factor_soft=12.0,
+    tolerance_factor_hard=12.0) -> Dict[Text, jnp.ndarray]:
+  """"""Flat-bottom loss to penalize structural violations between residues.""""""
+  assert len(pred_atom_positions.shape) == 2
+  assert len(pred_atom_mask.shape) == 2
+  assert len(residue_index.shape) == 1
+  assert len(aatype.shape) == 1
+
+  # Get the positions of the relevant backbone atoms.
+  this_ca_pos = pred_atom_positions[:-1, 1]  # (N - 1)
+  this_ca_mask = pred_atom_mask[:-1, 1]         # (N - 1)
+  this_c_pos = pred_atom_positions[:-1, 2]  # (N - 1)
+  this_c_mask = pred_atom_mask[:-1, 2]          # (N - 1)
+  next_n_pos = pred_atom_positions[1:, 0]  # (N - 1)
+  next_n_mask = pred_atom_mask[1:, 0]           # (N - 1)
+  next_ca_pos = pred_atom_positions[1:, 1]  # (N - 1)
+  next_ca_mask = pred_atom_mask[1:, 1]          # (N - 1)
+  has_no_gap_mask = ((residue_index[1:] - residue_index[:-1]) == 1.0).astype(
+      jnp.float32)
+
+  # Compute loss for the C--N bond.
+  c_n_bond_length = geometry.euclidean_distance(this_c_pos, next_n_pos, 1e-6)
+
+  # The C-N bond to proline has slightly different length because of the ring.
+  next_is_proline = (
+      aatype[1:] == residue_constants.restype_order['P']).astype(jnp.float32)
+  gt_length = (
+      (1. - next_is_proline) * residue_constants.between_res_bond_length_c_n[0]
+      + next_is_proline * residue_constants.between_res_bond_length_c_n[1])
+  gt_stddev = (
+      (1. - next_is_proline) *
+      residue_constants.between_res_bond_length_stddev_c_n[0] +
+      next_is_proline * residue_constants.between_res_bond_length_stddev_c_n[1])
+  c_n_bond_length_error = jnp.sqrt(1e-6 +
+                                   jnp.square(c_n_bond_length - gt_length))
+  c_n_loss_per_residue = jax.nn.relu(
+      c_n_bond_length_error - tolerance_factor_soft * gt_stddev)
+  mask = this_c_mask * next_n_mask * has_no_gap_mask
+  c_n_loss = jnp.sum(mask * c_n_loss_per_residue) / (jnp.sum(mask) + 1e-6)
+  c_n_violation_mask = mask * (
+      c_n_bond_length_error > (tolerance_factor_hard * gt_stddev))
+
+  # Compute loss for the angles.
+  c_ca_unit_vec = (this_ca_pos - this_c_pos).normalized(1e-6)
+  c_n_unit_vec = (next_n_pos - this_c_pos) / c_n_bond_length
+  n_ca_unit_vec = (next_ca_pos - next_n_pos).normalized(1e-6)
+
+  ca_c_n_cos_angle = c_ca_unit_vec.dot(c_n_unit_vec)
+  gt_angle = residue_constants.between_res_cos_angles_ca_c_n[0]
+  gt_stddev = residue_constants.between_res_bond_length_stddev_c_n[0]
+  ca_c_n_cos_angle_error = jnp.sqrt(
+      1e-6 + jnp.square(ca_c_n_cos_angle - gt_angle))
+  ca_c_n_loss_per_residue = jax.nn.relu(
+      ca_c_n_cos_angle_error - tolerance_factor_soft * gt_stddev)
+  mask = this_ca_mask * this_c_mask * next_n_mask * has_no_gap_mask
+  ca_c_n_loss = jnp.sum(mask * ca_c_n_loss_per_residue) / (jnp.sum(mask) + 1e-6)
+  ca_c_n_violation_mask = mask * (ca_c_n_cos_angle_error >
+                                  (tolerance_factor_hard * gt_stddev))
+
+  c_n_ca_cos_angle = (-c_n_unit_vec).dot(n_ca_unit_vec)
+  gt_angle = residue_constants.between_res_cos_angles_c_n_ca[0]
+  gt_stddev = residue_constants.between_res_cos_angles_c_n_ca[1]
+  c_n_ca_cos_angle_error = jnp.sqrt(
+      1e-6 + jnp.square(c_n_ca_cos_angle - gt_angle))
+  c_n_ca_loss_per_residue = jax.nn.relu(
+      c_n_ca_cos_angle_error - tolerance_factor_soft * gt_stddev)
+  mask = this_c_mask * next_n_mask * next_ca_mask * has_no_gap_mask
+  c_n_ca_loss = jnp.sum(mask * c_n_ca_loss_per_residue) / (jnp.sum(mask) + 1e-6)
+  c_n_ca_violation_mask = mask * (
+      c_n_ca_cos_angle_error > (tolerance_factor_hard * gt_stddev))
+
+  # Compute a per residue loss (equally distribute the loss to both
+  # neighbouring residues).
+  per_residue_loss_sum = (c_n_loss_per_residue +
+                          ca_c_n_loss_per_residue +
+                          c_n_ca_loss_per_residue)
+  per_residue_loss_sum = 0.5 * (jnp.pad(per_residue_loss_sum, [[0, 1]]) +
+                                jnp.pad(per_residue_loss_sum, [[1, 0]]))
+
+  # Compute hard violations.
+  violation_mask = jnp.max(
+      jnp.stack([c_n_violation_mask,
+                 ca_c_n_violation_mask,
+                 c_n_ca_violation_mask]), axis=0)
+  violation_mask = jnp.maximum(
+      jnp.pad(violation_mask, [[0, 1]]),
+      jnp.pad(violation_mask, [[1, 0]]))
+
+  return {'c_n_loss_mean': c_n_loss,  # shape ()
+          'ca_c_n_loss_mean': ca_c_n_loss,  # shape ()
+          'c_n_ca_loss_mean': c_n_ca_loss,  # shape ()
+          'per_residue_loss_sum': per_residue_loss_sum,  # shape (N)
+          'per_residue_violation_mask': violation_mask  # shape (N)
+         }
+
+
+def between_residue_clash_loss(
+    pred_positions: geometry.Vec3Array,  # (N, 14)
+    atom_exists: jnp.ndarray,  # (N, 14)
+    atom_radius: jnp.ndarray,  # (N, 14)
+    residue_index: jnp.ndarray,  # (N)
+    asym_id: jnp.ndarray,  # (N)
+    overlap_tolerance_soft=1.5,
+    overlap_tolerance_hard=1.5) -> Dict[Text, jnp.ndarray]:
+  """"""Loss to penalize steric clashes between residues.""""""
+  assert len(pred_positions.shape) == 2
+  assert len(atom_exists.shape) == 2
+  assert len(atom_radius.shape) == 2
+  assert len(residue_index.shape) == 1
+
+  # Create the distance matrix.
+  # (N, N, 14, 14)
+  dists = geometry.euclidean_distance(pred_positions[:, None, :, None],
+                                      pred_positions[None, :, None, :], 1e-10)
+
+  # Create the mask for valid distances.
+  # shape (N, N, 14, 14)
+  dists_mask = (atom_exists[:, None, :, None] * atom_exists[None, :, None, :])
+
+  # Mask out all the duplicate entries in the lower triangular matrix.
+  # Also mask out the diagonal (atom-pairs from the same residue) -- these atoms
+  # are handled separately.
+  dists_mask *= (
+      residue_index[:, None, None, None] < residue_index[None, :, None, None])
+
+  # Backbone C--N bond between subsequent residues is no clash.
+  c_one_hot = jax.nn.one_hot(2, num_classes=14)
+  n_one_hot = jax.nn.one_hot(0, num_classes=14)
+  neighbour_mask = ((residue_index[:, None] + 1) == residue_index[None, :])
+  neighbour_mask &= (asym_id[:, None] == asym_id[None, :])
+  neighbour_mask = neighbour_mask[..., None, None]
+  c_n_bonds = neighbour_mask * c_one_hot[None, None, :,
+                                         None] * n_one_hot[None, None, None, :]
+  dists_mask *= (1. - c_n_bonds)
+
+  # Disulfide bridge between two cysteines is no clash.
+  cys_sg_idx = residue_constants.restype_name_to_atom14_names['CYS'].index('SG')
+  cys_sg_one_hot = jax.nn.one_hot(cys_sg_idx, num_classes=14)
+  disulfide_bonds = (cys_sg_one_hot[None, None, :, None] *
+                     cys_sg_one_hot[None, None, None, :])
+  dists_mask *= (1. - disulfide_bonds)
+
+  # Compute the lower bound for the allowed distances.
+  # shape (N, N, 14, 14)
+  dists_lower_bound = dists_mask * (
+      atom_radius[:, None, :, None] + atom_radius[None, :, None, :])
+
+  # Compute the error.
+  # shape (N, N, 14, 14)
+  dists_to_low_error = dists_mask * jax.nn.relu(
+      dists_lower_bound - overlap_tolerance_soft - dists)
+
+  # Compute the mean loss.
+  # shape ()
+  mean_loss = (jnp.sum(dists_to_low_error)
+               / (1e-6 + jnp.sum(dists_mask)))
+
+  # Compute the per atom loss sum.
+  # shape (N, 14)
+  per_atom_loss_sum = (jnp.sum(dists_to_low_error, axis=[0, 2]) +
+                       jnp.sum(dists_to_low_error, axis=[1, 3]))
+
+  # Compute the hard clash mask.
+  # shape (N, N, 14, 14)
+  clash_mask = dists_mask * (
+      dists < (dists_lower_bound - overlap_tolerance_hard))
+
+  # Compute the per atom clash.
+  # shape (N, 14)
+  per_atom_clash_mask = jnp.maximum(
+      jnp.max(clash_mask, axis=[0, 2]),
+      jnp.max(clash_mask, axis=[1, 3]))
+
+  return {'mean_loss': mean_loss,  # shape ()
+          'per_atom_loss_sum': per_atom_loss_sum,  # shape (N, 14)
+          'per_atom_clash_mask': per_atom_clash_mask  # shape (N, 14)
+         }
+
+
+def within_residue_violations(
+    pred_positions: geometry.Vec3Array,  # (N, 14)
+    atom_exists: jnp.ndarray,  # (N, 14)
+    dists_lower_bound: jnp.ndarray,  # (N, 14, 14)
+    dists_upper_bound: jnp.ndarray,  # (N, 14, 14)
+    tighten_bounds_for_loss=0.0,
+) -> Dict[Text, jnp.ndarray]:
+  """"""Find within-residue violations.""""""
+  assert len(pred_positions.shape) == 2
+  assert len(atom_exists.shape) == 2
+  assert len(dists_lower_bound.shape) == 3
+  assert len(dists_upper_bound.shape) == 3
+
+  # Compute the mask for each residue.
+  # shape (N, 14, 14)
+  dists_masks = (1. - jnp.eye(14, 14)[None])
+  dists_masks *= (atom_exists[:, :, None] * atom_exists[:, None, :])
+
+  # Distance matrix
+  # shape (N, 14, 14)
+  dists = geometry.euclidean_distance(pred_positions[:, :, None],
+                                      pred_positions[:, None, :], 1e-10)
+
+  # Compute the loss.
+  # shape (N, 14, 14)
+  dists_to_low_error = jax.nn.relu(
+      dists_lower_bound + tighten_bounds_for_loss - dists)
+  dists_to_high_error = jax.nn.relu(
+      dists + tighten_bounds_for_loss - dists_upper_bound)
+  loss = dists_masks * (dists_to_low_error + dists_to_high_error)
+
+  # Compute the per atom loss sum.
+  # shape (N, 14)
+  per_atom_loss_sum = (jnp.sum(loss, axis=1) +
+                       jnp.sum(loss, axis=2))
+
+  # Compute the violations mask.
+  # shape (N, 14, 14)
+  violations = dists_masks * ((dists < dists_lower_bound) |
+                              (dists > dists_upper_bound))
+
+  # Compute the per atom violations.
+  # shape (N, 14)
+  per_atom_violations = jnp.maximum(
+      jnp.max(violations, axis=1), jnp.max(violations, axis=2))
+
+  return {'per_atom_loss_sum': per_atom_loss_sum,  # shape (N, 14)
+          'per_atom_violations': per_atom_violations  # shape (N, 14)
+         }
+
+
+def find_optimal_renaming(
+    gt_positions: geometry.Vec3Array,  # (N, 14)
+    alt_gt_positions: geometry.Vec3Array,  # (N, 14)
+    atom_is_ambiguous: jnp.ndarray,  # (N, 14)
+    gt_exists: jnp.ndarray,  # (N, 14)
+    pred_positions: geometry.Vec3Array,  # (N, 14)
+) -> jnp.ndarray:  # (N):
+  """"""Find optimal renaming for ground truth that maximizes LDDT.""""""
+  assert len(gt_positions.shape) == 2
+  assert len(alt_gt_positions.shape) == 2
+  assert len(atom_is_ambiguous.shape) == 2
+  assert len(gt_exists.shape) == 2
+  assert len(pred_positions.shape) == 2
+
+  # Create the pred distance matrix.
+  # shape (N, N, 14, 14)
+  pred_dists = geometry.euclidean_distance(pred_positions[:, None, :, None],
+                                           pred_positions[None, :, None, :],
+                                           1e-10)
+
+  # Compute distances for ground truth with original and alternative names.
+  # shape (N, N, 14, 14)
+  gt_dists = geometry.euclidean_distance(gt_positions[:, None, :, None],
+                                         gt_positions[None, :, None, :], 1e-10)
+
+  alt_gt_dists = geometry.euclidean_distance(alt_gt_positions[:, None, :, None],
+                                             alt_gt_positions[None, :, None, :],
+                                             1e-10)
+
+  # Compute LDDT's.
+  # shape (N, N, 14, 14)
+  lddt = jnp.sqrt(1e-10 + squared_difference(pred_dists, gt_dists))
+  alt_lddt = jnp.sqrt(1e-10 + squared_difference(pred_dists, alt_gt_dists))
+
+  # Create a mask for ambiguous atoms in rows vs. non-ambiguous atoms
+  # in cols.
+  # shape (N ,N, 14, 14)
+  mask = (
+      gt_exists[:, None, :, None] *  # rows
+      atom_is_ambiguous[:, None, :, None] *  # rows
+      gt_exists[None, :, None, :] *  # cols
+      (1. - atom_is_ambiguous[None, :, None, :]))  # cols
+
+  # Aggregate distances for each residue to the non-amibuguous atoms.
+  # shape (N)
+  per_res_lddt = jnp.sum(mask * lddt, axis=[1, 2, 3])
+  alt_per_res_lddt = jnp.sum(mask * alt_lddt, axis=[1, 2, 3])
+
+  # Decide for each residue, whether alternative naming is better.
+  # shape (N)
+  alt_naming_is_better = (alt_per_res_lddt < per_res_lddt).astype(jnp.float32)
+
+  return alt_naming_is_better  # shape (N)
+
+
+def frame_aligned_point_error(
+    pred_frames: geometry.Rigid3Array,  # shape (num_frames)
+    target_frames: geometry.Rigid3Array,  # shape (num_frames)
+    frames_mask: jnp.ndarray,  # shape (num_frames)
+    pred_positions: geometry.Vec3Array,  # shape (num_positions)
+    target_positions: geometry.Vec3Array,  # shape (num_positions)
+    positions_mask: jnp.ndarray,  # shape (num_positions)
+    pair_mask: jnp.ndarray,  # shape (num_frames, num_posiitons)
+    l1_clamp_distance: float,
+    length_scale=20.,
+    epsilon=1e-4) -> jnp.ndarray:  # shape ()
+  """"""Measure point error under different alignements.
+
+  Computes error between two structures with B points
+  under A alignments derived form the given pairs of frames.
+  Args:
+    pred_frames: num_frames reference frames for 'pred_positions'.
+    target_frames: num_frames reference frames for 'target_positions'.
+    frames_mask: Mask for frame pairs to use.
+    pred_positions: num_positions predicted positions of the structure.
+    target_positions: num_positions target positions of the structure.
+    positions_mask: Mask on which positions to score.
+    pair_mask: A (num_frames, num_positions) mask to use in the loss, useful
+      for separating intra from inter chain losses.
+    l1_clamp_distance: Distance cutoff on error beyond which gradients will
+      be zero.
+    length_scale: length scale to divide loss by.
+    epsilon: small value used to regularize denominator for masked average.
+  Returns:
+    Masked Frame aligned point error.
+  """"""
+  # For now we do not allow any batch dimensions.
+  assert len(pred_frames.rotation.shape) == 1
+  assert len(target_frames.rotation.shape) == 1
+  assert frames_mask.ndim == 1
+  assert pred_positions.x.ndim == 1
+  assert target_positions.x.ndim == 1
+  assert positions_mask.ndim == 1
+
+  # Compute array of predicted positions in the predicted frames.
+  # geometry.Vec3Array (num_frames, num_positions)
+  local_pred_pos = pred_frames[:, None].inverse().apply_to_point(
+      pred_positions[None, :])
+
+  # Compute array of target positions in the target frames.
+  # geometry.Vec3Array (num_frames, num_positions)
+  local_target_pos = target_frames[:, None].inverse().apply_to_point(
+      target_positions[None, :])
+
+  # Compute errors between the structures.
+  # jnp.ndarray (num_frames, num_positions)
+  error_dist = geometry.euclidean_distance(local_pred_pos, local_target_pos,
+                                           epsilon)
+
+  clipped_error_dist = jnp.clip(error_dist, 0, l1_clamp_distance)
+
+  normed_error = clipped_error_dist / length_scale
+  normed_error *= jnp.expand_dims(frames_mask, axis=-1)
+  normed_error *= jnp.expand_dims(positions_mask, axis=-2)
+  if pair_mask is not None:
+    normed_error *= pair_mask
+
+  mask = (jnp.expand_dims(frames_mask, axis=-1) *
+          jnp.expand_dims(positions_mask, axis=-2))
+  if pair_mask is not None:
+    mask *= pair_mask
+  normalization_factor = jnp.sum(mask, axis=(-1, -2))
+  return (jnp.sum(normed_error, axis=(-2, -1)) /
+          (epsilon + normalization_factor))
+
+
+def get_chi_atom_indices():
+  """"""Returns atom indices needed to compute chi angles for all residue types.
+
+  Returns:
+    A tensor of shape [residue_types=21, chis=4, atoms=4]. The residue types are
+    in the order specified in residue_constants.restypes + unknown residue type
+    at the end. For chi angles which are not defined on the residue, the
+    positions indices are by default set to 0.
+  """"""
+  chi_atom_indices = []
+  for residue_name in residue_constants.restypes:
+    residue_name = residue_constants.restype_1to3[residue_name]
+    residue_chi_angles = residue_constants.chi_angles_atoms[residue_name]
+    atom_indices = []
+    for chi_angle in residue_chi_angles:
+      atom_indices.append(
+          [residue_constants.atom_order[atom] for atom in chi_angle])
+    for _ in range(4 - len(atom_indices)):
+      atom_indices.append([0, 0, 0, 0])  # For chi angles not defined on the AA.
+    chi_atom_indices.append(atom_indices)
+
+  chi_atom_indices.append([[0, 0, 0, 0]] * 4)  # For UNKNOWN residue.
+
+  return jnp.asarray(chi_atom_indices)
+
+
+def compute_chi_angles(positions: geometry.Vec3Array,
+                       mask: geometry.Vec3Array,
+                       aatype: geometry.Vec3Array):
+  """"""Computes the chi angles given all atom positions and the amino acid type.
+
+  Args:
+    positions: A Vec3Array of shape
+      [num_res, residue_constants.atom_type_num], with positions of
+      atoms needed to calculate chi angles. Supports up to 1 batch dimension.
+    mask: An optional tensor of shape
+      [num_res, residue_constants.atom_type_num] that masks which atom
+      positions are set for each residue. If given, then the chi mask will be
+      set to 1 for a chi angle only if the amino acid has that chi angle and all
+      the chi atoms needed to calculate that chi angle are set. If not given
+      (set to None), the chi mask will be set to 1 for a chi angle if the amino
+      acid has that chi angle and whether the actual atoms needed to calculate
+      it were set will be ignored.
+    aatype: A tensor of shape [num_res] with amino acid type integer
+      code (0 to 21). Supports up to 1 batch dimension.
+
+  Returns:
+    A tuple of tensors (chi_angles, mask), where both have shape
+    [num_res, 4]. The mask masks out unused chi angles for amino acid
+    types that have less than 4 chi angles. If atom_positions_mask is set, the
+    chi mask will also mask out uncomputable chi angles.
+  """"""
+
+  # Don't assert on the num_res and batch dimensions as they might be unknown.
+  assert positions.shape[-1] == residue_constants.atom_type_num
+  assert mask.shape[-1] == residue_constants.atom_type_num
+
+  # Compute the table of chi angle indices. Shape: [restypes, chis=4, atoms=4].
+  chi_atom_indices = get_chi_atom_indices()
+  # Select atoms to compute chis. Shape: [num_res, chis=4, atoms=4].
+  atom_indices = utils.batched_gather(
+      params=chi_atom_indices, indices=aatype, axis=0)
+  # Gather atom positions. Shape: [num_res, chis=4, atoms=4, xyz=3].
+  chi_angle_atoms = jax.tree_map(
+      lambda x: utils.batched_gather(  # pylint: disable=g-long-lambda
+          params=x, indices=atom_indices, axis=-1, batch_dims=1), positions)
+  a, b, c, d = [chi_angle_atoms[..., i] for i in range(4)]
+
+  chi_angles = geometry.dihedral_angle(a, b, c, d)
+
+  # Copy the chi angle mask, add the UNKNOWN residue. Shape: [restypes, 4].
+  chi_angles_mask = list(residue_constants.chi_angles_mask)
+  chi_angles_mask.append([0.0, 0.0, 0.0, 0.0])
+  chi_angles_mask = jnp.asarray(chi_angles_mask)
+  # Compute the chi angle mask. Shape [num_res, chis=4].
+  chi_mask = utils.batched_gather(params=chi_angles_mask, indices=aatype,
+                                  axis=0)
+
+  # The chi_mask is set to 1 only when all necessary chi angle atoms were set.
+  # Gather the chi angle atoms mask. Shape: [num_res, chis=4, atoms=4].
+  chi_angle_atoms_mask = utils.batched_gather(
+      params=mask, indices=atom_indices, axis=-1, batch_dims=1)
+  # Check if all 4 chi angle atoms were set. Shape: [num_res, chis=4].
+  chi_angle_atoms_mask = jnp.prod(chi_angle_atoms_mask, axis=[-1])
+  chi_mask = chi_mask * chi_angle_atoms_mask.astype(jnp.float32)
+
+  return chi_angles, chi_mask
+
+
+def make_transform_from_reference(
+    a_xyz: geometry.Vec3Array,
+    b_xyz: geometry.Vec3Array,
+    c_xyz: geometry.Vec3Array) -> geometry.Rigid3Array:
+  """"""Returns rotation and translation matrices to convert from reference.
+
+  Note that this method does not take care of symmetries. If you provide the
+  coordinates in the non-standard way, the A atom will end up in the negative
+  y-axis rather than in the positive y-axis. You need to take care of such
+  cases in your code.
+
+  Args:
+    a_xyz: A Vec3Array.
+    b_xyz: A Vec3Array.
+    c_xyz: A Vec3Array.
+
+  Returns:
+    A Rigid3Array which, when applied to coordinates in a canonicalized
+    reference frame, will give coordinates approximately equal
+    the original coordinates (in the global frame).
+  """"""
+  rotation = geometry.Rot3Array.from_two_vectors(c_xyz - b_xyz,
+                                                 a_xyz - b_xyz)
+  return geometry.Rigid3Array(rotation, b_xyz)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/__init__.py",".py","617","15","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Alphafold model.""""""
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/modules_multimer.py",".py","42228","1179","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Core modules, which have been refactored in AlphaFold-Multimer.
+
+The main difference is that MSA sampling pipeline is moved inside the JAX model
+for easier implementation of recycling and ensembling.
+
+Lower-level modules up to EvoformerIteration are reused from modules.py.
+""""""
+
+import functools
+from typing import Sequence
+
+from alphafold.common import residue_constants
+from alphafold.model import all_atom_multimer
+from alphafold.model import common_modules
+from alphafold.model import folding_multimer
+from alphafold.model import geometry
+from alphafold.model import layer_stack
+from alphafold.model import modules
+from alphafold.model import prng
+from alphafold.model import utils
+
+import haiku as hk
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+
+def reduce_fn(x, mode):
+  if mode == 'none' or mode is None:
+    return jnp.asarray(x)
+  elif mode == 'sum':
+    return jnp.asarray(x).sum()
+  elif mode == 'mean':
+    return jnp.mean(jnp.asarray(x))
+  else:
+    raise ValueError('Unsupported reduction option.')
+
+
+def gumbel_noise(key: jnp.ndarray, shape: Sequence[int]) -> jnp.ndarray:
+  """"""Generate Gumbel Noise of given Shape.
+
+  This generates samples from Gumbel(0, 1).
+
+  Args:
+    key: Jax random number key.
+    shape: Shape of noise to return.
+
+  Returns:
+    Gumbel noise of given shape.
+  """"""
+  epsilon = 1e-6
+  uniform = utils.padding_consistent_rng(jax.random.uniform)
+  uniform_noise = uniform(
+      key, shape=shape, dtype=jnp.float32, minval=0., maxval=1.)
+  gumbel = -jnp.log(-jnp.log(uniform_noise + epsilon) + epsilon)
+  return gumbel
+
+
+def gumbel_max_sample(key: jnp.ndarray, logits: jnp.ndarray) -> jnp.ndarray:
+  """"""Samples from a probability distribution given by 'logits'.
+
+  This uses Gumbel-max trick to implement the sampling in an efficient manner.
+
+  Args:
+    key: prng key.
+    logits: Logarithm of probabilities to sample from, probabilities can be
+      unnormalized.
+
+  Returns:
+    Sample from logprobs in one-hot form.
+  """"""
+  z = gumbel_noise(key, logits.shape)
+  return jax.nn.one_hot(
+      jnp.argmax(logits + z, axis=-1),
+      logits.shape[-1],
+      dtype=logits.dtype)
+
+
+def gumbel_argsort_sample_idx(key: jnp.ndarray,
+                              logits: jnp.ndarray) -> jnp.ndarray:
+  """"""Samples with replacement from a distribution given by 'logits'.
+
+  This uses Gumbel trick to implement the sampling an efficient manner. For a
+  distribution over k items this samples k times without replacement, so this
+  is effectively sampling a random permutation with probabilities over the
+  permutations derived from the logprobs.
+
+  Args:
+    key: prng key.
+    logits: Logarithm of probabilities to sample from, probabilities can be
+      unnormalized.
+
+  Returns:
+    Sample from logprobs in one-hot form.
+  """"""
+  z = gumbel_noise(key, logits.shape)
+  # This construction is equivalent to jnp.argsort, but using a non stable sort,
+  # since stable sort's aren't supported by jax2tf.
+  axis = len(logits.shape) - 1
+  iota = jax.lax.broadcasted_iota(jnp.int64, logits.shape, axis)
+  _, perm = jax.lax.sort_key_val(
+      logits + z, iota, dimension=-1, is_stable=False)
+  return perm[::-1]
+
+
+def make_masked_msa(batch, key, config, epsilon=1e-6):
+  """"""Create data for BERT on raw MSA.""""""
+  # Add a random amino acid uniformly.
+  random_aa = jnp.array([0.05] * 20 + [0., 0.], dtype=jnp.float32)
+
+  categorical_probs = (
+      config.uniform_prob * random_aa +
+      config.profile_prob * batch['msa_profile'] +
+      config.same_prob * jax.nn.one_hot(batch['msa'], 22))
+
+  # Put all remaining probability on [MASK] which is a new column.
+  pad_shapes = [[0, 0] for _ in range(len(categorical_probs.shape))]
+  pad_shapes[-1][1] = 1
+  mask_prob = 1. - config.profile_prob - config.same_prob - config.uniform_prob
+  assert mask_prob >= 0.
+  categorical_probs = jnp.pad(
+      categorical_probs, pad_shapes, constant_values=mask_prob)
+  sh = batch['msa'].shape
+  key, mask_subkey, gumbel_subkey = key.split(3)
+  uniform = utils.padding_consistent_rng(jax.random.uniform)
+  mask_position = uniform(mask_subkey.get(), sh) < config.replace_fraction
+  mask_position *= batch['msa_mask']
+
+  logits = jnp.log(categorical_probs + epsilon)
+  bert_msa = gumbel_max_sample(gumbel_subkey.get(), logits)
+  bert_msa = jnp.where(mask_position,
+                       jnp.argmax(bert_msa, axis=-1), batch['msa'])
+  bert_msa *= batch['msa_mask']
+
+  # Mix real and masked MSA.
+  if 'bert_mask' in batch:
+    batch['bert_mask'] *= mask_position.astype(jnp.float32)
+  else:
+    batch['bert_mask'] = mask_position.astype(jnp.float32)
+  batch['true_msa'] = batch['msa']
+  batch['msa'] = bert_msa
+
+  return batch
+
+
+def nearest_neighbor_clusters(batch, gap_agreement_weight=0.):
+  """"""Assign each extra MSA sequence to its nearest neighbor in sampled MSA.""""""
+
+  # Determine how much weight we assign to each agreement.  In theory, we could
+  # use a full blosum matrix here, but right now let's just down-weight gap
+  # agreement because it could be spurious.
+  # Never put weight on agreeing on BERT mask.
+
+  weights = jnp.array(
+      [1.] * 21 + [gap_agreement_weight] + [0.], dtype=jnp.float32)
+
+  msa_mask = batch['msa_mask']
+  msa_one_hot = jax.nn.one_hot(batch['msa'], 23)
+
+  extra_mask = batch['extra_msa_mask']
+  extra_one_hot = jax.nn.one_hot(batch['extra_msa'], 23)
+
+  msa_one_hot_masked = msa_mask[:, :, None] * msa_one_hot
+  extra_one_hot_masked = extra_mask[:, :, None] * extra_one_hot
+
+  agreement = jnp.einsum('mrc, nrc->nm', extra_one_hot_masked,
+                         weights * msa_one_hot_masked)
+
+  cluster_assignment = jax.nn.softmax(1e3 * agreement, axis=0)
+  cluster_assignment *= jnp.einsum('mr, nr->mn', msa_mask, extra_mask)
+
+  cluster_count = jnp.sum(cluster_assignment, axis=-1)
+  cluster_count += 1.  # We always include the sequence itself.
+
+  msa_sum = jnp.einsum('nm, mrc->nrc', cluster_assignment, extra_one_hot_masked)
+  msa_sum += msa_one_hot_masked
+
+  cluster_profile = msa_sum / cluster_count[:, None, None]
+
+  extra_deletion_matrix = batch['extra_deletion_matrix']
+  deletion_matrix = batch['deletion_matrix']
+
+  del_sum = jnp.einsum('nm, mc->nc', cluster_assignment,
+                       extra_mask * extra_deletion_matrix)
+  del_sum += deletion_matrix  # Original sequence.
+  cluster_deletion_mean = del_sum / cluster_count[:, None]
+
+  return cluster_profile, cluster_deletion_mean
+
+
+def create_msa_feat(batch):
+  """"""Create and concatenate MSA features.""""""
+  msa_1hot = jax.nn.one_hot(batch['msa'], 23)
+  deletion_matrix = batch['deletion_matrix']
+  has_deletion = jnp.clip(deletion_matrix, 0., 1.)[..., None]
+  deletion_value = (jnp.arctan(deletion_matrix / 3.) * (2. / jnp.pi))[..., None]
+
+  deletion_mean_value = (jnp.arctan(batch['cluster_deletion_mean'] / 3.) *
+                         (2. / jnp.pi))[..., None]
+
+  msa_feat = [
+      msa_1hot,
+      has_deletion,
+      deletion_value,
+      batch['cluster_profile'],
+      deletion_mean_value
+  ]
+
+  return jnp.concatenate(msa_feat, axis=-1)
+
+
+def create_extra_msa_feature(batch, num_extra_msa):
+  """"""Expand extra_msa into 1hot and concat with other extra msa features.
+
+  We do this as late as possible as the one_hot extra msa can be very large.
+
+  Args:
+    batch: a dictionary with the following keys:
+     * 'extra_msa': [num_seq, num_res] MSA that wasn't selected as a cluster
+       centre. Note - This isn't one-hotted.
+     * 'extra_deletion_matrix': [num_seq, num_res] Number of deletions at given
+        position.
+    num_extra_msa: Number of extra msa to use.
+
+  Returns:
+    Concatenated tensor of extra MSA features.
+  """"""
+  # 23 = 20 amino acids + 'X' for unknown + gap + bert mask
+  extra_msa = batch['extra_msa'][:num_extra_msa]
+  deletion_matrix = batch['extra_deletion_matrix'][:num_extra_msa]
+  msa_1hot = jax.nn.one_hot(extra_msa, 23)
+  has_deletion = jnp.clip(deletion_matrix, 0., 1.)[..., None]
+  deletion_value = (jnp.arctan(deletion_matrix / 3.) * (2. / jnp.pi))[..., None]
+  extra_msa_mask = batch['extra_msa_mask'][:num_extra_msa]
+  return jnp.concatenate([msa_1hot, has_deletion, deletion_value],
+                         axis=-1), extra_msa_mask
+
+
+def sample_msa(key, batch, max_seq):
+  """"""Sample MSA randomly, remaining sequences are stored as `extra_*`.
+
+  Args:
+    key: safe key for random number generation.
+    batch: batch to sample msa from.
+    max_seq: number of sequences to sample.
+  Returns:
+    Protein with sampled msa.
+  """"""
+  # Sample uniformly among sequences with at least one non-masked position.
+  logits = (jnp.clip(jnp.sum(batch['msa_mask'], axis=-1), 0., 1.) - 1.) * 1e6
+  # The cluster_bias_mask can be used to preserve the first row (target
+  # sequence) for each chain, for example.
+  if 'cluster_bias_mask' not in batch:
+    cluster_bias_mask = jnp.pad(
+        jnp.zeros(batch['msa'].shape[0] - 1), (1, 0), constant_values=1.)
+  else:
+    cluster_bias_mask = batch['cluster_bias_mask']
+
+  logits += cluster_bias_mask * 1e6
+  index_order = gumbel_argsort_sample_idx(key.get(), logits)
+  sel_idx = index_order[:max_seq]
+  extra_idx = index_order[max_seq:]
+
+  for k in ['msa', 'deletion_matrix', 'msa_mask', 'bert_mask']:
+    if k in batch:
+      batch['extra_' + k] = batch[k][extra_idx]
+      batch[k] = batch[k][sel_idx]
+
+  return batch
+
+
+def make_msa_profile(batch):
+  """"""Compute the MSA profile.""""""
+
+  # Compute the profile for every residue (over all MSA sequences).
+  return utils.mask_mean(
+      batch['msa_mask'][:, :, None], jax.nn.one_hot(batch['msa'], 22), axis=0)
+
+
+class AlphaFoldIteration(hk.Module):
+  """"""A single recycling iteration of AlphaFold architecture.
+
+  Computes ensembled (averaged) representations from the provided features.
+  These representations are then passed to the various heads
+  that have been requested by the configuration file.
+  """"""
+
+  def __init__(self, config, global_config, name='alphafold_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               batch,
+               is_training,
+               return_representations=False,
+               safe_key=None):
+
+    if is_training:
+      num_ensemble = np.asarray(self.config.num_ensemble_train)
+    else:
+      num_ensemble = np.asarray(self.config.num_ensemble_eval)
+
+    # Compute representations for each MSA sample and average.
+    embedding_module = EmbeddingsAndEvoformer(
+        self.config.embeddings_and_evoformer, self.global_config)
+    repr_shape = hk.eval_shape(
+        lambda: embedding_module(batch, is_training))
+    representations = {
+        k: jnp.zeros(v.shape, v.dtype) for (k, v) in repr_shape.items()
+    }
+
+    def ensemble_body(x, unused_y):
+      """"""Add into representations ensemble.""""""
+      del unused_y
+      representations, safe_key = x
+      safe_key, safe_subkey = safe_key.split()
+      representations_update = embedding_module(
+          batch, is_training, safe_key=safe_subkey)
+
+      for k in representations:
+        if k not in {'msa', 'true_msa', 'bert_mask'}:
+          representations[k] += representations_update[k] * (
+              1. / num_ensemble).astype(representations[k].dtype)
+        else:
+          representations[k] = representations_update[k]
+
+      return (representations, safe_key), None
+
+    (representations, _), _ = hk.scan(
+        ensemble_body, (representations, safe_key), None, length=num_ensemble)
+
+    self.representations = representations
+    self.batch = batch
+    self.heads = {}
+    for head_name, head_config in sorted(self.config.heads.items()):
+      if not head_config.weight:
+        continue  # Do not instantiate zero-weight heads.
+
+      head_factory = {
+          'masked_msa':
+              modules.MaskedMsaHead,
+          'distogram':
+              modules.DistogramHead,
+          'structure_module':
+              folding_multimer.StructureModule,
+          'predicted_aligned_error':
+              modules.PredictedAlignedErrorHead,
+          'predicted_lddt':
+              modules.PredictedLDDTHead,
+          'experimentally_resolved':
+              modules.ExperimentallyResolvedHead,
+      }[head_name]
+      self.heads[head_name] = (head_config,
+                               head_factory(head_config, self.global_config))
+
+    structure_module_output = None
+    if 'entity_id' in batch and 'all_atom_positions' in batch:
+      _, fold_module = self.heads['structure_module']
+      structure_module_output = fold_module(representations, batch, is_training)
+
+    ret = {}
+    ret['representations'] = representations
+
+    for name, (head_config, module) in self.heads.items():
+      if name == 'structure_module' and structure_module_output is not None:
+        ret[name] = structure_module_output
+        representations['structure_module'] = structure_module_output.pop('act')
+      # Skip confidence heads until StructureModule is executed.
+      elif name in {'predicted_lddt', 'predicted_aligned_error',
+                    'experimentally_resolved'}:
+        continue
+      else:
+        ret[name] = module(representations, batch, is_training)
+
+    # Add confidence heads after StructureModule is executed.
+    if self.config.heads.get('predicted_lddt.weight', 0.0):
+      name = 'predicted_lddt'
+      head_config, module = self.heads[name]
+      ret[name] = module(representations, batch, is_training)
+
+    if self.config.heads.experimentally_resolved.weight:
+      name = 'experimentally_resolved'
+      head_config, module = self.heads[name]
+      ret[name] = module(representations, batch, is_training)
+
+    if self.config.heads.get('predicted_aligned_error.weight', 0.0):
+      name = 'predicted_aligned_error'
+      head_config, module = self.heads[name]
+      ret[name] = module(representations, batch, is_training)
+      # Will be used for ipTM computation.
+      ret[name]['asym_id'] = batch['asym_id']
+
+    return ret
+
+
+class AlphaFold(hk.Module):
+  """"""AlphaFold-Multimer model with recycling.
+  """"""
+
+  def __init__(self, config, name='alphafold'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = config.global_config
+
+  def __call__(
+      self,
+      batch,
+      is_training,
+      return_representations=False,
+      safe_key=None):
+
+    c = self.config
+    impl = AlphaFoldIteration(c, self.global_config)
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+    elif isinstance(safe_key, jnp.ndarray):
+      safe_key = prng.SafeKey(safe_key)
+
+    assert isinstance(batch, dict)
+    num_res = batch['aatype'].shape[0]
+
+    def get_prev(ret):
+      new_prev = {
+          'prev_pos':
+              ret['structure_module']['final_atom_positions'],
+          'prev_msa_first_row': ret['representations']['msa_first_row'],
+          'prev_pair': ret['representations']['pair'],
+      }
+      return jax.tree_map(jax.lax.stop_gradient, new_prev)
+
+    def apply_network(prev, safe_key):
+      recycled_batch = {**batch, **prev}
+      return impl(
+          batch=recycled_batch,
+          is_training=is_training,
+          safe_key=safe_key)
+
+    prev = {}
+    emb_config = self.config.embeddings_and_evoformer
+    if emb_config.recycle_pos:
+      prev['prev_pos'] = jnp.zeros(
+          [num_res, residue_constants.atom_type_num, 3])
+    if emb_config.recycle_features:
+      prev['prev_msa_first_row'] = jnp.zeros(
+          [num_res, emb_config.msa_channel])
+      prev['prev_pair'] = jnp.zeros(
+          [num_res, num_res, emb_config.pair_channel])
+
+    if self.config.num_recycle:
+      if 'num_iter_recycling' in batch:
+        # Training time: num_iter_recycling is in batch.
+        # Value for each ensemble batch is the same, so arbitrarily taking 0-th.
+        num_iter = batch['num_iter_recycling'][0]
+
+        # Add insurance that even when ensembling, we will not run more
+        # recyclings than the model is configured to run.
+        num_iter = jnp.minimum(num_iter, c.num_recycle)
+      else:
+        # Eval mode or tests: use the maximum number of iterations.
+        num_iter = c.num_recycle
+
+      def distances(points):
+        """"""Compute all pairwise distances for a set of points.""""""
+        return jnp.sqrt(jnp.sum((points[:, None] - points[None, :])**2,
+                                axis=-1))
+
+      def recycle_body(x):
+        i, _, prev, safe_key = x
+        safe_key1, safe_key2 = safe_key.split() if c.resample_msa_in_recycling else safe_key.duplicate()  # pylint: disable=line-too-long
+        ret = apply_network(prev=prev, safe_key=safe_key2)
+        return i+1, prev, get_prev(ret), safe_key1
+
+      def recycle_cond(x):
+        i, prev, next_in, _ = x
+        ca_idx = residue_constants.atom_order['CA']
+        sq_diff = jnp.square(distances(prev['prev_pos'][:, ca_idx, :]) -
+                             distances(next_in['prev_pos'][:, ca_idx, :]))
+        mask = batch['seq_mask'][:, None] * batch['seq_mask'][None, :]
+        sq_diff = utils.mask_mean(mask, sq_diff)
+        # Early stopping criteria based on criteria used in
+        # AF2Complex: https://www.nature.com/articles/s41467-022-29394-2
+        diff = jnp.sqrt(sq_diff + 1e-8)  # avoid bad numerics giving negatives
+        less_than_max_recycles = (i < num_iter)
+        has_exceeded_tolerance = (
+            (i == 0) | (diff > c.recycle_early_stop_tolerance))
+        return less_than_max_recycles & has_exceeded_tolerance
+
+      if hk.running_init():
+        num_recycles, _, prev, safe_key = recycle_body(
+            (0, prev, prev, safe_key))
+      else:
+        num_recycles, _, prev, safe_key = hk.while_loop(
+            recycle_cond,
+            recycle_body,
+            (0, prev, prev, safe_key))
+    else:
+      # No recycling.
+      num_recycles = 0
+
+    # Run extra iteration.
+    ret = apply_network(prev=prev, safe_key=safe_key)
+
+    if not return_representations:
+      del ret['representations']
+    ret['num_recycles'] = num_recycles
+
+    return ret
+
+
+class EmbeddingsAndEvoformer(hk.Module):
+  """"""Embeds the input data and runs Evoformer.
+
+  Produces the MSA, single and pair representations.
+  """"""
+
+  def __init__(self, config, global_config, name='evoformer'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def _relative_encoding(self, batch):
+    """"""Add relative position encodings.
+
+    For position (i, j), the value is (i-j) clipped to [-k, k] and one-hotted.
+
+    When not using 'use_chain_relative' the residue indices are used as is, e.g.
+    for heteromers relative positions will be computed using the positions in
+    the corresponding chains.
+
+    When using 'use_chain_relative' we add an extra bin that denotes
+    'different chain'. Furthermore we also provide the relative chain index
+    (i.e. sym_id) clipped and one-hotted to the network. And an extra feature
+    which denotes whether they belong to the same chain type, i.e. it's 0 if
+    they are in different heteromer chains and 1 otherwise.
+
+    Args:
+      batch: batch.
+    Returns:
+      Feature embedding using the features as described before.
+    """"""
+    c = self.config
+    gc = self.global_config
+    rel_feats = []
+    pos = batch['residue_index']
+    asym_id = batch['asym_id']
+    asym_id_same = jnp.equal(asym_id[:, None], asym_id[None, :])
+    offset = pos[:, None] - pos[None, :]
+    dtype = jnp.bfloat16 if gc.bfloat16 else jnp.float32
+
+    clipped_offset = jnp.clip(
+        offset + c.max_relative_idx, a_min=0, a_max=2 * c.max_relative_idx)
+
+    if c.use_chain_relative:
+
+      final_offset = jnp.where(asym_id_same, clipped_offset,
+                               (2 * c.max_relative_idx + 1) *
+                               jnp.ones_like(clipped_offset))
+
+      rel_pos = jax.nn.one_hot(final_offset, 2 * c.max_relative_idx + 2)
+
+      rel_feats.append(rel_pos)
+
+      entity_id = batch['entity_id']
+      entity_id_same = jnp.equal(entity_id[:, None], entity_id[None, :])
+      rel_feats.append(entity_id_same.astype(rel_pos.dtype)[..., None])
+
+      sym_id = batch['sym_id']
+      rel_sym_id = sym_id[:, None] - sym_id[None, :]
+
+      max_rel_chain = c.max_relative_chain
+
+      clipped_rel_chain = jnp.clip(
+          rel_sym_id + max_rel_chain, a_min=0, a_max=2 * max_rel_chain)
+
+      final_rel_chain = jnp.where(entity_id_same, clipped_rel_chain,
+                                  (2 * max_rel_chain + 1) *
+                                  jnp.ones_like(clipped_rel_chain))
+      rel_chain = jax.nn.one_hot(final_rel_chain, 2 * c.max_relative_chain + 2)
+
+      rel_feats.append(rel_chain)
+
+    else:
+      rel_pos = jax.nn.one_hot(clipped_offset, 2 * c.max_relative_idx + 1)
+      rel_feats.append(rel_pos)
+
+    rel_feat = jnp.concatenate(rel_feats, axis=-1)
+
+    rel_feat = rel_feat.astype(dtype)
+    return common_modules.Linear(
+        c.pair_channel,
+        name='position_activations')(
+            rel_feat)
+
+  def __call__(self, batch, is_training, safe_key=None):
+
+    c = self.config
+    gc = self.global_config
+
+    batch = dict(batch)
+    dtype = jnp.bfloat16 if gc.bfloat16 else jnp.float32
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    output = {}
+
+    batch['msa_profile'] = make_msa_profile(batch)
+
+    with utils.bfloat16_context():
+      target_feat = jax.nn.one_hot(batch['aatype'], 21).astype(dtype)
+
+      preprocess_1d = common_modules.Linear(
+          c.msa_channel, name='preprocess_1d')(
+              target_feat)
+
+      safe_key, sample_key, mask_key = safe_key.split(3)
+      batch = sample_msa(sample_key, batch, c.num_msa)
+      batch = make_masked_msa(batch, mask_key, c.masked_msa)
+
+      (batch['cluster_profile'],
+       batch['cluster_deletion_mean']) = nearest_neighbor_clusters(batch)
+
+      msa_feat = create_msa_feat(batch).astype(dtype)
+
+      preprocess_msa = common_modules.Linear(
+          c.msa_channel, name='preprocess_msa')(
+              msa_feat)
+      msa_activations = jnp.expand_dims(preprocess_1d, axis=0) + preprocess_msa
+
+      left_single = common_modules.Linear(
+          c.pair_channel, name='left_single')(
+              target_feat)
+      right_single = common_modules.Linear(
+          c.pair_channel, name='right_single')(
+              target_feat)
+      pair_activations = left_single[:, None] + right_single[None]
+      mask_2d = batch['seq_mask'][:, None] * batch['seq_mask'][None, :]
+      mask_2d = mask_2d.astype(dtype)
+
+      if c.recycle_pos:
+        prev_pseudo_beta = modules.pseudo_beta_fn(
+            batch['aatype'], batch['prev_pos'], None)
+
+        dgram = modules.dgram_from_positions(
+            prev_pseudo_beta, **self.config.prev_pos)
+        dgram = dgram.astype(dtype)
+        pair_activations += common_modules.Linear(
+            c.pair_channel, name='prev_pos_linear')(
+                dgram)
+      if c.recycle_features:
+        prev_msa_first_row = common_modules.LayerNorm(
+            axis=[-1],
+            create_scale=True,
+            create_offset=True,
+            name='prev_msa_first_row_norm')(
+                batch['prev_msa_first_row']).astype(dtype)
+        msa_activations = msa_activations.at[0].add(prev_msa_first_row)
+
+        pair_activations += common_modules.LayerNorm(
+            axis=[-1],
+            create_scale=True,
+            create_offset=True,
+            name='prev_pair_norm')(
+                batch['prev_pair']).astype(dtype)
+
+      if c.max_relative_idx:
+        pair_activations += self._relative_encoding(batch)
+
+      if c.template.enabled:
+        template_module = TemplateEmbedding(c.template, gc)
+        template_batch = {
+            'template_aatype': batch['template_aatype'],
+            'template_all_atom_positions': batch['template_all_atom_positions'],
+            'template_all_atom_mask': batch['template_all_atom_mask']
+        }
+        # Construct a mask such that only intra-chain template features are
+        # computed, since all templates are for each chain individually.
+        multichain_mask = batch['asym_id'][:, None] == batch['asym_id'][None, :]
+        safe_key, safe_subkey = safe_key.split()
+        template_act = template_module(
+            query_embedding=pair_activations,
+            template_batch=template_batch,
+            padding_mask_2d=mask_2d,
+            multichain_mask_2d=multichain_mask,
+            is_training=is_training,
+            safe_key=safe_subkey)
+        pair_activations += template_act
+
+      # Extra MSA stack.
+      (extra_msa_feat,
+       extra_msa_mask) = create_extra_msa_feature(batch, c.num_extra_msa)
+      extra_msa_activations = common_modules.Linear(
+          c.extra_msa_channel,
+          name='extra_msa_activations')(
+              extra_msa_feat).astype(dtype)
+      extra_msa_mask = extra_msa_mask.astype(dtype)
+
+      extra_evoformer_input = {
+          'msa': extra_msa_activations,
+          'pair': pair_activations,
+      }
+      extra_masks = {'msa': extra_msa_mask, 'pair': mask_2d}
+
+      extra_evoformer_iteration = modules.EvoformerIteration(
+          c.evoformer, gc, is_extra_msa=True, name='extra_msa_stack')
+
+      def extra_evoformer_fn(x):
+        act, safe_key = x
+        safe_key, safe_subkey = safe_key.split()
+        extra_evoformer_output = extra_evoformer_iteration(
+            activations=act,
+            masks=extra_masks,
+            is_training=is_training,
+            safe_key=safe_subkey)
+        return (extra_evoformer_output, safe_key)
+
+      if gc.use_remat:
+        extra_evoformer_fn = hk.remat(extra_evoformer_fn)
+
+      safe_key, safe_subkey = safe_key.split()
+      extra_evoformer_stack = layer_stack.layer_stack(
+          c.extra_msa_stack_num_block)(
+              extra_evoformer_fn)
+      extra_evoformer_output, safe_key = extra_evoformer_stack(
+          (extra_evoformer_input, safe_subkey))
+
+      pair_activations = extra_evoformer_output['pair']
+
+      # Get the size of the MSA before potentially adding templates, so we
+      # can crop out the templates later.
+      num_msa_sequences = msa_activations.shape[0]
+      evoformer_input = {
+          'msa': msa_activations,
+          'pair': pair_activations,
+      }
+      evoformer_masks = {
+          'msa': batch['msa_mask'].astype(dtype),
+          'pair': mask_2d
+      }
+      if c.template.enabled:
+        template_features, template_masks = (
+            template_embedding_1d(
+                batch=batch, num_channel=c.msa_channel, global_config=gc))
+
+        evoformer_input['msa'] = jnp.concatenate(
+            [evoformer_input['msa'], template_features], axis=0)
+        evoformer_masks['msa'] = jnp.concatenate(
+            [evoformer_masks['msa'], template_masks], axis=0)
+      evoformer_iteration = modules.EvoformerIteration(
+          c.evoformer, gc, is_extra_msa=False, name='evoformer_iteration')
+
+      def evoformer_fn(x):
+        act, safe_key = x
+        safe_key, safe_subkey = safe_key.split()
+        evoformer_output = evoformer_iteration(
+            activations=act,
+            masks=evoformer_masks,
+            is_training=is_training,
+            safe_key=safe_subkey)
+        return (evoformer_output, safe_key)
+
+      if gc.use_remat:
+        evoformer_fn = hk.remat(evoformer_fn)
+
+      safe_key, safe_subkey = safe_key.split()
+      evoformer_stack = layer_stack.layer_stack(c.evoformer_num_block)(
+          evoformer_fn)
+
+      def run_evoformer(evoformer_input):
+        evoformer_output, _ = evoformer_stack((evoformer_input, safe_subkey))
+        return evoformer_output
+
+      evoformer_output = run_evoformer(evoformer_input)
+
+      msa_activations = evoformer_output['msa']
+      pair_activations = evoformer_output['pair']
+
+      single_activations = common_modules.Linear(
+          c.seq_channel, name='single_activations')(
+              msa_activations[0])
+
+    output.update({
+        'single':
+            single_activations,
+        'pair':
+            pair_activations,
+        # Crop away template rows such that they are not used in MaskedMsaHead.
+        'msa':
+            msa_activations[:num_msa_sequences, :, :],
+        'msa_first_row':
+            msa_activations[0],
+    })
+
+    # Convert back to float32 if we're not saving memory.
+    if not gc.bfloat16_output:
+      for k, v in output.items():
+        if v.dtype == jnp.bfloat16:
+          output[k] = v.astype(jnp.float32)
+
+    return output
+
+
+class TemplateEmbedding(hk.Module):
+  """"""Embed a set of templates.""""""
+
+  def __init__(self, config, global_config, name='template_embedding'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, query_embedding, template_batch, padding_mask_2d,
+               multichain_mask_2d, is_training,
+               safe_key=None):
+    """"""Generate an embedding for a set of templates.
+
+    Args:
+      query_embedding: [num_res, num_res, num_channel] a query tensor that will
+        be used to attend over the templates to remove the num_templates
+        dimension.
+      template_batch: A dictionary containing:
+        `template_aatype`: [num_templates, num_res] aatype for each template.
+        `template_all_atom_positions`: [num_templates, num_res, 37, 3] atom
+          positions for all templates.
+        `template_all_atom_mask`: [num_templates, num_res, 37] mask for each
+          template.
+      padding_mask_2d: [num_res, num_res] Pair mask for attention operations.
+      multichain_mask_2d: [num_res, num_res] Mask indicating which residue pairs
+        are intra-chain, used to mask out residue distance based features
+        between chains.
+      is_training: bool indicating where we are running in training mode.
+      safe_key: random key generator.
+
+    Returns:
+      An embedding of size [num_res, num_res, num_channels]
+    """"""
+    c = self.config
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    num_templates = template_batch['template_aatype'].shape[0]
+    num_res, _, query_num_channels = query_embedding.shape
+
+    # Embed each template separately.
+    template_embedder = SingleTemplateEmbedding(self.config, self.global_config)
+    def partial_template_embedder(template_aatype,
+                                  template_all_atom_positions,
+                                  template_all_atom_mask,
+                                  unsafe_key):
+      safe_key = prng.SafeKey(unsafe_key)
+      return template_embedder(query_embedding,
+                               template_aatype,
+                               template_all_atom_positions,
+                               template_all_atom_mask,
+                               padding_mask_2d,
+                               multichain_mask_2d,
+                               is_training,
+                               safe_key)
+
+    safe_key, unsafe_key = safe_key.split()
+    unsafe_keys = jax.random.split(unsafe_key._key, num_templates)
+
+    def scan_fn(carry, x):
+      return carry + partial_template_embedder(*x), None
+
+    scan_init = jnp.zeros((num_res, num_res, c.num_channels),
+                          dtype=query_embedding.dtype)
+    summed_template_embeddings, _ = hk.scan(
+        scan_fn, scan_init,
+        (template_batch['template_aatype'],
+         template_batch['template_all_atom_positions'],
+         template_batch['template_all_atom_mask'], unsafe_keys))
+
+    embedding = summed_template_embeddings / num_templates
+    embedding = jax.nn.relu(embedding)
+    embedding = common_modules.Linear(
+        query_num_channels,
+        initializer='relu',
+        name='output_linear')(embedding)
+
+    return embedding
+
+
+class SingleTemplateEmbedding(hk.Module):
+  """"""Embed a single template.""""""
+
+  def __init__(self, config, global_config, name='single_template_embedding'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, query_embedding, template_aatype,
+               template_all_atom_positions, template_all_atom_mask,
+               padding_mask_2d, multichain_mask_2d, is_training,
+               safe_key):
+    """"""Build the single template embedding graph.
+
+    Args:
+      query_embedding: (num_res, num_res, num_channels) - embedding of the
+        query sequence/msa.
+      template_aatype: [num_res] aatype for each template.
+      template_all_atom_positions: [num_res, 37, 3] atom positions for all
+        templates.
+      template_all_atom_mask: [num_res, 37] mask for each template.
+      padding_mask_2d: Padding mask (Note: this doesn't care if a template
+        exists, unlike the template_pseudo_beta_mask).
+      multichain_mask_2d: A mask indicating intra-chain residue pairs, used
+        to mask out between chain distances/features when templates are for
+        single chains.
+      is_training: Are we in training mode.
+      safe_key: Random key generator.
+
+    Returns:
+      A template embedding (num_res, num_res, num_channels).
+    """"""
+    gc = self.global_config
+    c = self.config
+    assert padding_mask_2d.dtype == query_embedding.dtype
+    dtype = query_embedding.dtype
+    num_channels = self.config.num_channels
+
+    def construct_input(query_embedding, template_aatype,
+                        template_all_atom_positions, template_all_atom_mask,
+                        multichain_mask_2d):
+
+      # Compute distogram feature for the template.
+      template_positions, pseudo_beta_mask = modules.pseudo_beta_fn(
+          template_aatype, template_all_atom_positions, template_all_atom_mask)
+      pseudo_beta_mask_2d = (pseudo_beta_mask[:, None] *
+                             pseudo_beta_mask[None, :])
+      pseudo_beta_mask_2d *= multichain_mask_2d
+      template_dgram = modules.dgram_from_positions(
+          template_positions, **self.config.dgram_features)
+      template_dgram *= pseudo_beta_mask_2d[..., None]
+      template_dgram = template_dgram.astype(dtype)
+      pseudo_beta_mask_2d = pseudo_beta_mask_2d.astype(dtype)
+      to_concat = [(template_dgram, 1), (pseudo_beta_mask_2d, 0)]
+
+      aatype = jax.nn.one_hot(template_aatype, 22, axis=-1, dtype=dtype)
+      to_concat.append((aatype[None, :, :], 1))
+      to_concat.append((aatype[:, None, :], 1))
+
+      # Compute a feature representing the normalized vector between each
+      # backbone affine - i.e. in each residues local frame, what direction are
+      # each of the other residues.
+      raw_atom_pos = template_all_atom_positions
+      if gc.bfloat16:
+        # Vec3Arrays are required to be float32
+        raw_atom_pos = raw_atom_pos.astype(jnp.float32)
+
+      atom_pos = geometry.Vec3Array.from_array(raw_atom_pos)
+      rigid, backbone_mask = folding_multimer.make_backbone_affine(
+          atom_pos,
+          template_all_atom_mask,
+          template_aatype)
+      points = rigid.translation
+      rigid_vec = rigid[:, None].inverse().apply_to_point(points)
+      unit_vector = rigid_vec.normalized()
+      unit_vector = [unit_vector.x, unit_vector.y, unit_vector.z]
+
+      if gc.bfloat16:
+        unit_vector = [x.astype(jnp.bfloat16) for x in unit_vector]
+        backbone_mask = backbone_mask.astype(jnp.bfloat16)
+
+      backbone_mask_2d = backbone_mask[:, None] * backbone_mask[None, :]
+      backbone_mask_2d *= multichain_mask_2d
+      unit_vector = [x*backbone_mask_2d for x in unit_vector]
+
+      # Note that the backbone_mask takes into account C, CA and N (unlike
+      # pseudo beta mask which just needs CB) so we add both masks as features.
+      to_concat.extend([(x, 0) for x in unit_vector])
+      to_concat.append((backbone_mask_2d, 0))
+
+      query_embedding = common_modules.LayerNorm(
+          axis=[-1],
+          create_scale=True,
+          create_offset=True,
+          name='query_embedding_norm')(
+              query_embedding)
+      # Allow the template embedder to see the query embedding.  Note this
+      # contains the position relative feature, so this is how the network knows
+      # which residues are next to each other.
+      to_concat.append((query_embedding, 1))
+
+      act = 0
+
+      for i, (x, n_input_dims) in enumerate(to_concat):
+
+        act += common_modules.Linear(
+            num_channels,
+            num_input_dims=n_input_dims,
+            initializer='relu',
+            name=f'template_pair_embedding_{i}')(x)
+      return act
+
+    act = construct_input(query_embedding, template_aatype,
+                          template_all_atom_positions, template_all_atom_mask,
+                          multichain_mask_2d)
+
+    template_iteration = TemplateEmbeddingIteration(
+        c.template_pair_stack, gc, name='template_embedding_iteration')
+
+    def template_iteration_fn(x):
+      act, safe_key = x
+
+      safe_key, safe_subkey = safe_key.split()
+      act = template_iteration(
+          act=act,
+          pair_mask=padding_mask_2d,
+          is_training=is_training,
+          safe_key=safe_subkey)
+      return (act, safe_key)
+
+    if gc.use_remat:
+      template_iteration_fn = hk.remat(template_iteration_fn)
+
+    safe_key, safe_subkey = safe_key.split()
+    template_stack = layer_stack.layer_stack(
+        c.template_pair_stack.num_block)(
+            template_iteration_fn)
+    act, safe_key = template_stack((act, safe_subkey))
+
+    act = common_modules.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='output_layer_norm')(
+            act)
+
+    return act
+
+
+class TemplateEmbeddingIteration(hk.Module):
+  """"""Single Iteration of Template Embedding.""""""
+
+  def __init__(self, config, global_config,
+               name='template_embedding_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, act, pair_mask, is_training=True,
+               safe_key=None):
+    """"""Build a single iteration of the template embedder.
+
+    Args:
+      act: [num_res, num_res, num_channel] Input pairwise activations.
+      pair_mask: [num_res, num_res] padding mask.
+      is_training: Whether to run in training mode.
+      safe_key: Safe pseudo-random generator key.
+
+    Returns:
+      [num_res, num_res, num_channel] tensor of activations.
+    """"""
+    c = self.config
+    gc = self.global_config
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    dropout_wrapper_fn = functools.partial(
+        modules.dropout_wrapper,
+        is_training=is_training,
+        global_config=gc)
+
+    safe_key, *sub_keys = safe_key.split(20)
+    sub_keys = iter(sub_keys)
+
+    act = dropout_wrapper_fn(
+        modules.TriangleMultiplication(c.triangle_multiplication_outgoing, gc,
+                                       name='triangle_multiplication_outgoing'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    act = dropout_wrapper_fn(
+        modules.TriangleMultiplication(c.triangle_multiplication_incoming, gc,
+                                       name='triangle_multiplication_incoming'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+    act = dropout_wrapper_fn(
+        modules.TriangleAttention(c.triangle_attention_starting_node, gc,
+                                  name='triangle_attention_starting_node'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+    act = dropout_wrapper_fn(
+        modules.TriangleAttention(c.triangle_attention_ending_node, gc,
+                                  name='triangle_attention_ending_node'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+    act = dropout_wrapper_fn(
+        modules.Transition(c.pair_transition, gc,
+                           name='pair_transition'),
+        act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    return act
+
+
+def template_embedding_1d(batch, num_channel, global_config):
+  """"""Embed templates into an (num_res, num_templates, num_channels) embedding.
+
+  Args:
+    batch: A batch containing:
+      template_aatype, (num_templates, num_res) aatype for the templates.
+      template_all_atom_positions, (num_templates, num_residues, 37, 3) atom
+        positions for the templates.
+      template_all_atom_mask, (num_templates, num_residues, 37) atom mask for
+        each template.
+    num_channel: The number of channels in the output.
+    global_config: The global_config.
+
+  Returns:
+    An embedding of shape (num_templates, num_res, num_channels) and a mask of
+    shape (num_templates, num_res).
+  """"""
+
+  # Embed the templates aatypes.
+  aatype_one_hot = jax.nn.one_hot(batch['template_aatype'], 22, axis=-1)
+
+  num_templates = batch['template_aatype'].shape[0]
+  all_chi_angles = []
+  all_chi_masks = []
+  for i in range(num_templates):
+    atom_pos = geometry.Vec3Array.from_array(
+        batch['template_all_atom_positions'][i, :, :, :])
+    template_chi_angles, template_chi_mask = all_atom_multimer.compute_chi_angles(
+        atom_pos,
+        batch['template_all_atom_mask'][i, :, :],
+        batch['template_aatype'][i, :])
+    all_chi_angles.append(template_chi_angles)
+    all_chi_masks.append(template_chi_mask)
+  chi_angles = jnp.stack(all_chi_angles, axis=0)
+  chi_mask = jnp.stack(all_chi_masks, axis=0)
+
+  template_features = jnp.concatenate([
+      aatype_one_hot,
+      jnp.sin(chi_angles) * chi_mask,
+      jnp.cos(chi_angles) * chi_mask,
+      chi_mask], axis=-1)
+
+  template_mask = chi_mask[:, :, 0]
+
+  if global_config.bfloat16:
+    template_features = template_features.astype(jnp.bfloat16)
+    template_mask = template_mask.astype(jnp.bfloat16)
+
+  template_activations = common_modules.Linear(
+      num_channel,
+      initializer='relu',
+      name='template_single_embedding')(
+          template_features)
+  template_activations = jax.nn.relu(template_activations)
+  template_activations = common_modules.Linear(
+      num_channel,
+      initializer='relu',
+      name='template_projection')(
+          template_activations)
+  return template_activations, template_mask
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/quat_affine_test.py",".py","5038","151","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for quat_affine.""""""
+
+from absl import logging
+from absl.testing import absltest
+from alphafold.model import quat_affine
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+VERBOSE = False
+np.set_printoptions(precision=3, suppress=True)
+
+r2t = quat_affine.rot_list_to_tensor
+v2t = quat_affine.vec_list_to_tensor
+
+q2r = lambda q: r2t(quat_affine.quat_to_rot(q))
+
+
+class QuatAffineTest(absltest.TestCase):
+
+  def _assert_check(self, to_check, tol=1e-5):
+    for k, (correct, generated) in to_check.items():
+      if VERBOSE:
+        logging.info(k)
+        logging.info('Correct %s', correct)
+        logging.info('Predicted %s', generated)
+      self.assertLess(np.max(np.abs(correct - generated)), tol)
+
+  def test_conversion(self):
+    quat = jnp.array([-2., 5., -1., 4.])
+
+    rotation = jnp.array([
+        [0.26087, 0.130435, 0.956522],
+        [-0.565217, -0.782609, 0.26087],
+        [0.782609, -0.608696, -0.130435]])
+
+    translation = jnp.array([1., -3., 4.])
+    point = jnp.array([0.7, 3.2, -2.9])
+
+    a = quat_affine.QuatAffine(quat, translation, unstack_inputs=True)
+    true_new_point = jnp.matmul(rotation, point[:, None])[:, 0] + translation
+
+    self._assert_check({
+        'rot': (rotation, r2t(a.rotation)),
+        'trans': (translation, v2t(a.translation)),
+        'point': (true_new_point,
+                  v2t(a.apply_to_point(jnp.moveaxis(point, -1, 0)))),
+        # Because of the double cover, we must be careful and compare rotations
+        'quat': (q2r(a.quaternion),
+                 q2r(quat_affine.rot_to_quat(a.rotation))),
+
+    })
+
+  def test_double_cover(self):
+    """"""Test that -q is the same rotation as q.""""""
+    rng = jax.random.PRNGKey(42)
+    keys = jax.random.split(rng)
+    q = jax.random.normal(keys[0], (2, 4))
+    trans = jax.random.normal(keys[1], (2, 3))
+    a1 = quat_affine.QuatAffine(q, trans, unstack_inputs=True)
+    a2 = quat_affine.QuatAffine(-q, trans, unstack_inputs=True)
+
+    self._assert_check({
+        'rot': (r2t(a1.rotation),
+                r2t(a2.rotation)),
+        'trans': (v2t(a1.translation),
+                  v2t(a2.translation)),
+    })
+
+  def test_homomorphism(self):
+    rng = jax.random.PRNGKey(42)
+    keys = jax.random.split(rng, 4)
+    vec_q1 = jax.random.normal(keys[0], (2, 3))
+
+    q1 = jnp.concatenate([
+        jnp.ones_like(vec_q1)[:, :1],
+        vec_q1], axis=-1)
+
+    q2 = jax.random.normal(keys[1], (2, 4))
+    t1 = jax.random.normal(keys[2], (2, 3))
+    t2 = jax.random.normal(keys[3], (2, 3))
+
+    a1 = quat_affine.QuatAffine(q1, t1, unstack_inputs=True)
+    a2 = quat_affine.QuatAffine(q2, t2, unstack_inputs=True)
+    a21 = a2.pre_compose(jnp.concatenate([vec_q1, t1], axis=-1))
+
+    rng, key = jax.random.split(rng)
+    x = jax.random.normal(key, (2, 3))
+    new_x = a21.apply_to_point(jnp.moveaxis(x, -1, 0))
+    new_x_apply2 = a2.apply_to_point(a1.apply_to_point(jnp.moveaxis(x, -1, 0)))
+
+    self._assert_check({
+        'quat': (q2r(quat_affine.quat_multiply(a2.quaternion, a1.quaternion)),
+                 q2r(a21.quaternion)),
+        'rot': (jnp.matmul(r2t(a2.rotation), r2t(a1.rotation)),
+                r2t(a21.rotation)),
+        'point': (v2t(new_x_apply2),
+                  v2t(new_x)),
+        'inverse': (x, v2t(a21.invert_point(new_x))),
+    })
+
+  def test_batching(self):
+    """"""Test that affine applies batchwise.""""""
+    rng = jax.random.PRNGKey(42)
+    keys = jax.random.split(rng, 3)
+    q = jax.random.uniform(keys[0], (5, 2, 4))
+    t = jax.random.uniform(keys[1], (2, 3))
+    x = jax.random.uniform(keys[2], (5, 1, 3))
+
+    a = quat_affine.QuatAffine(q, t, unstack_inputs=True)
+    y = v2t(a.apply_to_point(jnp.moveaxis(x, -1, 0)))
+
+    y_list = []
+    for i in range(5):
+      for j in range(2):
+        a_local = quat_affine.QuatAffine(q[i, j], t[j],
+                                         unstack_inputs=True)
+        y_local = v2t(a_local.apply_to_point(jnp.moveaxis(x[i, 0], -1, 0)))
+        y_list.append(y_local)
+    y_combine = jnp.reshape(jnp.stack(y_list, axis=0), (5, 2, 3))
+
+    self._assert_check({
+        'batch': (y_combine, y),
+        'quat': (q2r(a.quaternion),
+                 q2r(quat_affine.rot_to_quat(a.rotation))),
+    })
+
+  def assertAllClose(self, a, b, rtol=1e-06, atol=1e-06):
+    self.assertTrue(np.allclose(a, b, rtol=rtol, atol=atol))
+
+  def assertAllEqual(self, a, b):
+    self.assertTrue(np.all(np.array(a) == np.array(b)))
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/quat_affine.py",".py","17388","460","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Quaternion geometry modules.
+
+This introduces a representation of coordinate frames that is based around a
+‘QuatAffine’ object. This object describes an array of coordinate frames.
+It consists of vectors corresponding to the
+origin of the frames as well as orientations which are stored in two
+ways, as unit quaternions as well as a rotation matrices.
+The rotation matrices are derived from the unit quaternions and the two are kept
+in sync.
+For an explanation of the relation between unit quaternions and rotations see
+https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation
+
+This representation is used in the model for the backbone frames.
+
+One important thing to note here, is that while we update both representations
+the jit compiler is going to ensure that only the parts that are
+actually used are executed.
+""""""
+
+
+import functools
+from typing import Tuple
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+# pylint: disable=bad-whitespace
+QUAT_TO_ROT = np.zeros((4, 4, 3, 3), dtype=np.float32)
+
+QUAT_TO_ROT[0, 0] = [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1]]  # rr
+QUAT_TO_ROT[1, 1] = [[ 1, 0, 0], [ 0,-1, 0], [ 0, 0,-1]]  # ii
+QUAT_TO_ROT[2, 2] = [[-1, 0, 0], [ 0, 1, 0], [ 0, 0,-1]]  # jj
+QUAT_TO_ROT[3, 3] = [[-1, 0, 0], [ 0,-1, 0], [ 0, 0, 1]]  # kk
+
+QUAT_TO_ROT[1, 2] = [[ 0, 2, 0], [ 2, 0, 0], [ 0, 0, 0]]  # ij
+QUAT_TO_ROT[1, 3] = [[ 0, 0, 2], [ 0, 0, 0], [ 2, 0, 0]]  # ik
+QUAT_TO_ROT[2, 3] = [[ 0, 0, 0], [ 0, 0, 2], [ 0, 2, 0]]  # jk
+
+QUAT_TO_ROT[0, 1] = [[ 0, 0, 0], [ 0, 0,-2], [ 0, 2, 0]]  # ir
+QUAT_TO_ROT[0, 2] = [[ 0, 0, 2], [ 0, 0, 0], [-2, 0, 0]]  # jr
+QUAT_TO_ROT[0, 3] = [[ 0,-2, 0], [ 2, 0, 0], [ 0, 0, 0]]  # kr
+
+QUAT_MULTIPLY = np.zeros((4, 4, 4), dtype=np.float32)
+QUAT_MULTIPLY[:, :, 0] = [[ 1, 0, 0, 0],
+                          [ 0,-1, 0, 0],
+                          [ 0, 0,-1, 0],
+                          [ 0, 0, 0,-1]]
+
+QUAT_MULTIPLY[:, :, 1] = [[ 0, 1, 0, 0],
+                          [ 1, 0, 0, 0],
+                          [ 0, 0, 0, 1],
+                          [ 0, 0,-1, 0]]
+
+QUAT_MULTIPLY[:, :, 2] = [[ 0, 0, 1, 0],
+                          [ 0, 0, 0,-1],
+                          [ 1, 0, 0, 0],
+                          [ 0, 1, 0, 0]]
+
+QUAT_MULTIPLY[:, :, 3] = [[ 0, 0, 0, 1],
+                          [ 0, 0, 1, 0],
+                          [ 0,-1, 0, 0],
+                          [ 1, 0, 0, 0]]
+
+QUAT_MULTIPLY_BY_VEC = QUAT_MULTIPLY[:, 1:, :]
+# pylint: enable=bad-whitespace
+
+
+def rot_to_quat(rot, unstack_inputs=False):
+  """"""Convert rotation matrix to quaternion.
+
+  Note that this function calls self_adjoint_eig which is extremely expensive on
+  the GPU. If at all possible, this function should run on the CPU.
+
+  Args:
+     rot: rotation matrix (see below for format).
+     unstack_inputs:  If true, rotation matrix should be shape (..., 3, 3)
+       otherwise the rotation matrix should be a list of lists of tensors.
+
+  Returns:
+    Quaternion as (..., 4) tensor.
+  """"""
+  if unstack_inputs:
+    rot = [jnp.moveaxis(x, -1, 0) for x in jnp.moveaxis(rot, -2, 0)]
+
+  [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]] = rot
+
+  # pylint: disable=bad-whitespace
+  k = [[ xx + yy + zz,      zy - yz,      xz - zx,      yx - xy,],
+       [      zy - yz, xx - yy - zz,      xy + yx,      xz + zx,],
+       [      xz - zx,      xy + yx, yy - xx - zz,      yz + zy,],
+       [      yx - xy,      xz + zx,      yz + zy, zz - xx - yy,]]
+  # pylint: enable=bad-whitespace
+
+  k = (1./3.) * jnp.stack([jnp.stack(x, axis=-1) for x in k],
+                          axis=-2)
+
+  # Get eigenvalues in non-decreasing order and associated.
+  _, qs = jnp.linalg.eigh(k)
+  return qs[..., -1]
+
+
+def rot_list_to_tensor(rot_list):
+  """"""Convert list of lists to rotation tensor.""""""
+  return jnp.stack(
+      [jnp.stack(rot_list[0], axis=-1),
+       jnp.stack(rot_list[1], axis=-1),
+       jnp.stack(rot_list[2], axis=-1)],
+      axis=-2)
+
+
+def vec_list_to_tensor(vec_list):
+  """"""Convert list to vector tensor.""""""
+  return jnp.stack(vec_list, axis=-1)
+
+
+def quat_to_rot(normalized_quat):
+  """"""Convert a normalized quaternion to a rotation matrix.""""""
+  rot_tensor = jnp.sum(
+      np.reshape(QUAT_TO_ROT, (4, 4, 9)) *
+      normalized_quat[..., :, None, None] *
+      normalized_quat[..., None, :, None],
+      axis=(-3, -2))
+  rot = jnp.moveaxis(rot_tensor, -1, 0)  # Unstack.
+  return [[rot[0], rot[1], rot[2]],
+          [rot[3], rot[4], rot[5]],
+          [rot[6], rot[7], rot[8]]]
+
+
+def quat_multiply_by_vec(quat, vec):
+  """"""Multiply a quaternion by a pure-vector quaternion.""""""
+  return jnp.sum(
+      QUAT_MULTIPLY_BY_VEC *
+      quat[..., :, None, None] *
+      vec[..., None, :, None],
+      axis=(-3, -2))
+
+
+def quat_multiply(quat1, quat2):
+  """"""Multiply a quaternion by another quaternion.""""""
+  return jnp.sum(
+      QUAT_MULTIPLY *
+      quat1[..., :, None, None] *
+      quat2[..., None, :, None],
+      axis=(-3, -2))
+
+
+def apply_rot_to_vec(rot, vec, unstack=False):
+  """"""Multiply rotation matrix by a vector.""""""
+  if unstack:
+    x, y, z = [vec[:, i] for i in range(3)]
+  else:
+    x, y, z = vec
+  return [rot[0][0] * x + rot[0][1] * y + rot[0][2] * z,
+          rot[1][0] * x + rot[1][1] * y + rot[1][2] * z,
+          rot[2][0] * x + rot[2][1] * y + rot[2][2] * z]
+
+
+def apply_inverse_rot_to_vec(rot, vec):
+  """"""Multiply the inverse of a rotation matrix by a vector.""""""
+  # Inverse rotation is just transpose
+  return [rot[0][0] * vec[0] + rot[1][0] * vec[1] + rot[2][0] * vec[2],
+          rot[0][1] * vec[0] + rot[1][1] * vec[1] + rot[2][1] * vec[2],
+          rot[0][2] * vec[0] + rot[1][2] * vec[1] + rot[2][2] * vec[2]]
+
+
+class QuatAffine(object):
+  """"""Affine transformation represented by quaternion and vector.""""""
+
+  def __init__(self, quaternion, translation, rotation=None, normalize=True,
+               unstack_inputs=False):
+    """"""Initialize from quaternion and translation.
+
+    Args:
+      quaternion: Rotation represented by a quaternion, to be applied
+        before translation.  Must be a unit quaternion unless normalize==True.
+      translation: Translation represented as a vector.
+      rotation: Same rotation as the quaternion, represented as a (..., 3, 3)
+        tensor.  If None, rotation will be calculated from the quaternion.
+      normalize: If True, l2 normalize the quaternion on input.
+      unstack_inputs: If True, translation is a vector with last component 3
+    """"""
+
+    if quaternion is not None:
+      assert quaternion.shape[-1] == 4
+
+    if unstack_inputs:
+      if rotation is not None:
+        rotation = [jnp.moveaxis(x, -1, 0)   # Unstack.
+                    for x in jnp.moveaxis(rotation, -2, 0)]  # Unstack.
+      translation = jnp.moveaxis(translation, -1, 0)  # Unstack.
+
+    if normalize and quaternion is not None:
+      quaternion = quaternion / jnp.linalg.norm(quaternion, axis=-1,
+                                                keepdims=True)
+
+    if rotation is None:
+      rotation = quat_to_rot(quaternion)
+
+    self.quaternion = quaternion
+    self.rotation = [list(row) for row in rotation]
+    self.translation = list(translation)
+
+    assert all(len(row) == 3 for row in self.rotation)
+    assert len(self.translation) == 3
+
+  def to_tensor(self):
+    return jnp.concatenate(
+        [self.quaternion] +
+        [jnp.expand_dims(x, axis=-1) for x in self.translation],
+        axis=-1)
+
+  def apply_tensor_fn(self, tensor_fn):
+    """"""Return a new QuatAffine with tensor_fn applied (e.g. stop_gradient).""""""
+    return QuatAffine(
+        tensor_fn(self.quaternion),
+        [tensor_fn(x) for x in self.translation],
+        rotation=[[tensor_fn(x) for x in row] for row in self.rotation],
+        normalize=False)
+
+  def apply_rotation_tensor_fn(self, tensor_fn):
+    """"""Return a new QuatAffine with tensor_fn applied to the rotation part.""""""
+    return QuatAffine(
+        tensor_fn(self.quaternion),
+        [x for x in self.translation],
+        rotation=[[tensor_fn(x) for x in row] for row in self.rotation],
+        normalize=False)
+
+  def scale_translation(self, position_scale):
+    """"""Return a new quat affine with a different scale for translation.""""""
+
+    return QuatAffine(
+        self.quaternion,
+        [x * position_scale for x in self.translation],
+        rotation=[[x for x in row] for row in self.rotation],
+        normalize=False)
+
+  @classmethod
+  def from_tensor(cls, tensor, normalize=False):
+    quaternion, tx, ty, tz = jnp.split(tensor, [4, 5, 6], axis=-1)
+    return cls(quaternion,
+               [tx[..., 0], ty[..., 0], tz[..., 0]],
+               normalize=normalize)
+
+  def pre_compose(self, update):
+    """"""Return a new QuatAffine which applies the transformation update first.
+
+    Args:
+      update: Length-6 vector. 3-vector of x, y, and z such that the quaternion
+        update is (1, x, y, z) and zero for the 3-vector is the identity
+        quaternion. 3-vector for translation concatenated.
+
+    Returns:
+      New QuatAffine object.
+    """"""
+    vector_quaternion_update, x, y, z = jnp.split(update, [3, 4, 5], axis=-1)
+    trans_update = [jnp.squeeze(x, axis=-1),
+                    jnp.squeeze(y, axis=-1),
+                    jnp.squeeze(z, axis=-1)]
+
+    new_quaternion = (self.quaternion +
+                      quat_multiply_by_vec(self.quaternion,
+                                           vector_quaternion_update))
+
+    trans_update = apply_rot_to_vec(self.rotation, trans_update)
+    new_translation = [
+        self.translation[0] + trans_update[0],
+        self.translation[1] + trans_update[1],
+        self.translation[2] + trans_update[2]]
+
+    return QuatAffine(new_quaternion, new_translation)
+
+  def apply_to_point(self, point, extra_dims=0):
+    """"""Apply affine to a point.
+
+    Args:
+      point: List of 3 tensors to apply affine.
+      extra_dims:  Number of dimensions at the end of the transformed_point
+        shape that are not present in the rotation and translation.  The most
+        common use is rotation N points at once with extra_dims=1 for use in a
+        network.
+
+    Returns:
+      Transformed point after applying affine.
+    """"""
+    rotation = self.rotation
+    translation = self.translation
+    for _ in range(extra_dims):
+      expand_fn = functools.partial(jnp.expand_dims, axis=-1)
+      rotation = jax.tree_map(expand_fn, rotation)
+      translation = jax.tree_map(expand_fn, translation)
+
+    rot_point = apply_rot_to_vec(rotation, point)
+    return [
+        rot_point[0] + translation[0],
+        rot_point[1] + translation[1],
+        rot_point[2] + translation[2]]
+
+  def invert_point(self, transformed_point, extra_dims=0):
+    """"""Apply inverse of transformation to a point.
+
+    Args:
+      transformed_point: List of 3 tensors to apply affine
+      extra_dims:  Number of dimensions at the end of the transformed_point
+        shape that are not present in the rotation and translation.  The most
+        common use is rotation N points at once with extra_dims=1 for use in a
+        network.
+
+    Returns:
+      Transformed point after applying affine.
+    """"""
+    rotation = self.rotation
+    translation = self.translation
+    for _ in range(extra_dims):
+      expand_fn = functools.partial(jnp.expand_dims, axis=-1)
+      rotation = jax.tree_map(expand_fn, rotation)
+      translation = jax.tree_map(expand_fn, translation)
+
+    rot_point = [
+        transformed_point[0] - translation[0],
+        transformed_point[1] - translation[1],
+        transformed_point[2] - translation[2]]
+
+    return apply_inverse_rot_to_vec(rotation, rot_point)
+
+  def __repr__(self):
+    return 'QuatAffine(%r, %r)' % (self.quaternion, self.translation)
+
+
+def _multiply(a, b):
+  return jnp.stack([
+      jnp.array([a[0][0]*b[0][0] + a[0][1]*b[1][0] + a[0][2]*b[2][0],
+                 a[0][0]*b[0][1] + a[0][1]*b[1][1] + a[0][2]*b[2][1],
+                 a[0][0]*b[0][2] + a[0][1]*b[1][2] + a[0][2]*b[2][2]]),
+
+      jnp.array([a[1][0]*b[0][0] + a[1][1]*b[1][0] + a[1][2]*b[2][0],
+                 a[1][0]*b[0][1] + a[1][1]*b[1][1] + a[1][2]*b[2][1],
+                 a[1][0]*b[0][2] + a[1][1]*b[1][2] + a[1][2]*b[2][2]]),
+
+      jnp.array([a[2][0]*b[0][0] + a[2][1]*b[1][0] + a[2][2]*b[2][0],
+                 a[2][0]*b[0][1] + a[2][1]*b[1][1] + a[2][2]*b[2][1],
+                 a[2][0]*b[0][2] + a[2][1]*b[1][2] + a[2][2]*b[2][2]])])
+
+
+def make_canonical_transform(
+    n_xyz: jnp.ndarray,
+    ca_xyz: jnp.ndarray,
+    c_xyz: jnp.ndarray) -> Tuple[jnp.ndarray, jnp.ndarray]:
+  """"""Returns translation and rotation matrices to canonicalize residue atoms.
+
+  Note that this method does not take care of symmetries. If you provide the
+  atom positions in the non-standard way, the N atom will end up not at
+  [-0.527250, 1.359329, 0.0] but instead at [-0.527250, -1.359329, 0.0]. You
+  need to take care of such cases in your code.
+
+  Args:
+    n_xyz: An array of shape [batch, 3] of nitrogen xyz coordinates.
+    ca_xyz: An array of shape [batch, 3] of carbon alpha xyz coordinates.
+    c_xyz: An array of shape [batch, 3] of carbon xyz coordinates.
+
+  Returns:
+    A tuple (translation, rotation) where:
+      translation is an array of shape [batch, 3] defining the translation.
+      rotation is an array of shape [batch, 3, 3] defining the rotation.
+    After applying the translation and rotation to all atoms in a residue:
+      * All atoms will be shifted so that CA is at the origin,
+      * All atoms will be rotated so that C is at the x-axis,
+      * All atoms will be shifted so that N is in the xy plane.
+  """"""
+  assert len(n_xyz.shape) == 2, n_xyz.shape
+  assert n_xyz.shape[-1] == 3, n_xyz.shape
+  assert n_xyz.shape == ca_xyz.shape == c_xyz.shape, (
+      n_xyz.shape, ca_xyz.shape, c_xyz.shape)
+
+  # Place CA at the origin.
+  translation = -ca_xyz
+  n_xyz = n_xyz + translation
+  c_xyz = c_xyz + translation
+
+  # Place C on the x-axis.
+  c_x, c_y, c_z = [c_xyz[:, i] for i in range(3)]
+  # Rotate by angle c1 in the x-y plane (around the z-axis).
+  sin_c1 = -c_y / jnp.sqrt(1e-20 + c_x**2 + c_y**2)
+  cos_c1 = c_x / jnp.sqrt(1e-20 + c_x**2 + c_y**2)
+  zeros = jnp.zeros_like(sin_c1)
+  ones = jnp.ones_like(sin_c1)
+  # pylint: disable=bad-whitespace
+  c1_rot_matrix = jnp.stack([jnp.array([cos_c1, -sin_c1, zeros]),
+                             jnp.array([sin_c1,  cos_c1, zeros]),
+                             jnp.array([zeros,    zeros,  ones])])
+
+  # Rotate by angle c2 in the x-z plane (around the y-axis).
+  sin_c2 = c_z / jnp.sqrt(1e-20 + c_x**2 + c_y**2 + c_z**2)
+  cos_c2 = jnp.sqrt(c_x**2 + c_y**2) / jnp.sqrt(
+      1e-20 + c_x**2 + c_y**2 + c_z**2)
+  c2_rot_matrix = jnp.stack([jnp.array([cos_c2,  zeros, sin_c2]),
+                             jnp.array([zeros,    ones,  zeros]),
+                             jnp.array([-sin_c2, zeros, cos_c2])])
+
+  c_rot_matrix = _multiply(c2_rot_matrix, c1_rot_matrix)
+  n_xyz = jnp.stack(apply_rot_to_vec(c_rot_matrix, n_xyz, unstack=True)).T
+
+  # Place N in the x-y plane.
+  _, n_y, n_z = [n_xyz[:, i] for i in range(3)]
+  # Rotate by angle alpha in the y-z plane (around the x-axis).
+  sin_n = -n_z / jnp.sqrt(1e-20 + n_y**2 + n_z**2)
+  cos_n = n_y / jnp.sqrt(1e-20 + n_y**2 + n_z**2)
+  n_rot_matrix = jnp.stack([jnp.array([ones,  zeros,  zeros]),
+                            jnp.array([zeros, cos_n, -sin_n]),
+                            jnp.array([zeros, sin_n,  cos_n])])
+  # pylint: enable=bad-whitespace
+
+  return (translation,
+          jnp.transpose(_multiply(n_rot_matrix, c_rot_matrix), [2, 0, 1]))
+
+
+def make_transform_from_reference(
+    n_xyz: jnp.ndarray,
+    ca_xyz: jnp.ndarray,
+    c_xyz: jnp.ndarray) -> Tuple[jnp.ndarray, jnp.ndarray]:
+  """"""Returns rotation and translation matrices to convert from reference.
+
+  Note that this method does not take care of symmetries. If you provide the
+  atom positions in the non-standard way, the N atom will end up not at
+  [-0.527250, 1.359329, 0.0] but instead at [-0.527250, -1.359329, 0.0]. You
+  need to take care of such cases in your code.
+
+  Args:
+    n_xyz: An array of shape [batch, 3] of nitrogen xyz coordinates.
+    ca_xyz: An array of shape [batch, 3] of carbon alpha xyz coordinates.
+    c_xyz: An array of shape [batch, 3] of carbon xyz coordinates.
+
+  Returns:
+    A tuple (rotation, translation) where:
+      rotation is an array of shape [batch, 3, 3] defining the rotation.
+      translation is an array of shape [batch, 3] defining the translation.
+    After applying the translation and rotation to the reference backbone,
+    the coordinates will approximately equal to the input coordinates.
+
+    The order of translation and rotation differs from make_canonical_transform
+    because the rotation from this function should be applied before the
+    translation, unlike make_canonical_transform.
+  """"""
+  translation, rotation = make_canonical_transform(n_xyz, ca_xyz, c_xyz)
+  return np.transpose(rotation, (0, 2, 1)), -translation
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/all_atom_test.py",".py","4706","136","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for all_atom.""""""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+from alphafold.model import all_atom
+from alphafold.model import r3
+import numpy as np
+
+L1_CLAMP_DISTANCE = 10
+
+
+def get_identity_rigid(shape):
+  """"""Returns identity rigid transform.""""""
+
+  ones = np.ones(shape)
+  zeros = np.zeros(shape)
+  rot = r3.Rots(ones, zeros, zeros,
+                zeros, ones, zeros,
+                zeros, zeros, ones)
+  trans = r3.Vecs(zeros, zeros, zeros)
+  return r3.Rigids(rot, trans)
+
+
+def get_global_rigid_transform(rot_angle, translation, bcast_dims):
+  """"""Returns rigid transform that globally rotates/translates by same amount.""""""
+
+  rot_angle = np.asarray(rot_angle)
+  translation = np.asarray(translation)
+  if bcast_dims:
+    for _ in range(bcast_dims):
+      rot_angle = np.expand_dims(rot_angle, 0)
+      translation = np.expand_dims(translation, 0)
+  sin_angle = np.sin(np.deg2rad(rot_angle))
+  cos_angle = np.cos(np.deg2rad(rot_angle))
+  ones = np.ones_like(sin_angle)
+  zeros = np.zeros_like(sin_angle)
+  rot = r3.Rots(ones, zeros, zeros,
+                zeros, cos_angle, -sin_angle,
+                zeros, sin_angle, cos_angle)
+  trans = r3.Vecs(translation[..., 0], translation[..., 1], translation[..., 2])
+  return r3.Rigids(rot, trans)
+
+
+class AllAtomTest(parameterized.TestCase, absltest.TestCase):
+
+  @parameterized.named_parameters(
+      ('identity', 0, [0, 0, 0]),
+      ('rot_90', 90, [0, 0, 0]),
+      ('trans_10', 0, [0, 0, 10]),
+      ('rot_174_trans_1', 174, [1, 1, 1]))
+  def test_frame_aligned_point_error_perfect_on_global_transform(
+      self, rot_angle, translation):
+    """"""Tests global transform between target and preds gives perfect score.""""""
+
+    # pylint: disable=bad-whitespace
+    target_positions = np.array(
+        [[ 21.182,  23.095,  19.731],
+         [ 22.055,  20.919,  17.294],
+         [ 24.599,  20.005,  15.041],
+         [ 25.567,  18.214,  12.166],
+         [ 28.063,  17.082,  10.043],
+         [ 28.779,  15.569,   6.985],
+         [ 30.581,  13.815,   4.612],
+         [ 29.258,  12.193,   2.296]])
+    # pylint: enable=bad-whitespace
+    global_rigid_transform = get_global_rigid_transform(
+        rot_angle, translation, 1)
+
+    target_positions = r3.vecs_from_tensor(target_positions)
+    pred_positions = r3.rigids_mul_vecs(
+        global_rigid_transform, target_positions)
+    positions_mask = np.ones(target_positions.x.shape[0])
+
+    target_frames = get_identity_rigid(10)
+    pred_frames = r3.rigids_mul_rigids(global_rigid_transform, target_frames)
+    frames_mask = np.ones(10)
+
+    fape = all_atom.frame_aligned_point_error(
+        pred_frames, target_frames, frames_mask, pred_positions,
+        target_positions, positions_mask, L1_CLAMP_DISTANCE,
+        L1_CLAMP_DISTANCE, epsilon=0)
+    self.assertAlmostEqual(fape, 0.)
+
+  @parameterized.named_parameters(
+      ('identity',
+       [[0, 0, 0], [5, 0, 0], [10, 0, 0]],
+       [[0, 0, 0], [5, 0, 0], [10, 0, 0]],
+       0.),
+      ('shift_2.5',
+       [[0, 0, 0], [5, 0, 0], [10, 0, 0]],
+       [[2.5, 0, 0], [7.5, 0, 0], [7.5, 0, 0]],
+       0.25),
+      ('shift_5',
+       [[0, 0, 0], [5, 0, 0], [10, 0, 0]],
+       [[5, 0, 0], [10, 0, 0], [15, 0, 0]],
+       0.5),
+      ('shift_10',
+       [[0, 0, 0], [5, 0, 0], [10, 0, 0]],
+       [[10, 0, 0], [15, 0, 0], [0, 0, 0]],
+       1.))
+  def test_frame_aligned_point_error_matches_expected(
+      self, target_positions, pred_positions, expected_alddt):
+    """"""Tests score matches expected.""""""
+
+    target_frames = get_identity_rigid(2)
+    pred_frames = target_frames
+    frames_mask = np.ones(2)
+
+    target_positions = r3.vecs_from_tensor(np.array(target_positions))
+    pred_positions = r3.vecs_from_tensor(np.array(pred_positions))
+    positions_mask = np.ones(target_positions.x.shape[0])
+
+    alddt = all_atom.frame_aligned_point_error(
+        pred_frames, target_frames, frames_mask, pred_positions,
+        target_positions, positions_mask, L1_CLAMP_DISTANCE,
+        L1_CLAMP_DISTANCE, epsilon=0)
+    self.assertAlmostEqual(alddt, expected_alddt)
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/common_modules.py",".py","5957","191","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""A collection of common Haiku modules for use in protein folding.""""""
+import numbers
+from typing import Union, Sequence
+
+import haiku as hk
+import jax.numpy as jnp
+import numpy as np
+
+
+# Constant from scipy.stats.truncnorm.std(a=-2, b=2, loc=0., scale=1.)
+TRUNCATED_NORMAL_STDDEV_FACTOR = np.asarray(.87962566103423978,
+                                            dtype=np.float32)
+
+
+def get_initializer_scale(initializer_name, input_shape):
+  """"""Get Initializer for weights and scale to multiply activations by.""""""
+
+  if initializer_name == 'zeros':
+    w_init = hk.initializers.Constant(0.0)
+  else:
+    # fan-in scaling
+    scale = 1.
+    for channel_dim in input_shape:
+      scale /= channel_dim
+    if initializer_name == 'relu':
+      scale *= 2
+
+    noise_scale = scale
+
+    stddev = np.sqrt(noise_scale)
+    # Adjust stddev for truncation.
+    stddev = stddev / TRUNCATED_NORMAL_STDDEV_FACTOR
+    w_init = hk.initializers.TruncatedNormal(mean=0.0, stddev=stddev)
+
+  return w_init
+
+
+class Linear(hk.Module):
+  """"""Protein folding specific Linear module.
+
+  This differs from the standard Haiku Linear in a few ways:
+    * It supports inputs and outputs of arbitrary rank
+    * Initializers are specified by strings
+  """"""
+
+  def __init__(self,
+               num_output: Union[int, Sequence[int]],
+               initializer: str = 'linear',
+               num_input_dims: int = 1,
+               use_bias: bool = True,
+               bias_init: float = 0.,
+               precision = None,
+               name: str = 'linear'):
+    """"""Constructs Linear Module.
+
+    Args:
+      num_output: Number of output channels. Can be tuple when outputting
+          multiple dimensions.
+      initializer: What initializer to use, should be one of {'linear', 'relu',
+        'zeros'}
+      num_input_dims: Number of dimensions from the end to project.
+      use_bias: Whether to include trainable bias
+      bias_init: Value used to initialize bias.
+      precision: What precision to use for matrix multiplication, defaults
+        to None.
+      name: Name of module, used for name scopes.
+    """"""
+    super().__init__(name=name)
+    if isinstance(num_output, numbers.Integral):
+      self.output_shape = (num_output,)
+    else:
+      self.output_shape = tuple(num_output)
+    self.initializer = initializer
+    self.use_bias = use_bias
+    self.bias_init = bias_init
+    self.num_input_dims = num_input_dims
+    self.num_output_dims = len(self.output_shape)
+    self.precision = precision
+
+  def __call__(self, inputs):
+    """"""Connects Module.
+
+    Args:
+      inputs: Tensor with at least num_input_dims dimensions.
+
+    Returns:
+      output of shape [...] + num_output.
+    """"""
+
+    num_input_dims = self.num_input_dims
+
+    if self.num_input_dims > 0:
+      in_shape = inputs.shape[-self.num_input_dims:]
+    else:
+      in_shape = ()
+
+    weight_init = get_initializer_scale(self.initializer, in_shape)
+
+    in_letters = 'abcde'[:self.num_input_dims]
+    out_letters = 'hijkl'[:self.num_output_dims]
+
+    weight_shape = in_shape + self.output_shape
+    weights = hk.get_parameter('weights', weight_shape, inputs.dtype,
+                               weight_init)
+
+    equation = f'...{in_letters}, {in_letters}{out_letters}->...{out_letters}'
+
+    output = jnp.einsum(equation, inputs, weights, precision=self.precision)
+
+    if self.use_bias:
+      bias = hk.get_parameter('bias', self.output_shape, inputs.dtype,
+                              hk.initializers.Constant(self.bias_init))
+      output += bias
+
+    return output
+
+
+class LayerNorm(hk.LayerNorm):
+  """"""LayerNorm module.
+
+  Equivalent to hk.LayerNorm but with different parameter shapes: they are
+  always vectors rather than possibly higher-rank tensors. This makes it easier
+  to change the layout whilst keep the model weight-compatible.
+  """"""
+
+  def __init__(self,
+               axis,
+               create_scale: bool,
+               create_offset: bool,
+               eps: float = 1e-5,
+               scale_init=None,
+               offset_init=None,
+               use_fast_variance: bool = False,
+               name=None,
+               param_axis=None):
+    super().__init__(
+        axis=axis,
+        create_scale=False,
+        create_offset=False,
+        eps=eps,
+        scale_init=None,
+        offset_init=None,
+        use_fast_variance=use_fast_variance,
+        name=name,
+        param_axis=param_axis)
+    self._temp_create_scale = create_scale
+    self._temp_create_offset = create_offset
+
+  def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+    is_bf16 = (x.dtype == jnp.bfloat16)
+    if is_bf16:
+      x = x.astype(jnp.float32)
+
+    param_axis = self.param_axis[0] if self.param_axis else -1
+    param_shape = (x.shape[param_axis],)
+
+    param_broadcast_shape = [1] * x.ndim
+    param_broadcast_shape[param_axis] = x.shape[param_axis]
+    scale = None
+    offset = None
+    if self._temp_create_scale:
+      scale = hk.get_parameter(
+          'scale', param_shape, x.dtype, init=self.scale_init)
+      scale = scale.reshape(param_broadcast_shape)
+
+    if self._temp_create_offset:
+      offset = hk.get_parameter(
+          'offset', param_shape, x.dtype, init=self.offset_init)
+      offset = offset.reshape(param_broadcast_shape)
+
+    out = super().__call__(x, scale=scale, offset=offset)
+
+    if is_bf16:
+      out = out.astype(jnp.bfloat16)
+
+    return out
+  ","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/data.py",".py","1097","34","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Convenience functions for reading data.""""""
+
+import io
+import os
+from alphafold.model import utils
+import haiku as hk
+import numpy as np
+# Internal import (7716).
+
+
+def get_model_haiku_params(model_name: str, data_dir: str) -> hk.Params:
+  """"""Get the Haiku parameters from a model name.""""""
+
+  path = os.path.join(data_dir, 'params', f'params_{model_name}.npz')
+
+  with open(path, 'rb') as f:
+    params = np.load(io.BytesIO(f.read()), allow_pickle=False)
+
+  return utils.flat_params_to_haiku(params)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/mapping.py",".py","7963","224","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Specialized mapping functions.""""""
+
+import functools
+import inspect
+
+from typing import Any, Callable, Optional, Sequence, Union
+
+import haiku as hk
+import jax
+import jax.numpy as jnp
+
+
+PYTREE = Any
+PYTREE_JAX_ARRAY = Any
+
+partial = functools.partial
+PROXY = object()
+
+
+def _maybe_slice(array, i, slice_size, axis):
+  if axis is PROXY:
+    return array
+  else:
+    return jax.lax.dynamic_slice_in_dim(
+        array, i, slice_size=slice_size, axis=axis)
+
+
+def _maybe_get_size(array, axis):
+  if axis == PROXY:
+    return -1
+  else:
+    return array.shape[axis]
+
+
+def _expand_axes(axes, values, name='sharded_apply'):
+  values_tree_def = jax.tree_util.tree_flatten(values)[1]
+  flat_axes = jax.api_util.flatten_axes(name, values_tree_def, axes)
+  # Replace None's with PROXY
+  flat_axes = [PROXY if x is None else x for x in flat_axes]
+  return jax.tree_util.tree_unflatten(values_tree_def, flat_axes)
+
+
+def sharded_map(
+    fun: Callable[..., PYTREE_JAX_ARRAY],
+    shard_size: Union[int, None] = 1,
+    in_axes: Union[int, PYTREE] = 0,
+    out_axes: Union[int, PYTREE] = 0) -> Callable[..., PYTREE_JAX_ARRAY]:
+  """"""Sharded vmap.
+
+  Maps `fun` over axes, in a way similar to vmap, but does so in shards of
+  `shard_size`. This allows a smooth trade-off between memory usage
+  (as in a plain map) vs higher throughput (as in a vmap).
+
+  Args:
+    fun: Function to apply smap transform to.
+    shard_size: Integer denoting shard size.
+    in_axes: Either integer or pytree describing which axis to map over for each
+      input to `fun`, None denotes broadcasting.
+    out_axes: integer or pytree denoting to what axis in the output the mapped
+      over axis maps.
+
+  Returns:
+    function with smap applied.
+  """"""
+  if 'split_rng' in inspect.signature(hk.vmap).parameters:
+    vmapped_fun = hk.vmap(fun, in_axes, out_axes, split_rng=False)
+  else:
+    # TODO(tomhennigan): Remove this when older versions of Haiku aren't used.
+    vmapped_fun = hk.vmap(fun, in_axes, out_axes)
+  return sharded_apply(vmapped_fun, shard_size, in_axes, out_axes)
+
+
+def sharded_apply(
+    fun: Callable[..., PYTREE_JAX_ARRAY],  # pylint: disable=g-bare-generic
+    shard_size: Union[int, None] = 1,
+    in_axes: Union[int, PYTREE] = 0,
+    out_axes: Union[int, PYTREE] = 0,
+    new_out_axes: bool = False) -> Callable[..., PYTREE_JAX_ARRAY]:
+  """"""Sharded apply.
+
+  Applies `fun` over shards to axes, in a way similar to vmap,
+  but does so in shards of `shard_size`. Shards are stacked after.
+  This allows a smooth trade-off between
+  memory usage (as in a plain map) vs higher throughput (as in a vmap).
+
+  Args:
+    fun: Function to apply smap transform to.
+    shard_size: Integer denoting shard size.
+    in_axes: Either integer or pytree describing which axis to map over for each
+      input to `fun`, None denotes broadcasting.
+    out_axes: integer or pytree denoting to what axis in the output the mapped
+      over axis maps.
+    new_out_axes: whether to stack outputs on new axes. This assumes that the
+      output sizes for each shard (including the possible remainder shard) are
+      the same.
+
+  Returns:
+    function with smap applied.
+  """"""
+  docstr = ('Mapped version of {fun}. Takes similar arguments to {fun} '
+            'but with additional array axes over which {fun} is mapped.')
+  if new_out_axes:
+    raise NotImplementedError('New output axes not yet implemented.')
+
+  # shard size None denotes no sharding
+  if shard_size is None:
+    return fun
+
+  @jax.util.wraps(fun, docstr=docstr)
+  def mapped_fn(*args):
+    # Expand in axes and Determine Loop range
+    in_axes_ = _expand_axes(in_axes, args)
+
+    in_sizes = jax.tree_map(_maybe_get_size, args, in_axes_)
+    flat_sizes = jax.tree_util.tree_flatten(in_sizes)[0]
+    in_size = max(flat_sizes)
+    assert all(i in {in_size, -1} for i in flat_sizes)
+
+    num_extra_shards = (in_size - 1) // shard_size
+
+    # Fix Up if necessary
+    last_shard_size = in_size % shard_size
+    last_shard_size = shard_size if last_shard_size == 0 else last_shard_size
+
+    def apply_fun_to_slice(slice_start, slice_size):
+      input_slice = jax.tree_map(
+          lambda array, axis: _maybe_slice(array, slice_start, slice_size, axis
+                                          ), args, in_axes_)
+      return fun(*input_slice)
+
+    remainder_shape_dtype = hk.eval_shape(
+        partial(apply_fun_to_slice, 0, last_shard_size))
+    out_dtypes = jax.tree_map(lambda x: x.dtype, remainder_shape_dtype)
+    out_shapes = jax.tree_map(lambda x: x.shape, remainder_shape_dtype)
+    out_axes_ = _expand_axes(out_axes, remainder_shape_dtype)
+
+    if num_extra_shards > 0:
+      regular_shard_shape_dtype = hk.eval_shape(
+          partial(apply_fun_to_slice, 0, shard_size))
+      shard_shapes = jax.tree_map(lambda x: x.shape, regular_shard_shape_dtype)
+
+      def make_output_shape(axis, shard_shape, remainder_shape):
+        return shard_shape[:axis] + (
+            shard_shape[axis] * num_extra_shards +
+            remainder_shape[axis],) + shard_shape[axis + 1:]
+
+      out_shapes = jax.tree_map(make_output_shape, out_axes_, shard_shapes,
+                                out_shapes)
+
+    # Calls dynamic Update slice with different argument order
+    # This is here since tree_map only works with positional arguments
+    def dynamic_update_slice_in_dim(full_array, update, axis, i):
+      return jax.lax.dynamic_update_slice_in_dim(full_array, update, i, axis)
+
+    def compute_shard(outputs, slice_start, slice_size):
+      slice_out = apply_fun_to_slice(slice_start, slice_size)
+      update_slice = partial(
+          dynamic_update_slice_in_dim, i=slice_start)
+      return jax.tree_map(update_slice, outputs, slice_out, out_axes_)
+
+    def scan_iteration(outputs, i):
+      new_outputs = compute_shard(outputs, i, shard_size)
+      return new_outputs, ()
+
+    slice_starts = jnp.arange(0, in_size - shard_size + 1, shard_size)
+
+    def allocate_buffer(dtype, shape):
+      return jnp.zeros(shape, dtype=dtype)
+
+    outputs = jax.tree_map(allocate_buffer, out_dtypes, out_shapes)
+
+    if slice_starts.shape[0] > 0:
+      outputs, _ = hk.scan(scan_iteration, outputs, slice_starts)
+
+    if last_shard_size != shard_size:
+      remainder_start = in_size - last_shard_size
+      outputs = compute_shard(outputs, remainder_start, last_shard_size)
+
+    return outputs
+
+  return mapped_fn
+
+
+def inference_subbatch(
+    module: Callable[..., PYTREE_JAX_ARRAY],
+    subbatch_size: int,
+    batched_args: Sequence[PYTREE_JAX_ARRAY],
+    nonbatched_args: Sequence[PYTREE_JAX_ARRAY],
+    low_memory: bool = True,
+    input_subbatch_dim: int = 0,
+    output_subbatch_dim: Optional[int] = None) -> PYTREE_JAX_ARRAY:
+  """"""Run through subbatches (like batch apply but with split and concat).""""""
+  assert len(batched_args) > 0  # pylint: disable=g-explicit-length-test
+
+  if not low_memory:
+    args = list(batched_args) + list(nonbatched_args)
+    return module(*args)
+
+  if output_subbatch_dim is None:
+    output_subbatch_dim = input_subbatch_dim
+
+  def run_module(*batched_args):
+    args = list(batched_args) + list(nonbatched_args)
+    return module(*args)
+  sharded_module = sharded_apply(run_module,
+                                 shard_size=subbatch_size,
+                                 in_axes=input_subbatch_dim,
+                                 out_axes=output_subbatch_dim)
+  return sharded_module(*batched_args)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/prng.py",".py","1978","70","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""A collection of utilities surrounding PRNG usage in protein folding.""""""
+
+import haiku as hk
+import jax
+
+
+def safe_dropout(*, tensor, safe_key, rate, is_deterministic, is_training):
+  if is_training and rate != 0.0 and not is_deterministic:
+    return hk.dropout(safe_key.get(), rate, tensor)
+  else:
+    return tensor
+
+
+class SafeKey:
+  """"""Safety wrapper for PRNG keys.""""""
+
+  def __init__(self, key):
+    self._key = key
+    self._used = False
+
+  def _assert_not_used(self):
+    if self._used:
+      raise RuntimeError('Random key has been used previously.')
+
+  def get(self):
+    self._assert_not_used()
+    self._used = True
+    return self._key
+
+  def split(self, num_keys=2):
+    self._assert_not_used()
+    self._used = True
+    new_keys = jax.random.split(self._key, num_keys)
+    return jax.tree_map(SafeKey, tuple(new_keys))
+
+  def duplicate(self, num_keys=2):
+    self._assert_not_used()
+    self._used = True
+    return tuple(SafeKey(self._key) for _ in range(num_keys))
+
+
+def _safe_key_flatten(safe_key):
+  # Flatten transfers ""ownership"" to the tree
+  return (safe_key._key,), safe_key._used  # pylint: disable=protected-access
+
+
+def _safe_key_unflatten(aux_data, children):
+  ret = SafeKey(children[0])
+  ret._used = aux_data  # pylint: disable=protected-access
+  return ret
+
+
+jax.tree_util.register_pytree_node(
+    SafeKey, _safe_key_flatten, _safe_key_unflatten)
+
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/utils.py",".py","4723","154","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""A collection of JAX utility functions for use in protein folding.""""""
+
+import collections
+import contextlib
+import functools
+import numbers
+from typing import Mapping
+
+import haiku as hk
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+
+def bfloat16_creator(next_creator, shape, dtype, init, context):
+  """"""Creates float32 variables when bfloat16 is requested.""""""
+  if context.original_dtype == jnp.bfloat16:
+    dtype = jnp.float32
+  return next_creator(shape, dtype, init)
+
+
+def bfloat16_getter(next_getter, value, context):
+  """"""Casts float32 to bfloat16 when bfloat16 was originally requested.""""""
+  if context.original_dtype == jnp.bfloat16:
+    assert value.dtype == jnp.float32
+    value = value.astype(jnp.bfloat16)
+  return next_getter(value)
+
+
+@contextlib.contextmanager
+def bfloat16_context():
+  with hk.custom_creator(bfloat16_creator), hk.custom_getter(bfloat16_getter):
+    yield
+
+
+def final_init(config):
+  if config.zero_init:
+    return 'zeros'
+  else:
+    return 'linear'
+
+
+def batched_gather(params, indices, axis=0, batch_dims=0):
+  """"""Implements a JAX equivalent of `tf.gather` with `axis` and `batch_dims`.""""""
+  take_fn = lambda p, i: jnp.take(p, i, axis=axis, mode='clip')
+  for _ in range(batch_dims):
+    take_fn = jax.vmap(take_fn)
+  return take_fn(params, indices)
+
+
+def mask_mean(mask, value, axis=None, drop_mask_channel=False, eps=1e-10):
+  """"""Masked mean.""""""
+  if drop_mask_channel:
+    mask = mask[..., 0]
+
+  mask_shape = mask.shape
+  value_shape = value.shape
+
+  assert len(mask_shape) == len(value_shape)
+
+  if isinstance(axis, numbers.Integral):
+    axis = [axis]
+  elif axis is None:
+    axis = list(range(len(mask_shape)))
+  assert isinstance(axis, collections.abc.Iterable), (
+      'axis needs to be either an iterable, integer or ""None""')
+
+  broadcast_factor = 1.
+  for axis_ in axis:
+    value_size = value_shape[axis_]
+    mask_size = mask_shape[axis_]
+    if mask_size == 1:
+      broadcast_factor *= value_size
+    else:
+      assert mask_size == value_size
+
+  return (jnp.sum(mask * value, axis=axis) /
+          (jnp.sum(mask, axis=axis) * broadcast_factor + eps))
+
+
+def flat_params_to_haiku(params: Mapping[str, np.ndarray]) -> hk.Params:
+  """"""Convert a dictionary of NumPy arrays to Haiku parameters.""""""
+  hk_params = {}
+  for path, array in params.items():
+    scope, name = path.split('//')
+    if scope not in hk_params:
+      hk_params[scope] = {}
+    hk_params[scope][name] = jnp.array(array)
+
+  return hk_params
+
+
+def padding_consistent_rng(f):
+  """"""Modify any element-wise random function to be consistent with padding.
+
+  Normally if you take a function like jax.random.normal and generate an array,
+  say of size (10,10), you will get a different set of random numbers to if you
+  add padding and take the first (10,10) sub-array.
+
+  This function makes a random function that is consistent regardless of the
+  amount of padding added.
+
+  Note: The padding-consistent function is likely to be slower to compile and
+  run than the function it is wrapping, but these slowdowns are likely to be
+  negligible in a large network.
+
+  Args:
+    f: Any element-wise function that takes (PRNG key, shape) as the first 2
+      arguments.
+
+  Returns:
+    An equivalent function to f, that is now consistent for different amounts of
+    padding.
+  """"""
+  def grid_keys(key, shape):
+    """"""Generate a grid of rng keys that is consistent with different padding.
+
+    Generate random keys such that the keys will be identical, regardless of
+    how much padding is added to any dimension.
+
+    Args:
+      key: A PRNG key.
+      shape: The shape of the output array of keys that will be generated.
+
+    Returns:
+      An array of shape `shape` consisting of random keys.
+    """"""
+    if not shape:
+      return key
+    new_keys = jax.vmap(functools.partial(jax.random.fold_in, key))(
+        jnp.arange(shape[0]))
+    return jax.vmap(functools.partial(grid_keys, shape=shape[1:]))(new_keys)
+
+  def inner(key, shape, **kwargs):
+    return jnp.vectorize(
+        lambda key: f(key, shape=(), **kwargs),
+        signature='(2)->()')(
+            grid_keys(key, shape))
+  return inner
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/config.py",".py","26814","700","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Model config.""""""
+
+import copy
+from alphafold.model.tf import shape_placeholders
+import ml_collections
+
+NUM_RES = shape_placeholders.NUM_RES
+NUM_MSA_SEQ = shape_placeholders.NUM_MSA_SEQ
+NUM_EXTRA_SEQ = shape_placeholders.NUM_EXTRA_SEQ
+NUM_TEMPLATES = shape_placeholders.NUM_TEMPLATES
+
+
+def model_config(name: str) -> ml_collections.ConfigDict:
+  """"""Get the ConfigDict of a CASP14 model.""""""
+
+  if name not in CONFIG_DIFFS:
+    raise ValueError(f'Invalid model name {name}.')
+  if 'multimer' in name:
+    cfg = copy.deepcopy(CONFIG_MULTIMER)
+  else:
+    cfg = copy.deepcopy(CONFIG)
+  cfg.update_from_flattened_dict(CONFIG_DIFFS[name])
+  return cfg
+
+
+MODEL_PRESETS = {
+    'monomer': (
+        'model_1',
+        'model_2',
+        'model_3',
+        'model_4',
+        'model_5',
+    ),
+    'monomer_ptm': (
+        'model_1_ptm',
+        'model_2_ptm',
+        'model_3_ptm',
+        'model_4_ptm',
+        'model_5_ptm',
+    ),
+    'multimer': (
+        'model_1_multimer_v3',
+        'model_2_multimer_v3',
+        'model_3_multimer_v3',
+        'model_4_multimer_v3',
+        'model_5_multimer_v3',
+    ),
+}
+MODEL_PRESETS['monomer_casp14'] = MODEL_PRESETS['monomer']
+
+
+CONFIG_DIFFS = {
+    'model_1': {
+        # Jumper et al. (2021) Suppl. Table 5, Model 1.1.1
+        'data.common.max_extra_msa': 5120,
+        'data.common.reduce_msa_clusters_by_max_templates': True,
+        'data.common.use_templates': True,
+        'model.embeddings_and_evoformer.template.embed_torsion_angles': True,
+        'model.embeddings_and_evoformer.template.enabled': True
+    },
+    'model_2': {
+        # Jumper et al. (2021) Suppl. Table 5, Model 1.1.2
+        'data.common.reduce_msa_clusters_by_max_templates': True,
+        'data.common.use_templates': True,
+        'model.embeddings_and_evoformer.template.embed_torsion_angles': True,
+        'model.embeddings_and_evoformer.template.enabled': True
+    },
+    'model_3': {
+        # Jumper et al. (2021) Suppl. Table 5, Model 1.2.1
+        'data.common.max_extra_msa': 5120,
+    },
+    'model_4': {
+        # Jumper et al. (2021) Suppl. Table 5, Model 1.2.2
+        'data.common.max_extra_msa': 5120,
+    },
+    'model_5': {
+        # Jumper et al. (2021) Suppl. Table 5, Model 1.2.3
+    },
+
+    # The following models are fine-tuned from the corresponding models above
+    # with an additional predicted_aligned_error head that can produce
+    # predicted TM-score (pTM) and predicted aligned errors.
+    'model_1_ptm': {
+        'data.common.max_extra_msa': 5120,
+        'data.common.reduce_msa_clusters_by_max_templates': True,
+        'data.common.use_templates': True,
+        'model.embeddings_and_evoformer.template.embed_torsion_angles': True,
+        'model.embeddings_and_evoformer.template.enabled': True,
+        'model.heads.predicted_aligned_error.weight': 0.1
+    },
+    'model_2_ptm': {
+        'data.common.reduce_msa_clusters_by_max_templates': True,
+        'data.common.use_templates': True,
+        'model.embeddings_and_evoformer.template.embed_torsion_angles': True,
+        'model.embeddings_and_evoformer.template.enabled': True,
+        'model.heads.predicted_aligned_error.weight': 0.1
+    },
+    'model_3_ptm': {
+        'data.common.max_extra_msa': 5120,
+        'model.heads.predicted_aligned_error.weight': 0.1
+    },
+    'model_4_ptm': {
+        'data.common.max_extra_msa': 5120,
+        'model.heads.predicted_aligned_error.weight': 0.1
+    },
+    'model_5_ptm': {
+        'model.heads.predicted_aligned_error.weight': 0.1
+    },
+    'model_1_multimer_v3': {},
+    'model_2_multimer_v3': {},
+    'model_3_multimer_v3': {},
+    'model_4_multimer_v3': {
+        'model.embeddings_and_evoformer.num_extra_msa': 1152
+    },
+    'model_5_multimer_v3': {
+        'model.embeddings_and_evoformer.num_extra_msa': 1152
+    },
+}
+# Key differences between multimer v1/v2 and v3, mostly due to numerical
+# optimisations in the TriangleMultiplication module.
+common_updates = {
+    'model.embeddings_and_evoformer.num_msa': 252,
+    'model.embeddings_and_evoformer.num_extra_msa': 1152,
+    'model.embeddings_and_evoformer.evoformer.triangle_multiplication_incoming.fuse_projection_weights': False,
+    'model.embeddings_and_evoformer.evoformer.triangle_multiplication_outgoing.fuse_projection_weights': False,
+    'model.embeddings_and_evoformer.template.template_pair_stack.triangle_multiplication_incoming.fuse_projection_weights': False,
+    'model.embeddings_and_evoformer.template.template_pair_stack.triangle_multiplication_outgoing.fuse_projection_weights': False,
+}
+CONFIG_DIFFS.update(
+    {f'model_{i}_multimer': common_updates for i in range(1, 6)})
+CONFIG_DIFFS.update(
+    {f'model_{i}_multimer_v2': common_updates for i in range(1, 6)})
+
+
+CONFIG = ml_collections.ConfigDict({
+    'data': {
+        'common': {
+            'masked_msa': {
+                'profile_prob': 0.1,
+                'same_prob': 0.1,
+                'uniform_prob': 0.1
+            },
+            'max_extra_msa': 1024,
+            'msa_cluster_features': True,
+            'num_recycle': 3,
+            'reduce_msa_clusters_by_max_templates': False,
+            'resample_msa_in_recycling': True,
+            'template_features': [
+                'template_all_atom_positions', 'template_sum_probs',
+                'template_aatype', 'template_all_atom_masks',
+                'template_domain_names'
+            ],
+            'unsupervised_features': [
+                'aatype', 'residue_index', 'sequence', 'msa', 'domain_name',
+                'num_alignments', 'seq_length', 'between_segment_residues',
+                'deletion_matrix'
+            ],
+            'use_templates': False,
+        },
+        'eval': {
+            'feat': {
+                'aatype': [NUM_RES],
+                'all_atom_mask': [NUM_RES, None],
+                'all_atom_positions': [NUM_RES, None, None],
+                'alt_chi_angles': [NUM_RES, None],
+                'atom14_alt_gt_exists': [NUM_RES, None],
+                'atom14_alt_gt_positions': [NUM_RES, None, None],
+                'atom14_atom_exists': [NUM_RES, None],
+                'atom14_atom_is_ambiguous': [NUM_RES, None],
+                'atom14_gt_exists': [NUM_RES, None],
+                'atom14_gt_positions': [NUM_RES, None, None],
+                'atom37_atom_exists': [NUM_RES, None],
+                'backbone_affine_mask': [NUM_RES],
+                'backbone_affine_tensor': [NUM_RES, None],
+                'bert_mask': [NUM_MSA_SEQ, NUM_RES],
+                'chi_angles': [NUM_RES, None],
+                'chi_mask': [NUM_RES, None],
+                'extra_deletion_value': [NUM_EXTRA_SEQ, NUM_RES],
+                'extra_has_deletion': [NUM_EXTRA_SEQ, NUM_RES],
+                'extra_msa': [NUM_EXTRA_SEQ, NUM_RES],
+                'extra_msa_mask': [NUM_EXTRA_SEQ, NUM_RES],
+                'extra_msa_row_mask': [NUM_EXTRA_SEQ],
+                'is_distillation': [],
+                'msa_feat': [NUM_MSA_SEQ, NUM_RES, None],
+                'msa_mask': [NUM_MSA_SEQ, NUM_RES],
+                'msa_row_mask': [NUM_MSA_SEQ],
+                'pseudo_beta': [NUM_RES, None],
+                'pseudo_beta_mask': [NUM_RES],
+                'random_crop_to_size_seed': [None],
+                'residue_index': [NUM_RES],
+                'residx_atom14_to_atom37': [NUM_RES, None],
+                'residx_atom37_to_atom14': [NUM_RES, None],
+                'resolution': [],
+                'rigidgroups_alt_gt_frames': [NUM_RES, None, None],
+                'rigidgroups_group_exists': [NUM_RES, None],
+                'rigidgroups_group_is_ambiguous': [NUM_RES, None],
+                'rigidgroups_gt_exists': [NUM_RES, None],
+                'rigidgroups_gt_frames': [NUM_RES, None, None],
+                'seq_length': [],
+                'seq_mask': [NUM_RES],
+                'target_feat': [NUM_RES, None],
+                'template_aatype': [NUM_TEMPLATES, NUM_RES],
+                'template_all_atom_masks': [NUM_TEMPLATES, NUM_RES, None],
+                'template_all_atom_positions': [
+                    NUM_TEMPLATES, NUM_RES, None, None],
+                'template_backbone_affine_mask': [NUM_TEMPLATES, NUM_RES],
+                'template_backbone_affine_tensor': [
+                    NUM_TEMPLATES, NUM_RES, None],
+                'template_mask': [NUM_TEMPLATES],
+                'template_pseudo_beta': [NUM_TEMPLATES, NUM_RES, None],
+                'template_pseudo_beta_mask': [NUM_TEMPLATES, NUM_RES],
+                'template_sum_probs': [NUM_TEMPLATES, None],
+                'true_msa': [NUM_MSA_SEQ, NUM_RES]
+            },
+            'fixed_size': True,
+            'subsample_templates': False,  # We want top templates.
+            'masked_msa_replace_fraction': 0.15,
+            'max_msa_clusters': 512,
+            'max_templates': 4,
+            'num_ensemble': 1,
+        },
+    },
+    'model': {
+        'embeddings_and_evoformer': {
+            'evoformer_num_block': 48,
+            'evoformer': {
+                'msa_row_attention_with_pair_bias': {
+                    'dropout_rate': 0.15,
+                    'gating': True,
+                    'num_head': 8,
+                    'orientation': 'per_row',
+                    'shared_dropout': True
+                },
+                'msa_column_attention': {
+                    'dropout_rate': 0.0,
+                    'gating': True,
+                    'num_head': 8,
+                    'orientation': 'per_column',
+                    'shared_dropout': True
+                },
+                'msa_transition': {
+                    'dropout_rate': 0.0,
+                    'num_intermediate_factor': 4,
+                    'orientation': 'per_row',
+                    'shared_dropout': True
+                },
+                'outer_product_mean': {
+                    'first': False,
+                    'chunk_size': 128,
+                    'dropout_rate': 0.0,
+                    'num_outer_channel': 32,
+                    'orientation': 'per_row',
+                    'shared_dropout': True
+                },
+                'triangle_attention_starting_node': {
+                    'dropout_rate': 0.25,
+                    'gating': True,
+                    'num_head': 4,
+                    'orientation': 'per_row',
+                    'shared_dropout': True
+                },
+                'triangle_attention_ending_node': {
+                    'dropout_rate': 0.25,
+                    'gating': True,
+                    'num_head': 4,
+                    'orientation': 'per_column',
+                    'shared_dropout': True
+                },
+                'triangle_multiplication_outgoing': {
+                    'dropout_rate': 0.25,
+                    'equation': 'ikc,jkc->ijc',
+                    'num_intermediate_channel': 128,
+                    'orientation': 'per_row',
+                    'shared_dropout': True,
+                    'fuse_projection_weights': False,
+                },
+                'triangle_multiplication_incoming': {
+                    'dropout_rate': 0.25,
+                    'equation': 'kjc,kic->ijc',
+                    'num_intermediate_channel': 128,
+                    'orientation': 'per_row',
+                    'shared_dropout': True,
+                    'fuse_projection_weights': False,
+                },
+                'pair_transition': {
+                    'dropout_rate': 0.0,
+                    'num_intermediate_factor': 4,
+                    'orientation': 'per_row',
+                    'shared_dropout': True
+                }
+            },
+            'extra_msa_channel': 64,
+            'extra_msa_stack_num_block': 4,
+            'max_relative_feature': 32,
+            'msa_channel': 256,
+            'pair_channel': 128,
+            'prev_pos': {
+                'min_bin': 3.25,
+                'max_bin': 20.75,
+                'num_bins': 15
+            },
+            'recycle_features': True,
+            'recycle_pos': True,
+            'seq_channel': 384,
+            'template': {
+                'attention': {
+                    'gating': False,
+                    'key_dim': 64,
+                    'num_head': 4,
+                    'value_dim': 64
+                },
+                'dgram_features': {
+                    'min_bin': 3.25,
+                    'max_bin': 50.75,
+                    'num_bins': 39
+                },
+                'embed_torsion_angles': False,
+                'enabled': False,
+                'template_pair_stack': {
+                    'num_block': 2,
+                    'triangle_attention_starting_node': {
+                        'dropout_rate': 0.25,
+                        'gating': True,
+                        'key_dim': 64,
+                        'num_head': 4,
+                        'orientation': 'per_row',
+                        'shared_dropout': True,
+                        'value_dim': 64
+                    },
+                    'triangle_attention_ending_node': {
+                        'dropout_rate': 0.25,
+                        'gating': True,
+                        'key_dim': 64,
+                        'num_head': 4,
+                        'orientation': 'per_column',
+                        'shared_dropout': True,
+                        'value_dim': 64
+                    },
+                    'triangle_multiplication_outgoing': {
+                        'dropout_rate': 0.25,
+                        'equation': 'ikc,jkc->ijc',
+                        'num_intermediate_channel': 64,
+                        'orientation': 'per_row',
+                        'shared_dropout': True,
+                        'fuse_projection_weights': False,
+                    },
+                    'triangle_multiplication_incoming': {
+                        'dropout_rate': 0.25,
+                        'equation': 'kjc,kic->ijc',
+                        'num_intermediate_channel': 64,
+                        'orientation': 'per_row',
+                        'shared_dropout': True,
+                        'fuse_projection_weights': False,
+                    },
+                    'pair_transition': {
+                        'dropout_rate': 0.0,
+                        'num_intermediate_factor': 2,
+                        'orientation': 'per_row',
+                        'shared_dropout': True
+                    }
+                },
+                'max_templates': 4,
+                'subbatch_size': 128,
+                'use_template_unit_vector': False,
+            }
+        },
+        'global_config': {
+            'deterministic': False,
+            'multimer_mode': False,
+            'subbatch_size': 4,
+            'use_remat': False,
+            'zero_init': True,
+            'eval_dropout': False,
+        },
+        'heads': {
+            'distogram': {
+                'first_break': 2.3125,
+                'last_break': 21.6875,
+                'num_bins': 64,
+                'weight': 0.3
+            },
+            'predicted_aligned_error': {
+                # `num_bins - 1` bins uniformly space the
+                # [0, max_error_bin A] range.
+                # The final bin covers [max_error_bin A, +infty]
+                # 31A gives bins with 0.5A width.
+                'max_error_bin': 31.,
+                'num_bins': 64,
+                'num_channels': 128,
+                'filter_by_resolution': True,
+                'min_resolution': 0.1,
+                'max_resolution': 3.0,
+                'weight': 0.0,
+            },
+            'experimentally_resolved': {
+                'filter_by_resolution': True,
+                'max_resolution': 3.0,
+                'min_resolution': 0.1,
+                'weight': 0.01
+            },
+            'structure_module': {
+                'num_layer': 8,
+                'fape': {
+                    'clamp_distance': 10.0,
+                    'clamp_type': 'relu',
+                    'loss_unit_distance': 10.0
+                },
+                'angle_norm_weight': 0.01,
+                'chi_weight': 0.5,
+                'clash_overlap_tolerance': 1.5,
+                'compute_in_graph_metrics': True,
+                'dropout': 0.1,
+                'num_channel': 384,
+                'num_head': 12,
+                'num_layer_in_transition': 3,
+                'num_point_qk': 4,
+                'num_point_v': 8,
+                'num_scalar_qk': 16,
+                'num_scalar_v': 16,
+                'position_scale': 10.0,
+                'sidechain': {
+                    'atom_clamp_distance': 10.0,
+                    'num_channel': 128,
+                    'num_residual_block': 2,
+                    'weight_frac': 0.5,
+                    'length_scale': 10.,
+                },
+                'structural_violation_loss_weight': 1.0,
+                'violation_tolerance_factor': 12.0,
+                'weight': 1.0
+            },
+            'predicted_lddt': {
+                'filter_by_resolution': True,
+                'max_resolution': 3.0,
+                'min_resolution': 0.1,
+                'num_bins': 50,
+                'num_channels': 128,
+                'weight': 0.01
+            },
+            'masked_msa': {
+                'num_output': 23,
+                'weight': 2.0
+            },
+        },
+        'num_recycle': 3,
+        'resample_msa_in_recycling': True
+    },
+})
+
+
+CONFIG_MULTIMER = ml_collections.ConfigDict({
+    'model': {
+        'embeddings_and_evoformer': {
+            'evoformer_num_block': 48,
+            'evoformer': {
+                'msa_column_attention': {
+                    'dropout_rate': 0.0,
+                    'gating': True,
+                    'num_head': 8,
+                    'orientation': 'per_column',
+                    'shared_dropout': True
+                },
+                'msa_row_attention_with_pair_bias': {
+                    'dropout_rate': 0.15,
+                    'gating': True,
+                    'num_head': 8,
+                    'orientation': 'per_row',
+                    'shared_dropout': True
+                },
+                'msa_transition': {
+                    'dropout_rate': 0.0,
+                    'num_intermediate_factor': 4,
+                    'orientation': 'per_row',
+                    'shared_dropout': True
+                },
+                'outer_product_mean': {
+                    'chunk_size': 128,
+                    'dropout_rate': 0.0,
+                    'first': True,
+                    'num_outer_channel': 32,
+                    'orientation': 'per_row',
+                    'shared_dropout': True
+                },
+                'pair_transition': {
+                    'dropout_rate': 0.0,
+                    'num_intermediate_factor': 4,
+                    'orientation': 'per_row',
+                    'shared_dropout': True
+                },
+                'triangle_attention_ending_node': {
+                    'dropout_rate': 0.25,
+                    'gating': True,
+                    'num_head': 4,
+                    'orientation': 'per_column',
+                    'shared_dropout': True
+                },
+                'triangle_attention_starting_node': {
+                    'dropout_rate': 0.25,
+                    'gating': True,
+                    'num_head': 4,
+                    'orientation': 'per_row',
+                    'shared_dropout': True,
+                },
+                'triangle_multiplication_incoming': {
+                    'dropout_rate': 0.25,
+                    'equation': 'kjc,kic->ijc',
+                    'num_intermediate_channel': 128,
+                    'orientation': 'per_row',
+                    'shared_dropout': True,
+                    'fuse_projection_weights': True,
+                },
+                'triangle_multiplication_outgoing': {
+                    'dropout_rate': 0.25,
+                    'equation': 'ikc,jkc->ijc',
+                    'num_intermediate_channel': 128,
+                    'orientation': 'per_row',
+                    'shared_dropout': True,
+                    'fuse_projection_weights': True,
+                }
+            },
+            'extra_msa_channel': 64,
+            'extra_msa_stack_num_block': 4,
+            'num_msa': 508,
+            'num_extra_msa': 2048,
+            'masked_msa': {
+                'profile_prob': 0.1,
+                'replace_fraction': 0.15,
+                'same_prob': 0.1,
+                'uniform_prob': 0.1
+            },
+            'use_chain_relative': True,
+            'max_relative_chain': 2,
+            'max_relative_idx': 32,
+            'seq_channel': 384,
+            'msa_channel': 256,
+            'pair_channel': 128,
+            'prev_pos': {
+                'max_bin': 20.75,
+                'min_bin': 3.25,
+                'num_bins': 15
+            },
+            'recycle_features': True,
+            'recycle_pos': True,
+            'template': {
+                'attention': {
+                    'gating': False,
+                    'num_head': 4
+                },
+                'dgram_features': {
+                    'max_bin': 50.75,
+                    'min_bin': 3.25,
+                    'num_bins': 39
+                },
+                'enabled': True,
+                'max_templates': 4,
+                'num_channels': 64,
+                'subbatch_size': 128,
+                'template_pair_stack': {
+                    'num_block': 2,
+                    'pair_transition': {
+                        'dropout_rate': 0.0,
+                        'num_intermediate_factor': 2,
+                        'orientation': 'per_row',
+                        'shared_dropout': True
+                    },
+                    'triangle_attention_ending_node': {
+                        'dropout_rate': 0.25,
+                        'gating': True,
+                        'num_head': 4,
+                        'orientation': 'per_column',
+                        'shared_dropout': True
+                    },
+                    'triangle_attention_starting_node': {
+                        'dropout_rate': 0.25,
+                        'gating': True,
+                        'num_head': 4,
+                        'orientation': 'per_row',
+                        'shared_dropout': True
+                    },
+                    'triangle_multiplication_incoming': {
+                        'dropout_rate': 0.25,
+                        'equation': 'kjc,kic->ijc',
+                        'num_intermediate_channel': 64,
+                        'orientation': 'per_row',
+                        'shared_dropout': True,
+                        'fuse_projection_weights': True,
+                    },
+                    'triangle_multiplication_outgoing': {
+                        'dropout_rate': 0.25,
+                        'equation': 'ikc,jkc->ijc',
+                        'num_intermediate_channel': 64,
+                        'orientation': 'per_row',
+                        'shared_dropout': True,
+                        'fuse_projection_weights': True,
+                    }
+                }
+            },
+        },
+        'global_config': {
+            'bfloat16': True,
+            'bfloat16_output': False,
+            'deterministic': False,
+            'multimer_mode': True,
+            'subbatch_size': 4,
+            'use_remat': False,
+            'zero_init': True,
+            'eval_dropout': False,
+        },
+        'heads': {
+            'distogram': {
+                'first_break': 2.3125,
+                'last_break': 21.6875,
+                'num_bins': 64,
+                'weight': 0.3
+            },
+            'experimentally_resolved': {
+                'filter_by_resolution': True,
+                'max_resolution': 3.0,
+                'min_resolution': 0.1,
+                'weight': 0.01
+            },
+            'masked_msa': {
+                'weight': 2.0
+            },
+            'predicted_aligned_error': {
+                'filter_by_resolution': True,
+                'max_error_bin': 31.0,
+                'max_resolution': 3.0,
+                'min_resolution': 0.1,
+                'num_bins': 64,
+                'num_channels': 128,
+                'weight': 0.1
+            },
+            'predicted_lddt': {
+                'filter_by_resolution': True,
+                'max_resolution': 3.0,
+                'min_resolution': 0.1,
+                'num_bins': 50,
+                'num_channels': 128,
+                'weight': 0.01
+            },
+            'structure_module': {
+                'angle_norm_weight': 0.01,
+                'chi_weight': 0.5,
+                'clash_overlap_tolerance': 1.5,
+                'dropout': 0.1,
+                'interface_fape': {
+                    'atom_clamp_distance': 1000.0,
+                    'loss_unit_distance': 20.0
+                },
+                'intra_chain_fape': {
+                    'atom_clamp_distance': 10.0,
+                    'loss_unit_distance': 10.0
+                },
+                'num_channel': 384,
+                'num_head': 12,
+                'num_layer': 8,
+                'num_layer_in_transition': 3,
+                'num_point_qk': 4,
+                'num_point_v': 8,
+                'num_scalar_qk': 16,
+                'num_scalar_v': 16,
+                'position_scale': 20.0,
+                'sidechain': {
+                    'atom_clamp_distance': 10.0,
+                    'loss_unit_distance': 10.0,
+                    'num_channel': 128,
+                    'num_residual_block': 2,
+                    'weight_frac': 0.5
+                },
+                'structural_violation_loss_weight': 1.0,
+                'violation_tolerance_factor': 12.0,
+                'weight': 1.0
+            }
+        },
+        'num_ensemble_eval': 1,
+        'num_recycle': 20,
+        # A negative value indicates that no early stopping will occur, i.e.
+        # the model will always run `num_recycle` number of recycling
+        # iterations.  A positive value will enable early stopping if the
+        # difference in pairwise distances is less than the tolerance between
+        # recycling steps.
+        'recycle_early_stop_tolerance': 0.5,
+        'resample_msa_in_recycling': True
+    }
+})
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/layer_stack_test.py",".py","10315","336","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for layer_stack.""""""
+
+import functools
+from absl.testing import absltest
+from absl.testing import parameterized
+from alphafold.model import layer_stack
+import haiku as hk
+import jax
+import jax.numpy as jnp
+import numpy as np
+import scipy.stats
+
+
+# Suffixes applied by Haiku for repeated module names.
+suffixes = [''] + [f'_{i}' for i in range(1, 100)]
+
+
+def _slice_layers_params(layers_params):
+  sliced_layers_params = {}
+  for k, v in layers_params.items():
+    for inner_k in v:
+      for var_slice, suffix in zip(v[inner_k], suffixes):
+        k_new = k.split('/')[-1] + suffix
+        if k_new not in sliced_layers_params:
+          sliced_layers_params[k_new] = {}
+        sliced_layers_params[k_new][inner_k] = var_slice
+  return sliced_layers_params
+
+
+class LayerStackTest(parameterized.TestCase):
+
+  @parameterized.parameters([1, 2, 4])
+  def test_layer_stack(self, unroll):
+    """"""Compare layer_stack to the equivalent unrolled stack.
+
+    Tests that the layer_stack application of a Haiku layer function is
+    equivalent to repeatedly applying the layer function in an unrolled loop.
+
+    Args:
+      unroll: Number of unrolled layers.
+    """"""
+    num_layers = 20
+
+    def inner_fn(x):
+      x += hk.Linear(100, name='linear1')(x)
+      x += hk.Linear(100, name='linear2')(x)
+      return x
+
+    def outer_fn_unrolled(x):
+      for _ in range(num_layers):
+        x = inner_fn(x)
+      return x
+
+    def outer_fn_layer_stack(x):
+      stack = layer_stack.layer_stack(num_layers, unroll=unroll)(inner_fn)
+      return stack(x)
+
+    unrolled_fn = hk.transform(outer_fn_unrolled)
+    layer_stack_fn = hk.transform(outer_fn_layer_stack)
+
+    x = jax.random.uniform(jax.random.PRNGKey(0), [10, 256, 100])
+
+    rng_init = jax.random.PRNGKey(42)
+
+    params = layer_stack_fn.init(rng_init, x)
+
+    sliced_params = _slice_layers_params(params)
+
+    unrolled_pred = unrolled_fn.apply(sliced_params, None, x)
+    layer_stack_pred = layer_stack_fn.apply(params, None, x)
+
+    np.testing.assert_allclose(unrolled_pred, layer_stack_pred)
+
+  def test_layer_stack_multi_args(self):
+    """"""Compare layer_stack to the equivalent unrolled stack.
+
+    Similar to `test_layer_stack`, but use a function that takes more than one
+    argument.
+    """"""
+    num_layers = 20
+
+    def inner_fn(x, y):
+      x_out = x + hk.Linear(100, name='linear1')(y)
+      y_out = y + hk.Linear(100, name='linear2')(x)
+      return x_out, y_out
+
+    def outer_fn_unrolled(x, y):
+      for _ in range(num_layers):
+        x, y = inner_fn(x, y)
+      return x, y
+
+    def outer_fn_layer_stack(x, y):
+      stack = layer_stack.layer_stack(num_layers)(inner_fn)
+      return stack(x, y)
+
+    unrolled_fn = hk.transform(outer_fn_unrolled)
+    layer_stack_fn = hk.transform(outer_fn_layer_stack)
+
+    x = jax.random.uniform(jax.random.PRNGKey(0), [10, 256, 100])
+    y = jax.random.uniform(jax.random.PRNGKey(1), [10, 256, 100])
+
+    rng_init = jax.random.PRNGKey(42)
+
+    params = layer_stack_fn.init(rng_init, x, y)
+
+    sliced_params = _slice_layers_params(params)
+
+    unrolled_x, unrolled_y = unrolled_fn.apply(sliced_params, None, x, y)
+    layer_stack_x, layer_stack_y = layer_stack_fn.apply(params, None, x, y)
+
+    np.testing.assert_allclose(unrolled_x, layer_stack_x)
+    np.testing.assert_allclose(unrolled_y, layer_stack_y)
+
+  def test_layer_stack_no_varargs(self):
+    """"""Test an error is raised when using a function with varargs.""""""
+
+    class VarArgsModule(hk.Module):
+      """"""When used, this module should cause layer_stack to raise an Error.""""""
+
+      def __call__(self, *args):
+        return args
+
+    class NoVarArgsModule(hk.Module):
+      """"""This module should be fine to use with layer_stack.""""""
+
+      def __call__(self, x):
+        return x
+
+    def build_and_init_stack(module_class):
+      def stack_fn(x):
+        module = module_class()
+        return layer_stack.layer_stack(1)(module)(x)
+
+      stack = hk.without_apply_rng(hk.transform(stack_fn))
+      stack.init(jax.random.PRNGKey(1729), jnp.ones([5]))
+
+    build_and_init_stack(NoVarArgsModule)
+    with self.assertRaisesRegex(
+        ValueError, 'The function `f` should not have any `varargs`'):
+      build_and_init_stack(VarArgsModule)
+
+  @parameterized.parameters([1, 2, 4])
+  def test_layer_stack_grads(self, unroll):
+    """"""Compare layer_stack gradients to the equivalent unrolled stack.
+
+    Tests that the layer_stack application of a Haiku layer function is
+    equivalent to repeatedly applying the layer function in an unrolled loop.
+
+    Args:
+      unroll: Number of unrolled layers.
+    """"""
+    num_layers = 20
+
+    def inner_fn(x):
+      x += hk.Linear(100, name='linear1')(x)
+      x += hk.Linear(100, name='linear2')(x)
+      return x
+
+    def outer_fn_unrolled(x):
+      for _ in range(num_layers):
+        x = inner_fn(x)
+      return x
+
+    def outer_fn_layer_stack(x):
+      stack = layer_stack.layer_stack(num_layers, unroll=unroll)(inner_fn)
+      return stack(x)
+
+    unrolled_fn = hk.transform(outer_fn_unrolled)
+    layer_stack_fn = hk.transform(outer_fn_layer_stack)
+
+    x = jax.random.uniform(jax.random.PRNGKey(0), [10, 256, 100])
+
+    rng_init = jax.random.PRNGKey(42)
+
+    params = layer_stack_fn.init(rng_init, x)
+
+    sliced_params = _slice_layers_params(params)
+
+    unrolled_grad = jax.grad(
+        lambda p, x: jnp.mean(unrolled_fn.apply(p, None, x)))(sliced_params, x)
+    layer_stack_grad = jax.grad(
+        lambda p, x: jnp.mean(layer_stack_fn.apply(p, None, x)))(params, x)
+
+    assert_fn = functools.partial(
+        np.testing.assert_allclose, atol=1e-4, rtol=1e-4)
+
+    jax.tree_map(assert_fn, unrolled_grad,
+                 _slice_layers_params(layer_stack_grad))
+
+  def test_random(self):
+    """"""Random numbers should be handled correctly.""""""
+    n = 100
+
+    @hk.transform
+    @layer_stack.layer_stack(n)
+    def add_random(x):
+      x = x + jax.random.normal(hk.next_rng_key())
+      return x
+
+    # Evaluate a bunch of times
+    key, *keys = jax.random.split(jax.random.PRNGKey(7), 1024 + 1)
+    params = add_random.init(key, 0.)
+    apply_fn = jax.jit(add_random.apply)
+    values = [apply_fn(params, key, 0.) for key in keys]
+
+    # Should be roughly N(0, sqrt(n))
+    cdf = scipy.stats.norm(scale=np.sqrt(n)).cdf
+    _, p = scipy.stats.kstest(values, cdf)
+    self.assertLess(0.3, p)
+
+  def test_threading(self):
+    """"""Test @layer_stack when the function gets per-layer state.""""""
+    n = 5
+
+    @layer_stack.layer_stack(n, with_state=True)
+    def f(x, y):
+      x = x + y * jax.nn.one_hot(y, len(x)) / 10
+      return x, 2 * y
+
+    @hk.without_apply_rng
+    @hk.transform
+    def g(x, ys):
+      x, zs = f(x, ys)
+      # Check here to catch issues at init time
+      self.assertEqual(zs.shape, (n,))
+      return x, zs
+
+    rng = jax.random.PRNGKey(7)
+    x = np.zeros(n)
+    ys = np.arange(n).astype(np.float32)
+    params = g.init(rng, x, ys)
+    x, zs = g.apply(params, x, ys)
+    self.assertTrue(np.allclose(x, [0, .1, .2, .3, .4]))
+    self.assertTrue(np.all(zs == 2 * ys))
+
+  def test_nested_stacks(self):
+    def stack_fn(x):
+      def layer_fn(x):
+        return hk.Linear(100)(x)
+
+      outer_fn = layer_stack.layer_stack(10)(layer_fn)
+
+      layer_outer = layer_stack.layer_stack(20)(outer_fn)
+      return layer_outer(x)
+
+    hk_mod = hk.transform(stack_fn)
+    apply_rng, init_rng = jax.random.split(jax.random.PRNGKey(0))
+
+    params = hk_mod.init(init_rng, jnp.zeros([10, 100]))
+
+    hk_mod.apply(params, apply_rng, jnp.zeros([10, 100]))
+
+    p, = params.values()
+
+    assert p['w'].shape == (10, 20, 100, 100)
+    assert p['b'].shape == (10, 20, 100)
+
+  def test_with_state_multi_args(self):
+    """"""Test layer_stack with state with multiple arguments.""""""
+    width = 4
+    batch_size = 5
+    stack_height = 3
+
+    def f_with_multi_args(x, a, b):
+      return hk.Linear(
+          width, w_init=hk.initializers.Constant(
+              jnp.eye(width)))(x) * a + b, None
+
+    @hk.without_apply_rng
+    @hk.transform
+    def hk_fn(x):
+      return layer_stack.layer_stack(
+          stack_height,
+          with_state=True)(f_with_multi_args)(x, jnp.full([stack_height], 2.),
+                                              jnp.ones([stack_height]))
+
+    x = jnp.zeros([batch_size, width])
+    key_seq = hk.PRNGSequence(19)
+    params = hk_fn.init(next(key_seq), x)
+    output, z = hk_fn.apply(params, x)
+    self.assertIsNone(z)
+    self.assertEqual(output.shape, (batch_size, width))
+    np.testing.assert_equal(output, np.full([batch_size, width], 7.))
+
+  def test_with_container_state(self):
+    width = 2
+    batch_size = 2
+    stack_height = 3
+
+    def f_with_container_state(x):
+      hk_layer = hk.Linear(
+          width, w_init=hk.initializers.Constant(jnp.eye(width)))
+      layer_output = hk_layer(x)
+      layer_state = {
+          'raw_output': layer_output,
+          'output_projection': jnp.sum(layer_output)
+      }
+      return layer_output + jnp.ones_like(layer_output), layer_state
+
+    @hk.without_apply_rng
+    @hk.transform
+    def hk_fn(x):
+      return layer_stack.layer_stack(
+          stack_height,
+          with_state=True)(f_with_container_state)(x)
+
+    x = jnp.zeros([batch_size, width])
+    key_seq = hk.PRNGSequence(19)
+    params = hk_fn.init(next(key_seq), x)
+    output, z = hk_fn.apply(params, x)
+    self.assertEqual(z['raw_output'].shape, (stack_height, batch_size, width))
+    self.assertEqual(output.shape, (batch_size, width))
+    self.assertEqual(z['output_projection'].shape, (stack_height,))
+    np.testing.assert_equal(np.sum(z['output_projection']), np.array(12.))
+    np.testing.assert_equal(
+        np.all(z['raw_output'] == np.array([0., 1., 2.])[..., None, None]),
+        np.array(True))
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/prng_test.py",".py","1250","47","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for prng.""""""
+
+from absl.testing import absltest
+from alphafold.model import prng
+import jax
+
+
+class PrngTest(absltest.TestCase):
+
+  def test_key_reuse(self):
+
+    init_key = jax.random.PRNGKey(42)
+    safe_key = prng.SafeKey(init_key)
+    _, safe_key = safe_key.split()
+
+    raw_key = safe_key.get()
+
+    self.assertNotEqual(raw_key[0], init_key[0])
+    self.assertNotEqual(raw_key[1], init_key[1])
+
+    with self.assertRaises(RuntimeError):
+      safe_key.get()
+
+    with self.assertRaises(RuntimeError):
+      safe_key.split()
+
+    with self.assertRaises(RuntimeError):
+      safe_key.duplicate()
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/modules.py",".py","74156","2194","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Modules and code used in the core part of AlphaFold.
+
+The structure generation code is in 'folding.py'.
+""""""
+import functools
+from alphafold.common import residue_constants
+from alphafold.model import all_atom
+from alphafold.model import common_modules
+from alphafold.model import folding
+from alphafold.model import layer_stack
+from alphafold.model import lddt
+from alphafold.model import mapping
+from alphafold.model import prng
+from alphafold.model import quat_affine
+from alphafold.model import utils
+import haiku as hk
+import jax
+import jax.numpy as jnp
+
+
+def softmax_cross_entropy(logits, labels):
+  """"""Computes softmax cross entropy given logits and one-hot class labels.""""""
+  loss = -jnp.sum(labels * jax.nn.log_softmax(logits), axis=-1)
+  return jnp.asarray(loss)
+
+
+def sigmoid_cross_entropy(logits, labels):
+  """"""Computes sigmoid cross entropy given logits and multiple class labels.""""""
+  log_p = jax.nn.log_sigmoid(logits)
+  # log(1 - sigmoid(x)) = log_sigmoid(-x), the latter is more numerically stable
+  log_not_p = jax.nn.log_sigmoid(-logits)
+  loss = -labels * log_p - (1. - labels) * log_not_p
+  return jnp.asarray(loss)
+
+
+def apply_dropout(*, tensor, safe_key, rate, is_training, broadcast_dim=None):
+  """"""Applies dropout to a tensor.""""""
+  if is_training and rate != 0.0:
+    shape = list(tensor.shape)
+    if broadcast_dim is not None:
+      shape[broadcast_dim] = 1
+    keep_rate = 1.0 - rate
+    keep = jax.random.bernoulli(safe_key.get(), keep_rate, shape=shape)
+    return keep * tensor / keep_rate
+  else:
+    return tensor
+
+
+def dropout_wrapper(module,
+                    input_act,
+                    mask,
+                    safe_key,
+                    global_config,
+                    output_act=None,
+                    is_training=True,
+                    **kwargs):
+  """"""Applies module + dropout + residual update.""""""
+  if output_act is None:
+    output_act = input_act
+
+  gc = global_config
+  residual = module(input_act, mask, is_training=is_training, **kwargs)
+  dropout_rate = 0.0 if gc.deterministic else module.config.dropout_rate
+
+  # Will override `is_training` to True if want to use dropout.
+  should_apply_dropout = True if gc.eval_dropout else is_training
+
+  if module.config.shared_dropout:
+    if module.config.orientation == 'per_row':
+      broadcast_dim = 0
+    else:
+      broadcast_dim = 1
+  else:
+    broadcast_dim = None
+
+  residual = apply_dropout(tensor=residual,
+                           safe_key=safe_key,
+                           rate=dropout_rate,
+                           is_training=should_apply_dropout,
+                           broadcast_dim=broadcast_dim)
+
+  new_act = output_act + residual
+
+  return new_act
+
+
+def create_extra_msa_feature(batch):
+  """"""Expand extra_msa into 1hot and concat with other extra msa features.
+
+  We do this as late as possible as the one_hot extra msa can be very large.
+
+  Arguments:
+    batch: a dictionary with the following keys:
+     * 'extra_msa': [N_extra_seq, N_res] MSA that wasn't selected as a cluster
+       centre. Note, that this is not one-hot encoded.
+     * 'extra_has_deletion': [N_extra_seq, N_res] Whether there is a deletion to
+       the left of each position in the extra MSA.
+     * 'extra_deletion_value': [N_extra_seq, N_res] The number of deletions to
+       the left of each position in the extra MSA.
+
+  Returns:
+    Concatenated tensor of extra MSA features.
+  """"""
+  # 23 = 20 amino acids + 'X' for unknown + gap + bert mask
+  msa_1hot = jax.nn.one_hot(batch['extra_msa'], 23)
+  msa_feat = [msa_1hot,
+              jnp.expand_dims(batch['extra_has_deletion'], axis=-1),
+              jnp.expand_dims(batch['extra_deletion_value'], axis=-1)]
+  return jnp.concatenate(msa_feat, axis=-1)
+
+
+class AlphaFoldIteration(hk.Module):
+  """"""A single recycling iteration of AlphaFold architecture.
+
+  Computes ensembled (averaged) representations from the provided features.
+  These representations are then passed to the various heads
+  that have been requested by the configuration file. Each head also returns a
+  loss which is combined as a weighted sum to produce the total loss.
+
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 3-22
+  """"""
+
+  def __init__(self, config, global_config, name='alphafold_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               ensembled_batch,
+               non_ensembled_batch,
+               is_training,
+               compute_loss=False,
+               ensemble_representations=False,
+               return_representations=False):
+
+    num_ensemble = jnp.asarray(ensembled_batch['seq_length'].shape[0])
+
+    if not ensemble_representations:
+      assert ensembled_batch['seq_length'].shape[0] == 1
+
+    def slice_batch(i):
+      b = {k: v[i] for k, v in ensembled_batch.items()}
+      b.update(non_ensembled_batch)
+      return b
+
+    # Compute representations for each batch element and average.
+    evoformer_module = EmbeddingsAndEvoformer(
+        self.config.embeddings_and_evoformer, self.global_config)
+    batch0 = slice_batch(0)
+    representations = evoformer_module(batch0, is_training)
+
+    # MSA representations are not ensembled so
+    # we don't pass tensor into the loop.
+    msa_representation = representations['msa']
+    del representations['msa']
+
+    # Average the representations (except MSA) over the batch dimension.
+    if ensemble_representations:
+      def body(x):
+        """"""Add one element to the representations ensemble.""""""
+        i, current_representations = x
+        feats = slice_batch(i)
+        representations_update = evoformer_module(
+            feats, is_training)
+
+        new_representations = {}
+        for k in current_representations:
+          new_representations[k] = (
+              current_representations[k] + representations_update[k])
+        return i+1, new_representations
+
+      if hk.running_init():
+        # When initializing the Haiku module, run one iteration of the
+        # while_loop to initialize the Haiku modules used in `body`.
+        _, representations = body((1, representations))
+      else:
+        _, representations = hk.while_loop(
+            lambda x: x[0] < num_ensemble,
+            body,
+            (1, representations))
+
+      for k in representations:
+        if k != 'msa':
+          representations[k] /= num_ensemble.astype(representations[k].dtype)
+
+    representations['msa'] = msa_representation
+    batch = batch0  # We are not ensembled from here on.
+
+    heads = {}
+    for head_name, head_config in sorted(self.config.heads.items()):
+      if not head_config.weight:
+        continue  # Do not instantiate zero-weight heads.
+
+      head_factory = {
+          'masked_msa': MaskedMsaHead,
+          'distogram': DistogramHead,
+          'structure_module': functools.partial(
+              folding.StructureModule, compute_loss=compute_loss),
+          'predicted_lddt': PredictedLDDTHead,
+          'predicted_aligned_error': PredictedAlignedErrorHead,
+          'experimentally_resolved': ExperimentallyResolvedHead,
+      }[head_name]
+      heads[head_name] = (head_config,
+                          head_factory(head_config, self.global_config))
+
+    total_loss = 0.
+    ret = {}
+    ret['representations'] = representations
+
+    def loss(module, head_config, ret, name, filter_ret=True):
+      if filter_ret:
+        value = ret[name]
+      else:
+        value = ret
+      loss_output = module.loss(value, batch)
+      ret[name].update(loss_output)
+      loss = head_config.weight * ret[name]['loss']
+      return loss
+
+    for name, (head_config, module) in heads.items():
+      # Skip PredictedLDDTHead and PredictedAlignedErrorHead until
+      # StructureModule is executed.
+      if name in ('predicted_lddt', 'predicted_aligned_error'):
+        continue
+      else:
+        ret[name] = module(representations, batch, is_training)
+        if 'representations' in ret[name]:
+          # Extra representations from the head. Used by the structure module
+          # to provide activations for the PredictedLDDTHead.
+          representations.update(ret[name].pop('representations'))
+      if compute_loss:
+        total_loss += loss(module, head_config, ret, name)
+
+    if self.config.heads.get('predicted_lddt.weight', 0.0):
+      # Add PredictedLDDTHead after StructureModule executes.
+      name = 'predicted_lddt'
+      # Feed all previous results to give access to structure_module result.
+      head_config, module = heads[name]
+      ret[name] = module(representations, batch, is_training)
+      if compute_loss:
+        total_loss += loss(module, head_config, ret, name, filter_ret=False)
+
+    if ('predicted_aligned_error' in self.config.heads
+        and self.config.heads.get('predicted_aligned_error.weight', 0.0)):
+      # Add PredictedAlignedErrorHead after StructureModule executes.
+      name = 'predicted_aligned_error'
+      # Feed all previous results to give access to structure_module result.
+      head_config, module = heads[name]
+      ret[name] = module(representations, batch, is_training)
+      if compute_loss:
+        total_loss += loss(module, head_config, ret, name, filter_ret=False)
+
+    if compute_loss:
+      return ret, total_loss
+    else:
+      return ret
+
+
+class AlphaFold(hk.Module):
+  """"""AlphaFold model with recycling.
+
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference""
+  """"""
+
+  def __init__(self, config, name='alphafold'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = config.global_config
+
+  def __call__(
+      self,
+      batch,
+      is_training,
+      compute_loss=False,
+      ensemble_representations=False,
+      return_representations=False):
+    """"""Run the AlphaFold model.
+
+    Arguments:
+      batch: Dictionary with inputs to the AlphaFold model.
+      is_training: Whether the system is in training or inference mode.
+      compute_loss: Whether to compute losses (requires extra features
+        to be present in the batch and knowing the true structure).
+      ensemble_representations: Whether to use ensembling of representations.
+      return_representations: Whether to also return the intermediate
+        representations.
+
+    Returns:
+      When compute_loss is True:
+        a tuple of loss and output of AlphaFoldIteration.
+      When compute_loss is False:
+        just output of AlphaFoldIteration.
+
+      The output of AlphaFoldIteration is a nested dictionary containing
+      predictions from the various heads.
+    """"""
+
+    impl = AlphaFoldIteration(self.config, self.global_config)
+    batch_size, num_residues = batch['aatype'].shape
+
+    def get_prev(ret):
+      new_prev = {
+          'prev_pos':
+              ret['structure_module']['final_atom_positions'],
+          'prev_msa_first_row': ret['representations']['msa_first_row'],
+          'prev_pair': ret['representations']['pair'],
+      }
+      return jax.tree_map(jax.lax.stop_gradient, new_prev)
+
+    def do_call(prev,
+                recycle_idx,
+                compute_loss=compute_loss):
+      if self.config.resample_msa_in_recycling:
+        num_ensemble = batch_size // (self.config.num_recycle + 1)
+        def slice_recycle_idx(x):
+          start = recycle_idx * num_ensemble
+          size = num_ensemble
+          return jax.lax.dynamic_slice_in_dim(x, start, size, axis=0)
+        ensembled_batch = jax.tree_map(slice_recycle_idx, batch)
+      else:
+        num_ensemble = batch_size
+        ensembled_batch = batch
+
+      non_ensembled_batch = jax.tree_map(lambda x: x, prev)
+
+      return impl(
+          ensembled_batch=ensembled_batch,
+          non_ensembled_batch=non_ensembled_batch,
+          is_training=is_training,
+          compute_loss=compute_loss,
+          ensemble_representations=ensemble_representations)
+
+    prev = {}
+    emb_config = self.config.embeddings_and_evoformer
+    if emb_config.recycle_pos:
+      prev['prev_pos'] = jnp.zeros(
+          [num_residues, residue_constants.atom_type_num, 3])
+    if emb_config.recycle_features:
+      prev['prev_msa_first_row'] = jnp.zeros(
+          [num_residues, emb_config.msa_channel])
+      prev['prev_pair'] = jnp.zeros(
+          [num_residues, num_residues, emb_config.pair_channel])
+
+    if self.config.num_recycle:
+      if 'num_iter_recycling' in batch:
+        # Training time: num_iter_recycling is in batch.
+        # The value for each ensemble batch is the same, so arbitrarily taking
+        # 0-th.
+        num_iter = batch['num_iter_recycling'][0]
+
+        # Add insurance that we will not run more
+        # recyclings than the model is configured to run.
+        num_iter = jnp.minimum(num_iter, self.config.num_recycle)
+      else:
+        # Eval mode or tests: use the maximum number of iterations.
+        num_iter = self.config.num_recycle
+
+      body = lambda x: (x[0] + 1,  # pylint: disable=g-long-lambda
+                        get_prev(do_call(x[1], recycle_idx=x[0],
+                                         compute_loss=False)))
+      if hk.running_init():
+        # When initializing the Haiku module, run one iteration of the
+        # while_loop to initialize the Haiku modules used in `body`.
+        _, prev = body((0, prev))
+      else:
+        _, prev = hk.while_loop(
+            lambda x: x[0] < num_iter,
+            body,
+            (0, prev))
+    else:
+      num_iter = 0
+
+    ret = do_call(prev=prev, recycle_idx=num_iter)
+    if compute_loss:
+      ret = ret[0], [ret[1]]
+
+    if not return_representations:
+      del (ret[0] if compute_loss else ret)['representations']  # pytype: disable=unsupported-operands
+    return ret
+
+
+class TemplatePairStack(hk.Module):
+  """"""Pair stack for the templates.
+
+  Jumper et al. (2021) Suppl. Alg. 16 ""TemplatePairStack""
+  """"""
+
+  def __init__(self, config, global_config, name='template_pair_stack'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, pair_act, pair_mask, is_training, safe_key=None):
+    """"""Builds TemplatePairStack module.
+
+    Arguments:
+      pair_act: Pair activations for single template, shape [N_res, N_res, c_t].
+      pair_mask: Pair mask, shape [N_res, N_res].
+      is_training: Whether the module is in training mode.
+      safe_key: Safe key object encapsulating the random number generation key.
+
+    Returns:
+      Updated pair_act, shape [N_res, N_res, c_t].
+    """"""
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    gc = self.global_config
+    c = self.config
+
+    if not c.num_block:
+      return pair_act
+
+    def block(x):
+      """"""One block of the template pair stack.""""""
+      pair_act, safe_key = x
+
+      dropout_wrapper_fn = functools.partial(
+          dropout_wrapper, is_training=is_training, global_config=gc)
+
+      safe_key, *sub_keys = safe_key.split(6)
+      sub_keys = iter(sub_keys)
+
+      pair_act = dropout_wrapper_fn(
+          TriangleAttention(c.triangle_attention_starting_node, gc,
+                            name='triangle_attention_starting_node'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+      pair_act = dropout_wrapper_fn(
+          TriangleAttention(c.triangle_attention_ending_node, gc,
+                            name='triangle_attention_ending_node'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+      pair_act = dropout_wrapper_fn(
+          TriangleMultiplication(c.triangle_multiplication_outgoing, gc,
+                                 name='triangle_multiplication_outgoing'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+      pair_act = dropout_wrapper_fn(
+          TriangleMultiplication(c.triangle_multiplication_incoming, gc,
+                                 name='triangle_multiplication_incoming'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+      pair_act = dropout_wrapper_fn(
+          Transition(c.pair_transition, gc, name='pair_transition'),
+          pair_act,
+          pair_mask,
+          next(sub_keys))
+
+      return pair_act, safe_key
+
+    if gc.use_remat:
+      block = hk.remat(block)
+
+    res_stack = layer_stack.layer_stack(c.num_block)(block)
+    pair_act, safe_key = res_stack((pair_act, safe_key))
+    return pair_act
+
+
+class Transition(hk.Module):
+  """"""Transition layer.
+
+  Jumper et al. (2021) Suppl. Alg. 9 ""MSATransition""
+  Jumper et al. (2021) Suppl. Alg. 15 ""PairTransition""
+  """"""
+
+  def __init__(self, config, global_config, name='transition_block'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, act, mask, is_training=True):
+    """"""Builds Transition module.
+
+    Arguments:
+      act: A tensor of queries of size [batch_size, N_res, N_channel].
+      mask: A tensor denoting the mask of size [batch_size, N_res].
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      A float32 tensor of size [batch_size, N_res, N_channel].
+    """"""
+    _, _, nc = act.shape
+
+    num_intermediate = int(nc * self.config.num_intermediate_factor)
+    mask = jnp.expand_dims(mask, axis=-1)
+
+    act = common_modules.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='input_layer_norm')(
+            act)
+
+    transition_module = hk.Sequential([
+        common_modules.Linear(
+            num_intermediate,
+            initializer='relu',
+            name='transition1'), jax.nn.relu,
+        common_modules.Linear(
+            nc,
+            initializer=utils.final_init(self.global_config),
+            name='transition2')
+    ])
+
+    act = mapping.inference_subbatch(
+        transition_module,
+        self.global_config.subbatch_size,
+        batched_args=[act],
+        nonbatched_args=[],
+        low_memory=not is_training)
+
+    return act
+
+
+def glorot_uniform():
+  return hk.initializers.VarianceScaling(scale=1.0,
+                                         mode='fan_avg',
+                                         distribution='uniform')
+
+
+class Attention(hk.Module):
+  """"""Multihead attention.""""""
+
+  def __init__(self, config, global_config, output_dim, name='attention'):
+    super().__init__(name=name)
+
+    self.config = config
+    self.global_config = global_config
+    self.output_dim = output_dim
+
+  def __call__(self, q_data, m_data, bias, nonbatched_bias=None):
+    """"""Builds Attention module.
+
+    Arguments:
+      q_data: A tensor of queries, shape [batch_size, N_queries, q_channels].
+      m_data: A tensor of memories from which the keys and values are
+        projected, shape [batch_size, N_keys, m_channels].
+      bias: A bias for the attention, shape [batch_size, N_queries, N_keys].
+      nonbatched_bias: Shared bias, shape [N_queries, N_keys].
+
+    Returns:
+      A float32 tensor of shape [batch_size, N_queries, output_dim].
+    """"""
+    # Sensible default for when the config keys are missing
+    key_dim = self.config.get('key_dim', int(q_data.shape[-1]))
+    value_dim = self.config.get('value_dim', int(m_data.shape[-1]))
+    num_head = self.config.num_head
+    assert key_dim % num_head == 0
+    assert value_dim % num_head == 0
+    key_dim = key_dim // num_head
+    value_dim = value_dim // num_head
+
+    q_weights = hk.get_parameter(
+        'query_w', shape=(q_data.shape[-1], num_head, key_dim),
+        dtype=q_data.dtype,
+        init=glorot_uniform())
+    k_weights = hk.get_parameter(
+        'key_w', shape=(m_data.shape[-1], num_head, key_dim),
+        dtype=q_data.dtype,
+        init=glorot_uniform())
+    v_weights = hk.get_parameter(
+        'value_w', shape=(m_data.shape[-1], num_head, value_dim),
+        dtype=q_data.dtype,
+        init=glorot_uniform())
+
+    q = jnp.einsum('bqa,ahc->bqhc', q_data, q_weights) * key_dim**(-0.5)
+    k = jnp.einsum('bka,ahc->bkhc', m_data, k_weights)
+    v = jnp.einsum('bka,ahc->bkhc', m_data, v_weights)
+    logits = jnp.einsum('bqhc,bkhc->bhqk', q, k) + bias
+    if nonbatched_bias is not None:
+      logits += jnp.expand_dims(nonbatched_bias, axis=0)
+    weights = jax.nn.softmax(logits)
+    weighted_avg = jnp.einsum('bhqk,bkhc->bqhc', weights, v)
+
+    if self.global_config.zero_init:
+      init = hk.initializers.Constant(0.0)
+    else:
+      init = glorot_uniform()
+
+    if self.config.gating:
+      gating_weights = hk.get_parameter(
+          'gating_w',
+          shape=(q_data.shape[-1], num_head, value_dim),
+          dtype=q_data.dtype,
+          init=hk.initializers.Constant(0.0))
+      gating_bias = hk.get_parameter(
+          'gating_b',
+          shape=(num_head, value_dim),
+          dtype=q_data.dtype,
+          init=hk.initializers.Constant(1.0))
+
+      gate_values = jnp.einsum('bqc, chv->bqhv', q_data,
+                               gating_weights) + gating_bias
+
+      gate_values = jax.nn.sigmoid(gate_values)
+
+      weighted_avg *= gate_values
+
+    o_weights = hk.get_parameter(
+        'output_w', shape=(num_head, value_dim, self.output_dim),
+        dtype=q_data.dtype,
+        init=init)
+    o_bias = hk.get_parameter(
+        'output_b', shape=(self.output_dim,),
+        dtype=q_data.dtype,
+        init=hk.initializers.Constant(0.0))
+
+    output = jnp.einsum('bqhc,hco->bqo', weighted_avg, o_weights) + o_bias
+
+    return output
+
+
+class GlobalAttention(hk.Module):
+  """"""Global attention.
+
+  Jumper et al. (2021) Suppl. Alg. 19 ""MSAColumnGlobalAttention"" lines 2-7
+  """"""
+
+  def __init__(self, config, global_config, output_dim, name='attention'):
+    super().__init__(name=name)
+
+    self.config = config
+    self.global_config = global_config
+    self.output_dim = output_dim
+
+  def __call__(self, q_data, m_data, q_mask):
+    """"""Builds GlobalAttention module.
+
+    Arguments:
+      q_data: A tensor of queries with size [batch_size, N_queries,
+        q_channels]
+      m_data: A tensor of memories from which the keys and values
+        projected. Size [batch_size, N_keys, m_channels]
+      q_mask: A binary mask for q_data with zeros in the padded sequence
+        elements and ones otherwise. Size [batch_size, N_queries, q_channels]
+        (or broadcastable to this shape).
+
+    Returns:
+      A float32 tensor of size [batch_size, N_queries, output_dim].
+    """"""
+    # Sensible default for when the config keys are missing
+    key_dim = self.config.get('key_dim', int(q_data.shape[-1]))
+    value_dim = self.config.get('value_dim', int(m_data.shape[-1]))
+    num_head = self.config.num_head
+    assert key_dim % num_head == 0
+    assert value_dim % num_head == 0
+    key_dim = key_dim // num_head
+    value_dim = value_dim // num_head
+
+    q_weights = hk.get_parameter(
+        'query_w', shape=(q_data.shape[-1], num_head, key_dim),
+        dtype=q_data.dtype,
+        init=glorot_uniform())
+    k_weights = hk.get_parameter(
+        'key_w', shape=(m_data.shape[-1], key_dim),
+        dtype=q_data.dtype,
+        init=glorot_uniform())
+    v_weights = hk.get_parameter(
+        'value_w', shape=(m_data.shape[-1], value_dim),
+        dtype=q_data.dtype,
+        init=glorot_uniform())
+
+    v = jnp.einsum('bka,ac->bkc', m_data, v_weights)
+
+    q_avg = utils.mask_mean(q_mask, q_data, axis=1)
+
+    q = jnp.einsum('ba,ahc->bhc', q_avg, q_weights) * key_dim**(-0.5)
+    k = jnp.einsum('bka,ac->bkc', m_data, k_weights)
+    bias = (1e9 * (q_mask[:, None, :, 0] - 1.))
+    logits = jnp.einsum('bhc,bkc->bhk', q, k) + bias
+    weights = jax.nn.softmax(logits)
+    weighted_avg = jnp.einsum('bhk,bkc->bhc', weights, v)
+
+    if self.global_config.zero_init:
+      init = hk.initializers.Constant(0.0)
+    else:
+      init = glorot_uniform()
+
+    o_weights = hk.get_parameter(
+        'output_w', shape=(num_head, value_dim, self.output_dim),
+        dtype=q_data.dtype,
+        init=init)
+    o_bias = hk.get_parameter(
+        'output_b', shape=(self.output_dim,),
+        dtype=q_data.dtype,
+        init=hk.initializers.Constant(0.0))
+
+    if self.config.gating:
+      gating_weights = hk.get_parameter(
+          'gating_w',
+          shape=(q_data.shape[-1], num_head, value_dim),
+          dtype=q_data.dtype,
+          init=hk.initializers.Constant(0.0))
+      gating_bias = hk.get_parameter(
+          'gating_b',
+          shape=(num_head, value_dim),
+          dtype=q_data.dtype,
+          init=hk.initializers.Constant(1.0))
+
+      gate_values = jnp.einsum('bqc, chv->bqhv', q_data, gating_weights)
+      gate_values = jax.nn.sigmoid(gate_values + gating_bias)
+      weighted_avg = weighted_avg[:, None] * gate_values
+      output = jnp.einsum('bqhc,hco->bqo', weighted_avg, o_weights) + o_bias
+    else:
+      output = jnp.einsum('bhc,hco->bo', weighted_avg, o_weights) + o_bias
+      output = output[:, None]
+    return output
+
+
+class MSARowAttentionWithPairBias(hk.Module):
+  """"""MSA per-row attention biased by the pair representation.
+
+  Jumper et al. (2021) Suppl. Alg. 7 ""MSARowAttentionWithPairBias""
+  """"""
+
+  def __init__(self, config, global_config,
+               name='msa_row_attention_with_pair_bias'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               msa_act,
+               msa_mask,
+               pair_act,
+               is_training=False):
+    """"""Builds MSARowAttentionWithPairBias module.
+
+    Arguments:
+      msa_act: [N_seq, N_res, c_m] MSA representation.
+      msa_mask: [N_seq, N_res] mask of non-padded regions.
+      pair_act: [N_res, N_res, c_z] pair representation.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to msa_act, shape [N_seq, N_res, c_m].
+    """"""
+    c = self.config
+
+    assert len(msa_act.shape) == 3
+    assert len(msa_mask.shape) == 2
+    assert c.orientation == 'per_row'
+
+    bias = (1e9 * (msa_mask - 1.))[:, None, None, :]
+    assert len(bias.shape) == 4
+
+    msa_act = common_modules.LayerNorm(
+        axis=[-1], create_scale=True, create_offset=True, name='query_norm')(
+            msa_act)
+
+    pair_act = common_modules.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='feat_2d_norm')(
+            pair_act)
+
+    init_factor = 1. / jnp.sqrt(int(pair_act.shape[-1]))
+    weights = hk.get_parameter(
+        'feat_2d_weights',
+        shape=(pair_act.shape[-1], c.num_head),
+        dtype=msa_act.dtype,
+        init=hk.initializers.RandomNormal(stddev=init_factor))
+    nonbatched_bias = jnp.einsum('qkc,ch->hqk', pair_act, weights)
+
+    attn_mod = Attention(
+        c, self.global_config, msa_act.shape[-1])
+    msa_act = mapping.inference_subbatch(
+        attn_mod,
+        self.global_config.subbatch_size,
+        batched_args=[msa_act, msa_act, bias],
+        nonbatched_args=[nonbatched_bias],
+        low_memory=not is_training)
+
+    return msa_act
+
+
+class MSAColumnAttention(hk.Module):
+  """"""MSA per-column attention.
+
+  Jumper et al. (2021) Suppl. Alg. 8 ""MSAColumnAttention""
+  """"""
+
+  def __init__(self, config, global_config, name='msa_column_attention'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               msa_act,
+               msa_mask,
+               is_training=False):
+    """"""Builds MSAColumnAttention module.
+
+    Arguments:
+      msa_act: [N_seq, N_res, c_m] MSA representation.
+      msa_mask: [N_seq, N_res] mask of non-padded regions.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to msa_act, shape [N_seq, N_res, c_m]
+    """"""
+    c = self.config
+
+    assert len(msa_act.shape) == 3
+    assert len(msa_mask.shape) == 2
+    assert c.orientation == 'per_column'
+
+    msa_act = jnp.swapaxes(msa_act, -2, -3)
+    msa_mask = jnp.swapaxes(msa_mask, -1, -2)
+
+    bias = (1e9 * (msa_mask - 1.))[:, None, None, :]
+    assert len(bias.shape) == 4
+
+    msa_act = common_modules.LayerNorm(
+        axis=[-1], create_scale=True, create_offset=True, name='query_norm')(
+            msa_act)
+
+    attn_mod = Attention(
+        c, self.global_config, msa_act.shape[-1])
+    msa_act = mapping.inference_subbatch(
+        attn_mod,
+        self.global_config.subbatch_size,
+        batched_args=[msa_act, msa_act, bias],
+        nonbatched_args=[],
+        low_memory=not is_training)
+
+    msa_act = jnp.swapaxes(msa_act, -2, -3)
+
+    return msa_act
+
+
+class MSAColumnGlobalAttention(hk.Module):
+  """"""MSA per-column global attention.
+
+  Jumper et al. (2021) Suppl. Alg. 19 ""MSAColumnGlobalAttention""
+  """"""
+
+  def __init__(self, config, global_config, name='msa_column_global_attention'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               msa_act,
+               msa_mask,
+               is_training=False):
+    """"""Builds MSAColumnGlobalAttention module.
+
+    Arguments:
+      msa_act: [N_seq, N_res, c_m] MSA representation.
+      msa_mask: [N_seq, N_res] mask of non-padded regions.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to msa_act, shape [N_seq, N_res, c_m].
+    """"""
+    c = self.config
+
+    assert len(msa_act.shape) == 3
+    assert len(msa_mask.shape) == 2
+    assert c.orientation == 'per_column'
+
+    msa_act = jnp.swapaxes(msa_act, -2, -3)
+    msa_mask = jnp.swapaxes(msa_mask, -1, -2)
+
+    bias = (1e9 * (msa_mask - 1.))[:, None, None, :]
+    assert len(bias.shape) == 4
+
+    msa_act = common_modules.LayerNorm(
+        axis=[-1], create_scale=True, create_offset=True, name='query_norm')(
+            msa_act)
+
+    attn_mod = GlobalAttention(
+        c, self.global_config, msa_act.shape[-1],
+        name='attention')
+    # [N_seq, N_res, 1]
+    msa_mask = jnp.expand_dims(msa_mask, axis=-1)
+    msa_act = mapping.inference_subbatch(
+        attn_mod,
+        self.global_config.subbatch_size,
+        batched_args=[msa_act, msa_act, msa_mask],
+        nonbatched_args=[],
+        low_memory=not is_training)
+
+    msa_act = jnp.swapaxes(msa_act, -2, -3)
+
+    return msa_act
+
+
+class TriangleAttention(hk.Module):
+  """"""Triangle Attention.
+
+  Jumper et al. (2021) Suppl. Alg. 13 ""TriangleAttentionStartingNode""
+  Jumper et al. (2021) Suppl. Alg. 14 ""TriangleAttentionEndingNode""
+  """"""
+
+  def __init__(self, config, global_config, name='triangle_attention'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, pair_act, pair_mask, is_training=False):
+    """"""Builds TriangleAttention module.
+
+    Arguments:
+      pair_act: [N_res, N_res, c_z] pair activations tensor
+      pair_mask: [N_res, N_res] mask of non-padded regions in the tensor.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to pair_act, shape [N_res, N_res, c_z].
+    """"""
+    c = self.config
+
+    assert len(pair_act.shape) == 3
+    assert len(pair_mask.shape) == 2
+    assert c.orientation in ['per_row', 'per_column']
+
+    if c.orientation == 'per_column':
+      pair_act = jnp.swapaxes(pair_act, -2, -3)
+      pair_mask = jnp.swapaxes(pair_mask, -1, -2)
+
+    bias = (1e9 * (pair_mask - 1.))[:, None, None, :]
+    assert len(bias.shape) == 4
+
+    pair_act = common_modules.LayerNorm(
+        axis=[-1], create_scale=True, create_offset=True, name='query_norm')(
+            pair_act)
+
+    init_factor = 1. / jnp.sqrt(int(pair_act.shape[-1]))
+    weights = hk.get_parameter(
+        'feat_2d_weights',
+        shape=(pair_act.shape[-1], c.num_head),
+        dtype=pair_act.dtype,
+        init=hk.initializers.RandomNormal(stddev=init_factor))
+    nonbatched_bias = jnp.einsum('qkc,ch->hqk', pair_act, weights)
+
+    attn_mod = Attention(
+        c, self.global_config, pair_act.shape[-1])
+    pair_act = mapping.inference_subbatch(
+        attn_mod,
+        self.global_config.subbatch_size,
+        batched_args=[pair_act, pair_act, bias],
+        nonbatched_args=[nonbatched_bias],
+        low_memory=not is_training)
+
+    if c.orientation == 'per_column':
+      pair_act = jnp.swapaxes(pair_act, -2, -3)
+
+    return pair_act
+
+
+class MaskedMsaHead(hk.Module):
+  """"""Head to predict MSA at the masked locations.
+
+  The MaskedMsaHead employs a BERT-style objective to reconstruct a masked
+  version of the full MSA, based on a linear projection of
+  the MSA representation.
+  Jumper et al. (2021) Suppl. Sec. 1.9.9 ""Masked MSA prediction""
+  """"""
+
+  def __init__(self, config, global_config, name='masked_msa_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+    if global_config.multimer_mode:
+      self.num_output = len(residue_constants.restypes_with_x_and_gap)
+    else:
+      self.num_output = config.num_output
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds MaskedMsaHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'msa': MSA representation, shape [N_seq, N_res, c_m].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing:
+        * 'logits': logits of shape [N_seq, N_res, N_aatype] with
+            (unnormalized) log probabilies of predicted aatype at position.
+    """"""
+    del batch
+    logits = common_modules.Linear(
+        self.num_output,
+        initializer=utils.final_init(self.global_config),
+        name='logits')(
+            representations['msa'])
+    return dict(logits=logits)
+
+  def loss(self, value, batch):
+    errors = softmax_cross_entropy(
+        labels=jax.nn.one_hot(batch['true_msa'], num_classes=self.num_output),
+        logits=value['logits'])
+    loss = (jnp.sum(errors * batch['bert_mask'], axis=(-2, -1)) /
+            (1e-8 + jnp.sum(batch['bert_mask'], axis=(-2, -1))))
+    return {'loss': loss}
+
+
+class PredictedLDDTHead(hk.Module):
+  """"""Head to predict the per-residue LDDT to be used as a confidence measure.
+
+  Jumper et al. (2021) Suppl. Sec. 1.9.6 ""Model confidence prediction (pLDDT)""
+  Jumper et al. (2021) Suppl. Alg. 29 ""predictPerResidueLDDT_Ca""
+  """"""
+
+  def __init__(self, config, global_config, name='predicted_lddt_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds PredictedLDDTHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'structure_module': Single representation from the structure module,
+             shape [N_res, c_s].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing :
+        * 'logits': logits of shape [N_res, N_bins] with
+            (unnormalized) log probabilies of binned predicted lDDT.
+    """"""
+    act = representations['structure_module']
+
+    act = common_modules.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='input_layer_norm')(
+            act)
+
+    act = common_modules.Linear(
+        self.config.num_channels,
+        initializer='relu',
+        name='act_0')(
+            act)
+    act = jax.nn.relu(act)
+
+    act = common_modules.Linear(
+        self.config.num_channels,
+        initializer='relu',
+        name='act_1')(
+            act)
+    act = jax.nn.relu(act)
+
+    logits = common_modules.Linear(
+        self.config.num_bins,
+        initializer=utils.final_init(self.global_config),
+        name='logits')(
+            act)
+    # Shape (batch_size, num_res, num_bins)
+    return dict(logits=logits)
+
+  def loss(self, value, batch):
+    # Shape (num_res, 37, 3)
+    pred_all_atom_pos = value['structure_module']['final_atom_positions']
+    # Shape (num_res, 37, 3)
+    true_all_atom_pos = batch['all_atom_positions']
+    # Shape (num_res, 37)
+    all_atom_mask = batch['all_atom_mask']
+
+    # Shape (num_res,)
+    lddt_ca = lddt.lddt(
+        # Shape (batch_size, num_res, 3)
+        predicted_points=pred_all_atom_pos[None, :, 1, :],
+        # Shape (batch_size, num_res, 3)
+        true_points=true_all_atom_pos[None, :, 1, :],
+        # Shape (batch_size, num_res, 1)
+        true_points_mask=all_atom_mask[None, :, 1:2].astype(jnp.float32),
+        cutoff=15.,
+        per_residue=True)
+    lddt_ca = jax.lax.stop_gradient(lddt_ca)
+
+    num_bins = self.config.num_bins
+    bin_index = jnp.floor(lddt_ca * num_bins).astype(jnp.int32)
+
+    # protect against out of range for lddt_ca == 1
+    bin_index = jnp.minimum(bin_index, num_bins - 1)
+    lddt_ca_one_hot = jax.nn.one_hot(bin_index, num_classes=num_bins)
+
+    # Shape (num_res, num_channel)
+    logits = value['predicted_lddt']['logits']
+    errors = softmax_cross_entropy(labels=lddt_ca_one_hot, logits=logits)
+
+    # Shape (num_res,)
+    mask_ca = all_atom_mask[:, residue_constants.atom_order['CA']]
+    mask_ca = mask_ca.astype(jnp.float32)
+    loss = jnp.sum(errors * mask_ca) / (jnp.sum(mask_ca) + 1e-8)
+
+    if self.config.filter_by_resolution:
+      # NMR & distillation have resolution = 0
+      loss *= ((batch['resolution'] >= self.config.min_resolution)
+               & (batch['resolution'] <= self.config.max_resolution)).astype(
+                   jnp.float32)
+
+    output = {'loss': loss}
+    return output
+
+
+class PredictedAlignedErrorHead(hk.Module):
+  """"""Head to predict the distance errors in the backbone alignment frames.
+
+  Can be used to compute predicted TM-Score.
+  Jumper et al. (2021) Suppl. Sec. 1.9.7 ""TM-score prediction""
+  """"""
+
+  def __init__(self, config, global_config,
+               name='predicted_aligned_error_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds PredictedAlignedErrorHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'pair': pair representation, shape [N_res, N_res, c_z].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing:
+        * logits: logits for aligned error, shape [N_res, N_res, N_bins].
+        * bin_breaks: array containing bin breaks, shape [N_bins - 1].
+    """"""
+
+    act = representations['pair']
+
+    # Shape (num_res, num_res, num_bins)
+    logits = common_modules.Linear(
+        self.config.num_bins,
+        initializer=utils.final_init(self.global_config),
+        name='logits')(act)
+    # Shape (num_bins,)
+    breaks = jnp.linspace(
+        0., self.config.max_error_bin, self.config.num_bins - 1)
+    return dict(logits=logits, breaks=breaks)
+
+  def loss(self, value, batch):
+    # Shape (num_res, 7)
+    predicted_affine = quat_affine.QuatAffine.from_tensor(
+        value['structure_module']['final_affines'])
+    # Shape (num_res, 7)
+    true_affine = quat_affine.QuatAffine.from_tensor(
+        batch['backbone_affine_tensor'])
+    # Shape (num_res)
+    mask = batch['backbone_affine_mask']
+    # Shape (num_res, num_res)
+    square_mask = mask[:, None] * mask[None, :]
+    num_bins = self.config.num_bins
+    # (1, num_bins - 1)
+    breaks = value['predicted_aligned_error']['breaks']
+    # (1, num_bins)
+    logits = value['predicted_aligned_error']['logits']
+
+    # Compute the squared error for each alignment.
+    def _local_frame_points(affine):
+      points = [jnp.expand_dims(x, axis=-2) for x in affine.translation]
+      return affine.invert_point(points, extra_dims=1)
+    error_dist2_xyz = [
+        jnp.square(a - b)
+        for a, b in zip(_local_frame_points(predicted_affine),
+                        _local_frame_points(true_affine))]
+    error_dist2 = sum(error_dist2_xyz)
+    # Shape (num_res, num_res)
+    # First num_res are alignment frames, second num_res are the residues.
+    error_dist2 = jax.lax.stop_gradient(error_dist2)
+
+    sq_breaks = jnp.square(breaks)
+    true_bins = jnp.sum((
+        error_dist2[..., None] > sq_breaks).astype(jnp.int32), axis=-1)
+
+    errors = softmax_cross_entropy(
+        labels=jax.nn.one_hot(true_bins, num_bins, axis=-1), logits=logits)
+
+    loss = (jnp.sum(errors * square_mask, axis=(-2, -1)) /
+            (1e-8 + jnp.sum(square_mask, axis=(-2, -1))))
+
+    if self.config.filter_by_resolution:
+      # NMR & distillation have resolution = 0
+      loss *= ((batch['resolution'] >= self.config.min_resolution)
+               & (batch['resolution'] <= self.config.max_resolution)).astype(
+                   jnp.float32)
+
+    output = {'loss': loss}
+    return output
+
+
+class ExperimentallyResolvedHead(hk.Module):
+  """"""Predicts if an atom is experimentally resolved in a high-res structure.
+
+  Only trained on high-resolution X-ray crystals & cryo-EM.
+  Jumper et al. (2021) Suppl. Sec. 1.9.10 '""Experimentally resolved"" prediction'
+  """"""
+
+  def __init__(self, config, global_config,
+               name='experimentally_resolved_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds ExperimentallyResolvedHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'single': Single representation, shape [N_res, c_s].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing:
+        * 'logits': logits of shape [N_res, 37],
+            log probability that an atom is resolved in atom37 representation,
+            can be converted to probability by applying sigmoid.
+    """"""
+    logits = common_modules.Linear(
+        37,  # atom_exists.shape[-1]
+        initializer=utils.final_init(self.global_config),
+        name='logits')(representations['single'])
+    return dict(logits=logits)
+
+  def loss(self, value, batch):
+    logits = value['logits']
+    assert len(logits.shape) == 2
+
+    # Does the atom appear in the amino acid?
+    atom_exists = batch['atom37_atom_exists']
+    # Is the atom resolved in the experiment? Subset of atom_exists,
+    # *except for OXT*
+    all_atom_mask = batch['all_atom_mask'].astype(jnp.float32)
+
+    xent = sigmoid_cross_entropy(labels=all_atom_mask, logits=logits)
+    loss = jnp.sum(xent * atom_exists) / (1e-8 + jnp.sum(atom_exists))
+
+    if self.config.filter_by_resolution:
+      # NMR & distillation examples have resolution = 0.
+      loss *= ((batch['resolution'] >= self.config.min_resolution)
+               & (batch['resolution'] <= self.config.max_resolution)).astype(
+                   jnp.float32)
+
+    output = {'loss': loss}
+    return output
+
+
+def _layer_norm(axis=-1, name='layer_norm'):
+  return common_modules.LayerNorm(
+      axis=axis,
+      create_scale=True,
+      create_offset=True,
+      eps=1e-5,
+      use_fast_variance=True,
+      scale_init=hk.initializers.Constant(1.),
+      offset_init=hk.initializers.Constant(0.),
+      param_axis=axis,
+      name=name)
+
+
+class TriangleMultiplication(hk.Module):
+  """"""Triangle multiplication layer (""outgoing"" or ""incoming"").
+
+  Jumper et al. (2021) Suppl. Alg. 11 ""TriangleMultiplicationOutgoing""
+  Jumper et al. (2021) Suppl. Alg. 12 ""TriangleMultiplicationIncoming""
+  """"""
+
+  def __init__(self, config, global_config, name='triangle_multiplication'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, left_act, left_mask, is_training=True):
+    """"""Builds TriangleMultiplication module.
+
+    Arguments:
+      left_act: Pair activations, shape [N_res, N_res, c_z]
+      left_mask: Pair mask, shape [N_res, N_res].
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Outputs, same shape/type as left_act.
+    """"""
+    del is_training
+
+    if self.config.fuse_projection_weights:
+      return self._fused_triangle_multiplication(left_act, left_mask)
+    else:
+      return self._triangle_multiplication(left_act, left_mask)
+
+  @hk.transparent
+  def _triangle_multiplication(self, left_act, left_mask):
+    """"""Implementation of TriangleMultiplication used in AF2 and AF-M<2.3.""""""
+    c = self.config
+    gc = self.global_config
+
+    mask = left_mask[..., None]
+
+    act = common_modules.LayerNorm(axis=[-1], create_scale=True, create_offset=True,
+                       name='layer_norm_input')(left_act)
+    input_act = act
+
+    left_projection = common_modules.Linear(
+        c.num_intermediate_channel,
+        name='left_projection')
+    left_proj_act = mask * left_projection(act)
+
+    right_projection = common_modules.Linear(
+        c.num_intermediate_channel,
+        name='right_projection')
+    right_proj_act = mask * right_projection(act)
+
+    left_gate_values = jax.nn.sigmoid(common_modules.Linear(
+        c.num_intermediate_channel,
+        bias_init=1.,
+        initializer=utils.final_init(gc),
+        name='left_gate')(act))
+
+    right_gate_values = jax.nn.sigmoid(common_modules.Linear(
+        c.num_intermediate_channel,
+        bias_init=1.,
+        initializer=utils.final_init(gc),
+        name='right_gate')(act))
+
+    left_proj_act *= left_gate_values
+    right_proj_act *= right_gate_values
+
+    # ""Outgoing"" edges equation: 'ikc,jkc->ijc'
+    # ""Incoming"" edges equation: 'kjc,kic->ijc'
+    # Note on the Suppl. Alg. 11 & 12 notation:
+    # For the ""outgoing"" edges, a = left_proj_act and b = right_proj_act
+    # For the ""incoming"" edges, it's swapped:
+    #   b = left_proj_act and a = right_proj_act
+    act = jnp.einsum(c.equation, left_proj_act, right_proj_act)
+
+    act = common_modules.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='center_layer_norm')(
+            act)
+
+    output_channel = int(input_act.shape[-1])
+
+    act = common_modules.Linear(
+        output_channel,
+        initializer=utils.final_init(gc),
+        name='output_projection')(act)
+
+    gate_values = jax.nn.sigmoid(common_modules.Linear(
+        output_channel,
+        bias_init=1.,
+        initializer=utils.final_init(gc),
+        name='gating_linear')(input_act))
+    act *= gate_values
+
+    return act
+
+  @hk.transparent
+  def _fused_triangle_multiplication(self, left_act, left_mask):
+    """"""TriangleMultiplication with fused projection weights.""""""
+    mask = left_mask[..., None]
+    c = self.config
+    gc = self.global_config
+
+    left_act = _layer_norm(axis=-1, name='left_norm_input')(left_act)
+
+    # Both left and right projections are fused into projection.
+    projection = common_modules.Linear(
+        2*c.num_intermediate_channel, name='projection')
+    proj_act = mask * projection(left_act)
+
+    # Both left + right gate are fused into gate_values.
+    gate_values = common_modules.Linear(
+        2 * c.num_intermediate_channel,
+        name='gate',
+        bias_init=1.,
+        initializer=utils.final_init(gc))(left_act)
+    proj_act *= jax.nn.sigmoid(gate_values)
+
+    left_proj_act = proj_act[:, :, :c.num_intermediate_channel]
+    right_proj_act = proj_act[:, :, c.num_intermediate_channel:]
+    act = jnp.einsum(c.equation, left_proj_act, right_proj_act)
+
+    act = _layer_norm(axis=-1, name='center_norm')(act)
+
+    output_channel = int(left_act.shape[-1])
+
+    act = common_modules.Linear(
+        output_channel,
+        initializer=utils.final_init(gc),
+        name='output_projection')(act)
+
+    gate_values = common_modules.Linear(
+        output_channel,
+        bias_init=1.,
+        initializer=utils.final_init(gc),
+        name='gating_linear')(left_act)
+    act *= jax.nn.sigmoid(gate_values)
+
+    return act
+
+
+class DistogramHead(hk.Module):
+  """"""Head to predict a distogram.
+
+  Jumper et al. (2021) Suppl. Sec. 1.9.8 ""Distogram prediction""
+  """"""
+
+  def __init__(self, config, global_config, name='distogram_head'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, representations, batch, is_training):
+    """"""Builds DistogramHead module.
+
+    Arguments:
+      representations: Dictionary of representations, must contain:
+        * 'pair': pair representation, shape [N_res, N_res, c_z].
+      batch: Batch, unused.
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Dictionary containing:
+        * logits: logits for distogram, shape [N_res, N_res, N_bins].
+        * bin_breaks: array containing bin breaks, shape [N_bins - 1,].
+    """"""
+    half_logits = common_modules.Linear(
+        self.config.num_bins,
+        initializer=utils.final_init(self.global_config),
+        name='half_logits')(
+            representations['pair'])
+
+    logits = half_logits + jnp.swapaxes(half_logits, -2, -3)
+    breaks = jnp.linspace(self.config.first_break, self.config.last_break,
+                          self.config.num_bins - 1)
+
+    return dict(logits=logits, bin_edges=breaks)
+
+  def loss(self, value, batch):
+    return _distogram_log_loss(value['logits'], value['bin_edges'],
+                               batch, self.config.num_bins)
+
+
+def _distogram_log_loss(logits, bin_edges, batch, num_bins):
+  """"""Log loss of a distogram.""""""
+
+  assert len(logits.shape) == 3
+  positions = batch['pseudo_beta']
+  mask = batch['pseudo_beta_mask']
+
+  assert positions.shape[-1] == 3
+
+  sq_breaks = jnp.square(bin_edges)
+
+  dist2 = jnp.sum(
+      jnp.square(
+          jnp.expand_dims(positions, axis=-2) -
+          jnp.expand_dims(positions, axis=-3)),
+      axis=-1,
+      keepdims=True)
+
+  true_bins = jnp.sum(dist2 > sq_breaks, axis=-1)
+
+  errors = softmax_cross_entropy(
+      labels=jax.nn.one_hot(true_bins, num_bins), logits=logits)
+
+  square_mask = jnp.expand_dims(mask, axis=-2) * jnp.expand_dims(mask, axis=-1)
+
+  avg_error = (
+      jnp.sum(errors * square_mask, axis=(-2, -1)) /
+      (1e-6 + jnp.sum(square_mask, axis=(-2, -1))))
+  dist2 = dist2[..., 0]
+  return dict(loss=avg_error, true_dist=jnp.sqrt(1e-6 + dist2))
+
+
+class OuterProductMean(hk.Module):
+  """"""Computes mean outer product.
+
+  Jumper et al. (2021) Suppl. Alg. 10 ""OuterProductMean""
+  """"""
+
+  def __init__(self,
+               config,
+               global_config,
+               num_output_channel,
+               name='outer_product_mean'):
+    super().__init__(name=name)
+    self.global_config = global_config
+    self.config = config
+    self.num_output_channel = num_output_channel
+
+  def __call__(self, act, mask, is_training=True):
+    """"""Builds OuterProductMean module.
+
+    Arguments:
+      act: MSA representation, shape [N_seq, N_res, c_m].
+      mask: MSA mask, shape [N_seq, N_res].
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      Update to pair representation, shape [N_res, N_res, c_z].
+    """"""
+    gc = self.global_config
+    c = self.config
+
+    mask = mask[..., None]
+    act = common_modules.LayerNorm([-1], True, True, name='layer_norm_input')(act)
+
+    left_act = mask * common_modules.Linear(
+        c.num_outer_channel,
+        initializer='linear',
+        name='left_projection')(
+            act)
+
+    right_act = mask * common_modules.Linear(
+        c.num_outer_channel,
+        initializer='linear',
+        name='right_projection')(
+            act)
+
+    if gc.zero_init:
+      init_w = hk.initializers.Constant(0.0)
+    else:
+      init_w = hk.initializers.VarianceScaling(scale=2., mode='fan_in')
+
+    output_w = hk.get_parameter(
+        'output_w',
+        shape=(c.num_outer_channel, c.num_outer_channel,
+               self.num_output_channel),
+        dtype=act.dtype,
+        init=init_w)
+    output_b = hk.get_parameter(
+        'output_b', shape=(self.num_output_channel,),
+        dtype=act.dtype,
+        init=hk.initializers.Constant(0.0))
+
+    def compute_chunk(left_act):
+      # This is equivalent to
+      #
+      # act = jnp.einsum('abc,ade->dceb', left_act, right_act)
+      # act = jnp.einsum('dceb,cef->bdf', act, output_w) + output_b
+      #
+      # but faster.
+      left_act = jnp.transpose(left_act, [0, 2, 1])
+      act = jnp.einsum('acb,ade->dceb', left_act, right_act)
+      act = jnp.einsum('dceb,cef->dbf', act, output_w) + output_b
+      return jnp.transpose(act, [1, 0, 2])
+
+    act = mapping.inference_subbatch(
+        compute_chunk,
+        c.chunk_size,
+        batched_args=[left_act],
+        nonbatched_args=[],
+        low_memory=True,
+        input_subbatch_dim=1,
+        output_subbatch_dim=0)
+
+    epsilon = 1e-3
+    norm = jnp.einsum('abc,adc->bdc', mask, mask)
+    act /= epsilon + norm
+
+    return act
+
+
+def dgram_from_positions(positions, num_bins, min_bin, max_bin):
+  """"""Compute distogram from amino acid positions.
+
+  Arguments:
+    positions: [N_res, 3] Position coordinates.
+    num_bins: The number of bins in the distogram.
+    min_bin: The left edge of the first bin.
+    max_bin: The left edge of the final bin. The final bin catches
+        everything larger than `max_bin`.
+
+  Returns:
+    Distogram with the specified number of bins.
+  """"""
+
+  def squared_difference(x, y):
+    return jnp.square(x - y)
+
+  lower_breaks = jnp.linspace(min_bin, max_bin, num_bins)
+  lower_breaks = jnp.square(lower_breaks)
+  upper_breaks = jnp.concatenate([lower_breaks[1:],
+                                  jnp.array([1e8], dtype=jnp.float32)], axis=-1)
+  dist2 = jnp.sum(
+      squared_difference(
+          jnp.expand_dims(positions, axis=-2),
+          jnp.expand_dims(positions, axis=-3)),
+      axis=-1, keepdims=True)
+
+  dgram = ((dist2 > lower_breaks).astype(jnp.float32) *
+           (dist2 < upper_breaks).astype(jnp.float32))
+  return dgram
+
+
+def pseudo_beta_fn(aatype, all_atom_positions, all_atom_masks):
+  """"""Create pseudo beta features.""""""
+
+  is_gly = jnp.equal(aatype, residue_constants.restype_order['G'])
+  ca_idx = residue_constants.atom_order['CA']
+  cb_idx = residue_constants.atom_order['CB']
+  pseudo_beta = jnp.where(
+      jnp.tile(is_gly[..., None], [1] * len(is_gly.shape) + [3]),
+      all_atom_positions[..., ca_idx, :],
+      all_atom_positions[..., cb_idx, :])
+
+  if all_atom_masks is not None:
+    pseudo_beta_mask = jnp.where(
+        is_gly, all_atom_masks[..., ca_idx], all_atom_masks[..., cb_idx])
+    pseudo_beta_mask = pseudo_beta_mask.astype(jnp.float32)
+    return pseudo_beta, pseudo_beta_mask
+  else:
+    return pseudo_beta
+
+
+class EvoformerIteration(hk.Module):
+  """"""Single iteration (block) of Evoformer stack.
+
+  Jumper et al. (2021) Suppl. Alg. 6 ""EvoformerStack"" lines 2-10
+  """"""
+
+  def __init__(self, config, global_config, is_extra_msa,
+               name='evoformer_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+    self.is_extra_msa = is_extra_msa
+
+  def __call__(self, activations, masks, is_training=True, safe_key=None):
+    """"""Builds EvoformerIteration module.
+
+    Arguments:
+      activations: Dictionary containing activations:
+        * 'msa': MSA activations, shape [N_seq, N_res, c_m].
+        * 'pair': pair activations, shape [N_res, N_res, c_z].
+      masks: Dictionary of masks:
+        * 'msa': MSA mask, shape [N_seq, N_res].
+        * 'pair': pair mask, shape [N_res, N_res].
+      is_training: Whether the module is in training mode.
+      safe_key: prng.SafeKey encapsulating rng key.
+
+    Returns:
+      Outputs, same shape/type as act.
+    """"""
+    c = self.config
+    gc = self.global_config
+
+    msa_act, pair_act = activations['msa'], activations['pair']
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    msa_mask, pair_mask = masks['msa'], masks['pair']
+
+    dropout_wrapper_fn = functools.partial(
+        dropout_wrapper,
+        is_training=is_training,
+        global_config=gc)
+
+    safe_key, *sub_keys = safe_key.split(10)
+    sub_keys = iter(sub_keys)
+
+    outer_module = OuterProductMean(
+        config=c.outer_product_mean,
+        global_config=self.global_config,
+        num_output_channel=int(pair_act.shape[-1]),
+        name='outer_product_mean')
+    if c.outer_product_mean.first:
+      pair_act = dropout_wrapper_fn(
+          outer_module,
+          msa_act,
+          msa_mask,
+          safe_key=next(sub_keys),
+          output_act=pair_act)
+
+    msa_act = dropout_wrapper_fn(
+        MSARowAttentionWithPairBias(
+            c.msa_row_attention_with_pair_bias, gc,
+            name='msa_row_attention_with_pair_bias'),
+        msa_act,
+        msa_mask,
+        safe_key=next(sub_keys),
+        pair_act=pair_act)
+
+    if not self.is_extra_msa:
+      attn_mod = MSAColumnAttention(
+          c.msa_column_attention, gc, name='msa_column_attention')
+    else:
+      attn_mod = MSAColumnGlobalAttention(
+          c.msa_column_attention, gc, name='msa_column_global_attention')
+    msa_act = dropout_wrapper_fn(
+        attn_mod,
+        msa_act,
+        msa_mask,
+        safe_key=next(sub_keys))
+
+    msa_act = dropout_wrapper_fn(
+        Transition(c.msa_transition, gc, name='msa_transition'),
+        msa_act,
+        msa_mask,
+        safe_key=next(sub_keys))
+
+    if not c.outer_product_mean.first:
+      pair_act = dropout_wrapper_fn(
+          outer_module,
+          msa_act,
+          msa_mask,
+          safe_key=next(sub_keys),
+          output_act=pair_act)
+
+    pair_act = dropout_wrapper_fn(
+        TriangleMultiplication(c.triangle_multiplication_outgoing, gc,
+                               name='triangle_multiplication_outgoing'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+    pair_act = dropout_wrapper_fn(
+        TriangleMultiplication(c.triangle_multiplication_incoming, gc,
+                               name='triangle_multiplication_incoming'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    pair_act = dropout_wrapper_fn(
+        TriangleAttention(c.triangle_attention_starting_node, gc,
+                          name='triangle_attention_starting_node'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+    pair_act = dropout_wrapper_fn(
+        TriangleAttention(c.triangle_attention_ending_node, gc,
+                          name='triangle_attention_ending_node'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    pair_act = dropout_wrapper_fn(
+        Transition(c.pair_transition, gc, name='pair_transition'),
+        pair_act,
+        pair_mask,
+        safe_key=next(sub_keys))
+
+    return {'msa': msa_act, 'pair': pair_act}
+
+
+class EmbeddingsAndEvoformer(hk.Module):
+  """"""Embeds the input data and runs Evoformer.
+
+  Produces the MSA, single and pair representations.
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 5-18
+  """"""
+
+  def __init__(self, config, global_config, name='evoformer'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, batch, is_training, safe_key=None):
+
+    c = self.config
+    gc = self.global_config
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    # Embed clustered MSA.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 5
+    # Jumper et al. (2021) Suppl. Alg. 3 ""InputEmbedder""
+    preprocess_1d = common_modules.Linear(
+        c.msa_channel, name='preprocess_1d')(
+            batch['target_feat'])
+
+    preprocess_msa = common_modules.Linear(
+        c.msa_channel, name='preprocess_msa')(
+            batch['msa_feat'])
+
+    msa_activations = jnp.expand_dims(preprocess_1d, axis=0) + preprocess_msa
+
+    left_single = common_modules.Linear(
+        c.pair_channel, name='left_single')(
+            batch['target_feat'])
+    right_single = common_modules.Linear(
+        c.pair_channel, name='right_single')(
+            batch['target_feat'])
+    pair_activations = left_single[:, None] + right_single[None]
+    mask_2d = batch['seq_mask'][:, None] * batch['seq_mask'][None, :]
+
+    # Inject previous outputs for recycling.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 6
+    # Jumper et al. (2021) Suppl. Alg. 32 ""RecyclingEmbedder""
+    if c.recycle_pos:
+      prev_pseudo_beta = pseudo_beta_fn(
+          batch['aatype'], batch['prev_pos'], None)
+      dgram = dgram_from_positions(prev_pseudo_beta, **self.config.prev_pos)
+      pair_activations += common_modules.Linear(
+          c.pair_channel, name='prev_pos_linear')(
+              dgram)
+
+    if c.recycle_features:
+      prev_msa_first_row = common_modules.LayerNorm(
+          axis=[-1],
+          create_scale=True,
+          create_offset=True,
+          name='prev_msa_first_row_norm')(
+              batch['prev_msa_first_row'])
+      msa_activations = msa_activations.at[0].add(prev_msa_first_row)
+
+      pair_activations += common_modules.LayerNorm(
+          axis=[-1],
+          create_scale=True,
+          create_offset=True,
+          name='prev_pair_norm')(
+              batch['prev_pair'])
+
+    # Relative position encoding.
+    # Jumper et al. (2021) Suppl. Alg. 4 ""relpos""
+    # Jumper et al. (2021) Suppl. Alg. 5 ""one_hot""
+    if c.max_relative_feature:
+      # Add one-hot-encoded clipped residue distances to the pair activations.
+      pos = batch['residue_index']
+      offset = pos[:, None] - pos[None, :]
+      rel_pos = jax.nn.one_hot(
+          jnp.clip(
+              offset + c.max_relative_feature,
+              a_min=0,
+              a_max=2 * c.max_relative_feature),
+          2 * c.max_relative_feature + 1)
+      pair_activations += common_modules.Linear(
+          c.pair_channel, name='pair_activiations')(
+              rel_pos)
+
+    # Embed templates into the pair activations.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 9-13
+    if c.template.enabled:
+      template_batch = {k: batch[k] for k in batch if k.startswith('template_')}
+      template_pair_representation = TemplateEmbedding(c.template, gc)(
+          pair_activations,
+          template_batch,
+          mask_2d,
+          is_training=is_training)
+
+      pair_activations += template_pair_representation
+
+    # Embed extra MSA features.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 14-16
+    extra_msa_feat = create_extra_msa_feature(batch)
+    extra_msa_activations = common_modules.Linear(
+        c.extra_msa_channel,
+        name='extra_msa_activations')(
+            extra_msa_feat)
+
+    # Extra MSA Stack.
+    # Jumper et al. (2021) Suppl. Alg. 18 ""ExtraMsaStack""
+    extra_msa_stack_input = {
+        'msa': extra_msa_activations,
+        'pair': pair_activations,
+    }
+
+    extra_msa_stack_iteration = EvoformerIteration(
+        c.evoformer, gc, is_extra_msa=True, name='extra_msa_stack')
+
+    def extra_msa_stack_fn(x):
+      act, safe_key = x
+      safe_key, safe_subkey = safe_key.split()
+      extra_evoformer_output = extra_msa_stack_iteration(
+          activations=act,
+          masks={
+              'msa': batch['extra_msa_mask'],
+              'pair': mask_2d
+          },
+          is_training=is_training,
+          safe_key=safe_subkey)
+      return (extra_evoformer_output, safe_key)
+
+    if gc.use_remat:
+      extra_msa_stack_fn = hk.remat(extra_msa_stack_fn)
+
+    extra_msa_stack = layer_stack.layer_stack(
+        c.extra_msa_stack_num_block)(
+            extra_msa_stack_fn)
+    extra_msa_output, safe_key = extra_msa_stack(
+        (extra_msa_stack_input, safe_key))
+
+    pair_activations = extra_msa_output['pair']
+
+    evoformer_input = {
+        'msa': msa_activations,
+        'pair': pair_activations,
+    }
+
+    evoformer_masks = {'msa': batch['msa_mask'], 'pair': mask_2d}
+
+    # Append num_templ rows to msa_activations with template embeddings.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 7-8
+    if c.template.enabled and c.template.embed_torsion_angles:
+      num_templ, num_res = batch['template_aatype'].shape
+
+      # Embed the templates aatypes.
+      aatype_one_hot = jax.nn.one_hot(batch['template_aatype'], 22, axis=-1)
+
+      # Embed the templates aatype, torsion angles and masks.
+      # Shape (templates, residues, msa_channels)
+      ret = all_atom.atom37_to_torsion_angles(
+          aatype=batch['template_aatype'],
+          all_atom_pos=batch['template_all_atom_positions'],
+          all_atom_mask=batch['template_all_atom_masks'],
+          # Ensure consistent behaviour during testing:
+          placeholder_for_undefined=not gc.zero_init)
+
+      template_features = jnp.concatenate([
+          aatype_one_hot,
+          jnp.reshape(
+              ret['torsion_angles_sin_cos'], [num_templ, num_res, 14]),
+          jnp.reshape(
+              ret['alt_torsion_angles_sin_cos'], [num_templ, num_res, 14]),
+          ret['torsion_angles_mask']], axis=-1)
+
+      template_activations = common_modules.Linear(
+          c.msa_channel,
+          initializer='relu',
+          name='template_single_embedding')(
+              template_features)
+      template_activations = jax.nn.relu(template_activations)
+      template_activations = common_modules.Linear(
+          c.msa_channel,
+          initializer='relu',
+          name='template_projection')(
+              template_activations)
+
+      # Concatenate the templates to the msa.
+      evoformer_input['msa'] = jnp.concatenate(
+          [evoformer_input['msa'], template_activations], axis=0)
+      # Concatenate templates masks to the msa masks.
+      # Use mask from the psi angle, as it only depends on the backbone atoms
+      # from a single residue.
+      torsion_angle_mask = ret['torsion_angles_mask'][:, :, 2]
+      torsion_angle_mask = torsion_angle_mask.astype(
+          evoformer_masks['msa'].dtype)
+      evoformer_masks['msa'] = jnp.concatenate(
+          [evoformer_masks['msa'], torsion_angle_mask], axis=0)
+
+    # Main trunk of the network
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 17-18
+    evoformer_iteration = EvoformerIteration(
+        c.evoformer, gc, is_extra_msa=False, name='evoformer_iteration')
+
+    def evoformer_fn(x):
+      act, safe_key = x
+      safe_key, safe_subkey = safe_key.split()
+      evoformer_output = evoformer_iteration(
+          activations=act,
+          masks=evoformer_masks,
+          is_training=is_training,
+          safe_key=safe_subkey)
+      return (evoformer_output, safe_key)
+
+    if gc.use_remat:
+      evoformer_fn = hk.remat(evoformer_fn)
+
+    evoformer_stack = layer_stack.layer_stack(c.evoformer_num_block)(
+        evoformer_fn)
+    evoformer_output, safe_key = evoformer_stack(
+        (evoformer_input, safe_key))
+
+    msa_activations = evoformer_output['msa']
+    pair_activations = evoformer_output['pair']
+
+    single_activations = common_modules.Linear(
+        c.seq_channel, name='single_activations')(
+            msa_activations[0])
+
+    num_sequences = batch['msa_feat'].shape[0]
+    output = {
+        'single': single_activations,
+        'pair': pair_activations,
+        # Crop away template rows such that they are not used in MaskedMsaHead.
+        'msa': msa_activations[:num_sequences, :, :],
+        'msa_first_row': msa_activations[0],
+    }
+
+    return output
+
+
+class SingleTemplateEmbedding(hk.Module):
+  """"""Embeds a single template.
+
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 9+11
+  """"""
+
+  def __init__(self, config, global_config, name='single_template_embedding'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, query_embedding, batch, mask_2d, is_training):
+    """"""Build the single template embedding.
+
+    Arguments:
+      query_embedding: Query pair representation, shape [N_res, N_res, c_z].
+      batch: A batch of template features (note the template dimension has been
+        stripped out as this module only runs over a single template).
+      mask_2d: Padding mask (Note: this doesn't care if a template exists,
+        unlike the template_pseudo_beta_mask).
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      A template embedding [N_res, N_res, c_z].
+    """"""
+    assert mask_2d.dtype == query_embedding.dtype
+    dtype = query_embedding.dtype
+    num_res = batch['template_aatype'].shape[0]
+    num_channels = (self.config.template_pair_stack
+                    .triangle_attention_ending_node.value_dim)
+    template_mask = batch['template_pseudo_beta_mask']
+    template_mask_2d = template_mask[:, None] * template_mask[None, :]
+    template_mask_2d = template_mask_2d.astype(dtype)
+
+    template_dgram = dgram_from_positions(batch['template_pseudo_beta'],
+                                          **self.config.dgram_features)
+    template_dgram = template_dgram.astype(dtype)
+
+    to_concat = [template_dgram, template_mask_2d[:, :, None]]
+
+    aatype = jax.nn.one_hot(batch['template_aatype'], 22, axis=-1, dtype=dtype)
+
+    to_concat.append(jnp.tile(aatype[None, :, :], [num_res, 1, 1]))
+    to_concat.append(jnp.tile(aatype[:, None, :], [1, num_res, 1]))
+
+    n, ca, c = [residue_constants.atom_order[a] for a in ('N', 'CA', 'C')]
+    rot, trans = quat_affine.make_transform_from_reference(
+        n_xyz=batch['template_all_atom_positions'][:, n],
+        ca_xyz=batch['template_all_atom_positions'][:, ca],
+        c_xyz=batch['template_all_atom_positions'][:, c])
+    affines = quat_affine.QuatAffine(
+        quaternion=quat_affine.rot_to_quat(rot, unstack_inputs=True),
+        translation=trans,
+        rotation=rot,
+        unstack_inputs=True)
+    points = [jnp.expand_dims(x, axis=-2) for x in affines.translation]
+    affine_vec = affines.invert_point(points, extra_dims=1)
+    inv_distance_scalar = jax.lax.rsqrt(
+        1e-6 + sum([jnp.square(x) for x in affine_vec]))
+
+    # Backbone affine mask: whether the residue has C, CA, N
+    # (the template mask defined above only considers pseudo CB).
+    template_mask = (
+        batch['template_all_atom_masks'][..., n] *
+        batch['template_all_atom_masks'][..., ca] *
+        batch['template_all_atom_masks'][..., c])
+    template_mask_2d = template_mask[:, None] * template_mask[None, :]
+
+    inv_distance_scalar *= template_mask_2d.astype(inv_distance_scalar.dtype)
+
+    unit_vector = [(x * inv_distance_scalar)[..., None] for x in affine_vec]
+
+    unit_vector = [x.astype(dtype) for x in unit_vector]
+    template_mask_2d = template_mask_2d.astype(dtype)
+    if not self.config.use_template_unit_vector:
+      unit_vector = [jnp.zeros_like(x) for x in unit_vector]
+    to_concat.extend(unit_vector)
+
+    to_concat.append(template_mask_2d[..., None])
+
+    act = jnp.concatenate(to_concat, axis=-1)
+
+    # Mask out non-template regions so we don't get arbitrary values in the
+    # distogram for these regions.
+    act *= template_mask_2d[..., None]
+
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 9
+    act = common_modules.Linear(
+        num_channels,
+        initializer='relu',
+        name='embedding2d')(
+            act)
+
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" line 11
+    act = TemplatePairStack(
+        self.config.template_pair_stack, self.global_config)(
+            act, mask_2d, is_training)
+
+    act = common_modules.LayerNorm([-1], True, True, name='output_layer_norm')(act)
+    return act
+
+
+class TemplateEmbedding(hk.Module):
+  """"""Embeds a set of templates.
+
+  Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 9-12
+  Jumper et al. (2021) Suppl. Alg. 17 ""TemplatePointwiseAttention""
+  """"""
+
+  def __init__(self, config, global_config, name='template_embedding'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, query_embedding, template_batch, mask_2d, is_training):
+    """"""Build TemplateEmbedding module.
+
+    Arguments:
+      query_embedding: Query pair representation, shape [N_res, N_res, c_z].
+      template_batch: A batch of template features.
+      mask_2d: Padding mask (Note: this doesn't care if a template exists,
+        unlike the template_pseudo_beta_mask).
+      is_training: Whether the module is in training mode.
+
+    Returns:
+      A template embedding [N_res, N_res, c_z].
+    """"""
+
+    num_templates = template_batch['template_mask'].shape[0]
+    num_channels = (self.config.template_pair_stack
+                    .triangle_attention_ending_node.value_dim)
+    num_res = query_embedding.shape[0]
+
+    dtype = query_embedding.dtype
+    template_mask = template_batch['template_mask']
+    template_mask = template_mask.astype(dtype)
+
+    query_num_channels = query_embedding.shape[-1]
+
+    # Make sure the weights are shared across templates by constructing the
+    # embedder here.
+    # Jumper et al. (2021) Suppl. Alg. 2 ""Inference"" lines 9-12
+    template_embedder = SingleTemplateEmbedding(self.config, self.global_config)
+
+    def map_fn(batch):
+      return template_embedder(query_embedding, batch, mask_2d, is_training)
+
+    template_pair_representation = mapping.sharded_map(map_fn, in_axes=0)(
+        template_batch)
+
+    # Cross attend from the query to the templates along the residue
+    # dimension by flattening everything else into the batch dimension.
+    # Jumper et al. (2021) Suppl. Alg. 17 ""TemplatePointwiseAttention""
+    flat_query = jnp.reshape(query_embedding,
+                             [num_res * num_res, 1, query_num_channels])
+
+    flat_templates = jnp.reshape(
+        jnp.transpose(template_pair_representation, [1, 2, 0, 3]),
+        [num_res * num_res, num_templates, num_channels])
+
+    bias = (1e9 * (template_mask[None, None, None, :] - 1.))
+
+    template_pointwise_attention_module = Attention(
+        self.config.attention, self.global_config, query_num_channels)
+    nonbatched_args = [bias]
+    batched_args = [flat_query, flat_templates]
+
+    embedding = mapping.inference_subbatch(
+        template_pointwise_attention_module,
+        self.config.subbatch_size,
+        batched_args=batched_args,
+        nonbatched_args=nonbatched_args,
+        low_memory=not is_training)
+    embedding = jnp.reshape(embedding,
+                            [num_res, num_res, query_num_channels])
+
+    # No gradients if no templates.
+    embedding *= (jnp.sum(template_mask) > 0.).astype(embedding.dtype)
+
+    return embedding
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/folding.py",".py","37264","1010","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Modules and utilities for the structure module.""""""
+
+import functools
+from typing import Dict
+from alphafold.common import residue_constants
+from alphafold.model import all_atom
+from alphafold.model import common_modules
+from alphafold.model import prng
+from alphafold.model import quat_affine
+from alphafold.model import r3
+from alphafold.model import utils
+import haiku as hk
+import jax
+import jax.numpy as jnp
+import ml_collections
+import numpy as np
+
+
+def squared_difference(x, y):
+  return jnp.square(x - y)
+
+
+class InvariantPointAttention(hk.Module):
+  """"""Invariant Point attention module.
+
+  The high-level idea is that this attention module works over a set of points
+  and associated orientations in 3D space (e.g. protein residues).
+
+  Each residue outputs a set of queries and keys as points in their local
+  reference frame.  The attention is then defined as the euclidean distance
+  between the queries and keys in the global frame.
+
+  Jumper et al. (2021) Suppl. Alg. 22 ""InvariantPointAttention""
+  """"""
+
+  def __init__(self,
+               config,
+               global_config,
+               dist_epsilon=1e-8,
+               name='invariant_point_attention'):
+    """"""Initialize.
+
+    Args:
+      config: Structure Module Config
+      global_config: Global Config of Model.
+      dist_epsilon: Small value to avoid NaN in distance calculation.
+      name: Haiku Module name.
+    """"""
+    super().__init__(name=name)
+
+    self._dist_epsilon = dist_epsilon
+    self._zero_initialize_last = global_config.zero_init
+
+    self.config = config
+
+    self.global_config = global_config
+
+  def __call__(self, inputs_1d, inputs_2d, mask, affine):
+    """"""Compute geometry-aware attention.
+
+    Given a set of query residues (defined by affines and associated scalar
+    features), this function computes geometry-aware attention between the
+    query residues and target residues.
+
+    The residues produce points in their local reference frame, which
+    are converted into the global frame in order to compute attention via
+    euclidean distance.
+
+    Equivalently, the target residues produce points in their local frame to be
+    used as attention values, which are converted into the query residues'
+    local frames.
+
+    Args:
+      inputs_1d: (N, C) 1D input embedding that is the basis for the
+        scalar queries.
+      inputs_2d: (N, M, C') 2D input embedding, used for biases and values.
+      mask: (N, 1) mask to indicate which elements of inputs_1d participate
+        in the attention.
+      affine: QuatAffine object describing the position and orientation of
+        every element in inputs_1d.
+
+    Returns:
+      Transformation of the input embedding.
+    """"""
+    num_residues, _ = inputs_1d.shape
+
+    # Improve readability by removing a large number of 'self's.
+    num_head = self.config.num_head
+    num_scalar_qk = self.config.num_scalar_qk
+    num_point_qk = self.config.num_point_qk
+    num_scalar_v = self.config.num_scalar_v
+    num_point_v = self.config.num_point_v
+    num_output = self.config.num_channel
+
+    assert num_scalar_qk > 0
+    assert num_point_qk > 0
+    assert num_point_v > 0
+
+    # Construct scalar queries of shape:
+    # [num_query_residues, num_head, num_points]
+    q_scalar = common_modules.Linear(
+        num_head * num_scalar_qk, name='q_scalar')(
+            inputs_1d)
+    q_scalar = jnp.reshape(
+        q_scalar, [num_residues, num_head, num_scalar_qk])
+
+    # Construct scalar keys/values of shape:
+    # [num_target_residues, num_head, num_points]
+    kv_scalar = common_modules.Linear(
+        num_head * (num_scalar_v + num_scalar_qk), name='kv_scalar')(
+            inputs_1d)
+    kv_scalar = jnp.reshape(kv_scalar,
+                            [num_residues, num_head,
+                             num_scalar_v + num_scalar_qk])
+    k_scalar, v_scalar = jnp.split(kv_scalar, [num_scalar_qk], axis=-1)
+
+    # Construct query points of shape:
+    # [num_residues, num_head, num_point_qk]
+
+    # First construct query points in local frame.
+    q_point_local = common_modules.Linear(
+        num_head * 3 * num_point_qk, name='q_point_local')(
+            inputs_1d)
+    q_point_local = jnp.split(q_point_local, 3, axis=-1)
+    # Project query points into global frame.
+    q_point_global = affine.apply_to_point(q_point_local, extra_dims=1)
+    # Reshape query point for later use.
+    q_point = [
+        jnp.reshape(x, [num_residues, num_head, num_point_qk])
+        for x in q_point_global]
+
+    # Construct key and value points.
+    # Key points have shape [num_residues, num_head, num_point_qk]
+    # Value points have shape [num_residues, num_head, num_point_v]
+
+    # Construct key and value points in local frame.
+    kv_point_local = common_modules.Linear(
+        num_head * 3 * (num_point_qk + num_point_v), name='kv_point_local')(
+            inputs_1d)
+    kv_point_local = jnp.split(kv_point_local, 3, axis=-1)
+    # Project key and value points into global frame.
+    kv_point_global = affine.apply_to_point(kv_point_local, extra_dims=1)
+    kv_point_global = [
+        jnp.reshape(x, [num_residues,
+                        num_head, (num_point_qk + num_point_v)])
+        for x in kv_point_global]
+    # Split key and value points.
+    k_point, v_point = list(
+        zip(*[
+            jnp.split(x, [num_point_qk,], axis=-1)
+            for x in kv_point_global
+        ]))
+
+    # We assume that all queries and keys come iid from N(0, 1) distribution
+    # and compute the variances of the attention logits.
+    # Each scalar pair (q, k) contributes Var q*k = 1
+    scalar_variance = max(num_scalar_qk, 1) * 1.
+    # Each point pair (q, k) contributes Var [0.5 ||q||^2 - <q, k>] = 9 / 2
+    point_variance = max(num_point_qk, 1) * 9. / 2
+
+    # Allocate equal variance to scalar, point and attention 2d parts so that
+    # the sum is 1.
+
+    num_logit_terms = 3
+
+    scalar_weights = np.sqrt(1.0 / (num_logit_terms * scalar_variance))
+    point_weights = np.sqrt(1.0 / (num_logit_terms * point_variance))
+    attention_2d_weights = np.sqrt(1.0 / (num_logit_terms))
+
+    # Trainable per-head weights for points.
+    trainable_point_weights = jax.nn.softplus(hk.get_parameter(
+        'trainable_point_weights', shape=[num_head],
+        # softplus^{-1} (1)
+        init=hk.initializers.Constant(np.log(np.exp(1.) - 1.))))
+    point_weights *= jnp.expand_dims(trainable_point_weights, axis=1)
+
+    v_point = [jnp.swapaxes(x, -2, -3) for x in v_point]
+
+    q_point = [jnp.swapaxes(x, -2, -3) for x in q_point]
+    k_point = [jnp.swapaxes(x, -2, -3) for x in k_point]
+    dist2 = [
+        squared_difference(qx[:, :, None, :], kx[:, None, :, :])
+        for qx, kx in zip(q_point, k_point)
+    ]
+    dist2 = sum(dist2)
+    attn_qk_point = -0.5 * jnp.sum(
+        point_weights[:, None, None, :] * dist2, axis=-1)
+
+    v = jnp.swapaxes(v_scalar, -2, -3)
+    q = jnp.swapaxes(scalar_weights * q_scalar, -2, -3)
+    k = jnp.swapaxes(k_scalar, -2, -3)
+    attn_qk_scalar = jnp.matmul(q, jnp.swapaxes(k, -2, -1))
+    attn_logits = attn_qk_scalar + attn_qk_point
+
+    attention_2d = common_modules.Linear(
+        num_head, name='attention_2d')(
+            inputs_2d)
+
+    attention_2d = jnp.transpose(attention_2d, [2, 0, 1])
+    attention_2d = attention_2d_weights * attention_2d
+    attn_logits += attention_2d
+
+    mask_2d = mask * jnp.swapaxes(mask, -1, -2)
+    attn_logits -= 1e5 * (1. - mask_2d)
+
+    # [num_head, num_query_residues, num_target_residues]
+    attn = jax.nn.softmax(attn_logits)
+
+    # [num_head, num_query_residues, num_head * num_scalar_v]
+    result_scalar = jnp.matmul(attn, v)
+
+    # For point result, implement matmul manually so that it will be a float32
+    # on TPU.  This is equivalent to
+    # result_point_global = [jnp.einsum('bhqk,bhkc->bhqc', attn, vx)
+    #                        for vx in v_point]
+    # but on the TPU, doing the multiply and reduce_sum ensures the
+    # computation happens in float32 instead of bfloat16.
+    result_point_global = [jnp.sum(
+        attn[:, :, :, None] * vx[:, None, :, :],
+        axis=-2) for vx in v_point]
+
+    # [num_query_residues, num_head, num_head * num_(scalar|point)_v]
+    result_scalar = jnp.swapaxes(result_scalar, -2, -3)
+    result_point_global = [
+        jnp.swapaxes(x, -2, -3)
+        for x in result_point_global]
+
+    # Features used in the linear output projection. Should have the size
+    # [num_query_residues, ?]
+    output_features = []
+
+    result_scalar = jnp.reshape(
+        result_scalar, [num_residues, num_head * num_scalar_v])
+    output_features.append(result_scalar)
+
+    result_point_global = [
+        jnp.reshape(r, [num_residues, num_head * num_point_v])
+        for r in result_point_global]
+    result_point_local = affine.invert_point(result_point_global, extra_dims=1)
+    output_features.extend(result_point_local)
+
+    output_features.append(jnp.sqrt(self._dist_epsilon +
+                                    jnp.square(result_point_local[0]) +
+                                    jnp.square(result_point_local[1]) +
+                                    jnp.square(result_point_local[2])))
+
+    # Dimensions: h = heads, i and j = residues,
+    # c = inputs_2d channels
+    # Contraction happens over the second residue dimension, similarly to how
+    # the usual attention is performed.
+    result_attention_over_2d = jnp.einsum('hij, ijc->ihc', attn, inputs_2d)
+    num_out = num_head * result_attention_over_2d.shape[-1]
+    output_features.append(
+        jnp.reshape(result_attention_over_2d,
+                    [num_residues, num_out]))
+
+    final_init = 'zeros' if self._zero_initialize_last else 'linear'
+
+    final_act = jnp.concatenate(output_features, axis=-1)
+
+    return common_modules.Linear(
+        num_output,
+        initializer=final_init,
+        name='output_projection')(final_act)
+
+
+class FoldIteration(hk.Module):
+  """"""A single iteration of the main structure module loop.
+
+  Jumper et al. (2021) Suppl. Alg. 20 ""StructureModule"" lines 6-21
+
+  First, each residue attends to all residues using InvariantPointAttention.
+  Then, we apply transition layers to update the hidden representations.
+  Finally, we use the hidden representations to produce an update to the
+  affine of each residue.
+  """"""
+
+  def __init__(self, config, global_config,
+               name='fold_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               activations,
+               sequence_mask,
+               update_affine,
+               is_training,
+               initial_act,
+               safe_key=None,
+               static_feat_2d=None,
+               aatype=None):
+    c = self.config
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    def safe_dropout_fn(tensor, safe_key):
+      return prng.safe_dropout(
+          tensor=tensor,
+          safe_key=safe_key,
+          rate=c.dropout,
+          is_deterministic=self.global_config.deterministic,
+          is_training=is_training)
+
+    affine = quat_affine.QuatAffine.from_tensor(activations['affine'])
+
+    act = activations['act']
+    attention_module = InvariantPointAttention(self.config, self.global_config)
+    # Attention
+    attn = attention_module(
+        inputs_1d=act,
+        inputs_2d=static_feat_2d,
+        mask=sequence_mask,
+        affine=affine)
+    act += attn
+    safe_key, *sub_keys = safe_key.split(3)
+    sub_keys = iter(sub_keys)
+    act = safe_dropout_fn(act, next(sub_keys))
+    act = common_modules.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='attention_layer_norm')(
+            act)
+
+    final_init = 'zeros' if self.global_config.zero_init else 'linear'
+
+    # Transition
+    input_act = act
+    for i in range(c.num_layer_in_transition):
+      init = 'relu' if i < c.num_layer_in_transition - 1 else final_init
+      act = common_modules.Linear(
+          c.num_channel,
+          initializer=init,
+          name='transition')(
+              act)
+      if i < c.num_layer_in_transition - 1:
+        act = jax.nn.relu(act)
+    act += input_act
+    act = safe_dropout_fn(act, next(sub_keys))
+    act = common_modules.LayerNorm(
+        axis=[-1],
+        create_scale=True,
+        create_offset=True,
+        name='transition_layer_norm')(act)
+
+    if update_affine:
+      # This block corresponds to
+      # Jumper et al. (2021) Alg. 23 ""Backbone update""
+      affine_update_size = 6
+
+      # Affine update
+      affine_update = common_modules.Linear(
+          affine_update_size,
+          initializer=final_init,
+          name='affine_update')(
+              act)
+
+      affine = affine.pre_compose(affine_update)
+
+    sc = MultiRigidSidechain(c.sidechain, self.global_config)(
+        affine.scale_translation(c.position_scale), [act, initial_act], aatype)
+
+    outputs = {'affine': affine.to_tensor(), 'sc': sc}
+
+    affine = affine.apply_rotation_tensor_fn(jax.lax.stop_gradient)
+
+    new_activations = {
+        'act': act,
+        'affine': affine.to_tensor()
+    }
+    return new_activations, outputs
+
+
+def generate_affines(representations, batch, config, global_config,
+                     is_training, safe_key):
+  """"""Generate predicted affines for a single chain.
+
+  Jumper et al. (2021) Suppl. Alg. 20 ""StructureModule""
+
+  This is the main part of the structure module - it iteratively applies
+  folding to produce a set of predicted residue positions.
+
+  Args:
+    representations: Representations dictionary.
+    batch: Batch dictionary.
+    config: Config for the structure module.
+    global_config: Global config.
+    is_training: Whether the model is being trained.
+    safe_key: A prng.SafeKey object that wraps a PRNG key.
+
+  Returns:
+    A dictionary containing residue affines and sidechain positions.
+  """"""
+  c = config
+  sequence_mask = batch['seq_mask'][:, None]
+
+  act = common_modules.LayerNorm(
+      axis=[-1],
+      create_scale=True,
+      create_offset=True,
+      name='single_layer_norm')(
+          representations['single'])
+
+  initial_act = act
+  act = common_modules.Linear(
+      c.num_channel, name='initial_projection')(
+          act)
+
+  affine = generate_new_affine(sequence_mask)
+
+  fold_iteration = FoldIteration(
+      c, global_config, name='fold_iteration')
+
+  assert len(batch['seq_mask'].shape) == 1
+
+  activations = {'act': act,
+                 'affine': affine.to_tensor(),
+                 }
+
+  act_2d = common_modules.LayerNorm(
+      axis=[-1],
+      create_scale=True,
+      create_offset=True,
+      name='pair_layer_norm')(
+          representations['pair'])
+
+  outputs = []
+  safe_keys = safe_key.split(c.num_layer)
+  for sub_key in safe_keys:
+    activations, output = fold_iteration(
+        activations,
+        initial_act=initial_act,
+        static_feat_2d=act_2d,
+        safe_key=sub_key,
+        sequence_mask=sequence_mask,
+        update_affine=True,
+        is_training=is_training,
+        aatype=batch['aatype'])
+    outputs.append(output)
+
+  output = jax.tree_map(lambda *x: jnp.stack(x), *outputs)
+  # Include the activations in the output dict for use by the LDDT-Head.
+  output['act'] = activations['act']
+
+  return output
+
+
+class StructureModule(hk.Module):
+  """"""StructureModule as a network head.
+
+  Jumper et al. (2021) Suppl. Alg. 20 ""StructureModule""
+  """"""
+
+  def __init__(self, config, global_config, compute_loss=True,
+               name='structure_module'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+    self.compute_loss = compute_loss
+
+  def __call__(self, representations, batch, is_training,
+               safe_key=None):
+    c = self.config
+    ret = {}
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    output = generate_affines(
+        representations=representations,
+        batch=batch,
+        config=self.config,
+        global_config=self.global_config,
+        is_training=is_training,
+        safe_key=safe_key)
+
+    ret['representations'] = {'structure_module': output['act']}
+
+    ret['traj'] = output['affine'] * jnp.array([1.] * 4 +
+                                               [c.position_scale] * 3)
+
+    ret['sidechains'] = output['sc']
+
+    atom14_pred_positions = r3.vecs_to_tensor(output['sc']['atom_pos'])[-1]
+    ret['final_atom14_positions'] = atom14_pred_positions  # (N, 14, 3)
+    ret['final_atom14_mask'] = batch['atom14_atom_exists']  # (N, 14)
+
+    atom37_pred_positions = all_atom.atom14_to_atom37(atom14_pred_positions,
+                                                      batch)
+    atom37_pred_positions *= batch['atom37_atom_exists'][:, :, None]
+    ret['final_atom_positions'] = atom37_pred_positions  # (N, 37, 3)
+
+    ret['final_atom_mask'] = batch['atom37_atom_exists']  # (N, 37)
+    ret['final_affines'] = ret['traj'][-1]
+
+    if self.compute_loss:
+      return ret
+    else:
+      no_loss_features = ['final_atom_positions', 'final_atom_mask',
+                          'representations']
+      no_loss_ret = {k: ret[k] for k in no_loss_features}
+      return no_loss_ret
+
+  def loss(self, value, batch):
+    ret = {'loss': 0.}
+
+    ret['metrics'] = {}
+    # If requested, compute in-graph metrics.
+    if self.config.compute_in_graph_metrics:
+      atom14_pred_positions = value['final_atom14_positions']
+      # Compute renaming and violations.
+      value.update(compute_renamed_ground_truth(batch, atom14_pred_positions))
+      value['violations'] = find_structural_violations(
+          batch, atom14_pred_positions, self.config)
+
+      # Several violation metrics:
+      violation_metrics = compute_violation_metrics(
+          batch=batch,
+          atom14_pred_positions=atom14_pred_positions,
+          violations=value['violations'])
+      ret['metrics'].update(violation_metrics)
+
+    backbone_loss(ret, batch, value, self.config)
+
+    if 'renamed_atom14_gt_positions' not in value:
+      value.update(compute_renamed_ground_truth(
+          batch, value['final_atom14_positions']))
+    sc_loss = sidechain_loss(batch, value, self.config)
+
+    ret['loss'] = ((1 - self.config.sidechain.weight_frac) * ret['loss'] +
+                   self.config.sidechain.weight_frac * sc_loss['loss'])
+    ret['sidechain_fape'] = sc_loss['fape']
+
+    supervised_chi_loss(ret, batch, value, self.config)
+
+    if self.config.structural_violation_loss_weight:
+      if 'violations' not in value:
+        value['violations'] = find_structural_violations(
+            batch, value['final_atom14_positions'], self.config)
+      structural_violation_loss(ret, batch, value, self.config)
+
+    return ret
+
+
+def compute_renamed_ground_truth(
+    batch: Dict[str, jnp.ndarray],
+    atom14_pred_positions: jnp.ndarray,
+    ) -> Dict[str, jnp.ndarray]:
+  """"""Find optimal renaming of ground truth based on the predicted positions.
+
+  Jumper et al. (2021) Suppl. Alg. 26 ""renameSymmetricGroundTruthAtoms""
+
+  This renamed ground truth is then used for all losses,
+  such that each loss moves the atoms in the same direction.
+  Shape (N).
+
+  Args:
+    batch: Dictionary containing:
+      * atom14_gt_positions: Ground truth positions.
+      * atom14_alt_gt_positions: Ground truth positions with renaming swaps.
+      * atom14_atom_is_ambiguous: 1.0 for atoms that are affected by
+          renaming swaps.
+      * atom14_gt_exists: Mask for which atoms exist in ground truth.
+      * atom14_alt_gt_exists: Mask for which atoms exist in ground truth
+          after renaming.
+      * atom14_atom_exists: Mask for whether each atom is part of the given
+          amino acid type.
+    atom14_pred_positions: Array of atom positions in global frame with shape
+      (N, 14, 3).
+  Returns:
+    Dictionary containing:
+      alt_naming_is_better: Array with 1.0 where alternative swap is better.
+      renamed_atom14_gt_positions: Array of optimal ground truth positions
+        after renaming swaps are performed.
+      renamed_atom14_gt_exists: Mask after renaming swap is performed.
+  """"""
+  alt_naming_is_better = all_atom.find_optimal_renaming(
+      atom14_gt_positions=batch['atom14_gt_positions'],
+      atom14_alt_gt_positions=batch['atom14_alt_gt_positions'],
+      atom14_atom_is_ambiguous=batch['atom14_atom_is_ambiguous'],
+      atom14_gt_exists=batch['atom14_gt_exists'],
+      atom14_pred_positions=atom14_pred_positions,
+      atom14_atom_exists=batch['atom14_atom_exists'])
+
+  renamed_atom14_gt_positions = (
+      (1. - alt_naming_is_better[:, None, None])
+      * batch['atom14_gt_positions']
+      + alt_naming_is_better[:, None, None]
+      * batch['atom14_alt_gt_positions'])
+
+  renamed_atom14_gt_mask = (
+      (1. - alt_naming_is_better[:, None]) * batch['atom14_gt_exists']
+      + alt_naming_is_better[:, None] * batch['atom14_alt_gt_exists'])
+
+  return {
+      'alt_naming_is_better': alt_naming_is_better,  # (N)
+      'renamed_atom14_gt_positions': renamed_atom14_gt_positions,  # (N, 14, 3)
+      'renamed_atom14_gt_exists': renamed_atom14_gt_mask,  # (N, 14)
+  }
+
+
+def backbone_loss(ret, batch, value, config):
+  """"""Backbone FAPE Loss.
+
+  Jumper et al. (2021) Suppl. Alg. 20 ""StructureModule"" line 17
+
+  Args:
+    ret: Dictionary to write outputs into, needs to contain 'loss'.
+    batch: Batch, needs to contain 'backbone_affine_tensor',
+      'backbone_affine_mask'.
+    value: Dictionary containing structure module output, needs to contain
+      'traj', a trajectory of rigids.
+    config: Configuration of loss, should contain 'fape.clamp_distance' and
+      'fape.loss_unit_distance'.
+  """"""
+  affine_trajectory = quat_affine.QuatAffine.from_tensor(value['traj'])
+  rigid_trajectory = r3.rigids_from_quataffine(affine_trajectory)
+
+  gt_affine = quat_affine.QuatAffine.from_tensor(
+      batch['backbone_affine_tensor'])
+  gt_rigid = r3.rigids_from_quataffine(gt_affine)
+  backbone_mask = batch['backbone_affine_mask']
+
+  fape_loss_fn = functools.partial(
+      all_atom.frame_aligned_point_error,
+      l1_clamp_distance=config.fape.clamp_distance,
+      length_scale=config.fape.loss_unit_distance)
+
+  fape_loss_fn = jax.vmap(fape_loss_fn, (0, None, None, 0, None, None))
+  fape_loss = fape_loss_fn(rigid_trajectory, gt_rigid, backbone_mask,
+                           rigid_trajectory.trans, gt_rigid.trans,
+                           backbone_mask)
+
+  if 'use_clamped_fape' in batch:
+    # Jumper et al. (2021) Suppl. Sec. 1.11.5 ""Loss clamping details""
+    use_clamped_fape = jnp.asarray(batch['use_clamped_fape'], jnp.float32)
+    unclamped_fape_loss_fn = functools.partial(
+        all_atom.frame_aligned_point_error,
+        l1_clamp_distance=None,
+        length_scale=config.fape.loss_unit_distance)
+    unclamped_fape_loss_fn = jax.vmap(unclamped_fape_loss_fn,
+                                      (0, None, None, 0, None, None))
+    fape_loss_unclamped = unclamped_fape_loss_fn(rigid_trajectory, gt_rigid,
+                                                 backbone_mask,
+                                                 rigid_trajectory.trans,
+                                                 gt_rigid.trans,
+                                                 backbone_mask)
+
+    fape_loss = (fape_loss * use_clamped_fape +
+                 fape_loss_unclamped * (1 - use_clamped_fape))
+
+  ret['fape'] = fape_loss[-1]
+  ret['loss'] += jnp.mean(fape_loss)
+
+
+def sidechain_loss(batch, value, config):
+  """"""All Atom FAPE Loss using renamed rigids.""""""
+  # Rename Frames
+  # Jumper et al. (2021) Suppl. Alg. 26 ""renameSymmetricGroundTruthAtoms"" line 7
+  alt_naming_is_better = value['alt_naming_is_better']
+  renamed_gt_frames = (
+      (1. - alt_naming_is_better[:, None, None])
+      * batch['rigidgroups_gt_frames']
+      + alt_naming_is_better[:, None, None]
+      * batch['rigidgroups_alt_gt_frames'])
+
+  flat_gt_frames = r3.rigids_from_tensor_flat12(
+      jnp.reshape(renamed_gt_frames, [-1, 12]))
+  flat_frames_mask = jnp.reshape(batch['rigidgroups_gt_exists'], [-1])
+
+  flat_gt_positions = r3.vecs_from_tensor(
+      jnp.reshape(value['renamed_atom14_gt_positions'], [-1, 3]))
+  flat_positions_mask = jnp.reshape(value['renamed_atom14_gt_exists'], [-1])
+
+  # Compute frame_aligned_point_error score for the final layer.
+  pred_frames = value['sidechains']['frames']
+  pred_positions = value['sidechains']['atom_pos']
+
+  def _slice_last_layer_and_flatten(x):
+    return jnp.reshape(x[-1], [-1])
+  flat_pred_frames = jax.tree_map(
+      _slice_last_layer_and_flatten, pred_frames)
+  flat_pred_positions = jax.tree_map(
+      _slice_last_layer_and_flatten, pred_positions)
+  # FAPE Loss on sidechains
+  fape = all_atom.frame_aligned_point_error(
+      pred_frames=flat_pred_frames,
+      target_frames=flat_gt_frames,
+      frames_mask=flat_frames_mask,
+      pred_positions=flat_pred_positions,
+      target_positions=flat_gt_positions,
+      positions_mask=flat_positions_mask,
+      l1_clamp_distance=config.sidechain.atom_clamp_distance,
+      length_scale=config.sidechain.length_scale)
+
+  return {
+      'fape': fape,
+      'loss': fape}
+
+
+def structural_violation_loss(ret, batch, value, config):
+  """"""Computes loss for structural violations.""""""
+  assert config.sidechain.weight_frac
+
+  # Put all violation losses together to one large loss.
+  violations = value['violations']
+  num_atoms = jnp.sum(batch['atom14_atom_exists']).astype(jnp.float32)
+  ret['loss'] += (config.structural_violation_loss_weight * (
+      violations['between_residues']['bonds_c_n_loss_mean'] +
+      violations['between_residues']['angles_ca_c_n_loss_mean'] +
+      violations['between_residues']['angles_c_n_ca_loss_mean'] +
+      jnp.sum(
+          violations['between_residues']['clashes_per_atom_loss_sum'] +
+          violations['within_residues']['per_atom_loss_sum']) /
+      (1e-6 + num_atoms)))
+
+
+def find_structural_violations(
+    batch: Dict[str, jnp.ndarray],
+    atom14_pred_positions: jnp.ndarray,  # (N, 14, 3)
+    config: ml_collections.ConfigDict
+    ):
+  """"""Computes several checks for structural violations.""""""
+
+  # Compute between residue backbone violations of bonds and angles.
+  connection_violations = all_atom.between_residue_bond_loss(
+      pred_atom_positions=atom14_pred_positions,
+      pred_atom_mask=batch['atom14_atom_exists'].astype(jnp.float32),
+      residue_index=batch['residue_index'].astype(jnp.float32),
+      aatype=batch['aatype'],
+      tolerance_factor_soft=config.violation_tolerance_factor,
+      tolerance_factor_hard=config.violation_tolerance_factor)
+
+  # Compute the Van der Waals radius for every atom
+  # (the first letter of the atom name is the element type).
+  # Shape: (N, 14).
+  atomtype_radius = jnp.array([
+      residue_constants.van_der_waals_radius[name[0]]
+      for name in residue_constants.atom_types
+  ])
+  atom14_atom_radius = batch['atom14_atom_exists'] * utils.batched_gather(
+      atomtype_radius, batch['residx_atom14_to_atom37'])
+
+  # Compute the between residue clash loss.
+  between_residue_clashes = all_atom.between_residue_clash_loss(
+      atom14_pred_positions=atom14_pred_positions,
+      atom14_atom_exists=batch['atom14_atom_exists'],
+      atom14_atom_radius=atom14_atom_radius,
+      residue_index=batch['residue_index'],
+      overlap_tolerance_soft=config.clash_overlap_tolerance,
+      overlap_tolerance_hard=config.clash_overlap_tolerance)
+
+  # Compute all within-residue violations (clashes,
+  # bond length and angle violations).
+  restype_atom14_bounds = residue_constants.make_atom14_dists_bounds(
+      overlap_tolerance=config.clash_overlap_tolerance,
+      bond_length_tolerance_factor=config.violation_tolerance_factor)
+  atom14_dists_lower_bound = utils.batched_gather(
+      restype_atom14_bounds['lower_bound'], batch['aatype'])
+  atom14_dists_upper_bound = utils.batched_gather(
+      restype_atom14_bounds['upper_bound'], batch['aatype'])
+  within_residue_violations = all_atom.within_residue_violations(
+      atom14_pred_positions=atom14_pred_positions,
+      atom14_atom_exists=batch['atom14_atom_exists'],
+      atom14_dists_lower_bound=atom14_dists_lower_bound,
+      atom14_dists_upper_bound=atom14_dists_upper_bound,
+      tighten_bounds_for_loss=0.0)
+
+  # Combine them to a single per-residue violation mask (used later for LDDT).
+  per_residue_violations_mask = jnp.max(jnp.stack([
+      connection_violations['per_residue_violation_mask'],
+      jnp.max(between_residue_clashes['per_atom_clash_mask'], axis=-1),
+      jnp.max(within_residue_violations['per_atom_violations'],
+              axis=-1)]), axis=0)
+
+  return {
+      'between_residues': {
+          'bonds_c_n_loss_mean':
+              connection_violations['c_n_loss_mean'],  # ()
+          'angles_ca_c_n_loss_mean':
+              connection_violations['ca_c_n_loss_mean'],  # ()
+          'angles_c_n_ca_loss_mean':
+              connection_violations['c_n_ca_loss_mean'],  # ()
+          'connections_per_residue_loss_sum':
+              connection_violations['per_residue_loss_sum'],  # (N)
+          'connections_per_residue_violation_mask':
+              connection_violations['per_residue_violation_mask'],  # (N)
+          'clashes_mean_loss':
+              between_residue_clashes['mean_loss'],  # ()
+          'clashes_per_atom_loss_sum':
+              between_residue_clashes['per_atom_loss_sum'],  # (N, 14)
+          'clashes_per_atom_clash_mask':
+              between_residue_clashes['per_atom_clash_mask'],  # (N, 14)
+      },
+      'within_residues': {
+          'per_atom_loss_sum':
+              within_residue_violations['per_atom_loss_sum'],  # (N, 14)
+          'per_atom_violations':
+              within_residue_violations['per_atom_violations'],  # (N, 14),
+      },
+      'total_per_residue_violations_mask':
+          per_residue_violations_mask,  # (N)
+  }
+
+
+def compute_violation_metrics(
+    batch: Dict[str, jnp.ndarray],
+    atom14_pred_positions: jnp.ndarray,  # (N, 14, 3)
+    violations: Dict[str, jnp.ndarray],
+    ) -> Dict[str, jnp.ndarray]:
+  """"""Compute several metrics to assess the structural violations.""""""
+
+  ret = {}
+  extreme_ca_ca_violations = all_atom.extreme_ca_ca_distance_violations(
+      pred_atom_positions=atom14_pred_positions,
+      pred_atom_mask=batch['atom14_atom_exists'].astype(jnp.float32),
+      residue_index=batch['residue_index'].astype(jnp.float32))
+  ret['violations_extreme_ca_ca_distance'] = extreme_ca_ca_violations
+  ret['violations_between_residue_bond'] = utils.mask_mean(
+      mask=batch['seq_mask'],
+      value=violations['between_residues'][
+          'connections_per_residue_violation_mask'])
+  ret['violations_between_residue_clash'] = utils.mask_mean(
+      mask=batch['seq_mask'],
+      value=jnp.max(
+          violations['between_residues']['clashes_per_atom_clash_mask'],
+          axis=-1))
+  ret['violations_within_residue'] = utils.mask_mean(
+      mask=batch['seq_mask'],
+      value=jnp.max(
+          violations['within_residues']['per_atom_violations'], axis=-1))
+  ret['violations_per_residue'] = utils.mask_mean(
+      mask=batch['seq_mask'],
+      value=violations['total_per_residue_violations_mask'])
+  return ret
+
+
+def supervised_chi_loss(ret, batch, value, config):
+  """"""Computes loss for direct chi angle supervision.
+
+  Jumper et al. (2021) Suppl. Alg. 27 ""torsionAngleLoss""
+
+  Args:
+    ret: Dictionary to write outputs into, needs to contain 'loss'.
+    batch: Batch, needs to contain 'seq_mask', 'chi_mask', 'chi_angles'.
+    value: Dictionary containing structure module output, needs to contain
+      value['sidechains']['angles_sin_cos'] for angles and
+      value['sidechains']['unnormalized_angles_sin_cos'] for unnormalized
+      angles.
+    config: Configuration of loss, should contain 'chi_weight' and
+      'angle_norm_weight', 'angle_norm_weight' scales angle norm term,
+      'chi_weight' scales torsion term.
+  """"""
+  eps = 1e-6
+
+  sequence_mask = batch['seq_mask']
+  num_res = sequence_mask.shape[0]
+  chi_mask = batch['chi_mask'].astype(jnp.float32)
+  pred_angles = jnp.reshape(
+      value['sidechains']['angles_sin_cos'], [-1, num_res, 7, 2])
+  pred_angles = pred_angles[:, :, 3:]
+
+  residue_type_one_hot = jax.nn.one_hot(
+      batch['aatype'], residue_constants.restype_num + 1,
+      dtype=jnp.float32)[None]
+  chi_pi_periodic = jnp.einsum('ijk, kl->ijl', residue_type_one_hot,
+                               jnp.asarray(residue_constants.chi_pi_periodic))
+
+  true_chi = batch['chi_angles'][None]
+  sin_true_chi = jnp.sin(true_chi)
+  cos_true_chi = jnp.cos(true_chi)
+  sin_cos_true_chi = jnp.stack([sin_true_chi, cos_true_chi], axis=-1)
+
+  # This is -1 if chi is pi-periodic and +1 if it's 2pi-periodic
+  shifted_mask = (1 - 2 * chi_pi_periodic)[..., None]
+  sin_cos_true_chi_shifted = shifted_mask * sin_cos_true_chi
+
+  sq_chi_error = jnp.sum(
+      squared_difference(sin_cos_true_chi, pred_angles), -1)
+  sq_chi_error_shifted = jnp.sum(
+      squared_difference(sin_cos_true_chi_shifted, pred_angles), -1)
+  sq_chi_error = jnp.minimum(sq_chi_error, sq_chi_error_shifted)
+
+  sq_chi_loss = utils.mask_mean(mask=chi_mask[None], value=sq_chi_error)
+  ret['chi_loss'] = sq_chi_loss
+  ret['loss'] += config.chi_weight * sq_chi_loss
+  unnormed_angles = jnp.reshape(
+      value['sidechains']['unnormalized_angles_sin_cos'], [-1, num_res, 7, 2])
+  angle_norm = jnp.sqrt(jnp.sum(jnp.square(unnormed_angles), axis=-1) + eps)
+  norm_error = jnp.abs(angle_norm - 1.)
+  angle_norm_loss = utils.mask_mean(mask=sequence_mask[None, :, None],
+                                    value=norm_error)
+
+  ret['angle_norm_loss'] = angle_norm_loss
+  ret['loss'] += config.angle_norm_weight * angle_norm_loss
+
+
+def generate_new_affine(sequence_mask):
+  num_residues, _ = sequence_mask.shape
+  quaternion = jnp.tile(
+      jnp.reshape(jnp.asarray([1., 0., 0., 0.]), [1, 4]),
+      [num_residues, 1])
+
+  translation = jnp.zeros([num_residues, 3])
+  return quat_affine.QuatAffine(quaternion, translation, unstack_inputs=True)
+
+
+def l2_normalize(x, axis=-1, epsilon=1e-12):
+  return x / jnp.sqrt(
+      jnp.maximum(jnp.sum(x**2, axis=axis, keepdims=True), epsilon))
+
+
+class MultiRigidSidechain(hk.Module):
+  """"""Class to make side chain atoms.""""""
+
+  def __init__(self, config, global_config, name='rigid_sidechain'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self, affine, representations_list, aatype):
+    """"""Predict side chains using multi-rigid representations.
+
+    Args:
+      affine: The affines for each residue (translations in angstroms).
+      representations_list: A list of activations to predict side chains from.
+      aatype: Amino acid types.
+
+    Returns:
+      Dict containing atom positions and frames (in angstroms).
+    """"""
+    act = [
+        common_modules.Linear(  # pylint: disable=g-complex-comprehension
+            self.config.num_channel,
+            name='input_projection')(jax.nn.relu(x))
+        for x in representations_list
+    ]
+    # Sum the activation list (equivalent to concat then Linear).
+    act = sum(act)
+
+    final_init = 'zeros' if self.global_config.zero_init else 'linear'
+
+    # Mapping with some residual blocks.
+    for _ in range(self.config.num_residual_block):
+      old_act = act
+      act = common_modules.Linear(
+          self.config.num_channel,
+          initializer='relu',
+          name='resblock1')(
+              jax.nn.relu(act))
+      act = common_modules.Linear(
+          self.config.num_channel,
+          initializer=final_init,
+          name='resblock2')(
+              jax.nn.relu(act))
+      act += old_act
+
+    # Map activations to torsion angles. Shape: (num_res, 14).
+    num_res = act.shape[0]
+    unnormalized_angles = common_modules.Linear(
+        14, name='unnormalized_angles')(
+            jax.nn.relu(act))
+    unnormalized_angles = jnp.reshape(
+        unnormalized_angles, [num_res, 7, 2])
+    angles = l2_normalize(unnormalized_angles, axis=-1)
+
+    outputs = {
+        'angles_sin_cos': angles,  # jnp.ndarray (N, 7, 2)
+        'unnormalized_angles_sin_cos':
+            unnormalized_angles,  # jnp.ndarray (N, 7, 2)
+    }
+
+    # Map torsion angles to frames.
+    backb_to_global = r3.rigids_from_quataffine(affine)
+
+    # Jumper et al. (2021) Suppl. Alg. 24 ""computeAllAtomCoordinates""
+
+    # r3.Rigids with shape (N, 8).
+    all_frames_to_global = all_atom.torsion_angles_to_frames(
+        aatype,
+        backb_to_global,
+        angles)
+
+    # Use frames and literature positions to create the final atom coordinates.
+    # r3.Vecs with shape (N, 14).
+    pred_positions = all_atom.frames_and_literature_positions_to_atom14_pos(
+        aatype, all_frames_to_global)
+
+    outputs.update({
+        'atom_pos': pred_positions,  # r3.Vecs (N, 14)
+        'frames': all_frames_to_global,  # r3.Rigids (N, 8)
+    })
+    return outputs
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/layer_stack.py",".py","9134","275","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Function to stack repeats of a layer function without shared parameters.""""""
+
+import collections
+import contextlib
+import functools
+import inspect
+from typing import Any, Callable, Optional, Tuple, Union
+
+import haiku as hk
+import jax
+import jax.numpy as jnp
+
+LayerStackCarry = collections.namedtuple('LayerStackCarry', ['x', 'rng'])
+LayerStackScanned = collections.namedtuple('LayerStackScanned',
+                                           ['i', 'args_ys'])
+
+# WrappedFn should take in arbitrarily nested `jnp.ndarray`, and return the
+# exact same type. We cannot express this with `typing`. So we just use it
+# to inform the user. In reality, the typing below will accept anything.
+NestedArray = Any
+WrappedFn = Callable[..., Union[NestedArray, Tuple[NestedArray]]]
+
+
+def _check_no_varargs(f):
+  if list(inspect.signature(
+      f).parameters.values())[0].kind == inspect.Parameter.VAR_POSITIONAL:
+    raise ValueError(
+        'The function `f` should not have any `varargs` (that is *args) '
+        'argument. Instead, it should only use explicit positional'
+        'arguments.')
+
+
+@contextlib.contextmanager
+def nullcontext():
+  yield
+
+
+def maybe_with_rng(key):
+  if key is not None:
+    return hk.with_rng(key)
+  else:
+    return nullcontext()
+
+
+def maybe_fold_in(key, data):
+  if key is not None:
+    return jax.random.fold_in(key, data)
+  else:
+    return None
+
+
+class _LayerStack(hk.Module):
+  """"""Module to compose parameterized functions, implemented as a scan.""""""
+
+  def __init__(self,
+               count: int,
+               unroll: int,
+               name: Optional[str] = None):
+    """"""Iterate a function `f` `count` times, with non-shared parameters.""""""
+    super().__init__(name=name)
+    self._count = count
+    self._unroll = unroll
+
+  def __call__(self, x, *args_ys):
+    count = self._count
+    if hk.running_init():
+      # At initialization time, we run just one layer but add an extra first
+      # dimension to every initialized tensor, making sure to use different
+      # random keys for different slices.
+      def creator(next_creator, shape, dtype, init, context):
+        del context
+
+        def multi_init(shape, dtype):
+          assert shape[0] == count
+          key = hk.maybe_next_rng_key()
+
+          def rng_context_init(slice_idx):
+            slice_key = maybe_fold_in(key, slice_idx)
+            with maybe_with_rng(slice_key):
+              return init(shape[1:], dtype)
+
+          return jax.vmap(rng_context_init)(jnp.arange(count))
+
+        return next_creator((count,) + tuple(shape), dtype, multi_init)
+
+      def getter(next_getter, value, context):
+        trailing_dims = len(context.original_shape) + 1
+        sliced_value = jax.lax.index_in_dim(
+            value, index=0, axis=value.ndim - trailing_dims, keepdims=False)
+        return next_getter(sliced_value)
+
+      with hk.experimental.custom_creator(
+          creator), hk.experimental.custom_getter(getter):
+        if len(args_ys) == 1 and args_ys[0] is None:
+          args0 = (None,)
+        else:
+          args0 = [
+              jax.lax.dynamic_index_in_dim(ys, 0, keepdims=False)
+              for ys in args_ys
+          ]
+        x, z = self._call_wrapped(x, *args0)
+        if z is None:
+          return x, z
+
+        # Broadcast state to hold each layer state.
+        def broadcast_state(layer_state):
+          return jnp.broadcast_to(
+              layer_state, [count,] + list(layer_state.shape))
+        zs = jax.tree_util.tree_map(broadcast_state, z)
+        return x, zs
+    else:
+      # Use scan during apply, threading through random seed so that it's
+      # unique for each layer.
+      def layer(carry: LayerStackCarry, scanned: LayerStackScanned):
+        rng = carry.rng
+
+        def getter(next_getter, value, context):
+          # Getter slices the full param at the current loop index.
+          trailing_dims = len(context.original_shape) + 1
+          assert value.shape[value.ndim - trailing_dims] == count, (
+              f'Attempting to use a parameter stack of size '
+              f'{value.shape[value.ndim - trailing_dims]} for a LayerStack of '
+              f'size {count}.')
+
+          sliced_value = jax.lax.dynamic_index_in_dim(
+              value, scanned.i, axis=value.ndim - trailing_dims, keepdims=False)
+          return next_getter(sliced_value)
+
+        with hk.experimental.custom_getter(getter):
+          if rng is None:
+            out_x, z = self._call_wrapped(carry.x, *scanned.args_ys)
+          else:
+            rng, rng_ = jax.random.split(rng)
+            with hk.with_rng(rng_):
+              out_x, z = self._call_wrapped(carry.x, *scanned.args_ys)
+        return LayerStackCarry(x=out_x, rng=rng), z
+
+      carry = LayerStackCarry(x=x, rng=hk.maybe_next_rng_key())
+      scanned = LayerStackScanned(i=jnp.arange(count, dtype=jnp.int32),
+                                  args_ys=args_ys)
+
+      carry, zs = hk.scan(
+          layer, carry, scanned, length=count, unroll=self._unroll)
+      return carry.x, zs
+
+  def _call_wrapped(self,
+                    x: jnp.ndarray,
+                    *args,
+                    ) -> Tuple[jnp.ndarray, Optional[jnp.ndarray]]:
+    raise NotImplementedError()
+
+
+class _LayerStackNoState(_LayerStack):
+  """"""_LayerStack impl with no per-layer state provided to the function.""""""
+
+  def __init__(self,
+               f: WrappedFn,
+               count: int,
+               unroll: int,
+               name: Optional[str] = None):
+    super().__init__(count=count, unroll=unroll, name=name)
+    _check_no_varargs(f)
+    self._f = f
+
+  @hk.transparent
+  def _call_wrapped(self, args, y):
+    del y
+    ret = self._f(*args)
+    if len(args) == 1:
+      # If the function takes a single argument, the wrapped function receives
+      # a tuple of length 1, and therefore it must return a tuple of length 1.
+      ret = (ret,)
+    return ret, None
+
+
+class _LayerStackWithState(_LayerStack):
+  """"""_LayerStack impl with per-layer state provided to the function.""""""
+
+  def __init__(self,
+               f: WrappedFn,
+               count: int,
+               unroll: int,
+               name: Optional[str] = None):
+    super().__init__(count=count, unroll=unroll, name=name)
+    self._f = f
+
+  @hk.transparent
+  def _call_wrapped(self, x, *args):
+    return self._f(x, *args)
+
+
+def layer_stack(num_layers: int,
+                with_state=False,
+                unroll: int = 1,
+                name: Optional[str] = None):
+  """"""Utility to wrap a Haiku function and recursively apply it to an input.
+
+  A function is valid if it uses only explicit position parameters, and
+  its return type matches its input type. The position parameters can be
+  arbitrarily nested structures with `jnp.ndarray` at the leaf nodes. Note
+  that kwargs are not supported, neither are functions with variable number
+  of parameters (specified by `*args`).
+
+  If `with_state=False` then the new, wrapped function can be understood as
+  performing the following:
+  ```
+  for i in range(num_layers):
+    x = f(x)
+  return x
+  ```
+
+  And if `with_state=True`, assuming `f` takes two arguments on top of `x`:
+  ```
+  for i in range(num_layers):
+    x, zs[i] = f(x, ys_0[i], ys_1[i])
+  return x, zs
+  ```
+  The code using `layer_stack` for the above function would be:
+  ```
+  def f(x, y_0, y_1):
+    ...
+    return new_x, z
+  x, zs = layer_stack.layer_stack(num_layers,
+                                  with_state=True)(f)(x, ys_0, ys_1)
+  ```
+
+  Crucially, any parameters created inside `f` will not be shared across
+  iterations.
+
+  Args:
+    num_layers: The number of times to iterate the wrapped function.
+    with_state: Whether or not to pass per-layer state to the wrapped function.
+    unroll: the unroll used by `scan`.
+    name: Name of the Haiku context.
+
+  Returns:
+    Callable that will produce a layer stack when called with a valid function.
+  """"""
+  def iterate(f):
+    if with_state:
+      @functools.wraps(f)
+      def wrapped(x, *args):
+        for ys in args:
+          assert ys.shape[0] == num_layers
+        return _LayerStackWithState(
+            f, num_layers, unroll=unroll, name=name)(x, *args)
+    else:
+      _check_no_varargs(f)
+      @functools.wraps(f)
+      def wrapped(*args):
+        ret = _LayerStackNoState(
+            f, num_layers, unroll=unroll, name=name)(args, None)[0]
+        if len(args) == 1:
+          # If the function takes a single argument, we must also return a
+          # single value, and not a tuple of length 1.
+          ret = ret[0]
+        return ret
+
+    return wrapped
+  return iterate
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/folding_multimer.py",".py","42498","1163","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Modules and utilities for the structure module in the multimer system.""""""
+
+import functools
+import numbers
+from typing import Any, Dict, Iterable, Mapping, Optional, Tuple, Union
+
+from alphafold.common import residue_constants
+from alphafold.model import all_atom_multimer
+from alphafold.model import common_modules
+from alphafold.model import geometry
+from alphafold.model import modules
+from alphafold.model import prng
+from alphafold.model import utils
+from alphafold.model.geometry import utils as geometry_utils
+import haiku as hk
+import jax
+import jax.numpy as jnp
+import ml_collections
+import numpy as np
+
+
+EPSILON = 1e-8
+Float = Union[float, jnp.ndarray]
+
+
+def squared_difference(x: jnp.ndarray, y: jnp.ndarray) -> jnp.ndarray:
+  """"""Computes Squared difference between two arrays.""""""
+  return jnp.square(x - y)
+
+
+def make_backbone_affine(
+    positions: geometry.Vec3Array,
+    mask: jnp.ndarray,
+    aatype: jnp.ndarray,
+    ) -> Tuple[geometry.Rigid3Array, jnp.ndarray]:
+  """"""Make backbone Rigid3Array and mask.""""""
+  del aatype
+  a = residue_constants.atom_order['N']
+  b = residue_constants.atom_order['CA']
+  c = residue_constants.atom_order['C']
+
+  rigid_mask = (mask[:, a] * mask[:, b] * mask[:, c]).astype(
+      jnp.float32)
+
+  rigid = all_atom_multimer.make_transform_from_reference(
+      a_xyz=positions[:, a], b_xyz=positions[:, b], c_xyz=positions[:, c])
+
+  return rigid, rigid_mask
+
+
+class QuatRigid(hk.Module):
+  """"""Module for projecting Rigids via a quaternion.""""""
+
+  def __init__(self,
+               global_config: ml_collections.ConfigDict,
+               rigid_shape: Union[int, Iterable[int]] = tuple(),
+               full_quat: bool = False,
+               init: str = 'zeros',
+               name: str = 'quat_rigid'):
+    """"""Module projecting a Rigid Object.
+
+    For this Module the Rotation is parametrized as a quaternion,
+    If 'full_quat' is True a 4 vector is produced for the rotation which is
+    normalized and treated as a quaternion.
+    When 'full_quat' is False a 3 vector is produced and the 1st component of
+    the quaternion is set to 1.
+
+    Args:
+      global_config: Global Config, used to set certain properties of underlying
+        Linear module, see common_modules.Linear for details.
+      rigid_shape: Shape of Rigids relative to shape of activations, e.g. when
+        activations have shape (n,) and this is (m,) output will be (n, m)
+      full_quat: Whether to parametrize rotation using full quaternion.
+      init: initializer to use, see common_modules.Linear for details
+      name: Name to use for module.
+    """"""
+    self.init = init
+    self.global_config = global_config
+    if isinstance(rigid_shape, int):
+      self.rigid_shape = (rigid_shape,)
+    else:
+      self.rigid_shape = tuple(rigid_shape)
+    self.full_quat = full_quat
+    super(QuatRigid, self).__init__(name=name)
+
+  def __call__(self, activations: jnp.ndarray) -> geometry.Rigid3Array:
+    """"""Executes Module.
+
+    This returns a set of rigid with the same shape as activations, projecting
+    the channel dimension, rigid_shape controls the trailing dimensions.
+    For example when activations is shape (12, 5) and rigid_shape is (3, 2)
+    then the shape of the output rigids will be (12, 3, 2).
+    This also supports passing in an empty tuple for rigid shape, in that case
+    the example would produce a rigid of shape (12,).
+
+    Args:
+      activations: Activations to use for projection, shape [..., num_channel]
+    Returns:
+      Rigid transformations with shape [...] + rigid_shape
+    """"""
+    if self.full_quat:
+      rigid_dim = 7
+    else:
+      rigid_dim = 6
+    linear_dims = self.rigid_shape + (rigid_dim,)
+    rigid_flat = common_modules.Linear(
+        linear_dims,
+        initializer=self.init,
+        precision=jax.lax.Precision.HIGHEST,
+        name='rigid')(
+            activations)
+    rigid_flat = geometry_utils.unstack(rigid_flat)
+    if self.full_quat:
+      qw, qx, qy, qz = rigid_flat[:4]
+      translation = rigid_flat[4:]
+    else:
+      qx, qy, qz = rigid_flat[:3]
+      qw = jnp.ones_like(qx)
+      translation = rigid_flat[3:]
+    rotation = geometry.Rot3Array.from_quaternion(
+        qw, qx, qy, qz, normalize=True)
+    translation = geometry.Vec3Array(*translation)
+    return geometry.Rigid3Array(rotation, translation)
+
+
+class PointProjection(hk.Module):
+  """"""Given input reprensentation and frame produces points in global frame.""""""
+
+  def __init__(self,
+               num_points: Union[Iterable[int], int],
+               global_config: ml_collections.ConfigDict,
+               return_local_points: bool = False,
+               name: str = 'point_projection'):
+    """"""Constructs Linear Module.
+
+    Args:
+      num_points: number of points to project. Can be tuple when outputting
+          multiple dimensions
+      global_config: Global Config, passed through to underlying Linear
+      return_local_points: Whether to return points in local frame as well.
+      name: name of module, used for name scopes.
+    """"""
+    if isinstance(num_points, numbers.Integral):
+      self.num_points = (num_points,)
+    else:
+      self.num_points = tuple(num_points)
+
+    self.return_local_points = return_local_points
+
+    self.global_config = global_config
+
+    super().__init__(name=name)
+
+  def __call__(
+      self, activations: jnp.ndarray, rigids: geometry.Rigid3Array
+  ) -> Union[geometry.Vec3Array, Tuple[geometry.Vec3Array, geometry.Vec3Array]]:
+    output_shape = self.num_points
+    output_shape = output_shape[:-1] + (3 * output_shape[-1],)
+    points_local = common_modules.Linear(
+        output_shape,
+        precision=jax.lax.Precision.HIGHEST,
+        name='point_projection')(
+            activations)
+    points_local = jnp.split(points_local, 3, axis=-1)
+    points_local = geometry.Vec3Array(*points_local)
+    rigids = rigids[(...,) + (None,) * len(output_shape)]
+    points_global = rigids.apply_to_point(points_local)
+    if self.return_local_points:
+      return points_global, points_local
+    else:
+      return points_global
+
+
+class InvariantPointAttention(hk.Module):
+  """"""Invariant point attention module.
+
+  The high-level idea is that this attention module works over a set of points
+  and associated orientations in 3D space (e.g. protein residues).
+
+  Each residue outputs a set of queries and keys as points in their local
+  reference frame.  The attention is then defined as the euclidean distance
+  between the queries and keys in the global frame.
+  """"""
+
+  def __init__(self,
+               config: ml_collections.ConfigDict,
+               global_config: ml_collections.ConfigDict,
+               dist_epsilon: float = 1e-8,
+               name: str = 'invariant_point_attention'):
+    """"""Initialize.
+
+    Args:
+      config: iterative Fold Head Config
+      global_config: Global Config of Model.
+      dist_epsilon: Small value to avoid NaN in distance calculation.
+      name: Sonnet name.
+    """"""
+    super().__init__(name=name)
+
+    self._dist_epsilon = dist_epsilon
+    self._zero_initialize_last = global_config.zero_init
+
+    self.config = config
+
+    self.global_config = global_config
+
+  def __call__(
+      self,
+      inputs_1d: jnp.ndarray,
+      inputs_2d: jnp.ndarray,
+      mask: jnp.ndarray,
+      rigid: geometry.Rigid3Array,
+      ) -> jnp.ndarray:
+    """"""Compute geometric aware attention.
+
+    Given a set of query residues (defined by affines and associated scalar
+    features), this function computes geometric aware attention between the
+    query residues and target residues.
+
+    The residues produce points in their local reference frame, which
+    are converted into the global frame to get attention via euclidean distance.
+
+    Equivalently the target residues produce points in their local frame to be
+    used as attention values, which are converted into the query residues local
+    frames.
+
+    Args:
+      inputs_1d: (N, C) 1D input embedding that is the basis for the
+        scalar queries.
+      inputs_2d: (N, M, C') 2D input embedding, used for biases values in the
+        attention between query_inputs_1d and target_inputs_1d.
+      mask: (N, 1) mask to indicate query_inputs_1d that participate in
+        the attention.
+      rigid: Rigid object describing the position and orientation of
+        every element in query_inputs_1d.
+
+    Returns:
+      Transformation of the input embedding.
+    """"""
+
+    num_head = self.config.num_head
+
+    attn_logits = 0.
+
+    num_point_qk = self.config.num_point_qk
+    # Each point pair (q, k) contributes Var [0.5 ||q||^2 - <q, k>] = 9 / 2
+    point_variance = max(num_point_qk, 1) * 9. / 2
+    point_weights = np.sqrt(1.0 / point_variance)
+
+    # This is equivalent to jax.nn.softplus, but avoids a bug in the test...
+    softplus = lambda x: jnp.logaddexp(x, jnp.zeros_like(x))
+    raw_point_weights = hk.get_parameter(
+        'trainable_point_weights',
+        shape=[num_head],
+        # softplus^{-1} (1)
+        init=hk.initializers.Constant(np.log(np.exp(1.) - 1.)))
+
+    # Trainable per-head weights for points.
+    trainable_point_weights = softplus(raw_point_weights)
+    point_weights *= trainable_point_weights
+    q_point = PointProjection([num_head, num_point_qk],
+                              self.global_config,
+                              name='q_point_projection')(inputs_1d,
+                                                         rigid)
+
+    k_point = PointProjection([num_head, num_point_qk],
+                              self.global_config,
+                              name='k_point_projection')(inputs_1d,
+                                                         rigid)
+
+    dist2 = geometry.square_euclidean_distance(
+        q_point[:, None, :, :], k_point[None, :, :, :], epsilon=0.)
+    attn_qk_point = -0.5 * jnp.sum(point_weights[:, None] * dist2, axis=-1)
+    attn_logits += attn_qk_point
+
+    num_scalar_qk = self.config.num_scalar_qk
+    # We assume that all queries and keys come iid from N(0, 1) distribution
+    # and compute the variances of the attention logits.
+    # Each scalar pair (q, k) contributes Var q*k = 1
+    scalar_variance = max(num_scalar_qk, 1) * 1.
+    scalar_weights = np.sqrt(1.0 / scalar_variance)
+    q_scalar = common_modules.Linear([num_head, num_scalar_qk],
+                                     use_bias=False,
+                                     name='q_scalar_projection')(
+                                         inputs_1d)
+
+    k_scalar = common_modules.Linear([num_head, num_scalar_qk],
+                                     use_bias=False,
+                                     name='k_scalar_projection')(
+                                         inputs_1d)
+    q_scalar *= scalar_weights
+    attn_logits += jnp.einsum('qhc,khc->qkh', q_scalar, k_scalar)
+
+    attention_2d = common_modules.Linear(
+        num_head, name='attention_2d')(inputs_2d)
+    attn_logits += attention_2d
+
+    mask_2d = mask * jnp.swapaxes(mask, -1, -2)
+    attn_logits -= 1e5 * (1. - mask_2d[..., None])
+
+    attn_logits *= np.sqrt(1. / 3)     # Normalize by number of logit terms (3)
+    attn = jax.nn.softmax(attn_logits, axis=-2)
+
+    num_scalar_v = self.config.num_scalar_v
+
+    v_scalar = common_modules.Linear([num_head, num_scalar_v],
+                                     use_bias=False,
+                                     name='v_scalar_projection')(
+                                         inputs_1d)
+
+    # [num_query_residues, num_head, num_scalar_v]
+    result_scalar = jnp.einsum('qkh, khc->qhc', attn, v_scalar)
+
+    num_point_v = self.config.num_point_v
+    v_point = PointProjection([num_head, num_point_v],
+                              self.global_config,
+                              name='v_point_projection')(inputs_1d,
+                                                         rigid)
+
+    result_point_global = jax.tree_map(
+        lambda x: jnp.sum(attn[..., None] * x, axis=-3), v_point[None])
+
+    # Features used in the linear output projection. Should have the size
+    # [num_query_residues, ?]
+    output_features = []
+    num_query_residues, _ = inputs_1d.shape
+
+    flat_shape = [num_query_residues, -1]
+
+    result_scalar = jnp.reshape(result_scalar, flat_shape)
+    output_features.append(result_scalar)
+
+    result_point_global = jax.tree_map(lambda r: jnp.reshape(r, flat_shape),
+                                       result_point_global)
+    result_point_local = rigid[..., None].apply_inverse_to_point(
+        result_point_global)
+    output_features.extend(
+        [result_point_local.x, result_point_local.y, result_point_local.z])
+
+    point_norms = result_point_local.norm(self._dist_epsilon)
+    output_features.append(point_norms)
+
+    # Dimensions: h = heads, i and j = residues,
+    # c = inputs_2d channels
+    # Contraction happens over the second residue dimension, similarly to how
+    # the usual attention is performed.
+    result_attention_over_2d = jnp.einsum('ijh, ijc->ihc', attn, inputs_2d)
+    output_features.append(jnp.reshape(result_attention_over_2d, flat_shape))
+
+    final_init = 'zeros' if self._zero_initialize_last else 'linear'
+
+    final_act = jnp.concatenate(output_features, axis=-1)
+
+    return common_modules.Linear(
+        self.config.num_channel,
+        initializer=final_init,
+        name='output_projection')(final_act)
+
+
+class FoldIteration(hk.Module):
+  """"""A single iteration of iterative folding.
+
+  First, each residue attends to all residues using InvariantPointAttention.
+  Then, we apply transition layers to update the hidden representations.
+  Finally, we use the hidden representations to produce an update to the
+  affine of each residue.
+  """"""
+
+  def __init__(self,
+               config: ml_collections.ConfigDict,
+               global_config: ml_collections.ConfigDict,
+               name: str = 'fold_iteration'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(
+      self,
+      activations: Mapping[str, Any],
+      aatype: jnp.ndarray,
+      sequence_mask: jnp.ndarray,
+      update_rigid: bool,
+      is_training: bool,
+      initial_act: jnp.ndarray,
+      safe_key: Optional[prng.SafeKey] = None,
+      static_feat_2d: Optional[jnp.ndarray] = None,
+  ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+
+    c = self.config
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    def safe_dropout_fn(tensor, safe_key):
+      return modules.apply_dropout(
+          tensor=tensor,
+          safe_key=safe_key,
+          rate=0.0 if self.global_config.deterministic else c.dropout,
+          is_training=is_training)
+
+    rigid = activations['rigid']
+
+    act = activations['act']
+    attention_module = InvariantPointAttention(
+        self.config, self.global_config)
+    # Attention
+    act += attention_module(
+        inputs_1d=act,
+        inputs_2d=static_feat_2d,
+        mask=sequence_mask,
+        rigid=rigid)
+
+    safe_key, *sub_keys = safe_key.split(3)
+    sub_keys = iter(sub_keys)
+    act = safe_dropout_fn(act, next(sub_keys))
+    act = common_modules.LayerNorm(
+        axis=-1,
+        create_scale=True,
+        create_offset=True,
+        name='attention_layer_norm')(
+            act)
+    final_init = 'zeros' if self.global_config.zero_init else 'linear'
+
+    # Transition
+    input_act = act
+    for i in range(c.num_layer_in_transition):
+      init = 'relu' if i < c.num_layer_in_transition - 1 else final_init
+      act = common_modules.Linear(
+          c.num_channel,
+          initializer=init,
+          name='transition')(
+              act)
+      if i < c.num_layer_in_transition - 1:
+        act = jax.nn.relu(act)
+    act += input_act
+    act = safe_dropout_fn(act, next(sub_keys))
+    act = common_modules.LayerNorm(
+        axis=-1,
+        create_scale=True,
+        create_offset=True,
+        name='transition_layer_norm')(act)
+    if update_rigid:
+      # Rigid update
+      rigid_update = QuatRigid(
+          self.global_config, init=final_init)(
+              act)
+      rigid = rigid @ rigid_update
+
+    sc = MultiRigidSidechain(c.sidechain, self.global_config)(
+        rigid.scale_translation(c.position_scale), [act, initial_act], aatype)
+
+    outputs = {'rigid': rigid, 'sc': sc}
+
+    rotation = jax.tree_map(jax.lax.stop_gradient, rigid.rotation)
+    rigid = geometry.Rigid3Array(rotation, rigid.translation)
+
+    new_activations = {
+        'act': act,
+        'rigid': rigid
+    }
+    return new_activations, outputs
+
+
+def generate_monomer_rigids(representations: Mapping[str, jnp.ndarray],
+                            batch: Mapping[str, jnp.ndarray],
+                            config: ml_collections.ConfigDict,
+                            global_config: ml_collections.ConfigDict,
+                            is_training: bool,
+                            safe_key: prng.SafeKey
+                            ) -> Dict[str, Any]:
+  """"""Generate predicted Rigid's for a single chain.
+
+  This is the main part of the iterative fold head - it iteratively applies
+  folding to produce a set of predicted residue positions.
+
+  Args:
+    representations: Embeddings dictionary.
+    batch: Batch dictionary.
+    config: config for the iterative fold head.
+    global_config: global config.
+    is_training: is training.
+    safe_key: A prng.SafeKey object that wraps a PRNG key.
+
+  Returns:
+    A dictionary containing residue Rigid's and sidechain positions.
+  """"""
+  c = config
+  sequence_mask = batch['seq_mask'][:, None]
+  act = common_modules.LayerNorm(
+      axis=-1, create_scale=True, create_offset=True, name='single_layer_norm')(
+          representations['single'])
+
+  initial_act = act
+  act = common_modules.Linear(
+      c.num_channel, name='initial_projection')(act)
+
+  # Sequence Mask has extra 1 at the end.
+  rigid = geometry.Rigid3Array.identity(sequence_mask.shape[:-1])
+
+  fold_iteration = FoldIteration(
+      c, global_config, name='fold_iteration')
+
+  assert len(batch['seq_mask'].shape) == 1
+
+  activations = {
+      'act':
+          act,
+      'rigid':
+          rigid
+  }
+
+  act_2d = common_modules.LayerNorm(
+      axis=-1,
+      create_scale=True,
+      create_offset=True,
+      name='pair_layer_norm')(
+          representations['pair'])
+
+  safe_keys = safe_key.split(c.num_layer)
+  outputs = []
+  for key in safe_keys:
+
+    activations, output = fold_iteration(
+        activations,
+        initial_act=initial_act,
+        static_feat_2d=act_2d,
+        aatype=batch['aatype'],
+        safe_key=key,
+        sequence_mask=sequence_mask,
+        update_rigid=True,
+        is_training=is_training,
+        )
+    outputs.append(output)
+
+  output = jax.tree_map(lambda *x: jnp.stack(x), *outputs)
+  # Pass along for LDDT-Head.
+  output['act'] = activations['act']
+
+  return output
+
+
+class StructureModule(hk.Module):
+  """"""StructureModule as a network head.
+
+  Jumper et al. (2021) Suppl. Alg. 20 ""StructureModule""
+  """"""
+
+  def __init__(self,
+               config: ml_collections.ConfigDict,
+               global_config: ml_collections.ConfigDict,
+               name: str = 'structure_module'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               representations: Mapping[str, jnp.ndarray],
+               batch: Mapping[str, Any],
+               is_training: bool,
+               safe_key: Optional[prng.SafeKey] = None,
+               compute_loss: bool = False
+               ) -> Dict[str, Any]:
+    c = self.config
+    ret = {}
+
+    if safe_key is None:
+      safe_key = prng.SafeKey(hk.next_rng_key())
+
+    output = generate_monomer_rigids(
+        representations=representations,
+        batch=batch,
+        config=self.config,
+        global_config=self.global_config,
+        is_training=is_training,
+        safe_key=safe_key)
+
+    ret['traj'] = output['rigid'].scale_translation(c.position_scale).to_array()
+    ret['sidechains'] = output['sc']
+    ret['sidechains']['atom_pos'] = ret['sidechains']['atom_pos'].to_array()
+    ret['sidechains']['frames'] = ret['sidechains']['frames'].to_array()
+    if 'local_atom_pos' in ret['sidechains']:
+      ret['sidechains']['local_atom_pos'] = ret['sidechains'][
+          'local_atom_pos'].to_array()
+      ret['sidechains']['local_frames'] = ret['sidechains'][
+          'local_frames'].to_array()
+
+    aatype = batch['aatype']
+    seq_mask = batch['seq_mask']
+
+    atom14_pred_mask = all_atom_multimer.get_atom14_mask(
+        aatype) * seq_mask[:, None]
+    atom14_pred_positions = output['sc']['atom_pos'][-1]
+    ret['final_atom14_positions'] = atom14_pred_positions  # (N, 14, 3)
+    ret['final_atom14_mask'] = atom14_pred_mask  # (N, 14)
+
+    atom37_mask = all_atom_multimer.get_atom37_mask(aatype) * seq_mask[:, None]
+    atom37_pred_positions = all_atom_multimer.atom14_to_atom37(
+        atom14_pred_positions, aatype)
+    atom37_pred_positions *= atom37_mask[:, :, None]
+    ret['final_atom_positions'] = atom37_pred_positions  # (N, 37, 3)
+    ret['final_atom_mask'] = atom37_mask  # (N, 37)
+    ret['final_rigids'] = ret['traj'][-1]
+
+    ret['act'] = output['act']
+
+    if compute_loss:
+      return ret
+    else:
+      no_loss_features = ['final_atom_positions', 'final_atom_mask', 'act']
+      no_loss_ret = {k: ret[k] for k in no_loss_features}
+      return no_loss_ret
+
+  def loss(self,
+           value: Mapping[str, Any],
+           batch: Mapping[str, Any]
+           ) -> Dict[str, Any]:
+
+    raise NotImplementedError(
+        'This function should be called on a batch with reordered chains (see '
+        'Evans et al (2021) Section 7.3. Multi-Chain Permutation Alignment.')
+
+    ret = {'loss': 0.}
+
+    ret['metrics'] = {}
+
+    aatype = batch['aatype']
+    all_atom_positions = batch['all_atom_positions']
+    all_atom_positions = geometry.Vec3Array.from_array(all_atom_positions)
+    all_atom_mask = batch['all_atom_mask']
+    seq_mask = batch['seq_mask']
+    residue_index = batch['residue_index']
+
+    gt_rigid, gt_affine_mask = make_backbone_affine(all_atom_positions,
+                                                    all_atom_mask,
+                                                    aatype)
+
+    chi_angles, chi_mask = all_atom_multimer.compute_chi_angles(
+        all_atom_positions, all_atom_mask, aatype)
+
+    pred_mask = all_atom_multimer.get_atom14_mask(aatype)
+    pred_mask *= seq_mask[:, None]
+    pred_positions = value['final_atom14_positions']
+    pred_positions = geometry.Vec3Array.from_array(pred_positions)
+
+    gt_positions, gt_mask, alt_naming_is_better = compute_atom14_gt(
+        aatype, all_atom_positions, all_atom_mask, pred_positions)
+
+    violations = find_structural_violations(
+        aatype=aatype,
+        residue_index=residue_index,
+        mask=pred_mask,
+        pred_positions=pred_positions,
+        config=self.config,
+        asym_id=batch['asym_id'])
+
+    sidechains = value['sidechains']
+
+    gt_chi_angles = get_renamed_chi_angles(aatype, chi_angles,
+                                           alt_naming_is_better)
+
+    # Several violation metrics:
+    violation_metrics = compute_violation_metrics(
+        residue_index=residue_index,
+        mask=pred_mask,
+        seq_mask=seq_mask,
+        pred_positions=pred_positions,
+        violations=violations)
+    ret['metrics'].update(violation_metrics)
+
+    target_rigid = geometry.Rigid3Array.from_array(value['traj'])
+    gt_frames_mask = gt_affine_mask
+
+    # Split the loss into within-chain and between-chain components.
+    intra_chain_mask = batch['asym_id'][:, None] == batch['asym_id'][None, :]
+    intra_chain_bb_loss, intra_chain_fape = backbone_loss(
+        gt_rigid=gt_rigid,
+        gt_frames_mask=gt_frames_mask,
+        gt_positions_mask=gt_affine_mask,
+        target_rigid=target_rigid,
+        config=self.config.intra_chain_fape,
+        pair_mask=intra_chain_mask)
+    interface_bb_loss, interface_fape = backbone_loss(
+        gt_rigid=gt_rigid,
+        gt_frames_mask=gt_frames_mask,
+        gt_positions_mask=gt_affine_mask,
+        target_rigid=target_rigid,
+        config=self.config.interface_fape,
+        pair_mask=1. - intra_chain_mask)
+
+    bb_loss = intra_chain_bb_loss + interface_bb_loss
+    ret['fape'] = intra_chain_fape + interface_fape
+    ret['bb_loss'] = bb_loss
+    ret['loss'] += bb_loss
+
+    pred_frames = geometry.Rigid3Array.from_array(sidechains['frames'])
+    pred_positions = geometry.Vec3Array.from_array(sidechains['atom_pos'])
+    gt_sc_frames, gt_sc_frames_mask = compute_frames(
+        aatype=aatype,
+        all_atom_positions=all_atom_positions,
+        all_atom_mask=all_atom_mask,
+        use_alt=alt_naming_is_better)
+
+    sc_loss = sidechain_loss(
+        gt_frames=gt_sc_frames,
+        gt_frames_mask=gt_sc_frames_mask,
+        gt_positions=gt_positions,
+        gt_mask=gt_mask,
+        pred_frames=pred_frames,
+        pred_positions=pred_positions,
+        config=self.config)
+
+    ret['loss'] = ((1 - self.config.sidechain.weight_frac) * ret['loss'] +
+                   self.config.sidechain.weight_frac * sc_loss['loss'])
+    ret['sidechain_fape'] = sc_loss['fape']
+
+    unnormed_angles = sidechains['unnormalized_angles_sin_cos']
+    pred_angles = sidechains['angles_sin_cos']
+
+    sup_chi_loss, ret['chi_loss'], ret[
+        'angle_norm_loss'] = supervised_chi_loss(
+            sequence_mask=seq_mask,
+            target_chi_mask=chi_mask,
+            target_chi_angles=gt_chi_angles,
+            aatype=aatype,
+            pred_angles=pred_angles,
+            unnormed_angles=unnormed_angles,
+            config=self.config)
+    ret['loss'] += sup_chi_loss
+
+    if self.config.structural_violation_loss_weight:
+
+      ret['loss'] += structural_violation_loss(
+          mask=pred_mask, violations=violations, config=self.config)
+
+    return ret
+
+
+def compute_atom14_gt(
+    aatype: jnp.ndarray,
+    all_atom_positions: geometry.Vec3Array,
+    all_atom_mask: jnp.ndarray,
+    pred_pos: geometry.Vec3Array
+) -> Tuple[geometry.Vec3Array, jnp.ndarray, jnp.ndarray]:
+  """"""Find atom14 positions, this includes finding the correct renaming.""""""
+  gt_positions, gt_mask = all_atom_multimer.atom37_to_atom14(
+      aatype, all_atom_positions,
+      all_atom_mask)
+  alt_gt_positions, alt_gt_mask = all_atom_multimer.get_alt_atom14(
+      aatype, gt_positions, gt_mask)
+  atom_is_ambiguous = all_atom_multimer.get_atom14_is_ambiguous(aatype)
+
+  alt_naming_is_better = all_atom_multimer.find_optimal_renaming(
+      gt_positions=gt_positions,
+      alt_gt_positions=alt_gt_positions,
+      atom_is_ambiguous=atom_is_ambiguous,
+      gt_exists=gt_mask,
+      pred_positions=pred_pos)
+
+  use_alt = alt_naming_is_better[:, None]
+
+  gt_mask = (1. - use_alt) * gt_mask + use_alt * alt_gt_mask
+  gt_positions = (1. - use_alt) * gt_positions + use_alt * alt_gt_positions
+
+  return gt_positions, alt_gt_mask, alt_naming_is_better
+
+
+def backbone_loss(gt_rigid: geometry.Rigid3Array,
+                  gt_frames_mask: jnp.ndarray,
+                  gt_positions_mask: jnp.ndarray,
+                  target_rigid: geometry.Rigid3Array,
+                  config: ml_collections.ConfigDict,
+                  pair_mask: jnp.ndarray
+                  ) -> Tuple[Float, jnp.ndarray]:
+  """"""Backbone FAPE Loss.""""""
+  loss_fn = functools.partial(
+      all_atom_multimer.frame_aligned_point_error,
+      l1_clamp_distance=config.atom_clamp_distance,
+      length_scale=config.loss_unit_distance)
+
+  loss_fn = jax.vmap(loss_fn, (0, None, None, 0, None, None, None))
+  fape = loss_fn(target_rigid, gt_rigid, gt_frames_mask,
+                 target_rigid.translation, gt_rigid.translation,
+                 gt_positions_mask, pair_mask)
+
+  return jnp.mean(fape), fape[-1]
+
+
+def compute_frames(
+    aatype: jnp.ndarray,
+    all_atom_positions: geometry.Vec3Array,
+    all_atom_mask: jnp.ndarray,
+    use_alt: jnp.ndarray
+    ) -> Tuple[geometry.Rigid3Array, jnp.ndarray]:
+  """"""Compute Frames from all atom positions.
+
+  Args:
+    aatype: array of aatypes, int of [N]
+    all_atom_positions: Vector of all atom positions, shape [N, 37]
+    all_atom_mask: mask, shape [N]
+    use_alt: whether to use alternative orientation for ambiguous aatypes
+             shape [N]
+  Returns:
+    Rigid corresponding to Frames w shape [N, 8],
+    mask which Rigids are present w shape [N, 8]
+  """"""
+  frames_batch = all_atom_multimer.atom37_to_frames(aatype, all_atom_positions,
+                                                    all_atom_mask)
+  gt_frames = frames_batch['rigidgroups_gt_frames']
+  alt_gt_frames = frames_batch['rigidgroups_alt_gt_frames']
+  use_alt = use_alt[:, None]
+
+  renamed_gt_frames = jax.tree_map(
+      lambda x, y: (1. - use_alt) * x + use_alt * y, gt_frames, alt_gt_frames)
+
+  return renamed_gt_frames, frames_batch['rigidgroups_gt_exists']
+
+
+def sidechain_loss(gt_frames: geometry.Rigid3Array,
+                   gt_frames_mask: jnp.ndarray,
+                   gt_positions: geometry.Vec3Array,
+                   gt_mask: jnp.ndarray,
+                   pred_frames: geometry.Rigid3Array,
+                   pred_positions: geometry.Vec3Array,
+                   config: ml_collections.ConfigDict
+                   ) -> Dict[str, jnp.ndarray]:
+  """"""Sidechain Loss using cleaned up rigids.""""""
+
+  flat_gt_frames = jax.tree_map(jnp.ravel, gt_frames)
+  flat_frames_mask = jnp.ravel(gt_frames_mask)
+
+  flat_gt_positions = jax.tree_map(jnp.ravel, gt_positions)
+  flat_positions_mask = jnp.ravel(gt_mask)
+
+  # Compute frame_aligned_point_error score for the final layer.
+  def _slice_last_layer_and_flatten(x):
+    return jnp.ravel(x[-1])
+
+  flat_pred_frames = jax.tree_map(_slice_last_layer_and_flatten, pred_frames)
+  flat_pred_positions = jax.tree_map(_slice_last_layer_and_flatten,
+                                     pred_positions)
+  fape = all_atom_multimer.frame_aligned_point_error(
+      pred_frames=flat_pred_frames,
+      target_frames=flat_gt_frames,
+      frames_mask=flat_frames_mask,
+      pred_positions=flat_pred_positions,
+      target_positions=flat_gt_positions,
+      positions_mask=flat_positions_mask,
+      pair_mask=None,
+      length_scale=config.sidechain.loss_unit_distance,
+      l1_clamp_distance=config.sidechain.atom_clamp_distance)
+
+  return {
+      'fape': fape,
+      'loss': fape}
+
+
+def structural_violation_loss(mask: jnp.ndarray,
+                              violations: Mapping[str, Float],
+                              config: ml_collections.ConfigDict
+                              ) -> Float:
+  """"""Computes Loss for structural Violations.""""""
+  # Put all violation losses together to one large loss.
+  num_atoms = jnp.sum(mask).astype(jnp.float32) + 1e-6
+  between_residues = violations['between_residues']
+  within_residues = violations['within_residues']
+  return (config.structural_violation_loss_weight *
+          (between_residues['bonds_c_n_loss_mean'] +
+           between_residues['angles_ca_c_n_loss_mean']  +
+           between_residues['angles_c_n_ca_loss_mean'] +
+           jnp.sum(between_residues['clashes_per_atom_loss_sum'] +
+                   within_residues['per_atom_loss_sum']) / num_atoms
+           ))
+
+
+def find_structural_violations(
+    aatype: jnp.ndarray,
+    residue_index: jnp.ndarray,
+    mask: jnp.ndarray,
+    pred_positions: geometry.Vec3Array,  # (N, 14)
+    config: ml_collections.ConfigDict,
+    asym_id: jnp.ndarray,
+    ) -> Dict[str, Any]:
+  """"""Computes several checks for structural Violations.""""""
+
+  # Compute between residue backbone violations of bonds and angles.
+  connection_violations = all_atom_multimer.between_residue_bond_loss(
+      pred_atom_positions=pred_positions,
+      pred_atom_mask=mask.astype(jnp.float32),
+      residue_index=residue_index.astype(jnp.float32),
+      aatype=aatype,
+      tolerance_factor_soft=config.violation_tolerance_factor,
+      tolerance_factor_hard=config.violation_tolerance_factor)
+
+  # Compute the van der Waals radius for every atom
+  # (the first letter of the atom name is the element type).
+  # shape (N, 14)
+  atomtype_radius = jnp.array([
+      residue_constants.van_der_waals_radius[name[0]]
+      for name in residue_constants.atom_types
+  ])
+  residx_atom14_to_atom37 = all_atom_multimer.get_atom14_to_atom37_map(aatype)
+  atom_radius = mask * utils.batched_gather(atomtype_radius,
+                                            residx_atom14_to_atom37)
+
+  # Compute the between residue clash loss.
+  between_residue_clashes = all_atom_multimer.between_residue_clash_loss(
+      pred_positions=pred_positions,
+      atom_exists=mask,
+      atom_radius=atom_radius,
+      residue_index=residue_index,
+      overlap_tolerance_soft=config.clash_overlap_tolerance,
+      overlap_tolerance_hard=config.clash_overlap_tolerance,
+      asym_id=asym_id)
+
+  # Compute all within-residue violations (clashes,
+  # bond length and angle violations).
+  restype_atom14_bounds = residue_constants.make_atom14_dists_bounds(
+      overlap_tolerance=config.clash_overlap_tolerance,
+      bond_length_tolerance_factor=config.violation_tolerance_factor)
+  dists_lower_bound = utils.batched_gather(restype_atom14_bounds['lower_bound'],
+                                           aatype)
+  dists_upper_bound = utils.batched_gather(restype_atom14_bounds['upper_bound'],
+                                           aatype)
+  within_residue_violations = all_atom_multimer.within_residue_violations(
+      pred_positions=pred_positions,
+      atom_exists=mask,
+      dists_lower_bound=dists_lower_bound,
+      dists_upper_bound=dists_upper_bound,
+      tighten_bounds_for_loss=0.0)
+
+  # Combine them to a single per-residue violation mask (used later for LDDT).
+  per_residue_violations_mask = jnp.max(jnp.stack([
+      connection_violations['per_residue_violation_mask'],
+      jnp.max(between_residue_clashes['per_atom_clash_mask'], axis=-1),
+      jnp.max(within_residue_violations['per_atom_violations'],
+              axis=-1)]), axis=0)
+
+  return {
+      'between_residues': {
+          'bonds_c_n_loss_mean':
+              connection_violations['c_n_loss_mean'],  # ()
+          'angles_ca_c_n_loss_mean':
+              connection_violations['ca_c_n_loss_mean'],  # ()
+          'angles_c_n_ca_loss_mean':
+              connection_violations['c_n_ca_loss_mean'],  # ()
+          'connections_per_residue_loss_sum':
+              connection_violations['per_residue_loss_sum'],  # (N)
+          'connections_per_residue_violation_mask':
+              connection_violations['per_residue_violation_mask'],  # (N)
+          'clashes_mean_loss':
+              between_residue_clashes['mean_loss'],  # ()
+          'clashes_per_atom_loss_sum':
+              between_residue_clashes['per_atom_loss_sum'],  # (N, 14)
+          'clashes_per_atom_clash_mask':
+              between_residue_clashes['per_atom_clash_mask'],  # (N, 14)
+      },
+      'within_residues': {
+          'per_atom_loss_sum':
+              within_residue_violations['per_atom_loss_sum'],  # (N, 14)
+          'per_atom_violations':
+              within_residue_violations['per_atom_violations'],  # (N, 14),
+      },
+      'total_per_residue_violations_mask':
+          per_residue_violations_mask,  # (N)
+  }
+
+
+def compute_violation_metrics(
+    residue_index: jnp.ndarray,
+    mask: jnp.ndarray,
+    seq_mask: jnp.ndarray,
+    pred_positions: geometry.Vec3Array,  # (N, 14)
+    violations: Mapping[str, jnp.ndarray],
+) -> Dict[str, jnp.ndarray]:
+  """"""Compute several metrics to assess the structural violations.""""""
+  ret = {}
+  between_residues = violations['between_residues']
+  within_residues = violations['within_residues']
+  extreme_ca_ca_violations = all_atom_multimer.extreme_ca_ca_distance_violations(
+      positions=pred_positions,
+      mask=mask.astype(jnp.float32),
+      residue_index=residue_index.astype(jnp.float32))
+  ret['violations_extreme_ca_ca_distance'] = extreme_ca_ca_violations
+  ret['violations_between_residue_bond'] = utils.mask_mean(
+      mask=seq_mask,
+      value=between_residues['connections_per_residue_violation_mask'])
+  ret['violations_between_residue_clash'] = utils.mask_mean(
+      mask=seq_mask,
+      value=jnp.max(between_residues['clashes_per_atom_clash_mask'], axis=-1))
+  ret['violations_within_residue'] = utils.mask_mean(
+      mask=seq_mask,
+      value=jnp.max(within_residues['per_atom_violations'], axis=-1))
+  ret['violations_per_residue'] = utils.mask_mean(
+      mask=seq_mask, value=violations['total_per_residue_violations_mask'])
+  return ret
+
+
+def supervised_chi_loss(
+    sequence_mask: jnp.ndarray,
+    target_chi_mask: jnp.ndarray,
+    aatype: jnp.ndarray,
+    target_chi_angles: jnp.ndarray,
+    pred_angles: jnp.ndarray,
+    unnormed_angles: jnp.ndarray,
+    config: ml_collections.ConfigDict) -> Tuple[Float, Float, Float]:
+  """"""Computes loss for direct chi angle supervision.""""""
+  eps = 1e-6
+  chi_mask = target_chi_mask.astype(jnp.float32)
+
+  pred_angles = pred_angles[:, :, 3:]
+
+  residue_type_one_hot = jax.nn.one_hot(
+      aatype, residue_constants.restype_num + 1, dtype=jnp.float32)[None]
+  chi_pi_periodic = jnp.einsum('ijk, kl->ijl', residue_type_one_hot,
+                               jnp.asarray(residue_constants.chi_pi_periodic))
+
+  true_chi = target_chi_angles[None]
+  sin_true_chi = jnp.sin(true_chi)
+  cos_true_chi = jnp.cos(true_chi)
+  sin_cos_true_chi = jnp.stack([sin_true_chi, cos_true_chi], axis=-1)
+
+  # This is -1 if chi is pi periodic and +1 if it's 2 pi periodic
+  shifted_mask = (1 - 2 * chi_pi_periodic)[..., None]
+  sin_cos_true_chi_shifted = shifted_mask * sin_cos_true_chi
+
+  sq_chi_error = jnp.sum(
+      squared_difference(sin_cos_true_chi, pred_angles), -1)
+  sq_chi_error_shifted = jnp.sum(
+      squared_difference(sin_cos_true_chi_shifted, pred_angles), -1)
+  sq_chi_error = jnp.minimum(sq_chi_error, sq_chi_error_shifted)
+
+  sq_chi_loss = utils.mask_mean(mask=chi_mask[None], value=sq_chi_error)
+  angle_norm = jnp.sqrt(jnp.sum(jnp.square(unnormed_angles), axis=-1) + eps)
+  norm_error = jnp.abs(angle_norm - 1.)
+  angle_norm_loss = utils.mask_mean(mask=sequence_mask[None, :, None],
+                                    value=norm_error)
+  loss = (config.chi_weight * sq_chi_loss
+          + config.angle_norm_weight * angle_norm_loss)
+  return loss, sq_chi_loss, angle_norm_loss
+
+
+def l2_normalize(x: jnp.ndarray,
+                 axis: int = -1,
+                 epsilon: float = 1e-12
+                 ) -> jnp.ndarray:
+  return x / jnp.sqrt(
+      jnp.maximum(jnp.sum(x**2, axis=axis, keepdims=True), epsilon))
+
+
+def get_renamed_chi_angles(aatype: jnp.ndarray,
+                           chi_angles: jnp.ndarray,
+                           alt_is_better: jnp.ndarray
+                           ) -> jnp.ndarray:
+  """"""Return renamed chi angles.""""""
+  chi_angle_is_ambiguous = utils.batched_gather(
+      jnp.array(residue_constants.chi_pi_periodic, dtype=jnp.float32), aatype)
+  alt_chi_angles = chi_angles + np.pi * chi_angle_is_ambiguous
+  # Map back to [-pi, pi].
+  alt_chi_angles = alt_chi_angles - 2 * np.pi * (alt_chi_angles > np.pi).astype(
+      jnp.float32)
+  alt_is_better = alt_is_better[:, None]
+  return (1. - alt_is_better) * chi_angles + alt_is_better * alt_chi_angles
+
+
+class MultiRigidSidechain(hk.Module):
+  """"""Class to make side chain atoms.""""""
+
+  def __init__(self,
+               config: ml_collections.ConfigDict,
+               global_config: ml_collections.ConfigDict,
+               name: str = 'rigid_sidechain'):
+    super().__init__(name=name)
+    self.config = config
+    self.global_config = global_config
+
+  def __call__(self,
+               rigid: geometry.Rigid3Array,
+               representations_list: Iterable[jnp.ndarray],
+               aatype: jnp.ndarray
+               ) -> Dict[str, Any]:
+    """"""Predict sidechains using multi-rigid representations.
+
+    Args:
+      rigid: The Rigid's for each residue (translations in angstoms)
+      representations_list: A list of activations to predict sidechains from.
+      aatype: amino acid types.
+
+    Returns:
+      dict containing atom positions and frames (in angstrom)
+    """"""
+    act = [
+        common_modules.Linear(  # pylint: disable=g-complex-comprehension
+            self.config.num_channel,
+            name='input_projection')(jax.nn.relu(x))
+        for x in representations_list]
+    # Sum the activation list (equivalent to concat then Conv1D)
+    act = sum(act)
+
+    final_init = 'zeros' if self.global_config.zero_init else 'linear'
+
+    # Mapping with some residual blocks.
+    for _ in range(self.config.num_residual_block):
+      old_act = act
+      act = common_modules.Linear(
+          self.config.num_channel,
+          initializer='relu',
+          name='resblock1')(
+              jax.nn.relu(act))
+      act = common_modules.Linear(
+          self.config.num_channel,
+          initializer=final_init,
+          name='resblock2')(
+              jax.nn.relu(act))
+      act += old_act
+
+    # Map activations to torsion angles.
+    # [batch_size, num_res, 14]
+    num_res = act.shape[0]
+    unnormalized_angles = common_modules.Linear(
+        14, name='unnormalized_angles')(
+            jax.nn.relu(act))
+    unnormalized_angles = jnp.reshape(
+        unnormalized_angles, [num_res, 7, 2])
+    angles = l2_normalize(unnormalized_angles, axis=-1)
+
+    outputs = {
+        'angles_sin_cos': angles,  # jnp.ndarray (N, 7, 2)
+        'unnormalized_angles_sin_cos':
+            unnormalized_angles,  # jnp.ndarray (N, 7, 2)
+    }
+
+    # Map torsion angles to frames.
+    # geometry.Rigid3Array with shape (N, 8)
+    all_frames_to_global = all_atom_multimer.torsion_angles_to_frames(
+        aatype,
+        rigid,
+        angles)
+
+    # Use frames and literature positions to create the final atom coordinates.
+    # geometry.Vec3Array with shape (N, 14)
+    pred_positions = all_atom_multimer.frames_and_literature_positions_to_atom14_pos(
+        aatype, all_frames_to_global)
+
+    outputs.update({
+        'atom_pos': pred_positions,  # geometry.Vec3Array (N, 14)
+        'frames': all_frames_to_global,  # geometry.Rigid3Array (N, 8)
+    })
+    return outputs
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/all_atom.py",".py","47028","1142","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Ops for all atom representations.
+
+Generally we employ two different representations for all atom coordinates,
+one is atom37 where each heavy atom corresponds to a given position in a 37
+dimensional array, This mapping is non amino acid specific, but each slot
+corresponds to an atom of a given name, for example slot 12 always corresponds
+to 'C delta 1', positions that are not present for a given amino acid are
+zeroed out and denoted by a mask.
+The other representation we employ is called atom14, this is a more dense way
+of representing atoms with 14 slots. Here a given slot will correspond to a
+different kind of atom depending on amino acid type, for example slot 5
+corresponds to 'N delta 2' for Aspargine, but to 'C delta 1' for Isoleucine.
+14 is chosen because it is the maximum number of heavy atoms for any standard
+amino acid.
+The order of slots can be found in 'residue_constants.residue_atoms'.
+Internally the model uses the atom14 representation because it is
+computationally more efficient.
+The internal atom14 representation is turned into the atom37 at the output of
+the network to facilitate easier conversion to existing protein datastructures.
+""""""
+
+from typing import Dict, Optional
+from alphafold.common import residue_constants
+
+from alphafold.model import r3
+from alphafold.model import utils
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+
+def squared_difference(x, y):
+  return jnp.square(x - y)
+
+
+def get_chi_atom_indices():
+  """"""Returns atom indices needed to compute chi angles for all residue types.
+
+  Returns:
+    A tensor of shape [residue_types=21, chis=4, atoms=4]. The residue types are
+    in the order specified in residue_constants.restypes + unknown residue type
+    at the end. For chi angles which are not defined on the residue, the
+    positions indices are by default set to 0.
+  """"""
+  chi_atom_indices = []
+  for residue_name in residue_constants.restypes:
+    residue_name = residue_constants.restype_1to3[residue_name]
+    residue_chi_angles = residue_constants.chi_angles_atoms[residue_name]
+    atom_indices = []
+    for chi_angle in residue_chi_angles:
+      atom_indices.append(
+          [residue_constants.atom_order[atom] for atom in chi_angle])
+    for _ in range(4 - len(atom_indices)):
+      atom_indices.append([0, 0, 0, 0])  # For chi angles not defined on the AA.
+    chi_atom_indices.append(atom_indices)
+
+  chi_atom_indices.append([[0, 0, 0, 0]] * 4)  # For UNKNOWN residue.
+
+  return jnp.asarray(chi_atom_indices)
+
+
+def atom14_to_atom37(atom14_data: jnp.ndarray,  # (N, 14, ...)
+                     batch: Dict[str, jnp.ndarray]
+                    ) -> jnp.ndarray:  # (N, 37, ...)
+  """"""Convert atom14 to atom37 representation.""""""
+  assert len(atom14_data.shape) in [2, 3]
+  assert 'residx_atom37_to_atom14' in batch
+  assert 'atom37_atom_exists' in batch
+
+  atom37_data = utils.batched_gather(atom14_data,
+                                     batch['residx_atom37_to_atom14'],
+                                     batch_dims=1)
+  if len(atom14_data.shape) == 2:
+    atom37_data *= batch['atom37_atom_exists']
+  elif len(atom14_data.shape) == 3:
+    atom37_data *= batch['atom37_atom_exists'][:, :,
+                                               None].astype(atom37_data.dtype)
+  return atom37_data
+
+
+def atom37_to_atom14(
+    atom37_data: jnp.ndarray,  # (N, 37, ...)
+    batch: Dict[str, jnp.ndarray]) -> jnp.ndarray:  # (N, 14, ...)
+  """"""Convert atom14 to atom37 representation.""""""
+  assert len(atom37_data.shape) in [2, 3]
+  assert 'residx_atom14_to_atom37' in batch
+  assert 'atom14_atom_exists' in batch
+
+  atom14_data = utils.batched_gather(atom37_data,
+                                     batch['residx_atom14_to_atom37'],
+                                     batch_dims=1)
+  if len(atom37_data.shape) == 2:
+    atom14_data *= batch['atom14_atom_exists'].astype(atom14_data.dtype)
+  elif len(atom37_data.shape) == 3:
+    atom14_data *= batch['atom14_atom_exists'][:, :,
+                                               None].astype(atom14_data.dtype)
+  return atom14_data
+
+
+def atom37_to_frames(
+    aatype: jnp.ndarray,  # (...)
+    all_atom_positions: jnp.ndarray,  # (..., 37, 3)
+    all_atom_mask: jnp.ndarray,  # (..., 37)
+) -> Dict[str, jnp.ndarray]:
+  """"""Computes the frames for the up to 8 rigid groups for each residue.
+
+  The rigid groups are defined by the possible torsions in a given amino acid.
+  We group the atoms according to their dependence on the torsion angles into
+  ""rigid groups"".  E.g., the position of atoms in the chi2-group depend on
+  chi1 and chi2, but do not depend on chi3 or chi4.
+  Jumper et al. (2021) Suppl. Table 2 and corresponding text.
+
+  Args:
+    aatype: Amino acid type, given as array with integers.
+    all_atom_positions: atom37 representation of all atom coordinates.
+    all_atom_mask: atom37 representation of mask on all atom coordinates.
+  Returns:
+    Dictionary containing:
+      * 'rigidgroups_gt_frames': 8 Frames corresponding to 'all_atom_positions'
+           represented as flat 12 dimensional array.
+      * 'rigidgroups_gt_exists': Mask denoting whether the atom positions for
+          the given frame are available in the ground truth, e.g. if they were
+          resolved in the experiment.
+      * 'rigidgroups_group_exists': Mask denoting whether given group is in
+          principle present for given amino acid type.
+      * 'rigidgroups_group_is_ambiguous': Mask denoting whether frame is
+          affected by naming ambiguity.
+      * 'rigidgroups_alt_gt_frames': 8 Frames with alternative atom renaming
+          corresponding to 'all_atom_positions' represented as flat
+          12 dimensional array.
+  """"""
+  # 0: 'backbone group',
+  # 1: 'pre-omega-group', (empty)
+  # 2: 'phi-group', (currently empty, because it defines only hydrogens)
+  # 3: 'psi-group',
+  # 4,5,6,7: 'chi1,2,3,4-group'
+  aatype_in_shape = aatype.shape
+
+  # If there is a batch axis, just flatten it away, and reshape everything
+  # back at the end of the function.
+  aatype = jnp.reshape(aatype, [-1])
+  all_atom_positions = jnp.reshape(all_atom_positions, [-1, 37, 3])
+  all_atom_mask = jnp.reshape(all_atom_mask, [-1, 37])
+
+  # Create an array with the atom names.
+  # shape (num_restypes, num_rigidgroups, 3_atoms): (21, 8, 3)
+  restype_rigidgroup_base_atom_names = np.full([21, 8, 3], '', dtype=object)
+
+  # 0: backbone frame
+  restype_rigidgroup_base_atom_names[:, 0, :] = ['C', 'CA', 'N']
+
+  # 3: 'psi-group'
+  restype_rigidgroup_base_atom_names[:, 3, :] = ['CA', 'C', 'O']
+
+  # 4,5,6,7: 'chi1,2,3,4-group'
+  for restype, restype_letter in enumerate(residue_constants.restypes):
+    resname = residue_constants.restype_1to3[restype_letter]
+    for chi_idx in range(4):
+      if residue_constants.chi_angles_mask[restype][chi_idx]:
+        atom_names = residue_constants.chi_angles_atoms[resname][chi_idx]
+        restype_rigidgroup_base_atom_names[
+            restype, chi_idx + 4, :] = atom_names[1:]
+
+  # Create mask for existing rigid groups.
+  restype_rigidgroup_mask = np.zeros([21, 8], dtype=np.float32)
+  restype_rigidgroup_mask[:, 0] = 1
+  restype_rigidgroup_mask[:, 3] = 1
+  restype_rigidgroup_mask[:20, 4:] = residue_constants.chi_angles_mask
+
+  # Translate atom names into atom37 indices.
+  lookuptable = residue_constants.atom_order.copy()
+  lookuptable[''] = 0
+  restype_rigidgroup_base_atom37_idx = np.vectorize(lambda x: lookuptable[x])(
+      restype_rigidgroup_base_atom_names)
+
+  # Compute the gather indices for all residues in the chain.
+  # shape (N, 8, 3)
+  residx_rigidgroup_base_atom37_idx = utils.batched_gather(
+      restype_rigidgroup_base_atom37_idx, aatype)
+
+  # Gather the base atom positions for each rigid group.
+  base_atom_pos = utils.batched_gather(
+      all_atom_positions,
+      residx_rigidgroup_base_atom37_idx,
+      batch_dims=1)
+
+  # Compute the Rigids.
+  gt_frames = r3.rigids_from_3_points(
+      point_on_neg_x_axis=r3.vecs_from_tensor(base_atom_pos[:, :, 0, :]),
+      origin=r3.vecs_from_tensor(base_atom_pos[:, :, 1, :]),
+      point_on_xy_plane=r3.vecs_from_tensor(base_atom_pos[:, :, 2, :])
+  )
+
+  # Compute a mask whether the group exists.
+  # (N, 8)
+  group_exists = utils.batched_gather(restype_rigidgroup_mask, aatype)
+
+  # Compute a mask whether ground truth exists for the group
+  gt_atoms_exist = utils.batched_gather(  # shape (N, 8, 3)
+      all_atom_mask.astype(jnp.float32),
+      residx_rigidgroup_base_atom37_idx,
+      batch_dims=1)
+  gt_exists = jnp.min(gt_atoms_exist, axis=-1) * group_exists  # (N, 8)
+
+  # Adapt backbone frame to old convention (mirror x-axis and z-axis).
+  rots = np.tile(np.eye(3, dtype=np.float32), [8, 1, 1])
+  rots[0, 0, 0] = -1
+  rots[0, 2, 2] = -1
+  gt_frames = r3.rigids_mul_rots(gt_frames, r3.rots_from_tensor3x3(rots))
+
+  # The frames for ambiguous rigid groups are just rotated by 180 degree around
+  # the x-axis. The ambiguous group is always the last chi-group.
+  restype_rigidgroup_is_ambiguous = np.zeros([21, 8], dtype=np.float32)
+  restype_rigidgroup_rots = np.tile(np.eye(3, dtype=np.float32), [21, 8, 1, 1])
+
+  for resname, _ in residue_constants.residue_atom_renaming_swaps.items():
+    restype = residue_constants.restype_order[
+        residue_constants.restype_3to1[resname]]
+    chi_idx = int(sum(residue_constants.chi_angles_mask[restype]) - 1)
+    restype_rigidgroup_is_ambiguous[restype, chi_idx + 4] = 1
+    restype_rigidgroup_rots[restype, chi_idx + 4, 1, 1] = -1
+    restype_rigidgroup_rots[restype, chi_idx + 4, 2, 2] = -1
+
+  # Gather the ambiguity information for each residue.
+  residx_rigidgroup_is_ambiguous = utils.batched_gather(
+      restype_rigidgroup_is_ambiguous, aatype)
+  residx_rigidgroup_ambiguity_rot = utils.batched_gather(
+      restype_rigidgroup_rots, aatype)
+
+  # Create the alternative ground truth frames.
+  alt_gt_frames = r3.rigids_mul_rots(
+      gt_frames, r3.rots_from_tensor3x3(residx_rigidgroup_ambiguity_rot))
+
+  gt_frames_flat12 = r3.rigids_to_tensor_flat12(gt_frames)
+  alt_gt_frames_flat12 = r3.rigids_to_tensor_flat12(alt_gt_frames)
+
+  # reshape back to original residue layout
+  gt_frames_flat12 = jnp.reshape(gt_frames_flat12, aatype_in_shape + (8, 12))
+  gt_exists = jnp.reshape(gt_exists, aatype_in_shape + (8,))
+  group_exists = jnp.reshape(group_exists, aatype_in_shape + (8,))
+  gt_frames_flat12 = jnp.reshape(gt_frames_flat12, aatype_in_shape + (8, 12))
+  residx_rigidgroup_is_ambiguous = jnp.reshape(residx_rigidgroup_is_ambiguous,
+                                               aatype_in_shape + (8,))
+  alt_gt_frames_flat12 = jnp.reshape(alt_gt_frames_flat12,
+                                     aatype_in_shape + (8, 12,))
+
+  return {
+      'rigidgroups_gt_frames': gt_frames_flat12,  # (..., 8, 12)
+      'rigidgroups_gt_exists': gt_exists,  # (..., 8)
+      'rigidgroups_group_exists': group_exists,  # (..., 8)
+      'rigidgroups_group_is_ambiguous':
+          residx_rigidgroup_is_ambiguous,  # (..., 8)
+      'rigidgroups_alt_gt_frames': alt_gt_frames_flat12,  # (..., 8, 12)
+  }
+
+
+def atom37_to_torsion_angles(
+    aatype: jnp.ndarray,  # (B, N)
+    all_atom_pos: jnp.ndarray,  # (B, N, 37, 3)
+    all_atom_mask: jnp.ndarray,  # (B, N, 37)
+    placeholder_for_undefined=False,
+) -> Dict[str, jnp.ndarray]:
+  """"""Computes the 7 torsion angles (in sin, cos encoding) for each residue.
+
+  The 7 torsion angles are in the order
+  '[pre_omega, phi, psi, chi_1, chi_2, chi_3, chi_4]',
+  here pre_omega denotes the omega torsion angle between the given amino acid
+  and the previous amino acid.
+
+  Args:
+    aatype: Amino acid type, given as array with integers.
+    all_atom_pos: atom37 representation of all atom coordinates.
+    all_atom_mask: atom37 representation of mask on all atom coordinates.
+    placeholder_for_undefined: flag denoting whether to set masked torsion
+      angles to zero.
+  Returns:
+    Dict containing:
+      * 'torsion_angles_sin_cos': Array with shape (B, N, 7, 2) where the final
+        2 dimensions denote sin and cos respectively
+      * 'alt_torsion_angles_sin_cos': same as 'torsion_angles_sin_cos', but
+        with the angle shifted by pi for all chi angles affected by the naming
+        ambiguities.
+      * 'torsion_angles_mask': Mask for which chi angles are present.
+  """"""
+
+  # Map aatype > 20 to 'Unknown' (20).
+  aatype = jnp.minimum(aatype, 20)
+
+  # Compute the backbone angles.
+  num_batch, num_res = aatype.shape
+
+  pad = jnp.zeros([num_batch, 1, 37, 3], jnp.float32)
+  prev_all_atom_pos = jnp.concatenate([pad, all_atom_pos[:, :-1, :, :]], axis=1)
+
+  pad = jnp.zeros([num_batch, 1, 37], jnp.float32)
+  prev_all_atom_mask = jnp.concatenate([pad, all_atom_mask[:, :-1, :]], axis=1)
+
+  # For each torsion angle collect the 4 atom positions that define this angle.
+  # shape (B, N, atoms=4, xyz=3)
+  pre_omega_atom_pos = jnp.concatenate(
+      [prev_all_atom_pos[:, :, 1:3, :],  # prev CA, C
+       all_atom_pos[:, :, 0:2, :]  # this N, CA
+      ], axis=-2)
+  phi_atom_pos = jnp.concatenate(
+      [prev_all_atom_pos[:, :, 2:3, :],  # prev C
+       all_atom_pos[:, :, 0:3, :]  # this N, CA, C
+      ], axis=-2)
+  psi_atom_pos = jnp.concatenate(
+      [all_atom_pos[:, :, 0:3, :],  # this N, CA, C
+       all_atom_pos[:, :, 4:5, :]  # this O
+      ], axis=-2)
+
+  # Collect the masks from these atoms.
+  # Shape [batch, num_res]
+  pre_omega_mask = (
+      jnp.prod(prev_all_atom_mask[:, :, 1:3], axis=-1)  # prev CA, C
+      * jnp.prod(all_atom_mask[:, :, 0:2], axis=-1))  # this N, CA
+  phi_mask = (
+      prev_all_atom_mask[:, :, 2]  # prev C
+      * jnp.prod(all_atom_mask[:, :, 0:3], axis=-1))  # this N, CA, C
+  psi_mask = (
+      jnp.prod(all_atom_mask[:, :, 0:3], axis=-1) *  # this N, CA, C
+      all_atom_mask[:, :, 4])  # this O
+
+  # Collect the atoms for the chi-angles.
+  # Compute the table of chi angle indices. Shape: [restypes, chis=4, atoms=4].
+  chi_atom_indices = get_chi_atom_indices()
+  # Select atoms to compute chis. Shape: [batch, num_res, chis=4, atoms=4].
+  atom_indices = utils.batched_gather(
+      params=chi_atom_indices, indices=aatype, axis=0, batch_dims=0)
+  # Gather atom positions. Shape: [batch, num_res, chis=4, atoms=4, xyz=3].
+  chis_atom_pos = utils.batched_gather(
+      params=all_atom_pos, indices=atom_indices, axis=-2,
+      batch_dims=2)
+
+  # Copy the chi angle mask, add the UNKNOWN residue. Shape: [restypes, 4].
+  chi_angles_mask = list(residue_constants.chi_angles_mask)
+  chi_angles_mask.append([0.0, 0.0, 0.0, 0.0])
+  chi_angles_mask = jnp.asarray(chi_angles_mask)
+
+  # Compute the chi angle mask. I.e. which chis angles exist according to the
+  # aatype. Shape [batch, num_res, chis=4].
+  chis_mask = utils.batched_gather(params=chi_angles_mask, indices=aatype,
+                                   axis=0, batch_dims=0)
+
+  # Constrain the chis_mask to those chis, where the ground truth coordinates of
+  # all defining four atoms are available.
+  # Gather the chi angle atoms mask. Shape: [batch, num_res, chis=4, atoms=4].
+  chi_angle_atoms_mask = utils.batched_gather(
+      params=all_atom_mask, indices=atom_indices, axis=-1,
+      batch_dims=2)
+  # Check if all 4 chi angle atoms were set. Shape: [batch, num_res, chis=4].
+  chi_angle_atoms_mask = jnp.prod(chi_angle_atoms_mask, axis=[-1])
+  chis_mask = chis_mask * (chi_angle_atoms_mask).astype(jnp.float32)
+
+  # Stack all torsion angle atom positions.
+  # Shape (B, N, torsions=7, atoms=4, xyz=3)
+  torsions_atom_pos = jnp.concatenate(
+      [pre_omega_atom_pos[:, :, None, :, :],
+       phi_atom_pos[:, :, None, :, :],
+       psi_atom_pos[:, :, None, :, :],
+       chis_atom_pos
+      ], axis=2)
+
+  # Stack up masks for all torsion angles.
+  # shape (B, N, torsions=7)
+  torsion_angles_mask = jnp.concatenate(
+      [pre_omega_mask[:, :, None],
+       phi_mask[:, :, None],
+       psi_mask[:, :, None],
+       chis_mask
+      ], axis=2)
+
+  # Create a frame from the first three atoms:
+  # First atom: point on x-y-plane
+  # Second atom: point on negative x-axis
+  # Third atom: origin
+  # r3.Rigids (B, N, torsions=7)
+  torsion_frames = r3.rigids_from_3_points(
+      point_on_neg_x_axis=r3.vecs_from_tensor(torsions_atom_pos[:, :, :, 1, :]),
+      origin=r3.vecs_from_tensor(torsions_atom_pos[:, :, :, 2, :]),
+      point_on_xy_plane=r3.vecs_from_tensor(torsions_atom_pos[:, :, :, 0, :]))
+
+  # Compute the position of the forth atom in this frame (y and z coordinate
+  # define the chi angle)
+  # r3.Vecs (B, N, torsions=7)
+  forth_atom_rel_pos = r3.rigids_mul_vecs(
+      r3.invert_rigids(torsion_frames),
+      r3.vecs_from_tensor(torsions_atom_pos[:, :, :, 3, :]))
+
+  # Normalize to have the sin and cos of the torsion angle.
+  # jnp.ndarray (B, N, torsions=7, sincos=2)
+  torsion_angles_sin_cos = jnp.stack(
+      [forth_atom_rel_pos.z, forth_atom_rel_pos.y], axis=-1)
+  torsion_angles_sin_cos /= jnp.sqrt(
+      jnp.sum(jnp.square(torsion_angles_sin_cos), axis=-1, keepdims=True)
+      + 1e-8)
+
+  # Mirror psi, because we computed it from the Oxygen-atom.
+  torsion_angles_sin_cos *= jnp.asarray(
+      [1., 1., -1., 1., 1., 1., 1.])[None, None, :, None]
+
+  # Create alternative angles for ambiguous atom names.
+  chi_is_ambiguous = utils.batched_gather(
+      jnp.asarray(residue_constants.chi_pi_periodic), aatype)
+  mirror_torsion_angles = jnp.concatenate(
+      [jnp.ones([num_batch, num_res, 3]),
+       1.0 - 2.0 * chi_is_ambiguous], axis=-1)
+  alt_torsion_angles_sin_cos = (
+      torsion_angles_sin_cos * mirror_torsion_angles[:, :, :, None])
+
+  if placeholder_for_undefined:
+    # Add placeholder torsions in place of undefined torsion angles
+    # (e.g. N-terminus pre-omega)
+    placeholder_torsions = jnp.stack([
+        jnp.ones(torsion_angles_sin_cos.shape[:-1]),
+        jnp.zeros(torsion_angles_sin_cos.shape[:-1])
+    ], axis=-1)
+    torsion_angles_sin_cos = torsion_angles_sin_cos * torsion_angles_mask[
+        ..., None] + placeholder_torsions * (1 - torsion_angles_mask[..., None])
+    alt_torsion_angles_sin_cos = alt_torsion_angles_sin_cos * torsion_angles_mask[
+        ..., None] + placeholder_torsions * (1 - torsion_angles_mask[..., None])
+
+  return {
+      'torsion_angles_sin_cos': torsion_angles_sin_cos,  # (B, N, 7, 2)
+      'alt_torsion_angles_sin_cos': alt_torsion_angles_sin_cos,  # (B, N, 7, 2)
+      'torsion_angles_mask': torsion_angles_mask  # (B, N, 7)
+  }
+
+
+def torsion_angles_to_frames(
+    aatype: jnp.ndarray,  # (N)
+    backb_to_global: r3.Rigids,  # (N)
+    torsion_angles_sin_cos: jnp.ndarray  # (N, 7, 2)
+) -> r3.Rigids:  # (N, 8)
+  """"""Compute rigid group frames from torsion angles.
+
+  Jumper et al. (2021) Suppl. Alg. 24 ""computeAllAtomCoordinates"" lines 2-10
+  Jumper et al. (2021) Suppl. Alg. 25 ""makeRotX""
+
+  Args:
+    aatype: aatype for each residue
+    backb_to_global: Rigid transformations describing transformation from
+      backbone frame to global frame.
+    torsion_angles_sin_cos: sin and cosine of the 7 torsion angles
+  Returns:
+    Frames corresponding to all the Sidechain Rigid Transforms
+  """"""
+  assert len(aatype.shape) == 1
+  assert len(backb_to_global.rot.xx.shape) == 1
+  assert len(torsion_angles_sin_cos.shape) == 3
+  assert torsion_angles_sin_cos.shape[1] == 7
+  assert torsion_angles_sin_cos.shape[2] == 2
+
+  # Gather the default frames for all rigid groups.
+  # r3.Rigids with shape (N, 8)
+  m = utils.batched_gather(residue_constants.restype_rigid_group_default_frame,
+                           aatype)
+  default_frames = r3.rigids_from_tensor4x4(m)
+
+  # Create the rotation matrices according to the given angles (each frame is
+  # defined such that its rotation is around the x-axis).
+  sin_angles = torsion_angles_sin_cos[..., 0]
+  cos_angles = torsion_angles_sin_cos[..., 1]
+
+  # insert zero rotation for backbone group.
+  num_residues, = aatype.shape
+  sin_angles = jnp.concatenate([jnp.zeros([num_residues, 1]), sin_angles],
+                               axis=-1)
+  cos_angles = jnp.concatenate([jnp.ones([num_residues, 1]), cos_angles],
+                               axis=-1)
+  zeros = jnp.zeros_like(sin_angles)
+  ones = jnp.ones_like(sin_angles)
+
+  # all_rots are r3.Rots with shape (N, 8)
+  all_rots = r3.Rots(ones, zeros, zeros,
+                     zeros, cos_angles, -sin_angles,
+                     zeros, sin_angles, cos_angles)
+
+  # Apply rotations to the frames.
+  all_frames = r3.rigids_mul_rots(default_frames, all_rots)
+
+  # chi2, chi3, and chi4 frames do not transform to the backbone frame but to
+  # the previous frame. So chain them up accordingly.
+  chi2_frame_to_frame = jax.tree_map(lambda x: x[:, 5], all_frames)
+  chi3_frame_to_frame = jax.tree_map(lambda x: x[:, 6], all_frames)
+  chi4_frame_to_frame = jax.tree_map(lambda x: x[:, 7], all_frames)
+
+  chi1_frame_to_backb = jax.tree_map(lambda x: x[:, 4], all_frames)
+  chi2_frame_to_backb = r3.rigids_mul_rigids(chi1_frame_to_backb,
+                                             chi2_frame_to_frame)
+  chi3_frame_to_backb = r3.rigids_mul_rigids(chi2_frame_to_backb,
+                                             chi3_frame_to_frame)
+  chi4_frame_to_backb = r3.rigids_mul_rigids(chi3_frame_to_backb,
+                                             chi4_frame_to_frame)
+
+  # Recombine them to a r3.Rigids with shape (N, 8).
+  def _concat_frames(xall, x5, x6, x7):
+    return jnp.concatenate(
+        [xall[:, 0:5], x5[:, None], x6[:, None], x7[:, None]], axis=-1)
+
+  all_frames_to_backb = jax.tree_map(
+      _concat_frames,
+      all_frames,
+      chi2_frame_to_backb,
+      chi3_frame_to_backb,
+      chi4_frame_to_backb)
+
+  # Create the global frames.
+  # shape (N, 8)
+  all_frames_to_global = r3.rigids_mul_rigids(
+      jax.tree_map(lambda x: x[:, None], backb_to_global),
+      all_frames_to_backb)
+
+  return all_frames_to_global
+
+
+def frames_and_literature_positions_to_atom14_pos(
+    aatype: jnp.ndarray,  # (N)
+    all_frames_to_global: r3.Rigids  # (N, 8)
+) -> r3.Vecs:  # (N, 14)
+  """"""Put atom literature positions (atom14 encoding) in each rigid group.
+
+  Jumper et al. (2021) Suppl. Alg. 24 ""computeAllAtomCoordinates"" line 11
+
+  Args:
+    aatype: aatype for each residue.
+    all_frames_to_global: All per residue coordinate frames.
+  Returns:
+    Positions of all atom coordinates in global frame.
+  """"""
+
+  # Pick the appropriate transform for every atom.
+  residx_to_group_idx = utils.batched_gather(
+      residue_constants.restype_atom14_to_rigid_group, aatype)
+  group_mask = jax.nn.one_hot(
+      residx_to_group_idx, num_classes=8)  # shape (N, 14, 8)
+
+  # r3.Rigids with shape (N, 14)
+  map_atoms_to_global = jax.tree_map(
+      lambda x: jnp.sum(x[:, None, :] * group_mask, axis=-1),
+      all_frames_to_global)
+
+  # Gather the literature atom positions for each residue.
+  # r3.Vecs with shape (N, 14)
+  lit_positions = r3.vecs_from_tensor(
+      utils.batched_gather(
+          residue_constants.restype_atom14_rigid_group_positions, aatype))
+
+  # Transform each atom from its local frame to the global frame.
+  # r3.Vecs with shape (N, 14)
+  pred_positions = r3.rigids_mul_vecs(map_atoms_to_global, lit_positions)
+
+  # Mask out non-existing atoms.
+  mask = utils.batched_gather(residue_constants.restype_atom14_mask, aatype)
+  pred_positions = jax.tree_map(lambda x: x * mask, pred_positions)
+
+  return pred_positions
+
+
+def extreme_ca_ca_distance_violations(
+    pred_atom_positions: jnp.ndarray,  # (N, 37(14), 3)
+    pred_atom_mask: jnp.ndarray,  # (N, 37(14))
+    residue_index: jnp.ndarray,  # (N)
+    max_angstrom_tolerance=1.5
+    ) -> jnp.ndarray:
+  """"""Counts residues whose Ca is a large distance from its neighbour.
+
+  Measures the fraction of CA-CA pairs between consecutive amino acids that are
+  more than 'max_angstrom_tolerance' apart.
+
+  Args:
+    pred_atom_positions: Atom positions in atom37/14 representation
+    pred_atom_mask: Atom mask in atom37/14 representation
+    residue_index: Residue index for given amino acid, this is assumed to be
+      monotonically increasing.
+    max_angstrom_tolerance: Maximum distance allowed to not count as violation.
+  Returns:
+    Fraction of consecutive CA-CA pairs with violation.
+  """"""
+  this_ca_pos = pred_atom_positions[:-1, 1, :]  # (N - 1, 3)
+  this_ca_mask = pred_atom_mask[:-1, 1]         # (N - 1)
+  next_ca_pos = pred_atom_positions[1:, 1, :]  # (N - 1, 3)
+  next_ca_mask = pred_atom_mask[1:, 1]  # (N - 1)
+  has_no_gap_mask = ((residue_index[1:] - residue_index[:-1]) == 1.0).astype(
+      jnp.float32)
+  ca_ca_distance = jnp.sqrt(
+      1e-6 + jnp.sum(squared_difference(this_ca_pos, next_ca_pos), axis=-1))
+  violations = (ca_ca_distance -
+                residue_constants.ca_ca) > max_angstrom_tolerance
+  mask = this_ca_mask * next_ca_mask * has_no_gap_mask
+  return utils.mask_mean(mask=mask, value=violations)
+
+
+def between_residue_bond_loss(
+    pred_atom_positions: jnp.ndarray,  # (N, 37(14), 3)
+    pred_atom_mask: jnp.ndarray,  # (N, 37(14))
+    residue_index: jnp.ndarray,  # (N)
+    aatype: jnp.ndarray,  # (N)
+    tolerance_factor_soft=12.0,
+    tolerance_factor_hard=12.0
+) -> Dict[str, jnp.ndarray]:
+  """"""Flat-bottom loss to penalize structural violations between residues.
+
+  This is a loss penalizing any violation of the geometry around the peptide
+  bond between consecutive amino acids. This loss corresponds to
+  Jumper et al. (2021) Suppl. Sec. 1.9.11, eq 44, 45.
+
+  Args:
+    pred_atom_positions: Atom positions in atom37/14 representation
+    pred_atom_mask: Atom mask in atom37/14 representation
+    residue_index: Residue index for given amino acid, this is assumed to be
+      monotonically increasing.
+    aatype: Amino acid type of given residue
+    tolerance_factor_soft: soft tolerance factor measured in standard deviations
+      of pdb distributions
+    tolerance_factor_hard: hard tolerance factor measured in standard deviations
+      of pdb distributions
+
+  Returns:
+    Dict containing:
+      * 'c_n_loss_mean': Loss for peptide bond length violations
+      * 'ca_c_n_loss_mean': Loss for violations of bond angle around C spanned
+          by CA, C, N
+      * 'c_n_ca_loss_mean': Loss for violations of bond angle around N spanned
+          by C, N, CA
+      * 'per_residue_loss_sum': sum of all losses for each residue
+      * 'per_residue_violation_mask': mask denoting all residues with violation
+          present.
+  """"""
+  assert len(pred_atom_positions.shape) == 3
+  assert len(pred_atom_mask.shape) == 2
+  assert len(residue_index.shape) == 1
+  assert len(aatype.shape) == 1
+
+  # Get the positions of the relevant backbone atoms.
+  this_ca_pos = pred_atom_positions[:-1, 1, :]  # (N - 1, 3)
+  this_ca_mask = pred_atom_mask[:-1, 1]         # (N - 1)
+  this_c_pos = pred_atom_positions[:-1, 2, :]   # (N - 1, 3)
+  this_c_mask = pred_atom_mask[:-1, 2]          # (N - 1)
+  next_n_pos = pred_atom_positions[1:, 0, :]    # (N - 1, 3)
+  next_n_mask = pred_atom_mask[1:, 0]           # (N - 1)
+  next_ca_pos = pred_atom_positions[1:, 1, :]   # (N - 1, 3)
+  next_ca_mask = pred_atom_mask[1:, 1]          # (N - 1)
+  has_no_gap_mask = ((residue_index[1:] - residue_index[:-1]) == 1.0).astype(
+      jnp.float32)
+
+  # Compute loss for the C--N bond.
+  c_n_bond_length = jnp.sqrt(
+      1e-6 + jnp.sum(squared_difference(this_c_pos, next_n_pos), axis=-1))
+
+  # The C-N bond to proline has slightly different length because of the ring.
+  next_is_proline = (
+      aatype[1:] == residue_constants.resname_to_idx['PRO']).astype(jnp.float32)
+  gt_length = (
+      (1. - next_is_proline) * residue_constants.between_res_bond_length_c_n[0]
+      + next_is_proline * residue_constants.between_res_bond_length_c_n[1])
+  gt_stddev = (
+      (1. - next_is_proline) *
+      residue_constants.between_res_bond_length_stddev_c_n[0] +
+      next_is_proline * residue_constants.between_res_bond_length_stddev_c_n[1])
+  c_n_bond_length_error = jnp.sqrt(1e-6 +
+                                   jnp.square(c_n_bond_length - gt_length))
+  c_n_loss_per_residue = jax.nn.relu(
+      c_n_bond_length_error - tolerance_factor_soft * gt_stddev)
+  mask = this_c_mask * next_n_mask * has_no_gap_mask
+  c_n_loss = jnp.sum(mask * c_n_loss_per_residue) / (jnp.sum(mask) + 1e-6)
+  c_n_violation_mask = mask * (
+      c_n_bond_length_error > (tolerance_factor_hard * gt_stddev))
+
+  # Compute loss for the angles.
+  ca_c_bond_length = jnp.sqrt(1e-6 + jnp.sum(
+      squared_difference(this_ca_pos, this_c_pos), axis=-1))
+  n_ca_bond_length = jnp.sqrt(1e-6 + jnp.sum(
+      squared_difference(next_n_pos, next_ca_pos), axis=-1))
+
+  c_ca_unit_vec = (this_ca_pos - this_c_pos) / ca_c_bond_length[:, None]
+  c_n_unit_vec = (next_n_pos - this_c_pos) / c_n_bond_length[:, None]
+  n_ca_unit_vec = (next_ca_pos - next_n_pos) / n_ca_bond_length[:, None]
+
+  ca_c_n_cos_angle = jnp.sum(c_ca_unit_vec * c_n_unit_vec, axis=-1)
+  gt_angle = residue_constants.between_res_cos_angles_ca_c_n[0]
+  gt_stddev = residue_constants.between_res_bond_length_stddev_c_n[0]
+  ca_c_n_cos_angle_error = jnp.sqrt(
+      1e-6 + jnp.square(ca_c_n_cos_angle - gt_angle))
+  ca_c_n_loss_per_residue = jax.nn.relu(
+      ca_c_n_cos_angle_error - tolerance_factor_soft * gt_stddev)
+  mask = this_ca_mask * this_c_mask * next_n_mask * has_no_gap_mask
+  ca_c_n_loss = jnp.sum(mask * ca_c_n_loss_per_residue) / (jnp.sum(mask) + 1e-6)
+  ca_c_n_violation_mask = mask * (ca_c_n_cos_angle_error >
+                                  (tolerance_factor_hard * gt_stddev))
+
+  c_n_ca_cos_angle = jnp.sum((-c_n_unit_vec) * n_ca_unit_vec, axis=-1)
+  gt_angle = residue_constants.between_res_cos_angles_c_n_ca[0]
+  gt_stddev = residue_constants.between_res_cos_angles_c_n_ca[1]
+  c_n_ca_cos_angle_error = jnp.sqrt(
+      1e-6 + jnp.square(c_n_ca_cos_angle - gt_angle))
+  c_n_ca_loss_per_residue = jax.nn.relu(
+      c_n_ca_cos_angle_error - tolerance_factor_soft * gt_stddev)
+  mask = this_c_mask * next_n_mask * next_ca_mask * has_no_gap_mask
+  c_n_ca_loss = jnp.sum(mask * c_n_ca_loss_per_residue) / (jnp.sum(mask) + 1e-6)
+  c_n_ca_violation_mask = mask * (
+      c_n_ca_cos_angle_error > (tolerance_factor_hard * gt_stddev))
+
+  # Compute a per residue loss (equally distribute the loss to both
+  # neighbouring residues).
+  per_residue_loss_sum = (c_n_loss_per_residue +
+                          ca_c_n_loss_per_residue +
+                          c_n_ca_loss_per_residue)
+  per_residue_loss_sum = 0.5 * (jnp.pad(per_residue_loss_sum, [[0, 1]]) +
+                                jnp.pad(per_residue_loss_sum, [[1, 0]]))
+
+  # Compute hard violations.
+  violation_mask = jnp.max(
+      jnp.stack([c_n_violation_mask,
+                 ca_c_n_violation_mask,
+                 c_n_ca_violation_mask]), axis=0)
+  violation_mask = jnp.maximum(
+      jnp.pad(violation_mask, [[0, 1]]),
+      jnp.pad(violation_mask, [[1, 0]]))
+
+  return {'c_n_loss_mean': c_n_loss,  # shape ()
+          'ca_c_n_loss_mean': ca_c_n_loss,  # shape ()
+          'c_n_ca_loss_mean': c_n_ca_loss,  # shape ()
+          'per_residue_loss_sum': per_residue_loss_sum,  # shape (N)
+          'per_residue_violation_mask': violation_mask  # shape (N)
+         }
+
+
+def between_residue_clash_loss(
+    atom14_pred_positions: jnp.ndarray,  # (N, 14, 3)
+    atom14_atom_exists: jnp.ndarray,  # (N, 14)
+    atom14_atom_radius: jnp.ndarray,  # (N, 14)
+    residue_index: jnp.ndarray,  # (N)
+    overlap_tolerance_soft=1.5,
+    overlap_tolerance_hard=1.5
+) -> Dict[str, jnp.ndarray]:
+  """"""Loss to penalize steric clashes between residues.
+
+  This is a loss penalizing any steric clashes due to non bonded atoms in
+  different peptides coming too close. This loss corresponds to the part with
+  different residues of
+  Jumper et al. (2021) Suppl. Sec. 1.9.11, eq 46.
+
+  Args:
+    atom14_pred_positions: Predicted positions of atoms in
+      global prediction frame
+    atom14_atom_exists: Mask denoting whether atom at positions exists for given
+      amino acid type
+    atom14_atom_radius: Van der Waals radius for each atom.
+    residue_index: Residue index for given amino acid.
+    overlap_tolerance_soft: Soft tolerance factor.
+    overlap_tolerance_hard: Hard tolerance factor.
+
+  Returns:
+    Dict containing:
+      * 'mean_loss': average clash loss
+      * 'per_atom_loss_sum': sum of all clash losses per atom, shape (N, 14)
+      * 'per_atom_clash_mask': mask whether atom clashes with any other atom
+          shape (N, 14)
+  """"""
+  assert len(atom14_pred_positions.shape) == 3
+  assert len(atom14_atom_exists.shape) == 2
+  assert len(atom14_atom_radius.shape) == 2
+  assert len(residue_index.shape) == 1
+
+  # Create the distance matrix.
+  # (N, N, 14, 14)
+  dists = jnp.sqrt(1e-10 + jnp.sum(
+      squared_difference(
+          atom14_pred_positions[:, None, :, None, :],
+          atom14_pred_positions[None, :, None, :, :]),
+      axis=-1))
+
+  # Create the mask for valid distances.
+  # shape (N, N, 14, 14)
+  dists_mask = (atom14_atom_exists[:, None, :, None] *
+                atom14_atom_exists[None, :, None, :])
+
+  # Mask out all the duplicate entries in the lower triangular matrix.
+  # Also mask out the diagonal (atom-pairs from the same residue) -- these atoms
+  # are handled separately.
+  dists_mask *= (
+      residue_index[:, None, None, None] < residue_index[None, :, None, None])
+
+  # Backbone C--N bond between subsequent residues is no clash.
+  c_one_hot = jax.nn.one_hot(2, num_classes=14)
+  n_one_hot = jax.nn.one_hot(0, num_classes=14)
+  neighbour_mask = ((residue_index[:, None, None, None] +
+                     1) == residue_index[None, :, None, None])
+  c_n_bonds = neighbour_mask * c_one_hot[None, None, :,
+                                         None] * n_one_hot[None, None, None, :]
+  dists_mask *= (1. - c_n_bonds)
+
+  # Disulfide bridge between two cysteines is no clash.
+  cys_sg_idx = residue_constants.restype_name_to_atom14_names['CYS'].index('SG')
+  cys_sg_one_hot = jax.nn.one_hot(cys_sg_idx, num_classes=14)
+  disulfide_bonds = (cys_sg_one_hot[None, None, :, None] *
+                     cys_sg_one_hot[None, None, None, :])
+  dists_mask *= (1. - disulfide_bonds)
+
+  # Compute the lower bound for the allowed distances.
+  # shape (N, N, 14, 14)
+  dists_lower_bound = dists_mask * (atom14_atom_radius[:, None, :, None] +
+                                    atom14_atom_radius[None, :, None, :])
+
+  # Compute the error.
+  # shape (N, N, 14, 14)
+  dists_to_low_error = dists_mask * jax.nn.relu(
+      dists_lower_bound - overlap_tolerance_soft - dists)
+
+  # Compute the mean loss.
+  # shape ()
+  mean_loss = (jnp.sum(dists_to_low_error)
+               / (1e-6 + jnp.sum(dists_mask)))
+
+  # Compute the per atom loss sum.
+  # shape (N, 14)
+  per_atom_loss_sum = (jnp.sum(dists_to_low_error, axis=[0, 2]) +
+                       jnp.sum(dists_to_low_error, axis=[1, 3]))
+
+  # Compute the hard clash mask.
+  # shape (N, N, 14, 14)
+  clash_mask = dists_mask * (
+      dists < (dists_lower_bound - overlap_tolerance_hard))
+
+  # Compute the per atom clash.
+  # shape (N, 14)
+  per_atom_clash_mask = jnp.maximum(
+      jnp.max(clash_mask, axis=[0, 2]),
+      jnp.max(clash_mask, axis=[1, 3]))
+
+  return {'mean_loss': mean_loss,  # shape ()
+          'per_atom_loss_sum': per_atom_loss_sum,  # shape (N, 14)
+          'per_atom_clash_mask': per_atom_clash_mask  # shape (N, 14)
+         }
+
+
+def within_residue_violations(
+    atom14_pred_positions: jnp.ndarray,  # (N, 14, 3)
+    atom14_atom_exists: jnp.ndarray,  # (N, 14)
+    atom14_dists_lower_bound: jnp.ndarray,  # (N, 14, 14)
+    atom14_dists_upper_bound: jnp.ndarray,  # (N, 14, 14)
+    tighten_bounds_for_loss=0.0,
+) -> Dict[str, jnp.ndarray]:
+  """"""Loss to penalize steric clashes within residues.
+
+  This is a loss penalizing any steric violations or clashes of non-bonded atoms
+  in a given peptide. This loss corresponds to the part with
+  the same residues of
+  Jumper et al. (2021) Suppl. Sec. 1.9.11, eq 46.
+
+  Args:
+    atom14_pred_positions: Predicted positions of atoms in
+      global prediction frame
+    atom14_atom_exists: Mask denoting whether atom at positions exists for given
+      amino acid type
+    atom14_dists_lower_bound: Lower bound on allowed distances.
+    atom14_dists_upper_bound: Upper bound on allowed distances
+    tighten_bounds_for_loss: Extra factor to tighten loss
+
+  Returns:
+    Dict containing:
+      * 'per_atom_loss_sum': sum of all clash losses per atom, shape (N, 14)
+      * 'per_atom_clash_mask': mask whether atom clashes with any other atom
+          shape (N, 14)
+  """"""
+  assert len(atom14_pred_positions.shape) == 3
+  assert len(atom14_atom_exists.shape) == 2
+  assert len(atom14_dists_lower_bound.shape) == 3
+  assert len(atom14_dists_upper_bound.shape) == 3
+
+  # Compute the mask for each residue.
+  # shape (N, 14, 14)
+  dists_masks = (1. - jnp.eye(14, 14)[None])
+  dists_masks *= (atom14_atom_exists[:, :, None] *
+                  atom14_atom_exists[:, None, :])
+
+  # Distance matrix
+  # shape (N, 14, 14)
+  dists = jnp.sqrt(1e-10 + jnp.sum(
+      squared_difference(
+          atom14_pred_positions[:, :, None, :],
+          atom14_pred_positions[:, None, :, :]),
+      axis=-1))
+
+  # Compute the loss.
+  # shape (N, 14, 14)
+  dists_to_low_error = jax.nn.relu(
+      atom14_dists_lower_bound + tighten_bounds_for_loss - dists)
+  dists_to_high_error = jax.nn.relu(
+      dists - (atom14_dists_upper_bound - tighten_bounds_for_loss))
+  loss = dists_masks * (dists_to_low_error + dists_to_high_error)
+
+  # Compute the per atom loss sum.
+  # shape (N, 14)
+  per_atom_loss_sum = (jnp.sum(loss, axis=1) +
+                       jnp.sum(loss, axis=2))
+
+  # Compute the violations mask.
+  # shape (N, 14, 14)
+  violations = dists_masks * ((dists < atom14_dists_lower_bound) |
+                              (dists > atom14_dists_upper_bound))
+
+  # Compute the per atom violations.
+  # shape (N, 14)
+  per_atom_violations = jnp.maximum(
+      jnp.max(violations, axis=1), jnp.max(violations, axis=2))
+
+  return {'per_atom_loss_sum': per_atom_loss_sum,  # shape (N, 14)
+          'per_atom_violations': per_atom_violations  # shape (N, 14)
+         }
+
+
+def find_optimal_renaming(
+    atom14_gt_positions: jnp.ndarray,  # (N, 14, 3)
+    atom14_alt_gt_positions: jnp.ndarray,  # (N, 14, 3)
+    atom14_atom_is_ambiguous: jnp.ndarray,  # (N, 14)
+    atom14_gt_exists: jnp.ndarray,  # (N, 14)
+    atom14_pred_positions: jnp.ndarray,  # (N, 14, 3)
+    atom14_atom_exists: jnp.ndarray,  # (N, 14)
+) -> jnp.ndarray:  # (N):
+  """"""Find optimal renaming for ground truth that maximizes LDDT.
+
+  Jumper et al. (2021) Suppl. Alg. 26
+  ""renameSymmetricGroundTruthAtoms"" lines 1-5
+
+  Args:
+    atom14_gt_positions: Ground truth positions in global frame of ground truth.
+    atom14_alt_gt_positions: Alternate ground truth positions in global frame of
+      ground truth with coordinates of ambiguous atoms swapped relative to
+      'atom14_gt_positions'.
+    atom14_atom_is_ambiguous: Mask denoting whether atom is among ambiguous
+      atoms, see Jumper et al. (2021) Suppl. Table 3
+    atom14_gt_exists: Mask denoting whether atom at positions exists in ground
+      truth.
+    atom14_pred_positions: Predicted positions of atoms in
+      global prediction frame
+    atom14_atom_exists: Mask denoting whether atom at positions exists for given
+      amino acid type
+
+  Returns:
+    Float array of shape [N] with 1. where atom14_alt_gt_positions is closer to
+    prediction and 0. otherwise
+  """"""
+  assert len(atom14_gt_positions.shape) == 3
+  assert len(atom14_alt_gt_positions.shape) == 3
+  assert len(atom14_atom_is_ambiguous.shape) == 2
+  assert len(atom14_gt_exists.shape) == 2
+  assert len(atom14_pred_positions.shape) == 3
+  assert len(atom14_atom_exists.shape) == 2
+
+  # Create the pred distance matrix.
+  # shape (N, N, 14, 14)
+  pred_dists = jnp.sqrt(1e-10 + jnp.sum(
+      squared_difference(
+          atom14_pred_positions[:, None, :, None, :],
+          atom14_pred_positions[None, :, None, :, :]),
+      axis=-1))
+
+  # Compute distances for ground truth with original and alternative names.
+  # shape (N, N, 14, 14)
+  gt_dists = jnp.sqrt(1e-10 + jnp.sum(
+      squared_difference(
+          atom14_gt_positions[:, None, :, None, :],
+          atom14_gt_positions[None, :, None, :, :]),
+      axis=-1))
+  alt_gt_dists = jnp.sqrt(1e-10 + jnp.sum(
+      squared_difference(
+          atom14_alt_gt_positions[:, None, :, None, :],
+          atom14_alt_gt_positions[None, :, None, :, :]),
+      axis=-1))
+
+  # Compute LDDT's.
+  # shape (N, N, 14, 14)
+  lddt = jnp.sqrt(1e-10 + squared_difference(pred_dists, gt_dists))
+  alt_lddt = jnp.sqrt(1e-10 + squared_difference(pred_dists, alt_gt_dists))
+
+  # Create a mask for ambiguous atoms in rows vs. non-ambiguous atoms
+  # in cols.
+  # shape (N ,N, 14, 14)
+  mask = (atom14_gt_exists[:, None, :, None] *  # rows
+          atom14_atom_is_ambiguous[:, None, :, None] *  # rows
+          atom14_gt_exists[None, :, None, :] *  # cols
+          (1. - atom14_atom_is_ambiguous[None, :, None, :]))  # cols
+
+  # Aggregate distances for each residue to the non-amibuguous atoms.
+  # shape (N)
+  per_res_lddt = jnp.sum(mask * lddt, axis=[1, 2, 3])
+  alt_per_res_lddt = jnp.sum(mask * alt_lddt, axis=[1, 2, 3])
+
+  # Decide for each residue, whether alternative naming is better.
+  # shape (N)
+  alt_naming_is_better = (alt_per_res_lddt < per_res_lddt).astype(jnp.float32)
+
+  return alt_naming_is_better  # shape (N)
+
+
+def frame_aligned_point_error(
+    pred_frames: r3.Rigids,  # shape (num_frames)
+    target_frames: r3.Rigids,  # shape (num_frames)
+    frames_mask: jnp.ndarray,  # shape (num_frames)
+    pred_positions: r3.Vecs,  # shape (num_positions)
+    target_positions: r3.Vecs,  # shape (num_positions)
+    positions_mask: jnp.ndarray,  # shape (num_positions)
+    length_scale: float,
+    l1_clamp_distance: Optional[float] = None,
+    epsilon=1e-4) -> jnp.ndarray:  # shape ()
+  """"""Measure point error under different alignments.
+
+  Jumper et al. (2021) Suppl. Alg. 28 ""computeFAPE""
+
+  Computes error between two structures with B points under A alignments derived
+  from the given pairs of frames.
+  Args:
+    pred_frames: num_frames reference frames for 'pred_positions'.
+    target_frames: num_frames reference frames for 'target_positions'.
+    frames_mask: Mask for frame pairs to use.
+    pred_positions: num_positions predicted positions of the structure.
+    target_positions: num_positions target positions of the structure.
+    positions_mask: Mask on which positions to score.
+    length_scale: length scale to divide loss by.
+    l1_clamp_distance: Distance cutoff on error beyond which gradients will
+      be zero.
+    epsilon: small value used to regularize denominator for masked average.
+  Returns:
+    Masked Frame Aligned Point Error.
+  """"""
+  assert pred_frames.rot.xx.ndim == 1
+  assert target_frames.rot.xx.ndim == 1
+  assert frames_mask.ndim == 1, frames_mask.ndim
+  assert pred_positions.x.ndim == 1
+  assert target_positions.x.ndim == 1
+  assert positions_mask.ndim == 1
+
+  # Compute array of predicted positions in the predicted frames.
+  # r3.Vecs (num_frames, num_positions)
+  local_pred_pos = r3.rigids_mul_vecs(
+      jax.tree_map(lambda r: r[:, None], r3.invert_rigids(pred_frames)),
+      jax.tree_map(lambda x: x[None, :], pred_positions))
+
+  # Compute array of target positions in the target frames.
+  # r3.Vecs (num_frames, num_positions)
+  local_target_pos = r3.rigids_mul_vecs(
+      jax.tree_map(lambda r: r[:, None], r3.invert_rigids(target_frames)),
+      jax.tree_map(lambda x: x[None, :], target_positions))
+
+  # Compute errors between the structures.
+  # jnp.ndarray (num_frames, num_positions)
+  error_dist = jnp.sqrt(
+      r3.vecs_squared_distance(local_pred_pos, local_target_pos)
+      + epsilon)
+
+  if l1_clamp_distance:
+    error_dist = jnp.clip(error_dist, 0, l1_clamp_distance)
+
+  normed_error = error_dist / length_scale
+  normed_error *= jnp.expand_dims(frames_mask, axis=-1)
+  normed_error *= jnp.expand_dims(positions_mask, axis=-2)
+
+  normalization_factor = (
+      jnp.sum(frames_mask, axis=-1) *
+      jnp.sum(positions_mask, axis=-1))
+  return (jnp.sum(normed_error, axis=(-2, -1)) /
+          (epsilon + normalization_factor))
+
+
+def _make_renaming_matrices():
+  """"""Matrices to map atoms to symmetry partners in ambiguous case.""""""
+  # As the atom naming is ambiguous for 7 of the 20 amino acids, provide
+  # alternative groundtruth coordinates where the naming is swapped
+  restype_3 = [
+      residue_constants.restype_1to3[res] for res in residue_constants.restypes
+  ]
+  restype_3 += ['UNK']
+  # Matrices for renaming ambiguous atoms.
+  all_matrices = {res: np.eye(14, dtype=np.float32) for res in restype_3}
+  for resname, swap in residue_constants.residue_atom_renaming_swaps.items():
+    correspondences = np.arange(14)
+    for source_atom_swap, target_atom_swap in swap.items():
+      source_index = residue_constants.restype_name_to_atom14_names[
+          resname].index(source_atom_swap)
+      target_index = residue_constants.restype_name_to_atom14_names[
+          resname].index(target_atom_swap)
+      correspondences[source_index] = target_index
+      correspondences[target_index] = source_index
+      renaming_matrix = np.zeros((14, 14), dtype=np.float32)
+      for index, correspondence in enumerate(correspondences):
+        renaming_matrix[index, correspondence] = 1.
+    all_matrices[resname] = renaming_matrix.astype(np.float32)
+  renaming_matrices = np.stack([all_matrices[restype] for restype in restype_3])
+  return renaming_matrices
+
+
+RENAMING_MATRICES = _make_renaming_matrices()
+
+
+def get_alt_atom14(aatype, positions, mask):
+  """"""Get alternative atom14 positions.
+
+  Constructs renamed atom positions for ambiguous residues.
+
+  Jumper et al. (2021) Suppl. Table 3 ""Ambiguous atom names due to 180 degree-
+  rotation-symmetry""
+
+  Args:
+    aatype: Amino acid at given position
+    positions: Atom positions as r3.Vecs in atom14 representation, (N, 14)
+    mask: Atom masks in atom14 representation, (N, 14)
+  Returns:
+    renamed atom positions, renamed atom mask
+  """"""
+  # pick the transformation matrices for the given residue sequence
+  # shape (num_res, 14, 14)
+  renaming_transform = utils.batched_gather(
+      jnp.asarray(RENAMING_MATRICES), aatype)
+
+  positions = jax.tree_map(lambda x: x[:, :, None], positions)
+  alternative_positions = jax.tree_map(
+      lambda x: jnp.sum(x, axis=1), positions * renaming_transform)
+
+  # Create the mask for the alternative ground truth (differs from the
+  # ground truth mask, if only one of the atoms in an ambiguous pair has a
+  # ground truth position)
+  alternative_mask = jnp.sum(mask[..., None] * renaming_transform, axis=1)
+
+  return alternative_positions, alternative_mask
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/lddt.py",".py","3505","89","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""lDDT protein distance score.""""""
+import jax.numpy as jnp
+
+
+def lddt(predicted_points,
+         true_points,
+         true_points_mask,
+         cutoff=15.,
+         per_residue=False):
+  """"""Measure (approximate) lDDT for a batch of coordinates.
+
+  lDDT reference:
+  Mariani, V., Biasini, M., Barbato, A. & Schwede, T. lDDT: A local
+  superposition-free score for comparing protein structures and models using
+  distance difference tests. Bioinformatics 29, 2722–2728 (2013).
+
+  lDDT is a measure of the difference between the true distance matrix and the
+  distance matrix of the predicted points.  The difference is computed only on
+  points closer than cutoff *in the true structure*.
+
+  This function does not compute the exact lDDT value that the original paper
+  describes because it does not include terms for physical feasibility
+  (e.g. bond length violations). Therefore this is only an approximate
+  lDDT score.
+
+  Args:
+    predicted_points: (batch, length, 3) array of predicted 3D points
+    true_points: (batch, length, 3) array of true 3D points
+    true_points_mask: (batch, length, 1) binary-valued float array.  This mask
+      should be 1 for points that exist in the true points.
+    cutoff: Maximum distance for a pair of points to be included
+    per_residue: If true, return score for each residue.  Note that the overall
+      lDDT is not exactly the mean of the per_residue lDDT's because some
+      residues have more contacts than others.
+
+  Returns:
+    An (approximate, see above) lDDT score in the range 0-1.
+  """"""
+
+  assert len(predicted_points.shape) == 3
+  assert predicted_points.shape[-1] == 3
+  assert true_points_mask.shape[-1] == 1
+  assert len(true_points_mask.shape) == 3
+
+  # Compute true and predicted distance matrices.
+  dmat_true = jnp.sqrt(1e-10 + jnp.sum(
+      (true_points[:, :, None] - true_points[:, None, :])**2, axis=-1))
+
+  dmat_predicted = jnp.sqrt(1e-10 + jnp.sum(
+      (predicted_points[:, :, None] -
+       predicted_points[:, None, :])**2, axis=-1))
+
+  dists_to_score = (
+      (dmat_true < cutoff).astype(jnp.float32) * true_points_mask *
+      jnp.transpose(true_points_mask, [0, 2, 1]) *
+      (1. - jnp.eye(dmat_true.shape[1]))  # Exclude self-interaction.
+  )
+
+  # Shift unscored distances to be far away.
+  dist_l1 = jnp.abs(dmat_true - dmat_predicted)
+
+  # True lDDT uses a number of fixed bins.
+  # We ignore the physical plausibility correction to lDDT, though.
+  score = 0.25 * ((dist_l1 < 0.5).astype(jnp.float32) +
+                  (dist_l1 < 1.0).astype(jnp.float32) +
+                  (dist_l1 < 2.0).astype(jnp.float32) +
+                  (dist_l1 < 4.0).astype(jnp.float32))
+
+  # Normalize over the appropriate axes.
+  reduce_axes = (-1,) if per_residue else (-2, -1)
+  norm = 1. / (1e-10 + jnp.sum(dists_to_score, axis=reduce_axes))
+  score = norm * (1e-10 + jnp.sum(dists_to_score * score, axis=reduce_axes))
+
+  return score
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/geometry/vector.py",".py","6896","218","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Vec3Array Class.""""""
+
+from __future__ import annotations
+import dataclasses
+from typing import Union
+
+from alphafold.model.geometry import struct_of_array
+from alphafold.model.geometry import utils
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+Float = Union[float, jnp.ndarray]
+
+VERSION = '0.1'
+
+
+@struct_of_array.StructOfArray(same_dtype=True)
+class Vec3Array:
+  """"""Vec3Array in 3 dimensional Space implemented as struct of arrays.
+
+  This is done in order to improve performance and precision.
+  On TPU small matrix multiplications are very suboptimal and will waste large
+  compute ressources, furthermore any matrix multiplication on tpu happen in
+  mixed bfloat16/float32 precision, which is often undesirable when handling
+  physical coordinates.
+  In most cases this will also be faster on cpu's/gpu's since it allows for
+  easier use of vector instructions.
+  """"""
+
+  x: jnp.ndarray = dataclasses.field(metadata={'dtype': jnp.float32})
+  y: jnp.ndarray
+  z: jnp.ndarray
+
+  def __post_init__(self):
+    if hasattr(self.x, 'dtype'):
+      assert self.x.dtype == self.y.dtype
+      assert self.x.dtype == self.z.dtype
+      assert all([x == y for x, y in zip(self.x.shape, self.y.shape)])
+      assert all([x == z for x, z in zip(self.x.shape, self.z.shape)])
+
+  def __add__(self, other: Vec3Array) -> Vec3Array:
+    return jax.tree_map(lambda x, y: x + y, self, other)
+
+  def __sub__(self, other: Vec3Array) -> Vec3Array:
+    return jax.tree_map(lambda x, y: x - y, self, other)
+
+  def __mul__(self, other: Float) -> Vec3Array:
+    return jax.tree_map(lambda x: x * other, self)
+
+  def __rmul__(self, other: Float) -> Vec3Array:
+    return self * other
+
+  def __truediv__(self, other: Float) -> Vec3Array:
+    return jax.tree_map(lambda x: x / other, self)
+
+  def __neg__(self) -> Vec3Array:
+    return jax.tree_map(lambda x: -x, self)
+
+  def __pos__(self) -> Vec3Array:
+    return jax.tree_map(lambda x: x, self)
+
+  def cross(self, other: Vec3Array) -> Vec3Array:
+    """"""Compute cross product between 'self' and 'other'.""""""
+    new_x = self.y * other.z - self.z * other.y
+    new_y = self.z * other.x - self.x * other.z
+    new_z = self.x * other.y - self.y * other.x
+    return Vec3Array(new_x, new_y, new_z)
+
+  def dot(self, other: Vec3Array) -> Float:
+    """"""Compute dot product between 'self' and 'other'.""""""
+    return self.x * other.x + self.y * other.y + self.z * other.z
+
+  def norm(self, epsilon: float = 1e-6) -> Float:
+    """"""Compute Norm of Vec3Array, clipped to epsilon.""""""
+    # To avoid NaN on the backward pass, we must use maximum before the sqrt
+    norm2 = self.dot(self)
+    if epsilon:
+      norm2 = jnp.maximum(norm2, epsilon**2)
+    return jnp.sqrt(norm2)
+
+  def norm2(self):
+    return self.dot(self)
+
+  def normalized(self, epsilon: float = 1e-6) -> Vec3Array:
+    """"""Return unit vector with optional clipping.""""""
+    return self / self.norm(epsilon)
+
+  @classmethod
+  def zeros(cls, shape, dtype=jnp.float32):
+    """"""Return Vec3Array corresponding to zeros of given shape.""""""
+    return cls(
+        jnp.zeros(shape, dtype), jnp.zeros(shape, dtype),
+        jnp.zeros(shape, dtype))  # pytype: disable=wrong-arg-count  # trace-all-classes
+
+  def to_array(self) -> jnp.ndarray:
+    return jnp.stack([self.x, self.y, self.z], axis=-1)
+
+  @classmethod
+  def from_array(cls, array):
+    return cls(*utils.unstack(array))
+
+  def __getstate__(self):
+    return (VERSION,
+            [np.asarray(self.x),
+             np.asarray(self.y),
+             np.asarray(self.z)])
+
+  def __setstate__(self, state):
+    version, state = state
+    del version
+    for i, letter in enumerate('xyz'):
+      object.__setattr__(self, letter, state[i])
+
+
+def square_euclidean_distance(vec1: Vec3Array,
+                              vec2: Vec3Array,
+                              epsilon: float = 1e-6) -> Float:
+  """"""Computes square of euclidean distance between 'vec1' and 'vec2'.
+
+  Args:
+    vec1: Vec3Array to compute  distance to
+    vec2: Vec3Array to compute  distance from, should be
+          broadcast compatible with 'vec1'
+    epsilon: distance is clipped from below to be at least epsilon
+
+  Returns:
+    Array of square euclidean distances;
+    shape will be result of broadcasting 'vec1' and 'vec2'
+  """"""
+  difference = vec1 - vec2
+  distance = difference.dot(difference)
+  if epsilon:
+    distance = jnp.maximum(distance, epsilon)
+  return distance
+
+
+def dot(vector1: Vec3Array, vector2: Vec3Array) -> Float:
+  return vector1.dot(vector2)
+
+
+def cross(vector1: Vec3Array, vector2: Vec3Array) -> Float:
+  return vector1.cross(vector2)
+
+
+def norm(vector: Vec3Array, epsilon: float = 1e-6) -> Float:
+  return vector.norm(epsilon)
+
+
+def normalized(vector: Vec3Array, epsilon: float = 1e-6) -> Vec3Array:
+  return vector.normalized(epsilon)
+
+
+def euclidean_distance(vec1: Vec3Array,
+                       vec2: Vec3Array,
+                       epsilon: float = 1e-6) -> Float:
+  """"""Computes euclidean distance between 'vec1' and 'vec2'.
+
+  Args:
+    vec1: Vec3Array to compute euclidean distance to
+    vec2: Vec3Array to compute euclidean distance from, should be
+          broadcast compatible with 'vec1'
+    epsilon: distance is clipped from below to be at least epsilon
+
+  Returns:
+    Array of euclidean distances;
+    shape will be result of broadcasting 'vec1' and 'vec2'
+  """"""
+  distance_sq = square_euclidean_distance(vec1, vec2, epsilon**2)
+  distance = jnp.sqrt(distance_sq)
+  return distance
+
+
+def dihedral_angle(a: Vec3Array, b: Vec3Array, c: Vec3Array,
+                   d: Vec3Array) -> Float:
+  """"""Computes torsion angle for a quadruple of points.
+
+  For points (a, b, c, d), this is the angle between the planes defined by
+  points (a, b, c) and (b, c, d). It is also known as the dihedral angle.
+
+  Arguments:
+    a: A Vec3Array of coordinates.
+    b: A Vec3Array of coordinates.
+    c: A Vec3Array of coordinates.
+    d: A Vec3Array of coordinates.
+
+  Returns:
+    A tensor of angles in radians: [-pi, pi].
+  """"""
+  v1 = a - b
+  v2 = b - c
+  v3 = d - c
+
+  c1 = v1.cross(v2)
+  c2 = v3.cross(v2)
+  c3 = c2.cross(c1)
+
+  v2_mag = v2.norm()
+  return jnp.arctan2(c3.dot(v2), v2_mag * c1.dot(c2))
+
+
+def random_gaussian_vector(shape, key, dtype=jnp.float32):
+  vec_array = jax.random.normal(key, shape + (3,), dtype)
+  return Vec3Array.from_array(vec_array)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/geometry/__init__.py",".py","1172","32","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Geometry Module.""""""
+
+from alphafold.model.geometry import rigid_matrix_vector
+from alphafold.model.geometry import rotation_matrix
+from alphafold.model.geometry import struct_of_array
+from alphafold.model.geometry import vector
+
+Rot3Array = rotation_matrix.Rot3Array
+Rigid3Array = rigid_matrix_vector.Rigid3Array
+
+StructOfArray = struct_of_array.StructOfArray
+
+Vec3Array = vector.Vec3Array
+square_euclidean_distance = vector.square_euclidean_distance
+euclidean_distance = vector.euclidean_distance
+dihedral_angle = vector.dihedral_angle
+dot = vector.dot
+cross = vector.cross
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/geometry/rigid_matrix_vector.py",".py","4148","107","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Rigid3Array Transformations represented by a Matrix and a Vector.""""""
+
+from __future__ import annotations
+from typing import Union
+
+from alphafold.model.geometry import rotation_matrix
+from alphafold.model.geometry import struct_of_array
+from alphafold.model.geometry import vector
+import jax
+import jax.numpy as jnp
+
+Float = Union[float, jnp.ndarray]
+
+VERSION = '0.1'
+
+
+@struct_of_array.StructOfArray(same_dtype=True)
+class Rigid3Array:
+  """"""Rigid Transformation, i.e. element of special euclidean group.""""""
+
+  rotation: rotation_matrix.Rot3Array
+  translation: vector.Vec3Array
+
+  def __matmul__(self, other: Rigid3Array) -> Rigid3Array:
+    new_rotation = self.rotation @ other.rotation
+    new_translation = self.apply_to_point(other.translation)
+    return Rigid3Array(new_rotation, new_translation)
+
+  def inverse(self) -> Rigid3Array:
+    """"""Return Rigid3Array corresponding to inverse transform.""""""
+    inv_rotation = self.rotation.inverse()
+    inv_translation = inv_rotation.apply_to_point(-self.translation)
+    return Rigid3Array(inv_rotation, inv_translation)
+
+  def apply_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
+    """"""Apply Rigid3Array transform to point.""""""
+    return self.rotation.apply_to_point(point) + self.translation
+
+  def apply_inverse_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
+    """"""Apply inverse Rigid3Array transform to point.""""""
+    new_point = point - self.translation
+    return self.rotation.apply_inverse_to_point(new_point)
+
+  def compose_rotation(self, other_rotation):
+    rot = self.rotation @ other_rotation
+    trans = jax.tree_map(lambda x: jnp.broadcast_to(x, rot.shape),
+                         self.translation)
+    return Rigid3Array(rot, trans)
+
+  @classmethod
+  def identity(cls, shape, dtype=jnp.float32) -> Rigid3Array:
+    """"""Return identity Rigid3Array of given shape.""""""
+    return cls(
+        rotation_matrix.Rot3Array.identity(shape, dtype=dtype),
+        vector.Vec3Array.zeros(shape, dtype=dtype))  # pytype: disable=wrong-arg-count  # trace-all-classes
+
+  def scale_translation(self, factor: Float) -> Rigid3Array:
+    """"""Scale translation in Rigid3Array by 'factor'.""""""
+    return Rigid3Array(self.rotation, self.translation * factor)
+
+  def to_array(self):
+    rot_array = self.rotation.to_array()
+    vec_array = self.translation.to_array()
+    return jnp.concatenate([rot_array, vec_array[..., None]], axis=-1)
+
+  @classmethod
+  def from_array(cls, array):
+    rot = rotation_matrix.Rot3Array.from_array(array[..., :3])
+    vec = vector.Vec3Array.from_array(array[..., -1])
+    return cls(rot, vec)  # pytype: disable=wrong-arg-count  # trace-all-classes
+
+  @classmethod
+  def from_array4x4(cls, array: jnp.ndarray) -> Rigid3Array:
+    """"""Construct Rigid3Array from homogeneous 4x4 array.""""""
+    assert array.shape[-1] == 4
+    assert array.shape[-2] == 4
+    rotation = rotation_matrix.Rot3Array(
+        array[..., 0, 0], array[..., 0, 1], array[..., 0, 2],
+        array[..., 1, 0], array[..., 1, 1], array[..., 1, 2],
+        array[..., 2, 0], array[..., 2, 1], array[..., 2, 2]
+        )
+    translation = vector.Vec3Array(
+        array[..., 0, 3], array[..., 1, 3], array[..., 2, 3])
+    return cls(rotation, translation)  # pytype: disable=wrong-arg-count  # trace-all-classes
+
+  def __getstate__(self):
+    return (VERSION, (self.rotation, self.translation))
+
+  def __setstate__(self, state):
+    version, (rot, trans) = state
+    del version
+    object.__setattr__(self, 'rotation', rot)
+    object.__setattr__(self, 'translation', trans)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/geometry/utils.py",".py","853","24","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Utils for geometry library.""""""
+
+from typing import List
+
+import jax.numpy as jnp
+
+
+def unstack(value: jnp.ndarray, axis: int = -1) -> List[jnp.ndarray]:
+  return [jnp.squeeze(v, axis=axis)
+          for v in jnp.split(value, value.shape[axis], axis=axis)]
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/geometry/test_utils.py",".py","4166","99","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Shared utils for tests.""""""
+
+import dataclasses
+
+from alphafold.model.geometry import rigid_matrix_vector
+from alphafold.model.geometry import rotation_matrix
+from alphafold.model.geometry import vector
+import jax.numpy as jnp
+import numpy as np
+
+
+def assert_rotation_matrix_equal(matrix1: rotation_matrix.Rot3Array,
+                                 matrix2: rotation_matrix.Rot3Array):
+  for field in dataclasses.fields(rotation_matrix.Rot3Array):
+    field = field.name
+    np.testing.assert_array_equal(
+        getattr(matrix1, field), getattr(matrix2, field))
+
+
+def assert_rotation_matrix_close(mat1: rotation_matrix.Rot3Array,
+                                 mat2: rotation_matrix.Rot3Array):
+  np.testing.assert_array_almost_equal(mat1.to_array(), mat2.to_array(), 6)
+
+
+def assert_array_equal_to_rotation_matrix(array: jnp.ndarray,
+                                          matrix: rotation_matrix.Rot3Array):
+  """"""Check that array and Matrix match.""""""
+  np.testing.assert_array_equal(matrix.xx, array[..., 0, 0])
+  np.testing.assert_array_equal(matrix.xy, array[..., 0, 1])
+  np.testing.assert_array_equal(matrix.xz, array[..., 0, 2])
+  np.testing.assert_array_equal(matrix.yx, array[..., 1, 0])
+  np.testing.assert_array_equal(matrix.yy, array[..., 1, 1])
+  np.testing.assert_array_equal(matrix.yz, array[..., 1, 2])
+  np.testing.assert_array_equal(matrix.zx, array[..., 2, 0])
+  np.testing.assert_array_equal(matrix.zy, array[..., 2, 1])
+  np.testing.assert_array_equal(matrix.zz, array[..., 2, 2])
+
+
+def assert_array_close_to_rotation_matrix(array: jnp.ndarray,
+                                          matrix: rotation_matrix.Rot3Array):
+  np.testing.assert_array_almost_equal(matrix.to_array(), array, 6)
+
+
+def assert_vectors_equal(vec1: vector.Vec3Array, vec2: vector.Vec3Array):
+  np.testing.assert_array_equal(vec1.x, vec2.x)
+  np.testing.assert_array_equal(vec1.y, vec2.y)
+  np.testing.assert_array_equal(vec1.z, vec2.z)
+
+
+def assert_vectors_close(vec1: vector.Vec3Array, vec2: vector.Vec3Array):
+  np.testing.assert_allclose(vec1.x, vec2.x, atol=1e-6, rtol=0.)
+  np.testing.assert_allclose(vec1.y, vec2.y, atol=1e-6, rtol=0.)
+  np.testing.assert_allclose(vec1.z, vec2.z, atol=1e-6, rtol=0.)
+
+
+def assert_array_close_to_vector(array: jnp.ndarray, vec: vector.Vec3Array):
+  np.testing.assert_allclose(vec.to_array(), array, atol=1e-6, rtol=0.)
+
+
+def assert_array_equal_to_vector(array: jnp.ndarray, vec: vector.Vec3Array):
+  np.testing.assert_array_equal(vec.to_array(), array)
+
+
+def assert_rigid_equal_to_rigid(rigid1: rigid_matrix_vector.Rigid3Array,
+                                rigid2: rigid_matrix_vector.Rigid3Array):
+  assert_rot_trans_equal_to_rigid(rigid1.rotation, rigid1.translation, rigid2)
+
+
+def assert_rigid_close_to_rigid(rigid1: rigid_matrix_vector.Rigid3Array,
+                                rigid2: rigid_matrix_vector.Rigid3Array):
+  assert_rot_trans_close_to_rigid(rigid1.rotation, rigid1.translation, rigid2)
+
+
+def assert_rot_trans_equal_to_rigid(rot: rotation_matrix.Rot3Array,
+                                    trans: vector.Vec3Array,
+                                    rigid: rigid_matrix_vector.Rigid3Array):
+  assert_rotation_matrix_equal(rot, rigid.rotation)
+  assert_vectors_equal(trans, rigid.translation)
+
+
+def assert_rot_trans_close_to_rigid(rot: rotation_matrix.Rot3Array,
+                                    trans: vector.Vec3Array,
+                                    rigid: rigid_matrix_vector.Rigid3Array):
+  assert_rotation_matrix_close(rot, rigid.rotation)
+  assert_vectors_close(trans, rigid.translation)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/geometry/rotation_matrix.py",".py","5751","158","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Rot3Array Matrix Class.""""""
+
+from __future__ import annotations
+import dataclasses
+
+from alphafold.model.geometry import struct_of_array
+from alphafold.model.geometry import utils
+from alphafold.model.geometry import vector
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+COMPONENTS = ['xx', 'xy', 'xz', 'yx', 'yy', 'yz', 'zx', 'zy', 'zz']
+
+VERSION = '0.1'
+
+
+@struct_of_array.StructOfArray(same_dtype=True)
+class Rot3Array:
+  """"""Rot3Array Matrix in 3 dimensional Space implemented as struct of arrays.""""""
+
+  xx: jnp.ndarray = dataclasses.field(metadata={'dtype': jnp.float32})
+  xy: jnp.ndarray
+  xz: jnp.ndarray
+  yx: jnp.ndarray
+  yy: jnp.ndarray
+  yz: jnp.ndarray
+  zx: jnp.ndarray
+  zy: jnp.ndarray
+  zz: jnp.ndarray
+
+  __array_ufunc__ = None
+
+  def inverse(self) -> Rot3Array:
+    """"""Returns inverse of Rot3Array.""""""
+    return Rot3Array(self.xx, self.yx, self.zx,
+                     self.xy, self.yy, self.zy,
+                     self.xz, self.yz, self.zz)
+
+  def apply_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
+    """"""Applies Rot3Array to point.""""""
+    return vector.Vec3Array(
+        self.xx * point.x + self.xy * point.y + self.xz * point.z,
+        self.yx * point.x + self.yy * point.y + self.yz * point.z,
+        self.zx * point.x + self.zy * point.y + self.zz * point.z)
+
+  def apply_inverse_to_point(self, point: vector.Vec3Array) -> vector.Vec3Array:
+    """"""Applies inverse Rot3Array to point.""""""
+    return self.inverse().apply_to_point(point)
+
+  def __matmul__(self, other: Rot3Array) -> Rot3Array:
+    """"""Composes two Rot3Arrays.""""""
+    c0 = self.apply_to_point(vector.Vec3Array(other.xx, other.yx, other.zx))
+    c1 = self.apply_to_point(vector.Vec3Array(other.xy, other.yy, other.zy))
+    c2 = self.apply_to_point(vector.Vec3Array(other.xz, other.yz, other.zz))
+    return Rot3Array(c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z)
+
+  @classmethod
+  def identity(cls, shape, dtype=jnp.float32) -> Rot3Array:
+    """"""Returns identity of given shape.""""""
+    ones = jnp.ones(shape, dtype=dtype)
+    zeros = jnp.zeros(shape, dtype=dtype)
+    return cls(ones, zeros, zeros, zeros, ones, zeros, zeros, zeros, ones)  # pytype: disable=wrong-arg-count  # trace-all-classes
+
+  @classmethod
+  def from_two_vectors(cls, e0: vector.Vec3Array,
+                       e1: vector.Vec3Array) -> Rot3Array:
+    """"""Construct Rot3Array from two Vectors.
+
+    Rot3Array is constructed such that in the corresponding frame 'e0' lies on
+    the positive x-Axis and 'e1' lies in the xy plane with positive sign of y.
+
+    Args:
+      e0: Vector
+      e1: Vector
+    Returns:
+      Rot3Array
+    """"""
+    # Normalize the unit vector for the x-axis, e0.
+    e0 = e0.normalized()
+    # make e1 perpendicular to e0.
+    c = e1.dot(e0)
+    e1 = (e1 - c * e0).normalized()
+    # Compute e2 as cross product of e0 and e1.
+    e2 = e0.cross(e1)
+    return cls(e0.x, e1.x, e2.x, e0.y, e1.y, e2.y, e0.z, e1.z, e2.z)  # pytype: disable=wrong-arg-count  # trace-all-classes
+
+  @classmethod
+  def from_array(cls, array: jnp.ndarray) -> Rot3Array:
+    """"""Construct Rot3Array Matrix from array of shape. [..., 3, 3].""""""
+    unstacked = utils.unstack(array, axis=-2)
+    unstacked = sum([utils.unstack(x, axis=-1) for x in unstacked], [])
+    return cls(*unstacked)
+
+  def to_array(self) -> jnp.ndarray:
+    """"""Convert Rot3Array to array of shape [..., 3, 3].""""""
+    return jnp.stack(
+        [jnp.stack([self.xx, self.xy, self.xz], axis=-1),
+         jnp.stack([self.yx, self.yy, self.yz], axis=-1),
+         jnp.stack([self.zx, self.zy, self.zz], axis=-1)],
+        axis=-2)
+
+  @classmethod
+  def from_quaternion(cls,
+                      w: jnp.ndarray,
+                      x: jnp.ndarray,
+                      y: jnp.ndarray,
+                      z: jnp.ndarray,
+                      normalize: bool = True,
+                      epsilon: float = 1e-6) -> Rot3Array:
+    """"""Construct Rot3Array from components of quaternion.""""""
+    if normalize:
+      inv_norm = jax.lax.rsqrt(jnp.maximum(epsilon, w**2 + x**2 + y**2 + z**2))
+      w *= inv_norm
+      x *= inv_norm
+      y *= inv_norm
+      z *= inv_norm
+    xx = 1 - 2 * (jnp.square(y) + jnp.square(z))
+    xy = 2 * (x * y - w * z)
+    xz = 2 * (x * z + w * y)
+    yx = 2 * (x * y + w * z)
+    yy = 1 - 2 * (jnp.square(x) + jnp.square(z))
+    yz = 2 * (y * z - w * x)
+    zx = 2 * (x * z - w * y)
+    zy = 2 * (y * z + w * x)
+    zz = 1 - 2 * (jnp.square(x) + jnp.square(y))
+    return cls(xx, xy, xz, yx, yy, yz, zx, zy, zz)  # pytype: disable=wrong-arg-count  # trace-all-classes
+
+  @classmethod
+  def random_uniform(cls, key, shape, dtype=jnp.float32) -> Rot3Array:
+    """"""Samples uniform random Rot3Array according to Haar Measure.""""""
+    quat_array = jax.random.normal(key, tuple(shape) + (4,), dtype=dtype)
+    quats = utils.unstack(quat_array)
+    return cls.from_quaternion(*quats)
+
+  def __getstate__(self):
+    return (VERSION,
+            [np.asarray(getattr(self, field)) for field in COMPONENTS])
+
+  def __setstate__(self, state):
+    version, state = state
+    del version
+    for i, field in enumerate(COMPONENTS):
+      object.__setattr__(self, field, state[i])
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/geometry/struct_of_array.py",".py","7745","221","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Class decorator to represent (nested) struct of arrays.""""""
+
+import dataclasses
+
+import jax
+
+
+def get_item(instance, key):
+  sliced = {}
+  for field in get_array_fields(instance):
+    num_trailing_dims = field.metadata.get('num_trailing_dims', 0)
+    this_key = key
+    if isinstance(key, tuple) and Ellipsis in this_key:
+      this_key += (slice(None),) * num_trailing_dims
+    sliced[field.name] = getattr(instance, field.name)[this_key]
+  return dataclasses.replace(instance, **sliced)
+
+
+@property
+def get_shape(instance):
+  """"""Returns Shape for given instance of dataclass.""""""
+  first_field = dataclasses.fields(instance)[0]
+  num_trailing_dims = first_field.metadata.get('num_trailing_dims', None)
+  value = getattr(instance, first_field.name)
+  if num_trailing_dims:
+    return value.shape[:-num_trailing_dims]
+  else:
+    return value.shape
+
+
+def get_len(instance):
+  """"""Returns length for given instance of dataclass.""""""
+  shape = instance.shape
+  if shape:
+    return shape[0]
+  else:
+    raise TypeError('len() of unsized object')  # Match jax.numpy behavior.
+
+
+@property
+def get_dtype(instance):
+  """"""Returns Dtype for given instance of dataclass.""""""
+  fields = dataclasses.fields(instance)
+  sets_dtype = [
+      field.name for field in fields if field.metadata.get('sets_dtype', False)
+  ]
+  if sets_dtype:
+    assert len(sets_dtype) == 1, 'at most field can set dtype'
+    field_value = getattr(instance, sets_dtype[0])
+  elif instance.same_dtype:
+    field_value = getattr(instance, fields[0].name)
+  else:
+    # Should this be Value Error?
+    raise AttributeError('Trying to access Dtype on Struct of Array without'
+                         'either ""same_dtype"" or field setting dtype')
+
+  if hasattr(field_value, 'dtype'):
+    return field_value.dtype
+  else:
+    # Should this be Value Error?
+    raise AttributeError(f'field_value {field_value} does not have dtype')
+
+
+def replace(instance, **kwargs):
+  return dataclasses.replace(instance, **kwargs)
+
+
+def post_init(instance):
+  """"""Validate instance has same shapes & dtypes.""""""
+  array_fields = get_array_fields(instance)
+  arrays = list(get_array_fields(instance, return_values=True).values())
+  first_field = array_fields[0]
+  # These slightly weird constructions about checking whether the leaves are
+  # actual arrays is since e.g. vmap internally relies on being able to
+  # construct pytree's with object() as leaves, this would break the checking
+  # as such we are only validating the object when the entries in the dataclass
+  # Are arrays or other dataclasses of arrays.
+  try:
+    dtype = instance.dtype
+  except AttributeError:
+    dtype = None
+  if dtype is not None:
+    first_shape = instance.shape
+    for array, field in zip(arrays, array_fields):
+      field_shape = array.shape
+      num_trailing_dims = field.metadata.get('num_trailing_dims', None)
+      if num_trailing_dims:
+        array_shape = array.shape
+        field_shape = array_shape[:-num_trailing_dims]
+        msg = (f'field {field} should have number of trailing dims'
+               ' {num_trailing_dims}')
+        assert len(array_shape) == len(first_shape) + num_trailing_dims, msg
+      else:
+        field_shape = array.shape
+
+      shape_msg = (f""Stripped Shape {field_shape} of field {field} doesn't ""
+                   f""match shape {first_shape} of field {first_field}"")
+      assert field_shape == first_shape, shape_msg
+
+      field_dtype = array.dtype
+
+      allowed_metadata_dtypes = field.metadata.get('allowed_dtypes', [])
+      if allowed_metadata_dtypes:
+        msg = f'Dtype is {field_dtype} but must be in {allowed_metadata_dtypes}'
+        assert field_dtype in allowed_metadata_dtypes, msg
+
+      if 'dtype' in field.metadata:
+        target_dtype = field.metadata['dtype']
+      else:
+        target_dtype = dtype
+
+      msg = f'Dtype is {field_dtype} but must be {target_dtype}'
+      assert field_dtype == target_dtype, msg
+
+
+def flatten(instance):
+  """"""Flatten Struct of Array instance.""""""
+  array_likes = list(get_array_fields(instance, return_values=True).values())
+  flat_array_likes = []
+  inner_treedefs = []
+  num_arrays = []
+  for array_like in array_likes:
+    flat_array_like, inner_treedef = jax.tree_util.tree_flatten(array_like)
+    inner_treedefs.append(inner_treedef)
+    flat_array_likes += flat_array_like
+    num_arrays.append(len(flat_array_like))
+  metadata = get_metadata_fields(instance, return_values=True)
+  metadata = type(instance).metadata_cls(**metadata)
+  return flat_array_likes, (inner_treedefs, metadata, num_arrays)
+
+
+def make_metadata_class(cls):
+  metadata_fields = get_fields(cls,
+                               lambda x: x.metadata.get('is_metadata', False))
+  metadata_cls = dataclasses.make_dataclass(
+      cls_name='Meta' + cls.__name__,
+      fields=[(field.name, field.type, field) for field in metadata_fields],
+      frozen=True,
+      eq=True)
+  return metadata_cls
+
+
+def get_fields(cls_or_instance, filterfn, return_values=False):
+  fields = dataclasses.fields(cls_or_instance)
+  fields = [field for field in fields if filterfn(field)]
+  if return_values:
+    return {
+        field.name: getattr(cls_or_instance, field.name) for field in fields
+    }
+  else:
+    return fields
+
+
+def get_array_fields(cls, return_values=False):
+  return get_fields(
+      cls,
+      lambda x: not x.metadata.get('is_metadata', False),
+      return_values=return_values)
+
+
+def get_metadata_fields(cls, return_values=False):
+  return get_fields(
+      cls,
+      lambda x: x.metadata.get('is_metadata', False),
+      return_values=return_values)
+
+
+class StructOfArray:
+  """"""Class Decorator for Struct Of Arrays.""""""
+
+  def __init__(self, same_dtype=True):
+    self.same_dtype = same_dtype
+
+  def __call__(self, cls):
+    cls.__array_ufunc__ = None
+    cls.replace = replace
+    cls.same_dtype = self.same_dtype
+    cls.dtype = get_dtype
+    cls.shape = get_shape
+    cls.__len__ = get_len
+    cls.__getitem__ = get_item
+    cls.__post_init__ = post_init
+    new_cls = dataclasses.dataclass(cls, frozen=True, eq=False)  # pytype: disable=wrong-keyword-args
+    # pytree claims to require metadata to be hashable, not sure why,
+    # But making derived dataclass that can just hold metadata
+    new_cls.metadata_cls = make_metadata_class(new_cls)
+
+    def unflatten(aux, data):
+      inner_treedefs, metadata, num_arrays = aux
+      array_fields = [field.name for field in get_array_fields(new_cls)]
+      value_dict = {}
+      array_start = 0
+      for num_array, inner_treedef, array_field in zip(num_arrays,
+                                                       inner_treedefs,
+                                                       array_fields):
+        value_dict[array_field] = jax.tree_util.tree_unflatten(
+            inner_treedef, data[array_start:array_start + num_array])
+        array_start += num_array
+      metadata_fields = get_metadata_fields(new_cls)
+      for field in metadata_fields:
+        value_dict[field.name] = getattr(metadata, field.name)
+
+      return new_cls(**value_dict)
+
+    jax.tree_util.register_pytree_node(
+        nodetype=new_cls, flatten_func=flatten, unflatten_func=unflatten)
+    return new_cls
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/protein_features_test.py",".py","1822","55","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for protein_features.""""""
+import uuid
+
+from absl.testing import absltest
+from absl.testing import parameterized
+from alphafold.model.tf import protein_features
+import tensorflow.compat.v1 as tf
+
+
+def _random_bytes():
+  return str(uuid.uuid4()).encode('utf-8')
+
+
+class FeaturesTest(parameterized.TestCase, tf.test.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    tf.disable_v2_behavior()
+
+  def testFeatureNames(self):
+    self.assertEqual(len(protein_features.FEATURE_SIZES),
+                     len(protein_features.FEATURE_TYPES))
+    sorted_size_names = sorted(protein_features.FEATURE_SIZES.keys())
+    sorted_type_names = sorted(protein_features.FEATURE_TYPES.keys())
+    for i, size_name in enumerate(sorted_size_names):
+      self.assertEqual(size_name, sorted_type_names[i])
+
+  def testReplacement(self):
+    for name in protein_features.FEATURE_SIZES.keys():
+      sizes = protein_features.shape(name,
+                                     num_residues=12,
+                                     msa_length=24,
+                                     num_templates=3)
+      for x in sizes:
+        self.assertEqual(type(x), int)
+        self.assertGreater(x, 0)
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/shape_helpers.py",".py","1415","48","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Utilities for dealing with shapes of TensorFlow tensors.""""""
+import tensorflow.compat.v1 as tf
+
+
+def shape_list(x):
+  """"""Return list of dimensions of a tensor, statically where possible.
+
+  Like `x.shape.as_list()` but with tensors instead of `None`s.
+
+  Args:
+    x: A tensor.
+  Returns:
+    A list with length equal to the rank of the tensor. The n-th element of the
+    list is an integer when that dimension is statically known otherwise it is
+    the n-th element of `tf.shape(x)`.
+  """"""
+  x = tf.convert_to_tensor(x)
+
+  # If unknown rank, return dynamic shape
+  if x.get_shape().dims is None:
+    return tf.shape(x)
+
+  static = x.get_shape().as_list()
+  shape = tf.shape(x)
+
+  ret = []
+  for i in range(len(static)):
+    dim = static[i]
+    if dim is None:
+      dim = shape[i]
+    ret.append(dim)
+  return ret
+
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/shape_helpers_test.py",".py","1318","43","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for shape_helpers.""""""
+
+from alphafold.model.tf import shape_helpers
+import numpy as np
+import tensorflow.compat.v1 as tf
+
+
+class ShapeTest(tf.test.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    tf.disable_v2_behavior()
+
+  def test_shape_list(self):
+    """"""Test that shape_list can allow for reshaping to dynamic shapes.""""""
+    a = tf.zeros([10, 4, 4, 2])
+    p = tf.placeholder(tf.float32, shape=[None, None, 1, 4, 4])
+    shape_dyn = shape_helpers.shape_list(p)[:2] + [4, 4]
+
+    b = tf.reshape(a, shape_dyn)
+    with self.session() as sess:
+      out = sess.run(b, feed_dict={p: np.ones((20, 1, 1, 4, 4))})
+
+    self.assertAllEqual(out.shape, (20, 1, 4, 4))
+
+
+if __name__ == '__main__':
+  tf.test.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/protein_features.py",".py","5051","130","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Contains descriptions of various protein features.""""""
+import enum
+from typing import Dict, Optional, Sequence, Tuple, Union
+from alphafold.common import residue_constants
+import tensorflow.compat.v1 as tf
+
+# Type aliases.
+FeaturesMetadata = Dict[str, Tuple[tf.dtypes.DType, Sequence[Union[str, int]]]]
+
+
+class FeatureType(enum.Enum):
+  ZERO_DIM = 0  # Shape [x]
+  ONE_DIM = 1  # Shape [num_res, x]
+  TWO_DIM = 2  # Shape [num_res, num_res, x]
+  MSA = 3  # Shape [msa_length, num_res, x]
+
+
+# Placeholder values that will be replaced with their true value at runtime.
+NUM_RES = ""num residues placeholder""
+NUM_SEQ = ""length msa placeholder""
+NUM_TEMPLATES = ""num templates placeholder""
+# Sizes of the protein features, NUM_RES and NUM_SEQ are allowed as placeholders
+# to be replaced with the number of residues and the number of sequences in the
+# multiple sequence alignment, respectively.
+
+
+FEATURES = {
+    #### Static features of a protein sequence ####
+    ""aatype"": (tf.float32, [NUM_RES, 21]),
+    ""between_segment_residues"": (tf.int64, [NUM_RES, 1]),
+    ""deletion_matrix"": (tf.float32, [NUM_SEQ, NUM_RES, 1]),
+    ""domain_name"": (tf.string, [1]),
+    ""msa"": (tf.int64, [NUM_SEQ, NUM_RES, 1]),
+    ""num_alignments"": (tf.int64, [NUM_RES, 1]),
+    ""residue_index"": (tf.int64, [NUM_RES, 1]),
+    ""seq_length"": (tf.int64, [NUM_RES, 1]),
+    ""sequence"": (tf.string, [1]),
+    ""all_atom_positions"": (tf.float32,
+                           [NUM_RES, residue_constants.atom_type_num, 3]),
+    ""all_atom_mask"": (tf.int64, [NUM_RES, residue_constants.atom_type_num]),
+    ""resolution"": (tf.float32, [1]),
+    ""template_domain_names"": (tf.string, [NUM_TEMPLATES]),
+    ""template_sum_probs"": (tf.float32, [NUM_TEMPLATES, 1]),
+    ""template_aatype"": (tf.float32, [NUM_TEMPLATES, NUM_RES, 22]),
+    ""template_all_atom_positions"": (tf.float32, [
+        NUM_TEMPLATES, NUM_RES, residue_constants.atom_type_num, 3
+    ]),
+    ""template_all_atom_masks"": (tf.float32, [
+        NUM_TEMPLATES, NUM_RES, residue_constants.atom_type_num, 1
+    ]),
+}
+
+FEATURE_TYPES = {k: v[0] for k, v in FEATURES.items()}
+FEATURE_SIZES = {k: v[1] for k, v in FEATURES.items()}
+
+
+def register_feature(name: str,
+                     type_: tf.dtypes.DType,
+                     shape_: Tuple[Union[str, int]]):
+  """"""Register extra features used in custom datasets.""""""
+  FEATURES[name] = (type_, shape_)
+  FEATURE_TYPES[name] = type_
+  FEATURE_SIZES[name] = shape_
+
+
+def shape(feature_name: str,
+          num_residues: int,
+          msa_length: int,
+          num_templates: Optional[int] = None,
+          features: Optional[FeaturesMetadata] = None):
+  """"""Get the shape for the given feature name.
+
+  This is near identical to _get_tf_shape_no_placeholders() but with 2
+  differences:
+  * This method does not calculate a single placeholder from the total number of
+    elements (eg given <NUM_RES, 3> and size := 12, this won't deduce NUM_RES
+    must be 4)
+  * This method will work with tensors
+
+  Args:
+    feature_name: String identifier for the feature. If the feature name ends
+      with ""_unnormalized"", this suffix is stripped off.
+    num_residues: The number of residues in the current domain - some elements
+      of the shape can be dynamic and will be replaced by this value.
+    msa_length: The number of sequences in the multiple sequence alignment, some
+      elements of the shape can be dynamic and will be replaced by this value.
+      If the number of alignments is unknown / not read, please pass None for
+      msa_length.
+    num_templates (optional): The number of templates in this tfexample.
+    features: A feature_name to (tf_dtype, shape) lookup; defaults to FEATURES.
+
+  Returns:
+    List of ints representation the tensor size.
+
+  Raises:
+    ValueError: If a feature is requested but no concrete placeholder value is
+        given.
+  """"""
+  features = features or FEATURES
+  if feature_name.endswith(""_unnormalized""):
+    feature_name = feature_name[:-13]
+
+  unused_dtype, raw_sizes = features[feature_name]
+  replacements = {NUM_RES: num_residues,
+                  NUM_SEQ: msa_length}
+
+  if num_templates is not None:
+    replacements[NUM_TEMPLATES] = num_templates
+
+  sizes = [replacements.get(dimension, dimension) for dimension in raw_sizes]
+  for dimension in sizes:
+    if isinstance(dimension, str):
+      raise ValueError(""Could not parse %s (shape: %s) with values: %s"" % (
+          feature_name, raw_sizes, replacements))
+  return sizes
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/proteins_dataset.py",".py","6344","167","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Datasets consisting of proteins.""""""
+from typing import Dict, Mapping, Optional, Sequence
+from alphafold.model.tf import protein_features
+import numpy as np
+import tensorflow.compat.v1 as tf
+
+TensorDict = Dict[str, tf.Tensor]
+
+
+def parse_tfexample(
+    raw_data: bytes,
+    features: protein_features.FeaturesMetadata,
+    key: Optional[str] = None) -> Dict[str, tf.train.Feature]:
+  """"""Read a single TF Example proto and return a subset of its features.
+
+  Args:
+    raw_data: A serialized tf.Example proto.
+    features: A dictionary of features, mapping string feature names to a tuple
+      (dtype, shape). This dictionary should be a subset of
+      protein_features.FEATURES (or the dictionary itself for all features).
+    key: Optional string with the SSTable key of that tf.Example. This will be
+      added into features as a 'key' but only if requested in features.
+
+  Returns:
+    A dictionary of features mapping feature names to features. Only the given
+    features are returned, all other ones are filtered out.
+  """"""
+  feature_map = {
+      k: tf.io.FixedLenSequenceFeature(shape=(), dtype=v[0], allow_missing=True)
+      for k, v in features.items()
+  }
+  parsed_features = tf.io.parse_single_example(raw_data, feature_map)
+  reshaped_features = parse_reshape_logic(parsed_features, features, key=key)
+
+  return reshaped_features
+
+
+def _first(tensor: tf.Tensor) -> tf.Tensor:
+  """"""Returns the 1st element - the input can be a tensor or a scalar.""""""
+  return tf.reshape(tensor, shape=(-1,))[0]
+
+
+def parse_reshape_logic(
+    parsed_features: TensorDict,
+    features: protein_features.FeaturesMetadata,
+    key: Optional[str] = None) -> TensorDict:
+  """"""Transforms parsed serial features to the correct shape.""""""
+  # Find out what is the number of sequences and the number of alignments.
+  num_residues = tf.cast(_first(parsed_features[""seq_length""]), dtype=tf.int32)
+
+  if ""num_alignments"" in parsed_features:
+    num_msa = tf.cast(_first(parsed_features[""num_alignments""]), dtype=tf.int32)
+  else:
+    num_msa = 0
+
+  if ""template_domain_names"" in parsed_features:
+    num_templates = tf.cast(
+        tf.shape(parsed_features[""template_domain_names""])[0], dtype=tf.int32)
+  else:
+    num_templates = 0
+
+  if key is not None and ""key"" in features:
+    parsed_features[""key""] = [key]  # Expand dims from () to (1,).
+
+  # Reshape the tensors according to the sequence length and num alignments.
+  for k, v in parsed_features.items():
+    new_shape = protein_features.shape(
+        feature_name=k,
+        num_residues=num_residues,
+        msa_length=num_msa,
+        num_templates=num_templates,
+        features=features)
+    new_shape_size = tf.constant(1, dtype=tf.int32)
+    for dim in new_shape:
+      new_shape_size *= tf.cast(dim, tf.int32)
+
+    assert_equal = tf.assert_equal(
+        tf.size(v), new_shape_size,
+        name=""assert_%s_shape_correct"" % k,
+        message=""The size of feature %s (%s) could not be reshaped ""
+        ""into %s"" % (k, tf.size(v), new_shape))
+    if ""template"" not in k:
+      # Make sure the feature we are reshaping is not empty.
+      assert_non_empty = tf.assert_greater(
+          tf.size(v), 0, name=""assert_%s_non_empty"" % k,
+          message=""The feature %s is not set in the tf.Example. Either do not ""
+          ""request the feature or use a tf.Example that has the ""
+          ""feature set."" % k)
+      with tf.control_dependencies([assert_non_empty, assert_equal]):
+        parsed_features[k] = tf.reshape(v, new_shape, name=""reshape_%s"" % k)
+    else:
+      with tf.control_dependencies([assert_equal]):
+        parsed_features[k] = tf.reshape(v, new_shape, name=""reshape_%s"" % k)
+
+  return parsed_features
+
+
+def _make_features_metadata(
+    feature_names: Sequence[str]) -> protein_features.FeaturesMetadata:
+  """"""Makes a feature name to type and shape mapping from a list of names.""""""
+  # Make sure these features are always read.
+  required_features = [""aatype"", ""sequence"", ""seq_length""]
+  feature_names = list(set(feature_names) | set(required_features))
+
+  features_metadata = {name: protein_features.FEATURES[name]
+                       for name in feature_names}
+  return features_metadata
+
+
+def create_tensor_dict(
+    raw_data: bytes,
+    features: Sequence[str],
+    key: Optional[str] = None,
+    ) -> TensorDict:
+  """"""Creates a dictionary of tensor features.
+
+  Args:
+    raw_data: A serialized tf.Example proto.
+    features: A list of strings of feature names to be returned in the dataset.
+    key: Optional string with the SSTable key of that tf.Example. This will be
+      added into features as a 'key' but only if requested in features.
+
+  Returns:
+    A dictionary of features mapping feature names to features. Only the given
+    features are returned, all other ones are filtered out.
+  """"""
+  features_metadata = _make_features_metadata(features)
+  return parse_tfexample(raw_data, features_metadata, key)
+
+
+def np_to_tensor_dict(
+    np_example: Mapping[str, np.ndarray],
+    features: Sequence[str],
+    ) -> TensorDict:
+  """"""Creates dict of tensors from a dict of NumPy arrays.
+
+  Args:
+    np_example: A dict of NumPy feature arrays.
+    features: A list of strings of feature names to be returned in the dataset.
+
+  Returns:
+    A dictionary of features mapping feature names to features. Only the given
+    features are returned, all other ones are filtered out.
+  """"""
+  features_metadata = _make_features_metadata(features)
+  tensor_dict = {k: tf.constant(v) for k, v in np_example.items()
+                 if k in features_metadata}
+
+  # Ensures shapes are as expected. Needed for setting size of empty features
+  # e.g. when no template hits were found.
+  tensor_dict = parse_reshape_logic(tensor_dict, features_metadata)
+  return tensor_dict
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/shape_placeholders.py",".py","812","21","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Placeholder values for run-time varying dimension sizes.""""""
+
+NUM_RES = 'num residues placeholder'
+NUM_MSA_SEQ = 'msa placeholder'
+NUM_EXTRA_SEQ = 'extra msa placeholder'
+NUM_TEMPLATES = 'num templates placeholder'
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/__init__.py",".py","633","15","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Alphafold model TensorFlow code.""""""
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/input_pipeline.py",".py","5357","167","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Feature pre-processing input pipeline for AlphaFold.""""""
+
+from alphafold.model.tf import data_transforms
+from alphafold.model.tf import shape_placeholders
+import tensorflow.compat.v1 as tf
+import tree
+
+# Pylint gets confused by the curry1 decorator because it changes the number
+#   of arguments to the function.
+# pylint:disable=no-value-for-parameter
+
+
+NUM_RES = shape_placeholders.NUM_RES
+NUM_MSA_SEQ = shape_placeholders.NUM_MSA_SEQ
+NUM_EXTRA_SEQ = shape_placeholders.NUM_EXTRA_SEQ
+NUM_TEMPLATES = shape_placeholders.NUM_TEMPLATES
+
+
+def nonensembled_map_fns(data_config):
+  """"""Input pipeline functions which are not ensembled.""""""
+  common_cfg = data_config.common
+
+  map_fns = [
+      data_transforms.correct_msa_restypes,
+      data_transforms.add_distillation_flag(False),
+      data_transforms.cast_64bit_ints,
+      data_transforms.squeeze_features,
+      # Keep to not disrupt RNG.
+      data_transforms.randomly_replace_msa_with_unknown(0.0),
+      data_transforms.make_seq_mask,
+      data_transforms.make_msa_mask,
+      # Compute the HHblits profile if it's not set. This has to be run before
+      # sampling the MSA.
+      data_transforms.make_hhblits_profile,
+      data_transforms.make_random_crop_to_size_seed,
+  ]
+  if common_cfg.use_templates:
+    map_fns.extend([
+        data_transforms.fix_templates_aatype,
+        data_transforms.make_template_mask,
+        data_transforms.make_pseudo_beta('template_')
+    ])
+  map_fns.extend([
+      data_transforms.make_atom14_masks,
+  ])
+
+  return map_fns
+
+
+def ensembled_map_fns(data_config):
+  """"""Input pipeline functions that can be ensembled and averaged.""""""
+  common_cfg = data_config.common
+  eval_cfg = data_config.eval
+
+  map_fns = []
+
+  if common_cfg.reduce_msa_clusters_by_max_templates:
+    pad_msa_clusters = eval_cfg.max_msa_clusters - eval_cfg.max_templates
+  else:
+    pad_msa_clusters = eval_cfg.max_msa_clusters
+
+  max_msa_clusters = pad_msa_clusters
+  max_extra_msa = common_cfg.max_extra_msa
+
+  map_fns.append(
+      data_transforms.sample_msa(
+          max_msa_clusters,
+          keep_extra=True))
+
+  if 'masked_msa' in common_cfg:
+    # Masked MSA should come *before* MSA clustering so that
+    # the clustering and full MSA profile do not leak information about
+    # the masked locations and secret corrupted locations.
+    map_fns.append(
+        data_transforms.make_masked_msa(common_cfg.masked_msa,
+                                        eval_cfg.masked_msa_replace_fraction))
+
+  if common_cfg.msa_cluster_features:
+    map_fns.append(data_transforms.nearest_neighbor_clusters())
+    map_fns.append(data_transforms.summarize_clusters())
+
+  # Crop after creating the cluster profiles.
+  if max_extra_msa:
+    map_fns.append(data_transforms.crop_extra_msa(max_extra_msa))
+  else:
+    map_fns.append(data_transforms.delete_extra_msa)
+
+  map_fns.append(data_transforms.make_msa_feat())
+
+  crop_feats = dict(eval_cfg.feat)
+
+  if eval_cfg.fixed_size:
+    map_fns.append(data_transforms.select_feat(list(crop_feats)))
+    map_fns.append(data_transforms.random_crop_to_size(
+        eval_cfg.crop_size,
+        eval_cfg.max_templates,
+        crop_feats,
+        eval_cfg.subsample_templates))
+    map_fns.append(data_transforms.make_fixed_size(
+        crop_feats,
+        pad_msa_clusters,
+        common_cfg.max_extra_msa,
+        eval_cfg.crop_size,
+        eval_cfg.max_templates))
+  else:
+    map_fns.append(data_transforms.crop_templates(eval_cfg.max_templates))
+
+  return map_fns
+
+
+def process_tensors_from_config(tensors, data_config):
+  """"""Apply filters and maps to an existing dataset, based on the config.""""""
+
+  def wrap_ensemble_fn(data, i):
+    """"""Function to be mapped over the ensemble dimension.""""""
+    d = data.copy()
+    fns = ensembled_map_fns(data_config)
+    fn = compose(fns)
+    d['ensemble_index'] = i
+    return fn(d)
+
+  eval_cfg = data_config.eval
+  tensors = compose(
+      nonensembled_map_fns(
+          data_config))(
+              tensors)
+
+  tensors_0 = wrap_ensemble_fn(tensors, tf.constant(0))
+  num_ensemble = eval_cfg.num_ensemble
+  if data_config.common.resample_msa_in_recycling:
+    # Separate batch per ensembling & recycling step.
+    num_ensemble *= data_config.common.num_recycle + 1
+
+  if isinstance(num_ensemble, tf.Tensor) or num_ensemble > 1:
+    fn_output_signature = tree.map_structure(
+        tf.TensorSpec.from_tensor, tensors_0)
+    tensors = tf.map_fn(
+        lambda x: wrap_ensemble_fn(tensors, x),
+        tf.range(num_ensemble),
+        parallel_iterations=1,
+        fn_output_signature=fn_output_signature)
+  else:
+    tensors = tree.map_structure(lambda x: x[None],
+                                 tensors_0)
+  return tensors
+
+
+@data_transforms.curry1
+def compose(x, fs):
+  for f in fs:
+    x = f(x)
+  return x
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/data_transforms.py",".py","21428","626","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Data for AlphaFold.""""""
+
+from alphafold.common import residue_constants
+from alphafold.model.tf import shape_helpers
+from alphafold.model.tf import shape_placeholders
+from alphafold.model.tf import utils
+import numpy as np
+import tensorflow.compat.v1 as tf
+
+# Pylint gets confused by the curry1 decorator because it changes the number
+#   of arguments to the function.
+# pylint:disable=no-value-for-parameter
+
+
+NUM_RES = shape_placeholders.NUM_RES
+NUM_MSA_SEQ = shape_placeholders.NUM_MSA_SEQ
+NUM_EXTRA_SEQ = shape_placeholders.NUM_EXTRA_SEQ
+NUM_TEMPLATES = shape_placeholders.NUM_TEMPLATES
+
+
+def cast_64bit_ints(protein):
+
+  for k, v in protein.items():
+    if v.dtype == tf.int64:
+      protein[k] = tf.cast(v, tf.int32)
+  return protein
+
+
+_MSA_FEATURE_NAMES = [
+    'msa', 'deletion_matrix', 'msa_mask', 'msa_row_mask', 'bert_mask',
+    'true_msa'
+]
+
+
+def make_seq_mask(protein):
+  protein['seq_mask'] = tf.ones(
+      shape_helpers.shape_list(protein['aatype']), dtype=tf.float32)
+  return protein
+
+
+def make_template_mask(protein):
+  protein['template_mask'] = tf.ones(
+      shape_helpers.shape_list(protein['template_domain_names']),
+      dtype=tf.float32)
+  return protein
+
+
+def curry1(f):
+  """"""Supply all arguments but the first.""""""
+
+  def fc(*args, **kwargs):
+    return lambda x: f(x, *args, **kwargs)
+
+  return fc
+
+
+@curry1
+def add_distillation_flag(protein, distillation):
+  protein['is_distillation'] = tf.constant(float(distillation),
+                                           shape=[],
+                                           dtype=tf.float32)
+  return protein
+
+
+def make_all_atom_aatype(protein):
+  protein['all_atom_aatype'] = protein['aatype']
+  return protein
+
+
+def fix_templates_aatype(protein):
+  """"""Fixes aatype encoding of templates.""""""
+  # Map one-hot to indices.
+  protein['template_aatype'] = tf.argmax(
+      protein['template_aatype'], output_type=tf.int32, axis=-1)
+  # Map hhsearch-aatype to our aatype.
+  new_order_list = residue_constants.MAP_HHBLITS_AATYPE_TO_OUR_AATYPE
+  new_order = tf.constant(new_order_list, dtype=tf.int32)
+  protein['template_aatype'] = tf.gather(params=new_order,
+                                         indices=protein['template_aatype'])
+  return protein
+
+
+def correct_msa_restypes(protein):
+  """"""Correct MSA restype to have the same order as residue_constants.""""""
+  new_order_list = residue_constants.MAP_HHBLITS_AATYPE_TO_OUR_AATYPE
+  new_order = tf.constant(new_order_list, dtype=protein['msa'].dtype)
+  protein['msa'] = tf.gather(new_order, protein['msa'], axis=0)
+
+  perm_matrix = np.zeros((22, 22), dtype=np.float32)
+  perm_matrix[range(len(new_order_list)), new_order_list] = 1.
+
+  for k in protein:
+    if 'profile' in k:  # Include both hhblits and psiblast profiles
+      num_dim = protein[k].shape.as_list()[-1]
+      assert num_dim in [20, 21, 22], (
+          'num_dim for %s out of expected range: %s' % (k, num_dim))
+      protein[k] = tf.tensordot(protein[k], perm_matrix[:num_dim, :num_dim], 1)
+  return protein
+
+
+def squeeze_features(protein):
+  """"""Remove singleton and repeated dimensions in protein features.""""""
+  protein['aatype'] = tf.argmax(
+      protein['aatype'], axis=-1, output_type=tf.int32)
+  for k in [
+      'domain_name', 'msa', 'num_alignments', 'seq_length', 'sequence',
+      'superfamily', 'deletion_matrix', 'resolution',
+      'between_segment_residues', 'residue_index', 'template_all_atom_masks']:
+    if k in protein:
+      final_dim = shape_helpers.shape_list(protein[k])[-1]
+      if isinstance(final_dim, int) and final_dim == 1:
+        protein[k] = tf.squeeze(protein[k], axis=-1)
+
+  for k in ['seq_length', 'num_alignments']:
+    if k in protein:
+      protein[k] = protein[k][0]  # Remove fake sequence dimension
+  return protein
+
+
+def make_random_crop_to_size_seed(protein):
+  """"""Random seed for cropping residues and templates.""""""
+  protein['random_crop_to_size_seed'] = utils.make_random_seed()
+  return protein
+
+
+@curry1
+def randomly_replace_msa_with_unknown(protein, replace_proportion):
+  """"""Replace a proportion of the MSA with 'X'.""""""
+  msa_mask = (tf.random.uniform(shape_helpers.shape_list(protein['msa'])) <
+              replace_proportion)
+  x_idx = 20
+  gap_idx = 21
+  msa_mask = tf.logical_and(msa_mask, protein['msa'] != gap_idx)
+  protein['msa'] = tf.where(msa_mask,
+                            tf.ones_like(protein['msa']) * x_idx,
+                            protein['msa'])
+  aatype_mask = (
+      tf.random.uniform(shape_helpers.shape_list(protein['aatype'])) <
+      replace_proportion)
+
+  protein['aatype'] = tf.where(aatype_mask,
+                               tf.ones_like(protein['aatype']) * x_idx,
+                               protein['aatype'])
+  return protein
+
+
+@curry1
+def sample_msa(protein, max_seq, keep_extra):
+  """"""Sample MSA randomly, remaining sequences are stored as `extra_*`.
+
+  Args:
+    protein: batch to sample msa from.
+    max_seq: number of sequences to sample.
+    keep_extra: When True sequences not sampled are put into fields starting
+      with 'extra_*'.
+
+  Returns:
+    Protein with sampled msa.
+  """"""
+  num_seq = tf.shape(protein['msa'])[0]
+  shuffled = tf.random_shuffle(tf.range(1, num_seq))
+  index_order = tf.concat([[0], shuffled], axis=0)
+  num_sel = tf.minimum(max_seq, num_seq)
+
+  sel_seq, not_sel_seq = tf.split(index_order, [num_sel, num_seq - num_sel])
+
+  for k in _MSA_FEATURE_NAMES:
+    if k in protein:
+      if keep_extra:
+        protein['extra_' + k] = tf.gather(protein[k], not_sel_seq)
+      protein[k] = tf.gather(protein[k], sel_seq)
+
+  return protein
+
+
+@curry1
+def crop_extra_msa(protein, max_extra_msa):
+  """"""MSA features are cropped so only `max_extra_msa` sequences are kept.""""""
+  num_seq = tf.shape(protein['extra_msa'])[0]
+  num_sel = tf.minimum(max_extra_msa, num_seq)
+  select_indices = tf.random_shuffle(tf.range(0, num_seq))[:num_sel]
+  for k in _MSA_FEATURE_NAMES:
+    if 'extra_' + k in protein:
+      protein['extra_' + k] = tf.gather(protein['extra_' + k], select_indices)
+
+  return protein
+
+
+def delete_extra_msa(protein):
+  for k in _MSA_FEATURE_NAMES:
+    if 'extra_' + k in protein:
+      del protein['extra_' + k]
+  return protein
+
+
+@curry1
+def block_delete_msa(protein, config):
+  """"""Sample MSA by deleting contiguous blocks.
+
+  Jumper et al. (2021) Suppl. Alg. 1 ""MSABlockDeletion""
+
+  Arguments:
+    protein: batch dict containing the msa
+    config: ConfigDict with parameters
+
+  Returns:
+    updated protein
+  """"""
+  num_seq = shape_helpers.shape_list(protein['msa'])[0]
+  block_num_seq = tf.cast(
+      tf.floor(tf.cast(num_seq, tf.float32) * config.msa_fraction_per_block),
+      tf.int32)
+
+  if config.randomize_num_blocks:
+    nb = tf.random.uniform([], 0, config.num_blocks + 1, dtype=tf.int32)
+  else:
+    nb = config.num_blocks
+
+  del_block_starts = tf.random.uniform([nb], 0, num_seq, dtype=tf.int32)
+  del_blocks = del_block_starts[:, None] + tf.range(block_num_seq)
+  del_blocks = tf.clip_by_value(del_blocks, 0, num_seq - 1)
+  del_indices = tf.unique(tf.sort(tf.reshape(del_blocks, [-1])))[0]
+
+  # Make sure we keep the original sequence
+  sparse_diff = tf.sets.difference(tf.range(1, num_seq)[None],
+                                   del_indices[None])
+  keep_indices = tf.squeeze(tf.sparse.to_dense(sparse_diff), 0)
+  keep_indices = tf.concat([[0], keep_indices], axis=0)
+
+  for k in _MSA_FEATURE_NAMES:
+    if k in protein:
+      protein[k] = tf.gather(protein[k], keep_indices)
+
+  return protein
+
+
+@curry1
+def nearest_neighbor_clusters(protein, gap_agreement_weight=0.):
+  """"""Assign each extra MSA sequence to its nearest neighbor in sampled MSA.""""""
+
+  # Determine how much weight we assign to each agreement.  In theory, we could
+  # use a full blosum matrix here, but right now let's just down-weight gap
+  # agreement because it could be spurious.
+  # Never put weight on agreeing on BERT mask
+  weights = tf.concat([
+      tf.ones(21),
+      gap_agreement_weight * tf.ones(1),
+      np.zeros(1)], 0)
+
+  # Make agreement score as weighted Hamming distance
+  sample_one_hot = (protein['msa_mask'][:, :, None] *
+                    tf.one_hot(protein['msa'], 23))
+  extra_one_hot = (protein['extra_msa_mask'][:, :, None] *
+                   tf.one_hot(protein['extra_msa'], 23))
+
+  num_seq, num_res, _ = shape_helpers.shape_list(sample_one_hot)
+  extra_num_seq, _, _ = shape_helpers.shape_list(extra_one_hot)
+
+  # Compute tf.einsum('mrc,nrc,c->mn', sample_one_hot, extra_one_hot, weights)
+  # in an optimized fashion to avoid possible memory or computation blowup.
+  agreement = tf.matmul(
+      tf.reshape(extra_one_hot, [extra_num_seq, num_res * 23]),
+      tf.reshape(sample_one_hot * weights, [num_seq, num_res * 23]),
+      transpose_b=True)
+
+  # Assign each sequence in the extra sequences to the closest MSA sample
+  protein['extra_cluster_assignment'] = tf.argmax(
+      agreement, axis=1, output_type=tf.int32)
+
+  return protein
+
+
+@curry1
+def summarize_clusters(protein):
+  """"""Produce profile and deletion_matrix_mean within each cluster.""""""
+  num_seq = shape_helpers.shape_list(protein['msa'])[0]
+  def csum(x):
+    return tf.math.unsorted_segment_sum(
+        x, protein['extra_cluster_assignment'], num_seq)
+
+  mask = protein['extra_msa_mask']
+  mask_counts = 1e-6 + protein['msa_mask'] + csum(mask)  # Include center
+
+  msa_sum = csum(mask[:, :, None] * tf.one_hot(protein['extra_msa'], 23))
+  msa_sum += tf.one_hot(protein['msa'], 23)  # Original sequence
+  protein['cluster_profile'] = msa_sum / mask_counts[:, :, None]
+
+  del msa_sum
+
+  del_sum = csum(mask * protein['extra_deletion_matrix'])
+  del_sum += protein['deletion_matrix']  # Original sequence
+  protein['cluster_deletion_mean'] = del_sum / mask_counts
+  del del_sum
+
+  return protein
+
+
+def make_msa_mask(protein):
+  """"""Mask features are all ones, but will later be zero-padded.""""""
+  protein['msa_mask'] = tf.ones(
+      shape_helpers.shape_list(protein['msa']), dtype=tf.float32)
+  protein['msa_row_mask'] = tf.ones(
+      shape_helpers.shape_list(protein['msa'])[0], dtype=tf.float32)
+  return protein
+
+
+def pseudo_beta_fn(aatype, all_atom_positions, all_atom_masks):
+  """"""Create pseudo beta features.""""""
+  is_gly = tf.equal(aatype, residue_constants.restype_order['G'])
+  ca_idx = residue_constants.atom_order['CA']
+  cb_idx = residue_constants.atom_order['CB']
+  pseudo_beta = tf.where(
+      tf.tile(is_gly[..., None], [1] * len(is_gly.shape) + [3]),
+      all_atom_positions[..., ca_idx, :],
+      all_atom_positions[..., cb_idx, :])
+
+  if all_atom_masks is not None:
+    pseudo_beta_mask = tf.where(
+        is_gly, all_atom_masks[..., ca_idx], all_atom_masks[..., cb_idx])
+    pseudo_beta_mask = tf.cast(pseudo_beta_mask, tf.float32)
+    return pseudo_beta, pseudo_beta_mask
+  else:
+    return pseudo_beta
+
+
+@curry1
+def make_pseudo_beta(protein, prefix=''):
+  """"""Create pseudo-beta (alpha for glycine) position and mask.""""""
+  assert prefix in ['', 'template_']
+  protein[prefix + 'pseudo_beta'], protein[prefix + 'pseudo_beta_mask'] = (
+      pseudo_beta_fn(
+          protein['template_aatype' if prefix else 'all_atom_aatype'],
+          protein[prefix + 'all_atom_positions'],
+          protein['template_all_atom_masks' if prefix else 'all_atom_mask']))
+  return protein
+
+
+@curry1
+def add_constant_field(protein, key, value):
+  protein[key] = tf.convert_to_tensor(value)
+  return protein
+
+
+def shaped_categorical(probs, epsilon=1e-10):
+  ds = shape_helpers.shape_list(probs)
+  num_classes = ds[-1]
+  counts = tf.random.categorical(
+      tf.reshape(tf.log(probs + epsilon), [-1, num_classes]),
+      1,
+      dtype=tf.int32)
+  return tf.reshape(counts, ds[:-1])
+
+
+def make_hhblits_profile(protein):
+  """"""Compute the HHblits MSA profile if not already present.""""""
+  if 'hhblits_profile' in protein:
+    return protein
+
+  # Compute the profile for every residue (over all MSA sequences).
+  protein['hhblits_profile'] = tf.reduce_mean(
+      tf.one_hot(protein['msa'], 22), axis=0)
+  return protein
+
+
+@curry1
+def make_masked_msa(protein, config, replace_fraction):
+  """"""Create data for BERT on raw MSA.""""""
+  # Add a random amino acid uniformly
+  random_aa = tf.constant([0.05] * 20 + [0., 0.], dtype=tf.float32)
+
+  categorical_probs = (
+      config.uniform_prob * random_aa +
+      config.profile_prob * protein['hhblits_profile'] +
+      config.same_prob * tf.one_hot(protein['msa'], 22))
+
+  # Put all remaining probability on [MASK] which is a new column
+  pad_shapes = [[0, 0] for _ in range(len(categorical_probs.shape))]
+  pad_shapes[-1][1] = 1
+  mask_prob = 1. - config.profile_prob - config.same_prob - config.uniform_prob
+  assert mask_prob >= 0.
+  categorical_probs = tf.pad(
+      categorical_probs, pad_shapes, constant_values=mask_prob)
+
+  sh = shape_helpers.shape_list(protein['msa'])
+  mask_position = tf.random.uniform(sh) < replace_fraction
+
+  bert_msa = shaped_categorical(categorical_probs)
+  bert_msa = tf.where(mask_position, bert_msa, protein['msa'])
+
+  # Mix real and masked MSA
+  protein['bert_mask'] = tf.cast(mask_position, tf.float32)
+  protein['true_msa'] = protein['msa']
+  protein['msa'] = bert_msa
+
+  return protein
+
+
+@curry1
+def make_fixed_size(protein, shape_schema, msa_cluster_size, extra_msa_size,
+                    num_res, num_templates=0):
+  """"""Guess at the MSA and sequence dimensions to make fixed size.""""""
+
+  pad_size_map = {
+      NUM_RES: num_res,
+      NUM_MSA_SEQ: msa_cluster_size,
+      NUM_EXTRA_SEQ: extra_msa_size,
+      NUM_TEMPLATES: num_templates,
+  }
+
+  for k, v in protein.items():
+    # Don't transfer this to the accelerator.
+    if k == 'extra_cluster_assignment':
+      continue
+    shape = v.shape.as_list()
+    schema = shape_schema[k]
+    assert len(shape) == len(schema), (
+        f'Rank mismatch between shape and shape schema for {k}: '
+        f'{shape} vs {schema}')
+    pad_size = [
+        pad_size_map.get(s2, None) or s1 for (s1, s2) in zip(shape, schema)
+    ]
+    padding = [(0, p - tf.shape(v)[i]) for i, p in enumerate(pad_size)]
+    if padding:
+      protein[k] = tf.pad(
+          v, padding, name=f'pad_to_fixed_{k}')
+      protein[k].set_shape(pad_size)
+
+  return protein
+
+
+@curry1
+def make_msa_feat(protein):
+  """"""Create and concatenate MSA features.""""""
+  # Whether there is a domain break. Always zero for chains, but keeping
+  # for compatibility with domain datasets.
+  has_break = tf.clip_by_value(
+      tf.cast(protein['between_segment_residues'], tf.float32),
+      0, 1)
+  aatype_1hot = tf.one_hot(protein['aatype'], 21, axis=-1)
+
+  target_feat = [
+      tf.expand_dims(has_break, axis=-1),
+      aatype_1hot,  # Everyone gets the original sequence.
+  ]
+
+  msa_1hot = tf.one_hot(protein['msa'], 23, axis=-1)
+  has_deletion = tf.clip_by_value(protein['deletion_matrix'], 0., 1.)
+  deletion_value = tf.atan(protein['deletion_matrix'] / 3.) * (2. / np.pi)
+
+  msa_feat = [
+      msa_1hot,
+      tf.expand_dims(has_deletion, axis=-1),
+      tf.expand_dims(deletion_value, axis=-1),
+  ]
+
+  if 'cluster_profile' in protein:
+    deletion_mean_value = (
+        tf.atan(protein['cluster_deletion_mean'] / 3.) * (2. / np.pi))
+    msa_feat.extend([
+        protein['cluster_profile'],
+        tf.expand_dims(deletion_mean_value, axis=-1),
+    ])
+
+  if 'extra_deletion_matrix' in protein:
+    protein['extra_has_deletion'] = tf.clip_by_value(
+        protein['extra_deletion_matrix'], 0., 1.)
+    protein['extra_deletion_value'] = tf.atan(
+        protein['extra_deletion_matrix'] / 3.) * (2. / np.pi)
+
+  protein['msa_feat'] = tf.concat(msa_feat, axis=-1)
+  protein['target_feat'] = tf.concat(target_feat, axis=-1)
+  return protein
+
+
+@curry1
+def select_feat(protein, feature_list):
+  return {k: v for k, v in protein.items() if k in feature_list}
+
+
+@curry1
+def crop_templates(protein, max_templates):
+  for k, v in protein.items():
+    if k.startswith('template_'):
+      protein[k] = v[:max_templates]
+  return protein
+
+
+@curry1
+def random_crop_to_size(protein, crop_size, max_templates, shape_schema,
+                        subsample_templates=False):
+  """"""Crop randomly to `crop_size`, or keep as is if shorter than that.""""""
+  seq_length = protein['seq_length']
+  if 'template_mask' in protein:
+    num_templates = tf.cast(
+        shape_helpers.shape_list(protein['template_mask'])[0], tf.int32)
+  else:
+    num_templates = tf.constant(0, dtype=tf.int32)
+  num_res_crop_size = tf.math.minimum(seq_length, crop_size)
+
+  # Ensures that the cropping of residues and templates happens in the same way
+  # across ensembling iterations.
+  # Do not use for randomness that should vary in ensembling.
+  seed_maker = utils.SeedMaker(initial_seed=protein['random_crop_to_size_seed'])
+
+  if subsample_templates:
+    templates_crop_start = tf.random.stateless_uniform(
+        shape=(), minval=0, maxval=num_templates + 1, dtype=tf.int32,
+        seed=seed_maker())
+  else:
+    templates_crop_start = 0
+
+  num_templates_crop_size = tf.math.minimum(
+      num_templates - templates_crop_start, max_templates)
+
+  num_res_crop_start = tf.random.stateless_uniform(
+      shape=(), minval=0, maxval=seq_length - num_res_crop_size + 1,
+      dtype=tf.int32, seed=seed_maker())
+
+  templates_select_indices = tf.argsort(tf.random.stateless_uniform(
+      [num_templates], seed=seed_maker()))
+
+  for k, v in protein.items():
+    if k not in shape_schema or (
+        'template' not in k and NUM_RES not in shape_schema[k]):
+      continue
+
+    # randomly permute the templates before cropping them.
+    if k.startswith('template') and subsample_templates:
+      v = tf.gather(v, templates_select_indices)
+
+    crop_sizes = []
+    crop_starts = []
+    for i, (dim_size, dim) in enumerate(zip(shape_schema[k],
+                                            shape_helpers.shape_list(v))):
+      is_num_res = (dim_size == NUM_RES)
+      if i == 0 and k.startswith('template'):
+        crop_size = num_templates_crop_size
+        crop_start = templates_crop_start
+      else:
+        crop_start = num_res_crop_start if is_num_res else 0
+        crop_size = (num_res_crop_size if is_num_res else
+                     (-1 if dim is None else dim))
+      crop_sizes.append(crop_size)
+      crop_starts.append(crop_start)
+    protein[k] = tf.slice(v, crop_starts, crop_sizes)
+
+  protein['seq_length'] = num_res_crop_size
+  return protein
+
+
+def make_atom14_masks(protein):
+  """"""Construct denser atom positions (14 dimensions instead of 37).""""""
+  restype_atom14_to_atom37 = []  # mapping (restype, atom14) --> atom37
+  restype_atom37_to_atom14 = []  # mapping (restype, atom37) --> atom14
+  restype_atom14_mask = []
+
+  for rt in residue_constants.restypes:
+    atom_names = residue_constants.restype_name_to_atom14_names[
+        residue_constants.restype_1to3[rt]]
+
+    restype_atom14_to_atom37.append([
+        (residue_constants.atom_order[name] if name else 0)
+        for name in atom_names
+    ])
+
+    atom_name_to_idx14 = {name: i for i, name in enumerate(atom_names)}
+    restype_atom37_to_atom14.append([
+        (atom_name_to_idx14[name] if name in atom_name_to_idx14 else 0)
+        for name in residue_constants.atom_types
+    ])
+
+    restype_atom14_mask.append([(1. if name else 0.) for name in atom_names])
+
+  # Add dummy mapping for restype 'UNK'
+  restype_atom14_to_atom37.append([0] * 14)
+  restype_atom37_to_atom14.append([0] * 37)
+  restype_atom14_mask.append([0.] * 14)
+
+  restype_atom14_to_atom37 = np.array(restype_atom14_to_atom37, dtype=np.int32)
+  restype_atom37_to_atom14 = np.array(restype_atom37_to_atom14, dtype=np.int32)
+  restype_atom14_mask = np.array(restype_atom14_mask, dtype=np.float32)
+
+  # create the mapping for (residx, atom14) --> atom37, i.e. an array
+  # with shape (num_res, 14) containing the atom37 indices for this protein
+  residx_atom14_to_atom37 = tf.gather(restype_atom14_to_atom37,
+                                      protein['aatype'])
+  residx_atom14_mask = tf.gather(restype_atom14_mask,
+                                 protein['aatype'])
+
+  protein['atom14_atom_exists'] = residx_atom14_mask
+  protein['residx_atom14_to_atom37'] = residx_atom14_to_atom37
+
+  # create the gather indices for mapping back
+  residx_atom37_to_atom14 = tf.gather(restype_atom37_to_atom14,
+                                      protein['aatype'])
+  protein['residx_atom37_to_atom14'] = residx_atom37_to_atom14
+
+  # create the corresponding mask
+  restype_atom37_mask = np.zeros([21, 37], dtype=np.float32)
+  for restype, restype_letter in enumerate(residue_constants.restypes):
+    restype_name = residue_constants.restype_1to3[restype_letter]
+    atom_names = residue_constants.residue_atoms[restype_name]
+    for atom_name in atom_names:
+      atom_type = residue_constants.atom_order[atom_name]
+      restype_atom37_mask[restype, atom_type] = 1
+
+  residx_atom37_mask = tf.gather(restype_atom37_mask,
+                                 protein['aatype'])
+  protein['atom37_atom_exists'] = residx_atom37_mask
+
+  return protein
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/model/tf/utils.py",".py","1276","48","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Shared utilities for various components.""""""
+import tensorflow.compat.v1 as tf
+
+
+def tf_combine_mask(*masks):
+  """"""Take the intersection of float-valued masks.""""""
+  ret = 1
+  for m in masks:
+    ret *= m
+  return ret
+
+
+class SeedMaker(object):
+  """"""Return unique seeds.""""""
+
+  def __init__(self, initial_seed=0):
+    self.next_seed = initial_seed
+
+  def __call__(self):
+    i = self.next_seed
+    self.next_seed += 1
+    return i
+
+seed_maker = SeedMaker()
+
+
+def make_random_seed():
+  return tf.random.uniform([2],
+                           tf.int32.min,
+                           tf.int32.max,
+                           tf.int32,
+                           seed=seed_maker())
+
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/relax/relax_test.py",".py","3827","90","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for relax.""""""
+import os
+
+from absl.testing import absltest
+from alphafold.common import protein
+from alphafold.relax import relax
+import numpy as np
+# Internal import (7716).
+
+
+class RunAmberRelaxTest(absltest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.test_dir = os.path.join(
+        absltest.get_default_test_srcdir(),
+        'alphafold/relax/testdata/')
+    self.test_config = {
+        'max_iterations': 1,
+        'tolerance': 2.39,
+        'stiffness': 10.0,
+        'exclude_residues': [],
+        'max_outer_iterations': 1,
+        'use_gpu': False}
+
+  def test_process(self):
+    amber_relax = relax.AmberRelaxation(**self.test_config)
+
+    with open(os.path.join(self.test_dir, 'model_output.pdb')) as f:
+      test_prot = protein.from_pdb_string(f.read())
+    pdb_min, debug_info, num_violations = amber_relax.process(prot=test_prot)
+
+    self.assertCountEqual(debug_info.keys(),
+                          set({'initial_energy', 'final_energy',
+                               'attempts', 'rmsd'}))
+    self.assertLess(debug_info['final_energy'], debug_info['initial_energy'])
+    self.assertGreater(debug_info['rmsd'], 0)
+
+    prot_min = protein.from_pdb_string(pdb_min)
+    # Most protein properties should be unchanged.
+    np.testing.assert_almost_equal(test_prot.aatype, prot_min.aatype)
+    np.testing.assert_almost_equal(test_prot.residue_index,
+                                   prot_min.residue_index)
+    # Atom mask and bfactors identical except for terminal OXT of last residue.
+    np.testing.assert_almost_equal(test_prot.atom_mask[:-1, :],
+                                   prot_min.atom_mask[:-1, :])
+    np.testing.assert_almost_equal(test_prot.b_factors[:-1, :],
+                                   prot_min.b_factors[:-1, :])
+    np.testing.assert_almost_equal(test_prot.atom_mask[:, :-1],
+                                   prot_min.atom_mask[:, :-1])
+    np.testing.assert_almost_equal(test_prot.b_factors[:, :-1],
+                                   prot_min.b_factors[:, :-1])
+    # There are no residues with violations.
+    np.testing.assert_equal(num_violations, np.zeros_like(num_violations))
+
+  def test_unresolved_violations(self):
+    amber_relax = relax.AmberRelaxation(**self.test_config)
+    with open(os.path.join(self.test_dir,
+                                 'with_violations_casp14.pdb')) as f:
+      test_prot = protein.from_pdb_string(f.read())
+    _, _, num_violations = amber_relax.process(prot=test_prot)
+    exp_num_violations = np.array(
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1,
+         1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+         0, 0, 0, 0])
+    # Check no violations were added. Can't check exactly due to stochasticity.
+    self.assertTrue(np.all(np.array(num_violations) <= exp_num_violations))
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/relax/amber_minimize.py",".py","19061","506","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Restrained Amber Minimization of a structure.""""""
+
+import io
+import time
+from typing import Collection, Optional, Sequence
+
+from absl import logging
+from alphafold.common import protein
+from alphafold.common import residue_constants
+from alphafold.model import folding
+from alphafold.relax import cleanup
+from alphafold.relax import utils
+import ml_collections
+import numpy as np
+import jax
+from simtk import openmm
+from simtk import unit
+from simtk.openmm import app as openmm_app
+from simtk.openmm.app.internal.pdbstructure import PdbStructure
+
+
+ENERGY = unit.kilocalories_per_mole
+LENGTH = unit.angstroms
+
+
+def will_restrain(atom: openmm_app.Atom, rset: str) -> bool:
+  """"""Returns True if the atom will be restrained by the given restraint set.""""""
+
+  if rset == ""non_hydrogen"":
+    return atom.element.name != ""hydrogen""
+  elif rset == ""c_alpha"":
+    return atom.name == ""CA""
+
+
+def _add_restraints(
+    system: openmm.System,
+    reference_pdb: openmm_app.PDBFile,
+    stiffness: unit.Unit,
+    rset: str,
+    exclude_residues: Sequence[int]):
+  """"""Adds a harmonic potential that restrains the system to a structure.""""""
+  assert rset in [""non_hydrogen"", ""c_alpha""]
+
+  force = openmm.CustomExternalForce(
+      ""0.5 * k * ((x-x0)^2 + (y-y0)^2 + (z-z0)^2)"")
+  force.addGlobalParameter(""k"", stiffness)
+  for p in [""x0"", ""y0"", ""z0""]:
+    force.addPerParticleParameter(p)
+
+  for i, atom in enumerate(reference_pdb.topology.atoms()):
+    if atom.residue.index in exclude_residues:
+      continue
+    if will_restrain(atom, rset):
+      force.addParticle(i, reference_pdb.positions[i])
+  logging.info(""Restraining %d / %d particles."",
+               force.getNumParticles(), system.getNumParticles())
+  system.addForce(force)
+
+
+def _openmm_minimize(
+    pdb_str: str,
+    max_iterations: int,
+    tolerance: unit.Unit,
+    stiffness: unit.Unit,
+    restraint_set: str,
+    exclude_residues: Sequence[int],
+    use_gpu: bool):
+  """"""Minimize energy via openmm.""""""
+
+  pdb_file = io.StringIO(pdb_str)
+  pdb = openmm_app.PDBFile(pdb_file)
+
+  force_field = openmm_app.ForceField(""amber99sb.xml"")
+  constraints = openmm_app.HBonds
+  system = force_field.createSystem(
+      pdb.topology, constraints=constraints)
+  if stiffness > 0 * ENERGY / (LENGTH**2):
+    _add_restraints(system, pdb, stiffness, restraint_set, exclude_residues)
+
+  integrator = openmm.LangevinIntegrator(0, 0.01, 0.0)
+  platform = openmm.Platform.getPlatformByName(""CUDA"" if use_gpu else ""CPU"")
+  simulation = openmm_app.Simulation(
+      pdb.topology, system, integrator, platform)
+  simulation.context.setPositions(pdb.positions)
+
+  ret = {}
+  state = simulation.context.getState(getEnergy=True, getPositions=True)
+  ret[""einit""] = state.getPotentialEnergy().value_in_unit(ENERGY)
+  ret[""posinit""] = state.getPositions(asNumpy=True).value_in_unit(LENGTH)
+  simulation.minimizeEnergy(maxIterations=max_iterations,
+                            tolerance=tolerance)
+  state = simulation.context.getState(getEnergy=True, getPositions=True)
+  ret[""efinal""] = state.getPotentialEnergy().value_in_unit(ENERGY)
+  ret[""pos""] = state.getPositions(asNumpy=True).value_in_unit(LENGTH)
+  ret[""min_pdb""] = _get_pdb_string(simulation.topology, state.getPositions())
+  return ret
+
+
+def _get_pdb_string(topology: openmm_app.Topology, positions: unit.Quantity):
+  """"""Returns a pdb string provided OpenMM topology and positions.""""""
+  with io.StringIO() as f:
+    openmm_app.PDBFile.writeFile(topology, positions, f)
+    return f.getvalue()
+
+
+def _check_cleaned_atoms(pdb_cleaned_string: str, pdb_ref_string: str):
+  """"""Checks that no atom positions have been altered by cleaning.""""""
+  cleaned = openmm_app.PDBFile(io.StringIO(pdb_cleaned_string))
+  reference = openmm_app.PDBFile(io.StringIO(pdb_ref_string))
+
+  cl_xyz = np.array(cleaned.getPositions().value_in_unit(LENGTH))
+  ref_xyz = np.array(reference.getPositions().value_in_unit(LENGTH))
+
+  for ref_res, cl_res in zip(reference.topology.residues(),
+                             cleaned.topology.residues()):
+    assert ref_res.name == cl_res.name
+    for rat in ref_res.atoms():
+      for cat in cl_res.atoms():
+        if cat.name == rat.name:
+          if not np.array_equal(cl_xyz[cat.index], ref_xyz[rat.index]):
+            raise ValueError(f""Coordinates of cleaned atom {cat} do not match ""
+                             f""coordinates of reference atom {rat}."")
+
+
+def _check_residues_are_well_defined(prot: protein.Protein):
+  """"""Checks that all residues contain non-empty atom sets.""""""
+  if (prot.atom_mask.sum(axis=-1) == 0).any():
+    raise ValueError(""Amber minimization can only be performed on proteins with""
+                     "" well-defined residues. This protein contains at least""
+                     "" one residue with no atoms."")
+
+
+def _check_atom_mask_is_ideal(prot):
+  """"""Sanity-check the atom mask is ideal, up to a possible OXT.""""""
+  atom_mask = prot.atom_mask
+  ideal_atom_mask = protein.ideal_atom_mask(prot)
+  utils.assert_equal_nonterminal_atom_types(atom_mask, ideal_atom_mask)
+
+
+def clean_protein(
+    prot: protein.Protein,
+    checks: bool = True):
+  """"""Adds missing atoms to Protein instance.
+
+  Args:
+    prot: A `protein.Protein` instance.
+    checks: A `bool` specifying whether to add additional checks to the cleaning
+      process.
+
+  Returns:
+    pdb_string: A string of the cleaned protein.
+  """"""
+  _check_atom_mask_is_ideal(prot)
+
+  # Clean pdb.
+  prot_pdb_string = protein.to_pdb(prot)
+  pdb_file = io.StringIO(prot_pdb_string)
+  alterations_info = {}
+  fixed_pdb = cleanup.fix_pdb(pdb_file, alterations_info)
+  fixed_pdb_file = io.StringIO(fixed_pdb)
+  pdb_structure = PdbStructure(fixed_pdb_file)
+  cleanup.clean_structure(pdb_structure, alterations_info)
+
+  logging.info(""alterations info: %s"", alterations_info)
+
+  # Write pdb file of cleaned structure.
+  as_file = openmm_app.PDBFile(pdb_structure)
+  pdb_string = _get_pdb_string(as_file.getTopology(), as_file.getPositions())
+  if checks:
+    _check_cleaned_atoms(pdb_string, prot_pdb_string)
+  return pdb_string
+
+
+def make_atom14_positions(prot):
+  """"""Constructs denser atom positions (14 dimensions instead of 37).""""""
+  restype_atom14_to_atom37 = []  # mapping (restype, atom14) --> atom37
+  restype_atom37_to_atom14 = []  # mapping (restype, atom37) --> atom14
+  restype_atom14_mask = []
+
+  for rt in residue_constants.restypes:
+    atom_names = residue_constants.restype_name_to_atom14_names[
+        residue_constants.restype_1to3[rt]]
+
+    restype_atom14_to_atom37.append([
+        (residue_constants.atom_order[name] if name else 0)
+        for name in atom_names
+    ])
+
+    atom_name_to_idx14 = {name: i for i, name in enumerate(atom_names)}
+    restype_atom37_to_atom14.append([
+        (atom_name_to_idx14[name] if name in atom_name_to_idx14 else 0)
+        for name in residue_constants.atom_types
+    ])
+
+    restype_atom14_mask.append([(1. if name else 0.) for name in atom_names])
+
+  # Add dummy mapping for restype 'UNK'.
+  restype_atom14_to_atom37.append([0] * 14)
+  restype_atom37_to_atom14.append([0] * 37)
+  restype_atom14_mask.append([0.] * 14)
+
+  restype_atom14_to_atom37 = np.array(restype_atom14_to_atom37, dtype=np.int32)
+  restype_atom37_to_atom14 = np.array(restype_atom37_to_atom14, dtype=np.int32)
+  restype_atom14_mask = np.array(restype_atom14_mask, dtype=np.float32)
+
+  # Create the mapping for (residx, atom14) --> atom37, i.e. an array
+  # with shape (num_res, 14) containing the atom37 indices for this protein.
+  residx_atom14_to_atom37 = restype_atom14_to_atom37[prot[""aatype""]]
+  residx_atom14_mask = restype_atom14_mask[prot[""aatype""]]
+
+  # Create a mask for known ground truth positions.
+  residx_atom14_gt_mask = residx_atom14_mask * np.take_along_axis(
+      prot[""all_atom_mask""], residx_atom14_to_atom37, axis=1).astype(np.float32)
+
+  # Gather the ground truth positions.
+  residx_atom14_gt_positions = residx_atom14_gt_mask[:, :, None] * (
+      np.take_along_axis(prot[""all_atom_positions""],
+                         residx_atom14_to_atom37[..., None],
+                         axis=1))
+
+  prot[""atom14_atom_exists""] = residx_atom14_mask
+  prot[""atom14_gt_exists""] = residx_atom14_gt_mask
+  prot[""atom14_gt_positions""] = residx_atom14_gt_positions
+
+  prot[""residx_atom14_to_atom37""] = residx_atom14_to_atom37
+
+  # Create the gather indices for mapping back.
+  residx_atom37_to_atom14 = restype_atom37_to_atom14[prot[""aatype""]]
+  prot[""residx_atom37_to_atom14""] = residx_atom37_to_atom14
+
+  # Create the corresponding mask.
+  restype_atom37_mask = np.zeros([21, 37], dtype=np.float32)
+  for restype, restype_letter in enumerate(residue_constants.restypes):
+    restype_name = residue_constants.restype_1to3[restype_letter]
+    atom_names = residue_constants.residue_atoms[restype_name]
+    for atom_name in atom_names:
+      atom_type = residue_constants.atom_order[atom_name]
+      restype_atom37_mask[restype, atom_type] = 1
+
+  residx_atom37_mask = restype_atom37_mask[prot[""aatype""]]
+  prot[""atom37_atom_exists""] = residx_atom37_mask
+
+  # As the atom naming is ambiguous for 7 of the 20 amino acids, provide
+  # alternative ground truth coordinates where the naming is swapped
+  restype_3 = [
+      residue_constants.restype_1to3[res] for res in residue_constants.restypes
+  ]
+  restype_3 += [""UNK""]
+
+  # Matrices for renaming ambiguous atoms.
+  all_matrices = {res: np.eye(14, dtype=np.float32) for res in restype_3}
+  for resname, swap in residue_constants.residue_atom_renaming_swaps.items():
+    correspondences = np.arange(14)
+    for source_atom_swap, target_atom_swap in swap.items():
+      source_index = residue_constants.restype_name_to_atom14_names[
+          resname].index(source_atom_swap)
+      target_index = residue_constants.restype_name_to_atom14_names[
+          resname].index(target_atom_swap)
+      correspondences[source_index] = target_index
+      correspondences[target_index] = source_index
+      renaming_matrix = np.zeros((14, 14), dtype=np.float32)
+      for index, correspondence in enumerate(correspondences):
+        renaming_matrix[index, correspondence] = 1.
+    all_matrices[resname] = renaming_matrix.astype(np.float32)
+  renaming_matrices = np.stack([all_matrices[restype] for restype in restype_3])
+
+  # Pick the transformation matrices for the given residue sequence
+  # shape (num_res, 14, 14).
+  renaming_transform = renaming_matrices[prot[""aatype""]]
+
+  # Apply it to the ground truth positions. shape (num_res, 14, 3).
+  alternative_gt_positions = np.einsum(""rac,rab->rbc"",
+                                       residx_atom14_gt_positions,
+                                       renaming_transform)
+  prot[""atom14_alt_gt_positions""] = alternative_gt_positions
+
+  # Create the mask for the alternative ground truth (differs from the
+  # ground truth mask, if only one of the atoms in an ambiguous pair has a
+  # ground truth position).
+  alternative_gt_mask = np.einsum(""ra,rab->rb"",
+                                  residx_atom14_gt_mask,
+                                  renaming_transform)
+
+  prot[""atom14_alt_gt_exists""] = alternative_gt_mask
+
+  # Create an ambiguous atoms mask.  shape: (21, 14).
+  restype_atom14_is_ambiguous = np.zeros((21, 14), dtype=np.float32)
+  for resname, swap in residue_constants.residue_atom_renaming_swaps.items():
+    for atom_name1, atom_name2 in swap.items():
+      restype = residue_constants.restype_order[
+          residue_constants.restype_3to1[resname]]
+      atom_idx1 = residue_constants.restype_name_to_atom14_names[resname].index(
+          atom_name1)
+      atom_idx2 = residue_constants.restype_name_to_atom14_names[resname].index(
+          atom_name2)
+      restype_atom14_is_ambiguous[restype, atom_idx1] = 1
+      restype_atom14_is_ambiguous[restype, atom_idx2] = 1
+
+  # From this create an ambiguous_mask for the given sequence.
+  prot[""atom14_atom_is_ambiguous""] = (
+      restype_atom14_is_ambiguous[prot[""aatype""]])
+
+  return prot
+
+
+def find_violations(prot_np: protein.Protein):
+  """"""Analyzes a protein and returns structural violation information.
+
+  Args:
+    prot_np: A protein.
+
+  Returns:
+    violations: A `dict` of structure components with structural violations.
+    violation_metrics: A `dict` of violation metrics.
+  """"""
+  batch = {
+      ""aatype"": prot_np.aatype,
+      ""all_atom_positions"": prot_np.atom_positions.astype(np.float32),
+      ""all_atom_mask"": prot_np.atom_mask.astype(np.float32),
+      ""residue_index"": prot_np.residue_index,
+  }
+
+  batch[""seq_mask""] = np.ones_like(batch[""aatype""], np.float32)
+  batch = make_atom14_positions(batch)
+
+  violations = folding.find_structural_violations(
+      batch=batch,
+      atom14_pred_positions=batch[""atom14_gt_positions""],
+      config=ml_collections.ConfigDict(
+          {""violation_tolerance_factor"": 12,  # Taken from model config.
+           ""clash_overlap_tolerance"": 1.5,  # Taken from model config.
+          }))
+  violation_metrics = folding.compute_violation_metrics(
+      batch=batch,
+      atom14_pred_positions=batch[""atom14_gt_positions""],
+      violations=violations,
+  )
+
+  return violations, violation_metrics
+
+
+def get_violation_metrics(prot: protein.Protein):
+  """"""Computes violation and alignment metrics.""""""
+  structural_violations, struct_metrics = find_violations(prot)
+  violation_idx = np.flatnonzero(
+      structural_violations[""total_per_residue_violations_mask""])
+
+  struct_metrics[""residue_violations""] = violation_idx
+  struct_metrics[""num_residue_violations""] = len(violation_idx)
+  struct_metrics[""structural_violations""] = structural_violations
+  return struct_metrics
+
+
+def _run_one_iteration(
+    *,
+    pdb_string: str,
+    max_iterations: int,
+    tolerance: float,
+    stiffness: float,
+    restraint_set: str,
+    max_attempts: int,
+    use_gpu: bool,
+    exclude_residues: Optional[Collection[int]] = None):
+  """"""Runs the minimization pipeline.
+
+  Args:
+    pdb_string: A pdb string.
+    max_iterations: An `int` specifying the maximum number of L-BFGS iterations.
+    A value of 0 specifies no limit.
+    tolerance: kcal/mol, the energy tolerance of L-BFGS.
+    stiffness: kcal/mol A**2, spring constant of heavy atom restraining
+      potential.
+    restraint_set: The set of atoms to restrain.
+    max_attempts: The maximum number of minimization attempts.
+    use_gpu: Whether to run on GPU.
+    exclude_residues: An optional list of zero-indexed residues to exclude from
+        restraints.
+
+  Returns:
+    A `dict` of minimization info.
+  """"""
+  exclude_residues = exclude_residues or []
+
+  # Assign physical dimensions.
+  tolerance = tolerance * ENERGY
+  stiffness = stiffness * ENERGY / (LENGTH**2)
+
+  start = time.time()
+  minimized = False
+  attempts = 0
+  while not minimized and attempts < max_attempts:
+    attempts += 1
+    try:
+      logging.info(""Minimizing protein, attempt %d of %d."",
+                   attempts, max_attempts)
+      ret = _openmm_minimize(
+          pdb_string, max_iterations=max_iterations,
+          tolerance=tolerance, stiffness=stiffness,
+          restraint_set=restraint_set,
+          exclude_residues=exclude_residues,
+          use_gpu=use_gpu)
+      minimized = True
+    except Exception as e:  # pylint: disable=broad-except
+      logging.info(e)
+  if not minimized:
+    raise ValueError(f""Minimization failed after {max_attempts} attempts."")
+  ret[""opt_time""] = time.time() - start
+  ret[""min_attempts""] = attempts
+  return ret
+
+
+def run_pipeline(
+    prot: protein.Protein,
+    stiffness: float,
+    use_gpu: bool,
+    max_outer_iterations: int = 1,
+    place_hydrogens_every_iteration: bool = True,
+    max_iterations: int = 0,
+    tolerance: float = 2.39,
+    restraint_set: str = ""non_hydrogen"",
+    max_attempts: int = 100,
+    checks: bool = True,
+    exclude_residues: Optional[Sequence[int]] = None):
+  """"""Run iterative amber relax.
+
+  Successive relax iterations are performed until all violations have been
+  resolved. Each iteration involves a restrained Amber minimization, with
+  restraint exclusions determined by violation-participating residues.
+
+  Args:
+    prot: A protein to be relaxed.
+    stiffness: kcal/mol A**2, the restraint stiffness.
+    use_gpu: Whether to run on GPU.
+    max_outer_iterations: The maximum number of iterative minimization.
+    place_hydrogens_every_iteration: Whether hydrogens are re-initialized
+        prior to every minimization.
+    max_iterations: An `int` specifying the maximum number of L-BFGS steps
+        per relax iteration. A value of 0 specifies no limit.
+    tolerance: kcal/mol, the energy tolerance of L-BFGS.
+        The default value is the OpenMM default.
+    restraint_set: The set of atoms to restrain.
+    max_attempts: The maximum number of minimization attempts per iteration.
+    checks: Whether to perform cleaning checks.
+    exclude_residues: An optional list of zero-indexed residues to exclude from
+        restraints.
+
+  Returns:
+    out: A dictionary of output values.
+  """"""
+
+  # `protein.to_pdb` will strip any poorly-defined residues so we need to
+  # perform this check before `clean_protein`.
+  _check_residues_are_well_defined(prot)
+  pdb_string = clean_protein(prot, checks=checks)
+
+  exclude_residues = exclude_residues or []
+  exclude_residues = set(exclude_residues)
+  violations = np.inf
+  iteration = 0
+
+  while violations > 0 and iteration < max_outer_iterations:
+    ret = _run_one_iteration(
+        pdb_string=pdb_string,
+        exclude_residues=exclude_residues,
+        max_iterations=max_iterations,
+        tolerance=tolerance,
+        stiffness=stiffness,
+        restraint_set=restraint_set,
+        max_attempts=max_attempts,
+        use_gpu=use_gpu)
+    prot = protein.from_pdb_string(ret[""min_pdb""])
+    if place_hydrogens_every_iteration:
+      pdb_string = clean_protein(prot, checks=True)
+    else:
+      pdb_string = ret[""min_pdb""]
+    # Calculation of violations can cause CUDA errors for some JAX versions.
+    with jax.default_device(jax.devices(""cpu"")[0]):
+      ret.update(get_violation_metrics(prot))
+    ret.update({
+        ""num_exclusions"": len(exclude_residues),
+        ""iteration"": iteration,
+    })
+    violations = ret[""violations_per_residue""]
+    exclude_residues = exclude_residues.union(ret[""residue_violations""])
+
+    logging.info(""Iteration completed: Einit %.2f Efinal %.2f Time %.2f s ""
+                 ""num residue violations %d num residue exclusions %d "",
+                 ret[""einit""], ret[""efinal""], ret[""opt_time""],
+                 ret[""num_residue_violations""], ret[""num_exclusions""])
+    iteration += 1
+  return ret
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/relax/cleanup.py",".py","4832","128","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Cleans up a PDB file using pdbfixer in preparation for OpenMM simulations.
+
+fix_pdb uses a third-party tool. We also support fixing some additional edge
+cases like removing chains of length one (see clean_structure).
+""""""
+import io
+
+import pdbfixer
+from simtk.openmm import app
+from simtk.openmm.app import element
+
+
+def fix_pdb(pdbfile, alterations_info):
+  """"""Apply pdbfixer to the contents of a PDB file; return a PDB string result.
+
+  1) Replaces nonstandard residues.
+  2) Removes heterogens (non protein residues) including water.
+  3) Adds missing residues and missing atoms within existing residues.
+  4) Adds hydrogens assuming pH=7.0.
+  5) KeepIds is currently true, so the fixer must keep the existing chain and
+     residue identifiers. This will fail for some files in wider PDB that have
+     invalid IDs.
+
+  Args:
+    pdbfile: Input PDB file handle.
+    alterations_info: A dict that will store details of changes made.
+
+  Returns:
+    A PDB string representing the fixed structure.
+  """"""
+  fixer = pdbfixer.PDBFixer(pdbfile=pdbfile)
+  fixer.findNonstandardResidues()
+  alterations_info['nonstandard_residues'] = fixer.nonstandardResidues
+  fixer.replaceNonstandardResidues()
+  _remove_heterogens(fixer, alterations_info, keep_water=False)
+  fixer.findMissingResidues()
+  alterations_info['missing_residues'] = fixer.missingResidues
+  fixer.findMissingAtoms()
+  alterations_info['missing_heavy_atoms'] = fixer.missingAtoms
+  alterations_info['missing_terminals'] = fixer.missingTerminals
+  fixer.addMissingAtoms(seed=0)
+  fixer.addMissingHydrogens()
+  out_handle = io.StringIO()
+  app.PDBFile.writeFile(fixer.topology, fixer.positions, out_handle,
+                        keepIds=True)
+  return out_handle.getvalue()
+
+
+def clean_structure(pdb_structure, alterations_info):
+  """"""Applies additional fixes to an OpenMM structure, to handle edge cases.
+
+  Args:
+    pdb_structure: An OpenMM structure to modify and fix.
+    alterations_info: A dict that will store details of changes made.
+  """"""
+  _replace_met_se(pdb_structure, alterations_info)
+  _remove_chains_of_length_one(pdb_structure, alterations_info)
+
+
+def _remove_heterogens(fixer, alterations_info, keep_water):
+  """"""Removes the residues that Pdbfixer considers to be heterogens.
+
+  Args:
+    fixer: A Pdbfixer instance.
+    alterations_info: A dict that will store details of changes made.
+    keep_water: If True, water (HOH) is not considered to be a heterogen.
+  """"""
+  initial_resnames = set()
+  for chain in fixer.topology.chains():
+    for residue in chain.residues():
+      initial_resnames.add(residue.name)
+  fixer.removeHeterogens(keepWater=keep_water)
+  final_resnames = set()
+  for chain in fixer.topology.chains():
+    for residue in chain.residues():
+      final_resnames.add(residue.name)
+  alterations_info['removed_heterogens'] = (
+      initial_resnames.difference(final_resnames))
+
+
+def _replace_met_se(pdb_structure, alterations_info):
+  """"""Replace the Se in any MET residues that were not marked as modified.""""""
+  modified_met_residues = []
+  for res in pdb_structure.iter_residues():
+    name = res.get_name_with_spaces().strip()
+    if name == 'MET':
+      s_atom = res.get_atom('SD')
+      if s_atom.element_symbol == 'Se':
+        s_atom.element_symbol = 'S'
+        s_atom.element = element.get_by_symbol('S')
+        modified_met_residues.append(s_atom.residue_number)
+  alterations_info['Se_in_MET'] = modified_met_residues
+
+
+def _remove_chains_of_length_one(pdb_structure, alterations_info):
+  """"""Removes chains that correspond to a single amino acid.
+
+  A single amino acid in a chain is both N and C terminus. There is no force
+  template for this case.
+
+  Args:
+    pdb_structure: An OpenMM pdb_structure to modify and fix.
+    alterations_info: A dict that will store details of changes made.
+  """"""
+  removed_chains = {}
+  for model in pdb_structure.iter_models():
+    valid_chains = [c for c in model.iter_chains() if len(c) > 1]
+    invalid_chain_ids = [c.chain_id for c in model.iter_chains() if len(c) <= 1]
+    model.chains = valid_chains
+    for chain_id in invalid_chain_ids:
+      model.chains_by_id.pop(chain_id)
+    removed_chains[model.number] = invalid_chain_ids
+  alterations_info['removed_chains'] = removed_chains
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/relax/utils_test.py",".py","1996","56","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for utils.""""""
+
+import os
+
+from absl.testing import absltest
+from alphafold.common import protein
+from alphafold.relax import utils
+import numpy as np
+# Internal import (7716).
+
+
+class UtilsTest(absltest.TestCase):
+
+  def test_overwrite_b_factors(self):
+    testdir = os.path.join(
+        absltest.get_default_test_srcdir(),
+        'alphafold/relax/testdata/'
+        'multiple_disulfides_target.pdb')
+    with open(testdir) as f:
+      test_pdb = f.read()
+    n_residues = 191
+    bfactors = np.stack([np.arange(0, n_residues)] * 37, axis=-1)
+
+    output_pdb = utils.overwrite_b_factors(test_pdb, bfactors)
+
+    # Check that the atom lines are unchanged apart from the B-factors.
+    atom_lines_original = [l for l in test_pdb.split('\n') if l[:4] == ('ATOM')]
+    atom_lines_new = [l for l in output_pdb.split('\n') if l[:4] == ('ATOM')]
+    for line_original, line_new in zip(atom_lines_original, atom_lines_new):
+      self.assertEqual(line_original[:60].strip(), line_new[:60].strip())
+      self.assertEqual(line_original[66:].strip(), line_new[66:].strip())
+
+    # Check B-factors are correctly set for all atoms present.
+    as_protein = protein.from_pdb_string(output_pdb)
+    np.testing.assert_almost_equal(
+        np.where(as_protein.atom_mask > 0, as_protein.b_factors, 0),
+        np.where(as_protein.atom_mask > 0, bfactors, 0))
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/relax/__init__.py",".py","618","15","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Amber relaxation.""""""
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/relax/cleanup_test.py",".py","6170","138","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for relax.cleanup.""""""
+import io
+
+from absl.testing import absltest
+from alphafold.relax import cleanup
+from simtk.openmm.app.internal import pdbstructure
+
+
+def _pdb_to_structure(pdb_str):
+  handle = io.StringIO(pdb_str)
+  return pdbstructure.PdbStructure(handle)
+
+
+def _lines_to_structure(pdb_lines):
+  return _pdb_to_structure('\n'.join(pdb_lines))
+
+
+class CleanupTest(absltest.TestCase):
+
+  def test_missing_residues(self):
+    pdb_lines = ['SEQRES   1 C    3  CYS GLY LEU',
+                 'ATOM      1  N   CYS C   1     -12.262  20.115  60.959  1.00 '
+                 '19.08           N',
+                 'ATOM      2  CA  CYS C   1     -11.065  20.934  60.773  1.00 '
+                 '17.23           C',
+                 'ATOM      3  C   CYS C   1     -10.002  20.742  61.844  1.00 '
+                 '15.38           C',
+                 'ATOM      4  O   CYS C   1     -10.284  20.225  62.929  1.00 '
+                 '16.04           O',
+                 'ATOM      5  N   LEU C   3      -7.688  18.700  62.045  1.00 '
+                 '14.75           N',
+                 'ATOM      6  CA  LEU C   3      -7.256  17.320  62.234  1.00 '
+                 '16.81           C',
+                 'ATOM      7  C   LEU C   3      -6.380  16.864  61.070  1.00 '
+                 '16.95           C',
+                 'ATOM      8  O   LEU C   3      -6.551  17.332  59.947  1.00 '
+                 '16.97           O']
+    input_handle = io.StringIO('\n'.join(pdb_lines))
+    alterations = {}
+    result = cleanup.fix_pdb(input_handle, alterations)
+    structure = _pdb_to_structure(result)
+    residue_names = [r.get_name() for r in structure.iter_residues()]
+    self.assertCountEqual(residue_names, ['CYS', 'GLY', 'LEU'])
+    self.assertCountEqual(alterations['missing_residues'].values(), [['GLY']])
+
+  def test_missing_atoms(self):
+    pdb_lines = ['SEQRES   1 A    1  PRO',
+                 'ATOM      1  CA  PRO A   1       1.000   1.000   1.000  1.00 '
+                 ' 0.00           C']
+    input_handle = io.StringIO('\n'.join(pdb_lines))
+    alterations = {}
+    result = cleanup.fix_pdb(input_handle, alterations)
+    structure = _pdb_to_structure(result)
+    atom_names = [a.get_name() for a in structure.iter_atoms()]
+    self.assertCountEqual(atom_names, ['N', 'CD', 'HD2', 'HD3', 'CG', 'HG2',
+                                       'HG3', 'CB', 'HB2', 'HB3', 'CA', 'HA',
+                                       'C', 'O', 'H2', 'H3', 'OXT'])
+    missing_atoms_by_residue = list(alterations['missing_heavy_atoms'].values())
+    self.assertLen(missing_atoms_by_residue, 1)
+    atoms_added = [a.name for a in missing_atoms_by_residue[0]]
+    self.assertCountEqual(atoms_added, ['N', 'CD', 'CG', 'CB', 'C', 'O'])
+    missing_terminals_by_residue = alterations['missing_terminals']
+    self.assertLen(missing_terminals_by_residue, 1)
+    has_missing_terminal = [r.name for r in missing_terminals_by_residue.keys()]
+    self.assertCountEqual(has_missing_terminal, ['PRO'])
+    self.assertCountEqual([t for t in missing_terminals_by_residue.values()],
+                          [['OXT']])
+
+  def test_remove_heterogens(self):
+    pdb_lines = ['SEQRES   1 A    1  GLY',
+                 'ATOM      1  CA  GLY A   1       0.000   0.000   0.000  1.00 '
+                 ' 0.00           C',
+                 'ATOM      2   O  HOH A   2       0.000   0.000   0.000  1.00 '
+                 ' 0.00           O']
+    input_handle = io.StringIO('\n'.join(pdb_lines))
+    alterations = {}
+    result = cleanup.fix_pdb(input_handle, alterations)
+    structure = _pdb_to_structure(result)
+    self.assertCountEqual([res.get_name() for res in structure.iter_residues()],
+                          ['GLY'])
+    self.assertEqual(alterations['removed_heterogens'], set(['HOH']))
+
+  def test_fix_nonstandard_residues(self):
+    pdb_lines = ['SEQRES   1 A    1  DAL',
+                 'ATOM      1  CA  DAL A   1       0.000   0.000   0.000  1.00 '
+                 ' 0.00           C']
+    input_handle = io.StringIO('\n'.join(pdb_lines))
+    alterations = {}
+    result = cleanup.fix_pdb(input_handle, alterations)
+    structure = _pdb_to_structure(result)
+    residue_names = [res.get_name() for res in structure.iter_residues()]
+    self.assertCountEqual(residue_names, ['ALA'])
+    self.assertLen(alterations['nonstandard_residues'], 1)
+    original_res, new_name = alterations['nonstandard_residues'][0]
+    self.assertEqual(original_res.id, '1')
+    self.assertEqual(new_name, 'ALA')
+
+  def test_replace_met_se(self):
+    pdb_lines = ['SEQRES   1 A    1  MET',
+                 'ATOM      1  SD  MET A   1       0.000   0.000   0.000  1.00 '
+                 ' 0.00          Se']
+    structure = _lines_to_structure(pdb_lines)
+    alterations = {}
+    cleanup._replace_met_se(structure, alterations)
+    sd = [a for a in structure.iter_atoms() if a.get_name() == 'SD']
+    self.assertLen(sd, 1)
+    self.assertEqual(sd[0].element_symbol, 'S')
+    self.assertCountEqual(alterations['Se_in_MET'], [sd[0].residue_number])
+
+  def test_remove_chains_of_length_one(self):
+    pdb_lines = ['SEQRES   1 A    1  GLY',
+                 'ATOM      1  CA  GLY A   1       0.000   0.000   0.000  1.00 '
+                 ' 0.00           C']
+    structure = _lines_to_structure(pdb_lines)
+    alterations = {}
+    cleanup._remove_chains_of_length_one(structure, alterations)
+    chains = list(structure.iter_chains())
+    self.assertEmpty(chains)
+    self.assertCountEqual(alterations['removed_chains'].values(), [['A']])
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/relax/utils.py",".py","2501","70","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Utils for minimization.""""""
+import io
+from alphafold.common import residue_constants
+from Bio import PDB
+import numpy as np
+
+
+def overwrite_b_factors(pdb_str: str, bfactors: np.ndarray) -> str:
+  """"""Overwrites the B-factors in pdb_str with contents of bfactors array.
+
+  Args:
+    pdb_str: An input PDB string.
+    bfactors: A numpy array with shape [1, n_residues, 37]. We assume that the
+      B-factors are per residue; i.e. that the nonzero entries are identical in
+      [0, i, :].
+
+  Returns:
+    A new PDB string with the B-factors replaced.
+  """"""
+  if bfactors.shape[-1] != residue_constants.atom_type_num:
+    raise ValueError(
+        f'Invalid final dimension size for bfactors: {bfactors.shape[-1]}.')
+
+  parser = PDB.PDBParser(QUIET=True)
+  handle = io.StringIO(pdb_str)
+  structure = parser.get_structure('', handle)
+
+  curr_resid = ('', '', '')
+  idx = -1
+  for atom in structure.get_atoms():
+    atom_resid = atom.parent.get_id()
+    if atom_resid != curr_resid:
+      idx += 1
+      if idx >= bfactors.shape[0]:
+        raise ValueError('Index into bfactors exceeds number of residues. '
+                         'B-factors shape: {shape}, idx: {idx}.')
+    curr_resid = atom_resid
+    atom.bfactor = bfactors[idx, residue_constants.atom_order['CA']]
+
+  new_pdb = io.StringIO()
+  pdb_io = PDB.PDBIO()
+  pdb_io.set_structure(structure)
+  pdb_io.save(new_pdb)
+  return new_pdb.getvalue()
+
+
+def assert_equal_nonterminal_atom_types(
+    atom_mask: np.ndarray, ref_atom_mask: np.ndarray):
+  """"""Checks that pre- and post-minimized proteins have same atom set.""""""
+  # Ignore any terminal OXT atoms which may have been added by minimization.
+  oxt = residue_constants.atom_order['OXT']
+  no_oxt_mask = np.ones(shape=atom_mask.shape, dtype=bool)
+  no_oxt_mask[..., oxt] = False
+  np.testing.assert_almost_equal(ref_atom_mask[no_oxt_mask],
+                                 atom_mask[no_oxt_mask])
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/relax/amber_minimize_test.py",".py","4348","134","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for amber_minimize.""""""
+import os
+
+from absl.testing import absltest
+from alphafold.common import protein
+from alphafold.relax import amber_minimize
+import numpy as np
+# Internal import (7716).
+
+_USE_GPU = False
+
+
+def _load_test_protein(data_path):
+  pdb_path = os.path.join(absltest.get_default_test_srcdir(), data_path)
+  with open(pdb_path, 'r') as f:
+    return protein.from_pdb_string(f.read())
+
+
+class AmberMinimizeTest(absltest.TestCase):
+
+  def test_multiple_disulfides_target(self):
+    prot = _load_test_protein(
+        'alphafold/relax/testdata/multiple_disulfides_target.pdb'
+        )
+    ret = amber_minimize.run_pipeline(prot, max_iterations=10, max_attempts=1,
+                                      stiffness=10., use_gpu=_USE_GPU)
+    self.assertIn('opt_time', ret)
+    self.assertIn('min_attempts', ret)
+
+  def test_raises_invalid_protein_assertion(self):
+    prot = _load_test_protein(
+        'alphafold/relax/testdata/multiple_disulfides_target.pdb'
+        )
+    prot.atom_mask[4, :] = 0
+    with self.assertRaisesRegex(
+        ValueError,
+        'Amber minimization can only be performed on proteins with well-defined'
+        ' residues. This protein contains at least one residue with no atoms.'):
+      amber_minimize.run_pipeline(prot, max_iterations=10,
+                                  stiffness=1.,
+                                  max_attempts=1,
+                                  use_gpu=_USE_GPU)
+
+  def test_iterative_relax(self):
+    prot = _load_test_protein(
+        'alphafold/relax/testdata/with_violations.pdb'
+        )
+    violations = amber_minimize.get_violation_metrics(prot)
+    self.assertGreater(violations['num_residue_violations'], 0)
+    out = amber_minimize.run_pipeline(
+        prot=prot, max_outer_iterations=10, stiffness=10., use_gpu=_USE_GPU)
+    self.assertLess(out['efinal'], out['einit'])
+    self.assertEqual(0, out['num_residue_violations'])
+
+  def test_find_violations(self):
+    prot = _load_test_protein(
+        'alphafold/relax/testdata/multiple_disulfides_target.pdb'
+        )
+    viols, _ = amber_minimize.find_violations(prot)
+
+    expected_between_residues_connection_mask = np.zeros((191,), np.float32)
+    for residue in (42, 43, 59, 60, 135, 136):
+      expected_between_residues_connection_mask[residue] = 1.0
+
+    expected_clash_indices = np.array([
+        [8, 4],
+        [8, 5],
+        [13, 3],
+        [14, 1],
+        [14, 4],
+        [26, 4],
+        [26, 5],
+        [31, 8],
+        [31, 10],
+        [39, 0],
+        [39, 1],
+        [39, 2],
+        [39, 3],
+        [39, 4],
+        [42, 5],
+        [42, 6],
+        [42, 7],
+        [42, 8],
+        [47, 7],
+        [47, 8],
+        [47, 9],
+        [47, 10],
+        [64, 4],
+        [85, 5],
+        [102, 4],
+        [102, 5],
+        [109, 13],
+        [111, 5],
+        [118, 6],
+        [118, 7],
+        [118, 8],
+        [124, 4],
+        [124, 5],
+        [131, 5],
+        [139, 7],
+        [147, 4],
+        [152, 7]], dtype=np.int32)
+    expected_between_residues_clash_mask = np.zeros([191, 14])
+    expected_between_residues_clash_mask[expected_clash_indices[:, 0],
+                                         expected_clash_indices[:, 1]] += 1
+    expected_per_atom_violations = np.zeros([191, 14])
+    np.testing.assert_array_equal(
+        viols['between_residues']['connections_per_residue_violation_mask'],
+        expected_between_residues_connection_mask)
+    np.testing.assert_array_equal(
+        viols['between_residues']['clashes_per_atom_clash_mask'],
+        expected_between_residues_clash_mask)
+    np.testing.assert_array_equal(
+        viols['within_residues']['per_atom_violations'],
+        expected_per_atom_violations)
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/relax/relax.py",".py","3288","85","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Amber relaxation.""""""
+from typing import Any, Dict, Sequence, Tuple
+from alphafold.common import protein
+from alphafold.relax import amber_minimize
+from alphafold.relax import utils
+import numpy as np
+
+
+class AmberRelaxation(object):
+  """"""Amber relaxation.""""""
+
+  def __init__(self,
+               *,
+               max_iterations: int,
+               tolerance: float,
+               stiffness: float,
+               exclude_residues: Sequence[int],
+               max_outer_iterations: int,
+               use_gpu: bool):
+    """"""Initialize Amber Relaxer.
+
+    Args:
+      max_iterations: Maximum number of L-BFGS iterations. 0 means no max.
+      tolerance: kcal/mol, the energy tolerance of L-BFGS.
+      stiffness: kcal/mol A**2, spring constant of heavy atom restraining
+        potential.
+      exclude_residues: Residues to exclude from per-atom restraining.
+        Zero-indexed.
+      max_outer_iterations: Maximum number of violation-informed relax
+       iterations. A value of 1 will run the non-iterative procedure used in
+       CASP14. Use 20 so that >95% of the bad cases are relaxed. Relax finishes
+       as soon as there are no violations, hence in most cases this causes no
+       slowdown. In the worst case we do 20 outer iterations.
+      use_gpu: Whether to run on GPU.
+    """"""
+
+    self._max_iterations = max_iterations
+    self._tolerance = tolerance
+    self._stiffness = stiffness
+    self._exclude_residues = exclude_residues
+    self._max_outer_iterations = max_outer_iterations
+    self._use_gpu = use_gpu
+
+  def process(self, *,
+              prot: protein.Protein
+              ) -> Tuple[str, Dict[str, Any], Sequence[float]]:
+    """"""Runs Amber relax on a prediction, adds hydrogens, returns PDB string.""""""
+    out = amber_minimize.run_pipeline(
+        prot=prot, max_iterations=self._max_iterations,
+        tolerance=self._tolerance, stiffness=self._stiffness,
+        exclude_residues=self._exclude_residues,
+        max_outer_iterations=self._max_outer_iterations,
+        use_gpu=self._use_gpu)
+    min_pos = out['pos']
+    start_pos = out['posinit']
+    rmsd = np.sqrt(np.sum((start_pos - min_pos)**2) / start_pos.shape[0])
+    debug_data = {
+        'initial_energy': out['einit'],
+        'final_energy': out['efinal'],
+        'attempts': out['min_attempts'],
+        'rmsd': rmsd
+    }
+    min_pdb = out['min_pdb']
+    min_pdb = utils.overwrite_b_factors(min_pdb, prot.b_factors)
+    utils.assert_equal_nonterminal_atom_types(
+        protein.from_pdb_string(min_pdb).atom_mask,
+        prot.atom_mask)
+    violations = out['structural_violations'][
+        'total_per_residue_violations_mask'].tolist()
+    return min_pdb, debug_data, violations
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/common/residue_constants_test.py",".py","9256","191","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Test that residue_constants generates correct values.""""""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+from alphafold.common import residue_constants
+import numpy as np
+
+
+class ResidueConstantsTest(parameterized.TestCase):
+
+  @parameterized.parameters(
+      ('ALA', 0),
+      ('CYS', 1),
+      ('HIS', 2),
+      ('MET', 3),
+      ('LYS', 4),
+      ('ARG', 4),
+  )
+  def testChiAnglesAtoms(self, residue_name, chi_num):
+    chi_angles_atoms = residue_constants.chi_angles_atoms[residue_name]
+    self.assertLen(chi_angles_atoms, chi_num)
+    for chi_angle_atoms in chi_angles_atoms:
+      self.assertLen(chi_angle_atoms, 4)
+
+  def testChiGroupsForAtom(self):
+    for k, chi_groups in residue_constants.chi_groups_for_atom.items():
+      res_name, atom_name = k
+      for chi_group_i, atom_i in chi_groups:
+        self.assertEqual(
+            atom_name,
+            residue_constants.chi_angles_atoms[res_name][chi_group_i][atom_i])
+
+  @parameterized.parameters(
+      ('ALA', 5), ('ARG', 11), ('ASN', 8), ('ASP', 8), ('CYS', 6), ('GLN', 9),
+      ('GLU', 9), ('GLY', 4), ('HIS', 10), ('ILE', 8), ('LEU', 8), ('LYS', 9),
+      ('MET', 8), ('PHE', 11), ('PRO', 7), ('SER', 6), ('THR', 7), ('TRP', 14),
+      ('TYR', 12), ('VAL', 7)
+  )
+  def testResidueAtoms(self, atom_name, num_residue_atoms):
+    residue_atoms = residue_constants.residue_atoms[atom_name]
+    self.assertLen(residue_atoms, num_residue_atoms)
+
+  def testStandardAtomMask(self):
+    with self.subTest('Check shape'):
+      self.assertEqual(residue_constants.STANDARD_ATOM_MASK.shape, (21, 37,))
+
+    with self.subTest('Check values'):
+      str_to_row = lambda s: [c == '1' for c in s]  # More clear/concise.
+      np.testing.assert_array_equal(
+          residue_constants.STANDARD_ATOM_MASK,
+          np.array([
+              # NB This was defined by c+p but looks sane.
+              str_to_row('11111                                '),  # ALA
+              str_to_row('111111     1           1     11 1    '),  # ARG
+              str_to_row('111111         11                    '),  # ASP
+              str_to_row('111111          11                   '),  # ASN
+              str_to_row('11111     1                          '),  # CYS
+              str_to_row('111111     1             11          '),  # GLU
+              str_to_row('111111     1              11         '),  # GLN
+              str_to_row('111 1                                '),  # GLY
+              str_to_row('111111       11     1    1           '),  # HIS
+              str_to_row('11111 11    1                        '),  # ILE
+              str_to_row('111111      11                       '),  # LEU
+              str_to_row('111111     1       1               1 '),  # LYS
+              str_to_row('111111            11                 '),  # MET
+              str_to_row('111111      11      11          1    '),  # PHE
+              str_to_row('111111     1                         '),  # PRO
+              str_to_row('11111   1                            '),  # SER
+              str_to_row('11111  1 1                           '),  # THR
+              str_to_row('111111      11       11 1   1    11  '),  # TRP
+              str_to_row('111111      11      11         11    '),  # TYR
+              str_to_row('11111 11                             '),  # VAL
+              str_to_row('                                     '),  # UNK
+          ]))
+
+    with self.subTest('Check row totals'):
+      # Check each row has the right number of atoms.
+      for row, restype in enumerate(residue_constants.restypes):  # A, R, ...
+        long_restype = residue_constants.restype_1to3[restype]  # ALA, ARG, ...
+        atoms_names = residue_constants.residue_atoms[
+            long_restype]  # ['C', 'CA', 'CB', 'N', 'O'], ...
+        self.assertLen(atoms_names,
+                       residue_constants.STANDARD_ATOM_MASK[row, :].sum(),
+                       long_restype)
+
+  def testAtomTypes(self):
+    self.assertEqual(residue_constants.atom_type_num, 37)
+
+    self.assertEqual(residue_constants.atom_types[0], 'N')
+    self.assertEqual(residue_constants.atom_types[1], 'CA')
+    self.assertEqual(residue_constants.atom_types[2], 'C')
+    self.assertEqual(residue_constants.atom_types[3], 'CB')
+    self.assertEqual(residue_constants.atom_types[4], 'O')
+
+    self.assertEqual(residue_constants.atom_order['N'], 0)
+    self.assertEqual(residue_constants.atom_order['CA'], 1)
+    self.assertEqual(residue_constants.atom_order['C'], 2)
+    self.assertEqual(residue_constants.atom_order['CB'], 3)
+    self.assertEqual(residue_constants.atom_order['O'], 4)
+    self.assertEqual(residue_constants.atom_type_num, 37)
+
+  def testRestypes(self):
+    three_letter_restypes = [
+        residue_constants.restype_1to3[r] for r  in residue_constants.restypes]
+    for restype, exp_restype in zip(
+        three_letter_restypes, sorted(residue_constants.restype_1to3.values())):
+      self.assertEqual(restype, exp_restype)
+    self.assertEqual(residue_constants.restype_num, 20)
+
+  def testSequenceToOneHotHHBlits(self):
+    one_hot = residue_constants.sequence_to_onehot(
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZ-', residue_constants.HHBLITS_AA_TO_ID)
+    exp_one_hot = np.array(
+        [[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+         [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+         [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]])
+    np.testing.assert_array_equal(one_hot, exp_one_hot)
+
+  def testSequenceToOneHotStandard(self):
+    one_hot = residue_constants.sequence_to_onehot(
+        'ARNDCQEGHILKMFPSTWYV', residue_constants.restype_order)
+    np.testing.assert_array_equal(one_hot, np.eye(20))
+
+  def testSequenceToOneHotUnknownMapping(self):
+    seq = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    expected_out = np.zeros([26, 21])
+    for row, position in enumerate(
+        [0, 20, 4, 3, 6, 13, 7, 8, 9, 20, 11, 10, 12, 2, 20, 14, 5, 1, 15, 16,
+         20, 19, 17, 20, 18, 20]):
+      expected_out[row, position] = 1
+    aa_types = residue_constants.sequence_to_onehot(
+        sequence=seq,
+        mapping=residue_constants.restype_order_with_x,
+        map_unknown_to_x=True)
+    self.assertTrue((aa_types == expected_out).all())
+
+  @parameterized.named_parameters(
+      ('lowercase', 'aaa'),  # Insertions in A3M.
+      ('gaps', '---'),  # Gaps in A3M.
+      ('dots', '...'),  # Gaps in A3M.
+      ('metadata', '>TEST'),  # FASTA metadata line.
+  )
+  def testSequenceToOneHotUnknownMappingError(self, seq):
+    with self.assertRaises(ValueError):
+      residue_constants.sequence_to_onehot(
+          sequence=seq,
+          mapping=residue_constants.restype_order_with_x,
+          map_unknown_to_x=True)
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/common/confidence.py",".py","6066","169","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Functions for processing confidence metrics.""""""
+
+from typing import Dict, Optional, Tuple
+import numpy as np
+import scipy.special
+
+
+def compute_plddt(logits: np.ndarray) -> np.ndarray:
+  """"""Computes per-residue pLDDT from logits.
+
+  Args:
+    logits: [num_res, num_bins] output from the PredictedLDDTHead.
+
+  Returns:
+    plddt: [num_res] per-residue pLDDT.
+  """"""
+  num_bins = logits.shape[-1]
+  bin_width = 1.0 / num_bins
+  bin_centers = np.arange(start=0.5 * bin_width, stop=1.0, step=bin_width)
+  probs = scipy.special.softmax(logits, axis=-1)
+  predicted_lddt_ca = np.sum(probs * bin_centers[None, :], axis=-1)
+  return predicted_lddt_ca * 100
+
+
+def _calculate_bin_centers(breaks: np.ndarray):
+  """"""Gets the bin centers from the bin edges.
+
+  Args:
+    breaks: [num_bins - 1] the error bin edges.
+
+  Returns:
+    bin_centers: [num_bins] the error bin centers.
+  """"""
+  step = (breaks[1] - breaks[0])
+
+  # Add half-step to get the center
+  bin_centers = breaks + step / 2
+  # Add a catch-all bin at the end.
+  bin_centers = np.concatenate([bin_centers, [bin_centers[-1] + step]],
+                               axis=0)
+  return bin_centers
+
+
+def _calculate_expected_aligned_error(
+    alignment_confidence_breaks: np.ndarray,
+    aligned_distance_error_probs: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+  """"""Calculates expected aligned distance errors for every pair of residues.
+
+  Args:
+    alignment_confidence_breaks: [num_bins - 1] the error bin edges.
+    aligned_distance_error_probs: [num_res, num_res, num_bins] the predicted
+      probs for each error bin, for each pair of residues.
+
+  Returns:
+    predicted_aligned_error: [num_res, num_res] the expected aligned distance
+      error for each pair of residues.
+    max_predicted_aligned_error: The maximum predicted error possible.
+  """"""
+  bin_centers = _calculate_bin_centers(alignment_confidence_breaks)
+
+  # Tuple of expected aligned distance error and max possible error.
+  return (np.sum(aligned_distance_error_probs * bin_centers, axis=-1),
+          np.asarray(bin_centers[-1]))
+
+
+def compute_predicted_aligned_error(
+    logits: np.ndarray,
+    breaks: np.ndarray) -> Dict[str, np.ndarray]:
+  """"""Computes aligned confidence metrics from logits.
+
+  Args:
+    logits: [num_res, num_res, num_bins] the logits output from
+      PredictedAlignedErrorHead.
+    breaks: [num_bins - 1] the error bin edges.
+
+  Returns:
+    aligned_confidence_probs: [num_res, num_res, num_bins] the predicted
+      aligned error probabilities over bins for each residue pair.
+    predicted_aligned_error: [num_res, num_res] the expected aligned distance
+      error for each pair of residues.
+    max_predicted_aligned_error: The maximum predicted error possible.
+  """"""
+  aligned_confidence_probs = scipy.special.softmax(
+      logits,
+      axis=-1)
+  predicted_aligned_error, max_predicted_aligned_error = (
+      _calculate_expected_aligned_error(
+          alignment_confidence_breaks=breaks,
+          aligned_distance_error_probs=aligned_confidence_probs))
+  return {
+      'aligned_confidence_probs': aligned_confidence_probs,
+      'predicted_aligned_error': predicted_aligned_error,
+      'max_predicted_aligned_error': max_predicted_aligned_error,
+  }
+
+
+def predicted_tm_score(
+    logits: np.ndarray,
+    breaks: np.ndarray,
+    residue_weights: Optional[np.ndarray] = None,
+    asym_id: Optional[np.ndarray] = None,
+    interface: bool = False) -> np.ndarray:
+  """"""Computes predicted TM alignment or predicted interface TM alignment score.
+
+  Args:
+    logits: [num_res, num_res, num_bins] the logits output from
+      PredictedAlignedErrorHead.
+    breaks: [num_bins] the error bins.
+    residue_weights: [num_res] the per residue weights to use for the
+      expectation.
+    asym_id: [num_res] the asymmetric unit ID - the chain ID. Only needed for
+      ipTM calculation, i.e. when interface=True.
+    interface: If True, interface predicted TM score is computed.
+
+  Returns:
+    ptm_score: The predicted TM alignment or the predicted iTM score.
+  """"""
+
+  # residue_weights has to be in [0, 1], but can be floating-point, i.e. the
+  # exp. resolved head's probability.
+  if residue_weights is None:
+    residue_weights = np.ones(logits.shape[0])
+
+  bin_centers = _calculate_bin_centers(breaks)
+
+  num_res = int(np.sum(residue_weights))
+  # Clip num_res to avoid negative/undefined d0.
+  clipped_num_res = max(num_res, 19)
+
+  # Compute d_0(num_res) as defined by TM-score, eqn. (5) in Yang & Skolnick
+  # ""Scoring function for automated assessment of protein structure template
+  # quality"", 2004: http://zhanglab.ccmb.med.umich.edu/papers/2004_3.pdf
+  d0 = 1.24 * (clipped_num_res - 15) ** (1./3) - 1.8
+
+  # Convert logits to probs.
+  probs = scipy.special.softmax(logits, axis=-1)
+
+  # TM-Score term for every bin.
+  tm_per_bin = 1. / (1 + np.square(bin_centers) / np.square(d0))
+  # E_distances tm(distance).
+  predicted_tm_term = np.sum(probs * tm_per_bin, axis=-1)
+
+  pair_mask = np.ones(shape=(num_res, num_res), dtype=bool)
+  if interface:
+    pair_mask *= asym_id[:, None] != asym_id[None, :]
+
+  predicted_tm_term *= pair_mask
+
+  pair_residue_weights = pair_mask * (
+      residue_weights[None, :] * residue_weights[:, None])
+  normed_residue_mask = pair_residue_weights / (1e-8 + np.sum(
+      pair_residue_weights, axis=-1, keepdims=True))
+  per_alignment = np.sum(predicted_tm_term * normed_residue_mask, axis=-1)
+  return np.asarray(per_alignment[(per_alignment * residue_weights).argmax()])
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/common/__init__.py",".py","655","15","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Common data types and constants used within Alphafold.""""""
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/common/residue_constants.py",".py","34974","898","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Constants used in AlphaFold.""""""
+
+import collections
+import functools
+import os
+from typing import List, Mapping, Tuple
+
+import numpy as np
+import tree
+
+# Internal import (35fd).
+
+
+# Distance from one CA to next CA [trans configuration: omega = 180].
+ca_ca = 3.80209737096
+
+# Format: The list for each AA type contains chi1, chi2, chi3, chi4 in
+# this order (or a relevant subset from chi1 onwards). ALA and GLY don't have
+# chi angles so their chi angle lists are empty.
+chi_angles_atoms = {
+    'ALA': [],
+    # Chi5 in arginine is always 0 +- 5 degrees, so ignore it.
+    'ARG': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'CD'],
+            ['CB', 'CG', 'CD', 'NE'], ['CG', 'CD', 'NE', 'CZ']],
+    'ASN': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'OD1']],
+    'ASP': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'OD1']],
+    'CYS': [['N', 'CA', 'CB', 'SG']],
+    'GLN': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'CD'],
+            ['CB', 'CG', 'CD', 'OE1']],
+    'GLU': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'CD'],
+            ['CB', 'CG', 'CD', 'OE1']],
+    'GLY': [],
+    'HIS': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'ND1']],
+    'ILE': [['N', 'CA', 'CB', 'CG1'], ['CA', 'CB', 'CG1', 'CD1']],
+    'LEU': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'CD1']],
+    'LYS': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'CD'],
+            ['CB', 'CG', 'CD', 'CE'], ['CG', 'CD', 'CE', 'NZ']],
+    'MET': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'SD'],
+            ['CB', 'CG', 'SD', 'CE']],
+    'PHE': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'CD1']],
+    'PRO': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'CD']],
+    'SER': [['N', 'CA', 'CB', 'OG']],
+    'THR': [['N', 'CA', 'CB', 'OG1']],
+    'TRP': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'CD1']],
+    'TYR': [['N', 'CA', 'CB', 'CG'], ['CA', 'CB', 'CG', 'CD1']],
+    'VAL': [['N', 'CA', 'CB', 'CG1']],
+}
+
+# If chi angles given in fixed-length array, this matrix determines how to mask
+# them for each AA type. The order is as per restype_order (see below).
+chi_angles_mask = [
+    [0.0, 0.0, 0.0, 0.0],  # ALA
+    [1.0, 1.0, 1.0, 1.0],  # ARG
+    [1.0, 1.0, 0.0, 0.0],  # ASN
+    [1.0, 1.0, 0.0, 0.0],  # ASP
+    [1.0, 0.0, 0.0, 0.0],  # CYS
+    [1.0, 1.0, 1.0, 0.0],  # GLN
+    [1.0, 1.0, 1.0, 0.0],  # GLU
+    [0.0, 0.0, 0.0, 0.0],  # GLY
+    [1.0, 1.0, 0.0, 0.0],  # HIS
+    [1.0, 1.0, 0.0, 0.0],  # ILE
+    [1.0, 1.0, 0.0, 0.0],  # LEU
+    [1.0, 1.0, 1.0, 1.0],  # LYS
+    [1.0, 1.0, 1.0, 0.0],  # MET
+    [1.0, 1.0, 0.0, 0.0],  # PHE
+    [1.0, 1.0, 0.0, 0.0],  # PRO
+    [1.0, 0.0, 0.0, 0.0],  # SER
+    [1.0, 0.0, 0.0, 0.0],  # THR
+    [1.0, 1.0, 0.0, 0.0],  # TRP
+    [1.0, 1.0, 0.0, 0.0],  # TYR
+    [1.0, 0.0, 0.0, 0.0],  # VAL
+]
+
+# The following chi angles are pi periodic: they can be rotated by a multiple
+# of pi without affecting the structure.
+chi_pi_periodic = [
+    [0.0, 0.0, 0.0, 0.0],  # ALA
+    [0.0, 0.0, 0.0, 0.0],  # ARG
+    [0.0, 0.0, 0.0, 0.0],  # ASN
+    [0.0, 1.0, 0.0, 0.0],  # ASP
+    [0.0, 0.0, 0.0, 0.0],  # CYS
+    [0.0, 0.0, 0.0, 0.0],  # GLN
+    [0.0, 0.0, 1.0, 0.0],  # GLU
+    [0.0, 0.0, 0.0, 0.0],  # GLY
+    [0.0, 0.0, 0.0, 0.0],  # HIS
+    [0.0, 0.0, 0.0, 0.0],  # ILE
+    [0.0, 0.0, 0.0, 0.0],  # LEU
+    [0.0, 0.0, 0.0, 0.0],  # LYS
+    [0.0, 0.0, 0.0, 0.0],  # MET
+    [0.0, 1.0, 0.0, 0.0],  # PHE
+    [0.0, 0.0, 0.0, 0.0],  # PRO
+    [0.0, 0.0, 0.0, 0.0],  # SER
+    [0.0, 0.0, 0.0, 0.0],  # THR
+    [0.0, 0.0, 0.0, 0.0],  # TRP
+    [0.0, 1.0, 0.0, 0.0],  # TYR
+    [0.0, 0.0, 0.0, 0.0],  # VAL
+    [0.0, 0.0, 0.0, 0.0],  # UNK
+]
+
+# Atoms positions relative to the 8 rigid groups, defined by the pre-omega, phi,
+# psi and chi angles:
+# 0: 'backbone group',
+# 1: 'pre-omega-group', (empty)
+# 2: 'phi-group', (currently empty, because it defines only hydrogens)
+# 3: 'psi-group',
+# 4,5,6,7: 'chi1,2,3,4-group'
+# The atom positions are relative to the axis-end-atom of the corresponding
+# rotation axis. The x-axis is in direction of the rotation axis, and the y-axis
+# is defined such that the dihedral-angle-defining atom (the last entry in
+# chi_angles_atoms above) is in the xy-plane (with a positive y-coordinate).
+# format: [atomname, group_idx, rel_position]
+rigid_group_atom_positions = {
+    'ALA': [
+        ['N', 0, (-0.525, 1.363, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.526, -0.000, -0.000)],
+        ['CB', 0, (-0.529, -0.774, -1.205)],
+        ['O', 3, (0.627, 1.062, 0.000)],
+    ],
+    'ARG': [
+        ['N', 0, (-0.524, 1.362, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.525, -0.000, -0.000)],
+        ['CB', 0, (-0.524, -0.778, -1.209)],
+        ['O', 3, (0.626, 1.062, 0.000)],
+        ['CG', 4, (0.616, 1.390, -0.000)],
+        ['CD', 5, (0.564, 1.414, 0.000)],
+        ['NE', 6, (0.539, 1.357, -0.000)],
+        ['NH1', 7, (0.206, 2.301, 0.000)],
+        ['NH2', 7, (2.078, 0.978, -0.000)],
+        ['CZ', 7, (0.758, 1.093, -0.000)],
+    ],
+    'ASN': [
+        ['N', 0, (-0.536, 1.357, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.526, -0.000, -0.000)],
+        ['CB', 0, (-0.531, -0.787, -1.200)],
+        ['O', 3, (0.625, 1.062, 0.000)],
+        ['CG', 4, (0.584, 1.399, 0.000)],
+        ['ND2', 5, (0.593, -1.188, 0.001)],
+        ['OD1', 5, (0.633, 1.059, 0.000)],
+    ],
+    'ASP': [
+        ['N', 0, (-0.525, 1.362, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.527, 0.000, -0.000)],
+        ['CB', 0, (-0.526, -0.778, -1.208)],
+        ['O', 3, (0.626, 1.062, -0.000)],
+        ['CG', 4, (0.593, 1.398, -0.000)],
+        ['OD1', 5, (0.610, 1.091, 0.000)],
+        ['OD2', 5, (0.592, -1.101, -0.003)],
+    ],
+    'CYS': [
+        ['N', 0, (-0.522, 1.362, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.524, 0.000, 0.000)],
+        ['CB', 0, (-0.519, -0.773, -1.212)],
+        ['O', 3, (0.625, 1.062, -0.000)],
+        ['SG', 4, (0.728, 1.653, 0.000)],
+    ],
+    'GLN': [
+        ['N', 0, (-0.526, 1.361, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.526, 0.000, 0.000)],
+        ['CB', 0, (-0.525, -0.779, -1.207)],
+        ['O', 3, (0.626, 1.062, -0.000)],
+        ['CG', 4, (0.615, 1.393, 0.000)],
+        ['CD', 5, (0.587, 1.399, -0.000)],
+        ['NE2', 6, (0.593, -1.189, -0.001)],
+        ['OE1', 6, (0.634, 1.060, 0.000)],
+    ],
+    'GLU': [
+        ['N', 0, (-0.528, 1.361, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.526, -0.000, -0.000)],
+        ['CB', 0, (-0.526, -0.781, -1.207)],
+        ['O', 3, (0.626, 1.062, 0.000)],
+        ['CG', 4, (0.615, 1.392, 0.000)],
+        ['CD', 5, (0.600, 1.397, 0.000)],
+        ['OE1', 6, (0.607, 1.095, -0.000)],
+        ['OE2', 6, (0.589, -1.104, -0.001)],
+    ],
+    'GLY': [
+        ['N', 0, (-0.572, 1.337, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.517, -0.000, -0.000)],
+        ['O', 3, (0.626, 1.062, -0.000)],
+    ],
+    'HIS': [
+        ['N', 0, (-0.527, 1.360, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.525, 0.000, 0.000)],
+        ['CB', 0, (-0.525, -0.778, -1.208)],
+        ['O', 3, (0.625, 1.063, 0.000)],
+        ['CG', 4, (0.600, 1.370, -0.000)],
+        ['CD2', 5, (0.889, -1.021, 0.003)],
+        ['ND1', 5, (0.744, 1.160, -0.000)],
+        ['CE1', 5, (2.030, 0.851, 0.002)],
+        ['NE2', 5, (2.145, -0.466, 0.004)],
+    ],
+    'ILE': [
+        ['N', 0, (-0.493, 1.373, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.527, -0.000, -0.000)],
+        ['CB', 0, (-0.536, -0.793, -1.213)],
+        ['O', 3, (0.627, 1.062, -0.000)],
+        ['CG1', 4, (0.534, 1.437, -0.000)],
+        ['CG2', 4, (0.540, -0.785, -1.199)],
+        ['CD1', 5, (0.619, 1.391, 0.000)],
+    ],
+    'LEU': [
+        ['N', 0, (-0.520, 1.363, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.525, -0.000, -0.000)],
+        ['CB', 0, (-0.522, -0.773, -1.214)],
+        ['O', 3, (0.625, 1.063, -0.000)],
+        ['CG', 4, (0.678, 1.371, 0.000)],
+        ['CD1', 5, (0.530, 1.430, -0.000)],
+        ['CD2', 5, (0.535, -0.774, 1.200)],
+    ],
+    'LYS': [
+        ['N', 0, (-0.526, 1.362, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.526, 0.000, 0.000)],
+        ['CB', 0, (-0.524, -0.778, -1.208)],
+        ['O', 3, (0.626, 1.062, -0.000)],
+        ['CG', 4, (0.619, 1.390, 0.000)],
+        ['CD', 5, (0.559, 1.417, 0.000)],
+        ['CE', 6, (0.560, 1.416, 0.000)],
+        ['NZ', 7, (0.554, 1.387, 0.000)],
+    ],
+    'MET': [
+        ['N', 0, (-0.521, 1.364, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.525, 0.000, 0.000)],
+        ['CB', 0, (-0.523, -0.776, -1.210)],
+        ['O', 3, (0.625, 1.062, -0.000)],
+        ['CG', 4, (0.613, 1.391, -0.000)],
+        ['SD', 5, (0.703, 1.695, 0.000)],
+        ['CE', 6, (0.320, 1.786, -0.000)],
+    ],
+    'PHE': [
+        ['N', 0, (-0.518, 1.363, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.524, 0.000, -0.000)],
+        ['CB', 0, (-0.525, -0.776, -1.212)],
+        ['O', 3, (0.626, 1.062, -0.000)],
+        ['CG', 4, (0.607, 1.377, 0.000)],
+        ['CD1', 5, (0.709, 1.195, -0.000)],
+        ['CD2', 5, (0.706, -1.196, 0.000)],
+        ['CE1', 5, (2.102, 1.198, -0.000)],
+        ['CE2', 5, (2.098, -1.201, -0.000)],
+        ['CZ', 5, (2.794, -0.003, -0.001)],
+    ],
+    'PRO': [
+        ['N', 0, (-0.566, 1.351, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.527, -0.000, 0.000)],
+        ['CB', 0, (-0.546, -0.611, -1.293)],
+        ['O', 3, (0.621, 1.066, 0.000)],
+        ['CG', 4, (0.382, 1.445, 0.0)],
+        # ['CD', 5, (0.427, 1.440, 0.0)],
+        ['CD', 5, (0.477, 1.424, 0.0)],  # manually made angle 2 degrees larger
+    ],
+    'SER': [
+        ['N', 0, (-0.529, 1.360, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.525, -0.000, -0.000)],
+        ['CB', 0, (-0.518, -0.777, -1.211)],
+        ['O', 3, (0.626, 1.062, -0.000)],
+        ['OG', 4, (0.503, 1.325, 0.000)],
+    ],
+    'THR': [
+        ['N', 0, (-0.517, 1.364, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.526, 0.000, -0.000)],
+        ['CB', 0, (-0.516, -0.793, -1.215)],
+        ['O', 3, (0.626, 1.062, 0.000)],
+        ['CG2', 4, (0.550, -0.718, -1.228)],
+        ['OG1', 4, (0.472, 1.353, 0.000)],
+    ],
+    'TRP': [
+        ['N', 0, (-0.521, 1.363, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.525, -0.000, 0.000)],
+        ['CB', 0, (-0.523, -0.776, -1.212)],
+        ['O', 3, (0.627, 1.062, 0.000)],
+        ['CG', 4, (0.609, 1.370, -0.000)],
+        ['CD1', 5, (0.824, 1.091, 0.000)],
+        ['CD2', 5, (0.854, -1.148, -0.005)],
+        ['CE2', 5, (2.186, -0.678, -0.007)],
+        ['CE3', 5, (0.622, -2.530, -0.007)],
+        ['NE1', 5, (2.140, 0.690, -0.004)],
+        ['CH2', 5, (3.028, -2.890, -0.013)],
+        ['CZ2', 5, (3.283, -1.543, -0.011)],
+        ['CZ3', 5, (1.715, -3.389, -0.011)],
+    ],
+    'TYR': [
+        ['N', 0, (-0.522, 1.362, 0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.524, -0.000, -0.000)],
+        ['CB', 0, (-0.522, -0.776, -1.213)],
+        ['O', 3, (0.627, 1.062, -0.000)],
+        ['CG', 4, (0.607, 1.382, -0.000)],
+        ['CD1', 5, (0.716, 1.195, -0.000)],
+        ['CD2', 5, (0.713, -1.194, -0.001)],
+        ['CE1', 5, (2.107, 1.200, -0.002)],
+        ['CE2', 5, (2.104, -1.201, -0.003)],
+        ['OH', 5, (4.168, -0.002, -0.005)],
+        ['CZ', 5, (2.791, -0.001, -0.003)],
+    ],
+    'VAL': [
+        ['N', 0, (-0.494, 1.373, -0.000)],
+        ['CA', 0, (0.000, 0.000, 0.000)],
+        ['C', 0, (1.527, -0.000, -0.000)],
+        ['CB', 0, (-0.533, -0.795, -1.213)],
+        ['O', 3, (0.627, 1.062, -0.000)],
+        ['CG1', 4, (0.540, 1.429, -0.000)],
+        ['CG2', 4, (0.533, -0.776, 1.203)],
+    ],
+}
+
+# A list of atoms (excluding hydrogen) for each AA type. PDB naming convention.
+residue_atoms = {
+    'ALA': ['C', 'CA', 'CB', 'N', 'O'],
+    'ARG': ['C', 'CA', 'CB', 'CG', 'CD', 'CZ', 'N', 'NE', 'O', 'NH1', 'NH2'],
+    'ASP': ['C', 'CA', 'CB', 'CG', 'N', 'O', 'OD1', 'OD2'],
+    'ASN': ['C', 'CA', 'CB', 'CG', 'N', 'ND2', 'O', 'OD1'],
+    'CYS': ['C', 'CA', 'CB', 'N', 'O', 'SG'],
+    'GLU': ['C', 'CA', 'CB', 'CG', 'CD', 'N', 'O', 'OE1', 'OE2'],
+    'GLN': ['C', 'CA', 'CB', 'CG', 'CD', 'N', 'NE2', 'O', 'OE1'],
+    'GLY': ['C', 'CA', 'N', 'O'],
+    'HIS': ['C', 'CA', 'CB', 'CG', 'CD2', 'CE1', 'N', 'ND1', 'NE2', 'O'],
+    'ILE': ['C', 'CA', 'CB', 'CG1', 'CG2', 'CD1', 'N', 'O'],
+    'LEU': ['C', 'CA', 'CB', 'CG', 'CD1', 'CD2', 'N', 'O'],
+    'LYS': ['C', 'CA', 'CB', 'CG', 'CD', 'CE', 'N', 'NZ', 'O'],
+    'MET': ['C', 'CA', 'CB', 'CG', 'CE', 'N', 'O', 'SD'],
+    'PHE': ['C', 'CA', 'CB', 'CG', 'CD1', 'CD2', 'CE1', 'CE2', 'CZ', 'N', 'O'],
+    'PRO': ['C', 'CA', 'CB', 'CG', 'CD', 'N', 'O'],
+    'SER': ['C', 'CA', 'CB', 'N', 'O', 'OG'],
+    'THR': ['C', 'CA', 'CB', 'CG2', 'N', 'O', 'OG1'],
+    'TRP': ['C', 'CA', 'CB', 'CG', 'CD1', 'CD2', 'CE2', 'CE3', 'CZ2', 'CZ3',
+            'CH2', 'N', 'NE1', 'O'],
+    'TYR': ['C', 'CA', 'CB', 'CG', 'CD1', 'CD2', 'CE1', 'CE2', 'CZ', 'N', 'O',
+            'OH'],
+    'VAL': ['C', 'CA', 'CB', 'CG1', 'CG2', 'N', 'O']
+}
+
+# Naming swaps for ambiguous atom names.
+# Due to symmetries in the amino acids the naming of atoms is ambiguous in
+# 4 of the 20 amino acids.
+# (The LDDT paper lists 7 amino acids as ambiguous, but the naming ambiguities
+# in LEU, VAL and ARG can be resolved by using the 3d constellations of
+# the 'ambiguous' atoms and their neighbours)
+residue_atom_renaming_swaps = {
+    'ASP': {'OD1': 'OD2'},
+    'GLU': {'OE1': 'OE2'},
+    'PHE': {'CD1': 'CD2', 'CE1': 'CE2'},
+    'TYR': {'CD1': 'CD2', 'CE1': 'CE2'},
+}
+
+# Van der Waals radii [Angstroem] of the atoms (from Wikipedia)
+van_der_waals_radius = {
+    'C': 1.7,
+    'N': 1.55,
+    'O': 1.52,
+    'S': 1.8,
+}
+
+Bond = collections.namedtuple(
+    'Bond', ['atom1_name', 'atom2_name', 'length', 'stddev'])
+BondAngle = collections.namedtuple(
+    'BondAngle',
+    ['atom1_name', 'atom2_name', 'atom3name', 'angle_rad', 'stddev'])
+
+
+@functools.lru_cache(maxsize=None)
+def load_stereo_chemical_props() -> Tuple[Mapping[str, List[Bond]],
+                                          Mapping[str, List[Bond]],
+                                          Mapping[str, List[BondAngle]]]:
+  """"""Load stereo_chemical_props.txt into a nice structure.
+
+  Load literature values for bond lengths and bond angles and translate
+  bond angles into the length of the opposite edge of the triangle
+  (""residue_virtual_bonds"").
+
+  Returns:
+    residue_bonds: Dict that maps resname -> list of Bond tuples.
+    residue_virtual_bonds: Dict that maps resname -> list of Bond tuples.
+    residue_bond_angles: Dict that maps resname -> list of BondAngle tuples.
+  """"""
+  stereo_chemical_props_path = os.path.join(
+      os.path.dirname(os.path.abspath(__file__)), 'stereo_chemical_props.txt'
+  )
+  with open(stereo_chemical_props_path, 'rt') as f:
+    stereo_chemical_props = f.read()
+  lines_iter = iter(stereo_chemical_props.splitlines())
+  # Load bond lengths.
+  residue_bonds = {}
+  next(lines_iter)  # Skip header line.
+  for line in lines_iter:
+    if line.strip() == '-':
+      break
+    bond, resname, length, stddev = line.split()
+    atom1, atom2 = bond.split('-')
+    if resname not in residue_bonds:
+      residue_bonds[resname] = []
+    residue_bonds[resname].append(
+        Bond(atom1, atom2, float(length), float(stddev)))
+  residue_bonds['UNK'] = []
+
+  # Load bond angles.
+  residue_bond_angles = {}
+  next(lines_iter)  # Skip empty line.
+  next(lines_iter)  # Skip header line.
+  for line in lines_iter:
+    if line.strip() == '-':
+      break
+    bond, resname, angle_degree, stddev_degree = line.split()
+    atom1, atom2, atom3 = bond.split('-')
+    if resname not in residue_bond_angles:
+      residue_bond_angles[resname] = []
+    residue_bond_angles[resname].append(
+        BondAngle(atom1, atom2, atom3,
+                  float(angle_degree) / 180. * np.pi,
+                  float(stddev_degree) / 180. * np.pi))
+  residue_bond_angles['UNK'] = []
+
+  def make_bond_key(atom1_name, atom2_name):
+    """"""Unique key to lookup bonds.""""""
+    return '-'.join(sorted([atom1_name, atom2_name]))
+
+  # Translate bond angles into distances (""virtual bonds"").
+  residue_virtual_bonds = {}
+  for resname, bond_angles in residue_bond_angles.items():
+    # Create a fast lookup dict for bond lengths.
+    bond_cache = {}
+    for b in residue_bonds[resname]:
+      bond_cache[make_bond_key(b.atom1_name, b.atom2_name)] = b
+    residue_virtual_bonds[resname] = []
+    for ba in bond_angles:
+      bond1 = bond_cache[make_bond_key(ba.atom1_name, ba.atom2_name)]
+      bond2 = bond_cache[make_bond_key(ba.atom2_name, ba.atom3name)]
+
+      # Compute distance between atom1 and atom3 using the law of cosines
+      # c^2 = a^2 + b^2 - 2ab*cos(gamma).
+      gamma = ba.angle_rad
+      length = np.sqrt(bond1.length**2 + bond2.length**2
+                       - 2 * bond1.length * bond2.length * np.cos(gamma))
+
+      # Propagation of uncertainty assuming uncorrelated errors.
+      dl_outer = 0.5 / length
+      dl_dgamma = (2 * bond1.length * bond2.length * np.sin(gamma)) * dl_outer
+      dl_db1 = (2 * bond1.length - 2 * bond2.length * np.cos(gamma)) * dl_outer
+      dl_db2 = (2 * bond2.length - 2 * bond1.length * np.cos(gamma)) * dl_outer
+      stddev = np.sqrt((dl_dgamma * ba.stddev)**2 +
+                       (dl_db1 * bond1.stddev)**2 +
+                       (dl_db2 * bond2.stddev)**2)
+      residue_virtual_bonds[resname].append(
+          Bond(ba.atom1_name, ba.atom3name, length, stddev))
+
+  return (residue_bonds,
+          residue_virtual_bonds,
+          residue_bond_angles)
+
+
+# Between-residue bond lengths for general bonds (first element) and for Proline
+# (second element).
+between_res_bond_length_c_n = [1.329, 1.341]
+between_res_bond_length_stddev_c_n = [0.014, 0.016]
+
+# Between-residue cos_angles.
+between_res_cos_angles_c_n_ca = [-0.5203, 0.0353]  # degrees: 121.352 +- 2.315
+between_res_cos_angles_ca_c_n = [-0.4473, 0.0311]  # degrees: 116.568 +- 1.995
+
+# This mapping is used when we need to store atom data in a format that requires
+# fixed atom data size for every residue (e.g. a numpy array).
+atom_types = [
+    'N', 'CA', 'C', 'CB', 'O', 'CG', 'CG1', 'CG2', 'OG', 'OG1', 'SG', 'CD',
+    'CD1', 'CD2', 'ND1', 'ND2', 'OD1', 'OD2', 'SD', 'CE', 'CE1', 'CE2', 'CE3',
+    'NE', 'NE1', 'NE2', 'OE1', 'OE2', 'CH2', 'NH1', 'NH2', 'OH', 'CZ', 'CZ2',
+    'CZ3', 'NZ', 'OXT'
+]
+atom_order = {atom_type: i for i, atom_type in enumerate(atom_types)}
+atom_type_num = len(atom_types)  # := 37.
+
+# A compact atom encoding with 14 columns
+# pylint: disable=line-too-long
+# pylint: disable=bad-whitespace
+restype_name_to_atom14_names = {
+    'ALA': ['N', 'CA', 'C', 'O', 'CB', '',    '',    '',    '',    '',    '',    '',    '',    ''],
+    'ARG': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'CD',  'NE',  'CZ',  'NH1', 'NH2', '',    '',    ''],
+    'ASN': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'OD1', 'ND2', '',    '',    '',    '',    '',    ''],
+    'ASP': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'OD1', 'OD2', '',    '',    '',    '',    '',    ''],
+    'CYS': ['N', 'CA', 'C', 'O', 'CB', 'SG',  '',    '',    '',    '',    '',    '',    '',    ''],
+    'GLN': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'CD',  'OE1', 'NE2', '',    '',    '',    '',    ''],
+    'GLU': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'CD',  'OE1', 'OE2', '',    '',    '',    '',    ''],
+    'GLY': ['N', 'CA', 'C', 'O', '',   '',    '',    '',    '',    '',    '',    '',    '',    ''],
+    'HIS': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'ND1', 'CD2', 'CE1', 'NE2', '',    '',    '',    ''],
+    'ILE': ['N', 'CA', 'C', 'O', 'CB', 'CG1', 'CG2', 'CD1', '',    '',    '',    '',    '',    ''],
+    'LEU': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'CD1', 'CD2', '',    '',    '',    '',    '',    ''],
+    'LYS': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'CD',  'CE',  'NZ',  '',    '',    '',    '',    ''],
+    'MET': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'SD',  'CE',  '',    '',    '',    '',    '',    ''],
+    'PHE': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'CD1', 'CD2', 'CE1', 'CE2', 'CZ',  '',    '',    ''],
+    'PRO': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'CD',  '',    '',    '',    '',    '',    '',    ''],
+    'SER': ['N', 'CA', 'C', 'O', 'CB', 'OG',  '',    '',    '',    '',    '',    '',    '',    ''],
+    'THR': ['N', 'CA', 'C', 'O', 'CB', 'OG1', 'CG2', '',    '',    '',    '',    '',    '',    ''],
+    'TRP': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'CD1', 'CD2', 'NE1', 'CE2', 'CE3', 'CZ2', 'CZ3', 'CH2'],
+    'TYR': ['N', 'CA', 'C', 'O', 'CB', 'CG',  'CD1', 'CD2', 'CE1', 'CE2', 'CZ',  'OH',  '',    ''],
+    'VAL': ['N', 'CA', 'C', 'O', 'CB', 'CG1', 'CG2', '',    '',    '',    '',    '',    '',    ''],
+    'UNK': ['',  '',   '',  '',  '',   '',    '',    '',    '',    '',    '',    '',    '',    ''],
+
+}
+# pylint: enable=line-too-long
+# pylint: enable=bad-whitespace
+
+
+# This is the standard residue order when coding AA type as a number.
+# Reproduce it by taking 3-letter AA codes and sorting them alphabetically.
+restypes = [
+    'A', 'R', 'N', 'D', 'C', 'Q', 'E', 'G', 'H', 'I', 'L', 'K', 'M', 'F', 'P',
+    'S', 'T', 'W', 'Y', 'V'
+]
+restype_order = {restype: i for i, restype in enumerate(restypes)}
+restype_num = len(restypes)  # := 20.
+unk_restype_index = restype_num  # Catch-all index for unknown restypes.
+
+restypes_with_x = restypes + ['X']
+restype_order_with_x = {restype: i for i, restype in enumerate(restypes_with_x)}
+
+
+def sequence_to_onehot(
+    sequence: str,
+    mapping: Mapping[str, int],
+    map_unknown_to_x: bool = False) -> np.ndarray:
+  """"""Maps the given sequence into a one-hot encoded matrix.
+
+  Args:
+    sequence: An amino acid sequence.
+    mapping: A dictionary mapping amino acids to integers.
+    map_unknown_to_x: If True, any amino acid that is not in the mapping will be
+      mapped to the unknown amino acid 'X'. If the mapping doesn't contain
+      amino acid 'X', an error will be thrown. If False, any amino acid not in
+      the mapping will throw an error.
+
+  Returns:
+    A numpy array of shape (seq_len, num_unique_aas) with one-hot encoding of
+    the sequence.
+
+  Raises:
+    ValueError: If the mapping doesn't contain values from 0 to
+      num_unique_aas - 1 without any gaps.
+  """"""
+  num_entries = max(mapping.values()) + 1
+
+  if sorted(set(mapping.values())) != list(range(num_entries)):
+    raise ValueError('The mapping must have values from 0 to num_unique_aas-1 '
+                     'without any gaps. Got: %s' % sorted(mapping.values()))
+
+  one_hot_arr = np.zeros((len(sequence), num_entries), dtype=np.int32)
+
+  for aa_index, aa_type in enumerate(sequence):
+    if map_unknown_to_x:
+      if aa_type.isalpha() and aa_type.isupper():
+        aa_id = mapping.get(aa_type, mapping['X'])
+      else:
+        raise ValueError(f'Invalid character in the sequence: {aa_type}')
+    else:
+      aa_id = mapping[aa_type]
+    one_hot_arr[aa_index, aa_id] = 1
+
+  return one_hot_arr
+
+
+restype_1to3 = {
+    'A': 'ALA',
+    'R': 'ARG',
+    'N': 'ASN',
+    'D': 'ASP',
+    'C': 'CYS',
+    'Q': 'GLN',
+    'E': 'GLU',
+    'G': 'GLY',
+    'H': 'HIS',
+    'I': 'ILE',
+    'L': 'LEU',
+    'K': 'LYS',
+    'M': 'MET',
+    'F': 'PHE',
+    'P': 'PRO',
+    'S': 'SER',
+    'T': 'THR',
+    'W': 'TRP',
+    'Y': 'TYR',
+    'V': 'VAL',
+}
+
+
+# NB: restype_3to1 differs from Bio.PDB.protein_letters_3to1 by being a simple
+# 1-to-1 mapping of 3 letter names to one letter names. The latter contains
+# many more, and less common, three letter names as keys and maps many of these
+# to the same one letter name (including 'X' and 'U' which we don't use here).
+restype_3to1 = {v: k for k, v in restype_1to3.items()}
+
+# Define a restype name for all unknown residues.
+unk_restype = 'UNK'
+
+resnames = [restype_1to3[r] for r in restypes] + [unk_restype]
+resname_to_idx = {resname: i for i, resname in enumerate(resnames)}
+
+
+# The mapping here uses hhblits convention, so that B is mapped to D, J and O
+# are mapped to X, U is mapped to C, and Z is mapped to E. Other than that the
+# remaining 20 amino acids are kept in alphabetical order.
+# There are 2 non-amino acid codes, X (representing any amino acid) and
+# ""-"" representing a missing amino acid in an alignment.  The id for these
+# codes is put at the end (20 and 21) so that they can easily be ignored if
+# desired.
+HHBLITS_AA_TO_ID = {
+    'A': 0,
+    'B': 2,
+    'C': 1,
+    'D': 2,
+    'E': 3,
+    'F': 4,
+    'G': 5,
+    'H': 6,
+    'I': 7,
+    'J': 20,
+    'K': 8,
+    'L': 9,
+    'M': 10,
+    'N': 11,
+    'O': 20,
+    'P': 12,
+    'Q': 13,
+    'R': 14,
+    'S': 15,
+    'T': 16,
+    'U': 1,
+    'V': 17,
+    'W': 18,
+    'X': 20,
+    'Y': 19,
+    'Z': 3,
+    '-': 21,
+}
+
+# Partial inversion of HHBLITS_AA_TO_ID.
+ID_TO_HHBLITS_AA = {
+    0: 'A',
+    1: 'C',  # Also U.
+    2: 'D',  # Also B.
+    3: 'E',  # Also Z.
+    4: 'F',
+    5: 'G',
+    6: 'H',
+    7: 'I',
+    8: 'K',
+    9: 'L',
+    10: 'M',
+    11: 'N',
+    12: 'P',
+    13: 'Q',
+    14: 'R',
+    15: 'S',
+    16: 'T',
+    17: 'V',
+    18: 'W',
+    19: 'Y',
+    20: 'X',  # Includes J and O.
+    21: '-',
+}
+
+restypes_with_x_and_gap = restypes + ['X', '-']
+MAP_HHBLITS_AATYPE_TO_OUR_AATYPE = tuple(
+    restypes_with_x_and_gap.index(ID_TO_HHBLITS_AA[i])
+    for i in range(len(restypes_with_x_and_gap)))
+
+
+def _make_standard_atom_mask() -> np.ndarray:
+  """"""Returns [num_res_types, num_atom_types] mask array.""""""
+  # +1 to account for unknown (all 0s).
+  mask = np.zeros([restype_num + 1, atom_type_num], dtype=np.int32)
+  for restype, restype_letter in enumerate(restypes):
+    restype_name = restype_1to3[restype_letter]
+    atom_names = residue_atoms[restype_name]
+    for atom_name in atom_names:
+      atom_type = atom_order[atom_name]
+      mask[restype, atom_type] = 1
+  return mask
+
+
+STANDARD_ATOM_MASK = _make_standard_atom_mask()
+
+
+# A one hot representation for the first and second atoms defining the axis
+# of rotation for each chi-angle in each residue.
+def chi_angle_atom(atom_index: int) -> np.ndarray:
+  """"""Define chi-angle rigid groups via one-hot representations.""""""
+  chi_angles_index = {}
+  one_hots = []
+
+  for k, v in chi_angles_atoms.items():
+    indices = [atom_types.index(s[atom_index]) for s in v]
+    indices.extend([-1]*(4-len(indices)))
+    chi_angles_index[k] = indices
+
+  for r in restypes:
+    res3 = restype_1to3[r]
+    one_hot = np.eye(atom_type_num)[chi_angles_index[res3]]
+    one_hots.append(one_hot)
+
+  one_hots.append(np.zeros([4, atom_type_num]))  # Add zeros for residue `X`.
+  one_hot = np.stack(one_hots, axis=0)
+  one_hot = np.transpose(one_hot, [0, 2, 1])
+
+  return one_hot
+
+chi_atom_1_one_hot = chi_angle_atom(1)
+chi_atom_2_one_hot = chi_angle_atom(2)
+
+# An array like chi_angles_atoms but using indices rather than names.
+chi_angles_atom_indices = [chi_angles_atoms[restype_1to3[r]] for r in restypes]
+chi_angles_atom_indices = tree.map_structure(
+    lambda atom_name: atom_order[atom_name], chi_angles_atom_indices)
+chi_angles_atom_indices = np.array([
+    chi_atoms + ([[0, 0, 0, 0]] * (4 - len(chi_atoms)))
+    for chi_atoms in chi_angles_atom_indices])
+
+# Mapping from (res_name, atom_name) pairs to the atom's chi group index
+# and atom index within that group.
+chi_groups_for_atom = collections.defaultdict(list)
+for res_name, chi_angle_atoms_for_res in chi_angles_atoms.items():
+  for chi_group_i, chi_group in enumerate(chi_angle_atoms_for_res):
+    for atom_i, atom in enumerate(chi_group):
+      chi_groups_for_atom[(res_name, atom)].append((chi_group_i, atom_i))
+chi_groups_for_atom = dict(chi_groups_for_atom)
+
+
+def _make_rigid_transformation_4x4(ex, ey, translation):
+  """"""Create a rigid 4x4 transformation matrix from two axes and transl.""""""
+  # Normalize ex.
+  ex_normalized = ex / np.linalg.norm(ex)
+
+  # make ey perpendicular to ex
+  ey_normalized = ey - np.dot(ey, ex_normalized) * ex_normalized
+  ey_normalized /= np.linalg.norm(ey_normalized)
+
+  # compute ez as cross product
+  eznorm = np.cross(ex_normalized, ey_normalized)
+  m = np.stack([ex_normalized, ey_normalized, eznorm, translation]).transpose()
+  m = np.concatenate([m, [[0., 0., 0., 1.]]], axis=0)
+  return m
+
+
+# create an array with (restype, atomtype) --> rigid_group_idx
+# and an array with (restype, atomtype, coord) for the atom positions
+# and compute affine transformation matrices (4,4) from one rigid group to the
+# previous group
+restype_atom37_to_rigid_group = np.zeros([21, 37], dtype=int)
+restype_atom37_mask = np.zeros([21, 37], dtype=np.float32)
+restype_atom37_rigid_group_positions = np.zeros([21, 37, 3], dtype=np.float32)
+restype_atom14_to_rigid_group = np.zeros([21, 14], dtype=int)
+restype_atom14_mask = np.zeros([21, 14], dtype=np.float32)
+restype_atom14_rigid_group_positions = np.zeros([21, 14, 3], dtype=np.float32)
+restype_rigid_group_default_frame = np.zeros([21, 8, 4, 4], dtype=np.float32)
+
+
+def _make_rigid_group_constants():
+  """"""Fill the arrays above.""""""
+  for restype, restype_letter in enumerate(restypes):
+    resname = restype_1to3[restype_letter]
+    for atomname, group_idx, atom_position in rigid_group_atom_positions[
+        resname]:
+      atomtype = atom_order[atomname]
+      restype_atom37_to_rigid_group[restype, atomtype] = group_idx
+      restype_atom37_mask[restype, atomtype] = 1
+      restype_atom37_rigid_group_positions[restype, atomtype, :] = atom_position
+
+      atom14idx = restype_name_to_atom14_names[resname].index(atomname)
+      restype_atom14_to_rigid_group[restype, atom14idx] = group_idx
+      restype_atom14_mask[restype, atom14idx] = 1
+      restype_atom14_rigid_group_positions[restype,
+                                           atom14idx, :] = atom_position
+
+  for restype, restype_letter in enumerate(restypes):
+    resname = restype_1to3[restype_letter]
+    atom_positions = {name: np.array(pos) for name, _, pos
+                      in rigid_group_atom_positions[resname]}
+
+    # backbone to backbone is the identity transform
+    restype_rigid_group_default_frame[restype, 0, :, :] = np.eye(4)
+
+    # pre-omega-frame to backbone (currently dummy identity matrix)
+    restype_rigid_group_default_frame[restype, 1, :, :] = np.eye(4)
+
+    # phi-frame to backbone
+    mat = _make_rigid_transformation_4x4(
+        ex=atom_positions['N'] - atom_positions['CA'],
+        ey=np.array([1., 0., 0.]),
+        translation=atom_positions['N'])
+    restype_rigid_group_default_frame[restype, 2, :, :] = mat
+
+    # psi-frame to backbone
+    mat = _make_rigid_transformation_4x4(
+        ex=atom_positions['C'] - atom_positions['CA'],
+        ey=atom_positions['CA'] - atom_positions['N'],
+        translation=atom_positions['C'])
+    restype_rigid_group_default_frame[restype, 3, :, :] = mat
+
+    # chi1-frame to backbone
+    if chi_angles_mask[restype][0]:
+      base_atom_names = chi_angles_atoms[resname][0]
+      base_atom_positions = [atom_positions[name] for name in base_atom_names]
+      mat = _make_rigid_transformation_4x4(
+          ex=base_atom_positions[2] - base_atom_positions[1],
+          ey=base_atom_positions[0] - base_atom_positions[1],
+          translation=base_atom_positions[2])
+      restype_rigid_group_default_frame[restype, 4, :, :] = mat
+
+    # chi2-frame to chi1-frame
+    # chi3-frame to chi2-frame
+    # chi4-frame to chi3-frame
+    # luckily all rotation axes for the next frame start at (0,0,0) of the
+    # previous frame
+    for chi_idx in range(1, 4):
+      if chi_angles_mask[restype][chi_idx]:
+        axis_end_atom_name = chi_angles_atoms[resname][chi_idx][2]
+        axis_end_atom_position = atom_positions[axis_end_atom_name]
+        mat = _make_rigid_transformation_4x4(
+            ex=axis_end_atom_position,
+            ey=np.array([-1., 0., 0.]),
+            translation=axis_end_atom_position)
+        restype_rigid_group_default_frame[restype, 4 + chi_idx, :, :] = mat
+
+
+_make_rigid_group_constants()
+
+
+def make_atom14_dists_bounds(overlap_tolerance=1.5,
+                             bond_length_tolerance_factor=15):
+  """"""compute upper and lower bounds for bonds to assess violations.""""""
+  restype_atom14_bond_lower_bound = np.zeros([21, 14, 14], np.float32)
+  restype_atom14_bond_upper_bound = np.zeros([21, 14, 14], np.float32)
+  restype_atom14_bond_stddev = np.zeros([21, 14, 14], np.float32)
+  residue_bonds, residue_virtual_bonds, _ = load_stereo_chemical_props()
+  for restype, restype_letter in enumerate(restypes):
+    resname = restype_1to3[restype_letter]
+    atom_list = restype_name_to_atom14_names[resname]
+
+    # create lower and upper bounds for clashes
+    for atom1_idx, atom1_name in enumerate(atom_list):
+      if not atom1_name:
+        continue
+      atom1_radius = van_der_waals_radius[atom1_name[0]]
+      for atom2_idx, atom2_name in enumerate(atom_list):
+        if (not atom2_name) or atom1_idx == atom2_idx:
+          continue
+        atom2_radius = van_der_waals_radius[atom2_name[0]]
+        lower = atom1_radius + atom2_radius - overlap_tolerance
+        upper = 1e10
+        restype_atom14_bond_lower_bound[restype, atom1_idx, atom2_idx] = lower
+        restype_atom14_bond_lower_bound[restype, atom2_idx, atom1_idx] = lower
+        restype_atom14_bond_upper_bound[restype, atom1_idx, atom2_idx] = upper
+        restype_atom14_bond_upper_bound[restype, atom2_idx, atom1_idx] = upper
+
+    # overwrite lower and upper bounds for bonds and angles
+    for b in residue_bonds[resname] + residue_virtual_bonds[resname]:
+      atom1_idx = atom_list.index(b.atom1_name)
+      atom2_idx = atom_list.index(b.atom2_name)
+      lower = b.length - bond_length_tolerance_factor * b.stddev
+      upper = b.length + bond_length_tolerance_factor * b.stddev
+      restype_atom14_bond_lower_bound[restype, atom1_idx, atom2_idx] = lower
+      restype_atom14_bond_lower_bound[restype, atom2_idx, atom1_idx] = lower
+      restype_atom14_bond_upper_bound[restype, atom1_idx, atom2_idx] = upper
+      restype_atom14_bond_upper_bound[restype, atom2_idx, atom1_idx] = upper
+      restype_atom14_bond_stddev[restype, atom1_idx, atom2_idx] = b.stddev
+      restype_atom14_bond_stddev[restype, atom2_idx, atom1_idx] = b.stddev
+  return {'lower_bound': restype_atom14_bond_lower_bound,  # shape (21,14,14)
+          'upper_bound': restype_atom14_bond_upper_bound,  # shape (21,14,14)
+          'stddev': restype_atom14_bond_stddev,  # shape (21,14,14)
+         }
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/common/protein.py",".py","9959","279","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Protein data type.""""""
+import dataclasses
+import io
+from typing import Any, Mapping, Optional
+from alphafold.common import residue_constants
+from Bio.PDB import PDBParser
+import numpy as np
+
+FeatureDict = Mapping[str, np.ndarray]
+ModelOutput = Mapping[str, Any]  # Is a nested dict.
+
+# Complete sequence of chain IDs supported by the PDB format.
+PDB_CHAIN_IDS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+PDB_MAX_CHAINS = len(PDB_CHAIN_IDS)  # := 62.
+
+
+@dataclasses.dataclass(frozen=True)
+class Protein:
+  """"""Protein structure representation.""""""
+
+  # Cartesian coordinates of atoms in angstroms. The atom types correspond to
+  # residue_constants.atom_types, i.e. the first three are N, CA, CB.
+  atom_positions: 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'.
+  aatype: 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.
+  atom_mask: np.ndarray  # [num_res, num_atom_type]
+
+  # Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
+  residue_index: np.ndarray  # [num_res]
+
+  # 0-indexed number corresponding to the chain in the protein that this residue
+  # belongs to.
+  chain_index: 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.
+  b_factors: np.ndarray  # [num_res, num_atom_type]
+
+  def __post_init__(self):
+    if len(np.unique(self.chain_index)) > PDB_MAX_CHAINS:
+      raise ValueError(
+          f'Cannot build an instance with more than {PDB_MAX_CHAINS} chains '
+          'because these cannot be written to PDB format.')
+
+
+def from_pdb_string(pdb_str: str, chain_id: Optional[str] = None) -> Protein:
+  """"""Takes a PDB string and constructs a Protein object.
+
+  WARNING: All non-standard residue types will be converted into UNK. All
+    non-standard atoms will be ignored.
+
+  Args:
+    pdb_str: The contents of the pdb file
+    chain_id: If chain_id is specified (e.g. A), then only that chain
+      is parsed. Otherwise all chains are parsed.
+
+  Returns:
+    A new `Protein` parsed from the pdb contents.
+  """"""
+  pdb_fh = io.StringIO(pdb_str)
+  parser = PDBParser(QUIET=True)
+  structure = parser.get_structure('none', pdb_fh)
+  models = list(structure.get_models())
+  if len(models) != 1:
+    raise ValueError(
+        f'Only single model PDBs are supported. Found {len(models)} models.')
+  model = models[0]
+
+  atom_positions = []
+  aatype = []
+  atom_mask = []
+  residue_index = []
+  chain_ids = []
+  b_factors = []
+
+  for chain in model:
+    if chain_id is not None and chain.id != chain_id:
+      continue
+    for res in chain:
+      if res.id[2] != ' ':
+        raise ValueError(
+            f'PDB contains an insertion code at chain {chain.id} and residue '
+            f'index {res.id[1]}. These are not supported.')
+      res_shortname = residue_constants.restype_3to1.get(res.resname, 'X')
+      restype_idx = residue_constants.restype_order.get(
+          res_shortname, residue_constants.restype_num)
+      pos = np.zeros((residue_constants.atom_type_num, 3))
+      mask = np.zeros((residue_constants.atom_type_num,))
+      res_b_factors = np.zeros((residue_constants.atom_type_num,))
+      for atom in res:
+        if atom.name not in residue_constants.atom_types:
+          continue
+        pos[residue_constants.atom_order[atom.name]] = atom.coord
+        mask[residue_constants.atom_order[atom.name]] = 1.
+        res_b_factors[residue_constants.atom_order[atom.name]] = atom.bfactor
+      if np.sum(mask) < 0.5:
+        # If no known atom positions are reported for the residue then skip it.
+        continue
+      aatype.append(restype_idx)
+      atom_positions.append(pos)
+      atom_mask.append(mask)
+      residue_index.append(res.id[1])
+      chain_ids.append(chain.id)
+      b_factors.append(res_b_factors)
+
+  # Chain IDs are usually characters so map these to ints.
+  unique_chain_ids = np.unique(chain_ids)
+  chain_id_mapping = {cid: n for n, cid in enumerate(unique_chain_ids)}
+  chain_index = np.array([chain_id_mapping[cid] for cid in chain_ids])
+
+  return Protein(
+      atom_positions=np.array(atom_positions),
+      atom_mask=np.array(atom_mask),
+      aatype=np.array(aatype),
+      residue_index=np.array(residue_index),
+      chain_index=chain_index,
+      b_factors=np.array(b_factors))
+
+
+def _chain_end(atom_index, end_resname, chain_name, residue_index) -> str:
+  chain_end = 'TER'
+  return (f'{chain_end:<6}{atom_index:>5}      {end_resname:>3} '
+          f'{chain_name:>1}{residue_index:>4}')
+
+
+def to_pdb(prot: Protein) -> str:
+  """"""Converts a `Protein` instance to a PDB string.
+
+  Args:
+    prot: The protein to convert to PDB.
+
+  Returns:
+    PDB string.
+  """"""
+  restypes = residue_constants.restypes + ['X']
+  res_1to3 = lambda r: residue_constants.restype_1to3.get(restypes[r], 'UNK')
+  atom_types = residue_constants.atom_types
+
+  pdb_lines = []
+
+  atom_mask = prot.atom_mask
+  aatype = prot.aatype
+  atom_positions = prot.atom_positions
+  residue_index = prot.residue_index.astype(np.int32)
+  chain_index = prot.chain_index.astype(np.int32)
+  b_factors = prot.b_factors
+
+  if np.any(aatype > residue_constants.restype_num):
+    raise ValueError('Invalid aatypes.')
+
+  # Construct a mapping from chain integer indices to chain ID strings.
+  chain_ids = {}
+  for i in np.unique(chain_index):  # np.unique gives sorted output.
+    if i >= PDB_MAX_CHAINS:
+      raise ValueError(
+          f'The PDB format supports at most {PDB_MAX_CHAINS} chains.')
+    chain_ids[i] = PDB_CHAIN_IDS[i]
+
+  pdb_lines.append('MODEL     1')
+  atom_index = 1
+  last_chain_index = chain_index[0]
+  # Add all atom sites.
+  for i in range(aatype.shape[0]):
+    # Close the previous chain if in a multichain PDB.
+    if last_chain_index != chain_index[i]:
+      pdb_lines.append(_chain_end(
+          atom_index, res_1to3(aatype[i - 1]), chain_ids[chain_index[i - 1]],
+          residue_index[i - 1]))
+      last_chain_index = chain_index[i]
+      atom_index += 1  # Atom index increases at the TER symbol.
+
+    res_name_3 = res_1to3(aatype[i])
+    for atom_name, pos, mask, b_factor in zip(
+        atom_types, atom_positions[i], atom_mask[i], b_factors[i]):
+      if mask < 0.5:
+        continue
+
+      record_type = 'ATOM'
+      name = atom_name if len(atom_name) == 4 else f' {atom_name}'
+      alt_loc = ''
+      insertion_code = ''
+      occupancy = 1.00
+      element = atom_name[0]  # Protein supports only C, N, O, S, this works.
+      charge = ''
+      # PDB is a columnar format, every space matters here!
+      atom_line = (f'{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}'
+                   f'{res_name_3:>3} {chain_ids[chain_index[i]]:>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(atom_line)
+      atom_index += 1
+
+  # Close the final chain.
+  pdb_lines.append(_chain_end(atom_index, res_1to3(aatype[-1]),
+                              chain_ids[chain_index[-1]], residue_index[-1]))
+  pdb_lines.append('ENDMDL')
+  pdb_lines.append('END')
+
+  # Pad all lines to 80 characters.
+  pdb_lines = [line.ljust(80) for line in pdb_lines]
+  return '\n'.join(pdb_lines) + '\n'  # Add terminating newline.
+
+
+def ideal_atom_mask(prot: Protein) -> np.ndarray:
+  """"""Computes an ideal atom mask.
+
+  `Protein.atom_mask` typically is defined according to the atoms that are
+  reported in the PDB. This function computes a mask according to heavy atoms
+  that should be present in the given sequence of amino acids.
+
+  Args:
+    prot: `Protein` whose fields are `numpy.ndarray` objects.
+
+  Returns:
+    An ideal atom mask.
+  """"""
+  return residue_constants.STANDARD_ATOM_MASK[prot.aatype]
+
+
+def from_prediction(
+    features: FeatureDict,
+    result: ModelOutput,
+    b_factors: Optional[np.ndarray] = None,
+    remove_leading_feature_dimension: bool = True) -> Protein:
+  """"""Assembles a protein from a prediction.
+
+  Args:
+    features: Dictionary holding model inputs.
+    result: Dictionary holding model outputs.
+    b_factors: (Optional) B-factors to use for the protein.
+    remove_leading_feature_dimension: Whether to remove the leading dimension
+      of the `features` values.
+
+  Returns:
+    A protein instance.
+  """"""
+  fold_output = result['structure_module']
+
+  def _maybe_remove_leading_dim(arr: np.ndarray) -> np.ndarray:
+    return arr[0] if remove_leading_feature_dimension else arr
+
+  if 'asym_id' in features:
+    chain_index = _maybe_remove_leading_dim(features['asym_id'])
+  else:
+    chain_index = np.zeros_like(_maybe_remove_leading_dim(features['aatype']))
+
+  if b_factors is None:
+    b_factors = np.zeros_like(fold_output['final_atom_mask'])
+
+  return Protein(
+      aatype=_maybe_remove_leading_dim(features['aatype']),
+      atom_positions=fold_output['final_atom_positions'],
+      atom_mask=fold_output['final_atom_mask'],
+      residue_index=_maybe_remove_leading_dim(features['residue_index']) + 1,
+      chain_index=chain_index,
+      b_factors=b_factors)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/common/protein_test.py",".py","4594","115","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for protein.""""""
+
+import os
+
+from absl.testing import absltest
+from absl.testing import parameterized
+from alphafold.common import protein
+from alphafold.common import residue_constants
+import numpy as np
+# Internal import (7716).
+
+TEST_DATA_DIR = 'alphafold/common/testdata/'
+
+
+class ProteinTest(parameterized.TestCase):
+
+  def _check_shapes(self, prot, num_res):
+    """"""Check that the processed shapes are correct.""""""
+    num_atoms = residue_constants.atom_type_num
+    self.assertEqual((num_res, num_atoms, 3), prot.atom_positions.shape)
+    self.assertEqual((num_res,), prot.aatype.shape)
+    self.assertEqual((num_res, num_atoms), prot.atom_mask.shape)
+    self.assertEqual((num_res,), prot.residue_index.shape)
+    self.assertEqual((num_res,), prot.chain_index.shape)
+    self.assertEqual((num_res, num_atoms), prot.b_factors.shape)
+
+  @parameterized.named_parameters(
+      dict(testcase_name='chain_A',
+           pdb_file='2rbg.pdb', chain_id='A', num_res=282, num_chains=1),
+      dict(testcase_name='chain_B',
+           pdb_file='2rbg.pdb', chain_id='B', num_res=282, num_chains=1),
+      dict(testcase_name='multichain',
+           pdb_file='2rbg.pdb', chain_id=None, num_res=564, num_chains=2))
+  def test_from_pdb_str(self, pdb_file, chain_id, num_res, num_chains):
+    pdb_file = os.path.join(absltest.get_default_test_srcdir(), TEST_DATA_DIR,
+                            pdb_file)
+    with open(pdb_file) as f:
+      pdb_string = f.read()
+    prot = protein.from_pdb_string(pdb_string, chain_id)
+    self._check_shapes(prot, num_res)
+    self.assertGreaterEqual(prot.aatype.min(), 0)
+    # Allow equal since unknown restypes have index equal to restype_num.
+    self.assertLessEqual(prot.aatype.max(), residue_constants.restype_num)
+    self.assertLen(np.unique(prot.chain_index), num_chains)
+
+  def test_to_pdb(self):
+    with open(
+        os.path.join(absltest.get_default_test_srcdir(), TEST_DATA_DIR,
+                     '2rbg.pdb')) as f:
+      pdb_string = f.read()
+    prot = protein.from_pdb_string(pdb_string)
+    pdb_string_reconstr = protein.to_pdb(prot)
+
+    for line in pdb_string_reconstr.splitlines():
+      self.assertLen(line, 80)
+
+    prot_reconstr = protein.from_pdb_string(pdb_string_reconstr)
+
+    np.testing.assert_array_equal(prot_reconstr.aatype, prot.aatype)
+    np.testing.assert_array_almost_equal(
+        prot_reconstr.atom_positions, prot.atom_positions)
+    np.testing.assert_array_almost_equal(
+        prot_reconstr.atom_mask, prot.atom_mask)
+    np.testing.assert_array_equal(
+        prot_reconstr.residue_index, prot.residue_index)
+    np.testing.assert_array_equal(
+        prot_reconstr.chain_index, prot.chain_index)
+    np.testing.assert_array_almost_equal(
+        prot_reconstr.b_factors, prot.b_factors)
+
+  def test_ideal_atom_mask(self):
+    with open(
+        os.path.join(absltest.get_default_test_srcdir(), TEST_DATA_DIR,
+                     '2rbg.pdb')) as f:
+      pdb_string = f.read()
+    prot = protein.from_pdb_string(pdb_string)
+    ideal_mask = protein.ideal_atom_mask(prot)
+    non_ideal_residues = set([102] + list(range(127, 286)))
+    for i, (res, atom_mask) in enumerate(
+        zip(prot.residue_index, prot.atom_mask)):
+      if res in non_ideal_residues:
+        self.assertFalse(np.all(atom_mask == ideal_mask[i]), msg=f'{res}')
+      else:
+        self.assertTrue(np.all(atom_mask == ideal_mask[i]), msg=f'{res}')
+
+  def test_too_many_chains(self):
+    num_res = protein.PDB_MAX_CHAINS + 1
+    num_atom_type = residue_constants.atom_type_num
+    with self.assertRaises(ValueError):
+      _ = protein.Protein(
+          atom_positions=np.random.random([num_res, num_atom_type, 3]),
+          aatype=np.random.randint(0, 21, [num_res]),
+          atom_mask=np.random.randint(0, 2, [num_res]).astype(np.float32),
+          residue_index=np.arange(1, num_res+1),
+          chain_index=np.arange(num_res),
+          b_factors=np.random.uniform(1, 100, [num_res]))
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/notebooks/notebook_utils.py",".py","6736","169","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Helper methods for the AlphaFold Colab notebook.""""""
+import json
+from typing import Any, Mapping, Optional, Sequence, Tuple
+
+from alphafold.common import residue_constants
+from alphafold.data import parsers
+from matplotlib import pyplot as plt
+import numpy as np
+
+
+def clean_and_validate_single_sequence(
+    input_sequence: str, min_length: int, max_length: int) -> str:
+  """"""Checks that the input sequence is ok and returns a clean version of it.""""""
+  # Remove all whitespaces, tabs and end lines; upper-case.
+  clean_sequence = input_sequence.translate(
+      str.maketrans('', '', ' \n\t')).upper()
+  aatypes = set(residue_constants.restypes)  # 20 standard aatypes.
+  if not set(clean_sequence).issubset(aatypes):
+    raise ValueError(
+        f'Input sequence contains non-amino acid letters: '
+        f'{set(clean_sequence) - aatypes}. AlphaFold only supports 20 standard '
+        'amino acids as inputs.')
+  if len(clean_sequence) < min_length:
+    raise ValueError(
+        f'Input sequence is too short: {len(clean_sequence)} amino acids, '
+        f'while the minimum is {min_length}')
+  if len(clean_sequence) > max_length:
+    raise ValueError(
+        f'Input sequence is too long: {len(clean_sequence)} amino acids, while '
+        f'the maximum is {max_length}. You may be able to run it with the full '
+        f'AlphaFold system depending on your resources (system memory, '
+        f'GPU memory).')
+  return clean_sequence
+
+
+def clean_and_validate_input_sequences(
+    input_sequences: Sequence[str],
+    min_sequence_length: int,
+    max_sequence_length: int) -> Sequence[str]:
+  """"""Validates and cleans input sequences.""""""
+  sequences = []
+
+  for input_sequence in input_sequences:
+    if input_sequence.strip():
+      input_sequence = clean_and_validate_single_sequence(
+          input_sequence=input_sequence,
+          min_length=min_sequence_length,
+          max_length=max_sequence_length)
+      sequences.append(input_sequence)
+
+  if sequences:
+    return sequences
+  else:
+    raise ValueError('No input amino acid sequence provided, please provide at '
+                     'least one sequence.')
+
+
+def merge_chunked_msa(
+    results: Sequence[Mapping[str, Any]],
+    max_hits: Optional[int] = None
+    ) -> parsers.Msa:
+  """"""Merges chunked database hits together into hits for the full database.""""""
+  unsorted_results = []
+  for chunk_index, chunk in enumerate(results):
+    msa = parsers.parse_stockholm(chunk['sto'])
+    e_values_dict = parsers.parse_e_values_from_tblout(chunk['tbl'])
+    # Jackhmmer lists sequences as <sequence name>/<residue from>-<residue to>.
+    e_values = [e_values_dict[t.partition('/')[0]] for t in msa.descriptions]
+    chunk_results = zip(
+        msa.sequences, msa.deletion_matrix, msa.descriptions, e_values)
+    if chunk_index != 0:
+      next(chunk_results)  # Only take query (first hit) from the first chunk.
+    unsorted_results.extend(chunk_results)
+
+  sorted_by_evalue = sorted(unsorted_results, key=lambda x: x[-1])
+  merged_sequences, merged_deletion_matrix, merged_descriptions, _ = zip(
+      *sorted_by_evalue)
+  merged_msa = parsers.Msa(sequences=merged_sequences,
+                           deletion_matrix=merged_deletion_matrix,
+                           descriptions=merged_descriptions)
+  if max_hits is not None:
+    merged_msa = merged_msa.truncate(max_seqs=max_hits)
+
+  return merged_msa
+
+
+def show_msa_info(
+    single_chain_msas: Sequence[parsers.Msa],
+    sequence_index: int):
+  """"""Prints info and shows a plot of the deduplicated single chain MSA.""""""
+  full_single_chain_msa = []
+  for single_chain_msa in single_chain_msas:
+    full_single_chain_msa.extend(single_chain_msa.sequences)
+
+  # Deduplicate but preserve order (hence can't use set).
+  deduped_full_single_chain_msa = list(dict.fromkeys(full_single_chain_msa))
+  total_msa_size = len(deduped_full_single_chain_msa)
+  print(f'\n{total_msa_size} unique sequences found in total for sequence '
+        f'{sequence_index}\n')
+
+  aa_map = {res: i for i, res in enumerate('ABCDEFGHIJKLMNOPQRSTUVWXYZ-')}
+  msa_arr = np.array(
+      [[aa_map[aa] for aa in seq] for seq in deduped_full_single_chain_msa])
+
+  plt.figure(figsize=(12, 3))
+  plt.title(f'Per-Residue Count of Non-Gap Amino Acids in the MSA for Sequence '
+            f'{sequence_index}')
+  plt.plot(np.sum(msa_arr != aa_map['-'], axis=0), color='black')
+  plt.ylabel('Non-Gap Count')
+  plt.yticks(range(0, total_msa_size + 1, max(1, int(total_msa_size / 3))))
+  plt.show()
+
+
+def empty_placeholder_template_features(
+    num_templates: int, num_res: int) -> Mapping[str, np.ndarray]:
+  return {
+      'template_aatype': np.zeros(
+          (num_templates, num_res,
+           len(residue_constants.restypes_with_x_and_gap)), dtype=np.float32),
+      'template_all_atom_masks': np.zeros(
+          (num_templates, num_res, residue_constants.atom_type_num),
+          dtype=np.float32),
+      'template_all_atom_positions': np.zeros(
+          (num_templates, num_res, residue_constants.atom_type_num, 3),
+          dtype=np.float32),
+      'template_domain_names': np.zeros([num_templates], dtype=object),
+      'template_sequence': np.zeros([num_templates], dtype=object),
+      'template_sum_probs': np.zeros([num_templates], dtype=np.float32),
+  }
+
+
+def get_pae_json(pae: np.ndarray, max_pae: float) -> str:
+  """"""Returns the PAE in the same format as is used in the AFDB.
+
+  Note that the values are presented as floats to 1 decimal place,
+  whereas AFDB returns integer values.
+
+  Args:
+    pae: The n_res x n_res PAE array.
+    max_pae: The maximum possible PAE value.
+  Returns:
+    PAE output format as a JSON string.
+  """"""
+  # Check the PAE array is the correct shape.
+  if (pae.ndim != 2 or pae.shape[0] != pae.shape[1]):
+    raise ValueError(f'PAE must be a square matrix, got {pae.shape}')
+
+  # Round the predicted aligned errors to 1 decimal place.
+  rounded_errors = np.round(pae.astype(np.float64), decimals=1)
+  formatted_output = [{
+      'predicted_aligned_error': rounded_errors.tolist(),
+      'max_predicted_aligned_error': max_pae
+  }]
+  return json.dumps(formatted_output, indent=None, separators=(',', ':'))
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/notebooks/__init__.py",".py","626","15","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""AlphaFold Colab notebook.""""""
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/notebooks/notebook_utils_test.py",".py","9107","197","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Tests for notebook_utils.""""""
+import io
+
+from absl.testing import absltest
+from absl.testing import parameterized
+from alphafold.data import parsers
+from alphafold.data import templates
+from alphafold.notebooks import notebook_utils
+
+import mock
+import numpy as np
+
+
+ONLY_QUERY_HIT = {
+    'sto': (
+        '# STOCKHOLM 1.0\n'
+        '#=GF ID query-i1\n'
+        'query   MAAHKGAEHHHKAAEHHEQAAKHHHAAAEHHEKGEHEQAAHHADTAYAHHKHAEEH\n'
+        '//\n'),
+    'tbl': '',
+    'stderr': b'',
+    'n_iter': 1,
+    'e_value': 0.0001}
+
+# pylint: disable=line-too-long
+MULTI_SEQUENCE_HIT_1 = {
+    'sto': (
+        '# STOCKHOLM 1.0\n'
+        '#=GF ID query-i1\n'
+        '#=GS ERR1700680_4602609/41-109  DE [subseq from] ERR1700680_4602609\n'
+        '#=GS ERR1019366_5760491/40-105  DE [subseq from] ERR1019366_5760491\n'
+        '#=GS SRR5580704_12853319/61-125 DE [subseq from] SRR5580704_12853319\n'
+        'query                              MAAHKGAEHHHKAAEHHEQAAKHHHAAAEHHEKGEHEQAAHHADTAYAHHKHAEEHAAQAAKHDAEHHAPKPH\n'
+        'ERR1700680_4602609/41-109          --INKGAEYHKKAAEHHELAAKHHREAAKHHEAGSHEKAAHHSEIAAGHGLTAVHHTEEATK-HHPEEHTEK--\n'
+        'ERR1019366_5760491/40-105          ---RSGAQHHDAAAQHYEEAARHHRMAAKQYQASHHEKAAHYAQLAYAHHMYAEQHAAEAAK-AHAKNHG----\n'
+        'SRR5580704_12853319/61-125         ----PAADHHMKAAEHHEEAAKHHRAAAEHHTAGDHQKAGHHAHVANGHHVNAVHHAEEASK-HHATDHS----\n'
+        '//\n'),
+    'tbl': (
+        'ERR1700680_4602609   -          query                -            7.7e-09   47.7  33.8   1.1e-08   47.2  33.8   1.2   1   0   0   1   1   1   1 -\n'
+        'ERR1019366_5760491   -          query                -            1.7e-08   46.6  33.1   2.5e-08   46.1  33.1   1.3   1   0   0   1   1   1   1 -\n'
+        'SRR5580704_12853319  -          query                -            1.1e-07   44.0  41.6     2e-07   43.1  41.6   1.4   1   0   0   1   1   1   1 -\n'),
+        'stderr': b'',
+        'n_iter': 1,
+        'e_value': 0.0001}
+
+MULTI_SEQUENCE_HIT_2 = {
+    'sto': (
+        '# STOCKHOLM 1.0\n'
+        '#=GF ID query-i1\n'
+        '#=GS ERR1700719_3476944/70-137  DE [subseq from] ERR1700719_3476944\n'
+        '#=GS ERR1700761_4254522/72-138  DE [subseq from] ERR1700761_4254522\n'
+        '#=GS SRR5438477_9761204/64-132  DE [subseq from] SRR5438477_9761204\n'
+        'query                              MAAHKGAEHHHKAAEHHEQAAKHHHAAAEHHEKGEHEQAAHHADTAYAHHKHAEEHAAQAAKHDAEHHAPKPH\n'
+        'ERR1700719_3476944/70-137          ---KQAAEHHHQAAEHHEHAARHHREAAKHHEAGDHESAAHHAHTAQGHLHQATHHASEAAKLHVEHHGQK--\n'
+        'ERR1700761_4254522/72-138          ----QASEHHNLAAEHHEHAARHHRDAAKHHKAGDHEKAAHHAHVAHGHHLHATHHATEAAKHHVEAHGEK--\n'
+        'SRR5438477_9761204/64-132          MPKHEGAEHHKKAAEHNEHAARHHKEAARHHEEGSHEKVGHHAHIAHGHHLHATHHAEEAAKTHSNQHE----\n'
+        '//\n'),
+    'tbl': (
+        'ERR1700719_3476944   -          query                -              2e-07   43.2  47.5   3.5e-07   42.4  47.5   1.4   1   0   0   1   1   1   1 -\n'
+        'ERR1700761_4254522   -          query                -            6.1e-07   41.6  48.1   8.1e-07   41.3  48.1   1.2   1   0   0   1   1   1   1 -\n'
+        'SRR5438477_9761204   -          query                -            1.8e-06   40.2  46.9   2.3e-06   39.8  46.9   1.2   1   0   0   1   1   1   1 -\n'),
+        'stderr': b'',
+        'n_iter': 1,
+        'e_value': 0.0001}
+# pylint: enable=line-too-long
+
+
+class NotebookUtilsTest(parameterized.TestCase):
+
+  @parameterized.parameters(
+      ('DeepMind', 'DEEPMIND'), ('A ', 'A'), ('\tA', 'A'), (' A\t\n', 'A'),
+      ('ACDEFGHIKLMNPQRSTVWY', 'ACDEFGHIKLMNPQRSTVWY'))
+  def test_clean_and_validate_sequence_ok(self, sequence, exp_clean):
+    clean = notebook_utils.clean_and_validate_single_sequence(
+        sequence, min_length=1, max_length=100)
+    self.assertEqual(clean, exp_clean)
+
+  @parameterized.named_parameters(
+      ('too_short', 'AA', 'too short'),
+      ('too_long', 'AAAAAAAAAA', 'too long'),
+      ('bad_amino_acids_B', 'BBBB', 'non-amino acid'),
+      ('bad_amino_acids_J', 'JJJJ', 'non-amino acid'),
+      ('bad_amino_acids_O', 'OOOO', 'non-amino acid'),
+      ('bad_amino_acids_U', 'UUUU', 'non-amino acid'),
+      ('bad_amino_acids_X', 'XXXX', 'non-amino acid'),
+      ('bad_amino_acids_Z', 'ZZZZ', 'non-amino acid'))
+  def test_clean_and_validate_sequence_bad(self, sequence, exp_error):
+    with self.assertRaisesRegex(ValueError, f'.*{exp_error}.*'):
+      notebook_utils.clean_and_validate_single_sequence(
+          sequence, min_length=4, max_length=8)
+
+  @parameterized.parameters(
+      (['A', '', '', ' ', '\t', ' \t\n', '', ''], ['A']),
+      (['', 'A'], ['A']),
+      (['A', 'C ', ''], ['A', 'C']),
+      (['', 'A', '', 'C '], ['A', 'C']))
+  def test_validate_input_ok(self, input_sequences, exp_sequences):
+    sequences = notebook_utils.clean_and_validate_input_sequences(
+        input_sequences=input_sequences,
+        min_sequence_length=1, max_sequence_length=100)
+    self.assertSequenceEqual(sequences, exp_sequences)
+
+  @parameterized.named_parameters(
+      ('no_input_sequence', ['', '\t', '\n'], 'No input amino acid sequence'),
+      ('too_long_single', ['AAAAAAAAA', 'AAAA'], 'Input sequence is too long'),
+      ('too_short_single', ['AAA', 'AAAA'], 'Input sequence is too short'))
+  def test_validate_input_bad(self, input_sequences, exp_error):
+    with self.assertRaisesRegex(ValueError, f'.*{exp_error}.*'):
+      notebook_utils.clean_and_validate_input_sequences(
+          input_sequences=input_sequences, min_sequence_length=4,
+          max_sequence_length=8)
+
+  def test_merge_chunked_msa_no_hits(self):
+    results = [ONLY_QUERY_HIT, ONLY_QUERY_HIT]
+    merged_msa = notebook_utils.merge_chunked_msa(
+        results=results)
+    self.assertSequenceEqual(
+        merged_msa.sequences,
+        ('MAAHKGAEHHHKAAEHHEQAAKHHHAAAEHHEKGEHEQAAHHADTAYAHHKHAEEH',))
+    self.assertSequenceEqual(merged_msa.deletion_matrix, ([0] * 56,))
+
+  def test_merge_chunked_msa(self):
+    results = [MULTI_SEQUENCE_HIT_1, MULTI_SEQUENCE_HIT_2]
+    merged_msa = notebook_utils.merge_chunked_msa(
+        results=results)
+    self.assertLen(merged_msa.sequences, 7)
+    # The 1st one is the query.
+    self.assertEqual(
+        merged_msa.sequences[0],
+        'MAAHKGAEHHHKAAEHHEQAAKHHHAAAEHHEKGEHEQAAHHADTAYAHHKHAEEHAAQAAKHDAEHHAP'
+        'KPH')
+    # The 2nd one is the one with the lowest e-value: ERR1700680_4602609.
+    self.assertEqual(
+        merged_msa.sequences[1],
+        '--INKGAEYHKKAAEHHELAAKHHREAAKHHEAGSHEKAAHHSEIAAGHGLTAVHHTEEATK-HHPEEHT'
+        'EK-')
+    # The last one is the one with the largest e-value: SRR5438477_9761204.
+    self.assertEqual(
+        merged_msa.sequences[-1],
+        'MPKHEGAEHHKKAAEHNEHAARHHKEAARHHEEGSHEKVGHHAHIAHGHHLHATHHAEEAAKTHSNQHE-'
+        '---')
+    self.assertLen(merged_msa.deletion_matrix, 7)
+
+  @mock.patch('sys.stdout', new_callable=io.StringIO)
+  def test_show_msa_info(self, mocked_stdout):
+    single_chain_msas = [
+        parsers.Msa(sequences=['A', 'B', 'C', 'C'],
+                    deletion_matrix=[None] * 4,
+                    descriptions=[''] * 4),
+        parsers.Msa(sequences=['A', 'A', 'A', 'D'],
+                    deletion_matrix=[None] * 4,
+                    descriptions=[''] * 4)
+    ]
+    notebook_utils.show_msa_info(
+        single_chain_msas=single_chain_msas, sequence_index=1)
+    self.assertEqual(mocked_stdout.getvalue(),
+                     '\n4 unique sequences found in total for sequence 1\n\n')
+
+  @parameterized.named_parameters(
+      ('some_templates', 4), ('no_templates', 0))
+  def test_empty_placeholder_template_features(self, num_templates):
+    template_features = notebook_utils.empty_placeholder_template_features(
+        num_templates=num_templates, num_res=16)
+    self.assertCountEqual(template_features.keys(),
+                          templates.TEMPLATE_FEATURES.keys())
+    self.assertSameElements(
+        [v.shape[0] for v in template_features.values()], [num_templates])
+    self.assertSequenceEqual(
+        [t.dtype for t in template_features.values()],
+        [np.array([], dtype=templates.TEMPLATE_FEATURES[feat_name]).dtype
+         for feat_name in template_features])
+
+  def test_get_pae_json(self):
+    pae = np.array([[0.01, 13.12345], [20.0987, 0.0]])
+    pae_json = notebook_utils.get_pae_json(pae=pae, max_pae=31.75)
+    self.assertEqual(
+        pae_json, '[{""predicted_aligned_error"":[[0.0,13.1],[20.1,0.0]],'
+        '""max_predicted_aligned_error"":31.75}]')
+
+
+if __name__ == '__main__':
+  absltest.main()
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/pipeline_custom_templates.py",".py","19376","444","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Functions for building the input features for the AlphaFold model.""""""
+
+import os
+import pandas as pd
+from typing import Any, Mapping, MutableMapping, Optional, Sequence, Union
+from absl import logging
+from alphafold.common import residue_constants
+from alphafold.data import msa_identifiers
+from alphafold.data import parsers
+from alphafold.data import templates
+from alphafold.data.tools import hhblits
+from alphafold.data.tools import hhsearch
+from alphafold.data.tools import hmmsearch
+from alphafold.data.tools import jackhmmer
+import numpy as np
+from alphafold.data.custom_templates import create_single_template_features, compile_template_features, mk_mock_template
+import tree
+
+# Internal import (7716).
+
+FeatureDict = MutableMapping[str, np.ndarray]
+TemplateSearcher = Union[hhsearch.HHSearch, hmmsearch.Hmmsearch]
+
+
+def make_sequence_features(
+    sequence: str, description: str, num_res: int) -> FeatureDict:
+  """"""Constructs a feature dict of sequence features.""""""
+  features = {}
+  features['aatype'] = residue_constants.sequence_to_onehot(
+      sequence=sequence,
+      mapping=residue_constants.restype_order_with_x,
+      map_unknown_to_x=True)
+  features['between_segment_residues'] = np.zeros((num_res,), dtype=np.int32)
+  features['domain_name'] = np.array([description.encode('utf-8')],
+                                     dtype=np.object_)
+  features['residue_index'] = np.array(range(num_res), dtype=np.int32)
+  features['seq_length'] = np.array([num_res] * num_res, dtype=np.int32)
+  features['sequence'] = np.array([sequence.encode('utf-8')], dtype=np.object_)
+  return features
+
+def make_mock_msa_features(msas) -> FeatureDict:
+  """"""Constructs a empty feature dict of MSA features.""""""
+  num_res = len(msas[0])
+  deletion_matrices = [[0] * len(msas[0])]
+  deletion_matrix = []
+  int_msa = []
+  species_ids = []
+  seen_sequences = set()
+  for sequence_index, sequence in enumerate(msas):
+    # for sequence_index, sequence in enumerate(msa):
+      # if sequence in seen_sequences:
+      #   continue
+      # seen_sequences.add(sequence)
+    int_msa.append(
+        [residue_constants.HHBLITS_AA_TO_ID[res] for res in sequence])
+    deletion_matrix.append(deletion_matrices[sequence_index])
+    species_ids.append("""".encode('utf-8'))
+
+  num_alignments = len(int_msa)
+  features = {}
+  features['deletion_matrix_int'] = np.array(deletion_matrix, dtype=np.int32)
+  features['msa'] = np.array(int_msa, dtype=np.int32)
+  features['num_alignments'] = np.array(
+      [num_alignments] * num_res, dtype=np.int32)
+  features['msa_species_identifiers'] = np.array(species_ids, dtype=np.object_)
+  return features
+
+def make_msa_features(msas: Sequence[parsers.Msa]) -> FeatureDict:
+  """"""Constructs a feature dict of MSA features.""""""
+  if not msas:
+    raise ValueError('At least one MSA must be provided.')
+
+  int_msa = []
+  deletion_matrix = []
+  species_ids = []
+  seen_sequences = set()
+  try:
+    for msa_index, msa in enumerate(msas):
+      if not msa:
+        raise ValueError(f'MSA {msa_index} must contain at least one sequence.')
+      for sequence_index, sequence in enumerate(msa.sequences):
+        if sequence in seen_sequences:
+          continue
+        seen_sequences.add(sequence)
+        int_msa.append(
+            [residue_constants.HHBLITS_AA_TO_ID[res] for res in sequence])
+        deletion_matrix.append(msa.deletion_matrix[sequence_index])
+        identifiers = msa_identifiers.get_identifiers(
+            msa.descriptions[sequence_index])
+        species_ids.append(identifiers.species_id.encode('utf-8'))
+    num_res = len(msas[0].sequences[0])
+  except:
+    msa=msas
+    for sequence_index, sequence in enumerate(msa.sequences):
+      if sequence in seen_sequences:
+        continue
+      seen_sequences.add(sequence)
+      int_msa.append(
+          [residue_constants.HHBLITS_AA_TO_ID[res] for res in sequence])
+      deletion_matrix.append(msa.deletion_matrix[sequence_index])
+      identifiers = msa_identifiers.get_identifiers(
+          msa.descriptions[sequence_index])
+      species_ids.append(identifiers.species_id.encode('utf-8'))
+    num_res = len(msas.sequences[0])
+
+  num_alignments = len(int_msa)
+  features = {}
+  features['deletion_matrix_int'] = np.array(deletion_matrix, dtype=np.int32)
+  features['msa'] = np.array(int_msa, dtype=np.int32)
+  features['num_alignments'] = np.array(
+      [num_alignments] * num_res, dtype=np.int32)
+  features['msa_species_identifiers'] = np.array(species_ids, dtype=np.object_)
+  return features
+
+
+def run_msa_tool(msa_runner, input_fasta_path: str, msa_out_path: str,
+                 msa_format: str, use_precomputed_msas: bool,
+                 max_sto_sequences: Optional[int] = None
+                 ) -> Mapping[str, Any]:
+  """"""Runs an MSA tool, checking if output already exists first.""""""
+  if not use_precomputed_msas or not os.path.exists(msa_out_path):
+    if msa_format == 'sto' and max_sto_sequences is not None:
+      result = msa_runner.query(input_fasta_path, max_sto_sequences)[0]  # pytype: disable=wrong-arg-count
+    else:
+      result = msa_runner.query(input_fasta_path)[0]
+    with open(msa_out_path, 'w') as f:
+      f.write(result[msa_format])
+  else:
+    logging.warning('Reading MSA from file %s', msa_out_path)
+    if msa_format == 'sto' and max_sto_sequences is not None:
+      precomputed_msa = parsers.truncate_stockholm_msa(
+          msa_out_path, max_sto_sequences)
+      result = {'sto': precomputed_msa}
+    else:
+      with open(msa_out_path, 'r') as f:
+        result = {msa_format: f.read()}
+  return result
+
+
+class DataPipeline:
+  """"""Runs the alignment tools and assembles the input features.""""""
+
+  def __init__(self,
+               jackhmmer_binary_path: str,
+               hhblits_binary_path: str,
+               uniref90_database_path: str,
+               mgnify_database_path: str,
+               bfd_database_path: Optional[str],
+               uniref30_database_path: Optional[str],
+               small_bfd_database_path: Optional[str],
+               template_searcher: TemplateSearcher,
+               template_featurizer: templates.TemplateHitFeaturizer,
+               use_small_bfd: bool,
+               mgnify_max_hits: int = 501,
+               uniref_max_hits: int = 10000,
+               use_precomputed_msas: bool = False):
+    """"""Initializes the data pipeline.""""""
+    self._use_small_bfd = use_small_bfd
+    self.jackhmmer_binary_path=jackhmmer_binary_path
+    self.jackhmmer_uniref90_runner = jackhmmer.Jackhmmer(
+        binary_path=jackhmmer_binary_path,
+        database_path=uniref90_database_path)
+    if use_small_bfd:
+      self.jackhmmer_small_bfd_runner = jackhmmer.Jackhmmer(
+          binary_path=jackhmmer_binary_path,
+          database_path=small_bfd_database_path)
+    else:
+      self.hhblits_bfd_uniref_runner = hhblits.HHBlits(
+          binary_path=hhblits_binary_path,
+          databases=[bfd_database_path, uniref30_database_path])
+    self.jackhmmer_mgnify_runner = jackhmmer.Jackhmmer(
+        binary_path=jackhmmer_binary_path,
+        database_path=mgnify_database_path)
+    self.template_searcher = template_searcher
+    self.template_featurizer = template_featurizer
+    self.mgnify_max_hits = mgnify_max_hits
+    self.uniref_max_hits = uniref_max_hits
+    self.use_precomputed_msas = use_precomputed_msas
+
+  def custom_MSA_features(self,
+                      MSA_database: str,
+                      input_fasta_path: str,
+                      msa_output_dir: str):
+    custom_MSA_runner = jackhmmer.Jackhmmer(
+      binary_path=self.jackhmmer_binary_path,
+      database_path=MSA_database)
+    custom_MSA_out_path = os.path.join(msa_output_dir, 'custom_MSA.sto')
+    custom_MSA_result = run_msa_tool(
+        msa_runner=custom_MSA_runner,
+        input_fasta_path=input_fasta_path,
+        msa_out_path=custom_MSA_out_path,
+        msa_format='sto',
+        use_precomputed_msas=self.use_precomputed_msas,
+        max_sto_sequences=self.uniref_max_hits)
+    custom_msa = parsers.parse_stockholm(custom_MSA_result['sto'])
+    logging.info('Custom MSA size: %d sequences.', len(custom_msa))
+
+    return custom_msa
+  
+  def msa_for_default_template(self,
+                                input_fasta_path: str,
+                                msa_output_dir: str):
+    uniref90_out_path = os.path.join(msa_output_dir, 'uniref90_hits.sto')
+    jackhmmer_uniref90_result = run_msa_tool(
+        msa_runner=self.jackhmmer_uniref90_runner,
+        input_fasta_path=input_fasta_path,
+        msa_out_path=uniref90_out_path,
+        msa_format='sto',
+        use_precomputed_msas=self.use_precomputed_msas,
+        max_sto_sequences=self.uniref_max_hits)
+    uniref90_msa = parsers.parse_stockholm(jackhmmer_uniref90_result['sto'])      
+    logging.info('Uniref90 MSA size: %d sequences. This is for templates, '
+                'not MSA construction)', len(uniref90_msa))
+    return jackhmmer_uniref90_result,uniref90_msa
+
+  def process(self, 
+              input_fasta_path: str,
+              msa_output_dir: str, 
+              use_custom_templates: bool,
+              template_alignfile: str, 
+              msa_mode: str,
+              use_custom_MSA_database: str,
+              MSA_database: str,
+              save_msa_fasta: bool,
+              save_template_names: bool,
+              msa_for_template_query_seq_only: bool) -> FeatureDict:
+    """"""Runs alignment tools on the input sequence and creates features.""""""
+    with open(input_fasta_path) as f:
+      input_fasta_str = f.read()
+    # print(input_fasta_str)
+    input_seqs, input_descs = parsers.parse_fasta(input_fasta_str)
+    # print(""length of input_seqs is %d:"" % len(input_seqs[0]))
+    # if len(input_seqs) != 1:
+    #   raise ValueError(
+    #       f'More than one input sequence found in {input_fasta_path}.')
+    input_sequence = """".join(input_seqs[0])
+    logging.info(""input_sequence is %s"" % input_sequence)
+    input_description = input_descs[0]
+    num_res = len(input_sequence)
+
+    ###########################################################
+    ## MSA
+    ###########################################################
+
+    # if MSA used:
+    if msa_mode!=""single_sequence"":
+      if use_custom_MSA_database==""only"":
+        # custom MSA 
+        custom_msa=DataPipeline.custom_MSA_features(self,MSA_database,input_fasta_path,msa_output_dir)
+        msa_features = make_msa_features((custom_msa))
+        if template_alignfile==""UseDefaultTemplate"": 
+          jackhmmer_uniref90_result,uniref90_msa=DataPipeline.msa_for_default_template(self,input_fasta_path,msa_output_dir)
+      else:
+        # default MSA
+        uniref90_out_path = os.path.join(msa_output_dir, 'uniref90_hits.sto')
+        jackhmmer_uniref90_result = run_msa_tool(
+            msa_runner=self.jackhmmer_uniref90_runner,
+            input_fasta_path=input_fasta_path,
+            msa_out_path=uniref90_out_path,
+            msa_format='sto',
+            use_precomputed_msas=self.use_precomputed_msas,
+            max_sto_sequences=self.uniref_max_hits)
+        mgnify_out_path = os.path.join(msa_output_dir, 'mgnify_hits.sto')
+        jackhmmer_mgnify_result = run_msa_tool(
+            msa_runner=self.jackhmmer_mgnify_runner,
+            input_fasta_path=input_fasta_path,
+            msa_out_path=mgnify_out_path,
+            msa_format='sto',
+            use_precomputed_msas=self.use_precomputed_msas,
+            max_sto_sequences=self.mgnify_max_hits)
+
+        uniref90_msa = parsers.parse_stockholm(jackhmmer_uniref90_result['sto'])
+        mgnify_msa = parsers.parse_stockholm(jackhmmer_mgnify_result['sto'])
+
+
+        if self._use_small_bfd:
+          bfd_out_path = os.path.join(msa_output_dir, 'small_bfd_hits.sto')
+          jackhmmer_small_bfd_result = run_msa_tool(
+              msa_runner=self.jackhmmer_small_bfd_runner,
+              input_fasta_path=input_fasta_path,
+              msa_out_path=bfd_out_path,
+              msa_format='sto',
+              use_precomputed_msas=self.use_precomputed_msas)
+          bfd_msa = parsers.parse_stockholm(jackhmmer_small_bfd_result['sto'])
+        else:
+          bfd_out_path = os.path.join(msa_output_dir, 'bfd_uniclust_hits.a3m')
+          hhblits_bfd_uniclust_result = run_msa_tool(
+              msa_runner=self.hhblits_bfd_uniref_runner,
+              input_fasta_path=input_fasta_path,
+              msa_out_path=bfd_out_path,
+              msa_format='a3m',
+              use_precomputed_msas=self.use_precomputed_msas)
+          bfd_msa = parsers.parse_a3m(hhblits_bfd_uniclust_result['a3m'])
+
+        if use_custom_MSA_database==""add"":
+          custom_msa=DataPipeline.custom_MSA_features(self,MSA_database,input_fasta_path,msa_output_dir)
+          msa_features = make_msa_features((uniref90_msa, bfd_msa, mgnify_msa, custom_msa))
+        else:
+          msa_features = make_msa_features((uniref90_msa, bfd_msa, mgnify_msa))
+
+        logging.info('Uniref90 MSA size: %d sequences.', len(uniref90_msa))
+        logging.info('BFD MSA size: %d sequences.', len(bfd_msa))
+        logging.info('MGnify MSA size: %d sequences.', len(mgnify_msa))
+
+    # if single sequence yet use default template
+    elif template_alignfile==""UseDefaultTemplate"": 
+      jackhmmer_uniref90_result,uniref90_msa=DataPipeline.msa_for_default_template(self,input_fasta_path,msa_output_dir)
+      msas=[input_sequence]
+      msa_features = make_mock_msa_features(msas)
+      
+    # if single sequence and not use default template 
+    else:
+      msas=[input_sequence]
+      msa_features = make_mock_msa_features(msas)
+
+    if save_msa_fasta:
+      msa_outpath=os.path.join(msa_output_dir, 'msa_feat_gaptoU.fasta')
+      with open(msa_outpath, 'w+') as fh:
+        fh.write("">query""+""\n""+input_sequence+""\n"")
+        counter=1
+        for seq in msa_features['msa']:
+            seq=[residue_constants.ID_TO_HHBLITS_AA[num] for num in seq]
+            # for x in range(len(seq)):
+            counter+=1
+            fh.write("">seq_""+str(counter)+""\n"")
+            out="""".join(seq).replace(""-"",""U"")
+            fh.write(out+""\n"")
+                
+    ###########################################################
+    ## Template
+    ###########################################################
+    # if defaullt template should be used 
+    if (not use_custom_templates) or (use_custom_templates and template_alignfile==""UseDefaultTemplate""):
+      msa_for_templates = jackhmmer_uniref90_result['sto']
+      msa_for_templates = parsers.deduplicate_stockholm_msa(msa_for_templates)
+      msa_for_templates = parsers.remove_empty_columns_from_stockholm_msa(
+          msa_for_templates)
+      if msa_for_template_query_seq_only:
+        '''BP 12/15/22 let's just keep the target (query) sequence'''
+        msa_for_templates = parsers.truncate_stockholm_msa2(msa_for_templates, 1)
+
+      if self.template_searcher.input_format == 'sto':
+        pdb_templates_result = self.template_searcher.query(msa_for_templates)
+      elif self.template_searcher.input_format == 'a3m':
+        uniref90_msa_as_a3m = parsers.convert_stockholm_to_a3m(msa_for_templates)
+        pdb_templates_result = self.template_searcher.query(uniref90_msa_as_a3m)
+      else:
+        raise ValueError('Unrecognized template input format: '
+                        f'{self.template_searcher.input_format}')
+
+      pdb_hits_out_path = os.path.join(
+          msa_output_dir, f'pdb_hits.{self.template_searcher.output_format}')
+      with open(pdb_hits_out_path, 'w') as f:
+        f.write(pdb_templates_result)
+
+      pdb_template_hits = self.template_searcher.get_template_hits(
+          output_string=pdb_templates_result, input_sequence=input_sequence)
+          
+      templates_result = self.template_featurizer.get_templates(
+      query_sequence=input_sequence,
+      hits=pdb_template_hits)
+
+    #if user defined template used
+    else:
+      #############################################
+      #update the templates
+      if len(template_alignfile)==0:
+        templates_result=mk_mock_template(input_sequence)
+        # print(templates_result.features['template_domain_names'])
+      else:
+        data = pd.read_table(template_alignfile)
+        # cols = ('template_pdbfile target_to_template_alignstring identities '
+        #         'target_len template_len'.split())
+        template_features_list = []
+        for tnum, row in data.iterrows():
+            target_to_template_alignment = {
+                int(x.split(':')[0]) : int(x.split(':')[1]) # 0-indexed
+                for x in row.target_to_template_alignstring.split(';')
+            }
+
+            template_name = os.path.basename(row.template_pdbfile).split(""."")[0]
+            template_features = create_single_template_features(
+                input_sequence, row.template_pdbfile, target_to_template_alignment,
+                template_name, allow_chainbreaks=True, allow_skipped_lines=True,
+                expected_identities = None,
+                expected_template_len = row.template_len,
+            )
+            template_features_list.append(template_features)
+
+        templates_result = compile_template_features(
+            template_features_list)
+
+      #############################################
+
+
+    sequence_features = make_sequence_features(
+        sequence=input_sequence,
+        description=input_description,
+        num_res=num_res)
+
+    # if len(input_seqs[0]) > 1:
+    if isinstance(input_seqs[0], list):
+      # print(""There are %d semi-colon seperated chains in this chain. Therefore updating the residue_index now"" % len(input_seqs[0]))
+      # Minkyung's code
+      # add big enough number to residue index to indicate chain breaks
+      idx_res = sequence_features['residue_index']
+      Ls=[len(seq) for seq in input_seqs[0]]
+      L_prev = 0
+      # Ls: number of residues in each chain
+      for L_i in Ls[:-1]:
+          idx_res[L_prev + L_i:] += 200
+          L_prev += L_i
+      # chains = list("""".join([ascii_uppercase[n] * L for n, L in enumerate(Ls)]))
+      sequence_features['residue_index'] = idx_res
+
+    logging.info('Final (deduplicated) MSA size: %d sequences.',
+                 msa_features['num_alignments'][0])
+    logging.info('Total number of templates (NB: this can include bad '
+                 'templates and is later filtered to top 4, and mock/no '
+                 'templates would also show number of templates as 1): %d.',
+                 templates_result.features['template_domain_names'].shape[0])
+
+    if save_template_names:
+      temp_name_fn=os.path.join(msa_output_dir, 'template_names.txt')
+      template_names=[name.decode('utf-8') for name in templates_result.features['template_domain_names']]
+      with open(temp_name_fn, 'w+') as fh:
+          fh.write(""\n"".join(template_names))
+          
+    return {**sequence_features, **msa_features, **templates_result.features}
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/pipeline_multimer.py",".py","11696","297","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Functions for building the features for the AlphaFold multimer model.""""""
+
+import collections
+import contextlib
+import copy
+import dataclasses
+import json
+import os
+import tempfile
+from typing import Mapping, MutableMapping, Sequence
+
+from absl import logging
+from alphafold.common import protein
+from alphafold.common import residue_constants
+from alphafold.data import feature_processing
+from alphafold.data import msa_pairing
+from alphafold.data import parsers
+from alphafold.data import pipeline
+from alphafold.data.tools import jackhmmer
+import numpy as np
+
+# Internal import (7716).
+
+
+@dataclasses.dataclass(frozen=True)
+class _FastaChain:
+  sequence: str
+  description: str
+
+
+def _make_chain_id_map(*,
+                       sequences: Sequence[str],
+                       descriptions: Sequence[str],
+                       ) -> Mapping[str, _FastaChain]:
+  """"""Makes a mapping from PDB-format chain ID to sequence and description.""""""
+  if len(sequences) != len(descriptions):
+    raise ValueError('sequences and descriptions must have equal length. '
+                     f'Got {len(sequences)} != {len(descriptions)}.')
+  if len(sequences) > protein.PDB_MAX_CHAINS:
+    raise ValueError('Cannot process more chains than the PDB format supports. '
+                     f'Got {len(sequences)} chains.')
+  chain_id_map = {}
+  for chain_id, sequence, description in zip(
+      protein.PDB_CHAIN_IDS, sequences, descriptions):
+    chain_id_map[chain_id] = _FastaChain(
+        sequence=sequence, description=description)
+  return chain_id_map
+
+
+@contextlib.contextmanager
+def temp_fasta_file(fasta_str: str):
+  with tempfile.NamedTemporaryFile('w', suffix='.fasta') as fasta_file:
+    fasta_file.write(fasta_str)
+    fasta_file.seek(0)
+    yield fasta_file.name
+
+
+def convert_monomer_features(
+    monomer_features: pipeline.FeatureDict,
+    chain_id: str) -> pipeline.FeatureDict:
+  """"""Reshapes and modifies monomer features for multimer models.""""""
+  converted = {}
+  converted['auth_chain_id'] = np.asarray(chain_id, dtype=np.object_)
+  unnecessary_leading_dim_feats = {
+      'sequence', 'domain_name', 'num_alignments', 'seq_length'}
+  for feature_name, feature in monomer_features.items():
+    if feature_name in unnecessary_leading_dim_feats:
+      # asarray ensures it's a np.ndarray.
+      feature = np.asarray(feature[0], dtype=feature.dtype)
+    elif feature_name == 'aatype':
+      # The multimer model performs the one-hot operation itself.
+      feature = np.argmax(feature, axis=-1).astype(np.int32)
+    elif feature_name == 'template_aatype':
+      feature = np.argmax(feature, axis=-1).astype(np.int32)
+      new_order_list = residue_constants.MAP_HHBLITS_AATYPE_TO_OUR_AATYPE
+      feature = np.take(new_order_list, feature.astype(np.int32), axis=0)
+    elif feature_name == 'template_all_atom_masks':
+      feature_name = 'template_all_atom_mask'
+    converted[feature_name] = feature
+  return converted
+
+
+def int_id_to_str_id(num: int) -> str:
+  """"""Encodes a number as a string, using reverse spreadsheet style naming.
+
+  Args:
+    num: A positive integer.
+
+  Returns:
+    A string that encodes the positive integer using reverse spreadsheet style,
+    naming e.g. 1 = A, 2 = B, ..., 27 = AA, 28 = BA, 29 = CA, ... This is the
+    usual way to encode chain IDs in mmCIF files.
+  """"""
+  if num <= 0:
+    raise ValueError(f'Only positive integers allowed, got {num}.')
+
+  num = num - 1  # 1-based indexing.
+  output = []
+  while num >= 0:
+    output.append(chr(num % 26 + ord('A')))
+    num = num // 26 - 1
+  return ''.join(output)
+
+
+def add_assembly_features(
+    all_chain_features: MutableMapping[str, pipeline.FeatureDict],
+    ) -> MutableMapping[str, pipeline.FeatureDict]:
+  """"""Add features to distinguish between chains.
+
+  Args:
+    all_chain_features: A dictionary which maps chain_id to a dictionary of
+      features for each chain.
+
+  Returns:
+    all_chain_features: A dictionary which maps strings of the form
+      `<seq_id>_<sym_id>` to the corresponding chain features. E.g. two
+      chains from a homodimer would have keys A_1 and A_2. Two chains from a
+      heterodimer would have keys A_1 and B_1.
+  """"""
+  # Group the chains by sequence
+  seq_to_entity_id = {}
+  grouped_chains = collections.defaultdict(list)
+  for chain_id, chain_features in all_chain_features.items():
+    seq = str(chain_features['sequence'])
+    if seq not in seq_to_entity_id:
+      seq_to_entity_id[seq] = len(seq_to_entity_id) + 1
+    grouped_chains[seq_to_entity_id[seq]].append(chain_features)
+
+  new_all_chain_features = {}
+  chain_id = 1
+  for entity_id, group_chain_features in grouped_chains.items():
+    for sym_id, chain_features in enumerate(group_chain_features, start=1):
+      new_all_chain_features[
+          f'{int_id_to_str_id(entity_id)}_{sym_id}'] = chain_features
+      seq_length = chain_features['seq_length']
+      chain_features['asym_id'] = chain_id * np.ones(seq_length)
+      chain_features['sym_id'] = sym_id * np.ones(seq_length)
+      chain_features['entity_id'] = entity_id * np.ones(seq_length)
+      chain_id += 1
+
+  return new_all_chain_features
+
+
+def pad_msa(np_example, min_num_seq):
+  np_example = dict(np_example)
+  num_seq = np_example['msa'].shape[0]
+  if num_seq < min_num_seq:
+    for feat in ('msa', 'deletion_matrix', 'bert_mask', 'msa_mask'):
+      np_example[feat] = np.pad(
+          np_example[feat], ((0, min_num_seq - num_seq), (0, 0)))
+    np_example['cluster_bias_mask'] = np.pad(
+        np_example['cluster_bias_mask'], ((0, min_num_seq - num_seq),))
+  return np_example
+
+
+class DataPipeline:
+  """"""Runs the alignment tools and assembles the input features.""""""
+
+  def __init__(self,
+               monomer_data_pipeline: pipeline.DataPipeline,
+               jackhmmer_binary_path: str,
+               uniprot_database_path: str,
+               max_uniprot_hits: int = 50000,
+               use_precomputed_msas: bool = False):
+    """"""Initializes the data pipeline.
+
+    Args:
+      monomer_data_pipeline: An instance of pipeline.DataPipeline - that runs
+        the data pipeline for the monomer AlphaFold system.
+      jackhmmer_binary_path: Location of the jackhmmer binary.
+      uniprot_database_path: Location of the unclustered uniprot sequences, that
+        will be searched with jackhmmer and used for MSA pairing.
+      max_uniprot_hits: The maximum number of hits to return from uniprot.
+      use_precomputed_msas: Whether to use pre-existing MSAs; see run_alphafold.
+    """"""
+    self._monomer_data_pipeline = monomer_data_pipeline
+    self._uniprot_msa_runner = jackhmmer.Jackhmmer(
+        binary_path=jackhmmer_binary_path,
+        database_path=uniprot_database_path)
+    self._max_uniprot_hits = max_uniprot_hits
+    self.use_precomputed_msas = use_precomputed_msas
+
+  def _process_single_chain(
+      self,
+      chain_id: str,
+      sequence: str,
+      description: str,
+      msa_output_dir: str,
+      is_homomer_or_monomer: bool,
+      save_msa_fasta: bool,
+      save_template_names: bool,
+      msa_for_template_query_seq_only: bool) -> pipeline.FeatureDict:
+    """"""Runs the monomer pipeline on a single chain.""""""
+    chain_fasta_str = f'>chain_{chain_id}\n{sequence}\n'
+    chain_msa_output_dir = os.path.join(msa_output_dir, chain_id)
+    if not os.path.exists(chain_msa_output_dir):
+      os.makedirs(chain_msa_output_dir)
+    with temp_fasta_file(chain_fasta_str) as chain_fasta_path:
+      logging.info('Running monomer pipeline on chain %s: %s',
+                   chain_id, description)
+      chain_features = self._monomer_data_pipeline.process(
+          input_fasta_path=chain_fasta_path,
+          msa_output_dir=chain_msa_output_dir,
+          save_msa_fasta=save_msa_fasta,
+          save_template_names=save_template_names,
+          msa_for_template_query_seq_only=msa_for_template_query_seq_only)
+
+      # We only construct the pairing features if there are 2 or more unique
+      # sequences.
+      if not is_homomer_or_monomer:
+        all_seq_msa_features = self._all_seq_msa_features(chain_fasta_path,
+                                                          chain_msa_output_dir)
+        chain_features.update(all_seq_msa_features)
+    return chain_features
+
+  def _all_seq_msa_features(self, input_fasta_path, msa_output_dir):
+    """"""Get MSA features for unclustered uniprot, for pairing.""""""
+    out_path = os.path.join(msa_output_dir, 'uniprot_hits.sto')
+    result = pipeline.run_msa_tool(
+        self._uniprot_msa_runner, input_fasta_path, out_path, 'sto',
+        self.use_precomputed_msas)
+    msa = parsers.parse_stockholm(result['sto'])
+    msa = msa.truncate(max_seqs=self._max_uniprot_hits)
+    all_seq_features = pipeline.make_msa_features([msa])
+    valid_feats = msa_pairing.MSA_FEATURES + (
+        'msa_species_identifiers',
+    )
+    feats = {f'{k}_all_seq': v for k, v in all_seq_features.items()
+             if k in valid_feats}
+    return feats
+
+  def process(self,
+              input_fasta_path: str,
+              msa_output_dir: str,
+              save_msa_fasta: bool,
+              save_template_names: bool,
+              msa_for_template_query_seq_only: bool) -> pipeline.FeatureDict:
+    """"""Runs alignment tools on the input sequences and creates features.""""""
+    with open(input_fasta_path) as f:
+      input_fasta_str = f.read()
+    input_seqs, input_descs = parsers.parse_fasta(input_fasta_str)
+
+    chain_id_map = _make_chain_id_map(sequences=input_seqs,
+                                      descriptions=input_descs)
+    chain_id_map_path = os.path.join(msa_output_dir, 'chain_id_map.json')
+    with open(chain_id_map_path, 'w') as f:
+      chain_id_map_dict = {chain_id: dataclasses.asdict(fasta_chain)
+                           for chain_id, fasta_chain in chain_id_map.items()}
+      json.dump(chain_id_map_dict, f, indent=4, sort_keys=True)
+
+    all_chain_features = {}
+    sequence_features = {}
+    is_homomer_or_monomer = len(set(input_seqs)) == 1
+    for chain_id, fasta_chain in chain_id_map.items():
+      if fasta_chain.sequence in sequence_features:
+        all_chain_features[chain_id] = copy.deepcopy(
+            sequence_features[fasta_chain.sequence])
+        continue
+      chain_features = self._process_single_chain(
+          chain_id=chain_id,
+          sequence=fasta_chain.sequence,
+          description=fasta_chain.description,
+          msa_output_dir=msa_output_dir,
+          is_homomer_or_monomer=is_homomer_or_monomer,
+          save_msa_fasta=save_msa_fasta,
+          save_template_names=save_template_names,
+          msa_for_template_query_seq_only=msa_for_template_query_seq_only)
+
+      chain_features = convert_monomer_features(chain_features,
+                                                chain_id=chain_id)
+      all_chain_features[chain_id] = chain_features
+      sequence_features[fasta_chain.sequence] = chain_features
+
+    all_chain_features = add_assembly_features(all_chain_features)
+
+    np_example = feature_processing.pair_and_merge(
+        all_chain_features=all_chain_features)
+
+    # Pad MSA to avoid zero-sized extra_msa.
+    np_example = pad_msa(np_example, 512)
+
+    return np_example
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/mmcif_parsing.py",".py","14174","387","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Parses the mmCIF file format.""""""
+import collections
+import dataclasses
+import functools
+import io
+from typing import Any, Mapping, Optional, Sequence, Tuple
+
+from absl import logging
+from Bio import PDB
+from Bio.Data import SCOPData
+
+# Type aliases:
+ChainId = str
+PdbHeader = Mapping[str, Any]
+PdbStructure = PDB.Structure.Structure
+SeqRes = str
+MmCIFDict = Mapping[str, Sequence[str]]
+
+
+@dataclasses.dataclass(frozen=True)
+class Monomer:
+  id: str
+  num: int
+
+
+# Note - mmCIF format provides no guarantees on the type of author-assigned
+# sequence numbers. They need not be integers.
+@dataclasses.dataclass(frozen=True)
+class AtomSite:
+  residue_name: str
+  author_chain_id: str
+  mmcif_chain_id: str
+  author_seq_num: str
+  mmcif_seq_num: int
+  insertion_code: str
+  hetatm_atom: str
+  model_num: int
+
+
+# Used to map SEQRES index to a residue in the structure.
+@dataclasses.dataclass(frozen=True)
+class ResiduePosition:
+  chain_id: str
+  residue_number: int
+  insertion_code: str
+
+
+@dataclasses.dataclass(frozen=True)
+class ResidueAtPosition:
+  position: Optional[ResiduePosition]
+  name: str
+  is_missing: bool
+  hetflag: str
+
+
+@dataclasses.dataclass(frozen=True)
+class MmcifObject:
+  """"""Representation of a parsed mmCIF file.
+
+  Contains:
+    file_id: A meaningful name, e.g. a pdb_id. Should be unique amongst all
+      files being processed.
+    header: Biopython header.
+    structure: Biopython structure.
+    chain_to_seqres: Dict mapping chain_id to 1 letter amino acid sequence. E.g.
+      {'A': 'ABCDEFG'}
+    seqres_to_structure: Dict; for each chain_id contains a mapping between
+      SEQRES index and a ResidueAtPosition. e.g. {'A': {0: ResidueAtPosition,
+                                                        1: ResidueAtPosition,
+                                                        ...}}
+    raw_string: The raw string used to construct the MmcifObject.
+  """"""
+  file_id: str
+  header: PdbHeader
+  structure: PdbStructure
+  chain_to_seqres: Mapping[ChainId, SeqRes]
+  seqres_to_structure: Mapping[ChainId, Mapping[int, ResidueAtPosition]]
+  raw_string: Any
+
+
+@dataclasses.dataclass(frozen=True)
+class ParsingResult:
+  """"""Returned by the parse function.
+
+  Contains:
+    mmcif_object: A MmcifObject, may be None if no chain could be successfully
+      parsed.
+    errors: A dict mapping (file_id, chain_id) to any exception generated.
+  """"""
+  mmcif_object: Optional[MmcifObject]
+  errors: Mapping[Tuple[str, str], Any]
+
+
+class ParseError(Exception):
+  """"""An error indicating that an mmCIF file could not be parsed.""""""
+
+
+def mmcif_loop_to_list(prefix: str,
+                       parsed_info: MmCIFDict) -> Sequence[Mapping[str, str]]:
+  """"""Extracts loop associated with a prefix from mmCIF data as a list.
+
+  Reference for loop_ in mmCIF:
+    http://mmcif.wwpdb.org/docs/tutorials/mechanics/pdbx-mmcif-syntax.html
+
+  Args:
+    prefix: Prefix shared by each of the data items in the loop.
+      e.g. '_entity_poly_seq.', where the data items are _entity_poly_seq.num,
+      _entity_poly_seq.mon_id. Should include the trailing period.
+    parsed_info: A dict of parsed mmCIF data, e.g. _mmcif_dict from a Biopython
+      parser.
+
+  Returns:
+    Returns a list of dicts; each dict represents 1 entry from an mmCIF loop.
+  """"""
+  cols = []
+  data = []
+  for key, value in parsed_info.items():
+    if key.startswith(prefix):
+      cols.append(key)
+      data.append(value)
+
+  assert all([len(xs) == len(data[0]) for xs in data]), (
+      'mmCIF error: Not all loops are the same length: %s' % cols)
+
+  return [dict(zip(cols, xs)) for xs in zip(*data)]
+
+
+def mmcif_loop_to_dict(prefix: str,
+                       index: str,
+                       parsed_info: MmCIFDict,
+                       ) -> Mapping[str, Mapping[str, str]]:
+  """"""Extracts loop associated with a prefix from mmCIF data as a dictionary.
+
+  Args:
+    prefix: Prefix shared by each of the data items in the loop.
+      e.g. '_entity_poly_seq.', where the data items are _entity_poly_seq.num,
+      _entity_poly_seq.mon_id. Should include the trailing period.
+    index: Which item of loop data should serve as the key.
+    parsed_info: A dict of parsed mmCIF data, e.g. _mmcif_dict from a Biopython
+      parser.
+
+  Returns:
+    Returns a dict of dicts; each dict represents 1 entry from an mmCIF loop,
+    indexed by the index column.
+  """"""
+  entries = mmcif_loop_to_list(prefix, parsed_info)
+  return {entry[index]: entry for entry in entries}
+
+
+@functools.lru_cache(16, typed=False)
+def parse(*,
+          file_id: str,
+          mmcif_string: str,
+          catch_all_errors: bool = True) -> ParsingResult:
+  """"""Entry point, parses an mmcif_string.
+
+  Args:
+    file_id: A string identifier for this file. Should be unique within the
+      collection of files being processed.
+    mmcif_string: Contents of an mmCIF file.
+    catch_all_errors: If True, all exceptions are caught and error messages are
+      returned as part of the ParsingResult. If False exceptions will be allowed
+      to propagate.
+
+  Returns:
+    A ParsingResult.
+  """"""
+  errors = {}
+  try:
+    parser = PDB.MMCIFParser(QUIET=True)
+    handle = io.StringIO(mmcif_string)
+    full_structure = parser.get_structure('', handle)
+    first_model_structure = _get_first_model(full_structure)
+    # Extract the _mmcif_dict from the parser, which contains useful fields not
+    # reflected in the Biopython structure.
+    parsed_info = parser._mmcif_dict  # pylint:disable=protected-access
+
+    # Ensure all values are lists, even if singletons.
+    for key, value in parsed_info.items():
+      if not isinstance(value, list):
+        parsed_info[key] = [value]
+
+    header = _get_header(parsed_info)
+
+    # Determine the protein chains, and their start numbers according to the
+    # internal mmCIF numbering scheme (likely but not guaranteed to be 1).
+    valid_chains = _get_protein_chains(parsed_info=parsed_info)
+    if not valid_chains:
+      return ParsingResult(
+          None, {(file_id, ''): 'No protein chains found in this file.'})
+    seq_start_num = {chain_id: min([monomer.num for monomer in seq])
+                     for chain_id, seq in valid_chains.items()}
+
+    # Loop over the atoms for which we have coordinates. Populate two mappings:
+    # -mmcif_to_author_chain_id (maps internal mmCIF chain ids to chain ids used
+    # the authors / Biopython).
+    # -seq_to_structure_mappings (maps idx into sequence to ResidueAtPosition).
+    mmcif_to_author_chain_id = {}
+    seq_to_structure_mappings = {}
+    for atom in _get_atom_site_list(parsed_info):
+      if atom.model_num != '1':
+        # We only process the first model at the moment.
+        continue
+
+      mmcif_to_author_chain_id[atom.mmcif_chain_id] = atom.author_chain_id
+
+      if atom.mmcif_chain_id in valid_chains:
+        hetflag = ' '
+        if atom.hetatm_atom == 'HETATM':
+          # Water atoms are assigned a special hetflag of W in Biopython. We
+          # need to do the same, so that this hetflag can be used to fetch
+          # a residue from the Biopython structure by id.
+          if atom.residue_name in ('HOH', 'WAT'):
+            hetflag = 'W'
+          else:
+            hetflag = 'H_' + atom.residue_name
+        insertion_code = atom.insertion_code
+        if not _is_set(atom.insertion_code):
+          insertion_code = ' '
+        position = ResiduePosition(chain_id=atom.author_chain_id,
+                                   residue_number=int(atom.author_seq_num),
+                                   insertion_code=insertion_code)
+        seq_idx = int(atom.mmcif_seq_num) - seq_start_num[atom.mmcif_chain_id]
+        current = seq_to_structure_mappings.get(atom.author_chain_id, {})
+        current[seq_idx] = ResidueAtPosition(position=position,
+                                             name=atom.residue_name,
+                                             is_missing=False,
+                                             hetflag=hetflag)
+        seq_to_structure_mappings[atom.author_chain_id] = current
+
+    # Add missing residue information to seq_to_structure_mappings.
+    for chain_id, seq_info in valid_chains.items():
+      author_chain = mmcif_to_author_chain_id[chain_id]
+      current_mapping = seq_to_structure_mappings[author_chain]
+      for idx, monomer in enumerate(seq_info):
+        if idx not in current_mapping:
+          current_mapping[idx] = ResidueAtPosition(position=None,
+                                                   name=monomer.id,
+                                                   is_missing=True,
+                                                   hetflag=' ')
+
+    author_chain_to_sequence = {}
+    for chain_id, seq_info in valid_chains.items():
+      author_chain = mmcif_to_author_chain_id[chain_id]
+      seq = []
+      for monomer in seq_info:
+        code = SCOPData.protein_letters_3to1.get(monomer.id, 'X')
+        seq.append(code if len(code) == 1 else 'X')
+      seq = ''.join(seq)
+      author_chain_to_sequence[author_chain] = seq
+
+    mmcif_object = MmcifObject(
+        file_id=file_id,
+        header=header,
+        structure=first_model_structure,
+        chain_to_seqres=author_chain_to_sequence,
+        seqres_to_structure=seq_to_structure_mappings,
+        raw_string=parsed_info)
+
+    return ParsingResult(mmcif_object=mmcif_object, errors=errors)
+  except Exception as e:  # pylint:disable=broad-except
+    errors[(file_id, '')] = e
+    if not catch_all_errors:
+      raise
+    return ParsingResult(mmcif_object=None, errors=errors)
+
+
+def _get_first_model(structure: PdbStructure) -> PdbStructure:
+  """"""Returns the first model in a Biopython structure.""""""
+  return next(structure.get_models())
+
+_MIN_LENGTH_OF_CHAIN_TO_BE_COUNTED_AS_PEPTIDE = 21
+
+
+def get_release_date(parsed_info: MmCIFDict) -> str:
+  """"""Returns the oldest revision date.""""""
+  revision_dates = parsed_info['_pdbx_audit_revision_history.revision_date']
+  return min(revision_dates)
+
+
+def _get_header(parsed_info: MmCIFDict) -> PdbHeader:
+  """"""Returns a basic header containing method, release date and resolution.""""""
+  header = {}
+
+  experiments = mmcif_loop_to_list('_exptl.', parsed_info)
+  header['structure_method'] = ','.join([
+      experiment['_exptl.method'].lower() for experiment in experiments])
+
+  # Note: The release_date here corresponds to the oldest revision. We prefer to
+  # use this for dataset filtering over the deposition_date.
+  if '_pdbx_audit_revision_history.revision_date' in parsed_info:
+    header['release_date'] = get_release_date(parsed_info)
+  else:
+    logging.warning('Could not determine release_date: %s',
+                    parsed_info['_entry.id'])
+
+  header['resolution'] = 0.00
+  for res_key in ('_refine.ls_d_res_high', '_em_3d_reconstruction.resolution',
+                  '_reflns.d_resolution_high'):
+    if res_key in parsed_info:
+      try:
+        raw_resolution = parsed_info[res_key][0]
+        header['resolution'] = float(raw_resolution)
+      except ValueError:
+        logging.debug('Invalid resolution format: %s', parsed_info[res_key])
+
+  return header
+
+
+def _get_atom_site_list(parsed_info: MmCIFDict) -> Sequence[AtomSite]:
+  """"""Returns list of atom sites; contains data not present in the structure.""""""
+  return [AtomSite(*site) for site in zip(  # pylint:disable=g-complex-comprehension
+      parsed_info['_atom_site.label_comp_id'],
+      parsed_info['_atom_site.auth_asym_id'],
+      parsed_info['_atom_site.label_asym_id'],
+      parsed_info['_atom_site.auth_seq_id'],
+      parsed_info['_atom_site.label_seq_id'],
+      parsed_info['_atom_site.pdbx_PDB_ins_code'],
+      parsed_info['_atom_site.group_PDB'],
+      parsed_info['_atom_site.pdbx_PDB_model_num'],
+      )]
+
+
+def _get_protein_chains(
+    *, parsed_info: Mapping[str, Any]) -> Mapping[ChainId, Sequence[Monomer]]:
+  """"""Extracts polymer information for protein chains only.
+
+  Args:
+    parsed_info: _mmcif_dict produced by the Biopython parser.
+
+  Returns:
+    A dict mapping mmcif chain id to a list of Monomers.
+  """"""
+  # Get polymer information for each entity in the structure.
+  entity_poly_seqs = mmcif_loop_to_list('_entity_poly_seq.', parsed_info)
+
+  polymers = collections.defaultdict(list)
+  for entity_poly_seq in entity_poly_seqs:
+    polymers[entity_poly_seq['_entity_poly_seq.entity_id']].append(
+        Monomer(id=entity_poly_seq['_entity_poly_seq.mon_id'],
+                num=int(entity_poly_seq['_entity_poly_seq.num'])))
+
+  # Get chemical compositions. Will allow us to identify which of these polymers
+  # are proteins.
+  chem_comps = mmcif_loop_to_dict('_chem_comp.', '_chem_comp.id', parsed_info)
+
+  # Get chains information for each entity. Necessary so that we can return a
+  # dict keyed on chain id rather than entity.
+  struct_asyms = mmcif_loop_to_list('_struct_asym.', parsed_info)
+
+  entity_to_mmcif_chains = collections.defaultdict(list)
+  for struct_asym in struct_asyms:
+    chain_id = struct_asym['_struct_asym.id']
+    entity_id = struct_asym['_struct_asym.entity_id']
+    entity_to_mmcif_chains[entity_id].append(chain_id)
+
+  # Identify and return the valid protein chains.
+  valid_chains = {}
+  for entity_id, seq_info in polymers.items():
+    chain_ids = entity_to_mmcif_chains[entity_id]
+
+    # Reject polymers without any peptide-like components, such as DNA/RNA.
+    if any(['peptide' in chem_comps[monomer.id]['_chem_comp.type']
+            for monomer in seq_info]):
+      for chain_id in chain_ids:
+        valid_chains[chain_id] = seq_info
+  return valid_chains
+
+
+def _is_set(data: str) -> bool:
+  """"""Returns False if data is a special mmCIF character indicating 'unset'.""""""
+  return data not in ('.', '?')
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/__init__.py",".py","634","15","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Data pipeline for model features.""""""
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/pipeline_multimer_custom_templates.py",".py","15215","379","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Functions for building the features for the AlphaFold multimer model.""""""
+
+import collections
+import contextlib
+import copy
+import dataclasses
+import json
+import os
+import tempfile
+from typing import Mapping, MutableMapping, Sequence
+
+from absl import logging
+from alphafold.common import protein
+from alphafold.common import residue_constants
+from alphafold.data import feature_processing
+from alphafold.data import msa_pairing
+from alphafold.data import parsers
+from alphafold.data import pipeline
+from alphafold.data.tools import jackhmmer
+import numpy as np
+
+# Internal import (7716).
+
+
+@dataclasses.dataclass(frozen=True)
+class _FastaChain:
+  sequence: str
+  description: str
+
+
+def _make_chain_id_map(*,
+                       sequences: Sequence[str],
+                       descriptions: Sequence[str],
+                       ) -> Mapping[str, _FastaChain]:
+  """"""Makes a mapping from PDB-format chain ID to sequence and description.""""""
+  if len(sequences) != len(descriptions):
+    raise ValueError('sequences and descriptions must have equal length. '
+                     f'Got {len(sequences)} != {len(descriptions)}.')
+  if len(sequences) > protein.PDB_MAX_CHAINS:
+    raise ValueError('Cannot process more chains than the PDB format supports. '
+                     f'Got {len(sequences)} chains.')
+  chain_id_map = {}
+  for chain_id, sequence, description in zip(
+      protein.PDB_CHAIN_IDS, sequences, descriptions):
+    chain_id_map[chain_id] = _FastaChain(
+        sequence=sequence, description=description)
+  return chain_id_map
+
+
+@contextlib.contextmanager
+def temp_fasta_file(fasta_str: str):
+  with tempfile.NamedTemporaryFile('w', suffix='.fasta') as fasta_file:
+    fasta_file.write(fasta_str)
+    fasta_file.seek(0)
+    yield fasta_file.name
+
+
+def convert_monomer_features(
+    monomer_features: pipeline.FeatureDict,
+    chain_id: str) -> pipeline.FeatureDict:
+  """"""Reshapes and modifies monomer features for multimer models.""""""
+  converted = {}
+  converted['auth_chain_id'] = np.asarray(chain_id, dtype=np.object_)
+  unnecessary_leading_dim_feats = {
+      'sequence', 'domain_name', 'num_alignments', 'seq_length'}
+  for feature_name, feature in monomer_features.items():
+    if feature_name in unnecessary_leading_dim_feats:
+      # asarray ensures it's a np.ndarray.
+      feature = np.asarray(feature[0], dtype=feature.dtype)
+    elif feature_name == 'aatype':
+      # The multimer model performs the one-hot operation itself.
+      feature = np.argmax(feature, axis=-1).astype(np.int32)
+    elif feature_name == 'template_aatype':
+      feature = np.argmax(feature, axis=-1).astype(np.int32)
+      new_order_list = residue_constants.MAP_HHBLITS_AATYPE_TO_OUR_AATYPE
+      feature = np.take(new_order_list, feature.astype(np.int32), axis=0)
+    elif feature_name == 'template_all_atom_masks':
+      feature_name = 'template_all_atom_mask'
+    converted[feature_name] = feature
+  return converted
+
+
+def int_id_to_str_id(num: int) -> str:
+  """"""Encodes a number as a string, using reverse spreadsheet style naming.
+
+  Args:
+    num: A positive integer.
+
+  Returns:
+    A string that encodes the positive integer using reverse spreadsheet style,
+    naming e.g. 1 = A, 2 = B, ..., 27 = AA, 28 = BA, 29 = CA, ... This is the
+    usual way to encode chain IDs in mmCIF files.
+  """"""
+  if num <= 0:
+    raise ValueError(f'Only positive integers allowed, got {num}.')
+
+  num = num - 1  # 1-based indexing.
+  output = []
+  while num >= 0:
+    output.append(chr(num % 26 + ord('A')))
+    num = num // 26 - 1
+  return ''.join(output)
+
+
+def add_assembly_features(
+    all_chain_features: MutableMapping[str, pipeline.FeatureDict],
+    ) -> MutableMapping[str, pipeline.FeatureDict]:
+  """"""Add features to distinguish between chains.
+
+  Args:
+    all_chain_features: A dictionary which maps chain_id to a dictionary of
+      features for each chain.
+
+  Returns:
+    all_chain_features: A dictionary which maps strings of the form
+      `<seq_id>_<sym_id>` to the corresponding chain features. E.g. two
+      chains from a homodimer would have keys A_1 and A_2. Two chains from a
+      heterodimer would have keys A_1 and B_1.
+  """"""
+  # Group the chains by sequence
+  seq_to_entity_id = {}
+  grouped_chains = collections.defaultdict(list)
+  for chain_id, chain_features in all_chain_features.items():
+    seq = str(chain_features['sequence'])
+    if seq not in seq_to_entity_id:
+      seq_to_entity_id[seq] = len(seq_to_entity_id) + 1
+    grouped_chains[seq_to_entity_id[seq]].append(chain_features)
+
+  new_all_chain_features = {}
+  chain_id = 1
+  for entity_id, group_chain_features in grouped_chains.items():
+    for sym_id, chain_features in enumerate(group_chain_features, start=1):
+      new_all_chain_features[
+          f'{int_id_to_str_id(entity_id)}_{sym_id}'] = chain_features
+      seq_length = chain_features['seq_length']
+      chain_features['asym_id'] = chain_id * np.ones(seq_length)
+      chain_features['sym_id'] = sym_id * np.ones(seq_length)
+      chain_features['entity_id'] = entity_id * np.ones(seq_length)
+      chain_id += 1
+
+  return new_all_chain_features
+
+
+def pad_msa(np_example, min_num_seq):
+  np_example = dict(np_example)
+  num_seq = np_example['msa'].shape[0]
+  if num_seq < min_num_seq:
+    for feat in ('msa', 'deletion_matrix', 'bert_mask', 'msa_mask'):
+      np_example[feat] = np.pad(
+          np_example[feat], ((0, min_num_seq - num_seq), (0, 0)))
+    np_example['cluster_bias_mask'] = np.pad(
+        np_example['cluster_bias_mask'], ((0, min_num_seq - num_seq),))
+  return np_example
+
+
+class DataPipeline:
+  """"""Runs the alignment tools and assembles the input features.""""""
+
+  def __init__(self,
+               monomer_data_pipeline: pipeline.DataPipeline,
+               jackhmmer_binary_path: str,
+               uniprot_database_path: str,
+               max_uniprot_hits: int = 50000,
+               use_precomputed_msas: bool = False):
+    """"""Initializes the data pipeline.
+
+    Args:
+      monomer_data_pipeline: An instance of pipeline.DataPipeline - that runs
+        the data pipeline for the monomer AlphaFold system.
+      jackhmmer_binary_path: Location of the jackhmmer binary.
+      uniprot_database_path: Location of the unclustered uniprot sequences, that
+        will be searched with jackhmmer and used for MSA pairing.
+      max_uniprot_hits: The maximum number of hits to return from uniprot.
+      use_precomputed_msas: Whether to use pre-existing MSAs; see run_alphafold.
+    """"""
+    self._monomer_data_pipeline = monomer_data_pipeline
+    self._uniprot_msa_runner = jackhmmer.Jackhmmer(
+        binary_path=jackhmmer_binary_path,
+        database_path=uniprot_database_path)
+    self._max_uniprot_hits = max_uniprot_hits
+    self.use_precomputed_msas = use_precomputed_msas
+
+  def _process_single_chain(
+      self,
+      chain_id: str,
+      sequence: str,
+      description: str,
+      msa_output_dir: str,
+      is_homomer_or_monomer: bool, 
+      use_custom_templates: bool,
+      template_alignfile: str,
+      msa_mode: str,
+      use_custom_MSA_database: str,
+      MSA_database: str,
+      save_msa_fasta: bool,
+      save_template_names: bool,
+      msa_for_template_query_seq_only: bool) -> pipeline.FeatureDict:
+    """"""Runs the monomer pipeline on a single chain.""""""
+    if isinstance(sequence, list):
+      chain_fasta_str = f'>chain_{chain_id}\n{"":"".join(sequence)}\n'
+    else:
+      chain_fasta_str = f'>chain_{chain_id}\n{sequence}\n'
+    chain_msa_output_dir = os.path.join(msa_output_dir, chain_id)
+    if not os.path.exists(chain_msa_output_dir):
+      os.makedirs(chain_msa_output_dir)
+    with temp_fasta_file(chain_fasta_str) as chain_fasta_path:
+      logging.info('Running monomer pipeline on chain %s: %s',
+                   chain_id, description)
+      if use_custom_templates or use_custom_MSA_database!=""none"":
+        chain_features = self._monomer_data_pipeline.process(
+            input_fasta_path=chain_fasta_path,
+            msa_output_dir=chain_msa_output_dir, 
+            use_custom_templates=use_custom_templates,
+            template_alignfile=template_alignfile,
+            msa_mode=msa_mode,
+            use_custom_MSA_database=use_custom_MSA_database,
+            MSA_database=MSA_database,
+            save_msa_fasta=save_msa_fasta,
+            save_template_names=save_template_names,
+            msa_for_template_query_seq_only=msa_for_template_query_seq_only)
+      else:
+        chain_features = self._monomer_data_pipeline.process(
+            input_fasta_path=chain_fasta_path,
+            msa_output_dir=chain_msa_output_dir,
+            save_msa_fasta=save_msa_fasta,
+            save_template_names=save_template_names,
+            msa_for_template_query_seq_only=msa_for_template_query_seq_only)
+
+      sequence="""".join(sequence)
+      # We only construct the pairing features if there are 2 or more unique
+      # sequences.
+      if not is_homomer_or_monomer:
+        if msa_mode==""single_sequence"" or use_custom_MSA_database==""only"":
+          all_seq_msa_features = self._mock_all_seq_msa_features(sequence)
+        else:
+          all_seq_msa_features = self._all_seq_msa_features(chain_fasta_path,
+                                                          chain_msa_output_dir)
+        chain_features.update(all_seq_msa_features)
+    return chain_features
+
+  def _mock_all_seq_msa_features(self, sequence):
+    
+    """"""Get MSA features for unclustered uniprot, for pairing.""""""
+    # out_path = os.path.join(msa_output_dir, 'uniprot_hits.sto')
+    # result = pipeline.run_msa_tool(
+    #     self._uniprot_msa_runner, input_fasta_path, out_path, 'sto',
+    #     self.use_precomputed_msas)
+    # msa = parsers.parse_stockholm(result['sto'])
+    # msa = msa.truncate(max_seqs=self._max_uniprot_hits)
+    from alphafold.data import  pipeline_custom_templates
+    all_seq_features = pipeline_custom_templates.make_mock_msa_features([sequence])
+    # valid_feats = msa_pairing.MSA_FEATURES + (
+    #     'msa_species_identifiers',
+    # )
+    feats = {f'{k}_all_seq': v for k, v in all_seq_features.items()}
+            #  if k in valid_feats}
+    return feats
+
+  # def _all_seq_msa_features_customized(self, input_fasta_path, msa_output_dir):
+  #   """"""Get MSA features for unclustered uniprot, for pairing.""""""
+  #   out_path = os.path.join(msa_output_dir, 'uniprot_hits.sto')
+  #   result = pipeline.run_msa_tool(
+  #       self._uniprot_msa_runner, input_fasta_path, out_path, 'sto',
+  #       self.use_precomputed_msas)
+  #   msa = parsers.parse_stockholm(result['sto'])
+  #   msa = msa.truncate(max_seqs=self._max_uniprot_hits)
+  #   all_seq_features = pipeline.make_msa_features([msa])
+  #   valid_feats = msa_pairing.MSA_FEATURES + (
+  #       'msa_species_identifiers',
+  #   )
+  #   feats = {f'{k}_all_seq': v for k, v in all_seq_features.items()
+  #            if k in valid_feats}
+  #   return feats
+
+  def _all_seq_msa_features(self, input_fasta_path, msa_output_dir):
+    """"""Get MSA features for unclustered uniprot, for pairing.""""""
+    out_path = os.path.join(msa_output_dir, 'uniprot_hits.sto')
+    result = pipeline.run_msa_tool(
+        self._uniprot_msa_runner, input_fasta_path, out_path, 'sto',
+        self.use_precomputed_msas)
+    msa = parsers.parse_stockholm(result['sto'])
+    msa = msa.truncate(max_seqs=self._max_uniprot_hits)
+    all_seq_features = pipeline.make_msa_features([msa])
+    valid_feats = msa_pairing.MSA_FEATURES + (
+        'msa_species_identifiers',
+    )
+    feats = {f'{k}_all_seq': v for k, v in all_seq_features.items()
+             if k in valid_feats}
+    return feats
+
+  def process(self,
+              input_fasta_path: str,
+              msa_output_dir: str, 
+              use_custom_templates: bool,
+              template_alignfile: str,
+              msa_mode: str,
+              use_custom_MSA_database: str,
+              MSA_database: str,
+              save_msa_fasta: bool,
+              save_template_names: bool,
+              msa_for_template_query_seq_only: bool) -> pipeline.FeatureDict:
+    """"""Runs alignment tools on the input sequences and creates features.""""""
+    with open(input_fasta_path) as f:
+      input_fasta_str = f.read()
+    input_seqs_raw, input_descs = parsers.parse_fasta(input_fasta_str)
+    input_seqs=[]
+    for index,seq in enumerate(input_seqs_raw):
+      input_seqs.append("""".join(seq))
+    chain_id_map = _make_chain_id_map(sequences=input_seqs,
+                                      descriptions=input_descs)
+    chain_id_map_path = os.path.join(msa_output_dir, 'chain_id_map.json')
+    with open(chain_id_map_path, 'w') as f:
+      chain_id_map_dict = {chain_id: dataclasses.asdict(fasta_chain)
+                           for chain_id, fasta_chain in chain_id_map.items()}
+      json.dump(chain_id_map_dict, f, indent=4, sort_keys=True)
+
+    all_chain_features = {}
+    sequence_features = {}
+    is_homomer_or_monomer = len(set(input_seqs)) == 1
+
+    if use_custom_templates:
+      template_alignfiles=template_alignfile.split("","")
+    else:
+      template_alignfiles=[""""] * len(chain_id_map)
+    if use_custom_MSA_database!=""none"": 
+      MSA_databases=MSA_database.split("","")
+    else:
+      MSA_databases=[""""] * len(chain_id_map)
+
+
+    for index, (chain_id, fasta_chain) in enumerate(chain_id_map.items()):
+      if fasta_chain.sequence in sequence_features:
+        all_chain_features[chain_id] = copy.deepcopy(
+            sequence_features[fasta_chain.sequence])
+        continue
+      chain_features = self._process_single_chain(
+          chain_id=chain_id,
+          sequence=input_seqs_raw[index],
+          description=fasta_chain.description,
+          msa_output_dir=msa_output_dir,
+          is_homomer_or_monomer=is_homomer_or_monomer,
+          use_custom_templates=use_custom_templates,
+          template_alignfile=template_alignfiles[index],
+          msa_mode=msa_mode,
+          use_custom_MSA_database=use_custom_MSA_database,
+          MSA_database=MSA_databases[index],
+          save_msa_fasta=save_msa_fasta,
+          save_template_names=save_template_names,
+          msa_for_template_query_seq_only=msa_for_template_query_seq_only)
+
+      chain_features = convert_monomer_features(chain_features,
+                                                chain_id=chain_id)
+      all_chain_features[chain_id] = chain_features
+      sequence_features[fasta_chain.sequence] = chain_features
+
+    all_chain_features = add_assembly_features(all_chain_features)
+
+    np_example = feature_processing.pair_and_merge(
+        all_chain_features=all_chain_features)
+
+    # Pad MSA to avoid zero-sized extra_msa.
+    np_example = pad_msa(np_example, 512)
+
+    return np_example
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/custom_templates.py",".py","9389","229","#Line 1-190 is from https://github.com/phbradley/alphafold_finetune/blob/main/predict_utils.py
+from alphafold.common import residue_constants
+from alphafold.data import templates
+import numpy as np
+
+#this is from alphafold/data.templates.py
+from typing import Any, Dict, Mapping, Optional, Sequence, Tuple, Union, List
+import dataclasses
+@dataclasses.dataclass(frozen=True)
+class TemplateSearchResult:
+  features: Mapping[str, Any]
+#   errors: Sequence[str]
+#   warnings: Sequence[str]
+
+def load_pdb_coords(
+        pdbfile,
+        allow_chainbreaks=False,
+        allow_skipped_lines=False,
+        verbose=False,
+):
+    ''' returns: chains, all_resids, all_coords, all_name1s
+    '''
+
+    chains = []
+    all_resids = {}
+    all_coords = {}
+    all_name1s = {}
+
+    if verbose:
+        print('reading:', pdbfile)
+    skipped_lines = False
+    with open(pdbfile,'r') as data:
+        for line in data:
+            if (line[:6] in ['ATOM  ','HETATM'] and line[17:20] != 'HOH' and
+                line[16] in ' A1'):
+                if ( line[17:20] in residue_constants.restype_3to1
+                     or line[17:20] == 'MSE'): # 2022-03-31 change to include MSE
+                    name1 = ('M' if line[17:20] == 'MSE' else
+                             residue_constants.restype_3to1[line[17:20]])
+                    resid = line[22:27]
+                    chain = line[21]
+                    if chain not in all_resids:
+                        all_resids[chain] = []
+                        all_coords[chain] = {}
+                        all_name1s[chain] = {}
+                        chains.append(chain)
+                    if line.startswith('HETATM'):
+                        print('WARNING: HETATM', pdbfile, line[:-1])
+                    atom = line[12:16].split()[0]
+                    if resid not in all_resids[chain]:
+                        all_resids[chain].append(resid)
+                        all_coords[chain][resid] = {}
+                        all_name1s[chain][resid] = name1
+
+                    all_coords[chain][resid][atom] = np.array(
+                        [float(line[30:38]), float(line[38:46]), float(line[46:54])])
+                else:
+                    print('skip ATOM line:', line[:-1], pdbfile)
+                    skipped_lines = True
+
+    # check for chainbreaks
+    maxdis = 1.75
+    for chain in chains:
+        for res1, res2 in zip(all_resids[chain][:-1], all_resids[chain][1:]):
+            coords1 = all_coords[chain][res1]
+            coords2 = all_coords[chain][res2]
+            if 'C' in coords1 and 'N' in coords2:
+                dis = np.sqrt(np.sum(np.square(coords1['C']-coords2['N'])))
+                if dis>maxdis:
+                    print('WARNING chainbreak:', chain, res1, res2, dis, pdbfile)
+                    if not allow_chainbreaks:
+                        print('STOP: chainbreaks', pdbfile)
+                        print('DONE')
+                        exit()
+
+    if skipped_lines and not allow_skipped_lines:
+        print('STOP: skipped lines:', pdbfile)
+        print('DONE')
+        exit()
+
+    return chains, all_resids, all_coords, all_name1s
+
+def fill_afold_coords(
+        chain_order,
+        all_resids,
+        all_coords,
+):
+    ''' returns: all_positions, all_positions_mask
+
+    these are 'atom37' coords (not 'atom14' coords)
+
+    '''
+    assert residue_constants.atom_type_num == 37 #HACK/SANITY
+    crs = [(chain,resid) for chain in chain_order for resid in all_resids[chain]]
+    num_res = len(crs)
+    all_positions = np.zeros([num_res, residue_constants.atom_type_num, 3])
+    all_positions_mask = np.zeros([num_res, residue_constants.atom_type_num],
+                                  dtype=np.int64)
+    for res_index, (chain,resid) in enumerate(crs):
+        pos = np.zeros([residue_constants.atom_type_num, 3], dtype=np.float32)
+        mask = np.zeros([residue_constants.atom_type_num], dtype=np.float32)
+        for atom_name, xyz in all_coords[chain][resid].items():
+            x,y,z = xyz
+            if atom_name in residue_constants.atom_order.keys():
+                pos[residue_constants.atom_order[atom_name]] = [x, y, z]
+                mask[residue_constants.atom_order[atom_name]] = 1.0
+            elif atom_name != 'NV': # PRO NV OK to skip
+                # this is just debugging/verbose output:
+                name = atom_name[:]
+                while name[0] in '123':
+                    name = name[1:]
+                if name[0] != 'H':
+                    print('unrecognized atom:', atom_name, chain, resid)
+            # elif atom_name.upper() == 'SE' and res.get_resname() == 'MSE':
+            #     # Put the coordinates of the selenium atom in the sulphur column.
+            #     pos[residue_constants.atom_order['SD']] = [x, y, z]
+            #     mask[residue_constants.atom_order['SD']] = 1.0
+
+        all_positions[res_index] = pos
+        all_positions_mask[res_index] = mask
+    return all_positions, all_positions_mask
+
+
+def create_single_template_features(
+        target_sequence,
+        template_pdbfile,
+        target_to_template_alignment,
+        template_name, # goes into template_domain_names, .encode()'ed
+        allow_chainbreaks=True,
+        allow_skipped_lines=True,
+        expected_identities=None,
+        expected_template_len=None,
+):
+    num_res = len(target_sequence)
+    chains_tmp, all_resids_tmp, all_coords_tmp, all_name1s_tmp = load_pdb_coords(
+        template_pdbfile, allow_chainbreaks=allow_chainbreaks,
+        allow_skipped_lines=allow_skipped_lines,
+    )
+
+    crs_tmp = [(c,r) for c in chains_tmp for r in all_resids_tmp[c]]
+    num_res_tmp = len(crs_tmp)
+    template_full_sequence = ''.join(all_name1s_tmp[c][r] for c,r in crs_tmp)
+
+    # if expected_template_len:
+    #     assert len(template_full_sequence) == expected_template_len
+
+    all_positions_tmp, all_positions_mask_tmp = fill_afold_coords(
+        chains_tmp, all_resids_tmp, all_coords_tmp)
+
+    identities = sum(target_sequence[i] == template_full_sequence[j]
+                     for i,j in target_to_template_alignment.items())
+    if expected_identities:
+        assert identities == expected_identities
+
+    all_positions = np.zeros([num_res, residue_constants.atom_type_num, 3])
+    all_positions_mask = np.zeros([num_res, residue_constants.atom_type_num],
+                                  dtype=np.int64)
+
+    template_alseq = ['-']*num_res
+    for i,j in target_to_template_alignment.items(): # i=target, j=template
+        template_alseq[i] = template_full_sequence[j]
+        all_positions[i] = all_positions_tmp[j]
+        all_positions_mask[i] = all_positions_mask_tmp[j]
+
+    template_sequence = ''.join(template_alseq)
+    assert len(template_sequence) == len(target_sequence)
+    assert identities == sum(a==b for a,b in zip(template_sequence, target_sequence))
+
+    template_aatype = residue_constants.sequence_to_onehot(
+        template_sequence, residue_constants.HHBLITS_AA_TO_ID)
+
+    template_features = {
+        'template_all_atom_positions': all_positions,
+        'template_all_atom_masks': all_positions_mask,
+        'template_sequence': template_sequence.encode(),
+        'template_aatype': template_aatype,
+        'template_domain_names': template_name.encode(),
+        'template_sum_probs': [identities],
+        }
+    return template_features
+
+
+def compile_template_features(template_features_list):
+    all_template_features = {}
+    for name, dtype in templates.TEMPLATE_FEATURES.items():
+        all_template_features[name] = np.stack(
+            [f[name] for f in template_features_list], axis=0).astype(dtype)
+    return TemplateSearchResult(features=all_template_features)
+
+
+#This function is modified from https://github.com/sokrypton/ColabFold/blob/aa7284b56c7c6ce44e252787011a6fd8d2817f85/colabfold/batch.py
+def mk_mock_template(query_sequence: Union[List[str], str], num_temp: int = 1):
+    ln = (
+        len(query_sequence)
+        if isinstance(query_sequence, str)
+        else sum(len(s) for s in query_sequence)
+    )
+    output_templates_sequence = ""A"" * ln
+    output_confidence_scores = np.full(ln, 1.0)
+
+    templates_all_atom_positions = np.zeros(
+        (ln, templates.residue_constants.atom_type_num, 3)
+    )
+    templates_all_atom_masks = np.zeros((ln, templates.residue_constants.atom_type_num))
+    templates_aatype = templates.residue_constants.sequence_to_onehot(
+        output_templates_sequence, templates.residue_constants.HHBLITS_AA_TO_ID
+    )
+    template_features = {
+        ""template_all_atom_positions"": np.tile(
+            templates_all_atom_positions[None], [num_temp, 1, 1, 1]
+        ),
+        ""template_all_atom_masks"": np.tile(
+            templates_all_atom_masks[None], [num_temp, 1, 1]
+        ),
+        ""template_sequence"": [f""none"".encode()] * num_temp,
+        ""template_aatype"": np.tile(np.array(templates_aatype)[None], [num_temp, 1, 1]),
+        # ""template_confidence_scores"": np.tile(
+        #     output_confidence_scores[None], [num_temp, 1]
+        # ),
+        ""template_domain_names"": np.array([f""none"".encode()] * num_temp),
+        # ""template_release_date"": [f""none"".encode()] * num_temp,
+        ""template_sum_probs"": np.zeros([num_temp], dtype=np.float32),
+    }
+    # all_template_features=compile_template_features([template_features])
+    return TemplateSearchResult(features=template_features)
+
+
+    # return all_template_features
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/pipeline.py",".py","11720","272","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Functions for building the input features for the AlphaFold model.""""""
+
+import os
+from typing import Any, Mapping, MutableMapping, Optional, Sequence, Union
+from absl import logging
+from alphafold.common import residue_constants
+from alphafold.data import msa_identifiers
+from alphafold.data import parsers
+from alphafold.data import templates
+from alphafold.data.tools import hhblits
+from alphafold.data.tools import hhsearch
+from alphafold.data.tools import hmmsearch
+from alphafold.data.tools import jackhmmer
+import numpy as np
+
+# Internal import (7716).
+
+FeatureDict = MutableMapping[str, np.ndarray]
+TemplateSearcher = Union[hhsearch.HHSearch, hmmsearch.Hmmsearch]
+
+
+def make_sequence_features(
+    sequence: str, description: str, num_res: int) -> FeatureDict:
+  """"""Constructs a feature dict of sequence features.""""""
+  features = {}
+  features['aatype'] = residue_constants.sequence_to_onehot(
+      sequence=sequence,
+      mapping=residue_constants.restype_order_with_x,
+      map_unknown_to_x=True)
+  features['between_segment_residues'] = np.zeros((num_res,), dtype=np.int32)
+  features['domain_name'] = np.array([description.encode('utf-8')],
+                                     dtype=np.object_)
+  features['residue_index'] = np.array(range(num_res), dtype=np.int32)
+  features['seq_length'] = np.array([num_res] * num_res, dtype=np.int32)
+  features['sequence'] = np.array([sequence.encode('utf-8')], dtype=np.object_)
+  return features
+
+
+def make_msa_features(msas: Sequence[parsers.Msa]) -> FeatureDict:
+  """"""Constructs a feature dict of MSA features.""""""
+  if not msas:
+    raise ValueError('At least one MSA must be provided.')
+
+  int_msa = []
+  deletion_matrix = []
+  species_ids = []
+  seen_sequences = set()
+  for msa_index, msa in enumerate(msas):
+    if not msa:
+      raise ValueError(f'MSA {msa_index} must contain at least one sequence.')
+    for sequence_index, sequence in enumerate(msa.sequences):
+      if sequence in seen_sequences:
+        continue
+      seen_sequences.add(sequence)
+      int_msa.append(
+          [residue_constants.HHBLITS_AA_TO_ID[res] for res in sequence])
+      deletion_matrix.append(msa.deletion_matrix[sequence_index])
+      identifiers = msa_identifiers.get_identifiers(
+          msa.descriptions[sequence_index])
+      species_ids.append(identifiers.species_id.encode('utf-8'))
+
+  num_res = len(msas[0].sequences[0])
+  num_alignments = len(int_msa)
+  features = {}
+  features['deletion_matrix_int'] = np.array(deletion_matrix, dtype=np.int32)
+  features['msa'] = np.array(int_msa, dtype=np.int32)
+  features['num_alignments'] = np.array(
+      [num_alignments] * num_res, dtype=np.int32)
+  features['msa_species_identifiers'] = np.array(species_ids, dtype=np.object_)
+  return features
+
+
+def run_msa_tool(msa_runner, input_fasta_path: str, msa_out_path: str,
+                 msa_format: str, use_precomputed_msas: bool,
+                 max_sto_sequences: Optional[int] = None
+                 ) -> Mapping[str, Any]:
+  """"""Runs an MSA tool, checking if output already exists first.""""""
+  if not use_precomputed_msas or not os.path.exists(msa_out_path):
+    if msa_format == 'sto' and max_sto_sequences is not None:
+      result = msa_runner.query(input_fasta_path, max_sto_sequences)[0]  # pytype: disable=wrong-arg-count
+    else:
+      result = msa_runner.query(input_fasta_path)[0]
+    with open(msa_out_path, 'w') as f:
+      f.write(result[msa_format])
+  else:
+    logging.warning('Reading MSA from file %s', msa_out_path)
+    if msa_format == 'sto' and max_sto_sequences is not None:
+      precomputed_msa = parsers.truncate_stockholm_msa(
+          msa_out_path, max_sto_sequences)
+      result = {'sto': precomputed_msa}
+    else:
+      with open(msa_out_path, 'r') as f:
+        result = {msa_format: f.read()}
+  return result
+
+
+class DataPipeline:
+  """"""Runs the alignment tools and assembles the input features.""""""
+
+  def __init__(self,
+               jackhmmer_binary_path: str,
+               hhblits_binary_path: str,
+               uniref90_database_path: str,
+               mgnify_database_path: str,
+               bfd_database_path: Optional[str],
+               uniref30_database_path: Optional[str],
+               small_bfd_database_path: Optional[str],
+               template_searcher: TemplateSearcher,
+               template_featurizer: templates.TemplateHitFeaturizer,
+               use_small_bfd: bool,
+               mgnify_max_hits: int = 501,
+               uniref_max_hits: int = 10000,
+               use_precomputed_msas: bool = False):
+    """"""Initializes the data pipeline.""""""
+    self._use_small_bfd = use_small_bfd
+    self.jackhmmer_uniref90_runner = jackhmmer.Jackhmmer(
+        binary_path=jackhmmer_binary_path,
+        database_path=uniref90_database_path)
+    if use_small_bfd:
+      self.jackhmmer_small_bfd_runner = jackhmmer.Jackhmmer(
+          binary_path=jackhmmer_binary_path,
+          database_path=small_bfd_database_path)
+    else:
+      self.hhblits_bfd_uniref_runner = hhblits.HHBlits(
+          binary_path=hhblits_binary_path,
+          databases=[bfd_database_path, uniref30_database_path])
+    self.jackhmmer_mgnify_runner = jackhmmer.Jackhmmer(
+        binary_path=jackhmmer_binary_path,
+        database_path=mgnify_database_path)
+    self.template_searcher = template_searcher
+    self.template_featurizer = template_featurizer
+    self.mgnify_max_hits = mgnify_max_hits
+    self.uniref_max_hits = uniref_max_hits
+    self.use_precomputed_msas = use_precomputed_msas
+
+  def process(self, input_fasta_path: str, 
+              msa_output_dir: str, 
+              save_msa_fasta: bool, 
+              save_template_names: bool,
+              msa_for_template_query_seq_only: bool) -> FeatureDict:
+    """"""Runs alignment tools on the input sequence and creates features.""""""
+    with open(input_fasta_path) as f:
+      input_fasta_str = f.read()
+    input_seqs, input_descs = parsers.parse_fasta(input_fasta_str)
+    if len(input_seqs) != 1:
+      raise ValueError(
+          f'More than one input sequence found in {input_fasta_path}.')
+    input_sequence = input_seqs[0]
+    input_description = input_descs[0]
+    num_res = len(input_sequence)
+
+    uniref90_out_path = os.path.join(msa_output_dir, 'uniref90_hits.sto')
+    jackhmmer_uniref90_result = run_msa_tool(
+        msa_runner=self.jackhmmer_uniref90_runner,
+        input_fasta_path=input_fasta_path,
+        msa_out_path=uniref90_out_path,
+        msa_format='sto',
+        use_precomputed_msas=self.use_precomputed_msas,
+        max_sto_sequences=self.uniref_max_hits)
+    mgnify_out_path = os.path.join(msa_output_dir, 'mgnify_hits.sto')
+    jackhmmer_mgnify_result = run_msa_tool(
+        msa_runner=self.jackhmmer_mgnify_runner,
+        input_fasta_path=input_fasta_path,
+        msa_out_path=mgnify_out_path,
+        msa_format='sto',
+        use_precomputed_msas=self.use_precomputed_msas,
+        max_sto_sequences=self.mgnify_max_hits)
+
+    msa_for_templates = jackhmmer_uniref90_result['sto']
+    msa_for_templates = parsers.deduplicate_stockholm_msa(msa_for_templates)
+    msa_for_templates = parsers.remove_empty_columns_from_stockholm_msa(
+        msa_for_templates)
+    if msa_for_template_query_seq_only:
+      '''BP 12/15/22 let's just keep the target (query) sequence'''
+      msa_for_templates = parsers.truncate_stockholm_msa2(msa_for_templates, 1)
+
+    if self.template_searcher.input_format == 'sto':
+      pdb_templates_result = self.template_searcher.query(msa_for_templates)
+    elif self.template_searcher.input_format == 'a3m':
+      uniref90_msa_as_a3m = parsers.convert_stockholm_to_a3m(msa_for_templates)
+      pdb_templates_result = self.template_searcher.query(uniref90_msa_as_a3m)
+    else:
+      raise ValueError('Unrecognized template input format: '
+                       f'{self.template_searcher.input_format}')
+
+    pdb_hits_out_path = os.path.join(
+        msa_output_dir, f'pdb_hits.{self.template_searcher.output_format}')
+    with open(pdb_hits_out_path, 'w') as f:
+      f.write(pdb_templates_result)
+
+    uniref90_msa = parsers.parse_stockholm(jackhmmer_uniref90_result['sto'])
+    mgnify_msa = parsers.parse_stockholm(jackhmmer_mgnify_result['sto'])
+
+    pdb_template_hits = self.template_searcher.get_template_hits(
+        output_string=pdb_templates_result, input_sequence=input_sequence)
+
+    if self._use_small_bfd:
+      bfd_out_path = os.path.join(msa_output_dir, 'small_bfd_hits.sto')
+      jackhmmer_small_bfd_result = run_msa_tool(
+          msa_runner=self.jackhmmer_small_bfd_runner,
+          input_fasta_path=input_fasta_path,
+          msa_out_path=bfd_out_path,
+          msa_format='sto',
+          use_precomputed_msas=self.use_precomputed_msas)
+      bfd_msa = parsers.parse_stockholm(jackhmmer_small_bfd_result['sto'])
+    else:
+      bfd_out_path = os.path.join(msa_output_dir, 'bfd_uniref_hits.a3m')
+      hhblits_bfd_uniref_result = run_msa_tool(
+          msa_runner=self.hhblits_bfd_uniref_runner,
+          input_fasta_path=input_fasta_path,
+          msa_out_path=bfd_out_path,
+          msa_format='a3m',
+          use_precomputed_msas=self.use_precomputed_msas)
+      bfd_msa = parsers.parse_a3m(hhblits_bfd_uniref_result['a3m'])
+
+    templates_result = self.template_featurizer.get_templates(
+        query_sequence=input_sequence,
+        hits=pdb_template_hits)
+
+    sequence_features = make_sequence_features(
+        sequence=input_sequence,
+        description=input_description,
+        num_res=num_res)
+
+    msa_features = make_msa_features((uniref90_msa, bfd_msa, mgnify_msa))
+
+    if save_msa_fasta:
+      msa_outpath=os.path.join(msa_output_dir, 'msa_feat_gaptoU.fasta')
+      with open(msa_outpath, 'w+') as fh:
+        fh.write("">query""+""\n""+input_sequence+""\n"")
+        counter=1
+        for seq in msa_features['msa']:
+            seq=[residue_constants.ID_TO_HHBLITS_AA[num] for num in seq]
+            # for x in range(len(seq)):
+            counter+=1
+            fh.write("">seq_""+str(counter)+""\n"")
+            out="""".join(seq).replace(""-"",""U"")
+            fh.write(out+""\n"")
+            
+    logging.info('Uniref90 MSA size: %d sequences.', len(uniref90_msa))
+    logging.info('BFD MSA size: %d sequences.', len(bfd_msa))
+    logging.info('MGnify MSA size: %d sequences.', len(mgnify_msa))
+    logging.info('Final (deduplicated) MSA size: %d sequences.',
+                 msa_features['num_alignments'][0])
+    logging.info('Total number of templates (NB: this can include bad '
+                 'templates and is later filtered to top 4): %d.',
+                 templates_result.features['template_domain_names'].shape[0])
+
+    if save_template_names:
+      temp_name_fn=os.path.join(msa_output_dir, 'template_names.txt')
+      # with open(temp_name_fn, 'w+') as fh:
+      #     fh.write(""\n"".join((map(str,templates_result.features['template_domain_names']))))
+      template_names=[name.decode('utf-8') for name in templates_result.features['template_domain_names']]
+      with open(temp_name_fn, 'w+') as fh:
+          fh.write(""\n"".join(template_names))
+          
+    return {**sequence_features, **msa_features, **templates_result.features}
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/msa_pairing.py",".py","17220","462","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Pairing logic for multimer data pipeline.""""""
+
+import collections
+import functools
+import string
+from typing import Any, Dict, Iterable, List, Sequence
+
+from alphafold.common import residue_constants
+from alphafold.data import pipeline
+import numpy as np
+import pandas as pd
+import scipy.linalg
+
+MSA_GAP_IDX = residue_constants.restypes_with_x_and_gap.index('-')
+SEQUENCE_GAP_CUTOFF = 0.5
+SEQUENCE_SIMILARITY_CUTOFF = 0.9
+
+MSA_PAD_VALUES = {'msa_all_seq': MSA_GAP_IDX,
+                  'msa_mask_all_seq': 1,
+                  'deletion_matrix_all_seq': 0,
+                  'deletion_matrix_int_all_seq': 0,
+                  'msa': MSA_GAP_IDX,
+                  'msa_mask': 1,
+                  'deletion_matrix': 0,
+                  'deletion_matrix_int': 0}
+
+MSA_FEATURES = ('msa', 'msa_mask', 'deletion_matrix', 'deletion_matrix_int')
+SEQ_FEATURES = ('residue_index', 'aatype', 'all_atom_positions',
+                'all_atom_mask', 'seq_mask', 'between_segment_residues',
+                'has_alt_locations', 'has_hetatoms', 'asym_id', 'entity_id',
+                'sym_id', 'entity_mask', 'deletion_mean',
+                'prediction_atom_mask',
+                'literature_positions', 'atom_indices_to_group_indices',
+                'rigid_group_default_frame')
+TEMPLATE_FEATURES = ('template_aatype', 'template_all_atom_positions',
+                     'template_all_atom_mask')
+CHAIN_FEATURES = ('num_alignments', 'seq_length')
+
+
+def create_paired_features(
+    chains: Iterable[pipeline.FeatureDict]) ->  List[pipeline.FeatureDict]:
+  """"""Returns the original chains with paired NUM_SEQ features.
+
+  Args:
+    chains:  A list of feature dictionaries for each chain.
+
+  Returns:
+    A list of feature dictionaries with sequence features including only
+    rows to be paired.
+  """"""
+  chains = list(chains)
+  chain_keys = chains[0].keys()
+
+  if len(chains) < 2:
+    return chains
+  else:
+    updated_chains = []
+    paired_chains_to_paired_row_indices = pair_sequences(chains)
+    paired_rows = reorder_paired_rows(
+        paired_chains_to_paired_row_indices)
+
+    for chain_num, chain in enumerate(chains):
+      new_chain = {k: v for k, v in chain.items() if '_all_seq' not in k}
+      for feature_name in chain_keys:
+        if feature_name.endswith('_all_seq'):
+          feats_padded = pad_features(chain[feature_name], feature_name)
+          new_chain[feature_name] = feats_padded[paired_rows[:, chain_num]]
+      new_chain['num_alignments_all_seq'] = np.asarray(
+          len(paired_rows[:, chain_num]))
+      updated_chains.append(new_chain)
+    return updated_chains
+
+
+def pad_features(feature: np.ndarray, feature_name: str) -> np.ndarray:
+  """"""Add a 'padding' row at the end of the features list.
+
+  The padding row will be selected as a 'paired' row in the case of partial
+  alignment - for the chain that doesn't have paired alignment.
+
+  Args:
+    feature: The feature to be padded.
+    feature_name: The name of the feature to be padded.
+
+  Returns:
+    The feature with an additional padding row.
+  """"""
+  assert feature.dtype != np.dtype(np.string_)
+  if feature_name in ('msa_all_seq', 'msa_mask_all_seq',
+                      'deletion_matrix_all_seq', 'deletion_matrix_int_all_seq'):
+    num_res = feature.shape[1]
+    padding = MSA_PAD_VALUES[feature_name] * np.ones([1, num_res],
+                                                     feature.dtype)
+  elif feature_name == 'msa_species_identifiers_all_seq':
+    padding = [b'']
+  else:
+    return feature
+  feats_padded = np.concatenate([feature, padding], axis=0)
+  return feats_padded
+
+
+def _make_msa_df(chain_features: pipeline.FeatureDict) -> pd.DataFrame:
+  """"""Makes dataframe with msa features needed for msa pairing.""""""
+  chain_msa = chain_features['msa_all_seq']
+  query_seq = chain_msa[0]
+  per_seq_similarity = np.sum(
+      query_seq[None] == chain_msa, axis=-1) / float(len(query_seq))
+  per_seq_gap = np.sum(chain_msa == 21, axis=-1) / float(len(query_seq))
+  msa_df = pd.DataFrame({
+      'msa_species_identifiers':
+          chain_features['msa_species_identifiers_all_seq'],
+      'msa_row':
+          np.arange(len(
+              chain_features['msa_species_identifiers_all_seq'])),
+      'msa_similarity': per_seq_similarity,
+      'gap': per_seq_gap
+  })
+  return msa_df
+
+
+def _create_species_dict(msa_df: pd.DataFrame) -> Dict[bytes, pd.DataFrame]:
+  """"""Creates mapping from species to msa dataframe of that species.""""""
+  species_lookup = {}
+  for species, species_df in msa_df.groupby('msa_species_identifiers'):
+    species_lookup[species] = species_df
+  return species_lookup
+
+
+def _match_rows_by_sequence_similarity(this_species_msa_dfs: List[pd.DataFrame]
+                                       ) -> List[List[int]]:
+  """"""Finds MSA sequence pairings across chains based on sequence similarity.
+
+  Each chain's MSA sequences are first sorted by their sequence similarity to
+  their respective target sequence. The sequences are then paired, starting
+  from the sequences most similar to their target sequence.
+
+  Args:
+    this_species_msa_dfs: a list of dataframes containing MSA features for
+      sequences for a specific species.
+
+  Returns:
+   A list of lists, each containing M indices corresponding to paired MSA rows,
+   where M is the number of chains.
+  """"""
+  all_paired_msa_rows = []
+
+  num_seqs = [len(species_df) for species_df in this_species_msa_dfs
+              if species_df is not None]
+  take_num_seqs = np.min(num_seqs)
+
+  sort_by_similarity = (
+      lambda x: x.sort_values('msa_similarity', axis=0, ascending=False))
+
+  for species_df in this_species_msa_dfs:
+    if species_df is not None:
+      species_df_sorted = sort_by_similarity(species_df)
+      msa_rows = species_df_sorted.msa_row.iloc[:take_num_seqs].values
+    else:
+      msa_rows = [-1] * take_num_seqs  # take the last 'padding' row
+    all_paired_msa_rows.append(msa_rows)
+  all_paired_msa_rows = list(np.array(all_paired_msa_rows).transpose())
+  return all_paired_msa_rows
+
+
+def pair_sequences(examples: List[pipeline.FeatureDict]
+                   ) -> Dict[int, np.ndarray]:
+  """"""Returns indices for paired MSA sequences across chains.""""""
+
+  num_examples = len(examples)
+
+  all_chain_species_dict = []
+  common_species = set()
+  for chain_features in examples:
+    msa_df = _make_msa_df(chain_features)
+    species_dict = _create_species_dict(msa_df)
+    all_chain_species_dict.append(species_dict)
+    common_species.update(set(species_dict))
+
+  common_species = sorted(common_species)
+  common_species.remove(b'')  # Remove target sequence species.
+
+  all_paired_msa_rows = [np.zeros(len(examples), int)]
+  all_paired_msa_rows_dict = {k: [] for k in range(num_examples)}
+  all_paired_msa_rows_dict[num_examples] = [np.zeros(len(examples), int)]
+
+  for species in common_species:
+    if not species:
+      continue
+    this_species_msa_dfs = []
+    species_dfs_present = 0
+    for species_dict in all_chain_species_dict:
+      if species in species_dict:
+        this_species_msa_dfs.append(species_dict[species])
+        species_dfs_present += 1
+      else:
+        this_species_msa_dfs.append(None)
+
+    # Skip species that are present in only one chain.
+    if species_dfs_present <= 1:
+      continue
+
+    if np.any(
+        np.array([len(species_df) for species_df in
+                  this_species_msa_dfs if
+                  isinstance(species_df, pd.DataFrame)]) > 600):
+      continue
+
+    paired_msa_rows = _match_rows_by_sequence_similarity(this_species_msa_dfs)
+    all_paired_msa_rows.extend(paired_msa_rows)
+    all_paired_msa_rows_dict[species_dfs_present].extend(paired_msa_rows)
+  all_paired_msa_rows_dict = {
+      num_examples: np.array(paired_msa_rows) for
+      num_examples, paired_msa_rows in all_paired_msa_rows_dict.items()
+  }
+  return all_paired_msa_rows_dict
+
+
+def reorder_paired_rows(all_paired_msa_rows_dict: Dict[int, np.ndarray]
+                        ) -> np.ndarray:
+  """"""Creates a list of indices of paired MSA rows across chains.
+
+  Args:
+    all_paired_msa_rows_dict: a mapping from the number of paired chains to the
+      paired indices.
+
+  Returns:
+    a list of lists, each containing indices of paired MSA rows across chains.
+    The paired-index lists are ordered by:
+      1) the number of chains in the paired alignment, i.e, all-chain pairings
+         will come first.
+      2) e-values
+  """"""
+  all_paired_msa_rows = []
+
+  for num_pairings in sorted(all_paired_msa_rows_dict, reverse=True):
+    paired_rows = all_paired_msa_rows_dict[num_pairings]
+    paired_rows_product = abs(np.array([np.prod(rows) for rows in paired_rows]))
+    paired_rows_sort_index = np.argsort(paired_rows_product)
+    all_paired_msa_rows.extend(paired_rows[paired_rows_sort_index])
+
+  return np.array(all_paired_msa_rows)
+
+
+def block_diag(*arrs: np.ndarray, pad_value: float = 0.0) -> np.ndarray:
+  """"""Like scipy.linalg.block_diag but with an optional padding value.""""""
+  ones_arrs = [np.ones_like(x) for x in arrs]
+  off_diag_mask = 1.0 - scipy.linalg.block_diag(*ones_arrs)
+  diag = scipy.linalg.block_diag(*arrs)
+  diag += (off_diag_mask * pad_value).astype(diag.dtype)
+  return diag
+
+
+def _correct_post_merged_feats(
+    np_example: pipeline.FeatureDict,
+    np_chains_list: Sequence[pipeline.FeatureDict],
+    pair_msa_sequences: bool) -> pipeline.FeatureDict:
+  """"""Adds features that need to be computed/recomputed post merging.""""""
+
+  np_example['seq_length'] = np.asarray(np_example['aatype'].shape[0],
+                                        dtype=np.int32)
+  np_example['num_alignments'] = np.asarray(np_example['msa'].shape[0],
+                                            dtype=np.int32)
+
+  if not pair_msa_sequences:
+    # Generate a bias that is 1 for the first row of every block in the
+    # block diagonal MSA - i.e. make sure the cluster stack always includes
+    # the query sequences for each chain (since the first row is the query
+    # sequence).
+    cluster_bias_masks = []
+    for chain in np_chains_list:
+      mask = np.zeros(chain['msa'].shape[0])
+      mask[0] = 1
+      cluster_bias_masks.append(mask)
+    np_example['cluster_bias_mask'] = np.concatenate(cluster_bias_masks)
+
+    # Initialize Bert mask with masked out off diagonals.
+    msa_masks = [np.ones(x['msa'].shape, dtype=np.float32)
+                 for x in np_chains_list]
+
+    np_example['bert_mask'] = block_diag(
+        *msa_masks, pad_value=0)
+  else:
+    np_example['cluster_bias_mask'] = np.zeros(np_example['msa'].shape[0])
+    np_example['cluster_bias_mask'][0] = 1
+
+    # Initialize Bert mask with masked out off diagonals.
+    msa_masks = [np.ones(x['msa'].shape, dtype=np.float32) for
+                 x in np_chains_list]
+    msa_masks_all_seq = [np.ones(x['msa_all_seq'].shape, dtype=np.float32) for
+                         x in np_chains_list]
+
+    msa_mask_block_diag = block_diag(
+        *msa_masks, pad_value=0)
+    msa_mask_all_seq = np.concatenate(msa_masks_all_seq, axis=1)
+    np_example['bert_mask'] = np.concatenate(
+        [msa_mask_all_seq, msa_mask_block_diag], axis=0)
+  return np_example
+
+
+def _pad_templates(chains: Sequence[pipeline.FeatureDict],
+                   max_templates: int) -> Sequence[pipeline.FeatureDict]:
+  """"""For each chain pad the number of templates to a fixed size.
+
+  Args:
+    chains: A list of protein chains.
+    max_templates: Each chain will be padded to have this many templates.
+
+  Returns:
+    The list of chains, updated to have template features padded to
+    max_templates.
+  """"""
+  for chain in chains:
+    for k, v in chain.items():
+      if k in TEMPLATE_FEATURES:
+        padding = np.zeros_like(v.shape)
+        padding[0] = max_templates - v.shape[0]
+        padding = [(0, p) for p in padding]
+        chain[k] = np.pad(v, padding, mode='constant')
+  return chains
+
+
+def _merge_features_from_multiple_chains(
+    chains: Sequence[pipeline.FeatureDict],
+    pair_msa_sequences: bool) -> pipeline.FeatureDict:
+  """"""Merge features from multiple chains.
+
+  Args:
+    chains: A list of feature dictionaries that we want to merge.
+    pair_msa_sequences: Whether to concatenate MSA features along the
+      num_res dimension (if True), or to block diagonalize them (if False).
+
+  Returns:
+    A feature dictionary for the merged example.
+  """"""
+  merged_example = {}
+  for feature_name in chains[0]:
+    feats = [x[feature_name] for x in chains]
+    feature_name_split = feature_name.split('_all_seq')[0]
+    if feature_name_split in MSA_FEATURES:
+      if pair_msa_sequences or '_all_seq' in feature_name:
+        merged_example[feature_name] = np.concatenate(feats, axis=1)
+      else:
+        merged_example[feature_name] = block_diag(
+            *feats, pad_value=MSA_PAD_VALUES[feature_name])
+    elif feature_name_split in SEQ_FEATURES:
+      merged_example[feature_name] = np.concatenate(feats, axis=0)
+    elif feature_name_split in TEMPLATE_FEATURES:
+      merged_example[feature_name] = np.concatenate(feats, axis=1)
+    elif feature_name_split in CHAIN_FEATURES:
+      merged_example[feature_name] = np.sum(x for x in feats).astype(np.int32)
+    else:
+      merged_example[feature_name] = feats[0]
+  return merged_example
+
+
+def _merge_homomers_dense_msa(
+    chains: Iterable[pipeline.FeatureDict]) -> Sequence[pipeline.FeatureDict]:
+  """"""Merge all identical chains, making the resulting MSA dense.
+
+  Args:
+    chains: An iterable of features for each chain.
+
+  Returns:
+    A list of feature dictionaries.  All features with the same entity_id
+    will be merged - MSA features will be concatenated along the num_res
+    dimension - making them dense.
+  """"""
+  entity_chains = collections.defaultdict(list)
+  for chain in chains:
+    entity_id = chain['entity_id'][0]
+    entity_chains[entity_id].append(chain)
+
+  grouped_chains = []
+  for entity_id in sorted(entity_chains):
+    chains = entity_chains[entity_id]
+    grouped_chains.append(chains)
+  chains = [
+      _merge_features_from_multiple_chains(chains, pair_msa_sequences=True)
+      for chains in grouped_chains]
+  return chains
+
+
+def _concatenate_paired_and_unpaired_features(
+    example: pipeline.FeatureDict) -> pipeline.FeatureDict:
+  """"""Merges paired and block-diagonalised features.""""""
+  features = MSA_FEATURES
+  for feature_name in features:
+    if feature_name in example:
+      feat = example[feature_name]
+      feat_all_seq = example[feature_name + '_all_seq']
+      merged_feat = np.concatenate([feat_all_seq, feat], axis=0)
+      example[feature_name] = merged_feat
+  example['num_alignments'] = np.array(example['msa'].shape[0],
+                                       dtype=np.int32)
+  return example
+
+
+def merge_chain_features(np_chains_list: List[pipeline.FeatureDict],
+                         pair_msa_sequences: bool,
+                         max_templates: int) -> pipeline.FeatureDict:
+  """"""Merges features for multiple chains to single FeatureDict.
+
+  Args:
+    np_chains_list: List of FeatureDicts for each chain.
+    pair_msa_sequences: Whether to merge paired MSAs.
+    max_templates: The maximum number of templates to include.
+
+  Returns:
+    Single FeatureDict for entire complex.
+  """"""
+  np_chains_list = _pad_templates(
+      np_chains_list, max_templates=max_templates)
+  np_chains_list = _merge_homomers_dense_msa(np_chains_list)
+  # Unpaired MSA features will be always block-diagonalised; paired MSA
+  # features will be concatenated.
+  np_example = _merge_features_from_multiple_chains(
+      np_chains_list, pair_msa_sequences=False)
+  if pair_msa_sequences:
+    np_example = _concatenate_paired_and_unpaired_features(np_example)
+  np_example = _correct_post_merged_feats(
+      np_example=np_example,
+      np_chains_list=np_chains_list,
+      pair_msa_sequences=pair_msa_sequences)
+
+  return np_example
+
+
+def deduplicate_unpaired_sequences(
+    np_chains: List[pipeline.FeatureDict]) -> List[pipeline.FeatureDict]:
+  """"""Removes unpaired sequences which duplicate a paired sequence.""""""
+
+  feature_names = np_chains[0].keys()
+  msa_features = MSA_FEATURES
+
+  for chain in np_chains:
+    # Convert the msa_all_seq numpy array to a tuple for hashing.
+    sequence_set = set(tuple(s) for s in chain['msa_all_seq'])
+    keep_rows = []
+    # Go through unpaired MSA seqs and remove any rows that correspond to the
+    # sequences that are already present in the paired MSA.
+    for row_num, seq in enumerate(chain['msa']):
+      if tuple(seq) not in sequence_set:
+        keep_rows.append(row_num)
+    for feature_name in feature_names:
+      if feature_name in msa_features:
+        chain[feature_name] = chain[feature_name][keep_rows]
+    chain['num_alignments'] = np.array(chain['msa'].shape[0], dtype=np.int32)
+  return np_chains
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/feature_processing.py",".py","8574","229","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Feature processing logic for multimer data pipeline.""""""
+
+from typing import Iterable, MutableMapping, List
+
+from alphafold.common import residue_constants
+from alphafold.data import msa_pairing
+from alphafold.data import pipeline
+import numpy as np
+
+REQUIRED_FEATURES = frozenset({
+    'aatype', 'all_atom_mask', 'all_atom_positions', 'all_chains_entity_ids',
+    'all_crops_all_chains_mask', 'all_crops_all_chains_positions',
+    'all_crops_all_chains_residue_ids', 'assembly_num_chains', 'asym_id',
+    'bert_mask', 'cluster_bias_mask', 'deletion_matrix', 'deletion_mean',
+    'entity_id', 'entity_mask', 'mem_peak', 'msa', 'msa_mask', 'num_alignments',
+    'num_templates', 'queue_size', 'residue_index', 'resolution',
+    'seq_length', 'seq_mask', 'sym_id', 'template_aatype',
+    'template_all_atom_mask', 'template_all_atom_positions'
+})
+
+MAX_TEMPLATES = 4
+MSA_CROP_SIZE = 2048
+
+
+def _is_homomer_or_monomer(chains: Iterable[pipeline.FeatureDict]) -> bool:
+  """"""Checks if a list of chains represents a homomer/monomer example.""""""
+  # Note that an entity_id of 0 indicates padding.
+  num_unique_chains = len(np.unique(np.concatenate(
+      [np.unique(chain['entity_id'][chain['entity_id'] > 0]) for
+       chain in chains])))
+  return num_unique_chains == 1
+
+
+def pair_and_merge(
+    all_chain_features: MutableMapping[str, pipeline.FeatureDict]
+    ) -> pipeline.FeatureDict:
+  """"""Runs processing on features to augment, pair and merge.
+
+  Args:
+    all_chain_features: A MutableMap of dictionaries of features for each chain.
+
+  Returns:
+    A dictionary of features.
+  """"""
+
+  process_unmerged_features(all_chain_features)
+
+  np_chains_list = list(all_chain_features.values())
+  pair_msa_sequences = not _is_homomer_or_monomer(np_chains_list)
+
+  if pair_msa_sequences:
+    np_chains_list = msa_pairing.create_paired_features(
+        chains=np_chains_list)
+    np_chains_list = msa_pairing.deduplicate_unpaired_sequences(np_chains_list)
+  np_chains_list = crop_chains(
+      np_chains_list,
+      msa_crop_size=MSA_CROP_SIZE,
+      pair_msa_sequences=pair_msa_sequences,
+      max_templates=MAX_TEMPLATES)
+  np_example = msa_pairing.merge_chain_features(
+      np_chains_list=np_chains_list, pair_msa_sequences=pair_msa_sequences,
+      max_templates=MAX_TEMPLATES)
+  np_example = process_final(np_example)
+  return np_example
+
+
+def crop_chains(
+    chains_list: List[pipeline.FeatureDict],
+    msa_crop_size: int,
+    pair_msa_sequences: bool,
+    max_templates: int) -> List[pipeline.FeatureDict]:
+  """"""Crops the MSAs for a set of chains.
+
+  Args:
+    chains_list: A list of chains to be cropped.
+    msa_crop_size: The total number of sequences to crop from the MSA.
+    pair_msa_sequences: Whether we are operating in sequence-pairing mode.
+    max_templates: The maximum templates to use per chain.
+
+  Returns:
+    The chains cropped.
+  """"""
+
+  # Apply the cropping.
+  cropped_chains = []
+  for chain in chains_list:
+    cropped_chain = _crop_single_chain(
+        chain,
+        msa_crop_size=msa_crop_size,
+        pair_msa_sequences=pair_msa_sequences,
+        max_templates=max_templates)
+    cropped_chains.append(cropped_chain)
+
+  return cropped_chains
+
+
+def _crop_single_chain(chain: pipeline.FeatureDict,
+                       msa_crop_size: int,
+                       pair_msa_sequences: bool,
+                       max_templates: int) -> pipeline.FeatureDict:
+  """"""Crops msa sequences to `msa_crop_size`.""""""
+  msa_size = chain['num_alignments']
+
+  if pair_msa_sequences:
+    msa_size_all_seq = chain['num_alignments_all_seq']
+    msa_crop_size_all_seq = np.minimum(msa_size_all_seq, msa_crop_size // 2)
+
+    # We reduce the number of un-paired sequences, by the number of times a
+    # sequence from this chain's MSA is included in the paired MSA.  This keeps
+    # the MSA size for each chain roughly constant.
+    msa_all_seq = chain['msa_all_seq'][:msa_crop_size_all_seq, :]
+    num_non_gapped_pairs = np.sum(
+        np.any(msa_all_seq != msa_pairing.MSA_GAP_IDX, axis=1))
+    num_non_gapped_pairs = np.minimum(num_non_gapped_pairs,
+                                      msa_crop_size_all_seq)
+
+    # Restrict the unpaired crop size so that paired+unpaired sequences do not
+    # exceed msa_seqs_per_chain for each chain.
+    max_msa_crop_size = np.maximum(msa_crop_size - num_non_gapped_pairs, 0)
+    msa_crop_size = np.minimum(msa_size, max_msa_crop_size)
+  else:
+    msa_crop_size = np.minimum(msa_size, msa_crop_size)
+
+  include_templates = 'template_aatype' in chain and max_templates
+  if include_templates:
+    num_templates = chain['template_aatype'].shape[0]
+    templates_crop_size = np.minimum(num_templates, max_templates)
+
+  for k in chain:
+    k_split = k.split('_all_seq')[0]
+    if k_split in msa_pairing.TEMPLATE_FEATURES:
+      chain[k] = chain[k][:templates_crop_size, :]
+    elif k_split in msa_pairing.MSA_FEATURES:
+      if '_all_seq' in k and pair_msa_sequences:
+        chain[k] = chain[k][:msa_crop_size_all_seq, :]
+      else:
+        chain[k] = chain[k][:msa_crop_size, :]
+
+  chain['num_alignments'] = np.asarray(msa_crop_size, dtype=np.int32)
+  if include_templates:
+    chain['num_templates'] = np.asarray(templates_crop_size, dtype=np.int32)
+  if pair_msa_sequences:
+    chain['num_alignments_all_seq'] = np.asarray(
+        msa_crop_size_all_seq, dtype=np.int32)
+  return chain
+
+
+def process_final(np_example: pipeline.FeatureDict) -> pipeline.FeatureDict:
+  """"""Final processing steps in data pipeline, after merging and pairing.""""""
+  np_example = _correct_msa_restypes(np_example)
+  np_example = _make_seq_mask(np_example)
+  np_example = _make_msa_mask(np_example)
+  np_example = _filter_features(np_example)
+  return np_example
+
+
+def _correct_msa_restypes(np_example):
+  """"""Correct MSA restype to have the same order as residue_constants.""""""
+  new_order_list = residue_constants.MAP_HHBLITS_AATYPE_TO_OUR_AATYPE
+  np_example['msa'] = np.take(new_order_list, np_example['msa'], axis=0)
+  np_example['msa'] = np_example['msa'].astype(np.int32)
+  return np_example
+
+
+def _make_seq_mask(np_example):
+  np_example['seq_mask'] = (np_example['entity_id'] > 0).astype(np.float32)
+  return np_example
+
+
+def _make_msa_mask(np_example):
+  """"""Mask features are all ones, but will later be zero-padded.""""""
+
+  np_example['msa_mask'] = np.ones_like(np_example['msa'], dtype=np.float32)
+
+  seq_mask = (np_example['entity_id'] > 0).astype(np.float32)
+  np_example['msa_mask'] *= seq_mask[None]
+
+  return np_example
+
+
+def _filter_features(np_example: pipeline.FeatureDict) -> pipeline.FeatureDict:
+  """"""Filters features of example to only those requested.""""""
+  return {k: v for (k, v) in np_example.items() if k in REQUIRED_FEATURES}
+
+
+def process_unmerged_features(
+    all_chain_features: MutableMapping[str, pipeline.FeatureDict]):
+  """"""Postprocessing stage for per-chain features before merging.""""""
+  num_chains = len(all_chain_features)
+  for chain_features in all_chain_features.values():
+    # Convert deletion matrices to float.
+    chain_features['deletion_matrix'] = np.asarray(
+        chain_features.pop('deletion_matrix_int'), dtype=np.float32)
+    if 'deletion_matrix_int_all_seq' in chain_features:
+      chain_features['deletion_matrix_all_seq'] = np.asarray(
+          chain_features.pop('deletion_matrix_int_all_seq'), dtype=np.float32)
+
+    chain_features['deletion_mean'] = np.mean(
+        chain_features['deletion_matrix'], axis=0)
+
+    # Add all_atom_mask and dummy all_atom_positions based on aatype.
+    all_atom_mask = residue_constants.STANDARD_ATOM_MASK[
+        chain_features['aatype']]
+    chain_features['all_atom_mask'] = all_atom_mask
+    chain_features['all_atom_positions'] = np.zeros(
+        list(all_atom_mask.shape) + [3])
+
+    # Add assembly_num_chains.
+    chain_features['assembly_num_chains'] = np.asarray(num_chains)
+
+  # Add entity_mask.
+  for chain_features in all_chain_features.values():
+    chain_features['entity_mask'] = (
+        chain_features['entity_id'] != 0).astype(np.int32)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/templates.py",".py","40677","1011","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Functions for getting templates and calculating template features.""""""
+import abc
+import dataclasses
+import datetime
+import functools
+import glob
+import os
+import re
+from typing import Any, Dict, Mapping, Optional, Sequence, Tuple
+
+from absl import logging
+from alphafold.common import residue_constants
+from alphafold.data import mmcif_parsing
+from alphafold.data import parsers
+from alphafold.data.tools import kalign
+import numpy as np
+
+# Internal import (7716).
+
+
+class Error(Exception):
+  """"""Base class for exceptions.""""""
+
+
+class NoChainsError(Error):
+  """"""An error indicating that template mmCIF didn't have any chains.""""""
+
+
+class SequenceNotInTemplateError(Error):
+  """"""An error indicating that template mmCIF didn't contain the sequence.""""""
+
+
+class NoAtomDataInTemplateError(Error):
+  """"""An error indicating that template mmCIF didn't contain atom positions.""""""
+
+
+class TemplateAtomMaskAllZerosError(Error):
+  """"""An error indicating that template mmCIF had all atom positions masked.""""""
+
+
+class QueryToTemplateAlignError(Error):
+  """"""An error indicating that the query can't be aligned to the template.""""""
+
+
+class CaDistanceError(Error):
+  """"""An error indicating that a CA atom distance exceeds a threshold.""""""
+
+
+class MultipleChainsError(Error):
+  """"""An error indicating that multiple chains were found for a given ID.""""""
+
+
+# Prefilter exceptions.
+class PrefilterError(Exception):
+  """"""A base class for template prefilter exceptions.""""""
+
+
+class DateError(PrefilterError):
+  """"""An error indicating that the hit date was after the max allowed date.""""""
+
+
+class AlignRatioError(PrefilterError):
+  """"""An error indicating that the hit align ratio to the query was too small.""""""
+
+
+class DuplicateError(PrefilterError):
+  """"""An error indicating that the hit was an exact subsequence of the query.""""""
+
+
+class LengthError(PrefilterError):
+  """"""An error indicating that the hit was too short.""""""
+
+
+TEMPLATE_FEATURES = {
+    'template_aatype': np.float32,
+    'template_all_atom_masks': np.float32,
+    'template_all_atom_positions': np.float32,
+    'template_domain_names': object,
+    'template_sequence': object,
+    'template_sum_probs': np.float32,
+}
+
+
+def _get_pdb_id_and_chain(hit: parsers.TemplateHit) -> Tuple[str, str]:
+  """"""Returns PDB id and chain id for an HHSearch Hit.""""""
+  # PDB ID: 4 letters. Chain ID: 1+ alphanumeric letters or ""."" if unknown.
+  id_match = re.match(r'[a-zA-Z\d]{4}_[a-zA-Z0-9.]+', hit.name)
+  if not id_match:
+    raise ValueError(f'hit.name did not start with PDBID_chain: {hit.name}')
+  pdb_id, chain_id = id_match.group(0).split('_')
+  return pdb_id.lower(), chain_id
+
+
+def _is_after_cutoff(
+    pdb_id: str,
+    release_dates: Mapping[str, datetime.datetime],
+    release_date_cutoff: Optional[datetime.datetime]) -> bool:
+  """"""Checks if the template date is after the release date cutoff.
+
+  Args:
+    pdb_id: 4 letter pdb code.
+    release_dates: Dictionary mapping PDB ids to their structure release dates.
+    release_date_cutoff: Max release date that is valid for this query.
+
+  Returns:
+    True if the template release date is after the cutoff, False otherwise.
+  """"""
+  if release_date_cutoff is None:
+    raise ValueError('The release_date_cutoff must not be None.')
+  if pdb_id in release_dates:
+    return release_dates[pdb_id] > release_date_cutoff
+  else:
+    # Since this is just a quick prefilter to reduce the number of mmCIF files
+    # we need to parse, we don't have to worry about returning True here.
+    return False
+
+
+def _parse_obsolete(obsolete_file_path: str) -> Mapping[str, Optional[str]]:
+  """"""Parses the data file from PDB that lists which pdb_ids are obsolete.""""""
+  with open(obsolete_file_path) as f:
+    result = {}
+    for line in f:
+      line = line.strip()
+      # Format:    Date      From     To
+      # 'OBSLTE    06-NOV-19 6G9Y'                - Removed, rare
+      # 'OBSLTE    31-JUL-94 116L     216L'       - Replaced, common
+      # 'OBSLTE    26-SEP-06 2H33     2JM5 2OWI'  - Replaced by multiple, rare
+      if line.startswith('OBSLTE'):
+        if len(line) > 30:
+          # Replaced by at least one structure.
+          from_id = line[20:24].lower()
+          to_id = line[29:33].lower()
+          result[from_id] = to_id
+        elif len(line) == 24:
+          # Removed.
+          from_id = line[20:24].lower()
+          result[from_id] = None
+    return result
+
+
+def _parse_release_dates(path: str) -> Mapping[str, datetime.datetime]:
+  """"""Parses release dates file, returns a mapping from PDBs to release dates.""""""
+  if path.endswith('txt'):
+    release_dates = {}
+    with open(path, 'r') as f:
+      for line in f:
+        pdb_id, date = line.split(':')
+        date = date.strip()
+        # Python 3.6 doesn't have datetime.date.fromisoformat() which is about
+        # 90x faster than strptime. However, splitting the string manually is
+        # about 10x faster than strptime.
+        release_dates[pdb_id.strip()] = datetime.datetime(
+            year=int(date[:4]), month=int(date[5:7]), day=int(date[8:10]))
+    return release_dates
+  else:
+    raise ValueError('Invalid format of the release date file %s.' % path)
+
+
+def _assess_hhsearch_hit(
+    hit: parsers.TemplateHit,
+    hit_pdb_code: str,
+    query_sequence: str,
+    release_dates: Mapping[str, datetime.datetime],
+    release_date_cutoff: datetime.datetime,
+    max_subsequence_ratio: float = 0.95,
+    min_align_ratio: float = 0.1) -> bool:
+  """"""Determines if template is valid (without parsing the template mmcif file).
+
+  Args:
+    hit: HhrHit for the template.
+    hit_pdb_code: The 4 letter pdb code of the template hit. This might be
+      different from the value in the actual hit since the original pdb might
+      have become obsolete.
+    query_sequence: Amino acid sequence of the query.
+    release_dates: Dictionary mapping pdb codes to their structure release
+      dates.
+    release_date_cutoff: Max release date that is valid for this query.
+    max_subsequence_ratio: Exclude any exact matches with this much overlap.
+    min_align_ratio: Minimum overlap between the template and query.
+
+  Returns:
+    True if the hit passed the prefilter. Raises an exception otherwise.
+
+  Raises:
+    DateError: If the hit date was after the max allowed date.
+    AlignRatioError: If the hit align ratio to the query was too small.
+    DuplicateError: If the hit was an exact subsequence of the query.
+    LengthError: If the hit was too short.
+  """"""
+  aligned_cols = hit.aligned_cols
+  align_ratio = aligned_cols / len(query_sequence)
+
+  template_sequence = hit.hit_sequence.replace('-', '')
+  length_ratio = float(len(template_sequence)) / len(query_sequence)
+
+  # Check whether the template is a large subsequence or duplicate of original
+  # query. This can happen due to duplicate entries in the PDB database.
+  duplicate = (template_sequence in query_sequence and
+               length_ratio > max_subsequence_ratio)
+
+  if _is_after_cutoff(hit_pdb_code, release_dates, release_date_cutoff):
+    raise DateError(f'Date ({release_dates[hit_pdb_code]}) > max template date '
+                    f'({release_date_cutoff}).')
+
+  if align_ratio <= min_align_ratio:
+    raise AlignRatioError('Proportion of residues aligned to query too small. '
+                          f'Align ratio: {align_ratio}.')
+
+  if duplicate:
+    raise DuplicateError('Template is an exact subsequence of query with large '
+                         f'coverage. Length ratio: {length_ratio}.')
+
+  if len(template_sequence) < 10:
+    raise LengthError(f'Template too short. Length: {len(template_sequence)}.')
+
+  return True
+
+
+def _find_template_in_pdb(
+    template_chain_id: str,
+    template_sequence: str,
+    mmcif_object: mmcif_parsing.MmcifObject) -> Tuple[str, str, int]:
+  """"""Tries to find the template chain in the given pdb file.
+
+  This method tries the three following things in order:
+    1. Tries if there is an exact match in both the chain ID and the sequence.
+       If yes, the chain sequence is returned. Otherwise:
+    2. Tries if there is an exact match only in the sequence.
+       If yes, the chain sequence is returned. Otherwise:
+    3. Tries if there is a fuzzy match (X = wildcard) in the sequence.
+       If yes, the chain sequence is returned.
+  If none of these succeed, a SequenceNotInTemplateError is thrown.
+
+  Args:
+    template_chain_id: The template chain ID.
+    template_sequence: The template chain sequence.
+    mmcif_object: The PDB object to search for the template in.
+
+  Returns:
+    A tuple with:
+    * The chain sequence that was found to match the template in the PDB object.
+    * The ID of the chain that is being returned.
+    * The offset where the template sequence starts in the chain sequence.
+
+  Raises:
+    SequenceNotInTemplateError: If no match is found after the steps described
+      above.
+  """"""
+  # Try if there is an exact match in both the chain ID and the (sub)sequence.
+  pdb_id = mmcif_object.file_id
+  chain_sequence = mmcif_object.chain_to_seqres.get(template_chain_id)
+  if chain_sequence and (template_sequence in chain_sequence):
+    logging.info(
+        'Found an exact template match %s_%s.', pdb_id, template_chain_id)
+    mapping_offset = chain_sequence.find(template_sequence)
+    return chain_sequence, template_chain_id, mapping_offset
+
+  # Try if there is an exact match in the (sub)sequence only.
+  for chain_id, chain_sequence in mmcif_object.chain_to_seqres.items():
+    if chain_sequence and (template_sequence in chain_sequence):
+      logging.info('Found a sequence-only match %s_%s.', pdb_id, chain_id)
+      mapping_offset = chain_sequence.find(template_sequence)
+      return chain_sequence, chain_id, mapping_offset
+
+  # Return a chain sequence that fuzzy matches (X = wildcard) the template.
+  # Make parentheses unnamed groups (?:_) to avoid the 100 named groups limit.
+  regex = ['.' if aa == 'X' else '(?:%s|X)' % aa for aa in template_sequence]
+  regex = re.compile(''.join(regex))
+  for chain_id, chain_sequence in mmcif_object.chain_to_seqres.items():
+    match = re.search(regex, chain_sequence)
+    if match:
+      logging.info('Found a fuzzy sequence-only match %s_%s.', pdb_id, chain_id)
+      mapping_offset = match.start()
+      return chain_sequence, chain_id, mapping_offset
+
+  # No hits, raise an error.
+  raise SequenceNotInTemplateError(
+      'Could not find the template sequence in %s_%s. Template sequence: %s, '
+      'chain_to_seqres: %s' % (pdb_id, template_chain_id, template_sequence,
+                               mmcif_object.chain_to_seqres))
+
+
+def _realign_pdb_template_to_query(
+    old_template_sequence: str,
+    template_chain_id: str,
+    mmcif_object: mmcif_parsing.MmcifObject,
+    old_mapping: Mapping[int, int],
+    kalign_binary_path: str) -> Tuple[str, Mapping[int, int]]:
+  """"""Aligns template from the mmcif_object to the query.
+
+  In case PDB70 contains a different version of the template sequence, we need
+  to perform a realignment to the actual sequence that is in the mmCIF file.
+  This method performs such realignment, but returns the new sequence and
+  mapping only if the sequence in the mmCIF file is 90% identical to the old
+  sequence.
+
+  Note that the old_template_sequence comes from the hit, and contains only that
+  part of the chain that matches with the query while the new_template_sequence
+  is the full chain.
+
+  Args:
+    old_template_sequence: The template sequence that was returned by the PDB
+      template search (typically done using HHSearch).
+    template_chain_id: The template chain id was returned by the PDB template
+      search (typically done using HHSearch). This is used to find the right
+      chain in the mmcif_object chain_to_seqres mapping.
+    mmcif_object: A mmcif_object which holds the actual template data.
+    old_mapping: A mapping from the query sequence to the template sequence.
+      This mapping will be used to compute the new mapping from the query
+      sequence to the actual mmcif_object template sequence by aligning the
+      old_template_sequence and the actual template sequence.
+    kalign_binary_path: The path to a kalign executable.
+
+  Returns:
+    A tuple (new_template_sequence, new_query_to_template_mapping) where:
+    * new_template_sequence is the actual template sequence that was found in
+      the mmcif_object.
+    * new_query_to_template_mapping is the new mapping from the query to the
+      actual template found in the mmcif_object.
+
+  Raises:
+    QueryToTemplateAlignError:
+    * If there was an error thrown by the alignment tool.
+    * Or if the actual template sequence differs by more than 10% from the
+      old_template_sequence.
+  """"""
+  aligner = kalign.Kalign(binary_path=kalign_binary_path)
+  new_template_sequence = mmcif_object.chain_to_seqres.get(
+      template_chain_id, '')
+
+  # Sometimes the template chain id is unknown. But if there is only a single
+  # sequence within the mmcif_object, it is safe to assume it is that one.
+  if not new_template_sequence:
+    if len(mmcif_object.chain_to_seqres) == 1:
+      logging.info('Could not find %s in %s, but there is only 1 sequence, so '
+                   'using that one.',
+                   template_chain_id,
+                   mmcif_object.file_id)
+      new_template_sequence = list(mmcif_object.chain_to_seqres.values())[0]
+    else:
+      raise QueryToTemplateAlignError(
+          f'Could not find chain {template_chain_id} in {mmcif_object.file_id}. '
+          'If there are no mmCIF parsing errors, it is possible it was not a '
+          'protein chain.')
+
+  try:
+    parsed_a3m = parsers.parse_a3m(
+        aligner.align([old_template_sequence, new_template_sequence]))
+    old_aligned_template, new_aligned_template = parsed_a3m.sequences
+  except Exception as e:
+    raise QueryToTemplateAlignError(
+        'Could not align old template %s to template %s (%s_%s). Error: %s' %
+        (old_template_sequence, new_template_sequence, mmcif_object.file_id,
+         template_chain_id, str(e)))
+
+  logging.info('Old aligned template: %s\nNew aligned template: %s',
+               old_aligned_template, new_aligned_template)
+
+  old_to_new_template_mapping = {}
+  old_template_index = -1
+  new_template_index = -1
+  num_same = 0
+  for old_template_aa, new_template_aa in zip(
+      old_aligned_template, new_aligned_template):
+    if old_template_aa != '-':
+      old_template_index += 1
+    if new_template_aa != '-':
+      new_template_index += 1
+    if old_template_aa != '-' and new_template_aa != '-':
+      old_to_new_template_mapping[old_template_index] = new_template_index
+      if old_template_aa == new_template_aa:
+        num_same += 1
+
+  # Require at least 90 % sequence identity wrt to the shorter of the sequences.
+  if float(num_same) / min(
+      len(old_template_sequence), len(new_template_sequence)) < 0.9:
+    raise QueryToTemplateAlignError(
+        'Insufficient similarity of the sequence in the database: %s to the '
+        'actual sequence in the mmCIF file %s_%s: %s. We require at least '
+        '90 %% similarity wrt to the shorter of the sequences. This is not a '
+        'problem unless you think this is a template that should be included.' %
+        (old_template_sequence, mmcif_object.file_id, template_chain_id,
+         new_template_sequence))
+
+  new_query_to_template_mapping = {}
+  for query_index, old_template_index in old_mapping.items():
+    new_query_to_template_mapping[query_index] = (
+        old_to_new_template_mapping.get(old_template_index, -1))
+
+  new_template_sequence = new_template_sequence.replace('-', '')
+
+  return new_template_sequence, new_query_to_template_mapping
+
+
+def _check_residue_distances(all_positions: np.ndarray,
+                             all_positions_mask: np.ndarray,
+                             max_ca_ca_distance: float):
+  """"""Checks if the distance between unmasked neighbor residues is ok.""""""
+  ca_position = residue_constants.atom_order['CA']
+  prev_is_unmasked = False
+  prev_calpha = None
+  for i, (coords, mask) in enumerate(zip(all_positions, all_positions_mask)):
+    this_is_unmasked = bool(mask[ca_position])
+    if this_is_unmasked:
+      this_calpha = coords[ca_position]
+      if prev_is_unmasked:
+        distance = np.linalg.norm(this_calpha - prev_calpha)
+        if distance > max_ca_ca_distance:
+          raise CaDistanceError(
+              'The distance between residues %d and %d is %f > limit %f.' % (
+                  i, i + 1, distance, max_ca_ca_distance))
+      prev_calpha = this_calpha
+    prev_is_unmasked = this_is_unmasked
+
+
+def _get_atom_positions(
+    mmcif_object: mmcif_parsing.MmcifObject,
+    auth_chain_id: str,
+    max_ca_ca_distance: float) -> Tuple[np.ndarray, np.ndarray]:
+  """"""Gets atom positions and mask from a list of Biopython Residues.""""""
+  num_res = len(mmcif_object.chain_to_seqres[auth_chain_id])
+
+  relevant_chains = [c for c in mmcif_object.structure.get_chains()
+                     if c.id == auth_chain_id]
+  if len(relevant_chains) != 1:
+    raise MultipleChainsError(
+        f'Expected exactly one chain in structure with id {auth_chain_id}.')
+  chain = relevant_chains[0]
+
+  all_positions = np.zeros([num_res, residue_constants.atom_type_num, 3])
+  all_positions_mask = np.zeros([num_res, residue_constants.atom_type_num],
+                                dtype=np.int64)
+  for res_index in range(num_res):
+    pos = np.zeros([residue_constants.atom_type_num, 3], dtype=np.float32)
+    mask = np.zeros([residue_constants.atom_type_num], dtype=np.float32)
+    res_at_position = mmcif_object.seqres_to_structure[auth_chain_id][res_index]
+    if not res_at_position.is_missing:
+      res = chain[(res_at_position.hetflag,
+                   res_at_position.position.residue_number,
+                   res_at_position.position.insertion_code)]
+      for atom in res.get_atoms():
+        atom_name = atom.get_name()
+        x, y, z = atom.get_coord()
+        if atom_name in residue_constants.atom_order.keys():
+          pos[residue_constants.atom_order[atom_name]] = [x, y, z]
+          mask[residue_constants.atom_order[atom_name]] = 1.0
+        elif atom_name.upper() == 'SE' and res.get_resname() == 'MSE':
+          # Put the coordinates of the selenium atom in the sulphur column.
+          pos[residue_constants.atom_order['SD']] = [x, y, z]
+          mask[residue_constants.atom_order['SD']] = 1.0
+
+      # Fix naming errors in arginine residues where NH2 is incorrectly
+      # assigned to be closer to CD than NH1.
+      cd = residue_constants.atom_order['CD']
+      nh1 = residue_constants.atom_order['NH1']
+      nh2 = residue_constants.atom_order['NH2']
+      if (res.get_resname() == 'ARG' and
+          all(mask[atom_index] for atom_index in (cd, nh1, nh2)) and
+          (np.linalg.norm(pos[nh1] - pos[cd]) >
+           np.linalg.norm(pos[nh2] - pos[cd]))):
+        pos[nh1], pos[nh2] = pos[nh2].copy(), pos[nh1].copy()
+        mask[nh1], mask[nh2] = mask[nh2].copy(), mask[nh1].copy()
+
+    all_positions[res_index] = pos
+    all_positions_mask[res_index] = mask
+  _check_residue_distances(
+      all_positions, all_positions_mask, max_ca_ca_distance)
+  return all_positions, all_positions_mask
+
+
+def _extract_template_features(
+    mmcif_object: mmcif_parsing.MmcifObject,
+    pdb_id: str,
+    mapping: Mapping[int, int],
+    template_sequence: str,
+    query_sequence: str,
+    template_chain_id: str,
+    kalign_binary_path: str) -> Tuple[Dict[str, Any], Optional[str]]:
+  """"""Parses atom positions in the target structure and aligns with the query.
+
+  Atoms for each residue in the template structure are indexed to coincide
+  with their corresponding residue in the query sequence, according to the
+  alignment mapping provided.
+
+  Args:
+    mmcif_object: mmcif_parsing.MmcifObject representing the template.
+    pdb_id: PDB code for the template.
+    mapping: Dictionary mapping indices in the query sequence to indices in
+      the template sequence.
+    template_sequence: String describing the amino acid sequence for the
+      template protein.
+    query_sequence: String describing the amino acid sequence for the query
+      protein.
+    template_chain_id: String ID describing which chain in the structure proto
+      should be used.
+    kalign_binary_path: The path to a kalign executable used for template
+        realignment.
+
+  Returns:
+    A tuple with:
+    * A dictionary containing the extra features derived from the template
+      protein structure.
+    * A warning message if the hit was realigned to the actual mmCIF sequence.
+      Otherwise None.
+
+  Raises:
+    NoChainsError: If the mmcif object doesn't contain any chains.
+    SequenceNotInTemplateError: If the given chain id / sequence can't
+      be found in the mmcif object.
+    QueryToTemplateAlignError: If the actual template in the mmCIF file
+      can't be aligned to the query.
+    NoAtomDataInTemplateError: If the mmcif object doesn't contain
+      atom positions.
+    TemplateAtomMaskAllZerosError: If the mmcif object doesn't have any
+      unmasked residues.
+  """"""
+  if mmcif_object is None or not mmcif_object.chain_to_seqres:
+    raise NoChainsError('No chains in PDB: %s_%s' % (pdb_id, template_chain_id))
+
+  warning = None
+  try:
+    seqres, chain_id, mapping_offset = _find_template_in_pdb(
+        template_chain_id=template_chain_id,
+        template_sequence=template_sequence,
+        mmcif_object=mmcif_object)
+  except SequenceNotInTemplateError:
+    # If PDB70 contains a different version of the template, we use the sequence
+    # from the mmcif_object.
+    chain_id = template_chain_id
+    warning = (
+        f'The exact sequence {template_sequence} was not found in '
+        f'{pdb_id}_{chain_id}. Realigning the template to the actual sequence.')
+    logging.warning(warning)
+    # This throws an exception if it fails to realign the hit.
+    seqres, mapping = _realign_pdb_template_to_query(
+        old_template_sequence=template_sequence,
+        template_chain_id=template_chain_id,
+        mmcif_object=mmcif_object,
+        old_mapping=mapping,
+        kalign_binary_path=kalign_binary_path)
+    logging.info('Sequence in %s_%s: %s successfully realigned to %s',
+                 pdb_id, chain_id, template_sequence, seqres)
+    # The template sequence changed.
+    template_sequence = seqres
+    # No mapping offset, the query is aligned to the actual sequence.
+    mapping_offset = 0
+
+  try:
+    # Essentially set to infinity - we don't want to reject templates unless
+    # they're really really bad.
+    all_atom_positions, all_atom_mask = _get_atom_positions(
+        mmcif_object, chain_id, max_ca_ca_distance=150.0)
+  except (CaDistanceError, KeyError) as ex:
+    raise NoAtomDataInTemplateError(
+        'Could not get atom data (%s_%s): %s' % (pdb_id, chain_id, str(ex))
+        ) from ex
+
+  all_atom_positions = np.split(all_atom_positions, all_atom_positions.shape[0])
+  all_atom_masks = np.split(all_atom_mask, all_atom_mask.shape[0])
+
+  output_templates_sequence = []
+  templates_all_atom_positions = []
+  templates_all_atom_masks = []
+
+  for _ in query_sequence:
+    # Residues in the query_sequence that are not in the template_sequence:
+    templates_all_atom_positions.append(
+        np.zeros((residue_constants.atom_type_num, 3)))
+    templates_all_atom_masks.append(np.zeros(residue_constants.atom_type_num))
+    output_templates_sequence.append('-')
+
+  for k, v in mapping.items():
+    template_index = v + mapping_offset
+    templates_all_atom_positions[k] = all_atom_positions[template_index][0]
+    templates_all_atom_masks[k] = all_atom_masks[template_index][0]
+    output_templates_sequence[k] = template_sequence[v]
+
+  # Alanine (AA with the lowest number of atoms) has 5 atoms (C, CA, CB, N, O).
+  if np.sum(templates_all_atom_masks) < 5:
+    raise TemplateAtomMaskAllZerosError(
+        'Template all atom mask was all zeros: %s_%s. Residue range: %d-%d' %
+        (pdb_id, chain_id, min(mapping.values()) + mapping_offset,
+         max(mapping.values()) + mapping_offset))
+
+  output_templates_sequence = ''.join(output_templates_sequence)
+
+  templates_aatype = residue_constants.sequence_to_onehot(
+      output_templates_sequence, residue_constants.HHBLITS_AA_TO_ID)
+
+  return (
+      {
+          'template_all_atom_positions': np.array(templates_all_atom_positions),
+          'template_all_atom_masks': np.array(templates_all_atom_masks),
+          'template_sequence': output_templates_sequence.encode(),
+          'template_aatype': np.array(templates_aatype),
+          'template_domain_names': f'{pdb_id.lower()}_{chain_id}'.encode(),
+      },
+      warning)
+
+
+def _build_query_to_hit_index_mapping(
+    hit_query_sequence: str,
+    hit_sequence: str,
+    indices_hit: Sequence[int],
+    indices_query: Sequence[int],
+    original_query_sequence: str) -> Mapping[int, int]:
+  """"""Gets mapping from indices in original query sequence to indices in the hit.
+
+  hit_query_sequence and hit_sequence are two aligned sequences containing gap
+  characters. hit_query_sequence contains only the part of the original query
+  sequence that matched the hit. When interpreting the indices from the .hhr, we
+  need to correct for this to recover a mapping from original query sequence to
+  the hit sequence.
+
+  Args:
+    hit_query_sequence: The portion of the query sequence that is in the .hhr
+      hit
+    hit_sequence: The portion of the hit sequence that is in the .hhr
+    indices_hit: The indices for each aminoacid relative to the hit sequence
+    indices_query: The indices for each aminoacid relative to the original query
+      sequence
+    original_query_sequence: String describing the original query sequence.
+
+  Returns:
+    Dictionary with indices in the original query sequence as keys and indices
+    in the hit sequence as values.
+  """"""
+  # If the hit is empty (no aligned residues), return empty mapping
+  if not hit_query_sequence:
+    return {}
+
+  # Remove gaps and find the offset of hit.query relative to original query.
+  hhsearch_query_sequence = hit_query_sequence.replace('-', '')
+  hit_sequence = hit_sequence.replace('-', '')
+  hhsearch_query_offset = original_query_sequence.find(hhsearch_query_sequence)
+
+  # Index of -1 used for gap characters. Subtract the min index ignoring gaps.
+  min_idx = min(x for x in indices_hit if x > -1)
+  fixed_indices_hit = [
+      x - min_idx if x > -1 else -1 for x in indices_hit
+  ]
+
+  min_idx = min(x for x in indices_query if x > -1)
+  fixed_indices_query = [x - min_idx if x > -1 else -1 for x in indices_query]
+
+  # Zip the corrected indices, ignore case where both seqs have gap characters.
+  mapping = {}
+  for q_i, q_t in zip(fixed_indices_query, fixed_indices_hit):
+    if q_t != -1 and q_i != -1:
+      if (q_t >= len(hit_sequence) or
+          q_i + hhsearch_query_offset >= len(original_query_sequence)):
+        continue
+      mapping[q_i + hhsearch_query_offset] = q_t
+
+  return mapping
+
+
+@dataclasses.dataclass(frozen=True)
+class SingleHitResult:
+  features: Optional[Mapping[str, Any]]
+  error: Optional[str]
+  warning: Optional[str]
+
+
+@functools.lru_cache(16, typed=False)
+def _read_file(path):
+  with open(path, 'r') as f:
+    file_data = f.read()
+  return file_data
+
+
+def _process_single_hit(
+    query_sequence: str,
+    hit: parsers.TemplateHit,
+    mmcif_dir: str,
+    max_template_date: datetime.datetime,
+    release_dates: Mapping[str, datetime.datetime],
+    obsolete_pdbs: Mapping[str, Optional[str]],
+    kalign_binary_path: str,
+    strict_error_check: bool = False) -> SingleHitResult:
+  """"""Tries to extract template features from a single HHSearch hit.""""""
+  # Fail hard if we can't get the PDB ID and chain name from the hit.
+  hit_pdb_code, hit_chain_id = _get_pdb_id_and_chain(hit)
+
+  # This hit has been removed (obsoleted) from PDB, skip it.
+  if hit_pdb_code in obsolete_pdbs and obsolete_pdbs[hit_pdb_code] is None:
+    return SingleHitResult(
+        features=None, error=None, warning=f'Hit {hit_pdb_code} is obsolete.')
+
+  if hit_pdb_code not in release_dates:
+    if hit_pdb_code in obsolete_pdbs:
+      hit_pdb_code = obsolete_pdbs[hit_pdb_code]
+
+  # Pass hit_pdb_code since it might have changed due to the pdb being obsolete.
+  try:
+    _assess_hhsearch_hit(
+        hit=hit,
+        hit_pdb_code=hit_pdb_code,
+        query_sequence=query_sequence,
+        release_dates=release_dates,
+        release_date_cutoff=max_template_date)
+  except PrefilterError as e:
+    msg = f'hit {hit_pdb_code}_{hit_chain_id} did not pass prefilter: {str(e)}'
+    logging.info(msg)
+    if strict_error_check and isinstance(e, (DateError, DuplicateError)):
+      # In strict mode we treat some prefilter cases as errors.
+      return SingleHitResult(features=None, error=msg, warning=None)
+
+    return SingleHitResult(features=None, error=None, warning=None)
+
+  mapping = _build_query_to_hit_index_mapping(
+      hit.query, hit.hit_sequence, hit.indices_hit, hit.indices_query,
+      query_sequence)
+
+  # The mapping is from the query to the actual hit sequence, so we need to
+  # remove gaps (which regardless have a missing confidence score).
+  template_sequence = hit.hit_sequence.replace('-', '')
+
+  cif_path = os.path.join(mmcif_dir, hit_pdb_code + '.cif')
+  logging.debug('Reading PDB entry from %s. Query: %s, template: %s', cif_path,
+                query_sequence, template_sequence)
+  # Fail if we can't find the mmCIF file.
+  cif_string = _read_file(cif_path)
+
+  parsing_result = mmcif_parsing.parse(
+      file_id=hit_pdb_code, mmcif_string=cif_string)
+
+  if parsing_result.mmcif_object is not None:
+    hit_release_date = datetime.datetime.strptime(
+        parsing_result.mmcif_object.header['release_date'], '%Y-%m-%d')
+    if hit_release_date > max_template_date:
+      error = ('Template %s date (%s) > max template date (%s).' %
+               (hit_pdb_code, hit_release_date, max_template_date))
+      if strict_error_check:
+        return SingleHitResult(features=None, error=error, warning=None)
+      else:
+        logging.debug(error)
+        return SingleHitResult(features=None, error=None, warning=None)
+
+  try:
+    features, realign_warning = _extract_template_features(
+        mmcif_object=parsing_result.mmcif_object,
+        pdb_id=hit_pdb_code,
+        mapping=mapping,
+        template_sequence=template_sequence,
+        query_sequence=query_sequence,
+        template_chain_id=hit_chain_id,
+        kalign_binary_path=kalign_binary_path)
+    if hit.sum_probs is None:
+      features['template_sum_probs'] = [0]
+    else:
+      features['template_sum_probs'] = [hit.sum_probs]
+
+    # It is possible there were some errors when parsing the other chains in the
+    # mmCIF file, but the template features for the chain we want were still
+    # computed. In such case the mmCIF parsing errors are not relevant.
+    return SingleHitResult(
+        features=features, error=None, warning=realign_warning)
+  except (NoChainsError, NoAtomDataInTemplateError,
+          TemplateAtomMaskAllZerosError) as e:
+    # These 3 errors indicate missing mmCIF experimental data rather than a
+    # problem with the template search, so turn them into warnings.
+    warning = ('%s_%s (sum_probs: %s, rank: %s): feature extracting errors: '
+               '%s, mmCIF parsing errors: %s'
+               % (hit_pdb_code, hit_chain_id, hit.sum_probs, hit.index,
+                  str(e), parsing_result.errors))
+    if strict_error_check:
+      return SingleHitResult(features=None, error=warning, warning=None)
+    else:
+      return SingleHitResult(features=None, error=None, warning=warning)
+  except Error as e:
+    error = ('%s_%s (sum_probs: %.2f, rank: %d): feature extracting errors: '
+             '%s, mmCIF parsing errors: %s'
+             % (hit_pdb_code, hit_chain_id, hit.sum_probs, hit.index,
+                str(e), parsing_result.errors))
+    return SingleHitResult(features=None, error=error, warning=None)
+
+
+@dataclasses.dataclass(frozen=True)
+class TemplateSearchResult:
+  features: Mapping[str, Any]
+  errors: Sequence[str]
+  warnings: Sequence[str]
+
+
+class TemplateHitFeaturizer(abc.ABC):
+  """"""An abstract base class for turning template hits to template features.""""""
+
+  def __init__(
+      self,
+      mmcif_dir: str,
+      max_template_date: str,
+      max_hits: int,
+      kalign_binary_path: str,
+      release_dates_path: Optional[str],
+      obsolete_pdbs_path: Optional[str],
+      strict_error_check: bool = False):
+    """"""Initializes the Template Search.
+
+    Args:
+      mmcif_dir: Path to a directory with mmCIF structures. Once a template ID
+        is found by HHSearch, this directory is used to retrieve the template
+        data.
+      max_template_date: The maximum date permitted for template structures. No
+        template with date higher than this date will be returned. In ISO8601
+        date format, YYYY-MM-DD.
+      max_hits: The maximum number of templates that will be returned.
+      kalign_binary_path: The path to a kalign executable used for template
+        realignment.
+      release_dates_path: An optional path to a file with a mapping from PDB IDs
+        to their release dates. Thanks to this we don't have to redundantly
+        parse mmCIF files to get that information.
+      obsolete_pdbs_path: An optional path to a file containing a mapping from
+        obsolete PDB IDs to the PDB IDs of their replacements.
+      strict_error_check: If True, then the following will be treated as errors:
+        * If any template date is after the max_template_date.
+        * If any template has identical PDB ID to the query.
+        * If any template is a duplicate of the query.
+        * Any feature computation errors.
+    """"""
+    self._mmcif_dir = mmcif_dir
+    if not glob.glob(os.path.join(self._mmcif_dir, '*.cif')):
+      logging.error('Could not find CIFs in %s', self._mmcif_dir)
+      raise ValueError(f'Could not find CIFs in {self._mmcif_dir}')
+
+    try:
+      self._max_template_date = datetime.datetime.strptime(
+          max_template_date, '%Y-%m-%d')
+    except ValueError:
+      raise ValueError(
+          'max_template_date must be set and have format YYYY-MM-DD.')
+    self._max_hits = max_hits
+    self._kalign_binary_path = kalign_binary_path
+    self._strict_error_check = strict_error_check
+
+    if release_dates_path:
+      logging.info('Using precomputed release dates %s.', release_dates_path)
+      self._release_dates = _parse_release_dates(release_dates_path)
+    else:
+      self._release_dates = {}
+
+    if obsolete_pdbs_path:
+      logging.info('Using precomputed obsolete pdbs %s.', obsolete_pdbs_path)
+      self._obsolete_pdbs = _parse_obsolete(obsolete_pdbs_path)
+    else:
+      self._obsolete_pdbs = {}
+
+  @abc.abstractmethod
+  def get_templates(
+      self,
+      query_sequence: str,
+      hits: Sequence[parsers.TemplateHit]) -> TemplateSearchResult:
+    """"""Computes the templates for given query sequence.""""""
+
+
+class HhsearchHitFeaturizer(TemplateHitFeaturizer):
+  """"""A class for turning a3m hits from hhsearch to template features.""""""
+
+  def get_templates(
+      self,
+      query_sequence: str,
+      hits: Sequence[parsers.TemplateHit]) -> TemplateSearchResult:
+    """"""Computes the templates for given query sequence (more details above).""""""
+    logging.info('Searching for template for: %s', query_sequence)
+
+    template_features = {}
+    for template_feature_name in TEMPLATE_FEATURES:
+      template_features[template_feature_name] = []
+
+    num_hits = 0
+    errors = []
+    warnings = []
+
+    for hit in sorted(hits, key=lambda x: x.sum_probs, reverse=True):
+      # We got all the templates we wanted, stop processing hits.
+      if num_hits >= self._max_hits:
+        break
+
+      result = _process_single_hit(
+          query_sequence=query_sequence,
+          hit=hit,
+          mmcif_dir=self._mmcif_dir,
+          max_template_date=self._max_template_date,
+          release_dates=self._release_dates,
+          obsolete_pdbs=self._obsolete_pdbs,
+          strict_error_check=self._strict_error_check,
+          kalign_binary_path=self._kalign_binary_path)
+
+      if result.error:
+        errors.append(result.error)
+
+      # There could be an error even if there are some results, e.g. thrown by
+      # other unparsable chains in the same mmCIF file.
+      if result.warning:
+        warnings.append(result.warning)
+
+      if result.features is None:
+        logging.info('Skipped invalid hit %s, error: %s, warning: %s',
+                     hit.name, result.error, result.warning)
+      else:
+        # Increment the hit counter, since we got features out of this hit.
+        num_hits += 1
+        for k in template_features:
+          template_features[k].append(result.features[k])
+
+    for name in template_features:
+      if num_hits > 0:
+        template_features[name] = np.stack(
+            template_features[name], axis=0).astype(TEMPLATE_FEATURES[name])
+      else:
+        # Make sure the feature has correct dtype even if empty.
+        template_features[name] = np.array([], dtype=TEMPLATE_FEATURES[name])
+
+    return TemplateSearchResult(
+        features=template_features, errors=errors, warnings=warnings)
+
+
+class HmmsearchHitFeaturizer(TemplateHitFeaturizer):
+  """"""A class for turning a3m hits from hmmsearch to template features.""""""
+
+  def get_templates(
+      self,
+      query_sequence: str,
+      hits: Sequence[parsers.TemplateHit]) -> TemplateSearchResult:
+    """"""Computes the templates for given query sequence (more details above).""""""
+    logging.info('Searching for template for: %s', query_sequence)
+
+    template_features = {}
+    for template_feature_name in TEMPLATE_FEATURES:
+      template_features[template_feature_name] = []
+
+    already_seen = set()
+    errors = []
+    warnings = []
+
+    if not hits or hits[0].sum_probs is None:
+      sorted_hits = hits
+    else:
+      sorted_hits = sorted(hits, key=lambda x: x.sum_probs, reverse=True)
+
+    for hit in sorted_hits:
+      # We got all the templates we wanted, stop processing hits.
+      if len(already_seen) >= self._max_hits:
+        break
+
+      result = _process_single_hit(
+          query_sequence=query_sequence,
+          hit=hit,
+          mmcif_dir=self._mmcif_dir,
+          max_template_date=self._max_template_date,
+          release_dates=self._release_dates,
+          obsolete_pdbs=self._obsolete_pdbs,
+          strict_error_check=self._strict_error_check,
+          kalign_binary_path=self._kalign_binary_path)
+
+      if result.error:
+        errors.append(result.error)
+
+      # There could be an error even if there are some results, e.g. thrown by
+      # other unparsable chains in the same mmCIF file.
+      if result.warning:
+        warnings.append(result.warning)
+
+      if result.features is None:
+        logging.debug('Skipped invalid hit %s, error: %s, warning: %s',
+                      hit.name, result.error, result.warning)
+      else:
+        already_seen_key = result.features['template_sequence']
+        if already_seen_key in already_seen:
+          continue
+        # Increment the hit counter, since we got features out of this hit.
+        already_seen.add(already_seen_key)
+        for k in template_features:
+          template_features[k].append(result.features[k])
+
+    if already_seen:
+      for name in template_features:
+        template_features[name] = np.stack(
+            template_features[name], axis=0).astype(TEMPLATE_FEATURES[name])
+    else:
+      num_res = len(query_sequence)
+      # Construct a default template with all zeros.
+      template_features = {
+          'template_aatype': np.zeros(
+              (1, num_res, len(residue_constants.restypes_with_x_and_gap)),
+              np.float32),
+          'template_all_atom_masks': np.zeros(
+              (1, num_res, residue_constants.atom_type_num), np.float32),
+          'template_all_atom_positions': np.zeros(
+              (1, num_res, residue_constants.atom_type_num, 3), np.float32),
+          'template_domain_names': np.array([''.encode()], dtype=object),
+          'template_sequence': np.array([''.encode()], dtype=object),
+          'template_sum_probs': np.array([0], dtype=np.float32)
+      }
+    return TemplateSearchResult(
+        features=template_features, errors=errors, warnings=warnings)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/parsers.py",".py","22226","638","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Functions for parsing various file formats.""""""
+import collections
+import dataclasses
+import itertools
+import re
+import string
+from typing import Dict, Iterable, List, Optional, Sequence, Tuple, Set
+
+# Internal import (7716).
+
+
+DeletionMatrix = Sequence[Sequence[int]]
+
+
+@dataclasses.dataclass(frozen=True)
+class Msa:
+  """"""Class representing a parsed MSA file.""""""
+  sequences: Sequence[str]
+  deletion_matrix: DeletionMatrix
+  descriptions: Sequence[str]
+
+  def __post_init__(self):
+    if not (len(self.sequences) ==
+            len(self.deletion_matrix) ==
+            len(self.descriptions)):
+      raise ValueError(
+          'All fields for an MSA must have the same length. '
+          f'Got {len(self.sequences)} sequences, '
+          f'{len(self.deletion_matrix)} rows in the deletion matrix and '
+          f'{len(self.descriptions)} descriptions.')
+
+  def __len__(self):
+    return len(self.sequences)
+
+  def truncate(self, max_seqs: int):
+    return Msa(sequences=self.sequences[:max_seqs],
+               deletion_matrix=self.deletion_matrix[:max_seqs],
+               descriptions=self.descriptions[:max_seqs])
+
+
+@dataclasses.dataclass(frozen=True)
+class TemplateHit:
+  """"""Class representing a template hit.""""""
+  index: int
+  name: str
+  aligned_cols: int
+  sum_probs: Optional[float]
+  query: str
+  hit_sequence: str
+  indices_query: List[int]
+  indices_hit: List[int]
+
+
+def parse_fasta(fasta_string: str) -> Tuple[Sequence[str], Sequence[str]]:
+  """"""Parses FASTA string and returns list of strings with amino-acid sequences.
+
+  Arguments:
+    fasta_string: The string contents of a FASTA file.
+
+  Returns:
+    A tuple of two lists:
+    * A list of sequences.
+    * A list of sequence descriptions taken from the comment lines. In the
+      same order as the sequences.
+  """"""
+  sequences = []
+  descriptions = []
+  index = -1
+  for line in fasta_string.splitlines():
+    line = line.strip()
+    if line.startswith('>'):
+      index += 1
+      descriptions.append(line[1:])  # Remove the '>' at the beginning.
+      sequences.append('')
+      continue
+    elif not line:
+      continue  # Skip blank lines.
+    sequences[index] += line
+
+  # Use gap to break a single chain
+  for index,sequence in enumerate(sequences):
+    if "":"" in sequence:
+      sequences[index]=sequence.upper().split("":"")
+      
+  return sequences, descriptions
+
+
+def parse_stockholm(stockholm_string: str) -> Msa:
+  """"""Parses sequences and deletion matrix from stockholm format alignment.
+
+  Args:
+    stockholm_string: The string contents of a stockholm file. The first
+      sequence in the file should be the query sequence.
+
+  Returns:
+    A tuple of:
+      * A list of sequences that have been aligned to the query. These
+        might contain duplicates.
+      * The deletion matrix for the alignment as a list of lists. The element
+        at `deletion_matrix[i][j]` is the number of residues deleted from
+        the aligned sequence i at residue position j.
+      * The names of the targets matched, including the jackhmmer subsequence
+        suffix.
+  """"""
+  name_to_sequence = collections.OrderedDict()
+  for line in stockholm_string.splitlines():
+    line = line.strip()
+    if not line or line.startswith(('#', '//')):
+      continue
+    name, sequence = line.split()
+    if name not in name_to_sequence:
+      name_to_sequence[name] = ''
+    name_to_sequence[name] += sequence
+
+  msa = []
+  deletion_matrix = []
+
+  query = ''
+  keep_columns = []
+  for seq_index, sequence in enumerate(name_to_sequence.values()):
+    if seq_index == 0:
+      # Gather the columns with gaps from the query
+      query = sequence
+      keep_columns = [i for i, res in enumerate(query) if res != '-']
+
+    # Remove the columns with gaps in the query from all sequences.
+    aligned_sequence = ''.join([sequence[c] for c in keep_columns])
+
+    msa.append(aligned_sequence)
+
+    # Count the number of deletions w.r.t. query.
+    deletion_vec = []
+    deletion_count = 0
+    for seq_res, query_res in zip(sequence, query):
+      if seq_res != '-' or query_res != '-':
+        if query_res == '-':
+          deletion_count += 1
+        else:
+          deletion_vec.append(deletion_count)
+          deletion_count = 0
+    deletion_matrix.append(deletion_vec)
+
+  return Msa(sequences=msa,
+             deletion_matrix=deletion_matrix,
+             descriptions=list(name_to_sequence.keys()))
+
+
+def parse_a3m(a3m_string: str) -> Msa:
+  """"""Parses sequences and deletion matrix from a3m format alignment.
+
+  Args:
+    a3m_string: The string contents of a a3m file. The first sequence in the
+      file should be the query sequence.
+
+  Returns:
+    A tuple of:
+      * A list of sequences that have been aligned to the query. These
+        might contain duplicates.
+      * The deletion matrix for the alignment as a list of lists. The element
+        at `deletion_matrix[i][j]` is the number of residues deleted from
+        the aligned sequence i at residue position j.
+      * A list of descriptions, one per sequence, from the a3m file.
+  """"""
+  sequences, descriptions = parse_fasta(a3m_string)
+  deletion_matrix = []
+  for msa_sequence in sequences:
+    deletion_vec = []
+    deletion_count = 0
+    for j in msa_sequence:
+      if j.islower():
+        deletion_count += 1
+      else:
+        deletion_vec.append(deletion_count)
+        deletion_count = 0
+    deletion_matrix.append(deletion_vec)
+
+  # Make the MSA matrix out of aligned (deletion-free) sequences.
+  deletion_table = str.maketrans('', '', string.ascii_lowercase)
+  aligned_sequences = [s.translate(deletion_table) for s in sequences]
+  return Msa(sequences=aligned_sequences,
+             deletion_matrix=deletion_matrix,
+             descriptions=descriptions)
+
+
+def _convert_sto_seq_to_a3m(
+    query_non_gaps: Sequence[bool], sto_seq: str) -> Iterable[str]:
+  for is_query_res_non_gap, sequence_res in zip(query_non_gaps, sto_seq):
+    if is_query_res_non_gap:
+      yield sequence_res
+    elif sequence_res != '-':
+      yield sequence_res.lower()
+
+
+def convert_stockholm_to_a3m(stockholm_format: str,
+                             max_sequences: Optional[int] = None,
+                             remove_first_row_gaps: bool = True) -> str:
+  """"""Converts MSA in Stockholm format to the A3M format.""""""
+  descriptions = {}
+  sequences = {}
+  reached_max_sequences = False
+
+  for line in stockholm_format.splitlines():
+    reached_max_sequences = max_sequences and len(sequences) >= max_sequences
+    if line.strip() and not line.startswith(('#', '//')):
+      # Ignore blank lines, markup and end symbols - remainder are alignment
+      # sequence parts.
+      seqname, aligned_seq = line.split(maxsplit=1)
+      if seqname not in sequences:
+        if reached_max_sequences:
+          continue
+        sequences[seqname] = ''
+      sequences[seqname] += aligned_seq
+
+  for line in stockholm_format.splitlines():
+    if line[:4] == '#=GS':
+      # Description row - example format is:
+      # #=GS UniRef90_Q9H5Z4/4-78            DE [subseq from] cDNA: FLJ22755 ...
+      columns = line.split(maxsplit=3)
+      seqname, feature = columns[1:3]
+      value = columns[3] if len(columns) == 4 else ''
+      if feature != 'DE':
+        continue
+      if reached_max_sequences and seqname not in sequences:
+        continue
+      descriptions[seqname] = value
+      if len(descriptions) == len(sequences):
+        break
+
+  # Convert sto format to a3m line by line
+  a3m_sequences = {}
+  if remove_first_row_gaps:
+    # query_sequence is assumed to be the first sequence
+    query_sequence = next(iter(sequences.values()))
+    query_non_gaps = [res != '-' for res in query_sequence]
+  for seqname, sto_sequence in sequences.items():
+    # Dots are optional in a3m format and are commonly removed.
+    out_sequence = sto_sequence.replace('.', '')
+    if remove_first_row_gaps:
+      out_sequence = ''.join(
+          _convert_sto_seq_to_a3m(query_non_gaps, out_sequence))
+    a3m_sequences[seqname] = out_sequence
+
+  fasta_chunks = (f"">{k} {descriptions.get(k, '')}\n{a3m_sequences[k]}""
+                  for k in a3m_sequences)
+  return '\n'.join(fasta_chunks) + '\n'  # Include terminating newline.
+
+
+def _keep_line(line: str, seqnames: Set[str]) -> bool:
+  """"""Function to decide which lines to keep.""""""
+  if not line.strip():
+    return True
+  if line.strip() == '//':  # End tag
+    return True
+  if line.startswith('# STOCKHOLM'):  # Start tag
+    return True
+  if line.startswith('#=GC RF'):  # Reference Annotation Line
+    return True
+  if line[:4] == '#=GS':  # Description lines - keep if sequence in list.
+    _, seqname, _ = line.split(maxsplit=2)
+    return seqname in seqnames
+  elif line.startswith('#'):  # Other markup - filter out
+    return False
+  else:  # Alignment data - keep if sequence in list.
+    seqname = line.partition(' ')[0]
+    return seqname in seqnames
+
+
+def truncate_stockholm_msa(stockholm_msa_path: str, max_sequences: int) -> str:
+  """"""Reads + truncates a Stockholm file while preventing excessive RAM usage.""""""
+  seqnames = set()
+  filtered_lines = []
+
+  with open(stockholm_msa_path) as f:
+    for line in f:
+      if line.strip() and not line.startswith(('#', '//')):
+        # Ignore blank lines, markup and end symbols - remainder are alignment
+        # sequence parts.
+        seqname = line.partition(' ')[0]
+        seqnames.add(seqname)
+        if len(seqnames) >= max_sequences:
+          break
+
+    f.seek(0)
+    for line in f:
+      if _keep_line(line, seqnames):
+        filtered_lines.append(line)
+
+  return ''.join(filtered_lines)
+
+def truncate_stockholm_msa2(stockholm_msa: str, max_sequences: int) -> str:
+  """"""Reads + truncates a Stockholm alignment - BP 12/15/22.""""""
+  seqnames = set()
+  filtered_lines = []
+  
+  for line in stockholm_msa.splitlines():    
+    if line.strip() and not line.startswith(('#', '//')):
+      # Ignore blank lines, markup and end symbols - remainder are alignment
+      # sequence parts.
+      seqname = line.partition(' ')[0]
+      seqnames.add(seqname)
+      if len(seqnames) >= max_sequences:
+        break
+
+  for line in stockholm_msa.splitlines():
+    if _keep_line(line, seqnames):
+      filtered_lines.append(line)
+
+  return '\n'.join(filtered_lines) + '\n'
+
+def remove_empty_columns_from_stockholm_msa(stockholm_msa: str) -> str:
+  """"""Removes empty columns (dashes-only) from a Stockholm MSA.""""""
+  processed_lines = {}
+  unprocessed_lines = {}
+  for i, line in enumerate(stockholm_msa.splitlines()):
+    if line.startswith('#=GC RF'):
+      reference_annotation_i = i
+      reference_annotation_line = line
+      # Reached the end of this chunk of the alignment. Process chunk.
+      _, _, first_alignment = line.rpartition(' ')
+      mask = []
+      for j in range(len(first_alignment)):
+        for _, unprocessed_line in unprocessed_lines.items():
+          prefix, _, alignment = unprocessed_line.rpartition(' ')
+          if alignment[j] != '-':
+            mask.append(True)
+            break
+        else:  # Every row contained a hyphen - empty column.
+          mask.append(False)
+      # Add reference annotation for processing with mask.
+      unprocessed_lines[reference_annotation_i] = reference_annotation_line
+
+      if not any(mask):  # All columns were empty. Output empty lines for chunk.
+        for line_index in unprocessed_lines:
+          processed_lines[line_index] = ''
+      else:
+        for line_index, unprocessed_line in unprocessed_lines.items():
+          prefix, _, alignment = unprocessed_line.rpartition(' ')
+          masked_alignment = ''.join(itertools.compress(alignment, mask))
+          processed_lines[line_index] = f'{prefix} {masked_alignment}'
+
+      # Clear raw_alignments.
+      unprocessed_lines = {}
+    elif line.strip() and not line.startswith(('#', '//')):
+      unprocessed_lines[i] = line
+    else:
+      processed_lines[i] = line
+  return '\n'.join((processed_lines[i] for i in range(len(processed_lines))))
+
+
+def deduplicate_stockholm_msa(stockholm_msa: str) -> str:
+  """"""Remove duplicate sequences (ignoring insertions wrt query).""""""
+  sequence_dict = collections.defaultdict(str)
+
+  # First we must extract all sequences from the MSA.
+  for line in stockholm_msa.splitlines():
+    # Only consider the alignments - ignore reference annotation, empty lines,
+    # descriptions or markup.
+    if line.strip() and not line.startswith(('#', '//')):
+      line = line.strip()
+      seqname, alignment = line.split()
+      sequence_dict[seqname] += alignment
+
+  seen_sequences = set()
+  seqnames = set()
+  # First alignment is the query.
+  query_align = next(iter(sequence_dict.values()))
+  mask = [c != '-' for c in query_align]  # Mask is False for insertions.
+  for seqname, alignment in sequence_dict.items():
+    # Apply mask to remove all insertions from the string.
+    masked_alignment = ''.join(itertools.compress(alignment, mask))
+    if masked_alignment in seen_sequences:
+      continue
+    else:
+      seen_sequences.add(masked_alignment)
+      seqnames.add(seqname)
+
+  filtered_lines = []
+  for line in stockholm_msa.splitlines():
+    if _keep_line(line, seqnames):
+      filtered_lines.append(line)
+
+  return '\n'.join(filtered_lines) + '\n'
+
+
+def _get_hhr_line_regex_groups(
+    regex_pattern: str, line: str) -> Sequence[Optional[str]]:
+  match = re.match(regex_pattern, line)
+  if match is None:
+    raise RuntimeError(f'Could not parse query line {line}')
+  return match.groups()
+
+
+def _update_hhr_residue_indices_list(
+    sequence: str, start_index: int, indices_list: List[int]):
+  """"""Computes the relative indices for each residue with respect to the original sequence.""""""
+  counter = start_index
+  for symbol in sequence:
+    if symbol == '-':
+      indices_list.append(-1)
+    else:
+      indices_list.append(counter)
+      counter += 1
+
+
+def _parse_hhr_hit(detailed_lines: Sequence[str]) -> TemplateHit:
+  """"""Parses the detailed HMM HMM comparison section for a single Hit.
+
+  This works on .hhr files generated from both HHBlits and HHSearch.
+
+  Args:
+    detailed_lines: A list of lines from a single comparison section between 2
+      sequences (which each have their own HMM's)
+
+  Returns:
+    A dictionary with the information from that detailed comparison section
+
+  Raises:
+    RuntimeError: If a certain line cannot be processed
+  """"""
+  # Parse first 2 lines.
+  number_of_hit = int(detailed_lines[0].split()[-1])
+  name_hit = detailed_lines[1][1:]
+
+  # Parse the summary line.
+  pattern = (
+      'Probab=(.*)[\t ]*E-value=(.*)[\t ]*Score=(.*)[\t ]*Aligned_cols=(.*)[\t'
+      ' ]*Identities=(.*)%[\t ]*Similarity=(.*)[\t ]*Sum_probs=(.*)[\t '
+      ']*Template_Neff=(.*)')
+  match = re.match(pattern, detailed_lines[2])
+  if match is None:
+    raise RuntimeError(
+        'Could not parse section: %s. Expected this: \n%s to contain summary.' %
+        (detailed_lines, detailed_lines[2]))
+  (_, _, _, aligned_cols, _, _, sum_probs, _) = [float(x)
+                                                 for x in match.groups()]
+
+  # The next section reads the detailed comparisons. These are in a 'human
+  # readable' format which has a fixed length. The strategy employed is to
+  # assume that each block starts with the query sequence line, and to parse
+  # that with a regexp in order to deduce the fixed length used for that block.
+  query = ''
+  hit_sequence = ''
+  indices_query = []
+  indices_hit = []
+  length_block = None
+
+  for line in detailed_lines[3:]:
+    # Parse the query sequence line
+    if (line.startswith('Q ') and not line.startswith('Q ss_dssp') and
+        not line.startswith('Q ss_pred') and
+        not line.startswith('Q Consensus')):
+      # Thus the first 17 characters must be 'Q <query_name> ', and we can parse
+      # everything after that.
+      #              start    sequence       end       total_sequence_length
+      patt = r'[\t ]*([0-9]*) ([A-Z-]*)[\t ]*([0-9]*) \([0-9]*\)'
+      groups = _get_hhr_line_regex_groups(patt, line[17:])
+
+      # Get the length of the parsed block using the start and finish indices,
+      # and ensure it is the same as the actual block length.
+      start = int(groups[0]) - 1  # Make index zero based.
+      delta_query = groups[1]
+      end = int(groups[2])
+      num_insertions = len([x for x in delta_query if x == '-'])
+      length_block = end - start + num_insertions
+      assert length_block == len(delta_query)
+
+      # Update the query sequence and indices list.
+      query += delta_query
+      _update_hhr_residue_indices_list(delta_query, start, indices_query)
+
+    elif line.startswith('T '):
+      # Parse the hit sequence.
+      if (not line.startswith('T ss_dssp') and
+          not line.startswith('T ss_pred') and
+          not line.startswith('T Consensus')):
+        # Thus the first 17 characters must be 'T <hit_name> ', and we can
+        # parse everything after that.
+        #              start    sequence       end     total_sequence_length
+        patt = r'[\t ]*([0-9]*) ([A-Z-]*)[\t ]*[0-9]* \([0-9]*\)'
+        groups = _get_hhr_line_regex_groups(patt, line[17:])
+        start = int(groups[0]) - 1  # Make index zero based.
+        delta_hit_sequence = groups[1]
+        assert length_block == len(delta_hit_sequence)
+
+        # Update the hit sequence and indices list.
+        hit_sequence += delta_hit_sequence
+        _update_hhr_residue_indices_list(delta_hit_sequence, start, indices_hit)
+
+  return TemplateHit(
+      index=number_of_hit,
+      name=name_hit,
+      aligned_cols=int(aligned_cols),
+      sum_probs=sum_probs,
+      query=query,
+      hit_sequence=hit_sequence,
+      indices_query=indices_query,
+      indices_hit=indices_hit,
+  )
+
+
+def parse_hhr(hhr_string: str) -> Sequence[TemplateHit]:
+  """"""Parses the content of an entire HHR file.""""""
+  lines = hhr_string.splitlines()
+
+  # Each .hhr file starts with a results table, then has a sequence of hit
+  # ""paragraphs"", each paragraph starting with a line 'No <hit number>'. We
+  # iterate through each paragraph to parse each hit.
+
+  block_starts = [i for i, line in enumerate(lines) if line.startswith('No ')]
+
+  hits = []
+  if block_starts:
+    block_starts.append(len(lines))  # Add the end of the final block.
+    for i in range(len(block_starts) - 1):
+      hits.append(_parse_hhr_hit(lines[block_starts[i]:block_starts[i + 1]]))
+  return hits
+
+
+def parse_e_values_from_tblout(tblout: str) -> Dict[str, float]:
+  """"""Parse target to e-value mapping parsed from Jackhmmer tblout string.""""""
+  e_values = {'query': 0}
+  lines = [line for line in tblout.splitlines() if line[0] != '#']
+  # As per http://eddylab.org/software/hmmer/Userguide.pdf fields are
+  # space-delimited. Relevant fields are (1) target name:  and
+  # (5) E-value (full sequence) (numbering from 1).
+  for line in lines:
+    fields = line.split()
+    e_value = fields[4]
+    target_name = fields[0]
+    e_values[target_name] = float(e_value)
+  return e_values
+
+
+def _get_indices(sequence: str, start: int) -> List[int]:
+  """"""Returns indices for non-gap/insert residues starting at the given index.""""""
+  indices = []
+  counter = start
+  for symbol in sequence:
+    # Skip gaps but add a placeholder so that the alignment is preserved.
+    if symbol == '-':
+      indices.append(-1)
+    # Skip deleted residues, but increase the counter.
+    elif symbol.islower():
+      counter += 1
+    # Normal aligned residue. Increase the counter and append to indices.
+    else:
+      indices.append(counter)
+      counter += 1
+  return indices
+
+
+@dataclasses.dataclass(frozen=True)
+class HitMetadata:
+  pdb_id: str
+  chain: str
+  start: int
+  end: int
+  length: int
+  text: str
+
+
+def _parse_hmmsearch_description(description: str) -> HitMetadata:
+  """"""Parses the hmmsearch A3M sequence description line.""""""
+  # Example 1: >4pqx_A/2-217 [subseq from] mol:protein length:217  Free text
+  # Example 2: >5g3r_A/1-55 [subseq from] mol:protein length:352
+  match = re.match(
+      r'^>?([a-z0-9]+)_(\w+)/([0-9]+)-([0-9]+).*protein length:([0-9]+) *(.*)$',
+      description.strip())
+
+  if not match:
+    raise ValueError(f'Could not parse description: ""{description}"".')
+
+  return HitMetadata(
+      pdb_id=match[1],
+      chain=match[2],
+      start=int(match[3]),
+      end=int(match[4]),
+      length=int(match[5]),
+      text=match[6])
+
+
+def parse_hmmsearch_a3m(query_sequence: str,
+                        a3m_string: str,
+                        skip_first: bool = True) -> Sequence[TemplateHit]:
+  """"""Parses an a3m string produced by hmmsearch.
+
+  Args:
+    query_sequence: The query sequence.
+    a3m_string: The a3m string produced by hmmsearch.
+    skip_first: Whether to skip the first sequence in the a3m string.
+
+  Returns:
+    A sequence of `TemplateHit` results.
+  """"""
+  # Zip the descriptions and MSAs together, skip the first query sequence.
+  parsed_a3m = list(zip(*parse_fasta(a3m_string)))
+  if skip_first:
+    parsed_a3m = parsed_a3m[1:]
+
+  indices_query = _get_indices(query_sequence, start=0)
+
+  hits = []
+  for i, (hit_sequence, hit_description) in enumerate(parsed_a3m, start=1):
+    if 'mol:protein' not in hit_description:
+      continue  # Skip non-protein chains.
+    metadata = _parse_hmmsearch_description(hit_description)
+    # Aligned columns are only the match states.
+    aligned_cols = sum([r.isupper() and r != '-' for r in hit_sequence])
+    indices_hit = _get_indices(hit_sequence, start=metadata.start - 1)
+
+    hit = TemplateHit(
+        index=i,
+        name=f'{metadata.pdb_id}_{metadata.chain}',
+        aligned_cols=aligned_cols,
+        sum_probs=None,
+        query=query_sequence,
+        hit_sequence=hit_sequence.upper(),
+        indices_query=indices_query,
+        indices_hit=indices_hit,
+    )
+    hits.append(hit)
+
+  return hits
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/msa_identifiers.py",".py","2966","91","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Utilities for extracting identifiers from MSA sequence descriptions.""""""
+
+import dataclasses
+import re
+from typing import Optional
+
+
+# Sequences coming from UniProtKB database come in the
+# `db|UniqueIdentifier|EntryName` format, e.g. `tr|A0A146SKV9|A0A146SKV9_FUNHE`
+# or `sp|P0C2L1|A3X1_LOXLA` (for TREMBL/Swiss-Prot respectively).
+_UNIPROT_PATTERN = re.compile(
+    r""""""
+    ^
+    # UniProtKB/TrEMBL or UniProtKB/Swiss-Prot
+    (?:tr|sp)
+    \|
+    # A primary accession number of the UniProtKB entry.
+    (?P<AccessionIdentifier>[A-Za-z0-9]{6,10})
+    # Occasionally there is a _0 or _1 isoform suffix, which we ignore.
+    (?:_\d)?
+    \|
+    # TREMBL repeats the accession ID here. Swiss-Prot has a mnemonic
+    # protein ID code.
+    (?:[A-Za-z0-9]+)
+    _
+    # A mnemonic species identification code.
+    (?P<SpeciesIdentifier>([A-Za-z0-9]){1,5})
+    # Small BFD uses a final value after an underscore, which we ignore.
+    (?:_\d+)?
+    $
+    """""",
+    re.VERBOSE)
+
+
+@dataclasses.dataclass(frozen=True)
+class Identifiers:
+  species_id: str = ''
+
+
+def _parse_sequence_identifier(msa_sequence_identifier: str) -> Identifiers:
+  """"""Gets species from an msa sequence identifier.
+
+  The sequence identifier has the format specified by
+  _UNIPROT_TREMBL_ENTRY_NAME_PATTERN or _UNIPROT_SWISSPROT_ENTRY_NAME_PATTERN.
+  An example of a sequence identifier: `tr|A0A146SKV9|A0A146SKV9_FUNHE`
+
+  Args:
+    msa_sequence_identifier: a sequence identifier.
+
+  Returns:
+    An `Identifiers` instance with species_id. These
+    can be empty in the case where no identifier was found.
+  """"""
+  matches = re.search(_UNIPROT_PATTERN, msa_sequence_identifier.strip())
+  if matches:
+    return Identifiers(
+        species_id=matches.group('SpeciesIdentifier'))
+  return Identifiers()
+
+
+def _extract_sequence_identifier(description: str) -> Optional[str]:
+  """"""Extracts sequence identifier from description. Returns None if no match.""""""
+  split_description = description.split()
+  if split_description:
+    return split_description[0].partition('/')[0]
+  else:
+    return None
+
+
+def get_identifiers(description: str) -> Identifiers:
+  """"""Computes extra MSA features from the description.""""""
+  sequence_identifier = _extract_sequence_identifier(description)
+  if sequence_identifier is None:
+    return Identifiers()
+  else:
+    return _parse_sequence_identifier(sequence_identifier)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/tools/jackhmmer.py",".py","8386","222","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Library to run Jackhmmer from Python.""""""
+
+from concurrent import futures
+import glob
+import os
+import subprocess
+from typing import Any, Callable, Mapping, Optional, Sequence
+from urllib import request
+
+from absl import logging
+
+from alphafold.data import parsers
+from alphafold.data.tools import utils
+# Internal import (7716).
+
+
+class Jackhmmer:
+  """"""Python wrapper of the Jackhmmer binary.""""""
+
+  def __init__(self,
+               *,
+               binary_path: str,
+               database_path: str,
+               n_cpu: int = 8,
+               n_iter: int = 1,
+               e_value: float = 0.0001,
+               z_value: Optional[int] = None,
+               get_tblout: bool = False,
+               filter_f1: float = 0.0005,
+               filter_f2: float = 0.00005,
+               filter_f3: float = 0.0000005,
+               incdom_e: Optional[float] = None,
+               dom_e: Optional[float] = None,
+               num_streamed_chunks: Optional[int] = None,
+               streaming_callback: Optional[Callable[[int], None]] = None):
+    """"""Initializes the Python Jackhmmer wrapper.
+
+    Args:
+      binary_path: The path to the jackhmmer executable.
+      database_path: The path to the jackhmmer database (FASTA format).
+      n_cpu: The number of CPUs to give Jackhmmer.
+      n_iter: The number of Jackhmmer iterations.
+      e_value: The E-value, see Jackhmmer docs for more details.
+      z_value: The Z-value, see Jackhmmer docs for more details.
+      get_tblout: Whether to save tblout string.
+      filter_f1: MSV and biased composition pre-filter, set to >1.0 to turn off.
+      filter_f2: Viterbi pre-filter, set to >1.0 to turn off.
+      filter_f3: Forward pre-filter, set to >1.0 to turn off.
+      incdom_e: Domain e-value criteria for inclusion of domains in MSA/next
+        round.
+      dom_e: Domain e-value criteria for inclusion in tblout.
+      num_streamed_chunks: Number of database chunks to stream over.
+      streaming_callback: Callback function run after each chunk iteration with
+        the iteration number as argument.
+    """"""
+    self.binary_path = binary_path
+    self.database_path = database_path
+    self.num_streamed_chunks = num_streamed_chunks
+
+    if not os.path.exists(self.database_path) and num_streamed_chunks is None:
+      logging.error('Could not find Jackhmmer database %s', database_path)
+      raise ValueError(f'Could not find Jackhmmer database {database_path}')
+
+    self.n_cpu = n_cpu
+    self.n_iter = n_iter
+    self.e_value = e_value
+    self.z_value = z_value
+    self.filter_f1 = filter_f1
+    self.filter_f2 = filter_f2
+    self.filter_f3 = filter_f3
+    self.incdom_e = incdom_e
+    self.dom_e = dom_e
+    self.get_tblout = get_tblout
+    self.streaming_callback = streaming_callback
+
+  def _query_chunk(self,
+                   input_fasta_path: str,
+                   database_path: str,
+                   max_sequences: Optional[int] = None) -> Mapping[str, Any]:
+    """"""Queries the database chunk using Jackhmmer.""""""
+    with utils.tmpdir_manager() as query_tmp_dir:
+      sto_path = os.path.join(query_tmp_dir, 'output.sto')
+
+      # The F1/F2/F3 are the expected proportion to pass each of the filtering
+      # stages (which get progressively more expensive), reducing these
+      # speeds up the pipeline at the expensive of sensitivity.  They are
+      # currently set very low to make querying Mgnify run in a reasonable
+      # amount of time.
+      cmd_flags = [
+          # Don't pollute stdout with Jackhmmer output.
+          '-o', '/dev/null',
+          '-A', sto_path,
+          '--noali',
+          '--F1', str(self.filter_f1),
+          '--F2', str(self.filter_f2),
+          '--F3', str(self.filter_f3),
+          '--incE', str(self.e_value),
+          # Report only sequences with E-values <= x in per-sequence output.
+          '-E', str(self.e_value),
+          '--cpu', str(self.n_cpu),
+          '-N', str(self.n_iter)
+      ]
+      if self.get_tblout:
+        tblout_path = os.path.join(query_tmp_dir, 'tblout.txt')
+        cmd_flags.extend(['--tblout', tblout_path])
+
+      if self.z_value:
+        cmd_flags.extend(['-Z', str(self.z_value)])
+
+      if self.dom_e is not None:
+        cmd_flags.extend(['--domE', str(self.dom_e)])
+
+      if self.incdom_e is not None:
+        cmd_flags.extend(['--incdomE', str(self.incdom_e)])
+
+      cmd = [self.binary_path] + cmd_flags + [input_fasta_path,
+                                              database_path]
+
+      logging.info('Launching subprocess ""%s""', ' '.join(cmd))
+      process = subprocess.Popen(
+          cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+      with utils.timing(
+          f'Jackhmmer ({os.path.basename(database_path)}) query'):
+        _, stderr = process.communicate()
+        retcode = process.wait()
+
+      if retcode:
+        raise RuntimeError(
+            'Jackhmmer failed\nstderr:\n%s\n' % stderr.decode('utf-8'))
+
+      # Get e-values for each target name
+      tbl = ''
+      if self.get_tblout:
+        with open(tblout_path) as f:
+          tbl = f.read()
+
+      if max_sequences is None:
+        with open(sto_path) as f:
+          sto = f.read()
+      else:
+        sto = parsers.truncate_stockholm_msa(sto_path, max_sequences)
+
+    raw_output = dict(
+        sto=sto,
+        tbl=tbl,
+        stderr=stderr,
+        n_iter=self.n_iter,
+        e_value=self.e_value)
+
+    return raw_output
+
+  def query(self,
+            input_fasta_path: str,
+            max_sequences: Optional[int] = None) -> Sequence[Mapping[str, Any]]:
+    """"""Queries the database using Jackhmmer.""""""
+    return self.query_multiple([input_fasta_path], max_sequences)[0]
+
+  def query_multiple(
+      self,
+      input_fasta_paths: Sequence[str],
+      max_sequences: Optional[int] = None,
+    ) -> Sequence[Sequence[Mapping[str, Any]]]:
+    """"""Queries the database for multiple queries using Jackhmmer.""""""
+    if self.num_streamed_chunks is None:
+      single_chunk_results = []
+      for input_fasta_path in input_fasta_paths:
+        single_chunk_results.append([self._query_chunk(
+            input_fasta_path, self.database_path, max_sequences)])
+      return single_chunk_results
+
+    db_basename = os.path.basename(self.database_path)
+    db_remote_chunk = lambda db_idx: f'{self.database_path}.{db_idx}'
+    db_local_chunk = lambda db_idx: f'/tmp/ramdisk/{db_basename}.{db_idx}'
+
+    # Remove existing files to prevent OOM
+    for f in glob.glob(db_local_chunk('[0-9]*')):
+      try:
+        os.remove(f)
+      except OSError:
+        print(f'OSError while deleting {f}')
+
+    # Download the (i+1)-th chunk while Jackhmmer is running on the i-th chunk
+    with futures.ThreadPoolExecutor(max_workers=2) as executor:
+      chunked_outputs = [[] for _ in range(len(input_fasta_paths))]
+      for i in range(1, self.num_streamed_chunks + 1):
+        # Copy the chunk locally
+        if i == 1:
+          future = executor.submit(
+              request.urlretrieve, db_remote_chunk(i), db_local_chunk(i))
+        if i < self.num_streamed_chunks:
+          next_future = executor.submit(
+              request.urlretrieve, db_remote_chunk(i+1), db_local_chunk(i+1))
+
+        # Run Jackhmmer with the chunk
+        future.result()
+        for fasta_index, input_fasta_path in enumerate(input_fasta_paths):
+          chunked_outputs[fasta_index].append(self._query_chunk(
+              input_fasta_path, db_local_chunk(i), max_sequences))
+        # Remove the local copy of the chunk
+        os.remove(db_local_chunk(i))
+        # Do not set next_future for the last chunk so that this works even for
+        # databases with only 1 chunk.
+        if i < self.num_streamed_chunks:
+          future = next_future
+        if self.streaming_callback:
+          self.streaming_callback(i)
+    return chunked_outputs
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/tools/__init__.py",".py","639","15","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Python wrappers for third party tools.""""""
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/tools/hmmbuild.py",".py","4576","139","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""A Python wrapper for hmmbuild - construct HMM profiles from MSA.""""""
+
+import os
+import re
+import subprocess
+
+from absl import logging
+from alphafold.data.tools import utils
+# Internal import (7716).
+
+
+class Hmmbuild(object):
+  """"""Python wrapper of the hmmbuild binary.""""""
+
+  def __init__(self,
+               *,
+               binary_path: str,
+               singlemx: bool = False):
+    """"""Initializes the Python hmmbuild wrapper.
+
+    Args:
+      binary_path: The path to the hmmbuild executable.
+      singlemx: Whether to use --singlemx flag. If True, it forces HMMBuild to
+        just use a common substitution score matrix.
+
+    Raises:
+      RuntimeError: If hmmbuild binary not found within the path.
+    """"""
+    self.binary_path = binary_path
+    self.singlemx = singlemx
+
+  def build_profile_from_sto(self, sto: str, model_construction='fast') -> str:
+    """"""Builds a HHM for the aligned sequences given as an A3M string.
+
+    Args:
+      sto: A string with the aligned sequences in the Stockholm format.
+      model_construction: Whether to use reference annotation in the msa to
+        determine consensus columns ('hand') or default ('fast').
+
+    Returns:
+      A string with the profile in the HMM format.
+
+    Raises:
+      RuntimeError: If hmmbuild fails.
+    """"""
+    return self._build_profile(sto, model_construction=model_construction)
+
+  def build_profile_from_a3m(self, a3m: str) -> str:
+    """"""Builds a HHM for the aligned sequences given as an A3M string.
+
+    Args:
+      a3m: A string with the aligned sequences in the A3M format.
+
+    Returns:
+      A string with the profile in the HMM format.
+
+    Raises:
+      RuntimeError: If hmmbuild fails.
+    """"""
+    lines = []
+    for line in a3m.splitlines():
+      if not line.startswith('>'):
+        line = re.sub('[a-z]+', '', line)  # Remove inserted residues.
+      lines.append(line + '\n')
+    msa = ''.join(lines)
+    return self._build_profile(msa, model_construction='fast')
+
+  def _build_profile(self, msa: str, model_construction: str = 'fast') -> str:
+    """"""Builds a HMM for the aligned sequences given as an MSA string.
+
+    Args:
+      msa: A string with the aligned sequences, in A3M or STO format.
+      model_construction: Whether to use reference annotation in the msa to
+        determine consensus columns ('hand') or default ('fast').
+
+    Returns:
+      A string with the profile in the HMM format.
+
+    Raises:
+      RuntimeError: If hmmbuild fails.
+      ValueError: If unspecified arguments are provided.
+    """"""
+    if model_construction not in {'hand', 'fast'}:
+      raise ValueError(f'Invalid model_construction {model_construction} - only'
+                       'hand and fast supported.')
+
+    with utils.tmpdir_manager() as query_tmp_dir:
+      input_query = os.path.join(query_tmp_dir, 'query.msa')
+      output_hmm_path = os.path.join(query_tmp_dir, 'output.hmm')
+
+      with open(input_query, 'w') as f:
+        f.write(msa)
+
+      cmd = [self.binary_path]
+      # If adding flags, we have to do so before the output and input:
+
+      if model_construction == 'hand':
+        cmd.append(f'--{model_construction}')
+      if self.singlemx:
+        cmd.append('--singlemx')
+      cmd.extend([
+          '--amino',
+          output_hmm_path,
+          input_query,
+      ])
+
+      logging.info('Launching subprocess %s', cmd)
+      process = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                 stderr=subprocess.PIPE)
+
+      with utils.timing('hmmbuild query'):
+        stdout, stderr = process.communicate()
+        retcode = process.wait()
+        logging.info('hmmbuild stdout:\n%s\n\nstderr:\n%s\n',
+                     stdout.decode('utf-8'), stderr.decode('utf-8'))
+
+      if retcode:
+        raise RuntimeError('hmmbuild failed\nstdout:\n%s\n\nstderr:\n%s\n'
+                           % (stdout.decode('utf-8'), stderr.decode('utf-8')))
+
+      with open(output_hmm_path, encoding='utf-8') as f:
+        hmm = f.read()
+
+    return hmm
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/tools/hhblits.py",".py","5504","156","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Library to run HHblits from Python.""""""
+
+import glob
+import os
+import subprocess
+from typing import Any, List, Mapping, Optional, Sequence
+
+from absl import logging
+from alphafold.data.tools import utils
+# Internal import (7716).
+
+
+_HHBLITS_DEFAULT_P = 20
+_HHBLITS_DEFAULT_Z = 500
+
+
+class HHBlits:
+  """"""Python wrapper of the HHblits binary.""""""
+
+  def __init__(self,
+               *,
+               binary_path: str,
+               databases: Sequence[str],
+               n_cpu: int = 4,
+               n_iter: int = 3,
+               e_value: float = 0.001,
+               maxseq: int = 1_000_000,
+               realign_max: int = 100_000,
+               maxfilt: int = 100_000,
+               min_prefilter_hits: int = 1000,
+               all_seqs: bool = False,
+               alt: Optional[int] = None,
+               p: int = _HHBLITS_DEFAULT_P,
+               z: int = _HHBLITS_DEFAULT_Z):
+    """"""Initializes the Python HHblits wrapper.
+
+    Args:
+      binary_path: The path to the HHblits executable.
+      databases: A sequence of HHblits database paths. This should be the
+        common prefix for the database files (i.e. up to but not including
+        _hhm.ffindex etc.)
+      n_cpu: The number of CPUs to give HHblits.
+      n_iter: The number of HHblits iterations.
+      e_value: The E-value, see HHblits docs for more details.
+      maxseq: The maximum number of rows in an input alignment. Note that this
+        parameter is only supported in HHBlits version 3.1 and higher.
+      realign_max: Max number of HMM-HMM hits to realign. HHblits default: 500.
+      maxfilt: Max number of hits allowed to pass the 2nd prefilter.
+        HHblits default: 20000.
+      min_prefilter_hits: Min number of hits to pass prefilter.
+        HHblits default: 100.
+      all_seqs: Return all sequences in the MSA / Do not filter the result MSA.
+        HHblits default: False.
+      alt: Show up to this many alternative alignments.
+      p: Minimum Prob for a hit to be included in the output hhr file.
+        HHblits default: 20.
+      z: Hard cap on number of hits reported in the hhr file.
+        HHblits default: 500. NB: The relevant HHblits flag is -Z not -z.
+
+    Raises:
+      RuntimeError: If HHblits binary not found within the path.
+    """"""
+    self.binary_path = binary_path
+    self.databases = databases
+
+    for database_path in self.databases:
+      if not glob.glob(database_path + '_*'):
+        logging.error('Could not find HHBlits database %s', database_path)
+        raise ValueError(f'Could not find HHBlits database {database_path}')
+
+    self.n_cpu = n_cpu
+    self.n_iter = n_iter
+    self.e_value = e_value
+    self.maxseq = maxseq
+    self.realign_max = realign_max
+    self.maxfilt = maxfilt
+    self.min_prefilter_hits = min_prefilter_hits
+    self.all_seqs = all_seqs
+    self.alt = alt
+    self.p = p
+    self.z = z
+
+  def query(self, input_fasta_path: str) -> List[Mapping[str, Any]]:
+    """"""Queries the database using HHblits.""""""
+    with utils.tmpdir_manager() as query_tmp_dir:
+      a3m_path = os.path.join(query_tmp_dir, 'output.a3m')
+
+      db_cmd = []
+      for db_path in self.databases:
+        db_cmd.append('-d')
+        db_cmd.append(db_path)
+      cmd = [
+          self.binary_path,
+          '-i', input_fasta_path,
+          '-cpu', str(self.n_cpu),
+          '-oa3m', a3m_path,
+          '-o', '/dev/null',
+          '-n', str(self.n_iter),
+          '-e', str(self.e_value),
+          '-maxseq', str(self.maxseq),
+          '-realign_max', str(self.realign_max),
+          '-maxfilt', str(self.maxfilt),
+          '-min_prefilter_hits', str(self.min_prefilter_hits)]
+      if self.all_seqs:
+        cmd += ['-all']
+      if self.alt:
+        cmd += ['-alt', str(self.alt)]
+      if self.p != _HHBLITS_DEFAULT_P:
+        cmd += ['-p', str(self.p)]
+      if self.z != _HHBLITS_DEFAULT_Z:
+        cmd += ['-Z', str(self.z)]
+      cmd += db_cmd
+
+      logging.info('Launching subprocess ""%s""', ' '.join(cmd))
+      process = subprocess.Popen(
+          cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+      with utils.timing('HHblits query'):
+        stdout, stderr = process.communicate()
+        retcode = process.wait()
+
+      if retcode:
+        # Logs have a 15k character limit, so log HHblits error line by line.
+        logging.error('HHblits failed. HHblits stderr begin:')
+        for error_line in stderr.decode('utf-8').splitlines():
+          if error_line.strip():
+            logging.error(error_line.strip())
+        logging.error('HHblits stderr end')
+        raise RuntimeError('HHblits failed\nstdout:\n%s\n\nstderr:\n%s\n' % (
+            stdout.decode('utf-8'), stderr[:500_000].decode('utf-8')))
+
+      with open(a3m_path) as f:
+        a3m = f.read()
+
+    raw_output = dict(
+        a3m=a3m,
+        output=stdout,
+        stderr=stderr,
+        n_iter=self.n_iter,
+        e_value=self.e_value)
+    return [raw_output]
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/tools/kalign.py",".py","3387","105","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""A Python wrapper for Kalign.""""""
+import os
+import subprocess
+from typing import Sequence
+
+from absl import logging
+
+from alphafold.data.tools import utils
+# Internal import (7716).
+
+
+def _to_a3m(sequences: Sequence[str]) -> str:
+  """"""Converts sequences to an a3m file.""""""
+  names = ['sequence %d' % i for i in range(1, len(sequences) + 1)]
+  a3m = []
+  for sequence, name in zip(sequences, names):
+    a3m.append(u'>' + name + u'\n')
+    a3m.append(sequence + u'\n')
+  return ''.join(a3m)
+
+
+class Kalign:
+  """"""Python wrapper of the Kalign binary.""""""
+
+  def __init__(self, *, binary_path: str):
+    """"""Initializes the Python Kalign wrapper.
+
+    Args:
+      binary_path: The path to the Kalign binary.
+
+    Raises:
+      RuntimeError: If Kalign binary not found within the path.
+    """"""
+    self.binary_path = binary_path
+
+  def align(self, sequences: Sequence[str]) -> str:
+    """"""Aligns the sequences and returns the alignment in A3M string.
+
+    Args:
+      sequences: A list of query sequence strings. The sequences have to be at
+        least 6 residues long (Kalign requires this). Note that the order in
+        which you give the sequences might alter the output slightly as
+        different alignment tree might get constructed.
+
+    Returns:
+      A string with the alignment in a3m format.
+
+    Raises:
+      RuntimeError: If Kalign fails.
+      ValueError: If any of the sequences is less than 6 residues long.
+    """"""
+    logging.info('Aligning %d sequences', len(sequences))
+
+    for s in sequences:
+      if len(s) < 6:
+        raise ValueError('Kalign requires all sequences to be at least 6 '
+                         'residues long. Got %s (%d residues).' % (s, len(s)))
+
+    with utils.tmpdir_manager() as query_tmp_dir:
+      input_fasta_path = os.path.join(query_tmp_dir, 'input.fasta')
+      output_a3m_path = os.path.join(query_tmp_dir, 'output.a3m')
+
+      with open(input_fasta_path, 'w') as f:
+        f.write(_to_a3m(sequences))
+
+      cmd = [
+          self.binary_path,
+          '-i', input_fasta_path,
+          '-o', output_a3m_path,
+          '-format', 'fasta',
+      ]
+
+      logging.info('Launching subprocess ""%s""', ' '.join(cmd))
+      process = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                 stderr=subprocess.PIPE)
+
+      with utils.timing('Kalign query'):
+        stdout, stderr = process.communicate()
+        retcode = process.wait()
+        logging.info('Kalign stdout:\n%s\n\nstderr:\n%s\n',
+                     stdout.decode('utf-8'), stderr.decode('utf-8'))
+
+      if retcode:
+        raise RuntimeError('Kalign failed\nstdout:\n%s\n\nstderr:\n%s\n'
+                           % (stdout.decode('utf-8'), stderr.decode('utf-8')))
+
+      with open(output_a3m_path) as f:
+        a3m = f.read()
+
+      return a3m
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/tools/hhsearch.py",".py","3601","108","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""Library to run HHsearch from Python.""""""
+
+import glob
+import os
+import subprocess
+from typing import Sequence
+
+from absl import logging
+
+from alphafold.data import parsers
+from alphafold.data.tools import utils
+# Internal import (7716).
+
+
+class HHSearch:
+  """"""Python wrapper of the HHsearch binary.""""""
+
+  def __init__(self,
+               *,
+               binary_path: str,
+               databases: Sequence[str],
+               maxseq: int = 1_000_000):
+    """"""Initializes the Python HHsearch wrapper.
+
+    Args:
+      binary_path: The path to the HHsearch executable.
+      databases: A sequence of HHsearch database paths. This should be the
+        common prefix for the database files (i.e. up to but not including
+        _hhm.ffindex etc.)
+      maxseq: The maximum number of rows in an input alignment. Note that this
+        parameter is only supported in HHBlits version 3.1 and higher.
+
+    Raises:
+      RuntimeError: If HHsearch binary not found within the path.
+    """"""
+    self.binary_path = binary_path
+    self.databases = databases
+    self.maxseq = maxseq
+
+    for database_path in self.databases:
+      if not glob.glob(database_path + '_*'):
+        logging.error('Could not find HHsearch database %s', database_path)
+        raise ValueError(f'Could not find HHsearch database {database_path}')
+
+  @property
+  def output_format(self) -> str:
+    return 'hhr'
+
+  @property
+  def input_format(self) -> str:
+    return 'a3m'
+
+  def query(self, a3m: str) -> str:
+    """"""Queries the database using HHsearch using a given a3m.""""""
+    with utils.tmpdir_manager() as query_tmp_dir:
+      input_path = os.path.join(query_tmp_dir, 'query.a3m')
+      hhr_path = os.path.join(query_tmp_dir, 'output.hhr')
+      with open(input_path, 'w') as f:
+        f.write(a3m)
+
+      db_cmd = []
+      for db_path in self.databases:
+        db_cmd.append('-d')
+        db_cmd.append(db_path)
+      cmd = [self.binary_path,
+             '-i', input_path,
+             '-o', hhr_path,
+             '-maxseq', str(self.maxseq)
+             ] + db_cmd
+
+      logging.info('Launching subprocess ""%s""', ' '.join(cmd))
+      process = subprocess.Popen(
+          cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+      with utils.timing('HHsearch query'):
+        stdout, stderr = process.communicate()
+        retcode = process.wait()
+
+      if retcode:
+        # Stderr is truncated to prevent proto size errors in Beam.
+        raise RuntimeError(
+            'HHSearch failed:\nstdout:\n%s\n\nstderr:\n%s\n' % (
+                stdout.decode('utf-8'), stderr[:100_000].decode('utf-8')))
+
+      with open(hhr_path) as f:
+        hhr = f.read()
+    return hhr
+
+  def get_template_hits(self,
+                        output_string: str,
+                        input_sequence: str) -> Sequence[parsers.TemplateHit]:
+    """"""Gets parsed template hits from the raw string output by the tool.""""""
+    del input_sequence  # Used by hmmseach but not needed for hhsearch.
+    return parsers.parse_hhr(output_string)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/tools/utils.py",".py","1223","41","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""""""Common utilities for data pipeline tools.""""""
+import contextlib
+import shutil
+import tempfile
+import time
+from typing import Optional
+
+from absl import logging
+
+
+@contextlib.contextmanager
+def tmpdir_manager(base_dir: Optional[str] = None):
+  """"""Context manager that deletes a temporary directory on exit.""""""
+  tmpdir = tempfile.mkdtemp(dir=base_dir)
+  try:
+    yield tmpdir
+  finally:
+    shutil.rmtree(tmpdir, ignore_errors=True)
+
+
+@contextlib.contextmanager
+def timing(msg: str):
+  logging.info('Started %s', msg)
+  tic = time.time()
+  yield
+  toc = time.time()
+  logging.info('Finished %s in %.3f seconds', msg, toc - tic)
+","Python"
+"AlphaFold","piercelab/tcrmodel2","alphafold/data/tools/hmmsearch.py",".py","4556","132","# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the ""License"");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an ""AS IS"" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""""""A Python wrapper for hmmsearch - search profile against a sequence db.""""""
+
+import os
+import subprocess
+from typing import Optional, Sequence
+
+from absl import logging
+from alphafold.data import parsers
+from alphafold.data.tools import hmmbuild
+from alphafold.data.tools import utils
+# Internal import (7716).
+
+
+class Hmmsearch(object):
+  """"""Python wrapper of the hmmsearch binary.""""""
+
+  def __init__(self,
+               *,
+               binary_path: str,
+               hmmbuild_binary_path: str,
+               database_path: str,
+               flags: Optional[Sequence[str]] = None):
+    """"""Initializes the Python hmmsearch wrapper.
+
+    Args:
+      binary_path: The path to the hmmsearch executable.
+      hmmbuild_binary_path: The path to the hmmbuild executable. Used to build
+        an hmm from an input a3m.
+      database_path: The path to the hmmsearch database (FASTA format).
+      flags: List of flags to be used by hmmsearch.
+
+    Raises:
+      RuntimeError: If hmmsearch binary not found within the path.
+    """"""
+    self.binary_path = binary_path
+    self.hmmbuild_runner = hmmbuild.Hmmbuild(binary_path=hmmbuild_binary_path)
+    self.database_path = database_path
+    if flags is None:
+      # Default hmmsearch run settings.
+      flags = ['--F1', '0.1',
+               '--F2', '0.1',
+               '--F3', '0.1',
+               '--incE', '100',
+               '-E', '100',
+               '--domE', '100',
+               '--incdomE', '100']
+    self.flags = flags
+
+    if not os.path.exists(self.database_path):
+      logging.error('Could not find hmmsearch database %s', database_path)
+      raise ValueError(f'Could not find hmmsearch database {database_path}')
+
+  @property
+  def output_format(self) -> str:
+    return 'sto'
+
+  @property
+  def input_format(self) -> str:
+    return 'sto'
+
+  def query(self, msa_sto: str) -> str:
+    """"""Queries the database using hmmsearch using a given stockholm msa.""""""
+    hmm = self.hmmbuild_runner.build_profile_from_sto(msa_sto,
+                                                      model_construction='hand')
+    return self.query_with_hmm(hmm)
+
+  def query_with_hmm(self, hmm: str) -> str:
+    """"""Queries the database using hmmsearch using a given hmm.""""""
+    with utils.tmpdir_manager() as query_tmp_dir:
+      hmm_input_path = os.path.join(query_tmp_dir, 'query.hmm')
+      out_path = os.path.join(query_tmp_dir, 'output.sto')
+      with open(hmm_input_path, 'w') as f:
+        f.write(hmm)
+
+      cmd = [
+          self.binary_path,
+          '--noali',  # Don't include the alignment in stdout.
+          '--cpu', '8'
+      ]
+      # If adding flags, we have to do so before the output and input:
+      if self.flags:
+        cmd.extend(self.flags)
+      cmd.extend([
+          '-A', out_path,
+          hmm_input_path,
+          self.database_path,
+      ])
+
+      logging.info('Launching sub-process %s', cmd)
+      process = subprocess.Popen(
+          cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+      with utils.timing(
+          f'hmmsearch ({os.path.basename(self.database_path)}) query'):
+        stdout, stderr = process.communicate()
+        retcode = process.wait()
+
+      if retcode:
+        raise RuntimeError(
+            'hmmsearch failed:\nstdout:\n%s\n\nstderr:\n%s\n' % (
+                stdout.decode('utf-8'), stderr.decode('utf-8')))
+
+      with open(out_path) as f:
+        out_msa = f.read()
+
+    return out_msa
+
+  def get_template_hits(self,
+                        output_string: str,
+                        input_sequence: str) -> Sequence[parsers.TemplateHit]:
+    """"""Gets parsed template hits from the raw string output by the tool.""""""
+    a3m_string = parsers.convert_stockholm_to_a3m(output_string,
+                                                  remove_first_row_gaps=False)
+    template_hits = parsers.parse_hmmsearch_a3m(
+        query_sequence=input_sequence,
+        a3m_string=a3m_string,
+        skip_first=False)
+    return template_hits
+","Python"
+"AlphaFold","piercelab/tcrmodel2","scripts/tcr_utils.py",".py","3883","84","from anarci import anarci
+import numpy as np
+
+def renumber_pdb(pdb_path, output_path, mhc_class=1):
+        import MDAnalysis as mda 
+
+        '''
+        This function takes a pdb from tcrmodel output and renumber the residues according to the AHO numering scheme
+        '''
+        #load pdb 
+        pdb_u = mda.Universe(pdb_path)
+        #create list of chains per residue
+        list_chains = [np.unique(i)[0] for i in pdb_u.residues.chainIDs]
+        #create lsit of residues 
+        list_res = [mda.lib.util.convert_aa_code(i) for i  in pdb_u.atoms.residues.resnames]
+        #get tcra and tcrb sequence
+        tcra_seq = ''.join(list(map(list_res.__getitem__, [i for i,a in enumerate(list_chains) if a == 'A']))) #considering that tcra is chain A in tcrmodel output
+        tcrb_seq = ''.join(list(map(list_res.__getitem__, [i for i,a in enumerate(list_chains) if a == 'B']))) #considering that tcra is chain B in tcrmodel output
+        #run anarci to get new residue numbers for tcra
+        anarci_tcra = anarci([('tcra', tcra_seq)], scheme=""aho"", output=False)
+        new_res_tcra = [i[0][0] for i in anarci_tcra[0][0][0][0] if i[1] != '-']
+        #run anarci to get new residue numbers for tcrb
+        anarci_tcrb = anarci([('tcrb', tcrb_seq)], scheme=""aho"", output=False)
+        new_res_tcrb = [i[0][0] for i in anarci_tcrb[0][0][0][0] if i[1] != '-']
+        #create copy
+        tmp_numbering = pdb_u.residues.resids
+        #change the residue number in original PDB for the new one
+        tmp_numbering[np.array(list_chains) == 'A'] = new_res_tcra
+        tmp_numbering[np.array(list_chains) == 'B'] = new_res_tcrb
+
+        pdb_u.residues.resids = tmp_numbering
+
+        chns=pdb_u.atoms.chainIDs
+        chns[chns==""A""]=""F""
+        chns[chns==""B""]=""G""
+        chns[chns==""D""]=""A""
+        if mhc_class==2:
+            chns[chns==""E""]=""B""
+        chns[chns==""F""]=""D""
+        chns[chns==""G""]=""E""
+        pdb_u.atoms.chainIDs=chns
+
+        #write PDB
+        pdb_u.select_atoms(""protein"").write(output_path)
+    
+def renumber_tcr_pdb(pdb_path, output_path):
+        import MDAnalysis as mda 
+
+        '''
+        This function takes a pdb from tcrmodel output and renumber the residues according to the AHO numering scheme
+        '''
+        #load pdb 
+        pdb_u = mda.Universe(pdb_path)
+        #create list of chains per residue
+        list_chains = [np.unique(i)[0] for i in pdb_u.residues.chainIDs]
+        #create lsit of residues 
+        list_res = [mda.lib.util.convert_aa_code(i) for i  in pdb_u.atoms.residues.resnames]
+        #get tcra and tcrb sequence
+        tcra_seq = ''.join(list(map(list_res.__getitem__, [i for i,a in enumerate(list_chains) if a == 'A']))) #considering that tcra is chain A in tcrmodel output
+        tcrb_seq = ''.join(list(map(list_res.__getitem__, [i for i,a in enumerate(list_chains) if a == 'B']))) #considering that tcra is chain B in tcrmodel output
+        #run anarci to get new residue numbers for tcra
+        anarci_tcra = anarci([('tcra', tcra_seq)], scheme=""aho"", output=False)
+        new_res_tcra = [i[0][0] for i in anarci_tcra[0][0][0][0] if i[1] != '-']
+        #run anarci to get new residue numbers for tcrb
+        anarci_tcrb = anarci([('tcrb', tcrb_seq)], scheme=""aho"", output=False)
+        new_res_tcrb = [i[0][0] for i in anarci_tcrb[0][0][0][0] if i[1] != '-']
+        #create copy
+        tmp_numbering = pdb_u.residues.resids
+        #change the residue number in original PDB for the new one
+        tmp_numbering[np.array(list_chains) == 'A'] = new_res_tcra
+        tmp_numbering[np.array(list_chains) == 'B'] = new_res_tcrb
+
+        pdb_u.residues.resids = tmp_numbering
+
+        chns=pdb_u.atoms.chainIDs
+        chns[chns==""A""]=""D""
+        chns[chns==""B""]=""E""
+
+        pdb_u.atoms.chainIDs=chns
+
+        #write PDB
+        pdb_u.select_atoms(""protein"").write(output_path)
+    
+    ","Python"
+"AlphaFold","piercelab/tcrmodel2","scripts/parse_tcr_seq_from_json.py",".py","2368","91","import json
+import subprocess
+import anarci
+import sys
+from anarci import anarci
+
+fn=sys.argv[1]
+user_json=sys.argv[2]
+json_output_path=sys.argv[3]
+
+with open(fn) as fh:
+    f=json.load(fh)
+
+def get_seq(pdb_chain):
+    command=""grep -A1 %s data/databases/pdb_seqres.txt"" % (pdb_chain)
+    output = subprocess.getoutput(command)
+    return output.split(""\n"")[1]
+
+def anarci_custom(seq):
+    command=""ANARCI --scheme aho -i %s"" % seq
+    output = subprocess.getoutput(command)
+    return output
+
+def parse_anarci(output):
+    cdr3, seq="""",""""
+    for i in output.split(""\n""):
+        if i[0]!=""#"" and i[0]!=""/"":
+            fields=i.rstrip().split()
+            num=int(fields[1])
+            res=fields[-1]
+            if res!=""-"":
+                seq+=res
+            if res!=""-"" and num >= 106 and num <= 139:
+                cdr3+=res
+    return cdr3, seq
+
+
+def get_germlines(seq:str):
+    '''
+    Get the VJ germlines from TCRa or TCRb sequences
+    '''
+    input_seq = [('seq',seq)]
+    try:
+        results = anarci(input_seq, scheme=""aho"", output=False, assign_germline=True)
+        v_gene = results[1][0][0]['germlines']['v_gene'][0][1]
+        j_gene = results[1][0][0]['germlines']['j_gene'][0][1]
+    except:
+        v_gene = 'NA'
+        j_gene = 'NA'
+    return v_gene, j_gene
+
+tcra=f['tcra_tmplts']
+tcra_seqs={}
+for pdb_chain in tcra:
+    in_seq=get_seq(pdb_chain)
+    anarci_out=anarci_custom(in_seq)
+    cdr3, seq=parse_anarci(anarci_out)
+    v_gene, j_gene=get_germlines(in_seq)
+    tcra_seqs[pdb_chain]=[cdr3, seq, v_gene, j_gene]
+
+tcrb=f['tcrb_tmplts']
+tcrb_seqs={}
+for pdb_chain in tcrb:
+    in_seq=get_seq(pdb_chain)
+    anarci_out=anarci_custom(in_seq)
+    cdr3, seq=parse_anarci(anarci_out)
+    v_gene, j_gene=get_germlines(in_seq)
+    tcrb_seqs[pdb_chain]=[cdr3, seq, v_gene, j_gene]
+
+out_json={}
+out_json[""tcra_seqs""]=tcra_seqs
+out_json[""tcrb_seqs""]=tcrb_seqs
+
+with open(user_json) as fh:
+    uf=json.load(fh)
+
+aseq=uf['aseq_user']
+anarci_out=anarci_custom(aseq)
+cdr3, seq=parse_anarci(anarci_out)
+v_gene, j_gene=get_germlines(in_seq)
+out_json[""tcra_user""]=[cdr3, seq, v_gene, j_gene]
+
+bseq=uf['bseq_user']
+anarci_out=anarci_custom(bseq)
+cdr3, seq=parse_anarci(anarci_out)
+v_gene, j_gene=get_germlines(in_seq)
+out_json[""tcrb_user""]=[cdr3, seq, v_gene, j_gene]
+
+with open(json_output_path, 'w') as f:
+    f.write(json.dumps(out_json, indent=4))
+","Python"
+"AlphaFold","piercelab/tcrmodel2","scripts/pdb_utils.py",".py","3511","117","import subprocess
+
+
+three_to_one = {'CYS': 'C', 'ASP': 'D', 'SER': 'S', 'GLN': 'Q', 'LYS': 'K',
+     'ILE': 'I', 'PRO': 'P', 'THR': 'T', 'PHE': 'F', 'ASN': 'N', 
+     'GLY': 'G', 'HIS': 'H', 'LEU': 'L', 'ARG': 'R', 'TRP': 'W', 
+     'ALA': 'A', 'VAL':'V', 'GLU': 'E', 'TYR': 'Y', 'MET': 'M'}
+one_to_three = {value : key for (key, value) in three_to_one.items()}
+
+def extract_sequence(pdb_fn):
+    # get sequence from pdb
+    # return a list of sequences for each chain
+    seqs=[]
+    pdb = []
+    with open(pdb_fn) as fh:
+        for line in fh:
+            if line[0:4] == 'ATOM':
+                pdb.append(line.rstrip())
+
+    chains = []        
+    for line in pdb:
+        if line[0:4] == 'ATOM':
+            chain_name = line[21]
+            if (chain_name not in chains):
+                chains.append(chain_name)
+    res_count = 0
+    start_res = 1
+    for chain in chains:
+        line_count = 0
+        prev_res = """"
+        seq=""""
+        for line in pdb:
+            if line[21] == chain:
+                curr_res = line[22:27]
+                if line_count == 0:
+                    prev_res = curr_res
+                    seq+=three_to_one[line[17:20]]
+                if curr_res != prev_res:
+                    res_count += 1
+                    prev_res = curr_res
+                    seq+=three_to_one[line[17:20]]
+                line_count += 1
+        seqs.append(seq)
+
+    return seqs
+
+
+def anarci(seq):
+    command=""ANARCI --scheme aho -i %s"" % seq
+    output = subprocess.getoutput(command)
+    return output
+
+def gen_res_str(res):
+    res_len = len(str(res))
+    res_str = """"
+    for i in range(4-res_len):
+        res_str += "" ""
+    res_str += str(res) + "" ""
+    return res_str
+
+def rename_chains_start_A_and_1(pdb):
+    #get unique chain name and the residue start
+
+    chains = []        
+    for line in pdb:
+        if line[0:4] == 'ATOM':
+            chain_name = line[21]
+            if (chain_name not in chains):
+                chains.append(chain_name)
+    chain_dict={}
+    for i, j in enumerate(chains):
+        chain_dict[j]=chr(ord('@')+i+1)
+
+    pdb_renum = []
+    for chain in chains:
+        line_count = 0
+        res_count = 0
+        prev_res = """"
+        start_res = 1
+        for line in pdb:
+            if line[21] == chain:
+                curr_res = line[22:27]
+                if line_count == 0:
+                    prev_res = curr_res
+                if curr_res != prev_res:
+                    res_count += 1
+                out_res = res_count + start_res 
+                outline = line[:21] +chain_dict[chain]+ gen_res_str(out_res) + line[27:]
+                pdb_renum.append(outline)
+                prev_res = curr_res
+                line_count += 1
+    return pdb_renum
+
+def align_pdbs_by_pmhc(ref_path, pdb_path, output_path, mhc_class):
+    import MDAnalysis as mda 
+    from MDAnalysis.analysis import align
+    pdb_u = mda.Universe(pdb_path)
+    ref = mda.Universe(ref_path)
+    if mhc_class==1:
+        align.alignto(pdb_u, ref, select=""chainID C or chainID A"", tol_mass=1000)
+    if mhc_class==2:
+        align.alignto(pdb_u, ref, select=""chainID C or chainID A or chainID B"", tol_mass=1000)
+
+    pdb_u.select_atoms(""protein"").write(output_path)
+
+
+def align_pdbs(ref_path, pdb_path, output_path):
+    import MDAnalysis as mda 
+    from MDAnalysis.analysis import align
+    pdb_u = mda.Universe(pdb_path)
+    ref = mda.Universe(ref_path)
+    align.alignto(pdb_u, ref, tol_mass=1000)
+
+    pdb_u.select_atoms(""protein"").write(output_path)
+
+
+","Python"
+"AlphaFold","piercelab/tcrmodel2","scripts/pmhc_templates.py",".py","10398","273","import os
+from scripts import pdb_utils
+import pandas as pd
+from Bio import pairwise2
+from Bio.pairwise2 import format_alignment
+from Bio import Align
+from Bio.Align import substitution_matrices
+from datetime import datetime
+
+
+aligner = Align.PairwiseAligner()
+aligner.substitution_matrix = substitution_matrices.load(""BLOSUM62"")
+tmplt_header=""template_pdbfile\ttarget_to_template_alignstring\ttarget_len\ttemplate_len\tidentities\n""
+
+def gen_aln(biopython_align_out,query_res_cnt,tmplt_res_cnt):
+    # return a query-template alignment map
+    alignment=""""
+    for index, ref_ab_res in enumerate(biopython_align_out[0]):
+        if ref_ab_res==""-"":  #query sequence residue not matched to template
+            tmplt_res_cnt+=1
+            continue
+        md_res=biopython_align_out[1][index]
+        if md_res==""-"": # template residue not aligned to anything 
+            query_res_cnt+=1
+            continue
+        else:
+            alignment+=""%d:%d;"" % (query_res_cnt, tmplt_res_cnt)
+            tmplt_res_cnt+=1
+            query_res_cnt+=1
+    return alignment[:-1]
+
+def gen_pep_aln(pep_len):
+    # return a query-template alignment map for peptide
+    out=""""
+    for i in range(pep_len):
+        out+=""%d:%d;"" % (i,i)
+    return out
+
+def get_best_hit_cls1(pep, mhc, df1, ignore_pdbs, cutoff):
+    # get top ranking templates, ranked by MHC then peptide similarity
+    # similarity is measured in BLOSUM62 alignment score 
+    # for class I pMHCs, peptide of template must match query length
+    df1['release_dates'] =  pd.to_datetime(df1['release_dates'], format='%Y-%m-%d') 
+
+    tmplt_dict={} # keep track of alignment scores
+    for idx, row in df1.iterrows():
+        if row.release_dates > cutoff:
+            # ignore pdbs released after a certain date
+            continue
+        if row.PDB.lower() in ignore_pdbs:
+            # ignore pdbs blacklisted by user
+            continue
+        if len(row.pep)!=len(pep):
+            # ignore templates with peptide of different length than query
+            continue
+        else:
+            # obtain MHC alignment score
+            #change penalize gaps back to 0:
+            aligner.open_gap_score=0
+            aligner.extend_gap_score=0
+            alignments = aligner.align(mhc, row.MHC)
+            alignment = alignments[0]
+            mhc_score = alignment.score
+
+
+            # obtain peptide alignment score
+
+            #test penalize gaps, default is 0:
+            aligner.open_gap_score=-100
+            aligner.extend_gap_score=-100
+            alignments = aligner.align(pep, row.pep)
+            alignment = alignments[0]
+            pep_score = alignment.score
+
+            # update template dictionary with scores
+            tmplt_dict[row.PDB]= (mhc_score,pep_score)
+
+    # rank templates first by MHC then by peptide similarity 
+    tmplt_dict=dict(sorted(tmplt_dict.items(), key=lambda item: item[1],reverse=True))
+
+    # return top 4 templates 
+    tmplt_dict=list(tmplt_dict.items())[:4]
+    return tmplt_dict
+
+def get_best_hit_cls2(pep, mhc1, mhc2, df2,ignore_pdbs, cutoff):
+    # get top ranking templates, ranked by MHC then peptide similarity
+    # similarity is measured in BLOSUM62 alignment score 
+    # for class II MHCs, the MHC similarity is a sum of MHCa and MHCb similarity 
+    df2['release_dates'] =  pd.to_datetime(df2['release_dates'], format='%Y-%m-%d') 
+
+    tmplt_dict={} # keep track of alignment scores
+    for idx, row in df2.iterrows():
+        if row.release_dates > cutoff:
+            # ignore pdbs released after a certain date
+            continue
+        if row.PDB.lower() in ignore_pdbs:
+            # ignore pdbs blacklisted by user
+            continue
+        # obtain MHC alignment score
+        mhc1_tmp, mhc2_tmp=row.MHC.split("" "")
+        alignments = aligner.align(mhc1, mhc1_tmp)
+        alignment = alignments[0]
+        mhc1_score=alignment.score
+        alignments = aligner.align(mhc2, mhc2_tmp)
+        alignment = alignments[0]
+        mhc2_score=alignment.score
+
+        # obtain peptide alignment score
+        pep_tmp=row.peptide_core
+        alignments = aligner.align(pep_tmp, pep)
+        alignment = alignments[0]
+        pep_score=alignment.score
+
+        # update template dictionary with scores
+        tmplt_dict[row.PDB]=(mhc1_score+mhc2_score,pep_score)
+
+    # rank templates first by MHC then by peptide similarity 
+    tmplt_dict=dict(sorted(tmplt_dict.items(), key=lambda item: item[1],reverse=True))
+
+    # return top 4 templates 
+    tmplt_dict=list(tmplt_dict.items())[:4]
+    return tmplt_dict
+
+def get_best_hit_corep1_cls2(pep, mhc1, mhc2, df2,ignore_pdbs, cutoff):
+    # get top ranking templates, ranked by MHC then peptide similarity
+    # similarity is measured in BLOSUM62 alignment score 
+    # for class II MHCs, the MHC similarity is a sum of MHCa and MHCb similarity 
+    df2['release_dates'] =  pd.to_datetime(df2['release_dates'], format='%Y-%m-%d') 
+
+    tmplt_dict={} # keep track of alignment scores
+    for idx, row in df2.iterrows():
+        if row.release_dates > cutoff:
+            # ignore pdbs released after a certain date
+            continue
+        if row.PDB.lower() in ignore_pdbs:
+            # ignore pdbs blacklisted by user
+            continue
+        # obtain MHC alignment score
+        mhc1_tmp, mhc2_tmp=row.MHC.split("" "")
+
+        alignments = aligner.align(mhc1, mhc1_tmp)
+        alignment = alignments[0]
+        mhc1_score=alignment.score
+        alignments = aligner.align(mhc2, mhc2_tmp)
+        alignment = alignments[0]
+        mhc2_score=alignment.score
+
+        # obtain peptide alignment score
+        pep_tmp=row.peptide_core_p1
+        alignments = aligner.align(pep_tmp, pep)
+        alignment = alignments[0]
+        pep_score=alignment.score
+
+        # update template dictionary with scores
+        tmplt_dict[row.PDB]=(mhc1_score+mhc2_score,pep_score)
+
+    # rank templates first by MHC then by peptide similarity 
+    tmplt_dict=dict(sorted(tmplt_dict.items(), key=lambda item: item[1],reverse=True))
+
+    # return top 4 templates 
+    tmplt_dict=list(tmplt_dict.items())[:4]
+    return tmplt_dict
+
+def gen_align_for_given_tmplt_cls1(tmplt_pdb, pep_len, mhc_seq):
+    # generate alignment between query and template for a given template
+
+    # extract template sequence
+    tmplt_seq = pdb_utils.extract_sequence(tmplt_pdb)
+    mhc_tmplt_seq=tmplt_seq[1]
+
+    # query and template peptide aligned position-wise
+    alignment=gen_pep_aln(pep_len)
+
+    # align MHC by mapping template to query residues after pairwise alignment
+    alignments=pairwise2.align.globalxx(mhc_seq, mhc_tmplt_seq, penalize_extend_when_opening=True)
+    alignment+=gen_aln(alignments[0],pep_len,pep_len)
+
+    tmplt_out=""%s\t%s\t%d\t%d\t0\n"" % (tmplt_pdb, alignment, pep_len+len(mhc_seq), len("""".join(tmplt_seq)))
+    return tmplt_out
+
+def gen_align_for_given_tmplt_cls2(tmplt_pdb, pep_len, mhc1_seq, mhc2_seq):
+    # generate alignment between query and template for a given template
+    
+    # extract template sequence
+    tmplt_seq = pdb_utils.extract_sequence(tmplt_pdb)
+    mhc1_tmplt_seq=tmplt_seq[1]
+    mhc2_tmplt_seq=tmplt_seq[2]
+
+    # align peptide position-wise
+    alignment=gen_pep_aln(pep_len)
+
+    # align MHC by mapping template to query residues after pairwise alignment
+    alignments=pairwise2.align.globalxx(mhc1_seq, mhc1_tmplt_seq, penalize_extend_when_opening=True)
+    alignment+=gen_aln(alignments[0],pep_len, pep_len)+"";""
+    alignments=pairwise2.align.globalxx(mhc2_seq, mhc2_tmplt_seq, penalize_extend_when_opening=True)
+    alignment+=gen_aln(alignments[0],pep_len+len(mhc1_seq),pep_len+len(mhc1_tmplt_seq))
+
+    tmplt_out=""%s\t%s\t%d\t%d\t0\n"" % (tmplt_pdb, alignment, pep_len+len(mhc1_seq)+len(mhc2_seq), len("""".join(tmplt_seq)))
+    return tmplt_out
+
+def gen_align_file_cls1(
+        pep_seq, 
+        mhc_seq, 
+        out_dir, 
+        ignore_pdbs, 
+        # data_dir,
+        cutoff=""2100-01-01""
+        ):
+    # generate full alignment file for a given query in class I
+
+    # read all nr class I complexes as dataframe
+    fn=""data/templates/nr_cls_I_complexes.txt""
+    df1=pd.read_csv(fn,sep=""\t"")
+    cutoff = datetime.strptime(cutoff, '%Y-%m-%d')
+
+    tmplt_dict=get_best_hit_cls1(pep_seq, mhc_seq, df1, ignore_pdbs, cutoff)
+    tmplt_out=""""
+    for (tmplt_name,score) in tmplt_dict:
+        tmplt_pdb=""data/templates/pdb/%s.pmhc.pdb"" % tmplt_name
+        tmplt_out+=gen_align_for_given_tmplt_cls1(tmplt_pdb, len(pep_seq),mhc_seq)
+
+    tmplt_aln_file=os.path.join(out_dir, ""pmhc_alignment.tsv"")    
+    with open(""%s"" % tmplt_aln_file,'w+') as fh:
+        fh.write(""%s%s"" % (tmplt_header, tmplt_out)) 
+
+def gen_align_file_cls2(
+        pep_seq, 
+        mhc1_seq, 
+        mhc2_seq, 
+        out_dir, 
+        ignore_pdbs,
+        cutoff=""2100-01-01""):
+    # generate full alignment file for a given query in class II
+
+    # read all nr class II complexes as dataframe
+    fn=""data/templates/nr_cls_II_complexes.txt""
+    df2=pd.read_csv(fn,sep=""\t"")
+    cutoff = datetime.strptime(cutoff, '%Y-%m-%d')
+
+    tmplt_dict=get_best_hit_cls2(pep_seq, mhc1_seq, mhc2_seq, df2, ignore_pdbs, cutoff)
+    tmplt_out=""""
+    for (tmplt_name,score) in tmplt_dict:
+        tmplt_pdb=""data/templates/pdb/%s.pmhc.pdb"" % tmplt_name
+        tmplt_out+=gen_align_for_given_tmplt_cls2(tmplt_pdb, len(pep_seq), mhc1_seq, mhc2_seq)
+
+    tmplt_aln_file=os.path.join(out_dir, ""pmhc_alignment.tsv"")
+    with open(""%s"" % tmplt_aln_file,'w+') as fh:
+        fh.write(""%s%s"" % (tmplt_header, tmplt_out)) 
+
+def gen_align_file_corep1_cls2(
+        pep_seq, 
+        mhc1_seq, 
+        mhc2_seq, 
+        out_dir, 
+        ignore_pdbs,
+        cutoff=""2100-01-01""):
+    # generate full alignment file for a given query in class II
+
+    # read all nr class II complexes as dataframe
+    fn=""data/templates/nr_cls_II_complexes.txt""
+    df2=pd.read_csv(fn,sep=""\t"")
+    cutoff = datetime.strptime(cutoff, '%Y-%m-%d')
+
+    tmplt_dict=get_best_hit_corep1_cls2(pep_seq, mhc1_seq, mhc2_seq, df2, ignore_pdbs, cutoff)
+    tmplt_out=""""
+    for (tmplt_name,score) in tmplt_dict:
+        tmplt_pdb=""data/templates/pdb/cp1/%s.pmhc.pdb"" % tmplt_name
+        tmplt_out+=gen_align_for_given_tmplt_cls2(tmplt_pdb, len(pep_seq), mhc1_seq, mhc2_seq)
+
+    tmplt_aln_file=os.path.join(out_dir, ""pmhc_alignment.tsv"")
+    with open(""%s"" % tmplt_aln_file,'w+') as fh:
+        fh.write(""%s%s"" % (tmplt_header, tmplt_out)) 
+","Python"
+"AlphaFold","piercelab/tcrmodel2","scripts/parse_tcr_seq.py",".py","1797","58","import subprocess
+
+from anarci import anarci
+
+
+def get_seq(pdb_chain):
+    command=""grep -A1 %s data/databases/pdb_seqres.txt"" % (pdb_chain)
+    output = subprocess.getoutput(command)
+    return output.split(""\n"")[1]
+
+
+def parse_anarci(in_seq):
+    try:
+        command=""ANARCI --scheme aho -i %s"" % in_seq
+        output = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT)
+        output = output.decode(""utf-8"")  # decode bytes to string
+    except subprocess.CalledProcessError as e:
+        print(f""ANARCI failed for {in_seq} with error: {e.output.decode('utf-8')}"")
+        return ""NA"", ""NA""
+
+    cdr3, seq="""",""""
+    for line in output.split(""\n""):
+        if line and line[0] != ""#"" and line[0] != ""/"":
+            try:
+                fields = line.rstrip().split()
+                num = int(fields[1])    # Second field for residue_number
+                res = fields[-1]        # Last field for aa
+                if res != ""-"":
+                    seq += res
+                    if num >= 106 and num <= 139:
+                        cdr3 += res
+            except (ValueError, IndexError) as e:
+                print(f""Error parsing line '{line.strip()}': {str(e)}"")
+    return cdr3, seq
+
+
+def get_germlines(seq:str):
+    '''
+    Get the VJ germlines from TCRa or TCRb sequences
+    '''
+    input_seq = [('seq',seq)]
+    try:
+        results = anarci(input_seq, scheme=""aho"", output=False, assign_germline=True)
+        v_gene = results[1][0][0]['germlines']['v_gene'][0][1]
+        j_gene = results[1][0][0]['germlines']['j_gene'][0][1]
+    except:
+        v_gene = 'NA'
+        j_gene = 'NA'
+    return v_gene, j_gene
+
+
+def parse_tcr(in_seq):
+    cdr3, seq = parse_anarci(in_seq)
+    v_gene, j_gene = get_germlines(in_seq)
+    return [cdr3, seq, v_gene, j_gene]
+
+
+","Python"
+"AlphaFold","piercelab/tcrmodel2","scripts/parse_cdr_confidence_from_json.py",".py","1077","33","# Load required packages
+import os
+import sys
+import pandas as pd
+import json
+from absl import flags
+from absl import app
+from glob import glob
+import MDAnalysis as mda
+
+fn=sys.argv[1]
+out_dir=sys.argv[2]
+json_output_path=sys.argv[3]
+
+with open(fn) as fh:
+    out_json=json.load(fh)
+
+#get CDR3s confidence scores 
+def get_cdr3_conf(pdb_path):
+    pdb_u = mda.Universe(pdb_path)
+    cdr3a_bfactors_avg = pdb_u.select_atoms('chainID D and resid 106:139').atoms.bfactors.mean()
+    cdr3b_bfactors_avg = pdb_u.select_atoms('chainID E and resid 106:139').atoms.bfactors.mean()
+    return cdr3a_bfactors_avg, cdr3b_bfactors_avg
+
+models_list = [i for i in glob('%s/*' % (out_dir)) if os.path.basename(i).startswith('ranked')]
+for model in models_list:
+    cdr3a_bfactors_avg, cdr3b_bfactors_avg = get_cdr3_conf(model)
+    out_json[os.path.basename(model).split('.pdb')[0]]['cdr3a_plddt'] = cdr3a_bfactors_avg
+    out_json[os.path.basename(model).split('.pdb')[0]]['cdr3b_plddt'] = cdr3b_bfactors_avg
+
+with open(json_output_path, 'w') as f:
+    f.write(json.dumps(out_json, indent=4))
+","Python"
+"AlphaFold","piercelab/tcrmodel2","scripts/seq_utils.py",".py","1711","64","
+import subprocess
+import os 
+
+def anarci(seq):
+    command=""ANARCI --scheme aho -i %s"" % seq
+    output = subprocess.getoutput(command)
+    return output
+
+
+def parse_anarci(output):
+    #24-42 (CDR1), 57-76 (CDR2), and 107-138 (CDR3)
+    seq=""""
+    for i in output.split(""\n""):
+        if i[0]!=""#"" and i[0]!=""/"":
+            fields=i.rstrip().split()
+            num=int(fields[1])
+            res=fields[-1]
+            if res!=""-"":
+                seq+=res
+    return seq
+
+def trim_tcr(seq):
+    # trim TCR sequence to variable domain sequence
+    anarci_out=anarci(seq)
+    return parse_anarci(anarci_out)
+
+def trim_mhc(seq, type, root_dir, out_dir):
+    # trim MHC sequence to alpha1 and alpha2 if class I (type 1)
+    # trim MHC to alpha1 if class II alpha (type 2)
+    # trim MHC to beta1 if class II beta (type 3)
+
+    if type==""1"":
+        hmmfile = ""%s/scripts/mhc_hmm/classI.hmm"" % root_dir 
+    elif type==""2"":
+        hmmfile = ""%s/scripts/mhc_hmm/classII_alpha.hmm"" % root_dir 
+    elif type==""3"":
+        hmmfile = ""%s/scripts/mhc_hmm/classII_beta.hmm"" % root_dir 
+    else:
+        return ""error""
+
+    tmpfn=""%s/tmp.fa"" % out_dir
+    with open(tmpfn, 'w') as fh:
+        fh.write("">tmp\n%s\n"" % seq)
+    
+    hmmcmd=""hmmsearch --noali %s %s"" % (hmmfile,tmpfn)
+    hmmout=subprocess.getoutput(hmmcmd)
+
+    os.remove(tmpfn)
+    start=0
+    end=0
+    hmmout=hmmout.split(""\n"")
+    for i,line in enumerate(hmmout):
+        if ""Domain annotation for each sequence"" in line:
+            line=hmmout[i+4]
+            start=int(line[59:66])
+            end=int(line[67:74])
+            break
+    if start == 0 or end == 0:
+        return ""none""
+    else:
+        start-=1
+        return seq[start:end]
+","Python"