# HG changeset patch # User Steve Losh # Date 1791901914 14400 # Node ID 97e37a4c1138a20119648cf1029400f30bf14963 # Parent c76aecc93001ad11a050538486542fe2b5680faa More diff -r c76aecc93001 -r 97e37a4c1138 bin/convert-to-mp3 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bin/convert-to-mp3 Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,8 @@ +#!/usr/bin/env bash + +set -euo pipefail + +input_file="$1" +output_file="$(echo "$1" | sed -Ee 's/[.][^.]+$/.mp3/')" + +ffmpeg -i "$input_file" -q:a 2 "$output_file" diff -r c76aecc93001 -r 97e37a4c1138 bin/vimmv --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bin/vimmv Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,66 @@ +#!/usr/bin/env bash +set -eu + +# Lists the current directory's files in Vim, so you can edit it and save to rename them +# USAGE: vimv [file1 file2] +# https://github.com/thameera/vimv + +declare -r FILENAMES_FILE=$(mktemp "${TMPDIR:-/tmp}/vimv.XXXXXX") + +trap '{ rm -f "${FILENAMES_FILE}" ; }' EXIT + +safeMove() { + local src="$1" + local dest="$2" + mkdir -p "$(dirname "$dest")" + if [ -e "$dest" ]; then + echo "WARN: Can't rename '$src' -> '$dest', destination exists!" >&2 + return 1 + fi + if git ls-files --error-unmatch "$src" > /dev/null 2>&1; then + git mv -- "$src" "$dest" + else + mv -n -- "$src" "$dest" + fi +} + +if [ $# -ne 0 ]; then + src=( "$@" ) +else + IFS=$'\r\n' GLOBIGNORE='*' command eval 'src=($(ls -1A))' +fi + +for ((i=0;i<${#src[@]};++i)); do + echo "${src[i]}" >> "${FILENAMES_FILE}" +done + +${EDITOR:-vi} "${FILENAMES_FILE}" + +IFS=$'\r\n' GLOBIGNORE='*' command eval 'dest=($(cat "${FILENAMES_FILE}"))' +IFS=$'\r\n' GLOBIGNORE='*' command eval 'dest_unique=($(cat "${FILENAMES_FILE}" | sort -u))' + +if (( ${#src[@]} != ${#dest[@]} )); then + echo "WARN: Number of files changed. Did you delete a line by accident? Aborting.." >&2 + exit 1 +fi + +if (( ${#dest[@]} != ${#dest_unique[@]} )); then + echo "WARN: Destination filenames are not unique! Aborting.." >&2 + exit 1 +fi + +declare -i count=0 +EXT="vimv-tmp-$(date +%s)-${RANDOM}" +for ((i=0;i<${#src[@]};++i)); do + if [ "${src[i]}" != "${dest[i]}" ]; then + safeMove "${src[i]}" "${dest[i]}.${EXT}" && ((++count)) + fi +done + +for ((i=0;i<${#src[@]};++i)); do + if [ "${src[i]}" != "${dest[i]}" ]; then + safeMove "${dest[i]}.${EXT}" "${dest[i]}" || : resume on error + fi +done + +echo "$count" files renamed. diff -r c76aecc93001 -r 97e37a4c1138 bin/xx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bin/xx Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,5 @@ +#!/usr/bin/env bash + +set -euo pipefail + +x txt diff -r c76aecc93001 -r 97e37a4c1138 fish/functions/vimhist.fish --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fish/functions/vimhist.fish Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,9 @@ +function vimhist -d "Edit history with Vim, copy the result." + set tmpfile (mktemp vimhist.XXXXXX) + history -n 20 --reverse > "$tmpfile" + vim -c 'set ft=fish' "$tmpfile" + cat "$tmpfile" | pbcopy + rm "$tmpfile" +end + + diff -r c76aecc93001 -r 97e37a4c1138 htoprc --- a/htoprc Thu Jul 16 11:24:25 2026 -0400 +++ b/htoprc Tue Oct 13 10:31:54 2026 -0400 @@ -3,7 +3,7 @@ htop_version=3.2.2 config_reader_min_version=3 fields=0 48 17 18 39 2 46 47 49 1 -hide_kernel_threads=0 +hide_kernel_threads=1 hide_userland_threads=1 hide_running_in_container=0 shadow_other_users=0 diff -r c76aecc93001 -r 97e37a4c1138 lisp/sav.lisp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/sav.lisp Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,426 @@ +(eval-when (:compile-toplevel :load-toplevel :execute) + (ql:quickload '(:adopt :str :alexandria :losh :iterate :boots) :silent t)) + +(defpackage :sav + (:use :cl :iterate :losh) + (:export :toplevel :*ui*)) + +(in-package :sav) + + +;;;; Configuration ------------------------------------------------------------ + +(defparameter *score-match* 1) +(defparameter *score-mismatch* -1.5) +(defparameter *score-gap* -2) + + +;;;; Utilities ---------------------------------------------------------------- +(defclass* seq () + (label bases (annotations :initform nil))) + + +(defun make-buffer (&key initial-contents + (element-type t) + (initial-capacity (max 64 (length initial-contents)))) + (let ((buffer (make-array initial-capacity + :element-type element-type + :adjustable t + :fill-pointer (length initial-contents)))) + (when initial-contents + (replace buffer initial-contents)) + buffer)) + +(defun buffer-push (buffer element) + (vector-push-extend element buffer) + element) + +(defun buffer-append (buffer sequence) + (let* ((l1 (length buffer)) + (l2 (length sequence)) + (needed (+ l1 l2))) + (when (< (array-total-size buffer) needed) + (adjust-array buffer (max needed (* l1 2)))) + (setf (fill-pointer buffer) needed) + (replace buffer sequence :start1 l1) + sequence)) + +(defmacro-clause (BUFFERING expr &optional + APPEND (append nil) + INTO (var iterate::*result-var*) + INITIAL-CONTENTS (initial-contents '()) + ELEMENT-TYPE (element-type t)) + `(progn + (with ,var = (make-buffer :initial-contents ,initial-contents + :element-type ,element-type)) + (,(if append 'buffer-append 'buffer-push) ,var ,expr))) + + +(defun read-fasta (stream) + (iterate + (with label = nil) + (case (peek-char nil stream nil :eof) + (:eof (finish)) + (#\Newline (read-char stream)) + ((#\> #\@) (if label + (finish) + (setf label (subseq (read-line stream) 1)))) + (t (buffering (read-line stream) :into data + :append t + :element-type 'character))) + (finally (return (make-instance 'seq :label label :bases data))))) + +(defun read-fastq (stream) + (let ((header-line (read-line stream)) + (sequence-line (read-line stream)) + (sep-line (read-line stream)) + (quality-line (read-line stream))) + (declare (ignore sep-line quality-line)) + (make-instance 'seq + :label (subseq header-line 1) + :bases sequence-line))) + +(defun read-bare (stream) + (make-instance 'seq :label "Query" :bases (read-line stream))) + +(defun read-fast* (stream) + (ecase (peek-char nil stream nil :eof) + (:eof nil) + ((#\A #\C #\T #\G #\n #\a #\c #\t #\g #\n) (read-bare stream)) + (#\> (read-fasta stream)) + (#\@ (read-fastq stream)))) + +(defun parse-file (path) + (with-open-file (s path) + (iterate + (for seq = (read-fast* s)) + (while seq) + (collect seq)))) + +(defun read-data (path &key default-name) + ;; todo handle - + (declare (ignore default-name)) + (parse-file path)) + +(defun dna-reverse (seq) + (reverse seq)) + +(defun dna-complement (seq) + (map (type-of seq) (lambda (ch) + (ecase ch + (#\A #\T) + (#\T #\A) + (#\C #\G) + (#\G #\C) + (#\N #\N))) + seq)) + +(defun dna-reverse-complement (seq) + (dna-reverse (dna-complement seq))) + + +;;;; Alignment ---------------------------------------------------------------- +(defun make-smith-waterman-grid (rows cols) + (make-array (list rows cols) :initial-element 0)) + +(defun extract-smith-waterman-path (grid prev best-row best-col) + (iterate (for coord + :first (cons best-row best-col) + :then (aref prev (car coord) (cdr coord))) + (until (< (aref grid (car coord) (cdr coord)) 0.1f0)) + (collect (cons (1- (car coord)) (1- (cdr coord))) :at start))) + +(defun print-grid (seq1 seq2 grid &key (pad 4)) + (flet ((print-padded (seq) + (map nil (lambda (el) (format t "~V@A" pad el)) seq)) + (row-of (array row) ; ugly hack, but just for debugging… + (iterate + (for col :below (array-dimension array 1)) + (collect (aref array row col))))) + (print-padded " ") + (print-padded seq1) + (terpri) + (iterate + (for row :below (array-dimension grid 0)) + (print-padded (list (if (plusp row) + (aref seq2 (1- row)) + #\Space))) + (print-padded (row-of grid row)) + (terpri)))) + +(defun render-annotations (seq pad gaps anns) + (if (null anns) + (list (list) "") + (let ((chars "123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") + (n 0) + (legend (list))) + (flet ((annotate (text) + (let ((ch (aref chars n))) + (incf n) + (push (format nil "~A - ~A" ch text) legend) + ch))) + (iterate + (for i :from 0 :below (length seq)) + (collect (if-found (text (gethash i anns)) + (annotate text) + #\space) + :into line :result-type 'string) + (loop :while (eql i (car gaps)) + :do (progn (collect #\space :into line :result-type 'string) + (pop gaps))) + (returning (list (nreverse legend) + (str:concat (str:repeat pad " ") line)))))))) + +(defclass* alignment () + (lab1 seq1 pad1 leg1 ann1 + m padm + lab2 seq2 pad2 leg2 ann2)) + +(defun render-alignment (rseq qseq path) + (iterate + (with seq1 = (bases rseq)) + (with seq2 = (bases qseq)) + (with (lo2 . lo1) = (first path)) + (with (hi2 . hi1) = (car (last path))) + (with gaps1 = (list)) + (with gaps2 = (list)) + (with pad1 = (if (>= lo1 lo2) 0 (- lo2 lo1))) + (with pad2 = (if (>= lo2 lo1) 0 (- lo1 lo2))) + (with padM = (max lo1 lo2)) + (with p1 = -1) + (with p2 = -1) + (for (i2 . i1) :in path) + (for ch1 = (aref seq1 i1)) + (for ch2 = (aref seq2 i2)) + (collect (cond ((or (= i1 p1) (= i2 p2)) #\g) + ((char= ch1 ch2) #\|) + (t #\x)) + :into m :result-type 'string) + (collect (if (> i1 p1) + (progn (setf p1 i1) + ch1) + (progn (push i1 gaps1) + #\-)) + :into l1 :result-type 'string) + (collect (if (> i2 p2) + (progn (setf p2 i2) + ch2) + (progn (push i2 gaps2) + #\-)) + :into l2 :result-type 'string) + (returning + (destructuring-bind (leg1 ann1) (render-annotations seq1 pad1 gaps1 (annotations rseq)) + (destructuring-bind (leg2 ann2) (render-annotations seq2 pad2 gaps2 (annotations qseq)) + (make-instance 'alignment + :lab1 (label rseq) + :seq1 (str:concat (str:repeat pad1 " ") + (subseq seq1 0 lo1) + l1 + (subseq seq1 (1+ hi1) nil)) + :pad1 pad1 :leg1 leg1 :ann1 ann1 + :m (str:concat (str:repeat padM " ") + m) + :padm padm + :lab2 (label qseq) + :seq2 (str:concat (str:repeat pad2 " ") + (subseq seq2 0 lo2) + l2 + (subseq seq2 (1+ hi2) nil)) + :pad2 pad2 :leg2 leg2 :ann2 ann2)))))) + + +;; (defun print-alignment (seq1 seq2 path &optional ann1 ann2) +;; (let ((a (render-alignment seq1 seq2 path ann1 ann2))) +;; (map nil #'write-line (leg1 a)) +;; (when (leg1 a) (write-line "")) +;; (write-line (ann1 a)) +;; (write-line (seq1 a)) +;; (write-line (m a)) +;; (write-line (seq2 a)) +;; (write-line (ann2 a)) +;; (when (leg2 a) (write-line "")) +;; (map nil #'write-line (leg2 a)))) + +(defun smith-waterman (rseq qseq) + (iterate + (with seq1 = (coerce (bases rseq) 'simple-base-string)) + (with seq2 = (coerce (bases qseq) 'simple-base-string)) + (with best-row = 0) + (with best-col = 0) + (with best-score = 0) + (with rows = (1+ (length seq2))) + (with cols = (1+ (length seq1))) + (with grid = (make-smith-waterman-grid rows cols)) + (with prev = (make-array (list rows cols) :initial-element nil)) + (for row :from 1 :below rows) + (for ch2 :in-string seq2) + (iterate + (for col :from 1 :below cols) + (for ch1 :in-string seq1) + (for row-1 = (1- row)) + (for col-1 = (1- col)) + (for match = (+ (aref grid row-1 col-1) + (if (char= ch1 ch2) *score-match* *score-mismatch*))) + (for gap-1 = (+ (aref grid row col-1) *score-gap*)) + (for gap-2 = (+ (aref grid row-1 col) *score-gap*)) + (for best = (max match gap-1 gap-2 0)) + (setf (aref grid row col) best + (aref prev row col) (cond ((= best 0) nil) + ((= best match) (cons row-1 col-1)) + ((= best gap-1) (cons row col-1)) + ((= best gap-2) (cons row-1 col)))) + (if (> best best-score) + (setf best-score best + best-row row + best-col col))) + (returning + (let ((path (extract-smith-waterman-path grid prev best-row best-col))) + (render-alignment rseq qseq path))))) + + +;;;; UI ----------------------------------------------------------------------- +(defparameter *selected-index* 0) +(defparameter *r-seqs* nil) +(defparameter *q-seq* nil) +(defparameter *x-offset* 5) + +(defparameter *alignments* nil) + +(defconstant +attr/match+ (boots:attr :bold t :fg (boots:rgb 50 255 50))) +(defconstant +attr/mismatch+ (boots:attr :bold t :fg (boots:rgb 255 50 50))) +(defconstant +attr/not-selected+ (boots:attr :bold t)) +(defconstant +attr/selected+ (boots:attr :bold t :fg (boots:rgb 0 0 0) :bg (boots:rgb 255 255 255))) + +(defun draw/status (pad) + (boots:draw pad 0 0 "SAV v1")) + +(defun draw/alignment (index pad &aux (alignment (nth index *alignments*))) + (boots:draw pad 0 0 (format nil "~A vs ~A" (lab1 alignment) (lab2 alignment)) + (if (= index *selected-index*) +attr/selected+ +attr/not-selected+)) + (boots:draw pad *x-offset* 2 (seq1 alignment)) + (boots:draw pad *x-offset* 4 (seq2 alignment)) + (loop :for i :from 0 + :for ch :across (m alignment) + :do (multiple-value-bind (c a) (case ch + (#\| (values #\| +attr/match+)) + (#\g (values #\space +attr/mismatch+)) + (#\x (values #\x +attr/mismatch+)) + (#\space (values nil nil))) + (when c + (boots:draw pad (+ *x-offset* i) 2 (aref (seq1 alignment) i) a) + (boots:draw pad (+ *x-offset* i) 3 c a) + (boots:draw pad (+ *x-offset* i) 4 (aref (seq2 alignment) i) a))))) + +(defun press-any-key () + (boots:read-event) + nil) + +(defun recompute-alignments () + (setf *alignments* (loop :for r-seq :in *r-seqs* + :collect (smith-waterman r-seq *q-seq*)))) + +(defun incf-selected (delta) + (zapf *selected-index* (mod (+ % delta) (length *alignments*)))) + +(defun swap-alignments (a b) + (let ((ai (mod a (length *alignments*))) + (bi (mod b (length *alignments*)))) + (rotatef (nth ai *alignments*) + (nth bi *alignments*)) + (setf *selected-index* bi))) + +(defun ui/main () + (setf (boots:root boots:*screen*) + (boots:make-stack + :children (list* + (boots:make-canvas :height 1 :draw #'draw/status) + (loop :for a :in *alignments* + :for i :from 0 + :collect (boots:make-canvas + :border-top t :fill-char #\space + :draw (curry #'draw/alignment i)))))) + (loop + (boots:redraw) + (boots:event-case (boots:read-event) + ((#\k :up) (incf-selected -1)) + ((#\j :down) (incf-selected 1)) + (#\K (swap-alignments *selected-index* (1- *selected-index*))) + (#\J (swap-alignments *selected-index* (1+ *selected-index*))) + ((#\h :left) (incf *x-offset* 10)) + ((#\l :right) (decf *x-offset* 10)) + ((#\escape #\q) (return))))) + + + +;;;; Entry Point -------------------------------------------------------------- +(defun run% (r-seqs q-seq) + (boots/terminals/ansi:with-ansi-terminal (terminal :truecolor t) + (boots:with-screen (boots:*screen* terminal) + (boots:with-light-borders + (let* ((*r-seqs* r-seqs) + (*q-seq* q-seq)) + (recompute-alignments) + (ui/main)))))) + +(defun run (reference-path query-path) + (let ((r-seqs (read-data reference-path :default-name "Reference")) + (q-seqs (read-data query-path :default-name "Query"))) + (run% r-seqs (first q-seqs)))) + + +(defun r () + (run "/home/sjl/scratch/sav-foo.fasta" "/home/sjl/scratch/sav-bar.fasta")) + + +;;;; User Interface ----------------------------------------------------------- +(defparameter *option/help* + (adopt:make-option 'help + :help "Display help and exit." + :long "help" + :short #\h + :reduce (constantly t))) + +(defparameter *option/version* + (adopt:make-option 'version + :help "Display version information and exit." + :long "version" + :reduce (constantly t))) + +(adopt:define-string *help-text* + "sav is a Sequence Alignment Visualizer") + +(defparameter *examples* + '(("Align the clipboard to the L1HS consensus sequence:" + . "sav path/to/l1.fa <(pbpaste)"))) + +(defparameter *ui* + (adopt:make-interface + :name "sav" + :usage "[OPTIONS] REF QUERY" + :summary "sequence alignment visualizer" + :help *help-text* + :examples *examples* + :contents (list + *option/help* + *option/version*))) + + +(defun toplevel () + (adopt::quit-on-ctrl-c () + (multiple-value-bind (arguments options) (adopt:parse-options-or-exit *ui*) + (when (gethash 'help options) + (adopt:print-help-and-exit *ui*)) + (let () ; todo options + (handler-case + (progn + (assert (= (length arguments) 2) () "REF and QUERY arguments are both required.") + (run (first arguments) (second arguments))) + (error (e) (adopt:print-error-and-exit e))))))) + + + +#; Scratch -------------------------------------------------------------------- + +;; (run "~/scratch/sav-foo.fasta" "~/scratch/sav-bar.fasta" +;; (alexandria:alist-hash-table '()) +;; (alexandria:alist-hash-table '())) diff -r c76aecc93001 -r 97e37a4c1138 refs/aluya-ont.fasta --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/refs/aluya-ont.fasta Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,16 @@ +>AluYa5 Normal Short-Way +CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +>AluYa5 Normal Long-Way +TGGCGGGATCTCGGCTCACTGCAAGCTCCGCCTCCCGGGTTCACGCCATTCTCCTGCCTCAGCCTCCCAAGTAGCTGGGACTACAGGCGCCCGCCACTACGCCCGGCTAATTTTTTGTATTTTTAGTAGAGACGGGGTTTCACCGTTTTAG +>AluYa5 Inverted Short-Way +GACGTGAGGTCGGACCCGCTGTCTCGCTCTGAGGCAGAGTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT +>AluYa5 Inverted Long-Way +ACCGCCCTAGAGCCGAGTGACGTTCGAGGCGGAGGGCCCAAGTGCGGTAAGAGGACGGAGTCGGAGGGTTCATCGACCCTGATGTCCGCGGGCGGTGATGCGGGCCGATTAAAAAACATAAAAATCATCTCTGCCCCAAAGTGGCAAAATC +>Nanopore Adapter Top Strand +CCTGTACTTCGTTCAGTTACGTATTGCT +>Nanopore Adapter Bottom Strand +GCAATACGTAACTGAACGAAGTACAGG +>Full AluYa5 +GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACGAGGTCAGGAGATCGAGACCATCCCGGCTAAAACGGTGAAACCCCGTCTCTACTAAAAATACAAAAAATTAGCCGGGCGTAGTGGCGGGCGCCTGTAGTCCCAGCTACTTGGGAGGCTGAGGCAGGAGAATGGCGTGAACCCGGGAGGCGGAGCTTGCAGTGAGCCGAGATCCCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +>Full AluYa5 (Revcomp) +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGGGATCTCGGCTCACTGCAAGCTCCGCCTCCCGGGTTCACGCCATTCTCCTGCCTCAGCCTCCCAAGTAGCTGGGACTACAGGCGCCCGCCACTACGCCCGGCTAATTTTTTGTATTTTTAGTAGAGACGGGGTTTCACCGTTTTAGCCGGGATGGTCTCGATCTCCTGACCTCGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCC diff -r c76aecc93001 -r 97e37a4c1138 refs/aluyb-ont.fasta --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/refs/aluyb-ont.fasta Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,16 @@ +>AluYb8 Normal Short-Way +GTCCGGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +>AluYb8 Normal Long-Way +TGCGGACTGCAGTGGCGCAATCTCGGCTCACTGCAAGCTCCGCTTCCCGGGTTCACGCCATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGACTACAGGCGCCCGCCACCGCGCCCGGCTAATTTTTTGTATTTTTAGTAGAGACGGGGTT +>AluYb8 Inverted Short-Way +CAGGCCGGACCCGCTGTCTCGCTCTGAGGCAGAGTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT +>AluYb8 Inverted Long-Way +ACGCCTGACGTCACCGCGTTAGAGCCGAGTGACGTTCGAGGCGAAGGGCCCAAGTGCGGTAAGAGGACGGAGTCGGAGGGCTCATCGACCCTGATGTCCGCGGGCGGTGGCGCGGGCCGATTAAAAAACATAAAAATCATCTCTGCCCCAA +>Nanopore Adapter Top Strand +CCTGTACTTCGTTCAGTTACGTATTGCT +>Nanopore Adapter Bottom Strand +GCAATACGTAACTGAACGAAGTACAGG +>Full AluYb8 +GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGTGGATCATGAGGTCAGGAGATCGAGACCATCCTGGCTAACAAGGTGAAACCCCGTCTCTACTAAAAATACAAAAAATTAGCCGGGCGCGGTGGCGGGCGCCTGTAGTCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATGGCGTGAACCCGGGAAGCGGAGCTTGCAGTGAGCCGAGATTGCGCCACTGCAGTCCGCAGTCCGGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +>Full AluYb8 (Revcomp) +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCCGGACTGCGGACTGCAGTGGCGCAATCTCGGCTCACTGCAAGCTCCGCTTCCCGGGTTCACGCCATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGACTACAGGCGCCCGCCACCGCGCCCGGCTAATTTTTTGTATTTTTAGTAGAGACGGGGTTTCACCTTGTTAGCCAGGATGGTCTCGATCTCCTGACCTCATGATCCACCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCC diff -r c76aecc93001 -r 97e37a4c1138 refs/l1-ont.fasta --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/refs/l1-ont.fasta Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,16 @@ +>L1.3 Normal Short-Way +GCTAGATGACACATTAGTGGGTGCAGCGCACCAGCATGGCACATGTATACATATGTAACTAACCTGCACAATGTGCACATGTACCCTAAAACTTAGAGTATAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +>L1.3 Normal Long-Way +ATTAGGTATATCTCCCAATGCTATCCCTCCCCCCTCCCCCGACCCCACCACAGTCCCCAGAGTGTGATATTCCCCTTCCTGTGTCCATGTGATCTCATTGTTCAATTCCCACCTATGAGTGAGAATATGCGGTGTTTGGTTTTTTGTTCT +>L1.3 Inverted Short-Way +CGATCTACTGTGTAATCACCCACGTCGCGTGGTCGTACCGTGTACATATGTATACATTGATTGGACGTGTTACACGTGTACATGGGATTTTGAATCTCATATTATTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT +>L1.3 Inverted Long-Way +TAATCCATATAGAGGGTTACGATAGGGAGGGGGGAGGGGGCTGGGGTGGTGTCAGGGGTCTCACACTATAAGGGGAAGGACACAGGTACACTAGAGTAACAAGTTAAGGGTGGATACTCACTCTTATACGCCACAAACCAAAAAACAAGA +>Nanopore Adapter Top Strand +CCTGTACTTCGTTCAGTTACGTATTGCT +>Nanopore Adapter Bottom Strand +GCAATACGTAACTGAACGAAGTACAGG +>Full L1.3 +GGGGGAGGAGCCAAGATGGCCGAATAGGAACAGCTCCGGTCTACAGCTCCCAGCGTGAGCGACGCAGAAGACGGTGATTTCTGCATTTCCATCTGAGGTACCGGGTTCATCTCACTAGGGAGTGCCAGACAGTGGGCGCAGGCCAGTGTGTGTGCGCACCGTGCGCGAGCCGAAGCAGGGCGAGGCATTGCCTCACCTGGGAAGCGCAAGGGGTCAGGGAGTTCCCTTTCTGAGTCAAAGAAAGGGGTGACGGTCGCACCTGGAAAATCGGGTCACTCCCACCCGAATATTGCGCTTTTCAGACCGGCTTAAGAAACGGCGCACCACGAGACTATATCCCACACCTGGCTCGGAGGGTCCTACGCCCACGGAATCTCGCTGATTGCTAGCACAGCAGTCTGAGATCAAACTGCAAGGCGGCAACGAGGCTGGGGGAGGGGCGCCCGCCATTGCCCAGGCTTGCTTAGGTAAACAAAGCAGCCGGGAAGCTCGAACTGGGTGGAGCCCACCACAGCTCAAGGAGGCCTGCCTGCCTCTGTAGGCTCCACCTCTGGGGGCAGGGCACAGACAAACAAAAAGACAGCAGTAACCTCTGCAGACTTAAGTGTCCCTGTCTGACAGCTTTGAAGAGAGCAGTGGTTCTCCCAGCACGCAGCTGGAGATCTGAGAACGGGCAGACAGACTGCCTCCTCAAGTGGGTCCCTGACTCCTGACCCCCGAGCAGCCTAACTGGGAGGCACCCCCCAGCAGGGGCACACTGACACCTCACACGGCAGGGTATTCCAACAGACCTGCAGCTGAGGGTCCTGTCTGTTAGAAGGAAAACTAACAACCAGAAAGGACATCTACACCGAAAACCCATCTGTACATCACCATCATCAAAGACCAAAAGTAGATAAAACCACAAAGATGGGGAAAAAACAGAACAGAAAAACTGGAAACTCTAAAACGCAGAGCGCCTCTCCTCCTCCAAAGGAACGCAGTTCCTCACCAGCAACGGAACAAAGCTGGATGGAGAATGATTTTGACGAGCTGAGAGAAGAAGGCTTCAGACGATCAAATTACTCTGAGCTACGGGAGGACATTCAAACCAAAGGCAAAGAAGTTGAAAACTTTGAAAAAAATTTAGAAGAATGTATAACTAGAATAACCAATACAGAGAAGTGCTTAAAGGAGCTGATGGAGCTGAAAACCAAGGCTCGAGAACTACGTGAAGAATGCAGAAGCCTCAGGAGCCGATGCGATCAACTGGAAGAAAGGGTATCAGCAATGGAAGATGAAATGAATGAAATGAAGCGAGAAGGGAAGTTTAGAGAAAAAAGAATAAAAAGAAATGAGCAAAGCCTCCAAGAAATATGGGACTATGTGAAAAGACCAAATCTACGTCTGATTGGTGTACCTGAAAGTGATGTGGAGAATGGAACCAAGTTGGAAAACACTCTGCAGGATATTATCCAGGAGAACTTCCCCAATCTAGCAAGGCAGGCCAACGTTCAGATTCAGGAAATACAGAGAACGCCACAAAGATACTCCTCGAGAAGAGCAACTCCAAGACACATAATTGTCAGATTCACCAAAGTTGAAATGAAGGAAAAAATGTTAAGGGCAGCCAGAGAGAAAGGTCGGGTTACCCTCAAAGGAAAGCCCATCAGACTAACAGTGGATCTCTCGGCAGAAACCCTACAAGCCAGAAGAGAGTGGGGGCCAATATTCAACATTCTTAAAGAAAAGAATTTTCAACCCAGAATTTCATATCCAGCCAAACTAAGCTTCATAAGTGAAGGAGAAATAAAATACTTTATAGACAAGCAAATGTTGAGAGATTTTGTCACCACCAGGCCTGCCCTAAAAGAGCTCCTGAAGGAAGCGCTAAACATGGAAAGGAACAACCGGTACCAGCCGCTGCAAAATCATGCCAAAATGTAAAGACCATCGAGACTAGGAAGAAACTGCATCAACTAATGAGCAAAATCACCAGCTAACATCATAATGACAGGATCAAATTCACACATAACAATATTAACTTTAAATATAAATGGACTAAATTCTGCAATTAAAAGACACAGACTGGCAAGTTGGATAAAGAGTCAAGACCCATCAGTGTGCTGTATTCAGGAAACCCATCTCACGTGCAGAGACACACATAGGCTCAAAATAAAAGGATGGAGGAAGATCTACCAAGCCAATGGAAAACAAAAAAAGGCAGGGGTTGCAATCCTAGTCTCTGATAAAACAGACTTTAAACCAACAAAGATCAAAAGAGACAAAGAAGGCCATTACATAATGGTAAAGGGATCAATTCAACAAGAGGAGCTAACTATCCTAAATATTTATGCACCCAATACAGGAGCACCCAGATTCATAAAGCAAGTCCTCAGTGACCTACAAAGAGACTTAGACTCCCACACATTAATAATGGGAGACTTTAACACCCCACTGTCAACATTAGACAGATCAACGAGACAGAAAGTCAACAAGGATACCCAGGAATTGAACTCAGCTCTGCACCAAGCAGACCTAATAGACATCTACAGAACTCTCCACCCCAAATCAACAGAATATACCTTTTTTTCAGCACCACACCACACCTATTCCAAAATTGACCACATAGTTGGAAGTAAAGCTCTCCTCAGCAAATGTAAAAGAACAGAAATTATAACAAACTATCTCTCAGACCACAGTGCAATCAAACTAGAACTCAGGATTAAGAATCTCACTCAAAGCCGCTCAACTACATGGAAACTGAACAACCTGCTCCTGAATGACTACTGGGTACATAACGAAATGAAGGCAGAAATAAAGATGTTCTTTGAAACCAACGAGAACAAAGACACCACATACCAGAATCTCTGGGACGCATTCAAAGCAGTGTGTAGAGGGAAATTTATAGCACTAAATGCCTACAAGAGAAAGCAGGAAAGATCCAAAATTGACACCCTAACATCACAATTAAAAGAACTAGAAAAGCAAGAGCAAACACATTCAAAAGCTAGCAGAAGGCAAGAAATAACTAAAATCAGAGCAGAACTGAAGGAAATAGAGACACAAAAAACCCTTCAAAAAATCAATGAATCCAGGAGCTGGTTTTTTGAAAGGATCAACAAAATTGATAGACCGCTAGCAAGACTAATAAAGAAAAAAAGAGAGAAGAATCAAATAGACACAATAAAAAATGATAAAGGGGATATCACCACCGATCCCACAGAAATACAAACTACCATCAGAGAATACTACAAACACCTCTACGCAAATAAACTAGAAAATCTAGAAGAAATGGATACATTCCTCGACACATACACTCTCCCAAGACTAAACCAGGAAGAAGTTGAATCTCTGAATAGACCAATAACAGGCTCTGAAATTGTGGCAATAATCAATAGTTTACCAACCAAAAAGAGTCCAGGACCAGATGGATTCACAGCCGAATTCTACCAGAGGTACATGGAGGAACTGGTACCATTCCTTCTGAAACTATTCCAATCAATAGAAAAAGAGGGAATCCTCCCTAACTCATTTTATGAGGCCAGCATCATTCTGATACCAAAGCCGGGCAGAGACACAACCAAAAAAGAGAATTTTAGACCAATATCCTTGATGAACATTGATGCAAAAATCCTCAATAAAATACTGGCAAACCGAATCCAGCAGCACATCAAAAAGCTTATCCACCATGATCAAGTGGGCTTCATCCCTGGGATGCAAGGCTGGTTCAATATACGCAAATCAATAAATGTAATCCAGCATATAAACAGAGCCAAAGACAAAAACCACATGATTATCTCAATAGATGCAGAAAAAGCCTTTGACAAAATTCAACAACCCTTCATGCTAAAAACTCTCAATAAATTAGGTATTGATGGGACGTATTTCAAAATAATAAGAGCTATCTATGACAAACCCACAGCCAATATCATACTGAATGGGCAAAAACTGGAAGCATTCCCTTTGAAAACCGGCACAAGACAGGGATGCCCTCTCTCACCGCTCCTATTCAACATAGTGTTGGAAGTTCTGGCCAGGGCAATCAGGCAGGAGAAGGAAATAAAGGGTATTCAATTAGGAAAAGAGGAAGTCAAATTGTCCCTGTTTGCAGACGACATGATTGTATATCTAGAAAACCCCATCGTCTCAGCCCAAAATCTCCTTAAGCTGATAAGCAACTTCAGCAAAGTCTCAGGATACAAAATCAATGTACAAAAATCACAAGCATTCTTATACACCAACAACAGACAAACAGAGAGCCAAATCATGGGTGAACTCCCATTCGTAATTGCTTCAAAGAGAATAAAATACCTAGGAATCCAACTTACAAGGGATGTGAAGGACCTCTTCAAGGAGAACTACAAACCACTGCTCAAGGAAATAAAAGAGGACACAAACAAATGGAAGAACATTCCATGCTCATGGGTAGGAAGAATCAATATCGTGAAAATGGCCATACTGCCCAAGGTAATTTACAGATTCAATGCCATCCCCATCAAGCTACCAATGACTTTCTTCACAGAATTGGAAAAAACTACTTTAAAGTTCATATGGAACCAAAAAAGAGCCCGCATTGCCAAGTCAATCCTAAGCCAAAAGAACAAAGCTGGAGGCATCACACTACCTGACTTCAAACTATACTACAAGGCTACAGTAACCAAAACAGCATGGTACTGGTACCAAAACAGAGATATAGATCAATGGAACAGAACAGAGCCCTCAGAAATAATGCCGCATATCTACAACTATCTGATCTTTGACAAACCTGAGAAAAACAAGCAATGGGGAAAGGATTCCCTATTTAATAAATGGTGCTGGGAAAACTGGCTAGCCATATGTAGAAAGCTGAAACTGGATCCCTTCCTTACACCTTATACAAAAATCAATTCAAGATGGATTAAAGATTTAAACGTTAAACCTAAAACCATAAAAACCCTAGAAGAAAACCTAGGCATTACCATTCAGGACATAGGCGTGGGCAAGGACTTCATGTCCAAAACACCAAAAGCAATGGCAACAAAAGACAAAATTGACAAATGGGATCTAATTAAACTAAAGAGCTTCTGCACAGCAAAAGAAACTACCATCAGAGTGAACAGGCAACCTACAACATGGGAGAAAATTTTCGCAACCTACTCATCTGACAAAGGGCTAATATCCAGAATCTACAATGAACTTAAACAAATTTACAAGAAAAAAACAAACAACCCCATCAAAAAGTGGGCGAAGGACATGAACAGACACTTCTCAAAAGAAGACATTTATGCAGCCAAAAAACACATGAAGAAATGCTCATCATCACTGGCCATCAGAGAAATGCAAATCAAAACCACTATGAGATATCATCTCACACCAGTTAGAATGGCAATCATTAAAAAGTCAGGAAACAACAGGTGCTGGAGAGGATGCGGAGAAATAGGAACACTTTTACACTGTTGGTGGGACTGTAAACTAGTTCAACCATTGTGGAAGTCAGTGTGGCGATTCCTCAGGGATCTAGAACTAGAAATACCATTTGACCCAGCCATCCCATTACTGGGTATATACCCAAATGAGTATAAATCATGCTGCTATAAAGACACATGCACACGTATGTTTATTGCGGCACTATTCACAATAGCAAAGACTTGGAACCAACCCAAATGTCCAACAATGATAGACTGGATTAAGAAAATGTGGCACATATACACCATGGAATACTATGCAGCCATAAAAAATGATGAGTTCATATCCTTTGTAGGGACATGGATGAAATTGGAAACCATCATTCTCAGTAAACTATCGCAAGAACAAAAAACCAAACACCGCATATTCTCACTCATAGGTGGGAATTGAACAATGAGATCACATGGACACAGGAAGGGGAATATCACACTCTGGGGACTGTGGTGGGGTCGGGGGAGGGGGGAGGGATAGCATTGGGAGATATACCTAATGCTAGATGACACATTAGTGGGTGCAGCGCACCAGCATGGCACATGTATACATATGTAACTAACCTGCACAATGTGCACATGTACCCTAAAACTTAGAGTATAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +>Full L1.3 (Revcomp) +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTATTATACTCTAAGTTTTAGGGTACATGTGCACATTGTGCAGGTTAGTTACATATGTATACATGTGCCATGCTGGTGCGCTGCACCCACTAATGTGTCATCTAGCATTAGGTATATCTCCCAATGCTATCCCTCCCCCCTCCCCCGACCCCACCACAGTCCCCAGAGTGTGATATTCCCCTTCCTGTGTCCATGTGATCTCATTGTTCAATTCCCACCTATGAGTGAGAATATGCGGTGTTTGGTTTTTTGTTCTTGCGATAGTTTACTGAGAATGATGGTTTCCAATTTCATCCATGTCCCTACAAAGGATATGAACTCATCATTTTTTATGGCTGCATAGTATTCCATGGTGTATATGTGCCACATTTTCTTAATCCAGTCTATCATTGTTGGACATTTGGGTTGGTTCCAAGTCTTTGCTATTGTGAATAGTGCCGCAATAAACATACGTGTGCATGTGTCTTTATAGCAGCATGATTTATACTCATTTGGGTATATACCCAGTAATGGGATGGCTGGGTCAAATGGTATTTCTAGTTCTAGATCCCTGAGGAATCGCCACACTGACTTCCACAATGGTTGAACTAGTTTACAGTCCCACCAACAGTGTAAAAGTGTTCCTATTTCTCCGCATCCTCTCCAGCACCTGTTGTTTCCTGACTTTTTAATGATTGCCATTCTAACTGGTGTGAGATGATATCTCATAGTGGTTTTGATTTGCATTTCTCTGATGGCCAGTGATGATGAGCATTTCTTCATGTGTTTTTTGGCTGCATAAATGTCTTCTTTTGAGAAGTGTCTGTTCATGTCCTTCGCCCACTTTTTGATGGGGTTGTTTGTTTTTTTCTTGTAAATTTGTTTAAGTTCATTGTAGATTCTGGATATTAGCCCTTTGTCAGATGAGTAGGTTGCGAAAATTTTCTCCCATGTTGTAGGTTGCCTGTTCACTCTGATGGTAGTTTCTTTTGCTGTGCAGAAGCTCTTTAGTTTAATTAGATCCCATTTGTCAATTTTGTCTTTTGTTGCCATTGCTTTTGGTGTTTTGGACATGAAGTCCTTGCCCACGCCTATGTCCTGAATGGTAATGCCTAGGTTTTCTTCTAGGGTTTTTATGGTTTTAGGTTTAACGTTTAAATCTTTAATCCATCTTGAATTGATTTTTGTATAAGGTGTAAGGAAGGGATCCAGTTTCAGCTTTCTACATATGGCTAGCCAGTTTTCCCAGCACCATTTATTAAATAGGGAATCCTTTCCCCATTGCTTGTTTTTCTCAGGTTTGTCAAAGATCAGATAGTTGTAGATATGCGGCATTATTTCTGAGGGCTCTGTTCTGTTCCATTGATCTATATCTCTGTTTTGGTACCAGTACCATGCTGTTTTGGTTACTGTAGCCTTGTAGTATAGTTTGAAGTCAGGTAGTGTGATGCCTCCAGCTTTGTTCTTTTGGCTTAGGATTGACTTGGCAATGCGGGCTCTTTTTTGGTTCCATATGAACTTTAAAGTAGTTTTTTCCAATTCTGTGAAGAAAGTCATTGGTAGCTTGATGGGGATGGCATTGAATCTGTAAATTACCTTGGGCAGTATGGCCATTTTCACGATATTGATTCTTCCTACCCATGAGCATGGAATGTTCTTCCATTTGTTTGTGTCCTCTTTTATTTCCTTGAGCAGTGGTTTGTAGTTCTCCTTGAAGAGGTCCTTCACATCCCTTGTAAGTTGGATTCCTAGGTATTTTATTCTCTTTGAAGCAATTACGAATGGGAGTTCACCCATGATTTGGCTCTCTGTTTGTCTGTTGTTGGTGTATAAGAATGCTTGTGATTTTTGTACATTGATTTTGTATCCTGAGACTTTGCTGAAGTTGCTTATCAGCTTAAGGAGATTTTGGGCTGAGACGATGGGGTTTTCTAGATATACAATCATGTCGTCTGCAAACAGGGACAATTTGACTTCCTCTTTTCCTAATTGAATACCCTTTATTTCCTTCTCCTGCCTGATTGCCCTGGCCAGAACTTCCAACACTATGTTGAATAGGAGCGGTGAGAGAGGGCATCCCTGTCTTGTGCCGGTTTTCAAAGGGAATGCTTCCAGTTTTTGCCCATTCAGTATGATATTGGCTGTGGGTTTGTCATAGATAGCTCTTATTATTTTGAAATACGTCCCATCAATACCTAATTTATTGAGAGTTTTTAGCATGAAGGGTTGTTGAATTTTGTCAAAGGCTTTTTCTGCATCTATTGAGATAATCATGTGGTTTTTGTCTTTGGCTCTGTTTATATGCTGGATTACATTTATTGATTTGCGTATATTGAACCAGCCTTGCATCCCAGGGATGAAGCCCACTTGATCATGGTGGATAAGCTTTTTGATGTGCTGCTGGATTCGGTTTGCCAGTATTTTATTGAGGATTTTTGCATCAATGTTCATCAAGGATATTGGTCTAAAATTCTCTTTTTTGGTTGTGTCTCTGCCCGGCTTTGGTATCAGAATGATGCTGGCCTCATAAAATGAGTTAGGGAGGATTCCCTCTTTTTCTATTGATTGGAATAGTTTCAGAAGGAATGGTACCAGTTCCTCCATGTACCTCTGGTAGAATTCGGCTGTGAATCCATCTGGTCCTGGACTCTTTTTGGTTGGTAAACTATTGATTATTGCCACAATTTCAGAGCCTGTTATTGGTCTATTCAGAGATTCAACTTCTTCCTGGTTTAGTCTTGGGAGAGTGTATGTGTCGAGGAATGTATCCATTTCTTCTAGATTTTCTAGTTTATTTGCGTAGAGGTGTTTGTAGTATTCTCTGATGGTAGTTTGTATTTCTGTGGGATCGGTGGTGATATCCCCTTTATCATTTTTTATTGTGTCTATTTGATTCTTCTCTCTTTTTTTCTTTATTAGTCTTGCTAGCGGTCTATCAATTTTGTTGATCCTTTCAAAAAACCAGCTCCTGGATTCATTGATTTTTTGAAGGGTTTTTTGTGTCTCTATTTCCTTCAGTTCTGCTCTGATTTTAGTTATTTCTTGCCTTCTGCTAGCTTTTGAATGTGTTTGCTCTTGCTTTTCTAGTTCTTTTAATTGTGATGTTAGGGTGTCAATTTTGGATCTTTCCTGCTTTCTCTTGTAGGCATTTAGTGCTATAAATTTCCCTCTACACACTGCTTTGAATGCGTCCCAGAGATTCTGGTATGTGGTGTCTTTGTTCTCGTTGGTTTCAAAGAACATCTTTATTTCTGCCTTCATTTCGTTATGTACCCAGTAGTCATTCAGGAGCAGGTTGTTCAGTTTCCATGTAGTTGAGCGGCTTTGAGTGAGATTCTTAATCCTGAGTTCTAGTTTGATTGCACTGTGGTCTGAGAGATAGTTTGTTATAATTTCTGTTCTTTTACATTTGCTGAGGAGAGCTTTACTTCCAACTATGTGGTCAATTTTGGAATAGGTGTGGTGTGGTGCTGAAAAAAAGGTATATTCTGTTGATTTGGGGTGGAGAGTTCTGTAGATGTCTATTAGGTCTGCTTGGTGCAGAGCTGAGTTCAATTCCTGGGTATCCTTGTTGACTTTCTGTCTCGTTGATCTGTCTAATGTTGACAGTGGGGTGTTAAAGTCTCCCATTATTAATGTGTGGGAGTCTAAGTCTCTTTGTAGGTCACTGAGGACTTGCTTTATGAATCTGGGTGCTCCTGTATTGGGTGCATAAATATTTAGGATAGTTAGCTCCTCTTGTTGAATTGATCCCTTTACCATTATGTAATGGCCTTCTTTGTCTCTTTTGATCTTTGTTGGTTTAAAGTCTGTTTTATCAGAGACTAGGATTGCAACCCCTGCCTTTTTTTGTTTTCCATTGGCTTGGTAGATCTTCCTCCATCCTTTTATTTTGAGCCTATGTGTGTCTCTGCACGTGAGATGGGTTTCCTGAATACAGCACACTGATGGGTCTTGACTCTTTATCCAACTTGCCAGTCTGTGTCTTTTAATTGCAGAATTTAGTCCATTTATATTTAAAGTTAATATTGTTATGTGTGAATTTGATCCTGTCATTATGATGTTAGCTGGTGATTTTGCTCATTAGTTGATGCAGTTTCTTCCTAGTCTCGATGGTCTTTACATTTTGGCATGATTTTGCAGCGGCTGGTACCGGTTGTTCCTTTCCATGTTTAGCGCTTCCTTCAGGAGCTCTTTTAGGGCAGGCCTGGTGGTGACAAAATCTCTCAACATTTGCTTGTCTATAAAGTATTTTATTTCTCCTTCACTTATGAAGCTTAGTTTGGCTGGATATGAAATTCTGGGTTGAAAATTCTTTTCTTTAAGAATGTTGAATATTGGCCCCCACTCTCTTCTGGCTTGTAGGGTTTCTGCCGAGAGATCCACTGTTAGTCTGATGGGCTTTCCTTTGAGGGTAACCCGACCTTTCTCTCTGGCTGCCCTTAACATTTTTTCCTTCATTTCAACTTTGGTGAATCTGACAATTATGTGTCTTGGAGTTGCTCTTCTCGAGGAGTATCTTTGTGGCGTTCTCTGTATTTCCTGAATCTGAACGTTGGCCTGCCTTGCTAGATTGGGGAAGTTCTCCTGGATAATATCCTGCAGAGTGTTTTCCAACTTGGTTCCATTCTCCACATCACTTTCAGGTACACCAATCAGACGTAGATTTGGTCTTTTCACATAGTCCCATATTTCTTGGAGGCTTTGCTCATTTCTTTTTATTCTTTTTTCTCTAAACTTCCCTTCTCGCTTCATTTCATTCATTTCATCTTCCATTGCTGATACCCTTTCTTCCAGTTGATCGCATCGGCTCCTGAGGCTTCTGCATTCTTCACGTAGTTCTCGAGCCTTGGTTTTCAGCTCCATCAGCTCCTTTAAGCACTTCTCTGTATTGGTTATTCTAGTTATACATTCTTCTAAATTTTTTTCAAAGTTTTCAACTTCTTTGCCTTTGGTTTGAATGTCCTCCCGTAGCTCAGAGTAATTTGATCGTCTGAAGCCTTCTTCTCTCAGCTCGTCAAAATCATTCTCCATCCAGCTTTGTTCCGTTGCTGGTGAGGAACTGCGTTCCTTTGGAGGAGGAGAGGCGCTCTGCGTTTTAGAGTTTCCAGTTTTTCTGTTCTGTTTTTTCCCCATCTTTGTGGTTTTATCTACTTTTGGTCTTTGATGATGGTGATGTACAGATGGGTTTTCGGTGTAGATGTCCTTTCTGGTTGTTAGTTTTCCTTCTAACAGACAGGACCCTCAGCTGCAGGTCTGTTGGAATACCCTGCCGTGTGAGGTGTCAGTGTGCCCCTGCTGGGGGGTGCCTCCCAGTTAGGCTGCTCGGGGGTCAGGAGTCAGGGACCCACTTGAGGAGGCAGTCTGTCTGCCCGTTCTCAGATCTCCAGCTGCGTGCTGGGAGAACCACTGCTCTCTTCAAAGCTGTCAGACAGGGACACTTAAGTCTGCAGAGGTTACTGCTGTCTTTTTGTTTGTCTGTGCCCTGCCCCCAGAGGTGGAGCCTACAGAGGCAGGCAGGCCTCCTTGAGCTGTGGTGGGCTCCACCCAGTTCGAGCTTCCCGGCTGCTTTGTTTACCTAAGCAAGCCTGGGCAATGGCGGGCGCCCCTCCCCCAGCCTCGTTGCCGCCTTGCAGTTTGATCTCAGACTGCTGTGCTAGCAATCAGCGAGATTCCGTGGGCGTAGGACCCTCCGAGCCAGGTGTGGGATATAGTCTCGTGGTGCGCCGTTTCTTAAGCCGGTCTGAAAAGCGCAATATTCGGGTGGGAGTGACCCGATTTTCCAGGTGCGACCGTCACCCCTTTCTTTGACTCAGAAAGGGAACTCCCTGACCCCTTGCGCTTCCCAGGTGAGGCAATGCCTCGCCCTGCTTCGGCTCGCGCACGGTGCGCACACACACTGGCCTGCGCCCACTGTCTGGCACTCCCTAGTGAGATGAACCCGGTACCTCAGATGGAAATGCAGAAATCACCGTCTTCTGCGTCGCTCACGCTGGGAGCTGTAGACCGGAGCTGTTCCTATTCGGCCATCTTGGCTCCTCCCCC diff -r c76aecc93001 -r 97e37a4c1138 refs/ont-barcodes-1.fasta --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/refs/ont-barcodes-1.fasta Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,28 @@ +>Nanopore Adapter Top Strand +CCTGTACTTCGTTCAGTTACGTATTGCT +>Nanopore Adapter Bottom Strand +GCAATACGTAACTGAACGAAGTACAGG +>NB01 +AAGGTTAACACAAAGACACCGACAACTTTCTTCAGCACCT +>NB02 +AAGGTTAAACAGACGACTACAAACGGAATCGACAGCACCT +>NB03 +AAGGTTAACCTGGTAACTGGGACACAAGACTCCAGCACCT +>NB04 +AAGGTTAATAGGGAAACACGATAGAATCCGAACAGCACCT +>NB05 +AAGGTTAAAAGGTTACACAAACCCTGGACAAGCAGCACCT +>NB06 +AAGGTTAAGACTACTTTCTGCCTTTGCGAGAACAGCACCT +>NB07 +AAGGTTAAAAGGATTCATTCCCACGGTAACACCAGCACCT +>NB08 +AAGGTTAAACGTAACTTGGTTTGTTCCCTGAACAGCACCT +>NB09 +AAGGTTAAAACCAAGACTCGCTGTGCCTAGTTCAGCACCT +>NB10 +AAGGTTAAGAGAGGACAAAGGTTTCAACGCTTCAGCACCT +>NB11 +AAGGTTAATCCATTCCCTCCGATAGATGAAACCAGCACCT +>NB12 +AAGGTTAATCCGATTCTGCTTCTTTCTACCTGCAGCACCT diff -r c76aecc93001 -r 97e37a4c1138 refs/ont-barcodes-2.fasta --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/refs/ont-barcodes-2.fasta Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,28 @@ +>Nanopore Adapter Top Strand +CCTGTACTTCGTTCAGTTACGTATTGCT +>Nanopore Adapter Bottom Strand +GCAATACGTAACTGAACGAAGTACAGG +>NB13 +AAGGTTAAAGAACGACTTCCATACTCGTGTGACAGCACCT +>NB14 +AAGGTTAAAACGAGTCTCTTGGGACCCATAGACAGCACCT +>NB15 +AAGGTTAAAGGTCTACCTCGCTAACACCACTGCAGCACCT +>NB16 +AAGGTTAACGTCAACTGACAGTGGTTCGTACTCAGCACCT +>NB17 +AAGGTTAAACCCTCCAGGAAAGTACCTCTGATCAGCACCT +>NB18 +AAGGTTAACCAAACCCAACAACCTAGATAGGCCAGCACCT +>NB19 +AAGGTTAAGTTCCTCGTGCAGTGTCAAGAGATCAGCACCT +>NB20 +AAGGTTAATTGCGTCCTGTTACGAGAACTCATCAGCACCT +>NB21 +AAGGTTAAGAGCCTCTCATTGTCCGTTCTCTACAGCACCT +>NB22 +AAGGTTAAACCACTGCCATGTATCAAAGTACGCAGCACCT +>NB23 +AAGGTTAACTTACTACCCAGTGAACCTCCTCGCAGCACCT +>NB24 +AAGGTTAAGCATAGTTCTGCATGATGGGTTAGCAGCACCT diff -r c76aecc93001 -r 97e37a4c1138 remote/bin/vimmv --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/remote/bin/vimmv Tue Oct 13 10:31:54 2026 -0400 @@ -0,0 +1,1 @@ +../../bin/vimmv \ No newline at end of file diff -r c76aecc93001 -r 97e37a4c1138 stumpwm/bioinf.lisp --- a/stumpwm/bioinf.lisp Thu Jul 16 11:24:25 2026 -0400 +++ b/stumpwm/bioinf.lisp Tue Oct 13 10:31:54 2026 -0400 @@ -83,29 +83,78 @@ (defcommand kmerize (k) ((:integer "k: ")) (pbcopy (kmerized-string k (pbpaste)))) +(defun dna-complement (seq) + (map 'string (lambda (base) + (case base + (#\A #\T) + (#\C #\G) + (#\G #\C) + (#\T #\A) + (#\N #\N) + (#\a #\t) + (#\c #\g) + (#\g #\c) + (#\t #\a) + (#\n #\n) + (t #\?))) + seq)) + +(defun rna-complement (seq) + (map 'string (lambda (base) + (case base + (#\A #\U) + (#\C #\G) + (#\G #\C) + (#\U #\A) + (#\N #\N) + (#\a #\u) + (#\c #\g) + (#\g #\c) + (#\t #\u) + (#\n #\n) + (t #\?))) + seq)) + +(defun bio-complement (seq) + (if (or (position #\U seq) (position #\u seq)) + (rna-complement seq) + (dna-complement seq))) + + (defun reverse-complement (seq) - (nreverse (map 'string (lambda (base) - (case base - (#\A #\T) - (#\C #\G) - (#\G #\C) - (#\T #\A) - (#\N #\N) - (#\a #\t) - (#\c #\g) - (#\g #\c) - (#\t #\a) - (#\n #\n) - (t #\?))) - seq))) + (nreverse (bio-complement seq))) (defcommand revcomp () () (pbcopy (reverse-complement (pbpaste)))) +(defcommand comp () () + (pbcopy (bio-complement (pbpaste)))) + (defcommand rev () () (pbcopy (reverse (pbpaste)))) +(defun align/ref% (ref) + (alexandria:write-string-into-file (pbpaste) "~/scratch/query.fastx" + :if-exists :supersede) + (run-shell-command (format nil "st -- sav ~A ~~/scratch/query.fastx" ref))) + +(defcommand align/l1 () () + (align/ref% "~/src/dotfiles/refs/l1-ont.fasta")) + +(defcommand align/aluya () () + (align/ref% "~/src/dotfiles/refs/aluya-ont.fasta")) + +(defcommand align/aluyb () () + (align/ref% "~/src/dotfiles/refs/aluyb-ont.fasta")) + +(defcommand align/barcodes1 () () + (align/ref% "~/src/dotfiles/refs/ont-barcodes-1.fasta")) + +(defcommand align/barcodes2 () () + (align/ref% "~/src/dotfiles/refs/ont-barcodes-2.fasta")) + + #; Scratch -------------------------------------------------------------------- (random-fasta-string 10 100) diff -r c76aecc93001 -r 97e37a4c1138 stumpwm/key-mapping.lisp --- a/stumpwm/key-mapping.lisp Thu Jul 16 11:24:25 2026 -0400 +++ b/stumpwm/key-mapping.lisp Tue Oct 13 10:31:54 2026 -0400 @@ -191,6 +191,7 @@ ("KP_Page_Up" "igv/select-reads") ; 9 ) + (defvar *keymap/igv* (make-sparse-keymap)) (define-key *keymap/igv* (kbd "s") "igv/supplementary-on") @@ -206,8 +207,17 @@ (define-key *keymap/igv* (kbd "m") "igv/minimera") (define-key *keymap/igv* (kbd "H-i") "igv") +(defvar *keymap/alignment* (make-sparse-keymap)) + +(define-key *keymap/alignment* (kbd "a") "align/aluya") +(define-key *keymap/alignment* (kbd "b") "align/aluyb") +(define-key *keymap/alignment* (kbd "l") "align/l1") +(define-key *keymap/alignment* (kbd "1") "align/barcodes1") +(define-key *keymap/alignment* (kbd "2") "align/barcodes2") + (define-top-keys ;; alternate maps - ("H-i" *keymap/igv*)) + ("H-i" *keymap/igv*) + ("H-a" *keymap/alignment*)) ;;; The G A M E R M O U S E: diff -r c76aecc93001 -r 97e37a4c1138 stumpwm/stumpconfig.asd --- a/stumpwm/stumpconfig.asd Thu Jul 16 11:24:25 2026 -0400 +++ b/stumpwm/stumpconfig.asd Tue Oct 13 10:31:54 2026 -0400 @@ -39,4 +39,5 @@ (:file "miscellaneous") (:file "igv") (:file "bioinf") + (:file "tasks") (:file "key-mapping"))) diff -r c76aecc93001 -r 97e37a4c1138 vim/custom-dictionary.utf-8.add --- a/vim/custom-dictionary.utf-8.add Thu Jul 16 11:24:25 2026 -0400 +++ b/vim/custom-dictionary.utf-8.add Tue Oct 13 10:31:54 2026 -0400 @@ -582,3 +582,5 @@ bcftools hg37 LLQR +nalbinding +nalbind diff -r c76aecc93001 -r 97e37a4c1138 vim/vimrc --- a/vim/vimrc Thu Jul 16 11:24:25 2026 -0400 +++ b/vim/vimrc Tue Oct 13 10:31:54 2026 -0400 @@ -2182,6 +2182,9 @@ " Fix s au FileType vlime_sldb nnoremap s :call vlime#ui#sldb#StepCurOrLastFrame("step") + " Fix S + au FileType vlime_sldb nnoremap S :call vlime#ui#sldb#OpenFrameSource() + " Fix p au FileType vlime_inspector nnoremap p :call vlime#ui#inspector#InspectorPop() augroup end