[med-svn] [falcon] 02/06: Imported Upstream version 1.8.2
Afif Elghraoui
afif at moszumanska.debian.org
Mon Nov 14 07:31:26 UTC 2016
This is an automated email from the git hooks/post-receive script.
afif pushed a commit to branch master
in repository falcon.
commit 2a04b8e929d8389442774dc5f1ddb3a727dc8680
Author: Afif Elghraoui <afif at debian.org>
Date: Sun Nov 13 22:20:09 2016 -0800
Imported Upstream version 1.8.2
---
DALIGNER/LA4Falcon.c | 168 +-
DAMASKER/tandem.c | 2 +-
DAZZ_DB/README | 15 +-
DAZZ_DB/fasta2DB.c | 2 +
DEXTRACTOR/DB.c | 1736 +++++++++++++++++++
DEXTRACTOR/DB.h | 420 +++++
DEXTRACTOR/GNUmakefile | 26 +
DEXTRACTOR/LICENSE | 34 +
DEXTRACTOR/Makefile | 37 +
DEXTRACTOR/QV.c | 1387 ++++++++++++++++
DEXTRACTOR/QV.h | 96 ++
DEXTRACTOR/README | 141 ++
DEXTRACTOR/dexqv.c | 164 ++
DEXTRACTOR/dexta.c | 219 +++
DEXTRACTOR/dextract.c | 594 +++++++
DEXTRACTOR/undexqv.c | 230 +++
DEXTRACTOR/undexta.c | 285 ++++
FALCON-examples/git-sym.makefile | 10 +-
FALCON-examples/makefile | 4 +-
FALCON-examples/run/ecoli/input.fofn | 6 +-
FALCON-examples/run/ecoli/makefile | 4 +
FALCON-examples/run/ecoli2/input.fofn | 6 +-
FALCON-examples/run/synth0/check.py | 2 +-
FALCON-examples/run/synth0/data/synth0.fasta | 1750 --------------------
FALCON-examples/run/synth0/data/synth5k/README | 8 +
.../run/synth0/data/{ => synth5k}/ref.fasta | 0
.../run/synth0/data/synth5k/subreads.dexta | Bin 0 -> 25665 bytes
.../run/synth0/data/synth5k/synth5k.bam | Bin 0 -> 35341 bytes
.../run/synth0/data/synth5k/synth5k.bam.bai | Bin 0 -> 16 bytes
.../run/synth0/data/synth5k/synth5k.bam.pbi | Bin 0 -> 346 bytes
.../run/synth0/data/synth5k/synth5k.xml | 15 +
FALCON-examples/run/synth0/fc_run.cfg | 14 +-
FALCON-examples/run/synth0/input.fofn | 2 +-
FALCON-make/makefile | 5 +-
FALCON/falcon_kit/bash.py | 37 +-
FALCON/falcon_kit/functional.py | 85 +-
FALCON/falcon_kit/mains/ovlp_to_graph.py | 35 +-
FALCON/falcon_kit/mains/run0.py | 683 --------
FALCON/falcon_kit/mains/run1.py | 738 ++++-----
FALCON/falcon_kit/pype_tasks.py | 398 +++++
FALCON/falcon_kit/run_support.py | 69 +-
FALCON/falcon_kit/stats_preassembly.py | 5 +-
FALCON/setup.py | 1 -
FALCON/test/se161.sh | 836 ++++++++++
FALCON/test/test_functional.py | 18 +-
pypeFLOW/LICENSE | 32 +
pypeFLOW/License.txt | 20 -
pypeFLOW/pwatcher/blocking.py | 464 ++++++
pypeFLOW/pwatcher/fs_based.py | 60 +-
pypeFLOW/pwatcher/mains/job_start.sh | 36 +
pypeFLOW/pwatcher/mains/network_heartbeat.py | 176 ++
pypeFLOW/pwatcher/mains/query_server.py | 125 ++
pypeFLOW/pwatcher/network_based.py | 1031 ++++++++++++
pypeFLOW/pypeflow/do_support.py | 51 +
pypeFLOW/pypeflow/do_task.py | 149 ++
pypeFLOW/pypeflow/pwatcher_bridge.py | 59 +-
pypeFLOW/pypeflow/simple_pwatcher_bridge.py | 566 +++++++
pypeFLOW/pypeflow/util.py | 31 +
pypeFLOW/setup.py | 2 +
pypeFLOW/travis.sh | 2 +-
60 files changed, 10053 insertions(+), 3038 deletions(-)
diff --git a/DALIGNER/LA4Falcon.c b/DALIGNER/LA4Falcon.c
index e767833..2ee07a6 100644
--- a/DALIGNER/LA4Falcon.c
+++ b/DALIGNER/LA4Falcon.c
@@ -60,32 +60,112 @@
#include <stdint.h>
#include <ctype.h>
#include <unistd.h>
+#include <stdbool.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "DB.h"
#include "align.h"
+#define MAX_OVERLAPS 50000
+
+#define MIN(X,Y) ((X) < (Y)) ? (X) : (Y)
+
+static bool GROUP = false;
+
+// Allows us to group overlaps between a pair of a/b reads as a unit, one per
+// direction (if applicable). beg/end will point to the same overlap when
+// only one overlap found.
typedef struct {
- int r_id;
+ Overlap beg;
+ Overlap end;
int score;
- int t_o;
- int t_s;
- int t_e;
- int t_l;
-} hit_record;
+ int blen;
+} OverlapGroup;
-hit_record * hits;
+OverlapGroup *ovlgrps;
-#define MIN(X,Y) ((X) < (Y)) ? (X) : (Y)
+static int compare_ovlgrps(const void *grp1, const void *grp2) {
+ return ((OverlapGroup *)grp2)->score - ((OverlapGroup *)grp1)->score;
+}
-static int compare_hits(const void * h1, const void *h2) {
- return ((hit_record *) h2)->score - ((hit_record *) h1)->score;
+static bool belongs(OverlapGroup *grp, const Overlap *ovl) {
+ Overlap *prev = &grp->end;
+ return prev->flags == ovl->flags
+ &&(ovl->path.abpos>prev->path.aepos)
+ &&(ovl->path.bbpos>prev->path.bepos)
+ &&(ovl->path.abpos-prev->path.aepos) < 251;
}
+// Add a new overlap to a new or existing overlap group. Always adds when group
+// flag is false, effectively greating groups of 1.
+// Returns 1 if added as a new overlap group, otherwise 0.
+// caller keeps track of count
+static bool add_overlap(const Alignment *aln, const Overlap *ovl, const int count) {
+ int added = false;
+ // we assume breads are in order
+ if (!GROUP || count < 0 || ovlgrps[count].beg.bread != ovl->bread) {
+ // Haven't seen this bread yet (or we're not grouping), move to new overlap group
+ OverlapGroup *next = &ovlgrps[count+1];
+ next->beg = *ovl;
+ next->end = *ovl;
+ next->blen = aln->blen;
+ const Path *p = &ovl->path;
+ int olen = p->bepos - p->bbpos;
+ int hlen = (MIN(p->abpos, p->bbpos)) +
+ (MIN(aln->alen - p->aepos,aln->blen - p->bepos));
+ next->score = olen - hlen;
+ added = true;
+ } else {
+ OverlapGroup *curr = &ovlgrps[count];
+ // Seen, should we combine it with the previous overlap group or move
+ // on to the next?
+ if (belongs(curr, ovl)) {
+ curr->end = *ovl;
+ // rescore
+ Overlap *beg = &curr->beg;
+ Overlap *end = &curr->end;
+ int olen = end->path.bepos - beg->path.bbpos;
+ int hlen = (MIN(beg->path.abpos, beg->path.bbpos)) +
+ (MIN(aln->alen - end->path.aepos,aln->blen - end->path.bepos));
+ curr->score = olen - hlen;
+ } else {
+ OverlapGroup *next = &ovlgrps[count+1];
+ next->beg = *ovl;
+ next->end = *ovl;
+ next->blen = aln->blen;
+ const Path *p = &ovl->path;
+ int olen = p->bepos - p->bbpos;
+ int hlen = (MIN(p->abpos, p->bbpos)) + (MIN(aln->alen - p->aepos,aln->blen - p->bepos));
+ next->score = olen - hlen;
+ added = true;
+ }
+ }
+ return added;
+}
+
+static void print_hits(const int hit_count, HITS_DB *db2, char *bbuffer, char buffer[], int64 bsize, const int MAX_HIT_COUNT) {
+ int tmp_idx;
+ qsort(ovlgrps, (hit_count+1), sizeof(OverlapGroup), compare_ovlgrps);
+ for (tmp_idx = 0; tmp_idx < (hit_count+1) && tmp_idx < MAX_HIT_COUNT; tmp_idx++) {
+ OverlapGroup *grp = &ovlgrps[tmp_idx];
+ Load_Read(db2, grp->end.bread, bbuffer, 0);
+ if (COMP(grp->end.flags)) Complement_Seq(bbuffer, grp->blen );
+ Upper_Read(bbuffer);
+ int64 const rlen = (int64)(grp->end.path.bepos) - (int64)(grp->beg.path.bbpos);
+ if (rlen < bsize) {
+ strncpy( buffer, bbuffer + grp->beg.path.bbpos, rlen );
+ buffer[rlen - 1] = '\0';
+ printf("%08d %s\n", grp->end.bread, buffer);
+ } else {
+ fprintf(stderr, "[WARNING]Skipping super-long read %08d, len=%lld, buf=%lld\n", grp->end.bread, rlen, bsize);
+ }
+ }
+ printf("+ +\n");
+}
static char *Usage[] =
- { "[-mfsocarUFM] [-i<int(4)>] [-w<int(100)>] [-b<int(10)>] ",
+ { "[-mfsocargUFM] [-i<int(4)>] [-w<int(100)>] [-b<int(10)>] ",
" <src1:db|dam> [ <src2:db|dam> ] <align:las> [ <reads:FILE> | <reads:range> ... ]"
};
@@ -114,6 +194,7 @@ int main(int argc, char *argv[])
int ISTWO;
int MAP;
int FALCON, OVERLAP, M4OVL;
+ // XXX: MAX_HIT_COUNT should be renamed
int SEED_MIN, MAX_HIT_COUNT, SKIP;
// Process options
@@ -144,7 +225,7 @@ int main(int argc, char *argv[])
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
- ARG_FLAGS("smfocarUFM")
+ ARG_FLAGS("smfocargUFM")
break;
case 'i':
ARG_NON_NEGATIVE(INDENT,"Indent")
@@ -160,7 +241,7 @@ int main(int argc, char *argv[])
break;
case 'n':
ARG_POSITIVE(MAX_HIT_COUNT, "max numer of supporting read ouput (used for FALCON consensus. default 400, max: 2000)")
- if (MAX_HIT_COUNT > 2000) MAX_HIT_COUNT = 2000;
+ if (MAX_HIT_COUNT > 2000) MAX_HIT_COUNT = 2000;
break;
}
else
@@ -177,6 +258,7 @@ int main(int argc, char *argv[])
M4OVL = flags['m'];
FALCON = flags['f'];
SKIP = flags['s'];
+ GROUP = flags['g'];
if (argc <= 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage[0]);
@@ -417,8 +499,8 @@ int main(int argc, char *argv[])
abuffer = New_Read_Buffer(db1);
bbuffer = New_Read_Buffer(db2);
if (FALCON) {
- hits = calloc(sizeof(hit_record), 50001);
- hit_count = 0;
+ ovlgrps = calloc(sizeof(OverlapGroup), MAX_OVERLAPS+1);
+ hit_count = -1;
}
}
else
@@ -470,7 +552,6 @@ int main(int argc, char *argv[])
seen = 0;
lhalf = rhalf = 0;
for (j = 0; j < novl; j++)
-
// Read it in
{ Read_Overlap(input,ovl);
@@ -622,24 +703,9 @@ int main(int argc, char *argv[])
skip_rest = 0;
}
if (p_aread != ovl -> aread ) {
- int tmp_idx;
- qsort( hits, hit_count, sizeof(hit_record), compare_hits );
- for (tmp_idx = 0; tmp_idx < hit_count && tmp_idx < MAX_HIT_COUNT; tmp_idx++) {
- Load_Read(db2, hits[tmp_idx].r_id, bbuffer, 0);
- if (hits[tmp_idx].t_o) Complement_Seq(bbuffer, hits[tmp_idx].t_l );
- Upper_Read(bbuffer);
- int64 const rlen = (int64)(hits[tmp_idx].t_e) - (int64)(hits[tmp_idx].t_s);
- if (rlen < (int64)sizeof(buffer)) {
- strncpy( buffer, bbuffer + hits[tmp_idx].t_s, rlen );
- buffer[rlen - 1] = '\0';
- printf("%08d %s\n", hits[tmp_idx].r_id, buffer);
- } else {
- fprintf(stderr, "[WARNING]Skipping super-long read %08d, len=%lld\n", hits[tmp_idx].r_id, rlen);
- }
- }
- hit_count = 0;
+ print_hits(hit_count, db2, bbuffer, buffer, (int64)sizeof(buffer), MAX_HIT_COUNT);
+ hit_count = -1;
- printf("+ +\n");
Load_Read(db1, ovl->aread, abuffer, 2);
printf("%08d %s\n", ovl->aread, abuffer);
p_aread = ovl->aread;
@@ -647,19 +713,11 @@ int main(int argc, char *argv[])
}
if (skip_rest == 0) {
- int ovl_len, overhang_len, score;
- ovl_len = ovl->path.bepos - ovl->path.bbpos;
- overhang_len = MIN( ovl->path.abpos, ovl->path.bbpos );
- overhang_len += MIN( aln->alen - ovl->path.aepos, aln->blen - ovl->path.bepos);
- score = ovl_len - overhang_len;
- hits[hit_count].r_id = ovl->bread;
- hits[hit_count].t_o = COMP(aln->flags);
- hits[hit_count].t_s = ovl->path.bbpos;
- hits[hit_count].t_e = ovl->path.bepos;
- hits[hit_count].t_l = aln->blen;
- hits[hit_count].score = score;
- hit_count ++;
- if (hit_count > 50000) skip_rest = 1;
+ if (add_overlap(aln, ovl, hit_count))
+ hit_count ++;
+
+ if ((hit_count+1) > MAX_OVERLAPS)
+ skip_rest = 1;
#undef TEST_ALN_OUT
#ifdef TEST_ALN_OUT
@@ -768,21 +826,11 @@ int main(int argc, char *argv[])
}
}
- if (FALCON)
- {
- qsort( hits, hit_count, sizeof(hit_record), compare_hits );
- int tmp_idx;
- for (tmp_idx = 0; tmp_idx < hit_count && tmp_idx < MAX_HIT_COUNT; tmp_idx++) {
- Load_Read(db2, hits[tmp_idx].r_id, bbuffer, 0);
- if (hits[tmp_idx].t_o) Complement_Seq(bbuffer, hits[tmp_idx].t_l );
- Upper_Read(bbuffer);
- strncpy( buffer, bbuffer + hits[tmp_idx].t_s, (int64) hits[tmp_idx].t_e - (int64) hits[tmp_idx].t_s );
- buffer[ (int64) hits[tmp_idx].t_e - (int64) hits[tmp_idx].t_s - 1] = '\0';
- printf("%08d %s\n", hits[tmp_idx].r_id, buffer);
- }
- printf("+ +\n");
+ if (FALCON && hit_count != -1)
+ {
+ print_hits(hit_count, db2, bbuffer, buffer, (int64)sizeof(buffer), MAX_HIT_COUNT);
printf("- -\n");
- free(hits);
+ free(ovlgrps);
}
diff --git a/DAMASKER/tandem.c b/DAMASKER/tandem.c
index 498f59f..eaa36e5 100644
--- a/DAMASKER/tandem.c
+++ b/DAMASKER/tandem.c
@@ -652,7 +652,7 @@ static int Entwine(Path *jpath, Path *kpath, Trace_Buffer *tbuf, int *where)
}
if (jpath->aepos == kpath->aepos)
- { i = abs(y2-b2);
+ { i = abs(jpath->bepos-kpath->bepos);
if (i <= min)
{ min = i;
if (i == 0)
diff --git a/DAZZ_DB/README b/DAZZ_DB/README
index 5d239dc..8fde891 100644
--- a/DAZZ_DB/README
+++ b/DAZZ_DB/README
@@ -353,17 +353,18 @@ respectively.
i # string - Quiva insertion value string
m # string - Quiva merge value string
s # string - Quiva substitution value string
- + X # - Total amount of X (X = H or S or I or P or R or M)
- @ X # - Maximum amount of X (X = H or S or I or P)
+ + X # - Total amount of X (X = H or S or I or P or R or M or T#)
+ @ X # - Maximum amount of X (X = H or S or I or P or T#)
1-code lines that begin with + or @ are always the first lines in the output. They
give size information about what is contained in the output. That is '+ X #' gives
the number of reads (X=R), the number of masks (X=M), or the total number of
-characters in all headers (X=H), sequences (X=S), or intrinsic quality vectors (X=I),
-or read profile vector (X=P). And '@ X #' gives the maximum number of characters
-in any header (X=H), sequence (X=S), intrincic quality vector (X=I), or read profile
-vector (X=P). The size numbers for the Quiva strings are identical to that for the
-sequence as they are all of the same length for any given entry.
+characters in all headers (X=H), sequences (X=S), intrinsic quality vectors (X=I),
+read profile vector (X=P), or track (X=T#). And '@ X #' gives the maximum number of
+characters in any header (X=H), sequence (X=S), intrincic quality vector (X=I), read
+profile vector (X=P), or track (X=T#). The size numbers for the Quiva strings are
+identical to that for the sequence as they are all of the same length for any
+given entry.
12. DBstats [-nu] [-b<int(1000)] [-m<track>]+ <path:db|dam>
diff --git a/DAZZ_DB/fasta2DB.c b/DAZZ_DB/fasta2DB.c
index b080fb5..071bbe0 100644
--- a/DAZZ_DB/fasta2DB.c
+++ b/DAZZ_DB/fasta2DB.c
@@ -396,6 +396,8 @@ int main(int argc, char *argv[])
eof = (fgets(read,MAX_NAME,input) == NULL);
if (eof || strlen(read) < 1)
{ fprintf(stderr,"Skipping '%s', file is empty!\n",core);
+ if (input == stdin)
+ break;
fclose(input);
free(core);
continue;
diff --git a/DEXTRACTOR/DB.c b/DEXTRACTOR/DB.c
new file mode 100644
index 0000000..46046b7
--- /dev/null
+++ b/DEXTRACTOR/DB.c
@@ -0,0 +1,1736 @@
+/*******************************************************************************************
+ *
+ * Compressed data base module. Auxiliary routines to open and manipulate a data base for
+ * which the sequence and read information are separated into two separate files, and the
+ * sequence is compressed into 2-bits for each base. Support for tracks of additional
+ * information, and trimming according to the current partition.
+ *
+ * Author : Gene Myers
+ * Date : July 2013
+ * Revised: April 2014
+ *
+ ********************************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <dirent.h>
+
+#include "DB.h"
+
+#ifdef HIDE_FILES
+#define PATHSEP "/."
+#else
+#define PATHSEP "/"
+#endif
+
+
+/*******************************************************************************************
+ *
+ * GENERAL UTILITIES
+ *
+ ********************************************************************************************/
+
+char *Prog_Name;
+
+#ifdef INTERACTIVE
+
+char Ebuffer[1000];
+
+#endif
+
+void *Malloc(int64 size, char *mesg)
+{ void *p;
+
+ if ((p = malloc(size)) == NULL)
+ { if (mesg == NULL)
+ EPRINTF(EPLACE,"%s: Out of memory\n",Prog_Name);
+ else
+ EPRINTF(EPLACE,"%s: Out of memory (%s)\n",Prog_Name,mesg);
+ }
+ return (p);
+}
+
+void *Realloc(void *p, int64 size, char *mesg)
+{ if (size <= 0)
+ size = 1;
+ if ((p = realloc(p,size)) == NULL)
+ { if (mesg == NULL)
+ EPRINTF(EPLACE,"%s: Out of memory\n",Prog_Name);
+ else
+ EPRINTF(EPLACE,"%s: Out of memory (%s)\n",Prog_Name,mesg);
+ }
+ return (p);
+}
+
+char *Strdup(char *name, char *mesg)
+{ char *s;
+
+ if (name == NULL)
+ return (NULL);
+ if ((s = strdup(name)) == NULL)
+ { if (mesg == NULL)
+ EPRINTF(EPLACE,"%s: Out of memory\n",Prog_Name);
+ else
+ EPRINTF(EPLACE,"%s: Out of memory (%s)\n",Prog_Name,mesg);
+ }
+ return (s);
+}
+
+FILE *Fopen(char *name, char *mode)
+{ FILE *f;
+
+ if (name == NULL || mode == NULL)
+ return (NULL);
+ if ((f = fopen(name,mode)) == NULL)
+ EPRINTF(EPLACE,"%s: Cannot open %s for '%s'\n",Prog_Name,name,mode);
+ return (f);
+}
+
+char *PathTo(char *name)
+{ char *path, *find;
+
+ if (name == NULL)
+ return (NULL);
+ if ((find = rindex(name,'/')) != NULL)
+ { *find = '\0';
+ path = Strdup(name,"Extracting path from");
+ *find = '/';
+ }
+ else
+ path = Strdup(".","Allocating default path");
+ return (path);
+}
+
+char *Root(char *name, char *suffix)
+{ char *path, *find, *dot;
+ int epos;
+
+ if (name == NULL)
+ return (NULL);
+ find = rindex(name,'/');
+ if (find == NULL)
+ find = name;
+ else
+ find += 1;
+ if (suffix == NULL)
+ { dot = strchr(find,'.');
+ if (dot != NULL)
+ *dot = '\0';
+ path = Strdup(find,"Extracting root from");
+ if (dot != NULL)
+ *dot = '.';
+ }
+ else
+ { epos = strlen(find);
+ epos -= strlen(suffix);
+ if (epos > 0 && strcasecmp(find+epos,suffix) == 0)
+ { find[epos] = '\0';
+ path = Strdup(find,"Extracting root from");
+ find[epos] = suffix[0];
+ }
+ else
+ path = Strdup(find,"Allocating root");
+ }
+ return (path);
+}
+
+char *Catenate(char *path, char *sep, char *root, char *suffix)
+{ static char *cat = NULL;
+ static int max = -1;
+ int len;
+
+ if (path == NULL || root == NULL || sep == NULL || suffix == NULL)
+ return (NULL);
+ len = strlen(path);
+ len += strlen(sep);
+ len += strlen(root);
+ len += strlen(suffix);
+ if (len > max)
+ { max = ((int) (1.2*len)) + 100;
+ if ((cat = (char *) realloc(cat,max+1)) == NULL)
+ { EPRINTF(EPLACE,"%s: Out of memory (Making path name for %s)\n",Prog_Name,root);
+ return (NULL);
+ }
+ }
+ sprintf(cat,"%s%s%s%s",path,sep,root,suffix);
+ return (cat);
+}
+
+char *Numbered_Suffix(char *left, int num, char *right)
+{ static char *suffix = NULL;
+ static int max = -1;
+ int len;
+
+ if (left == NULL || right == NULL)
+ return (NULL);
+ len = strlen(left);
+ len += strlen(right) + 40;
+ if (len > max)
+ { max = ((int) (1.2*len)) + 100;
+ if ((suffix = (char *) realloc(suffix,max+1)) == NULL)
+ { EPRINTF(EPLACE,"%s: Out of memory (Making number suffix for %d)\n",Prog_Name,num);
+ return (NULL);
+ }
+ }
+ sprintf(suffix,"%s%d%s",left,num,right);
+ return (suffix);
+}
+
+
+#define COMMA ','
+
+// Print big integers with commas/periods for better readability
+
+void Print_Number(int64 num, int width, FILE *out)
+{ if (width == 0)
+ { if (num < 1000ll)
+ fprintf(out,"%lld",num);
+ else if (num < 1000000ll)
+ fprintf(out,"%lld%c%03lld",num/1000ll,COMMA,num%1000ll);
+ else if (num < 1000000000ll)
+ fprintf(out,"%lld%c%03lld%c%03lld",num/1000000ll,
+ COMMA,(num%1000000ll)/1000ll,COMMA,num%1000ll);
+ else
+ fprintf(out,"%lld%c%03lld%c%03lld%c%03lld",num/1000000000ll,
+ COMMA,(num%1000000000ll)/1000000ll,
+ COMMA,(num%1000000ll)/1000ll,COMMA,num%1000ll);
+ }
+ else
+ { if (num < 1000ll)
+ fprintf(out,"%*lld",width,num);
+ else if (num < 1000000ll)
+ { if (width <= 4)
+ fprintf(out,"%lld%c%03lld",num/1000ll,COMMA,num%1000ll);
+ else
+ fprintf(out,"%*lld%c%03lld",width-4,num/1000ll,COMMA,num%1000ll);
+ }
+ else if (num < 1000000000ll)
+ { if (width <= 8)
+ fprintf(out,"%lld%c%03lld%c%03lld",num/1000000ll,COMMA,(num%1000000ll)/1000ll,
+ COMMA,num%1000ll);
+ else
+ fprintf(out,"%*lld%c%03lld%c%03lld",width-8,num/1000000ll,COMMA,(num%1000000ll)/1000ll,
+ COMMA,num%1000ll);
+ }
+ else
+ { if (width <= 12)
+ fprintf(out,"%lld%c%03lld%c%03lld%c%03lld",num/1000000000ll,COMMA,
+ (num%1000000000ll)/1000000ll,COMMA,
+ (num%1000000ll)/1000ll,COMMA,num%1000ll);
+ else
+ fprintf(out,"%*lld%c%03lld%c%03lld%c%03lld",width-12,num/1000000000ll,COMMA,
+ (num%1000000000ll)/1000000ll,COMMA,
+ (num%1000000ll)/1000ll,COMMA,num%1000ll);
+ }
+ }
+}
+
+// Return the number of digits, base 10, of num
+
+int Number_Digits(int64 num)
+{ int digit;
+
+ digit = 0;
+ while (num >= 1)
+ { num /= 10;
+ digit += 1;
+ }
+ return (digit);
+}
+
+
+/*******************************************************************************************
+ *
+ * READ COMPRESSION/DECOMPRESSION UTILITIES
+ *
+ ********************************************************************************************/
+
+// Compress read into 2-bits per base (from [0-3] per byte representation
+
+void Compress_Read(int len, char *s)
+{ int i;
+ char c, d;
+ char *s0, *s1, *s2, *s3;
+
+ s0 = s;
+ s1 = s0+1;
+ s2 = s1+1;
+ s3 = s2+1;
+
+ c = s1[len];
+ d = s2[len];
+ s0[len] = s1[len] = s2[len] = 0;
+
+ for (i = 0; i < len; i += 4)
+ *s++ = (char ) ((s0[i] << 6) | (s1[i] << 4) | (s2[i] << 2) | s3[i]);
+
+ s1[len] = c;
+ s2[len] = d;
+}
+
+// Uncompress read form 2-bits per base into [0-3] per byte representation
+
+void Uncompress_Read(int len, char *s)
+{ int i, tlen, byte;
+ char *s0, *s1, *s2, *s3;
+ char *t;
+
+ s0 = s;
+ s1 = s0+1;
+ s2 = s1+1;
+ s3 = s2+1;
+
+ tlen = (len-1)/4;
+
+ t = s+tlen;
+ for (i = tlen*4; i >= 0; i -= 4)
+ { byte = *t--;
+ s0[i] = (char) ((byte >> 6) & 0x3);
+ s1[i] = (char) ((byte >> 4) & 0x3);
+ s2[i] = (char) ((byte >> 2) & 0x3);
+ s3[i] = (char) (byte & 0x3);
+ }
+ s[len] = 4;
+}
+
+// Convert read in [0-3] representation to ascii representation (end with '\n')
+
+void Lower_Read(char *s)
+{ static char letter[4] = { 'a', 'c', 'g', 't' };
+
+ for ( ; *s != 4; s++)
+ *s = letter[(int) *s];
+ *s = '\0';
+}
+
+void Upper_Read(char *s)
+{ static char letter[4] = { 'A', 'C', 'G', 'T' };
+
+ for ( ; *s != 4; s++)
+ *s = letter[(int) *s];
+ *s = '\0';
+}
+
+// Convert read in ascii representation to [0-3] representation (end with 4)
+
+void Number_Read(char *s)
+{ static char number[128] =
+ { 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 2,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 3, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 2,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 3, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ };
+
+ for ( ; *s != '\0'; s++)
+ *s = number[(int) *s];
+ *s = 4;
+}
+
+
+/*******************************************************************************************
+ *
+ * DB OPEN, TRIM & CLOSE ROUTINES
+ *
+ ********************************************************************************************/
+
+
+// Open the given database or dam, "path" into the supplied HITS_DB record "db". If the name has
+// a part # in it then just the part is opened. The index array is allocated (for all or
+// just the part) and read in.
+// Return status of routine:
+// -1: The DB could not be opened for a reason reported by the routine to EPLACE
+// 0: Open of DB proceeded without mishap
+// 1: Open of DAM proceeded without mishap
+
+int Open_DB(char* path, HITS_DB *db)
+{ HITS_DB dbcopy;
+ char *root, *pwd, *bptr, *fptr, *cat;
+ int nreads;
+ FILE *index, *dbvis;
+ int status, plen, isdam;
+ int part, cutoff, all;
+ int ufirst, tfirst, ulast, tlast;
+
+ status = -1;
+ dbcopy = *db;
+
+ plen = strlen(path);
+ if (strcmp(path+(plen-4),".dam") == 0)
+ root = Root(path,".dam");
+ else
+ root = Root(path,".db");
+ pwd = PathTo(path);
+
+ bptr = rindex(root,'.');
+ if (bptr != NULL && bptr[1] != '\0' && bptr[1] != '-')
+ { part = strtol(bptr+1,&fptr,10);
+ if (*fptr != '\0' || part == 0)
+ part = 0;
+ else
+ *bptr = '\0';
+ }
+ else
+ part = 0;
+
+ isdam = 0;
+ cat = Catenate(pwd,"/",root,".db");
+ if (cat == NULL)
+ return (-1);
+ if ((dbvis = fopen(cat,"r")) == NULL)
+ { cat = Catenate(pwd,"/",root,".dam");
+ if (cat == NULL)
+ return (-1);
+ if ((dbvis = fopen(cat,"r")) == NULL)
+ { EPRINTF(EPLACE,"%s: Could not open database %s\n",Prog_Name,path);
+ goto error;
+ }
+ isdam = 1;
+ }
+
+ if ((index = Fopen(Catenate(pwd,PATHSEP,root,".idx"),"r")) == NULL)
+ goto error1;
+ if (fread(db,sizeof(HITS_DB),1,index) != 1)
+ { EPRINTF(EPLACE,"%s: Index file (.idx) of %s is junk\n",Prog_Name,root);
+ goto error2;
+ }
+
+ { int p, nblocks, nfiles;
+ int64 size;
+ char fname[MAX_NAME], prolog[MAX_NAME];
+
+ nblocks = 0;
+ if (fscanf(dbvis,DB_NFILE,&nfiles) != 1)
+ { EPRINTF(EPLACE,"%s: Stub file (.db) of %s is junk\n",Prog_Name,root);
+ goto error2;
+ }
+ for (p = 0; p < nfiles; p++)
+ if (fscanf(dbvis,DB_FDATA,&tlast,fname,prolog) != 3)
+ { EPRINTF(EPLACE,"%s: Stub file (.db) of %s is junk\n",Prog_Name,root);
+ goto error2;
+ }
+ if (fscanf(dbvis,DB_NBLOCK,&nblocks) != 1)
+ if (part == 0)
+ { cutoff = 0;
+ all = 1;
+ }
+ else
+ { EPRINTF(EPLACE,"%s: DB %s has not yet been partitioned, cannot request a block !\n",
+ Prog_Name,root);
+ goto error2;
+ }
+ else
+ { if (fscanf(dbvis,DB_PARAMS,&size,&cutoff,&all) != 3)
+ { EPRINTF(EPLACE,"%s: Stub file (.db) of %s is junk\n",Prog_Name,root);
+ goto error2;
+ }
+ if (part > nblocks)
+ { EPRINTF(EPLACE,"%s: DB %s has only %d blocks\n",Prog_Name,root,nblocks);
+ goto error2;
+ }
+ }
+
+ if (part > 0)
+ { for (p = 1; p <= part; p++)
+ if (fscanf(dbvis,DB_BDATA,&ufirst,&tfirst) != 2)
+ { EPRINTF(EPLACE,"%s: Stub file (.db) of %s is junk\n",Prog_Name,root);
+ goto error2;
+ }
+ if (fscanf(dbvis,DB_BDATA,&ulast,&tlast) != 2)
+ { EPRINTF(EPLACE,"%s: Stub file (.db) of %s is junk\n",Prog_Name,root);
+ goto error2;
+ }
+ }
+ else
+ { ufirst = tfirst = 0;
+ ulast = db->ureads;
+ tlast = db->treads;
+ }
+ }
+
+ db->trimmed = 0;
+ db->tracks = NULL;
+ db->part = part;
+ db->cutoff = cutoff;
+ db->all = all;
+ db->ufirst = ufirst;
+ db->tfirst = tfirst;
+
+ nreads = ulast-ufirst;
+ if (part <= 0)
+ { db->reads = (HITS_READ *) Malloc(sizeof(HITS_READ)*(nreads+2),"Allocating Open_DB index");
+ if (db->reads == NULL)
+ goto error2;
+ db->reads += 1;
+ if (fread(db->reads,sizeof(HITS_READ),nreads,index) != (size_t) nreads)
+ { EPRINTF(EPLACE,"%s: Index file (.idx) of %s is junk\n",Prog_Name,root);
+ free(db->reads);
+ goto error2;
+ }
+ }
+ else
+ { HITS_READ *reads;
+ int i, r, maxlen;
+ int64 totlen;
+
+ reads = (HITS_READ *) Malloc(sizeof(HITS_READ)*(nreads+2),"Allocating Open_DB index");
+ if (reads == NULL)
+ goto error2;
+ reads += 1;
+
+ fseeko(index,sizeof(HITS_READ)*ufirst,SEEK_CUR);
+ if (fread(reads,sizeof(HITS_READ),nreads,index) != (size_t) nreads)
+ { EPRINTF(EPLACE,"%s: Index file (.idx) of %s is junk\n",Prog_Name,root);
+ free(reads);
+ goto error2;
+ }
+
+ totlen = 0;
+ maxlen = 0;
+ for (i = 0; i < nreads; i++)
+ { r = reads[i].rlen;
+ totlen += r;
+ if (r > maxlen)
+ maxlen = r;
+ }
+
+ db->maxlen = maxlen;
+ db->totlen = totlen;
+ db->reads = reads;
+ }
+
+ ((int *) (db->reads))[-1] = ulast - ufirst; // Kludge, need these for DB part
+ ((int *) (db->reads))[-2] = tlast - tfirst;
+
+ db->nreads = nreads;
+ db->path = Strdup(Catenate(pwd,PATHSEP,root,""),"Allocating Open_DB path");
+ if (db->path == NULL)
+ goto error2;
+ db->bases = NULL;
+ db->loaded = 0;
+
+ status = isdam;
+
+error2:
+ fclose(index);
+error1:
+ fclose(dbvis);
+error:
+ if (bptr != NULL)
+ *bptr = '.';
+
+ free(pwd);
+ free(root);
+
+ if (status < 0)
+ *db = dbcopy;
+
+ return (status);
+}
+
+
+// Trim the DB or part thereof and all loaded tracks according to the cuttof and all settings
+// of the current DB partition. Reallocate smaller memory blocks for the information kept
+// for the retained reads.
+
+void Trim_DB(HITS_DB *db)
+{ int i, j, r;
+ int allflag, cutoff;
+ int64 totlen;
+ int maxlen, nreads;
+ HITS_TRACK *record;
+ HITS_READ *reads;
+
+ if (db->trimmed) return;
+
+ if (db->cutoff <= 0 && db->all) return;
+
+ cutoff = db->cutoff;
+ if (db->all)
+ allflag = 0;
+ else
+ allflag = DB_BEST;
+
+ reads = db->reads;
+ nreads = db->nreads;
+
+ for (record = db->tracks; record != NULL; record = record->next)
+ if (strcmp(record->name,". at qvs") == 0)
+ { uint16 *table = ((HITS_QV *) record)->table;
+
+ j = 0;
+ for (i = 0; i < db->nreads; i++)
+ if ((reads[i].flags & DB_BEST) >= allflag && reads[i].rlen >= cutoff)
+ table[j++] = table[i];
+ }
+ else
+ { int *anno4, size;
+ int64 *anno8;
+ char *anno, *data;
+
+ size = record->size;
+ data = (char *) record->data;
+ if (data == NULL)
+ { anno = (char *) record->anno;
+ j = 0;
+ for (i = r = 0; i < db->nreads; i++, r += size)
+ if ((reads[i].flags & DB_BEST) >= allflag && reads[i].rlen >= cutoff)
+ { memmove(anno+j,anno+r,size);
+ j += size;
+ }
+ memmove(anno+j,anno+r,size);
+ }
+ else if (size == 4)
+ { int ai;
+
+ anno4 = (int *) (record->anno);
+ j = anno4[0] = 0;
+ for (i = 0; i < db->nreads; i++)
+ if ((reads[i].flags & DB_BEST) >= allflag && reads[i].rlen >= cutoff)
+ { ai = anno4[i];
+ anno4[j+1] = anno4[j] + (anno4[i+1]-ai);
+ memmove(data+anno4[j],data+ai,anno4[i+1]-ai);
+ j += 1;
+ }
+ record->data = Realloc(record->data,anno4[j],NULL);
+ }
+ else // size == 8
+ { int64 ai;
+
+ anno8 = (int64 *) (record->anno);
+ j = anno8[0] = 0;
+ for (i = 0; i < db->nreads; i++)
+ if ((reads[i].flags & DB_BEST) >= allflag && reads[i].rlen >= cutoff)
+ { ai = anno8[i];
+ anno8[j+1] = anno8[j] + (anno8[i+1]-ai);
+ memmove(data+anno8[j],data+ai,anno8[i+1]-ai);
+ j += 1;
+ }
+ record->data = Realloc(record->data,anno8[j],NULL);
+ }
+ record->anno = Realloc(record->anno,record->size*(j+1),NULL);
+ }
+
+ totlen = maxlen = 0;
+ for (j = i = 0; i < nreads; i++)
+ { r = reads[i].rlen;
+ if ((reads[i].flags & DB_BEST) >= allflag && r >= cutoff)
+ { totlen += r;
+ if (r > maxlen)
+ maxlen = r;
+ reads[j++] = reads[i];
+ }
+ }
+
+ db->totlen = totlen;
+ db->maxlen = maxlen;
+ db->nreads = j;
+ db->trimmed = 1;
+
+ if (j < nreads)
+ { db->reads = Realloc(reads-1,sizeof(HITS_READ)*(j+2),NULL);
+ db->reads += 1;
+ }
+}
+
+// The DB has already been trimmed, but a track over the untrimmed DB needs to be loaded.
+// Trim the track by rereading the untrimmed DB index from the file system.
+
+static int Late_Track_Trim(HITS_DB *db, HITS_TRACK *track, int ispart)
+{ int i, j, r;
+ int allflag, cutoff;
+ int ureads;
+ char *root;
+ HITS_READ read;
+ FILE *indx;
+
+ if (!db->trimmed) return (0);
+
+ if (db->cutoff <= 0 && db->all) return (0);
+
+ cutoff = db->cutoff;
+ if (db->all)
+ allflag = 0;
+ else
+ allflag = DB_BEST;
+
+ root = rindex(db->path,'/') + 2;
+ indx = Fopen(Catenate(db->path,"","",".idx"),"r");
+ fseeko(indx,sizeof(HITS_DB) + sizeof(HITS_READ)*db->ufirst,SEEK_SET);
+ if (ispart)
+ ureads = ((int *) (db->reads))[-1];
+ else
+ ureads = db->ureads;
+
+ if (strcmp(track->name,". at qvs") == 0)
+ { EPRINTF(EPLACE,"%s: Cannot load QV track after trimming\n",Prog_Name);
+ fclose(indx);
+ EXIT(1);
+ }
+
+ { int *anno4, size;
+ int64 *anno8;
+ char *anno, *data;
+
+ size = track->size;
+ data = (char *) track->data;
+ if (data == NULL)
+ { anno = (char *) track->anno;
+ j = r = 0;
+ for (i = r = 0; i < ureads; i++, r += size)
+ { if (fread(&read,sizeof(HITS_READ),1,indx) != 1)
+ { EPRINTF(EPLACE,"%s: Index file (.idx) of %s is junk\n",Prog_Name,root);
+ fclose(indx);
+ EXIT(1);
+ }
+ if ((read.flags & DB_BEST) >= allflag && read.rlen >= cutoff)
+ { memmove(anno+j,anno+r,size);
+ j += size;
+ }
+ r += size;
+ }
+ memmove(anno+j,anno+r,size);
+ }
+ else if (size == 4)
+ { int ai;
+
+ anno4 = (int *) (track->anno);
+ j = anno4[0] = 0;
+ for (i = 0; i < ureads; i++)
+ { if (fread(&read,sizeof(HITS_READ),1,indx) != 1)
+ { EPRINTF(EPLACE,"%s: Index file (.idx) of %s is junk\n",Prog_Name,root);
+ fclose(indx);
+ EXIT(1);
+ }
+ if ((read.flags & DB_BEST) >= allflag && read.rlen >= cutoff)
+ { ai = anno4[i];
+ anno4[j+1] = anno4[j] + (anno4[i+1]-ai);
+ memmove(data+anno4[j],data+ai,anno4[i+1]-ai);
+ j += 1;
+ }
+ }
+ track->data = Realloc(track->data,anno4[j],NULL);
+ }
+ else // size == 8
+ { int64 ai;
+
+ anno8 = (int64 *) (track->anno);
+ j = anno8[0] = 0;
+ for (i = 0; i < ureads; i++)
+ { if (fread(&read,sizeof(HITS_READ),1,indx) != 1)
+ { EPRINTF(EPLACE,"%s: Index file (.idx) of %s is junk\n",Prog_Name,root);
+ fclose(indx);
+ EXIT(1);
+ }
+ if ((read.flags & DB_BEST) >= allflag && read.rlen >= cutoff)
+ { ai = anno8[i];
+ anno8[j+1] = anno8[j] + (anno8[i+1]-ai);
+ memmove(data+anno8[j],data+ai,anno8[i+1]-ai);
+ j += 1;
+ }
+ }
+ track->data = Realloc(track->data,anno8[j],NULL);
+ }
+ track->anno = Realloc(track->anno,track->size*(j+1),NULL);
+ }
+
+ fclose(indx);
+ return (0);
+}
+
+// Shut down an open 'db' by freeing all associated space, including tracks and QV structures,
+// and any open file pointers. The record pointed at by db however remains (the user
+// supplied it and so should free it).
+
+void Close_DB(HITS_DB *db)
+{ HITS_TRACK *t, *p;
+
+ if (db->loaded)
+ free(((char *) (db->bases)) - 1);
+ else if (db->bases != NULL)
+ fclose((FILE *) db->bases);
+ if (db->reads != NULL)
+ free(db->reads-1);
+ free(db->path);
+
+ Close_QVs(db);
+
+ for (t = db->tracks; t != NULL; t = p)
+ { p = t->next;
+ free(t->anno);
+ free(t->data);
+ free(t);
+ }
+}
+
+
+// Return the size in bytes of the memory occupied by a given DB
+
+int64 sizeof_DB(HITS_DB *db)
+{ int64 s;
+ HITS_TRACK *t;
+
+ s = sizeof(HITS_DB)
+ + sizeof(HITS_READ)*(db->nreads+2)
+ + strlen(db->path)+1
+ + (db->totlen+db->nreads+4);
+
+ t = db->tracks;
+ if (t != NULL && strcmp(t->name,". at qvs") == 0)
+ { HITS_QV *q = (HITS_QV *) t;
+ s += sizeof(HITS_QV)
+ + sizeof(uint16) * db->nreads
+ + q->ncodes * sizeof(QVcoding)
+ + 6;
+ t = t->next;
+ }
+
+ for (; t != NULL; t = t->next)
+ { s += sizeof(HITS_TRACK)
+ + strlen(t->name)+1
+ + t->size * (db->nreads+1);
+ if (t->data != NULL)
+ { if (t->size == 8)
+ s += sizeof(int)*((int64 *) t->anno)[db->nreads];
+ else // t->size == 4
+ s += sizeof(int)*((int *) t->anno)[db->nreads];
+ }
+ }
+
+ return (s);
+}
+
+
+/*******************************************************************************************
+ *
+ * QV LOAD & CLOSE ROUTINES
+ *
+ ********************************************************************************************/
+
+HITS_DB *Active_DB = NULL; // Last db/qv used by "Load_QVentry"
+HITS_QV *Active_QV; // Becomes invalid after closing
+
+int Load_QVs(HITS_DB *db)
+{ FILE *quiva, *istub, *indx;
+ char *root;
+ uint16 *table;
+ HITS_QV *qvtrk;
+ QVcoding *coding, *nx;
+ int ncodes = 0;
+
+ if (db->tracks != NULL && strcmp(db->tracks->name,". at qvs") == 0)
+ return (0);
+
+ if (db->trimmed)
+ { EPRINTF(EPLACE,"%s: Cannot load QVs after trimming the DB\n",Prog_Name);
+ EXIT(1);
+ }
+
+ if (db->reads[db->nreads-1].coff < 0)
+ { if (db->part > 0)
+ { EPRINTF(EPLACE,"%s: All QVs for this block have not been added to the DB!\n",Prog_Name);
+ EXIT(1);
+ }
+ else
+ { EPRINTF(EPLACE,"%s: All QVs for this DB have not been added!\n",Prog_Name);
+ EXIT(1);
+ }
+ }
+
+ // Open .qvs, .idx, and .db files
+
+ quiva = Fopen(Catenate(db->path,"","",".qvs"),"r");
+ if (quiva == NULL)
+ return (-1);
+
+ istub = NULL;
+ indx = NULL;
+ table = NULL;
+ coding = NULL;
+ qvtrk = NULL;
+
+ root = rindex(db->path,'/');
+ if (root[1] == '.')
+ { *root = '\0';
+ istub = Fopen(Catenate(db->path,"/",root+2,".db"),"r");
+ *root = '/';
+ }
+ else
+ istub = Fopen(Catenate(db->path,"","",".db"),"r");
+ if (istub == NULL)
+ goto error;
+
+ { int first, last, nfiles;
+ char prolog[MAX_NAME], fname[MAX_NAME];
+ int i, j;
+
+ if (fscanf(istub,DB_NFILE,&nfiles) != 1)
+ { EPRINTF(EPLACE,"%s: Stub file (.db) of %s is junk\n",Prog_Name,root);
+ goto error;
+ }
+
+ if (db->part > 0)
+ { int pfirst, plast;
+ int fbeg, fend;
+ int n, k;
+ FILE *indx;
+
+ // Determine first how many and which files span the block (fbeg to fend)
+
+ pfirst = db->ufirst;
+ plast = pfirst + db->nreads;
+
+ first = 0;
+ for (fbeg = 0; fbeg < nfiles; fbeg++)
+ { if (fscanf(istub,DB_FDATA,&last,fname,prolog) != 3)
+ { EPRINTF(EPLACE,"%s: Stub file (.db) of %s is junk\n",Prog_Name,root);
+ goto error;
+ }
+ if (last > pfirst)
+ break;
+ first = last;
+ }
+ for (fend = fbeg+1; fend <= nfiles; fend++)
+ { if (last >= plast)
+ break;
+ if (fscanf(istub,DB_FDATA,&last,fname,prolog) != 3)
+ { EPRINTF(EPLACE,"%s: Stub file (.db) of %s is junk\n",Prog_Name,root);
+ goto error;
+ }
+ first = last;
+ }
+
+ indx = Fopen(Catenate(db->path,"","",".idx"),"r");
+ ncodes = fend-fbeg;
+ coding = (QVcoding *) Malloc(sizeof(QVcoding)*ncodes,"Allocating coding schemes");
+ table = (uint16 *) Malloc(sizeof(uint16)*db->nreads,"Allocating QV table indices");
+ if (indx == NULL || coding == NULL || table == NULL)
+ { ncodes = 0;
+ goto error;
+ }
+
+ // Carefully get the first coding scheme (its offset is most likely in a HITS_RECORD
+ // in .idx that is *not* in memory). Get all the other coding schemes normally and
+ // assign the tables # for each read in the block in "tables".
+
+ rewind(istub);
+ (void) fscanf(istub,DB_NFILE,&nfiles);
+
+ first = 0;
+ for (n = 0; n < fbeg; n++)
+ { (void) fscanf(istub,DB_FDATA,&last,fname,prolog);
+ first = last;
+ }
+
+ for (n = fbeg; n < fend; n++)
+ { (void) fscanf(istub,DB_FDATA,&last,fname,prolog);
+
+ i = n-fbeg;
+ if (first < pfirst)
+ { HITS_READ read;
+
+ fseeko(indx,sizeof(HITS_DB) + sizeof(HITS_READ)*first,SEEK_SET);
+ if (fread(&read,sizeof(HITS_READ),1,indx) != 1)
+ { EPRINTF(EPLACE,"%s: Index file (.idx) of %s is junk\n",Prog_Name,root);
+ ncodes = i;
+ goto error;
+ }
+ fseeko(quiva,read.coff,SEEK_SET);
+ nx = Read_QVcoding(quiva);
+ if (nx == NULL)
+ { ncodes = i;
+ goto error;
+ }
+ coding[i] = *nx;
+ }
+ else
+ { fseeko(quiva,db->reads[first-pfirst].coff,SEEK_SET);
+ nx = Read_QVcoding(quiva);
+ if (nx == NULL)
+ { ncodes = i;
+ goto error;
+ }
+ coding[i] = *nx;
+ db->reads[first-pfirst].coff = ftello(quiva);
+ }
+
+ j = first-pfirst;
+ if (j < 0)
+ j = 0;
+ k = last-pfirst;
+ if (k > db->nreads)
+ k = db->nreads;
+ while (j < k)
+ table[j++] = (uint16) i;
+
+ first = last;
+ }
+
+ fclose(indx);
+ indx = NULL;
+ }
+
+ else
+ { // Load in coding scheme for each file, adjust .coff of first read in the file, and
+ // record which table each read uses
+
+ ncodes = nfiles;
+ coding = (QVcoding *) Malloc(sizeof(QVcoding)*nfiles,"Allocating coding schemes");
+ table = (uint16 *) Malloc(sizeof(uint16)*db->nreads,"Allocating QV table indices");
+ if (coding == NULL || table == NULL)
+ goto error;
+
+ first = 0;
+ for (i = 0; i < nfiles; i++)
+ { if (fscanf(istub,DB_FDATA,&last,fname,prolog) != 3)
+ { EPRINTF(EPLACE,"%s: Stub file (.db) of %s is junk\n",Prog_Name,root);
+ goto error;
+ }
+
+ fseeko(quiva,db->reads[first].coff,SEEK_SET);
+ nx = Read_QVcoding(quiva);
+ if (nx == NULL)
+ { ncodes = i;
+ goto error;
+ }
+ coding[i] = *nx;
+ db->reads[first].coff = ftello(quiva);
+
+ for (j = first; j < last; j++)
+ table[j] = (uint16) i;
+
+ first = last;
+ }
+ }
+
+ // Allocate and fill in the HITS_QV record and add it to the front of the
+ // track list
+
+ qvtrk = (HITS_QV *) Malloc(sizeof(HITS_QV),"Allocating QV pseudo-track");
+ if (qvtrk == NULL)
+ goto error;
+ qvtrk->name = Strdup(". at qvs","Allocating QV pseudo-track name");
+ if (qvtrk->name == NULL)
+ goto error;
+ qvtrk->next = db->tracks;
+ db->tracks = (HITS_TRACK *) qvtrk;
+ qvtrk->ncodes = ncodes;
+ qvtrk->table = table;
+ qvtrk->coding = coding;
+ qvtrk->quiva = quiva;
+ }
+
+ fclose(istub);
+ return (0);
+
+error:
+ if (qvtrk != NULL)
+ free(qvtrk);
+ if (table != NULL)
+ free(table);
+ if (coding != NULL)
+ { int i;
+ for (i = 0; i < ncodes; i++)
+ Free_QVcoding(coding+i);
+ free(coding);
+ }
+ if (indx != NULL)
+ fclose(indx);
+ if (istub != NULL)
+ fclose(istub);
+ fclose(quiva);
+ EXIT(1);
+}
+
+// Close the QV stream, free the QV pseudo track and all associated memory
+
+void Close_QVs(HITS_DB *db)
+{ HITS_TRACK *track;
+ HITS_QV *qvtrk;
+ int i;
+
+ Active_DB = NULL;
+
+ track = db->tracks;
+ if (track != NULL && strcmp(track->name,". at qvs") == 0)
+ { qvtrk = (HITS_QV *) track;
+ for (i = 0; i < qvtrk->ncodes; i++)
+ Free_QVcoding(qvtrk->coding+i);
+ free(qvtrk->coding);
+ free(qvtrk->table);
+ fclose(qvtrk->quiva);
+ db->tracks = track->next;
+ free(track);
+ }
+ return;
+}
+
+
+/*******************************************************************************************
+ *
+ * TRACK LOAD & CLOSE ROUTINES
+ *
+ ********************************************************************************************/
+
+// Return status of track:
+// 1: Track is for trimmed DB
+// 0: Track is for untrimmed DB
+// -1: Track is not the right size of DB either trimmed or untrimmed
+// -2: Could not find the track
+
+int Check_Track(HITS_DB *db, char *track, int *kind)
+{ FILE *afile;
+ int tracklen, size, ispart;
+ int ureads, treads;
+
+ afile = NULL;
+ if (db->part > 0)
+ { afile = fopen(Catenate(db->path,Numbered_Suffix(".",db->part,"."),track,".anno"),"r");
+ ispart = 1;
+ }
+ if (afile == NULL)
+ { afile = fopen(Catenate(db->path,".",track,".anno"),"r");
+ ispart = 0;
+ }
+ if (afile == NULL)
+ return (-2);
+
+ if (fread(&tracklen,sizeof(int),1,afile) != 1)
+ { fprintf(stderr,"%s: track files for %s are corrupted\n",Prog_Name,track);
+ exit (1);
+ }
+ if (fread(&size,sizeof(int),1,afile) != 1)
+ { fprintf(stderr,"%s: track files for %s are corrupted\n",Prog_Name,track);
+ exit (1);
+ }
+
+ if (size == 0)
+ *kind = MASK_TRACK;
+ else if (size > 0)
+ *kind = CUSTOM_TRACK;
+ else
+ { fprintf(stderr,"%s: track files for %s are corrupted\n",Prog_Name,track);
+ exit (1);
+ }
+
+ fclose(afile);
+
+ if (ispart)
+ { ureads = ((int *) (db->reads))[-1];
+ treads = ((int *) (db->reads))[-2];
+ }
+ else
+ { ureads = db->ureads;
+ treads = db->treads;
+ }
+
+ if (tracklen == ureads)
+ return (0);
+ else if (tracklen == treads)
+ return (1);
+ else
+ return (-1);
+}
+
+// If track is not already in the db's track list, then allocate all the storage for it,
+// read it in from the appropriate file, add it to the track list, and return a pointer
+// to the newly created HITS_TRACK record. If the track does not exist or cannot be
+// opened for some reason, then NULL is returned.
+
+HITS_TRACK *Load_Track(HITS_DB *db, char *track)
+{ FILE *afile, *dfile;
+ int tracklen, size;
+ int nreads, ispart;
+ int treads, ureads;
+ void *anno;
+ void *data;
+ char *name;
+ HITS_TRACK *record;
+
+ if (track[0] == '.')
+ { EPRINTF(EPLACE,"%s: Track name, '%s', cannot begin with a .\n",Prog_Name,track);
+ EXIT(NULL);
+ }
+
+ for (record = db->tracks; record != NULL; record = record->next)
+ if (strcmp(record->name,track) == 0)
+ return (record);
+
+ afile = NULL;
+ if (db->part)
+ { afile = fopen(Catenate(db->path,Numbered_Suffix(".",db->part,"."),track,".anno"),"r");
+ ispart = 1;
+ }
+ if (afile == NULL)
+ { afile = fopen(Catenate(db->path,".",track,".anno"),"r");
+ ispart = 0;
+ }
+ if (afile == NULL)
+ { EPRINTF(EPLACE,"%s: Track '%s' does not exist\n",Prog_Name,track);
+ return (NULL);
+ }
+
+ dfile = NULL;
+ anno = NULL;
+ data = NULL;
+ record = NULL;
+
+ if (ispart)
+ name = Catenate(db->path,Numbered_Suffix(".",db->part,"."),track,".data");
+ else
+ name = Catenate(db->path,".",track,".data");
+ if (name == NULL)
+ goto error;
+ dfile = fopen(name,"r");
+
+ if (fread(&tracklen,sizeof(int),1,afile) != 1)
+ { EPRINTF(EPLACE,"%s: Track '%s' annotation file is junk\n",Prog_Name,track);
+ goto error;
+ }
+ if (fread(&size,sizeof(int),1,afile) != 1)
+ { EPRINTF(EPLACE,"%s: Track '%s' annotation file is junk\n",Prog_Name,track);
+ goto error;
+ }
+
+ if (size < 0)
+ { EPRINTF(EPLACE,"%s: Track '%s' annotation file is junk\n",Prog_Name,track);
+ goto error;
+ }
+ if (size == 0)
+ size = 8;
+
+ if (ispart)
+ { ureads = ((int *) (db->reads))[-1];
+ treads = ((int *) (db->reads))[-2];
+ }
+ else
+ { ureads = db->ureads;
+ treads = db->treads;
+ }
+
+ if (db->trimmed)
+ { if (tracklen != treads && tracklen != ureads)
+ { EPRINTF(EPLACE,"%s: Track '%s' not same size as database !\n",Prog_Name,track);
+ goto error;
+ }
+ if ( ! ispart && db->part > 0)
+ { if (tracklen == treads)
+ fseeko(afile,size*db->tfirst,SEEK_CUR);
+ else
+ fseeko(afile,size*db->ufirst,SEEK_CUR);
+ }
+ }
+ else
+ { if (tracklen != ureads)
+ { if (tracklen == treads)
+ EPRINTF(EPLACE,"%s: Track '%s' is for a trimmed DB !\n",Prog_Name,track);
+ else
+ EPRINTF(EPLACE,"%s: Track '%s' not same size as database !\n",Prog_Name,track);
+ goto error;
+ }
+ if ( ! ispart && db->part > 0)
+ fseeko(afile,size*db->ufirst,SEEK_CUR);
+ }
+ if (tracklen == treads)
+ nreads = ((int *) (db->reads))[-2];
+ else
+ nreads = ((int *) (db->reads))[-1];
+
+ anno = (void *) Malloc(size*(nreads+1),"Allocating Track Anno Vector");
+ if (anno == NULL)
+ goto error;
+
+ if (dfile != NULL)
+ { int64 *anno8, off8, dlen;
+ int *anno4, off4;
+ int i;
+
+ if (fread(anno,size,nreads+1,afile) != (size_t) (nreads+1))
+ { EPRINTF(EPLACE,"%s: Track '%s' annotation file is junk\n",Prog_Name,track);
+ goto error;
+ }
+
+ if (size == 4)
+ { anno4 = (int *) anno;
+ off4 = anno4[0];
+ if (off4 != 0)
+ { for (i = 0; i <= nreads; i++)
+ anno4[i] -= off4;
+ fseeko(dfile,off4,SEEK_SET);
+ }
+ dlen = anno4[nreads];
+ data = (void *) Malloc(dlen,"Allocating Track Data Vector");
+ }
+ else
+ { anno8 = (int64 *) anno;
+ off8 = anno8[0];
+ if (off8 != 0)
+ { for (i = 0; i <= nreads; i++)
+ anno8[i] -= off8;
+ fseeko(dfile,off8,SEEK_SET);
+ }
+ dlen = anno8[nreads];
+ data = (void *) Malloc(dlen,"Allocating Track Data Vector");
+ }
+ if (data == NULL)
+ goto error;
+ if (dlen > 0)
+ { if (fread(data,dlen,1,dfile) != 1)
+ { EPRINTF(EPLACE,"%s: Track '%s' data file is junk\n",Prog_Name,track);
+ goto error;
+ }
+ }
+ fclose(dfile);
+ dfile = NULL;
+ }
+ else
+ { if (fread(anno,size,nreads,afile) != (size_t) nreads)
+ { EPRINTF(EPLACE,"%s: Track '%s' annotation file is junk\n",Prog_Name,track);
+ goto error;
+ }
+ data = NULL;
+ }
+
+ fclose(afile);
+
+ record = (HITS_TRACK *) Malloc(sizeof(HITS_TRACK),"Allocating Track Record");
+ if (record == NULL)
+ goto error;
+ record->name = Strdup(track,"Allocating Track Name");
+ if (record->name == NULL)
+ goto error;
+ record->data = data;
+ record->anno = anno;
+ record->size = size;
+
+ if (db->trimmed && tracklen != treads)
+ { if (Late_Track_Trim(db,record,ispart))
+ goto error;
+ }
+
+ if (db->tracks != NULL && strcmp(db->tracks->name,". at qvs") == 0)
+ { record->next = db->tracks->next;
+ db->tracks->next = record;
+ }
+ else
+ { record->next = db->tracks;
+ db->tracks = record;
+ }
+
+ return (record);
+
+error:
+ if (record != NULL)
+ free(record);
+ if (data != NULL)
+ free(data);
+ if (anno != NULL)
+ free(anno);
+ if (dfile != NULL)
+ fclose(dfile);
+ fclose(afile);
+ EXIT (NULL);
+}
+
+void Close_Track(HITS_DB *db, char *track)
+{ HITS_TRACK *record, *prev;
+
+ prev = NULL;
+ for (record = db->tracks; record != NULL; record = record->next)
+ { if (strcmp(record->name,track) == 0)
+ { free(record->anno);
+ free(record->data);
+ free(record->name);
+ if (prev == NULL)
+ db->tracks = record->next;
+ else
+ prev->next = record->next;
+ free(record);
+ return;
+ }
+ prev = record;
+ }
+ return;
+}
+
+
+/*******************************************************************************************
+ *
+ * READ BUFFER ALLOCATION AND READ ACCESS
+ *
+ ********************************************************************************************/
+
+// Allocate and return a buffer big enough for the largest read in 'db', leaving room
+// for an initial delimiter character
+
+char *New_Read_Buffer(HITS_DB *db)
+{ char *read;
+
+ read = (char *) Malloc(db->maxlen+4,"Allocating New Read Buffer");
+ if (read == NULL)
+ EXIT(NULL);
+ return (read+1);
+}
+
+// Load into 'read' the i'th read in 'db'. As an upper case ASCII string if ascii is 2, as a
+// lower-case ASCII string is ascii is 1, and as a numeric string over 0(A), 1(C), 2(G), and
+// 3(T) otherwise.
+//
+// **NB**, the byte before read will be set to a delimiter character!
+
+int Load_Read(HITS_DB *db, int i, char *read, int ascii)
+{ FILE *bases = (FILE *) db->bases;
+ int64 off;
+ int len, clen;
+ HITS_READ *r = db->reads;
+
+ if (i >= db->nreads)
+ { EPRINTF(EPLACE,"%s: Index out of bounds (Load_Read)\n",Prog_Name);
+ EXIT(1);
+ }
+ if (bases == NULL)
+ { bases = Fopen(Catenate(db->path,"","",".bps"),"r");
+ if (bases == NULL)
+ EXIT(1);
+ db->bases = (void *) bases;
+ }
+
+ off = r[i].boff;
+ len = r[i].rlen;
+
+ if (ftello(bases) != off)
+ fseeko(bases,off,SEEK_SET);
+ clen = COMPRESSED_LEN(len);
+ if (clen > 0)
+ { if (fread(read,clen,1,bases) != 1)
+ { EPRINTF(EPLACE,"%s: Failed read of .bps file (Load_Read)\n",Prog_Name);
+ EXIT(1);
+ }
+ }
+ Uncompress_Read(len,read);
+ if (ascii == 1)
+ { Lower_Read(read);
+ read[-1] = '\0';
+ }
+ else if (ascii == 2)
+ { Upper_Read(read);
+ read[-1] = '\0';
+ }
+ else
+ read[-1] = 4;
+ return (0);
+}
+
+char *Load_Subread(HITS_DB *db, int i, int beg, int end, char *read, int ascii)
+{ FILE *bases = (FILE *) db->bases;
+ int64 off;
+ int len, clen;
+ int bbeg, bend;
+ HITS_READ *r = db->reads;
+
+ if (i >= db->nreads)
+ { EPRINTF(EPLACE,"%s: Index out of bounds (Load_Read)\n",Prog_Name);
+ EXIT(NULL);
+ }
+ if (bases == NULL)
+ { bases = Fopen(Catenate(db->path,"","",".bps"),"r");
+ if (bases == NULL)
+ EXIT(NULL);
+ db->bases = (void *) bases;
+ }
+
+ bbeg = beg/4;
+ bend = (end-1)/4+1;
+
+ off = r[i].boff + bbeg;
+ len = end - beg;
+
+ if (ftello(bases) != off)
+ fseeko(bases,off,SEEK_SET);
+ clen = bend-bbeg;
+ if (clen > 0)
+ { if (fread(read,clen,1,bases) != 1)
+ { EPRINTF(EPLACE,"%s: Failed read of .bps file (Load_Read)\n",Prog_Name);
+ EXIT(NULL);
+ }
+ }
+ Uncompress_Read(4*clen,read);
+ read += beg%4;
+ read[len] = 4;
+ if (ascii == 1)
+ { Lower_Read(read);
+ read[-1] = '\0';
+ }
+ else if (ascii == 2)
+ { Upper_Read(read);
+ read[-1] = '\0';
+ }
+ else
+ read[-1] = 4;
+
+ return (read);
+}
+
+
+/*******************************************************************************************
+ *
+ * QV BUFFER ALLOCATION QV READ ACCESS
+ *
+ ********************************************************************************************/
+
+// Allocate and return a buffer of 5 vectors big enough for the largest read in 'db'
+
+char **New_QV_Buffer(HITS_DB *db)
+{ char **entry;
+ char *qvs;
+ int i;
+
+ qvs = (char *) Malloc(db->maxlen*5,"Allocating New QV Buffer");
+ entry = (char **) Malloc(sizeof(char *)*5,"Allocating New QV Buffer");
+ if (qvs == NULL || entry == NULL)
+ EXIT(NULL);
+ for (i = 0; i < 5; i++)
+ entry[i] = qvs + i*db->maxlen;
+ return (entry);
+}
+
+// Load into entry the QV streams for the i'th read from db. The parameter ascii applies to
+// the DELTAG stream as described for Load_Read.
+
+int Load_QVentry(HITS_DB *db, int i, char **entry, int ascii)
+{ HITS_READ *reads;
+ FILE *quiva;
+ int rlen;
+
+ if (db != Active_DB)
+ { if (db->tracks == NULL || strcmp(db->tracks->name,". at qvs") != 0)
+ { EPRINTF(EPLACE,"%s: QV's are not loaded (Load_QVentry)\n",Prog_Name);
+ EXIT(1);
+ }
+ Active_QV = (HITS_QV *) db->tracks;
+ Active_DB = db;
+ }
+ if (i >= db->nreads)
+ { EPRINTF(EPLACE,"%s: Index out of bounds (Load_QVentry)\n",Prog_Name);
+ EXIT(1);
+ }
+
+ reads = db->reads;
+ quiva = Active_QV->quiva;
+ rlen = reads[i].rlen;
+
+ fseeko(quiva,reads[i].coff,SEEK_SET);
+ if (Uncompress_Next_QVentry(quiva,entry,Active_QV->coding+Active_QV->table[i],rlen))
+ EXIT(1);
+
+ if (ascii != 1)
+ { char *deltag = entry[1];
+
+ if (ascii != 2)
+ { char x = deltag[rlen];
+ deltag[rlen] = '\0';
+ Number_Read(deltag);
+ deltag[rlen] = x;
+ }
+ else
+ { int j;
+ int u = 'A'-'a';
+
+ for (j = 0; j < rlen; j++)
+ deltag[j] = (char) (deltag[j]+u);
+ }
+ }
+
+ return (0);
+}
+
+
+/*******************************************************************************************
+ *
+ * BLOCK LOAD OF ALL READS (PRIMARILY FOR DALIGNER)
+ *
+ ********************************************************************************************/
+
+// Allocate a block big enough for all the uncompressed sequences, read them into it,
+// reset the 'off' in each read record to be its in-memory offset, and set the
+// bases pointer to point at the block after closing the bases file. If ascii is
+// non-zero then the reads are converted to ACGT ascii, otherwise the reads are left
+// as numeric strings over 0(A), 1(C), 2(G), and 3(T).
+
+int Read_All_Sequences(HITS_DB *db, int ascii)
+{ FILE *bases;
+ int nreads = db->nreads;
+ HITS_READ *reads = db->reads;
+ void (*translate)(char *s);
+
+ char *seq;
+ int64 o, off;
+ int i, len, clen;
+
+ bases = Fopen(Catenate(db->path,"","",".bps"),"r");
+ if (bases == NULL)
+ EXIT(1);
+
+ seq = (char *) Malloc(db->totlen+nreads+4,"Allocating All Sequence Reads");
+ if (seq == NULL)
+ { fclose(bases);
+ EXIT(1);
+ }
+
+ *seq++ = 4;
+
+ if (ascii == 1)
+ translate = Lower_Read;
+ else
+ translate = Upper_Read;
+
+ o = 0;
+ for (i = 0; i < nreads; i++)
+ { len = reads[i].rlen;
+ off = reads[i].boff;
+ if (ftello(bases) != off)
+ fseeko(bases,off,SEEK_SET);
+ clen = COMPRESSED_LEN(len);
+ if (clen > 0)
+ { if (fread(seq+o,clen,1,bases) != 1)
+ { EPRINTF(EPLACE,"%s: Read of .bps file failed (Read_All_Sequences)\n",Prog_Name);
+ free(seq);
+ fclose(bases);
+ EXIT(1);
+ }
+ }
+ Uncompress_Read(len,seq+o);
+ if (ascii)
+ translate(seq+o);
+ reads[i].boff = o;
+ o += (len+1);
+ }
+ reads[nreads].boff = o;
+
+ fclose(bases);
+
+ db->bases = (void *) seq;
+ db->loaded = 1;
+
+ return (0);
+}
+
+int List_DB_Files(char *path, void actor(char *path, char *extension))
+{ int status, plen, rlen, dlen;
+ char *root, *pwd, *name;
+ int isdam;
+ DIR *dirp;
+ struct dirent *dp;
+
+ status = 0;
+ pwd = PathTo(path);
+ plen = strlen(path);
+ if (strcmp(path+(plen-4),".dam") == 0)
+ root = Root(path,".dam");
+ else
+ root = Root(path,".db");
+ rlen = strlen(root);
+
+ if (root == NULL || pwd == NULL)
+ { free(pwd);
+ free(root);
+ EXIT(1);
+ }
+
+ if ((dirp = opendir(pwd)) == NULL)
+ { EPRINTF(EPLACE,"%s: Cannot open directory %s (List_DB_Files)\n",Prog_Name,pwd);
+ status = -1;
+ goto error;
+ }
+
+ isdam = 0;
+ while ((dp = readdir(dirp)) != NULL) // Get case dependent root name (if necessary)
+ { name = dp->d_name;
+ if (strcmp(name,Catenate("","",root,".db")) == 0)
+ break;
+ if (strcmp(name,Catenate("","",root,".dam")) == 0)
+ { isdam = 1;
+ break;
+ }
+ if (strcasecmp(name,Catenate("","",root,".db")) == 0)
+ { strncpy(root,name,rlen);
+ break;
+ }
+ if (strcasecmp(name,Catenate("","",root,".dam")) == 0)
+ { strncpy(root,name,rlen);
+ isdam = 1;
+ break;
+ }
+ }
+ if (dp == NULL)
+ { EPRINTF(EPLACE,"%s: Cannot find %s (List_DB_Files)\n",Prog_Name,pwd);
+ status = -1;
+ closedir(dirp);
+ goto error;
+ }
+
+ if (isdam)
+ actor(Catenate(pwd,"/",root,".dam"),"dam");
+ else
+ actor(Catenate(pwd,"/",root,".db"),"db");
+
+ rewinddir(dirp); // Report each auxiliary file
+ while ((dp = readdir(dirp)) != NULL)
+ { name = dp->d_name;
+ dlen = strlen(name);
+#ifdef HIDE_FILES
+ if (name[0] != '.')
+ continue;
+ dlen -= 1;
+ name += 1;
+#endif
+ if (dlen < rlen+1)
+ continue;
+ if (name[rlen] != '.')
+ continue;
+ if (strncmp(name,root,rlen) != 0)
+ continue;
+ actor(Catenate(pwd,PATHSEP,name,""),name+(rlen+1));
+ }
+ closedir(dirp);
+
+error:
+ free(pwd);
+ free(root);
+ return (status);
+}
+
+void Print_Read(char *s, int width)
+{ int i;
+
+ if (s[0] < 4)
+ { for (i = 0; s[i] != 4; i++)
+ { if (i%width == 0 && i != 0)
+ printf("\n");
+ printf("%d",s[i]);
+ }
+ printf("\n");
+ }
+ else
+ { for (i = 0; s[i] != '\0'; i++)
+ { if (i%width == 0 && i != 0)
+ printf("\n");
+ printf("%c",s[i]);
+ }
+ printf("\n");
+ }
+}
diff --git a/DEXTRACTOR/DB.h b/DEXTRACTOR/DB.h
new file mode 100644
index 0000000..983bee7
--- /dev/null
+++ b/DEXTRACTOR/DB.h
@@ -0,0 +1,420 @@
+/*******************************************************************************************
+ *
+ * Compressed data base module. Auxiliary routines to open and manipulate a data base for
+ * which the sequence and read information are separated into two separate files, and the
+ * sequence is compressed into 2-bits for each base. Support for tracks of additional
+ * information, and trimming according to the current partition. Eventually will also
+ * support compressed quality information.
+ *
+ * Author : Gene Myers
+ * Date : July 2013
+ * Revised: April 2014
+ *
+ ********************************************************************************************/
+
+#ifndef _HITS_DB
+
+#define _HITS_DB
+
+#include <stdio.h>
+
+#include "QV.h"
+
+#define HIDE_FILES // Auxiliary DB files start with a . so they are "hidden"
+ // Undefine if you don't want this
+
+// For interactive applications where it is inappropriate to simply exit with an error
+// message to standard error, define the constant INTERACTIVE. If set, then error
+// messages are put in the global variable Ebuffer and the caller of a DB routine
+// can decide how to deal with the error.
+//
+// DB, QV, or alignment routines that can encounter errors function as before in
+// non-INTERACTIVE mode by exiting after printing an error message to stderr. In
+// INTERACTIVE mode the routines place a message at EPLACE and return an error
+// value. For such routines that were previously void, they are now int, and
+// return 1 if an error occured, 0 otherwise.
+
+#ifdef INTERACTIVE
+
+#define EPRINTF sprintf
+#define EPLACE Ebuffer
+#define EXIT(x) return (x)
+
+#else // BATCH
+
+#define EPRINTF fprintf
+#define EPLACE stderr
+#define EXIT(x) exit (1)
+
+#endif
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint32;
+typedef unsigned long long uint64;
+typedef signed char int8;
+typedef signed short int16;
+typedef signed int int32;
+typedef signed long long int64;
+typedef float float32;
+typedef double float64;
+
+
+/*******************************************************************************************
+ *
+ * COMMAND LINE INTERPRETATION MACROS
+ *
+ ********************************************************************************************/
+
+extern char *Prog_Name; // Name of program
+
+#ifdef INTERACTIVE
+
+extern char Ebuffer[];
+
+#endif
+
+#define SYSTEM_ERROR \
+ { EPRINTF(EPLACE,"%s: System error, read failed!\n",Prog_Name); \
+ exit (2); \
+ }
+
+#define ARG_INIT(name) \
+ Prog_Name = Strdup(name,""); \
+ for (i = 0; i < 128; i++) \
+ flags[i] = 0;
+
+#define ARG_FLAGS(set) \
+ for (k = 1; argv[i][k] != '\0'; k++) \
+ { if (index(set,argv[i][k]) == NULL) \
+ { fprintf(stderr,"%s: -%c is an illegal option\n",Prog_Name,argv[i][k]); \
+ exit (1); \
+ } \
+ flags[(int) argv[i][k]] = 1; \
+ }
+
+#define ARG_POSITIVE(var,name) \
+ var = strtol(argv[i]+2,&eptr,10); \
+ if (*eptr != '\0' || argv[i][2] == '\0') \
+ { fprintf(stderr,"%s: -%c '%s' argument is not an integer\n", \
+ Prog_Name,argv[i][1],argv[i]+2); \
+ exit (1); \
+ } \
+ if (var <= 0) \
+ { fprintf(stderr,"%s: %s must be positive (%d)\n",Prog_Name,name,var); \
+ exit (1); \
+ }
+
+#define ARG_NON_NEGATIVE(var,name) \
+ var = strtol(argv[i]+2,&eptr,10); \
+ if (*eptr != '\0' || argv[i][2] == '\0') \
+ { fprintf(stderr,"%s: -%c '%s' argument is not an integer\n", \
+ Prog_Name,argv[i][1],argv[i]+2); \
+ exit (1); \
+ } \
+ if (var < 0) \
+ { fprintf(stderr,"%s: %s must be non-negative (%d)\n",Prog_Name,name,var); \
+ exit (1); \
+ }
+
+#define ARG_REAL(var) \
+ var = strtod(argv[i]+2,&eptr); \
+ if (*eptr != '\0' || argv[i][2] == '\0') \
+ { fprintf(stderr,"%s: -%c '%s' argument is not a real number\n", \
+ Prog_Name,argv[i][1],argv[i]+2); \
+ exit (1); \
+ }
+
+/*******************************************************************************************
+ *
+ * UTILITIES
+ *
+ ********************************************************************************************/
+
+// The following general utilities return NULL if any of their input pointers are NULL, or if they
+// could not perform their function (in which case they also print an error to stderr).
+
+void *Malloc(int64 size, char *mesg); // Guarded versions of malloc, realloc
+void *Realloc(void *object, int64 size, char *mesg); // and strdup, that output "mesg" to
+char *Strdup(char *string, char *mesg); // stderr if out of memory
+
+FILE *Fopen(char *path, char *mode); // Open file path for "mode"
+char *PathTo(char *path); // Return path portion of file name "path"
+char *Root(char *path, char *suffix); // Return the root name, excluding suffix, of "path"
+
+// Catenate returns concatenation of path.sep.root.suffix in a *temporary* buffer
+// Numbered_Suffix returns concatenation of left.<num>.right in a *temporary* buffer
+
+char *Catenate(char *path, char *sep, char *root, char *suffix);
+char *Numbered_Suffix(char *left, int num, char *right);
+
+
+// DB-related utilities
+
+void Print_Number(int64 num, int width, FILE *out); // Print readable big integer
+int Number_Digits(int64 num); // Return # of digits in printed number
+
+#define COMPRESSED_LEN(len) (((len)+3) >> 2)
+
+void Compress_Read(int len, char *s); // Compress read in-place into 2-bit form
+void Uncompress_Read(int len, char *s); // Uncompress read in-place into numeric form
+void Print_Read(char *s, int width);
+
+void Lower_Read(char *s); // Convert read from numbers to lowercase letters (0-3 to acgt)
+void Upper_Read(char *s); // Convert read from numbers to uppercase letters (0-3 to ACGT)
+void Number_Read(char *s); // Convert read from letters to numbers
+
+
+/*******************************************************************************************
+ *
+ * DB IN-CORE DATA STRUCTURES
+ *
+ ********************************************************************************************/
+
+#define DB_QV 0x03ff // Mask for 3-digit quality value
+#define DB_CSS 0x0400 // This is the second or later of a group of reads from a given insert
+#define DB_BEST 0x0800 // This is the longest read of a given insert (may be the only 1)
+
+// Fields have different interpretations if a .db versus a .dam
+
+typedef struct
+ { int origin; // Well # (DB), Contig # (DAM)
+ int rlen; // Length of the sequence (Last pulse = fpulse + rlen)
+ int fpulse; // First pulse (DB), left index of contig in scaffold (DAM)
+ int64 boff; // Offset (in bytes) of compressed read in 'bases' file, or offset of
+ // uncompressed bases in memory block
+ int64 coff; // Offset (in bytes) of compressed quiva streams in '.qvs' file (DB),
+ // Offset (in bytes) of scaffold header string in '.hdr' file (DAM)
+ int flags; // QV of read + flags above (DB only)
+ } HITS_READ;
+
+// A track can be of 3 types:
+// data == NULL: there are nreads 'anno' records of size 'size'.
+// data != NULL && size == 4: anno is an array of nreads+1 int's and data[anno[i]..anno[i+1])
+// contains the variable length data
+// data != NULL && size == 8: anno is an array of nreads+1 int64's and data[anno[i]..anno[i+1])
+// contains the variable length data
+
+typedef struct _track
+ { struct _track *next; // Link to next track
+ char *name; // Symbolic name of track
+ int size; // Size in bytes of anno records
+ void *anno; // over [0,nreads]: read i annotation: int, int64, or 'size' records
+ void *data; // data[anno[i] .. anno[i+1]-1] is data if data != NULL
+ } HITS_TRACK;
+
+// The information for accessing QV streams is in a HITS_QV record that is a "pseudo-track"
+// named ". at qvs" and is always the first track record in the list (if present). Since normal
+// track names cannot begin with a . (this is enforced), this pseudo-track is never confused
+// with a normal track.
+
+typedef struct
+ { struct _track *next;
+ char *name;
+ int ncodes; // # of coding tables
+ QVcoding *coding; // array [0..ncodes-1] of coding schemes (see QV.h)
+ uint16 *table; // for i in [0,db->nreads-1]: read i should be decompressed with
+ // scheme coding[table[i]]
+ FILE *quiva; // the open file pointer to the .qvs file
+ } HITS_QV;
+
+// The DB record holds all information about the current state of an active DB including an
+// array of HITS_READS, one per read, and a linked list of HITS_TRACKs the first of which
+// is always a HITS_QV pseudo-track (if the QVs have been loaded).
+
+typedef struct
+ { int ureads; // Total number of reads in untrimmed DB
+ int treads; // Total number of reads in trimmed DB
+ int cutoff; // Minimum read length in block (-1 if not yet set)
+ int all; // Consider multiple reads from a given well
+ float freq[4]; // frequency of A, C, G, T, respectively
+
+ // Set with respect to "active" part of DB (all vs block, untrimmed vs trimmed)
+
+ int maxlen; // length of maximum read (initially over all DB)
+ int64 totlen; // total # of bases (initially over all DB)
+
+ int nreads; // # of reads in actively loaded portion of DB
+ int trimmed; // DB has been trimmed by cutoff/all
+ int part; // DB block (if > 0), total DB (if == 0)
+ int ufirst; // Index of first read in block (without trimming)
+ int tfirst; // Index of first read in block (with trimming)
+
+ // In order to avoid forcing users to have to rebuild all thier DBs to accommodate
+ // the addition of fields for the size of the actively loaded trimmed and untrimmed
+ // blocks, an additional read record is allocated in "reads" when a DB is loaded into
+ // memory (reads[-1]) and the two desired fields are crammed into the first two
+ // integer spaces of the record.
+
+ char *path; // Root name of DB for .bps, .qvs, and tracks
+ int loaded; // Are reads loaded in memory?
+ void *bases; // file pointer for bases file (to fetch reads from),
+ // or memory pointer to uncompressed block of all sequences.
+ HITS_READ *reads; // Array [-1..nreads] of HITS_READ
+ HITS_TRACK *tracks; // Linked list of loaded tracks
+ } HITS_DB;
+
+
+/*******************************************************************************************
+ *
+ * DB STUB FILE FORMAT = NFILE FDATA^nfile NBLOCK PARAMS BDATA^nblock
+ *
+ ********************************************************************************************/
+
+#define MAX_NAME 10000 // Longest file name or fasta header line
+
+#define DB_NFILE "files = %9d\n" // number of files
+#define DB_FDATA " %9d %s %s\n" // last read index + 1, fasta prolog, file name
+#define DB_NBLOCK "blocks = %9d\n" // number of blocks
+#define DB_PARAMS "size = %10lld cutoff = %9d all = %1d\n" // block size, len cutoff, all in well
+#define DB_BDATA " %9d %9d\n" // First read index (untrimmed), first read index (trimmed)
+
+
+/*******************************************************************************************
+ *
+ * DB ROUTINES
+ *
+ ********************************************************************************************/
+
+ // Suppose DB is the name of an original database. Then there will be files .DB.idx, .DB.bps,
+ // .DB.qvs, and files .DB.<track>.anno and DB.<track>.data where <track> is a track name
+ // (not containing a . !).
+
+ // A DAM is basically a DB except that:
+ // 1. there are no QV's, instead .coff points the '\0' terminated fasta header of the read
+ // in the file .<dam>.hdr file
+ // 2. .origin contains the contig # of the read within a fasta entry (assembly sequences
+ // contain N-separated contigs), and .fpulse the first base of the contig in the
+ // fasta entry
+
+ // Open the given database or dam, "path" into the supplied HITS_DB record "db". If the name has
+ // a part # in it then just the part is opened. The index array is allocated (for all or
+ // just the part) and read in.
+ // Return status of routine:
+ // -1: The DB could not be opened for a reason reported by the routine to EPLACE
+ // 0: Open of DB proceeded without mishap
+ // 1: Open of DAM proceeded without mishap
+
+int Open_DB(char *path, HITS_DB *db);
+
+ // Trim the DB or part thereof and all loaded tracks according to the cutoff and all settings
+ // of the current DB partition. Reallocate smaller memory blocks for the information kept
+ // for the retained reads.
+
+void Trim_DB(HITS_DB *db);
+
+ // Shut down an open 'db' by freeing all associated space, including tracks and QV structures,
+ // and any open file pointers. The record pointed at by db however remains (the user
+ // supplied it and so should free it).
+
+void Close_DB(HITS_DB *db);
+
+ // Return the size in bytes of the given DB
+
+int64 sizeof_DB(HITS_DB *db);
+
+ // If QV pseudo track is not already in db's track list, then load it and set it up.
+ // The database must not have been trimmed yet. -1 is returned if a .qvs file is not
+ // present, and 1 is returned if an error (reported to EPLACE) occured and INTERACTIVE
+ // is defined. Otherwise a 0 is returned.
+
+int Load_QVs(HITS_DB *db);
+
+ // Remove the QV pseudo track, all space associated with it, and close the .qvs file.
+
+void Close_QVs(HITS_DB *db);
+
+ // Look up the file and header in the file of the indicated track. Return:
+ // 1: Track is for trimmed DB
+ // 0: Track is for untrimmed DB
+ // -1: Track is not the right size of DB either trimmed or untrimmed
+ // -2: Could not find the track
+ // In addition, if opened (0 or 1 returned), then kind points at an integer indicating
+ // the type of track as follows:
+ // CUSTOM 0 => a custom track
+ // MASK 1 => a mask track
+
+#define CUSTOM_TRACK 0
+#define MASK_TRACK 1
+
+int Check_Track(HITS_DB *db, char *track, int *kind);
+
+ // If track is not already in the db's track list, then allocate all the storage for it,
+ // read it in from the appropriate file, add it to the track list, and return a pointer
+ // to the newly created HITS_TRACK record. If the track does not exist or cannot be
+ // opened for some reason, then NULL is returned if INTERACTIVE is defined. Otherwise
+ // the routine prints an error message to stderr and exits if an error occurs, and returns
+ // with NULL only if the track does not exist.
+
+HITS_TRACK *Load_Track(HITS_DB *db, char *track);
+
+ // If track is on the db's track list, then it is removed and all storage associated with it
+ // is freed.
+
+void Close_Track(HITS_DB *db, char *track);
+
+ // Allocate and return a buffer big enough for the largest read in 'db'.
+ // **NB** free(x-1) if x is the value returned as *prefix* and suffix '\0'(4)-byte
+ // are needed by the alignment algorithms. If cannot allocate memory then return NULL
+ // if INTERACTIVE is defined, or print error to stderr and exit otherwise.
+
+char *New_Read_Buffer(HITS_DB *db);
+
+ // Load into 'read' the i'th read in 'db'. As a lower case ascii string if ascii is 1, an
+ // upper case ascii string if ascii is 2, and a numeric string over 0(A), 1(C), 2(G), and 3(T)
+ // otherwise. A '\0' (or 4) is prepended and appended to the string so it has a delimeter
+ // for traversals in either direction. A non-zero value is returned if an error occured
+ // and INTERACTIVE is defined.
+
+int Load_Read(HITS_DB *db, int i, char *read, int ascii);
+
+ // Load into 'read' the subread [beg,end] of the i'th read in 'db' and return a pointer to the
+ // the start of the subinterval (not necessarily = to read !!! ). As a lower case ascii
+ // string if ascii is 1, an upper case ascii string if ascii is 2, and a numeric string
+ // over 0(A), 1(C), 2(G), and 3(T) otherwise. A '\0' (or 4) is prepended and appended to
+ // the string holding the substring so it has a delimeter for traversals in either direction.
+ // A NULL pointer is returned if an error occured and INTERACTIVE is defined.
+
+char *Load_Subread(HITS_DB *db, int i, int beg, int end, char *read, int ascii);
+
+ // Allocate a set of 5 vectors large enough to hold the longest QV stream that will occur
+ // in the database. If cannot allocate memory then return NULL if INTERACTIVE is defined,
+ // or print error to stderr and exit otherwise.
+
+#define DEL_QV 0 // The deletion QVs are x[DEL_QV] if x is the buffer returned by New_QV_Buffer
+#define DEL_TAG 1 // The deleted characters
+#define INS_QV 2 // The insertion QVs
+#define SUB_QV 3 // The substitution QVs
+#define MRG_QV 4 // The merge QVs
+
+char **New_QV_Buffer(HITS_DB *db);
+
+ // Load into 'entry' the 5 QV vectors for i'th read in 'db'. The deletion tag or characters
+ // are converted to a numeric or upper/lower case ascii string as per ascii. Return with
+ // a zero, except when an error occurs and INTERACTIVE is defined in which case return wtih 1.
+
+int Load_QVentry(HITS_DB *db, int i, char **entry, int ascii);
+
+ // Allocate a block big enough for all the uncompressed sequences, read them into it,
+ // reset the 'off' in each read record to be its in-memory offset, and set the
+ // bases pointer to point at the block after closing the bases file. If ascii is
+ // 1 then the reads are converted to lowercase ascii, if 2 then uppercase ascii, and
+ // otherwise the reads are left as numeric strings over 0(A), 1(C), 2(G), and 3(T).
+ // Return with a zero, except when an error occurs and INTERACTIVE is defined in which
+ // case return wtih 1.
+
+int Read_All_Sequences(HITS_DB *db, int ascii);
+
+ // For the DB or DAM "path" = "prefix/root.[db|dam]", find all the files for that DB, i.e. all
+ // those of the form "prefix/[.]root.part" and call actor with the complete path to each file
+ // pointed at by path, and the suffix of the path by extension. The . proceeds the root
+ // name if the defined constant HIDE_FILES is set. Always the first call is with the
+ // path "prefix/root.[db|dam]" and extension "db" or "dam". There will always be calls for
+ // "prefix/[.]root.idx" and "prefix/[.]root.bps". All other calls are for *tracks* and
+ // so this routine gives one a way to know all the tracks associated with a given DB.
+ // -1 is returned if the path could not be found, and 1 is returned if an error (reported
+ // to EPLACE) occured and INTERACTIVE is defined. Otherwise a 0 is returned.
+
+int List_DB_Files(char *path, void actor(char *path, char *extension));
+
+#endif // _HITS_DB
diff --git a/DEXTRACTOR/GNUmakefile b/DEXTRACTOR/GNUmakefile
new file mode 100644
index 0000000..9546525
--- /dev/null
+++ b/DEXTRACTOR/GNUmakefile
@@ -0,0 +1,26 @@
+# Only dexta and undexta, for use with bam2fasta.
+THISDIR:=$(abspath $(dir $(realpath $(lastword ${MAKEFILE_LIST}))))
+CFLAGS = -O3 -Wall -Wextra -Wno-unused-result -fno-strict-aliasing
+LDLIBS+= -lm -lpthread
+#LDFLAGS+= $(patsubst %,-L%,${LIBDIRS})
+#ALL = dextract dexta undexta dexqv undexqv
+ALL = dexta undexta
+vpath %.c ${THISDIR}
+
+#%: %.c
+
+all: ${ALL}
+dexta: dexta.o
+undexta: undexta.o
+${ALL}: DB.o QV.o
+
+clean:
+ rm -f ${ALL}
+ rm -fr *.dSYM *.o
+
+install:
+ rsync -av ${ALL} ${PREFIX}/bin
+symlink:
+ ln -sf $(addprefix ${CURDIR}/,${ALL}) ${PREFIX}/bin
+
+.PHONY: clean all
diff --git a/DEXTRACTOR/LICENSE b/DEXTRACTOR/LICENSE
new file mode 100644
index 0000000..9aa819c
--- /dev/null
+++ b/DEXTRACTOR/LICENSE
@@ -0,0 +1,34 @@
+
+ Copyright (c) 2014, Dr. Eugene W. Myers (EWM). All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ · Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ · Redistributions in binary form must reproduce the above copyright notice, this
+ list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+
+ · The name of EWM may not be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY EWM ”AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EWM BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ For any issues regarding this software and its use, contact EWM at:
+
+ Eugene W. Myers Jr.
+ Bautzner Str. 122e
+ 01099 Dresden
+ GERMANY
+ Email: gene.myers at gmail.com
+
diff --git a/DEXTRACTOR/Makefile b/DEXTRACTOR/Makefile
new file mode 100644
index 0000000..d6c1d1a
--- /dev/null
+++ b/DEXTRACTOR/Makefile
@@ -0,0 +1,37 @@
+PATH_HDF5 = /sw/apps/hdf5/current
+PATH_HDF5 = /usr/local/hdf5
+
+DEST_DIR = ~/bin
+
+CFLAGS = -O3 -Wall -Wextra -Wno-unused-result -fno-strict-aliasing
+
+ALL = dextract dexta undexta dexqv undexqv
+
+all: $(ALL)
+
+dextract: dextract.c DB.c DB.h QV.c QV.h
+ gcc $(CFLAGS) -I$(PATH_HDF5)/include -L$(PATH_HDF5)/lib -o dextract dextract.c DB.c QV.c -lhdf5
+
+dexta: dexta.c DB.c DB.h QV.c QV.h
+ gcc $(CFLAGS) -o dexta dexta.c DB.c QV.c
+
+undexta: undexta.c DB.c DB.h QV.c QV.h
+ gcc $(CFLAGS) -o undexta undexta.c DB.c QV.c
+
+dexqv: dexqv.c DB.c DB.h QV.c QV.h
+ gcc $(CFLAGS) -o dexqv dexqv.c DB.c QV.c
+
+undexqv: undexqv.c DB.c DB.h QV.c QV.h
+ gcc $(CFLAGS) -o undexqv undexqv.c DB.c QV.c
+
+clean:
+ rm -f $(ALL)
+ rm -fr *.dSYM
+ rm -f dextract.tar.gz
+
+install:
+ cp $(ALL) $(DEST_DIR)
+
+package:
+ make clean
+ tar -zcf dextract.tar.gz README Makefile *.h *.c
diff --git a/DEXTRACTOR/QV.c b/DEXTRACTOR/QV.c
new file mode 100644
index 0000000..cdb6a63
--- /dev/null
+++ b/DEXTRACTOR/QV.c
@@ -0,0 +1,1387 @@
+/*******************************************************************************************
+ *
+ * Compressor/decompressor for .quiv files: customized Huffman codes for each stream based on
+ * the histogram of values occuring in a given file. The two low complexity streams
+ * (deletionQV and substitutionQV) use a Huffman coding of the run length of the prevelant
+ * character.
+ *
+ * Author: Gene Myers
+ * Date: Jan 18, 2014
+ * Modified: July 25, 2014
+ *
+ ********************************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <unistd.h>
+
+#include "DB.h"
+
+#undef DEBUG
+
+#define MIN_BUFFER 1000
+
+#define HUFF_CUTOFF 16 // This cannot be larger than 16 !
+
+
+/*******************************************************************************************
+ *
+ * Endian flipping routines
+ *
+ ********************************************************************************************/
+
+static int LittleEndian; // Little-endian machine ?
+ // Referred by: Decode & Decode_Run
+static int Flip; // Flip endian of all coded shorts and ints
+ // Referred by: Decode & Decode_Run & Read_Scheme
+
+static void Set_Endian(int flip)
+{ uint32 x = 3;
+ uint8 *b = (uint8 *) (&x);
+
+ Flip = flip;
+ LittleEndian = (b[0] == 3);
+}
+
+static void Flip_Long(void *w)
+{ uint8 *v = (uint8 *) w;
+ uint8 x;
+
+ x = v[0];
+ v[0] = v[3];
+ v[3] = x;
+ x = v[1];
+ v[1] = v[2];
+ v[2] = x;
+}
+
+static void Flip_Short(void *w)
+{ uint8 *v = (uint8 *) w;
+ uint8 x;
+
+ x = v[0];
+ v[0] = v[1];
+ v[1] = x;
+}
+
+
+/*******************************************************************************************
+ *
+ * Routines for computing a Huffman Encoding Scheme
+ *
+ ********************************************************************************************/
+
+typedef struct
+ { int type; // 0 => normal, 1 => normal but has long codes, 2 => truncated
+ uint32 codebits[256]; // If type = 2, then code 255 is the special code for
+ int codelens[256]; // non-Huffman exceptions
+ int lookup[0x10000]; // Lookup table (just for decoding)
+ } HScheme;
+
+typedef struct _HTree
+ { struct _HTree *lft, *rgt;
+ uint64 count;
+ } HTree;
+
+ // Establish heap property from node s down (1 is root, siblings of n are 2n and 2n+1)
+ // assuming s is the only perturbation in the tree.
+
+static void Reheap(int s, HTree **heap, int hsize)
+{ int c, l, r;
+ HTree *hs, *hr, *hl;
+
+ c = s;
+ hs = heap[s];
+ while ((l = 2*c) <= hsize)
+ { r = l+1;
+ hl = heap[l];
+ hr = heap[r];
+ if (r > hsize || hr->count > hl->count)
+ { if (hs->count > hl->count)
+ { heap[c] = hl;
+ c = l;
+ }
+ else
+ break;
+ }
+ else
+ { if (hs->count > hr->count)
+ { heap[c] = hr;
+ c = r;
+ }
+ else
+ break;
+ }
+ }
+ if (c != s)
+ heap[c] = hs;
+}
+
+ // Given Huffman tree build a table of codes from it, the low-order codelens[s] bits
+ // of codebits[s] contain the code for symbol s.
+
+static void Build_Table(HTree *node, int code, int len, uint32 *codebits, int *codelens)
+{ if (node->rgt == NULL)
+ { uint64 symbol = (uint64) (node->lft);
+ codebits[symbol] = code;
+ codelens[symbol] = len;
+ }
+ else
+ { code <<= 1;
+ len += 1;
+ Build_Table(node->lft,code,len,codebits,codelens);
+ Build_Table(node->rgt,code+1,len,codebits,codelens);
+ }
+}
+
+ // For the non-zero symbols in hist, compute a huffman tree over them, and then
+ // build a table of the codes. If inscheme is not NULL, then place all symbols
+ // with code 255 or with more than HUFF_CUTOFF bits in the encoding by inscheme
+ // as a single united entity, whose code signals that the value of these symbols
+ // occur explicitly in 8 (values) or 16 (run lengths) bits following the code.
+ // All the symbols in this class will have the same entry in the code table and
+ // 255 is always in this class.
+
+static HScheme *Huffman(uint64 *hist, HScheme *inscheme)
+{ HScheme *scheme;
+ HTree *heap[259];
+ HTree node[512];
+ int hsize;
+ HTree *lft, *rgt;
+ int value, range;
+ int i;
+
+ scheme = (HScheme *) Malloc(sizeof(HScheme),"Allocating Huffman scheme record");
+ if (scheme == NULL)
+ return (NULL);
+
+ hsize = 0; // Load heap
+ value = 0;
+ if (inscheme != NULL)
+ { node[0].count = 0;
+ node[0].lft = (HTree *) (uint64) 255;
+ node[0].rgt = NULL;
+ heap[++hsize] = node+(value++);
+ }
+ for (i = 0; i < 256; i++)
+ if (hist[i] > 0)
+ { if (inscheme != NULL && (inscheme->codelens[i] > HUFF_CUTOFF || i == 255))
+ node[0].count += hist[i];
+ else
+ { node[value].count = hist[i];
+ node[value].lft = (HTree *) (uint64) i;
+ node[value].rgt = NULL;
+ heap[++hsize] = node+(value++);
+ }
+ }
+
+ for (i = hsize/2; i >= 1; i--) // Establish heap property
+ Reheap(i,heap,hsize);
+
+ range = value; // Merge pairs with smallest count until have a tree
+ for (i = 1; i < value; i++)
+ { lft = heap[1];
+ heap[1] = heap[hsize--];
+ Reheap(1,heap,hsize);
+ rgt = heap[1];
+ node[range].lft = lft;
+ node[range].rgt = rgt;
+ node[range].count = lft->count + rgt->count;
+ heap[1] = node+(range++);
+ Reheap(1,heap,hsize);
+ }
+
+ for (i = 0; i < 256; i++) // Build the code table
+ { scheme->codebits[i] = 0;
+ scheme->codelens[i] = 0;
+ }
+
+ Build_Table(node+(range-1),0,0,scheme->codebits,scheme->codelens);
+
+ if (inscheme != NULL) // Set scheme type and if truncated (2), map truncated codes
+ { scheme->type = 2; // to code and length for 255
+ for (i = 0; i < 255; i++)
+ if (inscheme->codelens[i] > HUFF_CUTOFF || scheme->codelens[i] > HUFF_CUTOFF)
+ { scheme->codelens[i] = scheme->codelens[255];
+ scheme->codebits[i] = scheme->codebits[255];
+ }
+ }
+ else
+ { scheme->type = 0;
+ for (i = 0; i < 256; i++)
+ { if (scheme->codelens[i] > HUFF_CUTOFF)
+ scheme->type = 1;
+ }
+ }
+
+ return (scheme);
+}
+
+#ifdef DEBUG
+
+ // For debug, show the coding table
+
+static void Print_Table(HScheme *scheme, uint64 *hist, int infosize)
+{ uint64 total_bits;
+ uint32 specval, mask, code, *bits;
+ int speclen, clen, *lens;
+ int i, k;
+
+ total_bits = 0;
+ bits = scheme->codebits;
+ lens = scheme->codelens;
+ if (scheme->type == 2)
+ { specval = bits[255];
+ speclen = lens[255];
+ }
+ else
+ specval = speclen = 0x7fffffff;
+
+ printf("\nCode Table:\n");
+ for (i = 0; i < 256; i++)
+ if (lens[i] > 0)
+ { clen = lens[i];
+ mask = (1 << clen);
+ code = bits[i];
+ printf(" %3d: %2d ",i,clen);
+ for (k = 0; k < clen; k++)
+ { mask >>= 1;
+ if (code & mask)
+ printf("1");
+ else
+ printf("0");
+ }
+ if (code == specval && clen == speclen)
+ { printf(" ***");
+ if (hist != NULL)
+ total_bits += (clen+infosize)*hist[i];
+ }
+ else if (hist != NULL)
+ total_bits += clen*hist[i];
+ printf("\n");
+ }
+ if (hist != NULL)
+ printf("\nTotal Bytes = %lld\n",(total_bits-1)/8+1);
+}
+
+ // For debug, show the histogram
+
+static void Print_Histogram(uint64 *hist)
+{ int i, low, hgh;
+ uint64 count;
+
+ for (hgh = 255; hgh >= 0; hgh--)
+ if (hist[hgh] != 0)
+ break;
+ for (low = 0; low < 256; low++)
+ if (hist[low] != 0)
+ break;
+ count = 0;
+ for (i = low; i <= hgh; i++)
+ count += hist[i];
+
+ for (i = hgh; i >= low; i--)
+ printf(" %3d: %8llu %5.1f%%\n",i,hist[i],(hist[i]*100.)/count);
+}
+
+#endif
+
+
+/*******************************************************************************************
+ *
+ * Read and Write Huffman Schemes
+ *
+ ********************************************************************************************/
+
+ // Write the code table to out.
+
+static void Write_Scheme(HScheme *scheme, FILE *out)
+{ int i;
+ uint8 x;
+ uint32 *bits;
+ int *lens;
+
+ lens = scheme->codelens;
+ bits = scheme->codebits;
+
+ x = (uint8) (scheme->type);
+ fwrite(&x,1,1,out);
+
+ for (i = 0; i < 256; i++)
+ { x = (uint8) (lens[i]);
+ fwrite(&x,1,1,out);
+ if (x > 0)
+ fwrite(bits+i,sizeof(uint32),1,out);
+ }
+}
+
+ // Allocate and read a code table from in, and return a pointer to it.
+
+static HScheme *Read_Scheme(FILE *in)
+{ HScheme *scheme;
+ int *look, *lens;
+ uint32 *bits, base;
+ int i, j, powr;
+ uint8 x;
+
+ scheme = (HScheme *) Malloc(sizeof(HScheme),"Allocating Huffman scheme record");
+ if (scheme == NULL)
+ return (NULL);
+
+ lens = scheme->codelens;
+ bits = scheme->codebits;
+ look = scheme->lookup;
+
+ if (fread(&x,1,1,in) != 1)
+ { EPRINTF(EPLACE,"Could not read scheme type byte (Read_Scheme)\n");
+ free(scheme);
+ return (NULL);
+ }
+ scheme->type = x;
+ for (i = 0; i < 256; i++)
+ { if (fread(&x,1,1,in) != 1)
+ { EPRINTF(EPLACE,"Could not read length of %d'th code (Read_Scheme)\n",i);
+ return (NULL);
+ }
+ lens[i] = x;
+ if (x > 0)
+ { if (fread(bits+i,sizeof(uint32),1,in) != 1)
+ { EPRINTF(EPLACE,"Could not read bit encoding of %d'th code (Read_Scheme)\n",i);
+ free(scheme);
+ return (NULL);
+ }
+ }
+ else
+ bits[i] = 0;
+ }
+
+ if (Flip)
+ { for (i = 0; i < 256; i++)
+ Flip_Long(bits+i);
+ }
+
+ for (i = 0; i < 256; i++)
+ { if (lens[i] > 0)
+ { base = (bits[i] << (16-lens[i]));
+ powr = (1 << (16-lens[i]));
+ for (j = 0; j < powr; j++)
+ look[base+j] = i;
+ }
+ }
+
+ return (scheme);
+}
+
+
+/*******************************************************************************************
+ *
+ * Encoders and Decoders
+ *
+ ********************************************************************************************/
+
+ // Encode read[0..rlen-1] according to scheme and write to out
+
+static void Encode(HScheme *scheme, FILE *out, uint8 *read, int rlen)
+{ uint32 x, c, ocode;
+ int n, k, olen, llen;
+ int *nlens;
+ uint32 *nbits;
+ uint32 nspec;
+ int nslen;
+
+ nlens = scheme->codelens;
+ nbits = scheme->codebits;
+
+ if (scheme->type == 2)
+ { nspec = nbits[255];
+ nslen = nlens[255];
+ }
+ else
+ nspec = nslen = 0x7fffffff;
+
+#define OCODE(L,C) \
+{ int len = olen + (L); \
+ uint32 code = (C); \
+ \
+ llen = olen; \
+ if (len >= 32) \
+ { olen = len-32; \
+ ocode |= (code >> olen); \
+ fwrite(&ocode,sizeof(uint32),1,out); \
+ if (olen > 0) \
+ ocode = (code << (32-olen)); \
+ else \
+ ocode = 0; \
+ } \
+ else \
+ { olen = len; \
+ ocode |= (code << (32-olen));; \
+ } \
+}
+
+ llen = 0;
+ olen = 0;
+ ocode = 0;
+ for (k = 0; k < rlen; k++)
+ { x = read[k];
+ n = nlens[x];
+ c = nbits[x];
+ OCODE(n,c);
+ if (c == nspec && n == nslen)
+ OCODE(8,x);
+ }
+
+ if (olen > 0) // Tricky: must pad so decoder does not read past
+ { fwrite(&ocode,sizeof(uint32),1,out); // last integer int the coded output.
+ if (llen > 16 && olen > llen)
+ fwrite(&ocode,sizeof(uint32),1,out);
+ }
+ else if (llen > 16)
+ fwrite(&ocode,sizeof(uint32),1,out);
+}
+
+ // Encode read[0..rlen-1] according to non-rchar table neme, and run-length table reme for
+ // runs of rchar characters. Write to out.
+
+static void Encode_Run(HScheme *neme, HScheme *reme, FILE *out, uint8 *read, int rlen, int rchar)
+{ uint32 x, c, ocode;
+ int n, h, k, olen, llen;
+ int *nlens, *rlens;
+ uint32 *nbits, *rbits;
+ uint32 nspec, rspec;
+ int nslen, rslen;
+
+ nlens = neme->codelens;
+ nbits = neme->codebits;
+ rlens = reme->codelens;
+ rbits = reme->codebits;
+
+ if (neme->type == 2)
+ { nspec = nbits[255];
+ nslen = nlens[255];
+ }
+ else
+ nspec = nslen = 0x7fffffff;
+
+ rspec = rbits[255];
+ rslen = rlens[255];
+
+ llen = 0;
+ olen = 0;
+ ocode = 0;
+ k = 0;
+ while (k < rlen)
+ { h = k;
+ while (k < rlen && read[k] == rchar)
+ k += 1;
+ if (k-h >= 255)
+ x = 255;
+ else
+ x = k-h;
+ n = rlens[x];
+ c = rbits[x];
+ OCODE(n,c);
+ if (c == rspec && n == rslen)
+ OCODE(16,k-h);
+ if (k < rlen)
+ { x = read[k];
+ n = nlens[x];
+ c = nbits[x];
+ OCODE(n,c);
+ if (c == nspec && n == nslen)
+ OCODE(8,x);
+ k += 1;
+ }
+ }
+
+ if (olen > 0)
+ { fwrite(&ocode,sizeof(uint32),1,out);
+ if (llen > 16 && olen > llen)
+ fwrite(&ocode,sizeof(uint32),1,out);
+ }
+ else if (llen > 16)
+ fwrite(&ocode,sizeof(uint32),1,out);
+}
+
+ // Read and decode from in, the next rlen symbols into read according to scheme
+
+static int Decode(HScheme *scheme, FILE *in, char *read, int rlen)
+{ int *look, *lens;
+ int signal, ilen;
+ uint64 icode;
+ uint32 *ipart;
+ uint16 *xpart;
+ uint8 *cpart;
+ int j, n, c;
+
+ if (LittleEndian)
+ { ipart = ((uint32 *) (&icode));
+ xpart = ((uint16 *) (&icode)) + 2;
+ cpart = ((uint8 *) (&icode)) + 5;
+ }
+ else
+ { ipart = ((uint32 *) (&icode)) + 1;
+ xpart = ((uint16 *) (&icode)) + 1;
+ cpart = ((uint8 *) (&icode)) + 2;
+ }
+
+ if (scheme->type == 2)
+ signal = 255;
+ else
+ signal = 256;
+ lens = scheme->codelens;
+ look = scheme->lookup;
+
+#define GET \
+ if (n > ilen) \
+ { icode <<= ilen; \
+ if (fread(ipart,sizeof(uint32),1,in) != 1) \
+ { EPRINTF(EPLACE,"Could not read more bits (Decode)\n"); \
+ return (1); \
+ } \
+ ilen = n-ilen; \
+ icode <<= ilen; \
+ ilen = 32-ilen; \
+ } \
+ else \
+ { icode <<= n; \
+ ilen -= n; \
+ }
+
+#define GETFLIP \
+ if (n > ilen) \
+ { icode <<= ilen; \
+ if (fread(ipart,sizeof(uint32),1,in) != 1) \
+ { EPRINTF(EPLACE,"Could not read more bits (Decode)\n"); \
+ return (1); \
+ } \
+ Flip_Long(ipart); \
+ ilen = n-ilen; \
+ icode <<= ilen; \
+ ilen = 32-ilen; \
+ } \
+ else \
+ { icode <<= n; \
+ ilen -= n; \
+ }
+
+ n = 16;
+ ilen = 0;
+ icode = 0;
+ if (Flip)
+ for (j = 0; j < rlen; j++)
+ { GETFLIP
+ c = look[*xpart];
+ n = lens[c];
+ if (c == signal)
+ { GETFLIP
+ c = *cpart;
+ n = 8;
+ }
+ read[j] = (char) c;
+ }
+ else
+ for (j = 0; j < rlen; j++)
+ { GET
+ c = look[*xpart];
+ n = lens[c];
+ if (c == signal)
+ { GET
+ c = *cpart;
+ n = 8;
+ }
+ read[j] = (char) c;
+ }
+
+ return (0);
+}
+
+ // Read and decode from in, the next rlen symbols into read according to non-rchar scheme
+ // neme, and the rchar runlength shceme reme
+
+static int Decode_Run(HScheme *neme, HScheme *reme, FILE *in, char *read,
+ int rlen, int rchar)
+{ int *nlook, *nlens;
+ int *rlook, *rlens;
+ int nsignal, ilen;
+ uint64 icode;
+ uint32 *ipart;
+ uint16 *xpart;
+ uint8 *cpart;
+ int j, n, c, k;
+
+ if (LittleEndian)
+ { ipart = ((uint32 *) (&icode));
+ xpart = ((uint16 *) (&icode)) + 2;
+ cpart = ((uint8 *) (&icode)) + 5;
+ }
+ else
+ { ipart = ((uint32 *) (&icode)) + 1;
+ xpart = ((uint16 *) (&icode)) + 1;
+ cpart = ((uint8 *) (&icode)) + 2;
+ }
+
+ if (neme->type == 2)
+ nsignal = 255;
+ else
+ nsignal = 256;
+ nlens = neme->codelens;
+ nlook = neme->lookup;
+
+ rlens = reme->codelens;
+ rlook = reme->lookup;
+
+ n = 16;
+ ilen = 0;
+ icode = 0;
+ if (Flip)
+ for (j = 0; j < rlen; j++)
+ { GETFLIP
+ c = rlook[*xpart];
+ n = rlens[c];
+ if (c == 255)
+ { GETFLIP
+ c = *xpart;
+ n = 16;
+ }
+ for (k = 0; k < c; k++)
+ read[j++] = (char) rchar;
+
+ if (j < rlen)
+ { GETFLIP
+ c = nlook[*xpart];
+ n = nlens[c];
+ if (c == nsignal)
+ { GETFLIP
+ c = *cpart;
+ n = 8;
+ }
+ read[j] = (char) c;
+ }
+ }
+ else
+ for (j = 0; j < rlen; j++)
+ { GET
+ c = rlook[*xpart];
+ n = rlens[c];
+ if (c == 255)
+ { GET
+ c = *xpart;
+ n = 16;
+ }
+ for (k = 0; k < c; k++)
+ read[j++] = (char) rchar;
+
+ if (j < rlen)
+ { GET
+ c = nlook[*xpart];
+ n = nlens[c];
+ if (c == nsignal)
+ { GET
+ c = *cpart;
+ n = 8;
+ }
+ read[j] = (char) c;
+ }
+ }
+
+ return (0);
+}
+
+
+/*******************************************************************************************
+ *
+ * Histogrammers
+ *
+ ********************************************************************************************/
+
+// Histogram runlengths of symbol runChar in stream[0..rlen-1] into run.
+
+static void Histogram_Seqs(uint64 *hist, uint8 *stream, int rlen)
+{ int k;
+
+ for (k = 0; k < rlen; k++)
+ hist[stream[k]] += 1;
+}
+
+static void Histogram_Runs(uint64 *run, uint8 *stream, int rlen, int runChar)
+{ int k, h;
+
+ k = 0;
+ while (k < rlen)
+ { h = k;
+ while (k < rlen && stream[k] == runChar)
+ k += 1;
+ if (k-h >= 256)
+ run[255] += 1;
+ else
+ run[k-h] += 1;
+ if (k < rlen)
+ k += 1;
+ }
+}
+
+
+/*******************************************************************************************
+ *
+ * Reader
+ *
+ ********************************************************************************************/
+
+static char *Read = NULL; // Referred by: QVentry, Read_Lines, QVcoding_Scan,
+static int Rmax = -1; // Compress_Next_QVentry
+
+static int Nline; // Referred by: QVcoding_Scan
+
+char *QVentry()
+{ return (Read); }
+
+void Set_QV_Line(int line)
+{ Nline = line; }
+
+int Get_QV_Line()
+{ return (Nline); }
+
+// If nlines == 1 trying to read a single header, nlines = 5 trying to read 5 QV/fasta lines
+// for a sequence. Place line j at Read+j*Rmax and the length of every line is returned
+// unless eof occurs in which case return -1. If any error occurs return -2.
+
+int Read_Lines(FILE *input, int nlines)
+{ int i, rlen;
+ int tmax;
+ char *tread;
+ char *other;
+
+ if (Read == NULL)
+ { tmax = MIN_BUFFER;
+ tread = (char *) Malloc(5*tmax,"Allocating QV entry read buffer");
+ if (tread == NULL)
+ EXIT(-2);
+ Rmax = tmax;
+ Read = tread;
+ }
+
+ Nline += 1;
+ if (fgets(Read,Rmax,input) == NULL)
+ return (-1);
+
+ rlen = strlen(Read);
+ while (Read[rlen-1] != '\n')
+ { tmax = ((int) 1.4*Rmax) + MIN_BUFFER;
+ tread = (char *) Realloc(Read,5*tmax,"Reallocating QV entry read buffer");
+ if (tread == NULL)
+ EXIT(-2);
+ Rmax = tmax;
+ Read = tread;
+ if (fgets(Read+rlen,Rmax-rlen,input) == NULL)
+ { EPRINTF(EPLACE,"Line %d: Last line does not end with a newline !\n",Nline);
+ EXIT(-2);
+ }
+ rlen += strlen(Read+rlen);
+ }
+ other = Read;
+ for (i = 1; i < nlines; i++)
+ { other += Rmax;
+ Nline += 1;
+ if (fgets(other,Rmax,input) == NULL)
+ { EPRINTF(EPLACE,"Line %d: incomplete last entry of .quiv file\n",Nline);
+ EXIT(-2);
+ }
+ if (rlen != (int) strlen(other))
+ { EPRINTF(EPLACE,"Line %d: Lines for an entry are not the same length\n",Nline);
+ EXIT(-2);
+ }
+ }
+ return (rlen-1);
+}
+
+
+/*******************************************************************************************
+ *
+ * Tag compression and decompression routines
+ *
+ ********************************************************************************************/
+
+// Keep only the symbols in tags[0..rlen-1] for which qvs[k] != rchar and
+// return the # of symbols kept.
+
+static int Pack_Tag(char *tags, char *qvs, int rlen, int rchar)
+{ int j, k;
+
+ j = 0;
+ for (k = 0; k < rlen; k++)
+ if (qvs[k] != rchar)
+ tags[j++] = tags[k];
+ tags[j] = '\0';
+ return (j);
+}
+
+ // Count the # of non-rchar symbols in qvs[0..rlen-1]
+
+static int Packed_Length(char *qvs, int rlen, int rchar)
+{ int k, clen;
+
+ clen = 0;
+ for (k = 0; k < rlen; k++)
+ if (qvs[k] != rchar)
+ clen += 1;
+ return (clen);
+}
+
+ // Unpack tags by moving its i'th char to position k where qvs[k] is the i'th non-rchar
+ // symbol in qvs. All other chars are set to rchar. rlen is the length of qvs and
+ // the unpacked result, clen is the initial length of tags.
+
+static void Unpack_Tag(char *tags, int clen, char *qvs, int rlen, int rchar)
+{ int j, k;
+
+ j = clen-1;
+ for (k = rlen-1; k >= 0; k--)
+ { if (qvs[k] == rchar)
+ tags[k] = 'n';
+ else
+ tags[k] = tags[j--];
+ }
+}
+
+
+/*******************************************************************************************
+ *
+ * Statistics Scan and Scheme creation and write
+ *
+ ********************************************************************************************/
+
+ // Read up to the next num entries or until eof from the .quiva file on input and record
+ // frequency statistics. Copy these entries to the temporary file temp if != NULL.
+ // If there is an error then -1 is returned, otherwise the number of entries read.
+
+static uint64 delHist[256], insHist[256], mrgHist[256], subHist[256], delRun[256], subRun[256];
+static uint64 totChar;
+static int delChar, subChar;
+
+ // Referred by: QVcoding_Scan, Create_QVcoding
+
+int QVcoding_Scan(FILE *input, int num, FILE *temp)
+{ char *slash;
+ int rlen;
+ int i, r;
+
+ // Zero histograms
+
+ bzero(delHist,sizeof(uint64)*256);
+ bzero(mrgHist,sizeof(uint64)*256);
+ bzero(insHist,sizeof(uint64)*256);
+ bzero(subHist,sizeof(uint64)*256);
+
+ for (i = 0; i < 256; i++)
+ delRun[i] = subRun[i] = 1;
+
+ totChar = 0;
+ delChar = -1;
+ subChar = -1;
+
+ // Make a sweep through the .quiva entries, histogramming the relevant things
+ // and figuring out the run chars for the deletion and substition streams
+
+ r = 0;
+ for (i = 0; i < num; i++)
+ { int well, beg, end, qv;
+
+ rlen = Read_Lines(input,1);
+ if (rlen == -2)
+ EXIT(-1);
+ if (rlen < 0)
+ break;
+
+ if (rlen == 0 || Read[0] != '@')
+ { EPRINTF(EPLACE,"Line %d: Header in quiva file is missing\n",Nline);
+ EXIT(-1);
+ }
+ slash = index(Read+1,'/');
+ if (slash == NULL)
+ { EPRINTF(EPLACE,"%s: Line %d: Header line incorrectly formatted ?\n",
+ Prog_Name,Nline);
+ EXIT(-1);
+ }
+ if (sscanf(slash+1,"%d/%d_%d RQ=0.%d\n",&well,&beg,&end,&qv) != 4)
+ { EPRINTF(EPLACE,"%s: Line %d: Header line incorrectly formatted ?\n",
+ Prog_Name,Nline);
+ EXIT(-1);
+ }
+
+ if (temp != NULL)
+ fputs(Read,temp);
+
+ rlen = Read_Lines(input,5);
+ if (rlen < 0)
+ { if (rlen == -1)
+ EPRINTF(EPLACE,"Line %d: incomplete last entry of .quiv file\n",Nline);
+ EXIT(-1);
+ }
+
+ if (temp != NULL)
+ { fputs(Read,temp);
+ fputs(Read+Rmax,temp);
+ fputs(Read+2*Rmax,temp);
+ fputs(Read+3*Rmax,temp);
+ fputs(Read+4*Rmax,temp);
+ }
+
+ Histogram_Seqs(delHist,(uint8 *) (Read),rlen);
+ Histogram_Seqs(insHist,(uint8 *) (Read+2*Rmax),rlen);
+ Histogram_Seqs(mrgHist,(uint8 *) (Read+3*Rmax),rlen);
+ Histogram_Seqs(subHist,(uint8 *) (Read+4*Rmax),rlen);
+
+ if (delChar < 0)
+ { int k;
+ char *del = Read+Rmax;
+
+ for (k = 0; k < rlen; k++)
+ if (del[k] == 'n' || del[k] == 'N')
+ { delChar = Read[k];
+ break;
+ }
+ }
+ if (delChar >= 0)
+ Histogram_Runs( delRun,(uint8 *) (Read),rlen,delChar);
+ totChar += rlen;
+ if (subChar < 0)
+ { if (totChar >= 100000)
+ { int k;
+
+ subChar = 0;
+ for (k = 1; k < 256; k++)
+ if (subHist[k] > subHist[subChar])
+ subChar = k;
+ }
+ }
+ if (subChar >= 0)
+ Histogram_Runs( subRun,(uint8 *) (Read+4*Rmax),rlen,subChar);
+
+ r += 1;
+ }
+
+ return (r);
+}
+
+ // Using the statistics in the global stat tables, create the Huffman schemes and write
+ // them to output. If lossy is set, then create a lossy table for the insertion and merge
+ // QVs.
+
+QVcoding *Create_QVcoding(int lossy)
+{ static QVcoding coding;
+
+ HScheme *delScheme, *insScheme, *mrgScheme, *subScheme;
+ HScheme *dRunScheme, *sRunScheme;
+
+ delScheme = NULL;
+ dRunScheme = NULL;
+ insScheme = NULL;
+ mrgScheme = NULL;
+ subScheme = NULL;
+ sRunScheme = NULL;
+
+ // Check whether using a subtitution run char is a win
+
+ if (totChar < 200000 || subHist[subChar] < .5*totChar)
+ subChar = -1;
+
+ // If lossy encryption is enabled then scale insertions and merge QVs.
+
+ if (lossy)
+ { int k;
+
+ for (k = 0; k < 256; k += 2)
+ { insHist[k] += insHist[k+1];
+ insHist[k+1] = 0;
+ }
+
+ for (k = 0; k < 256; k += 4)
+ { mrgHist[k] += mrgHist[k+1];
+ mrgHist[k] += mrgHist[k+2];
+ mrgHist[k] += mrgHist[k+3];
+ mrgHist[k+1] = 0;
+ mrgHist[k+2] = 0;
+ mrgHist[k+3] = 0;
+ }
+ }
+
+ // Build a Huffman scheme for each stream entity from the histograms
+
+#define SCHEME_MACRO(meme,hist,label,bits) \
+ scheme = Huffman( (hist), NULL); \
+ if (scheme == NULL) \
+ goto error; \
+ if (scheme->type) \
+ { (meme) = Huffman( (hist), scheme); \
+ free(scheme); \
+ } \
+ else \
+ (meme) = scheme;
+
+#ifdef DEBUG
+
+#define MAKE_SCHEME(meme,hist,label,bits) \
+ SCHEME_MACRO(meme,hist,label,bits) \
+ printf("\n%s\n", (label) ); \
+ Print_Histogram( (hist)); \
+ Print_Table( (meme), (hist), (bits));
+
+#else
+
+#define MAKE_SCHEME(meme,hist,label,bits) \
+ SCHEME_MACRO(meme,hist,label,bits)
+
+#endif
+
+ { HScheme *scheme;
+
+ if (delChar < 0)
+ { MAKE_SCHEME(delScheme,delHist, "Hisotgram of Deletion QVs", 8);
+ dRunScheme = NULL;
+ }
+ else
+ { delHist[delChar] = 0;
+ MAKE_SCHEME(delScheme,delHist, "Hisotgram of Deletion QVs less run char", 8);
+ MAKE_SCHEME(dRunScheme,delRun, "Histogram of Deletion Runs QVs", 16);
+#ifdef DEBUG
+ printf("\nRun char is '%c'\n",delChar);
+#endif
+ }
+
+#ifdef DEBUG
+ { int k;
+ uint64 count;
+
+ count = 0;
+ for (k = 0; k < 256; k++)
+ count += delHist[k];
+ printf("\nDelTag will require %lld bytes\n",count/4);
+ }
+#endif
+
+ MAKE_SCHEME(insScheme,insHist, "Hisotgram of Insertion QVs", 8);
+ MAKE_SCHEME(mrgScheme,mrgHist, "Hisotgram of Merge QVs", 8);
+
+ if (subChar < 0)
+ { MAKE_SCHEME(subScheme,subHist, "Hisotgram of Subsitution QVs", 8);
+ sRunScheme = NULL;
+ }
+ else
+ { subHist[subChar] = 0;
+ MAKE_SCHEME(subScheme,subHist, "Hisotgram of Subsitution QVs less run char", 8);
+ MAKE_SCHEME(sRunScheme,subRun, "Histogram of Substitution Run QVs", 16);
+#ifdef DEBUG
+ printf("\nRun char is '%c'\n",subChar);
+#endif
+ }
+ }
+
+ // Setup endian handling
+
+ Set_Endian(0);
+
+ coding.delScheme = delScheme;
+ coding.insScheme = insScheme;
+ coding.mrgScheme = mrgScheme;
+ coding.subScheme = subScheme;
+ coding.dRunScheme = dRunScheme;
+ coding.sRunScheme = sRunScheme;
+ coding.delChar = delChar;
+ coding.subChar = subChar;
+ coding.prefix = NULL;
+ coding.flip = 0;
+
+ return (&coding);
+
+error:
+ if (delScheme != NULL)
+ free(delScheme);
+ if (dRunScheme != NULL)
+ free(dRunScheme);
+ if (insScheme != NULL)
+ free(insScheme);
+ if (mrgScheme != NULL)
+ free(mrgScheme);
+ if (subScheme != NULL)
+ free(subScheme);
+ if (sRunScheme != NULL)
+ free(sRunScheme);
+ EXIT(NULL);
+}
+
+ // Write the encoding scheme 'coding' to 'output'
+
+void Write_QVcoding(FILE *output, QVcoding *coding)
+{
+ // Write out the endian key, run chars, and prefix (if not NULL)
+
+ { uint16 half;
+ int len;
+
+ half = 0x33cc;
+ fwrite(&half,sizeof(uint16),1,output);
+
+ if (coding->delChar < 0)
+ half = 256;
+ else
+ half = (uint16) (coding->delChar);
+ fwrite(&half,sizeof(uint16),1,output);
+
+ if (coding->subChar < 0)
+ half = 256;
+ else
+ half = (uint16) (coding->subChar);
+ fwrite(&half,sizeof(uint16),1,output);
+
+ len = strlen(coding->prefix);
+ fwrite(&len,sizeof(int),1,output);
+ fwrite(coding->prefix,1,len,output);
+ }
+
+ // Write out the scheme tables
+
+ Write_Scheme(coding->delScheme,output);
+ if (coding->delChar >= 0)
+ Write_Scheme(coding->dRunScheme,output);
+ Write_Scheme(coding->insScheme,output);
+ Write_Scheme(coding->mrgScheme,output);
+ Write_Scheme(coding->subScheme,output);
+ if (coding->subChar >= 0)
+ Write_Scheme(coding->sRunScheme,output);
+}
+
+ // Read the encoding scheme 'coding' to 'output'
+
+QVcoding *Read_QVcoding(FILE *input)
+{ static QVcoding coding;
+
+ // Read endian key, run chars, and short name common to all headers
+
+ { uint16 half;
+ int len;
+
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ { EPRINTF(EPLACE,"Could not read flip byte (Read_QVcoding)\n");
+ EXIT(NULL);
+ }
+ coding.flip = (half != 0x33cc);
+
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ { EPRINTF(EPLACE,"Could not read deletion char (Read_QVcoding)\n");
+ EXIT(NULL);
+ }
+ if (coding.flip)
+ Flip_Short(&half);
+ coding.delChar = half;
+ if (coding.delChar >= 256)
+ coding.delChar = -1;
+
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ { EPRINTF(EPLACE,"Could not read substitution char (Read_QVcoding)\n");
+ EXIT(NULL);
+ }
+ if (coding.flip)
+ Flip_Short(&half);
+ coding.subChar = half;
+ if (coding.subChar >= 256)
+ coding.subChar = -1;
+
+ // Read the short name common to all headers
+
+ if (fread(&len,sizeof(int),1,input) != 1)
+ { EPRINTF(EPLACE,"Could not read header name length (Read_QVcoding)\n");
+ EXIT(NULL);
+ }
+ if (coding.flip)
+ Flip_Long(&len);
+ coding.prefix = (char *) Malloc(len+1,"Allocating header prefix");
+ if (coding.prefix == NULL)
+ EXIT(NULL);
+ if (len > 0)
+ { if (fread(coding.prefix,len,1,input) != 1)
+ { EPRINTF(EPLACE,"Could not read header name (Read_QVcoding)\n");
+ EXIT(NULL);
+ }
+ }
+ coding.prefix[len] = '\0';
+ }
+
+ // Setup endian handling
+
+ Set_Endian(coding.flip);
+
+ // Read the Huffman schemes used to compress the data
+
+ coding.delScheme = NULL;
+ coding.dRunScheme = NULL;
+ coding.insScheme = NULL;
+ coding.mrgScheme = NULL;
+ coding.subScheme = NULL;
+ coding.sRunScheme = NULL;
+
+ coding.delScheme = Read_Scheme(input);
+ if (coding.delScheme == NULL)
+ goto error;
+ if (coding.delChar >= 0)
+ { coding.dRunScheme = Read_Scheme(input);
+ if (coding.dRunScheme == NULL)
+ goto error;
+ }
+ coding.insScheme = Read_Scheme(input);
+ if (coding.insScheme == NULL)
+ goto error;
+ coding.mrgScheme = Read_Scheme(input);
+ if (coding.mrgScheme == NULL)
+ goto error;
+ coding.subScheme = Read_Scheme(input);
+ if (coding.subScheme == NULL)
+ goto error;
+ if (coding.subChar >= 0)
+ { coding.sRunScheme = Read_Scheme(input);
+ if (coding.sRunScheme == NULL)
+ goto error;
+ }
+
+ return (&coding);
+
+error:
+ if (coding.delScheme != NULL)
+ free(coding.delScheme);
+ if (coding.dRunScheme != NULL)
+ free(coding.dRunScheme);
+ if (coding.insScheme != NULL)
+ free(coding.insScheme);
+ if (coding.mrgScheme != NULL)
+ free(coding.mrgScheme);
+ if (coding.subScheme != NULL)
+ free(coding.subScheme);
+ if (coding.sRunScheme != NULL)
+ free(coding.sRunScheme);
+ EXIT(NULL);
+}
+
+ // Free all the auxilliary storage associated with the encoding argument
+
+void Free_QVcoding(QVcoding *coding)
+{ if (coding->subChar >= 0)
+ free(coding->sRunScheme);
+ free(coding->subScheme);
+ free(coding->mrgScheme);
+ free(coding->insScheme);
+ if (coding->delChar >= 0)
+ free(coding->dRunScheme);
+ free(coding->delScheme);
+ free(coding->prefix);
+}
+
+
+/*******************************************************************************************
+ *
+ * Encode/Decode (w.r.t. coding) next entry from input and write to output
+ *
+ ********************************************************************************************/
+
+int Compress_Next_QVentry(FILE *input, FILE *output, QVcoding *coding, int lossy)
+{ int rlen, clen;
+
+ // Get all 5 streams, compress each with its scheme, and output
+
+ rlen = Read_Lines(input,5);
+ if (rlen < 0)
+ { if (rlen == -1)
+ EPRINTF(EPLACE,"Line %d: incomplete last entry of .quiv file\n",Nline);
+ EXIT (-1);
+ }
+
+ if (coding->delChar < 0)
+ { Encode(coding->delScheme, output, (uint8 *) Read, rlen);
+ clen = rlen;
+ }
+ else
+ { Encode_Run(coding->delScheme, coding->dRunScheme, output,
+ (uint8 *) Read, rlen, coding->delChar);
+ clen = Pack_Tag(Read+Rmax,Read,rlen,coding->delChar);
+ }
+ Number_Read(Read+Rmax);
+ Compress_Read(clen,Read+Rmax);
+ fwrite(Read+Rmax,1,COMPRESSED_LEN(clen),output);
+
+ if (lossy)
+ { uint8 *insert = (uint8 *) (Read+2*Rmax);
+ uint8 *merge = (uint8 *) (Read+3*Rmax);
+ int k;
+
+ for (k = 0; k < rlen; k++)
+ { insert[k] = (uint8) ((insert[k] >> 1) << 1);
+ merge[k] = (uint8) (( merge[k] >> 2) << 2);
+ }
+ }
+
+ Encode(coding->insScheme, output, (uint8 *) (Read+2*Rmax), rlen);
+ Encode(coding->mrgScheme, output, (uint8 *) (Read+3*Rmax), rlen);
+ if (coding->subChar < 0)
+ Encode(coding->subScheme, output, (uint8 *) (Read+4*Rmax), rlen);
+ else
+ Encode_Run(coding->subScheme, coding->sRunScheme, output,
+ (uint8 *) (Read+4*Rmax), rlen, coding->subChar);
+
+ return (rlen);
+}
+
+int Uncompress_Next_QVentry(FILE *input, char **entry, QVcoding *coding, int rlen)
+{ int clen, tlen;
+
+ // Decode each stream and write to output
+
+ if (coding->delChar < 0)
+ { if (Decode(coding->delScheme, input, entry[0], rlen))
+ EXIT(1);
+ clen = rlen;
+ tlen = COMPRESSED_LEN(clen);
+ if (tlen > 0)
+ { if (fread(entry[1],tlen,1,input) != 1)
+ { EPRINTF(EPLACE,"Could not read deletions entry (Uncompress_Next_QVentry\n");
+ EXIT(1);
+ }
+ }
+ Uncompress_Read(clen,entry[1]);
+ Lower_Read(entry[1]);
+ }
+ else
+ { if (Decode_Run(coding->delScheme, coding->dRunScheme, input,
+ entry[0], rlen, coding->delChar))
+ EXIT(1);
+ clen = Packed_Length(entry[0],rlen,coding->delChar);
+ tlen = COMPRESSED_LEN(clen);
+ if (tlen > 0)
+ { if (fread(entry[1],tlen,1,input) != 1)
+ { EPRINTF(EPLACE,"Could not read deletions entry (Uncompress_Next_QVentry\n");
+ EXIT(1);
+ }
+ }
+ Uncompress_Read(clen,entry[1]);
+ Lower_Read(entry[1]);
+ Unpack_Tag(entry[1],clen,entry[0],rlen,coding->delChar);
+ }
+
+ if (Decode(coding->insScheme, input, entry[2], rlen))
+ EXIT(1);
+
+ if (Decode(coding->mrgScheme, input, entry[3], rlen))
+ EXIT(1);
+
+ if (coding->subChar < 0)
+ { if (Decode(coding->subScheme, input, entry[4], rlen))
+ EXIT(1);
+ }
+ else
+ { if (Decode_Run(coding->subScheme, coding->sRunScheme, input,
+ entry[4], rlen, coding->subChar))
+ EXIT(1);
+ }
+
+ return (0);
+}
diff --git a/DEXTRACTOR/QV.h b/DEXTRACTOR/QV.h
new file mode 100644
index 0000000..532b2f4
--- /dev/null
+++ b/DEXTRACTOR/QV.h
@@ -0,0 +1,96 @@
+/*******************************************************************************************
+ *
+ * Compressor/decompressor for .quiv files: customized Huffman codes for each stream based on
+ * the histogram of values occuring in a given file. The two low complexity streams
+ * (deletionQV and substitutionQV) use a Huffman coding of the run length of the prevelant
+ * character.
+ *
+ * Author: Gene Myers
+ * Date: Jan 18, 2014
+ * Modified: July 25, 2014
+ *
+ ********************************************************************************************/
+
+#ifndef _QV_COMPRESSOR
+
+#include <stdio.h>
+
+#define _QV_COMPRESSOR
+
+ // The defined constant INTERACTIVE (set in DB.h) determines whether an interactive or
+ // batch version of the routines in this library are compiled. In batch mode, routines
+ // print an error message and exit. In interactive mode, the routines place the error
+ // message in EPLACE (also defined in DB.h) and return an error value, typically NULL
+ // if the routine returns a pointer, and an unusual integer value if the routine returns
+ // an integer.
+ // Below when an error return is described, one should understand that this value is returned
+ // only if the routine was compiled in INTERACTIVE mode.
+
+ // A PacBio compression scheme
+
+typedef struct
+ { void *delScheme; // Huffman scheme for deletion QVs
+ void *insScheme; // Huffman scheme for insertion QVs
+ void *mrgScheme; // Huffman scheme for merge QVs
+ void *subScheme; // Huffman scheme for substitution QVs
+ void *dRunScheme; // Huffman scheme for deletion run lengths (if delChar > 0)
+ void *sRunScheme; // Huffman scheme for substitution run lengths (if subChar > 0)
+ int delChar; // If > 0, run-encoded deletion value
+ int subChar; // If > 0, run-encoded substitution value
+ int flip; // Need to flip multi-byte integers
+ char *prefix; // Header line prefix
+ } QVcoding;
+
+ // Read the next nlines of input, and QVentry returns a pointer to the first line if needed.
+ // If end-of-input is encountered before any further input, -1 is returned. If there is
+ // an error than -2 is returned. Otherwise the length of the line(s) read is returned.
+
+int Read_Lines(FILE *input, int nlines);
+char *QVentry();
+
+ // Get and set the line counter for error reporting
+
+void Set_QV_Line(int line);
+int Get_QV_Line();
+
+ // Read up to the next num entries or until eof from the .quiva file on input and record
+ // frequency statistics. Copy these entries to the temporary file temp if != NULL.
+ // If there is an error then -1 is returned, otherwise the number of entries read.
+
+int QVcoding_Scan(FILE *input, int num, FILE *temp);
+
+ // Given QVcoding_Scan has been called at least once, create an encoding scheme based on
+ // the accumulated statistics and return a pointer to it. The returned encoding object
+ // is *statically allocated within the routine. If lossy is set then use a lossy scaling
+ // for the insertion and merge streams. If there is an error, then NULL is returned.
+
+QVcoding *Create_QVcoding(int lossy);
+
+ // Read/write a coding scheme to input/output. The encoding object returned by the reader
+ // is *statically* allocated within the routine. If an error occurs while reading then
+ // NULL is returned.
+
+QVcoding *Read_QVcoding(FILE *input);
+void Write_QVcoding(FILE *output, QVcoding *coding);
+
+ // Free all the auxiliary storage associated with coding (but not the object itself!)
+
+void Free_QVcoding(QVcoding *coding);
+
+ // Assuming the file pointer is positioned just beyond an entry header line, read the
+ // next set of 5 QV lines, compress them according to 'coding', and output. If lossy
+ // is set then the scheme is a lossy one. A negative value is returned if an error
+ // occurred, and the sequence length otherwise.
+
+int Compress_Next_QVentry(FILE *input, FILE *output, QVcoding *coding, int lossy);
+
+ // Assuming the input is position just beyond the compressed encoding of an entry header,
+ // read the set of compressed encodings for the ensuing 5 QV vectors, decompress them,
+ // and place their decompressed values into entry which is a 5 element array of character
+ // pointers. The parameter rlen computed from the preceeding header line, critically
+ // provides the length of each of the 5 vectors. A non-zero value is return only if an
+ // error occured.
+
+int Uncompress_Next_QVentry(FILE *input, char **entry, QVcoding *coding, int rlen);
+
+#endif // _QV_COMPRESSOR
diff --git a/DEXTRACTOR/README b/DEXTRACTOR/README
new file mode 100644
index 0000000..6883aca
--- /dev/null
+++ b/DEXTRACTOR/README
@@ -0,0 +1,141 @@
+
+
+
+*** PLEASE GO TO THE DAZZLER BLOG (https://dazzlerblog.wordpress.com) FOR TYPESET ***
+ DOCUMENTATION, EXAMPLES OF USE, AND DESIGN PHILOSOPHY.
+
+
+
+/************************************************************************************\
+* *
+* Copyright (c) 2014, Dr. Eugene W. Myers (EWM). All rights reserved. *
+* *
+* Redistribution and use in source and binary forms, with or without modification, *
+* are permitted provided that the following conditions are met: *
+* *
+* · Redistributions of source code must retain the above copyright notice, this *
+* list of conditions and the following disclaimer. *
+* *
+* · Redistributions in binary form must reproduce the above copyright notice, this *
+* list of conditions and the following disclaimer in the documentation and/or *
+* other materials provided with the distribution. *
+* *
+* · The name of EWM may not be used to endorse or promote products derived from *
+* this software without specific prior written permission. *
+* *
+* THIS SOFTWARE IS PROVIDED BY EWM ”AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, *
+* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND *
+* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EWM BE LIABLE *
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES *
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS *
+* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY *
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
+* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN *
+* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
+* *
+* For any issues regarding this software and its use, contact EWM at: *
+* *
+* Eugene W. Myers Jr. *
+* Bautzner Str. 122e *
+* 01099 Dresden *
+* GERMANY *
+* Email: gene.myers at gmail.com *
+* *
+\************************************************************************************/
+
+
+ The Dextractor and Compression Command Library
+
+ Authors: Gene Myers, Martin Pippel
+ First: December 21, 2013
+ Current: February 26, 2014
+
+The Dextractor commands allow one to pull exactly and only the information needed for
+assembly and reconstruction from the source .bax.h5 HDF5 files produced by the PacBio
+RS II sequencer. Generally speaking, this information is the sequence of all the reads
+coded in the .bax.h5 file and a number of quality value (QV) streams needed by Quiver
+to produce a highly accurate consensus sequence as the last step in the assembly
+process. The Dextractor therefore produces a .fasta file of the sequence of all the
+reads, and a .quiva file containing the QV stream information in a .fastq readable
+format. For each of these two file types the library contains commands to compress the
+given file type, and to decompress it, which is a reversible process delivering the
+original uncompressed file. In this way, users of a PacBio can keep the data needed
+for assembly spooled up on disk in 1/14th the space occupied by the .bax.h5 files which
+can be archived to a cheap backup medium such as tape, should the raw data ever need to
+be consulted again (we expect never unless the spooled up data is compromised or lost
+in some way). The compressor/decompressor pairs are endian-aware so moving compressed
+files between machines is possible.
+
+1. dextract [-vq] [-o[<path>]] [-l<int(500)>] [-s<int(750)>] <input:bax.h5> ...
+
+ The dextract'or takes the .bax.h5 files produced for a given SMRT cell as
+input and:
+
+ (a) if the -o option is set, then the information needed for Quiver is extracted
+ and put in a file named <path>.quiva. If the -q option is not set, then the
+ sequence of each read is placed in a file named <path>.fasta, otherwise a
+ .fastq file of the sequence and the imputed "quality values" for each base in
+ the sequence is placed in a file named <path>.fastq. We personally do not
+ find these values useful and so never set -q but we give you the option in
+ case your downstream processes use such values.
+
+ If <path> is missing, then the path of the first .bax.h5 file is used for the
+ output file name, less any suffixes which are replaced by .fasta and .quiva.
+ E.G., the call "dextract -o EColi.1.bax.h5 EColi.2.bax.h5 Ecoli.3.bax.h5"
+ will result in the files EColi.fasta and Ecoli.quiva.
+
+ (b) if the -o option is not set, then if the -q option is also not set, then a
+ .fasta file of the sequence of each read is written to the standard output.
+ Otherwise a .fastq file is written to the standard output.
+
+ If the -v option is set then the program reports the processing of each .bax.h5
+ file, otherwise it runs silently. The parameter -l determines the shortest read
+ length to be extracted (default 500) and the -s parameter determines the minimum
+ quality/score of reads to be extracted (default 750 = 75%).
+
+
+2. dexta [-vk] ( -i | <path:fasta> .. .)
+ undexta [-vkU] [-w<int(80)>] ( -i | <path:dexta> ... )
+
+ Dexta compresses a set of .fasta files (produced by either Pacbio's software or
+ dextract) and replaces them with new files with a .dexta extension. That is,
+ submitting G.fasta will result in a compressed image G.dexta, and G.fasta
+ will no longer exist. With the -k option the .fasta source is *not* removed. If
+ -v is set, then the program reports its progress on each file. Otherwise it runs
+ completely silently (good for batch jobs to an HPC cluster). The compression
+ factor is always slightly better than 4.0. Undexta reverses the compression of
+ dexta, replacing the uncompressed image of G.dexta with G.fasta. By default the
+ sequences output by undexta are in lower case and 80 chars per line. The -U
+ option specifies upper case should be used, and the characters per line, or line
+ width, can be set to any positive value with the -w option
+
+ With the -i option set, the programs run as UNIX pipes that take .fasta (.dexta)
+ input from the standard input and write .dexta (.fasta) to the standard output.
+ In this case the -k option has no effect.
+
+
+3. dexqv [-vkl] <path:quiva> ...
+ undexqv [-vkU] <path:dexqv> ...
+
+ Dexqv compresses a set of .quiva files (produced by dextract) into new files with a
+ .dexqv extension. That is, submitting G.quiva will result in a compressed image
+ G.dexqv, and G.quiva will not longer exist. The -k flag prevents the removal
+ of G.quiva. With -v set progress is reported, otherwise the command runs
+ silently. If slightly more compression is desired at the expense of being a bit
+ "lossy" then set the -l option. This option is experimental in that it remains to
+ be seen if Quiver gives the same results with the scaled values responsible for the
+ loss. Undexqv reverses the compression of dexqv, replacing the uncompressed image
+ of G.dexqv with G.quiva. The flags are analgous to the v & k flags for dexqv.
+ The compression factor is typically 3.4 or so (4.0 or so with -l set). By .fastq
+ convention each QV vector is output by undexqv as a line without intervening
+ new-lines, and by default the Deletion Tag vector is in lower case letters. The -U
+ option specifies upper case letters should instead be used for said vector.
+
+
+ To compile the programs you must have the HDF5 library installed on your system and
+the library and include files for said must be on the appropriate search paths. The
+HDR5 library in turn depends on the presence of zlib, so make sure it is also installed
+on your system. The most recent version of the source for the HDF5 library can be
+obtained at:
+
+ http://www.hdfgroup.org/HDF5/release/obtainsrc.html
diff --git a/DEXTRACTOR/dexqv.c b/DEXTRACTOR/dexqv.c
new file mode 100644
index 0000000..675adb7
--- /dev/null
+++ b/DEXTRACTOR/dexqv.c
@@ -0,0 +1,164 @@
+/*******************************************************************************************
+ *
+ * Compressor for .quiv files, customized Huffman codes for each stream based on the
+ * histogram of values occuring in the given file. The two low complexity streams
+ * (deletionQV and substitutionQV) use a Huffman coding of the run length of the prevelant
+ * character.
+ *
+ * Author: Gene Myers
+ * Date: Jan 18, 2014
+ *
+ ********************************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <unistd.h>
+#include <stdint.h>
+
+#include "DB.h"
+
+static char *Usage = "[-vkl] <path:quiva> ...";
+
+int main(int argc, char* argv[])
+{ int VERBOSE;
+ int KEEP;
+ int LOSSY;
+
+ { int i, j, k;
+ int flags[128];
+
+ ARG_INIT("dexqv")
+
+ j = 1;
+ for (i = 1; i < argc; i++)
+ if (argv[i][0] == '-')
+ { ARG_FLAGS("vkl") }
+ else
+ argv[j++] = argv[i];
+ argc = j;
+
+ VERBOSE = flags['v'];
+ KEEP = flags['k'];
+ LOSSY = flags['l'];
+
+ if (argc == 1)
+ { fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
+ exit (1);
+ }
+ }
+
+ // For each .quiva file to be compressed:
+
+ { int i;
+
+ for (i = 1; i < argc; i++)
+ { char *pwd, *root;
+ uint16 half;
+ FILE *input, *output;
+ QVcoding *coding;
+
+ pwd = PathTo(argv[i]);
+ root = Root(argv[i],".quiva");
+ input = Fopen(Catenate(pwd,"/",root,".quiva"),"r");
+ if (input == NULL)
+ exit (1);
+ output = Fopen(Catenate(pwd,"/",root,".dexqv"),"w");
+ if (output == NULL)
+ exit (1);
+
+ if (VERBOSE)
+ { fprintf(stderr,"Processing '%s' ...\n",root);
+ fflush(stderr);
+ }
+
+ // Scan the file collecting statistics for Huffman schemes
+
+ Set_QV_Line(0);
+ QVcoding_Scan(input,INT32_MAX,NULL);
+
+ // Create and output the encoding schemes
+
+ coding = Create_QVcoding(LOSSY);
+
+ { char *slash, *read; // Get header line prefix from first line
+
+ rewind (input);
+ Read_Lines(input,1);
+ read = QVentry();
+
+ slash = index(read+1,'/');
+ coding->prefix = (char *) malloc((slash-read)+1);
+ if (coding->prefix == NULL)
+ { fprintf(stderr,"%s: Out of memory (Allocating header prefix)\n",Prog_Name);
+ exit (1);
+ }
+ *slash = '\0';
+ strcpy(coding->prefix,read);
+ *slash = '/';
+ }
+
+ half = 0x55aa;
+ fwrite(&half,sizeof(uint16),1,output);
+
+ Write_QVcoding(output,coding);
+
+ // For each entry do
+
+ { int lwell;
+
+ rewind (input);
+ Set_QV_Line(0);
+
+ lwell = 0;
+ while (Read_Lines(input,1) > 0)
+ { int well, beg, end, qv;
+ char *slash;
+ uint8 byte;
+
+ // Interpret the header, encode and write out the fields
+
+ slash = index(QVentry(),'/');
+ sscanf(slash+1,"%d/%d_%d RQ=0.%d\n",&well,&beg,&end,&qv);
+
+ while (well - lwell >= 255)
+ { byte = 0xff;
+ fwrite(&byte,1,1,output);
+ lwell += 255;
+ }
+ byte = (uint8) (well-lwell);
+ fwrite(&byte,1,1,output);
+ lwell = well;
+
+ fwrite(&beg,sizeof(int),1,output);
+ fwrite(&end,sizeof(int),1,output);
+ fwrite(&qv,sizeof(int),1,output);
+
+ Compress_Next_QVentry(input,output,coding,LOSSY);
+ }
+ }
+
+ // Clean up for the next file
+
+ Free_QVcoding(coding);
+
+ fclose(input);
+ fclose(output);
+
+ if (!KEEP)
+ unlink(Catenate(pwd,"/",root,".quiva"));
+ free(root);
+ free(pwd);
+
+ if (VERBOSE)
+ { fprintf(stderr,"Done\n");
+ fflush(stderr);
+ }
+ }
+ }
+
+ free(QVentry());
+
+ exit (0);
+}
diff --git a/DEXTRACTOR/dexta.c b/DEXTRACTOR/dexta.c
new file mode 100644
index 0000000..3ebe917
--- /dev/null
+++ b/DEXTRACTOR/dexta.c
@@ -0,0 +1,219 @@
+/*******************************************************************************************
+ *
+ * Compresses a .fasta file into a 2-bit per base .dexta file
+ *
+ * Author: Gene Myers
+ * Date : January 12, 2014
+ *
+ ********************************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include "DB.h"
+
+static char *Usage = "[-vk] ( -i | <path:fasta> ... )";
+
+#define MAX_BUFFER 100000
+
+// Compress read into 2-bits per base (from [0-3] per byte representation
+
+int main(int argc, char *argv[])
+{ int VERBOSE;
+ int KEEP;
+ int PIPE;
+
+ { int i, j, k;
+ int flags[128];
+
+ ARG_INIT("dexta")
+
+ j = 1;
+ for (i = 1; i < argc; i++)
+ if (argv[i][0] == '-')
+ { ARG_FLAGS("vki") }
+ else
+ argv[j++] = argv[i];
+ argc = j;
+
+ VERBOSE = flags['v'];
+ KEEP = flags['k'];
+ PIPE = flags['i'];
+
+ if ((PIPE && argc > 1) || (!PIPE && argc <= 1))
+ { fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
+ exit (1);
+ }
+ if (PIPE)
+ { KEEP = 1;
+ argc = 2;
+ }
+ }
+
+ // For each fasta file do:
+
+ { char *read;
+ int rmax;
+ int i;
+
+ rmax = MAX_BUFFER + 30000;
+ read = (char *) Malloc(rmax+1,"Allocating read buffer");
+ if (read == NULL)
+ exit (1);
+
+ for (i = 1; i < argc; i++)
+
+ { char *pwd, *root;
+ FILE *input, *output;
+ int eof;
+
+ // Open fasta file
+
+ if (PIPE)
+ { input = stdin;
+ output = stdout;
+ pwd = NULL;
+ root = Strdup("Standard Input","Allocaing string");
+ }
+ else
+ { pwd = PathTo(argv[i]);
+ root = Root(argv[i],".fasta");
+ input = Fopen(Catenate(pwd,"/",root,".fasta"),"r");
+ if (input == NULL)
+ exit (1);
+ output = Fopen(Catenate(pwd,"/",root,".dexta"),"w");
+ if (output == NULL)
+ exit (1);
+ }
+
+ if (VERBOSE)
+ { fprintf(stderr,"Processing '%s' ...\n",root);
+ fflush(stderr);
+ }
+
+ // Read the first header and output the endian key and short name
+
+ { char *slash;
+ uint16 half;
+ int x;
+
+ eof = (fgets(read,MAX_BUFFER,input) == NULL);
+ if (read[strlen(read)-1] != '\n')
+ { fprintf(stderr,"Line 1: Fasta line is too long (> %d chars)\n",MAX_BUFFER-2);
+ exit (1);
+ }
+ if (!eof && read[0] != '>')
+ { fprintf(stderr,"Line 1: First header in fasta file is missing\n");
+ exit (1);
+ }
+
+ slash = index(read,'/');
+ if (slash == NULL)
+ { fprintf(stderr,"%s: Header line incorrectly formatted ?\n",Prog_Name);
+ exit (1);
+ }
+
+ half = 0x55aa;
+ fwrite(&half,sizeof(uint16),1,output);
+
+ x = slash-read;
+ fwrite(&x,sizeof(int),1,output);
+ fwrite(read,1,slash-read,output);
+ }
+
+ // For each read do
+
+ { int nline, rlen, lwell;
+
+ nline = 1;
+ rlen = 0;
+ lwell = 0;
+ while (!eof)
+ { int well, beg, end, qv, x;
+ char *slash;
+ uint8 byte;
+
+ // Next header is always at read+(rlen+1). Interpret its fields
+
+ slash = index(read+(rlen+1),'/');
+ if (slash == NULL)
+ { fprintf(stderr,"%s: Header line incorrectly formatted ?\n",Prog_Name);
+ exit (1);
+ }
+ x = sscanf(slash+1,"%d/%d_%d RQ=0.%d\n",&well,&beg,&end,&qv);
+ if (x < 3)
+ { fprintf(stderr,"%s: Header line incorrectly formatted ?\n",Prog_Name);
+ exit (1);
+ }
+ else if (x == 3)
+ qv = 0;
+
+ // Read fasta sequence (@read) and stop at eof or after having read next header
+
+ rlen = 0;
+ while (1)
+ { int x;
+
+ eof = (fgets(read+rlen,MAX_BUFFER,input) == NULL);
+ nline += 1;
+ x = strlen(read+rlen)-1;
+ if (read[rlen+x] != '\n')
+ { fprintf(stderr,"Line %d: Fasta line is too long (> %d chars)\n",
+ nline,MAX_BUFFER-2);
+ exit (1);
+ }
+ if (eof || read[rlen] == '>')
+ break;
+ rlen += x;
+ if (rlen + MAX_BUFFER > rmax)
+ { rmax = ((int) (1.2 * rmax)) + 1000 + MAX_BUFFER;
+ read = (char *) Realloc(read,rmax+1,"Reallocaing read buffer");
+ if (read == NULL)
+ exit (1);
+ }
+ }
+ read[rlen] = '\0';
+
+ // Compress the header fields and output (except for short name, only output once)
+
+ while (well - lwell >= 255)
+ { byte = 0xff;
+ fwrite(&byte,1,1,output);
+ lwell += 255;
+ }
+ byte = (uint8) (well-lwell);
+ fwrite(&byte,1,1,output);
+ lwell = well;
+
+ fwrite(&beg,sizeof(int),1,output);
+ fwrite(&end,sizeof(int),1,output);
+ fwrite(&qv,sizeof(int),1,output);
+
+ // Compress read and output
+
+ Number_Read(read);
+ Compress_Read(rlen,read);
+ fwrite(read,1,COMPRESSED_LEN(rlen),output);
+ }
+ }
+
+ if (!KEEP)
+ unlink(Catenate(pwd,"/",root,".fasta"));
+ free(root);
+ free(pwd);
+
+ if (VERBOSE)
+ { fprintf(stderr,"Done\n");
+ fflush(stderr);
+ }
+ }
+
+ free(read);
+ }
+
+ exit (0);
+}
diff --git a/DEXTRACTOR/dextract.c b/DEXTRACTOR/dextract.c
new file mode 100644
index 0000000..74ed561
--- /dev/null
+++ b/DEXTRACTOR/dextract.c
@@ -0,0 +1,594 @@
+/*******************************************************************************************
+ *
+ * Dextractor: pullls requested info out of .bax.h5 files produced by Pacbio
+ *
+ *
+ * Author: Martin Pippel
+ * Date : Dec 12, 2013
+ *
+ * Author: Gene Myers
+ * Date: Jan 8, 2014, redesign of the modes of operation and flags, and also the
+ * logic for extraction in writeBaxReads
+ *
+ ********************************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <math.h>
+#include <ctype.h>
+#include <sys/stat.h>
+
+#include <hdf5.h>
+
+#include "DB.h"
+
+#define LOWER_OFFSET 32
+#define PHRED_OFFSET 33
+
+static char *Usage = "[-vq] [-o[<path>]] [-l<int(500)>] [-s<int(750)>] <input:bax_h5> ...";
+
+#define DEXTRACT
+
+// Exception codes
+
+#define CANNOT_OPEN_BAX_FILE 1
+#define BAX_BASECALL_ERR 2
+#define BAX_DEL_ERR 3
+#define BAX_TAG_ERR 4
+#define BAX_INS_ERR 5
+#define BAX_MRG_ERR 6
+#define BAX_SUB_ERR 7
+#define BAX_QV_ERR 8
+#define BAX_NR_EVENTS_ERR 9
+#define BAX_REGION_ERR 10
+#define BAX_HOLESTATUS_ERR 11
+
+typedef struct
+ { char *fullName; // full file path
+ char *shortName; // without path and file extension (used in header line)
+ int fastq; // if non-zero produce a fastq file instead of a fasta file
+ int quivqv; // if non-zero produce a quiv file
+
+ hsize_t numBP; // sum of all raw read lengths
+ char *baseCall; // 7 streams that may be extracted dependent on flag settings
+ char *delQV;
+ char *delTag;
+ char *insQV;
+ char *mergeQV;
+ char *subQV;
+ char *fastQV;
+
+ hsize_t numZMW; // number of wells/holes
+ int *readLen; // length of each read in events
+ char *holeType; // Hole type, only SEQUENCING holes are extracted
+
+ hsize_t numHQR; // number of regions
+ int *regions; // region information (5 ints per entry)
+
+ int delLimit; // The Del QV associated with N's in the Del Tag
+
+ } BaxData;
+
+// Initialize *the* BaxData structure
+
+static void initBaxData(BaxData *b, int fastq, int quivqv)
+{ b->fullName = NULL;
+ b->shortName = NULL;
+ b->fastq = fastq;
+ b->quivqv = quivqv;
+ b->baseCall = NULL;
+ b->delQV = NULL;
+ b->delTag = NULL;
+ b->insQV = NULL;
+ b->mergeQV = NULL;
+ b->subQV = NULL;
+ b->fastQV = NULL;
+ b->readLen = NULL;
+ b->holeType = NULL;
+ b->regions = NULL;
+ b->delLimit = 0;
+}
+
+// Record the names of the next bax file and reset the memory buffer high-water mark
+
+static void initBaxNames(BaxData *b, char *fname, char *hname)
+{ b->fullName = fname;
+ b->shortName = hname;
+ b->numBP = 0;
+ b->numZMW = 0;
+ b->numHQR = 0;
+}
+
+// Check if memory needed is above highwater mark, and if so allocate
+
+static void ensureBases(BaxData *b, hsize_t len)
+{ static hsize_t smax = 0;
+
+ b->numBP = len;
+ if (smax < len)
+ { smax = 1.2*len + 10000;
+ b->baseCall = (char *) Realloc(b->baseCall, smax, "Allocating basecall vector");
+ if (b->fastq)
+ b->fastQV = (char *) Realloc(b->fastQV, smax, "Allocating fastq vector");
+ if (b->quivqv)
+ { b->delQV = (char *) Realloc(b->delQV, 5ll*smax, "Allocating 5 QV vectors");
+ b->delTag = b->delQV + smax;
+ b->insQV = b->delTag + smax;
+ b->mergeQV = b->insQV + smax;
+ b->subQV = b->mergeQV + smax;
+ }
+ }
+}
+
+static void ensureZMW(BaxData *b, hsize_t len)
+{ static hsize_t smax = 0;
+
+ b->numZMW = len;
+ if (smax < len)
+ { smax = 1.2*len + 10000;
+ b->holeType = (char *) Realloc(b->holeType, smax, "Allocating hole vector");
+ b->readLen = (int *) Realloc(b->readLen , smax * sizeof(int), "Allocating event vector");
+ }
+}
+
+static void ensureHQR(BaxData *b, hsize_t len)
+{ static hsize_t smax = 0;
+
+ b->numHQR = len;
+ if (smax < len)
+ { smax = 1.2*len + 10000;
+ b->regions = (int *) Realloc(b->regions, (5ll*smax+1)*sizeof(int), "Allocating region vector");
+ }
+}
+
+// Fetch the relevant contents of the current bax.h5 file and return the H5 file id.
+
+static int getBaxData(BaxData *b)
+{ hid_t field_space;
+ hid_t field_set;
+ hsize_t field_len[2];
+ hid_t file_id;
+ herr_t stat;
+ int ecode;
+
+ H5Eset_auto(H5E_DEFAULT,0,0); // silence hdf5 error stack
+
+ file_id = H5Fopen(b->fullName, H5F_ACC_RDONLY, H5P_DEFAULT);
+ if (file_id < 0)
+ return (CANNOT_OPEN_BAX_FILE);
+
+#ifdef DEBUG
+ printf("PROCESSING %s, file_id: %d\n", baxFileName, file_id);
+#endif
+
+#define GET_SIZE(path,error) \
+ { ecode = error; \
+ if ((field_set = H5Dopen2(file_id, path, H5P_DEFAULT)) < 0) goto exit0; \
+ if ((field_space = H5Dget_space(field_set)) < 0) goto exit1; \
+ H5Sget_simple_extent_dims(field_space, field_len, NULL); \
+ }
+
+#define FETCH(field,type) \
+ { stat = H5Dread(field_set, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, b->field); \
+ H5Sclose(field_space); \
+ H5Dclose(field_set); \
+ if (stat < 0) goto exit0; \
+ }
+
+#define CHECK_FETCH(path,error,field,type,cntr) \
+ { GET_SIZE(path,error) \
+ if (b->cntr != field_len[0]) goto exit2; \
+ FETCH(field,type) \
+ }
+
+ GET_SIZE("/PulseData/BaseCalls/Basecall",BAX_BASECALL_ERR)
+ ensureBases(b,field_len[0]);
+ FETCH(baseCall,H5T_NATIVE_UCHAR)
+ if (b->fastq)
+ CHECK_FETCH("/PulseData/BaseCalls/QualityValue",BAX_QV_ERR,fastQV,H5T_NATIVE_UCHAR,numBP)
+ if (b->quivqv)
+ { CHECK_FETCH("/PulseData/BaseCalls/DeletionQV", BAX_DEL_ERR,delQV, H5T_NATIVE_UCHAR,numBP)
+ CHECK_FETCH("/PulseData/BaseCalls/DeletionTag", BAX_TAG_ERR,delTag, H5T_NATIVE_UCHAR,numBP)
+ CHECK_FETCH("/PulseData/BaseCalls/InsertionQV", BAX_INS_ERR,insQV, H5T_NATIVE_UCHAR,numBP)
+ CHECK_FETCH("/PulseData/BaseCalls/MergeQV", BAX_MRG_ERR,mergeQV,H5T_NATIVE_UCHAR,numBP)
+ CHECK_FETCH("/PulseData/BaseCalls/SubstitutionQV",BAX_SUB_ERR,subQV, H5T_NATIVE_UCHAR,numBP)
+ }
+
+ GET_SIZE("/PulseData/BaseCalls/ZMW/HoleStatus",BAX_HOLESTATUS_ERR)
+ ensureZMW(b,field_len[0]);
+ FETCH(holeType,H5T_NATIVE_UCHAR)
+ CHECK_FETCH("/PulseData/BaseCalls/ZMW/NumEvent",BAX_NR_EVENTS_ERR,readLen,H5T_NATIVE_INT,numZMW)
+
+ GET_SIZE("/PulseData/Regions",BAX_REGION_ERR)
+ ensureHQR(b,field_len[0]);
+ FETCH(regions,H5T_NATIVE_INT)
+
+ // Find the Del QV associated with N's in the Del Tag
+
+ if (b->quivqv)
+ { hsize_t i;
+
+ for (i = 0; i < b->numBP; i++)
+ if (b->delTag[i] == 'N')
+ { b->delLimit = b->delQV[i];
+ break;
+ }
+ }
+
+ return (0);
+
+exit2:
+ H5Sclose(field_space);
+exit1:
+ H5Dclose(field_set);
+exit0:
+ H5Fclose(file_id);
+ return (ecode);
+}
+
+// Find the good read invervals of the baxfile b(FileID), output the reads of length >= minLen and
+// score >= minScore to output (for the fasta or fastq part) and qvquiv (if b->quivqv is set)
+
+static char *fasta_header = ">%s/%d/%d_%d RQ=0.%d\n";
+static char *fastq_header = "@%s/%d/%d_%d RQ=0.%d\n";
+
+static void writeBaxReads(BaxData *b, int minLen, int minScore, FILE *output, FILE* qvquiv)
+{ int nreads, *rlen;
+ int roff, *hlen, *cur, h, w;
+ int tolower;
+ char *header;
+
+ char *baseCall;
+ char *delQV;
+ char *delTag;
+ char *insQV;
+ char *mergeQV;
+ char *subQV;
+ char *fastQV;
+
+ baseCall = b->baseCall;
+ delQV = b->delQV;
+ delTag = b->delTag;
+ insQV = b->insQV;
+ mergeQV = b->mergeQV;
+ subQV = b->subQV;
+ fastQV = b->fastQV;
+
+#ifdef DEBUG
+ printf("printSubreadFields\n");
+#endif
+
+#define HOLE 0
+#define TYPE 1
+#define ADAPTER_REGION 0
+#define INSERT_REGION 1
+#define HQV_REGION 2
+#define START 2
+#define FINISH 3
+#define SCORE 4
+
+ // Find the HQV regions and output as reads according to the various output options
+
+ tolower = isupper(b->baseCall[0]);
+ if (b->fastq)
+ header = fastq_header;
+ else
+ header = fasta_header;
+
+ rlen = b->readLen;
+ roff = 0;
+ cur = b->regions;
+ nreads = b->numZMW + cur[HOLE];
+ hlen = rlen - cur[HOLE];
+ cur[5*b->numHQR] = nreads;
+
+ for (h = cur[HOLE], w = 0; h < nreads; h++, w++)
+ { int *bot, *top, *hqv, *r;
+ int hbeg, hend, qv;
+ int ibeg, iend;
+
+ if (hlen[h] >= minLen)
+ { while (cur[HOLE] < h)
+ cur += 5;
+ bot = hqv = cur;
+ while (cur[HOLE] <= h)
+ { if (cur[TYPE] == HQV_REGION)
+ hqv = cur;
+ cur += 5;
+ }
+ top = cur-5;
+
+ qv = hqv[SCORE];
+ if (qv >= minScore)
+ { hbeg = hqv[START];
+ hend = hqv[FINISH];
+ for (r = bot; r <= top; r += 5)
+ { if (r[TYPE] != INSERT_REGION)
+ continue;
+
+ ibeg = r[START];
+ iend = r[FINISH];
+
+ if (ibeg < hbeg)
+ ibeg = hbeg;
+ if (iend > hend)
+ iend = hend;
+ if (iend - ibeg < minLen || b->holeType[w] > 0)
+ continue;
+
+ fprintf(output,header,b->shortName,h,ibeg,iend,qv);
+
+ ibeg += roff;
+ iend += roff;
+
+ if (tolower)
+ { int a;
+
+ for (a = ibeg; a < iend; a++)
+ baseCall[a] += LOWER_OFFSET;
+ if (b->quivqv)
+ for (a = ibeg; a < iend; a++)
+ delTag[a] += LOWER_OFFSET;
+ }
+
+ if (b->fastq)
+ { int a;
+
+ fprintf(output,"%.*s\n", iend-ibeg, baseCall + ibeg);
+ fprintf(output,"+\n");
+ for (a = ibeg; a < iend; a++)
+ fputc(fastQV[a]+PHRED_OFFSET,output);
+ fputc('\n',output);
+ }
+ else
+ { int a;
+
+ for (a = ibeg; a < iend; a += 80)
+ if (a+80 > iend)
+ fprintf(output,"%.*s\n", iend-a, baseCall + a);
+ else
+ fprintf(output,"%.80s\n", baseCall + a);
+ }
+
+ if (b->quivqv)
+ { int a, d;
+
+ fprintf(qvquiv,"@%s/%d/%d_%d RQ=0.%d\n",
+ b->shortName,h,ibeg-roff,iend-roff,qv);
+
+ d = b->delLimit;
+ for (a = ibeg; a < iend; a++)
+ { if (delQV[a] == d)
+ delTag[a] = 'n';
+ delQV[a] += PHRED_OFFSET;
+ insQV[a] += PHRED_OFFSET;
+ mergeQV[a] += PHRED_OFFSET;
+ subQV[a] += PHRED_OFFSET;
+ }
+
+ iend -= ibeg;
+ fprintf (qvquiv, "%.*s\n", iend, delQV + ibeg);
+ fprintf (qvquiv, "%.*s\n", iend, delTag + ibeg);
+ fprintf (qvquiv, "%.*s\n", iend, insQV + ibeg);
+ fprintf (qvquiv, "%.*s\n", iend, mergeQV + ibeg);
+ fprintf (qvquiv, "%.*s\n", iend, subQV + ibeg);
+ }
+ }
+ }
+ }
+ roff += hlen[h];
+ }
+}
+
+// Print an error message
+
+static void printBaxError(int ecode)
+{ fprintf(stderr," *** Warning ***: ");
+ switch (ecode)
+ { case CANNOT_OPEN_BAX_FILE:
+ fprintf(stderr,"Cannot open bax file:\n");
+ break;
+ case BAX_BASECALL_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/BaseCalls/Basecall from file:\n");
+ break;
+ case BAX_DEL_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/BaseCalls/DeletionQV from file:\n");
+ break;
+ case BAX_TAG_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/BaseCalls/DeletionTag from file:\n");
+ break;
+ case BAX_INS_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/BaseCalls/InsertionQV from file:\n");
+ break;
+ case BAX_MRG_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/BaseCalls/MergeQV from file:\n");
+ break;
+ case BAX_SUB_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/BaseCalls/SubstitutionQV from file:\n");
+ break;
+ case BAX_QV_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/BaseCalls/QualityValue from file:\n");
+ break;
+ case BAX_NR_EVENTS_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/BaseCalls/ZMW/NumEvent from file:\n");
+ break;
+ case BAX_REGION_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/Regions from file:\n");
+ break;
+ case BAX_HOLESTATUS_ERR:
+ fprintf(stderr,"Cannot parse /PulseData/BaseCalls/ZMW/HoleStatus from file:\n");
+ break;
+ default:
+ fprintf(stderr,"Cannot parse bax file:\n");
+ break;
+ }
+ fflush(stderr);
+}
+
+// Free *the* bax data structure
+
+static void freeBaxData(BaxData *b)
+{ free(b->baseCall);
+ free(b->delQV);
+ free(b->fastQV);
+ free(b->holeType);
+ free(b->readLen);
+ free(b->regions);
+}
+
+int main(int argc, char* argv[])
+{ char *output;
+ FILE *fileOut;
+ FILE *fileQuiv;
+
+ int FASTQ;
+ int QUIVQV;
+ int MIN_LEN;
+ int MIN_SCORE;
+ int VERBOSE;
+
+ BaxData b;
+
+ // Check that zlib library is present
+
+ if ( ! H5Zfilter_avail(H5Z_FILTER_DEFLATE))
+ { fprintf(stderr,"%s: zlib library is not present, check build/installation\n",Prog_Name);
+ exit (1);
+ }
+
+ { int i, j, k;
+ int flags[128];
+ char *eptr;
+
+ ARG_INIT("dextract")
+
+ MIN_LEN = 500;
+ MIN_SCORE = 750;
+ QUIVQV = 0;
+ output = NULL;
+
+ j = 1;
+ for (i = 1; i < argc; i++)
+ if (argv[i][0] == '-')
+ switch (argv[i][1])
+ { default:
+ ARG_FLAGS("qv")
+ break;
+ case 's':
+ ARG_NON_NEGATIVE(MIN_SCORE,"Subread score threshold")
+ break;
+ case 'l':
+ ARG_NON_NEGATIVE(MIN_LEN,"Minimum length threshold")
+ break;
+ case 'o':
+ QUIVQV = 1;
+ output = argv[i]+2;
+ break;
+ }
+ else
+ argv[j++] = argv[i];
+ argc = j;
+
+ VERBOSE = flags['v'];
+ FASTQ = flags['q'];
+
+ if (argc == 1)
+ { fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
+ exit (1);
+ }
+ }
+
+ fileQuiv = NULL;
+ if (QUIVQV)
+ { int explicit;
+
+ explicit = (*output != '\0');
+ if ( ! explicit)
+ output = Root(argv[1],NULL);
+
+ if (FASTQ)
+ fileOut = Fopen(Catenate("","",output,".fastq"), "w");
+ else
+ fileOut = Fopen(Catenate("","",output,".fasta"), "w");
+ fileQuiv = Fopen(Catenate("","",output,".quiva"), "w");
+ if (fileOut == NULL || fileQuiv == NULL)
+ exit (1);
+
+ if (explicit)
+ output = Root(output,NULL);
+ }
+ else
+ fileOut = stdout;
+
+ if (VERBOSE)
+ { fprintf(stderr, "Minimum length: %d\n", MIN_LEN);
+ fprintf(stderr, "Minimum score : %d\n", MIN_SCORE);
+ }
+
+ initBaxData(&b,FASTQ,QUIVQV);
+
+ { int i;
+
+ for (i = 1; i < argc; i++)
+ { char *root, *full, *input;
+ int ecode;
+
+ { char *pwd;
+ FILE *in;
+
+ pwd = PathTo(argv[i]);
+ root = Root(argv[i],".bax.h5");
+ full = Strdup(Catenate(pwd,"/",root,".bax.h5"),"Allocating full name");
+ input = Root(argv[i],NULL);
+
+ free(pwd);
+
+ if ((in = fopen(full,"r")) == NULL)
+ { fprintf(stderr,"%s: Cannot find %s !\n",Prog_Name,input);
+ exit (1);
+ }
+ else
+ fclose(in);
+ }
+
+ if (QUIVQV)
+ initBaxNames(&b,full,output);
+ else
+ initBaxNames(&b,full,input);
+
+ if (VERBOSE)
+ { fprintf(stderr, "Fetching file : %s ...\n", root); fflush(stderr); }
+
+ if ((ecode = getBaxData(&b)) == 0)
+ { if (VERBOSE)
+ { fprintf(stderr, "Extracting subreads ...\n"); fflush(stderr); }
+ writeBaxReads(&b, MIN_LEN, MIN_SCORE, fileOut, fileQuiv);
+ if (VERBOSE)
+ { fprintf(stderr, "Done\n"); fflush(stdout); }
+ }
+ else
+ { if (VERBOSE)
+ fprintf(stderr, "Skipping due to failure\n");
+ else
+ fprintf(stderr, "Skipping %s due to failure\n",root);
+ printBaxError(ecode);
+ }
+
+ free(root);
+ free(full);
+ free(input);
+ }
+ }
+
+ freeBaxData(&b);
+ if (fileOut != stdout)
+ fclose(fileOut);
+ if (fileQuiv != NULL)
+ fclose(fileQuiv);
+ if (QUIVQV)
+ free(output);
+
+ exit (0);
+}
diff --git a/DEXTRACTOR/undexqv.c b/DEXTRACTOR/undexqv.c
new file mode 100644
index 0000000..3a41d31
--- /dev/null
+++ b/DEXTRACTOR/undexqv.c
@@ -0,0 +1,230 @@
+/*******************************************************************************************
+ *
+ * Uncompressor for .dexqv files
+ *
+ * Author: Gene Myers
+ * Date: Jan 18, 2014
+ *
+ ********************************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <unistd.h>
+
+#include "DB.h"
+
+static char *Usage = "[-vkU] <path:dexqv> ...";
+
+static void flip_short(void *w)
+{ uint8 *v = (uint8 *) w;
+ uint8 x;
+
+ x = v[0];
+ v[0] = v[1];
+ v[1] = x;
+}
+
+static void flip_long(void *w)
+{ uint8 *v = (uint8 *) w;
+ uint8 x;
+
+ x = v[0];
+ v[0] = v[3];
+ v[3] = x;
+ x = v[1];
+ v[1] = v[2];
+ v[2] = x;
+}
+
+int main(int argc, char* argv[])
+{ int VERBOSE;
+ int KEEP;
+ int UPPER;
+
+ { int i, j, k;
+ int flags[128];
+
+ ARG_INIT("undexqv")
+
+ j = 1;
+ for (i = 1; i < argc; i++)
+ if (argv[i][0] == '-')
+ { ARG_FLAGS("vkU") }
+ else
+ argv[j++] = argv[i];
+ argc = j;
+
+ VERBOSE = flags['v'];
+ KEEP = flags['k'];
+ UPPER = flags['U'];
+
+ if (argc == 1)
+ { fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
+ exit (1);
+ }
+ }
+
+ // For each .dexqv file to be decompressed
+
+ { int i;
+ char *entry[5] = { NULL, NULL, NULL, NULL, NULL };
+ int emax = -1;
+
+ for (i = 1; i < argc; i++)
+ { char *pwd, *root;
+ uint16 half;
+ int newv;
+ FILE *input, *output;
+ QVcoding *coding;
+
+ // Open it and the appropriately named .quiva file
+
+ pwd = PathTo(argv[i]);
+ root = Root(argv[i],".dexqv");
+ input = Fopen(Catenate(pwd,"/",root,".dexqv"),"r");
+ if (input == NULL)
+ exit (1);
+ output = Fopen(Catenate(pwd,"/",root,".quiva"),"w");
+ if (output == NULL)
+ exit (1);
+
+ if (VERBOSE)
+ { fprintf(stderr,"Processing '%s' ...\n",root);
+ fflush(stderr);
+ }
+
+ // Read in compression scheme
+
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ if (half == 0x55aa || half == 0xaa55)
+ newv = 1;
+ else
+ { newv = 0;
+ rewind(input);
+ }
+
+ coding = Read_QVcoding(input);
+
+ // For each compressed entry do
+
+ { int well;
+
+ well = 0;
+ while (1)
+ { int beg, end, qv, rlen;
+ uint16 half;
+ uint8 byte;
+ int e;
+
+ // Decode the compressed header and write it out
+
+ if (fread(&byte,1,1,input) < 1) break;
+ while (byte == 255)
+ { well += 255;
+ if (fread(&byte,1,1,input) != 1)
+ SYSTEM_ERROR
+ }
+ well += byte;
+
+ if (newv)
+ if (coding->flip)
+ { if (fread(&beg,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ flip_long(&beg);
+ if (fread(&end,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ flip_long(&end);
+ if (fread(&qv,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ flip_long(&qv);
+ }
+ else
+ { if (fread(&beg,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ if (fread(&end,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ if (fread(&qv,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ }
+ else
+ if (coding->flip)
+ { if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ flip_short(&half);
+ beg = half;
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ flip_short(&half);
+ end = half;
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ flip_short(&half);
+ qv = half;
+ }
+ else
+ { if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ beg = half;
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ end = half;
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ qv = half;
+ }
+
+ fprintf(output,"%s/%d/%d_%d RQ=0.%d\n",coding->prefix,well,beg,end,qv);
+
+ // Decode the QV entry and write it out
+
+ rlen = end-beg;
+ if (rlen > emax)
+ { emax = ((int) (1.2*rlen)) + 1000;
+ entry[0] = (char *) Realloc(entry[0],5*emax,"Reallocating QV entry buffer");
+ if (entry[0] == NULL)
+ exit (1);
+ for (e = 1; e < 5; e++)
+ entry[e] = entry[e-1] + emax;
+ }
+
+ Uncompress_Next_QVentry(input,entry,coding,rlen);
+
+ if (UPPER)
+ { char *deltag = entry[1];
+ int j;
+
+ for (j = 0; j < rlen; j++)
+ deltag[j] -= 32;
+ }
+
+ for (e = 0; e < 5; e++)
+ fprintf(output,"%.*s\n",rlen,entry[e]);
+ }
+ }
+
+ // Clean up for the next file
+
+ Free_QVcoding(coding);
+
+ fclose(input);
+ fclose(output);
+
+ if (!KEEP)
+ unlink(Catenate(pwd,"/",root,".dexqv"));
+ free(root);
+ free(pwd);
+
+ if (VERBOSE)
+ { fprintf(stderr,"Done\n");
+ fflush(stderr);
+ }
+ }
+ }
+
+ free(QVentry());
+
+ exit (0);
+}
diff --git a/DEXTRACTOR/undexta.c b/DEXTRACTOR/undexta.c
new file mode 100644
index 0000000..a6643ba
--- /dev/null
+++ b/DEXTRACTOR/undexta.c
@@ -0,0 +1,285 @@
+/*******************************************************************************************
+ *
+ * Uncompresses a .dexta file (2-bit per base compression) back to a .fasta file
+ *
+ * Author: Gene Myers
+ * Date : January 12, 2014
+ ********************************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include "DB.h"
+
+static char *Usage = "[-vkU] [-w<int(80)>] ( -i | <path:dexta> ... )";
+
+#define MAX_BUFFER 100000
+
+// Uncompress read from 2-bits per base into [0-3] per byte representation
+
+static void flip_long(void *w)
+{ uint8 *v = (uint8 *) w;
+ uint8 x;
+
+ x = v[0];
+ v[0] = v[3];
+ v[3] = x;
+ x = v[1];
+ v[1] = v[2];
+ v[2] = x;
+}
+
+static void flip_short(void *w)
+{ uint8 *v = (uint8 *) w;
+ uint8 x;
+
+ x = v[0];
+ v[0] = v[1];
+ v[1] = x;
+}
+
+int main(int argc, char *argv[])
+{ int VERBOSE;
+ int KEEP;
+ int UPPER;
+ int WIDTH;
+ int PIPE;
+
+ { int i, j, k;
+ int flags[128];
+ char *eptr;
+
+ ARG_INIT("undexta")
+
+ WIDTH = 80;
+
+ j = 1;
+ for (i = 1; i < argc; i++)
+ if (argv[i][0] == '-')
+ switch (argv[i][1])
+ { default:
+ ARG_FLAGS("vkiU")
+ break;
+ case 'w':
+ ARG_NON_NEGATIVE(WIDTH,"Line width")
+ break;
+ }
+ else
+ argv[j++] = argv[i];
+ argc = j;
+
+ VERBOSE = flags['v'];
+ KEEP = flags['k'];
+ UPPER = flags['U'];
+ PIPE = flags['i'];
+
+ if ((PIPE && argc > 1) || (!PIPE && argc <= 1))
+ { fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
+ exit (1);
+ }
+ if (PIPE)
+ { KEEP = 1;
+ argc = 2;
+ }
+ }
+
+ // For each .dexta file do
+
+ { char *read;
+ int rmax;
+ int i;
+
+ rmax = MAX_BUFFER + 30000;
+ read = (char *) Malloc(rmax+1,"Allocating read buffer");
+ for (i = 1; i < argc; i++)
+ { char *pwd, *root;
+ FILE *input, *output;
+
+ // Open dexta file
+
+ if (PIPE)
+ { input = stdin;
+ output = stdout;
+ pwd = NULL;
+ root = Strdup("Standard Input","Allocaing string");
+ }
+ else
+ { pwd = PathTo(argv[i]);
+ root = Root(argv[i],".dexta");
+ input = Fopen(Catenate(pwd,"/",root,".dexta"),"r");
+ if (input == NULL)
+ exit (1);
+ output = Fopen(Catenate(pwd,"/",root,".fasta"),"w");
+ if (output == NULL)
+ exit (1);
+ }
+
+ if (VERBOSE)
+ { fprintf(stderr,"Processing '%s' ...\n",root);
+ fflush(stderr);
+ }
+
+ { char *name;
+ int well, flip, newv;
+
+ // Read endian key and short name common to all headers
+
+ { uint16 half;
+
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ if (half == 0x33cc)
+ { flip = 0;
+ newv = 0;
+ }
+ else if (half == 0xcc33)
+ { flip = 1;
+ newv = 0;
+ }
+ else if (half == 0x55aa)
+ { flip = 0;
+ newv = 1;
+ }
+ else if (half == 0xaa55)
+ { flip = 1;
+ newv = 1;
+ }
+ else
+ { fprintf(stderr,"%s: Not a .dexta file, endian key invalid\n",Prog_Name);
+ exit (1);
+ }
+
+ if (fread(&well,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ if (flip) flip_long(&well);
+ name = (char *) Malloc(well+1,"Allocating header prefix");
+ if (well > 0)
+ { if (fread(name,well,1,input) != 1)
+ SYSTEM_ERROR
+ }
+ name[well] = '\0';
+ }
+
+ // For each encoded entry do
+
+ well = 0;
+ while (1)
+ { int rlen, beg, end, qv;
+ int clen;
+ uint8 byte;
+
+ // Read and decompress header and output
+
+ if (fread(&byte,1,1,input) < 1) break;
+ while (byte == 255)
+ { well += 255;
+ if (fread(&byte,1,1,input) != 1)
+ SYSTEM_ERROR
+ }
+ well += byte;
+
+ if (newv)
+ if (flip)
+ { if (fread(&beg,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ flip_long(&beg);
+ if (fread(&end,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ flip_long(&end);
+ if (fread(&qv,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ flip_long(&qv);
+ }
+ else
+ { if (fread(&beg,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ if (fread(&end,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ if (fread(&qv,sizeof(int),1,input) != 1)
+ SYSTEM_ERROR
+ }
+ else
+ if (flip)
+ { uint16 half;
+
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ flip_short(&half);
+ beg = half;
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ flip_short(&half);
+ end = half;
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ flip_short(&half);
+ qv = half;
+ }
+ else
+ { uint16 half;
+
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ beg = half;
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ end = half;
+ if (fread(&half,sizeof(uint16),1,input) != 1)
+ SYSTEM_ERROR
+ qv = half;
+ }
+
+ fprintf(output,"%s/%d/%d_%d RQ=0.%d\n",name,well,beg,end,qv);
+
+ // Read compressed sequence (into buffer big enough for uncompressed sequence)
+ // Uncompress and output WIDTH symbols to a line
+
+ rlen = end-beg;
+ if (rlen > rmax)
+ { rmax = ((int) (1.2 * rmax)) + 1000 + MAX_BUFFER;
+ read = (char *) Realloc(read,rmax+1,"Allocating read buffer");
+ }
+ clen = COMPRESSED_LEN(rlen);
+ if (clen > 0)
+ { if (fread(read,clen,1,input) != 1)
+ SYSTEM_ERROR
+ }
+ Uncompress_Read(rlen,read);
+ if (UPPER)
+ Upper_Read(read);
+ else
+ Lower_Read(read);
+
+ { int j;
+
+ for (j = 0; j < rlen; j += WIDTH)
+ if (j+WIDTH > rlen)
+ fprintf(output,"%.*s\n", rlen-j, read+j);
+ else
+ fprintf(output,"%.*s\n", WIDTH, read+j);
+ }
+ }
+
+ free(name);
+ }
+
+ if (!KEEP)
+ unlink(Catenate(pwd,"/",root,".dexta"));
+ free(root);
+ free(pwd);
+
+ if (VERBOSE)
+ { fprintf(stderr,"Done\n");
+ fflush(stderr);
+ }
+ }
+
+ free(read);
+ }
+
+ exit (0);
+}
diff --git a/FALCON-examples/git-sym.makefile b/FALCON-examples/git-sym.makefile
index 2041a81..aecdd97 100644
--- a/FALCON-examples/git-sym.makefile
+++ b/FALCON-examples/git-sym.makefile
@@ -8,12 +8,6 @@ foo:
# This is just for testing git-sym. Sorry for touching home dir.
-touch ~/foo
cp -f ~/foo $@
-m140913_050931_42139_c100713652400000001823152404301535_s1_p0.1.subreads.fasta:
- curl -L https://www.dropbox.com/s/tb78i5i3nrvm6rg/m140913_050931_42139_c100713652400000001823152404301535_s1_p0.1.subreads.fasta
-m140913_050931_42139_c100713652400000001823152404301535_s1_p0.2.subreads.fasta:
- curl -L https://www.dropbox.com/s/v6wwpn40gedj470/m140913_050931_42139_c100713652400000001823152404301535_s1_p0.2.subreads.fasta
-m140913_050931_42139_c100713652400000001823152404301535_s1_p0.3.subreads.fasta:
- curl -L https://www.dropbox.com/s/j61j2cvdxn4dx4g/m140913_050931_42139_c100713652400000001823152404301535_s1_p0.3.subreads.fasta
lambda-creads.1.fasta:
cp -f /lustre/hpcprod/cdunn/data/lambda/cx.pb.fasta $@
lambda-hgap-3.creads.fasta:
@@ -29,3 +23,7 @@ synth0.ref.fasta:
#cp -f /lustre/hpcprod/cdunn/data/synth0/from.fasta $@
arab-creads.fasta:
cp -f /lustre/hpcprod/cdunn/data/arab_test/corrected.fasta $@
+synth5k.2016-11-02:
+ curl -L https://downloads.pacbcloud.com/public/data/git-sym/synth5k.2016-11-02.tgz | tar xvfz -
+ecoli.m140913_050931_42139_c100713652400000001823152404301535_s1_p0:
+ curl -L https://downloads.pacbcloud.com/public/data/git-sym/ecoli.m140913_050931_42139_c100713652400000001823152404301535_s1_p0.subreads.tar | tar xvf -
diff --git a/FALCON-examples/makefile b/FALCON-examples/makefile
index 5b65c85..57a7459 100644
--- a/FALCON-examples/makefile
+++ b/FALCON-examples/makefile
@@ -12,8 +12,8 @@ test:
python -c 'import falcon_kit; print falcon_kit.falcon'
${MAKE} run-synth0
${MAKE} -C run/synth0 test
- ${MAKE} -C run/synth0 clean
- ${MAKE} -C run/synth0 go0 # still test the old pypeflow too, for now
+ #${MAKE} -C run/synth0 clean
+ #${MAKE} -C run/synth0 go0 # still test the old pypeflow too, for now
${MAKE} -C run/synth0 clean
${MAKE} -C run/synth0 go1 # should be the same as go
diff --git a/FALCON-examples/run/ecoli/input.fofn b/FALCON-examples/run/ecoli/input.fofn
index e4d9b6b..1635041 100644
--- a/FALCON-examples/run/ecoli/input.fofn
+++ b/FALCON-examples/run/ecoli/input.fofn
@@ -1,3 +1,3 @@
-data/ecoli.1.subreads.fasta
-data/ecoli.2.subreads.fasta
-data/ecoli.3.subreads.fasta
+data/ecoli.m140913_050931_42139_c100713652400000001823152404301535_s1_p0.subreads/subreads.1.dexta
+data/ecoli.m140913_050931_42139_c100713652400000001823152404301535_s1_p0.subreads/subreads.2.dexta
+data/ecoli.m140913_050931_42139_c100713652400000001823152404301535_s1_p0.subreads/subreads.3.dexta
diff --git a/FALCON-examples/run/ecoli/makefile b/FALCON-examples/run/ecoli/makefile
new file mode 100644
index 0000000..12de288
--- /dev/null
+++ b/FALCON-examples/run/ecoli/makefile
@@ -0,0 +1,4 @@
+run:
+ fc_run fc_run.cfg logging.ini
+clean:
+ rm -rf 0-rawreads/ 1-preads_ovl/ 2-asm-falcon/ all.log mypwatcher/ scripts/ sge_log
diff --git a/FALCON-examples/run/ecoli2/input.fofn b/FALCON-examples/run/ecoli2/input.fofn
index e4d9b6b..1635041 100644
--- a/FALCON-examples/run/ecoli2/input.fofn
+++ b/FALCON-examples/run/ecoli2/input.fofn
@@ -1,3 +1,3 @@
-data/ecoli.1.subreads.fasta
-data/ecoli.2.subreads.fasta
-data/ecoli.3.subreads.fasta
+data/ecoli.m140913_050931_42139_c100713652400000001823152404301535_s1_p0.subreads/subreads.1.dexta
+data/ecoli.m140913_050931_42139_c100713652400000001823152404301535_s1_p0.subreads/subreads.2.dexta
+data/ecoli.m140913_050931_42139_c100713652400000001823152404301535_s1_p0.subreads/subreads.3.dexta
diff --git a/FALCON-examples/run/synth0/check.py b/FALCON-examples/run/synth0/check.py
index 5cdd9fc..6bed896 100755
--- a/FALCON-examples/run/synth0/check.py
+++ b/FALCON-examples/run/synth0/check.py
@@ -32,7 +32,7 @@ def compare_circ(ref, qry):
d = 'rc'
shift = compare_rot(reverse_complement(ref), qry)
print('shifted by %d (%s)' %(shift, d))
-def main(prog, ref='data/ref.fasta', qry='2-asm-falcon/p_ctg.fa'):
+def main(prog, ref='data/synth5k/ref.fasta', qry='2-asm-falcon/p_ctg.fa'):
compare_circ(read_dna(open(ref)), read_dna(open(qry)))
main(*sys.argv)
diff --git a/FALCON-examples/run/synth0/data/synth0.fasta b/FALCON-examples/run/synth0/data/synth0.fasta
deleted file mode 100644
index 15086cc..0000000
--- a/FALCON-examples/run/synth0/data/synth0.fasta
+++ /dev/null
@@ -1,1750 +0,0 @@
->m000_000/0/1899_3899
-CCCCGCATTCCCTAAGGATTCACGCGGCATTTGCAAACCCGATTCTGCTCATCACCAAGA
-GTCAGATGGCCGGCCAATATGTGGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGT
-CCTTAGGTGAGGTTAGCTTTGCCAATAACAAGGCCCTAATCCATCACCGTGGCATACATG
-TCAATTTTTGACACTCGGAATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGA
-AAAATCAACTGGTTCAATGAAAAAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGC
-TGGAAACGGGGGGATGGGGGTCGAATCGAGACAACGGCGACGGGGCCAACCCATGTGTAT
-CTCTCTCGGATGCGCTGGTCTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTC
-GTCGTGGCTGTATCCATTTTTCAGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAA
-AGTGTCGCGATTTCGCTGGAAGCCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATC
-TCGGGTCTAACACCCAGGTTGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACGCAT
-GGCTACGGTAAGAAAGGGCCGAACACAATAATCAAGCCCAACTATCTATTGAATCCAGGA
-TTGCGGCAACGATGGATAGCTAGGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTC
-TGCAGAAAAACCAGTTGAGCCCTAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTG
-GGCACTCAGGGCAGTGATTGCCTCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTAC
-GTTTTTTTTTTCCACCCACCCGTCCAGGGGCATCTAGCTAGAATACTGAGCTCCTTTCGA
-TTCCCTTCGACTCCTCCTCGGGCTCTCGACAGGATCCATGCCGACGTCATTCTCTATAAA
-AAGCCTACAAGGACGACGTTTGGACCTCAGACTTCACGAACATGTGCCACCGCGATCCCA
-CTGCTCATTGTCCAGGTACTAGACTGCGGGCTAGTAATGAGGCGGGTTCCTCAAAGTATA
-AGCGCCTAATGCTCCCAGTTTGAACATAGTCCTGCTGATTTCTTATTGCTTAGACACAGA
-CACTTCACCTTGTGCGAGAGTTAAGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTCATGT
-CAGTGCTAGTACTTTAACAAGATTAAATGAATCAGAGATAGCAAATCTGTGCATGAGTTA
-CCAGGAACTCGAACCCGGCTAACTACACAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCT
-TGCTGGTCTCGATCATGGTTGTGACGATAGCACGTCCGAACCGCCGGCCGAATGAGCGCG
-TAGGTGAACGATATCATGGCCCGACGCCCCGTAGAGCTGGACTGGGGGCCAATGCCGAAC
-AAGGGTATAACAAAAAAAAACCCCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGAT
-ACCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGG
-CTCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCC
-CAGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCA
-CCACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGG
-TTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCG
-AACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCACCCTCACCCTCACGTGAGATA
-AATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACATATGACTACGTGTTACATCT
-GGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAATTCCCAGGCAAGATAATGTC
-ACACAGGAGTGGTTACGAAT
->m000_000/1/2080_4080
-CAATTTTTGACACTCGGAATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGAA
-AAATCAACTGGTTCAATGAAAAAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGCT
-GGAAACGGGGGGATGGGGGTCGAATCGAGACAACGGCGACGGGGCCAACCCATGTGTATC
-TCTCTCGGATGCGCTGGTCTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCG
-TCGTGGCTGTATCCATTTTTCAGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAA
-GTGTCGCGATTTCGCTGGAAGCCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCT
-CGGGTCTAACACCCAGGTTGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACGCATG
-GCTACGGTAAGAAAGGGCCGAACACAATAATCAAGCCCAACTATCTATTGAATCCAGGAT
-TGCGGCAACGATGGATAGCTAGGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTCT
-GCAGAAAAACCAGTTGAGCCCTAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTGG
-GCACTCAGGGCAGTGATTGCCTCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTACG
-TTTTTTTTTTCCACCCACCCGTCCAGGGGCATCTAGCTAGAATACTGAGCTCCTTTCGAT
-TCCCTTCGACTCCTCCTCGGGCTCTCGACAGGATCCATGCCGACGTCATTCTCTATAAAA
-AGCCTACAAGGACGACGTTTGGACCTCAGACTTCACGAACATGTGCCACCGCGATCCCAC
-TGCTCATTGTCCAGGTACTAGACTGCGGGCTAGTAATGAGGCGGGTTCCTCAAAGTATAA
-GCGCCTAATGCTCCCAGTTTGAACATAGTCCTGCTGATTTCTTATTGCTTAGACACAGAC
-ACTTCACCTTGTGCGAGAGTTAAGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTCATGTC
-AGTGCTAGTACTTTAACAAGATTAAATGAATCAGAGATAGCAAATCTGTGCATGAGTTAC
-CAGGAACTCGAACCCGGCTAACTACACAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTT
-GCTGGTCTCGATCATGGTTGTGACGATAGCACGTCCGAACCGCCGGCCGAATGAGCGCGT
-AGGTGAACGATATCATGGCCCGACGCCCCGTAGAGCTGGACTGGGGGCCAATGCCGAACA
-AGGGTATAACAAAAAAAAACCCCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGATA
-CCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGC
-TCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCCC
-AGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCAC
-CACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGT
-TACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGA
-ACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCACCCTCACCCTCACGTGAGATAA
-ATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACATATGACTACGTGTTACATCTG
-GAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAATTCCCAGGCAAGATAATGTCA
-CACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATCACTATCGAGCTCCCGGTGCCA
-GTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGATTTACTCCAGTAGCCCACGTC
-TCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCTTGTCGAGATAGCGGACTATGC
-GAGTGAGAGAAGCACATGCT
->m000_000/2/3976_5976
-AGATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCC
-TCTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCA
-CGAGTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTC
-AAAATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGT
-AGCCAGATAGTTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCT
-TAATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAA
-GACCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAAC
-CTGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCC
-TAATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCA
-TGCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTA
-GGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTG
-GGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTT
-AAGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGA
-GATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCC
-TTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTAT
-CGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAG
-GTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCG
-CTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCC
-AAGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCT
-TGCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCG
-TTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGC
-TAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAG
-ATCATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGT
-GATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCAT
-TCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTT
-TGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAA
-ATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAA
-GTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTC
-TTGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGGCCGTG
-TCACACAATACCTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACA
-ATTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGC
-GCAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAAT
-ACCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCC
-CGTACTTTATCGATCGAGCA
->m000_000/3/4550_6550
-CGCCCGGGCGGATTCTACTCTCAGTAGGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGT
-ACTCATCGGAAACGTTTGTGTTACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAA
-ACCTTGATGGATCTACGATCCTACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCC
-TATGACAATGATTCAGGAGTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGT
-GATCGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATAC
-CCCATCTCAGCTCAGCCATCATTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCG
-CGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTC
-GACAGAGCGACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTA
-TTAATTGACAGACGACGGGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAG
-ATGGTGCCGCTATACAGCCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGC
-TGTTGACCTGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGA
-TGTTCATTCGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTG
-GGCATTACCAGGCTCGTTGATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTT
-GCATAGGTTACGTCCAATGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGG
-GCGGCTGTATGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGT
-GCAAAAGAAAAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGA
-AATAATGATACGCATCGGATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGC
-GTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAG
-AGTATTTTGTGATGAGACTTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGCTC
-CCCATGGAGGTGAGTCCGGGGCCGTGTCACACAATACCTCTTTGCAGACGCCGCGTCCTG
-GTTATTATCGAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAA
-TTTTACTTGAACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCC
-TATATTTCGTATAACGATGTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTC
-ACATCAGCTCGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCA
-ACCATCGCTTTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGA
-TCGAACTTCCGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTT
-GAACAGATAAGATAATTAACACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCACTA
-CATAATTTAGCCGCGACTACCTCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTGAA
-GTCGTTTTCCGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCGTCGTC
-CTTTCATTTTCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAAATATCTCCAAAATG
-CGACACTGTAGCAAGGACACACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGGTCGTA
-AAATTAAATCATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGCATCCA
-GGATTTGAACATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACTAAATT
-CACCAGTCGACTTGCAAGGC
->m000_000/4/733_2733
-GCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACAATTCAGTCAATCTCTCA
-CGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGCGCAGATTAGCGATTGGC
-TCTCTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAATACCATCTAATGCCGCTT
-ATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCCCGTACTTTATCGATCGA
-GCAGAGCAGGATACTCAACCATCGCTTTATTTACTATGTATTCTGCTGATGAGTGAGGGA
-GCTGAATCCTAATTCGATCGAACTTCCGGAGCCATGCATATCAGCGTCTAAACGCTTCAC
-GTTTTTCACACGTCGTTGAACAGATAAGATAATTAACACCCTGATTAGCCATTCGCGCGC
-GCCGGCAGAGGTCACTACATAATTTAGCCGCGACTACCTCCAATGACCTTTAGTCATCAC
-GAGCTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGAAACGCCCCATAAAGGCCCACGAAAC
-CCCGGCTCGTCGTCGTCCTTTCATTTTCTGTTGTGGCTAGCATAGGCCCCAGACGAAACG
-CAAATATCTCCAAAATGCGACACTGTAGCAAGGACACACGGGTATCTTAGACCCCTAATA
-AGGTTTCGGAGGTCGTAAAATTAAATCATGACGCCCAGTTTGAATTCCTGATCGTCCAAG
-TGCCACCCTAGCATCCAGGATTTGAACATTCATTGCTAAGCTCTACTAGGCAAGAGTCTA
-GACGCTCGTACTAAATTCACCAGTCGACTTGCAAGGCTCGGACACGTGTTGCCCCAACTA
-TATCCTAGCAGATTCTACCTCAATTGCTCGCGAGTTATATGAAATCGCCATCCCACATGC
-GCGGCCCACACTCGCAACAAGGAAATGACGACCAGGGACGACATGATGTAGCGGGACTTA
-GGCACAATCGACTGGCGATCTTAGTTGACTTACAAAAGATCACGGGCCTACGCAATCGCC
-TAAGGAGCACCATGGCCCGGAGGCCTGCACAATAGACGTACGGCGCTCAAATACATTAGA
-TCGCCAAACAGGGAGTATAGTCATGACCGCTATTCTCGCCTCAGGGGCGAGCGGCCCTGA
-TGAAATGTGACGAACAGTGAACGGATCCCCGCATTCCCTAAGGATTCACGCGGCATTTGC
-AAACCCGATTCTGCTCATCACCAAGAGTCAGATGGCCGGCCAATATGTGGAGTGCTGACC
-TCCCCAAACCCTGTTCGAAGCAACGTCCTTAGGTGAGGTTAGCTTTGCCAATAACAAGGC
-CCTAATCCATCACCGTGGCATACATGTCAATTTTTGACACTCGGAATGCGCGAACGGATA
-ATTCTACGCGTCTGTGGTGCGCAGGAAAAATCAACTGGTTCAATGAAAAAGGAAGCTACG
-CGTGTTCGCATTGATCCTGAGTTAGCTGGAAACGGGGGGATGGGGGTCGAATCGAGACAA
-CGGCGACGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGGTCTCGAGGTTAGCTCC
-CAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATTTTTCAGTAGTGGTACA
-CTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTGGAAGCCCTGGGGGTCA
-TTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGGTTGCTAACGGACAGTA
-AGTTGTTGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGGCCGAACACAATAATCA
-AGCCCAACTATCTATTGAATCCAGGATTGCGGCAACGATGGATAGCTAGGGTAACTCGGG
-TAGCCTTGTCGTGTACGGAGATGCTCTGCAGAAAAACCAGTTGAGCCCTAAAGCCACCTT
-CCGGAAAGGCACTCTGCCAACTACTGGGCACTCAGGGCAGTGATTGCCTCACCGGGTTCG
-GGCAAGCAGGGTGGTAATCC
->m000_000/5/1721_3721
-CTTACAAAAGATCACGGGCCTACGCAATCGCCTAAGGAGCACCATGGCCCGGAGGCCTGC
-ACAATAGACGTACGGCGCTCAAATACATTAGATCGCCAAACAGGGAGTATAGTCATGACC
-GCTATTCTCGCCTCAGGGGCGAGCGGCCCTGATGAAATGTGACGAACAGTGAACGGATCC
-CCGCATTCCCTAAGGATTCACGCGGCATTTGCAAACCCGATTCTGCTCATCACCAAGAGT
-CAGATGGCCGGCCAATATGTGGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGTCC
-TTAGGTGAGGTTAGCTTTGCCAATAACAAGGCCCTAATCCATCACCGTGGCATACATGTC
-AATTTTTGACACTCGGAATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGAAA
-AATCAACTGGTTCAATGAAAAAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGCTG
-GAAACGGGGGGATGGGGGTCGAATCGAGACAACGGCGACGGGGCCAACCCATGTGTATCT
-CTCTCGGATGCGCTGGTCTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCGT
-CGTGGCTGTATCCATTTTTCAGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAAG
-TGTCGCGATTTCGCTGGAAGCCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCTC
-GGGTCTAACACCCAGGTTGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACGCATGG
-CTACGGTAAGAAAGGGCCGAACACAATAATCAAGCCCAACTATCTATTGAATCCAGGATT
-GCGGCAACGATGGATAGCTAGGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTCTG
-CAGAAAAACCAGTTGAGCCCTAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTGGG
-CACTCAGGGCAGTGATTGCCTCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTACGT
-TTTTTTTTTCCACCCACCCGTCCAGGGGCATCTAGCTAGAATACTGAGCTCCTTTCGATT
-CCCTTCGACTCCTCCTCGGGCTCTCGACAGGATCCATGCCGACGTCATTCTCTATAAAAA
-GCCTACAAGGACGACGTTTGGACCTCAGACTTCACGAACATGTGCCACCGCGATCCCACT
-GCTCATTGTCCAGGTACTAGACTGCGGGCTAGTAATGAGGCGGGTTCCTCAAAGTATAAG
-CGCCTAATGCTCCCAGTTTGAACATAGTCCTGCTGATTTCTTATTGCTTAGACACAGACA
-CTTCACCTTGTGCGAGAGTTAAGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTCATGTCA
-GTGCTAGTACTTTAACAAGATTAAATGAATCAGAGATAGCAAATCTGTGCATGAGTTACC
-AGGAACTCGAACCCGGCTAACTACACAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTTG
-CTGGTCTCGATCATGGTTGTGACGATAGCACGTCCGAACCGCCGGCCGAATGAGCGCGTA
-GGTGAACGATATCATGGCCCGACGCCCCGTAGAGCTGGACTGGGGGCCAATGCCGAACAA
-GGGTATAACAAAAAAAAACCCCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGATAC
-CCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGCT
-CTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCCCA
-GAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACC
-ACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTT
-ACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAA
-CCTGATTCTTCTCTCTCCGA
->m000_000/6/3727_5727
-TTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAG
-TTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGC
-AGCGTCAATTAATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGCA
-GAACTCCTTATCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTG
-CAAGGACCGAGATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAA
-TGCATATCCTCTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCC
-CACCACCCACGAGTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACT
-TTGTGACTCAAAATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGG
-TATTAGTGTAGCCAGATAGTTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTG
-TCCCGTGCTTAATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGC
-TCTCGTCAAGACCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAA
-TTCACGAACCTGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTT
-ACGGTAGCCTAATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTC
-TCCGTGGCATGCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTA
-CTCTCAGTAGGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTT
-GTGTTACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACG
-ATCCTACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGG
-AGTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCA
-GAGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCC
-ATCATTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGA
-AGTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATAC
-GTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACG
-GGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAG
-CCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTC
-ATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCT
-AAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGT
-TGATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAA
-TGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTAC
-CTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCC
-AGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCG
-GATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTC
-GGGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGA
-CTTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCC
-GGGGCCGTGTCACACAATAC
->m000_000/7/1730_3730
-GATCACGGGCCTACGCAATCGCCTAAGGAGCACCATGGCCCGGAGGCCTGCACAATAGAC
-GTACGGCGCTCAAATACATTAGATCGCCAAACAGGGAGTATAGTCATGACCGCTATTCTC
-GCCTCAGGGGCGAGCGGCCCTGATGAAATGTGACGAACAGTGAACGGATCCCCGCATTCC
-CTAAGGATTCACGCGGCATTTGCAAACCCGATTCTGCTCATCACCAAGAGTCAGATGGCC
-GGCCAATATGTGGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGTCCTTAGGTGAG
-GTTAGCTTTGCCAATAACAAGGCCCTAATCCATCACCGTGGCATACATGTCAATTTTTGA
-CACTCGGAATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGAAAAATCAACTG
-GTTCAATGAAAAAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGCTGGAAACGGGG
-GGATGGGGGTCGAATCGAGACAACGGCGACGGGGCCAACCCATGTGTATCTCTCTCGGAT
-GCGCTGGTCTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGT
-ATCCATTTTTCAGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGAT
-TTCGCTGGAAGCCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAAC
-ACCCAGGTTGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACGCATGGCTACGGTAA
-GAAAGGGCCGAACACAATAATCAAGCCCAACTATCTATTGAATCCAGGATTGCGGCAACG
-ATGGATAGCTAGGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTCTGCAGAAAAAC
-CAGTTGAGCCCTAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTGGGCACTCAGGG
-CAGTGATTGCCTCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTACGTTTTTTTTTT
-CCACCCACCCGTCCAGGGGCATCTAGCTAGAATACTGAGCTCCTTTCGATTCCCTTCGAC
-TCCTCCTCGGGCTCTCGACAGGATCCATGCCGACGTCATTCTCTATAAAAAGCCTACAAG
-GACGACGTTTGGACCTCAGACTTCACGAACATGTGCCACCGCGATCCCACTGCTCATTGT
-CCAGGTACTAGACTGCGGGCTAGTAATGAGGCGGGTTCCTCAAAGTATAAGCGCCTAATG
-CTCCCAGTTTGAACATAGTCCTGCTGATTTCTTATTGCTTAGACACAGACACTTCACCTT
-GTGCGAGAGTTAAGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTCATGTCAGTGCTAGTA
-CTTTAACAAGATTAAATGAATCAGAGATAGCAAATCTGTGCATGAGTTACCAGGAACTCG
-AACCCGGCTAACTACACAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCG
-ATCATGGTTGTGACGATAGCACGTCCGAACCGCCGGCCGAATGAGCGCGTAGGTGAACGA
-TATCATGGCCCGACGCCCCGTAGAGCTGGACTGGGGGCCAATGCCGAACAAGGGTATAAC
-AAAAAAAAACCCCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGC
-ACACTCACTTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGG
-CTGGACTCCTTCGACGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCA
-AAAAAGCCAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAA
-ACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCT
-CAACAAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCT
-TCTCTCTCCGATTGGACTTT
->m000_000/8/4618_6618
-GAAACGTTTGTGTTACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGAT
-GGATCTACGATCCTACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAA
-TGATTCAGGAGTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGC
-TGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTC
-AGCTCAGCCATCATTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGG
-TTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGC
-GACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGA
-CAGACGACGGGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCC
-GCTATACAGCCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACC
-TGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATT
-CGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTAC
-CAGGCTCGTTGATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGGT
-TACGTCCAATGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTGT
-ATGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGA
-AAAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATGA
-TACGCATCGGATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCC
-GGCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTT
-GTGATGAGACTTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCCCATGGA
-GGTGAGTCCGGGGCCGTGTCACACAATACCTCTTTGCAGACGCCGCGTCCTGGTTATTAT
-CGAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTACTT
-GAACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATATTTC
-GTATAACGATGTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATCAGC
-TCGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCAACCATCGC
-TTTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGATCGAACTT
-CCGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTTGAACAGAT
-AAGATAATTAACACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCACTACATAATTT
-AGCCGCGACTACCTCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTT
-CCGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCGTCGTCCTTTCATT
-TTCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAAATATCTCCAAAATGCGACACTG
-TAGCAAGGACACACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGGTCGTAAAATTAAA
-TCATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGCATCCAGGATTTGA
-ACATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACTAAATTCACCAGTC
-GACTTGCAAGGCTCGGACACGTGTTGCCCCAACTATATCCTAGCAGATTCTACCTCAATT
-GCTCGCGAGTTATATGAAAT
->m000_000/9/3537_5537
-CAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCC
-TGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAG
-CGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCT
-CCGATTGGACTTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTC
-GTAACAACAGTTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATT
-GGCGAATCGCAGCGTCAATTAATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGA
-ATATGCAGCAGAACTCCTTATCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTC
-ACTCGAATTGCAAGGACCGAGATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGA
-CATCTATCAATGCATATCCTCTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACAT
-GCTGCCGCCCCACCACCCACGAGTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAG
-ATCATGCACTTTGTGACTCAAAATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATA
-GTAACTTGGGTATTAGTGTAGCCAGATAGTTTACACTTTGACTCTAGAACACCCAGGCGA
-ATAGGTCGTGTCCCGTGCTTAATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATG
-ATGTCTCAGCTCTCGTCAAGACCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAG
-AGGCAACAAATTCACGAACCTGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGG
-TACGGTACTTACGGTAGCCTAATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATT
-TTCCGTGGTCTCCGTGGCATGCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGG
-GCGGATTCTACTCTCAGTAGGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATC
-GGAAACGTTTGTGTTACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGA
-TGGATCTACGATCCTACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACA
-ATGATTCAGGAGTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCG
-CTGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCT
-CAGCTCAGCCATCATTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGG
-GTTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAG
-CGACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTG
-ACAGACGACGGGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGC
-CGCTATACAGCCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGAC
-CTGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCAT
-TCGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTA
-CCAGGCTCGTTGATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGG
-TTACGTCCAATGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTG
-TATGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAG
-AAAAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATG
-ATACGCATCGGATAGTTAAA
->m000_000/10/3679_5679
-CACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCAC
-CCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACA
-TATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAA
-TTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATC
-ACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGA
-TTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCT
-TGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACGA
-GTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAA
-ATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGC
-CAGATAGTTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAA
-TGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGAC
-CCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTG
-CGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAA
-TAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGC
-AGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGC
-GAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGG
-CGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAG
-GATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGAT
-AACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTT
-TAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGA
-CACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTC
-TTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTC
-AAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAG
-TATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGC
-ATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTA
-GTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAA
-CATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGATC
-ATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTGAT
-TAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCATTCA
-CGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTTGA
-ATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAAATT
-ACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAGTC
-GGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTCTTG
-TGTCGATAGCAGCAGTTAAT
->m000_000/11/2224_4224
-TCGAGACAACGGCGACGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGGTCTCGAG
-GTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATTTTTCAGT
-AGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTGGAAGCCC
-TGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGGTTGCTAA
-CGGACAGTAAGTTGTTGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGGCCGAACA
-CAATAATCAAGCCCAACTATCTATTGAATCCAGGATTGCGGCAACGATGGATAGCTAGGG
-TAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTCTGCAGAAAAACCAGTTGAGCCCTAA
-AGCCACCTTCCGGAAAGGCACTCTGCCAACTACTGGGCACTCAGGGCAGTGATTGCCTCA
-CCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTACGTTTTTTTTTTCCACCCACCCGTCC
-AGGGGCATCTAGCTAGAATACTGAGCTCCTTTCGATTCCCTTCGACTCCTCCTCGGGCTC
-TCGACAGGATCCATGCCGACGTCATTCTCTATAAAAAGCCTACAAGGACGACGTTTGGAC
-CTCAGACTTCACGAACATGTGCCACCGCGATCCCACTGCTCATTGTCCAGGTACTAGACT
-GCGGGCTAGTAATGAGGCGGGTTCCTCAAAGTATAAGCGCCTAATGCTCCCAGTTTGAAC
-ATAGTCCTGCTGATTTCTTATTGCTTAGACACAGACACTTCACCTTGTGCGAGAGTTAAG
-GGCATGCTCCGGCTCAAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTTAACAAGATTA
-AATGAATCAGAGATAGCAAATCTGTGCATGAGTTACCAGGAACTCGAACCCGGCTAACTA
-CACAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCATGGTTGTGAC
-GATAGCACGTCCGAACCGCCGGCCGAATGAGCGCGTAGGTGAACGATATCATGGCCCGAC
-GCCCCGTAGAGCTGGACTGGGGGCCAATGCCGAACAAGGGTATAACAAAAAAAAACCCCC
-TTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTCCGC
-TGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTCGA
-CGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAGCA
-ATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGTTTC
-GTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCG
-GATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTG
-GACTTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAA
-CAGTTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAAT
-CGCAGCGTCAATTAATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCA
-GCAGAACTCCTTATCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAA
-TTGCAAGGACCGAGATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTAT
-CAATGCATATCCTCTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCG
-CCCCACCACCCACGAGTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGC
-ACTTTGTGACTCAAAATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTT
-GGGTATTAGTGTAGCCAGAT
->m000_000/12/4046_6046
-ATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACGAGTCTAGA
-CCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAAATCATAT
-GAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGCCAGATAG
-TTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAATGAGGTA
-CTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTCGAA
-TATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAGCTT
-AACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAATAGTTAT
-CCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGCAGTCCTT
-TTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGCGAGCGCG
-AGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGGCGACTAG
-CAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATTCAT
-AATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACGCCT
-GGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTT
-ATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGACACCAGG
-GAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAAT
-AGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAACTAC
-GTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATAATA
-ACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGAATT
-ATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTCTGC
-GCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATTGGA
-GCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGATCATCGATG
-CAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTGATTAAGATG
-GCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCATTCACGAGTCT
-TGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTTGAATAAGAG
-GTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAAATTACAACCA
-GTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAG
-ACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTCTTGTGTCGAT
-AGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGGCCGTGTCACACAATA
-CCTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACAATTCAGTCAA
-TCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGCGCAGATTAGC
-GATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAATACCATCTAAT
-GCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCCCGTACTTTAT
-CGATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACTATGTATTCTGCTGATGAG
-TGAGGGAGCTGAATCCTAAT
->m000_000/13/4271_6271
-GTGCTTAATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTC
-GTCAAGACCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCA
-CGAACCTGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGG
-TAGCCTAATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCG
-TGGCATGCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCT
-CAGTAGGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGT
-TACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCC
-TACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTT
-TTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGG
-GAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCA
-TTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTG
-CCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCT
-TTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTA
-AGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCA
-TGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATAC
-TTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAAC
-GACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGAT
-GGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAA
-TGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAA
-CGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGA
-GGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATA
-GTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGC
-CTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTT
-AGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGG
-CCGTGTCACACAATACCTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAG
-TGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCAC
-ATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGTC
-TCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGT
-AGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACTATG
-TATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGATCGAACTTCCGGAGCCATGCA
-TATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTTGAACAGATAAGATAATTAACA
-CCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCACTACATAATTTAGCCGCGACTACC
-TCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGAAAC
-GCCCCATAAAGGCCCACGAA
->m000_000/14/3617_5617
-GGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTT
-CTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCC
-ACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCA
-CATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATT
-AATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTA
-TCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGA
-GATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCT
-CTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCAC
-GAGTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCA
-AAATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTA
-GCCAGATAGTTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTT
-AATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAG
-ACCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACC
-TGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCT
-AATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCAT
-GCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAG
-GCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGG
-GGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTA
-AGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAG
-ATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCT
-TTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATC
-GACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGG
-TCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGC
-TCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCA
-AGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTT
-GCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGT
-TAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCT
-AACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGA
-TCATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTG
-ATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCATT
-CACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTT
-GAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAAA
-TTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAG
-TCGGAGAAGACGGGCGGTCC
->m000_000/15/3358_5358
-ACCCCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCAC
-TTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTC
-CTTCGACGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCC
-AGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCT
-GGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGC
-GATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTC
-CGATTGGACTTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCG
-TAACAACAGTTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTG
-GCGAATCGCAGCGTCAATTAATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAA
-TATGCAGCAGAACTCCTTATCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCA
-CTCGAATTGCAAGGACCGAGATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGAC
-ATCTATCAATGCATATCCTCTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACATG
-CTGCCGCCCCACCACCCACGAGTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAGA
-TCATGCACTTTGTGACTCAAAATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATAG
-TAACTTGGGTATTAGTGTAGCCAGATAGTTTACACTTTGACTCTAGAACACCCAGGCGAA
-TAGGTCGTGTCCCGTGCTTAATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGA
-TGTCTCAGCTCTCGTCAAGACCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGA
-GGCAACAAATTCACGAACCTGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGT
-ACGGTACTTACGGTAGCCTAATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTT
-TCCGTGGTCTCCGTGGCATGCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGG
-CGGATTCTACTCTCAGTAGGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCG
-GAAACGTTTGTGTTACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGAT
-GGATCTACGATCCTACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAA
-TGATTCAGGAGTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGC
-TGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTC
-AGCTCAGCCATCATTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGG
-TTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGC
-GACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGA
-CAGACGACGGGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCC
-GCTATACAGCCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACC
-TGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATT
-CGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTAC
-CAGGCTCGTTGATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGGT
-TACGTCCAATGAATGTGTGA
->m000_000/16/1219_3219
-TTTGCGCTGAAGTCGTTTTCCGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCCGGC
-TCGTCGTCGTCCTTTCATTTTCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAAATA
-TCTCCAAAATGCGACACTGTAGCAAGGACACACGGGTATCTTAGACCCCTAATAAGGTTT
-CGGAGGTCGTAAAATTAAATCATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGCCAC
-CCTAGCATCCAGGATTTGAACATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGACGCT
-CGTACTAAATTCACCAGTCGACTTGCAAGGCTCGGACACGTGTTGCCCCAACTATATCCT
-AGCAGATTCTACCTCAATTGCTCGCGAGTTATATGAAATCGCCATCCCACATGCGCGGCC
-CACACTCGCAACAAGGAAATGACGACCAGGGACGACATGATGTAGCGGGACTTAGGCACA
-ATCGACTGGCGATCTTAGTTGACTTACAAAAGATCACGGGCCTACGCAATCGCCTAAGGA
-GCACCATGGCCCGGAGGCCTGCACAATAGACGTACGGCGCTCAAATACATTAGATCGCCA
-AACAGGGAGTATAGTCATGACCGCTATTCTCGCCTCAGGGGCGAGCGGCCCTGATGAAAT
-GTGACGAACAGTGAACGGATCCCCGCATTCCCTAAGGATTCACGCGGCATTTGCAAACCC
-GATTCTGCTCATCACCAAGAGTCAGATGGCCGGCCAATATGTGGAGTGCTGACCTCCCCA
-AACCCTGTTCGAAGCAACGTCCTTAGGTGAGGTTAGCTTTGCCAATAACAAGGCCCTAAT
-CCATCACCGTGGCATACATGTCAATTTTTGACACTCGGAATGCGCGAACGGATAATTCTA
-CGCGTCTGTGGTGCGCAGGAAAAATCAACTGGTTCAATGAAAAAGGAAGCTACGCGTGTT
-CGCATTGATCCTGAGTTAGCTGGAAACGGGGGGATGGGGGTCGAATCGAGACAACGGCGA
-CGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGGTCTCGAGGTTAGCTCCCAAGCT
-TAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATTTTTCAGTAGTGGTACACTAAGC
-AAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTGGAAGCCCTGGGGGTCATTTTAA
-ACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGGTTGCTAACGGACAGTAAGTTGT
-TGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGGCCGAACACAATAATCAAGCCCA
-ACTATCTATTGAATCCAGGATTGCGGCAACGATGGATAGCTAGGGTAACTCGGGTAGCCT
-TGTCGTGTACGGAGATGCTCTGCAGAAAAACCAGTTGAGCCCTAAAGCCACCTTCCGGAA
-AGGCACTCTGCCAACTACTGGGCACTCAGGGCAGTGATTGCCTCACCGGGTTCGGGCAAG
-CAGGGTGGTAATCCCAGTACGTTTTTTTTTTCCACCCACCCGTCCAGGGGCATCTAGCTA
-GAATACTGAGCTCCTTTCGATTCCCTTCGACTCCTCCTCGGGCTCTCGACAGGATCCATG
-CCGACGTCATTCTCTATAAAAAGCCTACAAGGACGACGTTTGGACCTCAGACTTCACGAA
-CATGTGCCACCGCGATCCCACTGCTCATTGTCCAGGTACTAGACTGCGGGCTAGTAATGA
-GGCGGGTTCCTCAAAGTATAAGCGCCTAATGCTCCCAGTTTGAACATAGTCCTGCTGATT
-TCTTATTGCTTAGACACAGACACTTCACCTTGTGCGAGAGTTAAGGGCATGCTCCGGCTC
-AAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTTAACAAGATTAAATGAATCAGAGATA
-GCAAATCTGTGCATGAGTTACCAGGAACTCGAACCCGGCTAACTACACAGTGAGGAAAGT
-GAGAAGAGGGTCGAAAAGCT
->m000_000/17/3533_5533
-AAGCCAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACG
-AGCCTGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAA
-CAAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCT
-CTCTCCGATTGGACTTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACA
-ATTCGTAACAACAGTTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGT
-GATTGGCGAATCGCAGCGTCAATTAATTCCCAGGCAAGATAATGTCACACAGGAGTGGTT
-ACGAATATGCAGCAGAACTCCTTATCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGG
-GGTCACTCGAATTGCAAGGACCGAGATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGG
-TAGACATCTATCAATGCATATCCTCTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGC
-ACATGCTGCCGCCCCACCACCCACGAGTCTAGACCTAGTCAAGTGCTTTACAATACATCG
-CCAGATCATGCACTTTGTGACTCAAAATCATATGAAGCAATCATGGTCGGCGGTGGCGAA
-TATAGTAACTTGGGTATTAGTGTAGCCAGATAGTTTACACTTTGACTCTAGAACACCCAG
-GCGAATAGGTCGTGTCCCGTGCTTAATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCG
-GATGATGTCTCAGCTCTCGTCAAGACCCTCGAATATGCAATTCACTCCAAGGGCAAGATC
-ACAGAGGCAACAAATTCACGAACCTGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGT
-AGGGTACGGTACTTACGGTAGCCTAATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGA
-TATTTTCCGTGGTCTCCGTGGCATGCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGC
-CCGGGCGGATTCTACTCTCAGTAGGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACT
-CATCGGAAACGTTTGTGTTACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACC
-TTGATGGATCTACGATCCTACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCCTAT
-GACAATGATTCAGGAGTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGAT
-CGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCC
-ATCTCAGCTCAGCCATCATTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGA
-TTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGAC
-AGAGCGACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTA
-ATTGACAGACGACGGGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGATG
-GTGCCGCTATACAGCCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCTGT
-TGACCTGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGT
-TCATTCGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGC
-ATTACCAGGCTCGTTGATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTGCA
-TAGGTTACGTCCAATGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGGCG
-GCTGTATGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCA
-AAAGAAAAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAAT
-AATGATACGCATCGGATAGT
->m000_000/18/759_2759
-GAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTACTTG
-AACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATATTTCG
-TATAACGATGTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATCAGCT
-CGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCAACCATCGCT
-TTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGATCGAACTTC
-CGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTTGAACAGATA
-AGATAATTAACACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCACTACATAATTTA
-GCCGCGACTACCTCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTTC
-CGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCGTCGTCCTTTCATTT
-TCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAAATATCTCCAAAATGCGACACTGT
-AGCAAGGACACACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGGTCGTAAAATTAAAT
-CATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGCATCCAGGATTTGAA
-CATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACTAAATTCACCAGTCG
-ACTTGCAAGGCTCGGACACGTGTTGCCCCAACTATATCCTAGCAGATTCTACCTCAATTG
-CTCGCGAGTTATATGAAATCGCCATCCCACATGCGCGGCCCACACTCGCAACAAGGAAAT
-GACGACCAGGGACGACATGATGTAGCGGGACTTAGGCACAATCGACTGGCGATCTTAGTT
-GACTTACAAAAGATCACGGGCCTACGCAATCGCCTAAGGAGCACCATGGCCCGGAGGCCT
-GCACAATAGACGTACGGCGCTCAAATACATTAGATCGCCAAACAGGGAGTATAGTCATGA
-CCGCTATTCTCGCCTCAGGGGCGAGCGGCCCTGATGAAATGTGACGAACAGTGAACGGAT
-CCCCGCATTCCCTAAGGATTCACGCGGCATTTGCAAACCCGATTCTGCTCATCACCAAGA
-GTCAGATGGCCGGCCAATATGTGGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGT
-CCTTAGGTGAGGTTAGCTTTGCCAATAACAAGGCCCTAATCCATCACCGTGGCATACATG
-TCAATTTTTGACACTCGGAATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGA
-AAAATCAACTGGTTCAATGAAAAAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGC
-TGGAAACGGGGGGATGGGGGTCGAATCGAGACAACGGCGACGGGGCCAACCCATGTGTAT
-CTCTCTCGGATGCGCTGGTCTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTC
-GTCGTGGCTGTATCCATTTTTCAGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAA
-AGTGTCGCGATTTCGCTGGAAGCCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATC
-TCGGGTCTAACACCCAGGTTGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACGCAT
-GGCTACGGTAAGAAAGGGCCGAACACAATAATCAAGCCCAACTATCTATTGAATCCAGGA
-TTGCGGCAACGATGGATAGCTAGGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTC
-TGCAGAAAAACCAGTTGAGCCCTAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTG
-GGCACTCAGGGCAGTGATTGCCTCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTAC
-GTTTTTTTTTTCCACCCACC
->m000_000/19/537_2537
-TTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAG
-TCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTCT
-TGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGGCCGTGT
-CACACAATACCTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACAA
-TTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGCG
-CAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAATA
-CCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCCC
-GTACTTTATCGATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACTATGTATTCT
-GCTGATGAGTGAGGGAGCTGAATCCTAATTCGATCGAACTTCCGGAGCCATGCATATCAG
-CGTCTAAACGCTTCACGTTTTTCACACGTCGTTGAACAGATAAGATAATTAACACCCTGA
-TTAGCCATTCGCGCGCGCCGGCAGAGGTCACTACATAATTTAGCCGCGACTACCTCCAAT
-GACCTTTAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGAAACGCCCCA
-TAAAGGCCCACGAAACCCCGGCTCGTCGTCGTCCTTTCATTTTCTGTTGTGGCTAGCATA
-GGCCCCAGACGAAACGCAAATATCTCCAAAATGCGACACTGTAGCAAGGACACACGGGTA
-TCTTAGACCCCTAATAAGGTTTCGGAGGTCGTAAAATTAAATCATGACGCCCAGTTTGAA
-TTCCTGATCGTCCAAGTGCCACCCTAGCATCCAGGATTTGAACATTCATTGCTAAGCTCT
-ACTAGGCAAGAGTCTAGACGCTCGTACTAAATTCACCAGTCGACTTGCAAGGCTCGGACA
-CGTGTTGCCCCAACTATATCCTAGCAGATTCTACCTCAATTGCTCGCGAGTTATATGAAA
-TCGCCATCCCACATGCGCGGCCCACACTCGCAACAAGGAAATGACGACCAGGGACGACAT
-GATGTAGCGGGACTTAGGCACAATCGACTGGCGATCTTAGTTGACTTACAAAAGATCACG
-GGCCTACGCAATCGCCTAAGGAGCACCATGGCCCGGAGGCCTGCACAATAGACGTACGGC
-GCTCAAATACATTAGATCGCCAAACAGGGAGTATAGTCATGACCGCTATTCTCGCCTCAG
-GGGCGAGCGGCCCTGATGAAATGTGACGAACAGTGAACGGATCCCCGCATTCCCTAAGGA
-TTCACGCGGCATTTGCAAACCCGATTCTGCTCATCACCAAGAGTCAGATGGCCGGCCAAT
-ATGTGGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGTCCTTAGGTGAGGTTAGCT
-TTGCCAATAACAAGGCCCTAATCCATCACCGTGGCATACATGTCAATTTTTGACACTCGG
-AATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGAAAAATCAACTGGTTCAAT
-GAAAAAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGCTGGAAACGGGGGGATGGG
-GGTCGAATCGAGACAACGGCGACGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGG
-TCTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATT
-TTTCAGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTG
-GAAGCCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGG
-TTGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGG
-CCGAACACAATAATCAAGCC
->m000_000/20/4725_6725
-TTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAA
-GGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAA
-AATACCCCATCTCAGCTCAGCCATCATTTATCGACACCAGGGAGTGAATGAACCGTGTTA
-GGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACC
-TTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGG
-CGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTAC
-CTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTG
-TCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGC
-GTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTA
-GCGTGGGCATTACCAGGCTCGTTGATGGAAGATCATCGATGCAATAATACGGACGCAAAG
-GAGTTGCATAGGTTACGTCCAATGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCG
-ATAGGGCGGCTGTATGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGC
-GAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGG
-AGAGAAATAATGATACGCATCGGATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCT
-CTAGCGTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGT
-ACCAGAGTATTTTGTGATGAGACTTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTG
-TGCTCCCCATGGAGGTGAGTCCGGGGCCGTGTCACACAATACCTCTTTGCAGACGCCGCG
-TCCTGGTTATTATCGAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGA
-CATAATTTTACTTGAACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCTCTTAAACAT
-AGCCCTATATTTCGTATAACGATGTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTA
-TTGTCACATCAGCTCGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGAT
-ACTCAACCATCGCTTTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAA
-TTCGATCGAACTTCCGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTTTTTCACACG
-TCGTTGAACAGATAAGATAATTAACACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGT
-CACTACATAATTTAGCCGCGACTACCTCCAATGACCTTTAGTCATCACGAGCTTTTTGCG
-CTGAAGTCGTTTTCCGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCG
-TCGTCCTTTCATTTTCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAAATATCTCCA
-AAATGCGACACTGTAGCAAGGACACACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGG
-TCGTAAAATTAAATCATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGC
-ATCCAGGATTTGAACATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACT
-AAATTCACCAGTCGACTTGCAAGGCTCGGACACGTGTTGCCCCAACTATATCCTAGCAGA
-TTCTACCTCAATTGCTCGCGAGTTATATGAAATCGCCATCCCACATGCGCGGCCCACACT
-CGCAACAAGGAAATGACGACCAGGGACGACATGATGTAGCGGGACTTAGGCACAATCGAC
-TGGCGATCTTAGTTGACTTA
->m000_000/21/4106_6106
-CCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAAATCATAT
-GAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGCCAGATAG
-TTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAATGAGGTA
-CTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTCGAA
-TATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAGCTT
-AACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAATAGTTAT
-CCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGCAGTCCTT
-TTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGCGAGCGCG
-AGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGGCGACTAG
-CAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATTCAT
-AATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACGCCT
-GGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTT
-ATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGACACCAGG
-GAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAAT
-AGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAACTAC
-GTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATAATA
-ACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGAATT
-ATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTCTGC
-GCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATTGGA
-GCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGATCATCGATG
-CAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTGATTAAGATG
-GCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCATTCACGAGTCT
-TGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTTGAATAAGAG
-GTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAAATTACAACCA
-GTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAG
-ACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTCTTGTGTCGAT
-AGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGGCCGTGTCACACAATA
-CCTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACAATTCAGTCAA
-TCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGCGCAGATTAGC
-GATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAATACCATCTAAT
-GCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCCCGTACTTTAT
-CGATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACTATGTATTCTGCTGATGAG
-TGAGGGAGCTGAATCCTAATTCGATCGAACTTCCGGAGCCATGCATATCAGCGTCTAAAC
-GCTTCACGTTTTTCACACGT
->m000_000/22/3035_5035
-CAGACACTTCACCTTGTGCGAGAGTTAAGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTC
-ATGTCAGTGCTAGTACTTTAACAAGATTAAATGAATCAGAGATAGCAAATCTGTGCATGA
-GTTACCAGGAACTCGAACCCGGCTAACTACACAGTGAGGAAAGTGAGAAGAGGGTCGAAA
-AGCTTGCTGGTCTCGATCATGGTTGTGACGATAGCACGTCCGAACCGCCGGCCGAATGAG
-CGCGTAGGTGAACGATATCATGGCCCGACGCCCCGTAGAGCTGGACTGGGGGCCAATGCC
-GAACAAGGGTATAACAAAAAAAAACCCCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGC
-GGATACCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGG
-TAGGCTCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGAGGTTCCGATCTTTTGA
-TGCCCAGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGA
-GCCACCACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTG
-TTGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCAT
-TTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCACCCTCACCCTCACGTGA
-GATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACATATGACTACGTGTTAC
-ATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAATTCCCAGGCAAGATAA
-TGTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATCACTATCGAGCTCCCGG
-TGCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGATTTACTCCAGTAGCCC
-ACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCTTGTCGAGATAGCGGAC
-TATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACGAGTCTAGACCTAGTCAA
-GTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAAATCATATGAAGCAATC
-ATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGCCAGATAGTTTACACTT
-TGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAATGAGGTACTTGAAGGA
-GACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTCGAATATGCAATT
-CACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAGCTTAACTCAGAG
-CGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAATAGTTATCCTCGGGTA
-CGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGCAGTCCTTTTTACCACC
-GTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGCGAGCGCGAGTAAATCC
-CAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGGCGACTAGCAGAGTTTG
-GCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATTCATAATCGGACA
-TCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACGCCTGGCCTAGAC
-AAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAGAGG
-CTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGACACCAGGGAGTGAATG
-AACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATCGGT
-TTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTG
-AGAAAATTGGCGTTATTAAT
->m000_000/23/4883_6883
-AGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGT
-AATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAAC
-TACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATA
-ATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGA
-ATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTC
-TGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATT
-GGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGATCATCG
-ATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTGATTAAG
-ATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCATTCACGAG
-TCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTTGAATAA
-GAGGTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAAATTACAA
-CCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAG
-AAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTCTTGTGTC
-GATAGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGGCCGTGTCACACA
-ATACCTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACAATTCAGT
-CAATCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGCGCAGATT
-AGCGATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAATACCATCT
-AATGCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCCCGTACTT
-TATCGATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACTATGTATTCTGCTGAT
-GAGTGAGGGAGCTGAATCCTAATTCGATCGAACTTCCGGAGCCATGCATATCAGCGTCTA
-AACGCTTCACGTTTTTCACACGTCGTTGAACAGATAAGATAATTAACACCCTGATTAGCC
-ATTCGCGCGCGCCGGCAGAGGTCACTACATAATTTAGCCGCGACTACCTCCAATGACCTT
-TAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGAAACGCCCCATAAAGG
-CCCACGAAACCCCGGCTCGTCGTCGTCCTTTCATTTTCTGTTGTGGCTAGCATAGGCCCC
-AGACGAAACGCAAATATCTCCAAAATGCGACACTGTAGCAAGGACACACGGGTATCTTAG
-ACCCCTAATAAGGTTTCGGAGGTCGTAAAATTAAATCATGACGCCCAGTTTGAATTCCTG
-ATCGTCCAAGTGCCACCCTAGCATCCAGGATTTGAACATTCATTGCTAAGCTCTACTAGG
-CAAGAGTCTAGACGCTCGTACTAAATTCACCAGTCGACTTGCAAGGCTCGGACACGTGTT
-GCCCCAACTATATCCTAGCAGATTCTACCTCAATTGCTCGCGAGTTATATGAAATCGCCA
-TCCCACATGCGCGGCCCACACTCGCAACAAGGAAATGACGACCAGGGACGACATGATGTA
-GCGGGACTTAGGCACAATCGACTGGCGATCTTAGTTGACTTACAAAAGATCACGGGCCTA
-CGCAATCGCCTAAGGAGCACCATGGCCCGGAGGCCTGCACAATAGACGTACGGCGCTCAA
-ATACATTAGATCGCCAAACAGGGAGTATAGTCATGACCGCTATTCTCGCCTCAGGGGCGA
-GCGGCCCTGATGAAATGTGA
->m000_000/24/4337_6337
-ACCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACC
-TGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCT
-AATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCAT
-GCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAG
-GCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGG
-GGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTA
-AGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAG
-ATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCT
-TTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATC
-GACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGG
-TCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGC
-TCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCA
-AGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTT
-GCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGT
-TAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCT
-AACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGA
-TCATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTG
-ATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCATT
-CACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTT
-GAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAAA
-TTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAG
-TCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTCT
-TGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGGCCGTGT
-CACACAATACCTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACAA
-TTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGCG
-CAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAATA
-CCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCCC
-GTACTTTATCGATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACTATGTATTCT
-GCTGATGAGTGAGGGAGCTGAATCCTAATTCGATCGAACTTCCGGAGCCATGCATATCAG
-CGTCTAAACGCTTCACGTTTTTCACACGTCGTTGAACAGATAAGATAATTAACACCCTGA
-TTAGCCATTCGCGCGCGCCGGCAGAGGTCACTACATAATTTAGCCGCGACTACCTCCAAT
-GACCTTTAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGAAACGCCCCA
-TAAAGGCCCACGAAACCCCGGCTCGTCGTCGTCCTTTCATTTTCTGTTGTGGCTAGCATA
-GGCCCCAGACGAAACGCAAA
->m000_000/25/770_2770
-GTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCA
-CATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGT
-CTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCG
-TAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACTAT
-GTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGATCGAACTTCCGGAGCCATGC
-ATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTTGAACAGATAAGATAATTAAC
-ACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCACTACATAATTTAGCCGCGACTAC
-CTCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGAAA
-CGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCGTCGTCCTTTCATTTTCTGTTGTGGC
-TAGCATAGGCCCCAGACGAAACGCAAATATCTCCAAAATGCGACACTGTAGCAAGGACAC
-ACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGGTCGTAAAATTAAATCATGACGCCCA
-GTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGCATCCAGGATTTGAACATTCATTGCT
-AAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACTAAATTCACCAGTCGACTTGCAAGGC
-TCGGACACGTGTTGCCCCAACTATATCCTAGCAGATTCTACCTCAATTGCTCGCGAGTTA
-TATGAAATCGCCATCCCACATGCGCGGCCCACACTCGCAACAAGGAAATGACGACCAGGG
-ACGACATGATGTAGCGGGACTTAGGCACAATCGACTGGCGATCTTAGTTGACTTACAAAA
-GATCACGGGCCTACGCAATCGCCTAAGGAGCACCATGGCCCGGAGGCCTGCACAATAGAC
-GTACGGCGCTCAAATACATTAGATCGCCAAACAGGGAGTATAGTCATGACCGCTATTCTC
-GCCTCAGGGGCGAGCGGCCCTGATGAAATGTGACGAACAGTGAACGGATCCCCGCATTCC
-CTAAGGATTCACGCGGCATTTGCAAACCCGATTCTGCTCATCACCAAGAGTCAGATGGCC
-GGCCAATATGTGGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGTCCTTAGGTGAG
-GTTAGCTTTGCCAATAACAAGGCCCTAATCCATCACCGTGGCATACATGTCAATTTTTGA
-CACTCGGAATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGAAAAATCAACTG
-GTTCAATGAAAAAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGCTGGAAACGGGG
-GGATGGGGGTCGAATCGAGACAACGGCGACGGGGCCAACCCATGTGTATCTCTCTCGGAT
-GCGCTGGTCTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGT
-ATCCATTTTTCAGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGAT
-TTCGCTGGAAGCCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAAC
-ACCCAGGTTGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACGCATGGCTACGGTAA
-GAAAGGGCCGAACACAATAATCAAGCCCAACTATCTATTGAATCCAGGATTGCGGCAACG
-ATGGATAGCTAGGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTCTGCAGAAAAAC
-CAGTTGAGCCCTAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTGGGCACTCAGGG
-CAGTGATTGCCTCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTACGTTTTTTTTTT
-CCACCCACCCGTCCAGGGGC
->m000_000/26/2718_4718
-GCAGGGTGGTAATCCCAGTACGTTTTTTTTTTCCACCCACCCGTCCAGGGGCATCTAGCT
-AGAATACTGAGCTCCTTTCGATTCCCTTCGACTCCTCCTCGGGCTCTCGACAGGATCCAT
-GCCGACGTCATTCTCTATAAAAAGCCTACAAGGACGACGTTTGGACCTCAGACTTCACGA
-ACATGTGCCACCGCGATCCCACTGCTCATTGTCCAGGTACTAGACTGCGGGCTAGTAATG
-AGGCGGGTTCCTCAAAGTATAAGCGCCTAATGCTCCCAGTTTGAACATAGTCCTGCTGAT
-TTCTTATTGCTTAGACACAGACACTTCACCTTGTGCGAGAGTTAAGGGCATGCTCCGGCT
-CAAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTTAACAAGATTAAATGAATCAGAGAT
-AGCAAATCTGTGCATGAGTTACCAGGAACTCGAACCCGGCTAACTACACAGTGAGGAAAG
-TGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCATGGTTGTGACGATAGCACGTCCGA
-ACCGCCGGCCGAATGAGCGCGTAGGTGAACGATATCATGGCCCGACGCCCCGTAGAGCTG
-GACTGGGGGCCAATGCCGAACAAGGGTATAACAAAAAAAAACCCCCTTGGAGTAACTGAA
-AGTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTT
-TCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAG
-AGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCG
-GGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAG
-GCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTC
-TCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCA
-CCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCAC
-ATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTA
-ATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTAT
-CACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAG
-ATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTC
-TTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACG
-AGTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAA
-AATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAG
-CCAGATAGTTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTA
-ATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGA
-CCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCT
-GCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTA
-ATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATG
-CAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGG
-CGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGG
-GCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAA
-GGATTCATAATCGGACATCC
->m000_000/27/4643_6643
-TAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATT
-CATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACG
-CCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGG
-CTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGACACC
-AGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGT
-AATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAAC
-TACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATA
-ATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGA
-ATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTC
-TGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATT
-GGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGATCATCG
-ATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTGATTAAG
-ATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCATTCACGAG
-TCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTTGAATAA
-GAGGTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAAATTACAA
-CCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAG
-AAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTCTTGTGTC
-GATAGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGGCCGTGTCACACA
-ATACCTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACAATTCAGT
-CAATCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGCGCAGATT
-AGCGATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAATACCATCT
-AATGCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCCCGTACTT
-TATCGATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACTATGTATTCTGCTGAT
-GAGTGAGGGAGCTGAATCCTAATTCGATCGAACTTCCGGAGCCATGCATATCAGCGTCTA
-AACGCTTCACGTTTTTCACACGTCGTTGAACAGATAAGATAATTAACACCCTGATTAGCC
-ATTCGCGCGCGCCGGCAGAGGTCACTACATAATTTAGCCGCGACTACCTCCAATGACCTT
-TAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGAAACGCCCCATAAAGG
-CCCACGAAACCCCGGCTCGTCGTCGTCCTTTCATTTTCTGTTGTGGCTAGCATAGGCCCC
-AGACGAAACGCAAATATCTCCAAAATGCGACACTGTAGCAAGGACACACGGGTATCTTAG
-ACCCCTAATAAGGTTTCGGAGGTCGTAAAATTAAATCATGACGCCCAGTTTGAATTCCTG
-ATCGTCCAAGTGCCACCCTAGCATCCAGGATTTGAACATTCATTGCTAAGCTCTACTAGG
-CAAGAGTCTAGACGCTCGTACTAAATTCACCAGTCGACTTGCAAGGCTCGGACACGTGTT
-GCCCCAACTATATCCTAGCAGATTCTACCTCAATTGCTCGCGAGTTATATGAAATCGCCA
-TCCCACATGCGCGGCCCACA
->m000_000/28/508_2508
-GAAATAATGATACGCATCGGATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTA
-GCGTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACC
-AGAGTATTTTGTGATGAGACTTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGC
-TCCCCATGGAGGTGAGTCCGGGGCCGTGTCACACAATACCTCTTTGCAGACGCCGCGTCC
-TGGTTATTATCGAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACAT
-AATTTTACTTGAACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGC
-CCTATATTTCGTATAACGATGTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTG
-TCACATCAGCTCGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACT
-CAACCATCGCTTTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTC
-GATCGAACTTCCGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCG
-TTGAACAGATAAGATAATTAACACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCAC
-TACATAATTTAGCCGCGACTACCTCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTG
-AAGTCGTTTTCCGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCGTCG
-TCCTTTCATTTTCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAAATATCTCCAAAA
-TGCGACACTGTAGCAAGGACACACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGGTCG
-TAAAATTAAATCATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGCATC
-CAGGATTTGAACATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACTAAA
-TTCACCAGTCGACTTGCAAGGCTCGGACACGTGTTGCCCCAACTATATCCTAGCAGATTC
-TACCTCAATTGCTCGCGAGTTATATGAAATCGCCATCCCACATGCGCGGCCCACACTCGC
-AACAAGGAAATGACGACCAGGGACGACATGATGTAGCGGGACTTAGGCACAATCGACTGG
-CGATCTTAGTTGACTTACAAAAGATCACGGGCCTACGCAATCGCCTAAGGAGCACCATGG
-CCCGGAGGCCTGCACAATAGACGTACGGCGCTCAAATACATTAGATCGCCAAACAGGGAG
-TATAGTCATGACCGCTATTCTCGCCTCAGGGGCGAGCGGCCCTGATGAAATGTGACGAAC
-AGTGAACGGATCCCCGCATTCCCTAAGGATTCACGCGGCATTTGCAAACCCGATTCTGCT
-CATCACCAAGAGTCAGATGGCCGGCCAATATGTGGAGTGCTGACCTCCCCAAACCCTGTT
-CGAAGCAACGTCCTTAGGTGAGGTTAGCTTTGCCAATAACAAGGCCCTAATCCATCACCG
-TGGCATACATGTCAATTTTTGACACTCGGAATGCGCGAACGGATAATTCTACGCGTCTGT
-GGTGCGCAGGAAAAATCAACTGGTTCAATGAAAAAGGAAGCTACGCGTGTTCGCATTGAT
-CCTGAGTTAGCTGGAAACGGGGGGATGGGGGTCGAATCGAGACAACGGCGACGGGGCCAA
-CCCATGTGTATCTCTCTCGGATGCGCTGGTCTCGAGGTTAGCTCCCAAGCTTAGGTCGAG
-ATCTAGTGCTCGTCGTGGCTGTATCCATTTTTCAGTAGTGGTACACTAAGCAAGTACAAG
-CCTCCAGAGAAAGTGTCGCGATTTCGCTGGAAGCCCTGGGGGTCATTTTAAACGAGAGAT
-GGGTTCTTATCTCGGGTCTAACACCCAGGTTGCTAACGGACAGTAAGTTGTTGCCACGAT
-TATGGACGCATGGCTACGGT
->m000_000/29/4132_6132
-GCCAGATCATGCACTTTGTGACTCAAAATCATATGAAGCAATCATGGTCGGCGGTGGCGA
-ATATAGTAACTTGGGTATTAGTGTAGCCAGATAGTTTACACTTTGACTCTAGAACACCCA
-GGCGAATAGGTCGTGTCCCGTGCTTAATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCC
-GGATGATGTCTCAGCTCTCGTCAAGACCCTCGAATATGCAATTCACTCCAAGGGCAAGAT
-CACAGAGGCAACAAATTCACGAACCTGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCG
-TAGGGTACGGTACTTACGGTAGCCTAATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGG
-ATATTTTCCGTGGTCTCCGTGGCATGCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACG
-CCCGGGCGGATTCTACTCTCAGTAGGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTAC
-TCATCGGAAACGTTTGTGTTACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAAC
-CTTGATGGATCTACGATCCTACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCCTA
-TGACAATGATTCAGGAGTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGA
-TCGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCC
-CATCTCAGCTCAGCCATCATTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCG
-ATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGA
-CAGAGCGACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATT
-AATTGACAGACGACGGGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGAT
-GGTGCCGCTATACAGCCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCTG
-TTGACCTGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATG
-TTCATTCGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGG
-CATTACCAGGCTCGTTGATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTGC
-ATAGGTTACGTCCAATGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGGC
-GGCTGTATGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGC
-AAAAGAAAAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAA
-TAATGATACGCATCGGATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGT
-ATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAG
-TATTTTGTGATGAGACTTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCC
-CATGGAGGTGAGTCCGGGGCCGTGTCACACAATACCTCTTTGCAGACGCCGCGTCCTGGT
-TATTATCGAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAATT
-TTACTTGAACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCCTA
-TATTTCGTATAACGATGTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTCAC
-ATCAGCTCGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCAAC
-CATCGCTTTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGATC
-GAACTTCCGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTTGA
-ACAGATAAGATAATTAACAC
->m000_000/30/1981_3981
-GGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGTCCTTAGGTGAGGTTAGCTTTGC
-CAATAACAAGGCCCTAATCCATCACCGTGGCATACATGTCAATTTTTGACACTCGGAATG
-CGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGAAAAATCAACTGGTTCAATGAAA
-AAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGCTGGAAACGGGGGGATGGGGGTC
-GAATCGAGACAACGGCGACGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGGTCTC
-GAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATTTTTC
-AGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTGGAAG
-CCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGGTTGC
-TAACGGACAGTAAGTTGTTGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGGCCGA
-ACACAATAATCAAGCCCAACTATCTATTGAATCCAGGATTGCGGCAACGATGGATAGCTA
-GGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTCTGCAGAAAAACCAGTTGAGCCC
-TAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTGGGCACTCAGGGCAGTGATTGCC
-TCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTACGTTTTTTTTTTCCACCCACCCG
-TCCAGGGGCATCTAGCTAGAATACTGAGCTCCTTTCGATTCCCTTCGACTCCTCCTCGGG
-CTCTCGACAGGATCCATGCCGACGTCATTCTCTATAAAAAGCCTACAAGGACGACGTTTG
-GACCTCAGACTTCACGAACATGTGCCACCGCGATCCCACTGCTCATTGTCCAGGTACTAG
-ACTGCGGGCTAGTAATGAGGCGGGTTCCTCAAAGTATAAGCGCCTAATGCTCCCAGTTTG
-AACATAGTCCTGCTGATTTCTTATTGCTTAGACACAGACACTTCACCTTGTGCGAGAGTT
-AAGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTTAACAAGA
-TTAAATGAATCAGAGATAGCAAATCTGTGCATGAGTTACCAGGAACTCGAACCCGGCTAA
-CTACACAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCATGGTTGT
-GACGATAGCACGTCCGAACCGCCGGCCGAATGAGCGCGTAGGTGAACGATATCATGGCCC
-GACGCCCCGTAGAGCTGGACTGGGGGCCAATGCCGAACAAGGGTATAACAAAAAAAAACC
-CCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTC
-CGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTT
-CGACGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGA
-GCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGT
-TTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGAT
-CCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGA
-TTGGACTTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAA
-CAACAGTTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCG
-AATCGCAGCGTCAATTAATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAATAT
-GCAGCAGAACTCCTTATCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTC
-GAATTGCAAGGACCGAGATT
->m000_000/31/4971_6971
-ACAGAGCGACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTAT
-TAATTGACAGACGACGGGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGA
-TGGTGCCGCTATACAGCCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCT
-GTTGACCTGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGAT
-GTTCATTCGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGG
-GCATTACCAGGCTCGTTGATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTG
-CATAGGTTACGTCCAATGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGG
-CGGCTGTATGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTG
-CAAAAGAAAAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAA
-ATAATGATACGCATCGGATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCG
-TATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGA
-GTATTTTGTGATGAGACTTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGCTCC
-CCATGGAGGTGAGTCCGGGGCCGTGTCACACAATACCTCTTTGCAGACGCCGCGTCCTGG
-TTATTATCGAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAAT
-TTTACTTGAACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCCT
-ATATTTCGTATAACGATGTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTCA
-CATCAGCTCGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCAA
-CCATCGCTTTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGAT
-CGAACTTCCGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTTG
-AACAGATAAGATAATTAACACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCACTAC
-ATAATTTAGCCGCGACTACCTCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTGAAG
-TCGTTTTCCGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCGTCGTCC
-TTTCATTTTCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAAATATCTCCAAAATGC
-GACACTGTAGCAAGGACACACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGGTCGTAA
-AATTAAATCATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGCATCCAG
-GATTTGAACATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACTAAATTC
-ACCAGTCGACTTGCAAGGCTCGGACACGTGTTGCCCCAACTATATCCTAGCAGATTCTAC
-CTCAATTGCTCGCGAGTTATATGAAATCGCCATCCCACATGCGCGGCCCACACTCGCAAC
-AAGGAAATGACGACCAGGGACGACATGATGTAGCGGGACTTAGGCACAATCGACTGGCGA
-TCTTAGTTGACTTACAAAAGATCACGGGCCTACGCAATCGCCTAAGGAGCACCATGGCCC
-GGAGGCCTGCACAATAGACGTACGGCGCTCAAATACATTAGATCGCCAAACAGGGAGTAT
-AGTCATGACCGCTATTCTCGCCTCAGGGGCGAGCGGCCCTGATGAAATGTGACGAACAGT
-GAACGGATCCCCGCATTCCCTAAGGATTCACGCGGCATTTGCAAACCCGATTCTGCTCAT
-CACCAAGAGTCAGATGGCCG
->m000_000/32/2059_4059
-CCATCACCGTGGCATACATGTCAATTTTTGACACTCGGAATGCGCGAACGGATAATTCTA
-CGCGTCTGTGGTGCGCAGGAAAAATCAACTGGTTCAATGAAAAAGGAAGCTACGCGTGTT
-CGCATTGATCCTGAGTTAGCTGGAAACGGGGGGATGGGGGTCGAATCGAGACAACGGCGA
-CGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGGTCTCGAGGTTAGCTCCCAAGCT
-TAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATTTTTCAGTAGTGGTACACTAAGC
-AAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTGGAAGCCCTGGGGGTCATTTTAA
-ACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGGTTGCTAACGGACAGTAAGTTGT
-TGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGGCCGAACACAATAATCAAGCCCA
-ACTATCTATTGAATCCAGGATTGCGGCAACGATGGATAGCTAGGGTAACTCGGGTAGCCT
-TGTCGTGTACGGAGATGCTCTGCAGAAAAACCAGTTGAGCCCTAAAGCCACCTTCCGGAA
-AGGCACTCTGCCAACTACTGGGCACTCAGGGCAGTGATTGCCTCACCGGGTTCGGGCAAG
-CAGGGTGGTAATCCCAGTACGTTTTTTTTTTCCACCCACCCGTCCAGGGGCATCTAGCTA
-GAATACTGAGCTCCTTTCGATTCCCTTCGACTCCTCCTCGGGCTCTCGACAGGATCCATG
-CCGACGTCATTCTCTATAAAAAGCCTACAAGGACGACGTTTGGACCTCAGACTTCACGAA
-CATGTGCCACCGCGATCCCACTGCTCATTGTCCAGGTACTAGACTGCGGGCTAGTAATGA
-GGCGGGTTCCTCAAAGTATAAGCGCCTAATGCTCCCAGTTTGAACATAGTCCTGCTGATT
-TCTTATTGCTTAGACACAGACACTTCACCTTGTGCGAGAGTTAAGGGCATGCTCCGGCTC
-AAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTTAACAAGATTAAATGAATCAGAGATA
-GCAAATCTGTGCATGAGTTACCAGGAACTCGAACCCGGCTAACTACACAGTGAGGAAAGT
-GAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCATGGTTGTGACGATAGCACGTCCGAA
-CCGCCGGCCGAATGAGCGCGTAGGTGAACGATATCATGGCCCGACGCCCCGTAGAGCTGG
-ACTGGGGGCCAATGCCGAACAAGGGTATAACAAAAAAAAACCCCCTTGGAGTAACTGAAA
-GTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTT
-CGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGA
-GGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGG
-GTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGG
-CTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCT
-CACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCAC
-CCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACA
-TATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAA
-TTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATC
-ACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGA
-TTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCT
-TGTCGAGATAGCGGACTATG
->m000_000/33/4928_6928
-GTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACG
-TCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGG
-GTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGC
-CCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCA
-TACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTA
-AACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTT
-GATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAAT
-GAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACC
-TAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCA
-GGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGG
-ATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCG
-GGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGAC
-TTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCG
-GGGCCGTGTCACACAATACCTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCG
-GAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCT
-CACATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGAT
-GTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTG
-CGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACT
-ATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGATCGAACTTCCGGAGCCAT
-GCATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTTGAACAGATAAGATAATTA
-ACACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCACTACATAATTTAGCCGCGACT
-ACCTCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGA
-AACGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCGTCGTCCTTTCATTTTCTGTTGTG
-GCTAGCATAGGCCCCAGACGAAACGCAAATATCTCCAAAATGCGACACTGTAGCAAGGAC
-ACACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGGTCGTAAAATTAAATCATGACGCC
-CAGTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGCATCCAGGATTTGAACATTCATTG
-CTAAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACTAAATTCACCAGTCGACTTGCAAG
-GCTCGGACACGTGTTGCCCCAACTATATCCTAGCAGATTCTACCTCAATTGCTCGCGAGT
-TATATGAAATCGCCATCCCACATGCGCGGCCCACACTCGCAACAAGGAAATGACGACCAG
-GGACGACATGATGTAGCGGGACTTAGGCACAATCGACTGGCGATCTTAGTTGACTTACAA
-AAGATCACGGGCCTACGCAATCGCCTAAGGAGCACCATGGCCCGGAGGCCTGCACAATAG
-ACGTACGGCGCTCAAATACATTAGATCGCCAAACAGGGAGTATAGTCATGACCGCTATTC
-TCGCCTCAGGGGCGAGCGGCCCTGATGAAATGTGACGAACAGTGAACGGATCCCCGCATT
-CCCTAAGGATTCACGCGGCA
->m000_000/34/1858_3858
-GGCGAGCGGCCCTGATGAAATGTGACGAACAGTGAACGGATCCCCGCATTCCCTAAGGAT
-TCACGCGGCATTTGCAAACCCGATTCTGCTCATCACCAAGAGTCAGATGGCCGGCCAATA
-TGTGGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGTCCTTAGGTGAGGTTAGCTT
-TGCCAATAACAAGGCCCTAATCCATCACCGTGGCATACATGTCAATTTTTGACACTCGGA
-ATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGAAAAATCAACTGGTTCAATG
-AAAAAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGCTGGAAACGGGGGGATGGGG
-GTCGAATCGAGACAACGGCGACGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGGT
-CTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATTT
-TTCAGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTGG
-AAGCCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGGT
-TGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGGC
-CGAACACAATAATCAAGCCCAACTATCTATTGAATCCAGGATTGCGGCAACGATGGATAG
-CTAGGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTCTGCAGAAAAACCAGTTGAG
-CCCTAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTGGGCACTCAGGGCAGTGATT
-GCCTCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTACGTTTTTTTTTTCCACCCAC
-CCGTCCAGGGGCATCTAGCTAGAATACTGAGCTCCTTTCGATTCCCTTCGACTCCTCCTC
-GGGCTCTCGACAGGATCCATGCCGACGTCATTCTCTATAAAAAGCCTACAAGGACGACGT
-TTGGACCTCAGACTTCACGAACATGTGCCACCGCGATCCCACTGCTCATTGTCCAGGTAC
-TAGACTGCGGGCTAGTAATGAGGCGGGTTCCTCAAAGTATAAGCGCCTAATGCTCCCAGT
-TTGAACATAGTCCTGCTGATTTCTTATTGCTTAGACACAGACACTTCACCTTGTGCGAGA
-GTTAAGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTTAACA
-AGATTAAATGAATCAGAGATAGCAAATCTGTGCATGAGTTACCAGGAACTCGAACCCGGC
-TAACTACACAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCATGGT
-TGTGACGATAGCACGTCCGAACCGCCGGCCGAATGAGCGCGTAGGTGAACGATATCATGG
-CCCGACGCCCCGTAGAGCTGGACTGGGGGCCAATGCCGAACAAGGGTATAACAAAAAAAA
-ACCCCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCAC
-TTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTC
-CTTCGACGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCC
-AGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCT
-GGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGC
-GATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTC
-CGATTGGACTTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCG
-TAACAACAGTTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTG
-GCGAATCGCAGCGTCAATTA
->m000_000/35/2727_4727
-TAATCCCAGTACGTTTTTTTTTTCCACCCACCCGTCCAGGGGCATCTAGCTAGAATACTG
-AGCTCCTTTCGATTCCCTTCGACTCCTCCTCGGGCTCTCGACAGGATCCATGCCGACGTC
-ATTCTCTATAAAAAGCCTACAAGGACGACGTTTGGACCTCAGACTTCACGAACATGTGCC
-ACCGCGATCCCACTGCTCATTGTCCAGGTACTAGACTGCGGGCTAGTAATGAGGCGGGTT
-CCTCAAAGTATAAGCGCCTAATGCTCCCAGTTTGAACATAGTCCTGCTGATTTCTTATTG
-CTTAGACACAGACACTTCACCTTGTGCGAGAGTTAAGGGCATGCTCCGGCTCAAGTCTTG
-AGCAAGTCATGTCAGTGCTAGTACTTTAACAAGATTAAATGAATCAGAGATAGCAAATCT
-GTGCATGAGTTACCAGGAACTCGAACCCGGCTAACTACACAGTGAGGAAAGTGAGAAGAG
-GGTCGAAAAGCTTGCTGGTCTCGATCATGGTTGTGACGATAGCACGTCCGAACCGCCGGC
-CGAATGAGCGCGTAGGTGAACGATATCATGGCCCGACGCCCCGTAGAGCTGGACTGGGGG
-CCAATGCCGAACAAGGGTATAACAAAAAAAAACCCCCTTGGAGTAACTGAAAGTCTCACC
-CGCGCAGCGGATACCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTTCGTGAACA
-GAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGAGGTTCCGA
-TCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGGGTTGTATT
-GCGCTAGAGCCACCACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGACTGC
-CTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACCCGCC
-GCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCACCCTCACCC
-TCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACATATGACTA
-CGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAATTCCCAGG
-CAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATCACTATCGA
-GCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGATTTACTCC
-AGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCTTGTCGAGA
-TAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACGAGTCTAGAC
-CTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAAATCATATG
-AAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGCCAGATAGT
-TTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAATGAGGTAC
-TTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTCGAAT
-ATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAGCTTA
-ACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAATAGTTATC
-CTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGCAGTCCTTT
-TTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGCGAGCGCGA
-GTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGGCGACTAGC
-AGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATTCATA
-ATCGGACATCCTAGGTGGTT
->m000_000/36/3186_5186
-CAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCATGGTTGTGACGA
-TAGCACGTCCGAACCGCCGGCCGAATGAGCGCGTAGGTGAACGATATCATGGCCCGACGC
-CCCGTAGAGCTGGACTGGGGGCCAATGCCGAACAAGGGTATAACAAAAAAAAACCCCCTT
-GGAGTAACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTCCGCTG
-GGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTCGACG
-TGTCTATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAGCAAT
-CCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGTTTCGT
-ACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCGGA
-TGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGA
-CTTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACA
-GTTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCG
-CAGCGTCAATTAATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGC
-AGAACTCCTTATCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATT
-GCAAGGACCGAGATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCA
-ATGCATATCCTCTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCC
-CCACCACCCACGAGTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCAC
-TTTGTGACTCAAAATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGG
-GTATTAGTGTAGCCAGATAGTTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGT
-GTCCCGTGCTTAATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAG
-CTCTCGTCAAGACCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAA
-ATTCACGAACCTGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACT
-TACGGTAGCCTAATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGT
-CTCCGTGGCATGCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCT
-ACTCTCAGTAGGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTT
-TGTGTTACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTAC
-GATCCTACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAG
-GAGTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATC
-AGAGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGC
-CATCATTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAG
-AAGTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATA
-CGTCTTTTCGCTCAAACTACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGAC
-GGGTAAGGCCAAGTATAATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACA
-GCCCATGGCTTGCATGAATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTT
-CATACTTCCGTTAGTTCTGC
->m000_000/37/4287_6287
-TTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTCGAAT
-ATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAGCTTA
-ACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAATAGTTATC
-CTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGCAGTCCTTT
-TTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGCGAGCGCGA
-GTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGGCGACTAGC
-AGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATTCATA
-ATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACGCCTG
-GCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTTA
-TGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGACACCAGGG
-AGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAATA
-GAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAACTACG
-TTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATAATAA
-CAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGAATTA
-TCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTCTGCG
-CATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATTGGAG
-CTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGATCATCGATGC
-AATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTGATTAAGATGG
-CAGACTACCGTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCATTCACGAGTCTT
-GGATAGCCGCCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTTGAATAAGAGG
-TAAGCATGCGCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAAATTACAACCAG
-TAGTGGCCGCCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAGA
-CGGGCGGTCCGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTCTTGTGTCGATA
-GCAGCAGTTAATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGGCCGTGTCACACAATAC
-CTCTTTGCAGACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACAATTCAGTCAAT
-CTCTCACGTTGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGCGCAGATTAGCG
-ATTGGCTCTCTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAATACCATCTAATG
-CCGCTTATCAGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCCCGTACTTTATC
-GATCGAGCAGAGCAGGATACTCAACCATCGCTTTATTTACTATGTATTCTGCTGATGAGT
-GAGGGAGCTGAATCCTAATTCGATCGAACTTCCGGAGCCATGCATATCAGCGTCTAAACG
-CTTCACGTTTTTCACACGTCGTTGAACAGATAAGATAATTAACACCCTGATTAGCCATTC
-GCGCGCGCCGGCAGAGGTCACTACATAATTTAGCCGCGACTACCTCCAATGACCTTTAGT
-CATCACGAGCTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGAAACGCCCCATAAAGGCCCA
-CGAAACCCCGGCTCGTCGTC
->m000_000/38/3264_5264
-GGCCGAATGAGCGCGTAGGTGAACGATATCATGGCCCGACGCCCCGTAGAGCTGGACTGG
-GGGCCAATGCCGAACAAGGGTATAACAAAAAAAAACCCCCTTGGAGTAACTGAAAGTCTC
-ACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTTCGTGA
-ACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGAGGTTC
-CGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGGGTTGT
-ATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGAC
-TGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACCC
-GCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCACCCTCA
-CCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACATATGA
-CTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAATTCCC
-AGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATCACTAT
-CGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGATTTAC
-TCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCTTGTCG
-AGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACGAGTCTA
-GACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAAATCAT
-ATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGCCAGAT
-AGTTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAATGAGG
-TACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTCG
-AATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAGC
-TTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAATAGTT
-ATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGCAGTCC
-TTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGCGAGCG
-CGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGGCGACT
-AGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATTC
-ATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACGC
-CTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGGC
-TTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGACACCA
-GGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTA
-ATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAACT
-ACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATAA
-TAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGAA
-TTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTCT
-GCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATTG
-GAGCTTGTGCGGGTCTGCCT
->m000_000/39/556_2556
-CCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTC
-CGAAGGAGTACCAGAGTATTTTGTGATGAGACTTTAGTTCTTGTGTCGATAGCAGCAGTT
-AATTGACTGTGCTCCCCATGGAGGTGAGTCCGGGGCCGTGTCACACAATACCTCTTTGCA
-GACGCCGCGTCCTGGTTATTATCGAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGT
-TGTCTCAGACATAATTTTACTTGAACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCT
-CTTAAACATAGCCCTATATTTCGTATAACGATGTCTCAATACCATCTAATGCCGCTTATC
-AGCAGTCTATTGTCACATCAGCTCGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCA
-GAGCAGGATACTCAACCATCGCTTTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCT
-GAATCCTAATTCGATCGAACTTCCGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTT
-TTTCACACGTCGTTGAACAGATAAGATAATTAACACCCTGATTAGCCATTCGCGCGCGCC
-GGCAGAGGTCACTACATAATTTAGCCGCGACTACCTCCAATGACCTTTAGTCATCACGAG
-CTTTTTGCGCTGAAGTCGTTTTCCGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCC
-GGCTCGTCGTCGTCCTTTCATTTTCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAA
-ATATCTCCAAAATGCGACACTGTAGCAAGGACACACGGGTATCTTAGACCCCTAATAAGG
-TTTCGGAGGTCGTAAAATTAAATCATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGC
-CACCCTAGCATCCAGGATTTGAACATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGAC
-GCTCGTACTAAATTCACCAGTCGACTTGCAAGGCTCGGACACGTGTTGCCCCAACTATAT
-CCTAGCAGATTCTACCTCAATTGCTCGCGAGTTATATGAAATCGCCATCCCACATGCGCG
-GCCCACACTCGCAACAAGGAAATGACGACCAGGGACGACATGATGTAGCGGGACTTAGGC
-ACAATCGACTGGCGATCTTAGTTGACTTACAAAAGATCACGGGCCTACGCAATCGCCTAA
-GGAGCACCATGGCCCGGAGGCCTGCACAATAGACGTACGGCGCTCAAATACATTAGATCG
-CCAAACAGGGAGTATAGTCATGACCGCTATTCTCGCCTCAGGGGCGAGCGGCCCTGATGA
-AATGTGACGAACAGTGAACGGATCCCCGCATTCCCTAAGGATTCACGCGGCATTTGCAAA
-CCCGATTCTGCTCATCACCAAGAGTCAGATGGCCGGCCAATATGTGGAGTGCTGACCTCC
-CCAAACCCTGTTCGAAGCAACGTCCTTAGGTGAGGTTAGCTTTGCCAATAACAAGGCCCT
-AATCCATCACCGTGGCATACATGTCAATTTTTGACACTCGGAATGCGCGAACGGATAATT
-CTACGCGTCTGTGGTGCGCAGGAAAAATCAACTGGTTCAATGAAAAAGGAAGCTACGCGT
-GTTCGCATTGATCCTGAGTTAGCTGGAAACGGGGGGATGGGGGTCGAATCGAGACAACGG
-CGACGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGGTCTCGAGGTTAGCTCCCAA
-GCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATTTTTCAGTAGTGGTACACTA
-AGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTGGAAGCCCTGGGGGTCATTT
-TAAACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGGTTGCTAACGGACAGTAAGT
-TGTTGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGGCCGAACACAATAATCAAGC
-CCAACTATCTATTGAATCCA
->m000_000/40/2274_4274
-TGGTCTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCC
-ATTTTTCAGTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCG
-CTGGAAGCCCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAACACCC
-AGGTTGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACGCATGGCTACGGTAAGAAA
-GGGCCGAACACAATAATCAAGCCCAACTATCTATTGAATCCAGGATTGCGGCAACGATGG
-ATAGCTAGGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTCTGCAGAAAAACCAGT
-TGAGCCCTAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTGGGCACTCAGGGCAGT
-GATTGCCTCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTACGTTTTTTTTTTCCAC
-CCACCCGTCCAGGGGCATCTAGCTAGAATACTGAGCTCCTTTCGATTCCCTTCGACTCCT
-CCTCGGGCTCTCGACAGGATCCATGCCGACGTCATTCTCTATAAAAAGCCTACAAGGACG
-ACGTTTGGACCTCAGACTTCACGAACATGTGCCACCGCGATCCCACTGCTCATTGTCCAG
-GTACTAGACTGCGGGCTAGTAATGAGGCGGGTTCCTCAAAGTATAAGCGCCTAATGCTCC
-CAGTTTGAACATAGTCCTGCTGATTTCTTATTGCTTAGACACAGACACTTCACCTTGTGC
-GAGAGTTAAGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTT
-AACAAGATTAAATGAATCAGAGATAGCAAATCTGTGCATGAGTTACCAGGAACTCGAACC
-CGGCTAACTACACAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCA
-TGGTTGTGACGATAGCACGTCCGAACCGCCGGCCGAATGAGCGCGTAGGTGAACGATATC
-ATGGCCCGACGCCCCGTAGAGCTGGACTGGGGGCCAATGCCGAACAAGGGTATAACAAAA
-AAAAACCCCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGCACAC
-TCACTTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGG
-ACTCCTTCGACGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAA
-AGCCAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGA
-GCCTGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAAC
-AAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTC
-TCTCCGATTGGACTTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAA
-TTCGTAACAACAGTTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTG
-ATTGGCGAATCGCAGCGTCAATTAATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTA
-CGAATATGCAGCAGAACTCCTTATCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGG
-GTCACTCGAATTGCAAGGACCGAGATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGT
-AGACATCTATCAATGCATATCCTCTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCA
-CATGCTGCCGCCCCACCACCCACGAGTCTAGACCTAGTCAAGTGCTTTACAATACATCGC
-CAGATCATGCACTTTGTGACTCAAAATCATATGAAGCAATCATGGTCGGCGGTGGCGAAT
-ATAGTAACTTGGGTATTAGTGTAGCCAGATAGTTTACACTTTGACTCTAGAACACCCAGG
-CGAATAGGTCGTGTCCCGTG
->m000_000/41/3008_5008
-TCCTGCTGATTTCTTATTGCTTAGACACAGACACTTCACCTTGTGCGAGAGTTAAGGGCA
-TGCTCCGGCTCAAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTTAACAAGATTAAATG
-AATCAGAGATAGCAAATCTGTGCATGAGTTACCAGGAACTCGAACCCGGCTAACTACACA
-GTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCATGGTTGTGACGATA
-GCACGTCCGAACCGCCGGCCGAATGAGCGCGTAGGTGAACGATATCATGGCCCGACGCCC
-CGTAGAGCTGGACTGGGGGCCAATGCCGAACAAGGGTATAACAAAAAAAAACCCCCTTGG
-AGTAACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTCCGCTGGG
-GGCTTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTCGACGTG
-TCTATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAGCAATCC
-CCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGTTTCGTAC
-TGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCGGATG
-TTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGACT
-TTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAGT
-TATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCA
-GCGTCAATTAATTCCCAGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGCAG
-AACTCCTTATCACTATCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTGC
-AAGGACCGAGATTTACTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAAT
-GCATATCCTCTTGTCGAGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCC
-ACCACCCACGAGTCTAGACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTT
-TGTGACTCAAAATCATATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGT
-ATTAGTGTAGCCAGATAGTTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGT
-CCCGTGCTTAATGAGGTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCT
-CTCGTCAAGACCCTCGAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAAT
-TCACGAACCTGCGAGCTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTA
-CGGTAGCCTAATAGTTATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCT
-CCGTGGCATGCAGTCCTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTAC
-TCTCAGTAGGCGAGCGCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTG
-TGTTACTGGGGCGACTAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGA
-TCCTACTTAAGGATTCATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGA
-GTTTTAGAGATAACGCCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAG
-AGGGAGCCTTTTAGGCTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCA
-TCATTTATCGACACCAGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAA
-GTGCCCAGGTCTTGTAATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACG
-TCTTTTCGCTCAAACTACGT
->m000_000/42/3392_5392
-AGCGGATACCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTA
-GGGTAGGCTCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGAGGTTCCGATCTTT
-TGATGCCCAGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCT
-AGAGCCACCACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGC
-CTGTTGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGT
-CATTTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCACCCTCACCCTCACG
-TGAGATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACATATGACTACGTGT
-TACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAATTCCCAGGCAAGA
-TAATGTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATCACTATCGAGCTCC
-CGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGATTTACTCCAGTAG
-CCCACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCTTGTCGAGATAGCG
-GACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACGAGTCTAGACCTAGT
-CAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAAATCATATGAAGCA
-ATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGCCAGATAGTTTACA
-CTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAATGAGGTACTTGAA
-GGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTCGAATATGCA
-ATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAGCTTAACTCA
-GAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAATAGTTATCCTCGG
-GTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGCAGTCCTTTTTACC
-ACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGCGAGCGCGAGTAAA
-TCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGGCGACTAGCAGAGT
-TTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATTCATAATCGG
-ACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACGCCTGGCCTA
-GACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAG
-AGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGACACCAGGGAGTGA
-ATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATC
-GGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAACTACGTTCTG
-CTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATAATAACAGCC
-GAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGAATTATCAAC
-AACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTCTGCGCATGC
-TGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATTGGAGCTTGT
-GCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGATCATCGATGCAATAA
-TACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTGATTAAGATGGCAGAC
-TACCGTCGACCCGATAGGGC
->m000_000/43/3383_5383
-CACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTTCGTG
-AACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGAGGTT
-CCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGGGTTG
-TATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGA
-CTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACC
-CGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCACCCTC
-ACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACATATG
-ACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAATTCC
-CAGGCAAGATAATGTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATCACTA
-TCGAGCTCCCGGTGCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGATTTA
-CTCCAGTAGCCCACGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCTTGTC
-GAGATAGCGGACTATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACGAGTCT
-AGACCTAGTCAAGTGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAAATCA
-TATGAAGCAATCATGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGCCAGA
-TAGTTTACACTTTGACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAATGAG
-GTACTTGAAGGAGACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTC
-GAATATGCAATTCACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAG
-CTTAACTCAGAGCGTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAATAGT
-TATCCTCGGGTACGTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGCAGTC
-CTTTTTACCACCGTCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGCGAGC
-GCGAGTAAATCCCAGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGGCGAC
-TAGCAGAGTTTGGCTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATT
-CATAATCGGACATCCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACG
-CCTGGCCTAGACAAAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGG
-CTTATGAAGAGGCTAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGACACC
-AGGGAGTGAATGAACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGT
-AATAGAATCGGTTTCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAAC
-TACGTTCTGCTGAGAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATA
-ATAACAGCCGAAGGAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGA
-ATTATCAACAACGGCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTC
-TGCGCATGCTGTCAGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATT
-GGAGCTTGTGCGGGTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGATCATCG
-ATGCAATAATACGGACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTGATTAAG
-ATGGCAGACTACCGTCGACC
->m000_000/44/155_2155
-ACCTGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTCAGTGCGCGCGTTGATGTTC
-ATTCGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGGGTCTGCCTAGCGTGGGCAT
-TACCAGGCTCGTTGATGGAAGATCATCGATGCAATAATACGGACGCAAAGGAGTTGCATA
-GGTTACGTCCAATGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGC
-TGTATGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAA
-AGAAAAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAA
-TGATACGCATCGGATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATT
-GCCGGCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTAT
-TTTGTGATGAGACTTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCCCAT
-GGAGGTGAGTCCGGGGCCGTGTCACACAATACCTCTTTGCAGACGCCGCGTCCTGGTTAT
-TATCGAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTA
-CTTGAACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATAT
-TTCGTATAACGATGTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATC
-AGCTCGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCAACCAT
-CGCTTTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGATCGAA
-CTTCCGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTTGAACA
-GATAAGATAATTAACACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCACTACATAA
-TTTAGCCGCGACTACCTCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTGAAGTCGT
-TTTCCGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCGTCGTCCTTTC
-ATTTTCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAAATATCTCCAAAATGCGACA
-CTGTAGCAAGGACACACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGGTCGTAAAATT
-AAATCATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGCATCCAGGATT
-TGAACATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACTAAATTCACCA
-GTCGACTTGCAAGGCTCGGACACGTGTTGCCCCAACTATATCCTAGCAGATTCTACCTCA
-ATTGCTCGCGAGTTATATGAAATCGCCATCCCACATGCGCGGCCCACACTCGCAACAAGG
-AAATGACGACCAGGGACGACATGATGTAGCGGGACTTAGGCACAATCGACTGGCGATCTT
-AGTTGACTTACAAAAGATCACGGGCCTACGCAATCGCCTAAGGAGCACCATGGCCCGGAG
-GCCTGCACAATAGACGTACGGCGCTCAAATACATTAGATCGCCAAACAGGGAGTATAGTC
-ATGACCGCTATTCTCGCCTCAGGGGCGAGCGGCCCTGATGAAATGTGACGAACAGTGAAC
-GGATCCCCGCATTCCCTAAGGATTCACGCGGCATTTGCAAACCCGATTCTGCTCATCACC
-AAGAGTCAGATGGCCGGCCAATATGTGGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCA
-ACGTCCTTAGGTGAGGTTAGCTTTGCCAATAACAAGGCCCTAATCCATCACCGTGGCATA
-CATGTCAATTTTTGACACTCGGAATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGC
-AGGAAAAATCAACTGGTTCA
->m000_000/45/1871_3871
-GATGAAATGTGACGAACAGTGAACGGATCCCCGCATTCCCTAAGGATTCACGCGGCATTT
-GCAAACCCGATTCTGCTCATCACCAAGAGTCAGATGGCCGGCCAATATGTGGAGTGCTGA
-CCTCCCCAAACCCTGTTCGAAGCAACGTCCTTAGGTGAGGTTAGCTTTGCCAATAACAAG
-GCCCTAATCCATCACCGTGGCATACATGTCAATTTTTGACACTCGGAATGCGCGAACGGA
-TAATTCTACGCGTCTGTGGTGCGCAGGAAAAATCAACTGGTTCAATGAAAAAGGAAGCTA
-CGCGTGTTCGCATTGATCCTGAGTTAGCTGGAAACGGGGGGATGGGGGTCGAATCGAGAC
-AACGGCGACGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGGTCTCGAGGTTAGCT
-CCCAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATTTTTCAGTAGTGGTA
-CACTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTGGAAGCCCTGGGGGT
-CATTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGGTTGCTAACGGACAG
-TAAGTTGTTGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGGCCGAACACAATAAT
-CAAGCCCAACTATCTATTGAATCCAGGATTGCGGCAACGATGGATAGCTAGGGTAACTCG
-GGTAGCCTTGTCGTGTACGGAGATGCTCTGCAGAAAAACCAGTTGAGCCCTAAAGCCACC
-TTCCGGAAAGGCACTCTGCCAACTACTGGGCACTCAGGGCAGTGATTGCCTCACCGGGTT
-CGGGCAAGCAGGGTGGTAATCCCAGTACGTTTTTTTTTTCCACCCACCCGTCCAGGGGCA
-TCTAGCTAGAATACTGAGCTCCTTTCGATTCCCTTCGACTCCTCCTCGGGCTCTCGACAG
-GATCCATGCCGACGTCATTCTCTATAAAAAGCCTACAAGGACGACGTTTGGACCTCAGAC
-TTCACGAACATGTGCCACCGCGATCCCACTGCTCATTGTCCAGGTACTAGACTGCGGGCT
-AGTAATGAGGCGGGTTCCTCAAAGTATAAGCGCCTAATGCTCCCAGTTTGAACATAGTCC
-TGCTGATTTCTTATTGCTTAGACACAGACACTTCACCTTGTGCGAGAGTTAAGGGCATGC
-TCCGGCTCAAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTTAACAAGATTAAATGAAT
-CAGAGATAGCAAATCTGTGCATGAGTTACCAGGAACTCGAACCCGGCTAACTACACAGTG
-AGGAAAGTGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCATGGTTGTGACGATAGCA
-CGTCCGAACCGCCGGCCGAATGAGCGCGTAGGTGAACGATATCATGGCCCGACGCCCCGT
-AGAGCTGGACTGGGGGCCAATGCCGAACAAGGGTATAACAAAAAAAAACCCCCTTGGAGT
-AACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTCCGCTGGGGGC
-TTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTCGACGTGTCT
-ATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAGCAATCCCCA
-TCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGTTTCGTACTGT
-GGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATCCGGATGTTG
-ATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGATTGGACTTTA
-CAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAACAACAGTTAT
-TGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCG
-TCAATTAATTCCCAGGCAAG
->m000_000/46/3636_5636
-TGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATT
-TCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCACCCTCACCCTCACGTGAG
-ATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACATATGACTACGTGTTACA
-TCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAATTCCCAGGCAAGATAAT
-GTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATCACTATCGAGCTCCCGGT
-GCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGATTTACTCCAGTAGCCCA
-CGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCTTGTCGAGATAGCGGACT
-ATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACGAGTCTAGACCTAGTCAAG
-TGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAAATCATATGAAGCAATCA
-TGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGCCAGATAGTTTACACTTT
-GACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAATGAGGTACTTGAAGGAG
-ACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTCGAATATGCAATTC
-ACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAGCTTAACTCAGAGC
-GTCGGCACTGCTCTCGTAGGGTACGGTACTTACGGTAGCCTAATAGTTATCCTCGGGTAC
-GTGGGCTCGGTTTAGGATATTTTCCGTGGTCTCCGTGGCATGCAGTCCTTTTTACCACCG
-TCTCTCCGGGTTGACGCCCGGGCGGATTCTACTCTCAGTAGGCGAGCGCGAGTAAATCCC
-AGCGTGCTCCCTGTACTCATCGGAAACGTTTGTGTTACTGGGGCGACTAGCAGAGTTTGG
-CTTAGCCGGTGAAAACCTTGATGGATCTACGATCCTACTTAAGGATTCATAATCGGACAT
-CCTAGGTGGTTTCCTATGACAATGATTCAGGAGTTTTAGAGATAACGCCTGGCCTAGACA
-AAGCATTAAGGCGTGATCGCGCTGAGCATCAGAGGGAGCCTTTTAGGCTTATGAAGAGGC
-TAGAGGTAAAATACCCCATCTCAGCTCAGCCATCATTTATCGACACCAGGGAGTGAATGA
-ACCGTGTTAGGCCGCGATTGGGTTTTGCAGAAGTGCCCAGGTCTTGTAATAGAATCGGTT
-TCTGAAACCTTTTCGACAGAGCGACGTATACGTCTTTTCGCTCAAACTACGTTCTGCTGA
-GAAAATTGGCGTTATTAATTGACAGACGACGGGTAAGGCCAAGTATAATAACAGCCGAAG
-GAGGGTTACCTAAGATGGTGCCGCTATACAGCCCATGGCTTGCATGAATTATCAACAACG
-GCTCGGCTGTCAGCTGTTGACCTGACTCTTCATACTTCCGTTAGTTCTGCGCATGCTGTC
-AGTGCGCGCGTTGATGTTCATTCGCGTTTCTAAACGACGCTAACATTGGAGCTTGTGCGG
-GTCTGCCTAGCGTGGGCATTACCAGGCTCGTTGATGGAAGATCATCGATGCAATAATACG
-GACGCAAAGGAGTTGCATAGGTTACGTCCAATGAATGTGTGATTAAGATGGCAGACTACC
-GTCGACCCGATAGGGCGGCTGTATGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCG
-CCCACCGGCGAGGTGCAAAAGAAAAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGC
-GCAAAACGGAGAGAAATAATGATACGCATCGGATAGTTAAATTACAACCAGTAGTGGCCG
-CCTTGTTCTCTAGCGTATTGCCGGCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTC
-CGAAGGAGTACCAGAGTATT
->m000_000/47/2436_4436
-ATCTCGGGTCTAACACCCAGGTTGCTAACGGACAGTAAGTTGTTGCCACGATTATGGACG
-CATGGCTACGGTAAGAAAGGGCCGAACACAATAATCAAGCCCAACTATCTATTGAATCCA
-GGATTGCGGCAACGATGGATAGCTAGGGTAACTCGGGTAGCCTTGTCGTGTACGGAGATG
-CTCTGCAGAAAAACCAGTTGAGCCCTAAAGCCACCTTCCGGAAAGGCACTCTGCCAACTA
-CTGGGCACTCAGGGCAGTGATTGCCTCACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAG
-TACGTTTTTTTTTTCCACCCACCCGTCCAGGGGCATCTAGCTAGAATACTGAGCTCCTTT
-CGATTCCCTTCGACTCCTCCTCGGGCTCTCGACAGGATCCATGCCGACGTCATTCTCTAT
-AAAAAGCCTACAAGGACGACGTTTGGACCTCAGACTTCACGAACATGTGCCACCGCGATC
-CCACTGCTCATTGTCCAGGTACTAGACTGCGGGCTAGTAATGAGGCGGGTTCCTCAAAGT
-ATAAGCGCCTAATGCTCCCAGTTTGAACATAGTCCTGCTGATTTCTTATTGCTTAGACAC
-AGACACTTCACCTTGTGCGAGAGTTAAGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTCA
-TGTCAGTGCTAGTACTTTAACAAGATTAAATGAATCAGAGATAGCAAATCTGTGCATGAG
-TTACCAGGAACTCGAACCCGGCTAACTACACAGTGAGGAAAGTGAGAAGAGGGTCGAAAA
-GCTTGCTGGTCTCGATCATGGTTGTGACGATAGCACGTCCGAACCGCCGGCCGAATGAGC
-GCGTAGGTGAACGATATCATGGCCCGACGCCCCGTAGAGCTGGACTGGGGGCCAATGCCG
-AACAAGGGTATAACAAAAAAAAACCCCCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCG
-GATACCCTTGGTGCACACTCACTTCCGCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGT
-AGGCTCTGATGGGGCTGGACTCCTTCGACGTGTCTATTTGAGAGGTTCCGATCTTTTGAT
-GCCCAGAAGCACCAAAAAAGCCAGAGCAATCCCCATCTTGCGGGTTGTATTGCGCTAGAG
-CCACCACACGCAAAACGAGCCTGGTTTCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGT
-TGGTTACTCGGCCTCAACAAGCGATCCGGATGTTGATATTTCTCACCCGCCGCGGTCATT
-TCGAACCTGATTCTTCTCTCTCCGATTGGACTTTACAGGCCACCCTCACCCTCACGTGAG
-ATAAATATGCCTGAACAATTCGTAACAACAGTTATTGCTCACATATGACTACGTGTTACA
-TCTGGAGTGCCCGTAGTGATTGGCGAATCGCAGCGTCAATTAATTCCCAGGCAAGATAAT
-GTCACACAGGAGTGGTTACGAATATGCAGCAGAACTCCTTATCACTATCGAGCTCCCGGT
-GCCAGTAGCTAACGCGGGGTCACTCGAATTGCAAGGACCGAGATTTACTCCAGTAGCCCA
-CGTCTCCCAGAGTTAGGTAGACATCTATCAATGCATATCCTCTTGTCGAGATAGCGGACT
-ATGCGAGTGAGAGAAGCACATGCTGCCGCCCCACCACCCACGAGTCTAGACCTAGTCAAG
-TGCTTTACAATACATCGCCAGATCATGCACTTTGTGACTCAAAATCATATGAAGCAATCA
-TGGTCGGCGGTGGCGAATATAGTAACTTGGGTATTAGTGTAGCCAGATAGTTTACACTTT
-GACTCTAGAACACCCAGGCGAATAGGTCGTGTCCCGTGCTTAATGAGGTACTTGAAGGAG
-ACCTAAGGCCTTCCCCGGATGATGTCTCAGCTCTCGTCAAGACCCTCGAATATGCAATTC
-ACTCCAAGGGCAAGATCACAGAGGCAACAAATTCACGAACCTGCGAGCTTAACTCAGAGC
-GTCGGCACTGCTCTCGTAGG
->m000_000/48/339_2339
-ACGTCCAATGAATGTGTGATTAAGATGGCAGACTACCGTCGACCCGATAGGGCGGCTGTA
-TGTCTTACCTAACGCATTCACGAGTCTTGGATAGCCGCCCACCGGCGAGGTGCAAAAGAA
-AAAGTCCCAGGAGGGTTTGAATAAGAGGTAAGCATGCGCAAAACGGAGAGAAATAATGAT
-ACGCATCGGATAGTTAAATTACAACCAGTAGTGGCCGCCTTGTTCTCTAGCGTATTGCCG
-GCTCAGTCGGGCCTCAAGTCGGAGAAGACGGGCGGTCCGAAGGAGTACCAGAGTATTTTG
-TGATGAGACTTTAGTTCTTGTGTCGATAGCAGCAGTTAATTGACTGTGCTCCCCATGGAG
-GTGAGTCCGGGGCCGTGTCACACAATACCTCTTTGCAGACGCCGCGTCCTGGTTATTATC
-GAAAGGTCGGAGTGACAATTCAGTCAATCTCTCACGTTGTCTCAGACATAATTTTACTTG
-AACAGGGCTCACATGGCGCAGATTAGCGATTGGCTCTCTTAAACATAGCCCTATATTTCG
-TATAACGATGTCTCAATACCATCTAATGCCGCTTATCAGCAGTCTATTGTCACATCAGCT
-CGGATGGTGCGTAGCCCCGTACTTTATCGATCGAGCAGAGCAGGATACTCAACCATCGCT
-TTATTTACTATGTATTCTGCTGATGAGTGAGGGAGCTGAATCCTAATTCGATCGAACTTC
-CGGAGCCATGCATATCAGCGTCTAAACGCTTCACGTTTTTCACACGTCGTTGAACAGATA
-AGATAATTAACACCCTGATTAGCCATTCGCGCGCGCCGGCAGAGGTCACTACATAATTTA
-GCCGCGACTACCTCCAATGACCTTTAGTCATCACGAGCTTTTTGCGCTGAAGTCGTTTTC
-CGGTCTGGAAACGCCCCATAAAGGCCCACGAAACCCCGGCTCGTCGTCGTCCTTTCATTT
-TCTGTTGTGGCTAGCATAGGCCCCAGACGAAACGCAAATATCTCCAAAATGCGACACTGT
-AGCAAGGACACACGGGTATCTTAGACCCCTAATAAGGTTTCGGAGGTCGTAAAATTAAAT
-CATGACGCCCAGTTTGAATTCCTGATCGTCCAAGTGCCACCCTAGCATCCAGGATTTGAA
-CATTCATTGCTAAGCTCTACTAGGCAAGAGTCTAGACGCTCGTACTAAATTCACCAGTCG
-ACTTGCAAGGCTCGGACACGTGTTGCCCCAACTATATCCTAGCAGATTCTACCTCAATTG
-CTCGCGAGTTATATGAAATCGCCATCCCACATGCGCGGCCCACACTCGCAACAAGGAAAT
-GACGACCAGGGACGACATGATGTAGCGGGACTTAGGCACAATCGACTGGCGATCTTAGTT
-GACTTACAAAAGATCACGGGCCTACGCAATCGCCTAAGGAGCACCATGGCCCGGAGGCCT
-GCACAATAGACGTACGGCGCTCAAATACATTAGATCGCCAAACAGGGAGTATAGTCATGA
-CCGCTATTCTCGCCTCAGGGGCGAGCGGCCCTGATGAAATGTGACGAACAGTGAACGGAT
-CCCCGCATTCCCTAAGGATTCACGCGGCATTTGCAAACCCGATTCTGCTCATCACCAAGA
-GTCAGATGGCCGGCCAATATGTGGAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGT
-CCTTAGGTGAGGTTAGCTTTGCCAATAACAAGGCCCTAATCCATCACCGTGGCATACATG
-TCAATTTTTGACACTCGGAATGCGCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGA
-AAAATCAACTGGTTCAATGAAAAAGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGC
-TGGAAACGGGGGGATGGGGGTCGAATCGAGACAACGGCGACGGGGCCAACCCATGTGTAT
-CTCTCTCGGATGCGCTGGTCTCGAGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTC
-GTCGTGGCTGTATCCATTTT
->m000_000/49/1862_3862
-AGCGGCCCTGATGAAATGTGACGAACAGTGAACGGATCCCCGCATTCCCTAAGGATTCAC
-GCGGCATTTGCAAACCCGATTCTGCTCATCACCAAGAGTCAGATGGCCGGCCAATATGTG
-GAGTGCTGACCTCCCCAAACCCTGTTCGAAGCAACGTCCTTAGGTGAGGTTAGCTTTGCC
-AATAACAAGGCCCTAATCCATCACCGTGGCATACATGTCAATTTTTGACACTCGGAATGC
-GCGAACGGATAATTCTACGCGTCTGTGGTGCGCAGGAAAAATCAACTGGTTCAATGAAAA
-AGGAAGCTACGCGTGTTCGCATTGATCCTGAGTTAGCTGGAAACGGGGGGATGGGGGTCG
-AATCGAGACAACGGCGACGGGGCCAACCCATGTGTATCTCTCTCGGATGCGCTGGTCTCG
-AGGTTAGCTCCCAAGCTTAGGTCGAGATCTAGTGCTCGTCGTGGCTGTATCCATTTTTCA
-GTAGTGGTACACTAAGCAAGTACAAGCCTCCAGAGAAAGTGTCGCGATTTCGCTGGAAGC
-CCTGGGGGTCATTTTAAACGAGAGATGGGTTCTTATCTCGGGTCTAACACCCAGGTTGCT
-AACGGACAGTAAGTTGTTGCCACGATTATGGACGCATGGCTACGGTAAGAAAGGGCCGAA
-CACAATAATCAAGCCCAACTATCTATTGAATCCAGGATTGCGGCAACGATGGATAGCTAG
-GGTAACTCGGGTAGCCTTGTCGTGTACGGAGATGCTCTGCAGAAAAACCAGTTGAGCCCT
-AAAGCCACCTTCCGGAAAGGCACTCTGCCAACTACTGGGCACTCAGGGCAGTGATTGCCT
-CACCGGGTTCGGGCAAGCAGGGTGGTAATCCCAGTACGTTTTTTTTTTCCACCCACCCGT
-CCAGGGGCATCTAGCTAGAATACTGAGCTCCTTTCGATTCCCTTCGACTCCTCCTCGGGC
-TCTCGACAGGATCCATGCCGACGTCATTCTCTATAAAAAGCCTACAAGGACGACGTTTGG
-ACCTCAGACTTCACGAACATGTGCCACCGCGATCCCACTGCTCATTGTCCAGGTACTAGA
-CTGCGGGCTAGTAATGAGGCGGGTTCCTCAAAGTATAAGCGCCTAATGCTCCCAGTTTGA
-ACATAGTCCTGCTGATTTCTTATTGCTTAGACACAGACACTTCACCTTGTGCGAGAGTTA
-AGGGCATGCTCCGGCTCAAGTCTTGAGCAAGTCATGTCAGTGCTAGTACTTTAACAAGAT
-TAAATGAATCAGAGATAGCAAATCTGTGCATGAGTTACCAGGAACTCGAACCCGGCTAAC
-TACACAGTGAGGAAAGTGAGAAGAGGGTCGAAAAGCTTGCTGGTCTCGATCATGGTTGTG
-ACGATAGCACGTCCGAACCGCCGGCCGAATGAGCGCGTAGGTGAACGATATCATGGCCCG
-ACGCCCCGTAGAGCTGGACTGGGGGCCAATGCCGAACAAGGGTATAACAAAAAAAAACCC
-CCTTGGAGTAACTGAAAGTCTCACCCGCGCAGCGGATACCCTTGGTGCACACTCACTTCC
-GCTGGGGGCTTACGTTTCGTGAACAGAGTAGGGTAGGCTCTGATGGGGCTGGACTCCTTC
-GACGTGTCTATTTGAGAGGTTCCGATCTTTTGATGCCCAGAAGCACCAAAAAAGCCAGAG
-CAATCCCCATCTTGCGGGTTGTATTGCGCTAGAGCCACCACACGCAAAACGAGCCTGGTT
-TCGTACTGTGGTGGAGGCTGACTGCCTAGCCTGTTGGTTACTCGGCCTCAACAAGCGATC
-CGGATGTTGATATTTCTCACCCGCCGCGGTCATTTCGAACCTGATTCTTCTCTCTCCGAT
-TGGACTTTACAGGCCACCCTCACCCTCACGTGAGATAAATATGCCTGAACAATTCGTAAC
-AACAGTTATTGCTCACATATGACTACGTGTTACATCTGGAGTGCCCGTAGTGATTGGCGA
-ATCGCAGCGTCAATTAATTC
diff --git a/FALCON-examples/run/synth0/data/synth5k/README b/FALCON-examples/run/synth0/data/synth5k/README
new file mode 100644
index 0000000..564bd23
--- /dev/null
+++ b/FALCON-examples/run/synth0/data/synth5k/README
@@ -0,0 +1,8 @@
+synth5k.xml is generated from subreads.fasta using fasta2bam, which uses
+some old lamdbda bam as a template. subreads.fasta is circularly sampled as error-free reads
+from ref.fasta, which is a 5000-base random genome.
+
+subreads.dexta is from thegenemyers/DEXTRACTOR on subreads.fasta, so subreads.fasta can be recovered
+using undexta.
+
+fasta2bam adds tags for both Quiver and Arrow, so it should work with either.
diff --git a/FALCON-examples/run/synth0/data/ref.fasta b/FALCON-examples/run/synth0/data/synth5k/ref.fasta
similarity index 100%
rename from FALCON-examples/run/synth0/data/ref.fasta
rename to FALCON-examples/run/synth0/data/synth5k/ref.fasta
diff --git a/FALCON-examples/run/synth0/data/synth5k/subreads.dexta b/FALCON-examples/run/synth0/data/synth5k/subreads.dexta
new file mode 100644
index 0000000..79eaf2b
Binary files /dev/null and b/FALCON-examples/run/synth0/data/synth5k/subreads.dexta differ
diff --git a/FALCON-examples/run/synth0/data/synth5k/synth5k.bam b/FALCON-examples/run/synth0/data/synth5k/synth5k.bam
new file mode 100644
index 0000000..aebb6ad
Binary files /dev/null and b/FALCON-examples/run/synth0/data/synth5k/synth5k.bam differ
diff --git a/FALCON-examples/run/synth0/data/synth5k/synth5k.bam.bai b/FALCON-examples/run/synth0/data/synth5k/synth5k.bam.bai
new file mode 100644
index 0000000..740d444
Binary files /dev/null and b/FALCON-examples/run/synth0/data/synth5k/synth5k.bam.bai differ
diff --git a/FALCON-examples/run/synth0/data/synth5k/synth5k.bam.pbi b/FALCON-examples/run/synth0/data/synth5k/synth5k.bam.pbi
new file mode 100644
index 0000000..e4923f6
Binary files /dev/null and b/FALCON-examples/run/synth0/data/synth5k/synth5k.bam.pbi differ
diff --git a/FALCON-examples/run/synth0/data/synth5k/synth5k.xml b/FALCON-examples/run/synth0/data/synth5k/synth5k.xml
new file mode 100644
index 0000000..bd28ddd
--- /dev/null
+++ b/FALCON-examples/run/synth0/data/synth5k/synth5k.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<SubreadSet CreatedAt="2016-05-10T09:48:10" MetaType="PacBio.DataSet.SubreadSet" Name="synth5k" Tags="" TimeStampedName="pacbio_dataset_subreadset-160510_164810243" UniqueId="f06315b8-8d1c-7d09-5e3a-49deb9777154" Version="3.0.1" xmlns="http://pacificbiosciences.com/PacBioDatasets.xsd" xmlns:pbbase="http://pacificbiosciences.com/PacBioBaseDataModel.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://pacificbiosciences.com/PacBioDataModel.xsd">
+ <pbbase:ExternalResources>
+ <pbbase:ExternalResource MetaType="PacBio.SubreadFile.SubreadBamFile" ResourceId="synth5k.bam" TimeStampedName="pacbio_subreadfile_subreadbamfile-160510_164810239" UniqueId="7ba37714-00cc-480e-8279-3cc2728e1707">
+ <pbbase:FileIndices>
+ <pbbase:FileIndex MetaType="PacBio.Index.PacBioIndex" ResourceId="synth5k.bam.pbi" TimeStampedName="pacbio_index_pacbioindex-160510_164810240" UniqueId="c64f370b-3ed0-468f-81d1-fc7bfc18bde7"/>
+ <pbbase:FileIndex MetaType="PacBio.Index.BamIndex" ResourceId="synth5k.bam.bai" TimeStampedName="pacbio_index_bamindex-160510_164810240" UniqueId="bfd943c0-0f6f-4d71-af30-82594368e1f6"/>
+ </pbbase:FileIndices>
+ </pbbase:ExternalResource>
+ </pbbase:ExternalResources>
+ <DataSetMetadata>
+ <TotalLength>100000</TotalLength>
+ <NumRecords>50</NumRecords>
+ </DataSetMetadata>
+</SubreadSet>
diff --git a/FALCON-examples/run/synth0/fc_run.cfg b/FALCON-examples/run/synth0/fc_run.cfg
index 91c1b01..0740760 100644
--- a/FALCON-examples/run/synth0/fc_run.cfg
+++ b/FALCON-examples/run/synth0/fc_run.cfg
@@ -20,13 +20,13 @@ seed_coverage = 20
length_cutoff_pr = 1
-jobqueue = production
-sge_option_da = -pe smp 8 -q %(jobqueue)s
-sge_option_la = -pe smp 2 -q %(jobqueue)s
-sge_option_pda = -pe smp 8 -q %(jobqueue)s
-sge_option_pla = -pe smp 2 -q %(jobqueue)s
-sge_option_fc = -pe smp 24 -q %(jobqueue)s
-sge_option_cns = -pe smp 8 -q %(jobqueue)s
+job_queue = production
+sge_option_da = -pe smp 8 -q %(job_queue)s
+sge_option_la = -pe smp 2 -q %(job_queue)s
+sge_option_pda = -pe smp 8 -q %(job_queue)s
+sge_option_pla = -pe smp 2 -q %(job_queue)s
+sge_option_fc = -pe smp 24 -q %(job_queue)s
+sge_option_cns = -pe smp 8 -q %(job_queue)s
pa_concurrent_jobs = 32
cns_concurrent_jobs = 32
diff --git a/FALCON-examples/run/synth0/input.fofn b/FALCON-examples/run/synth0/input.fofn
index 1a8d298..6bde2ca 100644
--- a/FALCON-examples/run/synth0/input.fofn
+++ b/FALCON-examples/run/synth0/input.fofn
@@ -1 +1 @@
-data/synth0.fasta
+data/synth5k/subreads.dexta
diff --git a/FALCON-make/makefile b/FALCON-make/makefile
index 708d052..f6c0d95 100644
--- a/FALCON-make/makefile
+++ b/FALCON-make/makefile
@@ -20,7 +20,7 @@ all: checklist
checklist:
@if [ -z "$${FALCON_PREFIX}" ]; then echo 'Error: FALCON_PREFIX is not set'; exit 1; fi
@if [ ! -e "$${FALCON_PREFIX}/bin" ] ; then echo 'Error: directory FALCON_PREFIX/bin (${FALCON_PREFIX}/bin) does not exist'; exit 1; fi
-install: install-DAZZ_DB install-DALIGNER install-DAMASKER install-pypeFLOW install-FALCON install-git-sym
+install: install-DAZZ_DB install-DALIGNER install-DAMASKER install-DEXTRACTOR install-pypeFLOW install-FALCON install-git-sym
install-DAZZ_DB:
${MAKE} -C ${FALCON_WORKSPACE}/DAZZ_DB all
PREFIX=${FALCON_PREFIX} ${MAKE} -C ${FALCON_WORKSPACE}/DAZZ_DB ${FALCON_INSTALL_RULE}
@@ -30,6 +30,9 @@ install-DALIGNER: install-DAZZ_DB
install-DAMASKER:
${MAKE} -C ${FALCON_WORKSPACE}/DAMASKER all
PREFIX=${FALCON_PREFIX} ${MAKE} -C ${FALCON_WORKSPACE}/DAMASKER ${FALCON_INSTALL_RULE}
+install-DEXTRACTOR:
+ ${MAKE} -C ${FALCON_WORKSPACE}/DEXTRACTOR all
+ PREFIX=${FALCON_PREFIX} ${MAKE} -C ${FALCON_WORKSPACE}/DEXTRACTOR ${FALCON_INSTALL_RULE}
install-pypeFLOW:
cd ${FALCON_WORKSPACE}/pypeFLOW; pip uninstall -v .; pip install -v ${FALCON_PIP_USER} ${FALCON_PIP_EDIT} .
install-FALCON: install-pypeFLOW
diff --git a/FALCON/falcon_kit/bash.py b/FALCON/falcon_kit/bash.py
index c62a113..fabe142 100644
--- a/FALCON/falcon_kit/bash.py
+++ b/FALCON/falcon_kit/bash.py
@@ -3,11 +3,13 @@
from . import functional
import functools
import getpass
+import logging
import md5
import os
import tempfile
import traceback
+LOG=logging.getLogger(__name__)
BASH='/bin/bash'
BUG_avoid_Text_file_busy=True
# http://stackoverflow.com/questions/1384398/usr-bin-perl-bad-interpreter-text-file-busy/
@@ -46,6 +48,12 @@ def write_sub_script(ofs, script):
exe = ''
return exe
+def write_script(script, script_fn, job_done_fn=None):
+ if job_done_fn:
+ script += '\ntouch {}'.format(job_done_fn)
+ with open(script_fn, 'w') as ofs:
+ exe = write_sub_script(ofs, script)
+
def write_script_and_wrapper_top(script, wrapper_fn, job_done):
"""
Write script to a filename based on wrapper_fn, in same directory.
@@ -54,7 +62,7 @@ def write_script_and_wrapper_top(script, wrapper_fn, job_done):
'job_done' should be either abspath or relative to dir of wrapper_fn.
"""
job_exit = job_done + '.exit'
- wdir = os.path.dirname(wrapper_fn)
+ wdir = os.path.abspath(os.path.dirname(wrapper_fn))
#mkdir(wdir) # To avoid races, callers must do this.
root, ext = os.path.splitext(os.path.basename(wrapper_fn))
@@ -171,6 +179,11 @@ def script_build_rdb(config, input_fofn_fn, run_jobs_bfn):
params['seed_coverage'], params['genome_size'], 'raw_reads')
else:
bash_cutoff = '{}'.format(length_cutoff)
+ try:
+ cat_fasta = functional.choose_cat_fasta(open(input_fofn_fn).read())
+ except Exception:
+ LOG.exception('Using "cat" by default.')
+ cat_fasta = 'cat '
DBdust = 'DBdust {} raw_reads'.format(params.get('pa_DBdust_option', ''))
mdust = '-mdust'
if not params.get('dust'):
@@ -178,8 +191,9 @@ def script_build_rdb(config, input_fofn_fn, run_jobs_bfn):
mdust = ''
params.update(locals())
script = """\
+set -o pipefail
#fc_fasta2fasta < {input_fofn_fn} >| fc.fofn
-while read fn; do fasta2DB -v raw_reads $fn; done < {input_fofn_fn}
+while read fn; do {cat_fasta} $fn | fasta2DB -v raw_reads -i${{fn##*/}}; done < {input_fofn_fn}
#cat fc.fofn | xargs rm -f
{DBsplit}
{DBdust}
@@ -209,15 +223,16 @@ HPC.daligner {ovlp_HPCdaligner_option} -H{length_cutoff_pr} preads {last_block}-
""".format(**params)
return script
-def script_run_DB2Falcon(config):
+def script_run_DB2Falcon(config, preads4falcon_fn, preads_db):
"""Run in pread_dir.
"""
params = dict(config)
params.update(locals())
script = """\
# Given preads.db,
-# write preads4falcon.fasta, in 1-preads_ovl:
-time DB2Falcon -U preads
+# write preads4falcon.fasta (implicitly) in CWD.
+time DB2Falcon -U {preads_db}
+[ -f preads4falcon.fasta ] || exit 1
""".format(**params)
return script
@@ -258,17 +273,17 @@ def scripts_merge(config, db_prefix, run_jobs_fn):
"""
with open(run_jobs_fn) as f:
mjob_data = functional.get_mjob_data(f)
+ #las_fns = functional.get_las_filenames(mjob_data, db_prefix) # ok, but tricky
for p_id in mjob_data:
bash_lines = mjob_data[p_id]
script = []
for line in bash_lines:
script.append(line.replace('&&', ';'))
- #script.append("mkdir -p ../las_files")
- #script.append("ln -sf ../m_%05d/%s.%s.las ../las_files" % (p_id, db_prefix, p_id))
- #script.append("ln -sf ./m_%05d/%s.%s.las .. " % (p_id, db_prefix, p_id))
- #las_fn = '%s.%s.las' % (db_prefix, p_id))
- yield p_id, '\n'.join(script + [''])
+ #las_fn = las_fns[p_id]
+ # We already know the output .las filename by convention.
+ las_fn = '%s.%s.las' % (db_prefix, p_id)
+ yield p_id, '\n'.join(script + ['']), las_fn
def script_run_consensus(config, db_fn, las_fn, out_file_bfn):
"""config: falcon_sense_option, length_cutoff
@@ -285,6 +300,8 @@ def script_run_consensus(config, db_fn, las_fn, out_file_bfn):
params.update(locals())
if config["falcon_sense_skip_contained"]:
run_consensus = """LA4Falcon -H$CUTOFF -fso {db_fn} {las_fn} | """
+ elif config["falcon_sense_greedy"]:
+ run_consensus = """LA4Falcon -H$CUTOFF -fog {db_fn} {las_fn} | """
else:
run_consensus = """LA4Falcon -H$CUTOFF -fo {db_fn} {las_fn} | """
run_consensus += """fc_consensus {falcon_sense_option} >| {out_file_bfn}"""
diff --git a/FALCON/falcon_kit/functional.py b/FALCON/falcon_kit/functional.py
index 201fdcf..a799b4d 100644
--- a/FALCON/falcon_kit/functional.py
+++ b/FALCON/falcon_kit/functional.py
@@ -9,6 +9,8 @@ def _verify_pairs(pairs1, pairs2):
if pairs1 != pairs2:
print('pair2dali:', pairs1)
print('pair2sort:', pairs2)
+ print('dali-sort:', set(pairs1) - set(pairs2))
+ print('sort-dali:', set(pairs2) - set(pairs1))
print('pair2dali:', len(pairs1))
print('pair2sort:', len(pairs2))
assert pairs1 == pairs2
@@ -86,13 +88,14 @@ def get_daligner_job_descriptions(run_jobs_stream, db_prefix, single=False):
pair2dali = {}
for line in lines_dali:
blocks = blocks_dali(line)
- for block in blocks:
- pair = (blocks[0], block)
+ block0 = blocks[0]
+ for block in blocks[1:]:
+ pair = (block0, block)
pair2dali[pair] = line
- if block != blocks[0]:
+ if block != block0:
# Then we have a reverse comparison too.
# https://dazzlerblog.wordpress.com/2014/07/10/dalign-fast-and-sensitive-detection-of-all-pairwise-local-alignments/
- rpair = (block, blocks[0])
+ rpair = (block, block0)
pair2dali[rpair] = line
pair2sort = {}
for line in lines_sort:
@@ -137,6 +140,45 @@ def first_block_las(line):
raise Exception('Pattern {!r} does not match line {!r}: {}'.format(
re_first_block_las.pattern, line, e))
+def get_las_filenames(mjob_data, db_prefix):
+ """Given result of get_mjob_data(),
+ return {int: final_las_filename}
+ """
+ # This is our best guess.
+ # (We might not even need this, since we know the output filename of each merge-task by convention.)
+ # Eventually, we need to re-write HPC.daligner.
+ result = {}
+ re_LAmerge = re.compile(r'^LAmerge\s+(?:\-\S+\s+)(\S+)')
+ re_LAcheck = re.compile(r'^LAcheck\s+(?:\-\S+\s+)\S+\s+(\S+)')
+ for p_id, bash_lines in mjob_data.iteritems():
+ if not bash_lines:
+ # The daligner+LAsort+LAmerge job produced the final .las
+ # for this block. We will symlink it later.
+ las_fn = '{}.{}.las'.format(db_prefix, p_id)
+ result[p_id] = las_fn
+ continue
+ # Find the last line which can tell us the final .las name.
+ i = len(bash_lines) - 1
+ while bash_lines[i].split()[0] not in ('LAmerge', 'LAcheck'):
+ i -= 1
+ # Now we will raise an exception if there were none. But in theory, there
+ # must be at least an LAsort.
+ first_word = bash_lines[i].split()[0]
+ if first_word == 'LAmerge':
+ regex = re_LAmerge
+ elif first_word == 'LAcheck':
+ regex = re_LAcheck
+ else:
+ raise Exception('first_word={!r} in line#{} of {!r}'.format(
+ first_word, i, bash_lines))
+ mo = regex.search(bash_lines[i])
+ if not mo:
+ raise Exception('Regex {!r} failed on {!r}'.format(
+ re_las_name.pattern, bash_lines[i]))
+ las_fn = mo.group(1) + '.las'
+ result[p_id] = las_fn
+ return result
+
def get_mjob_data(run_jobs_stream):
"""Given output of HPC.daligner,
return {int: [bash-lines]}
@@ -268,17 +310,27 @@ def parsed_readlengths_from_dbdump_output(output):
def mapped_readlengths_from_dbdump_output(output):
"""Given output text from the DBump command,
return dict of (id => read-length).
+ There will be alternate lines like these:
+ R #
+ L # # #
+ https://dazzlerblog.wordpress.com/command-guides/dazz_db-command-guide/
"""
lengths = dict()
+ re_rid = re.compile('^R\s+(\d+)$')
re_length = re.compile('^L\s+(\d+)\s+(\d+)\s+(\d+)$')
for line in output.splitlines():
+ mo = re_rid.search(line)
+ if mo:
+ idx = int(mo.group(1))
+ continue
mo = re_length.search(line)
if mo:
- idx, beg, end = mo.group(1, 2, 3)
- idx = int(idx)
+ well, beg, end = mo.group(1, 2, 3)
+ well = int(idx)
beg = int(beg)
end = int(end)
lengths[idx] = (end - beg)
+ continue
return lengths
def average_difference(dictA, dictB):
@@ -306,3 +358,24 @@ def calc_metric_truncation(dbdump_output, length_pairs_output):
orig_lengths = mapped_readlengths_from_dbdump_output(dbdump_output)
avg = -average_difference(pread_lengths, orig_lengths)
return avg
+
+def choose_cat_fasta(fofn):
+ """Given the contents of a fasta FOFN,
+ return a command to write the contents of a fasta to stdout,
+ keeping the original file.
+ Raise Exception on error.
+
+ >>> choose_cat_fasta('abc.gz')
+ 'zcat '
+ >>> choose_cat_fasta('abc.dexta')
+ 'undexta -vkU -w60 -i < '
+ >>> choose_cat_fasta('abc')
+ 'cat '
+ """
+ first_line = fofn.splitlines()[0]
+ if first_line.endswith('.gz'):
+ return 'zcat '
+ elif first_line.endswith('.dexta'):
+ return 'undexta -vkU -w60 -i < '
+ else:
+ return 'cat '
diff --git a/FALCON/falcon_kit/mains/ovlp_to_graph.py b/FALCON/falcon_kit/mains/ovlp_to_graph.py
index 58eb410..40dcd12 100644
--- a/FALCON/falcon_kit/mains/ovlp_to_graph.py
+++ b/FALCON/falcon_kit/mains/ovlp_to_graph.py
@@ -173,7 +173,7 @@ class StringGraph(object):
removed_edges = set()
for v in self.nodes:
- if len(self.nodes[v].out_edges) > 1:
+ if len([e for e in self.nodes[v].out_edges if self.e_reduce[ (e.in_node.name, e.out_node.name) ] != True]) > 1:
for out_edge in self.nodes[v].out_edges:
w = out_edge.out_node.name
@@ -184,7 +184,7 @@ class StringGraph(object):
self.e_reduce[(v2, w2)] = True
removed_edges.add( (v2, w2) )
- if len(self.nodes[v].in_edges) > 1:
+ if len([e for e in self.nodes[v].in_edges if self.e_reduce[ (e.in_node.name, e.out_node.name) ] != True]) > 1:
for in_edge in self.nodes[v].in_edges:
w = in_edge.in_node.name
if len(self.nodes[w].in_edges) == 0 and self.e_reduce[ (w, v) ] != True:
@@ -835,6 +835,7 @@ def generate_string_graph(args):
else:
chimer_edges = set() #empty set
+ spur_edges = sg.mark_spur_edge()
removed_edges = set()
if args.lfc == True:
@@ -842,7 +843,7 @@ def generate_string_graph(args):
else:
removed_edges = sg.mark_best_overlap() # mark those edges that are best overlap edges
- spur_edges = sg.mark_spur_edge()
+ spur_edges.update( sg.mark_spur_edge() )
if DEBUG_LOG_LEVEL > 1:
print sum( [1 for c in sg.e_reduce.values() if c == False] )
@@ -1197,6 +1198,32 @@ def identify_spurs(ug, u_edge_data):
break
return ug2
+def remove_dup_simple_path(ug, u_edge_data):
+ # identify simple dup path
+ # if there are many multiple simple path of length connect s and t, e.g. s->v1->t, and s->v2->t, we will only keep one
+ # Side-effect: Modifies u_edge_data
+ ug2 = ug.copy()
+ simple_edges = set()
+ dup_edges = {}
+ for s, t, v in u_edge_data:
+ length, score, edges, type_ = u_edge_data[ (s, t, v) ]
+ if len(edges) > 3:
+ continue
+ if type_ == "simple":
+ if (s, t) in simple_edges:
+ dup_edges[ (s, t) ].append( v )
+ else:
+ simple_edges.add( (s, t) )
+ dup_edges[ (s, t) ] = [v]
+ for s, t in dup_edges:
+ vl = dup_edges[ (s, t) ]
+ vl.sort()
+ for v in vl[1:]:
+ ug2.remove_edge( s, t, key= v)
+ length, score, edges, type_ = u_edge_data[ (s, t, v) ]
+ u_edge_data[ (s, t, v) ] = length, score, edges, "simple_dup"
+ return ug2
+
def construct_c_path_from_utgs(ug, u_edge_data, sg):
# Side-effects: None, I think.
@@ -1357,6 +1384,7 @@ def ovlp_to_graph(args):
print >>f, s, v, t, type_, length, score, path_or_edges
ug2 = identify_spurs(ug, u_edge_data)
+ ug2 = remove_dup_simple_path(ug2, u_edge_data)
#phase 2, finding all "consistent" compound paths
compound_paths = construct_compound_paths(ug2, u_edge_data)
@@ -1509,3 +1537,4 @@ def main(argv=sys.argv):
args = parser.parse_args(argv[1:])
ovlp_to_graph(args)
+
diff --git a/FALCON/falcon_kit/mains/run0.py b/FALCON/falcon_kit/mains/run0.py
deleted file mode 100644
index fa4ca0e..0000000
--- a/FALCON/falcon_kit/mains/run0.py
+++ /dev/null
@@ -1,683 +0,0 @@
-from .. import run_support as support
-from .. import bash
-from pypeflow.data import PypeLocalFile, makePypeLocalFile, fn
-from pypeflow.task import PypeTask, PypeThreadTaskBase
-from pypeflow.controller import PypeThreadWorkflow
-from falcon_kit.FastaReader import FastaReader
-from falcon_kit import stats_preassembly
-from ..util.system import only_these_symlinks
-import argparse
-import collections
-import glob
-import json
-import os
-import re
-import sys
-import time
-
-
-fc_run_logger = None
-
-def remove(*fns):
- for fn in fns:
- if os.path.exists(fn):
- os.remove(fn)
- assert not os.path.exists(fn)
-
-def system(call, check=False):
- fc_run_logger.debug('$(%s)' %repr(call))
- rc = os.system(call)
- msg = "Call %r returned %d." % (call, rc)
- if rc:
- fc_run_logger.warning(msg)
- if check:
- raise Exception(msg)
- else:
- fc_run_logger.debug(msg)
- return rc
-
-def _qsub_script(job_data, specific):
- script_fn = job_data["script_fn"]
- job_name = job_data["job_name"]
- cwd = job_data["cwd"]
- sge_option = job_data["sge_option"]
- with open(script_fn, 'r') as original: data = original.read()
- with open(script_fn, 'w') as modified: modified.write("#!/bin/bash" + "\n" + data)
- sge_cmd="qsub -N {job_name} {sge_option} -o {cwd}/sge_log {specific}\
- -S /bin/bash {script}".format(job_name=job_name,
- cwd=os.getcwd(),
- specific=specific,
- sge_option=sge_option,
- script=script_fn)
- system(sge_cmd, check=True)
-
-def _run_script_sge(job_data):
- specific = '-j y'
- _qsub_script(job_data, specific)
-
-def _run_script_torque(job_data):
- # See https://github.com/PacificBiosciences/FALCON/pull/227
- specific = '-j oe'
- _qsub_script(job_data, specific)
-
-def _run_script_slurm(job_data):
- script_fn = job_data["script_fn"]
- job_name = job_data["job_name"]
- cwd = job_data["cwd"]
- sge_option = job_data["sge_option"]
- with open(script_fn, 'r') as original: data = original.read()
- with open(script_fn, 'w') as modified: modified.write("#!/bin/sh" + "\n" + data)
- sge_cmd="sbatch -J {job_name} {sge_option} {script}".format(job_name=job_name, cwd=os.getcwd(),sge_option=sge_option, script=script_fn)
- system(sge_cmd, check=True)
-
-def _run_script_local(job_data):
- script_fn = job_data["script_fn"]
- job_name = job_data["job_name"]
- log_fn = '{0}.log'.format(script_fn)
- cmd = "bash {0} 1> {1} 2>&1".format(script_fn, log_fn)
- try:
- system(cmd, check=True)
- except Exception:
- out = open(log_fn).read()
- fc_run_logger.exception('Contents of %r:\n%s' %(log_fn, out))
- raise
-#add support for lsf, attention parameters (sge_option) for cfg has to changed i.e. -N 8 -q queue
-def _run_script_lsf(job_data):
- script_fn = job_data["script_fn"]
- job_name = job_data["job_name"]
- cwd = job_data["cwd"]
- sge_option = job_data["sge_option"]
- sge_cmd="bsub -J {job_name} {sge_option} -o {cwd}/sge_log \" sh {script}\"".format(job_name=job_name, cwd=os.getcwd(),sge_option=sge_option, script=script_fn)
-
- system(sge_cmd, check=True)
-_run_scripts = {
- 'SGE': _run_script_sge,
- 'TORQUE': _run_script_torque,
- 'SLURM': _run_script_slurm,
- 'LSF': _run_script_lsf,
- 'LOCAL': _run_script_local,
-}
-
-def run_script(job_data, job_type):
- """For now, we actually modify the script before running it.
- This assume a simple bash script.
- We will have a better solution eventually.
- """
- try:
- _run_script = _run_scripts[job_type.upper()]
- except LookupError as e:
- msg = 'Unknown job_type=%s' %repr(job_type)
- fc_run_logger.exception(msg)
- raise
- job_name = job_data["job_name"]
- script_fn = job_data["script_fn"]
- support.update_env_in_script(script_fn,
- ['PATH', 'PYTHONPATH', 'LD_LIBRARY_PATH'])
- fc_run_logger.info('(%s) %r' %(job_type, script_fn))
- fc_run_logger.debug('%s (job %r)' %(_run_script.__name__, job_name))
- rc = _run_script(job_data)
- # Someday, we might trap exceptions here, as a failure would be caught later anyway.
-
-def wait_for_file(filename, task, job_name = ""):
- """We could be in the thread or sub-process which spawned a qsub job,
- so we must check for the shutdown_event.
- """
- wait_time = .2
- while 1:
- time.sleep(wait_time)
- wait_time = 10 if wait_time > 10 else wait_time + .2
- # We prefer all jobs to rely on `*done.exit`, but not all do yet. So we check that 1st.
- exit_fn = filename + '.exit'
- if os.path.exists(exit_fn):
- fc_run_logger.info( "%r found." % (exit_fn) )
- fc_run_logger.debug( " job: %r exited." % (job_name) )
- if not os.path.exists(filename):
- fc_run_logger.warning( "%r is missing. job: %r failed!" % (filename, job_name) )
- break
- if os.path.exists(filename):
- os.listdir(os.path.dirname(exit_fn)) # sync NFS
- if not os.path.exists(exit_fn):
- # (rechecked exit_fn to avoid race condition)
- fc_run_logger.info( "%r not found, but job is done." % (exit_fn) )
- fc_run_logger.debug( " job: %r exited." % (job_name) )
- break
- if task.shutdown_event is not None and task.shutdown_event.is_set():
- fc_run_logger.warning( "shutdown_event received (Keyboard Interrupt maybe?), %r not finished."
- % (job_name) )
- if support.job_type == "SGE":
- fc_run_logger.info( "deleting the job by `qdel` now..." )
- system("qdel %s" % job_name) # Failure is ok.
- if support.job_type == "SLURM":
- fc_run_logger.info( "Deleting the job by 'scancel' now...")
- system("scancel -n %s" % job_name)
- if support.job_type == "LSF":
- fc_run_logger.info( "Deleting the job by 'bkill' now...")
- system("bkill -J %s" % job_name) # Failure is ok.
- break
-
-def run_script_and_wait(URL, script_fn, job_done, task,
- job_type, sge_option):
- job_data = support.make_job_data(URL, script_fn)
- job_data['sge_option'] = sge_option
- run_script(job_data, job_type)
- wait_for_file(job_done, task, job_name=job_data['job_name'])
-
-def run_script_and_wait_and_rm_exit(URL, script_fn, job_done, task,
- job_type, sge_option):
- try:
- run_script_and_wait(URL, script_fn, job_done, task,
- job_type, sge_option)
- finally:
- # By convention, job_exit is based on job_done.
- # See bash.write_script_and_wrapper().
- job_exit = job_done + '.exit'
- os.listdir(os.path.dirname(job_exit))
- if os.path.exists(job_exit):
- try:
- # to allow a restart later, if not done
- os.unlink(job_exit)
- except:
- pass
- else:
- fc_run_logger.warn('In %r, job-exit-file %r does not exist.' %(
- os.getcwd(), job_exit))
-
-def task_make_fofn_abs_raw(self):
- return support.make_fofn_abs(self.i_fofn.path, self.o_fofn.path)
-
-def task_make_fofn_abs_preads(self):
- return support.make_fofn_abs(self.i_fofn.path, self.o_fofn.path)
-
-def task_build_rdb(self):
- input_fofn_fn = fn(self.input_fofn)
- job_done = fn(self.rdb_build_done)
- db = fn(self.raw_reads_db)
- run_jobs = fn(self.run_jobs)
- remove(job_done, db, run_jobs)
- work_dir = self.parameters["work_dir"]
- config = self.parameters["config"]
- sge_option_da = config["sge_option_da"]
-
- script_fn = os.path.join( work_dir, "prepare_rdb.sh" )
- args = {
- 'input_fofn_fn': input_fofn_fn,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- 'run_jobs_fn': run_jobs,
- }
- support.build_rdb(**args)
- run_script_and_wait_and_rm_exit(self.URL, script_fn, job_done, self,
- job_type=config['job_type'], sge_option=sge_option_da)
-
-def task_build_pdb(self): #essential the same as build_rdb() but the subtle differences are tricky to consolidate to one function
- input_fofn_fn = fn(self.pread_fofn)
- job_done = fn(self.pdb_build_done)
- db = fn(self.preads_db)
- run_jobs = fn(self.run_jobs)
- remove(job_done, db, run_jobs)
- work_dir = self.parameters["work_dir"]
- config = self.parameters["config"]
-
- script_fn = os.path.join( work_dir, "prepare_pdb.sh" )
- args = {
- 'input_fofn_fn': input_fofn_fn,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- 'run_jobs_fn': run_jobs,
- }
- support.build_pdb(**args)
- run_script_and_wait_and_rm_exit(self.URL, script_fn, job_done, self,
- job_type=config['job_type'], sge_option=config['sge_option_pda'])
-
-def task_report_pre_assembly(self):
- # TODO(CD): Bashify this, in case it is slow. (Done in run1, and we do not really care here.)
- i_raw_reads_db_fn = fn(self.raw_reads_db)
- i_preads_fofn_fn = fn(self.preads_fofn)
- i_length_cutoff_fn = fn(self.length_cutoff_fn)
- o_json_fn = fn(self.pre_assembly_report)
- cfg = self.parameters
- genome_length = int(cfg.get('genome_size', 0)) # different name in falcon
- length_cutoff = int(cfg['length_cutoff'])
- length_cutoff = support.get_length_cutoff(length_cutoff, i_length_cutoff_fn)
- kwds = {
- 'i_raw_reads_db_fn': i_raw_reads_db_fn,
- 'i_preads_fofn_fn': i_preads_fofn_fn,
- 'genome_length': genome_length,
- 'length_cutoff': length_cutoff,
- }
- fc_run_logger.info('Report inputs: {}'.format(repr(kwds)))
- report_dict = stats_preassembly.calc_dict(**kwds)
- content = json.dumps(report_dict, sort_keys=True, indent=4, separators=(',', ': '))
- fc_run_logger.info('Report stats:\n{}'.format(content))
- open(o_json_fn, 'w').write(content)
-
-def task_run_db2falcon(self):
- wd = self.parameters["wd"]
- #self.p_merge_done
- job_done = fn(self.db2falcon_done)
- config = self.parameters["config"]
- script_dir = os.path.join(wd)
- script_fn = os.path.join(script_dir ,"run_db2falcon.sh")
- args = {
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- support.run_db2falcon(**args)
- run_script_and_wait_and_rm_exit(self.URL, script_fn, job_done, self,
- job_type=config['job_type'], sge_option=config['sge_option_fc'])
-
-def task_run_falcon_asm(self):
- wd = self.parameters["wd"]
- #self.db2falcon_done
- db_file = fn(self.db_file)
- job_done = fn(self.falcon_asm_done)
- config = self.parameters["config"]
- pread_dir = self.parameters["pread_dir"]
- script_dir = os.path.join( wd )
- script_fn = os.path.join( script_dir ,"run_falcon_asm.sh" )
- # Generate las.fofn in run-dir.
- system('cd {}; find {}/m_*/ -name "preads.*.las" >| las.fofn'.format(wd, pread_dir))
- las_fofn_fn = 'las.fofn'
- args = {
- 'las_fofn_fn': las_fofn_fn,
- 'preads4falcon_fasta_fn': os.path.join(pread_dir, 'preads4falcon.fasta'),
- 'db_file_fn': db_file,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- support.run_falcon_asm(**args)
- run_script_and_wait_and_rm_exit(self.URL, script_fn, job_done, self,
- job_type=config['job_type'], sge_option=config['sge_option_fc'])
-
-def task_run_daligner(self):
- job_done = fn(self.job_done)
- daligner_script = self.parameters["daligner_script"]
- job_uid = self.parameters["job_uid"]
- cwd = self.parameters["cwd"]
- mkdir(cwd)
- db_prefix = self.parameters["db_prefix"]
- config = self.parameters["config"]
- sge_option_da = config["sge_option_da"]
- script_dir = os.path.join(cwd)
- script_fn = os.path.join(script_dir , "rj_%s.sh" % (job_uid))
- args = {
- 'daligner_script': daligner_script,
- 'db_prefix': db_prefix,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- support.run_daligner(**args)
- run_script_and_wait_and_rm_exit(self.URL, script_fn, job_done, self,
- job_type=config['job_type'], sge_option=config['sge_option_da'])
-
-def task_run_las_merge(self):
- script = self.parameters["merge_script"]
- job_id = self.parameters["job_id"]
- cwd = self.parameters["cwd"]
- job_done = fn(self.job_done)
- config = self.parameters["config"]
- sge_option_la = config["sge_option_la"]
-
- script_dir = os.path.join( cwd )
- script_fn = os.path.join( script_dir , "rp_%05d.sh" % (job_id))
- args = {
- 'script': script,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- support.run_las_merge(**args)
- run_script_and_wait_and_rm_exit(self.URL, script_fn, job_done, self,
- job_type=config['job_type'], sge_option=config['sge_option_la'])
-
-def task_run_consensus(self):
- out_file_fn = fn(self.out_file)
- job_id = self.parameters["job_id"]
- cwd = self.parameters["cwd"]
- config = self.parameters["config"]
- prefix = self.parameters["prefix"]
- script_dir = os.path.join( cwd )
- job_done = os.path.join( cwd, "c_%05d_done" % job_id )
- script_fn = os.path.join( script_dir , "c_%05d.sh" % (job_id))
- db_fn = os.path.abspath('{cwd}/../{prefix}'.format(**locals()))
- las_fn = os.path.abspath('{cwd}/../m_{job_id:05d}/{prefix}.{job_id}.las'.format(**locals()))
- args = {
- 'db_fn': db_fn,
- 'las_fn': las_fn,
- 'out_file_fn': out_file_fn,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- support.run_consensus(**args)
- run_script_and_wait_and_rm_exit(self.URL, script_fn, job_done, self,
- job_type=config['job_type'], sge_option=config['sge_option_cns'])
-
-def mkdir(d):
- if not os.path.isdir(d):
- os.makedirs(d)
-
-def task_daligner_gather(self):
- da_done = fn(self.da_done)
- main_dir = os.path.dirname(da_done)
- out_dict = self.inputDataObjs
- nblock = self.parameters['nblock']
- fc_run_logger.debug('nblock=%d, out_dir:\n%s'%(nblock, out_dict))
-
- # Create m_* dirs.
- for block in xrange(1, nblock+1):
- mdir = os.path.join(main_dir, 'm_%05d' %block) # By convention. pbsmrtpipe works differently.
- mkdir(mdir)
- job_rundirs = [os.path.dirname(fn(dal_done)) for dal_done in out_dict.values()]
-
- # Symlink all daligner *.las.
- links = collections.defaultdict(list)
- for block, las_path in support.daligner_gather_las(job_rundirs):
- mdir = os.path.join(main_dir, 'm_%05d' %block) # By convention. pbsmrtpipe works differently.
- #las_path = os.path.relpath(las_path, mdir)
- links[mdir].append(las_path)
- only_these_symlinks(links)
- system("touch %s" %da_done)
-
-def create_daligner_tasks(run_jobs_fn, wd, db_prefix, rdb_build_done, nblock, config, pread_aln=False):
- tasks = []
- tasks_out = {}
- for job_uid, script in bash.scripts_daligner(run_jobs_fn, db_prefix, rdb_build_done, nblock, pread_aln):
- run_dir = "job_%s" %job_uid
- cwd = os.path.join(wd, run_dir)
- job_done_fn = os.path.abspath(os.path.join(cwd, "job_%s_done" %job_uid))
- job_done = makePypeLocalFile(job_done_fn)
- parameters = {"daligner_script": script,
- "cwd": cwd,
- "job_uid": job_uid,
- "config": config,
- "db_prefix": db_prefix}
- make_daligner_task = PypeTask(inputs = {"rdb_build_done": rdb_build_done},
- outputs = {"job_done": job_done},
- parameters = parameters,
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/d_%s_%s" %(job_uid, db_prefix))
- daligner_task = make_daligner_task(task_run_daligner)
- tasks.append(daligner_task)
- tasks_out[ "ajob_%s" % job_uid ] = job_done
- return tasks, tasks_out
-
-def create_merge_tasks(run_jobs_fn, wd, db_prefix, input_dep, config):
- merge_tasks = []
- merge_out = {}
- p_ids_merge_job_done = [] # for consensus
-
- merge_scripts = bash.scripts_merge(config, db_prefix, run_jobs_fn)
- for p_id, merge_script in merge_scripts:
- job_done = makePypeLocalFile(os.path.abspath("%s/m_%05d/m_%05d_done" % (wd, p_id, p_id)))
- parameters = {"merge_script": merge_script,
- "cwd": os.path.join(wd, "m_%05d" % p_id),
- "job_id": p_id,
- "config": config}
- make_merge_task = PypeTask(inputs = {"input_dep": input_dep},
- outputs = {"job_done": job_done},
- parameters = parameters,
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/m_%05d_%s" % (p_id, db_prefix))
- merge_task = make_merge_task(task_run_las_merge)
- merge_out["mjob_%d" % p_id] = job_done
- merge_tasks.append(merge_task)
- p_ids_merge_job_done.append((p_id, job_done))
- return merge_tasks, merge_out, p_ids_merge_job_done
-
-def create_consensus_tasks(wd, db_prefix, config, p_ids_merge_job_done):
- consensus_tasks = []
- consensus_out ={}
- # Unlike the merge tasks, consensus occurs in a single directory.
- rdir = os.path.join(wd, 'preads')
- mkdir(rdir)
- for p_id, job_done in p_ids_merge_job_done:
- out_file = makePypeLocalFile(os.path.abspath("%s/preads/out.%05d.fasta" % (wd, p_id)))
- out_done = makePypeLocalFile(os.path.abspath("%s/preads/c_%05d_done" % (wd, p_id)))
- parameters = {"cwd": rdir,
- "job_id": p_id,
- "prefix": db_prefix,
- "config": config}
- make_c_task = PypeTask(inputs = {"job_done": job_done},
- outputs = {"out_file": out_file, "out_done": out_done},
- parameters = parameters,
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/ct_%05d" % p_id)
- c_task = make_c_task(task_run_consensus)
- consensus_tasks.append(c_task)
- consensus_out["cjob_%d" % p_id] = out_done
- return consensus_tasks, consensus_out
-
-
-
-def main1(prog_name, input_config_fn, logger_config_fn=None):
- global fc_run_logger
- fc_run_logger = support.setup_logger(logger_config_fn)
-
- fc_run_logger.info("fc_run started with configuration %s", input_config_fn)
- try:
- config = support.get_dict_from_old_falcon_cfg(support.parse_config(input_config_fn))
- except Exception:
- fc_run_logger.exception('Failed to parse config "{}".'.format(input_config_fn))
- raise
- rawread_dir = os.path.abspath("./0-rawreads")
- pread_dir = os.path.abspath("./1-preads_ovl")
- falcon_asm_dir = os.path.abspath("./2-asm-falcon")
- script_dir = os.path.abspath("./scripts")
- sge_log_dir = os.path.abspath("./sge_log")
-
- for d in (rawread_dir, pread_dir, falcon_asm_dir, script_dir, sge_log_dir):
- support.make_dirs(d)
-
- exitOnFailure=config['stop_all_jobs_on_failure'] # only matter for parallel jobs
- concurrent_jobs = config["pa_concurrent_jobs"]
- PypeThreadWorkflow.setNumThreadAllowed(concurrent_jobs, concurrent_jobs)
- wf = PypeThreadWorkflow()
-
- input_fofn_plf = makePypeLocalFile(config["input_fofn"])
- rawread_fofn_plf = makePypeLocalFile(os.path.join(rawread_dir, os.path.basename(config["input_fofn"])))
- make_fofn_abs_task = PypeTask(inputs = {"i_fofn": input_fofn_plf},
- outputs = {"o_fofn": rawread_fofn_plf},
- parameters = {},
- TaskType = PypeThreadTaskBase)
- fofn_abs_task = make_fofn_abs_task(task_make_fofn_abs_raw)
-
- wf.addTasks([fofn_abs_task])
- wf.refreshTargets([fofn_abs_task])
-
- if config["input_type"] == "raw":
- #### import sequences into daligner DB
- sleep_done = makePypeLocalFile( os.path.join( rawread_dir, "sleep_done") )
- rdb_build_done = makePypeLocalFile( os.path.join( rawread_dir, "rdb_build_done") )
- run_jobs = makePypeLocalFile( os.path.join( rawread_dir, "run_jobs.sh") )
- parameters = {"work_dir": rawread_dir,
- "config": config}
-
- raw_reads_db_plf = makePypeLocalFile(os.path.join(rawread_dir, "%s.db" % "raw_reads"))
- make_build_rdb_task = PypeTask(inputs = {"input_fofn": rawread_fofn_plf},
- outputs = {"rdb_build_done": rdb_build_done,
- "raw_reads_db": raw_reads_db_plf,
- "run_jobs": run_jobs,
- },
- parameters = parameters,
- TaskType = PypeThreadTaskBase)
- build_rdb_task = make_build_rdb_task(task_build_rdb)
-
- wf.addTasks([build_rdb_task])
- wf.refreshTargets([rdb_build_done])
-
- raw_reads_nblock = support.get_nblock(fn(raw_reads_db_plf))
- #### run daligner
- daligner_tasks, daligner_out = create_daligner_tasks(fn(run_jobs), rawread_dir, "raw_reads", rdb_build_done,
- nblock=raw_reads_nblock, config=config)
-
- wf.addTasks(daligner_tasks)
- r_da_done = makePypeLocalFile( os.path.join( rawread_dir, "da_done") )
-
- parameters = {
- "nblock": raw_reads_nblock,
- }
- make_daligner_gather = PypeTask(
- inputs = daligner_out,
- outputs = {"da_done":r_da_done},
- parameters = parameters,
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/rda_check" )
- check_r_da_task = make_daligner_gather(task_daligner_gather)
- wf.addTask(check_r_da_task)
- wf.refreshTargets(exitOnFailure=exitOnFailure)
-
- merge_tasks, merge_out, p_ids_merge_job_done = create_merge_tasks(fn(run_jobs), rawread_dir, "raw_reads", r_da_done, config)
- wf.addTasks( merge_tasks )
- wf.refreshTargets(exitOnFailure=exitOnFailure)
-
- if config["target"] == "overlapping":
- sys.exit(0)
- consensus_tasks, consensus_out = create_consensus_tasks(rawread_dir, "raw_reads", config, p_ids_merge_job_done)
- wf.addTasks( consensus_tasks )
-
- r_cns_done = makePypeLocalFile( os.path.join( rawread_dir, "cns_done") )
- pread_fofn = makePypeLocalFile( os.path.join( pread_dir, "input_preads.fofn" ) )
-
- @PypeTask( inputs = consensus_out,
- outputs = {"cns_done":r_cns_done, "pread_fofn": pread_fofn},
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/cns_check" )
- def check_r_cns_task(self):
- with open(fn(self.pread_fofn), "w") as f:
- fn_list = glob.glob("%s/preads/out*.fasta" % rawread_dir)
- fn_list.sort()
- for fa_fn in fn_list:
- print >>f, fa_fn
- system("touch %s" % fn(self.cns_done))
- wf.addTask(check_r_cns_task)
-
- length_cutoff_plf = makePypeLocalFile(os.path.join(rawread_dir, "length_cutoff"))
- pre_assembly_report_plf = makePypeLocalFile(os.path.join(rawread_dir, "pre_assembly_stats.json")) #tho technically it needs pread_fofn
- make_task = PypeTask(
- inputs = {"length_cutoff_fn": length_cutoff_plf,
- "raw_reads_db": raw_reads_db_plf,
- "preads_fofn": pread_fofn, },
- outputs = {"pre_assembly_report": pre_assembly_report_plf, },
- parameters = config,
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/report_pre_assembly")
- task = make_task(task_report_pre_assembly)
- wf.addTask(task)
-
- concurrent_jobs = config["cns_concurrent_jobs"]
- PypeThreadWorkflow.setNumThreadAllowed(concurrent_jobs, concurrent_jobs)
- wf.refreshTargets(exitOnFailure=exitOnFailure)
-
- if config["target"] == "pre-assembly":
- sys.exit(0)
-
- # build pread database
- if config["input_type"] == "preads":
- pread_fofn = makePypeLocalFile(os.path.join(pread_dir, os.path.basename(config["input_fofn"])))
- make_fofn_abs_task = PypeTask(inputs = {"i_fofn": rawread_fofn_plf},
- outputs = {"o_fofn": pread_fofn},
- parameters = {},
- TaskType = PypeThreadTaskBase)
- fofn_abs_task = make_fofn_abs_task(task_make_fofn_abs_preads)
- wf.addTasks([fofn_abs_task])
- wf.refreshTargets([fofn_abs_task])
-
- pdb_build_done = makePypeLocalFile( os.path.join( pread_dir, "pdb_build_done") )
- parameters = {"work_dir": pread_dir,
- "config": config}
-
- run_jobs = makePypeLocalFile(os.path.join(pread_dir, 'run_jobs.sh'))
- preads_db = makePypeLocalFile(os.path.join(pread_dir, 'preads.db')) # Also .preads.*, of course.
- make_build_pdb_task = PypeTask(inputs = {"pread_fofn": pread_fofn },
- outputs = {"pdb_build_done": pdb_build_done,
- "preads_db": preads_db,
- "run_jobs": run_jobs},
- parameters = parameters,
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/build_pdb")
- build_pdb_task = make_build_pdb_task(task_build_pdb)
-
- wf.addTasks([build_pdb_task])
- wf.refreshTargets([pdb_build_done])
-
-
- preads_nblock = support.get_nblock(fn(preads_db))
- #### run daligner
- config["sge_option_da"] = config["sge_option_pda"]
- config["sge_option_la"] = config["sge_option_pla"]
- daligner_tasks, daligner_out = create_daligner_tasks(fn(run_jobs), pread_dir, "preads", pdb_build_done,
- nblock=preads_nblock, config=config, pread_aln=True)
- wf.addTasks(daligner_tasks)
-
- p_da_done = makePypeLocalFile(os.path.join( pread_dir, "da_done"))
- parameters = {
- "nblock": preads_nblock,
- }
- make_daligner_gather = PypeTask(
- inputs = daligner_out,
- outputs = {"da_done":p_da_done},
- parameters = parameters,
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/pda_check" )
- check_p_da_task = make_daligner_gather(task_daligner_gather)
- wf.addTask(check_p_da_task)
- wf.refreshTargets(exitOnFailure=exitOnFailure)
-
- merge_tasks, merge_out, _ = create_merge_tasks(fn(run_jobs), pread_dir, "preads", p_da_done, config)
- wf.addTasks( merge_tasks )
-
- p_merge_done = makePypeLocalFile(os.path.join( pread_dir, "p_merge_done"))
-
- @PypeTask( inputs = merge_out,
- outputs = {"p_merge_done": p_merge_done},
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/pmerge_check" )
- def check_p_merge_check_task(self):
- system("touch %s" % fn(self.p_merge_done))
- wf.addTask(check_p_merge_check_task)
-
- concurrent_jobs = config["ovlp_concurrent_jobs"]
- PypeThreadWorkflow.setNumThreadAllowed(concurrent_jobs, concurrent_jobs)
-
- wf.refreshTargets(exitOnFailure=exitOnFailure)
-
-
- db2falcon_done = makePypeLocalFile( os.path.join(pread_dir, "db2falcon_done"))
- make_run_db2falcon = PypeTask(
- inputs = {"p_merge_done": p_merge_done,},
- outputs = {"db2falcon_done": db2falcon_done},
- parameters = {"wd": pread_dir,
- "config": config,
- },
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/db2falcon" )
- wf.addTask(make_run_db2falcon(task_run_db2falcon))
-
- falcon_asm_done = makePypeLocalFile( os.path.join( falcon_asm_dir, "falcon_asm_done") )
- make_run_falcon_asm = PypeTask(
- inputs = {"db2falcon_done": db2falcon_done, "db_file": preads_db},
- outputs = {"falcon_asm_done": falcon_asm_done},
- parameters = {"wd": falcon_asm_dir,
- "config": config,
- "pread_dir": pread_dir},
- TaskType = PypeThreadTaskBase,
- URL = "task://localhost/falcon" )
- wf.addTask(make_run_falcon_asm(task_run_falcon_asm))
- wf.refreshTargets()
-
-
-def main(argv=sys.argv):
- parser = argparse.ArgumentParser()
- parser.add_argument('config',
- help='.cfg/.ini/.json')
- parser.add_argument('logger',
- nargs='?',
- help='(Optional)JSON config for standard Python logging module')
- args = parser.parse_args(argv[1:])
- main1(argv[0], args.config, args.logger)
diff --git a/FALCON/falcon_kit/mains/run1.py b/FALCON/falcon_kit/mains/run1.py
index 242b65e..cdfb05b 100644
--- a/FALCON/falcon_kit/mains/run1.py
+++ b/FALCON/falcon_kit/mains/run1.py
@@ -1,359 +1,152 @@
from .. import run_support as support
-from .. import bash
+from .. import bash, pype_tasks
from ..util.system import only_these_symlinks
-from falcon_kit import stats_preassembly
from pypeflow.pwatcher_bridge import PypeProcWatcherWorkflow, MyFakePypeThreadTaskBase
-from pypeflow.data import PypeLocalFile, makePypeLocalFile, fn
+from pypeflow.data import makePypeLocalFile, fn
from pypeflow.task import PypeTask
+from pypeflow.simple_pwatcher_bridge import (PypeProcWatcherWorkflow, MyFakePypeThreadTaskBase,
+ makePypeLocalFile, fn, PypeTask)
import argparse
-import collections
import glob
import json
+import logging
import os
import re
import sys
import time
-fc_run_logger = None
-
-def remove(*fns):
- for fn in fns:
- if os.path.exists(fn):
- os.remove(fn)
- assert not os.path.exists(fn)
-
-def system(call, check=False):
- fc_run_logger.debug('$(%s)' %repr(call))
- rc = os.system(call)
- msg = "Call %r returned %d." % (call, rc)
- if rc:
- fc_run_logger.warning(msg)
- if check:
- raise Exception(msg)
- else:
- fc_run_logger.debug(msg)
- return rc
-
-def task_make_fofn_abs_raw(self):
- #script_fn = 'noop.sh'
- #open(script_fn, 'w').write('echo NOOP raw')
- #self.generated_script_fn = script_fn
- support.make_fofn_abs(self.i_fofn.path, self.o_fofn.path)
-
-def task_make_fofn_abs_preads(self):
- #script_fn = 'noop.sh'
- #open(script_fn, 'w').write('echo NOOP preads')
- #self.generated_script_fn = script_fn
- support.make_fofn_abs(self.i_fofn.path, self.o_fofn.path)
-
-def task_build_rdb(self):
- input_fofn_fn = fn(self.input_fofn)
- job_done = fn(self.rdb_build_done)
- db = fn(self.raw_reads_db)
- run_jobs = fn(self.run_jobs)
- remove(job_done, db, run_jobs)
- work_dir = self.parameters["work_dir"]
- config = self.parameters["config"]
-
- script_fn = os.path.join( work_dir, "prepare_rdb.sh" )
- args = {
- 'input_fofn_fn': input_fofn_fn,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- 'run_jobs_fn': run_jobs,
- }
- support.build_rdb(**args)
- self.generated_script_fn = script_fn
-
-def task_build_pdb(self): #essential the same as build_rdb() but the subtle differences are tricky to consolidate to one function
- input_fofn_fn = fn(self.pread_fofn)
- job_done = fn(self.pdb_build_done)
- db = fn(self.preads_db)
- run_jobs = fn(self.run_jobs)
- remove(job_done, db, run_jobs)
- work_dir = self.parameters["work_dir"]
- config = self.parameters["config"]
-
- script_fn = os.path.join( work_dir, "prepare_pdb.sh" )
- args = {
- 'input_fofn_fn': input_fofn_fn,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- 'run_jobs_fn': run_jobs,
- }
- support.build_pdb(**args)
- self.generated_script_fn = script_fn
-
-def task_run_db2falcon(self):
- wd = self.parameters["wd"]
- #self.p_merge_done
- job_done = fn(self.db2falcon_done)
- config = self.parameters["config"]
- script_dir = os.path.join(wd)
- script_fn = os.path.join(script_dir ,"run_db2falcon.sh")
- args = {
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- support.run_db2falcon(**args)
- self.generated_script_fn = script_fn
-
-def task_run_falcon_asm(self):
- wd = self.parameters["wd"]
- #self.db2falcon_done
- db_file = fn(self.db_file)
- job_done = fn(self.falcon_asm_done)
- config = self.parameters["config"]
- pread_dir = self.parameters["pread_dir"]
- script_dir = os.path.join( wd )
- script_fn = os.path.join( script_dir ,"run_falcon_asm.sh" )
- # Generate las.fofn in run-dir.
- system('cd {}; find {}/m_*/ -name "preads.*.las" >| las.fofn'.format(wd, pread_dir))
- las_fofn_fn = 'las.fofn'
- args = {
- 'las_fofn_fn': las_fofn_fn,
- 'preads4falcon_fasta_fn': os.path.join(pread_dir, 'preads4falcon.fasta'),
- 'db_file_fn': db_file,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- support.run_falcon_asm(**args)
- self.generated_script_fn = script_fn
-
-def task_report_pre_assembly(self):
- i_raw_reads_db_fn = fn(self.raw_reads_db)
- i_preads_fofn_fn = fn(self.preads_fofn)
- i_length_cutoff_fn = fn(self.length_cutoff_fn)
- o_json_fn = fn(self.pre_assembly_report)
- cfg = self.parameters
- genome_length = int(cfg.get('genome_size', 0)) # different name in falcon
- length_cutoff = int(cfg['length_cutoff'])
- # Update length_cutoff if auto-calc (when length_cutoff is negative).
- # i_length_cutoff_fn was created long ago, so no filesystem issues.
- length_cutoff = support.get_length_cutoff(length_cutoff, i_length_cutoff_fn)
- cwd = self.parameters['cwd']
- mkdir(cwd)
- script_fn = os.path.join(cwd , 'run_report_pre_assembly.sh')
- job_done = os.path.join(cwd, 'report_pa_done')
- kwds = {
- 'i_raw_reads_db_fn': i_raw_reads_db_fn,
- 'i_preads_fofn_fn': i_preads_fofn_fn,
- 'genome_length': genome_length,
- 'length_cutoff': length_cutoff,
- 'o_json_fn': o_json_fn,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- fc_run_logger.info('Report inputs: {}'.format(repr(kwds)))
- support.run_report_pre_assembly(**kwds)
- self.generated_script_fn = script_fn
-
-def task_run_daligner(self):
- job_done = fn(self.job_done)
- daligner_script = self.parameters["daligner_script"]
- job_uid = self.parameters["job_uid"]
- cwd = self.parameters["cwd"]
- mkdir(cwd)
- db_prefix = self.parameters["db_prefix"]
- config = self.parameters["config"]
- script_dir = os.path.join(cwd)
- script_fn = os.path.join(script_dir , "rj_%s.sh" % (job_uid))
- args = {
- 'daligner_script': daligner_script,
- 'db_prefix': db_prefix,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- support.run_daligner(**args)
- self.generated_script_fn = script_fn
-
-def task_run_las_merge(self):
- script = self.parameters["merge_script"]
- job_id = self.parameters["job_id"]
- cwd = self.parameters["cwd"]
- job_done = fn(self.job_done)
- config = self.parameters["config"]
-
- script_dir = os.path.join( cwd )
- script_fn = os.path.join( script_dir , "rp_%05d.sh" % (job_id))
- args = {
- 'script': script,
- 'config': config,
- 'job_done': job_done,
- 'script_fn': script_fn,
- }
- support.run_las_merge(**args)
- self.generated_script_fn = script_fn
-
-def task_run_consensus(self):
- merge_job_done = fn(self.job_done)
- out_file_fn = fn(self.out_file)
- out_done = fn(self.out_done)
- job_id = self.parameters["job_id"]
- cwd = self.parameters["cwd"]
- config = self.parameters["config"]
- prefix = self.parameters["prefix"]
- script_dir = os.path.join( cwd )
- script_fn = os.path.join( script_dir , "c_%05d.sh" % (job_id))
- db_fn = os.path.abspath('{cwd}/../../{prefix}'.format(**locals())) # ASSUMING 2-levels deep
- merge_job_dir = os.path.dirname(merge_job_done)
- # by convention, we assume the name of the .las file
- las_fn = os.path.abspath('{merge_job_dir}/{prefix}.{job_id}.las'.format(**locals()))
- args = {
- 'db_fn': db_fn,
- 'las_fn': las_fn,
- 'out_file_fn': out_file_fn,
- 'config': config,
- 'job_done': out_done,
- 'script_fn': script_fn,
- }
- support.run_consensus(**args)
- self.generated_script_fn = script_fn
-
-def mkdir(d):
- if not os.path.isdir(d):
- os.makedirs(d)
-
-def task_daligner_gather(self):
- da_done = fn(self.da_done)
- main_dir = os.path.dirname(da_done)
- out_dict = self.inputDataObjs
- nblock = self.parameters['nblock']
- fc_run_logger.debug('nblock=%d, out_dir:\n%s'%(nblock, out_dict))
-
- # Create m_* dirs.
- for block in xrange(1, nblock+1):
- mdir = os.path.join(main_dir, 'm_%05d' %block) # By convention. pbsmrtpipe works differently.
- mkdir(mdir)
- # TODO: Remove existing symlinks?
- job_rundirs = [os.path.dirname(fn(dal_done)) for dal_done in out_dict.values()]
-
- # Symlink all daligner *.las.
- links = collections.defaultdict(list)
- for block, las_path in support.daligner_gather_las(job_rundirs):
- mdir = os.path.join(main_dir, 'm_%05d' %block) # By convention. pbsmrtpipe works differently.
- #las_path = os.path.relpath(las_path, mdir)
- links[mdir].append(las_path)
- only_these_symlinks(links)
- system("touch %s" %da_done)
-
-def create_daligner_tasks(run_jobs_fn, wd, db_prefix, rdb_build_done, nblock, config, pread_aln=False):
+fc_run_logger = logging.getLogger(__name__) # default, for remote tasks
+
+
+def create_daligner_tasks(basedir, scatter_fn):
tasks = []
tasks_out = {}
- skip_checks = config.get('skip_checks')
- fc_run_logger.info('Skip LAcheck after daligner? {}'.format(skip_checks))
- for job_uid, script in bash.scripts_daligner(run_jobs_fn, db_prefix, rdb_build_done, nblock, pread_aln, skip_checks):
- run_dir = "job_%s" %job_uid
- cwd = os.path.join(wd, run_dir)
- job_done_fn = os.path.abspath(os.path.join(cwd, "job_%s_done" %job_uid))
- job_done = makePypeLocalFile(job_done_fn)
- parameters = {"daligner_script": script,
- "cwd": cwd,
- "job_uid": job_uid,
- "config": config,
- "sge_option": config["sge_option_da"],
- "db_prefix": db_prefix}
- make_daligner_task = PypeTask(inputs = {"rdb_build_done": rdb_build_done},
- outputs = {"job_done": job_done},
+ content = json.loads(open(scatter_fn).read()) # array of descriptions
+ for section in content:
+ parameters = section['parameters']
+ inputs = section['inputs']
+ inputs['scatter_fn'] = scatter_fn
+ outputs = section['outputs']
+ URL = section['URL']
+ job_uid = parameters['job_uid']
+ wdir = os.path.join(basedir, 'job_%s' %job_uid)
+ make_daligner_task = PypeTask(inputs = inputs,
+ outputs = outputs,
parameters = parameters,
TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/d_%s_%s" %(job_uid, db_prefix))
- daligner_task = make_daligner_task(task_run_daligner)
+ URL = URL,
+ wdir = wdir,
+ )
+ daligner_task = make_daligner_task(pype_tasks.task_run_daligner)
tasks.append(daligner_task)
- tasks_out[ "ajob_%s" % job_uid ] = job_done
+ tasks_out['ajob_%s' % job_uid] = daligner_task.outputs['job_done'] # these are relative, so we need the PypeLocalFiles
return tasks, tasks_out
-def create_merge_tasks(run_jobs_fn, wd, db_prefix, input_dep, config):
- merge_tasks = []
- merge_out = {}
- p_ids_merge_job_done = [] # for consensus
-
- merge_scripts = bash.scripts_merge(config, db_prefix, run_jobs_fn)
- for p_id, merge_script in merge_scripts:
- job_done = makePypeLocalFile(os.path.abspath("%s/m_%05d/m_%05d_done" % (wd, p_id, p_id)))
- parameters = {"merge_script": merge_script,
- "cwd": os.path.join(wd, "m_%05d" % p_id),
- "job_id": p_id,
- "sge_option": config["sge_option_la"],
- "config": config}
- make_merge_task = PypeTask(inputs = {"input_dep": input_dep},
- outputs = {"job_done": job_done},
- parameters = parameters,
- TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/m_%05d_%s" % (p_id, db_prefix))
- merge_task = make_merge_task(task_run_las_merge)
- merge_out["mjob_%d" % p_id] = job_done
- merge_tasks.append(merge_task)
- p_ids_merge_job_done.append((p_id, job_done))
- return merge_tasks, merge_out, p_ids_merge_job_done
-
-def create_consensus_tasks(wd, db_prefix, config, p_ids_merge_job_done):
+def create_merge_tasks(basedir, scatter_fn):
+ tasks = []
+ p_ids_merged_las = {} # for consensus
+ content = json.loads(open(scatter_fn).read()) # array of descriptions
+ for section in content:
+ parameters = section['parameters']
+ inputs = section['inputs']
+ inputs['scatter_fn'] = scatter_fn
+ outputs = section['outputs']
+ URL = section['URL']
+ p_id = parameters['job_id']
+ #merge_script = parameters['merge_script']
+ #sge_option = parameters['sge_option']
+ wdir = os.path.join(basedir, 'm_%05d' %p_id)
+ make_task = PypeTask(inputs = inputs,
+ outputs = outputs,
+ parameters = parameters,
+ TaskType = MyFakePypeThreadTaskBase,
+ URL = URL,
+ wdir = wdir,
+ )
+ task = make_task(pype_tasks.task_run_las_merge)
+ tasks.append(task)
+ las_fn = task.outputs['merged_las'] # these are relative, so we need the PypeLocalFiles
+ p_ids_merged_las[p_id] = las_fn
+ return tasks, p_ids_merged_las
+
+def create_consensus_tasks(basedir, scatter_fn):
consensus_tasks = []
consensus_out ={}
- fasta_plfs = []
- for p_id, job_done in p_ids_merge_job_done:
- cns_label = 'cns_%05d' %p_id
- rdir = os.path.join(wd, 'preads', cns_label)
- mkdir(rdir)
- out_done = makePypeLocalFile(os.path.abspath("%s/%s_done" % (rdir, cns_label)))
- out_file = makePypeLocalFile(os.path.abspath("%s/%s.fasta" % (rdir, cns_label)))
- fasta_plfs.append(out_file)
- parameters = {"cwd": rdir,
- "job_id": p_id,
- "prefix": db_prefix,
- "sge_option": config["sge_option_cns"],
- "config": config}
- make_c_task = PypeTask(inputs = {"job_done": job_done},
- outputs = {"out_file": out_file, "out_done": out_done},
+ content = json.loads(open(scatter_fn).read()) # array of descriptions
+ for section in content:
+ parameters = section['parameters']
+ inputs = section['inputs']
+ inputs['scatter_fn'] = scatter_fn
+ outputs = section['outputs']
+ URL = section['URL']
+ p_id = int(parameters['job_id'])
+ cns_label = 'cns_%05d' %int(p_id)
+ wdir = os.path.join(basedir, 'preads', cns_label)
+ make_c_task = PypeTask(inputs = inputs,
+ outputs = outputs,
parameters = parameters,
TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/%s" % cns_label)
- c_task = make_c_task(task_run_consensus)
+ URL = URL,
+ wdir = wdir,
+ )
+ c_task = make_c_task(pype_tasks.task_run_consensus)
consensus_tasks.append(c_task)
- consensus_out["cjob_%d" % p_id] = out_done
-
- r_cns_done_plf = makePypeLocalFile(os.path.join(wd, 'preads', "cns_done"))
- pread_fofn_plf = makePypeLocalFile(os.path.join(wd, 'preads', "input_preads.fofn"))
-
- @PypeTask( inputs = consensus_out,
- outputs = {"cns_done":r_cns_done_plf, "pread_fofn": pread_fofn_plf},
+ consensus_out['cjob_%d' % p_id] = outputs['out_file']
+ return consensus_tasks, consensus_out
+
+def create_merge_gather_task(wd, inputs):
+ las_fofn_plf = makePypeLocalFile(os.path.join(wd, 'las.fofn'))
+ las_fopfn_plf = makePypeLocalFile(os.path.join(wd, 'las.fopfn'))
+
+ make_task = PypeTask(inputs = inputs, # p_ids_merged_las
+ outputs = {'las_fofn': las_fofn_plf,
+ 'las_fopfn': las_fopfn_plf,
+ },
+ TaskType = MyFakePypeThreadTaskBase,
+ )
+ # URL = 'task://localhost/pmerge_gather')
+ task = make_task(pype_tasks.task_merge_gather)
+ return task, las_fofn_plf, las_fopfn_plf
+
+def create_consensus_gather_task(wd, inputs):
+ # Happens only in stage-0.
+ preads_fofn_plf = makePypeLocalFile(os.path.join(wd, 'input_preads.fofn'))
+
+ make_cns_gather_task = PypeTask(
+ inputs = inputs, # consensus_out
+ outputs = {'preads_fofn': preads_fofn_plf},
TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/cns_check" )
- def check_r_cns_task(self):
- with open(fn(self.pread_fofn), "w") as f:
- for fa_fn in sorted(fn(plf) for plf in fasta_plfs):
- print >>f, fa_fn
- system("touch %s" % fn(self.cns_done))
- consensus_tasks.append(check_r_cns_task)
- return consensus_tasks, pread_fofn_plf
+ URL = 'task://localhost/cns_gather' )
+ task = make_cns_gather_task(pype_tasks.task_cns_gather)
+ return task, preads_fofn_plf
def main1(prog_name, input_config_fn, logger_config_fn=None):
global fc_run_logger
fc_run_logger = support.setup_logger(logger_config_fn)
- fc_run_logger.info("fc_run started with configuration %s", input_config_fn)
+ fc_run_logger.info('fc_run started with configuration %s', input_config_fn)
try:
config = support.get_dict_from_old_falcon_cfg(support.parse_config(input_config_fn))
except Exception:
fc_run_logger.exception('Failed to parse config "{}".'.format(input_config_fn))
raise
- input_fofn_plf = makePypeLocalFile(config["input_fofn"])
+ input_fofn_plf = makePypeLocalFile(config['input_fofn'])
#Workflow = PypeProcWatcherWorkflow
wf = PypeProcWatcherWorkflow(job_type=config['job_type'],
- job_queue=config['job_queue'])
+ job_queue=config['job_queue'],
+ sge_option=config.get('sge_option', ''),
+ watcher_type=config['pwatcher_type'],
+ watcher_directory=config['pwatcher_directory'])
run(wf, config,
+ os.path.abspath(input_config_fn),
input_fofn_plf=input_fofn_plf,
setNumThreadAllowed=PypeProcWatcherWorkflow.setNumThreadAllowed)
def run(wf, config,
+ input_config_fn,
input_fofn_plf,
setNumThreadAllowed,
):
@@ -362,134 +155,205 @@ def run(wf, config,
* fc_run_logger
* run_support.logger
"""
- rawread_dir = os.path.abspath("./0-rawreads")
- pread_dir = os.path.abspath("./1-preads_ovl")
- falcon_asm_dir = os.path.abspath("./2-asm-falcon")
- script_dir = os.path.abspath("./scripts")
- sge_log_dir = os.path.abspath("./sge_log")
+ rawread_dir = os.path.abspath('./0-rawreads')
+ pread_dir = os.path.abspath('./1-preads_ovl')
+ falcon_asm_dir = os.path.abspath('./2-asm-falcon')
+ script_dir = os.path.abspath('./scripts')
+ sge_log_dir = os.path.abspath('./sge_log')
for d in (rawread_dir, pread_dir, falcon_asm_dir, script_dir, sge_log_dir):
support.make_dirs(d)
exitOnFailure=config['stop_all_jobs_on_failure'] # only matter for parallel jobs
- concurrent_jobs = config["pa_concurrent_jobs"]
- setNumThreadAllowed(concurrent_jobs, concurrent_jobs)
+ concurrent_jobs = config['pa_concurrent_jobs']
+ wf.max_jobs = concurrent_jobs
- rawread_fofn_plf = makePypeLocalFile(os.path.join(rawread_dir, os.path.basename(config["input_fofn"])))
- make_fofn_abs_task = PypeTask(inputs = {"i_fofn": input_fofn_plf},
- outputs = {"o_fofn": rawread_fofn_plf},
+ rawread_fofn_plf = makePypeLocalFile(os.path.join(rawread_dir, 'raw-fofn-abs', os.path.basename(config['input_fofn'])))
+ make_fofn_abs_task = PypeTask(inputs = {'i_fofn': input_fofn_plf},
+ outputs = {'o_fofn': rawread_fofn_plf},
parameters = {},
TaskType = MyFakePypeThreadTaskBase)
- fofn_abs_task = make_fofn_abs_task(task_make_fofn_abs_raw)
+ fofn_abs_task = make_fofn_abs_task(pype_tasks.task_make_fofn_abs_raw)
wf.addTasks([fofn_abs_task])
wf.refreshTargets([fofn_abs_task])
- if config["input_type"] == "raw":
+ if config['input_type'] == 'raw':
#### import sequences into daligner DB
- sleep_done = makePypeLocalFile( os.path.join( rawread_dir, "sleep_done") )
- rdb_build_done = makePypeLocalFile( os.path.join( rawread_dir, "rdb_build_done") )
- run_jobs = makePypeLocalFile( os.path.join( rawread_dir, "run_jobs.sh") )
- parameters = {"work_dir": rawread_dir,
- "sge_option": config["sge_option_da"],
- "config": config}
-
- length_cutoff_plf = makePypeLocalFile(os.path.join(rawread_dir, "length_cutoff"))
- raw_reads_db_plf = makePypeLocalFile(os.path.join(rawread_dir, "%s.db" % "raw_reads"))
- make_build_rdb_task = PypeTask(inputs = {"input_fofn": rawread_fofn_plf},
- outputs = {"rdb_build_done": rdb_build_done,
- "raw_reads_db": raw_reads_db_plf,
- "length_cutoff": length_cutoff_plf,
- "run_jobs": run_jobs,
+ sleep_done = makePypeLocalFile( os.path.join( rawread_dir, 'sleep_done') )
+ rdb_build_done = makePypeLocalFile( os.path.join( rawread_dir, 'rdb_build_done') )
+ run_jobs = makePypeLocalFile( os.path.join( rawread_dir, 'run_jobs.sh') )
+ parameters = {'work_dir': rawread_dir,
+ 'sge_option': config['sge_option_da'],
+ 'config_fn': input_config_fn,
+ 'config': config}
+
+ length_cutoff_plf = makePypeLocalFile(os.path.join(rawread_dir, 'length_cutoff'))
+ raw_reads_db_plf = makePypeLocalFile(os.path.join(rawread_dir, '%s.db' % 'raw_reads'))
+ make_build_rdb_task = PypeTask(inputs = {'input_fofn': rawread_fofn_plf},
+ outputs = {'rdb_build_done': rdb_build_done,
+ 'raw_reads_db': raw_reads_db_plf,
+ 'length_cutoff': length_cutoff_plf,
+ 'run_jobs': run_jobs,
},
parameters = parameters,
TaskType = MyFakePypeThreadTaskBase)
- build_rdb_task = make_build_rdb_task(task_build_rdb)
+ build_rdb_task = make_build_rdb_task(pype_tasks.task_build_rdb)
wf.addTasks([build_rdb_task])
wf.refreshTargets([rdb_build_done])
raw_reads_nblock = support.get_nblock(fn(raw_reads_db_plf))
#### run daligner
- daligner_tasks, daligner_out = create_daligner_tasks(fn(run_jobs), rawread_dir, "raw_reads", rdb_build_done,
- nblock=raw_reads_nblock, config=config)
+ scattered_plf = os.path.join(rawread_dir, 'daligner-scatter', 'scattered.json')
+ make_daligner_scatter = PypeTask(
+ inputs = {
+ 'run_jobs_fn': run_jobs,
+ 'db_build_done': rdb_build_done,
+ },
+ outputs = {
+ 'scatter_fn': scattered_plf,
+ },
+ parameters = {
+ 'db_prefix': 'raw_reads',
+ 'nblock': raw_reads_nblock,
+ 'pread_aln': False,
+ 'config': config,
+ },
+ TaskType = MyFakePypeThreadTaskBase,
+ URL = 'task://localhost/raw-daligner-scatter'
+ )
+ task = make_daligner_scatter(pype_tasks.task_daligner_scatter)
+ wf.addTask(task)
+ wf.refreshTargets(exitOnFailure=exitOnFailure)
+
+ daligner_tasks, daligner_out = create_daligner_tasks(rawread_dir, scattered_plf)
wf.addTasks(daligner_tasks)
- r_da_done = makePypeLocalFile( os.path.join( rawread_dir, "da_done") )
+ r_gathered_las_plf = makePypeLocalFile(os.path.join(rawread_dir, 'raw-gather', 'gathered_las.txt'))
parameters = {
- "nblock": raw_reads_nblock,
+ 'nblock': raw_reads_nblock,
}
make_daligner_gather = PypeTask(
inputs = daligner_out,
- outputs = {"da_done":r_da_done},
+ outputs = {'gathered': r_gathered_las_plf},
parameters = parameters,
TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/rda_check" )
- check_r_da_task = make_daligner_gather(task_daligner_gather)
+ URL = 'task://localhost/rda_check' )
+ check_r_da_task = make_daligner_gather(pype_tasks.task_daligner_gather)
wf.addTask(check_r_da_task)
wf.refreshTargets(exitOnFailure=exitOnFailure)
- merge_tasks, merge_out, p_ids_merge_job_done = create_merge_tasks(fn(run_jobs), rawread_dir, "raw_reads", r_da_done, config)
- wf.addTasks( merge_tasks )
+ # Merge .las files.
+ scattered_plf = os.path.join(rawread_dir, 'merge-scatter', 'scattered.json')
+ make_task = PypeTask(
+ inputs = {
+ 'run_jobs': run_jobs,
+ 'gathered_las': r_gathered_las_plf,
+ },
+ outputs = {
+ 'scattered': scattered_plf,
+ },
+ parameters = {
+ 'db_prefix': 'raw_reads',
+ 'config': config,
+ },
+ TaskType = MyFakePypeThreadTaskBase,
+ URL = 'task://localhost/raw-merge-scatter'
+ )
+ task = make_task(pype_tasks.task_merge_scatter)
+ wf.addTask(task)
wf.refreshTargets(exitOnFailure=exitOnFailure)
- if config["target"] == "overlapping":
+ merge_tasks, p_ids_merged_las = create_merge_tasks(rawread_dir, scattered_plf)
+ wf.addTasks(merge_tasks)
+ task, _, las_fopfn_plf = create_merge_gather_task(os.path.join(rawread_dir, 'merge-gather'), p_ids_merged_las)
+ wf.addTask(task)
+ wf.refreshTargets(exitOnFailure=exitOnFailure)
+
+ if config['target'] == 'overlapping':
sys.exit(0)
- consensus_tasks, pread_fofn_plf = create_consensus_tasks(rawread_dir, "raw_reads", config, p_ids_merge_job_done)
- wf.addTasks( consensus_tasks )
+
+ # Produce new FOFN of preads fasta, based on consensus of overlaps.
+ scattered_plf = os.path.join(rawread_dir, 'cns-scatter', 'scattered.json')
+ make_task = PypeTask(
+ inputs = {
+ 'gathered': las_fopfn_plf,
+ },
+ outputs = {
+ 'scattered': scattered_plf,
+ },
+ parameters = {
+ 'db_prefix': 'raw_reads',
+ 'config': config,
+ },
+ TaskType = MyFakePypeThreadTaskBase,
+ URL = 'task://localhost/raw-cns-scatter'
+ )
+ task = make_task(pype_tasks.task_consensus_scatter)
+ wf.addTask(task)
+ wf.refreshTargets(exitOnFailure=exitOnFailure)
+
+ tasks, consensus_out = create_consensus_tasks(rawread_dir, scattered_plf)
+ wf.addTasks(tasks)
+ wf.refreshTargets(exitOnFailure=exitOnFailure)
+
+ task, preads_fofn_plf = create_consensus_gather_task(os.path.join(rawread_dir, 'preads'), consensus_out)
+ wf.addTask(task)
rdir = os.path.join(rawread_dir, 'report')
- pre_assembly_report_plf = makePypeLocalFile(os.path.join(rdir, "pre_assembly_stats.json"))
+ pre_assembly_report_plf = makePypeLocalFile(os.path.join(rdir, 'pre_assembly_stats.json'))
parameters = dict(config)
parameters['cwd'] = rdir
make_task = PypeTask(
- inputs = {"length_cutoff_fn": length_cutoff_plf,
- "raw_reads_db": raw_reads_db_plf,
- "preads_fofn": pread_fofn_plf, },
- outputs = {"pre_assembly_report": pre_assembly_report_plf, },
+ inputs = {'length_cutoff_fn': length_cutoff_plf,
+ 'raw_reads_db': raw_reads_db_plf,
+ 'preads_fofn': preads_fofn_plf, },
+ outputs = {'pre_assembly_report': pre_assembly_report_plf, },
parameters = parameters,
TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/report_pre_assembly")
- task = make_task(task_report_pre_assembly)
+ URL = 'task://localhost/report_pre_assembly')
+ task = make_task(pype_tasks.task_report_pre_assembly)
wf.addTask(task)
- concurrent_jobs = config["cns_concurrent_jobs"]
- setNumThreadAllowed(concurrent_jobs, concurrent_jobs)
+ concurrent_jobs = config['cns_concurrent_jobs']
+ wf.max_jobs = concurrent_jobs
wf.refreshTargets(exitOnFailure=exitOnFailure)
- if config["target"] == "pre-assembly":
- log.info("Quitting after stage-0 for 'pre-assembly' target.")
+ if config['target'] == 'pre-assembly':
+ log.info('Quitting after stage-0 for "pre-assembly" target.')
sys.exit(0)
# build pread database
- if config["input_type"] == "preads":
- pread_fofn_plf = makePypeLocalFile(os.path.join(pread_dir, os.path.basename(config["input_fofn"])))
- make_fofn_abs_task = PypeTask(inputs = {"i_fofn": rawread_fofn_plf},
- outputs = {"o_fofn": pread_fofn_plf},
+ if config['input_type'] == 'preads':
+ preads_fofn_plf = makePypeLocalFile(os.path.join(pread_dir, 'preads-fofn-abs', os.path.basename(config['input_fofn'])))
+ make_fofn_abs_task = PypeTask(inputs = {'i_fofn': rawread_fofn_plf},
+ outputs = {'o_fofn': preads_fofn_plf},
parameters = {},
TaskType = MyFakePypeThreadTaskBase)
- fofn_abs_task = make_fofn_abs_task(task_make_fofn_abs_preads)
+ fofn_abs_task = make_fofn_abs_task(pype_tasks.task_make_fofn_abs_preads)
wf.addTasks([fofn_abs_task])
wf.refreshTargets([fofn_abs_task])
- pdb_build_done = makePypeLocalFile( os.path.join( pread_dir, "pdb_build_done") )
- parameters = {"work_dir": pread_dir,
- "sge_option": config["sge_option_pda"],
- "config": config}
+ pdb_build_done = makePypeLocalFile( os.path.join( pread_dir, 'pdb_build_done') )
+ parameters = {'work_dir': pread_dir,
+ 'sge_option': config['sge_option_pda'],
+ 'config_fn': input_config_fn,
+ 'config': config}
run_jobs = makePypeLocalFile(os.path.join(pread_dir, 'run_jobs.sh'))
preads_db = makePypeLocalFile(os.path.join(pread_dir, 'preads.db')) # Also .preads.*, of course.
- make_build_pdb_task = PypeTask(inputs = {"pread_fofn": pread_fofn_plf },
- outputs = {"pdb_build_done": pdb_build_done,
- "preads_db": preads_db,
- "run_jobs": run_jobs,
+ make_build_pdb_task = PypeTask(inputs = {'preads_fofn': preads_fofn_plf },
+ outputs = {'pdb_build_done': pdb_build_done,
+ 'preads_db': preads_db,
+ 'run_jobs': run_jobs,
},
parameters = parameters,
TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/build_pdb")
- build_pdb_task = make_build_pdb_task(task_build_pdb)
+ URL = 'task://localhost/build_pdb')
+ build_pdb_task = make_build_pdb_task(pype_tasks.task_build_pdb)
wf.addTasks([build_pdb_task])
wf.refreshTargets([pdb_build_done])
@@ -497,69 +361,113 @@ def run(wf, config,
preads_nblock = support.get_nblock(fn(preads_db))
#### run daligner
- config["sge_option_da"] = config["sge_option_pda"]
- daligner_tasks, daligner_out = create_daligner_tasks(fn(run_jobs), pread_dir, "preads", pdb_build_done,
- nblock=preads_nblock, config=config, pread_aln=True)
+ config['sge_option_da'] = config['sge_option_pda']
+
+ scattered_plf = os.path.join(pread_dir, 'daligner-scatter', 'scattered.json')
+ make_daligner_scatter = PypeTask(
+ inputs = {
+ 'run_jobs_fn': run_jobs,
+ 'db_build_done': pdb_build_done,
+ },
+ outputs = {
+ 'scatter_fn': scattered_plf,
+ },
+ parameters = {
+ 'db_prefix': 'preads',
+ 'nblock': preads_nblock,
+ 'pread_aln': True,
+ 'config': config,
+ },
+ TaskType = MyFakePypeThreadTaskBase,
+ URL = 'task://localhost/preads-daligner-scatter'
+ )
+ task = make_daligner_scatter(pype_tasks.task_daligner_scatter)
+ wf.addTask(task)
+ wf.refreshTargets(exitOnFailure=exitOnFailure)
+
+ daligner_tasks, daligner_out = create_daligner_tasks(pread_dir, scattered_plf)
wf.addTasks(daligner_tasks)
- p_da_done = makePypeLocalFile(os.path.join( pread_dir, "da_done"))
+ p_gathered_las_plf = makePypeLocalFile(os.path.join(pread_dir, 'gathered-las', 'gathered-las.txt'))
parameters = {
- "nblock": preads_nblock,
+ 'nblock': preads_nblock,
}
make_daligner_gather = PypeTask(
inputs = daligner_out,
- outputs = {"da_done":p_da_done},
+ outputs = {'gathered': p_gathered_las_plf},
parameters = parameters,
TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/pda_check" )
- check_p_da_task = make_daligner_gather(task_daligner_gather)
+ URL = 'task://localhost/pda_check' )
+ check_p_da_task = make_daligner_gather(pype_tasks.task_daligner_gather)
wf.addTask(check_p_da_task)
wf.refreshTargets(exitOnFailure=exitOnFailure)
- config["sge_option_la"] = config["sge_option_pla"]
- merge_tasks, merge_out, _ = create_merge_tasks(fn(run_jobs), pread_dir, "preads", p_da_done, config)
- wf.addTasks( merge_tasks )
-
- p_merge_done = makePypeLocalFile(os.path.join( pread_dir, "p_merge_done"))
+ # Merge .las files.
+ config['sge_option_la'] = config['sge_option_pla']
+ scattered_plf = os.path.join(pread_dir, 'merge-scatter', 'scattered.json')
+ make_task = PypeTask(
+ inputs = {
+ 'run_jobs': run_jobs,
+ 'gathered_las': p_gathered_las_plf,
+ },
+ outputs = {
+ 'scattered': scattered_plf,
+ },
+ parameters = {
+ 'db_prefix': 'preads',
+ 'config': config,
+ },
+ TaskType = MyFakePypeThreadTaskBase,
+ #URL = 'task://localhost/preads-merge-scatter'
+ )
+ task = make_task(pype_tasks.task_merge_scatter)
+ wf.addTask(task)
+ wf.refreshTargets(exitOnFailure=exitOnFailure)
- @PypeTask( inputs = merge_out,
- outputs = {"p_merge_done": p_merge_done},
- TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/pmerge_check" )
- def check_p_merge_check_task(self):
- system("touch %s" % fn(self.p_merge_done))
- wf.addTask(check_p_merge_check_task)
+ merge_tasks, p_ids_merged_las = create_merge_tasks(pread_dir, scattered_plf)
+ wf.addTasks(merge_tasks)
+ task, las_fofn_plf, las_fopfn_plf = create_merge_gather_task(os.path.join(pread_dir, 'merge-gather'), p_ids_merged_las)
+ wf.addTask(task)
- concurrent_jobs = config["ovlp_concurrent_jobs"]
- setNumThreadAllowed(concurrent_jobs, concurrent_jobs)
+ concurrent_jobs = config['ovlp_concurrent_jobs']
+ wf.max_jobs = concurrent_jobs
wf.refreshTargets(exitOnFailure=exitOnFailure)
- db2falcon_done = makePypeLocalFile( os.path.join(pread_dir, "db2falcon_done"))
+ db2falcon_dir = os.path.join(pread_dir, 'db2falcon')
+ db2falcon_done = makePypeLocalFile(os.path.join(db2falcon_dir, 'db2falcon_done'))
+ preads4falcon_plf = makePypeLocalFile(os.path.join(db2falcon_dir, 'preads4falcon.fasta'))
make_run_db2falcon = PypeTask(
- inputs = {"p_merge_done": p_merge_done,},
- outputs = {"db2falcon_done": db2falcon_done},
- parameters = {"wd": pread_dir,
- "config": config,
- "sge_option": config["sge_option_fc"],
+ inputs = {'las_fofn_plf': las_fofn_plf,
+ 'preads_db': preads_db,
+ },
+ outputs = {'db2falcon_done': db2falcon_done,
+ 'preads4falcon': preads4falcon_plf,
+ },
+ parameters = {'wd': db2falcon_dir,
+ 'config': config,
+ 'sge_option': config['sge_option_fc'],
},
TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/db2falcon" )
- wf.addTask(make_run_db2falcon(task_run_db2falcon))
+ URL = 'task://localhost/db2falcon' )
+ wf.addTask(make_run_db2falcon(pype_tasks.task_run_db2falcon))
- falcon_asm_done = makePypeLocalFile( os.path.join( falcon_asm_dir, "falcon_asm_done") )
+ falcon_asm_done = makePypeLocalFile( os.path.join(falcon_asm_dir, 'falcon_asm_done'))
make_run_falcon_asm = PypeTask(
- inputs = {"db2falcon_done": db2falcon_done, "db_file": preads_db},
- outputs = {"falcon_asm_done": falcon_asm_done},
- parameters = {"wd": falcon_asm_dir,
- "config": config,
- "pread_dir": pread_dir,
- "sge_option": config["sge_option_fc"],
+ inputs = {'db2falcon_done': db2falcon_done, 'db_file': preads_db,
+ 'preads4falcon': preads4falcon_plf,
+ 'las_fofn': las_fofn_plf,
+ },
+ outputs = {'falcon_asm_done': falcon_asm_done},
+ parameters = {'wd': falcon_asm_dir,
+ 'config': config,
+ 'pread_dir': pread_dir,
+ 'sge_option': config['sge_option_fc'],
},
TaskType = MyFakePypeThreadTaskBase,
- URL = "task://localhost/falcon_asm" )
- wf.addTask(make_run_falcon_asm(task_run_falcon_asm))
+ URL = 'task://localhost/falcon_asm' )
+ wf.addTask(make_run_falcon_asm(pype_tasks.task_run_falcon_asm))
wf.refreshTargets()
return falcon_asm_done
diff --git a/FALCON/falcon_kit/pype_tasks.py b/FALCON/falcon_kit/pype_tasks.py
new file mode 100644
index 0000000..25857e0
--- /dev/null
+++ b/FALCON/falcon_kit/pype_tasks.py
@@ -0,0 +1,398 @@
+# PypeTask functions now need to be module-level.
+from . import run_support as support
+from . import bash # for scattering
+#from pypeflow.simple_pwatcher_bridge import fn # not really needed
+import collections
+import json
+import logging
+import os.path
+LOG = logging.getLogger(__name__)
+
+def fn(p): return p
+
+def system(call, check=False):
+ LOG.debug('$(%s)' %repr(call))
+ rc = os.system(call)
+ msg = 'Call %r returned %d.' % (call, rc)
+ if rc:
+ LOG.warning(msg)
+ if check:
+ raise Exception(msg)
+ else:
+ LOG.debug(msg)
+ return rc
+
+def remove(*fns):
+ for fn in fns:
+ if os.path.exists(fn):
+ os.remove(fn)
+ assert not os.path.exists(fn)
+
+# Someday, we can drop mkdir() in these.
+def mkdir(d):
+ if not os.path.isdir(d):
+ os.makedirs(d)
+
+def task_make_fofn_abs_raw(self):
+ script_fn = 'noop.sh'
+ open(script_fn, 'w').write('echo NOOP raw')
+ self.generated_script_fn = script_fn
+ mkdir(os.path.dirname(fn(self.o_fofn)))
+ support.make_fofn_abs(fn(self.i_fofn), fn(self.o_fofn))
+
+def task_make_fofn_abs_preads(self):
+ script_fn = 'noop.sh'
+ open(script_fn, 'w').write('echo NOOP preads')
+ self.generated_script_fn = script_fn
+ mkdir(os.path.dirname(fn(self.o_fofn)))
+ support.make_fofn_abs(fn(self.i_fofn), fn(self.o_fofn))
+
+def task_build_rdb(self):
+ input_fofn_fn = fn(self.input_fofn)
+ job_done = fn(self.rdb_build_done)
+ db = fn(self.raw_reads_db)
+ run_jobs = fn(self.run_jobs)
+ remove(job_done, db, run_jobs)
+ work_dir = self.parameters['work_dir']
+ config = self.parameters['config']
+
+ script_fn = os.path.join( work_dir, 'prepare_rdb.sh' )
+ args = {
+ 'input_fofn_fn': input_fofn_fn,
+ 'config': config,
+ 'job_done': job_done,
+ 'script_fn': script_fn,
+ 'run_jobs_fn': run_jobs,
+ }
+ support.build_rdb(**args)
+ self.generated_script_fn = script_fn
+
+def task_build_pdb(self): #essential the same as build_rdb() but the subtle differences are tricky to consolidate to one function
+ input_fofn_fn = fn(self.preads_fofn)
+ job_done = fn(self.pdb_build_done)
+ db = fn(self.preads_db)
+ run_jobs = fn(self.run_jobs)
+ remove(job_done, db, run_jobs)
+ work_dir = self.parameters['work_dir']
+ config = self.parameters['config']
+
+ script_fn = os.path.join( work_dir, 'prepare_pdb.sh' )
+ args = {
+ 'input_fofn_fn': input_fofn_fn,
+ 'config': config,
+ 'job_done': job_done,
+ 'script_fn': script_fn,
+ 'run_jobs_fn': run_jobs,
+ }
+ support.build_pdb(**args)
+ self.generated_script_fn = script_fn
+
+def task_run_db2falcon(self):
+ wd = self.parameters['wd']
+ mkdir(wd)
+ #self.las_fofn # TODO: Are there any implicit dependencies, or can we drop this?
+ job_done = fn(self.db2falcon_done)
+ preads4falcon_fn = fn(self.preads4falcon)
+ preads_db = fn(self.preads_db)
+ config = self.parameters['config']
+ script_dir = os.path.join(wd)
+ script_fn = os.path.join(script_dir ,'run_db2falcon.sh')
+ args = {
+ 'config': config,
+ 'job_done': job_done,
+ 'script_fn': script_fn,
+ 'preads4falcon_fn': preads4falcon_fn,
+ 'preads_db': preads_db,
+ }
+ support.run_db2falcon(**args)
+ self.generated_script_fn = script_fn
+
+def task_run_falcon_asm(self):
+ wd = self.parameters['wd']
+ #self.db2falcon_done
+ db_file = fn(self.db_file)
+ job_done = fn(self.falcon_asm_done)
+ config = self.parameters['config']
+ pread_dir = self.parameters['pread_dir']
+ preads4falcon_fn = fn(self.preads4falcon)
+ las_fofn_fn = fn(self.las_fofn)
+ script_dir = os.path.join(wd)
+ script_fn = os.path.join(script_dir ,'run_falcon_asm.sh')
+ args = {
+ 'las_fofn_fn': las_fofn_fn,
+ 'preads4falcon_fasta_fn': preads4falcon_fn,
+ 'db_file_fn': db_file,
+ 'config': config,
+ 'job_done': job_done,
+ 'script_fn': script_fn,
+ }
+ support.run_falcon_asm(**args)
+ self.generated_script_fn = script_fn
+
+def task_report_pre_assembly(self):
+ i_raw_reads_db_fn = fn(self.raw_reads_db)
+ i_preads_fofn_fn = fn(self.preads_fofn)
+ i_length_cutoff_fn = fn(self.length_cutoff_fn)
+ o_json_fn = fn(self.pre_assembly_report)
+ cfg = self.parameters
+ genome_length = int(cfg.get('genome_size', 0)) # different name in falcon
+ length_cutoff = int(cfg['length_cutoff'])
+ # Update length_cutoff if auto-calc (when length_cutoff is negative).
+ # i_length_cutoff_fn was created long ago, so no filesystem issues.
+ length_cutoff = support.get_length_cutoff(length_cutoff, i_length_cutoff_fn)
+ cwd = self.parameters['cwd']
+ mkdir(cwd)
+ script_fn = os.path.join(cwd , 'run_report_pre_assembly.sh')
+ job_done = os.path.join(cwd, 'report_pa_done')
+ kwds = {
+ 'i_raw_reads_db_fn': i_raw_reads_db_fn,
+ 'i_preads_fofn_fn': i_preads_fofn_fn,
+ 'genome_length': genome_length,
+ 'length_cutoff': length_cutoff,
+ 'o_json_fn': o_json_fn,
+ 'job_done': job_done,
+ 'script_fn': script_fn,
+ }
+ LOG.info('Report inputs: {}'.format(repr(kwds)))
+ support.run_report_pre_assembly(**kwds)
+ self.generated_script_fn = script_fn
+
+def task_run_daligner(self):
+ job_done = fn(self.job_done)
+ daligner_script = self.parameters['daligner_script']
+ job_uid = self.parameters['job_uid']
+ cwd = self.parameters['cwd']
+ #mkdir(cwd)
+ db_prefix = self.parameters['db_prefix']
+ config = self.parameters['config']
+ script_dir = os.path.join(cwd)
+ script_fn = os.path.join(script_dir , 'rj_%s.sh' % (job_uid))
+ args = {
+ 'daligner_script': daligner_script,
+ 'db_prefix': db_prefix,
+ 'config': config,
+ 'job_done': job_done,
+ 'script_fn': script_fn,
+ }
+ support.run_daligner(**args)
+ self.generated_script_fn = script_fn
+
+def read_gathered_las(path):
+ """Return dict of block->[las_paths].
+ For now, these are ws separated on each line of input.
+ """
+ result = collections.defaultdict(list)
+ with open(path) as ifs:
+ for line in ifs:
+ block, las_path = line.split()
+ result[int(block)].append(las_path)
+ #LOG.warning('path={!r}, result={}'.format(
+ # path, pprint.pformat(result)))
+ return result
+
+def task_run_las_merge(self):
+ job_done = fn(self.job_done)
+ gathered_las_fn = fn(self.gathered_las)
+ script = self.parameters['merge_script']
+ job_id = self.parameters['job_id'] # aka 'block'
+ cwd = self.parameters['cwd']
+ mkdir(cwd)
+
+ gathered_dict = read_gathered_las(gathered_las_fn)
+ las_paths = gathered_dict[job_id]
+ for las_path in las_paths:
+ src = os.path.relpath(las_path, cwd)
+ tgt = os.path.join(cwd, os.path.basename(las_path))
+ LOG.debug('symlink {!r} -> {!r}'.format(src, tgt))
+ os.symlink(src, tgt)
+
+ config = self.parameters['config']
+
+ script_dir = os.path.join( cwd )
+ script_fn = os.path.join( script_dir , 'rp_%05d.sh' % (job_id))
+ args = {
+ 'script': script,
+ 'config': config,
+ 'job_done': job_done,
+ 'script_fn': script_fn,
+ }
+ support.run_las_merge(**args)
+ self.generated_script_fn = script_fn
+
+def task_run_consensus(self):
+ las_fn = fn(self.las)
+ out_file_fn = fn(self.out_file)
+ out_done = 'out.done' #fn(self.out_done)
+ job_id = self.parameters['job_id']
+ cwd = self.parameters['cwd']
+ config = self.parameters['config']
+ prefix = self.parameters['prefix']
+ p_id = int(job_id)
+ script_dir = os.path.join( cwd )
+ script_fn = os.path.join( script_dir , 'c_%05d.sh' % (p_id))
+ db_fn = os.path.abspath('{cwd}/../../{prefix}'.format(**locals())) # ASSUMING 2-levels deep. TODO: DB should be an input.
+ #merge_job_dir = os.path.dirname(merged_las_fn)
+ #las_fn = os.path.abspath('{merge_job_dir}/{prefix}.{job_id}.las'.format(**locals()))
+ args = {
+ 'db_fn': db_fn,
+ 'las_fn': las_fn,
+ 'out_file_fn': out_file_fn,
+ 'config': config,
+ 'job_done': out_done,
+ 'script_fn': script_fn,
+ }
+ support.run_consensus(**args)
+ self.generated_script_fn = script_fn
+
+def task_daligner_scatter(self):
+ run_jobs_fn = self.run_jobs_fn
+ db_build_done = self.db_build_done
+ scatter_fn = self.scatter_fn
+ par = self.parameters
+ db_prefix = par['db_prefix']
+ nblock = par['nblock']
+ config = par['config']
+ pread_aln = par['pread_aln'] # False for raw_reads
+ skip_checks = config.get('skip_checks')
+ tasks = []
+ LOG.info('Skip LAcheck after daligner? {}'.format(skip_checks))
+ func = task_run_daligner
+ func_name = '{}.{}'.format(func.__module__, func.__name__)
+ for job_uid, script in bash.scripts_daligner(run_jobs_fn, db_prefix, db_build_done, nblock, pread_aln, skip_checks):
+ job_done_fn = 'job_%s_done' %job_uid
+ parameters = {'daligner_script': script,
+ 'job_uid': job_uid,
+ 'config': config,
+ 'sge_option': config['sge_option_da'],
+ 'db_prefix': db_prefix}
+ inputs = {'db_build_done': db_build_done}
+ outputs = {'job_done': job_done_fn}
+ python_function = func_name,
+ URL = 'task://localhost/d_%s_%s' %(job_uid, db_prefix)
+ daligner_task = {
+ 'inputs': inputs,
+ 'outputs': outputs,
+ 'parameters': parameters,
+ 'python_function': python_function,
+ 'URL': URL,
+ }
+ tasks.append(daligner_task)
+ content = json.dumps(tasks, sort_keys=True, indent=4, separators=(',', ': '))
+ open(scatter_fn, 'w').write(content)
+
+def task_merge_scatter(self):
+ run_jobs_fn = self.run_jobs
+ gathered_las_fn = self.gathered_las
+ scatter_fn = self.scattered
+ par = self.parameters
+ db_prefix = par['db_prefix']
+ config = par['config']
+ func = task_run_las_merge
+ func_name = '{}.{}'.format(func.__module__, func.__name__)
+
+ merge_scripts = bash.scripts_merge(config, db_prefix, run_jobs_fn)
+ tasks = []
+ for p_id, merge_script, merged_las_fn in merge_scripts:
+ parameters = {'merge_script': merge_script,
+ 'job_id': p_id,
+ 'config': config,
+ 'sge_option': config['sge_option_la'],
+ }
+ job_done_fn = 'm_%05d_done' % p_id
+ inputs = {'gathered_las': gathered_las_fn}
+ outputs = {'job_done': job_done_fn, # probably not needed anymore
+ 'merged_las': merged_las_fn,
+ }
+ python_function = func_name,
+ URL = 'task://localhost/m_%05d_%s' %(p_id, db_prefix)
+ task_desc = {
+ 'inputs': inputs,
+ 'outputs': outputs,
+ 'parameters': parameters,
+ 'python_function': python_function,
+ 'URL': URL,
+ }
+ tasks.append(task_desc)
+
+ content = json.dumps(tasks, sort_keys=True, indent=4, separators=(',', ': '))
+ open(scatter_fn, 'w').write(content)
+def task_consensus_scatter(self):
+ scatter_fn = self.scattered
+ gathered_fn = self.gathered
+ wd = os.path.dirname(scatter_fn)
+ par = self.parameters
+ db_prefix = par['db_prefix']
+ config = par['config']
+
+ func = task_run_consensus
+ func_name = '{}.{}'.format(func.__module__, func.__name__)
+ basedir = os.path.dirname(wd) # by convention, since we want to preseve some old paths for now
+
+ p_ids_merge_las = read_gathered_las(gathered_fn)
+ tasks = []
+ for p_id, las_fns in p_ids_merge_las.iteritems():
+ assert len(las_fns) == 1, repr(las_fns)
+ las_fn = las_fns[0] # since we know each merge-task is for a single block
+ cns_label = 'cns_%05d' %int(p_id)
+ #out_done_fn = '%s_done' % cns_label
+ out_file_fn = '%s.fasta' % cns_label
+
+ parameters = {#'cwd': rdir,
+ 'job_id': p_id,
+ 'prefix': db_prefix,
+ 'config': config,
+ 'sge_option': config['sge_option_cns'],
+ }
+ inputs = {'las': las_fn,
+ }
+ outputs = {'out_file': out_file_fn,
+ #'out_done': out_done_fn,
+ }
+ python_function = func_name,
+ URL = 'task://localhost/%s' %cns_label
+ task_desc = {
+ 'inputs': inputs,
+ 'outputs': outputs,
+ 'parameters': parameters,
+ 'python_function': python_function,
+ 'URL': URL,
+ }
+ tasks.append(task_desc)
+ content = json.dumps(tasks, sort_keys=True, indent=4, separators=(',', ': '))
+ open(scatter_fn, 'w').write(content)
+
+def task_daligner_gather(self):
+ """Find all .las leaves so far.
+ """
+ out_dict = self.inputs
+ gathered_fn = fn(self.gathered)
+ nblock = self.parameters['nblock']
+ LOG.debug('nblock=%d, out_dir:\n%s'%(nblock, out_dict))
+ job_rundirs = [os.path.dirname(fn(dal_done)) for dal_done in out_dict.values()]
+ wdir = os.path.dirname(gathered_fn)
+ #mkdir(wdir)
+ with open(gathered_fn, 'w') as ofs:
+ for block, las_path in support.daligner_gather_las(job_rundirs):
+ ofs.write('{} {}\n'.format(block, las_path))
+
+def task_cns_gather(self):
+ fofn_fn = fn(self.preads_fofn)
+ with open(fofn_fn, 'w') as f:
+ for filename in sorted(fn(plf) for plf in self.inputs.itervalues()):
+ print >>f, filename
+
+def task_merge_gather(self):
+ fofn_fn = fn(self.las_fofn)
+ with open(fofn_fn, 'w') as f:
+ # The keys are p_ids.
+ for filename in sorted(fn(plf) for plf in self.inputs.itervalues()):
+ print >>f, filename
+ fopfn_fn = fn(self.las_fopfn)
+ with open(fopfn_fn, 'w') as f:
+ # The keys are p_ids.
+ for filename, p_id in sorted((fn(plf), p_id) for (p_id, plf) in self.inputs.iteritems()):
+ print >>f, p_id, filename
+ #wdir = os.path.dirname(las_fofn_fn)
+ #pread_dir = os.path.dirname(wdir) # by convention, for now
+ # Generate las.fofn in run-dir. # No longer needed!
+ #system('find {}/m_*/ -name "preads.*.las" >| {}'.format(pread_dir, las_fofn_fn))
diff --git a/FALCON/falcon_kit/run_support.py b/FALCON/falcon_kit/run_support.py
index 2c74b7b..a3c56cb 100644
--- a/FALCON/falcon_kit/run_support.py
+++ b/FALCON/falcon_kit/run_support.py
@@ -1,5 +1,6 @@
from . import bash
import ConfigParser
+import contextlib
import json
import logging
import logging.config
@@ -11,7 +12,7 @@ import tempfile
import time
import uuid
-logger = None
+logger = logging.getLogger(__name__)
def _prepend_env_paths(content, names):
"""
@@ -101,6 +102,7 @@ def get_config(config):
config.set(section, name, val)
add('input_fofn', 'NA')
add('target', 'assembly')
+ #add('sge_option', 'NA') # Needed for PBS, but not for everything
add('sge_option_da', 'NA')
add('sge_option_la', 'NA')
add('sge_option_pda', 'NA')
@@ -128,20 +130,33 @@ def parse_config(config_fn):
return config
def get_dict_from_old_falcon_cfg(config):
- section = 'General'
-
job_type = "SGE"
+ section = 'General'
if config.has_option(section, 'job_type'):
job_type = config.get(section, 'job_type')
+ # This was not set in the past, so we must treat is specially.
+ if config.has_option(section, 'sge_option'):
+ sge_option = config.get(section, 'sge_option')
+ else:
+ sge_option = config.get(section, 'sge_option_da')
+
job_queue = "default"
if config.has_option(section, 'job_queue'):
job_queue = config.get(section, 'job_queue')
+ pwatcher_type = 'fs_based'
+ if config.has_option(section, 'pwatcher_type'):
+ pwatcher_type = config.get(section, 'pwatcher_type')
+
default_concurrent_jobs = 8
if config.has_option(section, 'default_concurrent_jobs'):
default_concurrent_jobs = config.getint(section, 'default_concurrent_jobs')
+ pwatcher_directory = 'mypwatcher'
+ if config.has_option(section, 'pwatcher_directory'):
+ pwatcher_directory = config.get(section, 'pwatcher_directory')
+
pa_concurrent_jobs = default_concurrent_jobs
if config.has_option(section, 'pa_concurrent_jobs'):
pa_concurrent_jobs = config.getint(section, 'pa_concurrent_jobs')
@@ -222,11 +237,11 @@ def get_dict_from_old_falcon_cfg(config):
falcon_sense_skip_contained = False
if config.has_option(section, 'falcon_sense_skip_contained'):
- falcon_sense_skip_contained = config.get(section, 'falcon_sense_skip_contained')
- if falcon_sense_skip_contained in ["True", "true", "1"]:
- falcon_sense_skip_contained = True
- else:
- falcon_sense_skip_contained = False
+ falcon_sense_skip_contained = config.getboolean(section, 'falcon_sense_skip_contained')
+
+ falcon_sense_greedy = False
+ if config.has_option(section, 'falcon_sense_greedy'):
+ falcon_sense_greedy = config.getboolean(section, 'falcon_sense_greedy')
genome_size = 0
if config.has_option(section, 'genome_size'):
@@ -301,6 +316,7 @@ def get_dict_from_old_falcon_cfg(config):
"seed_coverage" : seed_coverage,
"length_cutoff" : length_cutoff,
"length_cutoff_pr" : length_cutoff_pr,
+ "sge_option": sge_option,
"sge_option_da": config.get(section, 'sge_option_da'),
"sge_option_la": config.get(section, 'sge_option_la'),
"sge_option_pda": config.get(section, 'sge_option_pda'),
@@ -319,8 +335,11 @@ def get_dict_from_old_falcon_cfg(config):
"fc_ovlp_to_graph_option": fc_ovlp_to_graph_option,
"falcon_sense_option": falcon_sense_option,
"falcon_sense_skip_contained": falcon_sense_skip_contained,
+ "falcon_sense_greedy": falcon_sense_greedy,
"stop_all_jobs_on_failure": stop_all_jobs_on_failure,
"use_tmpdir": use_tmpdir,
+ "pwatcher_type": pwatcher_type,
+ "pwatcher_directory": pwatcher_directory,
TEXT_FILE_BUSY: bash.BUG_avoid_Text_file_busy,
}
provided = dict(config.items(section))
@@ -401,11 +420,23 @@ def setup_logger(logging_config_fn):
return logger
+ at contextlib.contextmanager
+def cd(newdir):
+ prevdir = os.getcwd()
+ logger.debug('CD: %r <- %r' %(newdir, prevdir))
+ os.chdir(os.path.expanduser(newdir))
+ try:
+ yield
+ finally:
+ logger.debug('CD: %r -> %r' %(newdir, prevdir))
+ os.chdir(prevdir)
+
def make_fofn_abs(i_fofn_fn, o_fofn_fn):
- """Copy i_fofn to o_fofn, but with relative filenames expanded for CWD.
+ """Copy i_fofn to o_fofn, but with relative filenames expanded for the dir of i_fofn.
"""
- assert os.path.abspath(o_fofn_fn) != os.path.abspath(i_fofn_fn)
+ assert os.path.abspath(o_fofn_fn) != os.path.abspath(i_fofn_fn), '{!r} != {!r}'.format(o_fofn_fn, i_fofn_fn)
with open(i_fofn_fn) as ifs, open(o_fofn_fn, 'w') as ofs:
+ with cd(os.path.dirname(i_fofn_fn)):
for line in ifs:
ifn = line.strip()
if not ifn: continue
@@ -459,31 +490,31 @@ def get_length_cutoff(length_cutoff, fn):
def build_rdb(input_fofn_fn, config, job_done, script_fn, run_jobs_fn):
run_jobs_fn = os.path.basename(run_jobs_fn)
script = bash.script_build_rdb(config, input_fofn_fn, run_jobs_fn)
- bash.get_write_script_and_wrapper(config)(script, script_fn, job_done)
+ bash.write_script(script, script_fn, job_done)
def build_pdb(input_fofn_fn, config, job_done, script_fn, run_jobs_fn):
run_jobs_fn = os.path.basename(run_jobs_fn)
script = bash.script_build_pdb(config, input_fofn_fn, run_jobs_fn)
- bash.get_write_script_and_wrapper(config)(script, script_fn, job_done)
+ bash.write_script(script, script_fn, job_done)
-def run_db2falcon(config, job_done, script_fn):
- script = bash.script_run_DB2Falcon(config)
- bash.get_write_script_and_wrapper(config)(script, script_fn, job_done)
+def run_db2falcon(config, preads4falcon_fn, preads_db, job_done, script_fn):
+ script = bash.script_run_DB2Falcon(config, preads4falcon_fn, preads_db)
+ bash.write_script(script, script_fn, job_done)
def run_falcon_asm(config, las_fofn_fn, preads4falcon_fasta_fn, db_file_fn, job_done, script_fn):
script = bash.script_run_falcon_asm(config, las_fofn_fn, preads4falcon_fasta_fn, db_file_fn)
- bash.get_write_script_and_wrapper(config)(script, script_fn, job_done)
+ bash.write_script(script, script_fn, job_done)
def run_report_pre_assembly(i_raw_reads_db_fn, i_preads_fofn_fn, genome_length, length_cutoff, o_json_fn, job_done, script_fn):
script = bash.script_run_report_pre_assembly(i_raw_reads_db_fn, i_preads_fofn_fn, genome_length, length_cutoff, o_json_fn)
bash.write_script_and_wrapper_top(script, script_fn, job_done)
def run_daligner(daligner_script, db_prefix, config, job_done, script_fn):
- bash.get_write_script_and_wrapper(config)(daligner_script, script_fn, job_done)
+ bash.write_script(daligner_script, script_fn, job_done)
def run_las_merge(script, job_done, config, script_fn):
- bash.get_write_script_and_wrapper(config)(script, script_fn, job_done)
+ bash.write_script(script, script_fn, job_done)
def run_consensus(db_fn, las_fn, out_file_fn, config, job_done, script_fn):
script = bash.script_run_consensus(config, db_fn, las_fn, os.path.basename(out_file_fn))
- bash.get_write_script_and_wrapper(config)(script, script_fn, job_done)
+ bash.write_script(script, script_fn, job_done)
diff --git a/FALCON/falcon_kit/stats_preassembly.py b/FALCON/falcon_kit/stats_preassembly.py
index 25a4e84..f322b7f 100644
--- a/FALCON/falcon_kit/stats_preassembly.py
+++ b/FALCON/falcon_kit/stats_preassembly.py
@@ -126,9 +126,10 @@ def metric_fragmentation(preads_fofn):
def metric_truncation(db, preads_fofn):
# https://jira.pacificbiosciences.com/browse/SAT-105
fastas = abs_filenames(preads_fofn)
- call = """perl -e 'while (<>) { if ( m{>[^/]+/0*(\d+)\d/(\d+)_(\d+)} ) { $lengths{$1} += ($3 - $2); } }; while (my ($k, $v) = each %%lengths) { print "$k $v\n"; };' %s""" %(' '.join(fastas))
+ call = """perl -e 'while (<>) { if ( m{>[^/]+/0*(\d+)\d/(\d+)_(\d+)} ) { $lengths{(1 + $1)} += ($3 - $2); } }; while (my ($k, $v) = each %%lengths) { print "$k $v\n"; };' %s""" %(' '.join(fastas))
+ # The +1 is because of the DBdump readids start at 1, but these start at 0.
length_pairs_output = syscall(call)
- call = 'DBdump -h {}'.format(db)
+ call = 'DBdump -rh {}'.format(db)
dbdump_output = syscall(call)
return functional.calc_metric_truncation(dbdump_output, length_pairs_output)
diff --git a/FALCON/setup.py b/FALCON/setup.py
index 5195762..b6f893c 100755
--- a/FALCON/setup.py
+++ b/FALCON/setup.py
@@ -54,7 +54,6 @@ setup(name='falcon_kit',
'fc_calc_cutoff=falcon_kit.mains.calc_cutoff:main',
'fc_run=falcon_kit.mains.run1:main',
'fc_run1=falcon_kit.mains.run1:main',
- 'fc_run0=falcon_kit.mains.run0:main',
'fc_fasta2fasta=falcon_kit.mains.fasta2fasta:main',
'fc_fetch_reads=falcon_kit.mains.fetch_reads:main',
'fc_get_read_ctg_map=falcon_kit.mains.get_read_ctg_map:main',
diff --git a/FALCON/test/se161.sh b/FALCON/test/se161.sh
new file mode 100644
index 0000000..2f14ed9
--- /dev/null
+++ b/FALCON/test/se161.sh
@@ -0,0 +1,836 @@
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.92 raw_reads.1 raw_reads.2 raw_reads.3 raw_reads.4 raw_reads.5 raw_reads.6 raw_reads.7 raw_reads.8 raw_reads.9 raw_reads.10 raw_reads.11 raw_reads.12 raw_reads.13 raw_reads.14 raw_reads.15 raw_reads.16 raw_reads.17 raw_reads.18 raw_reads.19 raw_reads.20 raw_reads.21 raw_reads.22 raw_reads.23
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.1.raw_reads.92.C0 raw_reads.1.raw_reads.92.N0 raw_reads.1.raw_reads.92.C1 raw_reads.1.raw_reads.92.N1 raw_reads.1.raw_reads.92.C2 raw_reads.1.raw_reads.92.N2 raw_reads.1.raw_reads.92.C3 raw_reads.1.raw_reads.92.N3 && LAmerge -v L1.1.92 raw_reads.1.raw_reads.92.C0.S raw_reads.1.raw_reads.92.N0.S raw_reads.1.raw_reads.92.C1.S raw_reads.1.raw_reads.92.N1.S raw_reads.1.raw_reads.92.C2.S raw_reads.1.raw_reads.92.N2.S raw_reads.1.raw_reads.92.C3.S raw_reads.1.raw_reads.92.N3.S
+LAsort -v raw_reads.2.raw_reads.92.C0 raw_reads.2.raw_reads.92.N0 raw_reads.2.raw_reads.92.C1 raw_reads.2.raw_reads.92.N1 raw_reads.2.raw_reads.92.C2 raw_reads.2.raw_reads.92.N2 raw_reads.2.raw_reads.92.C3 raw_reads.2.raw_reads.92.N3 && LAmerge -v L1.2.92 raw_reads.2.raw_reads.92.C0.S raw_reads.2.raw_reads.92.N0.S raw_reads.2.raw_reads.92.C1.S raw_reads.2.raw_reads.92.N1.S raw_reads.2.raw_reads.92.C2.S raw_reads.2.raw_reads.92.N2.S raw_reads.2.raw_reads.92.C3.S raw_reads.2.raw_reads.92.N3.S
+LAsort -v raw_reads.3.raw_reads.92.C0 raw_reads.3.raw_reads.92.N0 raw_reads.3.raw_reads.92.C1 raw_reads.3.raw_reads.92.N1 raw_reads.3.raw_reads.92.C2 raw_reads.3.raw_reads.92.N2 raw_reads.3.raw_reads.92.C3 raw_reads.3.raw_reads.92.N3 && LAmerge -v L1.3.92 raw_reads.3.raw_reads.92.C0.S raw_reads.3.raw_reads.92.N0.S raw_reads.3.raw_reads.92.C1.S raw_reads.3.raw_reads.92.N1.S raw_reads.3.raw_reads.92.C2.S raw_reads.3.raw_reads.92.N2.S raw_reads.3.raw_reads.92.C3.S raw_reads.3.raw_reads.92.N3.S
+LAsort -v raw_reads.4.raw_reads.92.C0 raw_reads.4.raw_reads.92.N0 raw_reads.4.raw_reads.92.C1 raw_reads.4.raw_reads.92.N1 raw_reads.4.raw_reads.92.C2 raw_reads.4.raw_reads.92.N2 raw_reads.4.raw_reads.92.C3 raw_reads.4.raw_reads.92.N3 && LAmerge -v L1.4.92 raw_reads.4.raw_reads.92.C0.S raw_reads.4.raw_reads.92.N0.S raw_reads.4.raw_reads.92.C1.S raw_reads.4.raw_reads.92.N1.S raw_reads.4.raw_reads.92.C2.S raw_reads.4.raw_reads.92.N2.S raw_reads.4.raw_reads.92.C3.S raw_reads.4.raw_reads.92.N3.S
+LAsort -v raw_reads.5.raw_reads.92.C0 raw_reads.5.raw_reads.92.N0 raw_reads.5.raw_reads.92.C1 raw_reads.5.raw_reads.92.N1 raw_reads.5.raw_reads.92.C2 raw_reads.5.raw_reads.92.N2 raw_reads.5.raw_reads.92.C3 raw_reads.5.raw_reads.92.N3 && LAmerge -v L1.5.92 raw_reads.5.raw_reads.92.C0.S raw_reads.5.raw_reads.92.N0.S raw_reads.5.raw_reads.92.C1.S raw_reads.5.raw_reads.92.N1.S raw_reads.5.raw_reads.92.C2.S raw_reads.5.raw_reads.92.N2.S raw_reads.5.raw_reads.92.C3.S raw_reads.5.raw_reads.92.N3.S
+LAsort -v raw_reads.6.raw_reads.92.C0 raw_reads.6.raw_reads.92.N0 raw_reads.6.raw_reads.92.C1 raw_reads.6.raw_reads.92.N1 raw_reads.6.raw_reads.92.C2 raw_reads.6.raw_reads.92.N2 raw_reads.6.raw_reads.92.C3 raw_reads.6.raw_reads.92.N3 && LAmerge -v L1.6.92 raw_reads.6.raw_reads.92.C0.S raw_reads.6.raw_reads.92.N0.S raw_reads.6.raw_reads.92.C1.S raw_reads.6.raw_reads.92.N1.S raw_reads.6.raw_reads.92.C2.S raw_reads.6.raw_reads.92.N2.S raw_reads.6.raw_reads.92.C3.S raw_reads.6.raw_reads.92.N3.S
+LAsort -v raw_reads.7.raw_reads.92.C0 raw_reads.7.raw_reads.92.N0 raw_reads.7.raw_reads.92.C1 raw_reads.7.raw_reads.92.N1 raw_reads.7.raw_reads.92.C2 raw_reads.7.raw_reads.92.N2 raw_reads.7.raw_reads.92.C3 raw_reads.7.raw_reads.92.N3 && LAmerge -v L1.7.92 raw_reads.7.raw_reads.92.C0.S raw_reads.7.raw_reads.92.N0.S raw_reads.7.raw_reads.92.C1.S raw_reads.7.raw_reads.92.N1.S raw_reads.7.raw_reads.92.C2.S raw_reads.7.raw_reads.92.N2.S raw_reads.7.raw_reads.92.C3.S raw_reads.7.raw_reads.92.N3.S
+LAsort -v raw_reads.8.raw_reads.92.C0 raw_reads.8.raw_reads.92.N0 raw_reads.8.raw_reads.92.C1 raw_reads.8.raw_reads.92.N1 raw_reads.8.raw_reads.92.C2 raw_reads.8.raw_reads.92.N2 raw_reads.8.raw_reads.92.C3 raw_reads.8.raw_reads.92.N3 && LAmerge -v L1.8.92 raw_reads.8.raw_reads.92.C0.S raw_reads.8.raw_reads.92.N0.S raw_reads.8.raw_reads.92.C1.S raw_reads.8.raw_reads.92.N1.S raw_reads.8.raw_reads.92.C2.S raw_reads.8.raw_reads.92.N2.S raw_reads.8.raw_reads.92.C3.S raw_reads.8.raw_reads.92.N3.S
+LAsort -v raw_reads.9.raw_reads.92.C0 raw_reads.9.raw_reads.92.N0 raw_reads.9.raw_reads.92.C1 raw_reads.9.raw_reads.92.N1 raw_reads.9.raw_reads.92.C2 raw_reads.9.raw_reads.92.N2 raw_reads.9.raw_reads.92.C3 raw_reads.9.raw_reads.92.N3 && LAmerge -v L1.9.92 raw_reads.9.raw_reads.92.C0.S raw_reads.9.raw_reads.92.N0.S raw_reads.9.raw_reads.92.C1.S raw_reads.9.raw_reads.92.N1.S raw_reads.9.raw_reads.92.C2.S raw_reads.9.raw_reads.92.N2.S raw_reads.9.raw_reads.92.C3.S raw_reads.9.raw_reads.92.N3.S
+LAsort -v raw_reads.10.raw_reads.92.C0 raw_reads.10.raw_reads.92.N0 raw_reads.10.raw_reads.92.C1 raw_reads.10.raw_reads.92.N1 raw_reads.10.raw_reads.92.C2 raw_reads.10.raw_reads.92.N2 raw_reads.10.raw_reads.92.C3 raw_reads.10.raw_reads.92.N3 && LAmerge -v L1.10.92 raw_reads.10.raw_reads.92.C0.S raw_reads.10.raw_reads.92.N0.S raw_reads.10.raw_reads.92.C1.S raw_reads.10.raw_reads.92.N1.S raw_reads.10.raw_reads.92.C2.S raw_reads.10.raw_reads.92.N2.S raw_reads.10.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.11.raw_reads.92.C0 raw_reads.11.raw_reads.92.N0 raw_reads.11.raw_reads.92.C1 raw_reads.11.raw_reads.92.N1 raw_reads.11.raw_reads.92.C2 raw_reads.11.raw_reads.92.N2 raw_reads.11.raw_reads.92.C3 raw_reads.11.raw_reads.92.N3 && LAmerge -v L1.11.92 raw_reads.11.raw_reads.92.C0.S raw_reads.11.raw_reads.92.N0.S raw_reads.11.raw_reads.92.C1.S raw_reads.11.raw_reads.92.N1.S raw_reads.11.raw_reads.92.C2.S raw_reads.11.raw_reads.92.N2.S raw_reads.11.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.12.raw_reads.92.C0 raw_reads.12.raw_reads.92.N0 raw_reads.12.raw_reads.92.C1 raw_reads.12.raw_reads.92.N1 raw_reads.12.raw_reads.92.C2 raw_reads.12.raw_reads.92.N2 raw_reads.12.raw_reads.92.C3 raw_reads.12.raw_reads.92.N3 && LAmerge -v L1.12.92 raw_reads.12.raw_reads.92.C0.S raw_reads.12.raw_reads.92.N0.S raw_reads.12.raw_reads.92.C1.S raw_reads.12.raw_reads.92.N1.S raw_reads.12.raw_reads.92.C2.S raw_reads.12.raw_reads.92.N2.S raw_reads.12.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.13.raw_reads.92.C0 raw_reads.13.raw_reads.92.N0 raw_reads.13.raw_reads.92.C1 raw_reads.13.raw_reads.92.N1 raw_reads.13.raw_reads.92.C2 raw_reads.13.raw_reads.92.N2 raw_reads.13.raw_reads.92.C3 raw_reads.13.raw_reads.92.N3 && LAmerge -v L1.13.92 raw_reads.13.raw_reads.92.C0.S raw_reads.13.raw_reads.92.N0.S raw_reads.13.raw_reads.92.C1.S raw_reads.13.raw_reads.92.N1.S raw_reads.13.raw_reads.92.C2.S raw_reads.13.raw_reads.92.N2.S raw_reads.13.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.14.raw_reads.92.C0 raw_reads.14.raw_reads.92.N0 raw_reads.14.raw_reads.92.C1 raw_reads.14.raw_reads.92.N1 raw_reads.14.raw_reads.92.C2 raw_reads.14.raw_reads.92.N2 raw_reads.14.raw_reads.92.C3 raw_reads.14.raw_reads.92.N3 && LAmerge -v L1.14.92 raw_reads.14.raw_reads.92.C0.S raw_reads.14.raw_reads.92.N0.S raw_reads.14.raw_reads.92.C1.S raw_reads.14.raw_reads.92.N1.S raw_reads.14.raw_reads.92.C2.S raw_reads.14.raw_reads.92.N2.S raw_reads.14.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.15.raw_reads.92.C0 raw_reads.15.raw_reads.92.N0 raw_reads.15.raw_reads.92.C1 raw_reads.15.raw_reads.92.N1 raw_reads.15.raw_reads.92.C2 raw_reads.15.raw_reads.92.N2 raw_reads.15.raw_reads.92.C3 raw_reads.15.raw_reads.92.N3 && LAmerge -v L1.15.92 raw_reads.15.raw_reads.92.C0.S raw_reads.15.raw_reads.92.N0.S raw_reads.15.raw_reads.92.C1.S raw_reads.15.raw_reads.92.N1.S raw_reads.15.raw_reads.92.C2.S raw_reads.15.raw_reads.92.N2.S raw_reads.15.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.16.raw_reads.92.C0 raw_reads.16.raw_reads.92.N0 raw_reads.16.raw_reads.92.C1 raw_reads.16.raw_reads.92.N1 raw_reads.16.raw_reads.92.C2 raw_reads.16.raw_reads.92.N2 raw_reads.16.raw_reads.92.C3 raw_reads.16.raw_reads.92.N3 && LAmerge -v L1.16.92 raw_reads.16.raw_reads.92.C0.S raw_reads.16.raw_reads.92.N0.S raw_reads.16.raw_reads.92.C1.S raw_reads.16.raw_reads.92.N1.S raw_reads.16.raw_reads.92.C2.S raw_reads.16.raw_reads.92.N2.S raw_reads.16.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.17.raw_reads.92.C0 raw_reads.17.raw_reads.92.N0 raw_reads.17.raw_reads.92.C1 raw_reads.17.raw_reads.92.N1 raw_reads.17.raw_reads.92.C2 raw_reads.17.raw_reads.92.N2 raw_reads.17.raw_reads.92.C3 raw_reads.17.raw_reads.92.N3 && LAmerge -v L1.17.92 raw_reads.17.raw_reads.92.C0.S raw_reads.17.raw_reads.92.N0.S raw_reads.17.raw_reads.92.C1.S raw_reads.17.raw_reads.92.N1.S raw_reads.17.raw_reads.92.C2.S raw_reads.17.raw_reads.92.N2.S raw_reads.17.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.18.raw_reads.92.C0 raw_reads.18.raw_reads.92.N0 raw_reads.18.raw_reads.92.C1 raw_reads.18.raw_reads.92.N1 raw_reads.18.raw_reads.92.C2 raw_reads.18.raw_reads.92.N2 raw_reads.18.raw_reads.92.C3 raw_reads.18.raw_reads.92.N3 && LAmerge -v L1.18.92 raw_reads.18.raw_reads.92.C0.S raw_reads.18.raw_reads.92.N0.S raw_reads.18.raw_reads.92.C1.S raw_reads.18.raw_reads.92.N1.S raw_reads.18.raw_reads.92.C2.S raw_reads.18.raw_reads.92.N2.S raw_reads.18.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.19.raw_reads.92.C0 raw_reads.19.raw_reads.92.N0 raw_reads.19.raw_reads.92.C1 raw_reads.19.raw_reads.92.N1 raw_reads.19.raw_reads.92.C2 raw_reads.19.raw_reads.92.N2 raw_reads.19.raw_reads.92.C3 raw_reads.19.raw_reads.92.N3 && LAmerge -v L1.19.92 raw_reads.19.raw_reads.92.C0.S raw_reads.19.raw_reads.92.N0.S raw_reads.19.raw_reads.92.C1.S raw_reads.19.raw_reads.92.N1.S raw_reads.19.raw_reads.92.C2.S raw_reads.19.raw_reads.92.N2.S raw_reads.19.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.20.raw_reads.92.C0 raw_reads.20.raw_reads.92.N0 raw_reads.20.raw_reads.92.C1 raw_reads.20.raw_reads.92.N1 raw_reads.20.raw_reads.92.C2 raw_reads.20.raw_reads.92.N2 raw_reads.20.raw_reads.92.C3 raw_reads.20.raw_reads.92.N3 && LAmerge -v L1.20.92 raw_reads.20.raw_reads.92.C0.S raw_reads.20.raw_reads.92.N0.S raw_reads.20.raw_reads.92.C1.S raw_reads.20.raw_reads.92.N1.S raw_reads.20.raw_reads.92.C2.S raw_reads.20.raw_reads.92.N2.S raw_reads.20.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.21.raw_reads.92.C0 raw_reads.21.raw_reads.92.N0 raw_reads.21.raw_reads.92.C1 raw_reads.21.raw_reads.92.N1 raw_reads.21.raw_reads.92.C2 raw_reads.21.raw_reads.92.N2 raw_reads.21.raw_reads.92.C3 raw_reads.21.raw_reads.92.N3 && LAmerge -v L1.21.92 raw_reads.21.raw_reads.92.C0.S raw_reads.21.raw_reads.92.N0.S raw_reads.21.raw_reads.92.C1.S raw_reads.21.raw_reads.92.N1.S raw_reads.21.raw_reads.92.C2.S raw_reads.21.raw_reads.92.N2.S raw_reads.21.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.22.raw_reads.92.C0 raw_reads.22.raw_reads.92.N0 raw_reads.22.raw_reads.92.C1 raw_reads.22.raw_reads.92.N1 raw_reads.22.raw_reads.92.C2 raw_reads.22.raw_reads.92.N2 raw_reads.22.raw_reads.92.C3 raw_reads.22.raw_reads.92.N3 && LAmerge -v L1.22.92 raw_reads.22.raw_reads.92.C0.S raw_reads.22.raw_reads.92.N0.S raw_reads.22.raw_reads.92.C1.S raw_reads.22.raw_reads.92.N1.S raw_reads.22.raw_reads.92.C2.S raw_reads.22.raw_reads.92.N2.S raw_reads.22.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.23.raw_reads.92.C0 raw_reads.23.raw_reads.92.N0 raw_reads.23.raw_reads.92.C1 raw_reads.23.raw_reads.92.N1 raw_reads.23.raw_reads.92.C2 raw_reads.23.raw_reads.92.N2 raw_reads.23.raw_reads.92.C3 raw_reads.23.raw_reads.92.N3 && LAmerge -v L1.23.92 raw_reads.23.raw_reads.92.C0.S raw_reads.23.raw_reads.92.N0.S raw_reads.23.raw_reads.92.C1.S raw_reads.23.raw_reads.92.N1.S raw_reads.23.raw_reads.92.C2.S raw_reads.23.raw_reads.92.N2.S raw_reads.23.raw_reads.92.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.1.C0 raw_reads.92.raw_reads.1.N0 raw_reads.92.raw_reads.1.C1 raw_reads.92.raw_reads.1.N1 raw_reads.92.raw_reads.1.C2 raw_reads.92.raw_reads.1.N2 raw_reads.92.raw_reads.1.C3 raw_reads.92.raw_reads.1.N3 && LAmerge -v L1.92.1 raw_reads.92.raw_reads.1.C0.S raw_reads.92.raw_reads.1.N0.S raw_reads.92.raw_reads.1.C1.S raw_reads.92.raw_reads.1.N1.S raw_reads.92.raw_reads.1.C2.S raw_reads.92.raw_reads.1.N2.S raw_reads.92.raw_reads.1.C3.S raw_reads.92.raw_reads.1.N3.S
+LAsort -v raw_reads.92.raw_reads.2.C0 raw_reads.92.raw_reads.2.N0 raw_reads.92.raw_reads.2.C1 raw_reads.92.raw_reads.2.N1 raw_reads.92.raw_reads.2.C2 raw_reads.92.raw_reads.2.N2 raw_reads.92.raw_reads.2.C3 raw_reads.92.raw_reads.2.N3 && LAmerge -v L1.92.2 raw_reads.92.raw_reads.2.C0.S raw_reads.92.raw_reads.2.N0.S raw_reads.92.raw_reads.2.C1.S raw_reads.92.raw_reads.2.N1.S raw_reads.92.raw_reads.2.C2.S raw_reads.92.raw_reads.2.N2.S raw_reads.92.raw_reads.2.C3.S raw_reads.92.raw_reads.2.N3.S
+LAsort -v raw_reads.92.raw_reads.3.C0 raw_reads.92.raw_reads.3.N0 raw_reads.92.raw_reads.3.C1 raw_reads.92.raw_reads.3.N1 raw_reads.92.raw_reads.3.C2 raw_reads.92.raw_reads.3.N2 raw_reads.92.raw_reads.3.C3 raw_reads.92.raw_reads.3.N3 && LAmerge -v L1.92.3 raw_reads.92.raw_reads.3.C0.S raw_reads.92.raw_reads.3.N0.S raw_reads.92.raw_reads.3.C1.S raw_reads.92.raw_reads.3.N1.S raw_reads.92.raw_reads.3.C2.S raw_reads.92.raw_reads.3.N2.S raw_reads.92.raw_reads.3.C3.S raw_reads.92.raw_reads.3.N3.S
+LAsort -v raw_reads.92.raw_reads.4.C0 raw_reads.92.raw_reads.4.N0 raw_reads.92.raw_reads.4.C1 raw_reads.92.raw_reads.4.N1 raw_reads.92.raw_reads.4.C2 raw_reads.92.raw_reads.4.N2 raw_reads.92.raw_reads.4.C3 raw_reads.92.raw_reads.4.N3 && LAmerge -v L1.92.4 raw_reads.92.raw_reads.4.C0.S raw_reads.92.raw_reads.4.N0.S raw_reads.92.raw_reads.4.C1.S raw_reads.92.raw_reads.4.N1.S raw_reads.92.raw_reads.4.C2.S raw_reads.92.raw_reads.4.N2.S raw_reads.92.raw_reads.4.C3.S raw_reads.92.raw_reads.4.N3.S
+LAsort -v raw_reads.92.raw_reads.5.C0 raw_reads.92.raw_reads.5.N0 raw_reads.92.raw_reads.5.C1 raw_reads.92.raw_reads.5.N1 raw_reads.92.raw_reads.5.C2 raw_reads.92.raw_reads.5.N2 raw_reads.92.raw_reads.5.C3 raw_reads.92.raw_reads.5.N3 && LAmerge -v L1.92.5 raw_reads.92.raw_reads.5.C0.S raw_reads.92.raw_reads.5.N0.S raw_reads.92.raw_reads.5.C1.S raw_reads.92.raw_reads.5.N1.S raw_reads.92.raw_reads.5.C2.S raw_reads.92.raw_reads.5.N2.S raw_reads.92.raw_reads.5.C3.S raw_reads.92.raw_reads.5.N3.S
+LAsort -v raw_reads.92.raw_reads.6.C0 raw_reads.92.raw_reads.6.N0 raw_reads.92.raw_reads.6.C1 raw_reads.92.raw_reads.6.N1 raw_reads.92.raw_reads.6.C2 raw_reads.92.raw_reads.6.N2 raw_reads.92.raw_reads.6.C3 raw_reads.92.raw_reads.6.N3 && LAmerge -v L1.92.6 raw_reads.92.raw_reads.6.C0.S raw_reads.92.raw_reads.6.N0.S raw_reads.92.raw_reads.6.C1.S raw_reads.92.raw_reads.6.N1.S raw_reads.92.raw_reads.6.C2.S raw_reads.92.raw_reads.6.N2.S raw_reads.92.raw_reads.6.C3.S raw_reads.92.raw_reads.6.N3.S
+LAsort -v raw_reads.92.raw_reads.7.C0 raw_reads.92.raw_reads.7.N0 raw_reads.92.raw_reads.7.C1 raw_reads.92.raw_reads.7.N1 raw_reads.92.raw_reads.7.C2 raw_reads.92.raw_reads.7.N2 raw_reads.92.raw_reads.7.C3 raw_reads.92.raw_reads.7.N3 && LAmerge -v L1.92.7 raw_reads.92.raw_reads.7.C0.S raw_reads.92.raw_reads.7.N0.S raw_reads.92.raw_reads.7.C1.S raw_reads.92.raw_reads.7.N1.S raw_reads.92.raw_reads.7.C2.S raw_reads.92.raw_reads.7.N2.S raw_reads.92.raw_reads.7.C3.S raw_reads.92.raw_reads.7.N3.S
+LAsort -v raw_reads.92.raw_reads.8.C0 raw_reads.92.raw_reads.8.N0 raw_reads.92.raw_reads.8.C1 raw_reads.92.raw_reads.8.N1 raw_reads.92.raw_reads.8.C2 raw_reads.92.raw_reads.8.N2 raw_reads.92.raw_reads.8.C3 raw_reads.92.raw_reads.8.N3 && LAmerge -v L1.92.8 raw_reads.92.raw_reads.8.C0.S raw_reads.92.raw_reads.8.N0.S raw_reads.92.raw_reads.8.C1.S raw_reads.92.raw_reads.8.N1.S raw_reads.92.raw_reads.8.C2.S raw_reads.92.raw_reads.8.N2.S raw_reads.92.raw_reads.8.C3.S raw_reads.92.raw_reads.8.N3.S
+LAsort -v raw_reads.92.raw_reads.9.C0 raw_reads.92.raw_reads.9.N0 raw_reads.92.raw_reads.9.C1 raw_reads.92.raw_reads.9.N1 raw_reads.92.raw_reads.9.C2 raw_reads.92.raw_reads.9.N2 raw_reads.92.raw_reads.9.C3 raw_reads.92.raw_reads.9.N3 && LAmerge -v L1.92.9 raw_reads.92.raw_reads.9.C0.S raw_reads.92.raw_reads.9.N0.S raw_reads.92.raw_reads.9.C1.S raw_reads.92.raw_reads.9.N1.S raw_reads.92.raw_reads.9.C2.S raw_reads.92.raw_reads.9.N2.S raw_reads.92.raw_reads.9.C3.S raw_reads.92.raw_reads.9.N3.S
+LAsort -v raw_reads.92.raw_reads.10.C0 raw_reads.92.raw_reads.10.N0 raw_reads.92.raw_reads.10.C1 raw_reads.92.raw_reads.10.N1 raw_reads.92.raw_reads.10.C2 raw_reads.92.raw_reads.10.N2 raw_reads.92.raw_reads.10.C3 raw_reads.92.raw_reads.10.N3 && LAmerge -v L1.92.10 raw_reads.92.raw_reads.10.C0.S raw_reads.92.raw_reads.10.N0.S raw_reads.92.raw_reads.10.C1.S raw_reads.92.raw_reads.10.N1.S raw_reads.92.raw_reads.10.C2.S raw_reads.92.raw_reads.10.N2.S raw_reads.92.raw_reads.10.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.11.C0 raw_reads.92.raw_reads.11.N0 raw_reads.92.raw_reads.11.C1 raw_reads.92.raw_reads.11.N1 raw_reads.92.raw_reads.11.C2 raw_reads.92.raw_reads.11.N2 raw_reads.92.raw_reads.11.C3 raw_reads.92.raw_reads.11.N3 && LAmerge -v L1.92.11 raw_reads.92.raw_reads.11.C0.S raw_reads.92.raw_reads.11.N0.S raw_reads.92.raw_reads.11.C1.S raw_reads.92.raw_reads.11.N1.S raw_reads.92.raw_reads.11.C2.S raw_reads.92.raw_reads.11.N2.S raw_reads.92.raw_reads.11.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.12.C0 raw_reads.92.raw_reads.12.N0 raw_reads.92.raw_reads.12.C1 raw_reads.92.raw_reads.12.N1 raw_reads.92.raw_reads.12.C2 raw_reads.92.raw_reads.12.N2 raw_reads.92.raw_reads.12.C3 raw_reads.92.raw_reads.12.N3 && LAmerge -v L1.92.12 raw_reads.92.raw_reads.12.C0.S raw_reads.92.raw_reads.12.N0.S raw_reads.92.raw_reads.12.C1.S raw_reads.92.raw_reads.12.N1.S raw_reads.92.raw_reads.12.C2.S raw_reads.92.raw_reads.12.N2.S raw_reads.92.raw_reads.12.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.13.C0 raw_reads.92.raw_reads.13.N0 raw_reads.92.raw_reads.13.C1 raw_reads.92.raw_reads.13.N1 raw_reads.92.raw_reads.13.C2 raw_reads.92.raw_reads.13.N2 raw_reads.92.raw_reads.13.C3 raw_reads.92.raw_reads.13.N3 && LAmerge -v L1.92.13 raw_reads.92.raw_reads.13.C0.S raw_reads.92.raw_reads.13.N0.S raw_reads.92.raw_reads.13.C1.S raw_reads.92.raw_reads.13.N1.S raw_reads.92.raw_reads.13.C2.S raw_reads.92.raw_reads.13.N2.S raw_reads.92.raw_reads.13.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.14.C0 raw_reads.92.raw_reads.14.N0 raw_reads.92.raw_reads.14.C1 raw_reads.92.raw_reads.14.N1 raw_reads.92.raw_reads.14.C2 raw_reads.92.raw_reads.14.N2 raw_reads.92.raw_reads.14.C3 raw_reads.92.raw_reads.14.N3 && LAmerge -v L1.92.14 raw_reads.92.raw_reads.14.C0.S raw_reads.92.raw_reads.14.N0.S raw_reads.92.raw_reads.14.C1.S raw_reads.92.raw_reads.14.N1.S raw_reads.92.raw_reads.14.C2.S raw_reads.92.raw_reads.14.N2.S raw_reads.92.raw_reads.14.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.15.C0 raw_reads.92.raw_reads.15.N0 raw_reads.92.raw_reads.15.C1 raw_reads.92.raw_reads.15.N1 raw_reads.92.raw_reads.15.C2 raw_reads.92.raw_reads.15.N2 raw_reads.92.raw_reads.15.C3 raw_reads.92.raw_reads.15.N3 && LAmerge -v L1.92.15 raw_reads.92.raw_reads.15.C0.S raw_reads.92.raw_reads.15.N0.S raw_reads.92.raw_reads.15.C1.S raw_reads.92.raw_reads.15.N1.S raw_reads.92.raw_reads.15.C2.S raw_reads.92.raw_reads.15.N2.S raw_reads.92.raw_reads.15.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.16.C0 raw_reads.92.raw_reads.16.N0 raw_reads.92.raw_reads.16.C1 raw_reads.92.raw_reads.16.N1 raw_reads.92.raw_reads.16.C2 raw_reads.92.raw_reads.16.N2 raw_reads.92.raw_reads.16.C3 raw_reads.92.raw_reads.16.N3 && LAmerge -v L1.92.16 raw_reads.92.raw_reads.16.C0.S raw_reads.92.raw_reads.16.N0.S raw_reads.92.raw_reads.16.C1.S raw_reads.92.raw_reads.16.N1.S raw_reads.92.raw_reads.16.C2.S raw_reads.92.raw_reads.16.N2.S raw_reads.92.raw_reads.16.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.17.C0 raw_reads.92.raw_reads.17.N0 raw_reads.92.raw_reads.17.C1 raw_reads.92.raw_reads.17.N1 raw_reads.92.raw_reads.17.C2 raw_reads.92.raw_reads.17.N2 raw_reads.92.raw_reads.17.C3 raw_reads.92.raw_reads.17.N3 && LAmerge -v L1.92.17 raw_reads.92.raw_reads.17.C0.S raw_reads.92.raw_reads.17.N0.S raw_reads.92.raw_reads.17.C1.S raw_reads.92.raw_reads.17.N1.S raw_reads.92.raw_reads.17.C2.S raw_reads.92.raw_reads.17.N2.S raw_reads.92.raw_reads.17.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.18.C0 raw_reads.92.raw_reads.18.N0 raw_reads.92.raw_reads.18.C1 raw_reads.92.raw_reads.18.N1 raw_reads.92.raw_reads.18.C2 raw_reads.92.raw_reads.18.N2 raw_reads.92.raw_reads.18.C3 raw_reads.92.raw_reads.18.N3 && LAmerge -v L1.92.18 raw_reads.92.raw_reads.18.C0.S raw_reads.92.raw_reads.18.N0.S raw_reads.92.raw_reads.18.C1.S raw_reads.92.raw_reads.18.N1.S raw_reads.92.raw_reads.18.C2.S raw_reads.92.raw_reads.18.N2.S raw_reads.92.raw_reads.18.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.19.C0 raw_reads.92.raw_reads.19.N0 raw_reads.92.raw_reads.19.C1 raw_reads.92.raw_reads.19.N1 raw_reads.92.raw_reads.19.C2 raw_reads.92.raw_reads.19.N2 raw_reads.92.raw_reads.19.C3 raw_reads.92.raw_reads.19.N3 && LAmerge -v L1.92.19 raw_reads.92.raw_reads.19.C0.S raw_reads.92.raw_reads.19.N0.S raw_reads.92.raw_reads.19.C1.S raw_reads.92.raw_reads.19.N1.S raw_reads.92.raw_reads.19.C2.S raw_reads.92.raw_reads.19.N2.S raw_reads.92.raw_reads.19.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.20.C0 raw_reads.92.raw_reads.20.N0 raw_reads.92.raw_reads.20.C1 raw_reads.92.raw_reads.20.N1 raw_reads.92.raw_reads.20.C2 raw_reads.92.raw_reads.20.N2 raw_reads.92.raw_reads.20.C3 raw_reads.92.raw_reads.20.N3 && LAmerge -v L1.92.20 raw_reads.92.raw_reads.20.C0.S raw_reads.92.raw_reads.20.N0.S raw_reads.92.raw_reads.20.C1.S raw_reads.92.raw_reads.20.N1.S raw_reads.92.raw_reads.20.C2.S raw_reads.92.raw_reads.20.N2.S raw_reads.92.raw_reads.20.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.21.C0 raw_reads.92.raw_reads.21.N0 raw_reads.92.raw_reads.21.C1 raw_reads.92.raw_reads.21.N1 raw_reads.92.raw_reads.21.C2 raw_reads.92.raw_reads.21.N2 raw_reads.92.raw_reads.21.C3 raw_reads.92.raw_reads.21.N3 && LAmerge -v L1.92.21 raw_reads.92.raw_reads.21.C0.S raw_reads.92.raw_reads.21.N0.S raw_reads.92.raw_reads.21.C1.S raw_reads.92.raw_reads.21.N1.S raw_reads.92.raw_reads.21.C2.S raw_reads.92.raw_reads.21.N2.S raw_reads.92.raw_reads.21.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.22.C0 raw_reads.92.raw_reads.22.N0 raw_reads.92.raw_reads.22.C1 raw_reads.92.raw_reads.22.N1 raw_reads.92.raw_reads.22.C2 raw_reads.92.raw_reads.22.N2 raw_reads.92.raw_reads.22.C3 raw_reads.92.raw_reads.22.N3 && LAmerge -v L1.92.22 raw_reads.92.raw_reads.22.C0.S raw_reads.92.raw_reads.22.N0.S raw_reads.92.raw_reads.22.C1.S raw_reads.92.raw_reads.22.N1.S raw_reads.92.raw_reads.22.C2.S raw_reads.92.raw_reads.22.N2.S raw_reads.92.raw_reads.22.C3.S raw_reads. [...]
+LAsort -v raw_reads.92.raw_reads.23.C0 raw_reads.92.raw_reads.23.N0 raw_reads.92.raw_reads.23.C1 raw_reads.92.raw_reads.23.N1 raw_reads.92.raw_reads.23.C2 raw_reads.92.raw_reads.23.N2 raw_reads.92.raw_reads.23.C3 raw_reads.92.raw_reads.23.N3 && LAmerge -v L1.92.23 raw_reads.92.raw_reads.23.C0.S raw_reads.92.raw_reads.23.N0.S raw_reads.92.raw_reads.23.C1.S raw_reads.92.raw_reads.23.N1.S raw_reads.92.raw_reads.23.C2.S raw_reads.92.raw_reads.23.N2.S raw_reads.92.raw_reads.23.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.1.92
+LAcheck -vS raw_reads L1.2.92
+LAcheck -vS raw_reads L1.3.92
+LAcheck -vS raw_reads L1.4.92
+LAcheck -vS raw_reads L1.5.92
+LAcheck -vS raw_reads L1.6.92
+LAcheck -vS raw_reads L1.7.92
+LAcheck -vS raw_reads L1.8.92
+LAcheck -vS raw_reads L1.9.92
+LAcheck -vS raw_reads L1.10.92
+LAcheck -vS raw_reads L1.11.92
+LAcheck -vS raw_reads L1.12.92
+LAcheck -vS raw_reads L1.13.92
+LAcheck -vS raw_reads L1.14.92
+LAcheck -vS raw_reads L1.15.92
+LAcheck -vS raw_reads L1.16.92
+LAcheck -vS raw_reads L1.17.92
+LAcheck -vS raw_reads L1.18.92
+LAcheck -vS raw_reads L1.19.92
+LAcheck -vS raw_reads L1.20.92
+LAcheck -vS raw_reads L1.21.92
+LAcheck -vS raw_reads L1.22.92
+LAcheck -vS raw_reads L1.23.92
+LAcheck -vS raw_reads L1.92.1
+LAcheck -vS raw_reads L1.92.2
+LAcheck -vS raw_reads L1.92.3
+LAcheck -vS raw_reads L1.92.4
+LAcheck -vS raw_reads L1.92.5
+LAcheck -vS raw_reads L1.92.6
+LAcheck -vS raw_reads L1.92.7
+LAcheck -vS raw_reads L1.92.8
+LAcheck -vS raw_reads L1.92.9
+LAcheck -vS raw_reads L1.92.10
+LAcheck -vS raw_reads L1.92.11
+LAcheck -vS raw_reads L1.92.12
+LAcheck -vS raw_reads L1.92.13
+LAcheck -vS raw_reads L1.92.14
+LAcheck -vS raw_reads L1.92.15
+LAcheck -vS raw_reads L1.92.16
+LAcheck -vS raw_reads L1.92.17
+LAcheck -vS raw_reads L1.92.18
+LAcheck -vS raw_reads L1.92.19
+LAcheck -vS raw_reads L1.92.20
+LAcheck -vS raw_reads L1.92.21
+LAcheck -vS raw_reads L1.92.22
+LAcheck -vS raw_reads L1.92.23
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.91 raw_reads.46 raw_reads.47 raw_reads.48 raw_reads.49 raw_reads.50 raw_reads.51 raw_reads.52 raw_reads.53 raw_reads.54 raw_reads.55 raw_reads.56 raw_reads.57 raw_reads.58 raw_reads.59 raw_reads.60 raw_reads.61 raw_reads.62 raw_reads.63 raw_reads.64 raw_reads.65 raw_reads.66 raw_reads.67 raw_reads.68
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.46.raw_reads.91.C0 raw_reads.46.raw_reads.91.N0 raw_reads.46.raw_reads.91.C1 raw_reads.46.raw_reads.91.N1 raw_reads.46.raw_reads.91.C2 raw_reads.46.raw_reads.91.N2 raw_reads.46.raw_reads.91.C3 raw_reads.46.raw_reads.91.N3 && LAmerge -v L1.46.91 raw_reads.46.raw_reads.91.C0.S raw_reads.46.raw_reads.91.N0.S raw_reads.46.raw_reads.91.C1.S raw_reads.46.raw_reads.91.N1.S raw_reads.46.raw_reads.91.C2.S raw_reads.46.raw_reads.91.N2.S raw_reads.46.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.47.raw_reads.91.C0 raw_reads.47.raw_reads.91.N0 raw_reads.47.raw_reads.91.C1 raw_reads.47.raw_reads.91.N1 raw_reads.47.raw_reads.91.C2 raw_reads.47.raw_reads.91.N2 raw_reads.47.raw_reads.91.C3 raw_reads.47.raw_reads.91.N3 && LAmerge -v L1.47.91 raw_reads.47.raw_reads.91.C0.S raw_reads.47.raw_reads.91.N0.S raw_reads.47.raw_reads.91.C1.S raw_reads.47.raw_reads.91.N1.S raw_reads.47.raw_reads.91.C2.S raw_reads.47.raw_reads.91.N2.S raw_reads.47.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.48.raw_reads.91.C0 raw_reads.48.raw_reads.91.N0 raw_reads.48.raw_reads.91.C1 raw_reads.48.raw_reads.91.N1 raw_reads.48.raw_reads.91.C2 raw_reads.48.raw_reads.91.N2 raw_reads.48.raw_reads.91.C3 raw_reads.48.raw_reads.91.N3 && LAmerge -v L1.48.91 raw_reads.48.raw_reads.91.C0.S raw_reads.48.raw_reads.91.N0.S raw_reads.48.raw_reads.91.C1.S raw_reads.48.raw_reads.91.N1.S raw_reads.48.raw_reads.91.C2.S raw_reads.48.raw_reads.91.N2.S raw_reads.48.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.49.raw_reads.91.C0 raw_reads.49.raw_reads.91.N0 raw_reads.49.raw_reads.91.C1 raw_reads.49.raw_reads.91.N1 raw_reads.49.raw_reads.91.C2 raw_reads.49.raw_reads.91.N2 raw_reads.49.raw_reads.91.C3 raw_reads.49.raw_reads.91.N3 && LAmerge -v L1.49.91 raw_reads.49.raw_reads.91.C0.S raw_reads.49.raw_reads.91.N0.S raw_reads.49.raw_reads.91.C1.S raw_reads.49.raw_reads.91.N1.S raw_reads.49.raw_reads.91.C2.S raw_reads.49.raw_reads.91.N2.S raw_reads.49.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.91.C0 raw_reads.50.raw_reads.91.N0 raw_reads.50.raw_reads.91.C1 raw_reads.50.raw_reads.91.N1 raw_reads.50.raw_reads.91.C2 raw_reads.50.raw_reads.91.N2 raw_reads.50.raw_reads.91.C3 raw_reads.50.raw_reads.91.N3 && LAmerge -v L1.50.91 raw_reads.50.raw_reads.91.C0.S raw_reads.50.raw_reads.91.N0.S raw_reads.50.raw_reads.91.C1.S raw_reads.50.raw_reads.91.N1.S raw_reads.50.raw_reads.91.C2.S raw_reads.50.raw_reads.91.N2.S raw_reads.50.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.51.raw_reads.91.C0 raw_reads.51.raw_reads.91.N0 raw_reads.51.raw_reads.91.C1 raw_reads.51.raw_reads.91.N1 raw_reads.51.raw_reads.91.C2 raw_reads.51.raw_reads.91.N2 raw_reads.51.raw_reads.91.C3 raw_reads.51.raw_reads.91.N3 && LAmerge -v L1.51.91 raw_reads.51.raw_reads.91.C0.S raw_reads.51.raw_reads.91.N0.S raw_reads.51.raw_reads.91.C1.S raw_reads.51.raw_reads.91.N1.S raw_reads.51.raw_reads.91.C2.S raw_reads.51.raw_reads.91.N2.S raw_reads.51.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.52.raw_reads.91.C0 raw_reads.52.raw_reads.91.N0 raw_reads.52.raw_reads.91.C1 raw_reads.52.raw_reads.91.N1 raw_reads.52.raw_reads.91.C2 raw_reads.52.raw_reads.91.N2 raw_reads.52.raw_reads.91.C3 raw_reads.52.raw_reads.91.N3 && LAmerge -v L1.52.91 raw_reads.52.raw_reads.91.C0.S raw_reads.52.raw_reads.91.N0.S raw_reads.52.raw_reads.91.C1.S raw_reads.52.raw_reads.91.N1.S raw_reads.52.raw_reads.91.C2.S raw_reads.52.raw_reads.91.N2.S raw_reads.52.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.53.raw_reads.91.C0 raw_reads.53.raw_reads.91.N0 raw_reads.53.raw_reads.91.C1 raw_reads.53.raw_reads.91.N1 raw_reads.53.raw_reads.91.C2 raw_reads.53.raw_reads.91.N2 raw_reads.53.raw_reads.91.C3 raw_reads.53.raw_reads.91.N3 && LAmerge -v L1.53.91 raw_reads.53.raw_reads.91.C0.S raw_reads.53.raw_reads.91.N0.S raw_reads.53.raw_reads.91.C1.S raw_reads.53.raw_reads.91.N1.S raw_reads.53.raw_reads.91.C2.S raw_reads.53.raw_reads.91.N2.S raw_reads.53.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.54.raw_reads.91.C0 raw_reads.54.raw_reads.91.N0 raw_reads.54.raw_reads.91.C1 raw_reads.54.raw_reads.91.N1 raw_reads.54.raw_reads.91.C2 raw_reads.54.raw_reads.91.N2 raw_reads.54.raw_reads.91.C3 raw_reads.54.raw_reads.91.N3 && LAmerge -v L1.54.91 raw_reads.54.raw_reads.91.C0.S raw_reads.54.raw_reads.91.N0.S raw_reads.54.raw_reads.91.C1.S raw_reads.54.raw_reads.91.N1.S raw_reads.54.raw_reads.91.C2.S raw_reads.54.raw_reads.91.N2.S raw_reads.54.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.55.raw_reads.91.C0 raw_reads.55.raw_reads.91.N0 raw_reads.55.raw_reads.91.C1 raw_reads.55.raw_reads.91.N1 raw_reads.55.raw_reads.91.C2 raw_reads.55.raw_reads.91.N2 raw_reads.55.raw_reads.91.C3 raw_reads.55.raw_reads.91.N3 && LAmerge -v L1.55.91 raw_reads.55.raw_reads.91.C0.S raw_reads.55.raw_reads.91.N0.S raw_reads.55.raw_reads.91.C1.S raw_reads.55.raw_reads.91.N1.S raw_reads.55.raw_reads.91.C2.S raw_reads.55.raw_reads.91.N2.S raw_reads.55.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.56.raw_reads.91.C0 raw_reads.56.raw_reads.91.N0 raw_reads.56.raw_reads.91.C1 raw_reads.56.raw_reads.91.N1 raw_reads.56.raw_reads.91.C2 raw_reads.56.raw_reads.91.N2 raw_reads.56.raw_reads.91.C3 raw_reads.56.raw_reads.91.N3 && LAmerge -v L1.56.91 raw_reads.56.raw_reads.91.C0.S raw_reads.56.raw_reads.91.N0.S raw_reads.56.raw_reads.91.C1.S raw_reads.56.raw_reads.91.N1.S raw_reads.56.raw_reads.91.C2.S raw_reads.56.raw_reads.91.N2.S raw_reads.56.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.57.raw_reads.91.C0 raw_reads.57.raw_reads.91.N0 raw_reads.57.raw_reads.91.C1 raw_reads.57.raw_reads.91.N1 raw_reads.57.raw_reads.91.C2 raw_reads.57.raw_reads.91.N2 raw_reads.57.raw_reads.91.C3 raw_reads.57.raw_reads.91.N3 && LAmerge -v L1.57.91 raw_reads.57.raw_reads.91.C0.S raw_reads.57.raw_reads.91.N0.S raw_reads.57.raw_reads.91.C1.S raw_reads.57.raw_reads.91.N1.S raw_reads.57.raw_reads.91.C2.S raw_reads.57.raw_reads.91.N2.S raw_reads.57.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.58.raw_reads.91.C0 raw_reads.58.raw_reads.91.N0 raw_reads.58.raw_reads.91.C1 raw_reads.58.raw_reads.91.N1 raw_reads.58.raw_reads.91.C2 raw_reads.58.raw_reads.91.N2 raw_reads.58.raw_reads.91.C3 raw_reads.58.raw_reads.91.N3 && LAmerge -v L1.58.91 raw_reads.58.raw_reads.91.C0.S raw_reads.58.raw_reads.91.N0.S raw_reads.58.raw_reads.91.C1.S raw_reads.58.raw_reads.91.N1.S raw_reads.58.raw_reads.91.C2.S raw_reads.58.raw_reads.91.N2.S raw_reads.58.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.59.raw_reads.91.C0 raw_reads.59.raw_reads.91.N0 raw_reads.59.raw_reads.91.C1 raw_reads.59.raw_reads.91.N1 raw_reads.59.raw_reads.91.C2 raw_reads.59.raw_reads.91.N2 raw_reads.59.raw_reads.91.C3 raw_reads.59.raw_reads.91.N3 && LAmerge -v L1.59.91 raw_reads.59.raw_reads.91.C0.S raw_reads.59.raw_reads.91.N0.S raw_reads.59.raw_reads.91.C1.S raw_reads.59.raw_reads.91.N1.S raw_reads.59.raw_reads.91.C2.S raw_reads.59.raw_reads.91.N2.S raw_reads.59.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.60.raw_reads.91.C0 raw_reads.60.raw_reads.91.N0 raw_reads.60.raw_reads.91.C1 raw_reads.60.raw_reads.91.N1 raw_reads.60.raw_reads.91.C2 raw_reads.60.raw_reads.91.N2 raw_reads.60.raw_reads.91.C3 raw_reads.60.raw_reads.91.N3 && LAmerge -v L1.60.91 raw_reads.60.raw_reads.91.C0.S raw_reads.60.raw_reads.91.N0.S raw_reads.60.raw_reads.91.C1.S raw_reads.60.raw_reads.91.N1.S raw_reads.60.raw_reads.91.C2.S raw_reads.60.raw_reads.91.N2.S raw_reads.60.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.61.raw_reads.91.C0 raw_reads.61.raw_reads.91.N0 raw_reads.61.raw_reads.91.C1 raw_reads.61.raw_reads.91.N1 raw_reads.61.raw_reads.91.C2 raw_reads.61.raw_reads.91.N2 raw_reads.61.raw_reads.91.C3 raw_reads.61.raw_reads.91.N3 && LAmerge -v L1.61.91 raw_reads.61.raw_reads.91.C0.S raw_reads.61.raw_reads.91.N0.S raw_reads.61.raw_reads.91.C1.S raw_reads.61.raw_reads.91.N1.S raw_reads.61.raw_reads.91.C2.S raw_reads.61.raw_reads.91.N2.S raw_reads.61.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.62.raw_reads.91.C0 raw_reads.62.raw_reads.91.N0 raw_reads.62.raw_reads.91.C1 raw_reads.62.raw_reads.91.N1 raw_reads.62.raw_reads.91.C2 raw_reads.62.raw_reads.91.N2 raw_reads.62.raw_reads.91.C3 raw_reads.62.raw_reads.91.N3 && LAmerge -v L1.62.91 raw_reads.62.raw_reads.91.C0.S raw_reads.62.raw_reads.91.N0.S raw_reads.62.raw_reads.91.C1.S raw_reads.62.raw_reads.91.N1.S raw_reads.62.raw_reads.91.C2.S raw_reads.62.raw_reads.91.N2.S raw_reads.62.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.91.C0 raw_reads.63.raw_reads.91.N0 raw_reads.63.raw_reads.91.C1 raw_reads.63.raw_reads.91.N1 raw_reads.63.raw_reads.91.C2 raw_reads.63.raw_reads.91.N2 raw_reads.63.raw_reads.91.C3 raw_reads.63.raw_reads.91.N3 && LAmerge -v L1.63.91 raw_reads.63.raw_reads.91.C0.S raw_reads.63.raw_reads.91.N0.S raw_reads.63.raw_reads.91.C1.S raw_reads.63.raw_reads.91.N1.S raw_reads.63.raw_reads.91.C2.S raw_reads.63.raw_reads.91.N2.S raw_reads.63.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.64.raw_reads.91.C0 raw_reads.64.raw_reads.91.N0 raw_reads.64.raw_reads.91.C1 raw_reads.64.raw_reads.91.N1 raw_reads.64.raw_reads.91.C2 raw_reads.64.raw_reads.91.N2 raw_reads.64.raw_reads.91.C3 raw_reads.64.raw_reads.91.N3 && LAmerge -v L1.64.91 raw_reads.64.raw_reads.91.C0.S raw_reads.64.raw_reads.91.N0.S raw_reads.64.raw_reads.91.C1.S raw_reads.64.raw_reads.91.N1.S raw_reads.64.raw_reads.91.C2.S raw_reads.64.raw_reads.91.N2.S raw_reads.64.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.65.raw_reads.91.C0 raw_reads.65.raw_reads.91.N0 raw_reads.65.raw_reads.91.C1 raw_reads.65.raw_reads.91.N1 raw_reads.65.raw_reads.91.C2 raw_reads.65.raw_reads.91.N2 raw_reads.65.raw_reads.91.C3 raw_reads.65.raw_reads.91.N3 && LAmerge -v L1.65.91 raw_reads.65.raw_reads.91.C0.S raw_reads.65.raw_reads.91.N0.S raw_reads.65.raw_reads.91.C1.S raw_reads.65.raw_reads.91.N1.S raw_reads.65.raw_reads.91.C2.S raw_reads.65.raw_reads.91.N2.S raw_reads.65.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.66.raw_reads.91.C0 raw_reads.66.raw_reads.91.N0 raw_reads.66.raw_reads.91.C1 raw_reads.66.raw_reads.91.N1 raw_reads.66.raw_reads.91.C2 raw_reads.66.raw_reads.91.N2 raw_reads.66.raw_reads.91.C3 raw_reads.66.raw_reads.91.N3 && LAmerge -v L1.66.91 raw_reads.66.raw_reads.91.C0.S raw_reads.66.raw_reads.91.N0.S raw_reads.66.raw_reads.91.C1.S raw_reads.66.raw_reads.91.N1.S raw_reads.66.raw_reads.91.C2.S raw_reads.66.raw_reads.91.N2.S raw_reads.66.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.67.raw_reads.91.C0 raw_reads.67.raw_reads.91.N0 raw_reads.67.raw_reads.91.C1 raw_reads.67.raw_reads.91.N1 raw_reads.67.raw_reads.91.C2 raw_reads.67.raw_reads.91.N2 raw_reads.67.raw_reads.91.C3 raw_reads.67.raw_reads.91.N3 && LAmerge -v L1.67.91 raw_reads.67.raw_reads.91.C0.S raw_reads.67.raw_reads.91.N0.S raw_reads.67.raw_reads.91.C1.S raw_reads.67.raw_reads.91.N1.S raw_reads.67.raw_reads.91.C2.S raw_reads.67.raw_reads.91.N2.S raw_reads.67.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.68.raw_reads.91.C0 raw_reads.68.raw_reads.91.N0 raw_reads.68.raw_reads.91.C1 raw_reads.68.raw_reads.91.N1 raw_reads.68.raw_reads.91.C2 raw_reads.68.raw_reads.91.N2 raw_reads.68.raw_reads.91.C3 raw_reads.68.raw_reads.91.N3 && LAmerge -v L1.68.91 raw_reads.68.raw_reads.91.C0.S raw_reads.68.raw_reads.91.N0.S raw_reads.68.raw_reads.91.C1.S raw_reads.68.raw_reads.91.N1.S raw_reads.68.raw_reads.91.C2.S raw_reads.68.raw_reads.91.N2.S raw_reads.68.raw_reads.91.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.46.C0 raw_reads.91.raw_reads.46.N0 raw_reads.91.raw_reads.46.C1 raw_reads.91.raw_reads.46.N1 raw_reads.91.raw_reads.46.C2 raw_reads.91.raw_reads.46.N2 raw_reads.91.raw_reads.46.C3 raw_reads.91.raw_reads.46.N3 && LAmerge -v L1.91.46 raw_reads.91.raw_reads.46.C0.S raw_reads.91.raw_reads.46.N0.S raw_reads.91.raw_reads.46.C1.S raw_reads.91.raw_reads.46.N1.S raw_reads.91.raw_reads.46.C2.S raw_reads.91.raw_reads.46.N2.S raw_reads.91.raw_reads.46.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.47.C0 raw_reads.91.raw_reads.47.N0 raw_reads.91.raw_reads.47.C1 raw_reads.91.raw_reads.47.N1 raw_reads.91.raw_reads.47.C2 raw_reads.91.raw_reads.47.N2 raw_reads.91.raw_reads.47.C3 raw_reads.91.raw_reads.47.N3 && LAmerge -v L1.91.47 raw_reads.91.raw_reads.47.C0.S raw_reads.91.raw_reads.47.N0.S raw_reads.91.raw_reads.47.C1.S raw_reads.91.raw_reads.47.N1.S raw_reads.91.raw_reads.47.C2.S raw_reads.91.raw_reads.47.N2.S raw_reads.91.raw_reads.47.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.48.C0 raw_reads.91.raw_reads.48.N0 raw_reads.91.raw_reads.48.C1 raw_reads.91.raw_reads.48.N1 raw_reads.91.raw_reads.48.C2 raw_reads.91.raw_reads.48.N2 raw_reads.91.raw_reads.48.C3 raw_reads.91.raw_reads.48.N3 && LAmerge -v L1.91.48 raw_reads.91.raw_reads.48.C0.S raw_reads.91.raw_reads.48.N0.S raw_reads.91.raw_reads.48.C1.S raw_reads.91.raw_reads.48.N1.S raw_reads.91.raw_reads.48.C2.S raw_reads.91.raw_reads.48.N2.S raw_reads.91.raw_reads.48.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.49.C0 raw_reads.91.raw_reads.49.N0 raw_reads.91.raw_reads.49.C1 raw_reads.91.raw_reads.49.N1 raw_reads.91.raw_reads.49.C2 raw_reads.91.raw_reads.49.N2 raw_reads.91.raw_reads.49.C3 raw_reads.91.raw_reads.49.N3 && LAmerge -v L1.91.49 raw_reads.91.raw_reads.49.C0.S raw_reads.91.raw_reads.49.N0.S raw_reads.91.raw_reads.49.C1.S raw_reads.91.raw_reads.49.N1.S raw_reads.91.raw_reads.49.C2.S raw_reads.91.raw_reads.49.N2.S raw_reads.91.raw_reads.49.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.50.C0 raw_reads.91.raw_reads.50.N0 raw_reads.91.raw_reads.50.C1 raw_reads.91.raw_reads.50.N1 raw_reads.91.raw_reads.50.C2 raw_reads.91.raw_reads.50.N2 raw_reads.91.raw_reads.50.C3 raw_reads.91.raw_reads.50.N3 && LAmerge -v L1.91.50 raw_reads.91.raw_reads.50.C0.S raw_reads.91.raw_reads.50.N0.S raw_reads.91.raw_reads.50.C1.S raw_reads.91.raw_reads.50.N1.S raw_reads.91.raw_reads.50.C2.S raw_reads.91.raw_reads.50.N2.S raw_reads.91.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.51.C0 raw_reads.91.raw_reads.51.N0 raw_reads.91.raw_reads.51.C1 raw_reads.91.raw_reads.51.N1 raw_reads.91.raw_reads.51.C2 raw_reads.91.raw_reads.51.N2 raw_reads.91.raw_reads.51.C3 raw_reads.91.raw_reads.51.N3 && LAmerge -v L1.91.51 raw_reads.91.raw_reads.51.C0.S raw_reads.91.raw_reads.51.N0.S raw_reads.91.raw_reads.51.C1.S raw_reads.91.raw_reads.51.N1.S raw_reads.91.raw_reads.51.C2.S raw_reads.91.raw_reads.51.N2.S raw_reads.91.raw_reads.51.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.52.C0 raw_reads.91.raw_reads.52.N0 raw_reads.91.raw_reads.52.C1 raw_reads.91.raw_reads.52.N1 raw_reads.91.raw_reads.52.C2 raw_reads.91.raw_reads.52.N2 raw_reads.91.raw_reads.52.C3 raw_reads.91.raw_reads.52.N3 && LAmerge -v L1.91.52 raw_reads.91.raw_reads.52.C0.S raw_reads.91.raw_reads.52.N0.S raw_reads.91.raw_reads.52.C1.S raw_reads.91.raw_reads.52.N1.S raw_reads.91.raw_reads.52.C2.S raw_reads.91.raw_reads.52.N2.S raw_reads.91.raw_reads.52.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.53.C0 raw_reads.91.raw_reads.53.N0 raw_reads.91.raw_reads.53.C1 raw_reads.91.raw_reads.53.N1 raw_reads.91.raw_reads.53.C2 raw_reads.91.raw_reads.53.N2 raw_reads.91.raw_reads.53.C3 raw_reads.91.raw_reads.53.N3 && LAmerge -v L1.91.53 raw_reads.91.raw_reads.53.C0.S raw_reads.91.raw_reads.53.N0.S raw_reads.91.raw_reads.53.C1.S raw_reads.91.raw_reads.53.N1.S raw_reads.91.raw_reads.53.C2.S raw_reads.91.raw_reads.53.N2.S raw_reads.91.raw_reads.53.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.54.C0 raw_reads.91.raw_reads.54.N0 raw_reads.91.raw_reads.54.C1 raw_reads.91.raw_reads.54.N1 raw_reads.91.raw_reads.54.C2 raw_reads.91.raw_reads.54.N2 raw_reads.91.raw_reads.54.C3 raw_reads.91.raw_reads.54.N3 && LAmerge -v L1.91.54 raw_reads.91.raw_reads.54.C0.S raw_reads.91.raw_reads.54.N0.S raw_reads.91.raw_reads.54.C1.S raw_reads.91.raw_reads.54.N1.S raw_reads.91.raw_reads.54.C2.S raw_reads.91.raw_reads.54.N2.S raw_reads.91.raw_reads.54.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.55.C0 raw_reads.91.raw_reads.55.N0 raw_reads.91.raw_reads.55.C1 raw_reads.91.raw_reads.55.N1 raw_reads.91.raw_reads.55.C2 raw_reads.91.raw_reads.55.N2 raw_reads.91.raw_reads.55.C3 raw_reads.91.raw_reads.55.N3 && LAmerge -v L1.91.55 raw_reads.91.raw_reads.55.C0.S raw_reads.91.raw_reads.55.N0.S raw_reads.91.raw_reads.55.C1.S raw_reads.91.raw_reads.55.N1.S raw_reads.91.raw_reads.55.C2.S raw_reads.91.raw_reads.55.N2.S raw_reads.91.raw_reads.55.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.56.C0 raw_reads.91.raw_reads.56.N0 raw_reads.91.raw_reads.56.C1 raw_reads.91.raw_reads.56.N1 raw_reads.91.raw_reads.56.C2 raw_reads.91.raw_reads.56.N2 raw_reads.91.raw_reads.56.C3 raw_reads.91.raw_reads.56.N3 && LAmerge -v L1.91.56 raw_reads.91.raw_reads.56.C0.S raw_reads.91.raw_reads.56.N0.S raw_reads.91.raw_reads.56.C1.S raw_reads.91.raw_reads.56.N1.S raw_reads.91.raw_reads.56.C2.S raw_reads.91.raw_reads.56.N2.S raw_reads.91.raw_reads.56.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.57.C0 raw_reads.91.raw_reads.57.N0 raw_reads.91.raw_reads.57.C1 raw_reads.91.raw_reads.57.N1 raw_reads.91.raw_reads.57.C2 raw_reads.91.raw_reads.57.N2 raw_reads.91.raw_reads.57.C3 raw_reads.91.raw_reads.57.N3 && LAmerge -v L1.91.57 raw_reads.91.raw_reads.57.C0.S raw_reads.91.raw_reads.57.N0.S raw_reads.91.raw_reads.57.C1.S raw_reads.91.raw_reads.57.N1.S raw_reads.91.raw_reads.57.C2.S raw_reads.91.raw_reads.57.N2.S raw_reads.91.raw_reads.57.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.58.C0 raw_reads.91.raw_reads.58.N0 raw_reads.91.raw_reads.58.C1 raw_reads.91.raw_reads.58.N1 raw_reads.91.raw_reads.58.C2 raw_reads.91.raw_reads.58.N2 raw_reads.91.raw_reads.58.C3 raw_reads.91.raw_reads.58.N3 && LAmerge -v L1.91.58 raw_reads.91.raw_reads.58.C0.S raw_reads.91.raw_reads.58.N0.S raw_reads.91.raw_reads.58.C1.S raw_reads.91.raw_reads.58.N1.S raw_reads.91.raw_reads.58.C2.S raw_reads.91.raw_reads.58.N2.S raw_reads.91.raw_reads.58.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.59.C0 raw_reads.91.raw_reads.59.N0 raw_reads.91.raw_reads.59.C1 raw_reads.91.raw_reads.59.N1 raw_reads.91.raw_reads.59.C2 raw_reads.91.raw_reads.59.N2 raw_reads.91.raw_reads.59.C3 raw_reads.91.raw_reads.59.N3 && LAmerge -v L1.91.59 raw_reads.91.raw_reads.59.C0.S raw_reads.91.raw_reads.59.N0.S raw_reads.91.raw_reads.59.C1.S raw_reads.91.raw_reads.59.N1.S raw_reads.91.raw_reads.59.C2.S raw_reads.91.raw_reads.59.N2.S raw_reads.91.raw_reads.59.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.60.C0 raw_reads.91.raw_reads.60.N0 raw_reads.91.raw_reads.60.C1 raw_reads.91.raw_reads.60.N1 raw_reads.91.raw_reads.60.C2 raw_reads.91.raw_reads.60.N2 raw_reads.91.raw_reads.60.C3 raw_reads.91.raw_reads.60.N3 && LAmerge -v L1.91.60 raw_reads.91.raw_reads.60.C0.S raw_reads.91.raw_reads.60.N0.S raw_reads.91.raw_reads.60.C1.S raw_reads.91.raw_reads.60.N1.S raw_reads.91.raw_reads.60.C2.S raw_reads.91.raw_reads.60.N2.S raw_reads.91.raw_reads.60.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.61.C0 raw_reads.91.raw_reads.61.N0 raw_reads.91.raw_reads.61.C1 raw_reads.91.raw_reads.61.N1 raw_reads.91.raw_reads.61.C2 raw_reads.91.raw_reads.61.N2 raw_reads.91.raw_reads.61.C3 raw_reads.91.raw_reads.61.N3 && LAmerge -v L1.91.61 raw_reads.91.raw_reads.61.C0.S raw_reads.91.raw_reads.61.N0.S raw_reads.91.raw_reads.61.C1.S raw_reads.91.raw_reads.61.N1.S raw_reads.91.raw_reads.61.C2.S raw_reads.91.raw_reads.61.N2.S raw_reads.91.raw_reads.61.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.62.C0 raw_reads.91.raw_reads.62.N0 raw_reads.91.raw_reads.62.C1 raw_reads.91.raw_reads.62.N1 raw_reads.91.raw_reads.62.C2 raw_reads.91.raw_reads.62.N2 raw_reads.91.raw_reads.62.C3 raw_reads.91.raw_reads.62.N3 && LAmerge -v L1.91.62 raw_reads.91.raw_reads.62.C0.S raw_reads.91.raw_reads.62.N0.S raw_reads.91.raw_reads.62.C1.S raw_reads.91.raw_reads.62.N1.S raw_reads.91.raw_reads.62.C2.S raw_reads.91.raw_reads.62.N2.S raw_reads.91.raw_reads.62.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.63.C0 raw_reads.91.raw_reads.63.N0 raw_reads.91.raw_reads.63.C1 raw_reads.91.raw_reads.63.N1 raw_reads.91.raw_reads.63.C2 raw_reads.91.raw_reads.63.N2 raw_reads.91.raw_reads.63.C3 raw_reads.91.raw_reads.63.N3 && LAmerge -v L1.91.63 raw_reads.91.raw_reads.63.C0.S raw_reads.91.raw_reads.63.N0.S raw_reads.91.raw_reads.63.C1.S raw_reads.91.raw_reads.63.N1.S raw_reads.91.raw_reads.63.C2.S raw_reads.91.raw_reads.63.N2.S raw_reads.91.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.64.C0 raw_reads.91.raw_reads.64.N0 raw_reads.91.raw_reads.64.C1 raw_reads.91.raw_reads.64.N1 raw_reads.91.raw_reads.64.C2 raw_reads.91.raw_reads.64.N2 raw_reads.91.raw_reads.64.C3 raw_reads.91.raw_reads.64.N3 && LAmerge -v L1.91.64 raw_reads.91.raw_reads.64.C0.S raw_reads.91.raw_reads.64.N0.S raw_reads.91.raw_reads.64.C1.S raw_reads.91.raw_reads.64.N1.S raw_reads.91.raw_reads.64.C2.S raw_reads.91.raw_reads.64.N2.S raw_reads.91.raw_reads.64.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.65.C0 raw_reads.91.raw_reads.65.N0 raw_reads.91.raw_reads.65.C1 raw_reads.91.raw_reads.65.N1 raw_reads.91.raw_reads.65.C2 raw_reads.91.raw_reads.65.N2 raw_reads.91.raw_reads.65.C3 raw_reads.91.raw_reads.65.N3 && LAmerge -v L1.91.65 raw_reads.91.raw_reads.65.C0.S raw_reads.91.raw_reads.65.N0.S raw_reads.91.raw_reads.65.C1.S raw_reads.91.raw_reads.65.N1.S raw_reads.91.raw_reads.65.C2.S raw_reads.91.raw_reads.65.N2.S raw_reads.91.raw_reads.65.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.66.C0 raw_reads.91.raw_reads.66.N0 raw_reads.91.raw_reads.66.C1 raw_reads.91.raw_reads.66.N1 raw_reads.91.raw_reads.66.C2 raw_reads.91.raw_reads.66.N2 raw_reads.91.raw_reads.66.C3 raw_reads.91.raw_reads.66.N3 && LAmerge -v L1.91.66 raw_reads.91.raw_reads.66.C0.S raw_reads.91.raw_reads.66.N0.S raw_reads.91.raw_reads.66.C1.S raw_reads.91.raw_reads.66.N1.S raw_reads.91.raw_reads.66.C2.S raw_reads.91.raw_reads.66.N2.S raw_reads.91.raw_reads.66.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.67.C0 raw_reads.91.raw_reads.67.N0 raw_reads.91.raw_reads.67.C1 raw_reads.91.raw_reads.67.N1 raw_reads.91.raw_reads.67.C2 raw_reads.91.raw_reads.67.N2 raw_reads.91.raw_reads.67.C3 raw_reads.91.raw_reads.67.N3 && LAmerge -v L1.91.67 raw_reads.91.raw_reads.67.C0.S raw_reads.91.raw_reads.67.N0.S raw_reads.91.raw_reads.67.C1.S raw_reads.91.raw_reads.67.N1.S raw_reads.91.raw_reads.67.C2.S raw_reads.91.raw_reads.67.N2.S raw_reads.91.raw_reads.67.C3.S raw_reads. [...]
+LAsort -v raw_reads.91.raw_reads.68.C0 raw_reads.91.raw_reads.68.N0 raw_reads.91.raw_reads.68.C1 raw_reads.91.raw_reads.68.N1 raw_reads.91.raw_reads.68.C2 raw_reads.91.raw_reads.68.N2 raw_reads.91.raw_reads.68.C3 raw_reads.91.raw_reads.68.N3 && LAmerge -v L1.91.68 raw_reads.91.raw_reads.68.C0.S raw_reads.91.raw_reads.68.N0.S raw_reads.91.raw_reads.68.C1.S raw_reads.91.raw_reads.68.N1.S raw_reads.91.raw_reads.68.C2.S raw_reads.91.raw_reads.68.N2.S raw_reads.91.raw_reads.68.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.46.91
+LAcheck -vS raw_reads L1.47.91
+LAcheck -vS raw_reads L1.48.91
+LAcheck -vS raw_reads L1.49.91
+LAcheck -vS raw_reads L1.50.91
+LAcheck -vS raw_reads L1.51.91
+LAcheck -vS raw_reads L1.52.91
+LAcheck -vS raw_reads L1.53.91
+LAcheck -vS raw_reads L1.54.91
+LAcheck -vS raw_reads L1.55.91
+LAcheck -vS raw_reads L1.56.91
+LAcheck -vS raw_reads L1.57.91
+LAcheck -vS raw_reads L1.58.91
+LAcheck -vS raw_reads L1.59.91
+LAcheck -vS raw_reads L1.60.91
+LAcheck -vS raw_reads L1.61.91
+LAcheck -vS raw_reads L1.62.91
+LAcheck -vS raw_reads L1.63.91
+LAcheck -vS raw_reads L1.64.91
+LAcheck -vS raw_reads L1.65.91
+LAcheck -vS raw_reads L1.66.91
+LAcheck -vS raw_reads L1.67.91
+LAcheck -vS raw_reads L1.68.91
+LAcheck -vS raw_reads L1.91.46
+LAcheck -vS raw_reads L1.91.47
+LAcheck -vS raw_reads L1.91.48
+LAcheck -vS raw_reads L1.91.49
+LAcheck -vS raw_reads L1.91.50
+LAcheck -vS raw_reads L1.91.51
+LAcheck -vS raw_reads L1.91.52
+LAcheck -vS raw_reads L1.91.53
+LAcheck -vS raw_reads L1.91.54
+LAcheck -vS raw_reads L1.91.55
+LAcheck -vS raw_reads L1.91.56
+LAcheck -vS raw_reads L1.91.57
+LAcheck -vS raw_reads L1.91.58
+LAcheck -vS raw_reads L1.91.59
+LAcheck -vS raw_reads L1.91.60
+LAcheck -vS raw_reads L1.91.61
+LAcheck -vS raw_reads L1.91.62
+LAcheck -vS raw_reads L1.91.63
+LAcheck -vS raw_reads L1.91.64
+LAcheck -vS raw_reads L1.91.65
+LAcheck -vS raw_reads L1.91.66
+LAcheck -vS raw_reads L1.91.67
+LAcheck -vS raw_reads L1.91.68
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.27 raw_reads.14 raw_reads.15 raw_reads.16 raw_reads.17 raw_reads.18 raw_reads.19 raw_reads.20 raw_reads.21 raw_reads.22 raw_reads.23 raw_reads.24 raw_reads.25 raw_reads.26 raw_reads.27
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.14.raw_reads.27.C0 raw_reads.14.raw_reads.27.N0 raw_reads.14.raw_reads.27.C1 raw_reads.14.raw_reads.27.N1 raw_reads.14.raw_reads.27.C2 raw_reads.14.raw_reads.27.N2 raw_reads.14.raw_reads.27.C3 raw_reads.14.raw_reads.27.N3 && LAmerge -v L1.14.27 raw_reads.14.raw_reads.27.C0.S raw_reads.14.raw_reads.27.N0.S raw_reads.14.raw_reads.27.C1.S raw_reads.14.raw_reads.27.N1.S raw_reads.14.raw_reads.27.C2.S raw_reads.14.raw_reads.27.N2.S raw_reads.14.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.15.raw_reads.27.C0 raw_reads.15.raw_reads.27.N0 raw_reads.15.raw_reads.27.C1 raw_reads.15.raw_reads.27.N1 raw_reads.15.raw_reads.27.C2 raw_reads.15.raw_reads.27.N2 raw_reads.15.raw_reads.27.C3 raw_reads.15.raw_reads.27.N3 && LAmerge -v L1.15.27 raw_reads.15.raw_reads.27.C0.S raw_reads.15.raw_reads.27.N0.S raw_reads.15.raw_reads.27.C1.S raw_reads.15.raw_reads.27.N1.S raw_reads.15.raw_reads.27.C2.S raw_reads.15.raw_reads.27.N2.S raw_reads.15.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.16.raw_reads.27.C0 raw_reads.16.raw_reads.27.N0 raw_reads.16.raw_reads.27.C1 raw_reads.16.raw_reads.27.N1 raw_reads.16.raw_reads.27.C2 raw_reads.16.raw_reads.27.N2 raw_reads.16.raw_reads.27.C3 raw_reads.16.raw_reads.27.N3 && LAmerge -v L1.16.27 raw_reads.16.raw_reads.27.C0.S raw_reads.16.raw_reads.27.N0.S raw_reads.16.raw_reads.27.C1.S raw_reads.16.raw_reads.27.N1.S raw_reads.16.raw_reads.27.C2.S raw_reads.16.raw_reads.27.N2.S raw_reads.16.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.17.raw_reads.27.C0 raw_reads.17.raw_reads.27.N0 raw_reads.17.raw_reads.27.C1 raw_reads.17.raw_reads.27.N1 raw_reads.17.raw_reads.27.C2 raw_reads.17.raw_reads.27.N2 raw_reads.17.raw_reads.27.C3 raw_reads.17.raw_reads.27.N3 && LAmerge -v L1.17.27 raw_reads.17.raw_reads.27.C0.S raw_reads.17.raw_reads.27.N0.S raw_reads.17.raw_reads.27.C1.S raw_reads.17.raw_reads.27.N1.S raw_reads.17.raw_reads.27.C2.S raw_reads.17.raw_reads.27.N2.S raw_reads.17.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.18.raw_reads.27.C0 raw_reads.18.raw_reads.27.N0 raw_reads.18.raw_reads.27.C1 raw_reads.18.raw_reads.27.N1 raw_reads.18.raw_reads.27.C2 raw_reads.18.raw_reads.27.N2 raw_reads.18.raw_reads.27.C3 raw_reads.18.raw_reads.27.N3 && LAmerge -v L1.18.27 raw_reads.18.raw_reads.27.C0.S raw_reads.18.raw_reads.27.N0.S raw_reads.18.raw_reads.27.C1.S raw_reads.18.raw_reads.27.N1.S raw_reads.18.raw_reads.27.C2.S raw_reads.18.raw_reads.27.N2.S raw_reads.18.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.19.raw_reads.27.C0 raw_reads.19.raw_reads.27.N0 raw_reads.19.raw_reads.27.C1 raw_reads.19.raw_reads.27.N1 raw_reads.19.raw_reads.27.C2 raw_reads.19.raw_reads.27.N2 raw_reads.19.raw_reads.27.C3 raw_reads.19.raw_reads.27.N3 && LAmerge -v L1.19.27 raw_reads.19.raw_reads.27.C0.S raw_reads.19.raw_reads.27.N0.S raw_reads.19.raw_reads.27.C1.S raw_reads.19.raw_reads.27.N1.S raw_reads.19.raw_reads.27.C2.S raw_reads.19.raw_reads.27.N2.S raw_reads.19.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.20.raw_reads.27.C0 raw_reads.20.raw_reads.27.N0 raw_reads.20.raw_reads.27.C1 raw_reads.20.raw_reads.27.N1 raw_reads.20.raw_reads.27.C2 raw_reads.20.raw_reads.27.N2 raw_reads.20.raw_reads.27.C3 raw_reads.20.raw_reads.27.N3 && LAmerge -v L1.20.27 raw_reads.20.raw_reads.27.C0.S raw_reads.20.raw_reads.27.N0.S raw_reads.20.raw_reads.27.C1.S raw_reads.20.raw_reads.27.N1.S raw_reads.20.raw_reads.27.C2.S raw_reads.20.raw_reads.27.N2.S raw_reads.20.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.21.raw_reads.27.C0 raw_reads.21.raw_reads.27.N0 raw_reads.21.raw_reads.27.C1 raw_reads.21.raw_reads.27.N1 raw_reads.21.raw_reads.27.C2 raw_reads.21.raw_reads.27.N2 raw_reads.21.raw_reads.27.C3 raw_reads.21.raw_reads.27.N3 && LAmerge -v L1.21.27 raw_reads.21.raw_reads.27.C0.S raw_reads.21.raw_reads.27.N0.S raw_reads.21.raw_reads.27.C1.S raw_reads.21.raw_reads.27.N1.S raw_reads.21.raw_reads.27.C2.S raw_reads.21.raw_reads.27.N2.S raw_reads.21.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.22.raw_reads.27.C0 raw_reads.22.raw_reads.27.N0 raw_reads.22.raw_reads.27.C1 raw_reads.22.raw_reads.27.N1 raw_reads.22.raw_reads.27.C2 raw_reads.22.raw_reads.27.N2 raw_reads.22.raw_reads.27.C3 raw_reads.22.raw_reads.27.N3 && LAmerge -v L1.22.27 raw_reads.22.raw_reads.27.C0.S raw_reads.22.raw_reads.27.N0.S raw_reads.22.raw_reads.27.C1.S raw_reads.22.raw_reads.27.N1.S raw_reads.22.raw_reads.27.C2.S raw_reads.22.raw_reads.27.N2.S raw_reads.22.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.23.raw_reads.27.C0 raw_reads.23.raw_reads.27.N0 raw_reads.23.raw_reads.27.C1 raw_reads.23.raw_reads.27.N1 raw_reads.23.raw_reads.27.C2 raw_reads.23.raw_reads.27.N2 raw_reads.23.raw_reads.27.C3 raw_reads.23.raw_reads.27.N3 && LAmerge -v L1.23.27 raw_reads.23.raw_reads.27.C0.S raw_reads.23.raw_reads.27.N0.S raw_reads.23.raw_reads.27.C1.S raw_reads.23.raw_reads.27.N1.S raw_reads.23.raw_reads.27.C2.S raw_reads.23.raw_reads.27.N2.S raw_reads.23.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.24.raw_reads.27.C0 raw_reads.24.raw_reads.27.N0 raw_reads.24.raw_reads.27.C1 raw_reads.24.raw_reads.27.N1 raw_reads.24.raw_reads.27.C2 raw_reads.24.raw_reads.27.N2 raw_reads.24.raw_reads.27.C3 raw_reads.24.raw_reads.27.N3 && LAmerge -v L1.24.27 raw_reads.24.raw_reads.27.C0.S raw_reads.24.raw_reads.27.N0.S raw_reads.24.raw_reads.27.C1.S raw_reads.24.raw_reads.27.N1.S raw_reads.24.raw_reads.27.C2.S raw_reads.24.raw_reads.27.N2.S raw_reads.24.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.25.raw_reads.27.C0 raw_reads.25.raw_reads.27.N0 raw_reads.25.raw_reads.27.C1 raw_reads.25.raw_reads.27.N1 raw_reads.25.raw_reads.27.C2 raw_reads.25.raw_reads.27.N2 raw_reads.25.raw_reads.27.C3 raw_reads.25.raw_reads.27.N3 && LAmerge -v L1.25.27 raw_reads.25.raw_reads.27.C0.S raw_reads.25.raw_reads.27.N0.S raw_reads.25.raw_reads.27.C1.S raw_reads.25.raw_reads.27.N1.S raw_reads.25.raw_reads.27.C2.S raw_reads.25.raw_reads.27.N2.S raw_reads.25.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.26.raw_reads.27.C0 raw_reads.26.raw_reads.27.N0 raw_reads.26.raw_reads.27.C1 raw_reads.26.raw_reads.27.N1 raw_reads.26.raw_reads.27.C2 raw_reads.26.raw_reads.27.N2 raw_reads.26.raw_reads.27.C3 raw_reads.26.raw_reads.27.N3 && LAmerge -v L1.26.27 raw_reads.26.raw_reads.27.C0.S raw_reads.26.raw_reads.27.N0.S raw_reads.26.raw_reads.27.C1.S raw_reads.26.raw_reads.27.N1.S raw_reads.26.raw_reads.27.C2.S raw_reads.26.raw_reads.27.N2.S raw_reads.26.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.14.C0 raw_reads.27.raw_reads.14.N0 raw_reads.27.raw_reads.14.C1 raw_reads.27.raw_reads.14.N1 raw_reads.27.raw_reads.14.C2 raw_reads.27.raw_reads.14.N2 raw_reads.27.raw_reads.14.C3 raw_reads.27.raw_reads.14.N3 && LAmerge -v L1.27.14 raw_reads.27.raw_reads.14.C0.S raw_reads.27.raw_reads.14.N0.S raw_reads.27.raw_reads.14.C1.S raw_reads.27.raw_reads.14.N1.S raw_reads.27.raw_reads.14.C2.S raw_reads.27.raw_reads.14.N2.S raw_reads.27.raw_reads.14.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.15.C0 raw_reads.27.raw_reads.15.N0 raw_reads.27.raw_reads.15.C1 raw_reads.27.raw_reads.15.N1 raw_reads.27.raw_reads.15.C2 raw_reads.27.raw_reads.15.N2 raw_reads.27.raw_reads.15.C3 raw_reads.27.raw_reads.15.N3 && LAmerge -v L1.27.15 raw_reads.27.raw_reads.15.C0.S raw_reads.27.raw_reads.15.N0.S raw_reads.27.raw_reads.15.C1.S raw_reads.27.raw_reads.15.N1.S raw_reads.27.raw_reads.15.C2.S raw_reads.27.raw_reads.15.N2.S raw_reads.27.raw_reads.15.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.16.C0 raw_reads.27.raw_reads.16.N0 raw_reads.27.raw_reads.16.C1 raw_reads.27.raw_reads.16.N1 raw_reads.27.raw_reads.16.C2 raw_reads.27.raw_reads.16.N2 raw_reads.27.raw_reads.16.C3 raw_reads.27.raw_reads.16.N3 && LAmerge -v L1.27.16 raw_reads.27.raw_reads.16.C0.S raw_reads.27.raw_reads.16.N0.S raw_reads.27.raw_reads.16.C1.S raw_reads.27.raw_reads.16.N1.S raw_reads.27.raw_reads.16.C2.S raw_reads.27.raw_reads.16.N2.S raw_reads.27.raw_reads.16.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.17.C0 raw_reads.27.raw_reads.17.N0 raw_reads.27.raw_reads.17.C1 raw_reads.27.raw_reads.17.N1 raw_reads.27.raw_reads.17.C2 raw_reads.27.raw_reads.17.N2 raw_reads.27.raw_reads.17.C3 raw_reads.27.raw_reads.17.N3 && LAmerge -v L1.27.17 raw_reads.27.raw_reads.17.C0.S raw_reads.27.raw_reads.17.N0.S raw_reads.27.raw_reads.17.C1.S raw_reads.27.raw_reads.17.N1.S raw_reads.27.raw_reads.17.C2.S raw_reads.27.raw_reads.17.N2.S raw_reads.27.raw_reads.17.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.18.C0 raw_reads.27.raw_reads.18.N0 raw_reads.27.raw_reads.18.C1 raw_reads.27.raw_reads.18.N1 raw_reads.27.raw_reads.18.C2 raw_reads.27.raw_reads.18.N2 raw_reads.27.raw_reads.18.C3 raw_reads.27.raw_reads.18.N3 && LAmerge -v L1.27.18 raw_reads.27.raw_reads.18.C0.S raw_reads.27.raw_reads.18.N0.S raw_reads.27.raw_reads.18.C1.S raw_reads.27.raw_reads.18.N1.S raw_reads.27.raw_reads.18.C2.S raw_reads.27.raw_reads.18.N2.S raw_reads.27.raw_reads.18.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.19.C0 raw_reads.27.raw_reads.19.N0 raw_reads.27.raw_reads.19.C1 raw_reads.27.raw_reads.19.N1 raw_reads.27.raw_reads.19.C2 raw_reads.27.raw_reads.19.N2 raw_reads.27.raw_reads.19.C3 raw_reads.27.raw_reads.19.N3 && LAmerge -v L1.27.19 raw_reads.27.raw_reads.19.C0.S raw_reads.27.raw_reads.19.N0.S raw_reads.27.raw_reads.19.C1.S raw_reads.27.raw_reads.19.N1.S raw_reads.27.raw_reads.19.C2.S raw_reads.27.raw_reads.19.N2.S raw_reads.27.raw_reads.19.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.20.C0 raw_reads.27.raw_reads.20.N0 raw_reads.27.raw_reads.20.C1 raw_reads.27.raw_reads.20.N1 raw_reads.27.raw_reads.20.C2 raw_reads.27.raw_reads.20.N2 raw_reads.27.raw_reads.20.C3 raw_reads.27.raw_reads.20.N3 && LAmerge -v L1.27.20 raw_reads.27.raw_reads.20.C0.S raw_reads.27.raw_reads.20.N0.S raw_reads.27.raw_reads.20.C1.S raw_reads.27.raw_reads.20.N1.S raw_reads.27.raw_reads.20.C2.S raw_reads.27.raw_reads.20.N2.S raw_reads.27.raw_reads.20.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.21.C0 raw_reads.27.raw_reads.21.N0 raw_reads.27.raw_reads.21.C1 raw_reads.27.raw_reads.21.N1 raw_reads.27.raw_reads.21.C2 raw_reads.27.raw_reads.21.N2 raw_reads.27.raw_reads.21.C3 raw_reads.27.raw_reads.21.N3 && LAmerge -v L1.27.21 raw_reads.27.raw_reads.21.C0.S raw_reads.27.raw_reads.21.N0.S raw_reads.27.raw_reads.21.C1.S raw_reads.27.raw_reads.21.N1.S raw_reads.27.raw_reads.21.C2.S raw_reads.27.raw_reads.21.N2.S raw_reads.27.raw_reads.21.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.22.C0 raw_reads.27.raw_reads.22.N0 raw_reads.27.raw_reads.22.C1 raw_reads.27.raw_reads.22.N1 raw_reads.27.raw_reads.22.C2 raw_reads.27.raw_reads.22.N2 raw_reads.27.raw_reads.22.C3 raw_reads.27.raw_reads.22.N3 && LAmerge -v L1.27.22 raw_reads.27.raw_reads.22.C0.S raw_reads.27.raw_reads.22.N0.S raw_reads.27.raw_reads.22.C1.S raw_reads.27.raw_reads.22.N1.S raw_reads.27.raw_reads.22.C2.S raw_reads.27.raw_reads.22.N2.S raw_reads.27.raw_reads.22.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.23.C0 raw_reads.27.raw_reads.23.N0 raw_reads.27.raw_reads.23.C1 raw_reads.27.raw_reads.23.N1 raw_reads.27.raw_reads.23.C2 raw_reads.27.raw_reads.23.N2 raw_reads.27.raw_reads.23.C3 raw_reads.27.raw_reads.23.N3 && LAmerge -v L1.27.23 raw_reads.27.raw_reads.23.C0.S raw_reads.27.raw_reads.23.N0.S raw_reads.27.raw_reads.23.C1.S raw_reads.27.raw_reads.23.N1.S raw_reads.27.raw_reads.23.C2.S raw_reads.27.raw_reads.23.N2.S raw_reads.27.raw_reads.23.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.24.C0 raw_reads.27.raw_reads.24.N0 raw_reads.27.raw_reads.24.C1 raw_reads.27.raw_reads.24.N1 raw_reads.27.raw_reads.24.C2 raw_reads.27.raw_reads.24.N2 raw_reads.27.raw_reads.24.C3 raw_reads.27.raw_reads.24.N3 && LAmerge -v L1.27.24 raw_reads.27.raw_reads.24.C0.S raw_reads.27.raw_reads.24.N0.S raw_reads.27.raw_reads.24.C1.S raw_reads.27.raw_reads.24.N1.S raw_reads.27.raw_reads.24.C2.S raw_reads.27.raw_reads.24.N2.S raw_reads.27.raw_reads.24.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.25.C0 raw_reads.27.raw_reads.25.N0 raw_reads.27.raw_reads.25.C1 raw_reads.27.raw_reads.25.N1 raw_reads.27.raw_reads.25.C2 raw_reads.27.raw_reads.25.N2 raw_reads.27.raw_reads.25.C3 raw_reads.27.raw_reads.25.N3 && LAmerge -v L1.27.25 raw_reads.27.raw_reads.25.C0.S raw_reads.27.raw_reads.25.N0.S raw_reads.27.raw_reads.25.C1.S raw_reads.27.raw_reads.25.N1.S raw_reads.27.raw_reads.25.C2.S raw_reads.27.raw_reads.25.N2.S raw_reads.27.raw_reads.25.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.26.C0 raw_reads.27.raw_reads.26.N0 raw_reads.27.raw_reads.26.C1 raw_reads.27.raw_reads.26.N1 raw_reads.27.raw_reads.26.C2 raw_reads.27.raw_reads.26.N2 raw_reads.27.raw_reads.26.C3 raw_reads.27.raw_reads.26.N3 && LAmerge -v L1.27.26 raw_reads.27.raw_reads.26.C0.S raw_reads.27.raw_reads.26.N0.S raw_reads.27.raw_reads.26.C1.S raw_reads.27.raw_reads.26.N1.S raw_reads.27.raw_reads.26.C2.S raw_reads.27.raw_reads.26.N2.S raw_reads.27.raw_reads.26.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.27.C0 raw_reads.27.raw_reads.27.N0 raw_reads.27.raw_reads.27.C1 raw_reads.27.raw_reads.27.N1 raw_reads.27.raw_reads.27.C2 raw_reads.27.raw_reads.27.N2 raw_reads.27.raw_reads.27.C3 raw_reads.27.raw_reads.27.N3 && LAmerge -v L1.27.27 raw_reads.27.raw_reads.27.C0.S raw_reads.27.raw_reads.27.N0.S raw_reads.27.raw_reads.27.C1.S raw_reads.27.raw_reads.27.N1.S raw_reads.27.raw_reads.27.C2.S raw_reads.27.raw_reads.27.N2.S raw_reads.27.raw_reads.27.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.14.27
+LAcheck -vS raw_reads L1.15.27
+LAcheck -vS raw_reads L1.16.27
+LAcheck -vS raw_reads L1.17.27
+LAcheck -vS raw_reads L1.18.27
+LAcheck -vS raw_reads L1.19.27
+LAcheck -vS raw_reads L1.20.27
+LAcheck -vS raw_reads L1.21.27
+LAcheck -vS raw_reads L1.22.27
+LAcheck -vS raw_reads L1.23.27
+LAcheck -vS raw_reads L1.24.27
+LAcheck -vS raw_reads L1.25.27
+LAcheck -vS raw_reads L1.26.27
+LAcheck -vS raw_reads L1.27.14
+LAcheck -vS raw_reads L1.27.15
+LAcheck -vS raw_reads L1.27.16
+LAcheck -vS raw_reads L1.27.17
+LAcheck -vS raw_reads L1.27.18
+LAcheck -vS raw_reads L1.27.19
+LAcheck -vS raw_reads L1.27.20
+LAcheck -vS raw_reads L1.27.21
+LAcheck -vS raw_reads L1.27.22
+LAcheck -vS raw_reads L1.27.23
+LAcheck -vS raw_reads L1.27.24
+LAcheck -vS raw_reads L1.27.25
+LAcheck -vS raw_reads L1.27.26
+LAcheck -vS raw_reads L1.27.27
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.73 raw_reads.19 raw_reads.20 raw_reads.21 raw_reads.22 raw_reads.23 raw_reads.24 raw_reads.25 raw_reads.26 raw_reads.27 raw_reads.28 raw_reads.29 raw_reads.30 raw_reads.31 raw_reads.32 raw_reads.33 raw_reads.34 raw_reads.35 raw_reads.36
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.19.raw_reads.73.C0 raw_reads.19.raw_reads.73.N0 raw_reads.19.raw_reads.73.C1 raw_reads.19.raw_reads.73.N1 raw_reads.19.raw_reads.73.C2 raw_reads.19.raw_reads.73.N2 raw_reads.19.raw_reads.73.C3 raw_reads.19.raw_reads.73.N3 && LAmerge -v L1.19.73 raw_reads.19.raw_reads.73.C0.S raw_reads.19.raw_reads.73.N0.S raw_reads.19.raw_reads.73.C1.S raw_reads.19.raw_reads.73.N1.S raw_reads.19.raw_reads.73.C2.S raw_reads.19.raw_reads.73.N2.S raw_reads.19.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.20.raw_reads.73.C0 raw_reads.20.raw_reads.73.N0 raw_reads.20.raw_reads.73.C1 raw_reads.20.raw_reads.73.N1 raw_reads.20.raw_reads.73.C2 raw_reads.20.raw_reads.73.N2 raw_reads.20.raw_reads.73.C3 raw_reads.20.raw_reads.73.N3 && LAmerge -v L1.20.73 raw_reads.20.raw_reads.73.C0.S raw_reads.20.raw_reads.73.N0.S raw_reads.20.raw_reads.73.C1.S raw_reads.20.raw_reads.73.N1.S raw_reads.20.raw_reads.73.C2.S raw_reads.20.raw_reads.73.N2.S raw_reads.20.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.21.raw_reads.73.C0 raw_reads.21.raw_reads.73.N0 raw_reads.21.raw_reads.73.C1 raw_reads.21.raw_reads.73.N1 raw_reads.21.raw_reads.73.C2 raw_reads.21.raw_reads.73.N2 raw_reads.21.raw_reads.73.C3 raw_reads.21.raw_reads.73.N3 && LAmerge -v L1.21.73 raw_reads.21.raw_reads.73.C0.S raw_reads.21.raw_reads.73.N0.S raw_reads.21.raw_reads.73.C1.S raw_reads.21.raw_reads.73.N1.S raw_reads.21.raw_reads.73.C2.S raw_reads.21.raw_reads.73.N2.S raw_reads.21.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.22.raw_reads.73.C0 raw_reads.22.raw_reads.73.N0 raw_reads.22.raw_reads.73.C1 raw_reads.22.raw_reads.73.N1 raw_reads.22.raw_reads.73.C2 raw_reads.22.raw_reads.73.N2 raw_reads.22.raw_reads.73.C3 raw_reads.22.raw_reads.73.N3 && LAmerge -v L1.22.73 raw_reads.22.raw_reads.73.C0.S raw_reads.22.raw_reads.73.N0.S raw_reads.22.raw_reads.73.C1.S raw_reads.22.raw_reads.73.N1.S raw_reads.22.raw_reads.73.C2.S raw_reads.22.raw_reads.73.N2.S raw_reads.22.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.23.raw_reads.73.C0 raw_reads.23.raw_reads.73.N0 raw_reads.23.raw_reads.73.C1 raw_reads.23.raw_reads.73.N1 raw_reads.23.raw_reads.73.C2 raw_reads.23.raw_reads.73.N2 raw_reads.23.raw_reads.73.C3 raw_reads.23.raw_reads.73.N3 && LAmerge -v L1.23.73 raw_reads.23.raw_reads.73.C0.S raw_reads.23.raw_reads.73.N0.S raw_reads.23.raw_reads.73.C1.S raw_reads.23.raw_reads.73.N1.S raw_reads.23.raw_reads.73.C2.S raw_reads.23.raw_reads.73.N2.S raw_reads.23.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.24.raw_reads.73.C0 raw_reads.24.raw_reads.73.N0 raw_reads.24.raw_reads.73.C1 raw_reads.24.raw_reads.73.N1 raw_reads.24.raw_reads.73.C2 raw_reads.24.raw_reads.73.N2 raw_reads.24.raw_reads.73.C3 raw_reads.24.raw_reads.73.N3 && LAmerge -v L1.24.73 raw_reads.24.raw_reads.73.C0.S raw_reads.24.raw_reads.73.N0.S raw_reads.24.raw_reads.73.C1.S raw_reads.24.raw_reads.73.N1.S raw_reads.24.raw_reads.73.C2.S raw_reads.24.raw_reads.73.N2.S raw_reads.24.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.25.raw_reads.73.C0 raw_reads.25.raw_reads.73.N0 raw_reads.25.raw_reads.73.C1 raw_reads.25.raw_reads.73.N1 raw_reads.25.raw_reads.73.C2 raw_reads.25.raw_reads.73.N2 raw_reads.25.raw_reads.73.C3 raw_reads.25.raw_reads.73.N3 && LAmerge -v L1.25.73 raw_reads.25.raw_reads.73.C0.S raw_reads.25.raw_reads.73.N0.S raw_reads.25.raw_reads.73.C1.S raw_reads.25.raw_reads.73.N1.S raw_reads.25.raw_reads.73.C2.S raw_reads.25.raw_reads.73.N2.S raw_reads.25.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.26.raw_reads.73.C0 raw_reads.26.raw_reads.73.N0 raw_reads.26.raw_reads.73.C1 raw_reads.26.raw_reads.73.N1 raw_reads.26.raw_reads.73.C2 raw_reads.26.raw_reads.73.N2 raw_reads.26.raw_reads.73.C3 raw_reads.26.raw_reads.73.N3 && LAmerge -v L1.26.73 raw_reads.26.raw_reads.73.C0.S raw_reads.26.raw_reads.73.N0.S raw_reads.26.raw_reads.73.C1.S raw_reads.26.raw_reads.73.N1.S raw_reads.26.raw_reads.73.C2.S raw_reads.26.raw_reads.73.N2.S raw_reads.26.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.73.C0 raw_reads.27.raw_reads.73.N0 raw_reads.27.raw_reads.73.C1 raw_reads.27.raw_reads.73.N1 raw_reads.27.raw_reads.73.C2 raw_reads.27.raw_reads.73.N2 raw_reads.27.raw_reads.73.C3 raw_reads.27.raw_reads.73.N3 && LAmerge -v L1.27.73 raw_reads.27.raw_reads.73.C0.S raw_reads.27.raw_reads.73.N0.S raw_reads.27.raw_reads.73.C1.S raw_reads.27.raw_reads.73.N1.S raw_reads.27.raw_reads.73.C2.S raw_reads.27.raw_reads.73.N2.S raw_reads.27.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.28.raw_reads.73.C0 raw_reads.28.raw_reads.73.N0 raw_reads.28.raw_reads.73.C1 raw_reads.28.raw_reads.73.N1 raw_reads.28.raw_reads.73.C2 raw_reads.28.raw_reads.73.N2 raw_reads.28.raw_reads.73.C3 raw_reads.28.raw_reads.73.N3 && LAmerge -v L1.28.73 raw_reads.28.raw_reads.73.C0.S raw_reads.28.raw_reads.73.N0.S raw_reads.28.raw_reads.73.C1.S raw_reads.28.raw_reads.73.N1.S raw_reads.28.raw_reads.73.C2.S raw_reads.28.raw_reads.73.N2.S raw_reads.28.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.29.raw_reads.73.C0 raw_reads.29.raw_reads.73.N0 raw_reads.29.raw_reads.73.C1 raw_reads.29.raw_reads.73.N1 raw_reads.29.raw_reads.73.C2 raw_reads.29.raw_reads.73.N2 raw_reads.29.raw_reads.73.C3 raw_reads.29.raw_reads.73.N3 && LAmerge -v L1.29.73 raw_reads.29.raw_reads.73.C0.S raw_reads.29.raw_reads.73.N0.S raw_reads.29.raw_reads.73.C1.S raw_reads.29.raw_reads.73.N1.S raw_reads.29.raw_reads.73.C2.S raw_reads.29.raw_reads.73.N2.S raw_reads.29.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.30.raw_reads.73.C0 raw_reads.30.raw_reads.73.N0 raw_reads.30.raw_reads.73.C1 raw_reads.30.raw_reads.73.N1 raw_reads.30.raw_reads.73.C2 raw_reads.30.raw_reads.73.N2 raw_reads.30.raw_reads.73.C3 raw_reads.30.raw_reads.73.N3 && LAmerge -v L1.30.73 raw_reads.30.raw_reads.73.C0.S raw_reads.30.raw_reads.73.N0.S raw_reads.30.raw_reads.73.C1.S raw_reads.30.raw_reads.73.N1.S raw_reads.30.raw_reads.73.C2.S raw_reads.30.raw_reads.73.N2.S raw_reads.30.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.31.raw_reads.73.C0 raw_reads.31.raw_reads.73.N0 raw_reads.31.raw_reads.73.C1 raw_reads.31.raw_reads.73.N1 raw_reads.31.raw_reads.73.C2 raw_reads.31.raw_reads.73.N2 raw_reads.31.raw_reads.73.C3 raw_reads.31.raw_reads.73.N3 && LAmerge -v L1.31.73 raw_reads.31.raw_reads.73.C0.S raw_reads.31.raw_reads.73.N0.S raw_reads.31.raw_reads.73.C1.S raw_reads.31.raw_reads.73.N1.S raw_reads.31.raw_reads.73.C2.S raw_reads.31.raw_reads.73.N2.S raw_reads.31.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.32.raw_reads.73.C0 raw_reads.32.raw_reads.73.N0 raw_reads.32.raw_reads.73.C1 raw_reads.32.raw_reads.73.N1 raw_reads.32.raw_reads.73.C2 raw_reads.32.raw_reads.73.N2 raw_reads.32.raw_reads.73.C3 raw_reads.32.raw_reads.73.N3 && LAmerge -v L1.32.73 raw_reads.32.raw_reads.73.C0.S raw_reads.32.raw_reads.73.N0.S raw_reads.32.raw_reads.73.C1.S raw_reads.32.raw_reads.73.N1.S raw_reads.32.raw_reads.73.C2.S raw_reads.32.raw_reads.73.N2.S raw_reads.32.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.33.raw_reads.73.C0 raw_reads.33.raw_reads.73.N0 raw_reads.33.raw_reads.73.C1 raw_reads.33.raw_reads.73.N1 raw_reads.33.raw_reads.73.C2 raw_reads.33.raw_reads.73.N2 raw_reads.33.raw_reads.73.C3 raw_reads.33.raw_reads.73.N3 && LAmerge -v L1.33.73 raw_reads.33.raw_reads.73.C0.S raw_reads.33.raw_reads.73.N0.S raw_reads.33.raw_reads.73.C1.S raw_reads.33.raw_reads.73.N1.S raw_reads.33.raw_reads.73.C2.S raw_reads.33.raw_reads.73.N2.S raw_reads.33.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.34.raw_reads.73.C0 raw_reads.34.raw_reads.73.N0 raw_reads.34.raw_reads.73.C1 raw_reads.34.raw_reads.73.N1 raw_reads.34.raw_reads.73.C2 raw_reads.34.raw_reads.73.N2 raw_reads.34.raw_reads.73.C3 raw_reads.34.raw_reads.73.N3 && LAmerge -v L1.34.73 raw_reads.34.raw_reads.73.C0.S raw_reads.34.raw_reads.73.N0.S raw_reads.34.raw_reads.73.C1.S raw_reads.34.raw_reads.73.N1.S raw_reads.34.raw_reads.73.C2.S raw_reads.34.raw_reads.73.N2.S raw_reads.34.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.35.raw_reads.73.C0 raw_reads.35.raw_reads.73.N0 raw_reads.35.raw_reads.73.C1 raw_reads.35.raw_reads.73.N1 raw_reads.35.raw_reads.73.C2 raw_reads.35.raw_reads.73.N2 raw_reads.35.raw_reads.73.C3 raw_reads.35.raw_reads.73.N3 && LAmerge -v L1.35.73 raw_reads.35.raw_reads.73.C0.S raw_reads.35.raw_reads.73.N0.S raw_reads.35.raw_reads.73.C1.S raw_reads.35.raw_reads.73.N1.S raw_reads.35.raw_reads.73.C2.S raw_reads.35.raw_reads.73.N2.S raw_reads.35.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.36.raw_reads.73.C0 raw_reads.36.raw_reads.73.N0 raw_reads.36.raw_reads.73.C1 raw_reads.36.raw_reads.73.N1 raw_reads.36.raw_reads.73.C2 raw_reads.36.raw_reads.73.N2 raw_reads.36.raw_reads.73.C3 raw_reads.36.raw_reads.73.N3 && LAmerge -v L1.36.73 raw_reads.36.raw_reads.73.C0.S raw_reads.36.raw_reads.73.N0.S raw_reads.36.raw_reads.73.C1.S raw_reads.36.raw_reads.73.N1.S raw_reads.36.raw_reads.73.C2.S raw_reads.36.raw_reads.73.N2.S raw_reads.36.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.19.C0 raw_reads.73.raw_reads.19.N0 raw_reads.73.raw_reads.19.C1 raw_reads.73.raw_reads.19.N1 raw_reads.73.raw_reads.19.C2 raw_reads.73.raw_reads.19.N2 raw_reads.73.raw_reads.19.C3 raw_reads.73.raw_reads.19.N3 && LAmerge -v L1.73.19 raw_reads.73.raw_reads.19.C0.S raw_reads.73.raw_reads.19.N0.S raw_reads.73.raw_reads.19.C1.S raw_reads.73.raw_reads.19.N1.S raw_reads.73.raw_reads.19.C2.S raw_reads.73.raw_reads.19.N2.S raw_reads.73.raw_reads.19.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.20.C0 raw_reads.73.raw_reads.20.N0 raw_reads.73.raw_reads.20.C1 raw_reads.73.raw_reads.20.N1 raw_reads.73.raw_reads.20.C2 raw_reads.73.raw_reads.20.N2 raw_reads.73.raw_reads.20.C3 raw_reads.73.raw_reads.20.N3 && LAmerge -v L1.73.20 raw_reads.73.raw_reads.20.C0.S raw_reads.73.raw_reads.20.N0.S raw_reads.73.raw_reads.20.C1.S raw_reads.73.raw_reads.20.N1.S raw_reads.73.raw_reads.20.C2.S raw_reads.73.raw_reads.20.N2.S raw_reads.73.raw_reads.20.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.21.C0 raw_reads.73.raw_reads.21.N0 raw_reads.73.raw_reads.21.C1 raw_reads.73.raw_reads.21.N1 raw_reads.73.raw_reads.21.C2 raw_reads.73.raw_reads.21.N2 raw_reads.73.raw_reads.21.C3 raw_reads.73.raw_reads.21.N3 && LAmerge -v L1.73.21 raw_reads.73.raw_reads.21.C0.S raw_reads.73.raw_reads.21.N0.S raw_reads.73.raw_reads.21.C1.S raw_reads.73.raw_reads.21.N1.S raw_reads.73.raw_reads.21.C2.S raw_reads.73.raw_reads.21.N2.S raw_reads.73.raw_reads.21.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.22.C0 raw_reads.73.raw_reads.22.N0 raw_reads.73.raw_reads.22.C1 raw_reads.73.raw_reads.22.N1 raw_reads.73.raw_reads.22.C2 raw_reads.73.raw_reads.22.N2 raw_reads.73.raw_reads.22.C3 raw_reads.73.raw_reads.22.N3 && LAmerge -v L1.73.22 raw_reads.73.raw_reads.22.C0.S raw_reads.73.raw_reads.22.N0.S raw_reads.73.raw_reads.22.C1.S raw_reads.73.raw_reads.22.N1.S raw_reads.73.raw_reads.22.C2.S raw_reads.73.raw_reads.22.N2.S raw_reads.73.raw_reads.22.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.23.C0 raw_reads.73.raw_reads.23.N0 raw_reads.73.raw_reads.23.C1 raw_reads.73.raw_reads.23.N1 raw_reads.73.raw_reads.23.C2 raw_reads.73.raw_reads.23.N2 raw_reads.73.raw_reads.23.C3 raw_reads.73.raw_reads.23.N3 && LAmerge -v L1.73.23 raw_reads.73.raw_reads.23.C0.S raw_reads.73.raw_reads.23.N0.S raw_reads.73.raw_reads.23.C1.S raw_reads.73.raw_reads.23.N1.S raw_reads.73.raw_reads.23.C2.S raw_reads.73.raw_reads.23.N2.S raw_reads.73.raw_reads.23.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.24.C0 raw_reads.73.raw_reads.24.N0 raw_reads.73.raw_reads.24.C1 raw_reads.73.raw_reads.24.N1 raw_reads.73.raw_reads.24.C2 raw_reads.73.raw_reads.24.N2 raw_reads.73.raw_reads.24.C3 raw_reads.73.raw_reads.24.N3 && LAmerge -v L1.73.24 raw_reads.73.raw_reads.24.C0.S raw_reads.73.raw_reads.24.N0.S raw_reads.73.raw_reads.24.C1.S raw_reads.73.raw_reads.24.N1.S raw_reads.73.raw_reads.24.C2.S raw_reads.73.raw_reads.24.N2.S raw_reads.73.raw_reads.24.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.25.C0 raw_reads.73.raw_reads.25.N0 raw_reads.73.raw_reads.25.C1 raw_reads.73.raw_reads.25.N1 raw_reads.73.raw_reads.25.C2 raw_reads.73.raw_reads.25.N2 raw_reads.73.raw_reads.25.C3 raw_reads.73.raw_reads.25.N3 && LAmerge -v L1.73.25 raw_reads.73.raw_reads.25.C0.S raw_reads.73.raw_reads.25.N0.S raw_reads.73.raw_reads.25.C1.S raw_reads.73.raw_reads.25.N1.S raw_reads.73.raw_reads.25.C2.S raw_reads.73.raw_reads.25.N2.S raw_reads.73.raw_reads.25.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.26.C0 raw_reads.73.raw_reads.26.N0 raw_reads.73.raw_reads.26.C1 raw_reads.73.raw_reads.26.N1 raw_reads.73.raw_reads.26.C2 raw_reads.73.raw_reads.26.N2 raw_reads.73.raw_reads.26.C3 raw_reads.73.raw_reads.26.N3 && LAmerge -v L1.73.26 raw_reads.73.raw_reads.26.C0.S raw_reads.73.raw_reads.26.N0.S raw_reads.73.raw_reads.26.C1.S raw_reads.73.raw_reads.26.N1.S raw_reads.73.raw_reads.26.C2.S raw_reads.73.raw_reads.26.N2.S raw_reads.73.raw_reads.26.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.27.C0 raw_reads.73.raw_reads.27.N0 raw_reads.73.raw_reads.27.C1 raw_reads.73.raw_reads.27.N1 raw_reads.73.raw_reads.27.C2 raw_reads.73.raw_reads.27.N2 raw_reads.73.raw_reads.27.C3 raw_reads.73.raw_reads.27.N3 && LAmerge -v L1.73.27 raw_reads.73.raw_reads.27.C0.S raw_reads.73.raw_reads.27.N0.S raw_reads.73.raw_reads.27.C1.S raw_reads.73.raw_reads.27.N1.S raw_reads.73.raw_reads.27.C2.S raw_reads.73.raw_reads.27.N2.S raw_reads.73.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.28.C0 raw_reads.73.raw_reads.28.N0 raw_reads.73.raw_reads.28.C1 raw_reads.73.raw_reads.28.N1 raw_reads.73.raw_reads.28.C2 raw_reads.73.raw_reads.28.N2 raw_reads.73.raw_reads.28.C3 raw_reads.73.raw_reads.28.N3 && LAmerge -v L1.73.28 raw_reads.73.raw_reads.28.C0.S raw_reads.73.raw_reads.28.N0.S raw_reads.73.raw_reads.28.C1.S raw_reads.73.raw_reads.28.N1.S raw_reads.73.raw_reads.28.C2.S raw_reads.73.raw_reads.28.N2.S raw_reads.73.raw_reads.28.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.29.C0 raw_reads.73.raw_reads.29.N0 raw_reads.73.raw_reads.29.C1 raw_reads.73.raw_reads.29.N1 raw_reads.73.raw_reads.29.C2 raw_reads.73.raw_reads.29.N2 raw_reads.73.raw_reads.29.C3 raw_reads.73.raw_reads.29.N3 && LAmerge -v L1.73.29 raw_reads.73.raw_reads.29.C0.S raw_reads.73.raw_reads.29.N0.S raw_reads.73.raw_reads.29.C1.S raw_reads.73.raw_reads.29.N1.S raw_reads.73.raw_reads.29.C2.S raw_reads.73.raw_reads.29.N2.S raw_reads.73.raw_reads.29.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.30.C0 raw_reads.73.raw_reads.30.N0 raw_reads.73.raw_reads.30.C1 raw_reads.73.raw_reads.30.N1 raw_reads.73.raw_reads.30.C2 raw_reads.73.raw_reads.30.N2 raw_reads.73.raw_reads.30.C3 raw_reads.73.raw_reads.30.N3 && LAmerge -v L1.73.30 raw_reads.73.raw_reads.30.C0.S raw_reads.73.raw_reads.30.N0.S raw_reads.73.raw_reads.30.C1.S raw_reads.73.raw_reads.30.N1.S raw_reads.73.raw_reads.30.C2.S raw_reads.73.raw_reads.30.N2.S raw_reads.73.raw_reads.30.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.31.C0 raw_reads.73.raw_reads.31.N0 raw_reads.73.raw_reads.31.C1 raw_reads.73.raw_reads.31.N1 raw_reads.73.raw_reads.31.C2 raw_reads.73.raw_reads.31.N2 raw_reads.73.raw_reads.31.C3 raw_reads.73.raw_reads.31.N3 && LAmerge -v L1.73.31 raw_reads.73.raw_reads.31.C0.S raw_reads.73.raw_reads.31.N0.S raw_reads.73.raw_reads.31.C1.S raw_reads.73.raw_reads.31.N1.S raw_reads.73.raw_reads.31.C2.S raw_reads.73.raw_reads.31.N2.S raw_reads.73.raw_reads.31.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.32.C0 raw_reads.73.raw_reads.32.N0 raw_reads.73.raw_reads.32.C1 raw_reads.73.raw_reads.32.N1 raw_reads.73.raw_reads.32.C2 raw_reads.73.raw_reads.32.N2 raw_reads.73.raw_reads.32.C3 raw_reads.73.raw_reads.32.N3 && LAmerge -v L1.73.32 raw_reads.73.raw_reads.32.C0.S raw_reads.73.raw_reads.32.N0.S raw_reads.73.raw_reads.32.C1.S raw_reads.73.raw_reads.32.N1.S raw_reads.73.raw_reads.32.C2.S raw_reads.73.raw_reads.32.N2.S raw_reads.73.raw_reads.32.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.33.C0 raw_reads.73.raw_reads.33.N0 raw_reads.73.raw_reads.33.C1 raw_reads.73.raw_reads.33.N1 raw_reads.73.raw_reads.33.C2 raw_reads.73.raw_reads.33.N2 raw_reads.73.raw_reads.33.C3 raw_reads.73.raw_reads.33.N3 && LAmerge -v L1.73.33 raw_reads.73.raw_reads.33.C0.S raw_reads.73.raw_reads.33.N0.S raw_reads.73.raw_reads.33.C1.S raw_reads.73.raw_reads.33.N1.S raw_reads.73.raw_reads.33.C2.S raw_reads.73.raw_reads.33.N2.S raw_reads.73.raw_reads.33.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.34.C0 raw_reads.73.raw_reads.34.N0 raw_reads.73.raw_reads.34.C1 raw_reads.73.raw_reads.34.N1 raw_reads.73.raw_reads.34.C2 raw_reads.73.raw_reads.34.N2 raw_reads.73.raw_reads.34.C3 raw_reads.73.raw_reads.34.N3 && LAmerge -v L1.73.34 raw_reads.73.raw_reads.34.C0.S raw_reads.73.raw_reads.34.N0.S raw_reads.73.raw_reads.34.C1.S raw_reads.73.raw_reads.34.N1.S raw_reads.73.raw_reads.34.C2.S raw_reads.73.raw_reads.34.N2.S raw_reads.73.raw_reads.34.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.35.C0 raw_reads.73.raw_reads.35.N0 raw_reads.73.raw_reads.35.C1 raw_reads.73.raw_reads.35.N1 raw_reads.73.raw_reads.35.C2 raw_reads.73.raw_reads.35.N2 raw_reads.73.raw_reads.35.C3 raw_reads.73.raw_reads.35.N3 && LAmerge -v L1.73.35 raw_reads.73.raw_reads.35.C0.S raw_reads.73.raw_reads.35.N0.S raw_reads.73.raw_reads.35.C1.S raw_reads.73.raw_reads.35.N1.S raw_reads.73.raw_reads.35.C2.S raw_reads.73.raw_reads.35.N2.S raw_reads.73.raw_reads.35.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.36.C0 raw_reads.73.raw_reads.36.N0 raw_reads.73.raw_reads.36.C1 raw_reads.73.raw_reads.36.N1 raw_reads.73.raw_reads.36.C2 raw_reads.73.raw_reads.36.N2 raw_reads.73.raw_reads.36.C3 raw_reads.73.raw_reads.36.N3 && LAmerge -v L1.73.36 raw_reads.73.raw_reads.36.C0.S raw_reads.73.raw_reads.36.N0.S raw_reads.73.raw_reads.36.C1.S raw_reads.73.raw_reads.36.N1.S raw_reads.73.raw_reads.36.C2.S raw_reads.73.raw_reads.36.N2.S raw_reads.73.raw_reads.36.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.19.73
+LAcheck -vS raw_reads L1.20.73
+LAcheck -vS raw_reads L1.21.73
+LAcheck -vS raw_reads L1.22.73
+LAcheck -vS raw_reads L1.23.73
+LAcheck -vS raw_reads L1.24.73
+LAcheck -vS raw_reads L1.25.73
+LAcheck -vS raw_reads L1.26.73
+LAcheck -vS raw_reads L1.27.73
+LAcheck -vS raw_reads L1.28.73
+LAcheck -vS raw_reads L1.29.73
+LAcheck -vS raw_reads L1.30.73
+LAcheck -vS raw_reads L1.31.73
+LAcheck -vS raw_reads L1.32.73
+LAcheck -vS raw_reads L1.33.73
+LAcheck -vS raw_reads L1.34.73
+LAcheck -vS raw_reads L1.35.73
+LAcheck -vS raw_reads L1.36.73
+LAcheck -vS raw_reads L1.73.19
+LAcheck -vS raw_reads L1.73.20
+LAcheck -vS raw_reads L1.73.21
+LAcheck -vS raw_reads L1.73.22
+LAcheck -vS raw_reads L1.73.23
+LAcheck -vS raw_reads L1.73.24
+LAcheck -vS raw_reads L1.73.25
+LAcheck -vS raw_reads L1.73.26
+LAcheck -vS raw_reads L1.73.27
+LAcheck -vS raw_reads L1.73.28
+LAcheck -vS raw_reads L1.73.29
+LAcheck -vS raw_reads L1.73.30
+LAcheck -vS raw_reads L1.73.31
+LAcheck -vS raw_reads L1.73.32
+LAcheck -vS raw_reads L1.73.33
+LAcheck -vS raw_reads L1.73.34
+LAcheck -vS raw_reads L1.73.35
+LAcheck -vS raw_reads L1.73.36
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.37 raw_reads.19 raw_reads.20 raw_reads.21 raw_reads.22 raw_reads.23 raw_reads.24 raw_reads.25 raw_reads.26 raw_reads.27 raw_reads.28 raw_reads.29 raw_reads.30 raw_reads.31 raw_reads.32 raw_reads.33 raw_reads.34 raw_reads.35 raw_reads.36 raw_reads.37
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.19.raw_reads.37.C0 raw_reads.19.raw_reads.37.N0 raw_reads.19.raw_reads.37.C1 raw_reads.19.raw_reads.37.N1 raw_reads.19.raw_reads.37.C2 raw_reads.19.raw_reads.37.N2 raw_reads.19.raw_reads.37.C3 raw_reads.19.raw_reads.37.N3 && LAmerge -v L1.19.37 raw_reads.19.raw_reads.37.C0.S raw_reads.19.raw_reads.37.N0.S raw_reads.19.raw_reads.37.C1.S raw_reads.19.raw_reads.37.N1.S raw_reads.19.raw_reads.37.C2.S raw_reads.19.raw_reads.37.N2.S raw_reads.19.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.20.raw_reads.37.C0 raw_reads.20.raw_reads.37.N0 raw_reads.20.raw_reads.37.C1 raw_reads.20.raw_reads.37.N1 raw_reads.20.raw_reads.37.C2 raw_reads.20.raw_reads.37.N2 raw_reads.20.raw_reads.37.C3 raw_reads.20.raw_reads.37.N3 && LAmerge -v L1.20.37 raw_reads.20.raw_reads.37.C0.S raw_reads.20.raw_reads.37.N0.S raw_reads.20.raw_reads.37.C1.S raw_reads.20.raw_reads.37.N1.S raw_reads.20.raw_reads.37.C2.S raw_reads.20.raw_reads.37.N2.S raw_reads.20.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.21.raw_reads.37.C0 raw_reads.21.raw_reads.37.N0 raw_reads.21.raw_reads.37.C1 raw_reads.21.raw_reads.37.N1 raw_reads.21.raw_reads.37.C2 raw_reads.21.raw_reads.37.N2 raw_reads.21.raw_reads.37.C3 raw_reads.21.raw_reads.37.N3 && LAmerge -v L1.21.37 raw_reads.21.raw_reads.37.C0.S raw_reads.21.raw_reads.37.N0.S raw_reads.21.raw_reads.37.C1.S raw_reads.21.raw_reads.37.N1.S raw_reads.21.raw_reads.37.C2.S raw_reads.21.raw_reads.37.N2.S raw_reads.21.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.22.raw_reads.37.C0 raw_reads.22.raw_reads.37.N0 raw_reads.22.raw_reads.37.C1 raw_reads.22.raw_reads.37.N1 raw_reads.22.raw_reads.37.C2 raw_reads.22.raw_reads.37.N2 raw_reads.22.raw_reads.37.C3 raw_reads.22.raw_reads.37.N3 && LAmerge -v L1.22.37 raw_reads.22.raw_reads.37.C0.S raw_reads.22.raw_reads.37.N0.S raw_reads.22.raw_reads.37.C1.S raw_reads.22.raw_reads.37.N1.S raw_reads.22.raw_reads.37.C2.S raw_reads.22.raw_reads.37.N2.S raw_reads.22.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.23.raw_reads.37.C0 raw_reads.23.raw_reads.37.N0 raw_reads.23.raw_reads.37.C1 raw_reads.23.raw_reads.37.N1 raw_reads.23.raw_reads.37.C2 raw_reads.23.raw_reads.37.N2 raw_reads.23.raw_reads.37.C3 raw_reads.23.raw_reads.37.N3 && LAmerge -v L1.23.37 raw_reads.23.raw_reads.37.C0.S raw_reads.23.raw_reads.37.N0.S raw_reads.23.raw_reads.37.C1.S raw_reads.23.raw_reads.37.N1.S raw_reads.23.raw_reads.37.C2.S raw_reads.23.raw_reads.37.N2.S raw_reads.23.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.24.raw_reads.37.C0 raw_reads.24.raw_reads.37.N0 raw_reads.24.raw_reads.37.C1 raw_reads.24.raw_reads.37.N1 raw_reads.24.raw_reads.37.C2 raw_reads.24.raw_reads.37.N2 raw_reads.24.raw_reads.37.C3 raw_reads.24.raw_reads.37.N3 && LAmerge -v L1.24.37 raw_reads.24.raw_reads.37.C0.S raw_reads.24.raw_reads.37.N0.S raw_reads.24.raw_reads.37.C1.S raw_reads.24.raw_reads.37.N1.S raw_reads.24.raw_reads.37.C2.S raw_reads.24.raw_reads.37.N2.S raw_reads.24.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.25.raw_reads.37.C0 raw_reads.25.raw_reads.37.N0 raw_reads.25.raw_reads.37.C1 raw_reads.25.raw_reads.37.N1 raw_reads.25.raw_reads.37.C2 raw_reads.25.raw_reads.37.N2 raw_reads.25.raw_reads.37.C3 raw_reads.25.raw_reads.37.N3 && LAmerge -v L1.25.37 raw_reads.25.raw_reads.37.C0.S raw_reads.25.raw_reads.37.N0.S raw_reads.25.raw_reads.37.C1.S raw_reads.25.raw_reads.37.N1.S raw_reads.25.raw_reads.37.C2.S raw_reads.25.raw_reads.37.N2.S raw_reads.25.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.26.raw_reads.37.C0 raw_reads.26.raw_reads.37.N0 raw_reads.26.raw_reads.37.C1 raw_reads.26.raw_reads.37.N1 raw_reads.26.raw_reads.37.C2 raw_reads.26.raw_reads.37.N2 raw_reads.26.raw_reads.37.C3 raw_reads.26.raw_reads.37.N3 && LAmerge -v L1.26.37 raw_reads.26.raw_reads.37.C0.S raw_reads.26.raw_reads.37.N0.S raw_reads.26.raw_reads.37.C1.S raw_reads.26.raw_reads.37.N1.S raw_reads.26.raw_reads.37.C2.S raw_reads.26.raw_reads.37.N2.S raw_reads.26.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.37.C0 raw_reads.27.raw_reads.37.N0 raw_reads.27.raw_reads.37.C1 raw_reads.27.raw_reads.37.N1 raw_reads.27.raw_reads.37.C2 raw_reads.27.raw_reads.37.N2 raw_reads.27.raw_reads.37.C3 raw_reads.27.raw_reads.37.N3 && LAmerge -v L1.27.37 raw_reads.27.raw_reads.37.C0.S raw_reads.27.raw_reads.37.N0.S raw_reads.27.raw_reads.37.C1.S raw_reads.27.raw_reads.37.N1.S raw_reads.27.raw_reads.37.C2.S raw_reads.27.raw_reads.37.N2.S raw_reads.27.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.28.raw_reads.37.C0 raw_reads.28.raw_reads.37.N0 raw_reads.28.raw_reads.37.C1 raw_reads.28.raw_reads.37.N1 raw_reads.28.raw_reads.37.C2 raw_reads.28.raw_reads.37.N2 raw_reads.28.raw_reads.37.C3 raw_reads.28.raw_reads.37.N3 && LAmerge -v L1.28.37 raw_reads.28.raw_reads.37.C0.S raw_reads.28.raw_reads.37.N0.S raw_reads.28.raw_reads.37.C1.S raw_reads.28.raw_reads.37.N1.S raw_reads.28.raw_reads.37.C2.S raw_reads.28.raw_reads.37.N2.S raw_reads.28.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.29.raw_reads.37.C0 raw_reads.29.raw_reads.37.N0 raw_reads.29.raw_reads.37.C1 raw_reads.29.raw_reads.37.N1 raw_reads.29.raw_reads.37.C2 raw_reads.29.raw_reads.37.N2 raw_reads.29.raw_reads.37.C3 raw_reads.29.raw_reads.37.N3 && LAmerge -v L1.29.37 raw_reads.29.raw_reads.37.C0.S raw_reads.29.raw_reads.37.N0.S raw_reads.29.raw_reads.37.C1.S raw_reads.29.raw_reads.37.N1.S raw_reads.29.raw_reads.37.C2.S raw_reads.29.raw_reads.37.N2.S raw_reads.29.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.30.raw_reads.37.C0 raw_reads.30.raw_reads.37.N0 raw_reads.30.raw_reads.37.C1 raw_reads.30.raw_reads.37.N1 raw_reads.30.raw_reads.37.C2 raw_reads.30.raw_reads.37.N2 raw_reads.30.raw_reads.37.C3 raw_reads.30.raw_reads.37.N3 && LAmerge -v L1.30.37 raw_reads.30.raw_reads.37.C0.S raw_reads.30.raw_reads.37.N0.S raw_reads.30.raw_reads.37.C1.S raw_reads.30.raw_reads.37.N1.S raw_reads.30.raw_reads.37.C2.S raw_reads.30.raw_reads.37.N2.S raw_reads.30.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.31.raw_reads.37.C0 raw_reads.31.raw_reads.37.N0 raw_reads.31.raw_reads.37.C1 raw_reads.31.raw_reads.37.N1 raw_reads.31.raw_reads.37.C2 raw_reads.31.raw_reads.37.N2 raw_reads.31.raw_reads.37.C3 raw_reads.31.raw_reads.37.N3 && LAmerge -v L1.31.37 raw_reads.31.raw_reads.37.C0.S raw_reads.31.raw_reads.37.N0.S raw_reads.31.raw_reads.37.C1.S raw_reads.31.raw_reads.37.N1.S raw_reads.31.raw_reads.37.C2.S raw_reads.31.raw_reads.37.N2.S raw_reads.31.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.32.raw_reads.37.C0 raw_reads.32.raw_reads.37.N0 raw_reads.32.raw_reads.37.C1 raw_reads.32.raw_reads.37.N1 raw_reads.32.raw_reads.37.C2 raw_reads.32.raw_reads.37.N2 raw_reads.32.raw_reads.37.C3 raw_reads.32.raw_reads.37.N3 && LAmerge -v L1.32.37 raw_reads.32.raw_reads.37.C0.S raw_reads.32.raw_reads.37.N0.S raw_reads.32.raw_reads.37.C1.S raw_reads.32.raw_reads.37.N1.S raw_reads.32.raw_reads.37.C2.S raw_reads.32.raw_reads.37.N2.S raw_reads.32.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.33.raw_reads.37.C0 raw_reads.33.raw_reads.37.N0 raw_reads.33.raw_reads.37.C1 raw_reads.33.raw_reads.37.N1 raw_reads.33.raw_reads.37.C2 raw_reads.33.raw_reads.37.N2 raw_reads.33.raw_reads.37.C3 raw_reads.33.raw_reads.37.N3 && LAmerge -v L1.33.37 raw_reads.33.raw_reads.37.C0.S raw_reads.33.raw_reads.37.N0.S raw_reads.33.raw_reads.37.C1.S raw_reads.33.raw_reads.37.N1.S raw_reads.33.raw_reads.37.C2.S raw_reads.33.raw_reads.37.N2.S raw_reads.33.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.34.raw_reads.37.C0 raw_reads.34.raw_reads.37.N0 raw_reads.34.raw_reads.37.C1 raw_reads.34.raw_reads.37.N1 raw_reads.34.raw_reads.37.C2 raw_reads.34.raw_reads.37.N2 raw_reads.34.raw_reads.37.C3 raw_reads.34.raw_reads.37.N3 && LAmerge -v L1.34.37 raw_reads.34.raw_reads.37.C0.S raw_reads.34.raw_reads.37.N0.S raw_reads.34.raw_reads.37.C1.S raw_reads.34.raw_reads.37.N1.S raw_reads.34.raw_reads.37.C2.S raw_reads.34.raw_reads.37.N2.S raw_reads.34.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.35.raw_reads.37.C0 raw_reads.35.raw_reads.37.N0 raw_reads.35.raw_reads.37.C1 raw_reads.35.raw_reads.37.N1 raw_reads.35.raw_reads.37.C2 raw_reads.35.raw_reads.37.N2 raw_reads.35.raw_reads.37.C3 raw_reads.35.raw_reads.37.N3 && LAmerge -v L1.35.37 raw_reads.35.raw_reads.37.C0.S raw_reads.35.raw_reads.37.N0.S raw_reads.35.raw_reads.37.C1.S raw_reads.35.raw_reads.37.N1.S raw_reads.35.raw_reads.37.C2.S raw_reads.35.raw_reads.37.N2.S raw_reads.35.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.36.raw_reads.37.C0 raw_reads.36.raw_reads.37.N0 raw_reads.36.raw_reads.37.C1 raw_reads.36.raw_reads.37.N1 raw_reads.36.raw_reads.37.C2 raw_reads.36.raw_reads.37.N2 raw_reads.36.raw_reads.37.C3 raw_reads.36.raw_reads.37.N3 && LAmerge -v L1.36.37 raw_reads.36.raw_reads.37.C0.S raw_reads.36.raw_reads.37.N0.S raw_reads.36.raw_reads.37.C1.S raw_reads.36.raw_reads.37.N1.S raw_reads.36.raw_reads.37.C2.S raw_reads.36.raw_reads.37.N2.S raw_reads.36.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.19.C0 raw_reads.37.raw_reads.19.N0 raw_reads.37.raw_reads.19.C1 raw_reads.37.raw_reads.19.N1 raw_reads.37.raw_reads.19.C2 raw_reads.37.raw_reads.19.N2 raw_reads.37.raw_reads.19.C3 raw_reads.37.raw_reads.19.N3 && LAmerge -v L1.37.19 raw_reads.37.raw_reads.19.C0.S raw_reads.37.raw_reads.19.N0.S raw_reads.37.raw_reads.19.C1.S raw_reads.37.raw_reads.19.N1.S raw_reads.37.raw_reads.19.C2.S raw_reads.37.raw_reads.19.N2.S raw_reads.37.raw_reads.19.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.20.C0 raw_reads.37.raw_reads.20.N0 raw_reads.37.raw_reads.20.C1 raw_reads.37.raw_reads.20.N1 raw_reads.37.raw_reads.20.C2 raw_reads.37.raw_reads.20.N2 raw_reads.37.raw_reads.20.C3 raw_reads.37.raw_reads.20.N3 && LAmerge -v L1.37.20 raw_reads.37.raw_reads.20.C0.S raw_reads.37.raw_reads.20.N0.S raw_reads.37.raw_reads.20.C1.S raw_reads.37.raw_reads.20.N1.S raw_reads.37.raw_reads.20.C2.S raw_reads.37.raw_reads.20.N2.S raw_reads.37.raw_reads.20.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.21.C0 raw_reads.37.raw_reads.21.N0 raw_reads.37.raw_reads.21.C1 raw_reads.37.raw_reads.21.N1 raw_reads.37.raw_reads.21.C2 raw_reads.37.raw_reads.21.N2 raw_reads.37.raw_reads.21.C3 raw_reads.37.raw_reads.21.N3 && LAmerge -v L1.37.21 raw_reads.37.raw_reads.21.C0.S raw_reads.37.raw_reads.21.N0.S raw_reads.37.raw_reads.21.C1.S raw_reads.37.raw_reads.21.N1.S raw_reads.37.raw_reads.21.C2.S raw_reads.37.raw_reads.21.N2.S raw_reads.37.raw_reads.21.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.22.C0 raw_reads.37.raw_reads.22.N0 raw_reads.37.raw_reads.22.C1 raw_reads.37.raw_reads.22.N1 raw_reads.37.raw_reads.22.C2 raw_reads.37.raw_reads.22.N2 raw_reads.37.raw_reads.22.C3 raw_reads.37.raw_reads.22.N3 && LAmerge -v L1.37.22 raw_reads.37.raw_reads.22.C0.S raw_reads.37.raw_reads.22.N0.S raw_reads.37.raw_reads.22.C1.S raw_reads.37.raw_reads.22.N1.S raw_reads.37.raw_reads.22.C2.S raw_reads.37.raw_reads.22.N2.S raw_reads.37.raw_reads.22.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.23.C0 raw_reads.37.raw_reads.23.N0 raw_reads.37.raw_reads.23.C1 raw_reads.37.raw_reads.23.N1 raw_reads.37.raw_reads.23.C2 raw_reads.37.raw_reads.23.N2 raw_reads.37.raw_reads.23.C3 raw_reads.37.raw_reads.23.N3 && LAmerge -v L1.37.23 raw_reads.37.raw_reads.23.C0.S raw_reads.37.raw_reads.23.N0.S raw_reads.37.raw_reads.23.C1.S raw_reads.37.raw_reads.23.N1.S raw_reads.37.raw_reads.23.C2.S raw_reads.37.raw_reads.23.N2.S raw_reads.37.raw_reads.23.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.24.C0 raw_reads.37.raw_reads.24.N0 raw_reads.37.raw_reads.24.C1 raw_reads.37.raw_reads.24.N1 raw_reads.37.raw_reads.24.C2 raw_reads.37.raw_reads.24.N2 raw_reads.37.raw_reads.24.C3 raw_reads.37.raw_reads.24.N3 && LAmerge -v L1.37.24 raw_reads.37.raw_reads.24.C0.S raw_reads.37.raw_reads.24.N0.S raw_reads.37.raw_reads.24.C1.S raw_reads.37.raw_reads.24.N1.S raw_reads.37.raw_reads.24.C2.S raw_reads.37.raw_reads.24.N2.S raw_reads.37.raw_reads.24.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.25.C0 raw_reads.37.raw_reads.25.N0 raw_reads.37.raw_reads.25.C1 raw_reads.37.raw_reads.25.N1 raw_reads.37.raw_reads.25.C2 raw_reads.37.raw_reads.25.N2 raw_reads.37.raw_reads.25.C3 raw_reads.37.raw_reads.25.N3 && LAmerge -v L1.37.25 raw_reads.37.raw_reads.25.C0.S raw_reads.37.raw_reads.25.N0.S raw_reads.37.raw_reads.25.C1.S raw_reads.37.raw_reads.25.N1.S raw_reads.37.raw_reads.25.C2.S raw_reads.37.raw_reads.25.N2.S raw_reads.37.raw_reads.25.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.26.C0 raw_reads.37.raw_reads.26.N0 raw_reads.37.raw_reads.26.C1 raw_reads.37.raw_reads.26.N1 raw_reads.37.raw_reads.26.C2 raw_reads.37.raw_reads.26.N2 raw_reads.37.raw_reads.26.C3 raw_reads.37.raw_reads.26.N3 && LAmerge -v L1.37.26 raw_reads.37.raw_reads.26.C0.S raw_reads.37.raw_reads.26.N0.S raw_reads.37.raw_reads.26.C1.S raw_reads.37.raw_reads.26.N1.S raw_reads.37.raw_reads.26.C2.S raw_reads.37.raw_reads.26.N2.S raw_reads.37.raw_reads.26.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.27.C0 raw_reads.37.raw_reads.27.N0 raw_reads.37.raw_reads.27.C1 raw_reads.37.raw_reads.27.N1 raw_reads.37.raw_reads.27.C2 raw_reads.37.raw_reads.27.N2 raw_reads.37.raw_reads.27.C3 raw_reads.37.raw_reads.27.N3 && LAmerge -v L1.37.27 raw_reads.37.raw_reads.27.C0.S raw_reads.37.raw_reads.27.N0.S raw_reads.37.raw_reads.27.C1.S raw_reads.37.raw_reads.27.N1.S raw_reads.37.raw_reads.27.C2.S raw_reads.37.raw_reads.27.N2.S raw_reads.37.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.28.C0 raw_reads.37.raw_reads.28.N0 raw_reads.37.raw_reads.28.C1 raw_reads.37.raw_reads.28.N1 raw_reads.37.raw_reads.28.C2 raw_reads.37.raw_reads.28.N2 raw_reads.37.raw_reads.28.C3 raw_reads.37.raw_reads.28.N3 && LAmerge -v L1.37.28 raw_reads.37.raw_reads.28.C0.S raw_reads.37.raw_reads.28.N0.S raw_reads.37.raw_reads.28.C1.S raw_reads.37.raw_reads.28.N1.S raw_reads.37.raw_reads.28.C2.S raw_reads.37.raw_reads.28.N2.S raw_reads.37.raw_reads.28.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.29.C0 raw_reads.37.raw_reads.29.N0 raw_reads.37.raw_reads.29.C1 raw_reads.37.raw_reads.29.N1 raw_reads.37.raw_reads.29.C2 raw_reads.37.raw_reads.29.N2 raw_reads.37.raw_reads.29.C3 raw_reads.37.raw_reads.29.N3 && LAmerge -v L1.37.29 raw_reads.37.raw_reads.29.C0.S raw_reads.37.raw_reads.29.N0.S raw_reads.37.raw_reads.29.C1.S raw_reads.37.raw_reads.29.N1.S raw_reads.37.raw_reads.29.C2.S raw_reads.37.raw_reads.29.N2.S raw_reads.37.raw_reads.29.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.30.C0 raw_reads.37.raw_reads.30.N0 raw_reads.37.raw_reads.30.C1 raw_reads.37.raw_reads.30.N1 raw_reads.37.raw_reads.30.C2 raw_reads.37.raw_reads.30.N2 raw_reads.37.raw_reads.30.C3 raw_reads.37.raw_reads.30.N3 && LAmerge -v L1.37.30 raw_reads.37.raw_reads.30.C0.S raw_reads.37.raw_reads.30.N0.S raw_reads.37.raw_reads.30.C1.S raw_reads.37.raw_reads.30.N1.S raw_reads.37.raw_reads.30.C2.S raw_reads.37.raw_reads.30.N2.S raw_reads.37.raw_reads.30.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.31.C0 raw_reads.37.raw_reads.31.N0 raw_reads.37.raw_reads.31.C1 raw_reads.37.raw_reads.31.N1 raw_reads.37.raw_reads.31.C2 raw_reads.37.raw_reads.31.N2 raw_reads.37.raw_reads.31.C3 raw_reads.37.raw_reads.31.N3 && LAmerge -v L1.37.31 raw_reads.37.raw_reads.31.C0.S raw_reads.37.raw_reads.31.N0.S raw_reads.37.raw_reads.31.C1.S raw_reads.37.raw_reads.31.N1.S raw_reads.37.raw_reads.31.C2.S raw_reads.37.raw_reads.31.N2.S raw_reads.37.raw_reads.31.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.32.C0 raw_reads.37.raw_reads.32.N0 raw_reads.37.raw_reads.32.C1 raw_reads.37.raw_reads.32.N1 raw_reads.37.raw_reads.32.C2 raw_reads.37.raw_reads.32.N2 raw_reads.37.raw_reads.32.C3 raw_reads.37.raw_reads.32.N3 && LAmerge -v L1.37.32 raw_reads.37.raw_reads.32.C0.S raw_reads.37.raw_reads.32.N0.S raw_reads.37.raw_reads.32.C1.S raw_reads.37.raw_reads.32.N1.S raw_reads.37.raw_reads.32.C2.S raw_reads.37.raw_reads.32.N2.S raw_reads.37.raw_reads.32.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.33.C0 raw_reads.37.raw_reads.33.N0 raw_reads.37.raw_reads.33.C1 raw_reads.37.raw_reads.33.N1 raw_reads.37.raw_reads.33.C2 raw_reads.37.raw_reads.33.N2 raw_reads.37.raw_reads.33.C3 raw_reads.37.raw_reads.33.N3 && LAmerge -v L1.37.33 raw_reads.37.raw_reads.33.C0.S raw_reads.37.raw_reads.33.N0.S raw_reads.37.raw_reads.33.C1.S raw_reads.37.raw_reads.33.N1.S raw_reads.37.raw_reads.33.C2.S raw_reads.37.raw_reads.33.N2.S raw_reads.37.raw_reads.33.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.34.C0 raw_reads.37.raw_reads.34.N0 raw_reads.37.raw_reads.34.C1 raw_reads.37.raw_reads.34.N1 raw_reads.37.raw_reads.34.C2 raw_reads.37.raw_reads.34.N2 raw_reads.37.raw_reads.34.C3 raw_reads.37.raw_reads.34.N3 && LAmerge -v L1.37.34 raw_reads.37.raw_reads.34.C0.S raw_reads.37.raw_reads.34.N0.S raw_reads.37.raw_reads.34.C1.S raw_reads.37.raw_reads.34.N1.S raw_reads.37.raw_reads.34.C2.S raw_reads.37.raw_reads.34.N2.S raw_reads.37.raw_reads.34.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.35.C0 raw_reads.37.raw_reads.35.N0 raw_reads.37.raw_reads.35.C1 raw_reads.37.raw_reads.35.N1 raw_reads.37.raw_reads.35.C2 raw_reads.37.raw_reads.35.N2 raw_reads.37.raw_reads.35.C3 raw_reads.37.raw_reads.35.N3 && LAmerge -v L1.37.35 raw_reads.37.raw_reads.35.C0.S raw_reads.37.raw_reads.35.N0.S raw_reads.37.raw_reads.35.C1.S raw_reads.37.raw_reads.35.N1.S raw_reads.37.raw_reads.35.C2.S raw_reads.37.raw_reads.35.N2.S raw_reads.37.raw_reads.35.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.36.C0 raw_reads.37.raw_reads.36.N0 raw_reads.37.raw_reads.36.C1 raw_reads.37.raw_reads.36.N1 raw_reads.37.raw_reads.36.C2 raw_reads.37.raw_reads.36.N2 raw_reads.37.raw_reads.36.C3 raw_reads.37.raw_reads.36.N3 && LAmerge -v L1.37.36 raw_reads.37.raw_reads.36.C0.S raw_reads.37.raw_reads.36.N0.S raw_reads.37.raw_reads.36.C1.S raw_reads.37.raw_reads.36.N1.S raw_reads.37.raw_reads.36.C2.S raw_reads.37.raw_reads.36.N2.S raw_reads.37.raw_reads.36.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.37.C0 raw_reads.37.raw_reads.37.N0 raw_reads.37.raw_reads.37.C1 raw_reads.37.raw_reads.37.N1 raw_reads.37.raw_reads.37.C2 raw_reads.37.raw_reads.37.N2 raw_reads.37.raw_reads.37.C3 raw_reads.37.raw_reads.37.N3 && LAmerge -v L1.37.37 raw_reads.37.raw_reads.37.C0.S raw_reads.37.raw_reads.37.N0.S raw_reads.37.raw_reads.37.C1.S raw_reads.37.raw_reads.37.N1.S raw_reads.37.raw_reads.37.C2.S raw_reads.37.raw_reads.37.N2.S raw_reads.37.raw_reads.37.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.19.37
+LAcheck -vS raw_reads L1.20.37
+LAcheck -vS raw_reads L1.21.37
+LAcheck -vS raw_reads L1.22.37
+LAcheck -vS raw_reads L1.23.37
+LAcheck -vS raw_reads L1.24.37
+LAcheck -vS raw_reads L1.25.37
+LAcheck -vS raw_reads L1.26.37
+LAcheck -vS raw_reads L1.27.37
+LAcheck -vS raw_reads L1.28.37
+LAcheck -vS raw_reads L1.29.37
+LAcheck -vS raw_reads L1.30.37
+LAcheck -vS raw_reads L1.31.37
+LAcheck -vS raw_reads L1.32.37
+LAcheck -vS raw_reads L1.33.37
+LAcheck -vS raw_reads L1.34.37
+LAcheck -vS raw_reads L1.35.37
+LAcheck -vS raw_reads L1.36.37
+LAcheck -vS raw_reads L1.37.19
+LAcheck -vS raw_reads L1.37.20
+LAcheck -vS raw_reads L1.37.21
+LAcheck -vS raw_reads L1.37.22
+LAcheck -vS raw_reads L1.37.23
+LAcheck -vS raw_reads L1.37.24
+LAcheck -vS raw_reads L1.37.25
+LAcheck -vS raw_reads L1.37.26
+LAcheck -vS raw_reads L1.37.27
+LAcheck -vS raw_reads L1.37.28
+LAcheck -vS raw_reads L1.37.29
+LAcheck -vS raw_reads L1.37.30
+LAcheck -vS raw_reads L1.37.31
+LAcheck -vS raw_reads L1.37.32
+LAcheck -vS raw_reads L1.37.33
+LAcheck -vS raw_reads L1.37.34
+LAcheck -vS raw_reads L1.37.35
+LAcheck -vS raw_reads L1.37.36
+LAcheck -vS raw_reads L1.37.37
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.25 raw_reads.1 raw_reads.2 raw_reads.3 raw_reads.4 raw_reads.5 raw_reads.6 raw_reads.7 raw_reads.8 raw_reads.9 raw_reads.10 raw_reads.11 raw_reads.12
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.1.raw_reads.25.C0 raw_reads.1.raw_reads.25.N0 raw_reads.1.raw_reads.25.C1 raw_reads.1.raw_reads.25.N1 raw_reads.1.raw_reads.25.C2 raw_reads.1.raw_reads.25.N2 raw_reads.1.raw_reads.25.C3 raw_reads.1.raw_reads.25.N3 && LAmerge -v L1.1.25 raw_reads.1.raw_reads.25.C0.S raw_reads.1.raw_reads.25.N0.S raw_reads.1.raw_reads.25.C1.S raw_reads.1.raw_reads.25.N1.S raw_reads.1.raw_reads.25.C2.S raw_reads.1.raw_reads.25.N2.S raw_reads.1.raw_reads.25.C3.S raw_reads.1.raw_reads.25.N3.S
+LAsort -v raw_reads.2.raw_reads.25.C0 raw_reads.2.raw_reads.25.N0 raw_reads.2.raw_reads.25.C1 raw_reads.2.raw_reads.25.N1 raw_reads.2.raw_reads.25.C2 raw_reads.2.raw_reads.25.N2 raw_reads.2.raw_reads.25.C3 raw_reads.2.raw_reads.25.N3 && LAmerge -v L1.2.25 raw_reads.2.raw_reads.25.C0.S raw_reads.2.raw_reads.25.N0.S raw_reads.2.raw_reads.25.C1.S raw_reads.2.raw_reads.25.N1.S raw_reads.2.raw_reads.25.C2.S raw_reads.2.raw_reads.25.N2.S raw_reads.2.raw_reads.25.C3.S raw_reads.2.raw_reads.25.N3.S
+LAsort -v raw_reads.3.raw_reads.25.C0 raw_reads.3.raw_reads.25.N0 raw_reads.3.raw_reads.25.C1 raw_reads.3.raw_reads.25.N1 raw_reads.3.raw_reads.25.C2 raw_reads.3.raw_reads.25.N2 raw_reads.3.raw_reads.25.C3 raw_reads.3.raw_reads.25.N3 && LAmerge -v L1.3.25 raw_reads.3.raw_reads.25.C0.S raw_reads.3.raw_reads.25.N0.S raw_reads.3.raw_reads.25.C1.S raw_reads.3.raw_reads.25.N1.S raw_reads.3.raw_reads.25.C2.S raw_reads.3.raw_reads.25.N2.S raw_reads.3.raw_reads.25.C3.S raw_reads.3.raw_reads.25.N3.S
+LAsort -v raw_reads.4.raw_reads.25.C0 raw_reads.4.raw_reads.25.N0 raw_reads.4.raw_reads.25.C1 raw_reads.4.raw_reads.25.N1 raw_reads.4.raw_reads.25.C2 raw_reads.4.raw_reads.25.N2 raw_reads.4.raw_reads.25.C3 raw_reads.4.raw_reads.25.N3 && LAmerge -v L1.4.25 raw_reads.4.raw_reads.25.C0.S raw_reads.4.raw_reads.25.N0.S raw_reads.4.raw_reads.25.C1.S raw_reads.4.raw_reads.25.N1.S raw_reads.4.raw_reads.25.C2.S raw_reads.4.raw_reads.25.N2.S raw_reads.4.raw_reads.25.C3.S raw_reads.4.raw_reads.25.N3.S
+LAsort -v raw_reads.5.raw_reads.25.C0 raw_reads.5.raw_reads.25.N0 raw_reads.5.raw_reads.25.C1 raw_reads.5.raw_reads.25.N1 raw_reads.5.raw_reads.25.C2 raw_reads.5.raw_reads.25.N2 raw_reads.5.raw_reads.25.C3 raw_reads.5.raw_reads.25.N3 && LAmerge -v L1.5.25 raw_reads.5.raw_reads.25.C0.S raw_reads.5.raw_reads.25.N0.S raw_reads.5.raw_reads.25.C1.S raw_reads.5.raw_reads.25.N1.S raw_reads.5.raw_reads.25.C2.S raw_reads.5.raw_reads.25.N2.S raw_reads.5.raw_reads.25.C3.S raw_reads.5.raw_reads.25.N3.S
+LAsort -v raw_reads.6.raw_reads.25.C0 raw_reads.6.raw_reads.25.N0 raw_reads.6.raw_reads.25.C1 raw_reads.6.raw_reads.25.N1 raw_reads.6.raw_reads.25.C2 raw_reads.6.raw_reads.25.N2 raw_reads.6.raw_reads.25.C3 raw_reads.6.raw_reads.25.N3 && LAmerge -v L1.6.25 raw_reads.6.raw_reads.25.C0.S raw_reads.6.raw_reads.25.N0.S raw_reads.6.raw_reads.25.C1.S raw_reads.6.raw_reads.25.N1.S raw_reads.6.raw_reads.25.C2.S raw_reads.6.raw_reads.25.N2.S raw_reads.6.raw_reads.25.C3.S raw_reads.6.raw_reads.25.N3.S
+LAsort -v raw_reads.7.raw_reads.25.C0 raw_reads.7.raw_reads.25.N0 raw_reads.7.raw_reads.25.C1 raw_reads.7.raw_reads.25.N1 raw_reads.7.raw_reads.25.C2 raw_reads.7.raw_reads.25.N2 raw_reads.7.raw_reads.25.C3 raw_reads.7.raw_reads.25.N3 && LAmerge -v L1.7.25 raw_reads.7.raw_reads.25.C0.S raw_reads.7.raw_reads.25.N0.S raw_reads.7.raw_reads.25.C1.S raw_reads.7.raw_reads.25.N1.S raw_reads.7.raw_reads.25.C2.S raw_reads.7.raw_reads.25.N2.S raw_reads.7.raw_reads.25.C3.S raw_reads.7.raw_reads.25.N3.S
+LAsort -v raw_reads.8.raw_reads.25.C0 raw_reads.8.raw_reads.25.N0 raw_reads.8.raw_reads.25.C1 raw_reads.8.raw_reads.25.N1 raw_reads.8.raw_reads.25.C2 raw_reads.8.raw_reads.25.N2 raw_reads.8.raw_reads.25.C3 raw_reads.8.raw_reads.25.N3 && LAmerge -v L1.8.25 raw_reads.8.raw_reads.25.C0.S raw_reads.8.raw_reads.25.N0.S raw_reads.8.raw_reads.25.C1.S raw_reads.8.raw_reads.25.N1.S raw_reads.8.raw_reads.25.C2.S raw_reads.8.raw_reads.25.N2.S raw_reads.8.raw_reads.25.C3.S raw_reads.8.raw_reads.25.N3.S
+LAsort -v raw_reads.9.raw_reads.25.C0 raw_reads.9.raw_reads.25.N0 raw_reads.9.raw_reads.25.C1 raw_reads.9.raw_reads.25.N1 raw_reads.9.raw_reads.25.C2 raw_reads.9.raw_reads.25.N2 raw_reads.9.raw_reads.25.C3 raw_reads.9.raw_reads.25.N3 && LAmerge -v L1.9.25 raw_reads.9.raw_reads.25.C0.S raw_reads.9.raw_reads.25.N0.S raw_reads.9.raw_reads.25.C1.S raw_reads.9.raw_reads.25.N1.S raw_reads.9.raw_reads.25.C2.S raw_reads.9.raw_reads.25.N2.S raw_reads.9.raw_reads.25.C3.S raw_reads.9.raw_reads.25.N3.S
+LAsort -v raw_reads.10.raw_reads.25.C0 raw_reads.10.raw_reads.25.N0 raw_reads.10.raw_reads.25.C1 raw_reads.10.raw_reads.25.N1 raw_reads.10.raw_reads.25.C2 raw_reads.10.raw_reads.25.N2 raw_reads.10.raw_reads.25.C3 raw_reads.10.raw_reads.25.N3 && LAmerge -v L1.10.25 raw_reads.10.raw_reads.25.C0.S raw_reads.10.raw_reads.25.N0.S raw_reads.10.raw_reads.25.C1.S raw_reads.10.raw_reads.25.N1.S raw_reads.10.raw_reads.25.C2.S raw_reads.10.raw_reads.25.N2.S raw_reads.10.raw_reads.25.C3.S raw_reads. [...]
+LAsort -v raw_reads.11.raw_reads.25.C0 raw_reads.11.raw_reads.25.N0 raw_reads.11.raw_reads.25.C1 raw_reads.11.raw_reads.25.N1 raw_reads.11.raw_reads.25.C2 raw_reads.11.raw_reads.25.N2 raw_reads.11.raw_reads.25.C3 raw_reads.11.raw_reads.25.N3 && LAmerge -v L1.11.25 raw_reads.11.raw_reads.25.C0.S raw_reads.11.raw_reads.25.N0.S raw_reads.11.raw_reads.25.C1.S raw_reads.11.raw_reads.25.N1.S raw_reads.11.raw_reads.25.C2.S raw_reads.11.raw_reads.25.N2.S raw_reads.11.raw_reads.25.C3.S raw_reads. [...]
+LAsort -v raw_reads.12.raw_reads.25.C0 raw_reads.12.raw_reads.25.N0 raw_reads.12.raw_reads.25.C1 raw_reads.12.raw_reads.25.N1 raw_reads.12.raw_reads.25.C2 raw_reads.12.raw_reads.25.N2 raw_reads.12.raw_reads.25.C3 raw_reads.12.raw_reads.25.N3 && LAmerge -v L1.12.25 raw_reads.12.raw_reads.25.C0.S raw_reads.12.raw_reads.25.N0.S raw_reads.12.raw_reads.25.C1.S raw_reads.12.raw_reads.25.N1.S raw_reads.12.raw_reads.25.C2.S raw_reads.12.raw_reads.25.N2.S raw_reads.12.raw_reads.25.C3.S raw_reads. [...]
+LAsort -v raw_reads.25.raw_reads.1.C0 raw_reads.25.raw_reads.1.N0 raw_reads.25.raw_reads.1.C1 raw_reads.25.raw_reads.1.N1 raw_reads.25.raw_reads.1.C2 raw_reads.25.raw_reads.1.N2 raw_reads.25.raw_reads.1.C3 raw_reads.25.raw_reads.1.N3 && LAmerge -v L1.25.1 raw_reads.25.raw_reads.1.C0.S raw_reads.25.raw_reads.1.N0.S raw_reads.25.raw_reads.1.C1.S raw_reads.25.raw_reads.1.N1.S raw_reads.25.raw_reads.1.C2.S raw_reads.25.raw_reads.1.N2.S raw_reads.25.raw_reads.1.C3.S raw_reads.25.raw_reads.1.N3.S
+LAsort -v raw_reads.25.raw_reads.2.C0 raw_reads.25.raw_reads.2.N0 raw_reads.25.raw_reads.2.C1 raw_reads.25.raw_reads.2.N1 raw_reads.25.raw_reads.2.C2 raw_reads.25.raw_reads.2.N2 raw_reads.25.raw_reads.2.C3 raw_reads.25.raw_reads.2.N3 && LAmerge -v L1.25.2 raw_reads.25.raw_reads.2.C0.S raw_reads.25.raw_reads.2.N0.S raw_reads.25.raw_reads.2.C1.S raw_reads.25.raw_reads.2.N1.S raw_reads.25.raw_reads.2.C2.S raw_reads.25.raw_reads.2.N2.S raw_reads.25.raw_reads.2.C3.S raw_reads.25.raw_reads.2.N3.S
+LAsort -v raw_reads.25.raw_reads.3.C0 raw_reads.25.raw_reads.3.N0 raw_reads.25.raw_reads.3.C1 raw_reads.25.raw_reads.3.N1 raw_reads.25.raw_reads.3.C2 raw_reads.25.raw_reads.3.N2 raw_reads.25.raw_reads.3.C3 raw_reads.25.raw_reads.3.N3 && LAmerge -v L1.25.3 raw_reads.25.raw_reads.3.C0.S raw_reads.25.raw_reads.3.N0.S raw_reads.25.raw_reads.3.C1.S raw_reads.25.raw_reads.3.N1.S raw_reads.25.raw_reads.3.C2.S raw_reads.25.raw_reads.3.N2.S raw_reads.25.raw_reads.3.C3.S raw_reads.25.raw_reads.3.N3.S
+LAsort -v raw_reads.25.raw_reads.4.C0 raw_reads.25.raw_reads.4.N0 raw_reads.25.raw_reads.4.C1 raw_reads.25.raw_reads.4.N1 raw_reads.25.raw_reads.4.C2 raw_reads.25.raw_reads.4.N2 raw_reads.25.raw_reads.4.C3 raw_reads.25.raw_reads.4.N3 && LAmerge -v L1.25.4 raw_reads.25.raw_reads.4.C0.S raw_reads.25.raw_reads.4.N0.S raw_reads.25.raw_reads.4.C1.S raw_reads.25.raw_reads.4.N1.S raw_reads.25.raw_reads.4.C2.S raw_reads.25.raw_reads.4.N2.S raw_reads.25.raw_reads.4.C3.S raw_reads.25.raw_reads.4.N3.S
+LAsort -v raw_reads.25.raw_reads.5.C0 raw_reads.25.raw_reads.5.N0 raw_reads.25.raw_reads.5.C1 raw_reads.25.raw_reads.5.N1 raw_reads.25.raw_reads.5.C2 raw_reads.25.raw_reads.5.N2 raw_reads.25.raw_reads.5.C3 raw_reads.25.raw_reads.5.N3 && LAmerge -v L1.25.5 raw_reads.25.raw_reads.5.C0.S raw_reads.25.raw_reads.5.N0.S raw_reads.25.raw_reads.5.C1.S raw_reads.25.raw_reads.5.N1.S raw_reads.25.raw_reads.5.C2.S raw_reads.25.raw_reads.5.N2.S raw_reads.25.raw_reads.5.C3.S raw_reads.25.raw_reads.5.N3.S
+LAsort -v raw_reads.25.raw_reads.6.C0 raw_reads.25.raw_reads.6.N0 raw_reads.25.raw_reads.6.C1 raw_reads.25.raw_reads.6.N1 raw_reads.25.raw_reads.6.C2 raw_reads.25.raw_reads.6.N2 raw_reads.25.raw_reads.6.C3 raw_reads.25.raw_reads.6.N3 && LAmerge -v L1.25.6 raw_reads.25.raw_reads.6.C0.S raw_reads.25.raw_reads.6.N0.S raw_reads.25.raw_reads.6.C1.S raw_reads.25.raw_reads.6.N1.S raw_reads.25.raw_reads.6.C2.S raw_reads.25.raw_reads.6.N2.S raw_reads.25.raw_reads.6.C3.S raw_reads.25.raw_reads.6.N3.S
+LAsort -v raw_reads.25.raw_reads.7.C0 raw_reads.25.raw_reads.7.N0 raw_reads.25.raw_reads.7.C1 raw_reads.25.raw_reads.7.N1 raw_reads.25.raw_reads.7.C2 raw_reads.25.raw_reads.7.N2 raw_reads.25.raw_reads.7.C3 raw_reads.25.raw_reads.7.N3 && LAmerge -v L1.25.7 raw_reads.25.raw_reads.7.C0.S raw_reads.25.raw_reads.7.N0.S raw_reads.25.raw_reads.7.C1.S raw_reads.25.raw_reads.7.N1.S raw_reads.25.raw_reads.7.C2.S raw_reads.25.raw_reads.7.N2.S raw_reads.25.raw_reads.7.C3.S raw_reads.25.raw_reads.7.N3.S
+LAsort -v raw_reads.25.raw_reads.8.C0 raw_reads.25.raw_reads.8.N0 raw_reads.25.raw_reads.8.C1 raw_reads.25.raw_reads.8.N1 raw_reads.25.raw_reads.8.C2 raw_reads.25.raw_reads.8.N2 raw_reads.25.raw_reads.8.C3 raw_reads.25.raw_reads.8.N3 && LAmerge -v L1.25.8 raw_reads.25.raw_reads.8.C0.S raw_reads.25.raw_reads.8.N0.S raw_reads.25.raw_reads.8.C1.S raw_reads.25.raw_reads.8.N1.S raw_reads.25.raw_reads.8.C2.S raw_reads.25.raw_reads.8.N2.S raw_reads.25.raw_reads.8.C3.S raw_reads.25.raw_reads.8.N3.S
+LAsort -v raw_reads.25.raw_reads.9.C0 raw_reads.25.raw_reads.9.N0 raw_reads.25.raw_reads.9.C1 raw_reads.25.raw_reads.9.N1 raw_reads.25.raw_reads.9.C2 raw_reads.25.raw_reads.9.N2 raw_reads.25.raw_reads.9.C3 raw_reads.25.raw_reads.9.N3 && LAmerge -v L1.25.9 raw_reads.25.raw_reads.9.C0.S raw_reads.25.raw_reads.9.N0.S raw_reads.25.raw_reads.9.C1.S raw_reads.25.raw_reads.9.N1.S raw_reads.25.raw_reads.9.C2.S raw_reads.25.raw_reads.9.N2.S raw_reads.25.raw_reads.9.C3.S raw_reads.25.raw_reads.9.N3.S
+LAsort -v raw_reads.25.raw_reads.10.C0 raw_reads.25.raw_reads.10.N0 raw_reads.25.raw_reads.10.C1 raw_reads.25.raw_reads.10.N1 raw_reads.25.raw_reads.10.C2 raw_reads.25.raw_reads.10.N2 raw_reads.25.raw_reads.10.C3 raw_reads.25.raw_reads.10.N3 && LAmerge -v L1.25.10 raw_reads.25.raw_reads.10.C0.S raw_reads.25.raw_reads.10.N0.S raw_reads.25.raw_reads.10.C1.S raw_reads.25.raw_reads.10.N1.S raw_reads.25.raw_reads.10.C2.S raw_reads.25.raw_reads.10.N2.S raw_reads.25.raw_reads.10.C3.S raw_reads. [...]
+LAsort -v raw_reads.25.raw_reads.11.C0 raw_reads.25.raw_reads.11.N0 raw_reads.25.raw_reads.11.C1 raw_reads.25.raw_reads.11.N1 raw_reads.25.raw_reads.11.C2 raw_reads.25.raw_reads.11.N2 raw_reads.25.raw_reads.11.C3 raw_reads.25.raw_reads.11.N3 && LAmerge -v L1.25.11 raw_reads.25.raw_reads.11.C0.S raw_reads.25.raw_reads.11.N0.S raw_reads.25.raw_reads.11.C1.S raw_reads.25.raw_reads.11.N1.S raw_reads.25.raw_reads.11.C2.S raw_reads.25.raw_reads.11.N2.S raw_reads.25.raw_reads.11.C3.S raw_reads. [...]
+LAsort -v raw_reads.25.raw_reads.12.C0 raw_reads.25.raw_reads.12.N0 raw_reads.25.raw_reads.12.C1 raw_reads.25.raw_reads.12.N1 raw_reads.25.raw_reads.12.C2 raw_reads.25.raw_reads.12.N2 raw_reads.25.raw_reads.12.C3 raw_reads.25.raw_reads.12.N3 && LAmerge -v L1.25.12 raw_reads.25.raw_reads.12.C0.S raw_reads.25.raw_reads.12.N0.S raw_reads.25.raw_reads.12.C1.S raw_reads.25.raw_reads.12.N1.S raw_reads.25.raw_reads.12.C2.S raw_reads.25.raw_reads.12.N2.S raw_reads.25.raw_reads.12.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.1.25
+LAcheck -vS raw_reads L1.2.25
+LAcheck -vS raw_reads L1.3.25
+LAcheck -vS raw_reads L1.4.25
+LAcheck -vS raw_reads L1.5.25
+LAcheck -vS raw_reads L1.6.25
+LAcheck -vS raw_reads L1.7.25
+LAcheck -vS raw_reads L1.8.25
+LAcheck -vS raw_reads L1.9.25
+LAcheck -vS raw_reads L1.10.25
+LAcheck -vS raw_reads L1.11.25
+LAcheck -vS raw_reads L1.12.25
+LAcheck -vS raw_reads L1.25.1
+LAcheck -vS raw_reads L1.25.2
+LAcheck -vS raw_reads L1.25.3
+LAcheck -vS raw_reads L1.25.4
+LAcheck -vS raw_reads L1.25.5
+LAcheck -vS raw_reads L1.25.6
+LAcheck -vS raw_reads L1.25.7
+LAcheck -vS raw_reads L1.25.8
+LAcheck -vS raw_reads L1.25.9
+LAcheck -vS raw_reads L1.25.10
+LAcheck -vS raw_reads L1.25.11
+LAcheck -vS raw_reads L1.25.12
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.99 raw_reads.60 raw_reads.61 raw_reads.62 raw_reads.63 raw_reads.64 raw_reads.65 raw_reads.66 raw_reads.67 raw_reads.68 raw_reads.69 raw_reads.70 raw_reads.71 raw_reads.72 raw_reads.73 raw_reads.74 raw_reads.75 raw_reads.76 raw_reads.77 raw_reads.78 raw_reads.79
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.60.raw_reads.99.C0 raw_reads.60.raw_reads.99.N0 raw_reads.60.raw_reads.99.C1 raw_reads.60.raw_reads.99.N1 raw_reads.60.raw_reads.99.C2 raw_reads.60.raw_reads.99.N2 raw_reads.60.raw_reads.99.C3 raw_reads.60.raw_reads.99.N3 && LAmerge -v L1.60.99 raw_reads.60.raw_reads.99.C0.S raw_reads.60.raw_reads.99.N0.S raw_reads.60.raw_reads.99.C1.S raw_reads.60.raw_reads.99.N1.S raw_reads.60.raw_reads.99.C2.S raw_reads.60.raw_reads.99.N2.S raw_reads.60.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.61.raw_reads.99.C0 raw_reads.61.raw_reads.99.N0 raw_reads.61.raw_reads.99.C1 raw_reads.61.raw_reads.99.N1 raw_reads.61.raw_reads.99.C2 raw_reads.61.raw_reads.99.N2 raw_reads.61.raw_reads.99.C3 raw_reads.61.raw_reads.99.N3 && LAmerge -v L1.61.99 raw_reads.61.raw_reads.99.C0.S raw_reads.61.raw_reads.99.N0.S raw_reads.61.raw_reads.99.C1.S raw_reads.61.raw_reads.99.N1.S raw_reads.61.raw_reads.99.C2.S raw_reads.61.raw_reads.99.N2.S raw_reads.61.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.62.raw_reads.99.C0 raw_reads.62.raw_reads.99.N0 raw_reads.62.raw_reads.99.C1 raw_reads.62.raw_reads.99.N1 raw_reads.62.raw_reads.99.C2 raw_reads.62.raw_reads.99.N2 raw_reads.62.raw_reads.99.C3 raw_reads.62.raw_reads.99.N3 && LAmerge -v L1.62.99 raw_reads.62.raw_reads.99.C0.S raw_reads.62.raw_reads.99.N0.S raw_reads.62.raw_reads.99.C1.S raw_reads.62.raw_reads.99.N1.S raw_reads.62.raw_reads.99.C2.S raw_reads.62.raw_reads.99.N2.S raw_reads.62.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.99.C0 raw_reads.63.raw_reads.99.N0 raw_reads.63.raw_reads.99.C1 raw_reads.63.raw_reads.99.N1 raw_reads.63.raw_reads.99.C2 raw_reads.63.raw_reads.99.N2 raw_reads.63.raw_reads.99.C3 raw_reads.63.raw_reads.99.N3 && LAmerge -v L1.63.99 raw_reads.63.raw_reads.99.C0.S raw_reads.63.raw_reads.99.N0.S raw_reads.63.raw_reads.99.C1.S raw_reads.63.raw_reads.99.N1.S raw_reads.63.raw_reads.99.C2.S raw_reads.63.raw_reads.99.N2.S raw_reads.63.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.64.raw_reads.99.C0 raw_reads.64.raw_reads.99.N0 raw_reads.64.raw_reads.99.C1 raw_reads.64.raw_reads.99.N1 raw_reads.64.raw_reads.99.C2 raw_reads.64.raw_reads.99.N2 raw_reads.64.raw_reads.99.C3 raw_reads.64.raw_reads.99.N3 && LAmerge -v L1.64.99 raw_reads.64.raw_reads.99.C0.S raw_reads.64.raw_reads.99.N0.S raw_reads.64.raw_reads.99.C1.S raw_reads.64.raw_reads.99.N1.S raw_reads.64.raw_reads.99.C2.S raw_reads.64.raw_reads.99.N2.S raw_reads.64.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.65.raw_reads.99.C0 raw_reads.65.raw_reads.99.N0 raw_reads.65.raw_reads.99.C1 raw_reads.65.raw_reads.99.N1 raw_reads.65.raw_reads.99.C2 raw_reads.65.raw_reads.99.N2 raw_reads.65.raw_reads.99.C3 raw_reads.65.raw_reads.99.N3 && LAmerge -v L1.65.99 raw_reads.65.raw_reads.99.C0.S raw_reads.65.raw_reads.99.N0.S raw_reads.65.raw_reads.99.C1.S raw_reads.65.raw_reads.99.N1.S raw_reads.65.raw_reads.99.C2.S raw_reads.65.raw_reads.99.N2.S raw_reads.65.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.66.raw_reads.99.C0 raw_reads.66.raw_reads.99.N0 raw_reads.66.raw_reads.99.C1 raw_reads.66.raw_reads.99.N1 raw_reads.66.raw_reads.99.C2 raw_reads.66.raw_reads.99.N2 raw_reads.66.raw_reads.99.C3 raw_reads.66.raw_reads.99.N3 && LAmerge -v L1.66.99 raw_reads.66.raw_reads.99.C0.S raw_reads.66.raw_reads.99.N0.S raw_reads.66.raw_reads.99.C1.S raw_reads.66.raw_reads.99.N1.S raw_reads.66.raw_reads.99.C2.S raw_reads.66.raw_reads.99.N2.S raw_reads.66.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.67.raw_reads.99.C0 raw_reads.67.raw_reads.99.N0 raw_reads.67.raw_reads.99.C1 raw_reads.67.raw_reads.99.N1 raw_reads.67.raw_reads.99.C2 raw_reads.67.raw_reads.99.N2 raw_reads.67.raw_reads.99.C3 raw_reads.67.raw_reads.99.N3 && LAmerge -v L1.67.99 raw_reads.67.raw_reads.99.C0.S raw_reads.67.raw_reads.99.N0.S raw_reads.67.raw_reads.99.C1.S raw_reads.67.raw_reads.99.N1.S raw_reads.67.raw_reads.99.C2.S raw_reads.67.raw_reads.99.N2.S raw_reads.67.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.68.raw_reads.99.C0 raw_reads.68.raw_reads.99.N0 raw_reads.68.raw_reads.99.C1 raw_reads.68.raw_reads.99.N1 raw_reads.68.raw_reads.99.C2 raw_reads.68.raw_reads.99.N2 raw_reads.68.raw_reads.99.C3 raw_reads.68.raw_reads.99.N3 && LAmerge -v L1.68.99 raw_reads.68.raw_reads.99.C0.S raw_reads.68.raw_reads.99.N0.S raw_reads.68.raw_reads.99.C1.S raw_reads.68.raw_reads.99.N1.S raw_reads.68.raw_reads.99.C2.S raw_reads.68.raw_reads.99.N2.S raw_reads.68.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.69.raw_reads.99.C0 raw_reads.69.raw_reads.99.N0 raw_reads.69.raw_reads.99.C1 raw_reads.69.raw_reads.99.N1 raw_reads.69.raw_reads.99.C2 raw_reads.69.raw_reads.99.N2 raw_reads.69.raw_reads.99.C3 raw_reads.69.raw_reads.99.N3 && LAmerge -v L1.69.99 raw_reads.69.raw_reads.99.C0.S raw_reads.69.raw_reads.99.N0.S raw_reads.69.raw_reads.99.C1.S raw_reads.69.raw_reads.99.N1.S raw_reads.69.raw_reads.99.C2.S raw_reads.69.raw_reads.99.N2.S raw_reads.69.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.70.raw_reads.99.C0 raw_reads.70.raw_reads.99.N0 raw_reads.70.raw_reads.99.C1 raw_reads.70.raw_reads.99.N1 raw_reads.70.raw_reads.99.C2 raw_reads.70.raw_reads.99.N2 raw_reads.70.raw_reads.99.C3 raw_reads.70.raw_reads.99.N3 && LAmerge -v L1.70.99 raw_reads.70.raw_reads.99.C0.S raw_reads.70.raw_reads.99.N0.S raw_reads.70.raw_reads.99.C1.S raw_reads.70.raw_reads.99.N1.S raw_reads.70.raw_reads.99.C2.S raw_reads.70.raw_reads.99.N2.S raw_reads.70.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.71.raw_reads.99.C0 raw_reads.71.raw_reads.99.N0 raw_reads.71.raw_reads.99.C1 raw_reads.71.raw_reads.99.N1 raw_reads.71.raw_reads.99.C2 raw_reads.71.raw_reads.99.N2 raw_reads.71.raw_reads.99.C3 raw_reads.71.raw_reads.99.N3 && LAmerge -v L1.71.99 raw_reads.71.raw_reads.99.C0.S raw_reads.71.raw_reads.99.N0.S raw_reads.71.raw_reads.99.C1.S raw_reads.71.raw_reads.99.N1.S raw_reads.71.raw_reads.99.C2.S raw_reads.71.raw_reads.99.N2.S raw_reads.71.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.72.raw_reads.99.C0 raw_reads.72.raw_reads.99.N0 raw_reads.72.raw_reads.99.C1 raw_reads.72.raw_reads.99.N1 raw_reads.72.raw_reads.99.C2 raw_reads.72.raw_reads.99.N2 raw_reads.72.raw_reads.99.C3 raw_reads.72.raw_reads.99.N3 && LAmerge -v L1.72.99 raw_reads.72.raw_reads.99.C0.S raw_reads.72.raw_reads.99.N0.S raw_reads.72.raw_reads.99.C1.S raw_reads.72.raw_reads.99.N1.S raw_reads.72.raw_reads.99.C2.S raw_reads.72.raw_reads.99.N2.S raw_reads.72.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.99.C0 raw_reads.73.raw_reads.99.N0 raw_reads.73.raw_reads.99.C1 raw_reads.73.raw_reads.99.N1 raw_reads.73.raw_reads.99.C2 raw_reads.73.raw_reads.99.N2 raw_reads.73.raw_reads.99.C3 raw_reads.73.raw_reads.99.N3 && LAmerge -v L1.73.99 raw_reads.73.raw_reads.99.C0.S raw_reads.73.raw_reads.99.N0.S raw_reads.73.raw_reads.99.C1.S raw_reads.73.raw_reads.99.N1.S raw_reads.73.raw_reads.99.C2.S raw_reads.73.raw_reads.99.N2.S raw_reads.73.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.74.raw_reads.99.C0 raw_reads.74.raw_reads.99.N0 raw_reads.74.raw_reads.99.C1 raw_reads.74.raw_reads.99.N1 raw_reads.74.raw_reads.99.C2 raw_reads.74.raw_reads.99.N2 raw_reads.74.raw_reads.99.C3 raw_reads.74.raw_reads.99.N3 && LAmerge -v L1.74.99 raw_reads.74.raw_reads.99.C0.S raw_reads.74.raw_reads.99.N0.S raw_reads.74.raw_reads.99.C1.S raw_reads.74.raw_reads.99.N1.S raw_reads.74.raw_reads.99.C2.S raw_reads.74.raw_reads.99.N2.S raw_reads.74.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.75.raw_reads.99.C0 raw_reads.75.raw_reads.99.N0 raw_reads.75.raw_reads.99.C1 raw_reads.75.raw_reads.99.N1 raw_reads.75.raw_reads.99.C2 raw_reads.75.raw_reads.99.N2 raw_reads.75.raw_reads.99.C3 raw_reads.75.raw_reads.99.N3 && LAmerge -v L1.75.99 raw_reads.75.raw_reads.99.C0.S raw_reads.75.raw_reads.99.N0.S raw_reads.75.raw_reads.99.C1.S raw_reads.75.raw_reads.99.N1.S raw_reads.75.raw_reads.99.C2.S raw_reads.75.raw_reads.99.N2.S raw_reads.75.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.76.raw_reads.99.C0 raw_reads.76.raw_reads.99.N0 raw_reads.76.raw_reads.99.C1 raw_reads.76.raw_reads.99.N1 raw_reads.76.raw_reads.99.C2 raw_reads.76.raw_reads.99.N2 raw_reads.76.raw_reads.99.C3 raw_reads.76.raw_reads.99.N3 && LAmerge -v L1.76.99 raw_reads.76.raw_reads.99.C0.S raw_reads.76.raw_reads.99.N0.S raw_reads.76.raw_reads.99.C1.S raw_reads.76.raw_reads.99.N1.S raw_reads.76.raw_reads.99.C2.S raw_reads.76.raw_reads.99.N2.S raw_reads.76.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.77.raw_reads.99.C0 raw_reads.77.raw_reads.99.N0 raw_reads.77.raw_reads.99.C1 raw_reads.77.raw_reads.99.N1 raw_reads.77.raw_reads.99.C2 raw_reads.77.raw_reads.99.N2 raw_reads.77.raw_reads.99.C3 raw_reads.77.raw_reads.99.N3 && LAmerge -v L1.77.99 raw_reads.77.raw_reads.99.C0.S raw_reads.77.raw_reads.99.N0.S raw_reads.77.raw_reads.99.C1.S raw_reads.77.raw_reads.99.N1.S raw_reads.77.raw_reads.99.C2.S raw_reads.77.raw_reads.99.N2.S raw_reads.77.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.78.raw_reads.99.C0 raw_reads.78.raw_reads.99.N0 raw_reads.78.raw_reads.99.C1 raw_reads.78.raw_reads.99.N1 raw_reads.78.raw_reads.99.C2 raw_reads.78.raw_reads.99.N2 raw_reads.78.raw_reads.99.C3 raw_reads.78.raw_reads.99.N3 && LAmerge -v L1.78.99 raw_reads.78.raw_reads.99.C0.S raw_reads.78.raw_reads.99.N0.S raw_reads.78.raw_reads.99.C1.S raw_reads.78.raw_reads.99.N1.S raw_reads.78.raw_reads.99.C2.S raw_reads.78.raw_reads.99.N2.S raw_reads.78.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.79.raw_reads.99.C0 raw_reads.79.raw_reads.99.N0 raw_reads.79.raw_reads.99.C1 raw_reads.79.raw_reads.99.N1 raw_reads.79.raw_reads.99.C2 raw_reads.79.raw_reads.99.N2 raw_reads.79.raw_reads.99.C3 raw_reads.79.raw_reads.99.N3 && LAmerge -v L1.79.99 raw_reads.79.raw_reads.99.C0.S raw_reads.79.raw_reads.99.N0.S raw_reads.79.raw_reads.99.C1.S raw_reads.79.raw_reads.99.N1.S raw_reads.79.raw_reads.99.C2.S raw_reads.79.raw_reads.99.N2.S raw_reads.79.raw_reads.99.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.60.C0 raw_reads.99.raw_reads.60.N0 raw_reads.99.raw_reads.60.C1 raw_reads.99.raw_reads.60.N1 raw_reads.99.raw_reads.60.C2 raw_reads.99.raw_reads.60.N2 raw_reads.99.raw_reads.60.C3 raw_reads.99.raw_reads.60.N3 && LAmerge -v L1.99.60 raw_reads.99.raw_reads.60.C0.S raw_reads.99.raw_reads.60.N0.S raw_reads.99.raw_reads.60.C1.S raw_reads.99.raw_reads.60.N1.S raw_reads.99.raw_reads.60.C2.S raw_reads.99.raw_reads.60.N2.S raw_reads.99.raw_reads.60.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.61.C0 raw_reads.99.raw_reads.61.N0 raw_reads.99.raw_reads.61.C1 raw_reads.99.raw_reads.61.N1 raw_reads.99.raw_reads.61.C2 raw_reads.99.raw_reads.61.N2 raw_reads.99.raw_reads.61.C3 raw_reads.99.raw_reads.61.N3 && LAmerge -v L1.99.61 raw_reads.99.raw_reads.61.C0.S raw_reads.99.raw_reads.61.N0.S raw_reads.99.raw_reads.61.C1.S raw_reads.99.raw_reads.61.N1.S raw_reads.99.raw_reads.61.C2.S raw_reads.99.raw_reads.61.N2.S raw_reads.99.raw_reads.61.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.62.C0 raw_reads.99.raw_reads.62.N0 raw_reads.99.raw_reads.62.C1 raw_reads.99.raw_reads.62.N1 raw_reads.99.raw_reads.62.C2 raw_reads.99.raw_reads.62.N2 raw_reads.99.raw_reads.62.C3 raw_reads.99.raw_reads.62.N3 && LAmerge -v L1.99.62 raw_reads.99.raw_reads.62.C0.S raw_reads.99.raw_reads.62.N0.S raw_reads.99.raw_reads.62.C1.S raw_reads.99.raw_reads.62.N1.S raw_reads.99.raw_reads.62.C2.S raw_reads.99.raw_reads.62.N2.S raw_reads.99.raw_reads.62.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.63.C0 raw_reads.99.raw_reads.63.N0 raw_reads.99.raw_reads.63.C1 raw_reads.99.raw_reads.63.N1 raw_reads.99.raw_reads.63.C2 raw_reads.99.raw_reads.63.N2 raw_reads.99.raw_reads.63.C3 raw_reads.99.raw_reads.63.N3 && LAmerge -v L1.99.63 raw_reads.99.raw_reads.63.C0.S raw_reads.99.raw_reads.63.N0.S raw_reads.99.raw_reads.63.C1.S raw_reads.99.raw_reads.63.N1.S raw_reads.99.raw_reads.63.C2.S raw_reads.99.raw_reads.63.N2.S raw_reads.99.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.64.C0 raw_reads.99.raw_reads.64.N0 raw_reads.99.raw_reads.64.C1 raw_reads.99.raw_reads.64.N1 raw_reads.99.raw_reads.64.C2 raw_reads.99.raw_reads.64.N2 raw_reads.99.raw_reads.64.C3 raw_reads.99.raw_reads.64.N3 && LAmerge -v L1.99.64 raw_reads.99.raw_reads.64.C0.S raw_reads.99.raw_reads.64.N0.S raw_reads.99.raw_reads.64.C1.S raw_reads.99.raw_reads.64.N1.S raw_reads.99.raw_reads.64.C2.S raw_reads.99.raw_reads.64.N2.S raw_reads.99.raw_reads.64.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.65.C0 raw_reads.99.raw_reads.65.N0 raw_reads.99.raw_reads.65.C1 raw_reads.99.raw_reads.65.N1 raw_reads.99.raw_reads.65.C2 raw_reads.99.raw_reads.65.N2 raw_reads.99.raw_reads.65.C3 raw_reads.99.raw_reads.65.N3 && LAmerge -v L1.99.65 raw_reads.99.raw_reads.65.C0.S raw_reads.99.raw_reads.65.N0.S raw_reads.99.raw_reads.65.C1.S raw_reads.99.raw_reads.65.N1.S raw_reads.99.raw_reads.65.C2.S raw_reads.99.raw_reads.65.N2.S raw_reads.99.raw_reads.65.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.66.C0 raw_reads.99.raw_reads.66.N0 raw_reads.99.raw_reads.66.C1 raw_reads.99.raw_reads.66.N1 raw_reads.99.raw_reads.66.C2 raw_reads.99.raw_reads.66.N2 raw_reads.99.raw_reads.66.C3 raw_reads.99.raw_reads.66.N3 && LAmerge -v L1.99.66 raw_reads.99.raw_reads.66.C0.S raw_reads.99.raw_reads.66.N0.S raw_reads.99.raw_reads.66.C1.S raw_reads.99.raw_reads.66.N1.S raw_reads.99.raw_reads.66.C2.S raw_reads.99.raw_reads.66.N2.S raw_reads.99.raw_reads.66.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.67.C0 raw_reads.99.raw_reads.67.N0 raw_reads.99.raw_reads.67.C1 raw_reads.99.raw_reads.67.N1 raw_reads.99.raw_reads.67.C2 raw_reads.99.raw_reads.67.N2 raw_reads.99.raw_reads.67.C3 raw_reads.99.raw_reads.67.N3 && LAmerge -v L1.99.67 raw_reads.99.raw_reads.67.C0.S raw_reads.99.raw_reads.67.N0.S raw_reads.99.raw_reads.67.C1.S raw_reads.99.raw_reads.67.N1.S raw_reads.99.raw_reads.67.C2.S raw_reads.99.raw_reads.67.N2.S raw_reads.99.raw_reads.67.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.68.C0 raw_reads.99.raw_reads.68.N0 raw_reads.99.raw_reads.68.C1 raw_reads.99.raw_reads.68.N1 raw_reads.99.raw_reads.68.C2 raw_reads.99.raw_reads.68.N2 raw_reads.99.raw_reads.68.C3 raw_reads.99.raw_reads.68.N3 && LAmerge -v L1.99.68 raw_reads.99.raw_reads.68.C0.S raw_reads.99.raw_reads.68.N0.S raw_reads.99.raw_reads.68.C1.S raw_reads.99.raw_reads.68.N1.S raw_reads.99.raw_reads.68.C2.S raw_reads.99.raw_reads.68.N2.S raw_reads.99.raw_reads.68.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.69.C0 raw_reads.99.raw_reads.69.N0 raw_reads.99.raw_reads.69.C1 raw_reads.99.raw_reads.69.N1 raw_reads.99.raw_reads.69.C2 raw_reads.99.raw_reads.69.N2 raw_reads.99.raw_reads.69.C3 raw_reads.99.raw_reads.69.N3 && LAmerge -v L1.99.69 raw_reads.99.raw_reads.69.C0.S raw_reads.99.raw_reads.69.N0.S raw_reads.99.raw_reads.69.C1.S raw_reads.99.raw_reads.69.N1.S raw_reads.99.raw_reads.69.C2.S raw_reads.99.raw_reads.69.N2.S raw_reads.99.raw_reads.69.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.70.C0 raw_reads.99.raw_reads.70.N0 raw_reads.99.raw_reads.70.C1 raw_reads.99.raw_reads.70.N1 raw_reads.99.raw_reads.70.C2 raw_reads.99.raw_reads.70.N2 raw_reads.99.raw_reads.70.C3 raw_reads.99.raw_reads.70.N3 && LAmerge -v L1.99.70 raw_reads.99.raw_reads.70.C0.S raw_reads.99.raw_reads.70.N0.S raw_reads.99.raw_reads.70.C1.S raw_reads.99.raw_reads.70.N1.S raw_reads.99.raw_reads.70.C2.S raw_reads.99.raw_reads.70.N2.S raw_reads.99.raw_reads.70.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.71.C0 raw_reads.99.raw_reads.71.N0 raw_reads.99.raw_reads.71.C1 raw_reads.99.raw_reads.71.N1 raw_reads.99.raw_reads.71.C2 raw_reads.99.raw_reads.71.N2 raw_reads.99.raw_reads.71.C3 raw_reads.99.raw_reads.71.N3 && LAmerge -v L1.99.71 raw_reads.99.raw_reads.71.C0.S raw_reads.99.raw_reads.71.N0.S raw_reads.99.raw_reads.71.C1.S raw_reads.99.raw_reads.71.N1.S raw_reads.99.raw_reads.71.C2.S raw_reads.99.raw_reads.71.N2.S raw_reads.99.raw_reads.71.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.72.C0 raw_reads.99.raw_reads.72.N0 raw_reads.99.raw_reads.72.C1 raw_reads.99.raw_reads.72.N1 raw_reads.99.raw_reads.72.C2 raw_reads.99.raw_reads.72.N2 raw_reads.99.raw_reads.72.C3 raw_reads.99.raw_reads.72.N3 && LAmerge -v L1.99.72 raw_reads.99.raw_reads.72.C0.S raw_reads.99.raw_reads.72.N0.S raw_reads.99.raw_reads.72.C1.S raw_reads.99.raw_reads.72.N1.S raw_reads.99.raw_reads.72.C2.S raw_reads.99.raw_reads.72.N2.S raw_reads.99.raw_reads.72.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.73.C0 raw_reads.99.raw_reads.73.N0 raw_reads.99.raw_reads.73.C1 raw_reads.99.raw_reads.73.N1 raw_reads.99.raw_reads.73.C2 raw_reads.99.raw_reads.73.N2 raw_reads.99.raw_reads.73.C3 raw_reads.99.raw_reads.73.N3 && LAmerge -v L1.99.73 raw_reads.99.raw_reads.73.C0.S raw_reads.99.raw_reads.73.N0.S raw_reads.99.raw_reads.73.C1.S raw_reads.99.raw_reads.73.N1.S raw_reads.99.raw_reads.73.C2.S raw_reads.99.raw_reads.73.N2.S raw_reads.99.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.74.C0 raw_reads.99.raw_reads.74.N0 raw_reads.99.raw_reads.74.C1 raw_reads.99.raw_reads.74.N1 raw_reads.99.raw_reads.74.C2 raw_reads.99.raw_reads.74.N2 raw_reads.99.raw_reads.74.C3 raw_reads.99.raw_reads.74.N3 && LAmerge -v L1.99.74 raw_reads.99.raw_reads.74.C0.S raw_reads.99.raw_reads.74.N0.S raw_reads.99.raw_reads.74.C1.S raw_reads.99.raw_reads.74.N1.S raw_reads.99.raw_reads.74.C2.S raw_reads.99.raw_reads.74.N2.S raw_reads.99.raw_reads.74.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.75.C0 raw_reads.99.raw_reads.75.N0 raw_reads.99.raw_reads.75.C1 raw_reads.99.raw_reads.75.N1 raw_reads.99.raw_reads.75.C2 raw_reads.99.raw_reads.75.N2 raw_reads.99.raw_reads.75.C3 raw_reads.99.raw_reads.75.N3 && LAmerge -v L1.99.75 raw_reads.99.raw_reads.75.C0.S raw_reads.99.raw_reads.75.N0.S raw_reads.99.raw_reads.75.C1.S raw_reads.99.raw_reads.75.N1.S raw_reads.99.raw_reads.75.C2.S raw_reads.99.raw_reads.75.N2.S raw_reads.99.raw_reads.75.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.76.C0 raw_reads.99.raw_reads.76.N0 raw_reads.99.raw_reads.76.C1 raw_reads.99.raw_reads.76.N1 raw_reads.99.raw_reads.76.C2 raw_reads.99.raw_reads.76.N2 raw_reads.99.raw_reads.76.C3 raw_reads.99.raw_reads.76.N3 && LAmerge -v L1.99.76 raw_reads.99.raw_reads.76.C0.S raw_reads.99.raw_reads.76.N0.S raw_reads.99.raw_reads.76.C1.S raw_reads.99.raw_reads.76.N1.S raw_reads.99.raw_reads.76.C2.S raw_reads.99.raw_reads.76.N2.S raw_reads.99.raw_reads.76.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.77.C0 raw_reads.99.raw_reads.77.N0 raw_reads.99.raw_reads.77.C1 raw_reads.99.raw_reads.77.N1 raw_reads.99.raw_reads.77.C2 raw_reads.99.raw_reads.77.N2 raw_reads.99.raw_reads.77.C3 raw_reads.99.raw_reads.77.N3 && LAmerge -v L1.99.77 raw_reads.99.raw_reads.77.C0.S raw_reads.99.raw_reads.77.N0.S raw_reads.99.raw_reads.77.C1.S raw_reads.99.raw_reads.77.N1.S raw_reads.99.raw_reads.77.C2.S raw_reads.99.raw_reads.77.N2.S raw_reads.99.raw_reads.77.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.78.C0 raw_reads.99.raw_reads.78.N0 raw_reads.99.raw_reads.78.C1 raw_reads.99.raw_reads.78.N1 raw_reads.99.raw_reads.78.C2 raw_reads.99.raw_reads.78.N2 raw_reads.99.raw_reads.78.C3 raw_reads.99.raw_reads.78.N3 && LAmerge -v L1.99.78 raw_reads.99.raw_reads.78.C0.S raw_reads.99.raw_reads.78.N0.S raw_reads.99.raw_reads.78.C1.S raw_reads.99.raw_reads.78.N1.S raw_reads.99.raw_reads.78.C2.S raw_reads.99.raw_reads.78.N2.S raw_reads.99.raw_reads.78.C3.S raw_reads. [...]
+LAsort -v raw_reads.99.raw_reads.79.C0 raw_reads.99.raw_reads.79.N0 raw_reads.99.raw_reads.79.C1 raw_reads.99.raw_reads.79.N1 raw_reads.99.raw_reads.79.C2 raw_reads.99.raw_reads.79.N2 raw_reads.99.raw_reads.79.C3 raw_reads.99.raw_reads.79.N3 && LAmerge -v L1.99.79 raw_reads.99.raw_reads.79.C0.S raw_reads.99.raw_reads.79.N0.S raw_reads.99.raw_reads.79.C1.S raw_reads.99.raw_reads.79.N1.S raw_reads.99.raw_reads.79.C2.S raw_reads.99.raw_reads.79.N2.S raw_reads.99.raw_reads.79.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.60.99
+LAcheck -vS raw_reads L1.61.99
+LAcheck -vS raw_reads L1.62.99
+LAcheck -vS raw_reads L1.63.99
+LAcheck -vS raw_reads L1.64.99
+LAcheck -vS raw_reads L1.65.99
+LAcheck -vS raw_reads L1.66.99
+LAcheck -vS raw_reads L1.67.99
+LAcheck -vS raw_reads L1.68.99
+LAcheck -vS raw_reads L1.69.99
+LAcheck -vS raw_reads L1.70.99
+LAcheck -vS raw_reads L1.71.99
+LAcheck -vS raw_reads L1.72.99
+LAcheck -vS raw_reads L1.73.99
+LAcheck -vS raw_reads L1.74.99
+LAcheck -vS raw_reads L1.75.99
+LAcheck -vS raw_reads L1.76.99
+LAcheck -vS raw_reads L1.77.99
+LAcheck -vS raw_reads L1.78.99
+LAcheck -vS raw_reads L1.79.99
+LAcheck -vS raw_reads L1.99.60
+LAcheck -vS raw_reads L1.99.61
+LAcheck -vS raw_reads L1.99.62
+LAcheck -vS raw_reads L1.99.63
+LAcheck -vS raw_reads L1.99.64
+LAcheck -vS raw_reads L1.99.65
+LAcheck -vS raw_reads L1.99.66
+LAcheck -vS raw_reads L1.99.67
+LAcheck -vS raw_reads L1.99.68
+LAcheck -vS raw_reads L1.99.69
+LAcheck -vS raw_reads L1.99.70
+LAcheck -vS raw_reads L1.99.71
+LAcheck -vS raw_reads L1.99.72
+LAcheck -vS raw_reads L1.99.73
+LAcheck -vS raw_reads L1.99.74
+LAcheck -vS raw_reads L1.99.75
+LAcheck -vS raw_reads L1.99.76
+LAcheck -vS raw_reads L1.99.77
+LAcheck -vS raw_reads L1.99.78
+LAcheck -vS raw_reads L1.99.79
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.40 raw_reads.21 raw_reads.22 raw_reads.23 raw_reads.24 raw_reads.25 raw_reads.26 raw_reads.27 raw_reads.28 raw_reads.29 raw_reads.30 raw_reads.31 raw_reads.32 raw_reads.33 raw_reads.34 raw_reads.35 raw_reads.36 raw_reads.37 raw_reads.38 raw_reads.39 raw_reads.40
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.21.raw_reads.40.C0 raw_reads.21.raw_reads.40.N0 raw_reads.21.raw_reads.40.C1 raw_reads.21.raw_reads.40.N1 raw_reads.21.raw_reads.40.C2 raw_reads.21.raw_reads.40.N2 raw_reads.21.raw_reads.40.C3 raw_reads.21.raw_reads.40.N3 && LAmerge -v L1.21.40 raw_reads.21.raw_reads.40.C0.S raw_reads.21.raw_reads.40.N0.S raw_reads.21.raw_reads.40.C1.S raw_reads.21.raw_reads.40.N1.S raw_reads.21.raw_reads.40.C2.S raw_reads.21.raw_reads.40.N2.S raw_reads.21.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.22.raw_reads.40.C0 raw_reads.22.raw_reads.40.N0 raw_reads.22.raw_reads.40.C1 raw_reads.22.raw_reads.40.N1 raw_reads.22.raw_reads.40.C2 raw_reads.22.raw_reads.40.N2 raw_reads.22.raw_reads.40.C3 raw_reads.22.raw_reads.40.N3 && LAmerge -v L1.22.40 raw_reads.22.raw_reads.40.C0.S raw_reads.22.raw_reads.40.N0.S raw_reads.22.raw_reads.40.C1.S raw_reads.22.raw_reads.40.N1.S raw_reads.22.raw_reads.40.C2.S raw_reads.22.raw_reads.40.N2.S raw_reads.22.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.23.raw_reads.40.C0 raw_reads.23.raw_reads.40.N0 raw_reads.23.raw_reads.40.C1 raw_reads.23.raw_reads.40.N1 raw_reads.23.raw_reads.40.C2 raw_reads.23.raw_reads.40.N2 raw_reads.23.raw_reads.40.C3 raw_reads.23.raw_reads.40.N3 && LAmerge -v L1.23.40 raw_reads.23.raw_reads.40.C0.S raw_reads.23.raw_reads.40.N0.S raw_reads.23.raw_reads.40.C1.S raw_reads.23.raw_reads.40.N1.S raw_reads.23.raw_reads.40.C2.S raw_reads.23.raw_reads.40.N2.S raw_reads.23.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.24.raw_reads.40.C0 raw_reads.24.raw_reads.40.N0 raw_reads.24.raw_reads.40.C1 raw_reads.24.raw_reads.40.N1 raw_reads.24.raw_reads.40.C2 raw_reads.24.raw_reads.40.N2 raw_reads.24.raw_reads.40.C3 raw_reads.24.raw_reads.40.N3 && LAmerge -v L1.24.40 raw_reads.24.raw_reads.40.C0.S raw_reads.24.raw_reads.40.N0.S raw_reads.24.raw_reads.40.C1.S raw_reads.24.raw_reads.40.N1.S raw_reads.24.raw_reads.40.C2.S raw_reads.24.raw_reads.40.N2.S raw_reads.24.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.25.raw_reads.40.C0 raw_reads.25.raw_reads.40.N0 raw_reads.25.raw_reads.40.C1 raw_reads.25.raw_reads.40.N1 raw_reads.25.raw_reads.40.C2 raw_reads.25.raw_reads.40.N2 raw_reads.25.raw_reads.40.C3 raw_reads.25.raw_reads.40.N3 && LAmerge -v L1.25.40 raw_reads.25.raw_reads.40.C0.S raw_reads.25.raw_reads.40.N0.S raw_reads.25.raw_reads.40.C1.S raw_reads.25.raw_reads.40.N1.S raw_reads.25.raw_reads.40.C2.S raw_reads.25.raw_reads.40.N2.S raw_reads.25.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.26.raw_reads.40.C0 raw_reads.26.raw_reads.40.N0 raw_reads.26.raw_reads.40.C1 raw_reads.26.raw_reads.40.N1 raw_reads.26.raw_reads.40.C2 raw_reads.26.raw_reads.40.N2 raw_reads.26.raw_reads.40.C3 raw_reads.26.raw_reads.40.N3 && LAmerge -v L1.26.40 raw_reads.26.raw_reads.40.C0.S raw_reads.26.raw_reads.40.N0.S raw_reads.26.raw_reads.40.C1.S raw_reads.26.raw_reads.40.N1.S raw_reads.26.raw_reads.40.C2.S raw_reads.26.raw_reads.40.N2.S raw_reads.26.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.27.raw_reads.40.C0 raw_reads.27.raw_reads.40.N0 raw_reads.27.raw_reads.40.C1 raw_reads.27.raw_reads.40.N1 raw_reads.27.raw_reads.40.C2 raw_reads.27.raw_reads.40.N2 raw_reads.27.raw_reads.40.C3 raw_reads.27.raw_reads.40.N3 && LAmerge -v L1.27.40 raw_reads.27.raw_reads.40.C0.S raw_reads.27.raw_reads.40.N0.S raw_reads.27.raw_reads.40.C1.S raw_reads.27.raw_reads.40.N1.S raw_reads.27.raw_reads.40.C2.S raw_reads.27.raw_reads.40.N2.S raw_reads.27.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.28.raw_reads.40.C0 raw_reads.28.raw_reads.40.N0 raw_reads.28.raw_reads.40.C1 raw_reads.28.raw_reads.40.N1 raw_reads.28.raw_reads.40.C2 raw_reads.28.raw_reads.40.N2 raw_reads.28.raw_reads.40.C3 raw_reads.28.raw_reads.40.N3 && LAmerge -v L1.28.40 raw_reads.28.raw_reads.40.C0.S raw_reads.28.raw_reads.40.N0.S raw_reads.28.raw_reads.40.C1.S raw_reads.28.raw_reads.40.N1.S raw_reads.28.raw_reads.40.C2.S raw_reads.28.raw_reads.40.N2.S raw_reads.28.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.29.raw_reads.40.C0 raw_reads.29.raw_reads.40.N0 raw_reads.29.raw_reads.40.C1 raw_reads.29.raw_reads.40.N1 raw_reads.29.raw_reads.40.C2 raw_reads.29.raw_reads.40.N2 raw_reads.29.raw_reads.40.C3 raw_reads.29.raw_reads.40.N3 && LAmerge -v L1.29.40 raw_reads.29.raw_reads.40.C0.S raw_reads.29.raw_reads.40.N0.S raw_reads.29.raw_reads.40.C1.S raw_reads.29.raw_reads.40.N1.S raw_reads.29.raw_reads.40.C2.S raw_reads.29.raw_reads.40.N2.S raw_reads.29.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.30.raw_reads.40.C0 raw_reads.30.raw_reads.40.N0 raw_reads.30.raw_reads.40.C1 raw_reads.30.raw_reads.40.N1 raw_reads.30.raw_reads.40.C2 raw_reads.30.raw_reads.40.N2 raw_reads.30.raw_reads.40.C3 raw_reads.30.raw_reads.40.N3 && LAmerge -v L1.30.40 raw_reads.30.raw_reads.40.C0.S raw_reads.30.raw_reads.40.N0.S raw_reads.30.raw_reads.40.C1.S raw_reads.30.raw_reads.40.N1.S raw_reads.30.raw_reads.40.C2.S raw_reads.30.raw_reads.40.N2.S raw_reads.30.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.31.raw_reads.40.C0 raw_reads.31.raw_reads.40.N0 raw_reads.31.raw_reads.40.C1 raw_reads.31.raw_reads.40.N1 raw_reads.31.raw_reads.40.C2 raw_reads.31.raw_reads.40.N2 raw_reads.31.raw_reads.40.C3 raw_reads.31.raw_reads.40.N3 && LAmerge -v L1.31.40 raw_reads.31.raw_reads.40.C0.S raw_reads.31.raw_reads.40.N0.S raw_reads.31.raw_reads.40.C1.S raw_reads.31.raw_reads.40.N1.S raw_reads.31.raw_reads.40.C2.S raw_reads.31.raw_reads.40.N2.S raw_reads.31.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.32.raw_reads.40.C0 raw_reads.32.raw_reads.40.N0 raw_reads.32.raw_reads.40.C1 raw_reads.32.raw_reads.40.N1 raw_reads.32.raw_reads.40.C2 raw_reads.32.raw_reads.40.N2 raw_reads.32.raw_reads.40.C3 raw_reads.32.raw_reads.40.N3 && LAmerge -v L1.32.40 raw_reads.32.raw_reads.40.C0.S raw_reads.32.raw_reads.40.N0.S raw_reads.32.raw_reads.40.C1.S raw_reads.32.raw_reads.40.N1.S raw_reads.32.raw_reads.40.C2.S raw_reads.32.raw_reads.40.N2.S raw_reads.32.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.33.raw_reads.40.C0 raw_reads.33.raw_reads.40.N0 raw_reads.33.raw_reads.40.C1 raw_reads.33.raw_reads.40.N1 raw_reads.33.raw_reads.40.C2 raw_reads.33.raw_reads.40.N2 raw_reads.33.raw_reads.40.C3 raw_reads.33.raw_reads.40.N3 && LAmerge -v L1.33.40 raw_reads.33.raw_reads.40.C0.S raw_reads.33.raw_reads.40.N0.S raw_reads.33.raw_reads.40.C1.S raw_reads.33.raw_reads.40.N1.S raw_reads.33.raw_reads.40.C2.S raw_reads.33.raw_reads.40.N2.S raw_reads.33.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.34.raw_reads.40.C0 raw_reads.34.raw_reads.40.N0 raw_reads.34.raw_reads.40.C1 raw_reads.34.raw_reads.40.N1 raw_reads.34.raw_reads.40.C2 raw_reads.34.raw_reads.40.N2 raw_reads.34.raw_reads.40.C3 raw_reads.34.raw_reads.40.N3 && LAmerge -v L1.34.40 raw_reads.34.raw_reads.40.C0.S raw_reads.34.raw_reads.40.N0.S raw_reads.34.raw_reads.40.C1.S raw_reads.34.raw_reads.40.N1.S raw_reads.34.raw_reads.40.C2.S raw_reads.34.raw_reads.40.N2.S raw_reads.34.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.35.raw_reads.40.C0 raw_reads.35.raw_reads.40.N0 raw_reads.35.raw_reads.40.C1 raw_reads.35.raw_reads.40.N1 raw_reads.35.raw_reads.40.C2 raw_reads.35.raw_reads.40.N2 raw_reads.35.raw_reads.40.C3 raw_reads.35.raw_reads.40.N3 && LAmerge -v L1.35.40 raw_reads.35.raw_reads.40.C0.S raw_reads.35.raw_reads.40.N0.S raw_reads.35.raw_reads.40.C1.S raw_reads.35.raw_reads.40.N1.S raw_reads.35.raw_reads.40.C2.S raw_reads.35.raw_reads.40.N2.S raw_reads.35.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.36.raw_reads.40.C0 raw_reads.36.raw_reads.40.N0 raw_reads.36.raw_reads.40.C1 raw_reads.36.raw_reads.40.N1 raw_reads.36.raw_reads.40.C2 raw_reads.36.raw_reads.40.N2 raw_reads.36.raw_reads.40.C3 raw_reads.36.raw_reads.40.N3 && LAmerge -v L1.36.40 raw_reads.36.raw_reads.40.C0.S raw_reads.36.raw_reads.40.N0.S raw_reads.36.raw_reads.40.C1.S raw_reads.36.raw_reads.40.N1.S raw_reads.36.raw_reads.40.C2.S raw_reads.36.raw_reads.40.N2.S raw_reads.36.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.40.C0 raw_reads.37.raw_reads.40.N0 raw_reads.37.raw_reads.40.C1 raw_reads.37.raw_reads.40.N1 raw_reads.37.raw_reads.40.C2 raw_reads.37.raw_reads.40.N2 raw_reads.37.raw_reads.40.C3 raw_reads.37.raw_reads.40.N3 && LAmerge -v L1.37.40 raw_reads.37.raw_reads.40.C0.S raw_reads.37.raw_reads.40.N0.S raw_reads.37.raw_reads.40.C1.S raw_reads.37.raw_reads.40.N1.S raw_reads.37.raw_reads.40.C2.S raw_reads.37.raw_reads.40.N2.S raw_reads.37.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.38.raw_reads.40.C0 raw_reads.38.raw_reads.40.N0 raw_reads.38.raw_reads.40.C1 raw_reads.38.raw_reads.40.N1 raw_reads.38.raw_reads.40.C2 raw_reads.38.raw_reads.40.N2 raw_reads.38.raw_reads.40.C3 raw_reads.38.raw_reads.40.N3 && LAmerge -v L1.38.40 raw_reads.38.raw_reads.40.C0.S raw_reads.38.raw_reads.40.N0.S raw_reads.38.raw_reads.40.C1.S raw_reads.38.raw_reads.40.N1.S raw_reads.38.raw_reads.40.C2.S raw_reads.38.raw_reads.40.N2.S raw_reads.38.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.39.raw_reads.40.C0 raw_reads.39.raw_reads.40.N0 raw_reads.39.raw_reads.40.C1 raw_reads.39.raw_reads.40.N1 raw_reads.39.raw_reads.40.C2 raw_reads.39.raw_reads.40.N2 raw_reads.39.raw_reads.40.C3 raw_reads.39.raw_reads.40.N3 && LAmerge -v L1.39.40 raw_reads.39.raw_reads.40.C0.S raw_reads.39.raw_reads.40.N0.S raw_reads.39.raw_reads.40.C1.S raw_reads.39.raw_reads.40.N1.S raw_reads.39.raw_reads.40.C2.S raw_reads.39.raw_reads.40.N2.S raw_reads.39.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.21.C0 raw_reads.40.raw_reads.21.N0 raw_reads.40.raw_reads.21.C1 raw_reads.40.raw_reads.21.N1 raw_reads.40.raw_reads.21.C2 raw_reads.40.raw_reads.21.N2 raw_reads.40.raw_reads.21.C3 raw_reads.40.raw_reads.21.N3 && LAmerge -v L1.40.21 raw_reads.40.raw_reads.21.C0.S raw_reads.40.raw_reads.21.N0.S raw_reads.40.raw_reads.21.C1.S raw_reads.40.raw_reads.21.N1.S raw_reads.40.raw_reads.21.C2.S raw_reads.40.raw_reads.21.N2.S raw_reads.40.raw_reads.21.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.22.C0 raw_reads.40.raw_reads.22.N0 raw_reads.40.raw_reads.22.C1 raw_reads.40.raw_reads.22.N1 raw_reads.40.raw_reads.22.C2 raw_reads.40.raw_reads.22.N2 raw_reads.40.raw_reads.22.C3 raw_reads.40.raw_reads.22.N3 && LAmerge -v L1.40.22 raw_reads.40.raw_reads.22.C0.S raw_reads.40.raw_reads.22.N0.S raw_reads.40.raw_reads.22.C1.S raw_reads.40.raw_reads.22.N1.S raw_reads.40.raw_reads.22.C2.S raw_reads.40.raw_reads.22.N2.S raw_reads.40.raw_reads.22.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.23.C0 raw_reads.40.raw_reads.23.N0 raw_reads.40.raw_reads.23.C1 raw_reads.40.raw_reads.23.N1 raw_reads.40.raw_reads.23.C2 raw_reads.40.raw_reads.23.N2 raw_reads.40.raw_reads.23.C3 raw_reads.40.raw_reads.23.N3 && LAmerge -v L1.40.23 raw_reads.40.raw_reads.23.C0.S raw_reads.40.raw_reads.23.N0.S raw_reads.40.raw_reads.23.C1.S raw_reads.40.raw_reads.23.N1.S raw_reads.40.raw_reads.23.C2.S raw_reads.40.raw_reads.23.N2.S raw_reads.40.raw_reads.23.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.24.C0 raw_reads.40.raw_reads.24.N0 raw_reads.40.raw_reads.24.C1 raw_reads.40.raw_reads.24.N1 raw_reads.40.raw_reads.24.C2 raw_reads.40.raw_reads.24.N2 raw_reads.40.raw_reads.24.C3 raw_reads.40.raw_reads.24.N3 && LAmerge -v L1.40.24 raw_reads.40.raw_reads.24.C0.S raw_reads.40.raw_reads.24.N0.S raw_reads.40.raw_reads.24.C1.S raw_reads.40.raw_reads.24.N1.S raw_reads.40.raw_reads.24.C2.S raw_reads.40.raw_reads.24.N2.S raw_reads.40.raw_reads.24.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.25.C0 raw_reads.40.raw_reads.25.N0 raw_reads.40.raw_reads.25.C1 raw_reads.40.raw_reads.25.N1 raw_reads.40.raw_reads.25.C2 raw_reads.40.raw_reads.25.N2 raw_reads.40.raw_reads.25.C3 raw_reads.40.raw_reads.25.N3 && LAmerge -v L1.40.25 raw_reads.40.raw_reads.25.C0.S raw_reads.40.raw_reads.25.N0.S raw_reads.40.raw_reads.25.C1.S raw_reads.40.raw_reads.25.N1.S raw_reads.40.raw_reads.25.C2.S raw_reads.40.raw_reads.25.N2.S raw_reads.40.raw_reads.25.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.26.C0 raw_reads.40.raw_reads.26.N0 raw_reads.40.raw_reads.26.C1 raw_reads.40.raw_reads.26.N1 raw_reads.40.raw_reads.26.C2 raw_reads.40.raw_reads.26.N2 raw_reads.40.raw_reads.26.C3 raw_reads.40.raw_reads.26.N3 && LAmerge -v L1.40.26 raw_reads.40.raw_reads.26.C0.S raw_reads.40.raw_reads.26.N0.S raw_reads.40.raw_reads.26.C1.S raw_reads.40.raw_reads.26.N1.S raw_reads.40.raw_reads.26.C2.S raw_reads.40.raw_reads.26.N2.S raw_reads.40.raw_reads.26.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.27.C0 raw_reads.40.raw_reads.27.N0 raw_reads.40.raw_reads.27.C1 raw_reads.40.raw_reads.27.N1 raw_reads.40.raw_reads.27.C2 raw_reads.40.raw_reads.27.N2 raw_reads.40.raw_reads.27.C3 raw_reads.40.raw_reads.27.N3 && LAmerge -v L1.40.27 raw_reads.40.raw_reads.27.C0.S raw_reads.40.raw_reads.27.N0.S raw_reads.40.raw_reads.27.C1.S raw_reads.40.raw_reads.27.N1.S raw_reads.40.raw_reads.27.C2.S raw_reads.40.raw_reads.27.N2.S raw_reads.40.raw_reads.27.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.28.C0 raw_reads.40.raw_reads.28.N0 raw_reads.40.raw_reads.28.C1 raw_reads.40.raw_reads.28.N1 raw_reads.40.raw_reads.28.C2 raw_reads.40.raw_reads.28.N2 raw_reads.40.raw_reads.28.C3 raw_reads.40.raw_reads.28.N3 && LAmerge -v L1.40.28 raw_reads.40.raw_reads.28.C0.S raw_reads.40.raw_reads.28.N0.S raw_reads.40.raw_reads.28.C1.S raw_reads.40.raw_reads.28.N1.S raw_reads.40.raw_reads.28.C2.S raw_reads.40.raw_reads.28.N2.S raw_reads.40.raw_reads.28.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.29.C0 raw_reads.40.raw_reads.29.N0 raw_reads.40.raw_reads.29.C1 raw_reads.40.raw_reads.29.N1 raw_reads.40.raw_reads.29.C2 raw_reads.40.raw_reads.29.N2 raw_reads.40.raw_reads.29.C3 raw_reads.40.raw_reads.29.N3 && LAmerge -v L1.40.29 raw_reads.40.raw_reads.29.C0.S raw_reads.40.raw_reads.29.N0.S raw_reads.40.raw_reads.29.C1.S raw_reads.40.raw_reads.29.N1.S raw_reads.40.raw_reads.29.C2.S raw_reads.40.raw_reads.29.N2.S raw_reads.40.raw_reads.29.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.30.C0 raw_reads.40.raw_reads.30.N0 raw_reads.40.raw_reads.30.C1 raw_reads.40.raw_reads.30.N1 raw_reads.40.raw_reads.30.C2 raw_reads.40.raw_reads.30.N2 raw_reads.40.raw_reads.30.C3 raw_reads.40.raw_reads.30.N3 && LAmerge -v L1.40.30 raw_reads.40.raw_reads.30.C0.S raw_reads.40.raw_reads.30.N0.S raw_reads.40.raw_reads.30.C1.S raw_reads.40.raw_reads.30.N1.S raw_reads.40.raw_reads.30.C2.S raw_reads.40.raw_reads.30.N2.S raw_reads.40.raw_reads.30.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.31.C0 raw_reads.40.raw_reads.31.N0 raw_reads.40.raw_reads.31.C1 raw_reads.40.raw_reads.31.N1 raw_reads.40.raw_reads.31.C2 raw_reads.40.raw_reads.31.N2 raw_reads.40.raw_reads.31.C3 raw_reads.40.raw_reads.31.N3 && LAmerge -v L1.40.31 raw_reads.40.raw_reads.31.C0.S raw_reads.40.raw_reads.31.N0.S raw_reads.40.raw_reads.31.C1.S raw_reads.40.raw_reads.31.N1.S raw_reads.40.raw_reads.31.C2.S raw_reads.40.raw_reads.31.N2.S raw_reads.40.raw_reads.31.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.32.C0 raw_reads.40.raw_reads.32.N0 raw_reads.40.raw_reads.32.C1 raw_reads.40.raw_reads.32.N1 raw_reads.40.raw_reads.32.C2 raw_reads.40.raw_reads.32.N2 raw_reads.40.raw_reads.32.C3 raw_reads.40.raw_reads.32.N3 && LAmerge -v L1.40.32 raw_reads.40.raw_reads.32.C0.S raw_reads.40.raw_reads.32.N0.S raw_reads.40.raw_reads.32.C1.S raw_reads.40.raw_reads.32.N1.S raw_reads.40.raw_reads.32.C2.S raw_reads.40.raw_reads.32.N2.S raw_reads.40.raw_reads.32.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.33.C0 raw_reads.40.raw_reads.33.N0 raw_reads.40.raw_reads.33.C1 raw_reads.40.raw_reads.33.N1 raw_reads.40.raw_reads.33.C2 raw_reads.40.raw_reads.33.N2 raw_reads.40.raw_reads.33.C3 raw_reads.40.raw_reads.33.N3 && LAmerge -v L1.40.33 raw_reads.40.raw_reads.33.C0.S raw_reads.40.raw_reads.33.N0.S raw_reads.40.raw_reads.33.C1.S raw_reads.40.raw_reads.33.N1.S raw_reads.40.raw_reads.33.C2.S raw_reads.40.raw_reads.33.N2.S raw_reads.40.raw_reads.33.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.34.C0 raw_reads.40.raw_reads.34.N0 raw_reads.40.raw_reads.34.C1 raw_reads.40.raw_reads.34.N1 raw_reads.40.raw_reads.34.C2 raw_reads.40.raw_reads.34.N2 raw_reads.40.raw_reads.34.C3 raw_reads.40.raw_reads.34.N3 && LAmerge -v L1.40.34 raw_reads.40.raw_reads.34.C0.S raw_reads.40.raw_reads.34.N0.S raw_reads.40.raw_reads.34.C1.S raw_reads.40.raw_reads.34.N1.S raw_reads.40.raw_reads.34.C2.S raw_reads.40.raw_reads.34.N2.S raw_reads.40.raw_reads.34.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.35.C0 raw_reads.40.raw_reads.35.N0 raw_reads.40.raw_reads.35.C1 raw_reads.40.raw_reads.35.N1 raw_reads.40.raw_reads.35.C2 raw_reads.40.raw_reads.35.N2 raw_reads.40.raw_reads.35.C3 raw_reads.40.raw_reads.35.N3 && LAmerge -v L1.40.35 raw_reads.40.raw_reads.35.C0.S raw_reads.40.raw_reads.35.N0.S raw_reads.40.raw_reads.35.C1.S raw_reads.40.raw_reads.35.N1.S raw_reads.40.raw_reads.35.C2.S raw_reads.40.raw_reads.35.N2.S raw_reads.40.raw_reads.35.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.36.C0 raw_reads.40.raw_reads.36.N0 raw_reads.40.raw_reads.36.C1 raw_reads.40.raw_reads.36.N1 raw_reads.40.raw_reads.36.C2 raw_reads.40.raw_reads.36.N2 raw_reads.40.raw_reads.36.C3 raw_reads.40.raw_reads.36.N3 && LAmerge -v L1.40.36 raw_reads.40.raw_reads.36.C0.S raw_reads.40.raw_reads.36.N0.S raw_reads.40.raw_reads.36.C1.S raw_reads.40.raw_reads.36.N1.S raw_reads.40.raw_reads.36.C2.S raw_reads.40.raw_reads.36.N2.S raw_reads.40.raw_reads.36.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.37.C0 raw_reads.40.raw_reads.37.N0 raw_reads.40.raw_reads.37.C1 raw_reads.40.raw_reads.37.N1 raw_reads.40.raw_reads.37.C2 raw_reads.40.raw_reads.37.N2 raw_reads.40.raw_reads.37.C3 raw_reads.40.raw_reads.37.N3 && LAmerge -v L1.40.37 raw_reads.40.raw_reads.37.C0.S raw_reads.40.raw_reads.37.N0.S raw_reads.40.raw_reads.37.C1.S raw_reads.40.raw_reads.37.N1.S raw_reads.40.raw_reads.37.C2.S raw_reads.40.raw_reads.37.N2.S raw_reads.40.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.38.C0 raw_reads.40.raw_reads.38.N0 raw_reads.40.raw_reads.38.C1 raw_reads.40.raw_reads.38.N1 raw_reads.40.raw_reads.38.C2 raw_reads.40.raw_reads.38.N2 raw_reads.40.raw_reads.38.C3 raw_reads.40.raw_reads.38.N3 && LAmerge -v L1.40.38 raw_reads.40.raw_reads.38.C0.S raw_reads.40.raw_reads.38.N0.S raw_reads.40.raw_reads.38.C1.S raw_reads.40.raw_reads.38.N1.S raw_reads.40.raw_reads.38.C2.S raw_reads.40.raw_reads.38.N2.S raw_reads.40.raw_reads.38.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.39.C0 raw_reads.40.raw_reads.39.N0 raw_reads.40.raw_reads.39.C1 raw_reads.40.raw_reads.39.N1 raw_reads.40.raw_reads.39.C2 raw_reads.40.raw_reads.39.N2 raw_reads.40.raw_reads.39.C3 raw_reads.40.raw_reads.39.N3 && LAmerge -v L1.40.39 raw_reads.40.raw_reads.39.C0.S raw_reads.40.raw_reads.39.N0.S raw_reads.40.raw_reads.39.C1.S raw_reads.40.raw_reads.39.N1.S raw_reads.40.raw_reads.39.C2.S raw_reads.40.raw_reads.39.N2.S raw_reads.40.raw_reads.39.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.40.C0 raw_reads.40.raw_reads.40.N0 raw_reads.40.raw_reads.40.C1 raw_reads.40.raw_reads.40.N1 raw_reads.40.raw_reads.40.C2 raw_reads.40.raw_reads.40.N2 raw_reads.40.raw_reads.40.C3 raw_reads.40.raw_reads.40.N3 && LAmerge -v L1.40.40 raw_reads.40.raw_reads.40.C0.S raw_reads.40.raw_reads.40.N0.S raw_reads.40.raw_reads.40.C1.S raw_reads.40.raw_reads.40.N1.S raw_reads.40.raw_reads.40.C2.S raw_reads.40.raw_reads.40.N2.S raw_reads.40.raw_reads.40.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.21.40
+LAcheck -vS raw_reads L1.22.40
+LAcheck -vS raw_reads L1.23.40
+LAcheck -vS raw_reads L1.24.40
+LAcheck -vS raw_reads L1.25.40
+LAcheck -vS raw_reads L1.26.40
+LAcheck -vS raw_reads L1.27.40
+LAcheck -vS raw_reads L1.28.40
+LAcheck -vS raw_reads L1.29.40
+LAcheck -vS raw_reads L1.30.40
+LAcheck -vS raw_reads L1.31.40
+LAcheck -vS raw_reads L1.32.40
+LAcheck -vS raw_reads L1.33.40
+LAcheck -vS raw_reads L1.34.40
+LAcheck -vS raw_reads L1.35.40
+LAcheck -vS raw_reads L1.36.40
+LAcheck -vS raw_reads L1.37.40
+LAcheck -vS raw_reads L1.38.40
+LAcheck -vS raw_reads L1.39.40
+LAcheck -vS raw_reads L1.40.21
+LAcheck -vS raw_reads L1.40.22
+LAcheck -vS raw_reads L1.40.23
+LAcheck -vS raw_reads L1.40.24
+LAcheck -vS raw_reads L1.40.25
+LAcheck -vS raw_reads L1.40.26
+LAcheck -vS raw_reads L1.40.27
+LAcheck -vS raw_reads L1.40.28
+LAcheck -vS raw_reads L1.40.29
+LAcheck -vS raw_reads L1.40.30
+LAcheck -vS raw_reads L1.40.31
+LAcheck -vS raw_reads L1.40.32
+LAcheck -vS raw_reads L1.40.33
+LAcheck -vS raw_reads L1.40.34
+LAcheck -vS raw_reads L1.40.35
+LAcheck -vS raw_reads L1.40.36
+LAcheck -vS raw_reads L1.40.37
+LAcheck -vS raw_reads L1.40.38
+LAcheck -vS raw_reads L1.40.39
+LAcheck -vS raw_reads L1.40.40
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.63 raw_reads.1 raw_reads.2 raw_reads.3 raw_reads.4 raw_reads.5 raw_reads.6 raw_reads.7 raw_reads.8 raw_reads.9 raw_reads.10 raw_reads.11 raw_reads.12 raw_reads.13 raw_reads.14 raw_reads.15 raw_reads.16 raw_reads.17 raw_reads.18 raw_reads.19 raw_reads.20 raw_reads.21
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.1.raw_reads.63.C0 raw_reads.1.raw_reads.63.N0 raw_reads.1.raw_reads.63.C1 raw_reads.1.raw_reads.63.N1 raw_reads.1.raw_reads.63.C2 raw_reads.1.raw_reads.63.N2 raw_reads.1.raw_reads.63.C3 raw_reads.1.raw_reads.63.N3 && LAmerge -v L1.1.63 raw_reads.1.raw_reads.63.C0.S raw_reads.1.raw_reads.63.N0.S raw_reads.1.raw_reads.63.C1.S raw_reads.1.raw_reads.63.N1.S raw_reads.1.raw_reads.63.C2.S raw_reads.1.raw_reads.63.N2.S raw_reads.1.raw_reads.63.C3.S raw_reads.1.raw_reads.63.N3.S
+LAsort -v raw_reads.2.raw_reads.63.C0 raw_reads.2.raw_reads.63.N0 raw_reads.2.raw_reads.63.C1 raw_reads.2.raw_reads.63.N1 raw_reads.2.raw_reads.63.C2 raw_reads.2.raw_reads.63.N2 raw_reads.2.raw_reads.63.C3 raw_reads.2.raw_reads.63.N3 && LAmerge -v L1.2.63 raw_reads.2.raw_reads.63.C0.S raw_reads.2.raw_reads.63.N0.S raw_reads.2.raw_reads.63.C1.S raw_reads.2.raw_reads.63.N1.S raw_reads.2.raw_reads.63.C2.S raw_reads.2.raw_reads.63.N2.S raw_reads.2.raw_reads.63.C3.S raw_reads.2.raw_reads.63.N3.S
+LAsort -v raw_reads.3.raw_reads.63.C0 raw_reads.3.raw_reads.63.N0 raw_reads.3.raw_reads.63.C1 raw_reads.3.raw_reads.63.N1 raw_reads.3.raw_reads.63.C2 raw_reads.3.raw_reads.63.N2 raw_reads.3.raw_reads.63.C3 raw_reads.3.raw_reads.63.N3 && LAmerge -v L1.3.63 raw_reads.3.raw_reads.63.C0.S raw_reads.3.raw_reads.63.N0.S raw_reads.3.raw_reads.63.C1.S raw_reads.3.raw_reads.63.N1.S raw_reads.3.raw_reads.63.C2.S raw_reads.3.raw_reads.63.N2.S raw_reads.3.raw_reads.63.C3.S raw_reads.3.raw_reads.63.N3.S
+LAsort -v raw_reads.4.raw_reads.63.C0 raw_reads.4.raw_reads.63.N0 raw_reads.4.raw_reads.63.C1 raw_reads.4.raw_reads.63.N1 raw_reads.4.raw_reads.63.C2 raw_reads.4.raw_reads.63.N2 raw_reads.4.raw_reads.63.C3 raw_reads.4.raw_reads.63.N3 && LAmerge -v L1.4.63 raw_reads.4.raw_reads.63.C0.S raw_reads.4.raw_reads.63.N0.S raw_reads.4.raw_reads.63.C1.S raw_reads.4.raw_reads.63.N1.S raw_reads.4.raw_reads.63.C2.S raw_reads.4.raw_reads.63.N2.S raw_reads.4.raw_reads.63.C3.S raw_reads.4.raw_reads.63.N3.S
+LAsort -v raw_reads.5.raw_reads.63.C0 raw_reads.5.raw_reads.63.N0 raw_reads.5.raw_reads.63.C1 raw_reads.5.raw_reads.63.N1 raw_reads.5.raw_reads.63.C2 raw_reads.5.raw_reads.63.N2 raw_reads.5.raw_reads.63.C3 raw_reads.5.raw_reads.63.N3 && LAmerge -v L1.5.63 raw_reads.5.raw_reads.63.C0.S raw_reads.5.raw_reads.63.N0.S raw_reads.5.raw_reads.63.C1.S raw_reads.5.raw_reads.63.N1.S raw_reads.5.raw_reads.63.C2.S raw_reads.5.raw_reads.63.N2.S raw_reads.5.raw_reads.63.C3.S raw_reads.5.raw_reads.63.N3.S
+LAsort -v raw_reads.6.raw_reads.63.C0 raw_reads.6.raw_reads.63.N0 raw_reads.6.raw_reads.63.C1 raw_reads.6.raw_reads.63.N1 raw_reads.6.raw_reads.63.C2 raw_reads.6.raw_reads.63.N2 raw_reads.6.raw_reads.63.C3 raw_reads.6.raw_reads.63.N3 && LAmerge -v L1.6.63 raw_reads.6.raw_reads.63.C0.S raw_reads.6.raw_reads.63.N0.S raw_reads.6.raw_reads.63.C1.S raw_reads.6.raw_reads.63.N1.S raw_reads.6.raw_reads.63.C2.S raw_reads.6.raw_reads.63.N2.S raw_reads.6.raw_reads.63.C3.S raw_reads.6.raw_reads.63.N3.S
+LAsort -v raw_reads.7.raw_reads.63.C0 raw_reads.7.raw_reads.63.N0 raw_reads.7.raw_reads.63.C1 raw_reads.7.raw_reads.63.N1 raw_reads.7.raw_reads.63.C2 raw_reads.7.raw_reads.63.N2 raw_reads.7.raw_reads.63.C3 raw_reads.7.raw_reads.63.N3 && LAmerge -v L1.7.63 raw_reads.7.raw_reads.63.C0.S raw_reads.7.raw_reads.63.N0.S raw_reads.7.raw_reads.63.C1.S raw_reads.7.raw_reads.63.N1.S raw_reads.7.raw_reads.63.C2.S raw_reads.7.raw_reads.63.N2.S raw_reads.7.raw_reads.63.C3.S raw_reads.7.raw_reads.63.N3.S
+LAsort -v raw_reads.8.raw_reads.63.C0 raw_reads.8.raw_reads.63.N0 raw_reads.8.raw_reads.63.C1 raw_reads.8.raw_reads.63.N1 raw_reads.8.raw_reads.63.C2 raw_reads.8.raw_reads.63.N2 raw_reads.8.raw_reads.63.C3 raw_reads.8.raw_reads.63.N3 && LAmerge -v L1.8.63 raw_reads.8.raw_reads.63.C0.S raw_reads.8.raw_reads.63.N0.S raw_reads.8.raw_reads.63.C1.S raw_reads.8.raw_reads.63.N1.S raw_reads.8.raw_reads.63.C2.S raw_reads.8.raw_reads.63.N2.S raw_reads.8.raw_reads.63.C3.S raw_reads.8.raw_reads.63.N3.S
+LAsort -v raw_reads.9.raw_reads.63.C0 raw_reads.9.raw_reads.63.N0 raw_reads.9.raw_reads.63.C1 raw_reads.9.raw_reads.63.N1 raw_reads.9.raw_reads.63.C2 raw_reads.9.raw_reads.63.N2 raw_reads.9.raw_reads.63.C3 raw_reads.9.raw_reads.63.N3 && LAmerge -v L1.9.63 raw_reads.9.raw_reads.63.C0.S raw_reads.9.raw_reads.63.N0.S raw_reads.9.raw_reads.63.C1.S raw_reads.9.raw_reads.63.N1.S raw_reads.9.raw_reads.63.C2.S raw_reads.9.raw_reads.63.N2.S raw_reads.9.raw_reads.63.C3.S raw_reads.9.raw_reads.63.N3.S
+LAsort -v raw_reads.10.raw_reads.63.C0 raw_reads.10.raw_reads.63.N0 raw_reads.10.raw_reads.63.C1 raw_reads.10.raw_reads.63.N1 raw_reads.10.raw_reads.63.C2 raw_reads.10.raw_reads.63.N2 raw_reads.10.raw_reads.63.C3 raw_reads.10.raw_reads.63.N3 && LAmerge -v L1.10.63 raw_reads.10.raw_reads.63.C0.S raw_reads.10.raw_reads.63.N0.S raw_reads.10.raw_reads.63.C1.S raw_reads.10.raw_reads.63.N1.S raw_reads.10.raw_reads.63.C2.S raw_reads.10.raw_reads.63.N2.S raw_reads.10.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.11.raw_reads.63.C0 raw_reads.11.raw_reads.63.N0 raw_reads.11.raw_reads.63.C1 raw_reads.11.raw_reads.63.N1 raw_reads.11.raw_reads.63.C2 raw_reads.11.raw_reads.63.N2 raw_reads.11.raw_reads.63.C3 raw_reads.11.raw_reads.63.N3 && LAmerge -v L1.11.63 raw_reads.11.raw_reads.63.C0.S raw_reads.11.raw_reads.63.N0.S raw_reads.11.raw_reads.63.C1.S raw_reads.11.raw_reads.63.N1.S raw_reads.11.raw_reads.63.C2.S raw_reads.11.raw_reads.63.N2.S raw_reads.11.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.12.raw_reads.63.C0 raw_reads.12.raw_reads.63.N0 raw_reads.12.raw_reads.63.C1 raw_reads.12.raw_reads.63.N1 raw_reads.12.raw_reads.63.C2 raw_reads.12.raw_reads.63.N2 raw_reads.12.raw_reads.63.C3 raw_reads.12.raw_reads.63.N3 && LAmerge -v L1.12.63 raw_reads.12.raw_reads.63.C0.S raw_reads.12.raw_reads.63.N0.S raw_reads.12.raw_reads.63.C1.S raw_reads.12.raw_reads.63.N1.S raw_reads.12.raw_reads.63.C2.S raw_reads.12.raw_reads.63.N2.S raw_reads.12.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.13.raw_reads.63.C0 raw_reads.13.raw_reads.63.N0 raw_reads.13.raw_reads.63.C1 raw_reads.13.raw_reads.63.N1 raw_reads.13.raw_reads.63.C2 raw_reads.13.raw_reads.63.N2 raw_reads.13.raw_reads.63.C3 raw_reads.13.raw_reads.63.N3 && LAmerge -v L1.13.63 raw_reads.13.raw_reads.63.C0.S raw_reads.13.raw_reads.63.N0.S raw_reads.13.raw_reads.63.C1.S raw_reads.13.raw_reads.63.N1.S raw_reads.13.raw_reads.63.C2.S raw_reads.13.raw_reads.63.N2.S raw_reads.13.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.14.raw_reads.63.C0 raw_reads.14.raw_reads.63.N0 raw_reads.14.raw_reads.63.C1 raw_reads.14.raw_reads.63.N1 raw_reads.14.raw_reads.63.C2 raw_reads.14.raw_reads.63.N2 raw_reads.14.raw_reads.63.C3 raw_reads.14.raw_reads.63.N3 && LAmerge -v L1.14.63 raw_reads.14.raw_reads.63.C0.S raw_reads.14.raw_reads.63.N0.S raw_reads.14.raw_reads.63.C1.S raw_reads.14.raw_reads.63.N1.S raw_reads.14.raw_reads.63.C2.S raw_reads.14.raw_reads.63.N2.S raw_reads.14.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.15.raw_reads.63.C0 raw_reads.15.raw_reads.63.N0 raw_reads.15.raw_reads.63.C1 raw_reads.15.raw_reads.63.N1 raw_reads.15.raw_reads.63.C2 raw_reads.15.raw_reads.63.N2 raw_reads.15.raw_reads.63.C3 raw_reads.15.raw_reads.63.N3 && LAmerge -v L1.15.63 raw_reads.15.raw_reads.63.C0.S raw_reads.15.raw_reads.63.N0.S raw_reads.15.raw_reads.63.C1.S raw_reads.15.raw_reads.63.N1.S raw_reads.15.raw_reads.63.C2.S raw_reads.15.raw_reads.63.N2.S raw_reads.15.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.16.raw_reads.63.C0 raw_reads.16.raw_reads.63.N0 raw_reads.16.raw_reads.63.C1 raw_reads.16.raw_reads.63.N1 raw_reads.16.raw_reads.63.C2 raw_reads.16.raw_reads.63.N2 raw_reads.16.raw_reads.63.C3 raw_reads.16.raw_reads.63.N3 && LAmerge -v L1.16.63 raw_reads.16.raw_reads.63.C0.S raw_reads.16.raw_reads.63.N0.S raw_reads.16.raw_reads.63.C1.S raw_reads.16.raw_reads.63.N1.S raw_reads.16.raw_reads.63.C2.S raw_reads.16.raw_reads.63.N2.S raw_reads.16.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.17.raw_reads.63.C0 raw_reads.17.raw_reads.63.N0 raw_reads.17.raw_reads.63.C1 raw_reads.17.raw_reads.63.N1 raw_reads.17.raw_reads.63.C2 raw_reads.17.raw_reads.63.N2 raw_reads.17.raw_reads.63.C3 raw_reads.17.raw_reads.63.N3 && LAmerge -v L1.17.63 raw_reads.17.raw_reads.63.C0.S raw_reads.17.raw_reads.63.N0.S raw_reads.17.raw_reads.63.C1.S raw_reads.17.raw_reads.63.N1.S raw_reads.17.raw_reads.63.C2.S raw_reads.17.raw_reads.63.N2.S raw_reads.17.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.18.raw_reads.63.C0 raw_reads.18.raw_reads.63.N0 raw_reads.18.raw_reads.63.C1 raw_reads.18.raw_reads.63.N1 raw_reads.18.raw_reads.63.C2 raw_reads.18.raw_reads.63.N2 raw_reads.18.raw_reads.63.C3 raw_reads.18.raw_reads.63.N3 && LAmerge -v L1.18.63 raw_reads.18.raw_reads.63.C0.S raw_reads.18.raw_reads.63.N0.S raw_reads.18.raw_reads.63.C1.S raw_reads.18.raw_reads.63.N1.S raw_reads.18.raw_reads.63.C2.S raw_reads.18.raw_reads.63.N2.S raw_reads.18.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.19.raw_reads.63.C0 raw_reads.19.raw_reads.63.N0 raw_reads.19.raw_reads.63.C1 raw_reads.19.raw_reads.63.N1 raw_reads.19.raw_reads.63.C2 raw_reads.19.raw_reads.63.N2 raw_reads.19.raw_reads.63.C3 raw_reads.19.raw_reads.63.N3 && LAmerge -v L1.19.63 raw_reads.19.raw_reads.63.C0.S raw_reads.19.raw_reads.63.N0.S raw_reads.19.raw_reads.63.C1.S raw_reads.19.raw_reads.63.N1.S raw_reads.19.raw_reads.63.C2.S raw_reads.19.raw_reads.63.N2.S raw_reads.19.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.20.raw_reads.63.C0 raw_reads.20.raw_reads.63.N0 raw_reads.20.raw_reads.63.C1 raw_reads.20.raw_reads.63.N1 raw_reads.20.raw_reads.63.C2 raw_reads.20.raw_reads.63.N2 raw_reads.20.raw_reads.63.C3 raw_reads.20.raw_reads.63.N3 && LAmerge -v L1.20.63 raw_reads.20.raw_reads.63.C0.S raw_reads.20.raw_reads.63.N0.S raw_reads.20.raw_reads.63.C1.S raw_reads.20.raw_reads.63.N1.S raw_reads.20.raw_reads.63.C2.S raw_reads.20.raw_reads.63.N2.S raw_reads.20.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.21.raw_reads.63.C0 raw_reads.21.raw_reads.63.N0 raw_reads.21.raw_reads.63.C1 raw_reads.21.raw_reads.63.N1 raw_reads.21.raw_reads.63.C2 raw_reads.21.raw_reads.63.N2 raw_reads.21.raw_reads.63.C3 raw_reads.21.raw_reads.63.N3 && LAmerge -v L1.21.63 raw_reads.21.raw_reads.63.C0.S raw_reads.21.raw_reads.63.N0.S raw_reads.21.raw_reads.63.C1.S raw_reads.21.raw_reads.63.N1.S raw_reads.21.raw_reads.63.C2.S raw_reads.21.raw_reads.63.N2.S raw_reads.21.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.1.C0 raw_reads.63.raw_reads.1.N0 raw_reads.63.raw_reads.1.C1 raw_reads.63.raw_reads.1.N1 raw_reads.63.raw_reads.1.C2 raw_reads.63.raw_reads.1.N2 raw_reads.63.raw_reads.1.C3 raw_reads.63.raw_reads.1.N3 && LAmerge -v L1.63.1 raw_reads.63.raw_reads.1.C0.S raw_reads.63.raw_reads.1.N0.S raw_reads.63.raw_reads.1.C1.S raw_reads.63.raw_reads.1.N1.S raw_reads.63.raw_reads.1.C2.S raw_reads.63.raw_reads.1.N2.S raw_reads.63.raw_reads.1.C3.S raw_reads.63.raw_reads.1.N3.S
+LAsort -v raw_reads.63.raw_reads.2.C0 raw_reads.63.raw_reads.2.N0 raw_reads.63.raw_reads.2.C1 raw_reads.63.raw_reads.2.N1 raw_reads.63.raw_reads.2.C2 raw_reads.63.raw_reads.2.N2 raw_reads.63.raw_reads.2.C3 raw_reads.63.raw_reads.2.N3 && LAmerge -v L1.63.2 raw_reads.63.raw_reads.2.C0.S raw_reads.63.raw_reads.2.N0.S raw_reads.63.raw_reads.2.C1.S raw_reads.63.raw_reads.2.N1.S raw_reads.63.raw_reads.2.C2.S raw_reads.63.raw_reads.2.N2.S raw_reads.63.raw_reads.2.C3.S raw_reads.63.raw_reads.2.N3.S
+LAsort -v raw_reads.63.raw_reads.3.C0 raw_reads.63.raw_reads.3.N0 raw_reads.63.raw_reads.3.C1 raw_reads.63.raw_reads.3.N1 raw_reads.63.raw_reads.3.C2 raw_reads.63.raw_reads.3.N2 raw_reads.63.raw_reads.3.C3 raw_reads.63.raw_reads.3.N3 && LAmerge -v L1.63.3 raw_reads.63.raw_reads.3.C0.S raw_reads.63.raw_reads.3.N0.S raw_reads.63.raw_reads.3.C1.S raw_reads.63.raw_reads.3.N1.S raw_reads.63.raw_reads.3.C2.S raw_reads.63.raw_reads.3.N2.S raw_reads.63.raw_reads.3.C3.S raw_reads.63.raw_reads.3.N3.S
+LAsort -v raw_reads.63.raw_reads.4.C0 raw_reads.63.raw_reads.4.N0 raw_reads.63.raw_reads.4.C1 raw_reads.63.raw_reads.4.N1 raw_reads.63.raw_reads.4.C2 raw_reads.63.raw_reads.4.N2 raw_reads.63.raw_reads.4.C3 raw_reads.63.raw_reads.4.N3 && LAmerge -v L1.63.4 raw_reads.63.raw_reads.4.C0.S raw_reads.63.raw_reads.4.N0.S raw_reads.63.raw_reads.4.C1.S raw_reads.63.raw_reads.4.N1.S raw_reads.63.raw_reads.4.C2.S raw_reads.63.raw_reads.4.N2.S raw_reads.63.raw_reads.4.C3.S raw_reads.63.raw_reads.4.N3.S
+LAsort -v raw_reads.63.raw_reads.5.C0 raw_reads.63.raw_reads.5.N0 raw_reads.63.raw_reads.5.C1 raw_reads.63.raw_reads.5.N1 raw_reads.63.raw_reads.5.C2 raw_reads.63.raw_reads.5.N2 raw_reads.63.raw_reads.5.C3 raw_reads.63.raw_reads.5.N3 && LAmerge -v L1.63.5 raw_reads.63.raw_reads.5.C0.S raw_reads.63.raw_reads.5.N0.S raw_reads.63.raw_reads.5.C1.S raw_reads.63.raw_reads.5.N1.S raw_reads.63.raw_reads.5.C2.S raw_reads.63.raw_reads.5.N2.S raw_reads.63.raw_reads.5.C3.S raw_reads.63.raw_reads.5.N3.S
+LAsort -v raw_reads.63.raw_reads.6.C0 raw_reads.63.raw_reads.6.N0 raw_reads.63.raw_reads.6.C1 raw_reads.63.raw_reads.6.N1 raw_reads.63.raw_reads.6.C2 raw_reads.63.raw_reads.6.N2 raw_reads.63.raw_reads.6.C3 raw_reads.63.raw_reads.6.N3 && LAmerge -v L1.63.6 raw_reads.63.raw_reads.6.C0.S raw_reads.63.raw_reads.6.N0.S raw_reads.63.raw_reads.6.C1.S raw_reads.63.raw_reads.6.N1.S raw_reads.63.raw_reads.6.C2.S raw_reads.63.raw_reads.6.N2.S raw_reads.63.raw_reads.6.C3.S raw_reads.63.raw_reads.6.N3.S
+LAsort -v raw_reads.63.raw_reads.7.C0 raw_reads.63.raw_reads.7.N0 raw_reads.63.raw_reads.7.C1 raw_reads.63.raw_reads.7.N1 raw_reads.63.raw_reads.7.C2 raw_reads.63.raw_reads.7.N2 raw_reads.63.raw_reads.7.C3 raw_reads.63.raw_reads.7.N3 && LAmerge -v L1.63.7 raw_reads.63.raw_reads.7.C0.S raw_reads.63.raw_reads.7.N0.S raw_reads.63.raw_reads.7.C1.S raw_reads.63.raw_reads.7.N1.S raw_reads.63.raw_reads.7.C2.S raw_reads.63.raw_reads.7.N2.S raw_reads.63.raw_reads.7.C3.S raw_reads.63.raw_reads.7.N3.S
+LAsort -v raw_reads.63.raw_reads.8.C0 raw_reads.63.raw_reads.8.N0 raw_reads.63.raw_reads.8.C1 raw_reads.63.raw_reads.8.N1 raw_reads.63.raw_reads.8.C2 raw_reads.63.raw_reads.8.N2 raw_reads.63.raw_reads.8.C3 raw_reads.63.raw_reads.8.N3 && LAmerge -v L1.63.8 raw_reads.63.raw_reads.8.C0.S raw_reads.63.raw_reads.8.N0.S raw_reads.63.raw_reads.8.C1.S raw_reads.63.raw_reads.8.N1.S raw_reads.63.raw_reads.8.C2.S raw_reads.63.raw_reads.8.N2.S raw_reads.63.raw_reads.8.C3.S raw_reads.63.raw_reads.8.N3.S
+LAsort -v raw_reads.63.raw_reads.9.C0 raw_reads.63.raw_reads.9.N0 raw_reads.63.raw_reads.9.C1 raw_reads.63.raw_reads.9.N1 raw_reads.63.raw_reads.9.C2 raw_reads.63.raw_reads.9.N2 raw_reads.63.raw_reads.9.C3 raw_reads.63.raw_reads.9.N3 && LAmerge -v L1.63.9 raw_reads.63.raw_reads.9.C0.S raw_reads.63.raw_reads.9.N0.S raw_reads.63.raw_reads.9.C1.S raw_reads.63.raw_reads.9.N1.S raw_reads.63.raw_reads.9.C2.S raw_reads.63.raw_reads.9.N2.S raw_reads.63.raw_reads.9.C3.S raw_reads.63.raw_reads.9.N3.S
+LAsort -v raw_reads.63.raw_reads.10.C0 raw_reads.63.raw_reads.10.N0 raw_reads.63.raw_reads.10.C1 raw_reads.63.raw_reads.10.N1 raw_reads.63.raw_reads.10.C2 raw_reads.63.raw_reads.10.N2 raw_reads.63.raw_reads.10.C3 raw_reads.63.raw_reads.10.N3 && LAmerge -v L1.63.10 raw_reads.63.raw_reads.10.C0.S raw_reads.63.raw_reads.10.N0.S raw_reads.63.raw_reads.10.C1.S raw_reads.63.raw_reads.10.N1.S raw_reads.63.raw_reads.10.C2.S raw_reads.63.raw_reads.10.N2.S raw_reads.63.raw_reads.10.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.11.C0 raw_reads.63.raw_reads.11.N0 raw_reads.63.raw_reads.11.C1 raw_reads.63.raw_reads.11.N1 raw_reads.63.raw_reads.11.C2 raw_reads.63.raw_reads.11.N2 raw_reads.63.raw_reads.11.C3 raw_reads.63.raw_reads.11.N3 && LAmerge -v L1.63.11 raw_reads.63.raw_reads.11.C0.S raw_reads.63.raw_reads.11.N0.S raw_reads.63.raw_reads.11.C1.S raw_reads.63.raw_reads.11.N1.S raw_reads.63.raw_reads.11.C2.S raw_reads.63.raw_reads.11.N2.S raw_reads.63.raw_reads.11.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.12.C0 raw_reads.63.raw_reads.12.N0 raw_reads.63.raw_reads.12.C1 raw_reads.63.raw_reads.12.N1 raw_reads.63.raw_reads.12.C2 raw_reads.63.raw_reads.12.N2 raw_reads.63.raw_reads.12.C3 raw_reads.63.raw_reads.12.N3 && LAmerge -v L1.63.12 raw_reads.63.raw_reads.12.C0.S raw_reads.63.raw_reads.12.N0.S raw_reads.63.raw_reads.12.C1.S raw_reads.63.raw_reads.12.N1.S raw_reads.63.raw_reads.12.C2.S raw_reads.63.raw_reads.12.N2.S raw_reads.63.raw_reads.12.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.13.C0 raw_reads.63.raw_reads.13.N0 raw_reads.63.raw_reads.13.C1 raw_reads.63.raw_reads.13.N1 raw_reads.63.raw_reads.13.C2 raw_reads.63.raw_reads.13.N2 raw_reads.63.raw_reads.13.C3 raw_reads.63.raw_reads.13.N3 && LAmerge -v L1.63.13 raw_reads.63.raw_reads.13.C0.S raw_reads.63.raw_reads.13.N0.S raw_reads.63.raw_reads.13.C1.S raw_reads.63.raw_reads.13.N1.S raw_reads.63.raw_reads.13.C2.S raw_reads.63.raw_reads.13.N2.S raw_reads.63.raw_reads.13.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.14.C0 raw_reads.63.raw_reads.14.N0 raw_reads.63.raw_reads.14.C1 raw_reads.63.raw_reads.14.N1 raw_reads.63.raw_reads.14.C2 raw_reads.63.raw_reads.14.N2 raw_reads.63.raw_reads.14.C3 raw_reads.63.raw_reads.14.N3 && LAmerge -v L1.63.14 raw_reads.63.raw_reads.14.C0.S raw_reads.63.raw_reads.14.N0.S raw_reads.63.raw_reads.14.C1.S raw_reads.63.raw_reads.14.N1.S raw_reads.63.raw_reads.14.C2.S raw_reads.63.raw_reads.14.N2.S raw_reads.63.raw_reads.14.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.15.C0 raw_reads.63.raw_reads.15.N0 raw_reads.63.raw_reads.15.C1 raw_reads.63.raw_reads.15.N1 raw_reads.63.raw_reads.15.C2 raw_reads.63.raw_reads.15.N2 raw_reads.63.raw_reads.15.C3 raw_reads.63.raw_reads.15.N3 && LAmerge -v L1.63.15 raw_reads.63.raw_reads.15.C0.S raw_reads.63.raw_reads.15.N0.S raw_reads.63.raw_reads.15.C1.S raw_reads.63.raw_reads.15.N1.S raw_reads.63.raw_reads.15.C2.S raw_reads.63.raw_reads.15.N2.S raw_reads.63.raw_reads.15.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.16.C0 raw_reads.63.raw_reads.16.N0 raw_reads.63.raw_reads.16.C1 raw_reads.63.raw_reads.16.N1 raw_reads.63.raw_reads.16.C2 raw_reads.63.raw_reads.16.N2 raw_reads.63.raw_reads.16.C3 raw_reads.63.raw_reads.16.N3 && LAmerge -v L1.63.16 raw_reads.63.raw_reads.16.C0.S raw_reads.63.raw_reads.16.N0.S raw_reads.63.raw_reads.16.C1.S raw_reads.63.raw_reads.16.N1.S raw_reads.63.raw_reads.16.C2.S raw_reads.63.raw_reads.16.N2.S raw_reads.63.raw_reads.16.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.17.C0 raw_reads.63.raw_reads.17.N0 raw_reads.63.raw_reads.17.C1 raw_reads.63.raw_reads.17.N1 raw_reads.63.raw_reads.17.C2 raw_reads.63.raw_reads.17.N2 raw_reads.63.raw_reads.17.C3 raw_reads.63.raw_reads.17.N3 && LAmerge -v L1.63.17 raw_reads.63.raw_reads.17.C0.S raw_reads.63.raw_reads.17.N0.S raw_reads.63.raw_reads.17.C1.S raw_reads.63.raw_reads.17.N1.S raw_reads.63.raw_reads.17.C2.S raw_reads.63.raw_reads.17.N2.S raw_reads.63.raw_reads.17.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.18.C0 raw_reads.63.raw_reads.18.N0 raw_reads.63.raw_reads.18.C1 raw_reads.63.raw_reads.18.N1 raw_reads.63.raw_reads.18.C2 raw_reads.63.raw_reads.18.N2 raw_reads.63.raw_reads.18.C3 raw_reads.63.raw_reads.18.N3 && LAmerge -v L1.63.18 raw_reads.63.raw_reads.18.C0.S raw_reads.63.raw_reads.18.N0.S raw_reads.63.raw_reads.18.C1.S raw_reads.63.raw_reads.18.N1.S raw_reads.63.raw_reads.18.C2.S raw_reads.63.raw_reads.18.N2.S raw_reads.63.raw_reads.18.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.19.C0 raw_reads.63.raw_reads.19.N0 raw_reads.63.raw_reads.19.C1 raw_reads.63.raw_reads.19.N1 raw_reads.63.raw_reads.19.C2 raw_reads.63.raw_reads.19.N2 raw_reads.63.raw_reads.19.C3 raw_reads.63.raw_reads.19.N3 && LAmerge -v L1.63.19 raw_reads.63.raw_reads.19.C0.S raw_reads.63.raw_reads.19.N0.S raw_reads.63.raw_reads.19.C1.S raw_reads.63.raw_reads.19.N1.S raw_reads.63.raw_reads.19.C2.S raw_reads.63.raw_reads.19.N2.S raw_reads.63.raw_reads.19.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.20.C0 raw_reads.63.raw_reads.20.N0 raw_reads.63.raw_reads.20.C1 raw_reads.63.raw_reads.20.N1 raw_reads.63.raw_reads.20.C2 raw_reads.63.raw_reads.20.N2 raw_reads.63.raw_reads.20.C3 raw_reads.63.raw_reads.20.N3 && LAmerge -v L1.63.20 raw_reads.63.raw_reads.20.C0.S raw_reads.63.raw_reads.20.N0.S raw_reads.63.raw_reads.20.C1.S raw_reads.63.raw_reads.20.N1.S raw_reads.63.raw_reads.20.C2.S raw_reads.63.raw_reads.20.N2.S raw_reads.63.raw_reads.20.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.21.C0 raw_reads.63.raw_reads.21.N0 raw_reads.63.raw_reads.21.C1 raw_reads.63.raw_reads.21.N1 raw_reads.63.raw_reads.21.C2 raw_reads.63.raw_reads.21.N2 raw_reads.63.raw_reads.21.C3 raw_reads.63.raw_reads.21.N3 && LAmerge -v L1.63.21 raw_reads.63.raw_reads.21.C0.S raw_reads.63.raw_reads.21.N0.S raw_reads.63.raw_reads.21.C1.S raw_reads.63.raw_reads.21.N1.S raw_reads.63.raw_reads.21.C2.S raw_reads.63.raw_reads.21.N2.S raw_reads.63.raw_reads.21.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.1.63
+LAcheck -vS raw_reads L1.2.63
+LAcheck -vS raw_reads L1.3.63
+LAcheck -vS raw_reads L1.4.63
+LAcheck -vS raw_reads L1.5.63
+LAcheck -vS raw_reads L1.6.63
+LAcheck -vS raw_reads L1.7.63
+LAcheck -vS raw_reads L1.8.63
+LAcheck -vS raw_reads L1.9.63
+LAcheck -vS raw_reads L1.10.63
+LAcheck -vS raw_reads L1.11.63
+LAcheck -vS raw_reads L1.12.63
+LAcheck -vS raw_reads L1.13.63
+LAcheck -vS raw_reads L1.14.63
+LAcheck -vS raw_reads L1.15.63
+LAcheck -vS raw_reads L1.16.63
+LAcheck -vS raw_reads L1.17.63
+LAcheck -vS raw_reads L1.18.63
+LAcheck -vS raw_reads L1.19.63
+LAcheck -vS raw_reads L1.20.63
+LAcheck -vS raw_reads L1.21.63
+LAcheck -vS raw_reads L1.63.1
+LAcheck -vS raw_reads L1.63.2
+LAcheck -vS raw_reads L1.63.3
+LAcheck -vS raw_reads L1.63.4
+LAcheck -vS raw_reads L1.63.5
+LAcheck -vS raw_reads L1.63.6
+LAcheck -vS raw_reads L1.63.7
+LAcheck -vS raw_reads L1.63.8
+LAcheck -vS raw_reads L1.63.9
+LAcheck -vS raw_reads L1.63.10
+LAcheck -vS raw_reads L1.63.11
+LAcheck -vS raw_reads L1.63.12
+LAcheck -vS raw_reads L1.63.13
+LAcheck -vS raw_reads L1.63.14
+LAcheck -vS raw_reads L1.63.15
+LAcheck -vS raw_reads L1.63.16
+LAcheck -vS raw_reads L1.63.17
+LAcheck -vS raw_reads L1.63.18
+LAcheck -vS raw_reads L1.63.19
+LAcheck -vS raw_reads L1.63.20
+LAcheck -vS raw_reads L1.63.21
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.50 raw_reads.34 raw_reads.35 raw_reads.36 raw_reads.37 raw_reads.38 raw_reads.39 raw_reads.40 raw_reads.41 raw_reads.42 raw_reads.43 raw_reads.44 raw_reads.45 raw_reads.46 raw_reads.47 raw_reads.48 raw_reads.49 raw_reads.50
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.34.raw_reads.50.C0 raw_reads.34.raw_reads.50.N0 raw_reads.34.raw_reads.50.C1 raw_reads.34.raw_reads.50.N1 raw_reads.34.raw_reads.50.C2 raw_reads.34.raw_reads.50.N2 raw_reads.34.raw_reads.50.C3 raw_reads.34.raw_reads.50.N3 && LAmerge -v L1.34.50 raw_reads.34.raw_reads.50.C0.S raw_reads.34.raw_reads.50.N0.S raw_reads.34.raw_reads.50.C1.S raw_reads.34.raw_reads.50.N1.S raw_reads.34.raw_reads.50.C2.S raw_reads.34.raw_reads.50.N2.S raw_reads.34.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.35.raw_reads.50.C0 raw_reads.35.raw_reads.50.N0 raw_reads.35.raw_reads.50.C1 raw_reads.35.raw_reads.50.N1 raw_reads.35.raw_reads.50.C2 raw_reads.35.raw_reads.50.N2 raw_reads.35.raw_reads.50.C3 raw_reads.35.raw_reads.50.N3 && LAmerge -v L1.35.50 raw_reads.35.raw_reads.50.C0.S raw_reads.35.raw_reads.50.N0.S raw_reads.35.raw_reads.50.C1.S raw_reads.35.raw_reads.50.N1.S raw_reads.35.raw_reads.50.C2.S raw_reads.35.raw_reads.50.N2.S raw_reads.35.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.36.raw_reads.50.C0 raw_reads.36.raw_reads.50.N0 raw_reads.36.raw_reads.50.C1 raw_reads.36.raw_reads.50.N1 raw_reads.36.raw_reads.50.C2 raw_reads.36.raw_reads.50.N2 raw_reads.36.raw_reads.50.C3 raw_reads.36.raw_reads.50.N3 && LAmerge -v L1.36.50 raw_reads.36.raw_reads.50.C0.S raw_reads.36.raw_reads.50.N0.S raw_reads.36.raw_reads.50.C1.S raw_reads.36.raw_reads.50.N1.S raw_reads.36.raw_reads.50.C2.S raw_reads.36.raw_reads.50.N2.S raw_reads.36.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.37.raw_reads.50.C0 raw_reads.37.raw_reads.50.N0 raw_reads.37.raw_reads.50.C1 raw_reads.37.raw_reads.50.N1 raw_reads.37.raw_reads.50.C2 raw_reads.37.raw_reads.50.N2 raw_reads.37.raw_reads.50.C3 raw_reads.37.raw_reads.50.N3 && LAmerge -v L1.37.50 raw_reads.37.raw_reads.50.C0.S raw_reads.37.raw_reads.50.N0.S raw_reads.37.raw_reads.50.C1.S raw_reads.37.raw_reads.50.N1.S raw_reads.37.raw_reads.50.C2.S raw_reads.37.raw_reads.50.N2.S raw_reads.37.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.38.raw_reads.50.C0 raw_reads.38.raw_reads.50.N0 raw_reads.38.raw_reads.50.C1 raw_reads.38.raw_reads.50.N1 raw_reads.38.raw_reads.50.C2 raw_reads.38.raw_reads.50.N2 raw_reads.38.raw_reads.50.C3 raw_reads.38.raw_reads.50.N3 && LAmerge -v L1.38.50 raw_reads.38.raw_reads.50.C0.S raw_reads.38.raw_reads.50.N0.S raw_reads.38.raw_reads.50.C1.S raw_reads.38.raw_reads.50.N1.S raw_reads.38.raw_reads.50.C2.S raw_reads.38.raw_reads.50.N2.S raw_reads.38.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.39.raw_reads.50.C0 raw_reads.39.raw_reads.50.N0 raw_reads.39.raw_reads.50.C1 raw_reads.39.raw_reads.50.N1 raw_reads.39.raw_reads.50.C2 raw_reads.39.raw_reads.50.N2 raw_reads.39.raw_reads.50.C3 raw_reads.39.raw_reads.50.N3 && LAmerge -v L1.39.50 raw_reads.39.raw_reads.50.C0.S raw_reads.39.raw_reads.50.N0.S raw_reads.39.raw_reads.50.C1.S raw_reads.39.raw_reads.50.N1.S raw_reads.39.raw_reads.50.C2.S raw_reads.39.raw_reads.50.N2.S raw_reads.39.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.40.raw_reads.50.C0 raw_reads.40.raw_reads.50.N0 raw_reads.40.raw_reads.50.C1 raw_reads.40.raw_reads.50.N1 raw_reads.40.raw_reads.50.C2 raw_reads.40.raw_reads.50.N2 raw_reads.40.raw_reads.50.C3 raw_reads.40.raw_reads.50.N3 && LAmerge -v L1.40.50 raw_reads.40.raw_reads.50.C0.S raw_reads.40.raw_reads.50.N0.S raw_reads.40.raw_reads.50.C1.S raw_reads.40.raw_reads.50.N1.S raw_reads.40.raw_reads.50.C2.S raw_reads.40.raw_reads.50.N2.S raw_reads.40.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.41.raw_reads.50.C0 raw_reads.41.raw_reads.50.N0 raw_reads.41.raw_reads.50.C1 raw_reads.41.raw_reads.50.N1 raw_reads.41.raw_reads.50.C2 raw_reads.41.raw_reads.50.N2 raw_reads.41.raw_reads.50.C3 raw_reads.41.raw_reads.50.N3 && LAmerge -v L1.41.50 raw_reads.41.raw_reads.50.C0.S raw_reads.41.raw_reads.50.N0.S raw_reads.41.raw_reads.50.C1.S raw_reads.41.raw_reads.50.N1.S raw_reads.41.raw_reads.50.C2.S raw_reads.41.raw_reads.50.N2.S raw_reads.41.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.42.raw_reads.50.C0 raw_reads.42.raw_reads.50.N0 raw_reads.42.raw_reads.50.C1 raw_reads.42.raw_reads.50.N1 raw_reads.42.raw_reads.50.C2 raw_reads.42.raw_reads.50.N2 raw_reads.42.raw_reads.50.C3 raw_reads.42.raw_reads.50.N3 && LAmerge -v L1.42.50 raw_reads.42.raw_reads.50.C0.S raw_reads.42.raw_reads.50.N0.S raw_reads.42.raw_reads.50.C1.S raw_reads.42.raw_reads.50.N1.S raw_reads.42.raw_reads.50.C2.S raw_reads.42.raw_reads.50.N2.S raw_reads.42.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.43.raw_reads.50.C0 raw_reads.43.raw_reads.50.N0 raw_reads.43.raw_reads.50.C1 raw_reads.43.raw_reads.50.N1 raw_reads.43.raw_reads.50.C2 raw_reads.43.raw_reads.50.N2 raw_reads.43.raw_reads.50.C3 raw_reads.43.raw_reads.50.N3 && LAmerge -v L1.43.50 raw_reads.43.raw_reads.50.C0.S raw_reads.43.raw_reads.50.N0.S raw_reads.43.raw_reads.50.C1.S raw_reads.43.raw_reads.50.N1.S raw_reads.43.raw_reads.50.C2.S raw_reads.43.raw_reads.50.N2.S raw_reads.43.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.44.raw_reads.50.C0 raw_reads.44.raw_reads.50.N0 raw_reads.44.raw_reads.50.C1 raw_reads.44.raw_reads.50.N1 raw_reads.44.raw_reads.50.C2 raw_reads.44.raw_reads.50.N2 raw_reads.44.raw_reads.50.C3 raw_reads.44.raw_reads.50.N3 && LAmerge -v L1.44.50 raw_reads.44.raw_reads.50.C0.S raw_reads.44.raw_reads.50.N0.S raw_reads.44.raw_reads.50.C1.S raw_reads.44.raw_reads.50.N1.S raw_reads.44.raw_reads.50.C2.S raw_reads.44.raw_reads.50.N2.S raw_reads.44.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.45.raw_reads.50.C0 raw_reads.45.raw_reads.50.N0 raw_reads.45.raw_reads.50.C1 raw_reads.45.raw_reads.50.N1 raw_reads.45.raw_reads.50.C2 raw_reads.45.raw_reads.50.N2 raw_reads.45.raw_reads.50.C3 raw_reads.45.raw_reads.50.N3 && LAmerge -v L1.45.50 raw_reads.45.raw_reads.50.C0.S raw_reads.45.raw_reads.50.N0.S raw_reads.45.raw_reads.50.C1.S raw_reads.45.raw_reads.50.N1.S raw_reads.45.raw_reads.50.C2.S raw_reads.45.raw_reads.50.N2.S raw_reads.45.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.46.raw_reads.50.C0 raw_reads.46.raw_reads.50.N0 raw_reads.46.raw_reads.50.C1 raw_reads.46.raw_reads.50.N1 raw_reads.46.raw_reads.50.C2 raw_reads.46.raw_reads.50.N2 raw_reads.46.raw_reads.50.C3 raw_reads.46.raw_reads.50.N3 && LAmerge -v L1.46.50 raw_reads.46.raw_reads.50.C0.S raw_reads.46.raw_reads.50.N0.S raw_reads.46.raw_reads.50.C1.S raw_reads.46.raw_reads.50.N1.S raw_reads.46.raw_reads.50.C2.S raw_reads.46.raw_reads.50.N2.S raw_reads.46.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.47.raw_reads.50.C0 raw_reads.47.raw_reads.50.N0 raw_reads.47.raw_reads.50.C1 raw_reads.47.raw_reads.50.N1 raw_reads.47.raw_reads.50.C2 raw_reads.47.raw_reads.50.N2 raw_reads.47.raw_reads.50.C3 raw_reads.47.raw_reads.50.N3 && LAmerge -v L1.47.50 raw_reads.47.raw_reads.50.C0.S raw_reads.47.raw_reads.50.N0.S raw_reads.47.raw_reads.50.C1.S raw_reads.47.raw_reads.50.N1.S raw_reads.47.raw_reads.50.C2.S raw_reads.47.raw_reads.50.N2.S raw_reads.47.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.48.raw_reads.50.C0 raw_reads.48.raw_reads.50.N0 raw_reads.48.raw_reads.50.C1 raw_reads.48.raw_reads.50.N1 raw_reads.48.raw_reads.50.C2 raw_reads.48.raw_reads.50.N2 raw_reads.48.raw_reads.50.C3 raw_reads.48.raw_reads.50.N3 && LAmerge -v L1.48.50 raw_reads.48.raw_reads.50.C0.S raw_reads.48.raw_reads.50.N0.S raw_reads.48.raw_reads.50.C1.S raw_reads.48.raw_reads.50.N1.S raw_reads.48.raw_reads.50.C2.S raw_reads.48.raw_reads.50.N2.S raw_reads.48.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.49.raw_reads.50.C0 raw_reads.49.raw_reads.50.N0 raw_reads.49.raw_reads.50.C1 raw_reads.49.raw_reads.50.N1 raw_reads.49.raw_reads.50.C2 raw_reads.49.raw_reads.50.N2 raw_reads.49.raw_reads.50.C3 raw_reads.49.raw_reads.50.N3 && LAmerge -v L1.49.50 raw_reads.49.raw_reads.50.C0.S raw_reads.49.raw_reads.50.N0.S raw_reads.49.raw_reads.50.C1.S raw_reads.49.raw_reads.50.N1.S raw_reads.49.raw_reads.50.C2.S raw_reads.49.raw_reads.50.N2.S raw_reads.49.raw_reads.50.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.34.C0 raw_reads.50.raw_reads.34.N0 raw_reads.50.raw_reads.34.C1 raw_reads.50.raw_reads.34.N1 raw_reads.50.raw_reads.34.C2 raw_reads.50.raw_reads.34.N2 raw_reads.50.raw_reads.34.C3 raw_reads.50.raw_reads.34.N3 && LAmerge -v L1.50.34 raw_reads.50.raw_reads.34.C0.S raw_reads.50.raw_reads.34.N0.S raw_reads.50.raw_reads.34.C1.S raw_reads.50.raw_reads.34.N1.S raw_reads.50.raw_reads.34.C2.S raw_reads.50.raw_reads.34.N2.S raw_reads.50.raw_reads.34.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.35.C0 raw_reads.50.raw_reads.35.N0 raw_reads.50.raw_reads.35.C1 raw_reads.50.raw_reads.35.N1 raw_reads.50.raw_reads.35.C2 raw_reads.50.raw_reads.35.N2 raw_reads.50.raw_reads.35.C3 raw_reads.50.raw_reads.35.N3 && LAmerge -v L1.50.35 raw_reads.50.raw_reads.35.C0.S raw_reads.50.raw_reads.35.N0.S raw_reads.50.raw_reads.35.C1.S raw_reads.50.raw_reads.35.N1.S raw_reads.50.raw_reads.35.C2.S raw_reads.50.raw_reads.35.N2.S raw_reads.50.raw_reads.35.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.36.C0 raw_reads.50.raw_reads.36.N0 raw_reads.50.raw_reads.36.C1 raw_reads.50.raw_reads.36.N1 raw_reads.50.raw_reads.36.C2 raw_reads.50.raw_reads.36.N2 raw_reads.50.raw_reads.36.C3 raw_reads.50.raw_reads.36.N3 && LAmerge -v L1.50.36 raw_reads.50.raw_reads.36.C0.S raw_reads.50.raw_reads.36.N0.S raw_reads.50.raw_reads.36.C1.S raw_reads.50.raw_reads.36.N1.S raw_reads.50.raw_reads.36.C2.S raw_reads.50.raw_reads.36.N2.S raw_reads.50.raw_reads.36.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.37.C0 raw_reads.50.raw_reads.37.N0 raw_reads.50.raw_reads.37.C1 raw_reads.50.raw_reads.37.N1 raw_reads.50.raw_reads.37.C2 raw_reads.50.raw_reads.37.N2 raw_reads.50.raw_reads.37.C3 raw_reads.50.raw_reads.37.N3 && LAmerge -v L1.50.37 raw_reads.50.raw_reads.37.C0.S raw_reads.50.raw_reads.37.N0.S raw_reads.50.raw_reads.37.C1.S raw_reads.50.raw_reads.37.N1.S raw_reads.50.raw_reads.37.C2.S raw_reads.50.raw_reads.37.N2.S raw_reads.50.raw_reads.37.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.38.C0 raw_reads.50.raw_reads.38.N0 raw_reads.50.raw_reads.38.C1 raw_reads.50.raw_reads.38.N1 raw_reads.50.raw_reads.38.C2 raw_reads.50.raw_reads.38.N2 raw_reads.50.raw_reads.38.C3 raw_reads.50.raw_reads.38.N3 && LAmerge -v L1.50.38 raw_reads.50.raw_reads.38.C0.S raw_reads.50.raw_reads.38.N0.S raw_reads.50.raw_reads.38.C1.S raw_reads.50.raw_reads.38.N1.S raw_reads.50.raw_reads.38.C2.S raw_reads.50.raw_reads.38.N2.S raw_reads.50.raw_reads.38.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.39.C0 raw_reads.50.raw_reads.39.N0 raw_reads.50.raw_reads.39.C1 raw_reads.50.raw_reads.39.N1 raw_reads.50.raw_reads.39.C2 raw_reads.50.raw_reads.39.N2 raw_reads.50.raw_reads.39.C3 raw_reads.50.raw_reads.39.N3 && LAmerge -v L1.50.39 raw_reads.50.raw_reads.39.C0.S raw_reads.50.raw_reads.39.N0.S raw_reads.50.raw_reads.39.C1.S raw_reads.50.raw_reads.39.N1.S raw_reads.50.raw_reads.39.C2.S raw_reads.50.raw_reads.39.N2.S raw_reads.50.raw_reads.39.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.40.C0 raw_reads.50.raw_reads.40.N0 raw_reads.50.raw_reads.40.C1 raw_reads.50.raw_reads.40.N1 raw_reads.50.raw_reads.40.C2 raw_reads.50.raw_reads.40.N2 raw_reads.50.raw_reads.40.C3 raw_reads.50.raw_reads.40.N3 && LAmerge -v L1.50.40 raw_reads.50.raw_reads.40.C0.S raw_reads.50.raw_reads.40.N0.S raw_reads.50.raw_reads.40.C1.S raw_reads.50.raw_reads.40.N1.S raw_reads.50.raw_reads.40.C2.S raw_reads.50.raw_reads.40.N2.S raw_reads.50.raw_reads.40.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.41.C0 raw_reads.50.raw_reads.41.N0 raw_reads.50.raw_reads.41.C1 raw_reads.50.raw_reads.41.N1 raw_reads.50.raw_reads.41.C2 raw_reads.50.raw_reads.41.N2 raw_reads.50.raw_reads.41.C3 raw_reads.50.raw_reads.41.N3 && LAmerge -v L1.50.41 raw_reads.50.raw_reads.41.C0.S raw_reads.50.raw_reads.41.N0.S raw_reads.50.raw_reads.41.C1.S raw_reads.50.raw_reads.41.N1.S raw_reads.50.raw_reads.41.C2.S raw_reads.50.raw_reads.41.N2.S raw_reads.50.raw_reads.41.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.42.C0 raw_reads.50.raw_reads.42.N0 raw_reads.50.raw_reads.42.C1 raw_reads.50.raw_reads.42.N1 raw_reads.50.raw_reads.42.C2 raw_reads.50.raw_reads.42.N2 raw_reads.50.raw_reads.42.C3 raw_reads.50.raw_reads.42.N3 && LAmerge -v L1.50.42 raw_reads.50.raw_reads.42.C0.S raw_reads.50.raw_reads.42.N0.S raw_reads.50.raw_reads.42.C1.S raw_reads.50.raw_reads.42.N1.S raw_reads.50.raw_reads.42.C2.S raw_reads.50.raw_reads.42.N2.S raw_reads.50.raw_reads.42.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.43.C0 raw_reads.50.raw_reads.43.N0 raw_reads.50.raw_reads.43.C1 raw_reads.50.raw_reads.43.N1 raw_reads.50.raw_reads.43.C2 raw_reads.50.raw_reads.43.N2 raw_reads.50.raw_reads.43.C3 raw_reads.50.raw_reads.43.N3 && LAmerge -v L1.50.43 raw_reads.50.raw_reads.43.C0.S raw_reads.50.raw_reads.43.N0.S raw_reads.50.raw_reads.43.C1.S raw_reads.50.raw_reads.43.N1.S raw_reads.50.raw_reads.43.C2.S raw_reads.50.raw_reads.43.N2.S raw_reads.50.raw_reads.43.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.44.C0 raw_reads.50.raw_reads.44.N0 raw_reads.50.raw_reads.44.C1 raw_reads.50.raw_reads.44.N1 raw_reads.50.raw_reads.44.C2 raw_reads.50.raw_reads.44.N2 raw_reads.50.raw_reads.44.C3 raw_reads.50.raw_reads.44.N3 && LAmerge -v L1.50.44 raw_reads.50.raw_reads.44.C0.S raw_reads.50.raw_reads.44.N0.S raw_reads.50.raw_reads.44.C1.S raw_reads.50.raw_reads.44.N1.S raw_reads.50.raw_reads.44.C2.S raw_reads.50.raw_reads.44.N2.S raw_reads.50.raw_reads.44.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.45.C0 raw_reads.50.raw_reads.45.N0 raw_reads.50.raw_reads.45.C1 raw_reads.50.raw_reads.45.N1 raw_reads.50.raw_reads.45.C2 raw_reads.50.raw_reads.45.N2 raw_reads.50.raw_reads.45.C3 raw_reads.50.raw_reads.45.N3 && LAmerge -v L1.50.45 raw_reads.50.raw_reads.45.C0.S raw_reads.50.raw_reads.45.N0.S raw_reads.50.raw_reads.45.C1.S raw_reads.50.raw_reads.45.N1.S raw_reads.50.raw_reads.45.C2.S raw_reads.50.raw_reads.45.N2.S raw_reads.50.raw_reads.45.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.46.C0 raw_reads.50.raw_reads.46.N0 raw_reads.50.raw_reads.46.C1 raw_reads.50.raw_reads.46.N1 raw_reads.50.raw_reads.46.C2 raw_reads.50.raw_reads.46.N2 raw_reads.50.raw_reads.46.C3 raw_reads.50.raw_reads.46.N3 && LAmerge -v L1.50.46 raw_reads.50.raw_reads.46.C0.S raw_reads.50.raw_reads.46.N0.S raw_reads.50.raw_reads.46.C1.S raw_reads.50.raw_reads.46.N1.S raw_reads.50.raw_reads.46.C2.S raw_reads.50.raw_reads.46.N2.S raw_reads.50.raw_reads.46.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.47.C0 raw_reads.50.raw_reads.47.N0 raw_reads.50.raw_reads.47.C1 raw_reads.50.raw_reads.47.N1 raw_reads.50.raw_reads.47.C2 raw_reads.50.raw_reads.47.N2 raw_reads.50.raw_reads.47.C3 raw_reads.50.raw_reads.47.N3 && LAmerge -v L1.50.47 raw_reads.50.raw_reads.47.C0.S raw_reads.50.raw_reads.47.N0.S raw_reads.50.raw_reads.47.C1.S raw_reads.50.raw_reads.47.N1.S raw_reads.50.raw_reads.47.C2.S raw_reads.50.raw_reads.47.N2.S raw_reads.50.raw_reads.47.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.48.C0 raw_reads.50.raw_reads.48.N0 raw_reads.50.raw_reads.48.C1 raw_reads.50.raw_reads.48.N1 raw_reads.50.raw_reads.48.C2 raw_reads.50.raw_reads.48.N2 raw_reads.50.raw_reads.48.C3 raw_reads.50.raw_reads.48.N3 && LAmerge -v L1.50.48 raw_reads.50.raw_reads.48.C0.S raw_reads.50.raw_reads.48.N0.S raw_reads.50.raw_reads.48.C1.S raw_reads.50.raw_reads.48.N1.S raw_reads.50.raw_reads.48.C2.S raw_reads.50.raw_reads.48.N2.S raw_reads.50.raw_reads.48.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.49.C0 raw_reads.50.raw_reads.49.N0 raw_reads.50.raw_reads.49.C1 raw_reads.50.raw_reads.49.N1 raw_reads.50.raw_reads.49.C2 raw_reads.50.raw_reads.49.N2 raw_reads.50.raw_reads.49.C3 raw_reads.50.raw_reads.49.N3 && LAmerge -v L1.50.49 raw_reads.50.raw_reads.49.C0.S raw_reads.50.raw_reads.49.N0.S raw_reads.50.raw_reads.49.C1.S raw_reads.50.raw_reads.49.N1.S raw_reads.50.raw_reads.49.C2.S raw_reads.50.raw_reads.49.N2.S raw_reads.50.raw_reads.49.C3.S raw_reads. [...]
+LAsort -v raw_reads.50.raw_reads.50.C0 raw_reads.50.raw_reads.50.N0 raw_reads.50.raw_reads.50.C1 raw_reads.50.raw_reads.50.N1 raw_reads.50.raw_reads.50.C2 raw_reads.50.raw_reads.50.N2 raw_reads.50.raw_reads.50.C3 raw_reads.50.raw_reads.50.N3 && LAmerge -v L1.50.50 raw_reads.50.raw_reads.50.C0.S raw_reads.50.raw_reads.50.N0.S raw_reads.50.raw_reads.50.C1.S raw_reads.50.raw_reads.50.N1.S raw_reads.50.raw_reads.50.C2.S raw_reads.50.raw_reads.50.N2.S raw_reads.50.raw_reads.50.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.34.50
+LAcheck -vS raw_reads L1.35.50
+LAcheck -vS raw_reads L1.36.50
+LAcheck -vS raw_reads L1.37.50
+LAcheck -vS raw_reads L1.38.50
+LAcheck -vS raw_reads L1.39.50
+LAcheck -vS raw_reads L1.40.50
+LAcheck -vS raw_reads L1.41.50
+LAcheck -vS raw_reads L1.42.50
+LAcheck -vS raw_reads L1.43.50
+LAcheck -vS raw_reads L1.44.50
+LAcheck -vS raw_reads L1.45.50
+LAcheck -vS raw_reads L1.46.50
+LAcheck -vS raw_reads L1.47.50
+LAcheck -vS raw_reads L1.48.50
+LAcheck -vS raw_reads L1.49.50
+LAcheck -vS raw_reads L1.50.34
+LAcheck -vS raw_reads L1.50.35
+LAcheck -vS raw_reads L1.50.36
+LAcheck -vS raw_reads L1.50.37
+LAcheck -vS raw_reads L1.50.38
+LAcheck -vS raw_reads L1.50.39
+LAcheck -vS raw_reads L1.50.40
+LAcheck -vS raw_reads L1.50.41
+LAcheck -vS raw_reads L1.50.42
+LAcheck -vS raw_reads L1.50.43
+LAcheck -vS raw_reads L1.50.44
+LAcheck -vS raw_reads L1.50.45
+LAcheck -vS raw_reads L1.50.46
+LAcheck -vS raw_reads L1.50.47
+LAcheck -vS raw_reads L1.50.48
+LAcheck -vS raw_reads L1.50.49
+LAcheck -vS raw_reads L1.50.50
+daligner -v -k18 -h70 -t14 -H7000 -e0.75 raw_reads.73 raw_reads.55 raw_reads.56 raw_reads.57 raw_reads.58 raw_reads.59 raw_reads.60 raw_reads.61 raw_reads.62 raw_reads.63 raw_reads.64 raw_reads.65 raw_reads.66 raw_reads.67 raw_reads.68 raw_reads.69 raw_reads.70 raw_reads.71 raw_reads.72 raw_reads.73
+LAcheck -v raw_reads *.las
+LAsort -v raw_reads.55.raw_reads.73.C0 raw_reads.55.raw_reads.73.N0 raw_reads.55.raw_reads.73.C1 raw_reads.55.raw_reads.73.N1 raw_reads.55.raw_reads.73.C2 raw_reads.55.raw_reads.73.N2 raw_reads.55.raw_reads.73.C3 raw_reads.55.raw_reads.73.N3 && LAmerge -v L1.55.73 raw_reads.55.raw_reads.73.C0.S raw_reads.55.raw_reads.73.N0.S raw_reads.55.raw_reads.73.C1.S raw_reads.55.raw_reads.73.N1.S raw_reads.55.raw_reads.73.C2.S raw_reads.55.raw_reads.73.N2.S raw_reads.55.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.56.raw_reads.73.C0 raw_reads.56.raw_reads.73.N0 raw_reads.56.raw_reads.73.C1 raw_reads.56.raw_reads.73.N1 raw_reads.56.raw_reads.73.C2 raw_reads.56.raw_reads.73.N2 raw_reads.56.raw_reads.73.C3 raw_reads.56.raw_reads.73.N3 && LAmerge -v L1.56.73 raw_reads.56.raw_reads.73.C0.S raw_reads.56.raw_reads.73.N0.S raw_reads.56.raw_reads.73.C1.S raw_reads.56.raw_reads.73.N1.S raw_reads.56.raw_reads.73.C2.S raw_reads.56.raw_reads.73.N2.S raw_reads.56.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.57.raw_reads.73.C0 raw_reads.57.raw_reads.73.N0 raw_reads.57.raw_reads.73.C1 raw_reads.57.raw_reads.73.N1 raw_reads.57.raw_reads.73.C2 raw_reads.57.raw_reads.73.N2 raw_reads.57.raw_reads.73.C3 raw_reads.57.raw_reads.73.N3 && LAmerge -v L1.57.73 raw_reads.57.raw_reads.73.C0.S raw_reads.57.raw_reads.73.N0.S raw_reads.57.raw_reads.73.C1.S raw_reads.57.raw_reads.73.N1.S raw_reads.57.raw_reads.73.C2.S raw_reads.57.raw_reads.73.N2.S raw_reads.57.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.58.raw_reads.73.C0 raw_reads.58.raw_reads.73.N0 raw_reads.58.raw_reads.73.C1 raw_reads.58.raw_reads.73.N1 raw_reads.58.raw_reads.73.C2 raw_reads.58.raw_reads.73.N2 raw_reads.58.raw_reads.73.C3 raw_reads.58.raw_reads.73.N3 && LAmerge -v L1.58.73 raw_reads.58.raw_reads.73.C0.S raw_reads.58.raw_reads.73.N0.S raw_reads.58.raw_reads.73.C1.S raw_reads.58.raw_reads.73.N1.S raw_reads.58.raw_reads.73.C2.S raw_reads.58.raw_reads.73.N2.S raw_reads.58.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.59.raw_reads.73.C0 raw_reads.59.raw_reads.73.N0 raw_reads.59.raw_reads.73.C1 raw_reads.59.raw_reads.73.N1 raw_reads.59.raw_reads.73.C2 raw_reads.59.raw_reads.73.N2 raw_reads.59.raw_reads.73.C3 raw_reads.59.raw_reads.73.N3 && LAmerge -v L1.59.73 raw_reads.59.raw_reads.73.C0.S raw_reads.59.raw_reads.73.N0.S raw_reads.59.raw_reads.73.C1.S raw_reads.59.raw_reads.73.N1.S raw_reads.59.raw_reads.73.C2.S raw_reads.59.raw_reads.73.N2.S raw_reads.59.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.60.raw_reads.73.C0 raw_reads.60.raw_reads.73.N0 raw_reads.60.raw_reads.73.C1 raw_reads.60.raw_reads.73.N1 raw_reads.60.raw_reads.73.C2 raw_reads.60.raw_reads.73.N2 raw_reads.60.raw_reads.73.C3 raw_reads.60.raw_reads.73.N3 && LAmerge -v L1.60.73 raw_reads.60.raw_reads.73.C0.S raw_reads.60.raw_reads.73.N0.S raw_reads.60.raw_reads.73.C1.S raw_reads.60.raw_reads.73.N1.S raw_reads.60.raw_reads.73.C2.S raw_reads.60.raw_reads.73.N2.S raw_reads.60.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.61.raw_reads.73.C0 raw_reads.61.raw_reads.73.N0 raw_reads.61.raw_reads.73.C1 raw_reads.61.raw_reads.73.N1 raw_reads.61.raw_reads.73.C2 raw_reads.61.raw_reads.73.N2 raw_reads.61.raw_reads.73.C3 raw_reads.61.raw_reads.73.N3 && LAmerge -v L1.61.73 raw_reads.61.raw_reads.73.C0.S raw_reads.61.raw_reads.73.N0.S raw_reads.61.raw_reads.73.C1.S raw_reads.61.raw_reads.73.N1.S raw_reads.61.raw_reads.73.C2.S raw_reads.61.raw_reads.73.N2.S raw_reads.61.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.62.raw_reads.73.C0 raw_reads.62.raw_reads.73.N0 raw_reads.62.raw_reads.73.C1 raw_reads.62.raw_reads.73.N1 raw_reads.62.raw_reads.73.C2 raw_reads.62.raw_reads.73.N2 raw_reads.62.raw_reads.73.C3 raw_reads.62.raw_reads.73.N3 && LAmerge -v L1.62.73 raw_reads.62.raw_reads.73.C0.S raw_reads.62.raw_reads.73.N0.S raw_reads.62.raw_reads.73.C1.S raw_reads.62.raw_reads.73.N1.S raw_reads.62.raw_reads.73.C2.S raw_reads.62.raw_reads.73.N2.S raw_reads.62.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.63.raw_reads.73.C0 raw_reads.63.raw_reads.73.N0 raw_reads.63.raw_reads.73.C1 raw_reads.63.raw_reads.73.N1 raw_reads.63.raw_reads.73.C2 raw_reads.63.raw_reads.73.N2 raw_reads.63.raw_reads.73.C3 raw_reads.63.raw_reads.73.N3 && LAmerge -v L1.63.73 raw_reads.63.raw_reads.73.C0.S raw_reads.63.raw_reads.73.N0.S raw_reads.63.raw_reads.73.C1.S raw_reads.63.raw_reads.73.N1.S raw_reads.63.raw_reads.73.C2.S raw_reads.63.raw_reads.73.N2.S raw_reads.63.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.64.raw_reads.73.C0 raw_reads.64.raw_reads.73.N0 raw_reads.64.raw_reads.73.C1 raw_reads.64.raw_reads.73.N1 raw_reads.64.raw_reads.73.C2 raw_reads.64.raw_reads.73.N2 raw_reads.64.raw_reads.73.C3 raw_reads.64.raw_reads.73.N3 && LAmerge -v L1.64.73 raw_reads.64.raw_reads.73.C0.S raw_reads.64.raw_reads.73.N0.S raw_reads.64.raw_reads.73.C1.S raw_reads.64.raw_reads.73.N1.S raw_reads.64.raw_reads.73.C2.S raw_reads.64.raw_reads.73.N2.S raw_reads.64.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.65.raw_reads.73.C0 raw_reads.65.raw_reads.73.N0 raw_reads.65.raw_reads.73.C1 raw_reads.65.raw_reads.73.N1 raw_reads.65.raw_reads.73.C2 raw_reads.65.raw_reads.73.N2 raw_reads.65.raw_reads.73.C3 raw_reads.65.raw_reads.73.N3 && LAmerge -v L1.65.73 raw_reads.65.raw_reads.73.C0.S raw_reads.65.raw_reads.73.N0.S raw_reads.65.raw_reads.73.C1.S raw_reads.65.raw_reads.73.N1.S raw_reads.65.raw_reads.73.C2.S raw_reads.65.raw_reads.73.N2.S raw_reads.65.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.66.raw_reads.73.C0 raw_reads.66.raw_reads.73.N0 raw_reads.66.raw_reads.73.C1 raw_reads.66.raw_reads.73.N1 raw_reads.66.raw_reads.73.C2 raw_reads.66.raw_reads.73.N2 raw_reads.66.raw_reads.73.C3 raw_reads.66.raw_reads.73.N3 && LAmerge -v L1.66.73 raw_reads.66.raw_reads.73.C0.S raw_reads.66.raw_reads.73.N0.S raw_reads.66.raw_reads.73.C1.S raw_reads.66.raw_reads.73.N1.S raw_reads.66.raw_reads.73.C2.S raw_reads.66.raw_reads.73.N2.S raw_reads.66.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.67.raw_reads.73.C0 raw_reads.67.raw_reads.73.N0 raw_reads.67.raw_reads.73.C1 raw_reads.67.raw_reads.73.N1 raw_reads.67.raw_reads.73.C2 raw_reads.67.raw_reads.73.N2 raw_reads.67.raw_reads.73.C3 raw_reads.67.raw_reads.73.N3 && LAmerge -v L1.67.73 raw_reads.67.raw_reads.73.C0.S raw_reads.67.raw_reads.73.N0.S raw_reads.67.raw_reads.73.C1.S raw_reads.67.raw_reads.73.N1.S raw_reads.67.raw_reads.73.C2.S raw_reads.67.raw_reads.73.N2.S raw_reads.67.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.68.raw_reads.73.C0 raw_reads.68.raw_reads.73.N0 raw_reads.68.raw_reads.73.C1 raw_reads.68.raw_reads.73.N1 raw_reads.68.raw_reads.73.C2 raw_reads.68.raw_reads.73.N2 raw_reads.68.raw_reads.73.C3 raw_reads.68.raw_reads.73.N3 && LAmerge -v L1.68.73 raw_reads.68.raw_reads.73.C0.S raw_reads.68.raw_reads.73.N0.S raw_reads.68.raw_reads.73.C1.S raw_reads.68.raw_reads.73.N1.S raw_reads.68.raw_reads.73.C2.S raw_reads.68.raw_reads.73.N2.S raw_reads.68.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.69.raw_reads.73.C0 raw_reads.69.raw_reads.73.N0 raw_reads.69.raw_reads.73.C1 raw_reads.69.raw_reads.73.N1 raw_reads.69.raw_reads.73.C2 raw_reads.69.raw_reads.73.N2 raw_reads.69.raw_reads.73.C3 raw_reads.69.raw_reads.73.N3 && LAmerge -v L1.69.73 raw_reads.69.raw_reads.73.C0.S raw_reads.69.raw_reads.73.N0.S raw_reads.69.raw_reads.73.C1.S raw_reads.69.raw_reads.73.N1.S raw_reads.69.raw_reads.73.C2.S raw_reads.69.raw_reads.73.N2.S raw_reads.69.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.70.raw_reads.73.C0 raw_reads.70.raw_reads.73.N0 raw_reads.70.raw_reads.73.C1 raw_reads.70.raw_reads.73.N1 raw_reads.70.raw_reads.73.C2 raw_reads.70.raw_reads.73.N2 raw_reads.70.raw_reads.73.C3 raw_reads.70.raw_reads.73.N3 && LAmerge -v L1.70.73 raw_reads.70.raw_reads.73.C0.S raw_reads.70.raw_reads.73.N0.S raw_reads.70.raw_reads.73.C1.S raw_reads.70.raw_reads.73.N1.S raw_reads.70.raw_reads.73.C2.S raw_reads.70.raw_reads.73.N2.S raw_reads.70.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.71.raw_reads.73.C0 raw_reads.71.raw_reads.73.N0 raw_reads.71.raw_reads.73.C1 raw_reads.71.raw_reads.73.N1 raw_reads.71.raw_reads.73.C2 raw_reads.71.raw_reads.73.N2 raw_reads.71.raw_reads.73.C3 raw_reads.71.raw_reads.73.N3 && LAmerge -v L1.71.73 raw_reads.71.raw_reads.73.C0.S raw_reads.71.raw_reads.73.N0.S raw_reads.71.raw_reads.73.C1.S raw_reads.71.raw_reads.73.N1.S raw_reads.71.raw_reads.73.C2.S raw_reads.71.raw_reads.73.N2.S raw_reads.71.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.72.raw_reads.73.C0 raw_reads.72.raw_reads.73.N0 raw_reads.72.raw_reads.73.C1 raw_reads.72.raw_reads.73.N1 raw_reads.72.raw_reads.73.C2 raw_reads.72.raw_reads.73.N2 raw_reads.72.raw_reads.73.C3 raw_reads.72.raw_reads.73.N3 && LAmerge -v L1.72.73 raw_reads.72.raw_reads.73.C0.S raw_reads.72.raw_reads.73.N0.S raw_reads.72.raw_reads.73.C1.S raw_reads.72.raw_reads.73.N1.S raw_reads.72.raw_reads.73.C2.S raw_reads.72.raw_reads.73.N2.S raw_reads.72.raw_reads.73.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.55.C0 raw_reads.73.raw_reads.55.N0 raw_reads.73.raw_reads.55.C1 raw_reads.73.raw_reads.55.N1 raw_reads.73.raw_reads.55.C2 raw_reads.73.raw_reads.55.N2 raw_reads.73.raw_reads.55.C3 raw_reads.73.raw_reads.55.N3 && LAmerge -v L1.73.55 raw_reads.73.raw_reads.55.C0.S raw_reads.73.raw_reads.55.N0.S raw_reads.73.raw_reads.55.C1.S raw_reads.73.raw_reads.55.N1.S raw_reads.73.raw_reads.55.C2.S raw_reads.73.raw_reads.55.N2.S raw_reads.73.raw_reads.55.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.56.C0 raw_reads.73.raw_reads.56.N0 raw_reads.73.raw_reads.56.C1 raw_reads.73.raw_reads.56.N1 raw_reads.73.raw_reads.56.C2 raw_reads.73.raw_reads.56.N2 raw_reads.73.raw_reads.56.C3 raw_reads.73.raw_reads.56.N3 && LAmerge -v L1.73.56 raw_reads.73.raw_reads.56.C0.S raw_reads.73.raw_reads.56.N0.S raw_reads.73.raw_reads.56.C1.S raw_reads.73.raw_reads.56.N1.S raw_reads.73.raw_reads.56.C2.S raw_reads.73.raw_reads.56.N2.S raw_reads.73.raw_reads.56.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.57.C0 raw_reads.73.raw_reads.57.N0 raw_reads.73.raw_reads.57.C1 raw_reads.73.raw_reads.57.N1 raw_reads.73.raw_reads.57.C2 raw_reads.73.raw_reads.57.N2 raw_reads.73.raw_reads.57.C3 raw_reads.73.raw_reads.57.N3 && LAmerge -v L1.73.57 raw_reads.73.raw_reads.57.C0.S raw_reads.73.raw_reads.57.N0.S raw_reads.73.raw_reads.57.C1.S raw_reads.73.raw_reads.57.N1.S raw_reads.73.raw_reads.57.C2.S raw_reads.73.raw_reads.57.N2.S raw_reads.73.raw_reads.57.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.58.C0 raw_reads.73.raw_reads.58.N0 raw_reads.73.raw_reads.58.C1 raw_reads.73.raw_reads.58.N1 raw_reads.73.raw_reads.58.C2 raw_reads.73.raw_reads.58.N2 raw_reads.73.raw_reads.58.C3 raw_reads.73.raw_reads.58.N3 && LAmerge -v L1.73.58 raw_reads.73.raw_reads.58.C0.S raw_reads.73.raw_reads.58.N0.S raw_reads.73.raw_reads.58.C1.S raw_reads.73.raw_reads.58.N1.S raw_reads.73.raw_reads.58.C2.S raw_reads.73.raw_reads.58.N2.S raw_reads.73.raw_reads.58.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.59.C0 raw_reads.73.raw_reads.59.N0 raw_reads.73.raw_reads.59.C1 raw_reads.73.raw_reads.59.N1 raw_reads.73.raw_reads.59.C2 raw_reads.73.raw_reads.59.N2 raw_reads.73.raw_reads.59.C3 raw_reads.73.raw_reads.59.N3 && LAmerge -v L1.73.59 raw_reads.73.raw_reads.59.C0.S raw_reads.73.raw_reads.59.N0.S raw_reads.73.raw_reads.59.C1.S raw_reads.73.raw_reads.59.N1.S raw_reads.73.raw_reads.59.C2.S raw_reads.73.raw_reads.59.N2.S raw_reads.73.raw_reads.59.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.60.C0 raw_reads.73.raw_reads.60.N0 raw_reads.73.raw_reads.60.C1 raw_reads.73.raw_reads.60.N1 raw_reads.73.raw_reads.60.C2 raw_reads.73.raw_reads.60.N2 raw_reads.73.raw_reads.60.C3 raw_reads.73.raw_reads.60.N3 && LAmerge -v L1.73.60 raw_reads.73.raw_reads.60.C0.S raw_reads.73.raw_reads.60.N0.S raw_reads.73.raw_reads.60.C1.S raw_reads.73.raw_reads.60.N1.S raw_reads.73.raw_reads.60.C2.S raw_reads.73.raw_reads.60.N2.S raw_reads.73.raw_reads.60.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.61.C0 raw_reads.73.raw_reads.61.N0 raw_reads.73.raw_reads.61.C1 raw_reads.73.raw_reads.61.N1 raw_reads.73.raw_reads.61.C2 raw_reads.73.raw_reads.61.N2 raw_reads.73.raw_reads.61.C3 raw_reads.73.raw_reads.61.N3 && LAmerge -v L1.73.61 raw_reads.73.raw_reads.61.C0.S raw_reads.73.raw_reads.61.N0.S raw_reads.73.raw_reads.61.C1.S raw_reads.73.raw_reads.61.N1.S raw_reads.73.raw_reads.61.C2.S raw_reads.73.raw_reads.61.N2.S raw_reads.73.raw_reads.61.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.62.C0 raw_reads.73.raw_reads.62.N0 raw_reads.73.raw_reads.62.C1 raw_reads.73.raw_reads.62.N1 raw_reads.73.raw_reads.62.C2 raw_reads.73.raw_reads.62.N2 raw_reads.73.raw_reads.62.C3 raw_reads.73.raw_reads.62.N3 && LAmerge -v L1.73.62 raw_reads.73.raw_reads.62.C0.S raw_reads.73.raw_reads.62.N0.S raw_reads.73.raw_reads.62.C1.S raw_reads.73.raw_reads.62.N1.S raw_reads.73.raw_reads.62.C2.S raw_reads.73.raw_reads.62.N2.S raw_reads.73.raw_reads.62.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.63.C0 raw_reads.73.raw_reads.63.N0 raw_reads.73.raw_reads.63.C1 raw_reads.73.raw_reads.63.N1 raw_reads.73.raw_reads.63.C2 raw_reads.73.raw_reads.63.N2 raw_reads.73.raw_reads.63.C3 raw_reads.73.raw_reads.63.N3 && LAmerge -v L1.73.63 raw_reads.73.raw_reads.63.C0.S raw_reads.73.raw_reads.63.N0.S raw_reads.73.raw_reads.63.C1.S raw_reads.73.raw_reads.63.N1.S raw_reads.73.raw_reads.63.C2.S raw_reads.73.raw_reads.63.N2.S raw_reads.73.raw_reads.63.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.64.C0 raw_reads.73.raw_reads.64.N0 raw_reads.73.raw_reads.64.C1 raw_reads.73.raw_reads.64.N1 raw_reads.73.raw_reads.64.C2 raw_reads.73.raw_reads.64.N2 raw_reads.73.raw_reads.64.C3 raw_reads.73.raw_reads.64.N3 && LAmerge -v L1.73.64 raw_reads.73.raw_reads.64.C0.S raw_reads.73.raw_reads.64.N0.S raw_reads.73.raw_reads.64.C1.S raw_reads.73.raw_reads.64.N1.S raw_reads.73.raw_reads.64.C2.S raw_reads.73.raw_reads.64.N2.S raw_reads.73.raw_reads.64.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.65.C0 raw_reads.73.raw_reads.65.N0 raw_reads.73.raw_reads.65.C1 raw_reads.73.raw_reads.65.N1 raw_reads.73.raw_reads.65.C2 raw_reads.73.raw_reads.65.N2 raw_reads.73.raw_reads.65.C3 raw_reads.73.raw_reads.65.N3 && LAmerge -v L1.73.65 raw_reads.73.raw_reads.65.C0.S raw_reads.73.raw_reads.65.N0.S raw_reads.73.raw_reads.65.C1.S raw_reads.73.raw_reads.65.N1.S raw_reads.73.raw_reads.65.C2.S raw_reads.73.raw_reads.65.N2.S raw_reads.73.raw_reads.65.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.66.C0 raw_reads.73.raw_reads.66.N0 raw_reads.73.raw_reads.66.C1 raw_reads.73.raw_reads.66.N1 raw_reads.73.raw_reads.66.C2 raw_reads.73.raw_reads.66.N2 raw_reads.73.raw_reads.66.C3 raw_reads.73.raw_reads.66.N3 && LAmerge -v L1.73.66 raw_reads.73.raw_reads.66.C0.S raw_reads.73.raw_reads.66.N0.S raw_reads.73.raw_reads.66.C1.S raw_reads.73.raw_reads.66.N1.S raw_reads.73.raw_reads.66.C2.S raw_reads.73.raw_reads.66.N2.S raw_reads.73.raw_reads.66.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.67.C0 raw_reads.73.raw_reads.67.N0 raw_reads.73.raw_reads.67.C1 raw_reads.73.raw_reads.67.N1 raw_reads.73.raw_reads.67.C2 raw_reads.73.raw_reads.67.N2 raw_reads.73.raw_reads.67.C3 raw_reads.73.raw_reads.67.N3 && LAmerge -v L1.73.67 raw_reads.73.raw_reads.67.C0.S raw_reads.73.raw_reads.67.N0.S raw_reads.73.raw_reads.67.C1.S raw_reads.73.raw_reads.67.N1.S raw_reads.73.raw_reads.67.C2.S raw_reads.73.raw_reads.67.N2.S raw_reads.73.raw_reads.67.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.68.C0 raw_reads.73.raw_reads.68.N0 raw_reads.73.raw_reads.68.C1 raw_reads.73.raw_reads.68.N1 raw_reads.73.raw_reads.68.C2 raw_reads.73.raw_reads.68.N2 raw_reads.73.raw_reads.68.C3 raw_reads.73.raw_reads.68.N3 && LAmerge -v L1.73.68 raw_reads.73.raw_reads.68.C0.S raw_reads.73.raw_reads.68.N0.S raw_reads.73.raw_reads.68.C1.S raw_reads.73.raw_reads.68.N1.S raw_reads.73.raw_reads.68.C2.S raw_reads.73.raw_reads.68.N2.S raw_reads.73.raw_reads.68.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.69.C0 raw_reads.73.raw_reads.69.N0 raw_reads.73.raw_reads.69.C1 raw_reads.73.raw_reads.69.N1 raw_reads.73.raw_reads.69.C2 raw_reads.73.raw_reads.69.N2 raw_reads.73.raw_reads.69.C3 raw_reads.73.raw_reads.69.N3 && LAmerge -v L1.73.69 raw_reads.73.raw_reads.69.C0.S raw_reads.73.raw_reads.69.N0.S raw_reads.73.raw_reads.69.C1.S raw_reads.73.raw_reads.69.N1.S raw_reads.73.raw_reads.69.C2.S raw_reads.73.raw_reads.69.N2.S raw_reads.73.raw_reads.69.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.70.C0 raw_reads.73.raw_reads.70.N0 raw_reads.73.raw_reads.70.C1 raw_reads.73.raw_reads.70.N1 raw_reads.73.raw_reads.70.C2 raw_reads.73.raw_reads.70.N2 raw_reads.73.raw_reads.70.C3 raw_reads.73.raw_reads.70.N3 && LAmerge -v L1.73.70 raw_reads.73.raw_reads.70.C0.S raw_reads.73.raw_reads.70.N0.S raw_reads.73.raw_reads.70.C1.S raw_reads.73.raw_reads.70.N1.S raw_reads.73.raw_reads.70.C2.S raw_reads.73.raw_reads.70.N2.S raw_reads.73.raw_reads.70.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.71.C0 raw_reads.73.raw_reads.71.N0 raw_reads.73.raw_reads.71.C1 raw_reads.73.raw_reads.71.N1 raw_reads.73.raw_reads.71.C2 raw_reads.73.raw_reads.71.N2 raw_reads.73.raw_reads.71.C3 raw_reads.73.raw_reads.71.N3 && LAmerge -v L1.73.71 raw_reads.73.raw_reads.71.C0.S raw_reads.73.raw_reads.71.N0.S raw_reads.73.raw_reads.71.C1.S raw_reads.73.raw_reads.71.N1.S raw_reads.73.raw_reads.71.C2.S raw_reads.73.raw_reads.71.N2.S raw_reads.73.raw_reads.71.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.72.C0 raw_reads.73.raw_reads.72.N0 raw_reads.73.raw_reads.72.C1 raw_reads.73.raw_reads.72.N1 raw_reads.73.raw_reads.72.C2 raw_reads.73.raw_reads.72.N2 raw_reads.73.raw_reads.72.C3 raw_reads.73.raw_reads.72.N3 && LAmerge -v L1.73.72 raw_reads.73.raw_reads.72.C0.S raw_reads.73.raw_reads.72.N0.S raw_reads.73.raw_reads.72.C1.S raw_reads.73.raw_reads.72.N1.S raw_reads.73.raw_reads.72.C2.S raw_reads.73.raw_reads.72.N2.S raw_reads.73.raw_reads.72.C3.S raw_reads. [...]
+LAsort -v raw_reads.73.raw_reads.73.C0 raw_reads.73.raw_reads.73.N0 raw_reads.73.raw_reads.73.C1 raw_reads.73.raw_reads.73.N1 raw_reads.73.raw_reads.73.C2 raw_reads.73.raw_reads.73.N2 raw_reads.73.raw_reads.73.C3 raw_reads.73.raw_reads.73.N3 && LAmerge -v L1.73.73 raw_reads.73.raw_reads.73.C0.S raw_reads.73.raw_reads.73.N0.S raw_reads.73.raw_reads.73.C1.S raw_reads.73.raw_reads.73.N1.S raw_reads.73.raw_reads.73.C2.S raw_reads.73.raw_reads.73.N2.S raw_reads.73.raw_reads.73.C3.S raw_reads. [...]
+LAcheck -vS raw_reads L1.55.73
+LAcheck -vS raw_reads L1.56.73
+LAcheck -vS raw_reads L1.57.73
+LAcheck -vS raw_reads L1.58.73
+LAcheck -vS raw_reads L1.59.73
+LAcheck -vS raw_reads L1.60.73
+LAcheck -vS raw_reads L1.61.73
+LAcheck -vS raw_reads L1.62.73
+LAcheck -vS raw_reads L1.63.73
+LAcheck -vS raw_reads L1.64.73
+LAcheck -vS raw_reads L1.65.73
+LAcheck -vS raw_reads L1.66.73
+LAcheck -vS raw_reads L1.67.73
+LAcheck -vS raw_reads L1.68.73
+LAcheck -vS raw_reads L1.69.73
+LAcheck -vS raw_reads L1.70.73
+LAcheck -vS raw_reads L1.71.73
+LAcheck -vS raw_reads L1.72.73
+LAcheck -vS raw_reads L1.73.55
+LAcheck -vS raw_reads L1.73.56
+LAcheck -vS raw_reads L1.73.57
+LAcheck -vS raw_reads L1.73.58
+LAcheck -vS raw_reads L1.73.59
+LAcheck -vS raw_reads L1.73.60
+LAcheck -vS raw_reads L1.73.61
+LAcheck -vS raw_reads L1.73.62
+LAcheck -vS raw_reads L1.73.63
+LAcheck -vS raw_reads L1.73.64
+LAcheck -vS raw_reads L1.73.65
+LAcheck -vS raw_reads L1.73.66
+LAcheck -vS raw_reads L1.73.67
+LAcheck -vS raw_reads L1.73.68
+LAcheck -vS raw_reads L1.73.69
+LAcheck -vS raw_reads L1.73.70
+LAcheck -vS raw_reads L1.73.71
+LAcheck -vS raw_reads L1.73.72
+LAcheck -vS raw_reads L1.73.73
diff --git a/FALCON/test/test_functional.py b/FALCON/test/test_functional.py
index 37cfa58..832ba1f 100644
--- a/FALCON/test/test_functional.py
+++ b/FALCON/test/test_functional.py
@@ -27,6 +27,15 @@ def test_get_daligner_job_descriptions_small():
helpers.equal_multiline(result[('.1', '.1')], "daligner -v -h1 -t50 -H1 -e0.99 -l1 -s1000 preads.1 preads.1\nLAcheck -v preads *.las\nLAsort -v preads.1.preads.1.C0 preads.1.preads.1.N0 preads.1.preads.1.C1 preads.1.preads.1.N1 preads.1.preads.1.C2 preads.1.preads.1.N2 preads.1.preads.1.C3 preads.1.preads.1.N3 && LAmerge -v preads.1 preads.1.preads.1.C0.S preads.1.preads.1.N0.S preads.1.preads.1.C1.S preads.1.preads.1.N1.S preads.1.preads.1.C2.S preads.1.preads.1.N2.S preads.1.preads [...]
eq_(len(result), 1)
+example_se161 = os.path.join(thisdir, 'se161.sh')
+
+def test_get_daligner_job_descriptions_se161():
+ # when there is only 1 block, a special case
+ example_HPCdaligner = open(example_se161)
+ result = f.get_daligner_job_descriptions(
+ example_HPCdaligner, 'raw_reads', single=False)
+ assert result
+
def test_get_mjob_data():
example_HPCdaligner = open(example_HPCdaligner_fn)
result = f.get_mjob_data(
@@ -149,12 +158,15 @@ sample_DBdump_output = """+ R 2
+ M 0
+ H 400
@ H 8
+R 0
H 8 m000_000
-L 0 1899 3899
+L 10 1899 3899
+R 1
H 8 m000_000
-L 1 2080 4080
+L 11 2080 4080
+R 2
H 8 m000_000
-L 2 0 2500
+L 12 0 2500
"""
def test_parsed_readlengths_from_dbdump_output():
lengths = list(f.parsed_readlengths_from_dbdump_output(sample_DBdump_output))
diff --git a/pypeFLOW/LICENSE b/pypeFLOW/LICENSE
new file mode 100644
index 0000000..f6fe1dd
--- /dev/null
+++ b/pypeFLOW/LICENSE
@@ -0,0 +1,32 @@
+The Clear BSD License
+
+Copyright (c) 2016, Jason Chin
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted (subject to the limitations in the disclaimer
+below) provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its contributors may be used
+ to endorse or promote products derived from this software without specific
+ prior written permission.
+
+NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS
+LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
diff --git a/pypeFLOW/License.txt b/pypeFLOW/License.txt
deleted file mode 100644
index f074d32..0000000
--- a/pypeFLOW/License.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (C) 2010 by Jason Chin
-Copyright (C) 2011 by Jason Chin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/pypeFLOW/pwatcher/blocking.py b/pypeFLOW/pwatcher/blocking.py
new file mode 100755
index 0000000..57a53c8
--- /dev/null
+++ b/pypeFLOW/pwatcher/blocking.py
@@ -0,0 +1,464 @@
+#!/usr/bin/env python2.7
+"""Blocking process-watcher.
+
+See fs_based.py. Here, delete is a no-op, and run() starts threads, so
+the main program needs to wait for threads to finish somehow.
+
+Typical submission_string:
+
+ qsub -S /bin/bash -sync y -V -q production -N ${JOB_ID} \\\n -o "${STDOUT_FILE}" \\\n -e "${STDERR_FILE}" \\\n -pe smp ${NPROC} \\\n "${CMD}"
+"""
+try:
+ from shlex import quote
+except ImportError:
+ from pipes import quote
+import collections
+import contextlib
+import glob
+import json
+import logging
+import os
+import pprint
+import re
+import signal
+import string
+import subprocess
+import sys
+import threading
+import time
+import traceback
+
+log = logging.getLogger(__name__)
+
+STATE_FN = 'state.py'
+Job = collections.namedtuple('Job', ['jobid', 'cmd', 'rundir', 'options'])
+MetaJob = collections.namedtuple('MetaJob', ['job', 'lang_exe'])
+lang_python_exe = sys.executable
+lang_bash_exe = '/bin/bash'
+
+ at contextlib.contextmanager
+def cd(newdir):
+ prevdir = os.getcwd()
+ log.debug('CD: %r <- %r' %(newdir, prevdir))
+ os.chdir(os.path.expanduser(newdir))
+ try:
+ yield
+ finally:
+ log.debug('CD: %r -> %r' %(newdir, prevdir))
+ os.chdir(prevdir)
+
+class MetaJobClass(object):
+ ext = {
+ lang_python_exe: '.py',
+ lang_bash_exe: '.bash',
+ }
+ def get_wrapper(self):
+ # Totally by convention, for now.
+ return '%s/run-%s%s' %(self.mj.job.rundir, self.mj.job.jobid, self.ext[self.mj.lang_exe])
+ def get_sentinel(self):
+ return 'exit-%s' %self.mj.job.jobid # in watched dir
+ def get_pid(self):
+ return self.mj.pid
+ def kill(self, pid, sig):
+ stored_pid = self.get_pid()
+ if not pid:
+ pid = stored_pid
+ log.info('Not passed a pid to kill. Using stored pid:%s' %pid)
+ if pid and stored_pid:
+ if pid != stored_pid:
+ log.error('pid:%s != stored_pid:%s' %(pid, stored_pid))
+ os.kill(pid, sig)
+ def __init__(self, mj):
+ self.mj = mj
+class State(object):
+ def notify_threaded(self, jobid):
+ self.jobids_threaded.add(jobid)
+ def notify_started(self, jobid):
+ #state.top['jobids_submitted'].append(jobid)
+ self.jobids_submitted.add(jobid)
+ self.jobids_threaded.remove(jobid)
+ def notify_exited(self, jobid, rc):
+ #self.top['jobid2exit'][jobid] = rc
+ self.jobid2exit[jobid] = rc
+ self.jobids_submitted.remove(jobid)
+ def set_job(self, jobid, mjob):
+ # Is this needed? For now, we are not actually saving state, so no.
+ self.top['jobs'][jobid] = mjob
+ def update_jobid2status(self, jobid2status):
+ for jobid in self.jobids_threaded:
+ status = 'THREADED'
+ jobid2status[jobid] = status
+ for jobid in self.jobids_submitted:
+ status = 'RUNNING'
+ # but actually it might not have started yet, or it could be dead, since we have blocking qsub calls
+ jobid2status[jobid] = status
+ for jobid, rc in self.jobid2exit.iteritems():
+ status = 'EXIT {}'.format(rc)
+ jobid2status[jobid] = status
+ def get_running_jobids(self):
+ return list(self.jobids_submitted)
+ def serialize(state):
+ return pprint.pformat(state.top)
+ @staticmethod
+ def deserialize(directory, content):
+ state = State(directory)
+ state.top = eval(content)
+ state.content_prev = content
+ return state
+ @staticmethod
+ def create(directory):
+ state = State(directory)
+ #makedirs(state.get_directory_wrappers())
+ #makedirs(state.get_directory_jobs())
+ return state
+ def __init__(self, directory):
+ self.__directory = os.path.abspath(directory)
+ self.content_prev = ''
+ self.top = dict() # for serialization, when we decide we need it
+ self.top['jobs'] = dict()
+ #self.top['jobids_submitted'] = list()
+ #self.top['jobid2exit'] = dict()
+ self.jobids_threaded = set()
+ self.jobids_submitted = set()
+ self.jobid2exit = dict()
+
+class SafeState(object):
+ """Synchronized State proxy for accessing any
+ data which might be modified in a Thread.
+ """
+ def notify_threaded(self, jobid):
+ with self.lock:
+ self.state.notify_threaded(jobid)
+ def notify_started(self, jobid):
+ with self.lock:
+ self.state.notify_started(jobid)
+ def notify_exited(self, jobid, rc):
+ with self.lock:
+ self.state.notify_exited(jobid, rc)
+ def update_jobid2status(self, table):
+ with self.lock:
+ return self.state.update_jobid2status(table)
+ def get_running_jobids(self):
+ with self.lock:
+ return self.state.get_running_jobids()
+ def serialize(self):
+ with self.lock:
+ return self.state.serialize()
+ def __getattr__(self, name):
+ """For all other methods, just delegate.
+ """
+ return getattr(self.state, name)
+ def __init__(self, state):
+ self.state = state
+ self.lock = threading.Lock()
+
+def get_state(directory):
+ """For now, we never write.
+ """
+ state_fn = os.path.join(directory, STATE_FN)
+ if not os.path.exists(state_fn):
+ return State.create(directory)
+ assert False, 'No state directory needed, for now.'
+ try:
+ return State.deserialize(directory, open(state_fn).read())
+ except Exception:
+ log.exception('Failed to read state "%s". Ignoring (and soon over-writing) current state.'%state_fn)
+ # TODO: Backup previous STATE_FN?
+ return State(directory)
+def State_save(state):
+ # TODO: RW Locks, maybe for runtime of whole program.
+ content = state.serialize()
+ content_prev = state.content_prev
+ if content == content_prev:
+ return
+ fn = state.get_state_fn()
+ open(fn, 'w').write(content)
+ log.debug('saved state to %s' %repr(os.path.abspath(fn)))
+def Job_get_MetaJob(job, lang_exe=lang_bash_exe):
+ return MetaJob(job, lang_exe=lang_exe)
+def MetaJob_wrap(mjob, state):
+ """Write wrapper contents to mjob.wrapper.
+ """
+ metajob_rundir = mjob.job.rundir
+ wdir = metajob_rundir
+
+ bash_template = """#!%(lang_exe)s
+cmd="%(cmd)s"
+rundir="%(rundir)s"
+finish() {
+ echo "finish code: $?"
+}
+trap finish 0
+#printenv
+echo
+set -ex
+while [ ! -d "$rundir" ]; do sleep 1; done
+cd "$rundir"
+eval "$cmd"
+ """
+ mji = MetaJobClass(mjob)
+ wrapper_fn = os.path.join(wdir, mji.get_wrapper())
+ command = mjob.job.cmd
+
+ wrapped = bash_template %dict(
+ lang_exe=mjob.lang_exe,
+ cmd=command,
+ rundir=metajob_rundir,
+ )
+ log.debug('Writing wrapper "%s"' %wrapper_fn)
+ open(wrapper_fn, 'w').write(wrapped)
+ system('chmod +x {}'.format(wrapper_fn))
+
+class JobThread(threading.Thread):
+ def run(self):
+ """Propagate environment, plus env_extra.
+ """
+ self.notify_start(self.jobname)
+ log.debug('hello! started Thread {}'.format(threading.current_thread()))
+ myenv = dict(os.environ)
+ myenv.update(self.env_extra)
+ log.debug('myenv:\n{}'.format(pprint.pformat(myenv)))
+ log.info("Popen: '{}'".format(self.cmd))
+ p = subprocess.Popen(self.cmd, env=myenv, shell=True)
+ log.debug("pid: {}".format(p.pid))
+ p.wait()
+ rc = p.returncode
+ log.debug("rc: {}".format(rc))
+ self.notify_exit(self.jobname, rc)
+ def __init__(self, jobname, cmd, notify_start, notify_exit, env_extra):
+ super(JobThread, self).__init__()
+ self.jobname = jobname
+ self.cmd = cmd
+ self.notify_start = notify_start
+ self.notify_exit = notify_exit
+ self.env_extra = env_extra
+
+class StringJobSubmitter(object):
+ """Substitute some variables into self.submission_string.
+ Use mains/job_start.sh as the top script. That requires
+ PYPEFLOW_JOB_START_SCRIPT in the environment as the real
+ script to run. This way, we are guaranteed that the top script exists,
+ and we can wait for the rest to appear in the filesystem.
+ """
+ def submit(self, jobname, mjob, state):
+ """Prepare job (based on wrappers) and submit as a new thread.
+ """
+ state.set_job(jobname, mjob)
+ jobname = mjob.job.jobid
+ mji = MetaJobClass(mjob)
+ #script_fn = os.path.join(state.get_directory_wrappers(), mji.get_wrapper())
+ script_fn = mji.get_wrapper()
+ exe = mjob.lang_exe
+
+ state.notify_threaded(jobname)
+ self.start(jobname, state, exe, script_fn) # Can raise
+ def get_cmd(self, jobname, script_fn, nproc):
+ """Vars:
+ JOB_ID, STDOUT_FILE, STDERR_FILE, NPROC, CMD
+ """
+ # We wrap in a program that waits for the executable to exist, so
+ # the filesystem has time to catch up on the remote machine.
+ # Hopefully, this will allow dependencies to become ready as well.
+ job_start_fn = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mains/job_start.sh')
+ CMD = job_start_fn
+ mapping = dict()
+ mapping['CMD'] = CMD
+ mapping['JOB_ID'] = jobname
+ mapping['STDOUT_FILE'] = script_fn + '.stdout'
+ mapping['STDERR_FILE'] = script_fn + '.stderr'
+ mapping['NPROC'] = str(nproc)
+ log.debug('mapping, submission_string: {}, {}'.format(repr(mapping), self.submission_string))
+ t = string.Template(self.submission_string)
+ return t.substitute(mapping)
+ def start(self, jobname, state, exe, script_fn):
+ """Run job in thread.
+ Thread will notify state.
+ Can raise.
+ """
+ nproc = 4
+ #cmd = script_fn
+ cmd = self.get_cmd(jobname, script_fn, nproc)
+ # job_start.sh relies on PYPEFLOW_*
+ env_extra = {
+ "PYPEFLOW_JOB_START_SCRIPT": script_fn,
+ "PYPEFLOW_JOB_START_TIMEOUT": "60",
+ }
+ log.debug('env_extra={}'.format(pprint.pformat(env_extra)))
+ notify_start = state.notify_started
+ notify_exit = state.notify_exited
+ th = JobThread(jobname, cmd, notify_start, notify_exit, env_extra)
+ #th.setDaemon(True)
+ th.start()
+ def __repr__(self):
+ return 'StringJobSubmitter(%s)' %repr(self.submission_string)
+ def __init__(self, submission_string):
+ self.submission_string = submission_string
+
+def link_rundir(state_rundir, user_rundir):
+ if user_rundir:
+ link_fn = os.path.join(user_rundir, 'pwatcher.dir')
+ if os.path.lexists(link_fn):
+ os.unlink(link_fn)
+ os.symlink(os.path.abspath(state_rundir), link_fn)
+
+def cmd_run(state, jobids, job_type, job_queue):
+ """
+ Wrap them and run them locally, each in the foreground of a thread.
+ """
+ jobs = dict()
+ submitted = list()
+ result = {'submitted': submitted}
+ if job_type != 'string':
+ log.warning("In blocking pwatcher, job_type={!r}, should be 'string'".format(job_type))
+ for jobid, desc in jobids.iteritems():
+ assert 'cmd' in desc
+ cmd = desc['cmd']
+ if 'rundir' in desc:
+ rundir = desc['rundir']
+ else:
+ rundir = os.path.dirname(cmd)
+ options = {}
+ jobs[jobid] = Job(jobid, cmd, rundir, options)
+ log.debug('jobs:\n%s' %pprint.pformat(jobs))
+ submission_string = job_queue
+ submitter = StringJobSubmitter(submission_string)
+ log.debug('submitter: {!r}'.format(submitter))
+ for jobid, job in jobs.iteritems():
+ desc = jobids[jobid]
+ log.debug('starting job %s' %pprint.pformat(job))
+ mjob = Job_get_MetaJob(job)
+ MetaJob_wrap(mjob, state)
+ try:
+ #link_rundir(state.get_directory_job(jobid), desc.get('rundir'))
+ submitter.submit(jobid, mjob, state)
+ submitted.append(jobid)
+ except Exception:
+ log.exception('Failed to submit background-job:\n{!r}'.format(
+ submitter))
+ return result
+ # The caller is responsible for deciding what to do about job-submission failures. Re-try, maybe?
+
+def system(call, checked=False):
+ log.info('!{}'.format(call))
+ rc = os.system(call)
+ if checked and rc:
+ raise Exception('{} <- {!r}'.format(rc, call))
+ return rc
+
+_warned = dict()
+def warnonce(hashkey, msg):
+ if hashkey in _warned:
+ return
+ log.warning(msg)
+ _warned[hashkey] = True
+
+def cmd_query(state, which, jobids):
+ """Return the state of named jobids.
+ If which=='list', then query jobs listed as jobids.
+ If which=='known', then query all known jobs.
+ If which=='infer', same as 'known' now.
+ """
+ result = dict()
+ jobstats = dict()
+ result['jobids'] = jobstats
+ if which == 'list':
+ for jobid in jobids:
+ jobstats[jobid] = 'UNKNOWN'
+ state.update_jobid2status(jobstats)
+ jobids = set(jobids)
+ if which == 'list':
+ for jobid in list(jobstats.keys()):
+ # TODO: This might remove thousands. We should pass jobids along to update_jobid2status().
+ if jobid not in jobids:
+ del jobstats[jobid]
+ return result
+def cmd_delete(state, which, jobids):
+ """Kill designated jobs, including (hopefully) their
+ entire process groups.
+ If which=='list', then kill all jobs listed as jobids.
+ If which=='known', then kill all known jobs.
+ If which=='infer', then kill all jobs with heartbeats.
+ """
+ log.error('Noop. We cannot kill blocked threads. Hopefully, everything will die on SIGTERM.')
+def makedirs(path):
+ if not os.path.isdir(path):
+ os.makedirs(path)
+def readjson(ifs):
+ """Del keys that start with ~.
+ That lets us have trailing commas on all other lines.
+ """
+ content = ifs.read()
+ log.debug('content:%s' %repr(content))
+ jsonval = json.loads(content)
+ #pprint.pprint(jsonval)
+ def striptildes(subd):
+ if not isinstance(subd, dict):
+ return
+ for k,v in subd.items():
+ if k.startswith('~'):
+ del subd[k]
+ else:
+ striptildes(v)
+ striptildes(jsonval)
+ #pprint.pprint(jsonval)
+ return jsonval
+
+class ProcessWatcher(object):
+ def run(self, jobids, job_type, job_queue):
+ #import traceback; log.debug(''.join(traceback.format_stack()))
+ log.debug('run(jobids={}, job_type={}, job_queue={})'.format(
+ '<%s>'%len(jobids), job_type, job_queue))
+ return cmd_run(self.state, jobids, job_type, job_queue)
+ def query(self, which='list', jobids=[]):
+ log.debug('query(which={!r}, jobids={})'.format(
+ which, '<%s>'%len(jobids)))
+ return cmd_query(self.state, which, jobids)
+ def delete(self, which='list', jobids=[]):
+ log.debug('delete(which={!r}, jobids={})'.format(
+ which, '<%s>'%len(jobids)))
+ return cmd_delete(self.state, which, jobids)
+ def __init__(self, state):
+ # state must be thread-safe
+ self.state = state
+
+def get_process_watcher(directory):
+ state = get_state(directory)
+ state = SafeState(state) # thread-safe proxy
+ #log.debug('state =\n%s' %pprint.pformat(state.top))
+ return ProcessWatcher(state)
+ #State_save(state)
+
+ at contextlib.contextmanager
+def process_watcher(directory):
+ """This will (someday) hold a lock, so that
+ the State can be written safely at the end.
+ """
+ state = get_state(directory)
+ state = SafeState(state) # thread-safe proxy
+ #log.debug('state =\n%s' %pprint.pformat(state.top))
+ yield ProcessWatcher(state)
+ #State_save(state)
+
+def main(prog, cmd, state_dir='mainpwatcher', argsfile=None):
+ logging.basicConfig()
+ logging.getLogger().setLevel(logging.NOTSET)
+ log.warning('logging basically configured')
+ log.debug('debug mode on')
+ assert cmd in ['run', 'query', 'delete']
+ ifs = sys.stdin if not argsfile else open(argsfile)
+ argsdict = readjson(ifs)
+ log.info('argsdict =\n%s' %pprint.pformat(argsdict))
+ with process_watcher(state_dir) as watcher:
+ result = getattr(watcher, cmd)(**argsdict)
+ if result is not None:
+ log.info('getattr({!r}, {!r}): {}'.format(
+ watcher, cmd, pprint.pformat(result)))
+ log.info('Waiting for running jobs...r')
+ while watcher.state.get_running_jobids():
+ log.info('running: {!s}'.format(watcher.state.get_running_jobids()))
+ time.sleep(1)
+
+if __name__ == "__main__":
+ #import pdb
+ #pdb.set_trace()
+ main(*sys.argv)
diff --git a/pypeFLOW/pwatcher/fs_based.py b/pypeFLOW/pwatcher/fs_based.py
index 7359919..0ace6c7 100755
--- a/pypeFLOW/pwatcher/fs_based.py
+++ b/pypeFLOW/pwatcher/fs_based.py
@@ -235,11 +235,24 @@ def background(script, exe='/bin/bash'):
#system(checkcall, checked=True)
return pid
+def qstripped(option):
+ """Given a string of options, remove any -q foo.
+
+ >>> qstripped('-xy -q foo -z bar')
+ '-xy -z bar'
+ """
+ # For now, do not strip -qfoo
+ vals = option.strip().split()
+ while '-q' in vals:
+ i = vals.index('-q')
+ vals = vals[0:i] + vals[i+2:]
+ return ' '.join(vals)
+
class MetaJobLocal(object):
def submit(self, state, exe, script_fn):
"""Can raise.
"""
- sge_option = self.mjob.job.options['sge_option']
+ #sge_option = self.mjob.job.options['sge_option']
#assert sge_option is None, sge_option # might be set anyway
pid = background(script_fn, exe=self.mjob.lang_exe)
def kill(self, state, heartbeat):
@@ -272,12 +285,13 @@ class MetaJobSge(object):
specific = self.specific
#cwd = os.getcwd()
job_name = self.get_jobname()
- sge_option = self.mjob.job.options['sge_option']
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
# Add shebang, in case shell_start_mode=unix_behavior.
# https://github.com/PacificBiosciences/FALCON/pull/348
with open(script_fn, 'r') as original: data = original.read()
with open(script_fn, 'w') as modified: modified.write("#!/bin/bash" + "\n" + data)
- sge_cmd = 'qsub -N {job_name} {sge_option} {specific} -cwd -o stdout -e stderr -S {exe} {script_fn}'.format(
+ sge_cmd = 'qsub -N {job_name} -q {job_queue} {sge_option} {specific} -cwd -o stdout -e stderr -S {exe} {script_fn}'.format(
**locals())
system(sge_cmd, checked=True) # TODO: Capture q-jobid
def kill(self, state, heartbeat):
@@ -315,12 +329,13 @@ usage: qsub [-a date_time] [-A account_string] [-c interval]
specific = self.specific
#cwd = os.getcwd()
job_name = self.get_jobname()
- sge_option = self.mjob.job.options['sge_option']
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
# Add shebang, in case shell_start_mode=unix_behavior.
# https://github.com/PacificBiosciences/FALCON/pull/348
with open(script_fn, 'r') as original: data = original.read()
with open(script_fn, 'w') as modified: modified.write("#!/bin/bash" + "\n" + data)
- sge_cmd = 'qsub -N {job_name} {sge_option} {specific} -o stdout -e stderr -S {exe} {script_fn}'.format(
+ sge_cmd = 'qsub -N {job_name} -q {job_queue} {sge_option} {specific} -o stdout -e stderr -S {exe} {script_fn}'.format(
**locals())
system(sge_cmd, checked=True) # TODO: Capture q-jobid
def kill(self, state, heartbeat):
@@ -351,13 +366,14 @@ class MetaJobTorque(object):
specific = self.specific
#cwd = os.getcwd()
job_name = self.get_jobname()
- sge_option = self.mjob.job.options['sge_option']
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
cwd = os.getcwd()
# Add shebang, in case shell_start_mode=unix_behavior.
# https://github.com/PacificBiosciences/FALCON/pull/348
with open(script_fn, 'r') as original: data = original.read()
with open(script_fn, 'w') as modified: modified.write("#!/bin/bash" + "\n" + data)
- sge_cmd = 'qsub -N {job_name} {sge_option} {specific} -d {cwd} -o stdout -e stderr -S {exe} {script_fn}'.format(
+ sge_cmd = 'qsub -N {job_name} -q {job_queue} {sge_option} {specific} -d {cwd} -o stdout -e stderr -S {exe} {script_fn}'.format(
**locals())
system(sge_cmd, checked=True) # TODO: Capture q-jobid
def kill(self, state, heartbeat):
@@ -378,16 +394,17 @@ class MetaJobTorque(object):
def __repr__(self):
return 'MetaJobTorque(%s)' %repr(self.mjob)
def __init__(self, mjob):
- super(MetaJobTorque, self).__init__(mjob)
+ self.mjob = mjob
self.specific = '-V' # pass enV; '-j oe' => combine out/err
class MetaJobSlurm(object):
def submit(self, state, exe, script_fn):
"""Can raise.
"""
job_name = self.get_jobname()
- sge_option = self.mjob.job.options['sge_option']
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
cwd = os.getcwd()
- sge_cmd = 'sbatch -J {job_name} {sge_option} -D {cwd} -o stdout -e stderr --wrap="{exe} {script_fn}"'.format(
+ sge_cmd = 'sbatch -J {job_name} -q {job_queue} {sge_option} -D {cwd} -o stdout -e stderr --wrap="{exe} {script_fn}"'.format(
**locals())
# "By default all environment variables are propagated."
# http://slurm.schedmd.com/sbatch.html
@@ -416,8 +433,9 @@ class MetaJobLsf(object):
"""Can raise.
"""
job_name = self.get_jobname()
- sge_option = self.mjob.job.options['sge_option']
- sge_cmd = 'bsub -J {job_name} {sge_option} -o stdout -e stderr "{exe} {script_fn}"'.format(
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
+ sge_cmd = 'bsub -J {job_name} -q {job_queue} {sge_option} -o stdout -e stderr "{exe} {script_fn}"'.format(
**locals())
# "Sets the user's execution environment for the job, including the current working directory, file creation mask, and all environment variables, and sets LSF environment variables before starting the job."
system(sge_cmd, checked=True) # TODO: Capture q-jobid
@@ -458,12 +476,19 @@ def cmd_run(state, jobids, job_type, job_queue):
for jobid, desc in jobids.iteritems():
assert 'cmd' in desc
options = {}
+ if 'job_queue' not in desc:
+ raise Exception(pprint.pformat(desc))
for k in ('sge_option', 'job_type', 'job_queue'): # extras to be stored
if k in desc:
- options[k] = desc[k]
+ if desc[k]:
+ options[k] = desc[k]
if options.get('sge_option', None) is None:
# This way we can always safely include it.
- options = {'sge_option': ''}
+ options['sge_option'] = ''
+ if not options.get('job_queue'):
+ options['job_queue'] = job_queue
+ if not options.get('job_type'):
+ options['job_type'] = job_type
jobs[jobid] = Job(jobid, desc['cmd'], desc['rundir'], options)
log.debug('jobs:\n%s' %pprint.pformat(jobs))
for jobid, job in jobs.iteritems():
@@ -691,6 +716,13 @@ class ProcessWatcher(object):
return cmd_delete(self.state, which, jobids)
def __init__(self, state):
self.state = state
+
+def get_process_watcher(directory):
+ state = get_state(directory)
+ #log.debug('state =\n%s' %pprint.pformat(state.top))
+ return ProcessWatcher(state)
+ #State_save(state)
+
@contextlib.contextmanager
def process_watcher(directory):
"""This will (someday) hold a lock, so that
diff --git a/pypeFLOW/pwatcher/mains/job_start.sh b/pypeFLOW/pwatcher/mains/job_start.sh
new file mode 100755
index 0000000..73b7348
--- /dev/null
+++ b/pypeFLOW/pwatcher/mains/job_start.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+# vim: filetype=sh ts=4 sw=4 sts=4 et:
+#
+# Wait until file exists, then spawn.
+
+# This is not Python because the start_tmpl from pbsmrtpipe always runs bash.
+# But we use the .py extension because we want this installed with our Python
+# code, so we do not need to deal with mobs for installation. (But we might
+# need to chmod +x.)
+#
+# This can be run via
+#
+# bash -c pwatcher/mains.job_start.py myprog 60
+#
+# Note: If anyone replaces this, you must ensure that running this is exactly equivalent
+# to running the "executable". In other words, no 'mkdir', no 'cd', etc. That will help
+# with debugging.
+
+set -vex
+executable=${PYPEFLOW_JOB_START_SCRIPT}
+timeout=${PYPEFLOW_JOB_START_TIMEOUT:-60} # wait 60s by default
+
+# Wait up to timeout seconds for the executable to become "executable",
+# then exec.
+#timeleft = int(timeout)
+while [[ ! -x "${executable}" ]]; do
+ if [[ "${timeout}" == "0" ]]; then
+ echo "timed out waiting for (${executable})"
+ exit 77
+ fi
+ echo "not executable: '${executable}', waiting ${timeout}s"
+ sleep 1
+ timeout=$((timeout-1))
+done
+
+bash ${executable}
diff --git a/pypeFLOW/pwatcher/mains/network_heartbeat.py b/pypeFLOW/pwatcher/mains/network_heartbeat.py
new file mode 100644
index 0000000..40bee48
--- /dev/null
+++ b/pypeFLOW/pwatcher/mains/network_heartbeat.py
@@ -0,0 +1,176 @@
+"""Network server heartbeat wrapper
+
+Perl might be better for efficiency.
+But we will use python for now.
+
+Non-zero status means *this* failed, not the wrapped command.
+"""
+import argparse
+import os
+import shlex
+import socket
+import subprocess
+import sys
+import threading
+import time
+
+DESCRIPTION = """
+We wrap a system call to produce a heartbeat.
+"""
+EPILOG = """
+We log to the status server, and forward command stdout/stderr as well.
+"""
+
+class _Formatter(argparse.RawDescriptionHelpFormatter, argparse.ArgumentDefaultsHelpFormatter):
+ pass
+_FORMATTER_CLASS = _Formatter
+
+def parse_args(args):
+ parser = argparse.ArgumentParser(
+ description=DESCRIPTION,
+ epilog=EPILOG,
+ formatter_class=_FORMATTER_CLASS,
+ )
+ parser.add_argument('--rate',
+ help='Heartbeat rate, in seconds',
+ type=int,
+ default=600,
+ )
+ parser.add_argument('--heartbeat-server',
+ help='Address of the heartbeat server',
+ required=True,
+ )
+ parser.add_argument('--heartbeat-port',
+ help='Port of the heartbeat server',
+ type=int,
+ required=True,
+ )
+ parser.add_argument('--jobid',
+ help='Our jobid',
+ required=True,
+ )
+ parser.add_argument('--exit-dir',
+ help='Path to emergency exit sentinel directory',
+ required=True,
+ )
+ parser.add_argument('--directory',
+ help='Directory in which to run COMMAND.',
+ default='.',
+ )
+ parser.add_argument('command',
+ help='System call (to be joined by " "). We will block on this and return its result.',
+ nargs='+',
+ #required=True,
+ )
+ return parser.parse_args(args)
+
+# send message delimited with a \0
+def socket_send(socket, message):
+ socket.sendall(b'{}\0'.format(message))
+
+def log(heartbeat_server, jobid, msg):
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(heartbeat_server)
+ socket_send(hsocket, 's {} {}\n'.format(jobid, msg))
+ hsocket.close()
+ except IOError: # better to miss a line than terminate
+ pass
+
+def thread_heartbeat(heartbeat_server, jobid, sleep_s):
+ pid = os.getpid()
+ pgid = os.getpgid(0)
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(heartbeat_server)
+ socket_send(hsocket, 'i {} {} {}'.format(jobid, pid, pgid))
+ hsocket.close()
+ except IOError: # we hope it's a temporary error
+ pass
+ while True:
+ time.sleep(sleep_s)
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(heartbeat_server)
+ socket_send(hsocket, 'h {}'.format(jobid))
+ hsocket.close()
+ except IOError: # we hope it's a temporary error
+ pass
+
+def start_heartbeat(heartbeat_server, jobid, sleep_s):
+ hb = threading.Thread(target=thread_heartbeat, args=(heartbeat_server, jobid, sleep_s))
+ log(heartbeat_server, jobid, 'alive? {}'.format(
+ bool(hb.is_alive())))
+ hb.daemon = True
+ hb.start()
+ return hb
+
+def run(args):
+ heartbeat_server = (args.heartbeat_server, args.heartbeat_port)
+ jobid = args.jobid
+ log(heartbeat_server, jobid, repr(args))
+ os.chdir(args.directory)
+ exit_dir = args.exit_dir
+ exit_fn = os.path.join(os.path.abspath(exit_dir), jobid)
+ cwd = os.getcwd()
+ hostname = socket.getfqdn()
+ sleep_s = args.rate
+ log(heartbeat_server, jobid, """
+cwd:{cwd!r}
+hostname={hostname}
+heartbeat_server={heartbeat_server!r}
+jobid={jobid}
+exit_dir={exit_dir!r}
+sleep_s={sleep_s!r}""".format(
+ **locals()))
+ log(heartbeat_server, jobid, "before setpgid: pid={} pgid={}".format(os.getpid(), os.getpgid(0)))
+ try:
+ os.setpgid(0, 0) # This allows the entire tree of procs to be killed.
+ log(heartbeat_server, jobid, " after setpgid: pid={} pgid={}".format(
+ os.getpid(), os.getpgid(0)))
+ except OSError as e:
+ log(heartbeat_server, jobid, ' Unable to set pgid. Possibly a grid job? Hopefully there will be no dangling processes when killed: {}'.format(
+ repr(e)))
+
+ thread = start_heartbeat(heartbeat_server, jobid, sleep_s)
+
+ log(heartbeat_server, jobid, 'alive? {} pid={} pgid={}'.format(
+ bool(thread.is_alive()), os.getpid(), os.getpgid(0)))
+
+ call = ' '.join(args.command)
+ log(heartbeat_server, jobid, 'In cwd: {}, Blocking call: {!r}'.format(
+ os.getcwd(), call))
+ sp = subprocess.Popen(shlex.split(call), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+ # forward all output to server until job ends, then get exit value
+ with sp.stdout as f:
+ for line in iter(f.readline, b''):
+ # can't use log() for this because it appends a \n
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(heartbeat_server)
+ socket_send(hsocket, 's {} {}'.format(jobid, line))
+ hsocket.close()
+ except IOError: # better to miss a line than terminate
+ pass
+ rc = sp.wait()
+
+ log(heartbeat_server, jobid, ' returned: {!r}'.format(
+ rc))
+
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(heartbeat_server)
+ socket_send(hsocket, 'e {} {}'.format(jobid, rc))
+ hsocket.close()
+ except IOError as e:
+ log(heartbeat_server, jobid, 'could not update heartbeat server with exit status: {} {}: {!r}'.format(jobid, rc, e))
+ with open(exit_fn, 'w') as f:
+ f.write(str(rc))
+ # sys.exit(rc) # No-one would see this anyway.
+
+def main():
+ args = parse_args(sys.argv[1:])
+ run(args)
+
+if __name__ == "__main__":
+ main()
diff --git a/pypeFLOW/pwatcher/mains/query_server.py b/pypeFLOW/pwatcher/mains/query_server.py
new file mode 100755
index 0000000..94604d5
--- /dev/null
+++ b/pypeFLOW/pwatcher/mains/query_server.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+
+"""
+Query the heartbeat server from the command line.
+As an argument, takes either server:port or the falcon run directory
+(if not argument is given, uses the current directory).
+"""
+
+import argparse
+import collections
+import os
+import re
+import socket
+import sys
+
+STATE_FN = 'state.py' # taken from network_based.py
+STATE_DIR = 'mypwatcher' # taken from pwatcher_bridge.py
+
+# send message delimited with a \0
+def socket_send(socket, message):
+ socket.sendall(b'{}\0'.format(message))
+
+# receive all of \0 delimited message
+# may discard content past \0, if any, so not safe to call twice on same socket
+def socket_read(socket):
+ buffer = bytearray(b' ' * 256)
+ nbytes = socket.recv_into(buffer, 256)
+ if nbytes == 0: # empty message
+ return
+ message = ''
+ while nbytes != 0:
+ try: # index() raises when it can't find the character
+ i = buffer[:nbytes].index('\0')
+ message += str(buffer[:i]) # discard past delimiter
+ break
+ except ValueError: # haven't reached end yet
+ message += str(buffer)
+ nbytes = socket.recv_into(buffer, 256)
+ return message
+
+# get server and port from watcher state file
+def use_state(filename):
+ with open(filename, 'r') as f:
+ for line in f:
+ match = re.match(r" 'server': \('([^']+)', (\d+)\)", line)
+ if match:
+ return (match.group(1), int(match.group(2)))
+ print('Error: could not find server info in state file {}'.format(filename))
+
+def parse_args():
+ parser = argparse.ArgumentParser(description='query falcon network based heartbeat server')
+ parser.add_argument('-s', '--server', help='<server_name:port>')
+ parser.add_argument('-f', '--file', help='location of pwatcher state file')
+ parser.add_argument('-d', '--debug', default=False, action='store_const', const=True, help='get server state instead of process list')
+ parser.add_argument('sf', nargs='?', help='specify server or file')
+ return parser.parse_args()
+
+# parse command line argument (if any) to find server info
+def find_server(args):
+ i = 0
+ if args.server:
+ i += 1
+ if args.file:
+ i += 1
+ if args.sf:
+ i += 1
+ if i > 1:
+ print('Error: may only specify server once')
+ parser.print_usage()
+ return
+ if args.sf:
+ if os.path.exists(args.sf):
+ args.file = args.sf
+ else:
+ try:
+ args.sf.index(':')
+ except ValueError:
+ print('Error: could not parse argument as file or server:port: {}'.format(args.sf))
+ return
+ args.server = args.sf
+ if args.server:
+ try:
+ i = args.server.index(':')
+ except ValueError:
+ print('Error: could not parse argument as server:port: {}'.format(args.server))
+ return
+ server = args.server[:i]
+ port = int(args.server[i + 1:])
+ return (server, port)
+ if not args.file:
+ args.file = '.'
+ if os.path.isfile(args.file):
+ return use_state(args.file)
+ elif os.path.isdir(args.file):
+ if os.path.isfile(os.path.join(args.file, STATE_FN)):
+ return use_state(os.path.join(args.file, STATE_FN))
+ elif os.path.isfile(os.path.join(args.file, STATE_DIR, STATE_FN)):
+ return use_state(os.path.join(args.file, STATE_DIR, STATE_FN))
+ print('Error: could not find state file: {}'.format(args.file))
+
+args = parse_args()
+server = find_server(args)
+if not server:
+ sys.exit(1)
+s = socket.socket()
+s.connect(server)
+
+if args.debug:
+ socket_send(s, 'D')
+ server_state = socket_read(s)
+ s.close()
+ state = eval(server_state)
+ for jobid, val in state.iteritems():
+ print('{}: {} {} {} {}'.format(jobid, val[0], val[1], val[2], val[3]))
+else:
+ socket_send(s, 'L')
+ jobids = socket_read(s)
+ s.close()
+ for jobid in jobids.split():
+ s = socket.socket()
+ s.connect(server)
+ socket_send(s, 'Q {}'.format(jobid))
+ m = socket_read(s)
+ s.close()
+ print('{} {}'.format(jobid, m))
diff --git a/pypeFLOW/pwatcher/network_based.py b/pypeFLOW/pwatcher/network_based.py
new file mode 100755
index 0000000..8866b54
--- /dev/null
+++ b/pypeFLOW/pwatcher/network_based.py
@@ -0,0 +1,1031 @@
+#!/usr/bin/env python2.7
+"""Network-based process-watcher.
+
+This is meant to be part of a 2-process system. For now, let's call these
+processes the Definer and the Watcher.
+* The Definer creates a graph of tasks and starts a resolver loop, like
+ pypeflow. It keeps a Waiting list, a Running list, and a Done list. It then
+ communicates with the Watcher.
+* The Watcher has 3 basic functions in its API.
+ 1. Spawn jobs.
+ 2. Kill jobs.
+ 3. Query jobs.
+1. Spawning jobs
+ The job definition includes the script, how to run it (locally, qsub, etc.),
+ and maybe some details (unique-id, run-directory). The Watcher then:
+ * wraps the script within something to update the heartbeat server
+ periodically,
+ * spawns each job (possibly as a background process locally),
+ * and records info (including PID or qsub-name) in a persistent database.
+2. Kill jobs.
+ Since it has a persistent database, it can always kill any job, upon request.
+3. Query jobs.
+ Whenever requested, it can poll the server for all or any jobs, returning the
+ subset of completed jobs.
+
+The Definer would call the Watcher to spawn tasks, and then periodically to poll
+them. Because these are both now single-threaded, the Watcher *could* be a
+function within the Definer, or a it could be blocking call to a separate
+process.
+
+Caching/timestamp-checking would be done in the Definer, flexibly specific to
+each Task.
+
+Eventually, the Watcher could be in a different programming language. Maybe
+perl. (In bash, a background heartbeat gets is own process group, so it can be
+hard to clean up.)
+"""
+try:
+ from shlex import quote
+except ImportError:
+ from pipes import quote
+import SocketServer
+import collections
+import contextlib
+import glob
+import json
+import logging
+import os
+import pprint
+import re
+import shutil
+import signal
+import socket
+import subprocess
+import sys
+import multiprocessing
+import time
+import traceback
+
+log = logging.getLogger(__name__)
+
+HEARTBEAT_RATE_S = 600
+STATE_FN = 'state.py'
+Job = collections.namedtuple('Job', ['jobid', 'cmd', 'rundir', 'options'])
+MetaJob = collections.namedtuple('MetaJob', ['job', 'lang_exe'])
+lang_python_exe = sys.executable
+lang_bash_exe = '/bin/bash'
+
+ at contextlib.contextmanager
+def cd(newdir):
+ prevdir = os.getcwd()
+ log.debug('CD: %r <- %r' %(newdir, prevdir))
+ os.chdir(os.path.expanduser(newdir))
+ try:
+ yield
+ finally:
+ log.debug('CD: %r -> %r' %(newdir, prevdir))
+ os.chdir(prevdir)
+
+# send message delimited with a \0
+def socket_send(socket, message):
+ socket.sendall(b'{}\0'.format(message))
+
+# receive all of \0 delimited message
+# may discard content past \0, if any, so not safe to call twice on same socket
+def socket_read(socket):
+ buffer = bytearray(b' ' * 256)
+ nbytes = socket.recv_into(buffer, 256)
+ if nbytes == 0: # empty message
+ return
+ message = ''
+ while nbytes != 0:
+ try: # index() raises when it can't find the character
+ i = buffer[:nbytes].index('\0')
+ message += str(buffer[:i]) # discard past delimiter
+ break
+ except ValueError: # haven't reached end yet
+ message += str(buffer)
+ nbytes = socket.recv_into(buffer, 256)
+ return message
+
+# TODO: have state be persistent in some fashion, so we can be killed
+# and restarted
+class StatusServer(SocketServer.BaseRequestHandler):
+ """input format is "command [jobid [arg1 [arg2]]]"
+ job status update commands are:
+ i <jobid> <pid> <pgid> - initialize job
+ d <jobid> - delete job info
+ e <jobid> <exit_status> - job exit
+ h <jobid> - heartbeat
+ s <jobid> <stdout/stderr output> - record script output
+ job status query commands are:
+ A - returns authentication key
+ D - returns the entire server state
+ L - returns a space-delimited list of all jobids
+ P <jobid> - returns "pid pgid" if available
+ Q <jobid> - for done/exited jobs returns "EXIT <exit_status>"
+ - for others, returns "RUNNING <seconds_since_last_update>"
+ """
+ def handle(self):
+ message = socket_read(self.request)
+ if not message:
+ return
+ args = message.split(None, 4)
+ if not args: # make sure we have some arguments
+ return
+ command = args[0]
+ if command == 'A': # send authentication key
+ # need repr() as it's a byte string and may have zeroes
+ socket_send(self.request, repr(multiprocessing.Process().authkey))
+ return
+ if command == 'D': # send server state
+ socket_send(self.request, repr(self.server.server_job_list))
+ return
+ if command == 'L': # send list of jobids
+ socket_send(self.request, ' '.join(self.server.server_job_list.keys()))
+ return
+ if len(args) < 2: # make sure we have a jobid argument
+ return
+ jobid = args[1]
+ if command == 'i': # job start (with pid and pgid)
+ if len(args) < 4: # missing pid/pgid
+ self.server.server_job_list[jobid] = [time.time(), None, None, None]
+ else:
+ self.server.server_job_list[jobid] = [time.time(), args[2], args[3], None]
+ with open(os.path.join(self.server.server_pid_dir, jobid), 'w') as f:
+ f.write('{} {}'.format(args[2], args[3]))
+ elif command == 'h' or command == 'e' or command == 's': # updates
+ log_file = os.path.join(self.server.server_log_dir, jobid)
+ if jobid in self.server.server_job_list:
+ j = self.server.server_job_list[jobid]
+ j[0] = time.time()
+ else: # unknown jobid, so create job
+ j = self.server.server_job_list[jobid] = [time.time(), None, None, None]
+ with open(log_file, 'w'):
+ pass
+ os.utime(log_file, (j[0], j[0]))
+ if command == 'e': # exit (with exit code)
+ if len(args) < 3: # lack of error code is an error (bug)
+ j[3] = '99'
+ else:
+ j[3] = args[2]
+ with open(os.path.join(self.server.server_exitrc_dir, jobid), 'w') as f:
+ f.write(str(j[3]))
+ elif command == 's': # record log output
+ if len(args) > 2:
+ with open(log_file, 'a') as f:
+ f.writelines(' '.join(args[2:]))
+ elif jobid not in self.server.server_job_list: # unknown jobid
+ return
+ elif command == 'd': # delete job info
+ del self.server.server_job_list[jobid]
+ elif command == 'Q' or command == 'P': # queries
+ j = self.server.server_job_list[jobid]
+ if command == 'Q': # query job status
+ if j[3]: # has exit status
+ socket_send(self.request, 'EXIT {}'.format(j[3]))
+ else: # return time since last heartbeat
+ # convert to int to keep message shorter -
+ # we don't need the extra precision, anyway
+ diff = int(time.time() - j[0])
+ if diff < 0: # possible with a clock change
+ diff = 0
+ socket_send(self.request, 'RUNNING {}'.format(diff))
+ elif command == 'P': # get job pid and pgid
+ if j[1] != None and j[2] != None:
+ socket_send(self.request, '{} {}'.format(j[1], j[2]))
+
+# get local ip address while avoiding some common problems
+def get_localhost_ipaddress(hostname, port):
+ if hostname == '0.0.0.0':
+ # use getaddrinfo to work with ipv6
+ list = socket.getaddrinfo(socket.gethostname(), port, socket.AF_INET, socket.SOCK_STREAM)
+ for a in list:
+ # TODO: have this part work with ipv6 addresses
+ if len(a[4]) == 2 and a[4][0] != '127.0.0.1':
+ return a[4][0]
+ return hostname
+
+# if we end up restarting a partially killed process, we'll try
+# to pick up the ongoing heartbeats
+class ReuseAddrServer(SocketServer.TCPServer):
+ def restore_from_directories(self):
+ """
+ as our heartbeat server has been down, there's no accurate way
+ to set the heartbeat times, so we just use the current time, and
+ hope for an update from the process before the heartbeat timeout
+ """
+ if os.path.isdir(self.server_pid_dir):
+ for file in os.listdir(self.server_pid_dir):
+ with open(os.path.join(self.server_pid_dir, file)) as f:
+ (pid, pgid) = f.readline().strip().split()
+ if pid and pgid:
+ self.server_job_list[file] = [time.time(), pid, pgid, None]
+ # for finished proceses, though, we use the exit file time
+ if os.path.isdir(self.server_exitrc_dir):
+ for file in os.listdir(self.server_exitrc_dir):
+ fn = os.path.join(self.server_exitrc_dir, file)
+ with open(fn) as f:
+ rc = f.readline().strip()
+ if rc:
+ if file in self.server_job_list:
+ self.server_job_list[file][0] = os.path.getmtime(fn)
+ self.server_job_list[file][3] = rc
+ else:
+ self.server_job_list[file] = [os.getmtime(fn), None, None, rc]
+ def __init__(self, server_address, RequestHandlerClass, server_directories):
+ self.allow_reuse_address = True
+ self.server_log_dir, self.server_pid_dir, self.server_exitrc_dir = server_directories
+ # {jobid} = [pid, pgid, heartbeat timestamp, exit rc]
+ self.server_job_list = dict()
+ self.restore_from_directories()
+ SocketServer.TCPServer.__init__(self, server_address, RequestHandlerClass)
+
+def start_server(server_directories, hostname='', port=0):
+ server = ReuseAddrServer((hostname, port), StatusServer, server_directories)
+ hostname, port = server.socket.getsockname()
+ hostname = get_localhost_ipaddress(hostname, port)
+ # we call it a thread, but use a process to avoid the gil
+ hb_thread = multiprocessing.Process(target=server.serve_forever)
+ # set daemon to make sure server shuts down when main program finishes
+ hb_thread.daemon = True
+ hb_thread.start()
+ log.debug('server ({}, {}) alive?'.format(hostname, port, hb_thread.is_alive()))
+ return (hb_thread.authkey, (hostname, port))
+
+class MetaJobClass(object):
+ ext = {
+ lang_python_exe: '.py',
+ lang_bash_exe: '.bash',
+ }
+ def get_wrapper(self):
+ return 'run-%s%s' %(self.mj.job.jobid, self.ext[self.mj.lang_exe])
+ def get_pid(self):
+ return self.mj.pid
+ def kill(self, pid, sig):
+ stored_pid = self.get_pid()
+ if not pid:
+ pid = stored_pid
+ log.info('Not passed a pid to kill. Using stored pid:%s' %pid)
+ if pid and stored_pid:
+ if pid != stored_pid:
+ log.error('pid:%s != stored_pid:%s' %(pid, stored_pid))
+ os.kill(pid, sig)
+ def __init__(self, mj):
+ self.mj = mj
+
+class State(object):
+ def get_state_fn(self):
+ return os.path.join(self.__directory, STATE_FN)
+ def get_heartbeat_server(self):
+ return self.top['server']
+ def get_directory_wrappers(self):
+ return os.path.join(self.__directory, 'wrappers')
+ def get_directory_exits(self): # more like, emergency exits ;)
+ return 'exits'
+ def get_server_directories(self):
+ return (os.path.join(self.__directory, 'log'), os.path.join(self.__directory, 'pid'), os.path.join(self.__directory, 'exit'))
+ def submit_background(self, bjob):
+ """Run job in background.
+ Record in state.
+ """
+ jobid = bjob.mjob.job.jobid
+ self.top['jobs'][jobid] = bjob
+ mji = MetaJobClass(bjob.mjob)
+ script_fn = os.path.join(self.get_directory_wrappers(), mji.get_wrapper())
+ exe = bjob.mjob.lang_exe
+ with cd(bjob.mjob.job.rundir):
+ bjob.submit(self, exe, script_fn) # Can raise
+ log.info('Submitted backgroundjob=%s'%repr(bjob))
+ self.top['jobids_submitted'].append(jobid)
+ self.__changed = True
+ def get_mji(self, jobid):
+ mjob = self.top['jobs'][jobid].mjob
+ return MetaJobClass(mjob)
+ def get_bjob(self, jobid):
+ return self.top['jobs'][jobid]
+ def get_bjobs(self):
+ return self.top['jobs']
+ def get_mjobs(self):
+ return {jobid: bjob.mjob for jobid, bjob in self.top['jobs'].iteritems()}
+ def add_deleted_jobid(self, jobid):
+ self.top['jobids_deleted'].append(jobid)
+ self.__changed = True
+ def restart_server(self):
+ hsocket = socket.socket()
+ try: # see if our old server is still there
+ hsocket.settimeout(60)
+ hsocket.connect(self.get_heartbeat_server())
+ socket_send(hsocket, 'A')
+ line = socket_read(hsocket)
+ hsocket.close()
+ # auth is binary, so we have to eval to restore it
+ if self.top['auth'] != eval(line): # not our server
+ raise IOError()
+ except IOError: # need to restart server
+ try: # first we try restarting at same location
+ old_hostname, old_port = self.get_heartbeat_server()
+ self.top['auth'], self.top['server'] = start_server(self.get_server_directories(), old_hostname, old_port)
+ except StandardError:
+ log.exception('Failed to restore previous watcher server settings')
+ try: # next we try restarting with original arguments
+ old_hostname, old_port = self.top['server_args']
+ self.top['auth'], self.top['server'] = start_server(self.get_server_directories(), old_hostname, old_port)
+ except StandardError:
+ self.top['auth'], self.top['server'] = start_server(self.get_server_directories())
+ self__.changed = True
+ # if we restarted, orphaned jobs might have left exit files
+ # update the server with exit info
+ def cleanup_exits(self):
+ if os.path.exists(self.get_directory_exits()):
+ for file in os.listdir(self.get_directory_exits()):
+ exit_fn = os.path.join(self.get_directory_exits(), file)
+ with open(exit_fn) as f:
+ rc = f.readline().strip()
+ hsocket = socket.socket()
+ hsocket.connect(self.get_heartbeat_server())
+ socket_send(hsocket, 'e {} {}'.format(jobid, rc))
+ hsocket.close()
+ os.remove(fn)
+ else:
+ makedirs(self.get_directory_exits())
+ def restore_from_save(self, state_fn):
+ with open(state_fn) as f:
+ self.top = eval(f.read())
+ self.restart_server()
+ self.cleanup_exits()
+ self.__initialized = True
+ def initialize(self, directory, hostname='', port=0):
+ self.__directory = os.path.abspath(directory)
+ state_fn = self.get_state_fn()
+ if os.path.exists(state_fn):
+ try: # try to restore state from last save
+ if self.restore_from_save(state_fn):
+ return
+ except StandardError:
+ log.exception('Failed to use saved state "%s". Ignoring (and soon over-writing) current state.'%state_fn)
+ makedirs(self.get_directory_wrappers())
+ makedirs(self.get_directory_exits())
+ for i in self.get_server_directories():
+ makedirs(i)
+ if directory != 'mypwatcher': # link mypwatcher to dir
+ if os.path.exists('mypwatcher'):
+ try:
+ if os.path.islink('mypwatcher'):
+ os.remove('mypwatcher')
+ else:
+ shutil.rmtree('mypwatcher')
+ except OSError:
+ pass
+ os.symlink(self.__directory, 'mypwatcher')
+ self.top['server_args'] = (hostname, port)
+ self.top['auth'], self.top['server'] = start_server(self.get_server_directories(), hostname, port)
+ self.__initialized = True
+ self.__changed = True
+ def is_initialized(self):
+ return self.__initialized
+ def save(self):
+ # TODO: RW Locks, maybe for runtime of whole program.
+ # only save if there has been a change
+ if self.__changed:
+ content = pprint.pformat(self.top)
+ fn = self.get_state_fn()
+ with open(fn + '.tmp', 'w') as f:
+ f.write(content)
+ # as atomic as we can portably manage
+ shutil.move(fn + '.tmp', fn)
+ self.__changed = False
+ log.debug('saved state to %s' %repr(os.path.abspath(fn)))
+ def __init__(self):
+ self.__initialized = False
+ self.__changed = False
+ self.top = dict()
+ self.top['jobs'] = dict()
+ self.top['jobids_deleted'] = list()
+ self.top['jobids_submitted'] = list()
+
+watcher_state = State()
+
+def get_state(directory, hostname='', port=0):
+ if not watcher_state.is_initialized():
+ watcher_state.initialize(directory, hostname, port)
+ return watcher_state
+def Job_get_MetaJob(job, lang_exe=lang_bash_exe):
+ return MetaJob(job, lang_exe=lang_exe)
+def MetaJob_wrap(mjob, state):
+ """Write wrapper contents to mjob.wrapper.
+ """
+ wdir = state.get_directory_wrappers()
+ # the wrapped job may chdir(), so use abspath
+ edir = os.path.abspath(state.get_directory_exits())
+ metajob_rundir = mjob.job.rundir
+
+ bash_template = """#!%(lang_exe)s
+%(cmd)s
+ """
+ # We do not bother with 'set -e' here because this script is run either
+ # in the background or via qsub.
+ templates = {
+ lang_python_exe: python_template,
+ lang_bash_exe: bash_template,
+ }
+ mji = MetaJobClass(mjob)
+ wrapper_fn = os.path.join(wdir, mji.get_wrapper())
+ heartbeat_server, heartbeat_port = state.get_heartbeat_server()
+ rate = HEARTBEAT_RATE_S
+ command = mjob.job.cmd
+ jobid = mjob.job.jobid
+ exit_sentinel_fn = os.path.join(edir, jobid)
+
+ prog = 'python2.7 -m pwatcher.mains.network_heartbeat'
+ heartbeat_wrapper_template = "{prog} --directory={metajob_rundir} --heartbeat-server={heartbeat_server} --heartbeat-port={heartbeat_port} --exit-dir={edir} --rate={rate} --jobid={jobid} {command} || echo 99 >| {exit_sentinel_fn}"
+ # We write 99 into exit-sentinel if the wrapper fails.
+ wrapped = heartbeat_wrapper_template.format(**locals())
+ log.debug('Wrapped "%s"' %wrapped)
+
+ wrapped = templates[mjob.lang_exe] %dict(
+ lang_exe=mjob.lang_exe,
+ cmd=wrapped,
+ )
+ log.debug('Writing wrapper "%s"' %wrapper_fn)
+ with open(wrapper_fn, 'w') as f:
+ f.write(wrapped)
+
+def background(script, exe='/bin/bash'):
+ """Start script in background (so it keeps going when we exit).
+ Run in cwd.
+ For now, stdout/stderr are captured.
+ Return pid.
+ """
+ args = [exe, script]
+ sin = open(os.devnull)
+ sout = open(os.devnull, 'w')
+ serr = open(os.devnull, 'w')
+ pseudo_call = '{exe} {script} 1>|stdout 2>|stderr & '.format(exe=exe, script=script)
+ log.debug('dir: {!r}\ncall: {!r}'.format(os.getcwd(), pseudo_call))
+ proc = subprocess.Popen([exe, script], stdin=sin, stdout=sout, stderr=serr)
+ pid = proc.pid
+ log.debug('pid=%s pgid=%s sub-pid=%s' %(os.getpid(), os.getpgid(0), proc.pid))
+ #checkcall = 'ls -l /proc/{}/cwd'.format(
+ # proc.pid)
+ #system(checkcall, checked=True)
+ return pid
+
+def qstripped(option):
+ """Given a string of options, remove any -q foo.
+
+ >>> qstripped('-xy -q foo -z bar')
+ '-xy -z bar'
+ """
+ # For now, do not strip -qfoo
+ vals = option.strip().split()
+ while '-q' in vals:
+ i = vals.index('-q')
+ vals = vals[0:i] + vals[i+2:]
+ return ' '.join(vals)
+
+class MetaJobLocal(object):
+ def submit(self, state, exe, script_fn):
+ """Can raise.
+ """
+ #sge_option = self.mjob.job.options['sge_option']
+ #assert sge_option is None, sge_option # might be set anyway
+ pid = background(script_fn, exe=self.mjob.lang_exe)
+ def kill(self, state):
+ """Can raise.
+ """
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(state.get_heartbeat_server())
+ socket_send(hsocket, 'P {}'.format(self.mj.job.jobid))
+ line = socket_read(hsocket)
+ hsocket.close()
+ except IOError as e:
+ log.exception('Failed to get pig/pgid for {}: {!r}'.format(self.mj.job.jobid, e))
+ return
+ args = line.split(None, 2)
+ pid = int(args[0])
+ pgid = int(args[1])
+ sig = signal.SIGKILL
+ log.info('Sending signal(%s) to pgid=-%s (pid=%s) based on heartbeat server' %(sig, pgid, pid))
+ try:
+ os.kill(-pgid, sig)
+ except Exception:
+ log.exception('Failed to kill(%s) pgid=-%s for %r. Trying pid=%s' %(sig, pgid, self.mj.job.jobid, pid))
+ os.kill(pid, sig)
+ def __repr__(self):
+ return 'MetaJobLocal(%s)' %repr(self.mjob)
+ def __init__(self, mjob):
+ self.mjob = mjob # PUBLIC
+class MetaJobSge(object):
+ def submit(self, state, exe, script_fn):
+ """Can raise.
+ """
+ specific = self.specific
+ #cwd = os.getcwd()
+ job_name = self.get_jobname()
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
+ # Add shebang, in case shell_start_mode=unix_behavior.
+ # https://github.com/PacificBiosciences/FALCON/pull/348
+ with open(script_fn, 'r') as original: data = original.read()
+ with open(script_fn, 'w') as modified: modified.write("#!/bin/bash" + "\n" + data)
+ sge_cmd = 'qsub -N {job_name} -q {job_queue} {sge_option} {specific} -cwd -o stdout -e stderr -S {exe} {script_fn}'.format(
+ **locals())
+ system(sge_cmd, checked=True) # TODO: Capture q-jobid
+ def kill(self, state, heartbeat):
+ """Can raise.
+ """
+ job_name = self.get_jobname()
+ sge_cmd = 'qdel {}'.format(
+ job_name)
+ system(sge_cmd, checked=False)
+ def get_jobname(self):
+ """Some systems are limited to 15 characters, so for now we simply truncate the jobid.
+ TODO: Choose a sequential jobname and record it. Priority: low, since collisions are very unlikely.
+ """
+ return self.mjob.job.jobid[:15]
+ def __repr__(self):
+ return 'MetaJobSge(%s)' %repr(self.mjob)
+ def __init__(self, mjob):
+ self.mjob = mjob
+ self.specific = '-V' # pass enV; '-j y' => combine out/err
+class MetaJobPbs(object):
+ """
+usage: qsub [-a date_time] [-A account_string] [-c interval]
+ [-C directive_prefix] [-e path] [-h ] [-I [-X]] [-j oe|eo] [-J X-Y[:Z]]
+ [-k o|e|oe] [-l resource_list] [-m mail_options] [-M user_list]
+ [-N jobname] [-o path] [-p priority] [-q queue] [-r y|n]
+ [-S path] [-u user_list] [-W otherattributes=value...]
+ [-v variable_list] [-V ] [-z] [script | -- command [arg1 ...]]
+ """
+ def submit(self, state, exe, script_fn):
+ """Can raise.
+ """
+ specific = self.specific
+ #cwd = os.getcwd()
+ job_name = self.get_jobname()
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
+ # Add shebang, in case shell_start_mode=unix_behavior.
+ # https://github.com/PacificBiosciences/FALCON/pull/348
+ with open(script_fn, 'r') as original: data = original.read()
+ with open(script_fn, 'w') as modified: modified.write("#!/bin/bash" + "\n" + data)
+ sge_cmd = 'qsub -N {job_name} -q {job_queue} {sge_option} {specific} -o ev/null -e /dev/null -S {exe} {script_fn}'.format(
+ **locals())
+ system(sge_cmd, checked=True) # TODO: Capture q-jobid
+ def kill(self, state, heartbeat):
+ """Can raise.
+ """
+ job_name = self.get_jobname()
+ sge_cmd = 'qdel {}'.format(
+ job_name)
+ system(sge_cmd, checked=False)
+ def get_jobname(self):
+ """Some systems are limited to 15 characters, so for now we simply truncate the jobid.
+ TODO: Choose a sequential jobname and record it. Priority: low, since collisions are very unlikely.
+ """
+ return self.mjob.job.jobid[:15]
+ def __repr__(self):
+ return 'MetaJobPbs(%s)' %repr(self.mjob)
+ def __init__(self, mjob):
+ self.mjob = mjob
+ self.specific = '-V' # pass enV; '-j y' => combine out/err
+class MetaJobTorque(object):
+ # http://docs.adaptivecomputing.com/torque/4-0-2/help.htm#topics/commands/qsub.htm
+ def submit(self, state, exe, script_fn):
+ """Can raise.
+ """
+ specific = self.specific
+ #cwd = os.getcwd()
+ job_name = self.get_jobname()
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
+ cwd = os.getcwd()
+ # Add shebang, in case shell_start_mode=unix_behavior.
+ # https://github.com/PacificBiosciences/FALCON/pull/348
+ with open(script_fn, 'r') as original: data = original.read()
+ with open(script_fn, 'w') as modified: modified.write("#!/bin/bash" + "\n" + data)
+ sge_cmd = 'qsub -N {job_name} -q {job_queue} {sge_option} {specific} -d {cwd} -o stdout -e stderr -S {exe} {script_fn}'.format(
+ **locals())
+ system(sge_cmd, checked=True) # TODO: Capture q-jobid
+ def kill(self, state, heartbeat):
+ """Can raise.
+ """
+ job_name = self.get_jobname()
+ sge_cmd = 'qdel {}'.format(
+ job_name)
+ system(sge_cmd, checked=False)
+ def get_jobname(self):
+ """Some systems are limited to 15 characters, so for now we simply truncate the jobid.
+ TODO: Choose a sequential jobname and record it. Priority: low, since collisions are very unlikely.
+ """
+ return self.mjob.job.jobid[:15]
+ def __repr__(self):
+ return 'MetaJobTorque(%s)' %repr(self.mjob)
+ def __init__(self, mjob):
+ super(MetaJobTorque, self).__init__(mjob)
+ self.specific = '-V' # pass enV; '-j oe' => combine out/err
+class MetaJobSlurm(object):
+ def submit(self, state, exe, script_fn):
+ """Can raise.
+ """
+ job_name = self.get_jobname()
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
+ cwd = os.getcwd()
+ sge_cmd = 'sbatch -J {job_name} -q {job_queue} {sge_option} -D {cwd} -o stdout -e stderr --wrap="{exe} {script_fn}"'.format(
+ **locals())
+ # "By default all environment variables are propagated."
+ # http://slurm.schedmd.com/sbatch.html
+ system(sge_cmd, checked=True) # TODO: Capture sbatch-jobid
+ def kill(self, state, heartbeat):
+ """Can raise.
+ """
+ job_name = self.get_jobname()
+ sge_cmd = 'scancel -n {}'.format(
+ job_name)
+ system(sge_cmd, checked=False)
+ def get_jobname(self):
+ """Some systems are limited to 15 characters, so for now we simply truncate the jobid.
+ TODO: Choose a sequential jobname and record it. Priority: low, since collisions are very unlikely.
+ """
+ return self.mjob.job.jobid[:15]
+ def __repr__(self):
+ return 'MetaJobSlurm(%s)' %repr(self.mjob)
+ def __init__(self, mjob):
+ self.mjob = mjob
+class MetaJobLsf(object):
+ def submit(self, state, exe, script_fn):
+ """Can raise.
+ """
+ job_name = self.get_jobname()
+ sge_option = qstripped(self.mjob.job.options['sge_option'])
+ job_queue = self.mjob.job.options['job_queue']
+ sge_cmd = 'bsub -J {job_name} -q {job_queue} {sge_option} -o stdout -e stderr "{exe} {script_fn}"'.format(
+ **locals())
+ # "Sets the user's execution environment for the job, including the current working directory, file creation mask, and all environment variables, and sets LSF environment variables before starting the job."
+ system(sge_cmd, checked=True) # TODO: Capture q-jobid
+ def kill(self, state, heartbeat):
+ """Can raise.
+ """
+ job_name = self.get_jobname()
+ sge_cmd = 'bkill -J {}'.format(
+ job_name)
+ system(sge_cmd, checked=False)
+ def get_jobname(self):
+ """Some systems are limited to 15 characters, so for now we simply truncate the jobid.
+ TODO: Choose a sequential jobname and record it. Priority: low, since collisions are very unlikely.
+ """
+ return self.mjob.job.jobid[:15]
+ def __repr__(self):
+ return 'MetaJobLsf(%s)' %repr(self.mjob)
+ def __init__(self, mjob):
+ self.mjob = mjob
+
+def cmd_run(state, jobids, job_type, job_queue):
+ """On stdin, each line is a unique job-id, followed by run-dir, followed by command+args.
+ Wrap them and run them locally, in the background.
+ """
+ jobs = dict()
+ submitted = list()
+ result = {'submitted': submitted}
+ for jobid, desc in jobids.iteritems():
+ assert 'cmd' in desc
+ options = {}
+ if 'job_queue' not in desc:
+ raise Exception(pprint.pformat(desc))
+ for k in ('sge_option', 'job_type', 'job_queue'): # extras to be stored
+ if k in desc:
+ if desc[k]:
+ options[k] = desc[k]
+ if options.get('sge_option', None) is None:
+ # This way we can always safely include it.
+ options['sge_option'] = ''
+ if not options.get('job_queue'):
+ options['job_queue'] = job_queue
+ if not options.get('job_type'):
+ options['job_type'] = job_type
+ jobs[jobid] = Job(jobid, desc['cmd'], desc['rundir'], options)
+ log.debug('jobs:\n%s' %pprint.pformat(jobs))
+ for jobid, job in jobs.iteritems():
+ desc = jobids[jobid]
+ log.info('starting job %s' %pprint.pformat(job))
+ mjob = Job_get_MetaJob(job)
+ MetaJob_wrap(mjob, state)
+ options = job.options
+ my_job_type = desc.get('job_type')
+ if my_job_type is None:
+ my_job_type = job_type
+ my_job_type = my_job_type.upper()
+ if my_job_type == 'LOCAL':
+ bjob = MetaJobLocal(mjob)
+ elif my_job_type == 'SGE':
+ bjob = MetaJobSge(mjob)
+ elif my_job_type == 'PBS':
+ bjob = MetaJobPbs(mjob)
+ elif my_job_type == 'TORQUE':
+ bjob = MetaJobTorque(mjob)
+ elif my_job_type == 'SLURM':
+ bjob = MetaJobSlurm(mjob)
+ elif my_job_type == 'LSF':
+ bjob = MetaJobLsf(mjob)
+ else:
+ raise Exception('Unknown my_job_type=%s' %repr(my_job_type))
+ try:
+ state.submit_background(bjob)
+ submitted.append(jobid)
+ except Exception:
+ log.exception('In pwatcher.network_based.cmd_run(), failed to submit background-job:\n{!r}'.format(
+ bjob))
+ return result
+ # The caller is responsible for deciding what to do about job-submission failures. Re-try, maybe?
+
+def system(call, checked=False):
+ log.info('!{}'.format(call))
+ rc = os.system(call)
+ if checked and rc:
+ raise Exception('{} <- {!r}'.format(rc, call))
+
+_warned = dict()
+def warnonce(hashkey, msg):
+ if hashkey in _warned:
+ return
+ log.warning(msg)
+ _warned[hashkey] = True
+
+def get_status(state, jobid):
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(state.get_heartbeat_server())
+ socket_send(hsocket, 'Q {}'.format(jobid))
+ line = socket_read(hsocket)
+ hsocket.close()
+ except IOError: # server can't be reached for comment
+ return 'UNKNOWN'
+ if not line: # bad formatting
+ return 'UNKNOWN'
+ args = line.split(None, 2) # status, arg
+ if len(args) != 2:
+ return 'UNKNOWN'
+ if args[0] == 'EXIT':
+ return line
+ elif args[0] == 'RUNNING':
+ if 3*HEARTBEAT_RATE_S < int(args[1]):
+ msg = 'DEAD job? 3*{} < {} for {!r}'.format(
+ HEARTBEAT_RATE_S, args[1], jobid)
+ log.debug(msg)
+ warnonce(jobid, msg)
+ return 'DEAD'
+ else:
+ return 'RUNNING'
+ return 'UNKNOWN'
+def cmd_query(state, which, jobids):
+ """Return the state of named jobids.
+ """
+ result = dict()
+ jobstats = dict()
+ result['jobids'] = jobstats
+ for jobid in find_jobids(state, which, jobids):
+ status = get_status(state, jobid)
+ log.debug('Status %s for jobid:%s' %(status, jobid))
+ jobstats[jobid] = status
+ return result
+def get_jobid2pid(pid2mjob):
+ result = dict()
+ for pid, mjob in pid2mjob.iteritems():
+ jobid = mjob.job.jobid
+ result[jobid] = pid
+ return result
+def find_jobids(state, which, jobids):
+ """Yield jobids.
+ If which=='list', then query jobs listed as jobids.
+ If which=='known', then query all known jobs.
+ If which=='infer', then query all jobs with heartbeats.
+ These are not quite finished, but already useful.
+ """
+ #log.debug('find_jobids for which=%s, jobids=%s' %(which, pprint.pformat(jobids)))
+ if which == 'infer':
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(state.get_heartbeat_server())
+ socket_send(hsocket, 'L')
+ line = socket_read(hsocket)
+ hsocket.close()
+ except IOError as e:
+ log.exception('In find_jobids(), unable to infer jobid list: {!r}'.format(e))
+ yield
+ for jobid in line.split():
+ yield jobid
+ elif which == 'known':
+ jobid2mjob = state.get_mjobs()
+ for jobid, mjob in jobid2mjob.iteritems():
+ yield jobid
+ elif which == 'list':
+ #jobid2mjob = state.get_mjobs()
+ #log.debug('jobid2mjob:\n%s' %pprint.pformat(jobid2mjob))
+ for jobid in jobids:
+ #log.debug('jobid=%s; jobids=%s' %(repr(jobid), repr(jobids)))
+ #if jobid not in jobid2mjob:
+ # log.info("jobid=%s is not known. Might have been deleted already." %jobid)
+ yield jobid
+ else:
+ raise Exception('which=%s'%repr(which))
+def delete_jobid(state, jobid, keep=False):
+ """
+ Kill the job with this heartbeat.
+ (If there is no heartbeat, then the job is already gone.)
+ Delete the entry from state and update its jobid.
+ """
+ try:
+ bjob = state.get_bjob(jobid)
+ except Exception:
+ log.exception('In delete_jobid(), unable to find batchjob for %' %(jobid))
+ # TODO: Maybe provide a default grid type, so we can attempt to delete anyway?
+ return
+ try:
+ bjob.kill(state, jobid)
+ except Exception as exc:
+ log.debug('Failed to kill job for jobid {!r}: {!r}'.format(
+ jobid , exc))
+ state.add_deleted_jobid(jobid)
+ # For now, keep it in the 'jobs' table.
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(state.get_heartbeat_server())
+ socket_send(hsocket, 'd {}'.format(jobid))
+ hsocket.close()
+ log.debug('Removed jobid=%s' %repr(jobid))
+ except IOError as e:
+ log.debug('Cannot remove jobid {}: {!r}'.format(jobid, e))
+def cmd_delete(state, which, jobids):
+ """Kill designated jobs, including (hopefully) their
+ entire process groups.
+ If which=='list', then kill all jobs listed as jobids.
+ If which=='known', then kill all known jobs.
+ If which=='infer', then kill all jobs with heartbeats.
+ Remove those heartbeat files.
+ """
+ log.debug('Deleting jobs for jobids from %s (%s)' %(
+ which, repr(jobids)))
+ for jobid in find_jobids(state, which, jobids):
+ delete_jobid(state, jobid)
+def makedirs(path):
+ if not os.path.isdir(path):
+ os.makedirs(path)
+def readjson(ifs):
+ """Del keys that start with ~.
+ That lets us have trailing commas on all other lines.
+ """
+ content = ifs.read()
+ log.debug('content:%s' %repr(content))
+ jsonval = json.loads(content)
+ #pprint.pprint(jsonval)
+ def striptildes(subd):
+ if not isinstance(subd, dict):
+ return
+ for k,v in subd.items():
+ if k.startswith('~'):
+ del subd[k]
+ else:
+ striptildes(v)
+ striptildes(jsonval)
+ #pprint.pprint(jsonval)
+ return jsonval
+
+class ProcessWatcher(object):
+ def run(self, jobids, job_type, job_queue):
+ #import traceback; log.debug(''.join(traceback.format_stack()))
+ log.debug('run(jobids={}, job_type={}, job_queue={})'.format(
+ '<%s>'%len(jobids), job_type, job_queue))
+ return cmd_run(self.state, jobids, job_type, job_queue)
+ def query(self, which='list', jobids=[]):
+ log.debug('query(which={!r}, jobids={})'.format(
+ which, '<%s>'%len(jobids)))
+ return cmd_query(self.state, which, jobids)
+ def delete(self, which='list', jobids=[]):
+ log.debug('delete(which={!r}, jobids={})'.format(
+ which, '<%s>'%len(jobids)))
+ return cmd_delete(self.state, which, jobids)
+ def __init__(self, state):
+ self.state = state
+
+def get_process_watcher(directory):
+ state = get_state(directory)
+ #log.debug('state =\n%s' %pprint.pformat(state.top))
+ return ProcessWatcher(state)
+ #State_save(state)
+
+ at contextlib.contextmanager
+def process_watcher(directory, hostname='', port=0):
+ """This will (someday) hold a lock, so that
+ the State can be written safely at the end.
+ """
+ state = get_state(directory, hostname, port)
+ #log.debug('state =\n%s' %pprint.pformat(state.top))
+ yield ProcessWatcher(state)
+ # TODO: Sometimes, maybe we should not save state.
+ # Or maybe we *should* on exception.
+ state.save()
+
+def main(prog, cmd, state_dir='mainpwatcher', argsfile=None):
+ logging.basicConfig()
+ logging.getLogger().setLevel(logging.NOTSET)
+ log.warning('logging basically configured')
+ log.debug('debug mode on')
+ assert cmd in ['run', 'query', 'delete']
+ ifs = sys.stdin if not argsfile else open(argsfile)
+ argsdict = readjson(ifs)
+ log.info('argsdict =\n%s' %pprint.pformat(argsdict))
+ with process_watcher(state_dir) as watcher:
+ result = getattr(watcher, cmd)(**argsdict)
+ if result is not None:
+ print pprint.pformat(result)
+
+
+# With bash, we would need to set the session, rather than
+# the process group. That's not ideal, but this is here for reference.
+# http://stackoverflow.com/questions/6549663/how-to-set-process-group-of-a-shell-script
+#
+bash_template = """#!%(lang_exe)s
+cmd='%(cmd)s'
+"$cmd"
+"""
+
+# perl might be better, for efficiency.
+# But we will use python for now.
+#
+python_template = r"""#!%(lang_exe)s
+import threading, time, os, sys, subprocess, socket
+
+cmd='%(cmd)s'
+heartbeat_server=('%(heartbeat_server)s' %(heartbeat_port)s)
+jobid='%(jobid)s'
+sleep_s=%(sleep_s)s
+cwd='%(cwd)s'
+
+os.chdir(cwd)
+
+def socket_send(socket, message):
+ socket.sendall(b'{}\0'.format(message))
+
+def log(msg):
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(heartbeat_server)
+ socket_send(hsocket, 's {} {}\n'.format(jobid, msg))
+ hsocket.close()
+ except IOError: # better to miss a line than terminate
+ pass
+
+def thread_heartbeat():
+ pid = os.getpid()
+ pgid = os.getpgid(0)
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(heartbeat_server)
+ socket_send(hsocket, 'i {} {} {}'.format(jobid, pid, pgid))
+ hsocket.close()
+ except IOError: # hope it's a temporary error
+ pass
+ while True:
+ time.sleep(sleep_s)
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(heartbeat_server)
+ socket_send(hsocket, 'h {}'.format(jobid))
+ hsocket.close()
+ except IOError: # hope it's a temporary error
+ pass
+
+def start_heartbeat():
+ hb = threading.Thread(target=thread_heartbeat)
+ log('alive? {}'.format(hb.is_alive()))
+ hb.daemon = True
+ hb.start()
+ return hb
+
+def main():
+ log('cwd:{!r}'.format(os.getcwd()))
+ log("before: pid={}s pgid={}s".format(os.getpid(), os.getpgid(0)))
+ try:
+ os.setpgid(0, 0)
+ except OSError as e:
+ log('Unable to set pgid. Possibly a grid job? Hopefully there will be no dangling processes when killed: {}'.format(
+ repr(e)))
+ log("after: pid={}s pgid={}s".format(os.getpid(), os.getpgid(0)))
+ hb = start_heartbeat()
+ log('alive? {} pid={} pgid={}'.format(hb.is_alive(), os.getpid(), os.getpgid(0)))
+ sp = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+ with sp.stdout as f:
+ for line in iter(f.readline, b''):
+ log(heartbeat_server, jobid, line)
+ rc = sp.wait()
+ # sys.exit(rc) # No-one would see this anyway.
+ hsocket = socket.socket()
+ try:
+ hsocket.connect(heartbeat_server)
+ socket_send(hsocket, 'e {} {}'.format(jobid, rc))
+ hsocket.close()
+ except IOError as e:
+ log('could not update heartbeat server with exit status: {} {}: {!r}'.format(jobid, rc, e))
+ if rc:
+ raise Exception('{} <- {!r}'.format(rc, cmd))
+main()
+"""
+
+if __name__ == "__main__":
+ import pdb
+ pdb.set_trace()
+ main(*sys.argv)
diff --git a/pypeFLOW/pypeflow/do_support.py b/pypeFLOW/pypeflow/do_support.py
new file mode 100644
index 0000000..d42ad67
--- /dev/null
+++ b/pypeFLOW/pypeflow/do_support.py
@@ -0,0 +1,51 @@
+import logging
+import logging.config
+import os
+import string
+import StringIO
+LOG = logging.getLogger(__name__)
+BASH = '/bin/bash'
+
+# This is used by some programs in falcon_kit/mains.
+simple_logging_config = """
+[loggers]
+keys=root
+
+[handlers]
+keys=stream
+
+[formatters]
+keys=form01,form02
+
+[logger_root]
+level=NOTSET
+handlers=stream
+
+[handler_stream]
+class=StreamHandler
+level=${FALCON_LOG_LEVEL}
+formatter=form01
+args=(sys.stderr,)
+
+[formatter_form01]
+format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+
+[formatter_form02]
+format=[%(levelname)s]%(message)s
+"""
+def setup_simple_logging(FALCON_LOG_LEVEL='DEBUG', **ignored):
+ cfg = string.Template(simple_logging_config).substitute(FALCON_LOG_LEVEL=FALCON_LOG_LEVEL)
+ logger_fileobj = StringIO.StringIO(cfg)
+ defaults = {}
+ logging.config.fileConfig(logger_fileobj, defaults=defaults, disable_existing_loggers=False)
+
+def run_bash(script_fn):
+ # Assume script was written by this program, so we know it is
+ # available in the filesystem.
+ # However, we cannot be sure that the execute permission is set,
+ # so run it as a script.
+ cmd = '{} -vex {}'.format(BASH, script_fn)
+ LOG.info('!{}'.format(cmd))
+ rc = os.system(cmd)
+ if rc:
+ raise Exception('{} <- {!r}'.format(rc, cmd))
diff --git a/pypeFLOW/pypeflow/do_task.py b/pypeFLOW/pypeflow/do_task.py
new file mode 100644
index 0000000..b3b36a8
--- /dev/null
+++ b/pypeFLOW/pypeflow/do_task.py
@@ -0,0 +1,149 @@
+#!/usr/bin/env python2.7
+from . import do_support
+import argparse
+import contextlib
+import importlib
+import inspect
+import json
+import logging
+import os
+import pprint
+import sys
+import time
+DONE = 'done'
+STATUS = 'status'
+TIMEOUT = 30
+LOG = logging.getLogger()
+DESCRIPTION = """Given a JSON description, call a python-function.
+"""
+EPILOG = """
+The JSON looks like this:
+{
+ "inputs": {"input-name": "filename"},
+ "outputs": {"output-name": "output-filename (relative)"},
+ "python_function": "falcon_kit.mains.foo",
+ "parameters": {}
+}
+
+This program will run on the work host, and it will do several things:
+ - Run in CWD.
+ - Verify that inputs are available. (Wait til timeout if not.)
+ - Possibly, cd to tmpdir and create symlinks from inputs.
+ - Run the python-function.
+ - Its module must be available (e.g. in PYTHONPATH).
+ - Pass a kwd-dict of the union of inputs/outputs/parameters.
+ - Ignore return-value. Expect exceptions.
+ - Possibly, mv outputs from tmpdir to workdir.
+ - Write exit-code into STATUS.
+ - Touch DONE on success.
+"""
+"""
+(Someday, we might also support runnable Python modules, or even executables via execvp().)
+
+Note: qsub will *not* run this directly. There is a higher layer.
+"""
+
+def get_parser():
+ class _Formatter(argparse.RawDescriptionHelpFormatter, argparse.ArgumentDefaultsHelpFormatter):
+ pass
+ parser = argparse.ArgumentParser(description=DESCRIPTION, epilog=EPILOG,
+ formatter_class=_Formatter,
+ )
+ parser.add_argument('--timeout',
+ type=int, default=60,
+ help='How many seconds to wait for input files (and JSON) to exist. (default: %(default)s')
+ parser.add_argument('--tmpdir',
+ help='Root directory to run in. (Sub-dir name will be based on CWD.)')
+ parser.add_argument('json_fn',
+ help='JSON file, as per epilog.')
+ return parser
+
+ at contextlib.contextmanager
+def cd(newdir):
+ prevdir = os.getcwd()
+ LOG.debug('CD: %r <- %r' %(newdir, prevdir))
+ os.chdir(os.path.expanduser(newdir))
+ try:
+ yield
+ finally:
+ LOG.debug('CD: %r -> %r' %(newdir, prevdir))
+ os.chdir(prevdir)
+
+def mkdirs(path):
+ if not os.path.isdir(path):
+ os.makedirs(path)
+
+def wait_for(fn):
+ global TIMEOUT
+ LOG.debug('Checking existence of {!r} with timeout={}'.format(fn, TIMEOUT))
+ while not os.path.exists(fn):
+ if TIMEOUT > 0:
+ time.sleep(1)
+ TIMEOUT -= 1
+ else:
+ raise Exception('Timed out waiting for {!r}'.format(fn))
+ assert os.access(fn, os.R_OK), '{!r} not readable'.format(fn)
+
+def get_func(python_function):
+ mod_name, func_name = os.path.splitext(python_function)
+ func_name = func_name[1:] # skip dot
+ mod = importlib.import_module(mod_name)
+ func = getattr(mod, func_name)
+ return func
+
+class OldTaskRunner(object):
+ def __init__(self, inputs, outputs, parameters):
+ for k,v in (inputs.items() + outputs.items()):
+ setattr(self, k, v)
+ self.parameters = parameters
+ self.inputs = inputs
+ self.outputs = outputs
+
+def run(json_fn, timeout, tmpdir):
+ if isinstance(timeout, int):
+ global TIMEOUT
+ TIMEOUT = timeout
+ wait_for(json_fn)
+ LOG.debug('Loading JSON from {!r}'.format(json_fn))
+ cfg = json.loads(open(json_fn).read())
+ LOG.debug(pprint.pformat(cfg))
+ for fn in cfg['inputs'].values():
+ wait_for(fn)
+ python_function_name = cfg['python_function']
+ func = get_func(python_function_name)
+ try:
+ if False:
+ kwds = dict()
+ kwds.update(cfg['inputs'])
+ kwds.update(cfg['outputs'])
+ kwds.update(cfg['parameters'])
+ func(**kwds)
+ else:
+ # old way, for now
+ cwd = os.getcwd()
+ cfg['parameters']['cwd'] = cwd
+ self = OldTaskRunner(cfg['inputs'], cfg['outputs'], cfg['parameters'])
+ func(self=self)
+ script_fn = getattr(self, 'generated_script_fn', None)
+ if script_fn is not None:
+ do_support.run_bash(script_fn)
+ except TypeError:
+ # Report the actual function spec.
+ LOG.error('For function "{}", {}'.format(python_function_name, inspect.getargspec(func)))
+ raise
+ for fn in cfg['outputs'].values():
+ wait_for(fn)
+
+def main():
+ parser = get_parser()
+ parsed_args = parser.parse_args(sys.argv[1:])
+ try:
+ run(**vars(parsed_args))
+ except Exception:
+ LOG.critical('Error in {} with args={!r}'.format(sys.argv[0], pprint.pformat(vars(parsed_args))))
+ raise
+
+if __name__ == "__main__":
+ do_support.setup_simple_logging(**os.environ)
+ LOG.debug('Running "{}"'.format(' '.join(sys.argv)))
+ main()
diff --git a/pypeFLOW/pypeflow/pwatcher_bridge.py b/pypeFLOW/pypeflow/pwatcher_bridge.py
index 4b37be9..d8b78c8 100644
--- a/pypeFLOW/pypeflow/pwatcher_bridge.py
+++ b/pypeFLOW/pypeflow/pwatcher_bridge.py
@@ -6,8 +6,11 @@ of pypeFLOW.
With PypeProcWatcherWorkflow, the refreshTargets() loop will
be single-threaded!
"""
-from pwatcher import fs_based
from pypeflow.task import PypeTask, PypeThreadTaskBase, PypeTaskBase, TaskFunctionError
+from pypeflow.data import fn
+import pwatcher.blocking
+import pwatcher.fs_based
+import pwatcher.network_based
import pypeflow.controller
import pypeflow.task
import collections
@@ -29,13 +32,26 @@ def PypeProcWatcherWorkflow(
URL = None,
job_type='local',
job_queue='UNSPECIFIED_QUEUE',
+ watcher_type='fs_based',
+ watcher_directory='mypwatcher',
+ max_jobs=None, # ignore here for now
**attributes):
"""Factory for the workflow using our new
filesystem process watcher.
"""
- th = MyPypeFakeThreadsHandler('mypwatcher', job_type, job_queue)
+ if watcher_type == 'blocking':
+ pwatcher_impl = pwatcher.blocking
+ elif watcher_type == 'network_based':
+ pwatcher_impl = pwatcher.network_based
+ else:
+ pwatcher_impl = pwatcher.fs_based
+ log.warning('In pwatcher_bridge, pwatcher_impl={!r}'.format(pwatcher_impl))
+ log.info('In pwatcher_bridge, pwatcher_impl={!r}'.format(pwatcher_impl))
+ watcher = pwatcher_impl.get_process_watcher(watcher_directory)
+ log.info('job_type={!r}, job_queue={!r}'.format(job_type, job_queue))
+ th = MyPypeFakeThreadsHandler(watcher, job_type, job_queue)
mq = MyMessageQueue()
- se = MyFakeShutdownEvent()
+ se = MyFakeShutdownEvent() # TODO: Save pwatcher state on ShutdownEvent. (Not needed for blocking pwatcher. Mildly useful for fs_based.)
return pypeflow.controller._PypeConcurrentWorkflow(URL=URL, thread_handler=th, messageQueue=mq, shutdown_event=se,
attributes=attributes)
@@ -178,31 +194,30 @@ class MyPypeFakeThreadsHandler(object):
'job_type': self.__job_type,
'job_queue': self.__job_queue,
}
- with fs_based.process_watcher(self.__state_directory) as watcher:
- result = watcher.run(**watcher_args)
- #log.debug('Result of watcher.run()={}'.format(repr(result)))
- submitted = result['submitted']
- self.__running.update(submitted)
- for jobid in set(jobids.keys()) - set(submitted):
- fred = ready[jobid]
- fred.endrun('UNSUBMITTED')
+ result = self.watcher.run(**watcher_args)
+ log.debug('Result of watcher.run()={}'.format(repr(result)))
+ submitted = result['submitted']
+ self.__running.update(submitted)
+ #log.info("QQQ ADDED: {}".format(jobid))
+ for jobid in set(jobids.keys()) - set(submitted):
+ fred = ready[jobid]
+ fred.endrun('UNSUBMITTED')
watcher_args = {
'jobids': list(self.__running),
'which': 'list',
}
- with fs_based.process_watcher(self.__state_directory) as watcher:
- q = watcher.query(**watcher_args)
+ q = self.watcher.query(**watcher_args)
#log.debug('In alive(), result of query:%s' %repr(q))
global _prev_q
if q != _prev_q:
- log.debug('In alive(), updated result of query:%s' %repr(q))
+ #log.debug('In alive(), updated result of query:%s' %repr(q))
_prev_q = q
_prev_q = None
for jobid, status in q['jobids'].iteritems():
- #log.debug('j={}, s={}'.format(jobid, status))
if status.startswith('EXIT') or status.startswith('DEAD'):
self.__running.remove(jobid)
+ #log.info("QQQ REMOVED: {}".format(jobid))
fred = self.__known[jobid]
try:
fred.endrun(status)
@@ -236,27 +251,31 @@ class MyPypeFakeThreadsHandler(object):
'jobids': list(self.__running),
'which': 'known',
}
- with fs_based.process_watcher(self.__state_directory) as watcher:
- q = watcher.delete(**watcher_args)
+ q = self.watcher.delete(**watcher_args)
log.debug('In notifyTerminate(), result of delete:%s' %repr(q))
# And our special methods.
def enqueue(self, fred):
self.__jobq.append(fred)
- def __init__(self, state_directory, job_type, job_queue=None):
+ def __init__(self, watcher, job_type, job_queue=None):
"""
job_type and job_queue are defaults, possibly over-ridden for specific jobs.
Note: job_queue is a string, not a collection. If None, then it would need to
come via per-job settings.
"""
- self.__state_directory = state_directory
+ self.watcher = watcher
self.__job_type = job_type
self.__job_queue = job_queue
self.__jobq = collections.deque()
self.__running = set()
self.__known = dict()
+def makedirs(path):
+ if not os.path.isdir(path):
+ log.debug('makedirs {!r}'.format(path))
+ os.makedirs(path)
+
class MyFakePypeThreadTaskBase(PypeThreadTaskBase):
"""Fake for PypeConcurrentWorkflow.
It demands a subclass, even though we do not use threads at all.
@@ -322,6 +341,8 @@ class MyFakePypeThreadTaskBase(PypeThreadTaskBase):
self.syncDirectories([o.localFileName for o in inputDataObjs.values()])
outputDataObjs = self.outputDataObjs
+ for datao in outputDataObjs.values():
+ makedirs(os.path.dirname(fn(datao)))
parameters = self.parameters
log.info('Running task from function %s()' %(self._taskFun.__name__))
diff --git a/pypeFLOW/pypeflow/simple_pwatcher_bridge.py b/pypeFLOW/pypeflow/simple_pwatcher_bridge.py
new file mode 100644
index 0000000..d1c7467
--- /dev/null
+++ b/pypeFLOW/pypeflow/simple_pwatcher_bridge.py
@@ -0,0 +1,566 @@
+from .util import (mkdirs, system, touch, run, cd)
+import pwatcher.blocking
+import pwatcher.fs_based
+import pwatcher.network_based
+import networkx
+import networkx.algorithms.dag #import (topological_sort, is_directed_acyclic_graph)
+
+import hashlib
+import json
+import logging
+import os
+import pprint
+import random
+import sys
+import time
+
+LOG = logging.getLogger(__name__)
+
+def generate_jobid(node, script_fn):
+ # For now, we keep it simple. Just the task.json.
+ script_content = open(script_fn).read()
+ checksum = hashlib.md5(script_content).hexdigest()
+ return 'P' + checksum[0:14]
+
+def endrun(thisnode, status):
+ """By convention for now, status is one of:
+ 'DEAD'
+ 'UNSUBMITTED' (a pseudo-status defined in the ready-loop of alive())
+ 'EXIT rc'
+ """
+ name = status.split()[0]
+ if name == 'DEAD':
+ LOG.warning(''.join(traceback.format_stack()))
+ LOG.error('Task {}\n is DEAD, meaning no HEARTBEAT, but this can be a race-condition. If it was not killed, then restarting might suffice. Otherwise, you might have excessive clock-skew.'.format(thisnode))
+ #thisnode.setSatisfied(False) # I think we can leave it unsatisfied. Not sure what happens on retry though.
+ elif name == 'UNSUBMITTED':
+ LOG.warning(''.join(traceback.format_stack()))
+ LOG.error('Task {}\n is UNSUBMITTED, meaning job-submission somehow failed. Possibly a re-start would work. Otherwise, you need to investigate.'.format(thisnode))
+ thisnode.setSatisfied(False)
+ elif name != 'EXIT':
+ raise Exception('Unexpected status {!r}'.format(name))
+ else:
+ code = int(status.split()[1])
+ if 0 != code:
+ LOG.error('Task {} failed with exit-code={}'.format(thisnode, code))
+ thisnode.setSatisfied(False)
+ else:
+ thisnode.setSatisfied(True)
+
+class PwatcherTaskQueue(object):
+ def enque(self, nodes):
+ """This should be an injected dependency.
+ Yield any Nodes that could not be submitted.
+ Nodes that lacked a script were actually run in-process and are considered
+ successful unless they raised an Exception, so they go into the to_report set.
+ """
+ # Start all "nodes".
+ # Note: It is safe to run this block always, but we save a
+ # call to pwatcher with 'if ready'.
+ LOG.debug('enque nodes:\n%s' %pprint.pformat(nodes))
+ jobids = dict()
+ #sge_option='-pe smp 8 -q default'
+ for node in nodes:
+ #node.satisfy() # This would do the job without a process-watcher.
+ mkdirs(node.wdir)
+ generated_script_fn = node.execute() # misnomer; this only dumps task.json now
+ if not generated_script_fn:
+ raise Exception('Missing generated_script_fn for Node {}'.format(node))
+ # This task is done.
+ endrun(node, 'EXIT 0')
+ self.__to_report.append(node)
+ continue
+ # For now, consider it as "submitted" and finished.
+ # (It would throw exception on error.)
+ jobid = generate_jobid(node, generated_script_fn)
+ self.__known[jobid] = node
+
+ rundir, basename = os.path.split(os.path.abspath(generated_script_fn))
+ cmd = '/bin/bash {}'.format(basename)
+ sge_option = node.pypetask.parameters.get('sge_option', self.__sge_option)
+ job_type = node.pypetask.parameters.get('job_type', None)
+ job_queue = node.pypetask.parameters.get('job_queue', None)
+ job_nprocs = node.pypetask.parameters.get('job_nprocs', None)
+ jobids[jobid] = {
+ 'cmd': cmd,
+ 'rundir': rundir,
+ # These are optional:
+ 'job_type': job_type,
+ 'job_queue': job_queue,
+ 'job_nprocs': job_nprocs,
+ 'sge_option': sge_option,
+ }
+ # Also send the default type and queue-name.
+ watcher_args = {
+ 'jobids': jobids,
+ 'job_type': self.__job_type,
+ 'job_queue': self.__job_queue,
+ }
+ result = self.watcher.run(**watcher_args)
+ LOG.debug('Result of watcher.run()={}'.format(repr(result)))
+ submitted = result['submitted']
+ self.__running.update(submitted)
+ #log.info("QQQ ADDED: {}".format(jobid))
+ for jobid in (set(jobids.keys()) - set(submitted)):
+ yield self.__known[jobid] # TODO: What should be the status for these submission failures?
+
+ def check_done(self):
+ """Yield Nodes which have finished since the last check.
+ """
+ watcher_args = {
+ 'jobids': list(self.__running),
+ 'which': 'list',
+ }
+ q = self.watcher.query(**watcher_args)
+ #LOG.debug('In check_done(), result of query:%s' %repr(q))
+ for jobid, status in q['jobids'].iteritems():
+ if status.startswith('EXIT') or status.startswith('DEAD'):
+ self.__running.remove(jobid)
+ node = self.__known[jobid]
+ self.__to_report.append(node)
+ try:
+ endrun(node, status)
+ except Exception as e:
+ msg = 'Failed to clean-up FakeThread: jobid={} status={}'.format(jobid, repr(status))
+ LOG.exception(msg)
+ raise
+ to_report = list(self.__to_report)
+ self.__to_report = list()
+ return to_report
+
+ def terminate(self):
+ watcher_args = {
+ 'jobids': list(self.__running),
+ 'which': 'known',
+ }
+ q = self.watcher.delete(**watcher_args)
+ LOG.debug('In notifyTerminate(), result of delete:%s' %repr(q))
+
+ def __init__(self, watcher, job_type='local', job_queue=None, sge_option=None):
+ self.watcher = watcher
+ self.__job_type = job_type
+ self.__job_queue = job_queue
+ self.__sge_option = sge_option
+ self.__running = set() # jobids
+ self.__known = dict() # jobid -> Node
+ self.__to_report = list() # Nodes
+
+def get_unsatisfied_subgraph(g):
+ unsatg = networkx.DiGraph(g)
+ for n in g.nodes():
+ if n.satisfied():
+ unsatg.remove_node(n)
+ return unsatg
+def find_next_ready(g, node):
+ """Given a recently satisfied node,
+ return any successors with in_degree 1.
+ """
+ ready = set()
+ for n in g.successors_iter(node):
+ if 1 == g.in_degree(n):
+ ready.add(n)
+ return ready
+def find_all_roots(g):
+ """Find all nodes in g which have no predecessors.
+ """
+ roots = set()
+ for node in g:
+ if 0 == g.in_degree(node):
+ roots.add(node)
+ return roots
+
+class Workflow(object):
+ def _create_node(self, pypetask):
+ """Given a PypeTask, return a Node for our Workflow graph.
+ Recursively create more nodes based on 'pypetask.inputs',
+ record them as 'node.needs', and update the global pypetask2node table.
+ """
+ needs = set()
+ node = PypeNode(pypetask.name, pypetask.wdir, pypetask, needs) #, pypetask.generated_script_fn)
+ self.pypetask2node[pypetask] = node
+ for key, plf in pypetask.inputs.iteritems():
+ if plf.producer is None:
+ continue
+ if plf.producer not in self.pypetask2node:
+ self._create_node(plf.producer)
+ needed_node = self.pypetask2node[plf.producer]
+ needs.add(needed_node)
+ LOG.debug('New {!r} needs {!r}'.format(node, needs))
+ return node
+ def addTask(self, pypetask):
+ node = self._create_node(pypetask)
+ sentinel_done_fn = node.sentinel_done_fn()
+ if sentinel_done_fn in self.sentinels:
+ msg = 'FOUND sentinel {!r} twice: {!r} ({!r}) and {!r}\nNote: Each task needs its own sentinel (and preferably its own run-dir).'.format(sentinel_done_fn, node, pypetask, self.sentinels[sentinel_done_fn])
+ raise Exception(msg)
+ self.sentinels[sentinel_done_fn] = node
+ self.graph.add_node(node)
+ for need in node.needs:
+ #print "Need:", need, node
+ self.graph.add_edge(need, node)
+ def addTasks(self, tlist):
+ for t in tlist:
+ self.addTask(t)
+ def refreshTargets(self, targets=None, updateFreq=10, exitOnFailure=True):
+ try:
+ self._refreshTargets(updateFreq, exitOnFailure)
+ except:
+ self.tq.terminate()
+ raise
+ def _refreshTargets(self, updateFreq, exitOnFailure):
+ """Raise Exception (eventually) on any failure.
+ - updateFreq (seconds) is really a max; we climb toward it gradually, and we reset when things change.
+ - exitOnFailure=False would allow us to keep running (for a while) when parallel jobs fail.
+ - self.max_jobs: the max number of concurrently running jobs
+ - possibly this should be the number of cpus in use, but for now it is qsub jobs, for simplicity.
+ """
+ # Note: With the 'blocking' pwatcher, we will have 1 thread per live qsub job.
+ # If/when that becomes a problem, please re-write the pwatcher as Go or Nim.
+ # This loop is single-threaded. If we ignore max_jobs,
+ # then we would send large queries for no reason, but that is not really a big deal.
+ # The Python 'blocking' pwatcher is the real reason to limit jobs, for now.
+ assert networkx.algorithms.dag.is_directed_acyclic_graph(self.graph)
+ failures = 0
+ unsatg = get_unsatisfied_subgraph(self.graph)
+ ready = find_all_roots(unsatg)
+ submitted = set()
+ init_sleep_time = 0.1
+ sleep_time = init_sleep_time
+ LOG.info('Num unsatisfied: {}, graph: {}'.format(len(unsatg), len(self.graph)))
+ while ready or submitted:
+ # Nodes cannot be in ready or submitted unless they are also in unsatg.
+ to_submit = set()
+ while ready and (self.max_jobs > len(submitted) + len(to_submit)):
+ node = ready.pop()
+ to_submit.add(node)
+ LOG.info('About to submit: {!r}'.format(node))
+ if to_submit:
+ unsubmitted = set(self.tq.enque(to_submit)) # In theory, this traps exceptions.
+ if unsubmitted:
+ LOG.error('Failed to enqueue {} of {} jobs: {!r}'.format(
+ len(unsubmitted), len(to_submit), unsubmitted))
+ #ready.update(unsubmitted) # Resubmit only in pwatcher, if at all.
+ submitted.update(to_submit - unsubmitted)
+ LOG.debug('N in queue: {}'.format(len(submitted)))
+ recently_done = set(self.tq.check_done())
+ if not recently_done:
+ if not submitted:
+ LOG.warning('Nothing is happening, and we had {} failures. Should we quit? Instead, we will just sleep.'.format(failures))
+ #break
+ LOG.info('sleep {}'.format(sleep_time))
+ time.sleep(sleep_time)
+ sleep_time = sleep_time + 0.1 if (sleep_time < updateFreq) else updateFreq
+ continue
+ LOG.debug('recently_done: {!r}'.format([(rd, rd.satisfied()) for rd in recently_done]))
+ LOG.debug('Num done in this iteration: {}'.format(len(recently_done)))
+ sleep_time = init_sleep_time
+ submitted -= recently_done
+ recently_satisfied = set(n for n in recently_done if n.satisfied())
+ recently_done -= recently_satisfied
+ #LOG.debug('Now N recently_done: {}'.format(len(recently_done)))
+ LOG.info('recently_satisfied: {!r}'.format(recently_satisfied))
+ LOG.info('Num satisfied in this iteration: {}'.format(len(recently_satisfied)))
+ for node in recently_satisfied:
+ ready.update(find_next_ready(unsatg, node))
+ unsatg.remove_node(node)
+ LOG.info('Num still unsatisfied: {}'.format(len(unsatg)))
+ if recently_done:
+ msg = 'Some tasks are recently_done but not satisfied: {!r}'.format(recently_done)
+ LOG.error(msg)
+ LOG.error('ready: {!r}\nsubmitted: {!r}'.format(ready, submitted))
+ failures += len(recently_done)
+ if exitOnFailure:
+ raise Exception(msg)
+ assert not submitted
+ assert not ready
+ if failures:
+ raise Exception('We had {} failures. {} tasks remain unsatisfied.'.format(
+ failures, len(unsatg)))
+
+ def __init__(self, watcher, job_type, job_queue, max_jobs, sge_option=''):
+ self.graph = networkx.DiGraph()
+ self.tq = PwatcherTaskQueue(watcher=watcher, job_type=job_type, job_queue=job_queue, sge_option=sge_option) # TODO: Inject this.
+ assert max_jobs > 0, 'max_jobs needs to be set. If you use the "blocking" process-watcher, it is also the number of threads.'
+ self.max_jobs = max_jobs
+ self.sentinels = dict() # sentinel_done_fn -> Node
+ self.pypetask2node = dict()
+
+class NodeBase(object):
+ """Graph node.
+ Can be satisfied on demand, but usually we call execute() and later run the script.
+ """
+ def setSatisfied(self, s):
+ self.__satisfied = s
+ def workdir(self):
+ return self.wdir
+ def script_fn(self):
+ return os.path.join(self.workdir(), 'run.sh')
+ def sentinel_done_fn(self):
+ return self.script_fn() + '.done'
+ def satisfied(self):
+ """Not just done, but successful.
+ If we see the sentinel file, then we memoize True.
+ But if we finished a distributed job with exit-code 0, we do not need
+ to wait for the sentinel; we know we had success.
+ """
+ #LOG.debug('Checking satisfied({!r}) for sentinel {!r}'.format(self, self.sentinel_done_fn()))
+ if self.__satisfied is not None:
+ return self.__satisfied
+ if os.path.exists(self.sentinel_done_fn()):
+ self.setSatisfied(True)
+ return self.__satisfied == True
+ def satisfy(self):
+ if self.__satisfied:
+ return
+ # Technically, we might need to cd into wdir first.
+ script_fn = self.execute()
+ if script_fn:
+ run(script_fn)
+ self.__satisfied = True
+ def execute(self):
+ try:
+ actual_script_fn = self.generate_script()
+ except Exception:
+ LOG.exception('Failed generate_script() for {!r}'.format(self))
+ raise
+ sentinel_done_fn = self.sentinel_done_fn()
+ wdir = self.workdir()
+ rel_actual_script_fn = os.path.relpath(actual_script_fn, wdir)
+ wrapper = """#!/bin/sh
+set -vex
+cd {wdir}
+bash {rel_actual_script_fn}
+touch {sentinel_done_fn}
+""".format(**locals())
+ wrapper_fn = self.script_fn()
+ #mkdirs(os.path.dirname(wrapper_fn))
+ with open(wrapper_fn, 'w') as ofs:
+ ofs.write(wrapper)
+ return wrapper_fn
+ def generate_script(self):
+ raise NotImplementedError(repr(self))
+ def __repr__(self):
+ return 'Node({})'.format(self.name)
+ def __init__(self, name, wdir, needs):
+ self.__satisfied = None # satisfiable
+ self.name = name
+ self.wdir = wdir
+ self.needs = needs
+class ComboNode(NodeBase):
+ """Several Nodes to be executed in sequence.
+ Only this ComboNode will be in the DiGraph, not the sub-Nodes.
+ """
+ def generate_script(self):
+ raise NotImplementedError(repr(self))
+ def __init__(self, nodes):
+ #super(ComboNode, self).__init__(name, wdir, needs)
+ self.nodes = nodes
+class PypeNode(NodeBase):
+ """
+ We will clean this up later. For now, it is pretty tightly coupled to PypeTask.
+ """
+ def generate_script(self):
+ pt = self.pypetask
+ task_desc = {
+ 'inputs': {k:v.path for k,v in pt.inputs.items()},
+ 'outputs': {k:v.path for k,v in pt.outputs.items()},
+ 'parameters': pt.parameters,
+ 'python_function': pt.func_name,
+ }
+ task_content = json.dumps(task_desc, sort_keys=True, indent=4, separators=(',', ': '))
+ task_json_fn = os.path.join(pt.wdir, 'task.json')
+ open(task_json_fn, 'w').write(task_content)
+ python = 'python2.7' # sys.executable fails sometimes because of binwrapper: SE-152
+ cmd = '{} -m pypeflow.do_task {}'.format(python, task_json_fn)
+ script_content = """#!/bin/bash
+hostname
+env | sort
+pwd
+time {}
+""".format(cmd)
+ script_fn = os.path.join(pt.wdir, 'task.sh')
+ open(script_fn, 'w').write(script_content)
+ return script_fn
+ def old_generate_script(self):
+ pt = self.pypetask
+ func = pt.func
+ func(pt) # Run the function! Probably just generate a script.
+ generated_script_fn = getattr(pt, 'generated_script_fn', None) # by convention
+ try:
+ # Maybe we should require a script always.
+ generated_script_fn = pt.generated_script_fn
+ except Exception:
+ LOG.exception('name={!r} URL={!r}'.format(pt.name, pt.URL))
+ raise
+ return generated_script_fn
+ def __init__(self, name, wdir, pypetask, needs): #, script_fn):
+ super(PypeNode, self).__init__(name, wdir, needs)
+ self.pypetask = pypetask
+
+# This global exists only because we continue to support the old PypeTask style,
+# where a PypeLocalFile does not know the PypeTask which produces it.
+# (This also allows us to specify PypeTasks out of order, fwiw.)
+# Someday, we might require PypeTasks to depend on outputs of other PypeTasks explicitly;
+# then we can drop this dict.
+PRODUCERS = dict()
+
+def findPypeLocalFile(path):
+ """Look-up based on tail dirname.
+ Do not call this for paths relative to their work-dirs.
+ """
+ assert os.path.isabs(path)
+ basename = os.path.basename(path)
+ basedir = os.path.relpath(os.path.dirname(path))
+ producer = PRODUCERS.get(basedir)
+ if producer is None:
+ msg = 'No producer PypeTask for basedir {!r} from path {!r} -- Pure input?'.format(
+ basedir, path)
+ LOG.debug(msg)
+ return PypeLocalFile(path, None)
+ siblings = producer.outputs
+ for plf in siblings.values():
+ sibling_basename = os.path.basename(plf.path)
+ if sibling_basename == basename:
+ return plf
+ raise Exception('Failed to find a PypeLocalFile for {!r} among outputs of {!r}'.format(
+ path, producer))
+def find_work_dir(paths):
+ """Return absolute path to directory of all these paths.
+ Must be same for all.
+ """
+ dirnames = set(os.path.dirname(os.path.normpath(p)) for p in paths)
+ if len(dirnames) != 1:
+ raise Exception('Cannot find work-dir for paths in multiple (or zero) dirs: {!r}'.format(
+ paths))
+ d = dirnames.pop()
+ return os.path.abspath(d)
+class PypeLocalFile(object):
+ def __repr__(self):
+ if self.producer:
+ path = os.path.relpath(self.path, self.producer.wdir)
+ return 'PLF({!r}, {!r})'.format(path, os.path.relpath(self.producer.wdir))
+ else:
+ path = os.path.relpath(self.path)
+ wdir = None
+ return 'PLF({!r}, {!r})'.format(path, None)
+ def __init__(self, path, producer):
+ self.path = os.path.abspath(path)
+ self.producer = producer
+def makePypeLocalFile(p, producer=None):
+ return PypeLocalFile(p, producer)
+def fn(p):
+ """This must be run in the top run-dir.
+ All task funcs are executed there.
+ """
+ if isinstance(p, PypeLocalFile):
+ p = p.path
+ return os.path.abspath(p)
+def only_path(p):
+ if isinstance(p, PypeLocalFile):
+ return p.path
+ else:
+ return p
+def PypeTask(inputs, outputs, TaskType=None, parameters=None, URL=None, wdir=None, name=None):
+ """A slightly messy factory because we want to support both strings and PypeLocalFiles, for now.
+ This can alter dict values in inputs/outputs if they were not already PypeLocalFiles.
+ """
+ if wdir is None:
+ wdir = find_work_dir([only_path(v) for v in outputs.values()])
+ this = _PypeTask(inputs, outputs, parameters, URL, wdir, name)
+ #basedir = os.path.basename(wdir)
+ basedir = this.name
+ if basedir in PRODUCERS:
+ raise Exception('Basedir {!r} already used for {!r}. Cannot create new PypeTask {!r}.'.format(
+ basedir, PRODUCERS[basedir], this))
+ LOG.debug('Added PRODUCERS[{!r}] = {!r}'.format(basedir, this))
+ PRODUCERS[basedir] = this
+ for key, val in outputs.items():
+ if not isinstance(val, PypeLocalFile):
+ # If relative, then it is relative to our wdir.
+ #LOG.warning('Making PLF: {!r} {!r}'.format(val, this))
+ if not os.path.isabs(val):
+ if not wdir:
+ raise Exception('No wdir for {!r}'.format(this))
+ val = os.path.join(wdir, val)
+ #LOG.warning('Muking PLF: {!r} {!r}'.format(val, this))
+ val = PypeLocalFile(val, this)
+ outputs[key] = val
+ else:
+ val.producer = this
+ for key, val in inputs.items():
+ if not isinstance(val, PypeLocalFile):
+ assert os.path.isabs(val), 'Inputs cannot be relative at this point: {!r} in {!r}'.format(val, this)
+ inputs[key] = findPypeLocalFile(val)
+ common = set(inputs.keys()) & set(outputs.keys())
+ assert (not common), 'Keys in both inputs and outputs of PypeTask({}): {!r}'.format(wdir, common)
+ LOG.debug('Built {!r}'.format(this))
+ return this
+class _PypeTask(object):
+ """Adaptor from old PypeTask API.
+ """
+ def __call__(self, func):
+ self.func = func
+ self.func_name = '{}.{}'.format(func.__module__, func.__name__)
+ return self
+ def __repr__(self):
+ return 'PypeTask({!r}, {!r}, {!r}, {!r})'.format(self.name, self.wdir, pprint.pformat(self.outputs), pprint.pformat(self.inputs))
+ def __init__(self, inputs, outputs, parameters=None, URL=None, wdir=None, name=None):
+ if parameters is None:
+ parameters = {}
+ if wdir is None:
+ wdir = parameters.get('wdir', name) # One of these must be a string!
+ if name is None:
+ name = os.path.relpath(wdir)
+ if URL is None:
+ URL = 'task://localhost/{}'.format(name)
+ self.inputs = inputs
+ self.outputs = outputs
+ self.parameters = parameters
+ self.wdir = wdir
+ self.name = name
+ self.URL = URL
+ #for key, bn in inputs.iteritems():
+ # setattr(self, key, os.path.abspath(bn))
+ #for key, bn in outputs.iteritems():
+ # setattr(self, key, os.path.abspath(bn))
+ LOG.debug('Created {!r}'.format(self))
+
+class DummyPypeTask(_PypeTask):
+ def __init__(self):
+ super(DummyPypeTask, self).__init__({}, {}, {}, wdir='/')
+
+#ROOT_PYPE_TASK = DummyPypeTask()
+
+MyFakePypeThreadTaskBase = None # just a symbol, not really used
+
+# Here is the main factory.
+def PypeProcWatcherWorkflow(
+ URL = None,
+ job_type='local',
+ job_queue='UNSPECIFIED_QUEUE',
+ watcher_type='fs_based',
+ watcher_directory='mypwatcher',
+ max_jobs = 24, # must be > 0, but not too high
+ sge_option = None,
+ **attributes):
+ """Factory for the workflow.
+ """
+ if watcher_type == 'blocking':
+ pwatcher_impl = pwatcher.blocking
+ elif watcher_type == 'network_based':
+ pwatcher_impl = pwatcher.network_based
+ else:
+ pwatcher_impl = pwatcher.fs_based
+ LOG.warning('In simple_pwatcher_bridge, pwatcher_impl={!r}'.format(pwatcher_impl))
+ LOG.info('In simple_pwatcher_bridge, pwatcher_impl={!r}'.format(pwatcher_impl))
+ watcher = pwatcher_impl.get_process_watcher(watcher_directory)
+ LOG.info('job_type={!r}, job_queue={!r}'.format(job_type, job_queue))
+ return Workflow(watcher, job_type=job_type, job_queue=job_queue, max_jobs=max_jobs, sge_option=sge_option)
+ #th = MyPypeFakeThreadsHandler('mypwatcher', job_type, job_queue)
+ #mq = MyMessageQueue()
+ #se = MyFakeShutdownEvent() # TODO: Save pwatcher state on ShutdownEvent. (Not needed for blocking pwatcher. Mildly useful for fs_based.)
+ #return pypeflow.controller._PypeConcurrentWorkflow(URL=URL, thread_handler=th, messageQueue=mq, shutdown_event=se,
+ # attributes=attributes)
+PypeProcWatcherWorkflow.setNumThreadAllowed = lambda x, y: None
+
+__all__ = ['PypeProcWatcherWorkflow', 'fn', 'makePypeLocalFile', 'MyFakePypeThreadTaskBase', 'PypeTask']
diff --git a/pypeFLOW/pypeflow/util.py b/pypeFLOW/pypeflow/util.py
new file mode 100644
index 0000000..1b3e13f
--- /dev/null
+++ b/pypeFLOW/pypeflow/util.py
@@ -0,0 +1,31 @@
+import contextlib
+import logging
+import os
+
+LOG = logging.getLogger()
+
+ at contextlib.contextmanager
+def cd(newdir):
+ prevdir = os.getcwd()
+ LOG.debug('CD: %r <- %r' %(newdir, prevdir))
+ os.chdir(os.path.expanduser(newdir))
+ try:
+ yield
+ finally:
+ LOG.debug('CD: %r -> %r' %(newdir, prevdir))
+ os.chdir(prevdir)
+def run(script_fn):
+ cwd, basename = os.path.split(script_fn)
+ with cd(cwd):
+ system('bash {}'.format(basename))
+def mkdirs(path):
+ if not os.path.isdir(path):
+ os.makedirs(path)
+def system(cmd):
+ LOG.info(cmd)
+ rc = os.system(cmd)
+ if rc:
+ raise Exception('{} <- {!r}'.format(rc, cmd))
+def touch(myfn):
+ cmd = 'touch {}'.format(myfn)
+ system(cmd)
diff --git a/pypeFLOW/setup.py b/pypeFLOW/setup.py
index 97f80b9..df77bec 100644
--- a/pypeFLOW/setup.py
+++ b/pypeFLOW/setup.py
@@ -17,6 +17,7 @@ setup(
'rdflib == 3.4.0',
'rdfextras >= 0.1',
'html5lib == 0.999999',
+ 'networkx >=1.7, <=1.10',
],
entry_points = {'console_scripts': [
'pwatcher-main=pwatcher.mains.pwatcher:main',
@@ -24,4 +25,5 @@ setup(
'heartbeat-wrapper=pwatcher.mains.fs_heartbeat:main',
],
},
+ package_data={'pwatcher.mains': ['*.sh']}
)
diff --git a/pypeFLOW/travis.sh b/pypeFLOW/travis.sh
index 651c8a8..1ee9256 100755
--- a/pypeFLOW/travis.sh
+++ b/pypeFLOW/travis.sh
@@ -8,4 +8,4 @@ set -vex
sudo mkdir -p /tmp
sudo chmod a+wrx /tmp
python setup.py install
-nosetests --with-doctest -v pypeflow/
+nosetests --with-doctest -v pypeflow/ pwatcher/fs_based.py
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-med/falcon.git
More information about the debian-med-commit
mailing list