From d7c0cd89b0475a8b24ea3439dca5a94a1cbab743 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Tue, 25 Feb 2025 12:07:54 -0700 Subject: [PATCH 01/42] Make yeast mito tRNA ref --- resources/ref/sacCer3-mito/convert-mt.py | 17 ++++++++ resources/ref/sacCer3-mito/make-ref.sh | 3 ++ resources/ref/sacCer3-mito/sacCer3.chrM.fa | 2 + .../sacCer3.chrM.trnas.adapted.fa | 26 ++++++++++++ .../ref/sacCer3-mito/sacCer3.chrM.trnas.fa | 42 +++++++++++++++++++ 5 files changed, 90 insertions(+) create mode 100644 resources/ref/sacCer3-mito/convert-mt.py create mode 100644 resources/ref/sacCer3-mito/make-ref.sh create mode 100644 resources/ref/sacCer3-mito/sacCer3.chrM.fa create mode 100644 resources/ref/sacCer3-mito/sacCer3.chrM.trnas.adapted.fa create mode 100644 resources/ref/sacCer3-mito/sacCer3.chrM.trnas.fa diff --git a/resources/ref/sacCer3-mito/convert-mt.py b/resources/ref/sacCer3-mito/convert-mt.py new file mode 100644 index 0000000..a3e15b6 --- /dev/null +++ b/resources/ref/sacCer3-mito/convert-mt.py @@ -0,0 +1,17 @@ +#! /usr/bin/env python + +from Bio import SeqIO +import sys +import pdb + +adaptor5 = "CCTAAGAGCAAGAAGAAGCCTGGN" +adaptor3 = "CCAACCTTGCCTTAAAAAAAAAA" + +for record in SeqIO.parse(sys.argv[1], "fasta"): + if "pseudo" in record.description: continue + + fs = record.description.split(" ") + name = f"mt-{fs[3]}-{fs[4].replace('(','').replace(')','')}" + seq = adaptor5 + str(record.seq) + adaptor3 + + print(f">{name}\n{seq}") diff --git a/resources/ref/sacCer3-mito/make-ref.sh b/resources/ref/sacCer3-mito/make-ref.sh new file mode 100644 index 0000000..0f09917 --- /dev/null +++ b/resources/ref/sacCer3-mito/make-ref.sh @@ -0,0 +1,3 @@ +bioawk -c fastx '{OFS=""} /chrM/ {print ">"$name,"\n",$seq}' ~/ref/genomes/sacCer3/sacCer3.fa > sacCer3.chrM.fa +tRNAscan-SE -a sacCer3.chrM.trnas.fa sacCer3.chrM.fa +python convert-mt.py sacCer3.chrM.trnas.fa > sacCer3.chrM.trnas.adapted.fa diff --git a/resources/ref/sacCer3-mito/sacCer3.chrM.fa b/resources/ref/sacCer3-mito/sacCer3.chrM.fa new file mode 100644 index 0000000..25157a1 --- /dev/null +++ b/resources/ref/sacCer3-mito/sacCer3.chrM.fa @@ -0,0 +1,2 @@ +>chrM +TTCATAATTAATTTTTTATATATATATTATATTATAATATTAATTTATATTATAAAAATAATATTTATTATTAAAATATTTATTCTCCTTTCGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAATTATTAATTAATAATAAATTATTATTAATAATTATTTATTATTTTATCATTAAAATATATAAATAAAAAATATTAAAAAGATAAAAAAAATAATGTTTATTCTTTATATAAATTATATATATATATATAATTAATTAATTAATTAATTAATTAATAATAAAAATATAATTATAAATAATATAAATATTATTCTTTATTAATAAATATATATTTATATATTATAAAAGTATCTTAATTAATAAAAATAAACATTTAATAATATGAATTATATATTATTATTATTATTAATAAAATTATTAATAATAATCAATATGAAATTAATAAAAATCTTATAAAAAAGTAATGAATACTCCTTTTTAAAAATAAAAAGGGGTTCGGTCCCCCCCCTTCCGTATACTTACGGGAGGGGGGTCCCTCACTCCTTCTTAATTAAATTATCTTAATTAAATTATCTTAATTAAATTATCTTAATTAAATTATCTTAATTAAATTATCTTAATTAAATTAAAAGGGGACTTTATATTTATAAAGTAATTATATTATTATTATTATTATTATTTATTTATTTTATTTTTATTATTTTATTATATATATTATATATTAATACAGATAGAAGCCAAAAGGTCAGGCGCTTTCTTTGGGAGAAAGACCTAGTTAGTTCGAGTCTATCCTATCTGATAATAATTTAATTAACCATTAAAAAAAAGTATATATATTTATCATAATATATTAAATTTTATTACATTACAAATGAACACTTTTATTTATATTTATAAAAATATGAACTCCTTCGGGGTCCGCCCCGCGGGGGCGGGCCGGACTCCATATTATTATTATTATAATTATTATTATAATTATTATTATAATTATTATTATAATTATTATTATAATTAAAGAGTTTTGGATACCAATATGATATAATATGATATAGGACCGAAACCCCTCATTTTATCATTTATTTATAATATTATAAATAAAAAAAAATATTATATATTATAATAAAATTAATATCATAATATATTATATTATATATTATATTATATATATATATATATATATTCTTTTATAAAATTTATATTCTTCTTATTAAAATTAAAAAGGGAGCGGACTTTTAATTATATTTAATTATAGTTTTTAATCATTGGTTGAGATTTCAAAATAAGGTATAATATTTATATTATTCTTTAACAAATATTATATTATAAAAAAAGATATAATATTTATATTATTCTTTAACAAATATTATATTATAAAAAAGATATAATATTTATATATTATTATTAATATTATTTTTAAGTTCCGAAAGGAGAAACTTATAATTTTTATATCATTATTTATTATTATTTTTAATTTCAACTCCTTTTAGGTATTTCCATTTAACTTTCAGCAGAGACTTTCTAATTATAATTATATATATATAAATTTAAATACATTTATAAAAAAGTATATAATATAATTATATTATATATAATAATATTATTAAATGAAGTATTCTTTATTATTAATTATAGGATATCTGGGGTCCATTAATAATTATTATTGTAAATAATAATAAGGACCCCCCCCATTATCTAATTAATAAATATATAAATAATCATTAATAAATATATTAATAATTATTAATAAATATATAAATAATCATTAATAAATATATAAATAATATAATATATTATAAAAATATAATAATAATAATTTATTATTAAAATATAATAATTTATTATAAAAATATAATAATTTATTATAAAAATATAATAATAACTCCTTTCGGGGTTCACACCTTTATAAATAATAAATAATAAATAATAAATAATAAATAATAAATATTAGTATTCACTAATATAAAATAATAATTATAAAAATAATCATTATTAAAAATATTATTAATTATTAAATTAAATACAATTAATATAATTTAGTTGTTTATATAATTTTAAATAATGTTTATATCAATTTAATAAAATTAAATTTATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGTTTATCTATATATTATAATAACTATATGAATTTAATTATTAAAAATAATAAAAATAAGGAATTTTAATAAGAAGTAATATTTATTATATAATATATAAAAAAAATATATATATATATATAAAAATATATATAATAAGTTTTATTATAATATATATTAAATTAATTATTATGAGGGGTTCGGTCCCTTTCCGGGCCCCAATTCATCTCATCTCATTTTATTTCATTTCAATATCATCTAATCTCATTTCTTTATAGATTTTACATATATATAAATATAAATATAAGATATTCACATTTATATATAATATAATATAATATAATAGATATTCATTCCTCTTTGATTAAACTAATAATTAATAATTAATAATTAATAATTAATAATTAATAATTATTCAGTAGAACTCCTTCTTAAAAAGGGGTTCGGTCCCCCTCCCATTAGTATAGTATAGGGAGGGGTCCCTCACTCCTTCGGGGTCCGCCCCGCAGGGGGCGGGCCGGACTATTATTAAATAATTTATAATTTATTATTTATTAATATATTTATATAATATAATATAATATAATATTATTCATACTTTTTATTAATATAATATAATATAATATTATTAATACTTTCTCCTTTCGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAACTATTAATATAAAGAAAAGAGTTTCAATTATTTATTTATTTATTTATTTTTTATAAAAATAAGTCCCCGCCCCGGCGGGGACCCCGAAGGAGTATTAATTTAAATAATTTATTTAATGAAATTATTAATTATAAATAAAAATAATAATTTTTAAAGATGTAATATAAAAATAAATATAATATAATTTAGGATAATTATATAAAATATTTATTATATATAGTTTTTATAAAGAGTTTTAAAAGTGATAATATAATATATAATATTTATAAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGTTATTTATATATATATAATTATAATCTTATTAATTATTTATATATATATTTAATATTATTTTTATATAATTTTATATTAAAGTATTATAATTATATATTTAATATTATTTTTATATAATTTTATATTATTTATTTATTTATTTATTTATTTAAAAATATTATAATCATATATTTAATATTATTTAATATATTTTATATATTATATCTTTTATTGATTTATATATATATAGATTTAATAAATATATATATATATATATATATAAATATTCATTATATATTTATTATTATTATTATTATTTATTACTATTTTTTATTATATATTAATAATATATATATTATTAGTTATGGGTATCCTAATAGTATATTATTATTTTTAATAATAATTTATGATTTATGTATAATAAATAAGTAGGGAATCGGTACGAATATCGAAAGGAGTTATATATTATTAATTATTTATAATTATTTTATATATTATTAATTATTTATAATTATTTTATATATTTATAATTATTTTATATAGATAGGTTAGATAGGATAGATAGTATAGATAGGGGTCCCATTTATTATTTACAATAATAATTATTAATGGGACCCGGATATCTTATTGTTATTAATTTATATATTATTCATTATTATTAATATATATTTAATATAATTAAATATTATATTATATTATATTATATTATTTATTAAAAAAAAATCTATTACTTATTTTTTTTATTAATATATAAATTATTTATATAATTTATCATTTTTATTTATATATTATTATTTTTTATATATAAATTAATATATATATATATTATATATACTTTTTTTTTTATAATATATCTATATATATAAATAAATATATTATATTATATTTTTATATAATATATTATTAATTATTATTTTAATTTTCTATTCTATTGTGGGGGTCCCAATTATTATTTTCAATAATAATTATTATTGGGACCCGGATATCTTCTTGTTTATCATTTATTATTTTATTAAATTTATTATTATTTTTAATTTATATTTATATTATATAATTAATTATATCGTTTATACTCCTTCGGGGTCCCCGCCGGGGCGGGGACTTTATATTTTATTATATAATATATTATATTCTTATAATATATTTATTGATTATGTTATAAAATTTATTCTATGTGTGCTCTATATATATTTAATATTCTGGTTATTATCACCCACCCCCTCCCCCTATTACGTCTCCGAGGTCCCGGTTTCGTAAGAAACCGGGACTTATATATTTATAAATATAAATCTAACTTAATTAATAATTTAAATAATATACTTTATATTTTATAAATAAAAATAATTATAACCTTTTTTATAATTATATATAATAATAATATATATTATCAAATAATTATTATTTCTTTTTTTTCTTTAATTAATTAATTAATTAATATTTTATAAAAATATATTTCTCCTTACGGGGTTCCGGCTCCCGTAGCCGGGGCCCGAAACTAAATAAAATATATTATTAATAATATTATATAATATAATAATAATATAATAATTTTATATAAATATATATTTATATATTAAATTAAATTATAATTTTATTATGAAAATTATATCTTTTTTTTATATTTTTATATAATAAAAATATGTTATATATATATTAATAATAAAAGGTAGTGAGGATTAAATAAATTATATAATAATTATAACTCTTAATTATAAAATAAATATATATATATATATAAGTATCCATTTCCATATAATCTTTTAATAAATATTAATAAATATTAAAAAAAAATAATATTATAATATTTTAGTATATAATTCAATAAAATTCATTGGAGGGGTAAATAATAATAATTTACTAATGGCAAGTTATAGTCTTAAAGGTTTTTATTTTTTTTATTAAATTAATAAAATAATAATACCATTTATATATTCCATTATATATATATATTTAATAAAAATAATAATATCATTTATATATTTTATTATATATTATATATATTTTATATAAAATAATAATAATAAATTTATATTTTTATATATTATTATTAAATAATAATAATATAAATAACTCCTTCGGGGTTCGGTCCCCACGGGTCCCTCACTCCTTCTTAAGAATAAAAAGGGGTTCGGTCCCCCTCCCGTTAGTACACGGGAGGGGGTCTCTCACTCCTTCTTAAAAAATAAAAAGGTGGAAGGACTAATATAATTTTAAATAATAATTAATACTTTAATAATAATTTGTATTTCTTTATTATTAATATATTAAATATAATAATAATTAATATAATTACAATATATTAATATTATCAAATATTAATAAATATACTTTTTTATATAATTTATTTATTTATTTATTTTTTTTTTATTAAACTAATTATAATTGTAATTTCGAAAAGGGGGTGGGAGTAAACATATATAATTTATAATCTATATATATATATATATAATTTTTTAATAAATATTAATAAATATTTATAAAAAGAATAATTTATATTTATAATATATAATTTATATATTTTATTTTTATTATACAATTAATATAAAATATAAAATATTAAATATTAAATATTAAATATTAAATATTAAATATTAATTTTTATAGGGGTTATATAATAATTATATTTATAATTATATAATATTAAAAAGGGTATTTTTATAATTATTACATTTTTATTTTATTTATAAAAATATTAATTTTAATAAGTATTGAATACTTTATATAATATAAATATTAATTACATAATTAATAATTAAATAATATTTAATAATATTATTTAAATTTATTATTTATAATTATTTATTTATAAAATTCTATTTTTATTATTATTATTTTTATTTTATTATTAAAGATTAATATAATAATTATTAATATATTAAAAATCTTTTATTATATTAATATTTATAAAAAAGTATTTAATAAAAAAGATGTATAAATTTATAAATTATATAATATTATTAATTTATATAATAATAATATTATAACTTTGTGATTGTCAATTTAGTTAATCATTGTTATTAATAAAGGAAAGATATAAAAAATATTCTCCTTCTTAAAAAGGGGTTCGGTTCCCCCCCGTAAGGGGGGGGTCCCTCACTCCTTTGGTCGGACTCCTTCGGGGTCCGCCCCGCGGGGGCGGGCCGGACTAATTTAACTTTTAATATTAATATTAATATTATTTATATTTTTAATATATAAAAATAAATAATTTTATTTTTATTAATAGTATATTATATAAACAATAAAATAGTATTAATTATATAAAATTTATATAAAATATATATAAATTTATTATATATATATATATTAATATTTTAATAAAGTTTTTATTATAAATTTATTTATTTATTTATTATAATATTAATAATTTATTTATTATTATATAAGTAATAAATAATAGTTTTATATAATAATAATAATATATATATATATATATTATTATATTAGTTATATAATAAGGAAAAGTAAAAAATTTATAAGAATATGATGTTGGTTCAGATTAAGCGCTAAATAAGGACATGACACATGCGAATCATACGTTTATTATTGATAAGATAATAAATATGTGGTGTAAACGTGAGTAATTTTATTAGGAATTAATGAACTATAGAATAAGCTAAATACTTAATATATTATTATATAAAAATAATTTATATAATAAAAAGGATATATATATAATATATATTTATCTATAGTCAAGCCAATAATGGTTTAGGTAGTAGGTTTATTAAGAGTTAAACCTAGCCAACGATCCATAATCGATAATGAAAGTTAGAACGATCACGTTGACTCTGAAATATAGTCAATATCTATAAGATACAGCAGTGAGGAATATTGGACAATGATCGAAAGATTGATCCAGTTACTTATTAGGATGATATATAAAAATATTTTATTTTATTTATAAATATTAAATATTTATAATAATAATAATAATAATATATATATATAAATTGATTAAAAATAAAATCCATAAATAATTAAAATAATGATATTAATTACCATATATATTTTTATATGGATATATATATTAATAATAATATTAATTTTATTATTATTAATAATATATTTTAATAGTCCTGACTAATATTTGTGCCAGCAGTCGCGGTAACACAAAGAGGGCGAGCGTTAATCATAATGGTTTAAAGGATCCGTAGAATGAATTATATATTATAATTTAGAGTTAATAAAATATAATTAAAGAATTATAATAGTAAAGATGAAATAATAATAATAATTATAAGACTAATATATGTGAAAATATTAATTAAATATTAACTGACATTGAGGGATTAAAACTAGAGTAGCGAAACGGATTCGATACCCGTGTAGTTCTAGTAGTAAACTATGAATACAATTATTTATAATATATATTATATATAAATAATAAATGAAAATGAAAGTATTCCACCTGAAGAGTACGTTAGCAATAATGAAACTCAAAACAATAGACGGTTACAGACTTAAGCAGTGGAGCATGTTATTTAATTCGATAATCCACGACTAACCTTACCATATTTTGAATATTATAATAATTATTATAATTATTATATTACAGGCGTTACATTGTTGTCTTTAGTTCGTGCTGCAAAGTTTTAGATTAAGTTCATAAACGAACAAAACTCCATATATATAATTTTAATTATATATAATTTTATATTATTTATTAATATAAAGAAAGGAATTAAGACAAATCATAATGATCCTTATAATATGGGTAATAGACGTGCTATAATAAAATGATAATAAAATTATATAAAATATATTTAATTATATTTAATTAATAATATAAAACATTTTAATTTTTAATATATTTTTTTATTATATATTAATATGAATTATAATCTGAAATTCGATTATATGAAAAAAGAATTGCTAGTAATACGTAAATTAGTATGTTACGGTGAATATTCTAACTGTTTCGCACTAATCACTCATCACGCGTTGAAACATATTATTATCTTATTATTTATATAATATTTTTTAATAAATATTAATAATTATTAATTTATATTTATTTATATCAGAAATAATATGAATTAATGCGAAGTTGAAATACAGTTACCGTAGGGGAACCTGCGGTGGGCTTATAAATATCTTAAATATTCTTACATAAATATTAATCTAAATATTAATATAAATATTAATATTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAAATATTAATATAAATATAAATATTAATATAAATATAAATATAAATATAAATATATTTTAATATAATATAATATAATATATAATATATTATATAAATATAATATATAAATAATATAATAAAATATTTTAATATATATATAATATAATATAATTATTATTATAATTTAATATAAATTATTATTATAATTTAATATAATAAATAAATAAATAATTATAATTATAATTATAATTATAATCTCAATATATAAATGATAAATTATTATAAATACAAAGGAAATAATTGATTTTTAAAATATATTTAATAAAATATATAATATAAATTATACTTTTTTTGTTATTATATAATAATTATATTAATATATTTAATAGAATTAAACTCCTTCGGCCGGACTATTATTCATTTTATATATTAATGATAAATCATTAATTATTATTAATAAATTTATTTATAATATTTAATTTTATATATTATTATTTATAATAAAAAAAATTATATTATAACAATTTAATTTTAATTTTTATTTTTAAATTATAAAATTAATAATTTATTTGTTTAAATAAAATTTATAACTCCTTCGGGGTTCGGCCGGACTATTAATATAAATAAATAATAAATATTTATAATAAAATAATATACATCTTCTTTAAATAAAAAAAGGGGACATTATAAATAGTATATAAATATATTATATCTTTTTTATTATTATTATTAATAAATAATAATAATAATTTATATATTTATAATATATTTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAATGTATTATAATTATTACATATAATTATTATTATTCACTTCTTATTAAAAATAATACTCTATATAATTTATATAATTTATTTTAATATATATATATTTATATATAATATAATATATATATTTATTTATTATAATCATTTTTTTTTAACTTAAAATAAAACTTATTATAATTTATATAATTTATAATTTTTATATAAAAATAATTATATAATTTTTATTTATTTATATAATAATAATATTATTTGTTATATATTATATATTATATATATAATAAATAAATAAATAATAAATAATAATAATAAGGATATAGTTTAATGGTAAAACAGTTGATTTCAAATCAATCATTAGGAGTTCGAATCTCTTTATCCTTGATAATAATAATAAAAATATGTATTTATTTAATTATTTTAATATTTCTCCTTTCGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAACTATTAATATAATATAATATAATATAAATATTCATTTATCTTTTTTTTAATATTCTTAATTAATTAATTAATTAATATATTAATTATAAAAAATATATTATAATTTTATTATTAATAAGTATAAATATATTATTAATAATAATTTATTAAAAATATATTATTATAATATATTAATATATCATAATTATAATCAATATTATATTATTTAATTTTATAATACTTAATTATTAATATATTATTCATATATATATAAATTAAATTAAATTAATTATATTGAATATATAAATATATATATATATAAATATATAAAAAATTATATAAATTATTTTAAGTAAAAATAATATTAATAAAAATTATACAATAATAATAATAAATATTCATTATTATTTAATTAATATCTCCTTTACTTCTTTTTCCTCCGTTGAGGACTTATTATTAAGTATATTATTATATACTACTTAAGATTATATATATAATATATATATATATATTATATATAAAATATAAATATATAAATAATATAAAAATTAATAAAATAAATAAAATAAATTAGTCCGATCGAATCCCCTATTTAATTAAATTAAATTAAATTAAGAAAGAGATAAATTTATATAAAATATTATTTATAATTAATTATAATTAAATTATAATATAATATAATATAAATAATAATATAATAAAAATAAAAATAAAATAATATTAGATTATATTATATAATTTATATAATTTTTTAATAATAATAATAAATAAGTTTATTTATAATTATAAATATAAATATAAATATAAATAAAGAAGGTATTATATTTTATAAAATATAATAATAATACAAAATTTATATTTTAATAAATATTAATATAAGTTTAAAGTTCCGGGGCCCGGCACGGGAGCCGGAACCCCGAAAGGAGAAATAAATAATATATTTATAAAAAATTAAATAAATAAATATTATCTATTTAAAAATAAATATAATATAATATAATATAATAATTCTAAATATAAATAATATTTATTATAATTATTATAATAATTGTATTATTTATTAATAATATATATAATTATATTAAAACTAATATTACATTATTTTGTATATTTAAACAATTAAATTGATTATTCTTATTTGTAATCTTTATTTATTTTATTATATCTTATTAATGATAAATTATAATTATTATTAAAATAATAATTTACTTCTTTTGATATAAAAATAAAATAATATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGGAAGGAGATAAATATATTATATTTTTATTCCTACCTATTAAAGGTAAAGACTCGATTCTCATAATTAAATTTATATCCTTCGGCCGGATTAATTTATTTTATTTATATTTATATTTATAGTGAATACCTTTTTTAATATTTATTTTTAATATTTATTTTTAATATTTTATTTTTAATAAAATATAATCTTGTAAGTAAGAAAAGAATTTCGGTGATTGGAACCTTGAAAGGATAAATTTCTTATTTATTATAATATTTATATTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGTATTATTAAACATTTAATATATTATATTAATATTTAATTTAAATGATTAATATATTATTATAATAATATTTATTTTATATTAAAATATTATAATTAATATATATATATTTATTTTAATAATATTATTATTATTATTATTAAAATTATTATTTTTATAAATATATATATATATATATATATATTATTTTTATTCTTATATAAATTATATAAAAAAAATATATATAATATATAATTAATTAATATATATTATTTAAATTATATATTATTTAAAATACTTTTTATATTATATCTTCTTTAAATTAAAATATAATTATTATTTATATTATAATTATTTATGAAATATTATTATTAAAATAAAAAAGAGGTTTAGACTATATATTTATTATTTATAAACTTATTATATTATTTATTATTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAAATAAATAAAATAAAAAATAATAAATATTAATATTATTAAATATTATTTATAATAAATATTAATATTATTAAATATTATTCATATTAATAAATTTTATTATTATTTGTAATATATTAAATATTAATAATATATATATTATTTATTATAATGAAAACCTATCCTATATTATCCTATCATATAATATCATATCATATTATATTATATCTTATTATATGATATATAAAGTATTCACTCTATATGAGGTTATGATTATTATATAAATCTTATTTTATTTTTATTTTTATTTGGACTAATAATAATTATAATAATAATTATTGATATGTTCTAATATTAATAAATACATATTTATATTATAATATAAATATTCATTTCTTACTAATTAATAAAAAGTTTTTATATTCATTATAATATAAATATATAAATATATATAAATATTTTAATAATTATAATTATATTAAGATATTATAAATATATATTTATTTTTTTTTATAAAATAAATAAATAAATAAATAATTAATATTTTTATATTATAACTTATTTTTATAATAATAATAAGTATTTTATTTTTTATTATATTATTATTTATATAATTATATATATATTAATTTCAATTTAATTAATTAATTAATTGGTATTTGGCATATAATATCAATTAATTGTAATTCTTATAAGAATTAATTAATTAATATGCTTTTTATATAATTTATACTTTTATATTTCTCCTTCCGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAACTATTATTATTATTTTTATTTATTTATTATTAAAATATAATAATAAATAGTCCGGCCCGCCCCGCGGGGCGGACGCCGGAGGAGAATTATATTTTTATATAATAATTTATATTTCTATATATATATATATATATTATATATAAATATTATTATATATATTTTTATATATATTATAATTATATTCATTAATATTTTATTATAGTGGTGGGGTCCCAATTATTATTTTCAATAATAATTTATCATGGGACCCGGATATCTTCTTGTTTTTATTTATTATTTTATTAAATTTATTTTAATTATTTATTTATAATTTATATTATACAATTTATTATTTCGTTAATACCTTTATTTATATTATATAATATATTATATTATTATAATATATTTATTGATTATATTAATACATTTAACTAATGTGTGCTCTATATTTATTGAATAGTTTGGTTCTTATCACCCACCCCCTCCCCCTATTACGTCTCCGAGGTCCCGGTTTCGTAAGAAACCGGGACTTATATATTTAATACTAAAAATATAACTACATTACTTTTTTAATATATATAACAATATATATATATATATATATTAATTATATAAAATATAATACTCTATATTAAATATTATTTTTATCAATATTTATTTATATATATAATAATAATAATAATAATCAATATTAATTATTTATATATATAAGATTAATATTATTTAATATATTATGAATAATTTAATTAATAAATCTTTAAATATTATCATAAAAATATAAATTAAATAATTTCTTATTTATAATAAAGAATAATAATATATATAAATATAATAAAGAATGTAAATAATATATATATAATATAATATAATATAAAAAATATATATATATATAAATATATATATAATATATAGATAATAATATTTTTATATAATTTATTTTATTATTAAGTAATAAATAATAAAAAAATCAATATATTAAATAATATATTTATATTAGTTCGGTTTAGTTGGTATTTTGTAATGAGTAAAAAGTAATATATAATATTAAATAATAAGTATTGATATAAGTAATAGATATAATAATAATATTATTAATATTTTATATAAATAATATTAATAATATAGATTATGAAAGAGAGTATTAATATCATTAAATATATATATATGTTATATAATTTAAATGATTTTAATATATATATATATATTATATTATAGATTATGATACATTTATATAAATAATATATATATAAAAATTAATTATACTATTACTTTATAATATAATAATATTTATTTATAAAGATATAAAAGAATTGTTTAAAGTTATAACTAAAATATTATATAGTATTCATTAATAATTAATATTATAAATTCAACTATTGTTATATTTATAAATAGAATAATATATTATTATCCTTTAAGATATAACAATAATTATTTAAATTAAATTAAATTAAATTTAATTAATTTTTTTTTTTAATGAATATAATAATAATAATATTATTAAAATTAATATATAAAAAAAAAGTAAAAATGGTACAAAGATGATTATATTCAACAAATGCAAAAGATATTGCAGTATTATATTTTATGTTAGCTATTTTTAGTGGTATGGCAGGAACAGCAATGTCTTTAATCATTAGATTAGAATTAGCTGCACCTGGTTCACAATATTTACATGGTAATTCACAATTATTTAATGGTGCGCCTCTCAGTGCGTATATTTCGTTGATGCGTCTAGCATTAGTATTATGAATCATCAATAGATACTTAAAACATATGACTAACTCAGTAGGGGCTAACTTTACGGGGACAATAGCATGTCATAAAACACCTATGATTAGTGTAGGTGGAGTTAAGTGTTACATGGTTAGGTTAACGAACTTCTTACAAGTCTTTATCAGGATTACAATTTCCTCTTATCATTTGGATATAGTAAAACAAGTTTGATTATTTTACGTTGAGGTAATCAGATTATGATTCATTGTTTTAGATAGCACAGGCAGTGTGAAAAAGATGAAGGACCTAAATAACACAAAAGGAAATACGAAAAGTGAGGGATCAACTGAAAGAGGAAACTCTGGAGTTGACAGAGGTATAGTAGTACCGAATACTCAAATAAAAATGAGATTTTTAAATCAAGTTAGATACTATTCAGTAAATAATAATTTAAAAATAGGGAAGGATACCAATATTGAGTTATCAAAAGATACAAGTACTTCGGACTTGTTAGAATTTGAGAAATTAGTAATAGATAATATAAATGAGGAAAATATAAATAATAATTTATTAAGTATTATAAAAAACGTAGATATATTAATATTAGCATATAATAGAATTAAGAGTAAACCTGGTAATATAACTCCAGGTACAACATTAGAAACATTAGATGGTATAAATATAATATATTTAAATAAATTATCAAATGAATTAGGAACAGGTAAATTCAAATTTAAACCCATGAGAATAGTTAATATTCCTAAACCTAAAGGTGGTATAAGACCTTTAAGTGTAGGTAATCCAAGAGATAAAATTGTACAAGAAGTTATAAGAATAATTTTAGATACAATTTTTGATAAAAAGATATCAACACATTCACATGGTTTTAGAAAGAATATAAGTTGTCAAACAGCAATTTGAGAAGTTAGAAATATATTTGGTGGAAGTAATTGATTTATTGAAGTAGACTTAAAAAAATGTTTTGATACAATTTCTCATGATTTAATTATTAAAGAATTAAAAAGATATATTTCAGATAAAGGTTTTATTGATTTAGTATATAAATTATTAAGAGCTGGTTATATTGATGAGAAAGGAACTTATCATAAACCTATATTAGGTTTACCTCAAGGATCATTAATTAGTCCTATCTTATGTAATATTGTAATAACATTGGTAGATAATTGATTAGAAGATTATATTAATTTATATAATAAAGGTAAAGTTAAAAAACAACATCCTACATATAAAAAATTATCAAGAATAATTGCAAAAGCTAAAATATTTTCGACAAGATTAAAATTACATAAAGAAAGAGCTAAAGGCCCACTATTTATTTATAATGATCCTAATTTCAAGAGAATAAAATACGTTAGATATGCAGATGATATTTTAATTGGGGTATTAGGTTCAAAAAATGATTGTAAAATAATCAAAAGAGATTTAAACAATTTTTTAAATTCATTAGGTTTAACTATAAATGAAGAAAAAACTTTAATTACTTGTGCAACTGAACTACCAGCAAGATTTTTAGGTTATAATATTTCAATTACACCTTTAAAAAGAATACCTACAGTTACTAAACTAATTAGAGGTAAACTTATTAGAAGTAGAAATACAACTAGACCTATTATTAATGCACCAATTAGAGATATTATCAATAAATTAGCTACTAATGGATATTGTAAGCATAATAAAAATGGTAGAATAGGAGTGCCTACAAGAGTAGGTAGATGACTATATGAAGAACCTAGAACAATTATTAATAATTATAAAGCGTTAGGTAGAGGTATCTTAAATTATTATAAATTAGCTACTAATTATAAAAGATTAAGAGAAAGAATCTATTACGTATTATATTATTCATGTGTATTAACTTTAGCTAGTAAATATAGATTAAAAACAATAAGTAAAACTATTAAAAAATTTGGTTATAATTTAAATATTATTGAAAATGATAAATTAATTGCCAATTTTCCAAGAAATACTTTTGATAATATCAAAAAAATTGAAAATCATGGTATATTTATATATATATCAGAAGCTAAAGTAACTGATCCTTTTGAATATATCGATTCAATTAAATATATATTACCTACAGCTAAAGCTAATTTTAATAAACCTTGTAGTATTTGTAATTCAACTATTGATGTAGAAATACATCATGTTAAACAATTACATAGAGGTATATTAAAAGCACTTAAAGATTATATTCTAGGTAGAATAATTACCATAAACAGAAAACAAATTCCATTATGTAAACAATGTCATATTAAAACACATAAAAATAAATTTAAAAATATAGGACCTGGTATATAAAATCTATTATTAATGATACTCAATATGGAAAGCCGTATGATGGGAAACTATCACGTACGGTTTGGGAAAGGCTCTTTAACACGTGGCAACATAGGTTAATTTGCTATTTCATTTTTAGTAGTTGGTCATGCTGTATTAATGATTTTCTGTGCGCCGTTTCGCTTAATTTATCACTGTATTGAAGTGTTAATTGATAAACATATCTCTGTTTATTCAATTAATGAAAACTTTACCGTATCATTTTGGTTCTGATTATTAGTAGTAACATACATAGTATTTAGATACGTAAACCATATGGCTTACCCAGTTGGGGCCAACTCAACGGGGACAATAGCATGCCATAAAAGCGCTGGAGTAAAACAGCCAGCGCAAGGTAAGAACTGTCCGATGGCTAGGTTAACGAATTCCTGTAAAGAATGTTTAGGGTTCTCATTAACTCCTTCCCACTTGGGGATTGTGATTCATGCTTATGTATTGGAAGAAGAGGTACACGAGTTAACCAAAAATGAATCATTAGCTTTAAGTAAAAGTTGACATTTGGAGGGCTGTACGAGTTCAAATGGAAAATTAAGAAATACGGGATTGTCCGAAAGGGGAAACCCTGGGGATAACGGAGTCTTCATAGTACCCAAATTTAATTTAAATAAAGTGAGATACTTTAGTACTTTATCTAAATTAAATGCAAGGAAGGAAGACAGTTTAGCGTATTTAACAAAGATTAATACTACGGATTTTTCCGAGTTAAATAAATTAATAGAAAATAATCATAATAAACTTGAAACCATTAATACTAGAATTTTAAAATTAATGTCAGATATTAGAATGTTATTAATTGCTTATAATAAAATTAAAAGTAAGAAAGGTAATATATCTAAAGGTTCTAATAATATTACCTTAGATGGGATTAATATTTCATATTTAAATAAATTATCTAAAGATATTAACACTAATATGTTTAAATTTTCTCCGGTTAGAAGAGTTGAAATTCCTAAAACATCTGGAGGATTTAGACCTTTAAGTGTTGGAAATCCTAGAGAAAAAATTGTACAAGAAAGTATGAGAATAATATTAGAAATTATCTATAATAATAGTTTCTCTTATTATTCTCATGGATTTAGACCTAACTTATCTTGTTTAACAGCTATTATTCAATGTAAAAATTATATGCAATACTGTAATTGATTTATTAAAGTAGATTTAAATAAATGCTTTGATACAATTCCACATAATATGTTAATTAATGTATTAAATGAGAGAATCAAAGATAAAGGTTTCATAGACTTATTATATAAATTATTAAGAGCTGGATATGTTGATAAAAATAATAATTATCATAATACAACTTTAGGAATTCCTCAAGGTAGTGTTGTCAGTCCTATTTTATGTAATATTTTTTTAGATAAATTAGATAAATATTTAGAAAATAAATTTGAGAATGAATTCAATACTGGAAATATGTCTAATAGAGGTAGAAATCCAATTTATAATAGTTTATCATCTAAAATTTATAGATGTAAATTATTATCTGAAAAATTAAAATTGATTAGATTAAGAGACCATTACCAAAGAAATATGGGATCTGATAAAAGTTTTAAAAGAGCTTATTTTGTTAGATATGCTGATGATATTATCATTGGTGTAATGGGTTCTCATAATGATTGTAAAAATATTTTAAACGATATTAATAACTTCTTAAAAGAAAATTTAGGTATGTCAATTAATATAGATAAATCCGTTATTAAACATTCTAAAGAAGGAGTTAGTTTTTTAGGGTATGATGTAAAAGTTACACCTTGAGAAAAAAGACCTTATAGAATGATTAAAAAAGGTGATAATTTTATTAGGGTTAGACATCATACTAGTTTAGTTGTTAATGCCCCTATTAGAAGTATTGTAATAAAATTAAATAAACATGGCTATTGTTCTCATGGTATTTTAGGAAAACCCAGAGGGGTTGGAAGATTAATTCATGAAGAAATGAAAACCATTTTAATGCATTACTTAGCTGTTGGTAGAGGTATTATAAACTATTATAGATTAGCTACCAATTTTACCACATTAAGAGGTAGAATTACATACATTTTATTTTATTCATGTTGTTTAACATTAGCAAGAAAATTTAAATTAAATACTGTTAAGAAAGTTATTTTAAAATTCGGTAAAGTATTAGTTGATCCTCATTCAAAAGTTAGTTTTAGTATTGATGATTTTAAAATTAGACATAAAATAAATATAACTGATTCTAATTATACACCTGATGAAATTTTAGATAGATATAAATATATGTTACCTAGATCTTTATCATTATTTAGTGGTATTTGTCAAATTTGTGGTTCTAAACATGATTTAGAAGTACATCACGTAAGAACATTAAATAATGCTGCCAATAAAATTAAAGATGATTATTTATTAGGTAGAATGATTAAGATAAATAGAAAACAAATTACTATCTGTAAAACATGTCATTTTAAAGTTCATCAAGGTAAATATAATGGTCCAGGTTTATAATAATTATTATACTATTAAATATGCGTTAAATGGAGAGCCGTATGATATGAAAGTATCACGTACGGTTCGGAGAGGGCTCTTTTATATGAATGTTATTACATTCAGATAGGTTTGCTACTCTACTCTTAGTAATGCCTGCTTTAATTGGAGGTTTTGGTAACCAAAAAAGATATGAAAGTAATAATAATAATAATCAAGTAATAGAAAATAAAGAATATAATTTAAAATTAAATTATGATAAGTTGGGACCTTATTTAGCTGGATTAATTGAAGGTGATGGAACTATTCTAGTTCAAAATTCATCTTCAATAAAAAAATCTAAATATAGACCGTTAATTGTTGTAGTATTTAAATTAGAAGATTTAGAATTAGCTAATTATTTATGTAATTTAACTAAATGTGGAAAAGTGTATAAAAAAATTAATCGTAATTATGTATTATGACTTATTCATGATTTAAAAGGTGTATATACATTATTAAATATTATTAATGGATATATGAGAACACCTAAATATGAAGCATTTGTTAGAGGTGCTGAATTTATAAATAATTATATTAATTCAACAACAATTCTACATAATAAATTAAAAAATATAGATAATATTAAAATTAAACCATTAGATACATCAGATATTGGTTCAAACGCTTGATTAGCTGGTATGACAGATGCAGATGGTAATTTTTCTATTAATTTAATAAATGGTAAAAATCGTTCTAGTAGAGCAATGCCTTATTATTGTTTAGAATTAAGACAAAATTATCAAAAAAATTCTAATAATAATAATATTAATTTTTCTTATTTTTATATTATGTCTGCAATTGCACTATATTTTAATGTTAATTTATATAGTAGAGAACGTAATTTAAATTTATTAGTATCTCTTAATAATACGTATAAACTATATTATAGTTATAAAGTAATAGTGGCTAATCTATATAAAAATATTAAAGTAATAGAATACTTTAATAAATATTCTTTATTATCATCTAAACACTTAGATTTTTTAGATTGATCTAAATTAGTTATTTTAATTAATAATGAGGGTCAAAGTATAAAACTTAATGGTAGTTGAGAATTAGGTATAAATTTACGTAAAGATTATAATAAAACTAGAACTACGTTTACTTGATCTCATTTAAAAAATACATATTTAGAAAATAAATAAATAAATTATTATTACTTTCTTCCCCTCCGAATCCGTAATATATTTACGGATATATAATCTCGTAGTGTAAAAGGTGTAACGAGATTATTAATAAGTTGCCGTAATATATTGTAAAATATATTATTATTACAACACTATATGCGGGAAAACCCTAAAGTCATAATATAATATTATCCCCACGAGGGCCACACATGTGTGGCCCTCGCGGGGTATGGTAAATTTAATTAAGTTATAAATGTACTATAGTATTAAAAATTATTATGAATAATTTCCCCACCCCCATGCGAAGCATGGGGGGGGGTATAAGTATGGACAATCCGCAGGAAACCAAATAATAATTAATATCCTGAAACAAAGTAAGTGAAGGAGATATCTTAAAATATATATAATATATATTTTATAAATTATTATGTAGGATCCTCAGAGACTACACGTGTTGCACCCATTATATTATGTATAATGGGTTGAAGATATAGTCCAAATATAATTGAAAGATTATAATAAAATGAACTATTTATTACCATTAATAATTGGAGCTACAGATACAGCATTTCCAAGAATTAATAACATTGCTTTTTGAGTATTACCTATGGGGTTAGTATGTTTAGTTACATCAACTTTAGTAGAATCAGGTGCTGGTACAGGGTGAACTGTCTATCCACCATTATCATCTATTCAGGCACATTCAGGACCTAGTGTAGATTTAGCAATTTTTGCATTACATTTAACATCAATTTCATCATTATTAGGTGCTATTAATTTCATTGTAACAACATTAAATATGAGAACAAATGGTATGACAATGCATAAATTACCATTATTTGTATGATCAATTTTCATTACAGCGTTCTTATTATTATTATCATTACCTGTATTATCTGCTGGTATTACAATGTTATTATTAGATAGAAACTTCAATACTTCATTCTTTGAAGTATCAGGAGGTGGTGACCCAATCTTATACGAGCATTTATTTTGATTCTTTGGTCAAACAGTGGCCCTTATTATTATATTAATAATATATAATGATATGCATTTTTCTAAATGCTGGAAATTATTAAAAAAATGAATTACAAATATTATAAGTCTATTATTTAAAGCCTTATTTGTAAAAATATTCATATCTTATAATAATCAGCAGGATAAGATAATAAATAATCTTATATTAAAAAAAGATAATATTAAAAGATCCTCAGAGACTACAAGAAAAATATTAAATAATTCAATAAATAAAAAATTTAATCAATGATTAGCTGGATTAATTGATGGTGATGGATATTTTGGTATTGTAAGTAAGAAATATGTATCATTAGAAATTCTAGTAGCATTAGAAGATGAAATAGCTTTAAAAGAAATTCAAAATAAATTTGGTGGTTCTATTAAATTAAGATCAGGTGTAAAAGCTATTAGATATAGATTACTTAATAAAACTGGTATAATTAAATTAATTAATGCAGTTAATGGTAATATTAGAAATACTAAAAGATTAGTACAATTTAATAAAGTTTGTATTTTATTAGGTATTGATTTTATTTATCCAATTAAATTAACTAAAGATAATAGTTGATTTGTTGGATTTTTTGATGCTGATGGTACAATTAATTATTCATTTAAAAATAATCATCCTCAATTAACAATTTCTGTAACTAATAAATATTTACAAGATGTACAAGAATATAAAAATATTTTAGGTGGTAATATTTATTTTGATAAATCACAAAATGGTTATTATAAATGATCCATTCAATCAAAAGATATAGTATTAAATTTTATTAATGATTATATTAAAATAAATCCATCAAGAACACTAAAAATAAATAAATTATATTTAAGTAAAGAATTTTATAATTTAAAAGAATTAAAAGCTTATAATAAATCTTCTGATTCAATACAATATAAAGCATGATTAAATTTTGAAAATAAATGAAAAAATAAATAAATTATTTAATAAAGATATAGTCCAAATTATATATATATAATATATATATATATAACAAGCACCCTGAAGTATATATTTTAATTATTCCTGGATTTGGTATTATTTCACATGTAGTATCAACATATTCTAAAAAACCTGTATTTGGTGAAATTTCAATGGTATATGCTATGGCTTCAATTGGATTATTAGGATTCTTAGTATGATCACATCATATGTATATTGTAGGATTAGATGCAGATCTTAGAGCATATTTCCTATCTGCACTAATGATTATTGCAATTCCAACAGGAATTAAAATTTTCTCATGATTAATAAATCCCTTTAGCAAGGATAAAAATAAAAATAAAAATAAAAAGTTGATCAGAAATTATCAAAAAATAAATAATAATAATATAATAAAAACATATTTAAATAATAATAATATAATTATAATAAATATATATAAAGGTAATTTATATGATATTTATCCAAGATCAAATAGAAATTATATTCAACCAAATAATATTAATAAAGAATTAGTAGTATATGGTTATAATTTAGAATCTTGTGTTGGTATACCTCTATATACTAATATTGTAAAACATATAGTAGGTATTCCTAATAATATTTTATATATTATAACAGGTATTTTATTAACAGATGGTTGAATTGATTATCTATCTAAAAAAGATTTAGATAAAAAAACAATTATAGAAATTAATTGTAGATTTAGATTAAAACAATCAATAATTCATAGTGAATATTTAATATATGTATTTATATTATTATCACATTATTGTATAAGTTATCCTAAAATAAAAATTGCTAAAGTTAAAGGTAAATCATATAATCAATTAGAATTTTATACTAGATCATTACCATGTTTTACTATTTTAAGATATATATTTTATAATGGTAGAGTAAAAATTGTACCTAATAATTTATATGATTTATTAAATTATGAATCTTTAGCTCATATAATTATATGTGATGGTTCATTTGTAAAAGGTGGAGGTTTATATTTAAATTTACAATCTTTTCTAACTAAAGAATTAATTTTTATTATAAATATTTTAAAAATTAAATTTAATTTAAATTGTCTATTACATAAATCTAGAAATAAATATCTTATTTATATAAGAGTAGAATCTGTTAAAAGATTATTTCCTATAATTTATAAATATATTTTACCTTCTATAAGATATAAATTTGATATTATATTATGACAAAAAAAATATAATATGATTAATTAATTAATTAATTAATTAATTTATTTATTATTTACTTTTTTGATATATATAGAGGCAAACTCGAGGAAAACCATATAATTAGAATAAGTAATAATTATATGACAACCGTCGAACTAAATCATATTCAAGAAATTAATATGTAAAAGCGTAGAGATTAGACGCCTCTGGTTATCTAAGTAATATATATATATATATTATATGATAACATAAGGTATAATCCAATGAGATCAGTAATGATTTTAAAACAATAATTTTGTTTTAAGTATTAATAATAATATTAATATTCGACCTCTTAATTGAGGATATTATAATCATAATTTTTTATATTATAATATAAAATTTAACTAGCTAGATAATATTATATAAAAAAAAAAAATAATATTATATAAATTAATTAAAATAATTTTTATTAATTGAAACTGAAATGTTTTAAAGTTAAATAAAAGAGCTCTAATCCATGGTGGTTCAATTAGATTAGCACTACCTATGTTATATGCAATTGCATTCTTATTCTTATTCACAATGGGTGGTTTAACTGGTGTTGCCTTAGCTAACGCCTCATTAGATGTAGCATTCCACGATATTAATTTAATAAGTGTCGTGCTTAAAATTCACTAAAATAATATATAATAAATTATAATAAATATATAAAAAAAATAAAAAAAATAAAAAAAAATTAATATCTTATGATTAATTTTATATAAATAAAAATTTATTAAATATTATTGGTTATATATATATATATATTAATAATAAAAAAATATATATATATATATAGCTAACGGGGAAACTCTTATAATTATTATTTATATAATAAATAAGACAATCCCGTGATAACTTTAATATATATATATTATATATTAAAGTATTGTAGAGACTAAACGTGAATGATTTTAATATTATTTAAATATTAAAATTAAGAGATAGTCCAATCTTATATGTAAATATAAGTTAATACCAAAAAAAAAATAATATTATTTTGACTTATTATATATTAATATTATTAATAATAATTTTAACTAATAATAAAGTTTTTATAGAAACTTTATATTATTATTTAATATTTAATTTTCAATTAATATCTCCTTTTGGGGTTCCGGTCCCTGGTCCGGCCCCCGAAACTAAAGATATTAAGAATTTATATGAATCAATTATAAATAATTATATTAATATTTTAAATAAATATCTTATTAATATTAATAAAGATAATATTAATAAATTAAAATTTTTAGATAATTATACTGAAGAAGAAAAAGGTTATTATTTATCTGGATTATTTGAAGGAGATGGTAATATTTATACTAGATGTTTTTCAATTACTTTTTCTTTAGAAGATGTTTTATTAGCTAATTATTTATGTCTTTATTTTAAAATTGGTCATATTACAGCTAAATATAATTTTAATAAAGAATTAACAGCTGTTAAATGAAATATTATAAAAAAAAAAGAACAAGAAGTATTTATAAATTATATTAATGGTAAATTATTAACATATAAAAGATATGATCAATATTTTAAATATAATTTTAATAATCGTTTAAATATTAAATTATTAAAACCTAAAGAATTTGATTTACTATTAAATCCTTGATTAACAGGTTTTAATGATGCTGATGGTTATTTTTATCTAGGTTTTCAAAAACATAAAAATAGTCAATGATTAAAATTTCATTTAGAATTATCACAAAAAGATAGTTATATTTTAGTCCGGCCCGCCCCCGCGGGGCGGACCCCAAAGGAGATATTATTAAAAAATATTTTAAACTTGGTGGTATTTTAAAAAGAGATTATAAATCTGGTGCTACAGCTTATATTTATAAAGCTCAATCATCAAAAGCTATAAAACCTTTTATTGAATATTTTAATAATTATCAACCATTAAGTCTTAGAAGATATAAACAATATTTATTATTAAATATTGCTTACTTATTAAAATTAAATAAATTACATATATTACTTAATTCTTTATTAATATTAAAAGAATTAATATTATTACAAAGTGTTAAAAATATATCTTTAGAAATAAAAAATGAATTAAATAATAGAGTTAAAATTATTATTAATAAACTTCATTATAACAATATCGAATAATGATAATATTAAAGAGTAAAATTCTTAAAGTGTTAATTAAATAATATTCTTTTTTTTTTATGACTTACTACGTGGTGGGACATTTTCGTGCGGTCTGAAAGTTATCATAAATAATATTTACCATATAATAATGGATAAATTATATTTTTATCAATATAAGTCTAATTACAAGTGTATTAAAATGGTAACATAAATATGCTAAGCTGTAATGACAAAAGTATCCATATTCTTGACAGTTATATTATAAAAAAAGATGAAGGAACTTTGACTGATCTAATATGCTCAACGAAAGTGAATCAAATGTTATAAAATTACTTACACCACTAATTGAAAACCTGTCTGATATTCAATTATTATTTATTATTATATAATTATATAATAATAAATAAAATGGTTGATGTTATGTATTGGAAATGAGCATACGATAAATCATATAACCATTAGTAATATAATTTGAGAGCTAAGTTAGATATTTACGTATTTATGATAAAACAGAATAAACCCTATAAATTATTATTATTAATAATAAAAAATAATAATAATACCAATATATATATTATTTAATTTATTATTATTATATTAATAAAATTTAATATATATTATAAATAATTATTGGATTAAGAAATATAATATTTTATAGAAATTTTCTTTATATTTAGAGGGTAAAAGATTGTATAAAAAGCTAATGCCATATTGTAATGATATGGATAAGAATTATTATTCTAAAGATGAAAATCTGCTAACTTATACTATAGGTGATATGCCTATCTTTATTTATATATATATTATTATTATTAATAATAAAAAAAAAAATTAAAAAAAAGATAGGAGGTTTATATATAACTGATAAATATTTATTATATTATTTTTTTTTATAATAAATATTAAAAGATATTGCGTGAGCCGTATGCGATGAAAGTCGCACGTACGGTTCTTACCGGGGGAAAACTTGTAAAGGTCTACCTATCGGGATACTATGTATTATCAATGGGTGCTATTTTCTCTTTATTTGCAGGATACTATTATTGAAGTCCTCAAATTTTAGGTTTAAACTATAATGAAAAATTAGCTCAAATTCAATTCTGATTAATTTTCATTGGGGCTAATGTTATTTTCTTCCCAATGCATTTTTTAGGTATTAATGGTATGCCTAGAAGAATTCCTGATTATCCTGATGCTTTCGCAGGATGAAATTATGTCGCTTCTATTGGTTCATTCATTGCACTATTATCATTATTCTTATTTATCTATATTTTATATGATCAATTAGTTAATGGATTAAACAATAAAGTTAATAATAAATCAGTTATTTATAATAAAGCACCTGATTTTGTAGAATCTAATCTTATCTTTAATTTAAATACAGTTAAATCTTCATCTATCGAATTCTTATTAACTTCTCCACCAGCTGTACACTCATTTAATACACCAGCTGTACAATCTTAAGTTATAAAATTTAATTATTTACTTAATAATTAAAAAGTAAATATTATATCTAAACTTAATAATATAATAATAATATTCTTATAAAAATATATAAAAAAAAATATATAAAATTTATTAAAATATCTCCTTTCGGGAACTATAATATATTTATATAAATAAATACTAATATAATCCTATTATATATATATATATATAAAATAATATATATATATAATTAATATAAATAATATTTATAATAATTTTTTAATAATATATATAATTTAATATATTAATGAATATTATATAATTATTAAATATATTATAATATTATTATTATTTTATAATAAAAATATTTTTAATACTAATTATTATTTATTATTTATAAATATATAAATAGTATGTTTAATATTATTAATACTAAAAAAAATATAATTATAATTAGGATCTAACAATACATTTATCTGATTAATATTAATATTAATATTAATATTTATATTAATAAACGGATTAAATTAATTGTATCCAATTTAATTAAATTATAGATATATTATTTATAATATTAATATATTGTTTTATTAAAAAGGTAAAAATAGTTTTTATTTTATATATAAATATAGGATATAAATAAATATATTATAGTGAACCCCGAAAGGAGAATATATTAAGAATATATTTATATTTTACATATAATTATTTATAATATAAATATCTCCGCAAAGCCGGATTAATGTAATTATTTAATAATTTTATTTAATAATTTATTAAAATAAATATTTACATTTGATAATATTTATATTATGTCAGTTATTTTATATTAATGTTTAATCTATTATAATATTTTTTTTTATAAATATATTATTTATTTATATTAATTATATATATATATTATTTTTATAATATATATATATTTTTATTAAATATTTATTAAATATTTATTAAATTATTATAATGTTGTTATTAATCTTATTAAAAAATATATATAAAAATGCCACAATTAGTTCCATTTTATTTTATGAATCAATTAACATATGGTTTCTTATTAATGATTCTATTATTAATTTTATTCTCACAATTCTTTTTACCTATGATCTTAAGATTATATGTATCTAGATTATTTATTTCTAAATTATAATATATATTATTAATTTATTTATTCATATAAATATTATTATTATATATAAATATTAATAATATTTATACTTATTTAATAATAATAAAATAAAAAATAATTATAATTTAATATATTTAATATATTTCCTTACGGACTATATATTTATATATATATATTAAATACAATTTAATTTAATTTAATTATGTTATTTATTAAATAAAGTTATATTATGATATAATAACAATATTATATATTATTATATAATTATAATATATTTTAATATAATTATCAAAAGAAATAATAAAAAAATATTAATAAGAATATAATTTAATAATTATTAAAAAAAAATTCTTATAGTCCGGCCCGCCCCCCCCGCGGGGCGGACCCCAAAGGAGGAGTAATAAAAATTATTAAATACAAATATTATATATATATAATTCATTATATATATATATATATAATAATTAATCTTATTTTTTTATATATTTATTTATATATCTATTTATATTTTATATATATTTATTTATATATCTAAGGGGTTCGGTCCCTCCCCCCGTAAGTATAATATACGGGGGTGGGTCCCTCACTATTTATATTTTTATTTTATATATTTTATATATTTATAAATAAAGTATAATAAGATATAATTATGATTAATTATTTATAAGTTATAGTTTTATAAATTTATAATTATTATGTTTAATTTATTAAATACATATATTACATCACCATTAGATCAATTTGAGATTAGACTATTATTTGGTTTACAATCATCATTTATTGATTTAAGTTGTTTAAATTTAACAACATTTTCATTATATACTATTATTGTATTATTAGTTATTACAAGTTTATATCTATTAACTAATAATAATAATAAAATTATTGGTTCAAGATGATTAATTTCACAAGAAGCTATTTATGATACTATTATAAATATGCTTAAAGGACAAATTGGAGGTAAAAATTGAGGTTTATATTTCCCTATGATCTTTACATTATTTATGTTTATTTTTATTGCTAATTTAATTAGTATGATTCCATACTCATTTGCATTATCAGCTCATTTAGTATTTATTATCTCTTTAAGTATTGTTATTTGATTAGGTAATACTATTTTAGGTTTATATAAACATGGTTGAGTATTCTTCTCATTATTCGTACCTGCTGGTACACCATTACCATTAGTACCTTTATTAGTTATTATTGAAACTTTATCTTATTTCGCTAGAGCTATTTCATTAGGTTTAAGATTAGGTTCTAATATCTTAGCTGGTCATTTATTAATGGTTATTTTAGCTGGTTTACTATTTAATTTTATGTTAATTAATTTATTTACTTTAGTATTCGGTTTTGTACCTTTAGCTATGATCTTAGCCATTATGATGTTAGAATTCGCTATTGGTATCATTCAGGGATATGTCTGGGCTATTTTAACAGCATCATATTTAAAAGATGCAGTATACTTACATTAAATTATAAAATAAAATTATAAAATAAAATAATTTACATATGGAGTATTAAACTATAATAAATACAATATACCCCATCCCCCCCTTTTAATAATATTCTTTTATCTAATAAAATATTTATTTATTAATATTATTATTATCTTCTTCAAGGACTTATTTAATATATTTAATAACTTATTATACTTATTTATATTTATAATTAATACAAATATATTATTAATCTTACTCCTTCGGAGTTCGGCCCCCCATAAGGGGGGGACCTCACTCCTTCCCCACTGCACTGGATGCGGGGACTTATTTTTATTATTATTATTTAATCTTTATTTATAAAATTATATATTATATATAAATTATTATACTTAATAATTAAAAAAAAACCTCTAATTATTATTAATATTATATATAATATATATATTCTCATTAATGTTATATATAATATATATATTCTCATTAATATATTAATATAGTATTAAAAAAAATAAAATATTTAATAAATATTATTATTAATAATATTTATTAAAAATAATATAACATAATAAATATAAGATTATTATATAATATATTTATTATATCATATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGGAAGGAGAAATTATAACATATTTTTTAATAATATTCATATTTATTTTATATACAAATAAATATATTTATTTAGAATAATAAAAAAAAATAATAAATAAATATATTATTATCATTATTATACTTTATTCATTATTTATTATAATAATTATATATAACAATTATAATATATAATTATATTTTATATAATATTATATTAATATTTAATATATTTATTATTATTATTACTTCTATGGAAACTTTATATTTTAGATATTTTTATTATTATTATTAATTTATAATGTTATATTTTTGATTTATAAATATATAAGTCCCGGTTTCTTACGAAACCGGGACCTCGGAGACGTAATAGGGGGAGGGGGTGGGTGATAATAACCAGAATATTCAATAAATACAGAGCACACATTAGATAAATTTTATAATATAACCAATATAAAATAAAATTAAAATAATTAATATATATATATAAATATAATAAATTATTATATATAAATATATATAATTTTTATAATAAATATTATAATATTATATAAATAAATAATTATAATATATAATAAATATATAATAATAATAAAAATATTAACAATATAATAAAAATTTATAATATAAATATAAATTATAAATAAGTTAAATTAATAAAATAATAAATGATTAACAAGAAGATATCTGGGGTCCCATTAATAATTATTATTTTCAATAATAATTGGGACCCCCCACCATTATAATATCATATTAATTAATATAATAATAATGTATATAAAATAGAAATAATAATTAATATAATAATAATAATATATATAAAATAGAAATAATAATTAAATATATATATAAATAATTATTTATATAATATATTATAAATAATAATAATAATAAATATTTATTAATTAATAATGATTATAAATATTTTATTTAATATAAATTTATAACTATTTTATTATATATATATTTTTTATTCATAAAAATTCCTTTTGAGGATTTTTATTTTATATAAATATCTTCTAATATTTATAATAAATAATAATATATTCATTATATTTATAATTATATATAATGTAATACGGGTAAACATTACCCGTTGTTCACGGGTAATGTTTACCCTATTTTATATAATTCTTAATAAATATATTTATATTTTTATATAAAAAAAATTATAATAATTTATTAATTCTCCTTTCGGGGTTCCGGCTCCCGTGGCCGGAACTCCGGAACTATAAAAATAATTTTAATATAATTTATATATTTTATGATTAATATAATATATTATTAATGTAACTCCTTCGGGATTTGGTCCCCCTCGTAAGTATATAGTATATAGTATATAGTATACGGGGGGTCCCTCACTCCTTCGGGGTTCGGTCCTCCCTTACGGGTACGGATACGGATACGAATATGGGGAGTCCCTCACTCCTTATCACTACGCTGAAGGTGGAATTTATTTTATATTATTATTAAATCTTTATTTATTTAATTATATATTTAATATATATATTATTATAATAAAACACCTAATTATTATTAATGTTATATTTAATATAATATATATATTCTTAAAAATTTATATAATATAAATAAATAAAAAAAAAAGAAAGTACATAATTAATATTATTATAAATAATATTATTAAAAAGAATATAATATAATTAATAGAAAGACGTTTTAAAAATAAAAATAAAAATAAAAATAAAAATAAAAATAAAAATAAAAATAAAAATAAAAGAGTTTTGGTTTACATATCAAGACCCAATTCAATTGAAACTATTTATTTATTAATCTCCTCCCCTCCCCCTCACTATTATTATAAGTACAATTAGGGCGCCAACCCCGCAGTGTTATTTACTGGGAAATGTTTATCCCAATTAATATAATAACGAGAGTTATTAATTATTATTTATAAATTCATATAATGTAATATAATGTAATGTAATTAATAGAACATTATTGTGTTATTCACCAGTGTTAAGATATATTAATCCCAATTTTATTTAATAGTGAAGATTATATTTTATTAATTATGAATCCATATTATTATTATTTAATATATTTATAATATTATATATAATTATAATTATAAATAATTTATATAAAAAAAGTTTTATTAAAAAATATTATTAAAAATATAATATTAATAATAAATAAAAATAATATTATACTCTTAATAGAATTTATAATGATAAAAATTAAGATGAAGACTTTTTTTTATAATTATTATAAATTTATATAAAAATAATATATATATATTTATATTTATTTTATTAATATATATAATATATTTATGTATATTAAAAAGATATATTTAAATATTTTTATTTTTTTTTTATAAGATAATTTTTGTAAATATATAAGTAATAAATTAAGTTTTATAGGGGGAGGGGGTGGGTGATTAGAAACTTAACTGAATAATATATATAAAGCATACATTAGTTAATATTTAATAATATAATCAATATATAATAATTATAAAATAATTAATTATATAATAATAATAATGTATAAACAATATAATAAATTGTATAAAATAAAATATAAATCATAAATAAAGCTAAATTAATAAAATAATAAATGATAAACAAGAAGATATCCGGGTCCCAATAATAATTATTATTGAAAATAATAATTGGGACCCCATATAGAATATAAATAATTAAATATATATATATAAATAATAATTTATATAATATATTATAAATAAATAATAATAAATATTATTAATCTATAATAATTATAAATATTTTATTAATATAAATTTAATAATTATATATATTTTTATAATAACTCCGAAAGAGTAAGGAGATATTAATTTCTTATAAAAATTTATTAATAATAATAATATATAAAATATATAAATAATATATTATATATAAAATAAAATAAAATAAATAATATATTAAAAATATTGAAAGTATTTTAATAAATAATAAATTTAAAATTCATATTTATAATAATAAATAAATAAATAAATAAATAAGTAAATATTTAGATTCTCATTAATATTAATATTTATATTTCTTTTTTTTTATAATAATAAAAATATCATATATAAATATAATATAATATAATATAATAAATTATTATATATAAATAATAAATATTAAATATAATATATAATAATATATAATCTTACAATTTATAATTTAATAAAGAAGGAAATAAATAATAATAACTCCTTTTGGGGTTCCGGTGGGGTTCACACCTTTATAAATAATAAATAAAGATGTTTACTCCTCTTCGGGGTTCCGGTCCCCTTTTTGGGTTCCGGAACTAATTAATATTTTATATAATAATAATAATATATTAATATAATTTCATTATTAATAAATATCTCCTGCGGGGTTCGGTTCCCCCCCGTAAGGGGGGGGTCCCTCACTCCTTCGGAGCGTACTATTATTATAAATAATTATATATTATAATATAATTAAAAAGTATTATAATTGAAACGAAAATTGTAATTTTAAATGGAATAATAATTATTATATATTTAATATATTTAATAAAGTTATAATATCTCTTTCTACCGGACTATTTTATTTTATTTTATTTTATTTTTATAAAGAAAAATAGTAATAATATTATCTTCTCCTCCTTTCGGGGTTCCGGTTCCCGTGCCGGGCCCCGGAACTATTAATTATATAATATAATATAATATAATATAATATAATATGATACGGATCAAACATTACCCGTTGTTCACTGGCAATGTTTAATCCTATTGTATATAAATATAATAAAATAATTATCCCTCTCGTAATACATATATAAAATATAAAATATAAAATAAAAATATTATGATTATTATAATATATATATATATATATATAAATATATATATATAATTTATAATTTATATGATTAATATATTATATATATAAAAAATATATTAAATTTACTTTTTATAGAAAGGAGTGAGGGACCCCCCCCCCTTACGGGGGGGAACCGAACCCCGCAGGAGATATTTATTTTAATACTTATATAGTATTTATTAATAATATAATAATTGTTATTATAAATATTAATAATAATATAAAAATAGGGTAAATAATATAAATAATATGAATAAATATAAAAACATATTAAATATAAAATATATCATAAATTTAATAAATATTATAATAATTTATAAATGATAGATATCTGGGGTCCTATAAATAATAATTATTTTCAATAATTATAGGGACCCCCACCTATTATATAAATATAAATATAAATATAAATATAAATACAAATATAAATATATAAATATATAAATATAATATAAATACAAATATAATATATAAATATAAATATAAATATATAAATATAAGTCCCCGCCCCGGCGGGGACCCCGAAGGAGTGAGGGACCCCTCCCTATACTAATGGGAGGGGGACCGAACCCCGAAGGAGTATAAATAAAAATTAATAATATATATATAATTATAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAAATAATAATATAATATATAATAAAATATAACTTATTAATATAATATTAAAAATATAATTAACAAGAATAAATAGTCCGTGGGATCGAACCCCCTTTTTTATTTAATATTTAATATTTAAAGAAGGAATTGTTTATATATATTAATATCTTATTTGGGGATTAATATAATATATAAGTTTTGGATACCAGGCCAAAGACCGGAATCCCAAAAGGAGATTATATAAATATTATTTATCTCCCTTTTTTAATATTATAATAATTTTATTAAAAATAAAATAATAATAATAATTATAATTTATAATAACAATTATAATAATTTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATAATAAATATAAATATAAAAAGAATATAATTTATAATAAATAAATTTATATATATATATATATATTAAATAAAATATTTACTTCATTAATATAAAATATAAATATATTTAATTAATAAGTATATATATATAATAATATATAATAACCTATTTATATATATAATCTTAATATAATTATAAGAAATATTATATAAGTAATATATAAAAATAATATAAAATAATTATAATTCAATTTATATATTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGGAATAAGATAAATATATAAATTATATTAATAAATATAAATTTTAAATGAATTAATAAAATTAATATATATATGTATATATATATATATATTAAAAATATTTAATTATTTTTAGGAAGGAGTGATAGATCCCTTTGGGGGACCGAACCCCTATTTAAGAAGGAGTGCGGGACCCCGTGGGAACCGAACCCCTTTTTTATTTAAAGAAGAAGTTTTATTTTATTTTATTTTATTTTATTTTATTTTATTTTATTTTATTTTATTTTATTTTATTTAATTTAATTTTAATTAGGTTAATAAATAGTAATAATAAACTTAATAATAATAATAATAATTTTATTTTTATAATTTATTAATAATAATAATAATTATATATATATATATTATTAATAAATATAGACCTTATCGTCTAATGGTTACGACATCACCTCTTCATGTTGATAATATCGGTTCGATTCCGATTAAGGTTATTCATAATAATAAATATTTGTAAAAAAAGTATATATAATTAAACATATTCTTTATATTAATTAATAATTATTAATAATATACATTTTATATAATACAATTATATATATATATATATTTTTTTTTAATACAAATAATATATTCATAATAATAAATACCGATTGTTATTATACTATAATAAAATATATAATATATTTTTCATTATAATATTTTTAAATAAATATTATAATAAATTATATAAATAATATTTATGTATAATAATAATAATAATAATTGTTATTAATTAATTCTATAATTATTATATATTTAATTTTTTTTTTTAATATAATATATAATAATATAATTTATTTTATTTTTTTTTATAGTTCCGGGGCCCGGTCACGGGAGCCGGAACCCCGAAAGGAGAATATAAATTAATAATAATATAAATAACATATTAACAATAAATTATTGTTAATATAATAATAATAATAACAATATTAATAAATAATATAAAAATTATTAATATTATATTTATATAATATTAATATAAAAATCTTTCATAATATTAATTATTATTAAATAATAATGATATCATTAATATTAATATAATCGTCAATATTATTTATTTATTTATTTATTTATTTATTTATTTATTTATTTATTATTAAATAAATATTTTTAAATATTATATTATATTATTAACTTTTTATTAAAAAAATTAATAATGATATAATATAATTAATATTATCCACGGGACCAATGACCAACCCAGTAGTTGACCGGATTGGCGCCCGCGAGGTTTATATTTAATAAATAATAATAATAATATTAATAAAATCTATTAACTTTTTTTTTTAATGGATTATATTAATGAAAAAAAAATGAGAAATATCTTTTTTTTTTAATAATTATAATTTATATATAATAAAATATGTATATATAATAAAAAAATAGTTTTTAATATTATAATATAATTATATATATAATTATAAATATATATATATATAATAAGTATTAATTAATAATATATATTTATATATTTTTTATTAATTAATATATATAAAATATTAGTAATAAATAATATTATTAATATTTTATAAATAAATAATAATAATATGGCATTTAGAAAATCAAATGTGTATTTAAGTTTAGTGAATAGTTATATTATTGATTCACCACAACCATCATCAATTAATTATTGATGAAATATGGGTTCATTATTAGGTTTATGTTTAGTTATTCAAATTGTAACAGGTATTTTTATGGCTATGCATTATTCATCTAATATTGAATTAGCTTTTTCATCTGTTGAACATATTATAAGAGATGTGCATAATGGTTATATTTTAAGATATTTACATGCAAATGGTGCATCATTCTTTTTTATGGTAATGTTTATGCATATGGCTAAAGGTTTATATTATGGTTCATATAGATCACCAAGAGTACTATTATGAAATGTAGGTGTTATTATTTTCATTTTAACTATTGCTACAGCTTTTTTAGGTTATTGTTGTGTTTATGGACAGAGTGAGACAAGTATAAGTATATTATTATAATATCATACCATTAAATAAATTATTTTAATGAAATGATTATGTTTATATATAACATATACCTAATTAGACATGCATTATTAGTAATAATTTTGTATGAAACTCTAATAATAATAATTATTATTAATTATTAAGGTAAGATTCATATGGATAGCGTAAGTCAATCTAATATTATAAAATATCGTAACATAAACAATATTTTTTTCTATTATTAATTAATAAATAATAATAAATAAAAATAATTATATGAGAAGTAAGATATTCAATTCTGTCTAGAATACATATATATACGTTAATACTCATCGGTATAAAATTAGAATCCTAAGTGAATTATTGAAAGTATAATAATATAAACTTGGTAAGCCCAATTATTTCCATATAATATTAATATAAATATTATATGGTAGTTATATATAATATTATTAAATAAATAATAATAGAAATTATAATATAGATAAGTGGGTAAAAGACTATTGAAAAAGCTAAAGATTATATGTAATGTATAATATAGATCAAATTATTTATATATTTTAATAAAAATATATTAATAATGGTTAATATTATTATTAATTAATTAATTAATTAATTAATAATAATAACGAATAAATGATTAATGTGAAAGCATGCTAACTTCAATATAGGATGATTTATATAGTATATAAATTGTTTGAGCTGTATACTATGAAAGTAGTACGTACAGTTCTGAGTGGGGGAAAATTTGTAAAGATCTACCTATCACAATTGTCACATTGAGGTAATATAAATATCGCCTCAAATATATTTAATATAATAAAACTAATTTATATAATAATGTTAATATTATTAATTTATATTTTTTATACGATTATAATAAGACAAATAATAAAAACTAAAGAATATCTTATATTAATTAAGAGTATAGATTATATTAATAAAAATAAATATATAATTAATTTAAATATAACAAATAAGAAAGATATAAATAATAATATTGGTCCATTAAATATAAACATTTTATCAATTATTTATGGTTCAATATTAGGAGATGGTCATGCTGAAAAAAGAAAAGGTGGTAAAGGAACAAGAATTGTATTTCAACAAGAATATTGTAATATTAATTATTTATATTATTTACATAGTTTATTAGCTAATTTAGGTTATTGTAATACTAATTTACCTTTAATTAAAACTAGATTAGGTAAAAAAGGTAAAATTAGACAATATTTAAAATTTAATACATGAACTTATGATTCATTTAATATGATTTATTCAGAATGGTATATTAAAAATATATCTGGAAAAGGTAATATTAAAGTTATTCCTAAATCTTTAGACAATTATTTAACTCCTTTAGCTTTAGCTATTTGAATTATAGATGATGGATGTAAATTAGGTAAAGGTTTAAAATTCACAACTAATTGTTTTAGTTATAAAGATGTTCAATATTTACTTTATTTATTACATAATAAATATAATATTAAATCTACTATTCTTAAAGGCAATAAAGAAAATACACAATTTGTTATTTATGTATGAAAAGAATCTATACCTATTTTAACTAAAATTGTATCTCCTTATATTATTCCTAGTATAAAATATAAATTAGGTAATTATTTATAATAAAATATATAGTATTATATTAATTATTATATTATTATAATGCGATATTATTGAAAACATGTCAAAATTATATTATTAAGTAACAAGACAGTGGGTTATATAATTATATGATCCCAACAGAATACACCAATAATAGGTATTATTATAAAAAAAATAATAATATTTAATGTTTATTCGAAGAAAATTTATAATATTATTATTATAACACAAGGTTTAATAATCTATATATATATATTATATATATAACTACTGTTATTATTCCATTTACCTAATTAATATATAAATAATGAATTATAATTATTATGATTAATATTTTTATAATAATAACCCCATCATAACATTTATATATAACATTTATATATAACATTTATATATAATATTTATATTATGGTATTATTAGGTATAAATATTTATTCATAAGAGAAAATAGTGATTAAATGGAATTATAAAAAGGGTAGATATTATTAAATACAGGGTATTATTTATATTAATAAATCAATAAATATTGAGATTATTATTATTAAAAAATAATAATAATTTATAAATAATATTATTTTCTTGGCACTAGTTATTACTAATTTATTCTCAGCAATTCCATTTGTAGGTAACGATATTGTATCTTGATTATGAGGTGGGTTTAATATAGAGGATCCATATTATAGTAATATAATATTAAATAAATCTGTTTTATGCTGAAATATCTTCATTTGAATAATAAATTACTATATTATTCAATTAATTATTTATAATAATATAATTTGAAATAAAAATAATATAGTTAAAATATTTATTATAAGAAGAAAATTAGCAGTAATTAATATATATATATATATAAAATTAATTATTCAGAGACTTTATAGTTATTATATAAATAATACTATTATTTATGATAAAAATCATAAATTAAACACAGATAATCCTATTTATGCATATATTGGTGGTTTATTTGAAGGAGATGGTTGAATTACTATTTCAAAAAAAGGTAAATATTTATTATATGAATTAGGTATTGAAATACATATTAGAGATATTCAATTATTATATAAAATTAAAAATATTTTAGGTATTGGTAAAGTAACAATTAAAAAATTAAAAATAAAAGATGGTACTATTAAAGAAATATGTAAATTTAATGTAAGAAATAAAAATCATTTAAAGAATATTATTATTCCTATTTTTGATAAATATCCTATATTAACTAATAAACATTATGATTATTTATATTTTAAAGATAATTTATTAAAAGATATTAAATATTATAATGATTTATCTTATTATTTACGTCCTATTAAACCATTTAATACTCTTGAAGATATTTTAAATAAAAATTATTTTTCTTCATGATTAATTGGTTTTTTTGAAGCTGAAAGTTGTTTTAGTATTTATAAACCTATAAATAAAAAAATAAAACTTGCTAGTTTTGAAGTATCTCAAAATAATAGTATAGAAGTTATATTAGCTATTAAATCATATTTAAAAATTACTCAAAATATTTATACAGATAAATTTAATAATTCAAGAATAACACTTAAAAGTATTAATGGTATTAAAAATGTTGTAATATTTATTAATAATAACCCTATTAAATTATTAGGTTATAAAAAATTACAATATTTATTATTCTTAAAAGATTTACGTCTTATTCTTAAATATAATAATTATTTTAAAATTCCTCCTAAATATTAATCTTATATAAAAATATAATAATAATATATTTATATATTATATAATTATATAAACAAAATATAATTTATATATAATTATTTATTATAAATATAGTCCGGCCCGCCCCGCGGGGCGGACCCCGGAGGAGTGAGGGACCCCTCCCTATTCTAACGGGAGGGGGACCGAACCCCGAAGGAGTTTAATTATATATTAAATATATTATTATCAATAAATAATTCCTTTGAACTATTTATTATTTTATTATATTTATTTTCTCCTTCATTATTAATTTTTATTAATAATTAAAATCTTATCATTTTATGGTATTTTTATTTCTATTTTAGGATATCGAAACTATAAATTAAAAAGTATAATTTTATTAATTATAATTTATGATTAATAAATAAGAAATAAAAACTTTAGAAGTAATATTTATCTTTTTTTTTTATAAATAAATATTATGATTAATATATAATCATTTATAAATATTTATATATAATTATATATATACATAAATAGGATTAAGATATAGTCCGAACAATATAGTGATATATTGATAATAGTTTTCAAATATGTAACTATTTAAACATTAAAAGCTCAGTATCTAACCCTCTAATCCAGAGATTCTTTGCGTTACATTATTTAGTACCTTTTATCATTGCTGCAATGGTTATTATGCATTTAATGGCATTACATATTCATGGTTCATCTAATCCATTAGGTATTACAGGTAATTTAGATAGAATTCCAATGCATTCATACTTTATTTTTAAAGATTTAGTAACTGTTTTCTTATTTATGTTAATTTTAGCATTATTTGTATTCTATTCACCTAATACTTTAGGTCAAAATATGGCCTTATTATTAATTACATATGTAATTAATATTTTATGTGCTGTATGCTGGAAATCTTTATTTATTAAATATCAATGAAAAATTTATAATAAAACTCTATATTATTTTATTATTCAAAATATTTTAAATACAAAACAATTAAATAATTTCGTATTAAAATTTAATTGAACAAAGCAATATAATAAAATAAATATTGTAAGTGATTTATTTAATCCCAATAGAGTAAAATATTATTATAAAGAAGATAATCAGCAGGTAACCAATATAAATTCTTCTAATACTCACTTAACGAGTAATAAAAAGAATTTATTAGTAGATACTTCAGAGACTACACGCACACTAAAAAATAAATTTAATTATTTATTAAATATTTTTAATATAAAAAAAATAAATCAAATTATTCTTAAAAGACATTATAGTATTTATAAAGATAGTAATATTAGATTTAACCAATGATTGGCCGGTTTAATTGACGGAGATGGTTATTTTTGTATTACTAAAAATAAATATGCATCTTGTGAAATTCTTGTAGAATTAAAAGATGAAAAAATGTTAAGACAAATCCAAGATAAATTTGGTGGTTCTGTAAAATTAAGATCAGGTGTTAAGGCTATTAGATATAGATTACAAAATAAAGAAGGTATAATTAAATTAATTAATGCCGTTAATGGTAATATTCGTAATAGTAAAAGATTAGTACAATTTAATAAAGTATGTATTTTATTAAATATCGATTTTAAAGAACCTATTAAATTAACTAAAGATAATGCTTGATTTATAGGGTTCTTTGATGCTGATGGTACTATTAATTATTATTATTCCGGTAAATTAAAAATTAGACCTCAATTAACTATTAGCGTTACAAATAAATATTTACATGATGTTGAATACTATAGAGAAGTATTTGGTGGTAATATTTATTTTGATAAAGCTAAAAATGGTTATTTTAAATGATCTATTAATAATAAAGAATTACATAATATTTTTTATCTTTATAATAAAAGTTGTCCTTCTAAATCTAATAAAGGTAAACGTTTATTTTTAATTGATAAATTTTATTATTTATATGATTTATTAGCTTTTAAAGCACCTCATAATACTGCTTTATATAAAGCTTGATTAAAATTTAATGAAAAATGAAATAATAATTAAATTTTCTCCGTATTCATTATTATATTATCTAATTTATAAAATATTTAAAGATTCCTTATAATAATATAACATCTTTGTAAATTATTGTTAAAGATAATATAAATTATTATGAATCGGTAGATTATATTTTTACAATCTTATTAAATAAAATTCTGATCATTAAACATGATTGAAGAAATAATAATAGTTTATGAAATAAGATAGTGTAATATAAATTTTTATGAAGATATAGTCCATTTTATATTTATTATAAAAGCATCCTGATAACTATATTCCTGGTAATCCTTTAGTAACACCAGCATCTATTGATATTAAAAATATTAATAAAATTATTATTATTTAATCTTATTTATTTTATATAAAAAAAATAAATAATAATTATTAATAAAAATATATTATTTATTTCTCCTTTCGGGGTTATTTATATATATTCCTTTATAATTTATATTTAATATATTATATTAAATATATGAAAAATTATAATAAATAAATTAATTAATTAATAATAAATAATAATAAAAAGTACAGTAGCATTAAATATTCTTAAGTTTCCGCTTTGTGGGAACTCCCATAAGGAGTTTAATGATTAAAATTGGTTAATTGTCAAGAAAATCTAAGGTATTAATAAATAAATAATACTATGACAACTTGCAGCGAAGTTTATATCATCTCTATATTATATATTAATATATATATATAATAATAATAATAATATTAATATAATATAAGATATAAAAACGTTCAACGACTAGAAAGTGAACTGAGATAGTAATACCTTTCCACGAAAACCAATTAATTTATAAATTATTTTTAAATAAAGAATAGATTATTAATTTTTTTTATATAGTTCCGGGCCCCGGCCACGGGAGCCGGAACCCCGGAAGGAGTAATATATATTATATATAAAATAAAAAATATATATATATATATTATAAAATATCAAAAGTTTTAATCTTTTATTATAAATTAATGACATAGTCTGAACAATAATGAAAATTATTGAGATAAGATATTAAATAATCTTATGTTAACATATATAAATTGTGTACCTGAATGATACTTATTACCATTCTATGCTATTTTAAGATCTATTCCTGATAAATTATTAGGAGTTATTCTAATGTTTGCAGCTATTTTAGTATTATTAGTTTTACCATTTACTGATAGAAGTGTAGTAAGAGGTAATACTTTTAAAGTATTATCTAAATTCTTCTTCTTTATCTTTGTATTCAATTTCGTATTATTAGGACAAATTGGAGCATGCCATGTAGAAGTACCTTATGTCTTAATGGGACAAATCGCTACATTTATCTACTTCGCTTATTTCTTAATTATTGTACCTGTTATCTCTACTATTGAAAATGTTTTATTCTATATCGGTAGAGTTAATAAATAATATATAATTAAATTAATACATAGATATAATATATATATTATTATTATTAATAATATAATAAAAATAAAAATAAAATTATTAATAATAATAATACTTTAATAATATTCTTAAAAATAATATATCTCTAATTTATAAAAATTAAATAATAATAATAAAAAAAAAATATTATAAAATATAAATTAATTAATAATGAAAATAATATACTTATTAAATTAATATAAATAAATGAATAATATAATATAACTATATTGAATTATAATCTATCTATCTTTTTTTTTCATATAATTATAATATATATATTAATATATATAATTATTATTTTATATATTATAGTTCCGGGGCCCGGTCACGGAAGCCGGAACCCCGCAAGGAGATTTATTAATTATTATTATCATTATTATTTTTTATTTAATCTTATTTATTATAAAATAATTAATTATCATAAAGCATAATTATTATAGAATCTTATTATTTTCTTTATTTAAATTTATAAAAATATAAAGTCCCCGCCCCCTTTTTATTTTATTTAATTAAGAAGGTATTTTAAAAAAGGAGTGAGGGACCCCCTCCCGTTAGGGAGGGGGACCGAACCCCGAAGGAGTACTCATTTAATATAAATATTAAATAAAAATTATTTTATATATATTAATGATTATTAATATTGATAATATAAATTATTTTATAATTAATTATTATAAATATATAACTATTAATAATTAATTTTTAATCTAGGGGTTTCCCCCACTTACATAAACTTACGTATACTTACATATACTTATGTATACTTACATATACTTACGTATACTTATATATACTTATGTATACTTACGTATACTTACATATATGGGGGATCCCTCACTCCTCCGGCGTCCTACTCACCCTATTTATTAATCATTAATAAGAAATTATTATTAAAAAAATTATAATTTACTCAAAGTTAATTATAAATATATTTTTAAATATCTATTTTATTAATCTTTTATAAAATTTAAATTAATTGTAATTAATTAATATTATAATAATTATTCTTAGGAAGGATATTTATTTATTTTAATTATGAATTCCTGACATAGAGACAATTAATTAGAACTTCTTATTATTATTATAGTAATAATAAAAATATTCTAAATATATTATATATATTATTATTTTTTTTATTATTAATAAAATATTATAATAAATTTAAATAAGTTTATAATTTTTGATAAGTATTGTTATATTTTTTATTTCCAAATATATAAGTCCCGGTTTCTTACGAAACCGGGACCTCGGAGACGTAATAGGGGGAGGGGGTGGGTGATAAGAACCAAACTATTCAATAAATATAGAGCACACATTAGTTAATATTTAATAATATAACTAATATATAATAATTATAAAATAATTAATTATATAATATAATATAAAGTCCCCGCCCCGGCGGGGACCCCAAAGGAGTATTAACAATATAATATATTGTATAAAATAAATTATAAATATTAAATAAAAACCAAATAAATAATATAATAAATGATAAACAAGAAGATATCCGGGTCCCAATAATAATTATTATTGAAAATAATAATTGGGACCCCCATCTAAAATATATATATAACTAATAATATATTATATATATTAATATATAATAATATTATTAAAATATAATATTATTAAAAAAAAAGTATATATAAAATAAGATATATATATATAAATATATATATTCTTAATAAATATTATATATAATAATAATAAATTATTTCATAATAAATTATTTCTTTTTATTAATAAAAATTACTTATCTCCTTCGACCGGACTATTAAATATTAAATATTTAATATTTAATATTTAATATTTTATTCTATAGATATTCATATGAAAAATAATAAGTATATAATTATGATAATGAATATATTTTTATTTATAATTTATTATTATAAAAATATTTTAATTTAATAATAATAATAAATCATTATATTAATTCTTTTAAGAATTTATAATTGTCATTATTTATTATATACTCCTTATTAAAAGGGATTCGGTTTCCCTCATCCTCATGGGTATCCCTCACTCCTTCTGATAATTAATTTTATAATAATAATAAAATAAACTTAATTAAATATTATATATTTATTTACAATTATATATATATATTACTCATAATTAAATTAAATTAAGATGCAATTCAATACGGTTGTATTATATTATTCATCAAATATTGTTAATATTGATACCTACAGAGATATTTAATATTTTTATTATTATTATCCATTACTTTTTTTATTATATTTTAATTATTTATTTATTTATTTATTTATAATAATAATATTTCATATTATCAATTATTATTTTTTTTTTTTATAATATATAATTAAATTATTTATATAGTTCCCCGAAAGGAGAATAAATAAAATATTATATAAATATTTATATCTTTATTAATATTAATATAAGTAATATATATAGTTTATGATATTTAATTTTATCATAATATAATAATAATTATATAAATCTTATACACATTTATATAAGTATATATATATATTATTAATATAATGAACATCTATTAAATAAAATAATTGTAAATCTCAAGTAAATTATTATTATTTTATTTTTAATAATAATTTATGATTTATAATTAATAAATAAAAGAGTAATTATATGATAAAAAAGGTAATAAATAAAATTTATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGTTTATTTATATATATATATATATGAATTAATATTTAATAATAAATAATAATATAATTAATAATATTATTATTATTATAATTTTTTTATTTATAATATTAATAAAATATTATTATATATATATTATAATAATATTAATAAGATATATAAATAAGTCCCTTTTTTTTTATTTAAAATAAAGAAAGAATAATTAAATAATATTTTAATAATTTAATTAAATAGTGTATTAAAAGATAATAAAAAGTAATATTAATATGTTAATTATATATAATATATTTATATATAATTATATATATATATATAAATAATAATAAATATATATATAATATAAAAATAAGAATAGATTAAATATTTAATAAATAAATATTATGCAATTAGTATTAGCAGCTAAATATATTGGAGCAGGTATCTCAACAATTGGTTTATTAGGAGCAGGTATTGGTATTGCTATCGTATTCGCAGCTTTAATTAATGGTGTATCAAGAAACCCATCAATTAAAGACCTAGTATTCCCTATGGCTATTTTAGGTTTCGCCTTATCAGAAGCTACAGGTTTATTCTGTTTAATGGTTTCATTCTTATTATTATTCGGTGTATAATATATATAATATATTATAAATAAATAAAAAATAATGAAATTAATAAAAAAATAAAATAAAATAAAATCTCATTTGATTAAATTAATAACATTCTTATAATTATATAATTATTATAAAATATATAAATATTATAATAATAATAATATATATAAATTATAATAAAAAATAATAATAATATATAATATACCTTTTTTTTAATATATTAATATATAAATAAATAAATAATGGATAATATATAATTACTTTTTTTATATTATTAATAATAATAATTTATAAATATTGTTATAATAAACATTTATATAAATAAATATAAATTACCATAATAAGATATATTATTTATTAATAATAAAAATATTTATTAATAAATAAGAAATATATATATTATGATAATATTTATTAATAAATAATAAATTCTTTATATATAAATATATTAAATATATTTAATTGAACACAATATAATTTTTATTGTATTATTCATTTAATAATATTAATATTAATATTAATATAATATTAGTGAACATCTCCTTTCGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAACTATTAATATTTAATAAAATATATATAATTTATAATTTTCATATAATTAATATAATAATTAGGTTTATAAATAAATTATAATATATTATAACAATATAATAAAATATATTATAAATCTATCTATCTATCTATATAATATATAAATTTATATATACATTAATAATATTTAATTATAATTATTTAAATATTTAATTTATTAATATTCCCCGCGGGCGCCAATCCGGTTGTTCACCGGATTGGTCCCGCGGGGTTTATATTATTTAAATATTAAATATTAAATAATAATTTATATTATATTAATAAATATAATAAATTAAAAATATATGATTAATTATATAATAATAATAATAATTATTTTAATATTATAATTTATAAAATTAATTATATTAATTATATTAATTCTTATTATATAATAATTATTAATAATAATTTATTTTAAGAAAGGAGTGAGGGACCCCCTCCCGTTAGGGAGGGGGACCGAACCCCGAAGGAGAAAATAAATTAATAAAAGTTTAAAAGTTCTTATATTAATAATTATATAATATTATATTAAAGATTTTTATAATATATATATATAATATATTTATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGTTTATTTAATATTTATATTTATATTAATATTTATATTTATATTTATATTCCTCTTAAGGATGGTTGACTGAGTGGTTTAAAGTGTGATATTTGAGCTATCATTAGTCTTTATTGGCTACGTAGGTTCAAATCCTACATCATCCGTAATAATACATATATATAATAATAATTTTAATATTATTCCTATAAAAATAAAATAAATAAATAAATAATAATAATTAATTAATTAATTAATTTTAATAAATATAAAATATATAAAAATAATAATAATAATAATTATTATTTTAATAATATTATTTATATAATAGTCCGGTCCGACCCTTTTTATTCTTAAGAAGGGATTTTATTTTATTAATTAATAATAATATATTAAAAATTATAAATAATTAATAATTCTTTATATTTATATATATATATATATATTTATATATTTATATATATATTTTAATAATATTATGATATATTTTATTTTAATAATATTTTTATTTTTATATATAAAATTATAATATTTTATTTTATAAATTATTTATATATAAATTATTAATAATAATTATTTTTTTTTATTTGGGATTTATATTATTATTATAAAGAATATAATGTTATTAATAACTGCAAAAAATATCTAATATATTATTATTTATAATAATAAATAATATTATAATAAGGATGCATATTATATATATATATATATTTCTATTTATATTAATATTAATATTAATATGTATATATAATAGATAAAAAGTAAAAATAAAAAATAATGAAATTAAAATTATTAAATATAATTTTATCAATAATAAATAAACTTAATAATAATAATAATATTATTATTAATAATCTATTAGATTCATTAATAAATAAGAAATTATTATTAAAGAATATATTATTAGATATAAATAATAAAAAAATAAATAATATAAAAAGAATATTAAATAATAATAATATAAACCCCGCGGGCGCCAATCCGGTTGTTCACCGGATTGGTCCCGCGGGGAATATTAATAATAAATTACAACATTTAAATAATATAAATAATTGAAATCTACAAATTTATAATTATAATAAAAATATAGAAATTATAAATACTATAAATGATAAATTAATTAATAAATTATTATATAAAATAATAACTTTAAAATTAAATAATATAAATATTAATAAAATTATTATAAGTAAACTTATTAATCAACATAGTTTAAATAAATTAAATATTAAATTTTATTATTATAATAATGATATTAATAATAATAATAATAATAATAATAATAATTATTATATAAATATAATAAATAAATTAATAAATATTATAAATAATAATATAAATAATAATTTATGTAATATTTTAAGTTATTATTATAAAAAAAAAGTAACTATTGAACCTATTAAATTATCATATATTTATTTAAATAGTGATATTTTTAGTAAATATATTAGTTTAAATGATATAGATAAATATAATAATGGTATCTTAACTAATTATCAACGTATATTAAATAATATTATGCCTAAATTAAATGATCATAATATTTCTATAAATTATATTAATAATATTAATAATATTAATAATAATAAATATAATAATATAATTAATTTATTAAATAATAATAATAATATTAATAATAATAATAATTATAATAATAATAATAATAATTATATTGGTAATATTAATAATATTTATAATAATATAACTATTGATAATATTCCTATAGATATTTTAATATATAAATATTTAGTTGGTTGATCTATTAAATTTAAAGGTAGATTAAGTAATAATAATGGTAGAACTAGTACACTTAATTTATTAAATGGTACTTTTAATAATAAAAAATATTTATGAAGTAATATTAATAATAATTATAAATTAAATTATATCCCTTCTAATCATAATTTATATAATAATTCTAATATTAATAAAAATGGTAAATATAATATTAAAGTTAAATTAAACTTTATTTAATATATATATTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAAATAAAATAAATATAATAAATAAAATAAATAAATAAATAATATATATATATATATAAATATATAAAATAATATTTACTTTTTATATATATATAATTATATATAAATAAAATATAATATAATATCATATAATTATATAAAAATAAAATTATAATTTATTTATATTAAAAATATTAATTAATTAATTTTTTTATATAATTATTATAATAATAATTTAATTAAAAATAAATATCAAATAAAATTATAAATTAATCCTACTTTTGGATCCTATTTATATTTTATTATTATAAATAATTATTATTGATAGTTAATTAAATAAAAATATATATATATATTACTCCTTCGGGGTCCGCCCCGCAGGGGGCGGGCCGGACTATTATAATTATTATTAATATATTAATTATTAAATTATATAAACCGCCCCCGCGGGGGCGGTTAGTTATTTATATTAATATATTTTATATTAATATATAATACTCTTTTTTCTATTATATTTTAATATATAATATTAAAAAAAATAAATAAAATAATATTCTTAATTTTTATTCTTTATCTTCTTTAACCAAACTCCTTCGGGGTTCGGTCCCCCTCCCATTAGGTTAGGGAGGGGGTCCCTCACTCCTTCGGGGTCCGCCCCCCCCCGCGGGGGCGGGCCGGACTATTTTAAATTTTAATTTAAATTTTATAAATATAATATTTAATTATAAATTTAATAATAATATATAAAAAATATATATATGGTTAATATATATAAAGATTATAATCTTTTTATTAAATAAAGGAAAATTTATTATATAATTTTTCTCTATAGTTATATATTTAAAACTTATTTTTTTTTTTTTATAAATAATAATTATAATAAATAATATTAATTATTTATTATATAATTAATTGGCCCCCATGCTGGGTTCCGGAACTCCTCCTTCTCGCGAGGTTAACACCTATTATATAACTATAACTATAACTATAACTATAATTATAATTATAACTATAACTATAAATATTCATTTTAATAATAATAATAATAATAATATTAATATAAATAGTCGAAGAATATATTTATTTATTTTAATATAAATAAAAAGTTTCAATTAATTTGAATTTGGAATTAAATTATTACTTCATATGGGGTTATGGATTTCGTTCGGAACTCCTCCCTCCTACCTCTATTTATTAATCATAAATCATAAATTATTATTAATTAATAATAATAATTTACTCGAGGTTCATACCTATTTTAATATTAATATTAATATTGATAAAATATATATTCACTAAAAAGTATATAATTTACTCAATTTATACTATAATTTTATATTTTTTTATTATAATTTAATTATTTCAAATAAAGTAATTATAATAATATATATCCTTTATTAAATATATATTAATTAATATATATATAAAAAGTAAATATTATTAATTGTATATAATTATAAATAATTAATATTTATTAAAATATATATAATTTATAATCCTCATATAATTAATATAATAAATAATATAACACAATGTAATTTAATTTAATTACATAATAAATTTATTATTATTATAATTATTATTTATTTATTTATTTATTATTATAAATTATAAATATTATTATAATTAAAATCAATTATTAATTATTAATGATAAATAATTAATGATAAATTATCAATAACCAATTAGATTATTTATCGATATTTAATTATATTATATTATATTATATTATATATATATATATATATTATATTATAAAATTTATTTATAAATATTTGTTTATTTATTTATTTATTGAATAACAATAGAATTAAATATTGTCAATAAATAATAAATAATGTTTAATATATATTATATTATATTAATATTAATATTATTATTATTTTTTTTATTATATTAATATAATTTATAAAAATATAAAATTATTATTTTTATTATAATTTATATATATATAATATATATATTTATTAAAATATTTTAAGAAAGGAGAAAAATAATTAAATTAAATTAAATTAAATTATTTATTATTATTATTATTATTTATATAATAATATATTATTTAAATATTTATATATTATTTTTATATTAATATTTATAGATGGGGGGTCCCTATTATTATTGAAAATAATAATTATTAATGGACCCCAGATAGCTTCTTGTTTATCATTTATATATATATATATATTATTAATTATTTTATTCTCCTTTCGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAACTTTATAATATTATTATTAATTATTTAATTAATATTATAATCATATAATTTAATATTTTATTTAATTTTATTAAAATTTAATATATATATTTTTATTATTATTTAATTAATTTATAAATATAAAATATTCTTAATATTAAAAATAAATAAATAATAAAGTTTATAAATCATATATTATAATTATTTATTATTTTTATATTATATTAATAAAATATTATTATTATAAAAAAAAATAGAAATTTTATAATATTTTTATATATTTTTAATTATTATTATTAATATTTATTAAAGGAAATATAAAAACCGAAGGAATATTATAATTATAATTATAATTATTATTATATTTAATTTATTATTATAATAATAATTATAGTCTGCCCCCTCTTTATCTTTATTTTAAAGTTCCGGGGCCCGGCTACGGGAGCCGGAACCCCGAAAGGAGAAGGATATTTAATAATTTATAATATTTAATTCATATATATATATATATATTTTATTTTTTATATATATATTTAATATATTATATTTATATTTATATTATTATTATATTTATATTATATTATTTAATTATTTTTTAATAATATATTATTAATATTTTACCTTTTGATAAATAAAAATTTATTAAAAATTTTATAATAAGTATTAAAATATCATAAAAGTATAATATTTATATAAAATGTATAAATTTATAATCTTCTAATTAAATTAAATTAAATAAATAAAATAAAATAAATTAAACTCCTTTTGAGATTCACACCTATTTTATTAAAAATAGGTATTCACTTAATTAAATTAAATTAAATTAAATTAAATTATGGATAATTTATTTAATAAATATATATATTAATTATAAAATAATAGTCCGGCCCGCCCCGCGGGGCGGACCCCGAAAGAGTCTGCCCCTTTTTATTTAATATTTAATATTTAATATTTAATATTTAATATTTAATATTTAAAGAAGGATATATTTATAATTTATCATAATATTATTTAATAAGAAATTATTAATTAATTAATTAATTAATTTATTTATTGTTTATATTTATTAATATTAATATAATAAAAATGTAAAATACTTAATATTATTAATATTATTATATATAATATATATAATAATATATTATATTTATATCTCCTTTATTCCTTTTTCCCCCGATGGGGACTTATTATATTATATTATTATATATTTCTTCGATAACTTTATATATATTTTATTTTTATAAAAAAATATTTATATATTATTATTTACAATAATAATTATTAATAGTCCGGCCCGTCCCGCGGGGGGGAACCGAAGGAGTGCGGGACCCCGTGGGAACCGCATCCCTTTTTATTTTTAATTAAGAAGGAGTGAGGGACCCCGTGGGGACCGAACCCCGAAGGAGTCTTTTTTCTATTTATTAATAATAACTATAAATTATATTTAAAATAATAATTTACTTGTTATAATCTTAATGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAAGTATATAAATATTTACTTGTTATAATTTATTATATATTTATAACCTCCTTCTTAAAATTATCTTTACTTTATAATAAAAATTAATATAATATAATCTGATAATAATCGAATTTTATTATATTTAATTTAATTAATAATAGACAATTATTATTATTATTTTACTTATTAATATTAATTTAGATTTATATATATAAATATTATTAATTTTATATTAATTTTTTATTAATTATTTATTTTTATATTCATATTTTTTATTAATATTATTTTTATTAATAACTTTTTAAATAATTATAAACTATATATTATTTATATTTATATTTATAATAAATGAAACAATTATAATAAAAATTACAATTACAATTATATTATAATTATGATTACAATAGGGTTAAACATTACCTGTGAACAACTGGTAATGTTTAACCCGTATTATTATTTATTATATTATATATATATTAAAATATTAATATTAATATTAATATTATATTATATTATATTATATTATATTATATTATATTATATTATATTTATAATTATATTATATTATATAATTTATATACTTTTATAATTCTTATTATTATTTATTTATTATTTATTTATTATTATTTAAATATATTATTATTATATATTAATAATATATATATTATTTTATATATTTTATTTAATATAAATTATTTATATTTTTATATTTTATTATGAGGGGGGGTCCCAATTATTATTTTCAATAATAATTTATCATGGGACCCGGATATCTTCTTGTTTATCATTTATTATTCTTATTATTTGGTTTTTATTTAATATTTATAATTTATTTTATACAATTTATTATATTGTTTATACCTTATTATTATTATATAATATATTATATTATTATAATAATTTAATTAATTATATTATTAAATATTAACTAATGTGTGCTCTATATATATTATTCATTCTAGTTTCTAATCACCCACCCCCTCCCCCTATTACTTATATATCTAGAAATAAAAATACATAACATATATTTTAAATATATATATATAATTATATAATAATTATTATATATAAAATATATATATATATAATATATATTTATAAAATAATAATAATAAATATTATTACTCCATTAGAGGTTTTGGTCCCATATCAGGAACCGAAACTATAATAATATATAATATTATAATAAAGATATTCTTATTTATAATATATTATTAAATAAATTAATAATAATTATAATATATATATATAATATATTATAATATATTTATTCGAGAACTTTTTATTTATTATAAAATAAAATATTTTATTTATTATTTAGTTTTTTTTTATTAAACATTTTATAAAAATATAAATGTTAATAATATTATGATTAATAAGTAATAATAAATTTATTTATTTTTATTAATTACTTCTTCGAGGTATTAGTATCAGTATCAGTATCAGTATCGTAAAAAACGGGTGACTAAAATATATATATATATAAAATTATAAATAAAAATATTATAATAATTTTAAATAAATAAATATCAATATATTATTATTATTTATATTATAATAAATATTATCTAATAATAGTCCGGCCCGCCCCCGCGGGGCGGACCCCGAAGGAGTCCGAACCCCTTTTTTATTTAATTTTATTTAAAGAAGGAGTGAGGGACCCCTCCCGTTAGGGAGGGGGACCGAACCCCGAAGGAGATAATTAGATATAATTATATTTTATTTTATATAAATTATATAATATTATATAATAATAATTATATAATAAGTTAATAATAATTATATAATAAGTTAATAATAATCATATCTCCTTTATAAATGAACTTTTATTAAATATATTTTATTAAATATTAAATATATTTTTTATAATATTAAATATATTTTATTAAAATATTTAATATATTTTATTAAATATTAAATATATTTTATTAAATATTAAATATAAATAAAGGTTTATATTATAATTCATTATTTATATCTTCTTTATAAATTAATATTCGTATTAGATCCTTATTTAATTTATAATCCTTTAAAAAACTTTTAATAAATATAATATAATATATATATAATTTTTATTATTTTTATATTATTTTTATTATTTAAATATATTATATATTTCATTATAATAATTATTTAAAAAGTTATTTAATAAATAATCTGATATTATATTTTATAATTAATTTTATTTATTTTATTTATTATATATATTATTATATATAATTAAAATTATAATTACAATTATAACTATAATTAAATTAAATTAAATTAAATTGGATTAAATTAAATTAAATTGGGCGCCAAGCCGGTTGTTCACCGACTTGGTCCCAATATAATATGAGATAATATAATATACTATATGATATAACATAAATATAATATATTATATGATATAACATAAATATAATATACTCCTTCGGGGTCCGCCCCCGCGTGGGCGGACCGGACTATATGAATATATTATTATTATAATTATAAAATTATAATAAATAAATAAAATTTCTTTAATAATTATTAATTAATATTATTAATTTATTTACAAATATTTTATTAATTTTTATTTTTATTAAATATAAATATATAAATATATATATATTTATTTATAATATTATTTATATTTATTATATATTATTATTAAATATATTTTTATTATATATCATTAAATATTAATATGTTATTATAGTGGTGGGGGTCCCAATTATTATTTTCAATAATAATTATTATTGGGACCCCGGATATCTTCTTGTTAATCAATTATTATATTATTTAATTTATTTTATTTCTTATTTATAATTTATATTATATAATTTATTATATTGTTAATACTCCTTCGGGGTCCCCGCCGGGGCGGGGACTTTTATTTATATTATTAATTATATTATATTATTATAATATATTTAATTGATTATATTATAAAATTATAACTAATGTATGCTTTGTATTTATTGAATAGTTTGGTTCTTATCACCCACCCCCTCCCCCTATTACTTCTCCGAGGTCCCGGTTTCGTAAGAAACCGGGACTTATATATTTGGTAATTAAAAATATAACTTATATAAATATTTAATAAATATATATTAAATATATTATTATTAATAATTTATTATTATATAAAAAAATAATAAATATTATTAATGATTTAAATTATATAAATATTAATTATTAAATAAATAATTATACTTTCTCCTTTCGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAACTTTAAAATAATATATATATATATAAAAGTATTTTATAATAATTAGTTTAATTATTATTCTTTTTTTTTATTAAATATAAAATCATTTTAGGTTATTAATTTTTATTTATTAAAAATAAATTTTATAATTAATATTTCTCCTTTCTTAAAATAAATAATATTATTATTATAATTATTAATTAATGAATACTCTTCTCTTTTGGGGTTCGGTCCACCCTCCCGTATACTTACGGGAGGGGGGTCCCTCACTCCTTTTGAGACTTTAATTTTATAAATATAAATATAAATATAATAAGATGTTAACTCTTTTATAAATAAATAATAAATATAATTCTATTTTTAATAATAATATATAATATTTTTATAATAAAATATATAAATAATAATATTTATATATATATATATACTTTTTTTTATATAAGAATAATATATATAGTTCACATTGGAGGCGAGTAAAAGGAGATAAGAAATATAATATAATATAATAATAAAAATATAATGAATAATAATAATAAAAATTTATATAATAACAAAATAGTCCGACCGAAGGAGATGAGATTATTAATATTATTAAATAATAAAATGTATTAATTATAAAATATAAAACCTATAAATAATTTATAATATAATTTATATTATGATAATAATAATATATATATTATAATATTTTATATATATATTTATTATATTTATATTTATATAAAAAAGTGATATTGATTAATTAATTAATTTATAATTAATAATTATTAATATAGTCCGGCCCGCCCCCGCGGGGCGGACCCCGAAGGAGTCCGGCCGAAGGAGTTTATTATATTATATTAAATAAGATTTATAATATAATTAATATATATTTTAATAAATATAAAAGATTATATTATATTATAAAAAGTATATTTTATATTTATATTTTATTTATTATTATTATTATATATATAAGTAGTAAAAAGTAGAATAATAGATTTGAAATATTTATTATATAGATTTAAAGAGATAATCATGGAGTATAATAATTAAATTTAATAAATTTAATATAACTATTAATAGAATTAGGTTACTAATAAATTAATAACAATTAATTTTAAAACCTAAAGGTAAACCTTTATATTAATAATGTTATTTTTTATTATTTTTATAATAAGAATAATTATTAATAATAATAAACTAAGTGAACTGAAACATCTAAGTAACTTAAGGATAAGAAATCAACAGAGATATTATGAGTATTGGTGAGAGAAAATAATAAAGGTCTAATAAGTATTATGTGAAAAAAATGTAAGAAAATAGGATAACAAATTCTAAGACTAAATACTATTAATAAGTATAGTAAGTACCGTAAGGGAAAGTATGAAAATGATTATTTTATAAGCAATCATGAATATATTATATTATATTAATGATGTACCTTTTGTATAATGGGTCAGCAAGTAATTAATATTAGTAAAACAATAAGTTATAAATAAATAGAATAATATATATATATAAAAAAATATATTAAAATATTTAATTAATATTAATTGACCCGAAAGCAAACGATCTAACTATGATAAGATGGATAAACGATCGAACAGGTTGATGTTGCAATATCATCTGATTAATTGTGGTTAGTAGTGAAAGACAAATCTGGTTTGCAGATAGCTGGTTTTCTATGAAATATATGTAAGTATAGCCTTTATAAATAATAATTATTATATAATATTATATTAATATTATATAAAGAATGGTACAGCAATTAATATATATTAGGGAACTATTAAAGTTTTATTAATAATATTAAATCTCGAAATATTTAATTATATATAATAAAGAGTCAGATTATGTGCGATAAGGTAAATAATCTAAAGGGAAACAGCCCAGATTAAGATATAAAGTTCCTAATAAATAATAAGTGAAATAAATATTAAAATATTATAATATAATCAGTTAATGGGTTTGACAATAACCATTTTTTAATGAACATGTAACAATGCACTGATTTATAATAAATAAAAAAAAATAATATTTAAAATCAAATATATATATATTTGTTAATAGATAATATACGGATCTTAATAATAAGAATTATTTAATTCCTAATATGGAATATTATATTTTTATAATAAAAATATAAATACTGAATATCTAAATATTATTATTACTTTTTTTTTAATAATAATAATATGGTAATAGAACATTTAATGATAATATATATTAGTTATTAATTAATATATGTATTAATTAAATAGAGAATGCTGACATGAGTAACGAAAAAAAGGTATAAACCTTTTCACCTAAAACATAAGGTTTAACTATAAAAGTACGGCCCCTAATTAAATTAATAAGAATATAAATATATTTAAGATGGGATAATCTATATTAATAAAAATTTATCTTAAAATATATATATTATTAATAATTATATTAATTAATTAATAATATATATAATTATATTATATATTATATATTTTTTATATAATATAAACTAATAAAGATCAGGAAATAATTAATGTATACCGTAATGTAGACCGACTCAGGTATGTAAGTAGAGAATATGAAGGTGAATTAGATAATTAAAGGGAAGGAACTCGGCAAAGATAGCTCATAAGTTAGTCAATAAAGAGTAATAAGAACAAAGTTGTACAACTGTTTACTAAAAACACCGCACTTTGCAGAAACGATAAGTTTAAGTATAAGGTGTGAACTCTGCTCCATGCTTAATATATAAATAAAATTATTTAACGATAATTTAATTAAATTTAGGTAAATAGCAGCCTTATTATGAGGGTTATAATGTAGCGAAATTCCTTGGCCTATAATTGAGGTCCCGCATGAATGACGTAATGATACAACAACTGTCTCCCCTTTAAGCTAAGTGAAATTGAAATCGTAGTGAAGATGCTATGTACCTTCAGCAAGACGGAAAGACCCTATGCAGCTTTACTGTAATTAGATAGATCGAATTATTGTTTATTATATTCAGCATATTAAGTAATCCTATTATTAGGTAATCGTTTAGATATTAATGAGATACTTATTATAATATAATGATAATTCTAATCTTATAAATAATTATTATTATTATTATTAATAATAATAATATGCTTTCAAGCATAGTGATAAAACATATTTATATGATAATCACTTTACTTAATAGATATAATTCTTAAGTAATATATAATATATATTTTATATATATTATATATAATATAAGAGACAATCTCTAATTGGTAGTTTTGATGGGGCGTCATTATCAGCAAAAGTATCTGAATAAGTCCATAAATAAATATATAAAATTATTGAATAAAAAAAAAATAATATATATTATATATATTAATTATAAATTGAAATATGTTTATATAAATTTATATTTATTGAATATATTTTAGTAATAGATAAAAATATGTACAGTAAAATTGTAAGGAAAACAATAATAACTTTCTCCTCTCTCGGTGGGGGTTCACACCTATTTTTAATAGGTGTGAACCCCTCTTCGGGGTTCCGGTTCCCTTTCGGGTCCCGGAACTTAAATAAAAATGGAAAGAATTAAATTAATATAATGGTATAACTGTGCGATAATTGTAACACAAACGAGTGAAACAAGTACGTAAGTATGGCATAATGAACAAATAACACTGATTGTAAAGGTTATTGATAACGAATAAAAGTTACGCTAGGGATAATTTACCCCCTTGTCCCATTATATTGAAAAATATAATTATTCAATTAATTATTTAATTGAAGTAAATTGGGTGAATTGCTTAGATATCCATATAGATAAAAATAATGGACAATAAGCAGCGAAGCTTATAACAACTTTCATATATGTATATATACGGTTATAAGAACGTTCAACGACTAGATGATGAGTGGAGTTAACAATAATTCATCCACGAGCGCCCAATGTCGAATAAATAAAATATTAAATAAATATCAAAGGATATATAAAGATTTTTAATAAATCAAAAAATAAAATAAAATGAAAAATATTAAAAAAAATCAAGTAATAAATTTAGGACCTAATTCTAAATTATTAAAAGAATATAAATCACAATTAATTGAATTAAATATTGAACAATTTGAAGCAGGTATTGGTTTAATTTTAGGAGATGCTTATATTCGTAGTCGTGATGAAGGTAAACTATATTGTATGCAATTTGAGTGAAAAAATAAGGCATACATGGATCATGTATGTTTATTATATGATCAATGAGTATTATCACCTCCTCATAAAAAAGAAAGAGTTAATCATTTAGGTAATTTAGTAATTACCTGAGGAGCTCAAACTTTTAAACATCAAGCTTTTAATAAATTAGCTAACTTATTTATTGTAAATAATAAAAAACTTATTCCTAATAATTTAGTTGAAAATTATTTAACACCTATAAGTTTAGCATATTGATTTATAGATGATGGAGGTAAATGAGATTATAATAAAAATTCTCTTAATAAAAGTATTGTATTAAATACACAAAGTTTTACTTTTGAAGAAGTAGAATATTTAGTTAAAGGTTTAAGAAATAAATTTCAATTAAATTGTTATGTTAAAATTAATAAAAATAAACCAATTATTTATATTGATTCTATAAGTTATTTAATTTTTTATAATTTAATTAAACCTTATTTAATTCCTCAAATGATATATAAATTACCTAATACTATTTCATCCGAAACTTTTTTAAAATAATATTCTTATTTTTATTTTATGATATATTTCATAAATATTTATTTATATTAAATTTTATTTGATAATGATATAGTCTGAACAATATAGTAATATATTGAAGTAATTATTTAAATGTAATTACGATAACAAAAAATTTGAACAGGGTAATATAGCGAAAGAGTAGATATTGTAAGCTATGTTTGCCACCTCGATGTCGACTCAACATTTCCTCTTGGTTGTAAAAGCTAAGAAGGGTTTGACTGTTCGTCAATTAAAATGTTACGTGAGTTGGGTTAAATACGATGTGAATCAGTATGGTTCCTATCTGCTGAAGGAAATATTATCAAATTAAATCTCATTATTAGTACGCAAGGACCATAATGAATCAACCCATGGTGTATCTATTGATAATAATATAATATATTTAATAAAAATAATACTTTATTAATATATTATCTATATTAGTTTATATTTTAATTATATATTATCATAGTAGATAAGCTAAGTTGATAATAAATAAATATTGAATACATATTAAATATGAAGTTGTTTTAATAAGATAATTAATCTGATAATTTTATACTAAAATTAATAATTATAGGTTTTATATATTATTTATAAATAAATATATTATAATAATAATAATTATTATTATTAATAAAAAATATTAATTATAATATTAATAAAATACTAATTTATCAGTTATCTATATAATATCTAATCTATTATTCTATATACTTATTACTCCTTTTTAATTAAATTAAAAAGGGGTTCGGTTCCCCCCCCCCATAAGTATGATTATAATTATAATTATAATATAAGGGAGGGGTCCCTCACTCCTTATGGGGTCCCGGTTGGACCGAGACTCCTCCCTTGCGGGATTGGTTCACACCTTTATAAATAAATAATAAATAATAAATAAAGGTGTTCACTAATAAATATATATATATATATATATATATTATATTATAATATTATTTAATACTTAATATATTATATATTTTATATTTAATAAATAAAAAAAATATTAATAAATAATAATATTAATAATAAAGAAATTATAATTAATACCCTCTATATATAATTCTAATTAATTAAATTAAATATTTATATATAATAATCAATATATTATTAATTTAATAATTATTATAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGTTTATAAAAGATATATTTTTATATTATATTATATTATATTTAATAAATATTACCTTTTTTTATTATTATTTTTATATATTATATAATATTATTAATTTTTATTATAATATTATTTACTTTTTTATTGGATTATTTATTTATTTATTTATTTATTAATTAATTAATTAAATATTTATTAATTAATATATATATTAAATATTAATATTTCATTAAAAAAAAGAGATATATGAATAATATATTATGTTATATTATATTATATAATTATATTATTTTTATAATATTAATAATTAAAAATAAGAACTTATTTAAAAATTATAATTATGATAATAAATTAATACTTTTTAATTTATAAAAATATAAATTTCTTTACATATATATATATATATATTATTATTATTTATATTAATCATAATTTTAATATTTATAATAAATTTATATAAAATCAATTATAATATTATATACTTTTTATATACTTTATAATCTTTATATCTTCACCCCCCCTTTTTTAATAATATATTATATTAAAAATATAATAATTTATATGATTTATTAATACTTTTTATATAATTATATTATTATTTTTTTTTATAGATGTTATATTATTTTTTATAATAATTTTTTTTTATTTAAATAAAATTTATAACTCCTTCTTAATTAAAGATAAAAGGGGTTCCCCCCTTAAGTATAAGTATAAGTATAAGTATAAGTATAAGTATAAGTATAAGTATAAGTATAAGTATAAGTATAGTATACGGGGGGGGGGTCCCTCACTCCTTCGTTAATTTATATATATTATTAATAATTATTTAATTTTTATTATTTATTTATATATAAAAATATTCTAAAATTATTAATATTTATAATAGAATAAATATTATAAAGTATAATTATAAATAATTAATTATTTAAATAATAATAATATATTTATTATTATATAATAAATATATTATAAATAATAGTTATATTAGCTTAATTGGTAGAGCATTCGTTTTGTAATCGAAAGGTTTGGGGTTCAAATCCCTAATATAACAATAATAATAATAAAATATTAAAATAAATATAATATTTATAAAAAATTTATTAATTTATATAAAAAATATATATATAAATAATAATTATAATAAAACATTTTATAATCAATAATTTAATAAATAATCTTCTTATTATAATATTATGTTTAAATATTACTCTTTATGAGGTCCAACAAACTAATAAGATATAAATATATATATATTATATAATAATAATAATAATAATATATTATTTAATATATTATCAAGAAGATAAATATAAATAATATTTTAATAATTTTAAATAAATCTAATTTATATATTAATAATTTAATAATCTTAATATTTATTATCATTATTTCATATTTATATTATATAAATATTTATTTAAATAAAAAATATTAAAGAGTTTATTTTATTTATTATAAATTATTTAATAAAATATATATAATAATATATAGAATAAAGATATAAATAATTATAAGTATATAAAGTAATAAAGGAGATGTTGTTTTAAGGTTAAACTATTAGATTGCAAATCTACTTATTAAGAGTTCGATTCTCTTCATCTCTTAAATAAATAATATAATAATAAAATATTATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGGAAGGAGATAAATATATATATATTTATAATAATTATATAATAAAGGTGAATATATTTCAATGGTAGAAAATACGCTTGTGGTGCGTTAAATCTGAGTTCGATTCTCAGTATTCACCCTATAAATAATAATAATAATATATTTTATTATTCTTAAATTTTTTATTCTTTATATTATATATATAATATTAATATTATTACTTTTTAATAACAAAATATTATAATTAATTGATATATATATATACCAAATATAATTAATTGAAATTAAATAATAAATAAAATATTTACTTCTTTATTAAAATTCTAATTAATTGATTCTTTTTATTGAATATTAAATTCTATTATAACTTATTAATTAATTAATTAATTAATTATAATAATAATAATATTTATTATTAATTATTAAATATTTATTATTATATATAAGATTTAATTTTAAATATTAATAAAAAAAGAATAAAATAAAATAAAATGAATAATATTTCTTTATCTCTTTCGATCGGACTCCTTCGGCCGGACTCCTTCGGGGTCCGCCCCGCGGGGCGGGCCGGACTATTTATTATTATAATATAATATTTAATCAATAGATTTATAATTTATTTAATGAATATTTTATAAATATATAAAACAATTCCTTTTTATTATTATAAATTTTTCATTATTTATTTATTTATTTATTTATTTATTCAATATATAAAAATAATTATAAAAAGATTATTAAAAATAATAATTTAATGATAAATATATATTATATATATTAATATAAAAATAATAAATATAAATATATTATGTAAATATTATATAAATTTGTATATGTATATATTATAATAATGTTATATAAGTAATAATATAATAAAATATTTTATGTAATTTATATATATTTATAATTATAAAATAAAAATATTATAAATAATAAAATTAATAATAATAATAATTTTAATAAAATAAATTATATATTTAATTTTATTATGAAGTTTATACTTAATATAAATTATATTTCCTTTATAAATTATTAATATATCCTTTTTAATTAAATAAAATAAAAATATTATAAATATTAATAATTAATTTTTTATTTATATTTATATATATATTAAAGATTAAATATATTATTAATACTAATTTATAATTTATTATTAATAAATAGTCCGGCCCGCCCCCTGCGGGGCGGACCCCGAAGGAGTTCGACTTAAATTATAATTTAATAATTTTTATTTATTAATAGTTTCGGGGCCCGGCCACGGGAGTCGGAACCCCGAAAGGAGTTTTATTATTAATATAAAAAGAGTAAGGATAATAATAAATTCTTTTAATTTATTTTTAATAAAATATAATTTTAAAATAGTTTTTATAGTCCGGCCCGCCCCGCGGGGGGGGGCGGACCCCGAAGGAGTTCGGTCTGGCATTAATTATAATAATTATATTAATATTATTATTATTTATTATATTATAATATATTTATTTATATTTTATAATATTAATAATTATTTTATATTTAATAAATATAATATATATATTATTTTTTTTAATAACTATCTAATTAATAGCTATTTTGGTGGAATTGGTAGACACGATACTCTTAAGATGTATTACTTTACAGTATGAAGGTTCAAGTCCTTTAAATAGCAATAAATATATATAATATATATAATATATATAAATGAGTCGTAGACTAATAGGTAAGTTACCAAAATTTGAGTTTGGAGTTTGTTTGTTCGAATCAAACCGATTCAATATTATAATATATATATTATTTATATATAAATATATAATTATACTCCTATTTTTATATTAATTAATTAATAATATATGATAATATAAAAATTATTGAATTATTAACTCTTATTAATAATAATAATAATCATAATAATAATATATATATATATAGTATATATATAAAAGTTTTATTATATTATATTATATTATATATTTATTTATATATAATTCTTATTAATTGAAAAAAGAATAATTAATAATCTTATTAAAAAAATAAATACTTTCATTTTATTTTATTTTATTTAATTTAATTATAATATATAAATATTAAAAAAAGGATATAAGTTTTTTATAAGATATAATATATATATATATTAAATATAAAGAAGTTAATATTTATATTTTAATTATAAAATGTTAATACTCCTTTGGGGACTTATTAATTAAATTATTAATTAATAATAATTTATGATTTATAAATAATAAATAAAGGAATAAGTATCAATTAATTAATATATTATATTTAATATTTTATATTTAATATTTAATATTTAATATTTTAAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGTAGTATTAATTATGGATAGTGAGGGTGGATTTAATCCTTTTGTTATGTTATTAATTAATTAATTAATTTATATATATAAAATATTTTAATTAATTTTTATATAAATATATATATATATATATATTAATAATAGTCCGGCCCGCCCCGTGGGGCGGACCCCAAAGGAGTAATATATATTATGTATAAACAATAGAGAATATTGTTTAATGGTAAAACAGTTGTCTTTTAAGCAACCCATGCTTGGTTCAACTCCAGCTATTCTCATAATATTATATATATATATTTCCCTTTCTAAAAATAATAATAATTATATATAATAATAATATAATTATATATATATATATTATAATAATAATAATAATAATAATAATAAATAATAATAATTATTTTTATTAATAATATTAATATATTATAATTATTAATAAATATTAATAAAAATAGCTCTCTTAGCTTAATGGTTAAAGCATAATACTTCTAATATTAATATTCCATGTTCAAATCATGGAGAGAGTAATTATATTATATTAATAATCCCCCCCCCATTTTTAATTAAATTAAGAAGTTTAATTTACTATTTAATAATAAATGAAATAATAATAATAGATATAAGTTAATTGGTAAACTGGATGTCTTCCAAACATTGAATGCGAGTTCGATTCTCGCTATCTATAATTAATATTAATATAAATTAATATCCTATAATTAATTAAATACAAAATTATATTAAAACTTATATTATATTATATTATAATATTATATTATTATTATATAAAAATATAATAATAATAATATTTAATTTTATTTAATAATAATATTTTATATAATAAAATAATCATATTTATAATATTTAATATTAATAATAATTTATTATAATAATTCTTTAATATACTTATTTATTATTATTTTAATAAATAAATATAATTCTTATAAATATATTATAACAAAATATATTATATTTTAATTAAATACAATATTATAAATATATATATATATATAAATATTTATATAAAAAAAAAATAAAAATATTTTAATAATTATTCTTTATAAATAAATAATGATAATAATAATTTATAATAATCTCCTTGTGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAACTATAATATATTTTAATATATTTTTTATTACTCCTCCTTTGGGGTCCGCCCCGCGGGGGCGGGGCGGACTATAATAATTTTTTATTGATAAAAAAGTATATATAATATAATTAATATATTTCTTTTTATATAAATTATAAATATTATTTTATAATAAAAAAAGTATATATAATATTATATATTTAATAAATAATATAATAATAATATAAATAAATATATATATATTATTAATATATTAAATTTTATAATAATAATTATAATAATAGTAGTAGGTATAAATTTTAATAAAGAGTTTTATTCCAATGGAGTAATAATAATAATAATAATAAAATAAAGGATCTGTAGCTTAATAGTAAAGTACCATTTTGTCATAATGGAGGATGTCAGTGCAAATCTGATTAGATTCGTATATTTATACTTAATATAAAAAAAATAAATAATAATCTTTTTTATTATTATATTTATTAATAATAAATTATTTTGTTATTATTATTAATTTATATTAATATTTTATATAAATTATTTATTTAATCTTTCATTATATATTTAATATATTATTAATATTAATTAATATTTTATAATAAATAAATAAAATAAAATAAATATTTTAATATAATACTCCTTCGGGGTTCGGTCCCCCTCCCATTAGTATAGTATAGGGAGGGGTCCCTCACTCCTTCGGGGTCCCCGCCGGGGCGGGGACTTATTTTTATATTTATTAATAATAATTAATTTTTATATAAATTTATTATTTCTTACAATATATTTATTACTATTATTTTTTAATAATCTTATATATAATATATAAAATATATATATATTATATATATATATAAATATAATATATATTATTATAAATATTTATAATCTTATTAATTAATTAGATTATATTATATTATATTAGATCATATTATATTATATTATATTATATTATATTATTATTATTAATATTTTTATTTTTATTTTATATTTAATAGTAAAAAATCATAATTTTATAATTTATTAATTATTATATAATTTCATTAATATATTTCTTCTTTTTATTTATTTATTTATTACTTATTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAAAATAATATAAAAAATAATTATAATTTATTATAATTTATTAATTTATTAATTTATTAATTTATTTATTAATTTATTAATTTATTTATTATTATATTTTTTTTAATAAAGGAAAATTAACTATAGGTAAAGTGGATTATTTGCTAAGTAATTGAATTGTAAATTCTTATGAGTTCGAATCTCATATTTTCCGTATATATCTTTAATTTAATGGTAAAATATTAGAATACGAATCTAATTATATAGGTTCAAATCCTATAAGATATTATATTATATTATATAATATTATATATTAATAAATATTATTAATTAATTTATTTATTTATTTATTATTAAATAAAAATATTTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAATAATATAAAATATTATAATTATTTATATATTAATTATTAATTATTTATTATTTATTATATAAAAAGTATATAATTTTATATTTTAATATAGGGTTAATTAATTAATTATTAATTTTTTATAATAAGATAATAATATATTAAAAACTTATTATAAATTTATAAAATAATATTTATTTACTTTGATATTATTTTTAATCTTTCATTAATATATATTTTATTATAAGTAATAATATAGTTTAATTTAATTAATATAAATAAATTACATAAGAATAATATTATAATAATATTATATATTATATAAAGAAATAATAATTTATATTTTTATTTTTTTTATAAATAATATAAATATAAATATAATGGGGTTATAGTTAAATTTGGTAGAACGACTGCGTTGCATGCATTTAATATGAGTTCAAGTCTCATTAACTCCAATAATTATATTATATAATATATATATTAATAAATTATATATATATATATATATATAAATATTAAATAAATATTATATTAATAAATAATATAAATTATCTAATCGAAGGAGATATTTATAATATAATATAAATATTTTAATAAATTAATAAATATTATATTAATAAATAATTAATAAATATATAAATTATAATAAATTTTAATATTATTATATAAATTAATTAAATATAATAATTAATGAAATAGAAACTATAATTCAATTGGTTAGAATAGTATTTTGATAAGGTACAAATATAGGTTCAATCCCTGTTAGTTTCATATTATATATCATTAATATATAAAATATAAATATATATATTATAATAATAATAATAATAAATATAAATATAATTATATATATATATATATATAAATAAATAATTATTTAATTTATAATAAATATATATAGTTCCCGCGAAGCGGGAACCCCATAAGGAGTTTTATTATTAATTATATTTAATAAATATTAATTATTAATTTTATATTTATAAATAAATTTATTACTCCTTCTTAATTAAGAATAAAAAGGGATGCGGTTCCCATGGGGTCCCGCACTCCTTCGGGGTCCGCCCCCTCCCCTGCGGGAGGGGAGCGGACTATTTTATTAAAAATATTATAATTAAATAATAATATAAATAATTTATAATATAATAATATATACTTATAAATAATATTTAAATCTTATTATTAATTTATAAATCATAAATTATTATTAATAAATATCTCTTTTAGATAAGATAAATTGAACTTATATTTATATTATATATATATAGATATAAATCTTAAATAGAGTAAATATATTATAATAATTATATAAATATATATATATTATATTAAGATAATAATATATATATATATTAATATATAAGGAGGGATTTTCAATGTTGGTAGTTGGAGTTGAGCTGTAAACTCAATGACTTAGGTCTTCATAGGTTCAATTCCTATTCCCTTCATAATTTATTATTAATTATATATTATTATAAATCAAATCCATTGAAATTAATATAATCCAATGAATAATTAATTTAATACATAATTTAATATATAAAATTATATATATATATACTTTATAAAAAAAAAAATTATATAATAATTATATTAATATATTTATATATATAAATAAATAAATAAATAATAATAATTATAATTATAATTATAATTAATTAATTAATAAATAAATAATAATTTATATTATCTTTATAATATATATATATACTTTTATAAAAAAAATATATAAATAATTCTAAAATGTATATTTCTCCTTTCGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAACTATTAATAAAATTAATAATAAAATAATTATTATCTGTATTTAATAAATTTAATTATAGAGTTATATTTCTATATATTTATATATTTATTTATTTATTCTCCTTCCGGAACTAATAAAATATATAAAATAAGGGTTTTTATTTATTTAATTAATATATATTTATTCTTTTATATAATATGTCCTTATAGCTTATCGGTTAAAGCATCTCACTGTTAATGAGAATAGATGGGTTCAATTCCTATTAAGGACGATAATAATATATATATATTTTAATTTATATATCATATATATATATATATTAAAGAAAATAATATAAAAAGTATGTATTAATAATAATAATAAATAAATAATAATAAATAATTTTATTATATTATATTATATTATATTTATTGATATATTTATTGATATTTATTAATTTAAGATTATTCATTAAATATATAATTATTAATAATTTAATATATTTTATAATTTTTATTATATTTTATGTAAGAAGAAACTATTTTATATATTATATATATATATATAATTTTTATAAAATGATAAATTTTATATTATAAATATTATTAAAATATTTTTATAAATATTTAAATTATTTATAAAAAGGTATATAATAATAATTATTAATATTATATTATATTATATATTTATTTATATTATATATAATAATATATTTATATATATATTAATTAATAAATTAAATAAGTATCTATATTTTATATTATATTATATTATTTTATTTTATTAATTCCGGAAGGAGAATAAAAAGTATTCTAAAGAAATTATATATTTATTATTTTTATTAATATGTTATAAATTAATAAAAAATAAATATGTATATATAAATTATATTTATTATGTTTAATTATTTATAATTTATTATAATATATAGTATAAGATATCTTATTTATATTTATATATAATAAAGAATATTATTAAACTAACACCTATATTATATATATTATATTATATAATATTATATATATATTAATTACTAAGAATAAATTTATAATTAGATAATATTTATATTTATTTATTTATTTAATTAACAAATATATTAATATTTTTAATTAATTAATAATACCTTTATATATATATATATATATATATTAATTTTAATTATATAATTATCTTTTTTATTAATAATTATAAATATATTATATATTTTATATAATAAGATTATAATTTTATAATTATTTTATTTTTTATTAAAAATTATTATTATTATAATTATTATATTATAATTATAAATTATTAAAGAATATATTTATTAATATTTTAATAATTAATATCTTTTATTTATATTTATAAAATAAGGTATAAATATTGATAATAAAGAGTAAATATTGTATTAATTATAATAATAATTATAATTAAGGAGCTTGTATAGTTTAATTGGTTAAAACATTTGTCTCATAAATAAATAATGTAAGGTTCAATTCCTTCTACAAGTAATAATGATTATAATATTTATATATATTAAAATAATATTAATAAATAATTACTCCTCCTAGCAGGATTCACATCTCCTTCGGCCGGACTCCTTCGGGGTCCGCCCCGCGGGGGCGGGCCGGACTATTTTATTATTATTAAATAGATGTTCATTAAATAATTATAAATATAATTTATCTTTTAAATATATATATATAATATAATATTTAAATATATATTATAAATAAATAAATAAATAATTAATTAATAAAAACATATAATGTATATTTATCTATAAAAAATATTAATTAAATTAATATATTATTACAGTTCCGGGGGCCGGCCACGGGAGCCGGAACCCCGAAGGAGATAAATAAATAAATAAATATAAATAATTCTTCTTCTTTAAAATTAAATAAAATAAAATAAAAAGGGGGGCGGACTCCTTCGGGGTCCCGCCCCCCTCCGCGGGGCGGACTATTTTATTTTTAAATATATATTATATTAATAATATAAATATAAGTCCCCGCCCCGGCGGGGACCCCGAAGGAGTATAAATAAAAATTAATAATATATTATATATATATTATATTAATAATAATAATAATAATAATAATAATAAATAATAACTCCTTGCTTCATACCTTTATAAATAAGGTAATCACTAATATATTATAATAATAAAAATTATATATATTATATATAATCTAAATATTATATATTTTAATAAATATTAATATATATGATATGAATATTATTAGTTTTTGGGAAGCGGGAATCCCGTAAGGAGTGAGGGACCCCTCCCTAACGGGAGGAGGACCGAAGGAGTTTTAGTATTTTTTTTTTTTTAATAAAATATATATTTATATGATTAATAATATTATATATATTATTTATAAAAATAATATATAATTTTAATTATTTTTAATAAAAAAAGGTGGGGTTGATAATATAATATAATATTTTTTATTTTAATTTATAATATATAATAATAAATTATAAATAAATTTTAATTAAAAGTAGTATTAACATATTATAAATAGACAAAAGAGTCTAAAGGTTAAGATTTATTAAAATGTTAGATTTATTAAGATTACAATTAACAACATTCATTATGAATGATGTACCAACACCTTATGCATGTTATTTTCAGGATTCAGCAACACCAAATCAAGAAGGTATTTTAGAATTACATGATAATATTATGTTTTATTTATTAGTTATTTTAGGTTTAGTATCTTGAATGTTATATACAATTGTTATAACATATTCAAAAAATCCTATTGCATATAAATATATTAAACATGGACAAACTATTGAAGTTATTTGAACAATTTTTCCAGCTGTAATTTTATTAATTATTGCTTTTCCTTCATTTATTTTATTATATTTATGTGATGAAGTTATTTCACCAGCTATAACTATTAAAGCTATTGGATATCAATGATATTGAAAATATGAATATTCAGATTTTATTAATGATAGTGGTGAAACTGTTGAATTTGAATCATATGTTATTCCTGATGAATTATTAGAAGAAGGTCAATTAAGATTATTAGATACTGATACTTCTATAGTTGTACCTGTAGATACACATATTAGATTCGTTGTAACAGCTGCTGATGTTATTCATGATTTTGCTATTCCAAGTTTAGGTATTAAAGTTGATGCTACTCCTGGTAGATTAAATCAAGTTTCTGCTTTAATTCAAAGAGAAGGTGTCTTCTATGGAGCATGTTCTGAGTTGTGTGGGACAGGTCATGCAAATATGCCAATTAAGATCGAAGCAGTATCATTACCTAAATTTTTGGAATGATTAAATGAACAATAATTAATATTTACTTATTATTAATATTTTTAATTATTAAAAATAATAATAATAATAATAATTATAATAATATTCTTAAATATAATAAAGATATAGATTTATATTCTATTCAATCACCTTATATTAAAAATATAAATATTATTAAAAGAGGTTATCATACTTCTTTAAATAATAAATTAATTATTGTTCAAAAAGATAATAAAAATAATAATAAGAATAATTTAGAAATAGATAATTTTTATAAATGATTAGTAGGATTTACAGATGGAGATGGTAGTTTTTATATTAAATTAAATGATAAAAAATATTTAAGATTTTTTTATGGTTTTAGAATACATATTGATGATAAAGCATGTTTAGAAAAGATTAGAAATATATTAAATATACCTTCTAATTTTGAAGAACTACTTAAAACAATTATATTAGTAAATTCACAAAAGAAATGGTTATATTCTAATATTGTAACTATTTTTGATAAGTATCCTTGTTTAACAATTAAATATTATAGTTATTATAAATGAAAAATAGCTATAATTAATAATTTAAATGGTATATCTTATAATAATAAAGATTTATTAAATATTAAAAATACAATTAATAATTATGAAGTTATACCTAATTTAAAAATTCCATATGATAAAATAAATGATTATTGAATTTTAGGTTTTATTGAAGCTGAAGGTTCATTTGATCTATCTCCAAAACGTAATATTTGTGGTTTTAATGTTTCACAACATAAACGTAGTATTAATACATTAAAAGCTATTAAATCTTATGTATTAAATAATTGAAAACCAATTGATAATACACCATTATTAATTAAAAATAAATTATTAAAAGATTGAGATTCATCTATTAAATTAACTAAACCTGATAAAAATGGAGTTATTAAATTAGAATTTAATAGAATAGATTTTTTATATTATGTTATTTTACCTAAATTATATTCATTAAAATGATATAGTCGTAAAGAAATTGATTTCCAATTATGAAAAACACTTATAGAAATCTATATAAAAGGTTTACATAATACACTTAAAGGTTCTAATTTATTAAAATTAATTAATAATAATATTAATAAAAAAAGATATTATTCTAATTATAATATTTCTCCTTTCGGGGTTCCGGCTCCCGTGGCCGGGCCCCGGAACTAAAAATATTATTGATGATGTATTAAATATAAATCTTATCTATAATTATAAATTACCATATCGTATAAATAGTGATATTCAACGTTTAAATTCTATAAATAATAATAATACTAAATTTATTAATGTTGGAGTATTTGTTTATGATTTAAATAATACATTAATTATAACATTTACTGGTTATAGACCAGCAGCTCTTTACTTTAATTGTTCTCCTTTTCGGGGTCCCGACTGGGGCCGGGACTAAACATGAAATTGCTAAATATATTAAAAATGGTAATGTATTTATAAATAAATATATTTTAAAAAATATTTTATTAGATTAATTATTATTTTTACTTCTTCTTAAAATTAAAAAAGGAGACTTTTTTATATTTATATAAATTATATATAAATTATTCTTTTATTATAAATATATAAAATTATTTTCTTTTAATTATTTTTATAATTAATTAATTCTTCATGGCTATAGCCATAACTTTTAATAATATTCTTTTATTCTTTATTATTATATATATATATATTTATTATTTATTATTATAGAATTTATATTTATAAAAATATTAATATTTTATTTAAAATAAATAATGATTAATTTATAAAATATATATTAATTAAGTTTCGGGTCCCGGCTACGGGACCCGGAACCCCCGAGAGGAGTTATTATATTTATAATTAAATCTTTAAATAATATATCTTAAATTATTATATTGATATTAATATTATATTGATATTAATATTAAATATATATTTAATATTTAGCTTATTATTTTATAAAATTATATTTATATATTATAATATAATTAAATATATTATAAATTTAATAATTTAATAAAAATATTCTTTTTATAATTATTATAATAATTAAATAAATAATAATAATAAGAATAATTAATGTATAATTTTTTTATAAATATTATATATTTTTATATTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAAATATTAATAAAATAAAATAAAATTATAATATAATTAAATTATAAGAATTATATTTACTCCTTTTATAATTTATATTTATAATATAATATAATATAAAATAAATATAATATAATATAAAATAAATATAATGTAATAGGTATTCACTCCTCTTTGGGGTTCCGATCCCCCATACGGATACGGATACGGATACGAATACGGATACGGATACGGATACGGGGGGCCGTCCCCCAGAACTTAATATTATATCTTAAATAATTAATATAAATATAATATATTATTTAATAATAATAATAAATAAATAAATAAATAAATAAATAAATTAAATAAATAATAATATTATTATAATTACTTTTTAATAAATAATATTAATATAATATTATATTAGTATTATAAATAGACTTTTTATTATTTTATATATAATATAGTCCGGCCCGCCCCCGCGGGGCGGACCCCGAAGGAGTAATATATTATATAATTATTATTTTTAATTATAAATAAAATATAATTATTATTTATTATATAATTTATATAAATATATATATATATTTATTATATATATAAATATAAATATAAATATAATAATTAATAATATTAAAGTTTTATATATATTAATATATTATAAAAGGTTTATATATATATATAATAAGATAAGTAATAAATTAATTAATTAATAATATAAAAATATATATTATATATTATGTTTTATTTATATATATATATATATTATGTATTATTATATAAATATATATATATATTATATTATAAGTAATAATAAGTATTATATTATATATAGCTTTTATAGCTTAGTGGTAAAGCGATAAATTGAAGATTTATTTACATGTAGTTCGATTCTCATTAAGGGCAATAATAATAATATATTAATTAATAATTAATTTATAATAAATATATTATAATAATTAATATATATATATATAATATATTTAATACAAAGAAAATATATATTATATCTCTTATTTATTTATTTATTAATATTTTAATAAATATAATATTATAAAAAAAAGTTTATATATTTAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGGTAGGAGAAATATAAATATAAATATAAATATAATATAAGTTTGGTATTCATTTAATTATATTATTTAATTAAAAATATTCTAAATAAGAATAAATATCAATAAAGGAGTTATAAATATATATATATATTAATATATATATAAAAATATATATTATTATTAGTTCCCGCTTTGCGGGAACCCCGTAAGGAGTGAGGGACCCCATGGGAACCGAACCCCTATTTAAGAAGGAGTTTTATTATAATAAAATTTATATATATTTAATATATAATTATAAAAATATTATATAATAAATAATAAATAATTATTAATAATAAATAAATATAATAATAATATTATAATAAATTTATAAATGATTATAATAAATTTATATTAATTTTTTATTTTGTAAATACTAAGATTTGAACTTAGATAATATGCACCTAAAAACATACATTTTACCATTAAATTATATTTACCTTATTAATTATATAAAATTTATTAAATATATAATATATTAATTATATAAAAATTATTAAATAAATATATAATATATTATATATAATTTATAATATATATATTATAAATATTATTATATATAAAATATAATATACTACTTATAAAAATATATATATATATATAAATATATATATAAATAAATATTTTATATATTAAATTAAATAATTATTAATAAATTTAATTATAAAGTATAATTTTCAATAGGAATATTTATAAGATTATAATAATTATATGAATTATTATAATTATATATATATAAATAAATAAAATAATAATTATAATAATTAATAAGAGTTTTGGATATATATCTGTGGAGTATATATTTTATAAAGGAGATTAGCTTAATTGGTATAGCATTCGTTTTACACACGAAAGATTATAGGTTCGAACCCTATATTTCCTAAATCTAGATATAATATTATATCTATCTTAATATAATAATATTTATTTATTAAATAAAAAAAAAATAAATAATATTAATTAATATAAGATTCTTTTTTAATTATAATAATAAATAAATAAAAAGAAGATATTATCAATGATTTATATTAATAATAAATATAAATAATAAAAAATATATATAATATAATATAATAAATATATTTCCTTTAATATTAATAAATTAATAATAATAATAATAATAATAATAAAATATTTAAATAAATTATATTCAATACAAATTAATTATTTATATTATTAATAATTGAATAAATAATCCGGTCGAAAGAGATATTAATTCGATTATATTATTTATTTAATTATATTTAATTTAAATATATAAATTAATATATATATATTGAATTATATATAAATTTATTTTATAATTTTATAAATAATATATTATTATAAATATTTAATATAATTTATATTATTATTAAATAAAAGATTTATTAAATTAATATTATTATTTAATTTTATTATATAGTTTAAGGGATAATATTTTATTAATATTTTTTTTATTTATTTATTTAATTATATTATATATATAATATATATATAACAATAAATTTATGACACATTTAGAAAGAAGTAGACATCAACAACATCCATTTCATATGGTTATGCCTTCACCATGACCTATTGTAGTATCATTTGCATTATTATCATTAGCATTATCACTAGCATTAACAATGCATGGTTATATTGGTAATATGAATATGGTATATTTAGCATTATTTGTATTATTAACAAGTTCTATTTTATGATTTAGAGATATTGTAGCTGAAGCTACATATTTAGGTGATCATACTATAGCAGTAAGAAAAGGTATTAATTTAGGTTTCTTAATGTTTGTATTATCTGAAGTATTAATCTTTGCTGGTTTATTCTGAGCTTATTTCCATTCAGCTATGAGTCCTGATGTACTATTAGGTGCATGTTGACCACCCGTAGGTATTGAAGCTGTACAACCTACCGAATTACCTTTATTAAATACTATTATCTTATTATCTTCTGGTGCTACTGTAACTTATAGTCATCATGCCTTAATCGCAGGTAATAGAAATAAAGCCTTATCAGGTTTATTAATTACATTCTGATTAATTGTTATTTTTGTTACTTGTCAATATATTGAATATACTAATGCTGCATTCACTATCTCTGATGGTGTTTATGGTTCAGTATTCTATGCTGGTACAGGATTACATTTCTTACATATGGTAATGTTAGCAGCTATGTTAGGTGTTAATTATTGAAGAATGAGAAATTATCATTTAACAGCTGGACATCATGTTGGATATGAAACAACTATTATTTATCTACATGTTTTAGATGTTATCTGATTATTTTTATACGTAGTCTTCTACTGATGAGGAGTCTAAGGCTATAGAATTATATATCTAAATGATTAATATATATATTATTAATAATTAACAATAATTAATATATTATAATTTATATATATATATTTTATATTATTATAATAATATTCTTACAAATATAATTATTATATATTATTCCTTCAAAACTCCTAACGGGGTTCCCGCGAAGCGGGAACTAATAATAATATAATCATTATACTCTTTTTTCATTTACCTTTTATAAAGATAATTAATAAATTTATTTAATATTTATAAAAAAAAAAATATAATATTAATATAATATAATATAATAATGTAATTATTTATATTTTTATATTCCTTCGAGGTCACCGCCTCACCTCCAGCGGGACTTTTTTAATATGATATAATATAATATAAATATTATTAATTTAACTAATATATAAATTCATATATATATATATATTATTAATATTATTTTATAAAAAATATTTTTTATTTGATTATTATTAAATATTATATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAAATATTAATATATTATAAATATACTATTTATGTAATTATTTTTTGAAGTGAGCACCTATTTTATATATATTTTATATATATTTTATTATATTTTATTAAAAATAGGTGTGAACCTCCATGAGAGAGGAATGAATACCTATTTTATAAAGTATATTTTATATTCTATATATTATAAATATGAACCAAAAAAAGGAGTTTAAAATTTAATTAAATTTAATTAATTGAATTTCTTTATTATTATTATCATAATTATTAAACCCTTTATTAATATAATAATATATTATTTATTATCAAAATACCTACCCTTTTTATAATTTATATCTTTAATAATATAATTAAATATAAAATGTTTATTAAATATTATATAAAAATAAAAATAAAAATATATATATATATATAAATGATAAATAATAAGGAATTCACACTTATATAAATTTAAATATAAAGTCCCAAAAGAAGTATTCATTAAATAAATTATCATTAATTAATTATAATAAACTTATTTAATATTATTAAAGATTAATTTATAATAATAATTATTATTATTATTATTAATATTAATAAAATATATAAATAATTAAATAGTTCATATATTAAAAAGAATTAGAATTAAACTTTAATAAGTGTATTTAATATATAGAATATTAATAGAATATTTATTCTATTTATATATATATTTATATATATATATATTAAATAATATTATTTATATTATATTTTATATATATATTATTAATATAAAAAGTATATTATATGTATTATATATATTATATATTATATATTTAATAATATATTACTCCTTTGGGGTGGGTCCGCCCCACGGGGCGGGCCGGACTATTATAATTAATAATTTTATAAAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAATAAATAATTATATATCTTCTTCTTAATTAAATTAAATTAAATTAAATTAAATTAAATTAAATTAAATTAAAAAGGGGTTCGGTCCCCCTCCCTAACGGGAGGGGGTCCCTCACTCATTCAAACTATAATTTAATATATTATGATATTATTTATAATTTATAATATAATGTATAATATTATATTATAAATATTATATAAAAATAAAATGATATATATAATAATAATAATAATAATAATAAAAAAATAGAAAAGAATAATTTTTATTATTTTAGTATATATAAGAATTTAATAAGTTATATTATTGCGGACACCGTTACGCGGAGTGGGGACTATTATATTTTACCTATATATATTAATATTATTATAATTTCCTTCTTTAAAAGAAAAAAGGAATTCGAGAACTTATTATTATATTAATATATTAATAATAAATAATAATAAATAATAAAAAAGTAAATAATTATAAATTATATAAAAATATAATTTTATTATTAAGAAAGGAGTTTAAATATAAAATATAATATTATCATTAAGTTCTAATAAAGGTATATAATGAAGATCTATTAGAACCTAAAAAGAATATTAATATATCTATTATAAAATAATAATAATAAATATAAATATAAAAATAAATTGTAATATTTATAAATAATAATAAAAAATAAATAAGGAATATATTAATTATTAATAATAAATAAATTATATTAAAATATAATATTATTATTAAATTAAAGAATTATATTAAATATATTTATTAAAATTTTATAAATAAGTTAATATTTTATTAAATAATATTTATAAATAATAAAAAAAAATAAGTATATAATTATTAATATATTAATTTATTATGTTATATATTTATATATTTCAAATATATAAGTAATAGGGGGAGGGGGTGGGTGATAATAACCAGAATATTAAATAAATACAGAGCACACATTTGTTAATATTTAATAATATAATCAATAAATATATTATAATAATATAATATAATTAATAATAGATATAAAGTATAAACAATATAATAAATTATATAAAATAAATATAAATTAAAAATAATAACCAAATAATTAATATAATAAATGATAAACAAGAAGATATCCGGGTCCCAATAATAATTATTATTGAAAATAATAATTGGGACCCCCACAATAGAATAAAAAATAAAAAGAATTAATAATATATAAATAATATAAAATATATTATATATATATATAATATATATATATATATAATAAAAAAAAATATATAATATAATATATATATATAAAATAATAAATTATATATATATATATAAAATAATAAAAAATAATAATCATATGAATTTTATAAATATAATTATTATTAATAATAATAATAATAATAATAAAGTCCGGTCCGCCCCGCGGAGGGGGCGGACCCCCGAAGGAGTGCGGGACCCCGTGGGAACCGCATCCCTTTTTATTCTTAATTAAGAAGGAGATAATAATTTATAAAAATTAATATTTATTTTATGTAATATTAATATTAATATTAATATAATATAATATAATATAATACGGATTAAATATTACCAGTTGTTCACAGGTAATATAAAATCCTATTGTTTCACCTATTATTAATTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGAAAGGAGAATAAGTATATATAATAAAATTTAATAAAAAAAAATAATTATATAATAAATATATATATTATAATATTATATAAATATAAAATATAATTGATATTAACATTATATAATTAATAATATAATCAAATAATATAAATATAATATAAAAAGTTTTAATTATTAAAATTATATAAATATTATTTAATAAAAATAAAAATAATAATAATAATAATAATAATAAAGTCCGGTCCGCCCCCTCCGCGGAGGGGGCGGACCCCGAAAGAGTGAGGGACCCCCCCGTATACTTACGGGGGGAGAACCGAACCCCTTTTTTTATTTAAAGAAGGAGATAAATATTTATATCTTTATTTATAATTATATATAAATAAAAGTTTATTAAAATTTATAATAATAATATAAAAAAGTATATAATAAATTTATTATAAATAAATAAATATTTAGTAATAATATTTAATAAAATTATAAATATTATAAATAAAATATTAATAATAAATAATAAATATATAATATAATATAATATAATAAATTAATAACAATAAGATATCCGGGTCCCCTAAATAATTATTATATAAAATAATAATTGGGACCCATACATATAAATATAAAATATTTTAATATTTATATATAAATAATAATAATATATATTTATATTATATTATAATATAACCCTTTCCAATTAATATTAATATTAATATTAATTACTTCCTTAAAAAAATAATAATTAATTAATTGATTTTTATATTAATATAAAAAAGTTAATATATATATTTATATATAAATAATATAAATTAATATAAAGATAATAAGTCCCCGCTTTCAGCGCAGTGAGGGACCCCCTCCCGTAAATATACGGGAGGGGAGACCGAACCCCAAAGGAATAATAAATAATAGTATGTATTTAAATAAATATTTAATATACTATTTTTTTTTATTATTTTTATAATATATTTATAATAATATATTTAATTATAATTTATAAAAAAGAGATATAATATTTTATTATATATAATATTAATATAATACAAATTAACATTATTTAATTATTATTAATAATATTTAACTTTATTATTATCTTCTACGGTTGGACTCCTTCTTAAAAAGGGGTTCGGTCCCCCTCCCATTAGGGAGGGGTCCCTCACTCCTTCGGGGTCCGCGCCCCCCGCGGGGGGGGGCGGACCGGACTATTATTACTATTTATTTATTAATAATAAATAATAAATTATAAAGTCACTGAAAGAGTGAGGAATTTTCCTTTTCCCAAGGGAAAACCCCAAAGGATAATATAAATATTATAAAATTTTTATTAAATAATATAAAATTCAATAAAATAATTTTAATTAATTAATTAATTAATTAATATAAAAATAAATATTTTTAATTAATATTAATATTAATAGTTCCGGGGCCCGGCCACGGGAGCCGGAACCCCGGAAGGAGAAATATAAATATAATAGTATAGTATATAGGAAGTTAATAATAATATAAATATTATATAATATATATATGTATATATATTATATTATATAATTAATTTTCTCCTTTTGTATTTACATCTTAATAAAATATAAAATATAAAATGTTATTAACAATAAAAATTATTAATCTTTATAATATTAATAATAGTAAATTTATTTATATATCTCCTTTAGGATGGACTCCTTCGGCCGGACTCCTTCGGGGTCCGCCCCGCGGGGGCGGGCCGGACTATTTTTATTTTTTTTTTAAAAAATATTAAATATTATAAATATATTATAAATATATTATAAATATGTTATAAATATATTATAAATAGAATATAATATAATATTATATATTATAATGATAAAGATTATATATATTTTCTTTTTTTTTTTATTTATTATTTTTAATAAGTAAAAATTATATTATATATATATATATATTAGATTTTATAAGTAATATAATATAAGTATTAATATATAAATGCAATATGATGTAATTGGTTAACATTTTAGGGTCATGACCTAATTATATACGTTCAAATCGTATTATTGCTAATAAATTAATATATAATATTTATAAAAAAGTATAATAAAATATATTATAAGAAGAATATATTATATAATAATTATATTAATAATATTAATAAATAATATATAAATAATTATAAAAAAGTATATAATATTAATCAATTAATTAATTAATAAATATAAATAATATATTAATTTTTAATTAATTTGAATAAGATATTTATATTATTAATAGGAAAGTCATAAATATATAAATTATATTATATAATTAATATAATAATAAAATAAATTATATATTTTATTTATAATATTATTTCTTTATAAGATAAAATATTATCTGATGAATAATTAGATTGAATAATATTTATAAAGAAATATATATAAAAAGTCATTATATAAATTTAATTATAATTTAAATAAATTTTATATAAATTAATATAATATTAATAAAGTAATTAGTATAAATAAATAATATGAAAATAAAACTTAATAAATATATAAATATAGTCCGGCCCGCCCCCCCGCGGCGGGCGGACCCCGAAGGAGTGAGGGACCCCTCCCTAATGGGAGGGGGACCGAACCCCTTTTTAAGAAGGAGTCCATATATATATATTAATAAAAAAAAGTAATATATATATATATATTGGAATAGTTATATTATTATACAGAAATATGCTTAATTATAATATAATATCCATA diff --git a/resources/ref/sacCer3-mito/sacCer3.chrM.trnas.adapted.fa b/resources/ref/sacCer3-mito/sacCer3.chrM.trnas.adapted.fa new file mode 100644 index 0000000..b0173f5 --- /dev/null +++ b/resources/ref/sacCer3-mito/sacCer3.chrM.trnas.adapted.fa @@ -0,0 +1,26 @@ +>mt-Sup-TCA +CCTAAGAGCAAGAAGAAGCCTGGNAAGGATATAGTTTAATGGTAAAACAGTTGATTTCAAATCAATCATTAGGAGTTCGAATCTCTTTATCCTTGCCAACCTTGCCTTAAAAAAAAAA +>mt-Ser-TGA +CCTAAGAGCAAGAAGAAGCCTGGNGGATGGTTGACTGAGTGGTTTAAAGTGTGATATTTGAGCTATCATTAGTCTTTATTGGCTACGTAGGTTCAAATCCTACATCATCCGCCAACCTTGCCTTAAAAAAAAAA +>mt-Thr-TGT +CCTAAGAGCAAGAAGAAGCCTGGNGTTATATTAGCTTAATTGGTAGAGCATTCGTTTTGTAATCGAAAGGTTTGGGGTTCAAATCCCTAATATAACACCAACCTTGCCTTAAAAAAAAAA +>mt-His-GTG +CCTAAGAGCAAGAAGAAGCCTGGNGTGAATATATTTCAATGGTAGAAAATACGCTTGTGGTGCGTTAAATCTGAGTTCGATTCTCAGTATTCACCCCAACCTTGCCTTAAAAAAAAAA +>mt-Leu-TAA +CCTAAGAGCAAGAAGAAGCCTGGNGCTATTTTGGTGGAATTGGTAGACACGATACTCTTAAGATGTATTACTTTACAGTATGAAGGTTCAAGTCCTTTAAATAGCACCAACCTTGCCTTAAAAAAAAAA +>mt-Lys-TTT +CCTAAGAGCAAGAAGAAGCCTGGNGAGAATATTGTTTAATGGTAAAACAGTTGTCTTTTAAGCAACCCATGCTTGGTTCAACTCCAGCTATTCTCACCAACCTTGCCTTAAAAAAAAAA +>mt-Arg-TCT +CCTAAGAGCAAGAAGAAGCCTGGNGCTCTCTTAGCTTAATGGTTAAAGCATAATACTTCTAATATTAATATTCCATGTTCAAATCATGGAGAGAGTACCAACCTTGCCTTAAAAAAAAAA +>mt-Ala-TGC +CCTAAGAGCAAGAAGAAGCCTGGNGGGGTTATAGTTAAATTTGGTAGAACGACTGCGTTGCATGCATTTAATATGAGTTCAAGTCTCATTAACTCCACCAACCTTGCCTTAAAAAAAAAA +>mt-Ile-GAT +CCTAAGAGCAAGAAGAAGCCTGGNGAAACTATAATTCAATTGGTTAGAATAGTATTTTGATAAGGTACAAATATAGGTTCAATCCCTGTTAGTTTCACCAACCTTGCCTTAAAAAAAAAA +>mt-Asn-GTT +CCTAAGAGCAAGAAGAAGCCTGGNGTCCTTATAGCTTATCGGTTAAAGCATCTCACTGTTAATGAGAATAGATGGGTTCAATTCCTATTAAGGACGCCAACCTTGCCTTAAAAAAAAAA +>mt-Met-CAT +CCTAAGAGCAAGAAGAAGCCTGGNGCTTGTATAGTTTAATTGGTTAAAACATTTGTCTCATAAATAAATAATGTAAGGTTCAATTCCTTCTACAAGTACCAACCTTGCCTTAAAAAAAAAA +>mt-Phe-GAA +CCTAAGAGCAAGAAGAAGCCTGGNGCTTTTATAGCTTAGTGGTAAAGCGATAAATTGAAGATTTATTTACATGTAGTTCGATTCTCATTAAGGGCACCAACCTTGCCTTAAAAAAAAAA +>mt-Val-TAC +CCTAAGAGCAAGAAGAAGCCTGGNAGGAGATTAGCTTAATTGGTATAGCATTCGTTTTACACACGAAAGATTATAGGTTCGAACCCTATATTTCCTACCAACCTTGCCTTAAAAAAAAAA diff --git a/resources/ref/sacCer3-mito/sacCer3.chrM.trnas.fa b/resources/ref/sacCer3-mito/sacCer3.chrM.trnas.fa new file mode 100644 index 0000000..7a3b6a4 --- /dev/null +++ b/resources/ref/sacCer3-mito/sacCer3.chrM.trnas.fa @@ -0,0 +1,42 @@ +>chrM.trna1 chrM:9374-9444 (+) Sup (TCA) 71 bp Sc: 48.3 +AAGGATATAGTTTAATGGTAAAACAGTTGATTTCAAATCAATCATTAGGAGTTCGAATCT +CTTTATCCTTG +>chrM.trna2 chrM:48201-48287 (+) Ser (TGA) 87 bp Sc: 57.4 +GGATGGTTGACTGAGTGGTTTAAAGTGTGATATTTGAGCTATCATTAGTCTTTATTGGCT +ACGTAGGTTCAAATCCTACATCATCCG +>chrM.trna3 chrM:63862-63934 (+) Thr (TGT) 73 bp Sc: 63.6 +GTTATATTAGCTTAATTGGTAGAGCATTCGTTTTGTAATCGAAAGGTTTGGGGTTCAAAT +CCCTAATATAACA +>chrM.trna4 chrM:64597-64667 (+) His (GTG) 71 bp Sc: 46.1 +GTGAATATATTTCAATGGTAGAAAATACGCTTGTGGTGCGTTAAATCTGAGTTCGATTCT +CAGTATTCACC +>chrM.trna5 chrM:66095-66176 (+) Leu (TAA) 82 bp Sc: 45.0 +GCTATTTTGGTGGAATTGGTAGACACGATACTCTTAAGATGTATTACTTTACAGTATGAA +GGTTCAAGTCCTTTAAATAGCA +>chrM.trna6 chrM:67061-67132 (+) Lys (TTT) 72 bp Sc: 35.1 +GAGAATATTGTTTAATGGTAAAACAGTTGTCTTTTAAGCAACCCATGCTTGGTTCAACTC +CAGCTATTCTCA +>chrM.trna7 chrM:67309-67381 (+) Arg (TCT) 73 bp Sc: 54.7 +GCTCTCTTAGCTTAATGGTTAAAGCATAATACTTCTAATATTAATATTCCATGTTCAAAT +CATGGAGAGAGTA +>chrM.trna8 chrM:69289-69359 (+) Arg (ACG) 71 bp Sc: 38.9 Possible pseudogene +ATATCTTTAATTTAATGGTAAAATATTAGAATACGAATCTAATTATATAGGTTCAAATCC +TATAAGATATT +>chrM.trna9 chrM:69846-69918 (+) Ala (TGC) 73 bp Sc: 39.4 +GGGGTTATAGTTAAATTTGGTAGAACGACTGCGTTGCATGCATTTAATATGAGTTCAAGT +CTCATTAACTCCA +>chrM.trna10 chrM:70162-70234 (+) Ile (GAT) 73 bp Sc: 46.2 +GAAACTATAATTCAATTGGTTAGAATAGTATTTTGATAAGGTACAAATATAGGTTCAATC +CCTGTTAGTTTCA +>chrM.trna11 chrM:71433-71504 (+) Asn (GTT) 72 bp Sc: 52.6 +GTCCTTATAGCTTATCGGTTAAAGCATCTCACTGTTAATGAGAATAGATGGGTTCAATTC +CTATTAAGGACG +>chrM.trna12 chrM:72632-72705 (+) Met (CAT) 74 bp Sc: 50.6 +GCTTGTATAGTTTAATTGGTTAAAACATTTGTCTCATAAATAAATAATGTAAGGTTCAAT +TCCTTCTACAAGTA +>chrM.trna13 chrM:77431-77502 (+) Phe (GAA) 72 bp Sc: 53.8 +GCTTTTATAGCTTAGTGGTAAAGCGATAAATTGAAGATTTATTTACATGTAGTTCGATTC +TCATTAAGGGCA +>chrM.trna14 chrM:78533-78605 (+) Val (TAC) 73 bp Sc: 60.5 +AGGAGATTAGCTTAATTGGTATAGCATTCGTTTTACACACGAAAGATTATAGGTTCGAAC +CCTATATTTCCTA From 0b8e67727496c7c751b57750d110cd8511fd98aa Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sat, 8 Mar 2025 07:16:16 -0700 Subject: [PATCH 02/42] Remove linters for now Too chirpy. Run `snakefmt workflow/rules/*` --- .github/linters/.snakefmt.toml | 7 ------- .github/workflows/lint.yaml | 34 ---------------------------------- 2 files changed, 41 deletions(-) delete mode 100644 .github/linters/.snakefmt.toml delete mode 100644 .github/workflows/lint.yaml diff --git a/.github/linters/.snakefmt.toml b/.github/linters/.snakefmt.toml deleted file mode 100644 index 5915968..0000000 --- a/.github/linters/.snakefmt.toml +++ /dev/null @@ -1,7 +0,0 @@ -[tool.snakefmt] -line_length = 90 -include = '\.smk$|^Snakefile|\.py$' - -# snakefmt passes these options on to black -[tool.black] -skip_string_normalization = true diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml deleted file mode 100644 index 81fc454..0000000 --- a/.github/workflows/lint.yaml +++ /dev/null @@ -1,34 +0,0 @@ -name: Lint with snakefmt - -on: # yamllint disable-line rule:truthy - push: null - pull_request: null - -permissions: {} - -jobs: - build: - name: Lint - runs-on: ubuntu-latest - - permissions: - contents: read - packages: read - # To report GitHub Actions status checks - statuses: write - - steps: - - name: Checkout code - uses: actions/checkout@v4 - with: - # super-linter needs the full git history to get the - # list of files that changed across commits - fetch-depth: 0 - - - name: Super-linter - uses: super-linter/super-linter@v7.2.1 # x-release-please-version - env: - # To report GitHub Actions status checks - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - VALIDATE_ALL_CODEBASE: false - VALIDATE_SNAKEMAKE_SNAKEFMT: true From 7be34851195bb95e1bd972c684eb7c3c18d44641 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sat, 8 Mar 2025 07:17:57 -0700 Subject: [PATCH 03/42] ruff format --- workflow/scripts/extract_signal_metrics.py | 2 -- workflow/scripts/filter_reads.py | 5 ----- workflow/scripts/get_align_stats.py | 1 - workflow/scripts/get_bcerror_freqs.py | 6 +++--- workflow/scripts/get_charging_summary.py | 2 -- workflow/scripts/get_charging_table.py | 3 +-- workflow/scripts/transfer_tags.py | 6 ++---- 7 files changed, 6 insertions(+), 19 deletions(-) diff --git a/workflow/scripts/extract_signal_metrics.py b/workflow/scripts/extract_signal_metrics.py index 4f8669b..b274c57 100644 --- a/workflow/scripts/extract_signal_metrics.py +++ b/workflow/scripts/extract_signal_metrics.py @@ -36,7 +36,6 @@ def get_metric_data( signal_norm_method="norm", scale_iters_opt=0, ): - s_name = sample_name ref_chr = chrom ref_strand = strand @@ -69,7 +68,6 @@ def get_metric_data( def iter_metrics(sample_name, samples_metrics, all_bam_reads, ref_reg): - for metrics, reads in zip(samples_metrics, all_bam_reads): n_reads, n_pos = next(iter(metrics.values())).shape diff --git a/workflow/scripts/filter_reads.py b/workflow/scripts/filter_reads.py index 391a8e7..d4f53e1 100644 --- a/workflow/scripts/filter_reads.py +++ b/workflow/scripts/filter_reads.py @@ -73,7 +73,6 @@ def __str__(self): def count_adapter_edits(aln, ref_start, ref_end): - # use get_aligned_pairs to get the aligned positions # count number of mismatches, deletions and insertions # in the adapter region @@ -97,7 +96,6 @@ def count_adapter_edits(aln, ref_start, ref_end): in_adapter = False for query_pos, ref_pos, seq in aligned_pairs: - if ref_pos is not None and ref_pos >= ref_end: break @@ -122,7 +120,6 @@ def count_adapter_edits(aln, ref_start, ref_end): def compatible_secondary_alignments(aln, trna_ref_dict, isodecoder_ref_dict): - # read doesn't have multiple alignments (at least not in the XA tag) # likely due to a larger number of secondary alignments than -h setting in bwa mem if not aln.has_tag("XA"): @@ -150,7 +147,6 @@ def compatible_secondary_alignments(aln, trna_ref_dict, isodecoder_ref_dict): def filter_bam(args): - five_p_truncation = args.five_p_truncation p3_truncation_max = args.three_p_truncation min_mapq = args.min_mapq @@ -264,7 +260,6 @@ def filter_bam(args): if __name__ == "__main__": - parser = argparse.ArgumentParser( description=""" Filter reads in a BAM file according to the indicated criteria. diff --git a/workflow/scripts/get_align_stats.py b/workflow/scripts/get_align_stats.py index afd80b5..cca26c4 100644 --- a/workflow/scripts/get_align_stats.py +++ b/workflow/scripts/get_align_stats.py @@ -185,7 +185,6 @@ def get_read_stats(fn, flag=None, sample_id=None, sample_info=None): if __name__ == "__main__": - parser = argparse.ArgumentParser( description=""" Collect read and alignment statistics from unmapped, mapped, and further processed BAM files. diff --git a/workflow/scripts/get_bcerror_freqs.py b/workflow/scripts/get_bcerror_freqs.py index d4e2464..3cf0008 100644 --- a/workflow/scripts/get_bcerror_freqs.py +++ b/workflow/scripts/get_bcerror_freqs.py @@ -165,7 +165,7 @@ def calculate_error_frequencies(bam_file, fasta_file): parser = argparse.ArgumentParser( description="Calculate Basecalling Error Frequencies" ) - + parser.add_argument("bam_file", help="Path to the BAM file") parser.add_argument("fasta_file", help="Path to the FASTA file") parser.add_argument("output_tsv", help="Path for the output TSV file") @@ -175,6 +175,6 @@ def calculate_error_frequencies(bam_file, fasta_file): if args.output_tsv.endswith(".gz"): with gzip.open(args.output_tsv, "wt") as file_out: - error_freq_df.write_csv(file_out, separator = "\t") + error_freq_df.write_csv(file_out, separator="\t") else: - error_freq_df.write_csv(args.output_tsv, separator = "\t") \ No newline at end of file + error_freq_df.write_csv(args.output_tsv, separator="\t") diff --git a/workflow/scripts/get_charging_summary.py b/workflow/scripts/get_charging_summary.py index 2a0d980..9000bbe 100644 --- a/workflow/scripts/get_charging_summary.py +++ b/workflow/scripts/get_charging_summary.py @@ -4,7 +4,6 @@ def get_charging_stats(fn): - fo = pysam.AlignmentFile(fn) read_counts = {} for read in fo: @@ -18,7 +17,6 @@ def get_charging_stats(fn): if __name__ == "__main__": - parser = argparse.ArgumentParser( description=""" Generate a table of read counts and percent aminoacylation. diff --git a/workflow/scripts/get_charging_table.py b/workflow/scripts/get_charging_table.py index 632e8aa..bb997f1 100644 --- a/workflow/scripts/get_charging_table.py +++ b/workflow/scripts/get_charging_table.py @@ -11,7 +11,6 @@ def extract_tag(bam_file, output_tsv, tag): - open_func = gzip.open if output_tsv.endswith(".gz") else open mode = "wt" if output_tsv.endswith(".gz") else "w" @@ -28,7 +27,7 @@ def extract_tag(bam_file, output_tsv, tag): tag_array = dict(read.tags).get(tag, None) # XXX: handle case where there are more than 1 tag value - # not clear why this is, but we skip for now as it's a small + # not clear why this is, but we skip for now as it's a small # number of reads affected if len(tag_array) > 1: continue diff --git a/workflow/scripts/transfer_tags.py b/workflow/scripts/transfer_tags.py index 5fbdc42..02a67d5 100644 --- a/workflow/scripts/transfer_tags.py +++ b/workflow/scripts/transfer_tags.py @@ -9,13 +9,11 @@ def transfer_tags(source_bam, target_bam, output_bam): - - with( + with ( pysam.AlignmentFile(source_bam, "rb") as source, pysam.AlignmentFile(target_bam, "rb") as target, - pysam.AlignmentFile(output_bam, "wb", template=target) as output + pysam.AlignmentFile(output_bam, "wb", template=target) as output, ): - # Create a dictionary to store ML and MM tags from the source BAM based on read IDs source_tags = {} for read in source: From e5530838b6a265925710c64fa06ea3488d44f750 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Wed, 12 Mar 2025 21:31:30 -0600 Subject: [PATCH 04/42] Download and install dorado and model (#56) --- .gitignore | 1 + config/config-base.yml | 6 ++- environment.yml | 2 - workflow/Snakefile | 12 +++++- workflow/rules/basecaller.smk | 76 +++++++++++++++++++++++++++++++++++ workflow/rules/common.smk | 8 ++-- 6 files changed, 97 insertions(+), 8 deletions(-) create mode 100644 workflow/rules/basecaller.smk diff --git a/.gitignore b/.gitignore index afead54..925fdba 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,4 @@ logs .temp_dorado_model* .vscode results/ +resources/dorado/* diff --git a/config/config-base.yml b/config/config-base.yml index ccc2014..8028696 100644 --- a/config/config-base.yml +++ b/config/config-base.yml @@ -2,7 +2,7 @@ # this is included in the main Snakefile # either a path to a basecalling model to use with dorado or a model selection name to specify model to download and use -base_calling_model: "resources/models/rna004_130bps_sup@v5.0.0" +base_calling_model: "resources/models/rna004_130bps_sup@v5.1.0" # either FAST5 or POD5, if FAST5 then these files will be converted to pod5 before rebasecalling input_format: "POD5" @@ -18,6 +18,10 @@ remora_kmer_table: "resources/kmers/9mer_levels_v1.txt" # read classification model - remora trained model to classify charged vs uncharged reads remora_cca_classifier: "resources/models/cca_classifier.pt" +# TODO: allow multiple versions +dorado_version: 0.9.1 +dorado_model: rna004_130bps_sup@v5.1.0 + # additional options for particular commands opts: # additional options for dorado basecalling e.g diff --git a/environment.yml b/environment.yml index 6858622..28689c7 100644 --- a/environment.yml +++ b/environment.yml @@ -3,7 +3,6 @@ name: aatrnaseqpipe channels: - conda-forge - bioconda - - hcc dependencies: - pysam @@ -16,7 +15,6 @@ dependencies: - snakefmt - gitpython - pip - - dorado >= 0.7.2 - pip: - pod5 - ont-remora >= 3.2 diff --git a/workflow/Snakefile b/workflow/Snakefile index 90b51b3..c001b66 100644 --- a/workflow/Snakefile +++ b/workflow/Snakefile @@ -4,9 +4,18 @@ from snakemake.utils import min_version min_version("8.0") - configfile: "config/config-base.yml" +# Add a onstart handler to update the PATH environment variable +DORADO_VERSION = config["dorado_version"] +DORADO_DIR = "resources/dorado" + +onstart: + import os + dorado_bin_path = os.path.abspath(f"{DORADO_DIR}/bin") + os.environ["PATH"] = f"{dorado_bin_path}:{os.environ['PATH']}" + shell.prefix(f"export PATH={dorado_bin_path}:$PATH; ") + SNAKEFILE_DIR = os.path.dirname(workflow.snakefile) PIPELINE_DIR = os.path.dirname(SNAKEFILE_DIR) @@ -14,6 +23,7 @@ PIPELINE_DIR = os.path.dirname(SNAKEFILE_DIR) include: "rules/common.smk" include: "rules/aatrnaseq.smk" +include: "rules/basecaller.smk" report_metadata() diff --git a/workflow/rules/basecaller.smk b/workflow/rules/basecaller.smk new file mode 100644 index 0000000..04bd9de --- /dev/null +++ b/workflow/rules/basecaller.smk @@ -0,0 +1,76 @@ +# Determine OS-specific and architecture-specific Dorado URL +import platform + +system = platform.system().lower() +machine = platform.machine().lower() + +# Detect architecture +if machine in ["arm64", "aarch64"]: + arch = "arm64" +elif machine in ["x86_64", "amd64", "x64"]: + arch = "x64" +else: + raise ValueError(f"Unsupported architecture: {machine}") + +# Construct OS-specific suffix and file extension +if system == "linux": + os_suffix = f"linux-{arch}" + file_ext = "tar.gz" +elif system == "darwin": + os_suffix = f"osx-{arch}" + file_ext = "zip" +else: + raise ValueError(f"Unsupported operating system: {system}") + +DORADO_URL = f"https://cdn.oxfordnanoportal.com/software/analysis/dorado-{DORADO_VERSION}-{os_suffix}.{file_ext}" + + +rule setup_dorado: + output: + dorado_bin=f"{DORADO_DIR}/bin/dorado", + params: + dorado_url=DORADO_URL, + dorado_dir=DORADO_DIR, + file_ext=file_ext, + shell: + """ + # Create directory structure if it doesn't exist + mkdir -p {params.dorado_dir} + + # Download Dorado tarball + curl -L -o dorado.{params.file_ext} {params.dorado_url} + + # Extract based on file type + if [ "{params.file_ext}" = "tar.gz" ]; then + tar -xzf dorado.{params.file_ext} -C {params.dorado_dir} --strip-components=1 + elif [ "{params.file_ext}" = "zip" ]; then + unzip -o dorado.{params.file_ext} -d {params.dorado_dir}_temp + # Find the extracted directory and move its contents + mv {params.dorado_dir}_temp/*/* {params.dorado_dir}/ + rm -rf {params.dorado_dir}_temp + fi + + # Remove the tarball + rm dorado.{params.file_ext} + + # Make the binary executable (just to be sure) + chmod +x {output.dorado_bin} + """ + + +rule dorado_model: + """ + download dorado base-calling model + """ + output: + # Create a dummy flag file to track completion + touch(os.path.join("resources/models", f"{config['dorado_model']}.done")), + log: + os.path.join(outdir, "logs", "dorado"), + params: + model=config["dorado_model"], + model_dir=os.path.join("resources/models"), + shell: + """ + dorado download --model {params.model} --models-directory {params.model_dir} > {log} 2>&1 + """ diff --git a/workflow/rules/common.smk b/workflow/rules/common.smk index d9a2f68..d002c8b 100644 --- a/workflow/rules/common.smk +++ b/workflow/rules/common.smk @@ -127,6 +127,10 @@ def pipeline_outputs(): values=["cpm", "counts"], ) + outs += [f"{DORADO_DIR}/bin/dorado"] + + outs += [os.path.join("resources/models", config["dorado_model"])] + if ( "remora_kmer_table" in config and config["remora_kmer_table"] != "" @@ -137,10 +141,6 @@ def pipeline_outputs(): sample=samples.keys(), ) - # if "trna_table" in config and config["trna_table"] != "" and config["trna_table"] is not None: - # outs += expand(os.path.join(outdir, "tables", "{sample}", "{sample}.charging_status.tsv"), - # sample = samples.keys()) - return outs From dafa2c0bf532831ae82b27a4f5b0716ec71f4599 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Wed, 12 Mar 2025 22:24:24 -0600 Subject: [PATCH 05/42] Call modified bases --- config/config-base.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/config-base.yml b/config/config-base.yml index 8028696..7a3905e 100644 --- a/config/config-base.yml +++ b/config/config-base.yml @@ -25,7 +25,7 @@ dorado_model: rna004_130bps_sup@v5.1.0 # additional options for particular commands opts: # additional options for dorado basecalling e.g - dorado: " --emit-moves " + dorado: " --emit-moves --modified-bases pseU m5C inosine_m6A" # additional options for bwa alignment # based on Novoa lab optimising bwa for tRNA alignment From c62e4a9b8935d28fbe9c53e8e47dbc54a7aa3fea Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Wed, 12 Mar 2025 22:55:56 -0600 Subject: [PATCH 06/42] Update model download strategy --- workflow/rules/basecaller.smk | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/workflow/rules/basecaller.smk b/workflow/rules/basecaller.smk index 04bd9de..f562797 100644 --- a/workflow/rules/basecaller.smk +++ b/workflow/rules/basecaller.smk @@ -60,17 +60,33 @@ rule setup_dorado: rule dorado_model: """ - download dorado base-calling model + Download dorado base-calling model """ output: - # Create a dummy flag file to track completion - touch(os.path.join("resources/models", f"{config['dorado_model']}.done")), + directory(os.path.join("resources", "models", config["dorado_model"])), log: - os.path.join(outdir, "logs", "dorado"), + os.path.join(outdir, "logs", "dorado_model.log"), params: model=config["dorado_model"], - model_dir=os.path.join("resources/models"), + model_dir=os.path.join("resources", "models"), shell: """ + mkdir -p {params.model_dir} + + # Run Dorado download dorado download --model {params.model} --models-directory {params.model_dir} > {log} 2>&1 + + # Create a marker file if needed + if [ ! -d "{output}" ]; then + echo "Error: Model directory not created: {output}" >> {log} + exit 1 + fi + + # List the contents of the model directory to help with debugging + echo "Contents of {output}:" >> {log} + ls -la {output} >> {log} 2>&1 + + # Touch a marker file in case the download doesn't create any files + # This ensures the output directory is not empty + touch {output}/.downloaded """ From 8020289c9097205f4a74b85cc85f40b6e6004779 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Thu, 13 Mar 2025 09:41:26 -0600 Subject: [PATCH 07/42] Install modkit (#59) --- .gitignore | 2 +- config/config-base.yml | 4 +- workflow/Snakefile | 15 ++++-- workflow/rules/common.smk | 2 + .../rules/{basecaller.smk => tool_setup.smk} | 47 +++++++++++++++++++ 5 files changed, 64 insertions(+), 6 deletions(-) rename workflow/rules/{basecaller.smk => tool_setup.smk} (63%) diff --git a/.gitignore b/.gitignore index 925fdba..2043ff6 100644 --- a/.gitignore +++ b/.gitignore @@ -6,4 +6,4 @@ logs .temp_dorado_model* .vscode results/ -resources/dorado/* +resources/tools/* diff --git a/config/config-base.yml b/config/config-base.yml index 7a3905e..defe05c 100644 --- a/config/config-base.yml +++ b/config/config-base.yml @@ -18,9 +18,11 @@ remora_kmer_table: "resources/kmers/9mer_levels_v1.txt" # read classification model - remora trained model to classify charged vs uncharged reads remora_cca_classifier: "resources/models/cca_classifier.pt" -# TODO: allow multiple versions +# software tools dorado_version: 0.9.1 dorado_model: rna004_130bps_sup@v5.1.0 +# note "v" +modkit_version: v0.4.3 # additional options for particular commands opts: diff --git a/workflow/Snakefile b/workflow/Snakefile index c001b66..d67f110 100644 --- a/workflow/Snakefile +++ b/workflow/Snakefile @@ -4,17 +4,24 @@ from snakemake.utils import min_version min_version("8.0") + configfile: "config/config-base.yml" + # Add a onstart handler to update the PATH environment variable DORADO_VERSION = config["dorado_version"] -DORADO_DIR = "resources/dorado" +DORADO_DIR = f"resources/tools/dorado/{DORADO_VERSION}" +MODKIT_VERSION = config["modkit_version"] +MODKIT_DIR = f"resources/tools/modkit/{MODKIT_VERSION}" + onstart: import os + dorado_bin_path = os.path.abspath(f"{DORADO_DIR}/bin") - os.environ["PATH"] = f"{dorado_bin_path}:{os.environ['PATH']}" - shell.prefix(f"export PATH={dorado_bin_path}:$PATH; ") + modkit_bin_path = os.path.abspath(f"{MODKIT_DIR}/bin") + os.environ["PATH"] = f"{dorado_bin_path}:{modkit_bin_path}:{os.environ['PATH']}" + shell.prefix(f"export PATH={dorado_bin_path}:{modkit_bin_path}:$PATH; ") SNAKEFILE_DIR = os.path.dirname(workflow.snakefile) @@ -23,7 +30,7 @@ PIPELINE_DIR = os.path.dirname(SNAKEFILE_DIR) include: "rules/common.smk" include: "rules/aatrnaseq.smk" -include: "rules/basecaller.smk" +include: "rules/tool_setup.smk" report_metadata() diff --git a/workflow/rules/common.smk b/workflow/rules/common.smk index d002c8b..8279ff5 100644 --- a/workflow/rules/common.smk +++ b/workflow/rules/common.smk @@ -131,6 +131,8 @@ def pipeline_outputs(): outs += [os.path.join("resources/models", config["dorado_model"])] + outs += [f"{MODKIT_DIR}/bin/modkit"] + if ( "remora_kmer_table" in config and config["remora_kmer_table"] != "" diff --git a/workflow/rules/basecaller.smk b/workflow/rules/tool_setup.smk similarity index 63% rename from workflow/rules/basecaller.smk rename to workflow/rules/tool_setup.smk index f562797..b87714c 100644 --- a/workflow/rules/basecaller.smk +++ b/workflow/rules/tool_setup.smk @@ -90,3 +90,50 @@ rule dorado_model: # This ensures the output directory is not empty touch {output}/.downloaded """ + + +rule setup_modkit: + """ + Install modkit from source using cargo --git + """ + output: + modkit_bin=f"{MODKIT_DIR}/bin/modkit", + params: + modkit_dir=MODKIT_DIR, + modkit_repository="https://github.com/nanoporetech/modkit", + modkit_version=MODKIT_VERSION, + log: + os.path.join(outdir, "logs", "setup_modkit.log"), + threads: 4 + shell: + """ + # Create directory structure if it doesn't exist + mkdir -p {params.modkit_dir} + + # Install Rust if not already installed + if ! command -v rustc &> /dev/null; then + echo "Rust not found, installing..." >> {log} 2>&1 + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y >> {log} 2>&1 + source "$HOME/.cargo/env" + fi + + # Make sure cargo is available in PATH + export PATH="$HOME/.cargo/bin:$PATH" + + # Install modkit using cargo with the specified version + echo "Installing modkit from source (version {params.modkit_version})..." >> {log} 2>&1 + cargo install --git {params.modkit_repository} \ + --tag {params.modkit_version} \ + --root {params.modkit_dir} \ + --jobs {threads} >> {log} 2>&1 + + # Verify installation + if [ -f "{output.modkit_bin}" ]; then + echo "modkit successfully installed at {output.modkit_bin}" >> {log} 2>&1 + # Display version information + {output.modkit_bin} --version >> {log} 2>&1 + else + echo "Error: modkit installation failed!" >> {log} 2>&1 + exit 1 + fi + """ From 642d452a89a5b801ab24d8df07f234219b0447a4 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Thu, 13 Mar 2025 11:50:18 -0600 Subject: [PATCH 08/42] Use cli for cargo install --- workflow/rules/tool_setup.smk | 1 + 1 file changed, 1 insertion(+) diff --git a/workflow/rules/tool_setup.smk b/workflow/rules/tool_setup.smk index b87714c..e202baf 100644 --- a/workflow/rules/tool_setup.smk +++ b/workflow/rules/tool_setup.smk @@ -122,6 +122,7 @@ rule setup_modkit: # Install modkit using cargo with the specified version echo "Installing modkit from source (version {params.modkit_version})..." >> {log} 2>&1 + export CARGO_NET_GIT_FETCH_WITH_CLI=true cargo install --git {params.modkit_repository} \ --tag {params.modkit_version} \ --root {params.modkit_dir} \ From 2bdfcc86242ded56872c6882963346d4f9ee23ad Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Thu, 13 Mar 2025 19:32:30 -0600 Subject: [PATCH 09/42] Install binary modkit on linux x86 --- workflow/rules/tool_setup.smk | 63 ++++++++++++++++++++++++----------- 1 file changed, 43 insertions(+), 20 deletions(-) diff --git a/workflow/rules/tool_setup.smk b/workflow/rules/tool_setup.smk index e202baf..b92db8d 100644 --- a/workflow/rules/tool_setup.smk +++ b/workflow/rules/tool_setup.smk @@ -94,44 +94,67 @@ rule dorado_model: rule setup_modkit: """ - Install modkit from source using cargo --git + Install modkit from pre-built binary or source depending on the system """ output: modkit_bin=f"{MODKIT_DIR}/bin/modkit", params: modkit_dir=MODKIT_DIR, - modkit_repository="https://github.com/nanoporetech/modkit", modkit_version=MODKIT_VERSION, + modkit_repository="https://github.com/nanoporetech/modkit", + linux_binary_url=f"https://github.com/nanoporetech/modkit/releases/download/v{MODKIT_VERSION}/modkit_v{MODKIT_VERSION}_u16_x86_64.tar.gz", log: os.path.join(outdir, "logs", "setup_modkit.log"), - threads: 4 shell: """ # Create directory structure if it doesn't exist - mkdir -p {params.modkit_dir} + mkdir -p {params.modkit_dir}/bin - # Install Rust if not already installed - if ! command -v rustc &> /dev/null; then - echo "Rust not found, installing..." >> {log} 2>&1 - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y >> {log} 2>&1 - source "$HOME/.cargo/env" - fi + # Detect OS and architecture + OS=$(uname -s) + ARCH=$(uname -m) + + if [ "$OS" = "Linux" ] && [ "$ARCH" = "x86_64" ]; then + echo "Installing modkit from pre-built binary for Linux x86_64..." >> {log} 2>&1 - # Make sure cargo is available in PATH - export PATH="$HOME/.cargo/bin:$PATH" + # Download the tarball + echo "Downloading from {params.linux_binary_url}..." >> {log} 2>&1 + curl -L -o modkit.tar.gz {params.linux_binary_url} >> {log} 2>&1 - # Install modkit using cargo with the specified version - echo "Installing modkit from source (version {params.modkit_version})..." >> {log} 2>&1 - export CARGO_NET_GIT_FETCH_WITH_CLI=true - cargo install --git {params.modkit_repository} \ - --tag {params.modkit_version} \ - --root {params.modkit_dir} \ - --jobs {threads} >> {log} 2>&1 + # Extract the binary + tar -xzf modkit.tar.gz >> {log} 2>&1 + + # Move the binary to the destination + mv modkit {output.modkit_bin} >> {log} 2>&1 + + # Clean up + rm modkit.tar.gz >> {log} 2>&1 + else + echo "Pre-built binary not available for $OS $ARCH, building from source..." >> {log} 2>&1 + + # Install Rust if not already installed + if ! command -v rustc &> /dev/null; then + echo "Rust not found, installing..." >> {log} 2>&1 + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y >> {log} 2>&1 + source "$HOME/.cargo/env" + fi + + # Make sure cargo is available in PATH + export PATH="$HOME/.cargo/bin:$PATH" + + # Install modkit using cargo with the specified version + echo "Installing modkit from source (version {params.modkit_version})..." >> {log} 2>&1 + export CARGO_NET_GIT_FETCH_WITH_CLI=true + cargo install --git {params.modkit_repository} \\ + --tag v{params.modkit_version} \\ + --root {params.modkit_dir} \\ + --jobs 4 >> {log} 2>&1 + fi # Verify installation if [ -f "{output.modkit_bin}" ]; then echo "modkit successfully installed at {output.modkit_bin}" >> {log} 2>&1 - # Display version information + chmod +x {output.modkit_bin} {output.modkit_bin} --version >> {log} 2>&1 else echo "Error: modkit installation failed!" >> {log} 2>&1 From 0a1b719f9a783104a7d0dd048cfbc549cf918d46 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sat, 15 Mar 2025 06:50:32 -0600 Subject: [PATCH 10/42] use bare version number --- config/config-base.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/config-base.yml b/config/config-base.yml index defe05c..49d4f52 100644 --- a/config/config-base.yml +++ b/config/config-base.yml @@ -22,7 +22,7 @@ remora_cca_classifier: "resources/models/cca_classifier.pt" dorado_version: 0.9.1 dorado_model: rna004_130bps_sup@v5.1.0 # note "v" -modkit_version: v0.4.3 +modkit_version: 0.4.3 # additional options for particular commands opts: From d287cdfdadaba9bacecdb056daaa3a34ea443773 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sat, 15 Mar 2025 16:39:22 -0600 Subject: [PATCH 11/42] Eliminate support of FAST5 files (#43) Closes #40 * Set file extension * Eliminate input_format option --- .test/make_test_data.sh | 16 ---------------- config/README.md | 3 ++- config/config-base.yml | 3 --- workflow/rules/aatrnaseq.smk | 15 ++------------- workflow/rules/common.smk | 17 +++-------------- 5 files changed, 7 insertions(+), 47 deletions(-) diff --git a/.test/make_test_data.sh b/.test/make_test_data.sh index 630e16b..c68ae41 100644 --- a/.test/make_test_data.sh +++ b/.test/make_test_data.sh @@ -45,22 +45,6 @@ od=sample2/pod5_fail mkdir -p $od pod5 filter $ex/rbc/JMW_510_37C/JMW_510_37C.pod5 --ids ex2_read_ids_3.txt --force-overwrite -o $od/1.pod5 -od=sample1/fast5_pass -mkdir -p $od -pod5 convert to_fast5 -f -o $od sample1/pod5_pass/*.pod5 - -od=sample1/fast5_fail -mkdir -p $od -pod5 convert to_fast5 -f -o $od sample1/pod5_fail/*.pod5 - -od=sample2/fast5_pass -mkdir -p $od -pod5 convert to_fast5 -f -o $od sample2/pod5_pass/*.pod5 - -od=sample2/fast5_fail -mkdir -p $od -pod5 convert to_fast5 -f -o $od sample2/pod5_fail/*.pod5 - # make another "sample2" dataset to test merging multiple runs # don't duplicate sample2 reads to avoid throwing an error when merging # pod5s diff --git a/config/README.md b/config/README.md index 8b897ec..1343153 100644 --- a/config/README.md +++ b/config/README.md @@ -6,7 +6,8 @@ Edit config.yml to specify the following parameters. TSV file should have (1) a unique id for the sample and (2 a path to the sequencing run folder which has `pod5_pass`, `pod5`, `pod5_fail`, `fast5_pass`, or `fast5_fail` subdirectories containing raw data. The pipeline will recursively search for POD5 files to process within the specified directory. -- `output_directory`: A path to an output directory for files produced by pipeline. + - a unique id for the sample + - a path to the sequencing run folder with `pod5_pass` and `pod5_fail` subdirectories containing raw data. - `base_calling_model`: Path to the dorado basecalling model to use for rebasecalling. We use `rna004_130bps_sup@v5.0.0` for now, will evaluate newer model soon. diff --git a/config/config-base.yml b/config/config-base.yml index 49d4f52..4198324 100644 --- a/config/config-base.yml +++ b/config/config-base.yml @@ -4,9 +4,6 @@ # either a path to a basecalling model to use with dorado or a model selection name to specify model to download and use base_calling_model: "resources/models/rna004_130bps_sup@v5.1.0" -# either FAST5 or POD5, if FAST5 then these files will be converted to pod5 before rebasecalling -input_format: "POD5" - # path to fasta file to use for bwa alignment. # a BWA index will be built if it does not exist for this fasta file fasta: "resources/ref/sacCer3-mature-tRNAs-dual-adapt-v2.fa" diff --git a/workflow/rules/aatrnaseq.smk b/workflow/rules/aatrnaseq.smk index d784294..39fb2b7 100644 --- a/workflow/rules/aatrnaseq.smk +++ b/workflow/rules/aatrnaseq.smk @@ -1,7 +1,7 @@ rule merge_pods: """ - merge all fast5/pod5s into a single pod5 + merge pod5s into a single pod5 """ input: get_raw_inputs, @@ -9,15 +9,9 @@ rule merge_pods: os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), log: os.path.join(outdir, "logs", "merge_pods", "{sample}"), - params: - is_fast5=config["input_format"], shell: """ - if [ "{params.is_fast5}" == "FAST5" ]; then - pod5 convert fast5 -f --output {output} {input} - else pod5 merge -f -o {output} {input} - fi """ @@ -34,7 +28,6 @@ rule rebasecall: os.path.join(outdir, "logs", "rebasecall", "{sample}"), params: model=config["base_calling_model"], - is_fast5=config["input_format"], raw_data_dir=get_basecalling_dir, temp_pod5=os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), dorado_opts=config["opts"]["dorado"], @@ -51,11 +44,7 @@ rule rebasecall: def get_optional_bam_inputs(wildcards): sample = wildcards.sample - - if config["input_format"] == "BAM": - return samples[sample]["raw_files"] - else: - return os.path.join(rbc_outdir, sample, sample + ".unmapped.bam") + return os.path.join(rbc_outdir, sample, sample + ".unmapped.bam") rule ubam_to_fq: diff --git a/workflow/rules/common.smk b/workflow/rules/common.smk index 8279ff5..48bbc67 100644 --- a/workflow/rules/common.smk +++ b/workflow/rules/common.smk @@ -58,27 +58,16 @@ def report_metadata(): def find_raw_inputs(sample_dict): """ - parse through directories listed in samples.tsv and identify fast5 or pod5 files to process + parse through directories listed in samples.tsv and identify pod5 files to process store input files and uuid base file names in dictionary for each sample """ POD5_DIRS = ["pod5_pass", "pod5_fail", "pod5"] - FAST5_DIRS = ["fast5_pass", "fast5_fail"] - fmt = config["input_format"] - - data_subdirs = [] - if fmt == "POD5": - data_subdirs = POD5_DIRS - ext = ".pod5" - elif fmt == "FAST5": - data_subdirs = FAST5_DIRS - ext = ".fast5" - else: - sys.exit("input_format config option must be either FAST5, or POD5") + ext = ".pod5" for sample, info in sample_dict.items(): raw_fls = [] for path in info["path"]: - for subdir in data_subdirs: + for subdir in POD5_DIRS: data_path = os.path.join(path, subdir, "*" + ext) fls = glob.glob(data_path) raw_fls += fls From b8823ca5282e230c49783daf065c0c1182462ce7 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sat, 15 Mar 2025 17:48:44 -0600 Subject: [PATCH 12/42] Remove optional bam inputs --- workflow/rules/aatrnaseq.smk | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/workflow/rules/aatrnaseq.smk b/workflow/rules/aatrnaseq.smk index 39fb2b7..c68e34e 100644 --- a/workflow/rules/aatrnaseq.smk +++ b/workflow/rules/aatrnaseq.smk @@ -8,7 +8,7 @@ rule merge_pods: output: os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), log: - os.path.join(outdir, "logs", "merge_pods", "{sample}"), + os.path.join(outdir, "logs", "01_merge_pods", "{sample}"), shell: """ pod5 merge -f -o {output} {input} @@ -25,7 +25,7 @@ rule rebasecall: output: protected(os.path.join(rbc_outdir, "{sample}", "{sample}.unmapped.bam")), log: - os.path.join(outdir, "logs", "rebasecall", "{sample}"), + os.path.join(outdir, "logs", "02_rebasecall", "{sample}"), params: model=config["base_calling_model"], raw_data_dir=get_basecalling_dir, @@ -42,17 +42,12 @@ rule rebasecall: """ -def get_optional_bam_inputs(wildcards): - sample = wildcards.sample - return os.path.join(rbc_outdir, sample, sample + ".unmapped.bam") - - rule ubam_to_fq: """ extract reads from bam into FASTQ format for alignment """ input: - get_optional_bam_inputs, + rules.rebasecall.output, output: os.path.join(outdir, "fastqs", "{sample}.fastq.gz"), log: @@ -240,7 +235,7 @@ rule align_stats: extract alignment stats """ input: - unmapped=get_optional_bam_inputs, + unmapped=rules.rebasecall.output, aligned=rules.bwa_align.output.bam, classified=rules.transfer_bam_tags.output.classified_bam, output: From d45e40a689c9be632770b94cdeec2460c0bb7ec9 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sat, 15 Mar 2025 17:54:15 -0600 Subject: [PATCH 13/42] Increase threads for pod5 merge --- workflow/rules/aatrnaseq.smk | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/workflow/rules/aatrnaseq.smk b/workflow/rules/aatrnaseq.smk index c68e34e..b74a408 100644 --- a/workflow/rules/aatrnaseq.smk +++ b/workflow/rules/aatrnaseq.smk @@ -9,9 +9,10 @@ rule merge_pods: os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), log: os.path.join(outdir, "logs", "01_merge_pods", "{sample}"), + threads: 12 shell: """ - pod5 merge -f -o {output} {input} + pod5 merge -t {threads} -f -o {output} {input} """ From 59c9af68f102e367847cb86b15f3a85e7e1d4af4 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 12:47:35 -0600 Subject: [PATCH 14/42] Add modkit rules And reorganize rule files and summary outputs --- config/config-base.yml | 1 - workflow/Snakefile | 3 +- workflow/rules/aatrnaseq-process.smk | 167 +++++++++++++ workflow/rules/aatrnaseq-summaries.smk | 221 +++++++++++++++++ workflow/rules/aatrnaseq.smk | 328 ------------------------- workflow/rules/common.smk | 39 ++- 6 files changed, 423 insertions(+), 336 deletions(-) create mode 100644 workflow/rules/aatrnaseq-process.smk create mode 100644 workflow/rules/aatrnaseq-summaries.smk delete mode 100644 workflow/rules/aatrnaseq.smk diff --git a/config/config-base.yml b/config/config-base.yml index 4198324..434bf0e 100644 --- a/config/config-base.yml +++ b/config/config-base.yml @@ -18,7 +18,6 @@ remora_cca_classifier: "resources/models/cca_classifier.pt" # software tools dorado_version: 0.9.1 dorado_model: rna004_130bps_sup@v5.1.0 -# note "v" modkit_version: 0.4.3 # additional options for particular commands diff --git a/workflow/Snakefile b/workflow/Snakefile index d67f110..603f562 100644 --- a/workflow/Snakefile +++ b/workflow/Snakefile @@ -29,8 +29,9 @@ PIPELINE_DIR = os.path.dirname(SNAKEFILE_DIR) include: "rules/common.smk" -include: "rules/aatrnaseq.smk" include: "rules/tool_setup.smk" +include: "rules/aatrnaseq-process.smk" +include: "rules/aatrnaseq-summaries.smk" report_metadata() diff --git a/workflow/rules/aatrnaseq-process.smk b/workflow/rules/aatrnaseq-process.smk new file mode 100644 index 0000000..996b853 --- /dev/null +++ b/workflow/rules/aatrnaseq-process.smk @@ -0,0 +1,167 @@ +""" +Rules for processing raw data from aa-tRNA-seq experiments +""" + + +rule merge_pods: + """ + merge pod5s into a single pod5 + """ + input: + get_raw_inputs, + output: + os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), + log: + os.path.join(outdir, "logs", "merge_pods", "{sample}"), + threads: 12 + shell: + """ + pod5 merge -t {threads} -f -o {output} {input} + """ + + +rule rebasecall: + """ + rebasecall using different accuracy model + requires a GPU + """ + input: + rules.merge_pods.output, + output: + protected(os.path.join(rbc_outdir, "{sample}", "{sample}.unmapped.bam")), + log: + os.path.join(outdir, "logs", "rebasecall", "{sample}"), + params: + model=config["base_calling_model"], + raw_data_dir=get_basecalling_dir, + temp_pod5=os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), + dorado_opts=config["opts"]["dorado"], + shell: + """ + if [[ "${{CUDA_VISIBLE_DEVICES:-}}" ]]; then + echo "CUDA_VISIBLE_DEVICES $CUDA_VISIBLE_DEVICES" + export CUDA_VISIBLE_DEVICES + fi + + dorado basecaller {params.dorado_opts} -v {params.model} {input} > {output} + """ + + +rule ubam_to_fastq: + """ + extract reads from bam into FASTQ format for alignment + """ + input: + rules.rebasecall.output, + output: + os.path.join(outdir, "fastqs", "{sample}.fastq.gz"), + log: + os.path.join(outdir, "logs", "ubam_to_fq", "{sample}"), + shell: + """ + samtools fastq -T "*" {input} | gzip > {output} + """ + + +rule bwa_idx: + input: + config["fasta"], + output: + multiext(config["fasta"], ".amb", ".ann", ".bwt", ".pac", ".sa"), + log: + os.path.join(outdir, "logs", "bwa_idx", "log"), + shell: + """ + bwa index {input} + """ + + +rule bwa_align: + """ + align reads to tRNA references with bwa mem + """ + input: + reads=rules.ubam_to_fastq.output, + idx=rules.bwa_idx.output, + output: + bam=os.path.join(outdir, "bams", "{sample}", "{sample}.bwa.unfiltered.bam"), + bai=os.path.join(outdir, "bams", "{sample}", "{sample}.bwa.unfiltered.bam.bai"), + params: + index=config["fasta"], + bwa_opts=config["opts"]["bwa"], + log: + os.path.join(outdir, "logs", "bwa", "{sample}"), + threads: 12 + shell: + """ + bwa mem -C -t {threads} {params.bwa_opts} {params.index} {input.reads} \ + | samtools view -F 4 -h \ + | awk '($1 ~ /^@/ || $4 <= 25)' \ + | samtools view -Sb - \ + | samtools sort -o {output.bam} + + samtools index {output.bam} + """ + + +rule classify_charging: + """ + run remora trained model to classify charged and uncharged reads + """ + input: + pod5=rules.merge_pods.output, + bam=rules.bwa_align.output.bam, + output: + mod_bam=os.path.join(outdir, "mod_bams", "{sample}_mod.bam"), + mod_bam_bai=os.path.join(outdir, "mod_bams", "{sample}_mod.bam.bai"), + txt=os.path.join(outdir, "mod_bams", "{sample}.txt"), + temp_sorted_bam=temp(os.path.join(outdir, "mod_bams", "{sample}_mod.bam.tmp")), + log: + os.path.join(outdir, "logs", "classify_chargin", "{sample}"), + params: + model=config["remora_cca_classifier"], + shell: + """ + if [[ "${{CUDA_VISIBLE_DEVICES:-}}" ]]; then + echo "CUDA_VISIBLE_DEVICES $CUDA_VISIBLE_DEVICES" + export CUDA_VISIBLE_DEVICES + fi + + remora infer from_pod5_and_bam {input.pod5} {input.bam} \ + --model {params.model} \ + --out-bam {output.mod_bam} \ + --log-filename {output.txt} \ + --reference-anchored \ + --device 0 + + # sort the result + samtools sort {output.mod_bam} > {output.temp_sorted_bam} + cp {output.temp_sorted_bam} {output.mod_bam} + + samtools index {output.mod_bam} + """ + + +rule transfer_bam_tags: + """ + creates final bam with classified reads MM and ML tags and table with charging probability per read + """ + input: + source_bam=rules.classify_charging.output.mod_bam, + target_bam=rules.bwa_align.output.bam, + output: + classified_bam=os.path.join(outdir, "classified_bams", "{sample}.bam"), + classified_bam_bai=os.path.join(outdir, "classified_bams", "{sample}.bam.bai"), + log: + os.path.join(outdir, "logs", "transfer_bam_tags", "{sample}"), + params: + src=SCRIPT_DIR, + shell: + """ + python {params.src}/transfer_tags.py \ + -s {input.source_bam} \ + -t {input.target_bam} \ + -o {output.classified_bam} + + samtools index {output.classified_bam} + """ diff --git a/workflow/rules/aatrnaseq-summaries.smk b/workflow/rules/aatrnaseq-summaries.smk new file mode 100644 index 0000000..5e5764a --- /dev/null +++ b/workflow/rules/aatrnaseq-summaries.smk @@ -0,0 +1,221 @@ +rule get_cca_trna: + """ + extract and report charing probability (ML tag) per read + """ + input: + bam=rules.transfer_bam_tags.output.classified_bam, + output: + charging_tab=os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.charging_prob.tsv.gz" + ), + log: + os.path.join(outdir, "logs", "get_cca_trna", "{sample}"), + params: + src=SCRIPT_DIR, + shell: + """ + python {params.src}/get_charging_table.py \ + {input.bam} \ + {output.charging_tab} + """ + + +rule get_cca_trna_cpm: + """ + calculate cpm for cca classified trnas + """ + input: + charging_tab=rules.get_cca_trna.output.charging_tab, + output: + cpm=os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.charging.cpm.tsv.gz" + ), + log: + os.path.join(outdir, "logs", "cca_trna_cpm", "{sample}"), + params: + src=SCRIPT_DIR, + # XXX move `ml_thresh` to config file + ml_thresh=200, + shell: + """ + python {params.src}/get_trna_charging_cpm.py \ + --input {input.charging_tab} \ + --output {output.cpm} \ + --ml-threshold {params.ml_thresh} + """ + + +rule base_calling_error: + """ + extract base calling error metrics to tsv file + """ + input: + bam=rules.transfer_bam_tags.output.classified_bam, + bai=rules.transfer_bam_tags.output.classified_bam_bai, + output: + tsv=os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.bcerror.tsv.gz" + ), + log: + os.path.join(outdir, "logs", "bcerror", "{sample}.bwa"), + params: + src=SCRIPT_DIR, + fa=config["fasta"], + shell: + """ + python {params.src}/get_bcerror_freqs.py \ + {input.bam} \ + {params.fa} \ + {output.tsv} + """ + + +rule align_stats: + """ + extract alignment stats + """ + input: + unmapped=rules.rebasecall.output, + aligned=rules.bwa_align.output.bam, + classified=rules.transfer_bam_tags.output.classified_bam, + output: + tsv=os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.align_stats.tsv.gz" + ), + log: + os.path.join(outdir, "logs", "stats", "{sample}.align_stats"), + params: + src=SCRIPT_DIR, + shell: + """ + python {params.src}/get_align_stats.py \ + -o {output.tsv} \ + -a unmapped aligned classified \ + -i {wildcards.sample} \ + -b {input.unmapped} \ + {input.aligned} \ + {input.classified} + """ + + +rule bam_to_coverage: + input: + bam=rules.transfer_bam_tags.output.classified_bam, + bai=rules.transfer_bam_tags.output.classified_bam_bai, + output: + counts_tmp=temp( + os.path.join(outdir, "summary", "tables", "{sample}", "{sample}.counts.bg") + ), + cpm_tmp=temp( + os.path.join(outdir, "summary", "tables", "{sample}", "{sample}.cpm.bg") + ), + counts=protected( + os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.counts.bg.gz" + ) + ), + cpm=protected( + os.path.join(outdir, "summary", "tables", "{sample}", "{sample}.cpm.bg.gz") + ), + params: + bg_opts=config["opts"]["coverage"], + log: + os.path.join(outdir, "logs", "bg", "{sample}.txt"), + threads: 4 + shell: + """ + bamCoverage \ + -b {input.bam} \ + -o {output.cpm_tmp} \ + --normalizeUsing CPM \ + --outFileFormat bedgraph \ + -bs 1 \ + -p {threads} \ + {params.bg_opts} + + bamCoverage \ + -b {input.bam} \ + -o {output.counts_tmp} \ + --outFileFormat bedgraph \ + -bs 1 \ + -p {threads} \ + {params.bg_opts} + + gzip -c {output.counts_tmp} > {output.counts} + gzip -c {output.cpm_tmp} > {output.cpm} + """ + + +rule remora_signal_stats: + """ + run remora to get signal stats + """ + input: + bam=rules.transfer_bam_tags.output.classified_bam, + bai=rules.transfer_bam_tags.output.classified_bam_bai, + pod5=rules.merge_pods.output, + output: + tsv=os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.remora.tsv.gz" + ), + log: + os.path.join(outdir, "logs", "remora", "{sample}"), + params: + src=SCRIPT_DIR, + kmer=config["remora_kmer_table"], + opts=config["opts"]["remora"], + shell: + """ + python {params.src}/extract_signal_metrics.py \ + --pod5_dir {input.pod5} \ + --bam {input.bam} \ + --kmer {params.kmer} \ + --sample_name {wildcards.sample} \ + {params.opts} \ + | gzip -c \ + > {output.tsv} + """ + + +rule modkit_pileup: + """ + """ + input: + bam=rules.transfer_bam_tags.output.classified_bam, + bai=rules.transfer_bam_tags.output.classified_bam_bai, + output: + bed=os.path.join( + outdir, "summary", "modkit", "{sample}", "{sample}.pileup.bed.gz" + ), + log: + os.path.join(outdir, "logs", "modkit", "pileup", "{sample}"), + shell: + """ + modkit pileup \ + --bgzf \ + --log-filepath {log} + {input.bam} {output.bed} + """ + + +rule modkit_extract_calls: + """ + """ + input: + bam=rules.transfer_bam_tags.output.classified_bam, + bai=rules.transfer_bam_tags.output.classified_bam_bai, + output: + tsv=os.path.join( + outdir, "summary", "modkit", "{sample}", "{sample}.mod_calls.tsv.gz" + ), + log: + os.path.join(outdir, "logs", "modkit", "extract_calls", "{sample}"), + shell: + """ + modkit extract calls \ + --bgzf \ + --log-filepath {log} \ + --edge-filter 20 \ + --mapped --pass \ + {input.bam} {output.tsv} + """ diff --git a/workflow/rules/aatrnaseq.smk b/workflow/rules/aatrnaseq.smk deleted file mode 100644 index b74a408..0000000 --- a/workflow/rules/aatrnaseq.smk +++ /dev/null @@ -1,328 +0,0 @@ - -rule merge_pods: - """ - merge pod5s into a single pod5 - """ - input: - get_raw_inputs, - output: - os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), - log: - os.path.join(outdir, "logs", "01_merge_pods", "{sample}"), - threads: 12 - shell: - """ - pod5 merge -t {threads} -f -o {output} {input} - """ - - -rule rebasecall: - """ - rebasecall using different accuracy model - requires a GPU - """ - input: - rules.merge_pods.output, - output: - protected(os.path.join(rbc_outdir, "{sample}", "{sample}.unmapped.bam")), - log: - os.path.join(outdir, "logs", "02_rebasecall", "{sample}"), - params: - model=config["base_calling_model"], - raw_data_dir=get_basecalling_dir, - temp_pod5=os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), - dorado_opts=config["opts"]["dorado"], - shell: - """ - if [[ "${{CUDA_VISIBLE_DEVICES:-}}" ]]; then - echo "CUDA_VISIBLE_DEVICES $CUDA_VISIBLE_DEVICES" - export CUDA_VISIBLE_DEVICES - fi - - dorado basecaller {params.dorado_opts} -v {params.model} {input} > {output} - """ - - -rule ubam_to_fq: - """ - extract reads from bam into FASTQ format for alignment - """ - input: - rules.rebasecall.output, - output: - os.path.join(outdir, "fastqs", "{sample}.fastq.gz"), - log: - os.path.join(outdir, "logs", "ubam_to_fq", "{sample}"), - shell: - """ - samtools fastq -T "*" {input} | gzip > {output} - """ - - -rule bwa_idx: - input: - config["fasta"], - output: - multiext(config["fasta"], ".amb", ".ann", ".bwt", ".pac", ".sa"), - log: - os.path.join(outdir, "logs", "bwa_idx", "log"), - shell: - """ - bwa index {input} - """ - - -rule bwa_align: - """ - align reads to tRNA references with bwa mem - """ - input: - reads=rules.ubam_to_fq.output, - idx=rules.bwa_idx.output, - output: - bam=os.path.join(outdir, "bams", "{sample}", "{sample}.bwa.unfiltered.bam"), - bai=os.path.join(outdir, "bams", "{sample}", "{sample}.bwa.unfiltered.bam.bai"), - params: - index=config["fasta"], - bwa_opts=config["opts"]["bwa"], - log: - os.path.join(outdir, "logs", "bwa", "{sample}"), - threads: 12 - shell: - """ - bwa mem -C -t {threads} {params.bwa_opts} {params.index} {input.reads} \ - | samtools view -F 4 -h \ - | awk '($1 ~ /^@/ || $4 <= 25)' \ - | samtools view -Sb - \ - | samtools sort -o {output.bam} - - samtools index {output.bam} - """ - - -rule cca_classify: - """ - run remora trained model to classify charged and uncharged reads - """ - input: - pod5=rules.merge_pods.output, - bam=rules.bwa_align.output.bam, - output: - mod_bam=os.path.join(outdir, "mod_bams", "{sample}_mod.bam"), - mod_bam_bai=os.path.join(outdir, "mod_bams", "{sample}_mod.bam.bai"), - txt=os.path.join(outdir, "mod_bams", "{sample}.txt"), - temp_sorted_bam=temp(os.path.join(outdir, "mod_bams", "{sample}_mod.bam.tmp")), - log: - os.path.join(outdir, "logs", "cca_classify", "{sample}"), - params: - model=config["remora_cca_classifier"], - shell: - """ - if [[ "${{CUDA_VISIBLE_DEVICES:-}}" ]]; then - echo "CUDA_VISIBLE_DEVICES $CUDA_VISIBLE_DEVICES" - export CUDA_VISIBLE_DEVICES - fi - - remora infer from_pod5_and_bam {input.pod5} {input.bam} \ - --model {params.model} \ - --out-bam {output.mod_bam} \ - --log-filename {output.txt} \ - --reference-anchored \ - --device 0 - - # sort the result - samtools sort {output.mod_bam} > {output.temp_sorted_bam} - cp {output.temp_sorted_bam} {output.mod_bam} - - samtools index {output.mod_bam} - """ - - -rule transfer_bam_tags: - """ - creates final bam with classified reads MM and ML tags and table with charging probability per read - """ - input: - source_bam=rules.cca_classify.output.mod_bam, - target_bam=rules.bwa_align.output.bam, - output: - classified_bam=os.path.join(outdir, "classified_bams", "{sample}.bam"), - classified_bam_bai=os.path.join(outdir, "classified_bams", "{sample}.bam.bai"), - log: - os.path.join(outdir, "logs", "transfer_bam_tags", "{sample}"), - params: - src=SCRIPT_DIR, - shell: - """ - python {params.src}/transfer_tags.py \ - -s {input.source_bam} \ - -t {input.target_bam} \ - -o {output.classified_bam} - - samtools index {output.classified_bam} - """ - - -rule get_cca_trna: - """ - extract and report charing probability (ML tag) per read - """ - input: - bam=rules.transfer_bam_tags.output.classified_bam, - output: - charging_tab=os.path.join( - outdir, "tables", "{sample}", "{sample}.charging_prob.tsv.gz" - ), - log: - os.path.join(outdir, "logs", "get_cca_trna", "{sample}"), - params: - src=SCRIPT_DIR, - shell: - """ - python {params.src}/get_charging_table.py \ - {input.bam} \ - {output.charging_tab} - """ - - -rule get_cca_trna_cpm: - """ - calculate cpm for cca classified trnas - """ - input: - charging_tab=rules.get_cca_trna.output.charging_tab, - output: - cpm=os.path.join(outdir, "tables", "{sample}", "{sample}.charging.cpm.tsv.gz"), - log: - os.path.join(outdir, "logs", "cca_trna_cpm", "{sample}"), - params: - src=SCRIPT_DIR, - # XXX move `ml_thresh` to config file - ml_thresh=200, - shell: - """ - python {params.src}/get_trna_charging_cpm.py \ - --input {input.charging_tab} \ - --output {output.cpm} \ - --ml-threshold {params.ml_thresh} - """ - - -rule bcerror: - """ - extract base calling error metrics to tsv file - """ - input: - bam=rules.transfer_bam_tags.output.classified_bam, - bai=rules.transfer_bam_tags.output.classified_bam_bai, - output: - tsv=os.path.join(outdir, "tables", "{sample}", "{sample}.bcerror.tsv.gz"), - log: - os.path.join(outdir, "logs", "bcerror", "{sample}.bwa"), - params: - src=SCRIPT_DIR, - fa=config["fasta"], - shell: - """ - python {params.src}/get_bcerror_freqs.py \ - {input.bam} \ - {params.fa} \ - {output.tsv} - """ - - -rule align_stats: - """ - extract alignment stats - """ - input: - unmapped=rules.rebasecall.output, - aligned=rules.bwa_align.output.bam, - classified=rules.transfer_bam_tags.output.classified_bam, - output: - tsv=os.path.join(outdir, "tables", "{sample}", "{sample}.align_stats.tsv.gz"), - log: - os.path.join(outdir, "logs", "stats", "{sample}.align_stats"), - params: - src=SCRIPT_DIR, - shell: - """ - python {params.src}/get_align_stats.py \ - -o {output.tsv} \ - -a unmapped aligned classified \ - -i {wildcards.sample} \ - -b {input.unmapped} \ - {input.aligned} \ - {input.classified} - """ - - -rule bam_to_coverage: - input: - bam=rules.transfer_bam_tags.output.classified_bam, - bai=rules.transfer_bam_tags.output.classified_bam_bai, - output: - counts_tmp=temp( - os.path.join(outdir, "tables", "{sample}", "{sample}.counts.bg") - ), - cpm_tmp=temp(os.path.join(outdir, "tables", "{sample}", "{sample}.cpm.bg")), - counts=protected( - os.path.join(outdir, "tables", "{sample}", "{sample}.counts.bg.gz") - ), - cpm=protected(os.path.join(outdir, "tables", "{sample}", "{sample}.cpm.bg.gz")), - params: - bg_opts=config["opts"]["coverage"], - log: - os.path.join(outdir, "logs", "bg", "{sample}.txt"), - threads: 4 - shell: - """ - bamCoverage \ - -b {input.bam} \ - -o {output.cpm_tmp} \ - --normalizeUsing CPM \ - --outFileFormat bedgraph \ - -bs 1 \ - -p {threads} \ - {params.bg_opts} - - bamCoverage \ - -b {input.bam} \ - -o {output.counts_tmp} \ - --outFileFormat bedgraph \ - -bs 1 \ - -p {threads} \ - {params.bg_opts} - - gzip -c {output.counts_tmp} > {output.counts} - gzip -c {output.cpm_tmp} > {output.cpm} - """ - - -rule remora_signal_stats: - """ - run remora to get signal stats - """ - input: - bam=rules.transfer_bam_tags.output.classified_bam, - bai=rules.transfer_bam_tags.output.classified_bam_bai, - pod5=rules.merge_pods.output, - output: - tsv=os.path.join(outdir, "tables", "{sample}", "{sample}.remora.tsv.gz"), - log: - os.path.join(outdir, "logs", "remora", "{sample}"), - params: - src=SCRIPT_DIR, - kmer=config["remora_kmer_table"], - opts=config["opts"]["remora"], - shell: - """ - python {params.src}/extract_signal_metrics.py \ - --pod5_dir {input.pod5} \ - --bam {input.bam} \ - --kmer {params.kmer} \ - --sample_name {wildcards.sample} \ - {params.opts} \ - | gzip -c \ - > {output.tsv} - """ diff --git a/workflow/rules/common.smk b/workflow/rules/common.smk index 48bbc67..7ba6f6e 100644 --- a/workflow/rules/common.smk +++ b/workflow/rules/common.smk @@ -91,31 +91,58 @@ samples = find_raw_inputs(samples) # Define target files for rule all def pipeline_outputs(): outs = expand( - os.path.join(outdir, "tables", "{sample}", "{sample}.charging_prob.tsv.gz"), + os.path.join(outdir, "summary", "tables", "{sample}", "{sample}.charging_prob.tsv.gz"), sample=samples.keys(), ) outs += expand( - os.path.join(outdir, "tables", "{sample}", "{sample}.charging.cpm.tsv.gz"), + os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.charging.cpm.tsv.gz" + ), sample=samples.keys(), ) outs += expand( - os.path.join(outdir, "tables", "{sample}", "{sample}.bcerror.tsv.gz"), + os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.bcerror.tsv.gz" + ), sample=samples.keys(), ) outs += expand( - os.path.join(outdir, "tables", "{sample}", "{sample}.align_stats.tsv.gz"), + os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.align_stats.tsv.gz" + ), sample=samples.keys(), ) outs += expand( - os.path.join(outdir, "tables", "{sample}", "{sample}.{values}.bg.gz"), + os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.{values}.bg.gz" + ), sample=samples.keys(), values=["cpm", "counts"], ) + # modkit outputs + outs += expand( + os.path.join( + outdir, + "summary", + "modkit", + "{sample}", + "{sample}.pileup.bed.gz", + ), + sample=samples.keys(), + ) + + outs += expand( + os.path.join( + outdir, "summary", "modkit", "{sample}", "{sample}.mod_calls.tsv.gz" + ), + sample=samples.keys(), + ) + outs += [f"{DORADO_DIR}/bin/dorado"] outs += [os.path.join("resources/models", config["dorado_model"])] @@ -128,7 +155,7 @@ def pipeline_outputs(): and config["remora_kmer_table"] is not None ): outs += expand( - os.path.join(outdir, "tables", "{sample}", "{sample}.remora.tsv.gz"), + os.path.join(outdir, "summary", "tables", "{sample}", "{sample}.remora.tsv.gz"), sample=samples.keys(), ) From e2f8399aadc00c5caa5054328ef56f7a917de614 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 12:48:13 -0600 Subject: [PATCH 15/42] Simplify modkit install Always build from source. The linux dist doesn't run on bodhi because glibc is out of date. --- workflow/rules/tool_setup.smk | 63 +++++++---------------------------- 1 file changed, 12 insertions(+), 51 deletions(-) diff --git a/workflow/rules/tool_setup.smk b/workflow/rules/tool_setup.smk index b92db8d..f4e7a4e 100644 --- a/workflow/rules/tool_setup.smk +++ b/workflow/rules/tool_setup.smk @@ -107,57 +107,18 @@ rule setup_modkit: os.path.join(outdir, "logs", "setup_modkit.log"), shell: """ - # Create directory structure if it doesn't exist - mkdir -p {params.modkit_dir}/bin - - # Detect OS and architecture - OS=$(uname -s) - ARCH=$(uname -m) - - if [ "$OS" = "Linux" ] && [ "$ARCH" = "x86_64" ]; then - echo "Installing modkit from pre-built binary for Linux x86_64..." >> {log} 2>&1 - - # Download the tarball - echo "Downloading from {params.linux_binary_url}..." >> {log} 2>&1 - curl -L -o modkit.tar.gz {params.linux_binary_url} >> {log} 2>&1 - - # Extract the binary - tar -xzf modkit.tar.gz >> {log} 2>&1 - - # Move the binary to the destination - mv modkit {output.modkit_bin} >> {log} 2>&1 - - # Clean up - rm modkit.tar.gz >> {log} 2>&1 - else - echo "Pre-built binary not available for $OS $ARCH, building from source..." >> {log} 2>&1 - - # Install Rust if not already installed - if ! command -v rustc &> /dev/null; then - echo "Rust not found, installing..." >> {log} 2>&1 - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y >> {log} 2>&1 - source "$HOME/.cargo/env" - fi - - # Make sure cargo is available in PATH - export PATH="$HOME/.cargo/bin:$PATH" - - # Install modkit using cargo with the specified version - echo "Installing modkit from source (version {params.modkit_version})..." >> {log} 2>&1 - export CARGO_NET_GIT_FETCH_WITH_CLI=true - cargo install --git {params.modkit_repository} \\ - --tag v{params.modkit_version} \\ - --root {params.modkit_dir} \\ - --jobs 4 >> {log} 2>&1 + if ! command -v rustc &> /dev/null; then + echo "Rust not found, installing..." >> {log} 2>&1 + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y >> {log} 2>&1 + source "$HOME/.cargo/env" fi - # Verify installation - if [ -f "{output.modkit_bin}" ]; then - echo "modkit successfully installed at {output.modkit_bin}" >> {log} 2>&1 - chmod +x {output.modkit_bin} - {output.modkit_bin} --version >> {log} 2>&1 - else - echo "Error: modkit installation failed!" >> {log} 2>&1 - exit 1 - fi + export PATH="$HOME/.cargo/bin:$PATH" + + export CARGO_NET_GIT_FETCH_WITH_CLI=true + cargo install --git {params.modkit_repository} \\ + --tag v{params.modkit_version} \\ + --root {params.modkit_dir} \\ + --jobs 4 >> {log} 2>&1 + """ From 33154b4376ee46f9a349b784eb8f6717f4ec2767 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 13:53:41 -0600 Subject: [PATCH 16/42] add bedtools --- environment.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/environment.yml b/environment.yml index 28689c7..9979f81 100644 --- a/environment.yml +++ b/environment.yml @@ -11,6 +11,7 @@ dependencies: - samtools - bwa - deeptools + - bedtools - snakemake - snakefmt - gitpython From 4e848b6eb5bd1f93b652fca49133a15093deeba1 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 16:56:35 -0600 Subject: [PATCH 17/42] update rule --- cluster/config.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cluster/config.yaml b/cluster/config.yaml index 31c2a69..3a8696d 100644 --- a/cluster/config.yaml +++ b/cluster/config.yaml @@ -28,10 +28,10 @@ set-resources: - rebasecall:gpu_opts="-gpu num=1:j_exclusive=yes" - rebasecall:ngpu=1 - rebasecall:mem_mb=24 - - cca_classify:queue="gpu" - - cca_classify:gpu_opts="-gpu num=1:j_exclusive=yes" - - cca_classify:ngpu=1 - - cca_classify:mem_mb=24 + - classify_charging:queue="gpu" + - classify_charging:gpu_opts="-gpu num=1:j_exclusive=yes" + - classify_charging:ngpu=1 + - classify_charging:mem_mb=24 - remora_signal_stats:mem_mb=24 - bwa_align:mem_mb=24 From e4f006c1cdf93c32138341aeabc2ba8f6e518623 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 16:56:58 -0600 Subject: [PATCH 18/42] modkit testing --- run-test.sh | 8 ++++---- workflow/rules/aatrnaseq-summaries.smk | 9 ++++++--- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/run-test.sh b/run-test.sh index 862b54b..ff6f507 100644 --- a/run-test.sh +++ b/run-test.sh @@ -1,11 +1,11 @@ #! /usr/bin/env bash #BSUB -n 1 -#BSUB -J aatrnaseq-main -#BSUB -e results/logs/aatrnaseq-main_%J.err -#BSUB -o results/logs/aatrnaseq-main_%J.out +#BSUB -J aatrnaseq-main-test +#BSUB -e .test/logs/aatrnaseq-main-test_%J.err +#BSUB -o .test/logs/aatrnaseq-main-test_%J.out -mkdir -p results/logs +mkdir -p .test/logs snakemake \ --configfile=config/config-test.yml \ diff --git a/workflow/rules/aatrnaseq-summaries.smk b/workflow/rules/aatrnaseq-summaries.smk index 5e5764a..d4edb0e 100644 --- a/workflow/rules/aatrnaseq-summaries.smk +++ b/workflow/rules/aatrnaseq-summaries.smk @@ -189,12 +189,15 @@ rule modkit_pileup: ), log: os.path.join(outdir, "logs", "modkit", "pileup", "{sample}"), + params: + fa=config["fasta"] shell: """ modkit pileup \ - --bgzf \ - --log-filepath {log} - {input.bam} {output.bed} + --log-filepath {log} \ + --ref {params.fa} \ + {input.bam} - \ + | gzip -9 -c > {output.bed} """ From fb135b68249cb5a218dc74612a11b35a859c0788 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 18:28:48 -0600 Subject: [PATCH 19/42] Reorganize output directory --- workflow/rules/aatrnaseq-process.smk | 37 ++++++++++++++-------------- workflow/rules/common.smk | 1 - 2 files changed, 18 insertions(+), 20 deletions(-) diff --git a/workflow/rules/aatrnaseq-process.smk b/workflow/rules/aatrnaseq-process.smk index 996b853..23841df 100644 --- a/workflow/rules/aatrnaseq-process.smk +++ b/workflow/rules/aatrnaseq-process.smk @@ -10,7 +10,7 @@ rule merge_pods: input: get_raw_inputs, output: - os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), + os.path.join(outdir, "pod5", "{sample}", "{sample}.pod5"), log: os.path.join(outdir, "logs", "merge_pods", "{sample}"), threads: 12 @@ -28,13 +28,13 @@ rule rebasecall: input: rules.merge_pods.output, output: - protected(os.path.join(rbc_outdir, "{sample}", "{sample}.unmapped.bam")), + protected(os.path.join(outdir, "bam", "rebasecall", "{sample}", "{sample}.rbc.bam")), log: os.path.join(outdir, "logs", "rebasecall", "{sample}"), params: model=config["base_calling_model"], raw_data_dir=get_basecalling_dir, - temp_pod5=os.path.join(rbc_outdir, "{sample}", "{sample}.pod5"), + temp_pod5=os.path.join(outdir, "{sample}", "{sample}.pod5"), dorado_opts=config["opts"]["dorado"], shell: """ @@ -54,7 +54,7 @@ rule ubam_to_fastq: input: rules.rebasecall.output, output: - os.path.join(outdir, "fastqs", "{sample}.fastq.gz"), + os.path.join(outdir, "fq", "{sample}.fq.gz"), log: os.path.join(outdir, "logs", "ubam_to_fq", "{sample}"), shell: @@ -84,8 +84,8 @@ rule bwa_align: reads=rules.ubam_to_fastq.output, idx=rules.bwa_idx.output, output: - bam=os.path.join(outdir, "bams", "{sample}", "{sample}.bwa.unfiltered.bam"), - bai=os.path.join(outdir, "bams", "{sample}", "{sample}.bwa.unfiltered.bam.bai"), + bam=os.path.join(outdir, "bam", "aln", "{sample}", "{sample}.aln.bam"), + bai=os.path.join(outdir, "bam", "aln", "{sample}", "{sample}.aln.bam.bai"), params: index=config["fasta"], bwa_opts=config["opts"]["bwa"], @@ -112,12 +112,11 @@ rule classify_charging: pod5=rules.merge_pods.output, bam=rules.bwa_align.output.bam, output: - mod_bam=os.path.join(outdir, "mod_bams", "{sample}_mod.bam"), - mod_bam_bai=os.path.join(outdir, "mod_bams", "{sample}_mod.bam.bai"), - txt=os.path.join(outdir, "mod_bams", "{sample}.txt"), - temp_sorted_bam=temp(os.path.join(outdir, "mod_bams", "{sample}_mod.bam.tmp")), + charging_bam=os.path.join(outdir, "bam", "charging", "{sample}.charging.bam"), + charging_bam_bai=os.path.join(outdir, "bam", "charging", "{sample}.charging.bam.bai"), + temp_sorted_bam=temp(os.path.join(outdir, "bam", "charging", "{sample}.charging.bam.tmp")), log: - os.path.join(outdir, "logs", "classify_chargin", "{sample}"), + os.path.join(outdir, "logs", "classify_charging", "{sample}"), params: model=config["remora_cca_classifier"], shell: @@ -129,16 +128,16 @@ rule classify_charging: remora infer from_pod5_and_bam {input.pod5} {input.bam} \ --model {params.model} \ - --out-bam {output.mod_bam} \ - --log-filename {output.txt} \ + --out-bam {output.charging_bam} \ + --log-filename {log} \ --reference-anchored \ --device 0 # sort the result - samtools sort {output.mod_bam} > {output.temp_sorted_bam} - cp {output.temp_sorted_bam} {output.mod_bam} + samtools sort {output.charging_bam} > {output.temp_sorted_bam} + cp {output.temp_sorted_bam} {output.charging_bam} - samtools index {output.mod_bam} + samtools index {output.charging_bam} """ @@ -147,11 +146,11 @@ rule transfer_bam_tags: creates final bam with classified reads MM and ML tags and table with charging probability per read """ input: - source_bam=rules.classify_charging.output.mod_bam, + source_bam=rules.classify_charging.output.charging_bam, target_bam=rules.bwa_align.output.bam, output: - classified_bam=os.path.join(outdir, "classified_bams", "{sample}.bam"), - classified_bam_bai=os.path.join(outdir, "classified_bams", "{sample}.bam.bai"), + classified_bam=os.path.join(outdir, "bam", "final", "{sample}.bam"), + classified_bam_bai=os.path.join(outdir, "bam", "final", "{sample}.bam.bai"), log: os.path.join(outdir, "logs", "transfer_bam_tags", "{sample}"), params: diff --git a/workflow/rules/common.smk b/workflow/rules/common.smk index 7ba6f6e..01549a5 100644 --- a/workflow/rules/common.smk +++ b/workflow/rules/common.smk @@ -82,7 +82,6 @@ def find_raw_inputs(sample_dict): # set up global samples dictionary to be used throughout pipeline outdir = config["output_directory"] -rbc_outdir = os.path.join(outdir, "rbc_bams") samples = parse_samples(config["samples"]) samples = find_raw_inputs(samples) From bc2a5d856ced72d5e182fa1b8372dab366f62948 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 18:35:06 -0600 Subject: [PATCH 20/42] Rename charging tags during transfer --- workflow/rules/aatrnaseq-process.smk | 8 +-- workflow/scripts/transfer_tags.py | 76 ++++++++++++++++++---------- 2 files changed, 54 insertions(+), 30 deletions(-) diff --git a/workflow/rules/aatrnaseq-process.smk b/workflow/rules/aatrnaseq-process.smk index 23841df..43dd362 100644 --- a/workflow/rules/aatrnaseq-process.smk +++ b/workflow/rules/aatrnaseq-process.smk @@ -158,9 +158,11 @@ rule transfer_bam_tags: shell: """ python {params.src}/transfer_tags.py \ - -s {input.source_bam} \ - -t {input.target_bam} \ - -o {output.classified_bam} + --tags ML MM \ + --rename ML=CL MM=CM \ + --source {input.source_bam} \ + --target {input.target_bam} \ + --output {output.classified_bam} samtools index {output.classified_bam} """ diff --git a/workflow/scripts/transfer_tags.py b/workflow/scripts/transfer_tags.py index 02a67d5..fcd589c 100644 --- a/workflow/scripts/transfer_tags.py +++ b/workflow/scripts/transfer_tags.py @@ -1,28 +1,33 @@ #! /usr/bin/env python """ -Transfer ML/MM tags from one BAM file to another based on read IDs. -Output only primary alignments with transferred tags." +Transfer tags from one BAM file to another based on read IDs. + +Output only primary alignments with transferred tags. + +Use `--rename` to rename tags during transfer. """ -import pysam +from collections import defaultdict +from pysam import AlignmentFile + +def transfer_tags(tags, rename, source_bam, target_bam, output_bam): + renamed_tags = parse_tag_items(rename) -def transfer_tags(source_bam, target_bam, output_bam): with ( - pysam.AlignmentFile(source_bam, "rb") as source, - pysam.AlignmentFile(target_bam, "rb") as target, - pysam.AlignmentFile(output_bam, "wb", template=target) as output, + AlignmentFile(source_bam, "rb") as source, + AlignmentFile(target_bam, "rb") as target, + AlignmentFile(output_bam, "wb", template=target) as output, ): - # Create a dictionary to store ML and MM tags from the source BAM based on read IDs - source_tags = {} + # Store tags from the source BAM based on read ID + source_tags = defaultdict(dict) + for read in source: if not read.is_unmapped: - # Extract ML and MM tags - ml_tag = read.get_tag("ML") if read.has_tag("ML") else None - mm_tag = read.get_tag("MM") if read.has_tag("MM") else None - if ml_tag or mm_tag: - source_tags[read.query_name] = (ml_tag, mm_tag) + for tag in tags: + if read.has_tag(tag): + source_tags[read.query_name][tag] = read.get_tag(tag) # Transfer tags and write only primary alignments with transferred tags for read in target: @@ -31,33 +36,50 @@ def transfer_tags(source_bam, target_bam, output_bam): continue if read.query_name in source_tags: - ml_tag, mm_tag = source_tags[read.query_name] - # Add ML and MM tags to the target read if they exist - if mm_tag is not None: - read.set_tag("MM", mm_tag) - if ml_tag is not None: - read.set_tag("ML", ml_tag) - # Write the read to the output BAM only if tags were transferred + for tag, tag_val in source_tags[read.query_name].items(): + if tag in renamed_tags: + read.set_tag(renamed_tags[tag], tag_val) + else: + read.set_tag(tag, tag_val) + + # Write read only if tags were transferred output.write(read) +def parse_tag_items(rename): + ret = {} + for item in rename: + key, val = map(str.strip, item.split("=")) + ret[key] = val + return ret + + if __name__ == "__main__": import argparse parser = argparse.ArgumentParser( - description="Transfer ML/MM tags from one BAM file to another based on read IDs, and output only primary alignments with transferred tags." + description="Transfer tags from one BAM file to another based on read IDs, and output only primary alignments with transferred tags." + ) + parser.add_argument( + "-t", "--tags", metavar="MM", nargs="+", required=True, help="Tags to transfer" ) + parser.add_argument( - "-s", "--source", required=True, help="Source BAM file (with ML/MM tags)" + "--rename", + nargs="+", + metavar="OLD=NEW", + help="tags to rename during transfer", ) + + parser.add_argument("--source", required=True, help="Source BAM file (with tags)") + parser.add_argument( - "-t", "--target", required=True, help="Target BAM file (without ML/MM tags)" + "--target", required=True, help="Target BAM file (without tags)" ) parser.add_argument( - "-o", "--output", required=True, help="Output BAM file with transferred tags" + "--output", required=True, help="Output BAM file with transferred tags" ) args = parser.parse_args() - # Call the function to transfer tags - transfer_tags(args.source, args.target, args.output) + transfer_tags(args.tags, args.rename, args.source, args.target, args.output) From 2664321c9ea8d89a7d123d5eb612c3884395602b Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 19:11:37 -0600 Subject: [PATCH 21/42] Update tag for charging table And snakefmt --- workflow/rules/aatrnaseq-process.smk | 19 ++++++++++++++----- workflow/rules/aatrnaseq-summaries.smk | 3 ++- workflow/rules/common.smk | 8 ++++++-- 3 files changed, 22 insertions(+), 8 deletions(-) diff --git a/workflow/rules/aatrnaseq-process.smk b/workflow/rules/aatrnaseq-process.smk index 43dd362..3994ecd 100644 --- a/workflow/rules/aatrnaseq-process.smk +++ b/workflow/rules/aatrnaseq-process.smk @@ -28,7 +28,9 @@ rule rebasecall: input: rules.merge_pods.output, output: - protected(os.path.join(outdir, "bam", "rebasecall", "{sample}", "{sample}.rbc.bam")), + protected( + os.path.join(outdir, "bam", "rebasecall", "{sample}", "{sample}.rbc.bam") + ), log: os.path.join(outdir, "logs", "rebasecall", "{sample}"), params: @@ -56,7 +58,7 @@ rule ubam_to_fastq: output: os.path.join(outdir, "fq", "{sample}.fq.gz"), log: - os.path.join(outdir, "logs", "ubam_to_fq", "{sample}"), + os.path.join(outdir, "logs", "ubam_to_fastq", "{sample}"), shell: """ samtools fastq -T "*" {input} | gzip > {output} @@ -90,7 +92,7 @@ rule bwa_align: index=config["fasta"], bwa_opts=config["opts"]["bwa"], log: - os.path.join(outdir, "logs", "bwa", "{sample}"), + os.path.join(outdir, "logs", "bwa_align", "{sample}"), threads: 12 shell: """ @@ -113,8 +115,12 @@ rule classify_charging: bam=rules.bwa_align.output.bam, output: charging_bam=os.path.join(outdir, "bam", "charging", "{sample}.charging.bam"), - charging_bam_bai=os.path.join(outdir, "bam", "charging", "{sample}.charging.bam.bai"), - temp_sorted_bam=temp(os.path.join(outdir, "bam", "charging", "{sample}.charging.bam.tmp")), + charging_bam_bai=os.path.join( + outdir, "bam", "charging", "{sample}.charging.bam.bai" + ), + temp_sorted_bam=temp( + os.path.join(outdir, "bam", "charging", "{sample}.charging.bam.tmp") + ), log: os.path.join(outdir, "logs", "classify_charging", "{sample}"), params: @@ -144,6 +150,9 @@ rule classify_charging: rule transfer_bam_tags: """ creates final bam with classified reads MM and ML tags and table with charging probability per read + + MM/ML tags from the charging classification are transferred to CM/CL so as not to interfere with + base modifications. """ input: source_bam=rules.classify_charging.output.charging_bam, diff --git a/workflow/rules/aatrnaseq-summaries.smk b/workflow/rules/aatrnaseq-summaries.smk index d4edb0e..992747d 100644 --- a/workflow/rules/aatrnaseq-summaries.smk +++ b/workflow/rules/aatrnaseq-summaries.smk @@ -15,6 +15,7 @@ rule get_cca_trna: shell: """ python {params.src}/get_charging_table.py \ + --tag CL \ {input.bam} \ {output.charging_tab} """ @@ -190,7 +191,7 @@ rule modkit_pileup: log: os.path.join(outdir, "logs", "modkit", "pileup", "{sample}"), params: - fa=config["fasta"] + fa=config["fasta"], shell: """ modkit pileup \ diff --git a/workflow/rules/common.smk b/workflow/rules/common.smk index 01549a5..57cd111 100644 --- a/workflow/rules/common.smk +++ b/workflow/rules/common.smk @@ -90,7 +90,9 @@ samples = find_raw_inputs(samples) # Define target files for rule all def pipeline_outputs(): outs = expand( - os.path.join(outdir, "summary", "tables", "{sample}", "{sample}.charging_prob.tsv.gz"), + os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.charging_prob.tsv.gz" + ), sample=samples.keys(), ) @@ -154,7 +156,9 @@ def pipeline_outputs(): and config["remora_kmer_table"] is not None ): outs += expand( - os.path.join(outdir, "summary", "tables", "{sample}", "{sample}.remora.tsv.gz"), + os.path.join( + outdir, "summary", "tables", "{sample}", "{sample}.remora.tsv.gz" + ), sample=samples.keys(), ) From 24faab987cf74d2cd1b5cf289a80090c6a0378a1 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 19:15:48 -0600 Subject: [PATCH 22/42] Update readme --- README.md | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index b5b2000..335625e 100644 --- a/README.md +++ b/README.md @@ -1,18 +1,18 @@ # aa-tRNA-seq-pipeline -A pipeline to process ONT aa-tRNA-seq data built using snakemake. +A Snakemake pipeline to process ONT aa-tRNA-seq data. Downstream analysis to generate figures for the initial preprint can be found at: [https://github.com/rnabioco/aa-tRNA-seq](https://github.com/rnabioco/aa-tRNA-seq) ## Usage -The pipeline can be configued by editing the `config/config.yml` file. The config file specifications will +The pipeline can be configured by editing the `config/config.yml` file. The config file specifications will run a small example dataset through the pipeline. To download these data files: ``` -git clone https://github.com/rnabioco/AAtRNAseqPipe.git +git clone https://github.com/rnabioco/aa-tRNA-seq-pipeline.git -# download test data +# download test data bash .test/dl_data.sh ``` @@ -20,18 +20,25 @@ Set up a conda environment: ```bash mamba env create -f environment.yml -conda activate aatrnaseqpipe +mamba activate aatrnaseqpipe +``` + +Set up the dorado and modkit resources. This will install the tools in the `resources/tools` directory, +so only need to be done once during the first run of the pipeline. + +``` +snakemake setup_dorado dorado_model setup_modkit ``` Test the pipeline by invoking a dry-run snakemake in the pipeline root directory: ``` -snakemake -n -c 1 -p +snakemake -np --configfile=config/config-test.yml ``` ## Configuration -To use on your own samples, edit `config.yml` and `samples.tsv` in `config/`. +To use on your own samples, edit `config.yml` and `samples.tsv` in `config/`. See [README.md in the config directory](https://github.com/rnabioco/aa-tRNA-seq-pipeline/tree/main/config) for additional details. @@ -53,7 +60,3 @@ A few notes about Remora classification for charged vs. uncharged tRNA reads ## Cluster execution The pipeline includes a `run.sh` script optimized for the LSF scheduler. For more details on configuring for HPC jobs, see `cluster/config.yaml`. - -## Notes - -The dorado basecaller can be installed using pre-built binaries available from [github](https://github.com/nanoporetech/dorado?tab=readme-ov-file#installation). The conda `environment.yml` installs dorado 0.7.2 from an unsupported (by ONT) channel. From 4dac8fca6ed50097247f63926b6ef50d16565cdb Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 16 Mar 2025 20:07:59 -0600 Subject: [PATCH 23/42] Reduce dorado verbosity --- workflow/rules/aatrnaseq-process.smk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/workflow/rules/aatrnaseq-process.smk b/workflow/rules/aatrnaseq-process.smk index 3994ecd..0e6481d 100644 --- a/workflow/rules/aatrnaseq-process.smk +++ b/workflow/rules/aatrnaseq-process.smk @@ -45,7 +45,7 @@ rule rebasecall: export CUDA_VISIBLE_DEVICES fi - dorado basecaller {params.dorado_opts} -v {params.model} {input} > {output} + dorado basecaller {params.dorado_opts} {params.model} {input} > {output} """ From dacba62e16b5cb02b70523b78721cc1c8c41a6bf Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Mon, 17 Mar 2025 05:26:37 -0600 Subject: [PATCH 24/42] Restore `-v` option in dorado Removing it causes it to fail. --- workflow/rules/aatrnaseq-process.smk | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/workflow/rules/aatrnaseq-process.smk b/workflow/rules/aatrnaseq-process.smk index 0e6481d..8382e58 100644 --- a/workflow/rules/aatrnaseq-process.smk +++ b/workflow/rules/aatrnaseq-process.smk @@ -45,7 +45,8 @@ rule rebasecall: export CUDA_VISIBLE_DEVICES fi - dorado basecaller {params.dorado_opts} {params.model} {input} > {output} + # TODO: remove `-v` to reduce log file size. Removing it cases the call to fail. + dorado basecaller {params.dorado_opts} -v {params.model} {input} > {output} """ From 1b579166e8daa6842ef37c18ed8c06468d9e50c7 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Mon, 17 Mar 2025 05:57:54 -0600 Subject: [PATCH 25/42] Add rule for modkit extract full --- workflow/rules/aatrnaseq-summaries.smk | 33 +++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/workflow/rules/aatrnaseq-summaries.smk b/workflow/rules/aatrnaseq-summaries.smk index 992747d..1f1797b 100644 --- a/workflow/rules/aatrnaseq-summaries.smk +++ b/workflow/rules/aatrnaseq-summaries.smk @@ -214,12 +214,43 @@ rule modkit_extract_calls: ), log: os.path.join(outdir, "logs", "modkit", "extract_calls", "{sample}"), + params: + fa=config["fasta"], shell: """ modkit extract calls \ --bgzf \ + --reference {params.fa} \ + --log-filepath {log} \ + # TODO: inspect edge filter settings + --edge-filter 10 \ + --mapped --pass \ + {input.bam} {output.tsv} + """ + + +rule modkit_extract_full: + """ + """ + input: + bam=rules.transfer_bam_tags.output.classified_bam, + bai=rules.transfer_bam_tags.output.classified_bam_bai, + output: + tsv=os.path.join( + outdir, "summary", "modkit", "{sample}", "{sample}.mod_full.tsv.gz" + ), + log: + os.path.join(outdir, "logs", "modkit", "extract_full", "{sample}"), + params: + fa=config["fasta"], + shell: + """ + modkit extract full \ + --bgzf \ + --reference {params.fa} \ --log-filepath {log} \ - --edge-filter 20 \ + # TODO: inspect edge filter settings + --edge-filter 10 \ --mapped --pass \ {input.bam} {output.tsv} """ From c1efe37ad36d4c26160f79523c073f6e7f0148f2 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Mon, 17 Mar 2025 21:22:46 -0600 Subject: [PATCH 26/42] Move comments out of shell call --- workflow/rules/aatrnaseq-process.smk | 4 ++-- workflow/rules/aatrnaseq-summaries.smk | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/workflow/rules/aatrnaseq-process.smk b/workflow/rules/aatrnaseq-process.smk index 8382e58..7e18b28 100644 --- a/workflow/rules/aatrnaseq-process.smk +++ b/workflow/rules/aatrnaseq-process.smk @@ -23,7 +23,8 @@ rule merge_pods: rule rebasecall: """ rebasecall using different accuracy model - requires a GPU + + TODO: remove `-v` to reduce log file size. Removing it cases the call to fail. """ input: rules.merge_pods.output, @@ -45,7 +46,6 @@ rule rebasecall: export CUDA_VISIBLE_DEVICES fi - # TODO: remove `-v` to reduce log file size. Removing it cases the call to fail. dorado basecaller {params.dorado_opts} -v {params.model} {input} > {output} """ diff --git a/workflow/rules/aatrnaseq-summaries.smk b/workflow/rules/aatrnaseq-summaries.smk index 1f1797b..4365fe0 100644 --- a/workflow/rules/aatrnaseq-summaries.smk +++ b/workflow/rules/aatrnaseq-summaries.smk @@ -204,6 +204,7 @@ rule modkit_pileup: rule modkit_extract_calls: """ + TODO: inspect edge filter settings """ input: bam=rules.transfer_bam_tags.output.classified_bam, @@ -222,7 +223,6 @@ rule modkit_extract_calls: --bgzf \ --reference {params.fa} \ --log-filepath {log} \ - # TODO: inspect edge filter settings --edge-filter 10 \ --mapped --pass \ {input.bam} {output.tsv} @@ -231,6 +231,7 @@ rule modkit_extract_calls: rule modkit_extract_full: """ + TODO: inspect edge filter settings """ input: bam=rules.transfer_bam_tags.output.classified_bam, @@ -249,7 +250,6 @@ rule modkit_extract_full: --bgzf \ --reference {params.fa} \ --log-filepath {log} \ - # TODO: inspect edge filter settings --edge-filter 10 \ --mapped --pass \ {input.bam} {output.tsv} From 6159157a45c382f96d4f09dacdafd4ba2e39d3ac Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Tue, 18 Mar 2025 06:31:41 -0600 Subject: [PATCH 27/42] Increase thread number and remove arg --- workflow/rules/aatrnaseq-summaries.smk | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/workflow/rules/aatrnaseq-summaries.smk b/workflow/rules/aatrnaseq-summaries.smk index 4365fe0..3e4f7a4 100644 --- a/workflow/rules/aatrnaseq-summaries.smk +++ b/workflow/rules/aatrnaseq-summaries.smk @@ -240,6 +240,7 @@ rule modkit_extract_full: tsv=os.path.join( outdir, "summary", "modkit", "{sample}", "{sample}.mod_full.tsv.gz" ), + threads: 12 log: os.path.join(outdir, "logs", "modkit", "extract_full", "{sample}"), params: @@ -248,9 +249,10 @@ rule modkit_extract_full: """ modkit extract full \ --bgzf \ + --threads 12 \ --reference {params.fa} \ --log-filepath {log} \ --edge-filter 10 \ - --mapped --pass \ + --mapped \ {input.bam} {output.tsv} """ From 38c948a078b3f8a7e6922ae61ff588e1d9c54542 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Tue, 18 Mar 2025 08:12:14 -0600 Subject: [PATCH 28/42] add modit full outputs --- workflow/rules/common.smk | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/workflow/rules/common.smk b/workflow/rules/common.smk index 57cd111..ee2faa8 100644 --- a/workflow/rules/common.smk +++ b/workflow/rules/common.smk @@ -144,6 +144,13 @@ def pipeline_outputs(): sample=samples.keys(), ) + outs += expand( + os.path.join( + outdir, "summary", "modkit", "{sample}", "{sample}.mod_full.tsv.gz" + ), + sample=samples.keys(), + ) + outs += [f"{DORADO_DIR}/bin/dorado"] outs += [os.path.join("resources/models", config["dorado_model"])] From 59dbcb2e200d295ffb37761aaeb8b9f51438e56f Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Wed, 19 Mar 2025 06:04:48 -0600 Subject: [PATCH 29/42] Update column names for tidy selection TODO: compute these values directly from the BAM file. --- workflow/scripts/get_trna_charging_cpm.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/workflow/scripts/get_trna_charging_cpm.py b/workflow/scripts/get_trna_charging_cpm.py index 91ab892..295f336 100644 --- a/workflow/scripts/get_trna_charging_cpm.py +++ b/workflow/scripts/get_trna_charging_cpm.py @@ -1,15 +1,21 @@ #! /usr/bin/env python """ -and collapses the output of running a Remora CCA model and extracting +Collapses the output of running a Remora CCA model and extracting per-read information on charging likelihood into an ML tag into per-isodecoder counts (and CPM-normalized counts) of charged and uncharged tRNAs as determined by the model with a ML >= 200 threshold. -tRNA-AA-anticodon-family-species-chargingref are all preserved from BWA alignment, +TODO: we should compute this directly from the final BAM file, which + contains the same charging information in the `CL` tag; no need to write out + the intermediate per-read charging info. Also, `per_read_charging()` + does not reflect what this script actuall does. Should be `aggregate_trna_charging()` + or similar. + +tRNA-AA-anticodon-family-species-ref are all preserved from BWA alignment, and can be further collapsed as desired in downstream analysis -CPM normalization reflects counts per million reads that passed alingnment and +CPM normalization reflects counts per million reads that passed alignment and the filtering parameters for Remora classification; these are full length tRNA """ @@ -23,7 +29,7 @@ def per_read_charging(input, output, threshold): # Categorize tRNAs as charged or uncharged df["status"] = df["charging_likelihood"].apply( - lambda x: "charged" if x >= threshold else "uncharged" + lambda x: "counts_charged" if x >= threshold else "counts_uncharged" ) # Group by tRNA and status to get counts @@ -33,8 +39,8 @@ def per_read_charging(input, output, threshold): total_reads = len(df) # Normalize counts by CPM - count_data["charged_CPM"] = (count_data["charged"] / total_reads) * 1e6 - count_data["uncharged_CPM"] = (count_data["uncharged"] / total_reads) * 1e6 + count_data["cpm_charged"] = (count_data["counts_charged"] / total_reads) * 1e6 + count_data["cpm_uncharged"] = (count_data["counts_uncharged"] / total_reads) * 1e6 if output.endswith(".gz"): output_file = gzip.open(output, "wt") From bc5441e80078ee2f7b41cca1800e54640a5150d3 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Thu, 20 Mar 2025 12:16:58 -0600 Subject: [PATCH 30/42] Increase memory for modkit rules --- cluster/config.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/cluster/config.yaml b/cluster/config.yaml index 3a8696d..e64fda3 100644 --- a/cluster/config.yaml +++ b/cluster/config.yaml @@ -34,6 +34,8 @@ set-resources: - classify_charging:mem_mb=24 - remora_signal_stats:mem_mb=24 - bwa_align:mem_mb=24 + - modkit_extract_calls:mem_mb=24 + - modkit_extract_full:mem_mb=24 printshellcmds: True From 9d77a3d68068fc6949e1bc5eaab5ffc143a91d03 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Thu, 20 Mar 2025 12:32:24 -0600 Subject: [PATCH 31/42] even more memory for modkit --- cluster/config.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cluster/config.yaml b/cluster/config.yaml index e64fda3..7e801c6 100644 --- a/cluster/config.yaml +++ b/cluster/config.yaml @@ -34,8 +34,8 @@ set-resources: - classify_charging:mem_mb=24 - remora_signal_stats:mem_mb=24 - bwa_align:mem_mb=24 - - modkit_extract_calls:mem_mb=24 - - modkit_extract_full:mem_mb=24 + - modkit_extract_calls:mem_mb=96 + - modkit_extract_full:mem_mb=48 printshellcmds: True From 318fa67d9b640ee646aadf89f0abddc4cadf4c3a Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sat, 22 Mar 2025 11:25:50 -0600 Subject: [PATCH 32/42] Update workflow image --- workflow/workflow_dag.png | Bin 70734 -> 111653 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/workflow/workflow_dag.png b/workflow/workflow_dag.png index 23c56fa8fdb4afbfd06409ca50dcee0c55a8835a..3c3e6096aa85cf8087e2d2906638b9f5e31d4232 100644 GIT binary patch literal 111653 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 literal 70734 zcmYg&2RxPi8~(AfvLbsEifj@hD|^pul7y_R?2N23l4P$WQAk$y)(}F-CL{Y~9s7Sj z-rxW8|9g8sZ*QG*p6B^~@9%wI_jO(OiPq6lCLy9HLZMJ3sw#?lC=~V({5wW)4*o=} zHh=;CbIw*>SrK)L{FBpAn1n*HqEr>-416 z`i?`F(ci;|Cu{-b-LsnilK*T(MlSYyZ`^o!=WxlV_l7bTK`4qH`AHM19mFE1fFC7E zt|3L_r=tCJS`_>^ytI8y8Unw0Q#vUVT6nN*{ZGPX>rvbznQP*tO}ERI!^f(nu44B4 zgR?gG9j3B)Mr!ml6&0x-fAYBW+2Yq6*Py5EnijDP-3nHns7{%C0emVC_T6`%x()s& zFj5j{%0K$Pby;XR$)(h=-MT<#ExcEGWp^X(H+sf_rYcR+?V%$f(cqIL=17NkcFsl0 zaBEwS%{FK7dsw224~4tkRDWUza2JpZcXP(Yu`?w(va{z2ei|BlEM1AEwCr1?5PfBW zpZ7$#F9hco8@hbny~rfn^07&+d}}w)PoW|%c6K5W0TS_3cF1+R#qLb$qks-AhPGG0^?{$M~!K@ky6KPDJ7QAuMd7b4Hq)+>^drqo%C})XKSJ%x2#%;1~9O z^K(oSdl?M-74djD(ySx=Af52K#@j`5N=Kq|XWMr{Dnm#@Zi(ynlqha_s(IBxp`D{2^Itg&k-jmxz2o9Fv{V{ zf7{7rXLX`HBZu<8-Zyx*YB7ScC+K+h{rQx+cf}v%)zpZDg@rf2i}YHr{CfZP?b{He z;*K;ir@rA~ZWj&$>@43|!WYTOZ2bJB-(FsAQ)UUID(fvSZKQ`+E0~(nyEN<=Nn~o3 zST!-<%BQHUt*u$i^4Bpi;QVz}yQ=p~;}hhy!(C>u|n}sUP;OMbnypi z{|*mZ9Jra+e@E8Et!MlbSJZeH9TmmiH|E;(Y~@28sd7AX$MN1&{FqA}Nz=(rDY}!v zHK(|kSUB~3)4@<_`|#-uS#WcHyi5$-C+YF=F=oFvI8L3v7B@39bJoc+aK|uUD}74Q z%#0x`;GgQa&r~30DL;Pm3wO5l>B;fZ#zt2nhw_`s-lRvcDQ*j?_wwGqCyAFmkqFwY z$hLu1L4`bHxHj8CW7Y0d+VCV_Io|f~&jN|P@rOd<3oK6_o*wVrfme+*21@O&jYY1n zuZN7d)XbbKF{>t3P*CvQ>bZtquiMbtZHU%tz8RKNOr-CWVt__AYyT6_A+nUw5uFe?s0H2Xk~yl-G2EP|LOCjNe<>Fa_5O{Z+`r0i@Kx2BvN6zml_E|!Ib z1rOiRyGm;fjr0Hh{p;)R$AY&_OfZ!-Xcbc4!3n9J^dn{o!mw#wpQkbp+MoBGdv@&& z6(!2S&T7Zq4O6c_8Mkol>`duuaV4=`yGB#muuG3CM}Rr)S7sscooFAUqoZ?p@Zcg# z#i+Aw=B~lsBVo!t64ceJSG#}wc%s3jU}QvXYHHfPSZ^ut`}gmJq$HeFjVIr~f2Zs` zhnk2O0I**iLO&zcMp#K(TYoU+RetwI>7DSTR^S-2pNc7D`X6XrInxAvy zL5FLYz2H-yfZfr1uu2Zj&g}w0XkzEFsu`#%c{v;I?u%s(XNo>IDOWuNY6(=su2EDsgu_B*%@ zXkKIE=ElF0?AUpjvGkR!dm0xv`&8rya@C$|Q%{v*sj)UwLd}DZcWTzE#&q=c!v+Tp zj*b>(Y4$X!h=k?HN5T`MqEy&@s@5>VMR9Ge)Fsa)Gm_|;m?HWe+Se!QbPWx~iUW_4 zb?mTh5$Tnte7zL9$fD5W>(y=L_iwCzAff1|DkFsw_E|0HcOM!ah8UV`-fP^u0cmgi z(PAdgl`Hah?-mT^MhvDt(Rkr-0Som-$T2!USEVHliWwd(lx? zl-AR;v-JO0c#{)3MMcisTU|UEG6I7hc+^F61*G?WF_Pko(v!q7UcVqnk;wDA{P65U zV)9rMx!BLjk8Ze0o%dBLB0LD$xJMuI^5j%)n9ktJMQQ=dr#ntT0$V95x}YEep+5ofR|$7P51N`hp>nU zI-lj3Ks;SD;N)nlx9e*4xW~`Zt)jxL)~2IxP18uFdDwdcKfX&OsoF{HV8Wa6BgtIC z16r-@Yj$0^ORZ;RJMVxQE|#u1 zCaJ!W5#R6bR>8+!aE+sb;ig-9dKchR(3@>!a}hL_uSm4}7n~<$Oq+aU(NdG z6%?wp@!(3yCFO%RTV6i40ZZ=0~{Nvd5wa2M5#MbpV2_%S}+2m7+Vgw&W}s+Nxeu1$DS?yio8LB#+0^CzdMNVP<}5l}<9-;N{S?T@&B|Niwo-Whgp!K1;w zwC=U?Yi2f9;Fg>m)^~dmz@5R2dtT?lu#lom&%jV__vHegc@4R?%s%I@QY+cNLgxH5 zCy>8ct}WfZMJIv(PcssNfZZ5`IzZ2GS;LoI=Z?-Yo*0qJBG&3qo)}1zPM>z zN0t&7C42w)e1i*v?L3imsco|*Py7=5eu)OfC01PFkTJx73t|6liKUp;11G3s{LL*}Ec*NFJ<2+1*mfLBc^ikE!t+`923-neTn>Sa=7 zr~13UWTTvl>J634C9((+75J|mR0w6wsjFjn{~jRt{I`@j&p=77;lj36ulye}q27gb z(2zmPN5pm6M)1mzNs+eH%vQxjqt2U-$p(Kc6ac;M?rwrFXfZ7TqQf4yE*>{dZc@uy zXSFe!wm21NHNuYC6wOd;NTE4pH(B{_3PIY z(4msBp+$<2g9aVNP}X*KxB%;>qkW#!BWue}SZmHd`0H05)Np{tC~^jd*nj^#3=9ld z#b0uKYT_3cr%p~z)+suoVIU_->T|a;R)G;xM zdPRE@EkpP07Lo^6rEZ+u8PcJXIB7=`78JsOhjdLK~+1}2nt);Up4c4dv zlIiEgJMUt^RVI^>Iae1Ov5ZdqXLQ*tM`PEsYKY}(Ytf;6c zcbk#_poOpM;UOFo8>?$&MJ7iMfSW8?Edql{B8y-nqCN|FHrwj4{=UAD{(fDw5MYzp zS=;hqVLWZ9QvkpKSpj@TAStX+7Gciyvj^kBZETdhn({3%B_(oo)%k-~WM3#AF)VEV z&=6jHSC~R1sSUtHTPvqL9h);cMiI7)goFgEa=<(@%Pb-y!mZYvmXe`Z zb!MCRVWC<7uB|COd?+H#OolpL_6!P=kCAZ3c4p1wWY6oB{(eJvaLs}!~7aWOGOw z*&MW%&C}DYsNj3?&?fR(e10*{d_kXw%B0@6Tw*!U+8XJOkoUyQvq1ESOrw4Ke*O&2 z%3?+fy*G+|{`>;q7DA5v=>LJi~!AV%!nyLSoM*}dVCPXPkuzI{s&a(d{C*|afvZxo%M=g^uR1Z#1*Y}9$A&PO1Q z`NkEQmx+mw?|ysvU#L2~`#CU>2#pp`eee`kkM1b`?)X*g+((92_2EVa(>Qnv|go4GnE$ z#bY$)Zj^}8lc22K+{hvC!Kx?5om~QVj)sF-!tG{B^^jxb+YcXZSz2a&YSHcENmheH zA2lzvwzf8l&y$yWc7^RrbrW%chr3JFQtRRtLbuVUvJ!+2$^kp3+Tv23UsYw~oQ#j5 zEI~McOIV(K#X~V4K70u2f)GD<4k%f_hLcwwsThnekOMuppAO7#?Ux0g2B9^S-~__4 z=ZuSCC+vDbNzq>~DkvDz*?G&|%e2TK@6)Fj`Nf4d-y7wZmTrU>*V)a2HPrd-23H)twuXkHmzUV=+}x!&evdD9!mnSy);N$X z(2EWa55FG8Q}b_YtHXn}V)W^oH(b#id2U@u+Rb}8@V6a!g1F0jkYnv?mB}>~;fsn%|V-6o%J2$8%l zAnk%++O!Dm`R?9c{AqzpX%d`K4(w-7Ck8Bwqmxtr;9xj<)E+AK>N|=u`P{&ODp9NR<7NiYX5cbKwzCNL~e=qrNhr(({bELDxrAV)MN-lXy66O(-M94pe zDhfe>y6NP^d+XLMh`Clmq~OMw02qND6&BAn(+Nt+%d2MR8Y~6eJ-52h&zBuc3z!Sx zfB{cBSz1~e`ECBWAUhE^a=LifA2nDq$^-y;!ZdpaYCCktum0&=AR>k2SyNLJ(v>Gv zbneK?*xsHC)jaP}-k5gAf%43bta&5x3nU_{QBq8Hvf%N;WIN|?c+mGo>a>~;7pbVC zSlHn%v1La3k2=mC@GC%`-Sr9L^qzC5J_k|A6j?t#Wr;GQRlPoa(2Gy{HV;uv{I-;N zBT{RN=IqI6Z``;6X)wV=HuJ@c@a1L4a$X!&ZU7KyG&5s{%0(ROO&eBCcI4 zMj1)!f_JLN+?V>;U}etG(e2xGkZw8S_&ko*9jvzq@e6oA}?ge*1AkV8F`_-{(vQXBWxjNHOBCpTfWQ?&q%L-+p($Y^G{P$uA zE42z0;KTuw&x$JZYjCKLLicym8eGum9fVBs?HkUt>yC-BG5&|!KV-L77)c;B!{g#e zKYjWXwWqJArvv%G+l;kIpp#F(Mp@Dq3HH_k$*s``eQTa< zm$}XnCanq>cszV)Bb+KIEQ}537~0_~-;8@_jF622Ij-onYx%{+>PX#;{PJa3B2Y%U zzdtrJpZZ1DeKgDds9q!$^{NbusK;NeR;f&_)zJ!kfC?xbL&FXc-YtS}(7W^SVFF|z z5=}JT&U;)}Q&&&b3GOKy3nS@avdwgV-|>XHPGRaZ8C@8)uo|^Bxp}FQzDTRe9x^hXJdV$@FvSENY ztmE(2%;W-TfW2_!w#1h&Uu^HuN48PubSm~gLk_d*SC{HLQ;mUeH1JSR*%9nf*wfUx zyfZWNi~oGxahPk&CwgbT?@Etf67JaHqJo__lqz~2b4&T@x>iPR`vNl__3RlQ%G1Z^ zj<2u8>#qFGGfst5L|ps{)W2vZnQgxtFZnIL5=L9iUBo>)ak%z5gCEsAD{=KCpOxVW zt!2&ii^8Z&lEJZ3)vVL~`4dY%wF=(#uU@?h5l%o#3=xl#021k((Jd`0tnL`YnJ!}C+!r}s=A3oiuc96%9p97v&Mc6%w4}ttTS7@m znV6V})f|j<=i$SL1o5|K&gc|}AAsti45`*<1FMsl$KL&lCu`6qmgMr4OFtKUYg9jN z5@Cy1dFHKu`xnnLZ$G__8@Lp=xMSO!bz?U56(lPt1mUZ`oL3P(vp<6Z7YnEgEW#Z? zp*rT~-^2ZgzRrEpczaKdEosL8_I;gzeb=>)EG&t@#y%$PTml}P>mGjyzTM2DMN$ED zblGH35W7BoXUJAm7Nz+(bR{F5k*s+tYjc3y2PZl{UK#jtBun818_Yc4w2d1n~4EGSUVx_V92dbUL)pIulq@ z7O0(&9Qk_OR5@5^bZgW zM9*$&WAFU3+{y|BS@-2=Cz^%?V7ntuy~2q~ikD&?E(v1`Cv;uYn>dxLXI zu@jFKs2RRb_EiSv*CxMs!D;#0q0+Q}bo8>jA{F1+I~|Y|{)Y3-n>TrRdDtG;PscTe z+jrExH{IV+_sq)e=tf)O0%gM072pe$OLI{PmojPqDgn?;f|7?6GHt-*VCH zLoyi*D{xBCYC!FG|67o9&fNDmbd5ffkC1%l^s7V;Zlbx7TWa^@_z>M2d_s98naJ4k zQGvw$hacx|NoHzAe*dlk{b|d*M=mIRu)=zgN+RvaNc;n}niUfM`Soj`#IK(J*9#C% z=tYZ&G;TkxFHVD2KrU4_4)k-)bSN>Pi4coA@7&Ly=~)7|b(_6utOA7oM-SVq{jS8! zv7GvTZ|t!bVfI^M%Lv>Z-P}K7QiTGIbnC0*wUhwcYxWn?(f_^)#Exlruhy-9CI%{* zba!Ja9(e27jE6rSci5(G*Yw-Yv_>GwZu&GqQidm*Jpsf+QO${oiB=#SI!^ul{R>Dh zFTWaRp2-=#!YFDMp<8|L>lhaK$!4T%)Sl1AHhdXTMr&wHF|Fvk(fwPf4n=kw7MET@HbpO z_a^)~qO1n2m`$~^oNVHcyLT~}RM?aJklxY&_^a`EBs=KfG9o9wc=SDTOI`lx%p zDv0RMpFbA_EKpu9w7s{-Atq+HT;`B=R*m&L!zG0^81XiC{Njrgw6wH3Cw!)^R>|VJ zX{;#Bd{YhX>FMF&<7?+Ft;bIK!YLygR0n-KfLJ7A%KZ0SKmeZu`8nffc|?*1WyWev z|C^kgn@7xm9TY86zXdd(#p3g5noGjDag6se+|P--j7Mz*pB{F9|4zj+)!=_^(6Lg& z*KTW}hetpFALTsy5f7sL?%lhHJgEz34Ymzu)2a_s-E^!u-U}@NqD{b_u`Ff>%McL} zZFY0SPyaG=&DBL?h!ozF&R7fZ18U-z(?^&@B0iC(%}0#Gr~#Y0Q} zsk)lu#to(`$!f57F?OwAel(Cn|JD^Q`4N#xA!Tr%Kc~<<2bdnSTG2c0DT$EYusb-L z+Ux;KxsjV~EGOh+)vn4&3WBSGB&0W9_2C04WCMO&xn|HgH364#fS1B)_ygXwl||6r zgb$Rsa@!7~jG%+R`jWdfH~e>}vrmt>fdc$c|4*&Gt4rI@9H=40RIoeds;sB?Q)rK4 zs6D&->C^K-Hh?;*c@e2xlDQu~@Vl>809~f4N+^)SPLzutIzSul14IYL1*ndqX@t-7 zGzYMZMd;=3E=1`FMemCpG+Hzp)t^48(2{84BlUHOHY_X*x_XnA2_A*qVx^?&$F(Y}HX>6GHf>+7YVr&VVhI(nTPJe1hl znbonSWp18^@I>ZjqAxAP~m1JA0a zckgjoKRgu-`Ze-I_S2qq-+Wd84k5q^v_>N2jeGYB+oAFyAC$I;U=U_$g2Dm9=HNsF zclYvk-9+6_5APpGO!2tPdC!E?2lyL?<3x2cJyUivAuKQup?3&{ErmH9DRrMXo_OESwQ~m&` zJv=;6m|#mONlDJQD6Me7$o}vLrLMcSD&EXz^_4g_o#~ z8gau=(-B!%=#$@naQ}v;g1Lsz-TaZUaf+`|bgMchYXcaM1OSJyDQ93Cjx?WTy-7V! zOlz1PSKC2`r(MyV#JoS*tJWhn!ugZSrMjh21GeatOX4#cxjL-iqyStAbPzDr(_&;c zQ7rz^Q46^MkRfDHC{U+?4Da}?NhDzC$3(fzO6OUN9$pVZAr33e)LYRUX`dmw+dDh4 zQGR}Y(;np<8Z`(XD%$(0vNE^2nkJ;F4)nGHU&mCQv_NO!JA-qs>OMhg*dBxB7nDW4 z0C9nf1jYKnNZ>f3o8K$1YAUrHC0rj>)S&c*-->jjTdKlpHEf8 z$peKK3k4g3-I<#736W<+$$-QI&fPYE>280XlEzz(4Aiuba$R}RJ#x}Gq3o9`ns2d! zAME(nQX3by5yKJA<5~2mh0WuLllaloqjc-mlXl&H=LgGl%^!4$CmCrwwdsFvqPuD9 zrT5RH+-{*G&jYKkb$i>dVQG2!xdc0X*FQ4&kcIzQxjp;Eb)h=8A&KOUA*DcOV;&GLKiRr<=CEcwkA#1*eeui63S z;=MjjSUpApU<*XK8Q1O*cdHCV=9Qh(`IqfS-s7wB8*O0Yqa8h5*( zkz3Y`@nMj3^>B6Gl-KOf$6adF?1lwTyVvfbf~-E0-{&5c`3dbqGz}9CH8ndgub-@< zBGHNcCH5FSFap`izc(t@)zxhYm;Aa!mA`<={7>nH9xDw6nJtTWkU%%f*WqSCyDL zej2KcC)l)qKF?w5O!`SGL$E!gp3%CyWej@{-`K+3h6_waj0;`OE@#!l#kM`FhdPntW=WrtM!j_VwC}bgv|< zsH-bzYm8@rc}j#JbO6!_j^}BEfBAx0|T3Q;w zKokm~IdA|kCD>!QfQFh~v*sECdQjthpbU$oq-1E-#y%_bTz(DAC~!^i1igJzix7`I zMB6(%xggzzoMOKLpzD2*lS9wUd=6>j+B-V%yrzKav%OAeTwEw1B0?E*>TIa39pB#n z-RkI>x+2vKbW%VlVPTAq0fM#<{8elL(HtyHC|1t7wRw+6Hy?<>Te-!=E~*tYar^lA zRQqb;^;|{TH;V5dJpk2w#9^wV6A~Vdizosj<=Y&WFJI>D!W=kOjs?!P2vVu=ry$rM z?Fozu{3#Vxe$>!yu_f&vK8#NZ z?H@|Ht-v0zSfZu zT4(X}c8VTZr0B5&111m7MAT_}JFF8A6?b-yvM6Ql@`1ZFrBgBRi-$(q1HOa=D9bV) zth49qgti3`$Q+J)Y)nkfkRzmmydmFVGFH!>LEyP7{pzoYYw};eemh_TEC;?Vvy5ju zYO}nu((&>R$T2FKn#r)AM!B!@BRoPfPmS&D^t%3F4tZKz<~sn;=CA(m%rr7LAr?8-$ypWMJU6 z6tJ!sZQo54y`JCClhpwaoFtL9k0>;{uU1x8D2>yhOhMOpDK2UutQMX=6%Z}j+uy&A zQ%I3LLZ0pA3M6<$MB+$eL82i-sBj<}npxBd?;$+SNPOBtySavL##4}mlNA0tYpSzR zij;NO?#}z;2r#DVgutCa`=U^wZ9%z)RoiMY*V4`SjuE5{sT>+e%*Z%jphp;TiS=Q` z*_|yfFJBO#8d%xE`hus+qdK%R=L_fCiHpGh7i|KP*_)~vp#e_sC{;<%~r6WKm{4mxmA_Vuxn)&nrScPO1E zq6bf*p{5pt5$T(nA}bsKE+P>T#~Ab4J}>v31&lqMZ$WYKbIn%0k}@At9r#tml-z~q z=Cy$bFDz7^bzlzzj-e^iyN(HrTC-7k49M;X+JfG{y`+mesWNfSR(^OjW4VZ1O;hut zKs^uv3rqhlr;XgnxWt-^u+=`ly4pV^DfotgtJs2 z??pe5*w2cfKKpFYR4?t$XsW2(L@FtTt|$ZO*v-u$BOfUef?{Uv;Ba;jd)Iyb%o)ce ztg$NMBA$Lbo>^W<4#1pIgc}t{^w=u|2g@Q_4>9du43Ho| zXq6ZtLIo=U_TgkC3b`-NKOm%!kDqUDk~9GdP}WJOwI5Usr>CKZ9OJv%{>HE&EU$_@QmvVs?CtGMyv%ZzxKgxl-~r8MW4H(`C4UeP zVukxAoa`nNRLmBf=ABc8 z@Oif&`e_>`=Q0s9l7AnTG&ES$O9+980#p(-FEVMX@*Q9m0Brk1S5zbk&UdmJUUTqn zBn@9y22i6-8yfGz;t?p%=pmU2)CBId6`^^V^<(6sULTW}!CYL%sDI)Gg|*(gf8GNf z+MxtWh1Y*(lkXc#1=jY*x>ZU&h+<-dyKyChBrWXB= zEJW3-3^D7Z;UMrJLJskHYH0yp$ZLKr3C9(Tyt}lbt`>IiAMr_J6RZPC5smbby z!&Q`?0$d>Oii$yVl>;;4PXf3)>q1Z`+1Dk@qc5=@p)N=xQ6;ZJj>~w%k1C|;*ccJa zu_!ciba=|FTd>PH6gky3H0*kpFQ;KzvM#Z6BSdsWrks~Is;^~Yt+C7qL5HefYO?j`&0VB$F_Ya zuyxV(`{C6KhTM%35BRIJbqeN&;tmrpq=(^sF6bUIy2+-W<(BUDXA8^gf%vMdtv_y$Ogt#+4x^?T^pre=0?#i}lxxbxA+V|``7Ly!N zi4l7|f4{skZ&>;`ocql(66ekPKAvr!_|tPQFIj||Jo2sfdFYQ@zgJ6WCUecE@6Sug zjQi=uM1*pv5^n+1HOo)lQssdgw6=yGB_9UozPfU9d?C;9Y(EoXn?czD=Lk~JSH4n$ z66sbqVO~UfCi}8MvVzPD_^#-ohlhQWHb&>p0ZQtL<&(CR(lBS*vB&=~54CDEvs?)E zY#(Z4>h*&DDF*XbU90uWF=}s_*|8G5yO)OU*tBP4J|-_LFc15OalI-2C8nNgchC%d zRCm0@M5OUXtlYz{@SSyE$4xrQAa`{bcX;(cX8ZhSLEBvvDubUz24hQ=%`7_iQzXd^ zz1*HtZv_@w;A1y^rNKULe+akjSP3a3tZVM^*xD04y4&|6TN5>`FUeBq_U-KMf~g7% zl>lf6RLdU6V54|KS0C9J%P!->*r-iz(!A2p7$#${6aLuKEV= z@%TkHrUkvqDrr5vof6HL?`U*b4F(sW0#U)&Rqo&aTe3^@9!fSibFfi}EB(wW!1E6| zoQQFL6XsW%?JGbau<3}oSaIc;)~#yh{Rd_1-Sb!|D&b37s`a$rp7TfOF^?9obj|Hv zFZ0KctTOGhpqej^?y>4qGT(TiX-~%dD3_tff)sUPIx}Q=ZrtrL#kow|=kM>c%b{dO zWuMSgowxqJypdcIojkYede8bkdi85iBW9KuP!*`^Fqg9Y>PzAu78OHaG*F=ZUMST2 z`Tgu3Kc1WffrkbQ1?HT4Vg_x0);r$hpORMhX15m<6T8cGt_kw!hh1=zVDQ?r85w#O z@fkdq*r+8I_d9I^Otj2fDFUy#E~Aq+>}+l9w*$*k)$P-1w43@PEhrF0s|hatgO{+6g!Ky4)9*Lm6h>P!Lg;| z`Y1S==GS9IM}O*x2&%DB>HOJuUe*s}v>2nS^B= z$U$dX$rv1X55-)1dSlAhiC>ShFc>S-^gS4UJ_(n*p07_NA$}ZYEbcCyVa=Qruzw1FS_dwmd-RVR z3c5-xrBBp0o{pV7D>XU{kO2!L9&h_w;YQP**OC$l-o%TZaG^Q%UD@%YJ%0`+-n?_0 zI32z(cQ}n5Pw8uxFgDc)5r1YS6x_^$z$`r#}3Q4s$U zNurDUktuq2rvCw()Q?F2PWbyKmXz$w?~=>cy+?1WM(ul4`i;@#C)FQdU>rjIrk3q2 zl~Q~chYe@{W29#w-`?IvZCdF97?a5l#NY~KJ=niiKXJ^HcC{{y&eGt^;0spWc@~3y z`w4uk#stQDt_@AG>LqG%h8IOPQZ+>G^j+3Do+p3x%O!H;hnwUJwM&39u~1+uH-C1V z7R{vl%Al7SDbcr)!J47v4N@@h;}`|MxzqQEin>=2F4He!!+4#^Dfa_C%6czN=+A1# zpP_+8&;9nI=!^UGZ(o=fyllnTDaoOh$5ustceQ5?@nI2)3KiM+?602Tg@W~U7qqv% z{le2dkv|7lu4}|zePyW8&u@4w8wG1&)RL-dv4)OvfT-cePYi zADgdh`rmvg@c%hpgt&M(3Zv$ChA z^|Na)aJ`QbzP9fLIk)cFNy4}ch&(71aMj+2-;L_?DU9ER#UenB50F#K;@0r?5Bp?# z)Of2gultq#Rc@hM710~ThS3Gdm`ydTy8ns&b+TR`BL;O$V=<3Ntav`~Z(;oW?u2MP-93Z1{FbV0? z*Ern53ij2ERe_?9qt3Gt9k@b83yK}1NDnBg(9qB@y9VM6AqQKUOv<+i5O169h%7Y^ zz%v?!4DgS`LW%EHFOGBbIUbrD%JH;;)Dp z5L|0O<1HW!djk^eOyl7?v7_F^zyRf-@LOwW7A`nNr5XfBsCsRFKdw~+`V(Zh^C{o( znw!*a3=qapcJL06mu8H{__(?XATtl(1v2;SS3)c~sH1hCrZ%W_PeBJjH7k(a2nQZ> z8fJ*_QT3oHMa9Q=A)~Mp6VD2>{D@FF!z<-r)y(kvbz5ID2y9Fs-S&jE|8^Fi+Znd% zT3X`yA#=DIGVJ>M6QPih5N5Z!iKO`y{}@!YtB52G^~~|shMdGmnGMc*!=9y(?seZy zR?x8@BeRzQ&%k{Lg4oj^KeP}rNMdJDzhjX(U{elklE8#f(a_BOR2R7TEe7aBL?0ga z9(#cKlcbHfYYmHyW?(W7@m5U+9X21Z8gK!LFY z9|;9v+E}!XpOIh#tN7vt733EvOwG>X3Z;uWEH8s`$&kL%-g;IoWw3w+q$G*M)rxXp zJDsN*nZOByffdHWB;~^}4Gbv$>83#R@sS$${F*fjp9!z=CZC*&3QEM0@S*X*Q5xM&DKa_bjPyI=#>K}qdQ6Jg6cn1V z!z&kM_Ww}Y9PX~Q!ieIfXY&wTG$?}XfPc}L5$)gueVd(SC`kmZcj9kwA;F0Jo>E(y z4Oz0#7HfovK)hvgFpCFmR@a1&vT|e&&;cziEvj?AuqqLt_n=RnkT8T_?pU;?rCCo35w3uCq?aGP2#cVKMUQeiDRz1hjYegO79njXoBdNvmTBcUpHL_huH? zek6qo9b2Q`kcF8wu$L!;g%=EI>?rc}Ca~h}!vL;&-(SzrFLsjlR?P9rh(%W1b&|2{ z*y`jT4O$F|%Ltg+1Q#DnSIL0~I~44L`k!*Mu2u1B(KV(k>a_j2@)DE}yanXmHR>2!tKgE+q%kM;% z1s;0az=&ID?;`P68IDmHiEf?sxh;y!SoVv8$3B|(@r;gaT1Ljxq2eY-UZ2ssDKjt? z7s*P1OiP{(t=U)1z;Jn&p|M2-;7=r+A-cgdNsWI8bra-*$>7sK(Er<3cI1l;X2JBT zFL^B6|07e%9fbDSVr%H2r!bw@ur0SHHiBqi)a)#hkx6v0K~?zDuy@@}vEZ6)+-xO= z)(m`)v2d_$V3@}xn5sl3 z3z(Rcm}w zHu=I}dk4KK%6DhTxZLxvUckxzB9{K5y&v1ymsxBS*l=<1NpBVo0Cp&w=wkx+%HM})=l~Xmu=MGHd z$U{8>n}_H24}@NeqQf>Z9i56Th>y>K9>gjzjbUK~76u$%X9q~YXeN`CchugL-^$et zkFS?)g)8iP=#LhzHOYBSb$xLsC6d+aMrWN)~@Yk;@tgvCT#o$gp+i47;Y?=w17Gs)Mjk#~;I7&45FkMm8Q z91NdFrC)QUc6I%KmWz#sJ+Rs#mW#QWNS02>czA^akG}7=fF{ER7$6RD0|Y?4KuRHJ zfh;~;X4?@%$8-l8F(h;1$V4@QX+?xglHmL~9Aw%jSnsOWbM5{xWZq%`Jj|S2F*7;` zSSaAOFq3LinF1(ZSaaNXs(#_Ydc;t-HaFQ{M{G2$^mqXKG)yo$o z`N%(d|Md6qTJz7`I?>HYTGkR6nlSWww;Uil+~H;DV>nzpz&SDHw;Z&7k3nX)JbtDk z`5{T+>qgL?6yjTb_Uzdiu7DYH8}K>8NJ!e8k9^>;`9l&Y3vo>+D@~n^froCh z?a}VaayZRxWU^1g@X1=iFV-b{B6PB2b$Ss}C8YZn7=Ya@j}L?%g#;OT?rOM`;0kA! zLEO0+#@yd%P>fbRV366)C9{DEfHT_(I1pAR8yI?_@MnA|_gXQk-w51jgL`!!GBieR z2S`+Xt!oDA78XoeS<=yV!qH%qb-${k_^_bq5WeWasE&X=&%=GToludT0@eKS?zew_ zF|#er+349#4qx6)Y*XiA>tCZD2cN;#hkP9c!MQLK7&(Ikd*ZGy3S-*H%p44*=QTDm zgIw4WiZ=qY^)>D;4A)%R-)N?jpFh_R2mvfQG+-VbseklPD>om$Zi6oJUbzYK^#EXX zY=zN(WJ{1Kd?anCzvM%v;lrfXYjAjtN`SUFH|tSL{_GZ8fIl2yDQSkPgR%=< z#UYbMRg9holMjqYe?yiM3k4flvykRQP80#+-6o7;Kif*L=-iET%qH})m;B2Z4S$hbsC`EPz6Ep(K&2MP9Q79{$ zul`_ztr!yN2Fh3fll-C0}wPXxQyK{T(aiKY3k zuD>Zv{YTmf6DEBL$0MeGYoT?UlCyC`PVoh$E*0X$|3o9%}U9B3;)1$jlcO#avWV_sK*X` z&&X_+|9T4qt9?KTC)Ty2EjCp1%O6()4n7|>#Fm2>3}OVlJYe8b8Z{^u`?m*^GQ0vO z4lX0`O#m-LnL7=`^N$9zd+cH8;lYI| zupK{j+jZ$=fhzc_oq2137PS^{(Pmn6f321#6|Lkx=w5y*Nla~GoHNnLJoM%$a@ln6 zuUKJYqT*zBw#R@}z=41E@hPX(M+H%`(A<67w_NOBA2YtglY^nVE8Swt-wWfPFspA< z|Dk`8-bqi%_vU+PceOT^i;<}2hEDI_jpIBn^~r46x@2`1EVeXWjJMB=igBFyCdkXi;bGF`gbs>|ww*04@Ct8ieQ0N~MB5Bz>(#Qa zC2&s9$Y!j&pA>6G+^@w(6%P@Cbjmt_&E6Ekm3H+Ba{2Du-wvYGb}yKdx$@27i@HT-1a`(0V-IGEiUAC&zFD}R`{W}7qqe>sF+tBoh?0KMk7ly8?}jKbf}cf!_u>s^jbDW4tyRqF#$oni$pb%T?@@}25;8-f>|$2h0MwGtli4&q1XAJ zhN(b@&0D|nb=je&tfhU+&v;X+y#BS($i?|Hd8?Qc>F{e4q;w50)Mn4-t`44@(0(Ad zHY!`Ri+X>w&+}(1IC=LnlLpRzQ#a)XAMFj%Wc=3?0&bX3cm6`DD!0&@ z(;LN+alfS5yS|^bEvacJC#u)3`07-qgN*{F?EOh5?>m2$c=Y!r-MxWHI7+#fnBr4u z^D{FsY4hL!dyBuxF|zCRl?TBaxVs68jOuC6`SP4Ns~B$GsQ6_0*njLh>a|CSr}712 z5AX=U*G;BttxjW@Iy&PJs-1MAyXBlWKr;NciZl?#BFz@eh4UmmY})Ub+JB(@*6juo zsVv-+d$gT>6O6|*^GCbOkrrVM2Q3c=&CfM@-@a0uzR2=6L51tr&H>~X;KNe-qlHC6 zR}G48v3GbtO9R`g_3vIHWO~tRq)P=mN|2!-3*#GBjkwZB;^m6A4^*{QzPD)~rg9;L z{8!np$Ttf=AHBJ#omYN?n&b74?-7bw2965L(eGdXyE&*|*fGeB5*)LCRCI0X*Bak6 z2}$4ku%ARXJpOH=ZXWT6QQsH)b6<@3+Y)0Hjy!F^eXeMWBd7ZBbZs$ya#8mVZD?B? zyF-*3G@1`;(K87{VgenlC7(dW43Jjc@|p*_B+rnsc;i;=?lB=%UoQB!1RGu?1QZhr zHbti7{@wWv4593wvVIAEJ41N*bDHS>;B{V~$3|+?A6L9xvGe_BZXUMwvuk=bjoza` zIb9~J{wlj{@ts;T%wxU%^5MQ;y-NOWiEFvO(7UNQ!NqSsv<_v?BzQu8PZiSvtc^;~ z4Xc_j{O^B$biY6yjvzR#A!luqbboyJ^a~CvY~!XTX){k|(=2dV|5h9#5Ja?Mw=ed? z;9mIDZY4jSTOQw_{8^M$0{M{H^rzsZG!L&N3gLfeo7q!LE1tQi$1mk+3E925cr(ay?QIOz z>(>6_B7;%aSB>fB*oq`q5sJ4r*lTBEU5O!k6YSjjqO2HA#qM*DRo2;)^~H9(>IFvOGRI_1Dc1Y7f3)Vs%^xH%3DUy~eraVF)iI-O zB!BbPEv90AYcc?Q6Zp2Y($A#7?l?$w5bhjma-OE+q9(x)(#;f+m|RLar+|7XX8b1C zbFL@Rw~77d&s(t?*5ZFmt29ElxASi#sYt?UGDM>wh%W-kjE#*`N4d3=f2qiDW~=TV z0YTENVqR^KtGHM+XSQWZL^CrrPoBdciley$$@+0%!vqAJ5)-;E;N^?nxI#(H5vNjU zLWMblgl-ZgZ6&@$$>G)o*BifHy}bfFGL%1;Dt0Hrik=w%+u&dx{vuRHTwPrYP3Y9o zy1F^z+k4&u`Zs2uXTjkrP>V0OwDG0g(ygp6!9f&bu?rxtpUbqaiHmED#AqyH$p_a< zy|R-Rm;O=#4B&M8kjDDm|Fd(mwMg-m4{aC#9AvP+&qA7xdmFi)5 zA$9>7fr}rD!o^A817M?)gTFXBYDBmw3O)&mV$7D??9 zFwot9e|PO|xZrnS_K|(JymTG?rJ$5rJs5_BFH%|xNG5etR_#%S7enB|+h&|l$?^@h zg93kC53d@3g##i`e^4Q|DNH9dG*k_O%+Ue`KPxk(u8o%x!-qjHYLLv_DsOuC_u!%u zXTT$|V&|)9?5=P|*dNo8tXRRpy1sp@cG$Inmd+OdT8@-}4=ryhQk>iUwv?1suoJnR zn8oo&p4HQBbdZwRLc)lA;$dcSaZS^V*!9CCO{L9Co_R);_<1q$R{8Bc5#dU>P;5}U z4%yT+satTBQ5m+Ym~2pt^>~Sw(<`Z7$G*mh>4lYoT`C=nILw=p$F^>DCWs6Jn66li zc2=ifhhi2bML-t+S}h?J6-t{HQ@b{zDRbRuwDi>-o(=-rf`KmiG92eZdS&fBKTR`u2i2xZ8eTx zHK_e8ur-SGhOc`*hUYak>tWr3XPy#(Kj(A{BoFK7XkRpvM&hEPH!bTUeS#+ zPF?_`1FJz9Sq%~m`)zuQbwzJ82EqeIfdF4!ogn;P?BannobHSAv-Y5zf zkLdDzY4w`B+VNa)N+2UA=S&?c(n%!24XP@ za#osfp&V`eAO-mM{Kk3iFtzySAc%5`sWrR^#k^>p4%LDIV6(OXGw17jO zQ*T*z|2qv(C$MV$M=g zAeQ7uHXkP=nLxm(c_mW31wK)kXwmboEF)TF2r|d@ubmL8cM5N)En(3}5%?^?y=uhh zT}R)Jf1bdrnX$GfS^?>h1GYwU)camm#A4^{|a^f+P4^-G5=)-C<{D!kBISLzfWJUzs-nmLe zH#RnM>M71fWToUIu_J}2LI;m*&}Hz)5AkKvijl|qZfO}qOFavJHsOX44!m+<7#31! z^-$!s3tdOMjJA#=1pm8L53vV>W_cMBSDs11y{8Qp%Je_=|+ z9ZV@iHhL$|fy$A`Q2bYfnnJ5skBV85RbhTOEGw0P-&$n@3m&nGY>1f@l)PumN(*ar zWCjFkemZo3$*8u0fkAFWA$8|7;r<0NCGBpTTrL|tSg$tB*68^pvx*MHiUxGbvo5yJ z7a^2RO--q;RD=DZy}dI0UR+7GTI|vE^*9yBcar@7U9#3ua_@p4utq_jO4Kw-0hI}? znwh3%FH^%$z&H@GC}8M)OIg^sqiW9NJEG`>K;(trj_0x@l2df^6*B!m`=ov?M4;q5 zEMTZ3V>_S<1@lK&gZF$&^xsUnza{yPku`p|2(4Dv1M9U4?#R|w%A)2yBc!JUaMT5R zozYP&#s(|cU{*2yQqzJP7rDLGs`+kF^!z=jaRAvb!m9`37Ho|WW?-XZ*c#0}OW3;b zC-JBy?R4$kj?9wEU~bjgRrk1XKpB=P&pCTbhm2u00+*6+&bEeJB=Qd{;p#tG<%atq z+D}4T$0KaNIDeP?(Q0FcZc8bQ7x^!~sZ>`ToEMZq6HRwGJ=}C63!Z$=MYkceWM1nR zX6?-*)E=kNPIcS!GWA5H`%OQ>0#7P>y?fyVUpH_Z#jno3fC-Fbaw&Pi8H-9%VeU8C zTKP{hIik;`;XeK>Wf*-{WO2E8(16V5@(T}asMa*C692|OB@SN}Q@ly#m=l}Q(vJih zU(7Kjxz2Gvb$hhbN03)hEzode!POt!a5SkP%Bmwf|IYPwyBq%^>wI&rd$FPETDT7N zL?_NB;c?WbZ+4V87&_=~Z1KwfGl>t zGB$AwyqAL${-29sqt0hbzpqs0BV@a5N2N;s>({p!5f)z>YA%+wW6~@ocBxcZl7{9W z|3|h!+%FhVpj9qM4@jI2FNV38B3e2kXM#5|X3XxG`L+yuphjVu+>G}~RJ26F-Wf*H zh8N`lE9bdyiZG4_|Kz<@Svi~edT33aA|>V1eR<9}&|O8h;w{0`o-PHncx7hbPm zfDtd_oBTBzL$hZW@V00dSw%% zc_8OWq7ASDHP@=x4+u}rpg4%V(gwVVQqotn>x%oWuUwrT|8a6QwTKEO!g73Og6%jQ ztEbJMpm^1wm><~$ZC;L3+$G7968ikc{ntk|iY@F1<6o6!@a6Rf{nsnA_P&TLl%P-@ z9lnuqDoOC&qIh0^s4P{%@i@+^tK`neg(~bI)k+1WW;70JbbLj*7xy=IZxVSc`Yqh~U;zX4@x>74w;wLy_;>fs{VmHUVJ!Y{ zYgQe}k~(<))_ErS?=3Yj)q@up&`g7~kv&qUS0_X3W!i9~kjpaW*TXkFOvr1~$ty+2 zC{qa3F0ojb7^+$piPnBHUqzwn?@n59-uEti$)(z^R+xxHNFF`4Lh{d=xScGYOf7A7 z>r$}ORTl|SO4N92y;6NjWP@BtN~&I*sKu&zfPOUoGI+@{JuTJ*2cw#Jz`@l{?ZFI>+hEW{*b}0e0o3BidPZf9g%=SScIZw zD8S>ei8OAcul#~K^>a|%H#egYd>p|&K^#MX`h^(X63OivfgQPw5Y7;T;N4kazi`A18oU(SK`6!jCKq}3KAhckQdU)ni9qR)>|Y(xb@zV=D`0U^^h#Rooi<9B?$&p=2&UHMOG0V8H&4V)y|HlO&MT{nM zRYyLlMP}^--gS$E(jQdkd=a~V1s6P@&AXkH4VHH&hrK7I-VSgRyI0&4eW4h(*7InhMkE>M7<3Q2ofYbWTCzP>7d@I!pXVy-+Xvi z!JT9h2%buasjXpy*Hu_{i%v8$vTNa*ufd|#xYmIHReHCY5Ec&w$krwP)v#B+p`x0Vj~zC-sl@yi48lNxDo=@zaDZ%+u2>7ROa?e+Q|Qf! zr!}q0LODyIV(1JUfJ{x#a$Ip=Dqt9Y!8q&sKS-*gRJ{OD;8HEr^7XX zWwt%#{G{0sz&`}><6ZM$iILssYXp<}Ic_Z)svZd1R8*KesK_9T6R}7&uVh5t8v-*F|pnC-ZPBOP=(O|Q~n=;(zSefn6bduWsT1`Q)G@4IXDF@ z2z~OCuJDKGmFKSKRy7t7n(l3PQ)@e&Cf%3=37L{CdK9JR9%Jdo#l$~&s6TF2j9YpF z28v2~ke!7UMoIQWPBd_TVvxzT;-^zij3;h;fr~1>bLKp-p}ncJr%p#+4=bh})1X@? z!#G-I&W*7Y>yJ)kBtU()@`-`^I+Eg{Kc~$FzhOFugF5<@6nCeZfQ#MByO*!_9P50s zA<6&BRaHE%dm7H7V(Bd;;Jss(`2BL?ju^>L2vAz~rZ}N>db1H>g)DIERG2#b9m_Y& zVAw0uSU?rEQ)r^S7tb+WHpSj}5a*v)!>(V$#woy#R~$6C`bLDJ%u$DdUXPv0@qHjHS@~w2Ubjas_wt|GD4|3C+ug6C@#Leo zE-Yyf>J&tNK^U^V$c(#>hv`Dzl5|KaRy zX@e3IRw|5O&?o^VRgpr$^@e;cn=EG3-+Z35Auoz;iX#TXz>g@EKWFO0j+<{6R+ili zvbZq*lH4$Q3tRj&Pc71^P1jSx8gqKmACLz^+HA0WkERV4oWj6o4N;G7ZmMSCLbQPT!ai0fj2vsIC z_e}#hHJ&VG6%j&cbF+oCA(Wm1a2-qIc1Q^^lny-C5zxS}9^H6)i&_DEhe z^ji_P$}QG6XRJRN`H^mCGvhBU-=xz2p7jh5JI#Z6EO*cbwg(;PsC@x33Gu8?l{Vw^+^Q|$QWN(A z79Cl*cxm|o2U*D8QStD~&zQJf;vb(Wc_@iwxO`A_2X{Tp7@Xuc8ZS|4Up`&V zFezQ7%+1Xqq~uO=YwSk_3e|JJj;KZmjP7vfMtH=bT&SobVcyQWvCxu&kHJ$`;2+%RQ z3}zEAh3}cIF5Tp$n%#b^=%%h7y?zqrGpK|n|9|84@F{l%x&W$%Zf^WIL(5MsX0ez7 zHiiu05h(hdD|VA&EiNg+L4CTfb$5-2Q$P=SrFYlW9_5vzBeTN*i-2MvN*=ss^()L| z$}{U@s|<==lC@>1jOD`$(~v-C#Y9Gk!Y~!Xe1SlqEJ;43j8IEgu23{9%CMJn6W?=HR*nC)<+Y*1K&5^D^p5n*4?5On zI-C~2^P`d(&cZh~NNZf^BHI)9CijR3QOLc&Mb?8A6#wFLBP3AyU_-&Hkp|qDj7pfB zfTrl#c4Zu1PV%))24v%>0};xjVIpGpL`ew~etJYDAC%v#(5E<^tF0(eUg~nNsJWDM zyT)toN{$z&XAMXMTjw`=mg->cAq9T15}g}cP@qL9y|XjGLW??gt03fWPW$}1Vo9Tz zFf0zTMd@#gMLiTPGUs-g-`H~mLuHkC{8LR26sPpc7hMa*8Ob¾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 TVxzK|gkSnP#@Z!X_QC%T1AN>k From 5b730a72ba88175449017590e996fa423789f9be Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Fri, 25 Apr 2025 13:34:04 -0600 Subject: [PATCH 33/42] Downgrade numpy to fix remora stats --- environment.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/environment.yml b/environment.yml index 9979f81..9b13a25 100644 --- a/environment.yml +++ b/environment.yml @@ -6,7 +6,7 @@ channels: dependencies: - pysam - - numpy + - numpy < 2 - pandas - samtools - bwa From 514bdd74c187790d252936d594e98595b507cadb Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sat, 21 Jun 2025 07:03:15 -0600 Subject: [PATCH 34/42] update ignores --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 2043ff6..2e3ef55 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,5 @@ logs .vscode results/ resources/tools/* +*.bam +*.pod5 From 914c39f1210ec601043e5fa7ecea514162692b94 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sat, 21 Jun 2025 06:25:47 -0600 Subject: [PATCH 35/42] Reduce and make optional dorado verbosity --- config/config-base.yml | 6 ++++-- workflow/rules/aatrnaseq-process.smk | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/config/config-base.yml b/config/config-base.yml index 434bf0e..34093cc 100644 --- a/config/config-base.yml +++ b/config/config-base.yml @@ -22,8 +22,10 @@ modkit_version: 0.4.3 # additional options for particular commands opts: - # additional options for dorado basecalling e.g - dorado: " --emit-moves --modified-bases pseU m5C inosine_m6A" + # additional options for dorado basecalling + # XXX place modified bases first as the arg parser gets confused + # XXX add `-v` for verbose logging + dorado: " --modified-bases pseU m5C inosine_m6A --emit-moves " # additional options for bwa alignment # based on Novoa lab optimising bwa for tRNA alignment diff --git a/workflow/rules/aatrnaseq-process.smk b/workflow/rules/aatrnaseq-process.smk index 7e18b28..0ab428a 100644 --- a/workflow/rules/aatrnaseq-process.smk +++ b/workflow/rules/aatrnaseq-process.smk @@ -46,7 +46,7 @@ rule rebasecall: export CUDA_VISIBLE_DEVICES fi - dorado basecaller {params.dorado_opts} -v {params.model} {input} > {output} + dorado basecaller {params.dorado_opts} {params.model} {input} > {output} """ From 57afd804b5eee7cf38ff2f5c68872b975c20cba2 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 22 Jun 2025 05:13:17 -0600 Subject: [PATCH 36/42] Use LSF-specific cluster config (#63) --- README.md | 4 +-- cluster/{ => generic}/config.yaml | 0 cluster/lsf/config.yaml | 30 +++++++++++++++++++ run-test.sh | 2 +- .../envs/aatrnaseqpipe-env.yml | 0 5 files changed, 33 insertions(+), 3 deletions(-) rename cluster/{ => generic}/config.yaml (100%) create mode 100644 cluster/lsf/config.yaml rename environment.yml => workflow/envs/aatrnaseqpipe-env.yml (100%) diff --git a/README.md b/README.md index 335625e..036881b 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ bash .test/dl_data.sh Set up a conda environment: ```bash -mamba env create -f environment.yml +mamba env create -f workflow/envs/aatrnaseqpipe-env.yml mamba activate aatrnaseqpipe ``` @@ -33,7 +33,7 @@ snakemake setup_dorado dorado_model setup_modkit Test the pipeline by invoking a dry-run snakemake in the pipeline root directory: ``` -snakemake -np --configfile=config/config-test.yml +snakemake -n --configfile=config/config-test.yml ``` ## Configuration diff --git a/cluster/config.yaml b/cluster/generic/config.yaml similarity index 100% rename from cluster/config.yaml rename to cluster/generic/config.yaml diff --git a/cluster/lsf/config.yaml b/cluster/lsf/config.yaml new file mode 100644 index 0000000..e9e1b66 --- /dev/null +++ b/cluster/lsf/config.yaml @@ -0,0 +1,30 @@ +executor: lsf +jobs: 300 + +# note that GB values should be passed to mem_mb +default-resources: + - 'mem_mb=8' + - 'lsf_queue=rna' + - 'lsf_extra=""' + +# amc-bodhi has 12 GPUs +resources: + - ngpu=12 + +# set rule specific requirements +set-resources: + - rebasecall:lsf_queue="gpu" + - rebasecall:lsf_extra="-gpu num=1:j_exclusive=yes" + - rebasecall:ngpu=1 + - rebasecall:mem_mb=24 + - classify_charging:lsf_queue="gpu" + - classify_charging:lsf_extra="-gpu num=1:j_exclusive=yes" + - classify_charging:ngpu=1 + - classify_charging:mem_mb=24 + - remora_signal_stats:mem_mb=24 + - bwa_align:mem_mb=24 + - modkit_extract_calls:mem_mb=96 + +printshellcmds: True +show-failed-logs: True +latency-wait: 15 diff --git a/run-test.sh b/run-test.sh index ff6f507..584e142 100644 --- a/run-test.sh +++ b/run-test.sh @@ -9,4 +9,4 @@ mkdir -p .test/logs snakemake \ --configfile=config/config-test.yml \ - --profile cluster + --profile=cluster/lsf diff --git a/environment.yml b/workflow/envs/aatrnaseqpipe-env.yml similarity index 100% rename from environment.yml rename to workflow/envs/aatrnaseqpipe-env.yml From 50068880e8267571ce4893f723769e14b278365d Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 22 Jun 2025 07:40:30 -0600 Subject: [PATCH 37/42] Rename to recommended test directory --- .gitignore | 2 +- {.test => .tests}/dl_test_data.sh | 0 {.test => .tests}/make_test_data.sh | 0 cluster/lsf/config.yaml | 4 ++-- config/config-test.yml | 2 +- config/samples-test.tsv | 6 +++--- 6 files changed, 7 insertions(+), 7 deletions(-) rename {.test => .tests}/dl_test_data.sh (100%) rename {.test => .tests}/make_test_data.sh (100%) diff --git a/.gitignore b/.gitignore index 2e3ef55..61099d7 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,4 @@ -.test +.tests .snakemake ext logs diff --git a/.test/dl_test_data.sh b/.tests/dl_test_data.sh similarity index 100% rename from .test/dl_test_data.sh rename to .tests/dl_test_data.sh diff --git a/.test/make_test_data.sh b/.tests/make_test_data.sh similarity index 100% rename from .test/make_test_data.sh rename to .tests/make_test_data.sh diff --git a/cluster/lsf/config.yaml b/cluster/lsf/config.yaml index e9e1b66..7b45b59 100644 --- a/cluster/lsf/config.yaml +++ b/cluster/lsf/config.yaml @@ -1,13 +1,13 @@ executor: lsf jobs: 300 -# note that GB values should be passed to mem_mb +# N.B. GB values should be passed to mem_mb default-resources: - 'mem_mb=8' - 'lsf_queue=rna' + - 'lsf_project=aatrnaseq' - 'lsf_extra=""' -# amc-bodhi has 12 GPUs resources: - ngpu=12 diff --git a/config/config-test.yml b/config/config-test.yml index 50f4ca2..6fed93f 100644 --- a/config/config-test.yml +++ b/config/config-test.yml @@ -11,4 +11,4 @@ samples: config/samples-test.tsv # output directory for files produced by pipline -output_directory: ".test/outputs" +output_directory: ".tests/outputs" diff --git a/config/samples-test.tsv b/config/samples-test.tsv index 3ed42bf..36dc4bb 100644 --- a/config/samples-test.tsv +++ b/config/samples-test.tsv @@ -1,3 +1,3 @@ -sample1 .test/sample1 -sample2 .test/sample2 -sample2 .test/sample2_1 +sample1 .tests/sample1 +sample2 .tests/sample2 +sample2 .tests/sample2_1 From 0850ae7f324e70cfe629cc397ecdf71a8399b1aa Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 22 Jun 2025 14:49:12 -0600 Subject: [PATCH 38/42] Reduce remora logging level --- workflow/scripts/extract_signal_metrics.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/workflow/scripts/extract_signal_metrics.py b/workflow/scripts/extract_signal_metrics.py index b274c57..83b4fc8 100644 --- a/workflow/scripts/extract_signal_metrics.py +++ b/workflow/scripts/extract_signal_metrics.py @@ -8,7 +8,7 @@ import numpy as np import polars as pl -import remora +import logging from remora import io, refine_signal_map, util ####### @@ -19,8 +19,7 @@ ####### # silence Remora DEBUG messages -# logging.getLogger("Remora").setLevel(logging.DEBUG) - +logging.getLogger("Remora").setLevel(logging.INFO) def get_metric_data( bam_fh, @@ -183,11 +182,11 @@ def main(args): parser = argparse.ArgumentParser( description=""" Extract signal metrics using the Remora API. Output will be generated - across all regions with read coverage, restricting to reads mapped on - the positive strand, as it is expected that the reads are aligned + across all regions with read coverage, restricting to reads mapped on + the positive strand, as it is expected that the reads are aligned against transcripts rather than a genome reference. Output can be restricted to a specific region using the --region option, or to a set of regions - using the --bed option. + using the --bed option. The output is TSV text with the following columns: Sample\tContig\tReference_Position\tRead_id\tMetric1\tMetric2\tMetric3\t... The Reference_Position is 1-based. @@ -213,7 +212,7 @@ def main(args): help=""" Window size used for signal extraction. Regions will be chunked into windows of this length prior to processing. Use this option if you want to extract data from large regions (e.g. regions >> than the read length). - Without this option the entire region will be processed at once, which for e.g. chromosomes or long RNAs + Without this option the entire region will be processed at once, which for e.g. chromosomes or long RNAs would use excessive memory. Set this to the median of the read lengths in the dataset. Setting to 0 disables this option, which is the default. Default: 0 """, From ec81e1f81dc990a25f04a347fafa65606bfd3bf4 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Sun, 22 Jun 2025 20:32:50 -0600 Subject: [PATCH 39/42] Prefer pandas as polars is flaky on some nodes --- workflow/scripts/extract_signal_metrics.py | 1 - workflow/scripts/get_bcerror_freqs.py | 11 +++-------- 2 files changed, 3 insertions(+), 9 deletions(-) diff --git a/workflow/scripts/extract_signal_metrics.py b/workflow/scripts/extract_signal_metrics.py index 83b4fc8..07b99a5 100644 --- a/workflow/scripts/extract_signal_metrics.py +++ b/workflow/scripts/extract_signal_metrics.py @@ -6,7 +6,6 @@ import pod5 import pysam import numpy as np -import polars as pl import logging from remora import io, refine_signal_map, util diff --git a/workflow/scripts/get_bcerror_freqs.py b/workflow/scripts/get_bcerror_freqs.py index 3cf0008..1de4bae 100644 --- a/workflow/scripts/get_bcerror_freqs.py +++ b/workflow/scripts/get_bcerror_freqs.py @@ -1,6 +1,6 @@ import argparse import pysam -import polars as pl +import pandas as pd import gzip """ @@ -158,7 +158,7 @@ def calculate_error_frequencies(bam_file, fasta_file): samfile.close() faidx.close() - return pl.DataFrame(error_data) + return pd.DataFrame(error_data) if __name__ == "__main__": @@ -172,9 +172,4 @@ def calculate_error_frequencies(bam_file, fasta_file): args = parser.parse_args() error_freq_df = calculate_error_frequencies(args.bam_file, args.fasta_file) - - if args.output_tsv.endswith(".gz"): - with gzip.open(args.output_tsv, "wt") as file_out: - error_freq_df.write_csv(file_out, separator="\t") - else: - error_freq_df.write_csv(args.output_tsv, separator="\t") + error_freq_df.to_csv(args.output_tsv, sep="\t", index=False, compression="gzip") From 9a01b4eeea2df11687a8f2db9c0934df20d88740 Mon Sep 17 00:00:00 2001 From: Jay Hesselberth Date: Wed, 5 Nov 2025 11:12:33 -0700 Subject: [PATCH 40/42] Initialize new project setup (#65) Co-authored-by: Claude --- CLAUDE.md | 172 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 172 insertions(+) create mode 100644 CLAUDE.md diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..2488a19 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,172 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project Overview + +This is a Snakemake pipeline for processing Oxford Nanopore Technologies (ONT) aa-tRNA-seq data. The pipeline distinguishes between charged (aminoacylated) and uncharged tRNA molecules using Remora machine learning models trained on nanopore signal data over the CCA 3' end of tRNA molecules. + +## Setup and Environment + +### Initial Setup + +```bash +# Create conda environment +mamba env create -f workflow/envs/aatrnaseqpipe-env.yml +mamba activate aatrnaseqpipe + +# Download test data (first time only) +bash .tests/dl_test_data.sh + +# Install dorado and modkit (first time only) +snakemake setup_dorado dorado_model setup_modkit +``` + +### Running the Pipeline + +```bash +# Dry run with test config +snakemake -n --configfile=config/config-test.yml + +# Execute locally (specify cores) +snakemake --cores 12 --configfile=config/config-test.yml + +# Run on LSF cluster (uses cluster/lsf profile) +bsub < run-test.sh +``` + +### Cluster Execution + +The pipeline is optimized for LSF scheduler. Key files: +- `run-test.sh`: Test data execution on LSF +- `run-preprint.sh`: Full preprint data execution on LSF +- `cluster/lsf/config.yaml`: LSF-specific resource configurations + +GPU-intensive rules (rebasecall, classify_charging) automatically request GPU resources via LSF queue configuration. + +## Architecture + +### Snakemake Workflow Structure + +The workflow is modular with rules split across multiple files: + +``` +workflow/ +├── Snakefile # Main entry point, includes all rule modules +├── rules/ +│ ├── common.smk # Sample parsing, helper functions, outputs definition +│ ├── tool_setup.smk # Dorado and modkit installation +│ ├── aatrnaseq-process.smk # Core processing: pod5 merge → basecalling → alignment +│ └── aatrnaseq-summaries.smk # Summary statistics and output tables +├── scripts/ # Python scripts called by rules +└── envs/ + └── aatrnaseqpipe-env.yml # Conda environment +``` + +**Key Architectural Details:** + +- **Sample Management**: `workflow/rules/common.smk` contains `parse_samples()` which reads `config/samples.tsv` and `find_raw_inputs()` which recursively searches for pod5 files in specified directories +- **Dynamic PATH Setup**: The Snakefile `onstart` handler dynamically adds dorado and modkit binaries to PATH based on configured versions +- **Output Aggregation**: `pipeline_outputs()` in `common.smk` defines all final output files for the `rule all` target + +### Core Processing Pipeline (aatrnaseq-process.smk) + +The main data flow through the pipeline: + +1. **merge_pods**: Merge all pod5 files per sample into single pod5 +2. **rebasecall**: Use dorado to rebasecall with move tables (required for Remora) +3. **ubam_to_fastq**: Extract reads from unmapped BAM to FASTQ +4. **bwa_align**: Align reads to tRNA + adapter reference with BWA MEM +5. **filter_reads**: Filter for full-length tRNA reads with proper adapter boundaries +6. **classify_charging**: Use Remora model to classify charged vs uncharged reads (adds ML tag to BAM) +7. **transfer_bam_tags**: Transfer alignment tags back to classified BAM + +### Summary Generation (aatrnaseq-summaries.smk) + +After classification, generates: +- Charging probability tables (ML tag values per read) +- CPM (counts per million) for charged/uncharged tRNA +- Base calling error frequencies +- Alignment statistics +- Remora signal metrics (if kmer table provided) +- Modkit modification calls and pileups + +## Configuration + +### Main Config Files + +- `config/config-base.yml`: Base configuration included by Snakefile + - Base calling model path + - Reference fasta + - Remora models and kmer tables + - Tool versions (dorado, modkit) + - Command-line options for tools (dorado, bwa, filters) + +- `config/samples.tsv`: Two-column TSV (no header) + - Column 1: Unique sample ID + - Column 2: Path to sequencing run folder containing pod5_pass/pod5_fail/pod5 subdirectories + +- `config/config-test.yml`: Overrides base config for test data + +### Important Config Parameters + +- **opts.bam_filter**: Controls full-length read filtering (`-5 24 -3 23 -s` requires 24bp 5' adapter, 23bp 3' adapter, positive strand) +- **opts.dorado**: Includes `--modified-bases pseU m5C inosine_m6A --emit-moves` for modification calling and move tables +- **opts.bwa**: RNA-optimized alignment parameters (`-W 13 -k 6 -T 20 -x ont2d`) +- **ml-threshold**: Currently hardcoded in `get_cca_trna_cpm` rule (200-255 = charged, <200 = uncharged) + +## Charged vs Uncharged Classification + +The pipeline uses Remora machine learning to classify charging state: + +- **Model Location**: `remora_cca_classifier` config parameter (resources/models/cca_classifier.pt) +- **Signal Region**: 6-nucleotide kmer spanning CCA 3' end + first 3 adapter bases (CCAGGC) +- **ML Tag**: Classification score stored in BAM ML tag (0-255 scale) +- **Threshold**: ML ≥ 200 = charged, ML < 200 = uncharged (adjustable in get_cca_trna_cpm rule) +- **Filtering**: Only full-length tRNA reads with proper 5'/3' adapters are classified + +## Development + +### Adding New Rules + +When adding new Snakemake rules: +- Place processing rules in `aatrnaseq-process.smk` +- Place summary/analysis rules in `aatrnaseq-summaries.smk` +- Add helper functions to `common.smk` +- Reference Python scripts should go in `workflow/scripts/` +- Update `pipeline_outputs()` if rule produces final outputs + +### Testing Changes + +```bash +# Always test with dry run first +snakemake -n --configfile=config/config-test.yml + +# Run specific rule +snakemake --configfile=config/config-test.yml + +# Force rerun of specific rule +snakemake --forcerun --configfile=config/config-test.yml +``` + +### Cluster Resource Configuration + +Modify `cluster/lsf/config.yaml` to adjust: +- Memory requirements per rule (mem_mb) +- GPU queue assignments +- LSF project tags +- Maximum concurrent jobs + +Rules requiring GPU (rebasecall, classify_charging) must set: +- lsf_queue: "gpu" +- lsf_extra: "-gpu num=1:j_exclusive=yes" +- ngpu: 1 + +## Important Notes + +- The pipeline requires Snakemake 8.0+ +- Dorado and modkit are installed by the pipeline (not via conda) to specific versions +- The pipeline tracks git commit ID for reproducibility (see `get_pipeline_commit()`) +- CUDA_VISIBLE_DEVICES is passed through to dorado if set +- Pod5 files are searched recursively in pod5_pass/pod5_fail/pod5 subdirectories +- The ML threshold for charging classification is currently hardcoded in the `get_cca_trna_cpm` rule From 99405a53f29ce17ae639add8a8c358eb7a959585 Mon Sep 17 00:00:00 2001 From: Laura White Date: Thu, 6 Nov 2025 10:17:13 -0700 Subject: [PATCH 41/42] Add comprehensive CI/CD build and test checks from claude code web (#68) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Add comprehensive CI/CD build and test checks This commit implements a complete testing and continuous integration infrastructure for the aa-tRNA-seq-pipeline: New CI/CD Components: - GitHub Actions CI workflow (.github/workflows/ci.yml) - Snakemake syntax validation with dry-run - Pipeline integration testing (merge_pods rule) - Configuration file validation - Automated tool setup (dorado, modkit) - GitHub Actions Lint workflow (.github/workflows/lint.yml) - Snakemake formatting checks (snakefmt) - Python code quality checks (black, flake8) - Markdown linting - YAML linting - Pre-commit hooks configuration (.pre-commit-config.yaml) - Automatic code quality checks before commits - Python formatting and linting - Snakemake formatting - General file hygiene checks - Local test script (.tests/run_local_tests.sh) - Quick validation script for local development - Checks Snakemake installation and syntax - Validates configuration files - Verifies directory structure Documentation: - Comprehensive testing guide (.github/TESTING.md) - CI/CD workflow documentation - Local testing instructions - Troubleshooting guide - Contributing guidelines - Updated README with CI status badges The CI workflow runs on all pushes and pull requests to main branches and claude/** branches. GPU-intensive rules are not tested in CI due to runner limitations but can be tested locally or on HPC clusters. * Fix CI workflow by replacing deprecated Mambaforge with Miniforge3 The Mambaforge variant is no longer available (404 error), causing the Snakemake Syntax Check to fail. Updated to use Miniforge3 as recommended by the setup-miniconda action warning. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --------- Co-authored-by: Claude Co-authored-by: lkwhite --- .github/TESTING.md | 222 +++++++++++++++++++++++++++++++++++++ .github/workflows/ci.yml | 154 +++++++++++++++++++++++++ .github/workflows/lint.yml | 97 ++++++++++++++++ .pre-commit-config.yaml | 36 ++++++ .tests/run_local_tests.sh | 65 +++++++++++ README.md | 3 + 6 files changed, 577 insertions(+) create mode 100644 .github/TESTING.md create mode 100644 .github/workflows/ci.yml create mode 100644 .github/workflows/lint.yml create mode 100644 .pre-commit-config.yaml create mode 100755 .tests/run_local_tests.sh diff --git a/.github/TESTING.md b/.github/TESTING.md new file mode 100644 index 0000000..e813733 --- /dev/null +++ b/.github/TESTING.md @@ -0,0 +1,222 @@ +# Testing and CI/CD Documentation + +This document describes the testing infrastructure and continuous integration (CI/CD) setup for the aa-tRNA-seq-pipeline. + +## Overview + +The pipeline includes several automated checks to ensure code quality and functionality: + +1. **CI Workflow** (`.github/workflows/ci.yml`) - Syntax validation and integration tests +2. **Lint Workflow** (`.github/workflows/lint.yml`) - Code quality and formatting checks +3. **Local Test Script** (`.tests/run_local_tests.sh`) - Run tests locally before pushing +4. **Pre-commit Hooks** (`.pre-commit-config.yaml`) - Automatic checks before git commits + +## CI Workflow + +The main CI workflow runs on every push and pull request. It includes three jobs: + +### 1. Syntax Check +- Sets up Mambaforge and the conda environment +- Verifies Snakemake installation +- Runs `snakemake -n` (dry-run) to validate workflow syntax + +### 2. Pipeline Integration Test +- Downloads test data +- Sets up dorado and modkit tools +- Downloads the dorado basecalling model +- Runs the `merge_pods` rule as a basic integration test +- Validates that output files are created + +### 3. Configuration Validation +- Validates YAML syntax of all config files +- Checks that sample files exist and have content +- Verifies required directory structure + +## Lint Workflow + +The linting workflow checks code quality and formatting: + +### 1. Snakemake Linting +- Uses `snakefmt` to check Snakemake file formatting + +### 2. Python Linting +- **black**: Checks Python code formatting +- **flake8**: Checks for Python code quality issues +- Both checks are non-blocking (won't fail the build) + +### 3. Markdown Linting +- Uses `markdownlint` to check Markdown file formatting +- Non-blocking + +### 4. YAML Linting +- Uses `yamllint` to check YAML file formatting +- Non-blocking + +## Running Tests Locally + +### Quick Syntax Check + +Run the local test script to verify basic functionality: + +```bash +# Activate the conda environment first +mamba activate aatrnaseqpipe + +# Run the test script +bash .tests/run_local_tests.sh +``` + +This script checks: +- Snakemake installation +- Config file validity +- Sample file existence +- Workflow syntax (dry-run) +- Required directory structure + +### Full Integration Test + +To run a complete test of the pipeline: + +```bash +# 1. Download test data (first time only) +bash .tests/dl_test_data.sh + +# 2. Set up tools (first time only) +snakemake setup_dorado dorado_model setup_modkit --configfile=config/config-test.yml + +# 3. Run the pipeline with test data +snakemake --cores 2 --configfile=config/config-test.yml +``` + +### Running Specific Tests + +```bash +# Syntax check only +snakemake -n --configfile=config/config-test.yml + +# Run a specific rule +snakemake merge_pods --configfile=config/config-test.yml --cores 1 + +# Force rerun of a specific rule +snakemake --forcerun --configfile=config/config-test.yml +``` + +## Pre-commit Hooks + +Pre-commit hooks automatically check your code before each commit. + +### Installation + +```bash +# Install pre-commit +pip install pre-commit + +# Install the git hooks +pre-commit install +``` + +### Usage + +Once installed, the hooks will run automatically on `git commit`. To run manually: + +```bash +# Run on all files +pre-commit run --all-files + +# Run on staged files only +pre-commit run +``` + +### What Gets Checked + +- Trailing whitespace removal +- End-of-file fixer +- YAML syntax validation +- Large file detection (max 1MB) +- Merge conflict detection +- Line ending normalization +- Python code formatting (black) +- Python linting (flake8) +- Snakemake formatting (snakefmt) + +## CI Status Badges + +The README includes badges showing the status of CI workflows: + +- [![CI](https://github.com/rnabioco/aa-tRNA-seq-pipeline/actions/workflows/ci.yml/badge.svg)](https://github.com/rnabioco/aa-tRNA-seq-pipeline/actions/workflows/ci.yml) - Main CI tests +- [![Lint](https://github.com/rnabioco/aa-tRNA-seq-pipeline/actions/workflows/lint.yml/badge.svg)](https://github.com/rnabioco/aa-tRNA-seq-pipeline/actions/workflows/lint.yml) - Code quality checks + +## Troubleshooting + +### CI Failures + +If the CI workflow fails: + +1. Check the GitHub Actions logs for detailed error messages +2. Run the same commands locally to reproduce the issue +3. Use the local test script to verify basic functionality +4. Ensure all config files are valid YAML +5. Verify that test data paths are correct in `config/samples-test.tsv` + +### Common Issues + +**Conda environment not activated:** +```bash +Error: No conda environment is activated. +Solution: mamba activate aatrnaseqpipe +``` + +**Missing test data:** +```bash +Error: Test data not found +Solution: bash .tests/dl_test_data.sh +``` + +**Snakemake syntax errors:** +```bash +Solution: Check the error message and fix the syntax in the indicated file +Run: snakemake -n --configfile=config/config-test.yml +``` + +**Pre-commit hook failures:** +```bash +Solution: Fix the issues reported by the hooks +Run: pre-commit run --all-files +Bypass (not recommended): git commit --no-verify +``` + +## GPU Tests + +Note: The CI pipeline does not run GPU-intensive rules (`rebasecall`, `classify_charging`) as GitHub Actions runners don't have GPU access. These rules should be tested locally on a system with GPU access or on the HPC cluster. + +To test GPU rules locally: + +```bash +# Ensure CUDA is available +nvidia-smi + +# Run specific GPU rule +snakemake rebasecall --configfile=config/config-test.yml --cores 1 +snakemake classify_charging --configfile=config/config-test.yml --cores 1 +``` + +## Contributing + +When contributing to this repository: + +1. Install pre-commit hooks: `pre-commit install` +2. Run local tests before pushing: `bash .tests/run_local_tests.sh` +3. Ensure all CI checks pass on your pull request +4. Fix any linting issues reported by the Lint workflow + +## Future Enhancements + +Potential improvements to the testing infrastructure: + +- [ ] Add unit tests for Python scripts in `workflow/scripts/` +- [ ] Add integration tests for individual Snakemake rules +- [ ] Set up test data generation/validation +- [ ] Add code coverage reporting +- [ ] Add performance benchmarking +- [ ] Create Docker container for reproducible testing +- [ ] Add GPU-enabled CI runners for full pipeline testing diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..5590b62 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,154 @@ +name: CI + +on: + push: + branches: [main, master, develop, claude/**] + pull_request: + branches: [main, master, develop] + workflow_dispatch: + +jobs: + syntax-check: + name: Snakemake Syntax Check + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup Miniforge + uses: conda-incubator/setup-miniconda@v3 + with: + miniforge-variant: Miniforge3 + miniforge-version: latest + activate-environment: aatrnaseqpipe + use-mamba: true + + - name: Cache conda environment + uses: actions/cache@v3 + with: + path: /usr/share/miniconda3/envs/aatrnaseqpipe + key: conda-${{ runner.os }}-${{ hashFiles('workflow/envs/aatrnaseqpipe-env.yml') }} + + - name: Install dependencies + shell: bash -l {0} + run: | + mamba env update -n aatrnaseqpipe -f workflow/envs/aatrnaseqpipe-env.yml + + - name: Verify Snakemake installation + shell: bash -l {0} + run: | + conda activate aatrnaseqpipe + snakemake --version + + - name: Snakemake dry-run (syntax check) + shell: bash -l {0} + run: | + conda activate aatrnaseqpipe + snakemake -n --configfile=config/config-test.yml + + pipeline-test: + name: Pipeline Integration Test + runs-on: ubuntu-latest + needs: syntax-check + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup Miniforge + uses: conda-incubator/setup-miniconda@v3 + with: + miniforge-variant: Miniforge3 + miniforge-version: latest + activate-environment: aatrnaseqpipe + use-mamba: true + + - name: Cache conda environment + uses: actions/cache@v3 + with: + path: /usr/share/miniconda3/envs/aatrnaseqpipe + key: conda-${{ runner.os }}-${{ hashFiles('workflow/envs/aatrnaseqpipe-env.yml') }} + + - name: Install dependencies + shell: bash -l {0} + run: | + mamba env update -n aatrnaseqpipe -f workflow/envs/aatrnaseqpipe-env.yml + + - name: Download test data + shell: bash -l {0} + run: | + bash .tests/dl_test_data.sh + + - name: Setup dorado + shell: bash -l {0} + run: | + conda activate aatrnaseqpipe + snakemake setup_dorado --cores 1 --configfile=config/config-test.yml + + - name: Download dorado model + shell: bash -l {0} + run: | + conda activate aatrnaseqpipe + snakemake dorado_model --cores 1 --configfile=config/config-test.yml + + - name: Setup modkit + shell: bash -l {0} + run: | + conda activate aatrnaseqpipe + snakemake setup_modkit --cores 1 --configfile=config/config-test.yml + + - name: Run pipeline test (non-GPU rules only) + shell: bash -l {0} + run: | + conda activate aatrnaseqpipe + # Run merge_pods rule as a basic test (doesn't require GPU) + snakemake merge_pods --cores 2 --configfile=config/config-test.yml + + - name: Validate outputs + shell: bash -l {0} + run: | + # Check that expected output files were created + if [ ! -d ".tests/outputs" ]; then + echo "Error: Output directory not created" + exit 1 + fi + echo "Pipeline test completed successfully" + + config-validation: + name: Configuration Validation + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Check config files syntax + run: | + # Validate YAML syntax + python3 -c "import yaml; yaml.safe_load(open('config/config-base.yml'))" + python3 -c "import yaml; yaml.safe_load(open('config/config-test.yml'))" + python3 -c "import yaml; yaml.safe_load(open('config/config-preprint.yml'))" + echo "All config files are valid YAML" + + - name: Check samples files + run: | + # Validate samples TSV files exist and have content + if [ ! -f "config/samples-test.tsv" ]; then + echo "Error: samples-test.tsv not found" + exit 1 + fi + if [ ! -s "config/samples-test.tsv" ]; then + echo "Error: samples-test.tsv is empty" + exit 1 + fi + echo "Sample files validated" + + - name: Check required directories + run: | + # Check that required directories exist + directories=("workflow" "workflow/rules" "workflow/scripts" "config" "resources" "cluster") + for dir in "${directories[@]}"; do + if [ ! -d "$dir" ]; then + echo "Error: Required directory $dir not found" + exit 1 + fi + done + echo "All required directories exist" diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..b7f6f78 --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,97 @@ +name: Lint + +on: + push: + branches: [main, master, develop, claude/**] + pull_request: + branches: [main, master, develop] + workflow_dispatch: + +jobs: + snakemake-lint: + name: Snakemake Linting + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup Python + uses: actions/setup-python@v4 + with: + python-version: '3.11' + + - name: Install Snakemake + run: | + pip install snakemake snakefmt + + - name: Run snakefmt check + run: | + snakefmt --check workflow/ + + python-lint: + name: Python Linting + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup Python + uses: actions/setup-python@v4 + with: + python-version: '3.11' + + - name: Install linting tools + run: | + pip install black flake8 pylint + + - name: Run black check + continue-on-error: true + run: | + black --check workflow/scripts/ || echo "Black formatting issues found (non-blocking)" + + - name: Run flake8 + continue-on-error: true + run: | + flake8 workflow/scripts/ --max-line-length=100 --ignore=E203,W503 || echo "Flake8 issues found (non-blocking)" + + markdown-lint: + name: Markdown Linting + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup Node.js + uses: actions/setup-node@v4 + with: + node-version: '18' + + - name: Install markdownlint + run: | + npm install -g markdownlint-cli + + - name: Run markdownlint + continue-on-error: true + run: | + markdownlint '**/*.md' --ignore node_modules || echo "Markdown linting issues found (non-blocking)" + + yaml-lint: + name: YAML Linting + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup Python + uses: actions/setup-python@v4 + with: + python-version: '3.11' + + - name: Install yamllint + run: | + pip install yamllint + + - name: Run yamllint + continue-on-error: true + run: | + yamllint -d "{extends: default, rules: {line-length: {max: 120}, document-start: disable}}" config/ .github/ || echo "YAML linting issues found (non-blocking)" diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..423a895 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,36 @@ +# Pre-commit hooks for aa-tRNA-seq-pipeline +# Install: pip install pre-commit && pre-commit install +# Run manually: pre-commit run --all-files + +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.5.0 + hooks: + - id: trailing-whitespace + - id: end-of-file-fixer + - id: check-yaml + args: ['--allow-multiple-documents'] + - id: check-added-large-files + args: ['--maxkb=1000'] + - id: check-merge-conflict + - id: mixed-line-ending + + - repo: https://github.com/psf/black + rev: 23.12.1 + hooks: + - id: black + language_version: python3 + files: ^workflow/scripts/.*\.py$ + + - repo: https://github.com/pycqa/flake8 + rev: 7.0.0 + hooks: + - id: flake8 + args: ['--max-line-length=100', '--ignore=E203,W503'] + files: ^workflow/scripts/.*\.py$ + + - repo: https://github.com/snakemake/snakefmt + rev: v0.10.0 + hooks: + - id: snakefmt + files: ^workflow/.*\.(smk|Snakefile)$ diff --git a/.tests/run_local_tests.sh b/.tests/run_local_tests.sh new file mode 100755 index 0000000..994df8d --- /dev/null +++ b/.tests/run_local_tests.sh @@ -0,0 +1,65 @@ +#!/bin/bash +# Local test script for aa-tRNA-seq-pipeline +# This script runs the same checks as the CI pipeline locally + +set -e + +echo "========================================" +echo "Running local tests for aa-tRNA-seq-pipeline" +echo "========================================" + +# Check if conda/mamba environment is activated +if [[ -z "${CONDA_DEFAULT_ENV}" ]]; then + echo "Error: No conda environment is activated." + echo "Please activate the aatrnaseqpipe environment first:" + echo " mamba activate aatrnaseqpipe" + exit 1 +fi + +echo "" +echo "[1/5] Checking Snakemake installation..." +if ! command -v snakemake &> /dev/null; then + echo "Error: Snakemake is not installed in the current environment" + exit 1 +fi +echo "✓ Snakemake version: $(snakemake --version)" + +echo "" +echo "[2/5] Validating configuration files..." +python3 -c "import yaml; yaml.safe_load(open('config/config-base.yml'))" || exit 1 +python3 -c "import yaml; yaml.safe_load(open('config/config-test.yml'))" || exit 1 +python3 -c "import yaml; yaml.safe_load(open('config/config-preprint.yml'))" || exit 1 +echo "✓ All config files are valid YAML" + +echo "" +echo "[3/5] Checking sample files..." +if [ ! -f "config/samples-test.tsv" ] || [ ! -s "config/samples-test.tsv" ]; then + echo "Error: samples-test.tsv is missing or empty" + exit 1 +fi +echo "✓ Sample files validated" + +echo "" +echo "[4/5] Running Snakemake dry-run (syntax check)..." +snakemake -n --configfile=config/config-test.yml || exit 1 +echo "✓ Snakemake dry-run successful" + +echo "" +echo "[5/5] Checking required directories..." +for dir in workflow workflow/rules workflow/scripts config resources cluster; do + if [ ! -d "$dir" ]; then + echo "Error: Required directory $dir not found" + exit 1 + fi +done +echo "✓ All required directories exist" + +echo "" +echo "========================================" +echo "All local tests passed! ✓" +echo "========================================" +echo "" +echo "To run the full pipeline test:" +echo " 1. Download test data: bash .tests/dl_test_data.sh" +echo " 2. Setup tools: snakemake setup_dorado dorado_model setup_modkit" +echo " 3. Run test: snakemake --cores 2 --configfile=config/config-test.yml" diff --git a/README.md b/README.md index 036881b..4027449 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,8 @@ # aa-tRNA-seq-pipeline +[![CI](https://github.com/rnabioco/aa-tRNA-seq-pipeline/actions/workflows/ci.yml/badge.svg)](https://github.com/rnabioco/aa-tRNA-seq-pipeline/actions/workflows/ci.yml) +[![Lint](https://github.com/rnabioco/aa-tRNA-seq-pipeline/actions/workflows/lint.yml/badge.svg)](https://github.com/rnabioco/aa-tRNA-seq-pipeline/actions/workflows/lint.yml) + A Snakemake pipeline to process ONT aa-tRNA-seq data. Downstream analysis to generate figures for the initial preprint can be found at: [https://github.com/rnabioco/aa-tRNA-seq](https://github.com/rnabioco/aa-tRNA-seq) From 677a72f21d7e7f2056018c5c761b5d59d8a92e12 Mon Sep 17 00:00:00 2001 From: Laura White Date: Fri, 7 Nov 2025 20:30:41 -0700 Subject: [PATCH 42/42] Add Claude Code session start hook for automated development setup (#69) This completes the test and build check infrastructure by adding: - SessionStart hook that automatically sets up the conda environment - Validates Snakemake installation and config files - Installs pre-commit hooks if not present - Runs quick syntax checks on session start - Comprehensive documentation in .claude/SETUP.md The hook ensures developers have a properly configured environment before starting work, reducing setup friction and catching issues early. Co-authored-by: Claude --- .claude/README.md | 39 ++++++ .claude/SETUP.md | 254 +++++++++++++++++++++++++++++++++++++ .claude/hooks/SessionStart | 111 ++++++++++++++++ 3 files changed, 404 insertions(+) create mode 100644 .claude/README.md create mode 100644 .claude/SETUP.md create mode 100755 .claude/hooks/SessionStart diff --git a/.claude/README.md b/.claude/README.md new file mode 100644 index 0000000..b457d53 --- /dev/null +++ b/.claude/README.md @@ -0,0 +1,39 @@ +# Claude Code Configuration + +This directory contains configuration and hooks for Claude Code development sessions. + +## Session Start Hook + +The `hooks/SessionStart` script runs automatically when you start a Claude Code session. It: + +- Verifies conda/mamba is available +- Checks if the `aatrnaseqpipe` environment exists (creates it if not) +- Activates the environment +- Validates Snakemake installation +- Validates configuration files +- Sets up pre-commit hooks +- Runs a quick Snakemake syntax check + +This ensures your development environment is properly configured before starting work. + +## Manual Testing + +You can run the session start hook manually: + +```bash +bash .claude/hooks/SessionStart +``` + +## Development Workflow + +1. **Before making changes**: Run `bash .tests/run_local_tests.sh` to verify everything works +2. **During development**: Use `snakemake -n --configfile=config/config-test.yml` for syntax checks +3. **Before committing**: Pre-commit hooks will automatically run linting and formatting +4. **After committing**: GitHub Actions will run full CI/CD checks + +## Learn More + +- Project documentation: `CLAUDE.md` +- Local test script: `.tests/run_local_tests.sh` +- CI/CD workflows: `.github/workflows/` +- Pre-commit config: `.pre-commit-config.yaml` diff --git a/.claude/SETUP.md b/.claude/SETUP.md new file mode 100644 index 0000000..c37392c --- /dev/null +++ b/.claude/SETUP.md @@ -0,0 +1,254 @@ +# Complete Test and Build Check Setup + +This document describes the comprehensive test and build infrastructure for the aa-tRNA-seq-pipeline. + +## ✅ What's Installed + +### 1. GitHub Actions CI/CD + +**Location**: `.github/workflows/` + +#### CI Pipeline (`ci.yml`) +Runs on: push to main/master/develop/claude/**, pull requests, manual trigger + +- **Syntax Check Job** + - Sets up conda environment with Snakemake + - Validates Snakemake syntax with dry-run + +- **Pipeline Integration Test Job** + - Downloads test data + - Sets up dorado and modkit tools + - Runs merge_pods rule (non-GPU test) + - Validates output directory creation + +- **Configuration Validation Job** + - Validates YAML syntax in all config files + - Checks samples.tsv files exist and have content + - Verifies required directory structure + +#### Lint Pipeline (`lint.yml`) +Runs on: push to main/master/develop/claude/**, pull requests, manual trigger + +- **Snakemake Linting**: snakefmt format checking +- **Python Linting**: black and flake8 on workflow/scripts/ +- **Markdown Linting**: markdownlint on all .md files +- **YAML Linting**: yamllint on config/ and .github/ + +### 2. Pre-commit Hooks + +**Location**: `.pre-commit-config.yaml` + +Automatically runs before each commit: +- Trailing whitespace removal +- End-of-file fixing +- YAML syntax validation +- Large file detection (>1MB warning) +- Merge conflict detection +- Line ending normalization +- Black formatting for Python scripts +- Flake8 linting for Python scripts +- Snakefmt formatting for Snakemake files + +**Installation**: +```bash +pip install pre-commit +pre-commit install +``` + +### 3. Local Test Script + +**Location**: `.tests/run_local_tests.sh` + +Runs the same checks as CI locally: +1. Verifies Snakemake installation +2. Validates configuration files (YAML syntax) +3. Checks sample files exist +4. Runs Snakemake dry-run (syntax check) +5. Verifies required directory structure + +**Usage**: +```bash +# Requires active conda environment +mamba activate aatrnaseqpipe +bash .tests/run_local_tests.sh +``` + +### 4. Claude Code Session Hooks + +**Location**: `.claude/hooks/SessionStart` + +Automatically runs when starting a Claude Code session: +- Verifies conda/mamba availability +- Creates aatrnaseqpipe environment if missing +- Activates the environment +- Validates Snakemake installation +- Checks config file syntax +- Installs pre-commit hooks if not present +- Runs quick Snakemake syntax check +- Displays helpful development commands + +## 📋 Development Workflow + +### Starting a New Session + +When you start working with Claude Code, the SessionStart hook automatically: +1. Sets up your environment +2. Validates configurations +3. Shows available commands + +### Before Making Changes + +```bash +# Run full local test suite +bash .tests/run_local_tests.sh + +# Or just syntax check +snakemake -n --configfile=config/config-test.yml +``` + +### During Development + +```bash +# Test specific rule +snakemake -n --configfile=config/config-test.yml + +# Run linting manually +pre-commit run --all-files + +# Format Snakemake files +snakefmt workflow/ + +# Format Python scripts +black workflow/scripts/ +``` + +### Before Committing + +Pre-commit hooks run automatically. If they fail: +```bash +# Fix issues and re-stage +git add + +# Or skip hooks (not recommended) +git commit --no-verify +``` + +### After Pushing + +GitHub Actions automatically runs: +- All syntax checks +- Integration tests +- All linters +- Configuration validation + +Check status at: `https://github.com///actions` + +## 🧪 Testing Levels + +### Level 1: Quick Validation (< 30 seconds) +```bash +# Config and syntax only +python3 -c "import yaml; yaml.safe_load(open('config/config-test.yml'))" +snakemake -n --configfile=config/config-test.yml +``` + +### Level 2: Local Tests (~ 2 minutes) +```bash +# Full local test suite +bash .tests/run_local_tests.sh +``` + +### Level 3: Integration Test (~ 10-15 minutes) +```bash +# Download test data (first time only) +bash .tests/dl_test_data.sh + +# Setup tools (first time only) +snakemake setup_dorado dorado_model setup_modkit --cores 1 --configfile=config/config-test.yml + +# Run non-GPU pipeline rules +snakemake merge_pods --cores 2 --configfile=config/config-test.yml +``` + +### Level 4: Full Pipeline (requires GPU) +```bash +# Run complete pipeline with test data +snakemake --cores 12 --configfile=config/config-test.yml + +# Or submit to LSF cluster +bsub < run-test.sh +``` + +## 🔍 Continuous Integration Details + +### What Gets Tested on Every Push + +1. **Snakemake syntax**: Dry-run validation +2. **Config files**: YAML syntax validation +3. **Sample files**: Existence and content checks +4. **Directory structure**: Required directories present +5. **Code formatting**: Black, flake8, snakefmt +6. **Documentation**: Markdown linting + +### What Gets Tested on Pull Requests + +All of the above, plus: +- Integration test with test data +- Tool setup (dorado, modkit) +- Pipeline execution (non-GPU rules) + +### What's NOT Tested in CI + +Due to GitHub Actions limitations: +- GPU-intensive rules (rebasecall, classify_charging) +- Full end-to-end pipeline +- LSF cluster execution + +These should be tested locally or on your cluster before merging. + +## 🛠️ Maintenance + +### Updating Dependencies + +```bash +# Update conda environment +mamba env update -n aatrnaseqpipe -f workflow/envs/aatrnaseqpipe-env.yml + +# Update pre-commit hooks +pre-commit autoupdate +``` + +### Adding New Tests + +1. **Local tests**: Edit `.tests/run_local_tests.sh` +2. **CI tests**: Edit `.github/workflows/ci.yml` +3. **Linting**: Edit `.pre-commit-config.yaml` and `.github/workflows/lint.yml` + +### Troubleshooting + +**Pre-commit hooks failing?** +```bash +# Run manually to see detailed errors +pre-commit run --all-files + +# Update hooks to latest versions +pre-commit autoupdate +``` + +**CI failing but local tests pass?** +- Check GitHub Actions logs for specific errors +- Ensure all files are committed +- Verify config files are valid YAML + +**SessionStart hook not running?** +- Check if Claude Code session hooks are enabled +- Run manually: `bash .claude/hooks/SessionStart` +- Ensure file is executable: `chmod +x .claude/hooks/SessionStart` + +## 📚 Additional Resources + +- **Project Overview**: `CLAUDE.md` +- **CI Workflows**: `.github/workflows/` +- **Pre-commit Config**: `.pre-commit-config.yaml` +- **Test Scripts**: `.tests/` +- **Snakemake Docs**: https://snakemake.readthedocs.io/ diff --git a/.claude/hooks/SessionStart b/.claude/hooks/SessionStart new file mode 100755 index 0000000..ef1b530 --- /dev/null +++ b/.claude/hooks/SessionStart @@ -0,0 +1,111 @@ +#!/bin/bash +# Claude Code Session Start Hook +# This script runs automatically when starting a Claude Code session +# It verifies the development environment is properly configured + +set -e + +echo "==========================================" +echo "🧬 aa-tRNA-seq-pipeline Development Setup" +echo "==========================================" + +# Function to print colored output +print_status() { + echo "✓ $1" +} + +print_error() { + echo "✗ $1" +} + +print_info() { + echo "ℹ $1" +} + +# Check if conda is available +if ! command -v conda &> /dev/null && ! command -v mamba &> /dev/null; then + print_error "Conda/Mamba not found. Please install miniforge or miniconda." + exit 1 +fi +print_status "Conda/Mamba available" + +# Check if environment exists +if conda env list | grep -q "aatrnaseqpipe"; then + print_status "Environment 'aatrnaseqpipe' exists" +else + print_info "Environment 'aatrnaseqpipe' not found. Creating it now..." + mamba env create -f workflow/envs/aatrnaseqpipe-env.yml || { + print_error "Failed to create environment" + exit 1 + } + print_status "Environment created successfully" +fi + +# Activate environment if not already activated +if [[ "${CONDA_DEFAULT_ENV}" != "aatrnaseqpipe" ]]; then + print_info "Activating aatrnaseqpipe environment..." + eval "$(conda shell.bash hook)" + conda activate aatrnaseqpipe || { + print_error "Failed to activate environment. Please run: mamba activate aatrnaseqpipe" + exit 1 + } + print_status "Environment activated" +else + print_status "Environment 'aatrnaseqpipe' already activated" +fi + +# Verify Snakemake installation +if command -v snakemake &> /dev/null; then + SNAKEMAKE_VERSION=$(snakemake --version) + print_status "Snakemake ${SNAKEMAKE_VERSION} installed" +else + print_error "Snakemake not found in environment" + exit 1 +fi + +# Quick config validation +echo "" +echo "Validating configuration files..." +if python3 -c "import yaml; yaml.safe_load(open('config/config-base.yml'))" 2>/dev/null && \ + python3 -c "import yaml; yaml.safe_load(open('config/config-test.yml'))" 2>/dev/null; then + print_status "Config files are valid" +else + print_error "Config file validation failed" + exit 1 +fi + +# Check if pre-commit is installed +if command -v pre-commit &> /dev/null; then + print_status "Pre-commit hooks available" + if [ ! -f .git/hooks/pre-commit ]; then + print_info "Installing pre-commit hooks..." + pre-commit install + print_status "Pre-commit hooks installed" + fi +else + print_info "Pre-commit not installed. Install with: pip install pre-commit" +fi + +# Quick syntax check +echo "" +echo "Running Snakemake syntax check..." +if snakemake -n --configfile=config/config-test.yml > /dev/null 2>&1; then + print_status "Snakemake syntax check passed" +else + print_error "Snakemake syntax check failed. Run for details: snakemake -n --configfile=config/config-test.yml" +fi + +echo "" +echo "==========================================" +echo "✓ Development environment ready!" +echo "==========================================" +echo "" +echo "Available commands:" +echo " • Run local tests: bash .tests/run_local_tests.sh" +echo " • Syntax check: snakemake -n --configfile=config/config-test.yml" +echo " • Dry run: snakemake -n --cores 1 --configfile=config/config-test.yml" +echo " • Format code: pre-commit run --all-files" +echo " • Full test setup: bash .tests/dl_test_data.sh" +echo "" +echo "Documentation: See CLAUDE.md for project details" +echo ""